diff --git a/README.md b/README.md index 0b039a1..3a1946d 100644 --- a/README.md +++ b/README.md @@ -1,13 +1,12 @@ -[![PyPI version](https://badge.fury.io/py/traker.svg)](https://badge.fury.io/py/traker) [![arXiv](https://img.shields.io/badge/arXiv-2303.14186-b31b1b.svg?style=flat-square)](https://arxiv.org/abs/2303.14186) +[![PyPI version](https://badge.fury.io/py/traker.svg)](https://badge.fury.io/py/traker) + +# TRAK: Attributing Model Behavior at Scale [[docs & tutorials]](https://trak.readthedocs.io/en/latest/) -[[paper]](https://arxiv.org/abs/2303.14186) [[blog post]](https://gradientscience.org/trak/) [[website]](https://trak.csail.mit.edu) -# TRAK: Attributing Model Behavior at Scale - In our [paper](https://arxiv.org/abs/2303.14186), we introduce a new data attribution method called `TRAK` (Tracing with the Randomly-Projected After Kernel). Using `TRAK`, you can make accurate counterfactual predictions (e.g., answers to questions of the form “what would @@ -17,21 +16,10 @@ comparably effective methods, e.g., see our evaluation on: ![Main figure](/docs/assets/main_figure.png) -## Citation -If you use this code in your work, please cite using the following BibTeX entry: -``` -@inproceedings{park2023trak, - title = {TRAK: Attributing Model Behavior at Scale}, - author = {Sung Min Park and Kristian Georgiev and Andrew Ilyas and Guillaume Leclerc and Aleksander Madry}, - booktitle = {Arxiv preprint arXiv:2303.14186}, - year = {2023} -} -``` - ## Usage - -[[Quickstart]](https://trak.readthedocs.io/en/latest/quickstart.html) +[[quickstart]](https://trak.readthedocs.io/en/latest/quickstart.html) +[[pre-computed TRAK scores for CIFAR-10]](https://colab.research.google.com/drive/1Mlpzno97qpI3UC1jpOATXEHPD-lzn9Wg?usp=sharing) Check [our docs](https://trak.readthedocs.io/en/latest/) for more detailed examples and tutorials on how to use `TRAK`. Below, we provide a brief blueprint of using `TRAK`'s API to compute attribution scores. @@ -74,6 +62,17 @@ scores = traker.finalize_scores() ## Examples You can find several end-to-end examples in the `examples/` directory. +## Citation +If you use this code in your work, please cite using the following BibTeX entry: +``` +@inproceedings{park2023trak, + title = {TRAK: Attributing Model Behavior at Scale}, + author = {Sung Min Park and Kristian Georgiev and Andrew Ilyas and Guillaume Leclerc and Aleksander Madry}, + booktitle = {Arxiv preprint arXiv:2303.14186}, + year = {2023} +} +``` + ## Installation To install the version of our package which contains a fast, custom `CUDA` @@ -93,9 +92,8 @@ pip install traker Please send an email to trak@mit.edu -## Maintainers: +## Maintainers [Kristian Georgiev](https://twitter.com/kris_georgiev1)
[Andrew Ilyas](https://twitter.com/andrew_ilyas)
-[Guillaume Leclerc](https://twitter.com/gpoleclerc)
[Sung Min Park](https://twitter.com/smsampark) diff --git a/docs/source/conf.py b/docs/source/conf.py index 1d94000..7b0248f 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -22,8 +22,8 @@ author = 'Kristian Georgiev' # The full version, including alpha/beta/rc tags -release = '0.1.2' -version = '0.1.2' +release = '0.1.3' +version = '0.1.3' # -- General configuration --------------------------------------------------- diff --git a/docs/source/quickstart.rst b/docs/source/quickstart.rst index e6dabda..9d009eb 100644 --- a/docs/source/quickstart.rst +++ b/docs/source/quickstart.rst @@ -92,21 +92,36 @@ classification task of your choice.) ) return model - def get_dataloader(batch_size=256, num_workers=8, split='train'): - - transforms = torchvision.transforms.Compose( - [torchvision.transforms.RandomHorizontalFlip(), - torchvision.transforms.RandomAffine(0), - torchvision.transforms.ToTensor(), - torchvision.transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.201))]) - + def get_dataloader(batch_size=256, num_workers=8, split='train', shuffle=False, augment=True): + if augment: + transforms = torchvision.transforms.Compose( + [torchvision.transforms.RandomHorizontalFlip(), + torchvision.transforms.RandomAffine(0), + torchvision.transforms.ToTensor(), + torchvision.transforms.Normalize((0.4914, 0.4822, 0.4465), + (0.2023, 0.1994, 0.201))]) + else: + transforms = torchvision.transforms.Compose([ + torchvision.transforms.ToTensor(), + torchvision.transforms.Normalize((0.4914, 0.4822, 0.4465), + (0.2023, 0.1994, 0.201))]) + is_train = (split == 'train') - dataset = torchvision.datasets.CIFAR10(root='/tmp/cifar/', download=True, train=is_train, transform=transforms) - loader = torch.utils.data.DataLoader(dataset=dataset, shuffle=False, batch_size=batch_size, num_workers=num_workers) - + dataset = torchvision.datasets.CIFAR10(root='/tmp/cifar/', + download=True, + train=is_train, + transform=transforms) + + loader = torch.utils.data.DataLoader(dataset=dataset, + shuffle=shuffle, + batch_size=batch_size, + num_workers=num_workers) + return loader - def train(model, loader, lr=0.4, epochs=24, momentum=0.9, weight_decay=5e-4, lr_peak_epoch=5, label_smoothing=0.0): + def train(model, loader, lr=0.4, epochs=24, momentum=0.9, + weight_decay=5e-4, lr_peak_epoch=5, label_smoothing=0.0, model_id=0): + opt = SGD(model.parameters(), lr=lr, momentum=momentum, weight_decay=weight_decay) iters_per_epoch = len(loader) # Cyclic LR with single triangle @@ -118,9 +133,8 @@ classification task of your choice.) loss_fn = CrossEntropyLoss(label_smoothing=label_smoothing) for ep in range(epochs): - model_count = 0 for it, (ims, labs) in enumerate(loader): - ims = ims.float().cuda() + ims = ims.cuda() labs = labs.cuda() opt.zero_grad(set_to_none=True) with autocast(): @@ -131,15 +145,19 @@ classification task of your choice.) scaler.step(opt) scaler.update() scheduler.step() + if ep in [12, 15, 18, 21, 23]: + torch.save(model.state_dict(), f'./checkpoints/sd_{model_id}_epoch_{ep}.pt') + + return model os.makedirs('./checkpoints', exist_ok=True) + loader_for_training = get_dataloader(batch_size=512, split='train', shuffle=True) - for i in tqdm(range(3), desc='Training models..'): + # you can modify the for loop below to train more models + for i in tqdm(range(1), desc='Training models..'): model = construct_rn9().to(memory_format=torch.channels_last).cuda() - loader_train = get_dataloader(batch_size=512, split='train') - train(model, loader_train) + model = train(model, loader_for_training, model_id=i) - torch.save(model.state_dict(), f'./checkpoints/sd_{i}.pt') .. raw:: html @@ -311,4 +329,4 @@ The final line above returns :code:`TRAK` scores as a :code:`numpy.array` from t That's it! Once you have your model(s) and your data, just a few API-calls to TRAK -let's you compute data attribution scores. \ No newline at end of file +let's you compute data attribution scores. diff --git a/examples/cifar2_correlation.ipynb b/examples/cifar2_correlation.ipynb index 0a4e462..9c7aad0 100644 --- a/examples/cifar2_correlation.ipynb +++ b/examples/cifar2_correlation.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "5ec6fa04-de0a-4e73-8b35-a4f08bf871c4", "metadata": { "tags": [] @@ -38,12 +38,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "f949d611-c408-4fe0-a00a-e68006e766fe", "metadata": { - "jupyter": { - "source_hidden": true - }, "tags": [] }, "outputs": [], @@ -62,6 +59,8 @@ " num_workers=8,\n", " split='train', # split \\in [train, val]\n", " aug_seed=0,\n", + " order='sequential',\n", + " subsample=False,\n", " should_augment=True,\n", " indices=None):\n", " label_pipeline: List[Operation] = [IntDecoder(),\n", @@ -74,7 +73,7 @@ " image_pipeline.extend([\n", " RandomHorizontalFlip(),\n", " RandomTranslate(padding=2, fill=tuple(map(int, STATS['mean']))),\n", - " Cutout(4, tuple(map(int, STATS['std']))),\n", + " Cutout(4, tuple(map(int, STATS['mean']))),\n", " ])\n", "\n", " image_pipeline.extend([\n", @@ -88,11 +87,19 @@ " beton_url = BETONS[split]\n", " beton_path = f'./{split}.beton'\n", " wget.download(beton_url, out=str(beton_path), bar=None)\n", + " \n", + " if subsample and split == 'train':\n", + " indices = np.random.choice(np.arange(10_000), replace=False, size=5_000)\n", "\n", + " if order == 'sequential':\n", + " order = OrderOption.SEQUENTIAL\n", + " else:\n", + " order = OrderOption.RANDOM\n", + " \n", " return Loader(beton_path,\n", " batch_size=batch_size,\n", " num_workers=num_workers,\n", - " order=OrderOption.SEQUENTIAL,\n", + " order=order,\n", " drop_last=False,\n", " seed=aug_seed,\n", " indices=indices,\n", @@ -153,7 +160,6 @@ " loss_fn = CrossEntropyLoss(label_smoothing=label_smoothing)\n", "\n", " for ep in range(epochs):\n", - " model_count = 0\n", " for it, (ims, labs) in enumerate(loader):\n", " opt.zero_grad(set_to_none=True)\n", " with autocast():\n", @@ -163,37 +169,69 @@ " scaler.scale(loss).backward()\n", " scaler.step(opt)\n", " scaler.update()\n", - " scheduler.step()" + " scheduler.step()\n", + "\n", + "def evaluate(model, loader_val):\n", + " model.eval()\n", + " with torch.no_grad():\n", + " total_correct, total_num = 0., 0.\n", + " for ims, labs in tqdm(loader):\n", + " with autocast():\n", + " out = model(ims)\n", + " total_correct += out.argmax(1).eq(labs).sum().cpu().item()\n", + " total_num += ims.shape[0]\n", + " print(f'Test accuracy: {total_correct / total_num * 100:.1f}%')" ] }, { "cell_type": "code", "execution_count": null, "id": "cfb400b1-9646-4352-a803-ae8cb1ee7b1a", - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ - "os.makedirs('./checkpoints', exist_ok=True)\n", + "os.makedirs('./checkpoints_cifar2', exist_ok=True)\n", "\n", - "for i in tqdm(range(20), desc='Training models..'):\n", + "for i in tqdm(range(5), desc='Training models..'):\n", " model = construct_rn9().to(memory_format=torch.channels_last).cuda()\n", - " loader_train = get_dataloader(batch_size=512, split='train')\n", + " loader_train = get_dataloader(batch_size=512, split='train', order='random', subsample=True)\n", " train(model, loader_train)\n", " \n", - " torch.save(model.state_dict(), f'./checkpoints/sd_{i}.pt')" + " torch.save(model.state_dict(), f'./checkpoints_cifar2/sd_{i}.pt')" ] }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, "id": "73561d60-eb99-462a-9c1b-93fa6db800b7", "metadata": { "tags": [] }, "outputs": [], "source": [ - "ckpt_files = list(Path('./checkpoints').rglob('*.pt'))\n", - "ckpts = [torch.load(ckpt, map_location='cpu') for ckpt in ckpt_files]" + "ckpt_files = list(Path('./models_cifar2').rglob('model_sd_99.pt'))\n", + "ckpts = [torch.load(ckpt, map_location='cpu') for ckpt in ckpt_files]\n", + "\n", + "ckpt_files_old = list(Path('/mnt/cfs/projects/better_tracin/checkpoints/resnet9_cifar2/50pct/debug').rglob('*.pt'))\n", + "ckpts_old = [torch.load(ckpt, map_location='cpu') for ckpt in ckpt_files_old]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "34185f06-482c-47a8-b51c-020fd13df7b9", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "loader = get_dataloader(split='val')\n", + "model = construct_rn9().to(memory_format=torch.channels_last).cuda()\n", + "model.load_state_dict(ckpts[1])\n", + "\n", + "evaluate(model, loader)" ] }, { @@ -206,7 +244,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "id": "19cf723c-d1b2-425b-a1e6-265bdedbae77", "metadata": { "tags": [] @@ -219,27 +257,30 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": null, + "id": "beb047af-0c14-425d-b1ea-5b2ba7e6b7e8", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from trak.projectors import BasicProjector\n", + "from trak import TRAKer" + ] + }, + { + "cell_type": "code", + "execution_count": null, "id": "c9804779-3229-47a2-84d8-771eb7568e1b", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Existing IDs in /tmp/trak_scores: []\n" - ] - } - ], + "outputs": [], "source": [ - "from trak import TRAKer\n", - "\n", "traker = TRAKer(model=model,\n", " task='image_classification',\n", - " proj_dim=1024,\n", - " save_dir='/tmp/trak_scores',\n", + " proj_dim=2048,\n", + " save_dir='./trak_results_cifar_2_debug_2k',\n", " train_set_size=10_000)" ] }, @@ -253,7 +294,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": null, "id": "89886b24-27f2-4876-9e56-a7ed368fe3c0", "metadata": { "tags": [] @@ -266,25 +307,14 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": null, "id": "48bbce69-67d0-49d6-8467-6f8602c89154", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:12<00:00, 4.18s/it]\n", - "Finalizing features for all model IDs..: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 11.23it/s]\n" - ] - } - ], + "outputs": [], "source": [ - "from tqdm import tqdm # for progress tracking\n", - "\n", - "for model_id, ckpt in enumerate(tqdm(ckpts[:3])):\n", + "for model_id, ckpt in enumerate(tqdm(ckpts)):\n", " traker.load_checkpoint(ckpt, model_id=model_id)\n", " for batch in loader_train:\n", " traker.featurize(batch=batch, num_samples=batch[0].shape[0])\n", @@ -302,49 +332,26 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": null, "id": "96d6fbe7-2d76-47b5-8f35-a42d63705480", "metadata": { "tags": [] }, "outputs": [], "source": [ - "loader_targets = get_dataloader(batch_size=batch_size, split='val')" + "loader_targets = get_dataloader(batch_size=batch_size, split='val', should_augment=False)" ] }, { "cell_type": "code", - "execution_count": 48, + "execution_count": null, "id": "a6629868-7026-4e9f-bbea-1d69515d6944", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:04<00:00, 1.38s/it]\n", - "Finalizing scores for all model IDs..: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 94.60it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Saving scores in /tmp/trak_scores/scores/scores_394ca197-a6dc-436b-8863-7b800c29140d.npy\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], + "outputs": [], "source": [ - "for model_id, ckpt in enumerate(tqdm(ckpts[:3])):\n", + "for model_id, ckpt in enumerate(tqdm(ckpts)):\n", " traker.start_scoring_checkpoint(ckpt,\n", " model_id=model_id,\n", " num_targets=len(loader_targets.indices))\n", @@ -359,12 +366,12 @@ "id": "a2d76d04-8b6d-4c46-b616-d1e5f4ca488e", "metadata": {}, "source": [ - "# Visualize the attributions!" + "# Visualize the attributions" ] }, { "cell_type": "code", - "execution_count": 49, + "execution_count": null, "id": "a9d477cf-f12d-4a04-b480-f16c72e7d121", "metadata": { "tags": [] @@ -376,46 +383,25 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": null, "id": "8417c903-f291-4185-b0e5-ba32dd45b346", "metadata": { "tags": [] }, "outputs": [], "source": [ - "targets = [1, 2] # let's look at two validation images\n", + "targets = [85, 100] # let's look at two validation images\n", "loader_targets = get_dataloader(batch_size=2, split='val', indices=targets, should_augment=False)" ] }, { "cell_type": "code", - "execution_count": 51, + "execution_count": null, "id": "b2678eba-4d19-406c-ad2a-440d85c9b55b", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIcAAACHCAYAAAA850oKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAAARR0lEQVR4nO1dSW8k2XHOrTKzVlZxK5I9bDbZPZta0kgCtAK66OKLr/6NvvhgXywdDMPyQYIgybK20fQyQ7K7SRabRda+5O6LkRFfjJ4mCTRgH+I7vYdIZr5MRsX2IuLZRVEUlkLxV+D8Xy9A8f8XyhwKI5Q5FEYocyiMUOZQGKHMoTBCmUNhhDKHwghlDoURXtUL/+FHxzBfxTSudR8CzdnYL8d+LQOam69gXmREz9wAaLlbh7lv2+V4dHsLtF/9+r/K8XSBz3A9H+b233jtLMP18gBybiEtsxO2WPyduQXOHTstx80GPt+zXZinKT2n0+kAbTKZlOMoSoDmWfj9+E8/zXHtq2RufRVUciiMUOZQGFFZrbgOXprmJCbDGl77+GSvHO9stYG2GF3D/PrykmhZCrTMQVGYrvNy/PmLU6BNRrNynDP1Y1mWlaYRzF2H7uPY+PsI66jK6mFYjqMkBprt0n0SIeKtDOdHRzvluNvGb7kYoYjnq280cT27XaLe3oyAFi9wfQfvHZTjyRJpVaCSQ2GEMofCiMpqxbJRd4QN8gCODveAdrxHFnaRrIHmeqgqnC6J7VkkLOocptbF7bQcR6sZ0A72tukZvvB6RMpKvUWi2XFQBYVBCPOcWfnLBd5nNFqW41YLxf9qJlRQQmpmPloAbTKcwPzoYb8c3w5RDTdbtL7dbguf6eG33t1qlGPxKStBJYfCCGUOhRHKHAojKtsciYtRvP7ug3LcC1DHX//pd+U4jZdASyPUtzlzX90AdWgj3IB5FpNu9n10e8Mm6eIgRP1/8uQJzJdL7gKiNh4MpI6ne232mrj2mFxk/DqWFRdoP43f0jM3N3F93Q66+45D9pxfawBt+JZsrf52F2gP9nZgvlhSpPjN1ZV1X6jkUBihzKEworJauVviZlZtRlG9dIyROmdKm2KHByjqoileO53QPGz1gJYG6K66OYnxjQ661q5PfN5so5qreeiCzibk8jUbqMrCWhfmN1c35bgQquLoaLccLyaoPosYVUW3TWpPeNrWdIx/e3FJ368RolpJM3K9Pz+7AVqngdcuWUR3LdZeBSo5FEYocyiMUOZQGFHZ5ng1uIP53VsKZYcpupW7DXLVdrZl4BadviQmXWhPMYy8SlGn1tukUzdDXPqM6eJ2C13gq8u3MN/odMtxHOOObS52hvt7FMr2A1x7q0Hz1QJ3YV3h3lshuadxgc/0anjf8TXZHFFTrI+F+4safoPBBMPnQY1++47Yqa4ClRwKI5Q5FEYocyiMqGxzeDUMHa9m43K8XqCuq7Ht6fFkjDQXYw5pzmwSub1foL3iJ2QPrAtMGr4ekQ10Fr0CWlMk6ToOxWhWIn4T1DF+YjNdbVsiXjKn+MTdCO0lmdS8WNG7FTnGNXY30EY6tCl+4oV4n4ilNQzH+MzMQvuky2JBizl+2ypQyaEwQplDYURltdLfwjC4w8RvJsRbvqD5dDYFWquBmVa2S/zp+yjSHRHyLZjbG+Yo4n3G55M1itDExmsjRu/v7gJtHaFovmP1MfM5JgK///6jctxqit3TIb73Rpfc+8kYs8S+uHkN835/i9azwmsjVtPiuvjbtsV7eiwButmU+8ZfDZUcCiOUORRGKHMojKhsczRExtTjDz8ox/02urlnL/9Sjpshhm29L7EjC5+LWtRUFArFbJ57GJ72PLJX6iKD3A3QHezvkP20XqONIdFs0pZ+t4cpBStmu3gilG1/qbCKvp+0Feoyc31N7vViLcLyNXqXlkg3cHKxNbGkv41j3bJXvEMocyiMUOZQGFHZ5nh62Id5nfn1+w9Ffw4Wr1iOL4G2mAzxxi7pZtfF5SSyNpmlAm6zImHLsqw8JRvktYgx5MJeWrD+HbKB8+HhezBPWTpCu4WxjHVEcY8Xz86A5nn4LvMFXSu3EGRYnhd3y432JCHbwavhezUb4rcekw2yXmr4XPEOocyhMKK6Wjk5hPmLN1QkMxB9IsLWJo1dzKwqUgwHTyaUYW6LHiC5g+H0rZOjcvy9n/wd3icjF+/T59i7o8hQ/NZZlrZUZQ/eewBzLo7Pz/G+fkC/re9+77tAq3noni4W43J8dYnh8nQuCqundG1qoYr04Jvgt/RFkXp/v1uO9/ZxZ7oKVHIojFDmUBihzKEwonpPMBGC9ljh8vPnfwHaUZ/czEc7m0ALDzDkm9WIvpiPgdbZQBfv5JMflOPto6e4Prad/lhkkNWEP7i/TesrPLRrcnFtsia9nq7QHbR9chUfHWMrzsDHEH7B3NU4wvvMxljZ98Xp83L85uwZ0LIxVQGsp2iPnF9hmGB4TfT9h+iiV4FKDoURyhwKIyqrlazAcOUm24lNNjFBtuvTbacikykR4vajb/+wHMcJJvt2REH05sGjcix3UxcjcqfzNd4nFLvGyYJcRzvE9XhNvNZlvT6OT1B1OOw9Gw38u8US3VMeae12cHfXF8nbbdbra6uLLvH5H6hT8yjBb7B/gFHjOxYJfnk+sO4LlRwKI5Q5FEYocyiMqGxzOAXaDm2WdNQTbpLLelr97Hf/DbSxSLz6++MPy/HBEer07gbq24jZGa8/+xPQBhdn5TgQdsRmHXeNLy5f0lqFrfD46Tdgznuahp7InGc+siuKoWXv09mc3MosR1fbEyF8y6bw/uMPvoY0Fs4PhK3ytUMM/U+YvfdP//Iz675QyaEwQplDYYQyh8KIyjZHzUGdWm/wGATSLliV2LNrLGpeZRiuHs1YX00H0wKyGur44YCyyl6fYlg5n1Oco765DbT5EE91mg7J5/c7GKOxC0wxCAK21S3sCp5h4Hri+4heqPU6vUueoj3i2rL5HcU5ajL2/xGtzy7wmbsHmK33tE/VfBcjTKuoApUcCiOUORRGVFYrdRfdJpu5dUtx7es5OzWphaJvfYdh5asryop68j62obZE8U8ck2tWE+F8CDOLAuzF3Rjvy3ZFe519IDVFobfDipXsAsP5DitUlq6s4+Da+cGCmVhf3Rche1akXoji6GaHVGYc4zPPn5/D/CSg+xw9QpVTBSo5FEYocyiMUOZQGFHdlfWxl3fCCoXHEWYyXSdkV7T3hKsoin1GY+o1ulrgfawcs8h6WzT/6OnXgeZO6T63N2OgrdZo53jsAOCd7S2g+QG6oKz+2XLsv3EYlvA4ZbFUyvubiiJrW4QJLF7UJI4Zs1jKQ62JWXWXZ89hvkqoic44E9+2AlRyKIxQ5lAYocyhMKL60aFiG3y+JB12evMGaLOCIh+uOK7aa+L8ekZ9yfm2tmVZli0OUd7dp633rIe2zN3Z5+U4yM6AFtzi0VwRbwojquxiEd4vmNFRpKLvJ2uk4om+qKnoB8+NEl80l7FqMiZCz8xivE/MT7rGR1qOh9c6S/o/NPL7Hx6qkkNhhDKHwojqakWEg9+wk5JPby6AtvIpPCwzogrRi+L0FRUnf/biM6AdH57AvMVUSa2FLmh7j8StWxfh6Et0+a7PX9Baheqaz0RTEKYenEwchdGmb5KJ90xEc5F6nVxkR+zg5haqg5SF92e3uKN8N6Ad5UIcibbTwfdsM7U3X2FGfhWo5FAYocyhMEKZQ2FEZZvjZoTHeL0YUIbXROjimPFckaEuDutiS9yjAuif//I/gXZwgNnUP+6xpjDCtbbZadZeD3l+o4Y+H083sH1sajKZYn/znNkcG2I732Xu6XyGfyd7grncZhPb8LKacD4hO+P80z8ALbkj2laAbrfVRTvMZi5xnqkrq3iHUOZQGFFZrXx+gy0jhyt2InWAO4cFP+5CROZs4RL3H1AS7NWrK6D9xy/+HeZPTt4vx/t7WEhlu+xUohlmWs1WIlrZIJd4mYgI5BpPpLQKerc4EuppRu+2WKJa2d7BJOdul0V0UatYro2u7WxCkdiL8zOg9Vli90YTd8oleKQ11Qip4l1CmUNhhDKHwojKNsfZCE91XnEvSiQrQddlUbAj6p8sj7Vk3n+IGdJnbzCb+tmLP5fjLdEwxmcnQEfi6LDTZy9hPmC7tPIEat/FDPPplLLIkhRtGZu1zZ6Mx0D75DvfgvkmuOEY3g89bJvtWuQyz+eiEQ3blT3cx+8lC7IDlhFv18UJ2RWgkkNhhDKHwghlDoURlW2O2wT9+IRlYstMa5dlT8vKL3GpZbNr/YbQiyKz6Yxt7//w+z8Ams16j+bi+K+pKCL+43Nq/LJYoH0S+vhJchb+X8WJuJbWmwra6OfYE/Rgn+I5Tz/+BJ9hoy2z/4Aavx1//DHQ3rAepaMM8w36bdHsJiF6LoMrFaCSQ2GEMofCiMpqJXJx57XImSgURTqZcWJZuXAHa6y9tDwzuR6Y3cpC9KZIWV9qmdq7K/pzbo9JPaVDmSGF6+t0yM3s2KLgiUlqVyQmX59i389/++m/0iTCaw9Ea+zZlMLnM5G4fJvTen7zBYYXvvEYppbNCs+D+0fPVXIozFDmUBihzKEworLNkTuotHgWlC2yjGzWqCRwMDQc+Dhv1GkeiCyxRoHzVkjXylMTI3Y6dCZC4v3dXZjvnlLGVOSgi26JkySbNrN7xFEd0ZLZK8JT3G1jEfj5S2pS84+DfwZarYd9Uq+uKG0gjtHW48eO2QUezXEm+pt/84NH5fhJv2vdFyo5FEYocyiMUOZQGFG94q3ASx0WVga9bFlWs0nxgJaPW+v1EG0OHl6XGeXNLZwHNUqLCzzk6/maioaLDEPZS7HtXWcxiYMmbnvzpnSWZVk2U+uZOPY0SMjyyYSt4taw+ix8j9779AKbyVy+xV6tBdtScF0R/eHmVI7/k+kzbNDydkiVfdOvYyZ/FajkUBihzKEwonpPsEy4mSzbu9fALOgm61uVr1HcxnPRQ4KJ0EwU+65XonC5w7K91tj91GG+5HKB7unlBRZ6JxHdN/QwPJ2ITPWCZZ8HLhZA8VbYuSe2EIRrO3hLaxonGKLP/C9tVdN9LVSRBXOnHUf2EkFVdnZDamb0iz9b94VKDoURyhwKI5Q5FEZUtjl67g7M2x2yM2qiYmsdsVOcYwzxWrnYw2eQbps8HjSOKbtqPh0DrcmO47p7i2Hkl+LE7JAdD9rbwOLjlihOdh2ynxrCtooisjnWohj6YoDb6a9H5L4ucvGbFN5qwd1iYY5w1z/PZD6EqDy0yZ4aRpoJpniHUOZQGFFZrXSCLsxzJvEjsUUaxyTCxMFHViFEn81UkmwhYYuobG+jwa5FMT5hicJvrrAgeyD6aj3eohOh7RCf4YkarCZTQU1xkqQb0YKH15jE/PwcC7LH3EV2MKJcxOI3ylxZR7bCZt9LZs4VDn6TiH38mlW37guVHAojlDkURihzKIy4x4nUOM/ZUVS2cEFDljXu14R+FY9k3qDliuOtNjp43+NjaojiiqMmTl9RiDx30XB4+sl3YN5lfUo9sXZ5hAV3K+dTtCNylgF/PUC7ZjhEYyt3ya10xHtaBf5GeaGXzHlLEnZ0WCFdVzTaMo9CCl4iemFXgEoOhRHKHAojlDkURlS2OcJAHjVFf+r7qM9qrAdnKP5sLeIeszXrWS50784mbkF32CnP4wsMT9++poZ2+50e0LpdzATPWSqAzFSXDVqWLDNM2iNLdtzF5UA0mrPxXVxmBzmicLoQx3pwm0PGOTLe+E00get1MJbBbcHxjawD/Gqo5FAYocyhMKKyWulvYaJwzHZeXZnIxFy1ZIW7sp5oNd1pkau7XmMG13SGIWmfPTOLMNm3bZHYrosTHjPRerpgmVg1V4p0dIMDdgJjKlTFrz/9fTkejvAZboChdv6pXVv0APlSiJw/Bz+uw37PYjPc+uaHWJCdse/32yFmw1WBSg6FEcocCiOUORRG2IVs6KVQ/C9UciiMUOZQGKHMoTBCmUNhhDKHwghlDoURyhwKI5Q5FEYocyiM+B/Zw6FAO/fO0AAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "for batch in loader_targets:\n", " ims, _ = batch\n", @@ -435,91 +421,46 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": null, "id": "2ed6b44c-9d44-4081-8db7-fb5fff4c4779", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Top scorers for target 1\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Top scorers for target 2\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIcAAACHCAYAAAA850oKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAAARiElEQVR4nO1d2Y4c2XHNtaqy9qreF3aTTc4MRx5RsC0JkAC/+Cv8eX73N9g/YEiCLGjhjMnpbjabvdWelVm5+8FARZyAL5Q0CNgPcZ7y4mblvZkdHduNxa6qqrIUiv8Bzv/1BhT/f6HEoTBCiUNhhBKHwgglDoURShwKI5Q4FEYocSiMUOJQGOHVvfHsn05hnKfZ9jrLcphrt+mxh+c7MGfbBYzHO4Pt9Wy+hLmqQOftzk6HBp4Lc/Nos71uNnAui/B/oEhpD/1BAHNBG9e0C7r3b1/8BObe3nzcXn+4vYO5dtmGcRzTc/MsgTnfxjUP9na31+5gA3OdU9pv1diHubxYw3hxM6e9/uYW5v74z++tvwblHAojlDgURtQWKztVF8Z2i37aGDTx5pJYYbDxcUG/hHG/JBHQbvZgbvIwhfHemFiq6+DWW769vfZ9XDP1UJRt0nR7PchRBHUq/H/xXRofliiCesOT7XV5u4C5JMH3jJ7m22vHhinr2/NzGJ+0R9vrOECx4rBPvUhi3KuN3ySL6d38ufXZUM6hMEKJQ2FEbbHSaiAdZSVZK8PRCObSiNhZEiFbrJrI4h3GxrudDszNchQreUhWke81YM7OSOOvXNT+fU+IiibxZjtD9u8V4rkVyYD7H25g7ruzs+111Eaxu85CGKdDmi8d3M+hg6Jt+o6soOoVilovJ5EZiH/t1RTXfLic0PohvmcdKOdQGKHEoTBCiUNhRG2dY3Qs9IEVeTMTH02qqkU0V2ZiiQDl64aZdY6LNl7l42/XOclN38bnWE26NyzQY9sUMr7B7nWEKRsmqK+UOY37Gb7nQZt0l+en6EGuHPSYWh3ae+Wh6b8QZvm/FqRrxRbqQGHM3w31t5sP9/jckPS90q39p95COYfCCCUOhRG1eU2/LzykAbG7RYQmVBC0aIEAvZVFmVoIEiVFhWKlFGImLWmcFMhS+UGcK6Zc8S9QRmSGpxs08RabDMYuM5n/7uQZzJ3ukJnpLB5gLs/xPYs4ojVtFBW9U/SQPj+jdf7tYQJz7VF/e707wL/J/hhffHJFos3z5Hf/61DOoTBCiUNhhBKHwojaOsfiCQNJbGYONiw0zaqUzK1OgPI1Fu7qJttCHgt57+JvHaaf5DHK0NKnNYMAA21scXpZMr2iIeS/leP+YvYueYrPWV//uL1OL3+EuY7Qe/wGrROn4sR2ivpKPKdgoD/89i8w15yOt9c/e426yux+hvubkrthZ7RrfS6UcyiMUOJQGKHEoTCits5RYEys5TkkVDvCJR6zo3U7R19F00K/h8WCiDeZFNQtGHrMXVzOI5jrdMm9H4gjeysUQcNMR8rEcb4torTsnPSTSoQQOCumu8S496qB77lhbvDMQfd+leO7jNm33Q0w+uzHS9K1fnOP+ogn3PBpTLpN/7n47jWgnENhhBKHwoj6YgU5oRW4JEocETTss6ixOBUBsiLqKc2JhTqCpw9F/sk+y+8YuMgmdxskglorEVAc4jhhP71NVzDXKHC/zxr0iX59jnkinQ65r9/d4V7XCww43kQkl5dC1L766hDXHNN77n5EkXN1S2IlnGGeT7crAqtZkHPQQhFdB8o5FEYocSiMUOJQGFFb5whDkbM5INPRFUFZvkcyc12iPuKKqPGiovlWhYrNvsiH/dUpJRFdNNFl32Pbcx/R1f8Q43MnJTMVffz/OBG5s9+N6Yj8zQjl9l8eSOb/y2/Rff6sK44U1hTW8LtLDHH4do3f9s1PSbcJ1yKKnXnwhapnhRa+93pJpvbT7dz6XCjnUBihxKEwQolDYURtnWO9wuPqvCDZ3BA0xvWI0hIR5UIHCdj8oYf3/uM3L2H88z2q9dG4F2F5G5L/jjiFD/qoR+wz38rPxkOYC4XfY4f5DnzhA8mY+zxZ4vfZf4F1SfYv6Mj8T7d/grlIHBtcPbGj9wZ+k4xFwLeaqJO1WnhvtCSfyHKK71UHyjkURihxKIyoLVZcYa/OJsT6mn1koT6LrgoXGJ3U9JHFd9lzf3GObuS/H49h7D09ba+LKbqno5BMvqkw/0YdTEZ+xqKiXBGZtrifw9hv0x7sNiZ2pezd/uE1JjW9Oh/A+PSEkq4/TlA83cyQ5V/NyCTdO0OX/Th83F73mig/946GMI6id9trfmpdF8o5FEYocSiMUOJQGFE/kXqMMnS+omyqVYiR4D2Por89C3UMP8eorBcduvenMqvuIyYjFwmT1aL+VdGgdbo+6kejAepEGSv7uFjMYS4uMAK+V7HSjhuU8TsnpA/c36H7fJmhq/37CekRiUgC//T4BOPkiHQkf4Brnr4kfWk1w8g0K0D9qT2kPVTe5/dcUs6hMEKJQ2HEZyRSY6JQo0UsNRXJx2vmxXMsZKHuBqOXvulT0nBfeArTJUY1OywSzBGnu26T9jduowisCvQcPoWUnByLRKVCJG+7TJI9vf0Ic82X5MF9+fMhzL398RrG//5H8oqeHxzBnCO+bcoSxipRxXO0R2LO8/sw9zRF8WRV9D2lh7sOlHMojFDiUBihxKEwon6hKFuYeB0yk5aJiO5ek66wsdDMfS5OTE+ZTlJtMGIrldYXM4M7oiKLx/SRStQAe3hAF/6c1ev0RMcCuxB1yBZ079xBHejPn36/vT59hifI1Qjd3ssmRZHf5uguX1aoDzg90iXsNprEg4CUkJVM7GrhMUFu0fec3emprOILQolDYYQSh8KI+tHn4hic1xNvtEWmVYNFlIu6nm/28Vi+U7JI9RCjpx1XJFKzbLlEdIcqMtKJZC25ySPK23BOzovhQBR6EdFoc5ap5omMsk9vyWX+n+8+wdzOt1/jcza0h3vhLu+JCneDLilmQp2znh7JZX5ziccLx8/Qf3JwfLC93kSiLmoNKOdQGKHEoTCitlgpLRQPm4TYreuIxGWLWPyxqFPxZoQnpAOWqLzJ8Tllha53mwUjp0km7qXfRvM5zLWaIomYBUU1W3hqnImg3XhBIsgXyeTHXXLT/8ctipX1Eo8JjvYoouwuFtFxTRRlyxVFuaWiYeJqxsSc6GzV7eF4zqLG/I6Wt1Z8QShxKIxQ4lAYUVsQeUJ3yHktTdHukAc6HYv2EYciir3Djqf9hmjbMRd1P6OI3YvPLVgEl9tE/ehoF13Zj3dkSspOE1mAz81ZYpCdo9JxfkB6xCpHHWi+QJ1j/5Bc4qlYtNdHnWjKarc+iW+wmtF+WoGInBOFcTYl/fboBboQ6kA5h8IIJQ6FEUocCiNq6xy+yK6yLNaWShRvcUuSzTtCH/EsUdC0SbqMneC9jugOXRa0Zi585Lzw3GCA9v6j8DlMVnQU4ItE5UIkelcV6S+yb8vePukR37RRV7lcYkbeOiP3+W4XdYzdQ9SJLNaj5t3dFUw1WG3W+yd0w3eH+Ie4+PZie50nGn2u+IJQ4lAYUV+s+OLkNSYzaSNc2U1WT3QgaonaHrLt1GERXAWyPtdG2q1Ym69Mnsoy+3myQJHz8foRxi6Tgw1frFmi6ejZJC5c0ZW72aPn7A0w6Tte4KedskKu7QHORSW+yw/fU+frJBY1Xm3WIbOBz7GFm8Dn7UzEEUcdKOdQGKHEoTBCiUNhRG2dY3Iva3mTKzussBjJ68HQuEAmWmry6G4rQZkZiSytNCYzOBftI6oWuZJ/uMK9TkQNzsMRHbU3RJhATxzhF6xOqS3ab4yYTA86GFHWE7qMx0ziKMU172+wvtnNDZmomYiGs1lEebOLJvtigiY7bzs2HGjxFsUXhBKHwojaYmUugnTXSxIrK5Hs0+9RDQm7RBaaie6LGesOnYmE7ChGcRWzROtImLLRhszcP7zDhOe2MBWP9kisFMLEK1z0dE5ZxNtBFxO0PXYy3BziCWlfiCA/pXfzLfQ2L9/fwzgv6bdBF+9dsC5YsSgfGQlR9umSvt+rr4+tz4VyDoURShwKI5Q4FEbU1jkceSTJTLNARGX1mHkYiPLW9yHKycQjU80Wpmwujnsj1nJjVaJJfHNL5mAjx+Soi3Ps3NxiycmZ6Fa5Fl7mMCRzcKeN8n+VsURmB81KT5i2QYfepRQVWWYr1K2G473tdXeABVpWa0pOCkQkmCeSo55uKQFqMcc16kA5h8IIJQ6FEUocCiNq6xxtIUNbLKo899CPcMyixo5EZHVio0/k45J0kHKJMjPooF9hGpOeUYgGy/0xyd8LUZDNFm1G56xtViX0pYVojZEz34tsBzJjEedlgjLd9VEHma7puW+vsJjcLEL9acBqs8cb3E/DpW87HomMtyEMreWSueVtXKMOlHMojFDiUBhRW6y0RG2q2YrMpPUca3e0uiSCBqJe6KqFLL6yabxc42lqJU5M71hgcClcxV+dUdJOJ0Oav7zHMtCPMYmDuMRPsBRs/GCHWHchWnPMWGfp1RN+g6TA8Yy5z99PJjgn1ixZMHBV4ZHCYk5J2JsY1/jF+XMY//JXVCOkFCKxDpRzKIxQ4lAYocShMKJ+8ZYKZdb+Ibl4Hz6imcSjxJIVRla54ri62aN5P0Ezd/mIdTbX7Lg/FzJ0MiP5m4uo9acEnzOruJ6Da8pk5GpIesZMROCvVrSH5RLXuJ1gxLu1Q5FYtojKCsboIr98d7u9HokO2ednVOcrXOJRRNBBs/yY/Y1mc9F+owaUcyiMUOJQGKHEoTCifpjgFGXWASuIcnF+AnPZlOTteoGy2EpRxqcsLK8hWlY1I/Rl+Cn5T4oU9ZwoJp+I00K9YS2KpaxZKEAqQhF8EWLwsKF17q9vYK5iruyygXsPRYG9gtUzXeQYJR4MRH3zIb1nv4fHFrvD0fbasUShPoxUsD5cU/hhuyPOG2pAOYfCCCUOhRH1O1I7yPo+XH/YXr95/QzmSp9ExXyD9JeuURyUrOVGa0/UuBqKRKGE+Ga2QnEVMzd8YuEpcShc7SWrb5as0CS+FAlQHksY3zvDU+KTczIrM9H+K5yIembM1I5y3PuwO4LxEas1lqxxf/d3tL9S1Cj5cIX1OsKI3PR/8x1Gw9WBcg6FEUocCiOUOBRG1NY5GoFoU8nqUS1E/atpRnLyukT6izYobxssUbnVQXPQFlFawYj0nmaGsviBJV2HYo32Gcr0wCVd5uoGW028f8R3eXVEZvrwaBfmRmfD7fX3wsydRGhXZiWZsmcv0fRv+fhnCEuKKvtwiTXVeY2yr19jFtv1R8z0O3t5tr0+eKYZb4ovCCUOhRG1xUpRoql2ckRsyhcdFqfRfHu9KZHF90doDlpDEiUPIri3GaCnc8jYb7qDp5Uzm9bpXxzA3PgE63VtWInooxdDmPOGGO118RMyAfdP0dSeLOn09GF2C3OJMFcDdvrsiG5Qd6JzUx7S92z10bPZZye67SH++U4aKPZefEVixflfsAHlHAojlDgURihxKIyo3x1yiibe0R7JUNEky8qZflKIIiadMeocRYN1h1xjYlAm2lT4TOTnPsrt1hGZq75Y4/ZhDuNdl/SKXVF0ZZ1idFXFkpOTFN3yS1bP7PgA5b3ri1ZdrH5YmYm6rR7qFY0OvVu7g7rVeExmeJ6HYg7vrTL6ng9PGgmm+IJQ4lAYocShMKJ+8ZYGylsnIFlc+UhjwQ652geii/NaJFJHMSuAVom2D6JVR8baX4QF+kQqlo12/QnlfbnBNT3WOsyrUHfJ0WNvbVit8T+/x/YWlU26w9HzPZh7PsZkbrdJD7ZFDdWixPdOWKE828b9Zcx/4hX4gboiqr1ibU9KC/WcOlDOoTBCiUNhRG2xkqOlZsVjEgdZiSzL7pBYWSUYTFuJDssTlkS8FsG9vRaevOZd2m7moLi6ntPp6jpDNt0SvmNuMJ+eoTjYDdDV7jWJVZe3aGqH4ZzuK9EE7nbQRF6t6d51jNFwjjD3i4rE4M4O7sdiNczKHMVKMcA15zMSr1FDW2ooviCUOBRGKHEojLCrStqPCsV/QzmHwgglDoURShwKI5Q4FEYocSiMUOJQGKHEoTBCiUNhhBKHwoj/Aq/C8c2vIDzLAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ + "scores_prev = np.load('/mnt/cfs/projects/better_tracin/estimators/CIFAR2/ablation_jl_dim/100models_1epochs_jl1000/estimates.npy')\n", + "S = scores_prev\n", + "# S = scores.cpu()\n", + "\n", "for target in targets:\n", " print(f'Top scorers for target {target}')\n", - " loader_top_scorer = get_dataloader(batch_size=3, split='train', indices=scores[target].argsort()[-3:].cpu().numpy(), should_augment=False)\n", + " loader_top_scorer = get_dataloader(batch_size=3, split='train', indices=S[:, target].argsort()[-3:],\n", + " should_augment=False)\n", + " for batch in loader_top_scorer:\n", + " ims, _ = batch\n", + " ims = (ims - ims.min()) / (ims.max() - ims.min())\n", + " for image in ims:\n", + " plt.figure(figsize=(1.5, 1.5))\n", + " plt.imshow(image.cpu().permute([1, 2, 0]).numpy()); plt.axis('off'); plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d23a8f6a-72c7-445c-ae09-280396d8e518", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# scores_prev = np.load('/mnt/cfs/projects/better_tracin/estimators/CIFAR2/ablation_jl_dim/100models_1epochs_jl1000/estimates.npy')\n", + "# S = scores_prev\n", + "S = scores.cpu()\n", + "\n", + "for target in targets:\n", + " print(f'Top scorers for target {target}')\n", + " loader_top_scorer = get_dataloader(batch_size=3, split='train', indices=S[:, target].argsort()[-3:],\n", + " should_augment=False)\n", " for batch in loader_top_scorer:\n", " ims, _ = batch\n", " ims = (ims - ims.min()) / (ims.max() - ims.min())\n", @@ -550,100 +491,81 @@ }, { "cell_type": "code", - "execution_count": 53, - "id": "39ee710b-30e9-4bb1-9f4d-eb145b10b7d4", + "execution_count": null, + "id": "3e26aa26-63ee-48f5-8c6f-d36727f7ca98", "metadata": { "tags": [] }, "outputs": [], "source": [ - "from scipy.stats import spearmanr" + "EVAL_DIR = Path('/mnt/cfs/home/spark/store/kernel/cifar2/50pct_new_augs_10x_per_mask')\n", + "indices = np.where(np.load(EVAL_DIR / '_completed.npy'))[0]\n", + "\n", + "comp_indices = []\n", + "\n", + "for i in tqdm(range(0, 99480, 10)):\n", + " if all(j in indices for j in range(i,i+10)):\n", + " comp_indices.extend(list(range(i,i+10)))\n", + "\n", + "masks = np.load(EVAL_DIR / 'mask.npy')[comp_indices[::10]]\n", + "margins = np.load(EVAL_DIR / 'val_margins.npy')[comp_indices]\n", + "margins = margins.reshape(len(margins) // 10,10,2000).mean(1)" ] }, { "cell_type": "code", - "execution_count": 54, - "id": "5ba25042-2b4d-4501-b611-4ac7eb716727", + "execution_count": null, + "id": "39ee710b-30e9-4bb1-9f4d-eb145b10b7d4", "metadata": { "tags": [] }, "outputs": [], "source": [ - "def eval_correlations(scores, tmp_path):\n", - " masks_url = 'https://www.dropbox.com/s/2nmcjaftdavyg0m/mask.npy?dl=1'\n", - " margins_url = 'https://www.dropbox.com/s/tc3r3c3kgna2h27/val_margins.npy?dl=1'\n", - "\n", - " masks_path = Path(tmp_path).joinpath('mask.npy')\n", - " wget.download(masks_url, out=str(masks_path), bar=None)\n", - " # num masks, num train samples\n", - " masks = torch.as_tensor(np.load(masks_path, mmap_mode='r')).float()\n", - "\n", - " margins_path = Path(tmp_path).joinpath('val_margins.npy')\n", - " wget.download(margins_url, out=str(margins_path), bar=None)\n", - " # num , num val samples\n", - " margins = torch.as_tensor(np.load(margins_path, mmap_mode='r'))\n", - "\n", - " val_inds = np.arange(2000)\n", - " preds = masks @ scores\n", - " rs = []\n", - " ps = []\n", - " for ind, j in tqdm(enumerate(val_inds)):\n", - " r, p = spearmanr(preds[:, ind], margins[:, j])\n", - " rs.append(r)\n", - " ps.append(p)\n", - " rs, ps = np.array(rs), np.array(ps)\n", - " print(f'Correlation: {rs.mean()} (avg p value {ps.mean()})')\n", - " return rs.mean()" + "from scipy.stats import spearmanr" ] }, { "cell_type": "code", - "execution_count": 55, - "id": "64b9e974-c668-4b91-a4e0-d362652af13c", + "execution_count": null, + "id": "5ba25042-2b4d-4501-b611-4ac7eb716727", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2000it [00:03, 512.51it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Correlation: 0.06293852844167423 (avg p value 0.006028405998261695)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "data": { - "text/plain": [ - "0.06293852844167423" - ] - }, - "execution_count": 55, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "eval_correlations(scores.cpu(), '.')" + "# SS = scores_prev\n", + "SS = scores.cpu().numpy()\n", + "\n", + "tmp_path = '.'\n", + "# masks_url = 'https://www.dropbox.com/s/2nmcjaftdavyg0m/mask.npy?dl=1'\n", + "# margins_url = 'https://www.dropbox.com/s/tc3r3c3kgna2h27/val_margins.npy?dl=1'\n", + "\n", + "# masks_path = Path(tmp_path).joinpath('mask.npy')\n", + "# wget.download(masks_url, out=str(masks_path), bar=None)\n", + "# # num masks, num train samples\n", + "# masks = torch.as_tensor(np.load(masks_path, mmap_mode='r')).float()\n", + "\n", + "# margins_path = Path(tmp_path).joinpath('val_margins.npy')\n", + "# wget.download(margins_url, out=str(margins_path), bar=None)\n", + "# # num , num val samples\n", + "# margins = torch.as_tensor(np.load(margins_path, mmap_mode='r'))\n", + "\n", + "val_inds = np.arange(2000)\n", + "preds = masks @ SS\n", + "rs = []\n", + "ps = []\n", + "for ind, j in tqdm(enumerate(val_inds)):\n", + " r, p = spearmanr(preds[:, ind], margins[:, j])\n", + " rs.append(r)\n", + " ps.append(p)\n", + "rs, ps = np.array(rs), np.array(ps)\n", + "print(f'Correlation: {rs.mean()} (avg p value {ps.mean()})')" ] }, { "cell_type": "code", "execution_count": null, - "id": "d40cf573-0543-4dac-bb0b-bae875977342", + "id": "14f4bf6e-cac3-4917-9900-249af7b3f737", "metadata": {}, "outputs": [], "source": [] diff --git a/examples/cifar_quickstart.ipynb b/examples/cifar_quickstart.ipynb index 9d108f1..bfa9222 100644 --- a/examples/cifar_quickstart.ipynb +++ b/examples/cifar_quickstart.ipynb @@ -15,7 +15,25 @@ "tags": [] }, "source": [ - "Check out https://trak.readthedocs.io/en/latest/quickstart.html" + "Check out the quickstart tutorial: https://trak.readthedocs.io/en/latest/quickstart.html.\n", + "\n", + "Use this notebook to follow along (it contains only the code from the quickstart tutorial, no comments/explanations)." + ] + }, + { + "cell_type": "markdown", + "id": "e881aa88-e373-44c9-a224-6efbdacc31ed", + "metadata": {}, + "source": [ + "We ran this notebook on a 1xA100 80G GPU. Depending on your setup, you might need to reduce the batch sizes for training & computing TRAK." + ] + }, + { + "cell_type": "markdown", + "id": "d659eddc-aa63-4d7b-97b1-1af353ef02f5", + "metadata": {}, + "source": [ + "If you just want to play around with (pre-computed) TRAK scores, check out this Colab notebook instead: https://colab.research.google.com/drive/1Mlpzno97qpI3UC1jpOATXEHPD-lzn9Wg?usp=sharing." ] }, { @@ -148,7 +166,7 @@ "outputs": [], "source": [ "def train(model, loader, lr=0.4, epochs=24, momentum=0.9,\n", - " weight_decay=5e-4, lr_peak_epoch=5, label_smoothing=0.0):\n", + " weight_decay=5e-4, lr_peak_epoch=5, label_smoothing=0.0, model_id=0):\n", " \n", " opt = SGD(model.parameters(), lr=lr, momentum=momentum, weight_decay=weight_decay)\n", " iters_per_epoch = len(loader)\n", @@ -173,13 +191,15 @@ " scaler.step(opt)\n", " scaler.update()\n", " scheduler.step()\n", - "\n", + " if ep in [12, 15, 18, 21, 23]:\n", + " torch.save(model.state_dict(), f'./checkpoints/sd_{model_id}_epoch_{ep}.pt')\n", + " \n", " return model" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 10, "id": "cfb400b1-9646-4352-a803-ae8cb1ee7b1a", "metadata": { "tags": [] @@ -195,12 +215,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8219860b1333464bbdb4ccd0d888fd6a", + "model_id": "51e816a90cd943b2a26f9b90725737da", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Training models..: 0%| | 0/10 [00:00')" ] }, { @@ -645,7 +607,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 7, "id": "d5ca8c8b-6b51-4fdb-af27-23bf95f73772", "metadata": { "tags": [] @@ -657,7 +619,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 8, "id": "6472aefa-5510-44b9-a5e5-f2c8daa9e07b", "metadata": { "tags": [] @@ -679,7 +641,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 10, "id": "23d001f5-6986-4ccd-b86a-9045f9562965", "metadata": { "tags": [] @@ -687,9 +649,19 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -697,9 +669,9 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABJ4AAADcCAYAAAAxzGueAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAABMaklEQVR4nO3dya8l6X3m919EnDjTne/NobIqsyayiiJF0lRTJCW73bYEu7thudUw3EB70Qa8sg004F0vDMPwxvDWgAHDgBf+A7zxQoNbbRltq9VNUlRLNKmBpSrWXJXzHc+5Z4rBiyQNwXqel/dcZlTdZH8/y9+5EW8Mb7zxRmQinqxt2zYAAAAAAACApyz/tDcAAAAAAAAAP5t48QQAAAAAAIBO8OIJAAAAAAAAneDFEwAAAAAAADrBiycAAAAAAAB0ghdPAAAAAAAA6AQvngAAAAAAANAJXjwBAAAAAACgE7x4AgAAAAAAQCd6F/3D3/zWH+of6touk7eZrBdZqzem0O/B8lyvJyIiMv2bW6Lwa4oi1+0XhV4qN3+fmW1K/2b2IzPHJPN7Uq75OrG1RyuianR9VesfTNmfkIhoG90fmsatTP/9k190f1zVS1lfLnUb86VvI4q+LP/dv/Gv+WWugO/8k/9V1t11FxGxmFeyXtf6+GTmWq0T48T5fKG3K9d9fHNzZNd1eHIq62+8cyTrxzO9f2Guuyc/6X0v3fjR0/Vhv7RtjEp9HPe2hrJ++9auXVff7MqH9/Sxmp6vZP36wdi2sbujf+v39Tnc3dmy6xqN9W3JjZ2N6YvLpTm3EdG2epkXv/I37TKftv/5f/zvZb2q/H66Y7buvcuPxX5d5hDbe9qTZRLjrlyXrheFn9q47W3Mfeij+/dkfWdzw7axu7Mp663Z98rdaCOi13P3ejO/MvOV1DlcLPQY7M5Hv6fvgRERZtoXp9OJrC/Nvq9qP8dx5+q//i//kV3mKvjb/9VvyXqbmNNY5jjn5odmzWsrwl9fKbYV+4Ob+67fiuuvrRsHXWeNiMa1YY+7Zx55LLtZl+gml1gkMnNOfD8188FUI2ZVv/Pf/Z3UUp+qbx7qetuuf3/MM71M5o5l4mC6NtzUPr9Er3BzA/usnej09il4zTbSF5Y7vm68Wf+5PfVq4mm5xLB9qXF73bbzQjfy0gXeP/A/ngAAAAAAANAJXjwBAAAAAACgE7x4AgAAAAAAQCd48QQAAAAAAIBOXPjj4rX5gKn5zm5ErP8BMfeBtqZZ/6Nfmf2gW2Jdrn3z8drcfKo8Mx/3fLLMul/+dh+a8we+cttrj5U/Jj3TTuvqa37QLbWu3HSu5Dk0H6Tu9wZ6Xa3+kHKW+Kpamzi/V5n7kPqi9R8nPj/XH2U/n+vj1i/1sRkkPqR9MtHtD/t6e92HFCP8R2+3xvr8T8x+uH4cEdGYazg3/XhoPg487vt+fHNff5y4NNfqqO8/9luYZdxHaPd2ddtbm4k2zFcsq0p/VH651Mc9ImJjQ7djP4htPpQ5GCY+EG8+TvwsSn0Uc90PTac+QO24c2yDMRKTBv+h8nU/Ou6PSW328eREBxD84A91sMqNF27ZNr701a/IemHGjsFAj08REaORDlOYTqeyPp/P7bocO6aaw+7GlAh/fEdDvY/ZQt9jzLdLIyI9J7zK3NwwNd+wUyf/9X5ZTn1I27f9CYyTdjcSc0azUO4+Lu4OYuqDza7tdc9HinsWMsc9NY+2p+oSHyq3z1XueeQSH6t+Fu/A7mPdqdummxe68S1zz1CJ68G2YU5++uPi7gPf6330vEh2MPdsZw6w3fVkJzarWn8cdM/bbg79VH2at7rE+P/T7Dv/4wkAAAAAAACd4MUTAAAAAAAAOsGLJwAAAAAAAHSCF08AAAAAAADoBC+eAAAAAAAA0AlePAEAAAAAAKATvYv+oYuwb02U8pOFXPy1iTk0bbhI6NQyvZ7etUEiBripTLS6iRDNzbpSUcP2OJqMVhdJ7epP1qXjOO1+mL+P8PGpRejzXpt6ka9/DuvaRH5Xfntz8y41y/QyeWuiwBP5qK5vXXWz2ULWU8Gqs2Ul65O5vlZ6ZjwYJM7Z2bluY2O8Iet17cec+UJv19m52XeTj2tjXcOPX8O+7hc7GzpGfHujtG3cPNiS9aXZv7Lvt3cw0O3sbPdlfTjU8e39RBsu3ro25/305Myua2NjqLdroMcQNw5niXHtMsnin7bGjEmp+6P7zV1Dro1UlLONX3Zxxol1rdt+buYYq5W+TlLrOnn4QNYf//mbst4s5raNL3z1K7K+u7Ut63nintKued4vc39y62obE09f++PbNLpvbW/q8Xw80OPQWWKMaJ7Re7Cbg7k5W3plthFZvkyMuNve1JpczPa6e9gkZyZrbpc77mttUXqZRPK4X9eax9fdZ3/0o16XXcSfRduOXZftjIk2nj2ludU2iWOZmflJz0yn3Nwzdf1m5j6Ym6PsZwyR6DDrjR+Jx2C7L3Yu5+YS5vktImI51/fn/kDPx91cIsVNZdz2uus93cbTG7fXX4//zTw6XQj/4wkAAAAAAACd4MUTAAAAAAAAOsGLJwAAAAAAAHSCF08AAAAAAADoBC+eAAAAAAAA0ImLR4OYdJPUm6vCfJ3fJbu5nAOXdBPhv0TvkmDa1BfiTbKI+6p82dPZAOnUHtO0SzWx4RKJtAiXlOG+wG/XZIMJozQra8x+NIkkMpfI0HOxCIXf4sL9ZvpiW+pLoK110lpERLt2PstVoY/NIJlWpi1XJhXLLLCo/PF0fWw00Odmc+TT4PoD3c72tk5hWp6ey7rtexExNNEmN/Z0atPkfCnrW5s6XSMiYmOs93HTJOFtmuS8iAgXKLlntrfs6TZKF8MSEY1Lvxrq7ZrN9HGPiJhP9W8uoaVv0gTXz2G72i6TlFIlrrt12kjd09ZdJrUuty8uda0sdV+dm0SbCD+mzQ6PZb1vxogwCZMREY+ODmV9VOjExsLchyIizmczvV1m312q3UcffWTbuHbtmqy7M5WZBOCIRMKlSxo0k6LEbSkWJjnvynPTk0TM5rqhZJca22yQlRtzUitz1/16SUuXSpyzx9HNidc/WnaJZIqX4ZLo1vvzC/164UYus0zrLtZEYvYlmv+09cxGN6lzb35z63JTz1RXdddWZvpEKnHOW69/JR7TEteDSXA1k9jTB49sG2eP9T349c+9JutlItVuabZrafq3TZBPJROu+V4k6aldXL7tZDLiT8D/eAIAAAAAAEAnePEEAAAAAACATvDiCQAAAAAAAJ3gxRMAAAAAAAA6wYsnAAAAAAAAdOLCqXbui+uFSXaLiMhNEo1LOvBpbInED5OmtAqdelLmiV026xoOdHpMv9Dv7ZKpduanyoS01CbxJUu8M3TpTzY1MBEQk5togsLEIritqiqfblGYlLDSpPPk5rhH+ATEVa0TdVwqoms7IqJ2CYRXnEucS71/LnO9r1sbOp2pWum/X7hEo4goR/r8b23q62409OcmM8lrTavTvXbGOnVtIxGpNCj1byOzWZNW7/vGsG/bGJnkvp5JnHPJbhERTWP2fUen2rmUyTIRU+LGYZcyVOQ+LaM2A1Jtkibb9jLpos/mNaykUu3c+Jan7oO6lUT7rm7SzRIJp2573bl36Tzj8di2sVjpdc1X5v547UDXE22cnekkvHZHjwVNah5l7kXTc512d/feXVl//913bRu/9I2vyXrP9Z/EWJCZS2symeg2CpNSWup7TETEYu7vJ1eZC3ZL5RZla0YUXSobac0NS4ZDuwFhzVS79F6b+acZED6JKdtlUvjccfTHMHHdrfnDpVIDbRP+l/XXdnXZR4/ErphAbZvmbFPtfBNrJ5YXl0hztG2bep663tdMfVtM9b3j6N5928T+hkltdvMPk9Qd4RNki76+b7s9rxMdxc6LXDqwXZNf5mn6af7XEv/jCQAAAAAAAJ3gxRMAAAAAAAA6wYsnAAAAAAAAdIIXTwAAAAAAAOgEL54AAAAAAADQiQtH21QuES2RDtSa9Dr31X5XL0wyUkREZiIDWlNfJb5cX5hkpsLED7TmK/QurSDCJ86tTOpbGybxzYfghA2cMUkCTSLyo65NSkhr0sN0YFCslraJCLOPNoXNpIRF+P44WyxkPTPJi3UiBaX7vIBuNKbvTWf+eNoEt4EeOupSt1HWvsOWJipkuTDpU4ntXSz1iZtM9DIv3trS9Zu6/qQNvY8Dk3Cxu6fXtWmS6yJ8SkzPpPal2GQzc0rcmFqm2jYXa2PqlelXERFVvX666bp/n0qCu6rc/lwmwKQ1Y74797nrLOGP5WVSau1vLgXHjB3DkU+cc2Fp9UD/MHzlJVlfJfrw5Ewnzk0bPQ4tHp/YdfXMeFP09fjx6NEjWV9V5uYcET4lTO/jrEql85hkWTP3comFq8Yf31Q60FXmEuoSU9xPaL7hkpPMNZzYKrcvbjxwSVY+Kc33y+1tnRQ7megJ6HKZSthcLw4umfTnf1pTKj5tvZ5yqRQ+G17nUhGTWWyX2IJPV+6mbKlpmUucs0l07rgkrrk1206dFhc4XNjr1LXhe5hL1asmOg32/NGhrN957pZtY8OkYq9qfW+ez/xD38mx3q7v/cn3ZX20NZL1z/zcZ20b+9d1eu6gr5O3UxfwuvNb1x9SYaA/zdXL/3gCAAAAAABAJ3jxBAAAAAAAgE7w4gkAAAAAAACd4MUTAAAAAAAAOsGLJwAAAAAAAHSCF08AAAAAAADohM5EF5ZLHXnbS8T2FSbquCh1szYNNJHpl/dMLGOlY4uXSx2lGBGxMdSxhVWjN6Bq9f71Eu/zMpNbmOfumJgIy8bHwK5MVHZrorKLwncDd+hbmxGq1zVfzG0bdeio7p7pnq2JpI6IGAx0hOa4p+O1s0Lvx2S2sG0sfPNXmrtUz2c6ajgiIst0PHFp4own5/o8L1Z+nBgP9Xn+8L5e13Tht7dvIs43NvS1vb+9Kes3buzaNpaVuYZbs13mWGXJrFK9TGuubRcvHRHRNOvF4Lp1pSK0M9e+idQdmLE2IqKo/dim1Gv+fUREY8b0Z1HT+GvL9ZfW3Icy0yl7vQtPFf5SG3q7ytJlUvtl+n29TM/MJUrz9xER09OJrE8qff0+nk31NtW+jaUZo6a1nkdN7t3363rrQ1nv7W7L+tHZqf77xDFx9/PazGXO5v7+uFzqG+S68e2pdPjeM/pPpq05ClkiejyZaa3aSB04wy7h4thT7dtV6ZXZv09kvrehx/ytoZ5LVkvdYZbL9e8ddrPWjDCPCN/J3bw/sSrbt9xxT6zMdcfMtOFuQamumF3meH3K7DQrsSvuGLhVFZcIqrfXkOtHifEmN+333I7Yc+/3YzXXc/ujx4eyvr+p73UbGyPbRpvpe3Bhbh4/fPsNu67f+I3flfV7Dx/K+tA8b1z74z+ybbz2+mdl/Ze//jVZv3njhl3X05InOvb6vfQvrxcAAAAAAADoAC+eAAAAAAAA0AlePAEAAAAAAKATvHgCAAAAAABAJ3jxBAAAAAAAgE5cOKqmMilq9cKnm/R6OhGrMevqDXQixaCvE8merEunxBw/+EjW3/zT79p1vfTyq7L+mc9/Sbfd6v2oav8+r8h0skxmUoP6pl6atiMiFiblqTIfqK+q9ZM9CrNdRV+f88Kkx0VEhNkXE6QYtUkGioho10zRak3/SYSExWy1/vG6ChYmbahOpItM53qZoYkxWZhjszJtR0QcmWUenukEytXKn//97aGsP7e3Ieujkbm+BrofR0QMxqZztPrariq9vatEP1osTJLmSid1LEt/fAvTmfsmESx3CWYmaS8iorbpabpuU/Aiolwz0c8dX5eQFvFsptq5/bnMvqQSZ9ZtI5VSty63jzadx/Qjl0QbEXFuElYnMz3eHJ2dyfrzN5+zbczO9bxoMdXX/PmhTtqLiJh9/EDW6xOdtjcp9bF64eU7to3CnEOXdreo/bVVZ3oe57jknM2R71fjoR+frzZz3FIJX+teq2ummz35zXHXo2/fXsNr5iC5/YiIyM2/mY9Mqu1qrPvL6XliLukS3Gyis12VTQpzC7ljmEyi8z9pyVQ5l4a2XivuGP7412eNCVEPExwcET5BzqYKr7dJSe50FYlUu8zcO116rkvhq1Z+Tvrovk6D2xzpZ/3xpp6/t4n7fGbuQ3OTyPo7//if2HX9829+R9b/g7//H8n6tet7sl63/pi4a+t8ei7rReJadGfXjivutpQYVX6afsr/eAIAAAAAAEAnePEEAAAAAACATvDiCQAAAAAAAJ3gxRMAAAAAAAA6wYsnAAAAAAAAdOLCqXZ1pb8Ef/f9d+wyfZNONDTJE/2+/oL6cLjp2zABKo/uvSfr7735fbuu5VynxHzm5z4v66VJasuTCSX6kDe1/tr92cx80T6RajcY+xRA2bZJGYyIqF1CnkmWGw91qliz0olBTxrRJ3G4syvrk7n/0n5l4iUykyC2XOjtWiZS2IpM7+NV5xLqUt11aNIvVpU+Z61JWigHOlUwIuLozCRjmg37/MvX7br2d3Q7w76+7na29Ll0SSQRPvEwM9e2S4BsGp2uFRFxeqqTtOZznWpXlj7laXd3JOsupC6r9A954dOqXOKckyfTcdZL3nD5MKnUwHXTea6CVErf01rXZZLz1k3VSx17t66FSXNcmPvmsvIpcVNzT+2ZFJzbN5+X9b5JcI2IWJpI1tlM71/v4JpdV/myHgtm53rfxybBtU6cpvNzPRbZ9MnEOc9tQo5WZPo6HZkxO8LP+55dyVgsXTcH1KUEPs0MsSyxNpdytW77ySHazPPOF/q6G/R1QmKRJxpxXdwukoz6M/X11nSZW4BLwkvdg9dNv1qzi/5ooWfv/z24YSfVV20iq02fXLvj2fbdEkXizFS1vtf2zf1xaVLiTh4f2zZGJvF+Z3NL1t28IJ3UqfuXu3UdHNyw6/rc535OL7Ov0+teuqMTZEdDf0+7c/uW/qHVY9r5mZ/j9M3zlksgds9tqWTRn+YW/Oxd+QAAAAAAAHgm8OIJAAAAAAAAneDFEwAAAAAAADrBiycAAAAAAAB0ghdPAAAAAAAA6AQvngAAAAAAANAJn+33/3N9T8cc1lMdJxgRcXZyIuuzuambSN+j0BGAERGjUscAfvz+D2R9cvLQruturgMC33rjT2R9Pj2V9YGJT4+IOLj5sqz3N3Z0G3MdmXx+ptuOiNjf0+dkY2ND1otETPqw1PviQhbPTh/L+g/NMYyImE50vPXrX/kFWe9vHth1VfV671KzTO+f2e0nvz2DUewREbOFifIu/DFrS903qlpHYPdN309Frpem+f2tkaw/f02PRRERN6+Pdfumx/ZM309tr0k3DXcZ9cwxGZjY84iIgYlqPzycyvp8piNwIyIac7H2zLnNC31u0/GpupHcxLHnqRhrs71VlciDF1ZLPXZGROSJMe+qaht9XrI2dVxMTK7J2M7M+UoNeY3Zrp6J7m1chwx/X3HXqVtiOp/ZNqLSF7DrkjZ2PDVGmPGxZ3ajShzgbHdb1kc39Ph48kDfgxcLP0ZM5uY30x+a1t8z3C/u+BauzyWispt6vbHgqnDR6i6+Pv2bi2lfM1s9wl54dl1+cyPM2BKZXqi1sfK+j7n78+lUj/l7enode1v+2WK51NfwdK7riVMY7uCveaiS47Br3tXzxPbadT3FqW/ycF1Rdqqc2Bl3znLb7009cezduOLWdZlzX/b0zp+dT2R9a6Tn4hER25v6ntaYuYwd7RMd0kxLolrptf27/87fsuva2/uerB8+/FjW/+1//a/J+mKqj1VExMDMS6arhW57cmbXde1APyOPdvQzR2UGr9Q0/af5X0v8jycAAAAAAAB0ghdPAAAAAAAA6AQvngAAAAAAANAJXjwBAAAAAACgE7x4AgAAAAAAQCcunGrnUkS2t01cRERsber0qfn0SNaPH9+X9azwm1nUOr1mNtPJefcfP7LrejzRiRivfPCubmOq28gaE3sVESvzpf2tvRdkvVfqr9AfHd6zbbz3tv4C/ysvvyLrZV+n3UVEFL2hrLuEvMPHeruaRn+ZPyKiaXWa4ftv6v148ZXP23WtKh0bVJQ6JWw41vtXmASHiIhB8Wym2rnwq7bwERcL02G3Rvp4box1SoxPpYrYGurre2Xa/ujBoV3X9et6zMkys/MmyTJLneN0fM1fXZdJtOm5iKuIuHbdJFkN9fF98NinXJ6e6TFyPNZjy9Ck7bmEuie/rXdNtIkkNpci1jPXpEt9qhLXcCrh66qySUOJ/miTcMwPuYntcclTqe1yyYFFz/eVyiS7tCbFqjD9zqVCRkRMpjpF1aXz1SbGsswS14Mbb+bHuvzmW3Zdq2O9vbNrOr325Fi3sfPii7aNxuyLD4/z59D1FTek5mZdq8r3uf7Ip5FdbZeZO7j0q3VbvkSsnUvFTMZ4rZtX5rbLr2c80v112DdjjsnF2hz6YzI3+1GY55FUf53Odfs20c8MLampR+tSDs0yqVzIdu3k5vX6z7PKzdjSiXOm7v5+zXqKS69LTPmjNf8fZXKiU9RyM4feGm/aNvzxcimaZoMT8XxVpe/nh4fHsn56op9DIyKWJlnufKpTpt/6wQ9kfWfo5yXLE51GOzYp9SPzbiAiojDnMDNXfWGuX5d+/GRdl8f/eAIAAAAAAEAnePEEAAAAAACATvDiCQAAAAAAAJ3gxRMAAAAAAAA6wYsnAAAAAAAAdOLCqXb1Un8hvl/qVLCIiPFQ/zYzaU6T04msN7VPiXv4UH8J/tEjnTjXFj4N5frNm7K+u60TpvZ29Vf7s9ZE10XEsDSHvNKJelWl05ce3XvbtvHRB38h6+NSH8fRxr5dVx36HJY9vR8P776nV5RIxMrMF/Xf+tM3ZP3o3vt2XeVQpyxmvZGsFyOT4FX6fvLindfsb1fZygRA9BJRKS4xyyWMNSbZpTKJURERY5NQlI91AoRL3oqIqGvdTm7SLzLz973EONEz7Rcmxct2fZMGEhGxd6DHnDw34/BIJ19ERHz00bGsn0912t10oK/t7R0/1heFPleZSR3LM3/rsWkZ5kC6w9smEjnu3z+2v11V7jJtEv9+ZMLgonHXtYlAahIphBsbPl1FyRIRQIOBXtdqqVNl6pXeriaR2lOZqLbUMlJiP+qVvtc++t1/Juv7Oz5Zdrmj5xmTEz3H6Zn9cMc2Iuy+ZOa8u3ScCJ+QY0c7c2/Iwo/Ba4duXRHrdrGIn5RGd/E23DwrtYz75TL/Yu17zPqpdrsbum+YkOIYmiTNs5Wedz/ZKt3+7tjsvRtsw48tMxOuWpt7V+ocrhsm2CYWcH3Onyn9S3qTLnM1fLpsqt0lkmXdMmsG0Sa50Ld+4go+fKyfw2czPV+8fkM/c9WJ89uYa6V215A7Vol4vjbT95V33tfPqL/7f/xTu66ziU68u3NHJ8V++OFdWR+/+JxtI69M8qW5Tje2r9l19c3zixs/CnOsXDrek3Vd/v8t8T+eAAAAAAAA0AlePAEAAAAAAKATvHgCAAAAAABAJ3jxBAAAAAAAgE7w4gkAAAAAAACduHCq3cClsSUS3LLQv5U9k1bS6Pdg773jU8zmE53s8t67D2S9bnQ6TkTE9es63a01qXqZS01qE1+CN/EW1VwnCaxqnSTw6P47to1HH+vjNbmlv6jfNwl1ERF5oc+hCRmK87MjWc/cOY+I69f01/nPTo9l/fDwvl3X7Zc/I+uN6eqrQ50k8NwLOq0gIqKfSge6whYmzWlkUswifFLb3KRcTiqd/hAm3SwiYj/TiYP722NZ397Wfx8RkZkEiNakM1UmSaIsUxEiOsGtNUlt5cD8ffhEnd/6zf9T1r///Tdl/T/9z/5ju67nn9fj0cOHx7J+djaV9ZFJH4yIKPsm/cgk0RWJRD+X3pKb8bY1/TqVfrhtksKuMpcw2WT+WC4qfZ2uTL/Pzb3OnceIiGym+/FgW/eXIrEum2qTmWVMbI9LlYuIWK70MbFpYKZDuvMRkUgN3NcJQOdjf08pn78l6y/29fj44d17sr65tWXbsJGJ5lrsJRKL+ua6G/Z1P80y3U/Kvh9vfvakkmV13SWPuRQklzz2o5Wt1XbqX6zXD98yyaeJRlx+3MCMBzsmvXi+8El0j2d6XdOFjqIbFX7Px6XeGRcWOjXzq8v8TwGfcujZlDa70CUi1569UDufapc4MTbVzvV7n2vn2zB1dw0tXZxiRPyz3/t9Wd/Z1feuza2fl/WNod9eF3Jdmx/cvTarfSeqTFL89/74u7K+mJlnl4gozT3tzCTL3jVpe/nq3Lbx0m39fH5jxyRWJ1Kbjw/1dg3GB7JemO1tzTuciIjs4q+P/gr+xxMAAAAAAAA6wYsnAAAAAAAAdIIXTwAAAAAAAOgEL54AAAAAAADQCV48AQAAAAAAoBO8eAIAAAAAAEAnLpyH52KZM5cHGj6KtT8cynqd63UdnTy2bdy+eV3WZ0sdpVj2dbR5RMR4rOOGq0pHM5eFXteg9DHAPRPLeD6fyPrJ6X3996ePbBurmV7X5Egvs721YdfVtAtZn5kI7cW5bnu8vWvbcLmq87mOt7z74IFd083bn5X1l199TdbvvPKKrN+4pSOsIyLy0P33qnPHsxr5aPnVVC+z7OuhozT17YG/7g5MtP3enq7nPj0+onXxn+tFomepfNxcr6soddtv/vlbsv6//A//m29irHfyH/6j/0TWh4PEQWn1ORkOdT1rTey5byHaRo/d7ji6iOHUby7WvjFt9BK3t60dHUX/LFqsfOTtqnHHTB+bxsQTt8nY4pmsj/r6vGxt6fvskw3Q/agx1+nC3OfnC12PiJjNdZR0Xeu23RjRmG19soyuT15+XtYH2ciu67kdvUyYMeLVDT1u9hNjsB8H9d/3E8PN0Pw46JnrtDTXac/Po9x4c/WtH26frZk772La3TmOuMxWeX5dbm16ib1Nf/63RrovnZ7ra7tX6DFye+yviQ8P9TLzpd7eaeKmVmSmv5qD5WYf6fNhznu2Xv+5QEOiETN+rN/ylVbY3u2P8brn0l8nCab5ptZ9+KOPPrKr+oM/+I6sv/Lqy7L+6mdekHV/9UbUK/1MvTJ1d2nNZnruERHxzX/xTVn/tql/9avfsOva3NyW9bff+aFu4y/+TNZ/6Wt/zbbRmmeX3/+mPh+f//mv2HVt7+7JejHUvfHWLf33daPPxxOXv2vwP54AAAAAAADQCV48AQAAAAAAoBO8eAIAAAAAAEAnePEEAAAAAACATvDiCQAAAAAAAJ24cKrd2cokOWU+3qQwiTo98zH04ZZOqCuHPnXrw3s69a23oZNzfu3Xft2u6+U7t2V9cnoo61mjd2Qw8olJK/Pl+lWt0+OqWqd0LBa6HhGxMKk9x8d6P248p497RMTKfNV+dq5TgxpzTB489Cl8Z+d6309Motr9xyd2XY+O9TJffeF1WW+GB7J+1zcR20OfInWVjQcDWZ+bhMKIiIFJgZybJK3T2bms54nUj8FIt9E3qWuFSZWLiMjMkFabdI/LpNrlJpnyj/7592X9v/mH/5Osnx/7a/g//2//gay/cPuarJ8eH9t1rcy5Gpj+0Jp0r17pj4lNN7Wnff2kHZdsUrjkvNTdLZHGelXNTcDIsvLH0iX+ZTbhylwPlwhGqs12zec+iaZpdF+tTJ90yXKNTbeMWC71/Wa4odNK855uY6P218Oi0stUC92J95739+BqU29X1uoOMRiZ1NVUqpn5qTAXXWnGwIiIQV/nGblxuzAxpVn4a7Qy/eTZlbjAUhGggrs91qnkvDXT1S4zfrt0tcY8J5S5b6Mw1/fDEzO/NsnUn3/JJzqXpUn0Nde9S12NiFia8SA3xyS36/pkcuJa0467b9itTRyT9hJ96NPm57F+rPIpdbofuWvOJbtGRNSmfx8d6kT4mUm4jogYmtT5o6MjWT98rJ8r+4nk0ZV5fs1yvff37t6V9d/4zd+0bfzRH31X1quVPo4ff/ChXVe/r+fKD+9/LOtjcw++fvOmbePt996V9e986w9k/bXXv2zXde3ghqy/967exxs3dKpdaxKuIyKaxHPYT8L/eAIAAAAAAEAnePEEAAAAAACATvDiCQAAAAAAAJ3gxRMAAAAAAAA6wYsnAAAAAAAAdOLCqXYPz3TylU0zioheob96npu4oTzTX1a//fKXbBtvv/mnsv71v/43Zf2r3/gVu65xX7+Hm5w+kPWjh7q+rHxK2PnsTNZ7PZPsYhNf/Kmran3cT88msn54pFMJIiLKofnafaaTa3b2derWe3/2A9vGyzs6WW5ja1fW59X7dl2bBzodqO6PZP3Do6mszyqfmjM2qT3/pl3iatjZ0skMi6VPV5stdPrFyiRW1SZ5496xT7J61aQa7mzrtLus0PUIn86Um+vIptqZv3+ykB7z5iZ2rJrqNrY2faLOZ794R9YXM32uTPhkRETkmUucc/uuxw93rCJ8potbJrGqRBKOqa+Z+vSk/U8mHehpWplxPXUs1+eOsV/Cte+SV4ueH1tdf2nM+XJ/P53qe11ExD2TRLO5oa/Hg1yPN0XfjxFvn5zK+mCo70ObJlEvIqJtzNzL/b2ppxKmXHqdS6Ire/7fLF3gXWvGzdok4ZaJZFE3t7zq3FanEqvceXOpYC5F6zLJlO7iTq3Kba9LRCtzk/iW6GMPzkzacq3b6C/1mLM11nOiiIidkb6+lyu9Xf2e75OzxsyxzLFy10QqPc3d0+w4kbxvPp2bSmrO8AkF9D1VbsRPJ/SZ5EJzAFy9McmuEREnxzqGe7XS9w73vBnh98UlyD54oJPlR4n/1tKa56v33n9P1n/nH/+OrL+fSqLr6ee02qTaPnrw0K5ra2tT1kcD3cav/Oqvyvq3/+A7to1Hj3Ty+7//d/6urG9ubtt1jcd6e+eVfg47OtTzpcFAz1ciIgbu8SXx6PRj/I8nAAAAAAAAdIIXTwAAAAAAAOgEL54AAAAAAADQCV48AQAAAAAAoBO8eAIAAAAAAEAnLpxqd740yROJ1AKXfJKbeI2s1X+/+/xnbBtfvnZL1jdGOiWmMYl6ERG5+Qr+3v5NWZ+d6y/BP3rwkW1jaRLEhuN9WR9v6FS5nT2dBBcR8c47H8j68Zn+ov3hsU8Aeu2LX5b1/Zuvyfq1a3q7Hk98IsPpiW5/vtD95JXP/aJd12tf+oast5n+1P7G0CTGnPt+XT2lxI9P2ude0OdmttApDxER5yuTHjPXaRnnC10/m/o2Hj3SSY+7JoVvPE6kM5lIpbbV+5GZd+9tk4pc0b/tXtcpE61Ju3nhiy/YFr7whddlva7cfiSYcXV2bsaikUkDqX0aWVHo66s2SSxZImLJp2+5hCXdhkvRiojoJ1JdrqqhSVGbmWsuIqI2x6BNJIatb73z0iSurdqkUrl0lb7pd3/+z79p23h8dCzrJ3d1qs2o1ePQe5W/bx4NdRLe7Zc+K+suiSwi0Y/ddWLKee7PuUtVs1di5cfzRa3HFZek1DNJf3Xq30WfzVuwT/lKDOCNGSvt1Hv9JqxUEuK63L6XfT0nn1e+7aOJvg/2TAqjm5ecnvl+fM3MPx6cnsv6lknFjPBJYe6YTEzSr0uZjEicK9MfLpPEZsccm6jn20in6l1NhR2T/HxizYxe2yceH+uk1IiI6VSnT2+bPvnw48d2XYV5VuqZdNeTR/p6uDv3KXHf/7Pvy/qfv/nnsn56eizr25s+DfZ8ou/PpytdX6z88d3tjWW939PtzyY6Lf33/+n/Zdv4+te/Luu/8Au/IOtHied2l/q6Ye6177+r31msEnP+1z6nn1FGez4J78f4H08AAAAAAADoBC+eAAAAAAAA0AlePAEAAAAAAKATvHgCAAAAAABAJ3jxBAAAAAAAgE7w4gkAAAAAAACd0DmmwrAwcaAmLjsiwiwShYmHzV1UaCL6uT/ScZGNWdes8ts7NMmBpQm+XMx15Gnb6KjXCL+PvUJHVbaljnRdmpj7iIjGvE88n+ntLUsfSfna574o68XmHVmvc92lXv/yN2wb3/vjP5T1nRs61v1XvurX9fptHVFflPq45yYGddr3fW5ePJvvazc39bkZj3wU7HVzETfmuH1w70TWjxOxxW99dCTrGxsmkvy5Xbuu0kTOFxce6Z5oTBT8j9YmqxtjfR3deGVH1v/Bf/HrtoWROSeLmb7u68SYc3x8JusrM4Zsbun9sPHdEdE0Zkx3Uc6pla2ZlZ6ZdaXaqCp/vK6qQc+MYZkeJyMiFit9U1vUNmNbS8R4l2Y8zM3JT52Xwtw/VmY/vv/d/0fWP/zwY9vGiy+/Kuv3792T9W890lHD9z7U9YiIL3ztl2R9vLMl66ljsm6kfW7mS6n1NC42OdframwYeERrxoLW9TkzJ+sNfb8u1hwjrgp7Ckwc/ZPfzLpcG0/x2LSJ85xaSjI7P1/p8z8/1RHxqSb6PT1+uHHw3vHSNvHCgY4F3+jr+Pj9bR8j3jQr84ve3tlcb1fqtpmZ5yonNYttTX90Y4hruUl0H3ffvsrcTDlr/RzaHYK81X3ybK77/f2Hep4cETEc6ufEhXnmOzvSc8KIiMJscVbr+g/feE/Wv/3Q34Pfu/e+rJcDfT30zfPx9ETfsyMiRkN9TnZ39XXa94/B0R+6Y6L7cGm6w7WdTdvGF19/TdbH47GsPz7Sz1oREX/4L/9A1r/9rW/L+mCkd37vYN+2sb2rf7u+p98N/GXP5hM0AAAAAAAArjxePAEAAAAAAKATvHgCAAAAAABAJ3jxBAAAAAAAgE7w4gkAAAAAAACduHDW07Ut/VX5JpGu5iIYXEBOv9QpJplJuomImC11WkRl0vYm5iv/ERFto1MGitVM1s/PdfpA49JbIqKX68/dl+Yz+I8fnsr6ZOr3ozARXq1JUViuXOJGRK+nt6vX1+dqsdBt3HlJJwlFRFw7uC7rLlfsuYNdu67Nodn30NvVVPpc9bLEpZFIRrzKTHiMTSGK8KlkZ+dTWZ9O9LWSSolrW/3+++jEpcfoBI+IiEGjx6nSjC1FoftFL5GkWde6b7hkiL/9935V1v+tX/2qbWMx0cfXpSIVRSpVRS+0uaWPY5bpc9UkImpqk4pVJNJe1mcSdUwCz2Km+2JExOmJHldvrb9Rn5is1uN0mbg/FgPd71uTmuRSi9x9ICIiM9d22+q5gUtAjIjo93XizF+88UNZ/63f/N9lfe/gmm1ja1OnTL69+kC3/ZGuX9vfs21s7uyaX9ZPCXPnxI0FbavPhwuui4goTHqdSzVrcj3OPtkus4zJvpqd677Yq32f2xr59q80f9L8IrbPrJsKlup7bl1PL3kst+O3aTnRdFnqMS83CZtDk3Y3Xfi5b2Yej/Y3TFrWlu+vi6W+1/Z6uh+fnrtnDj/v94lz+kD6frV+kqbt1qmFnr1Qu3A5m3VyZ/TBKcyzYGbmM21iAJ9N9Vy5MUmHx8eHdl3HDx+YX/T18PHdu7I+yCa2jRs7ut/ff6yT+4ZDnQZ7+/nbto3NbT0ff+Otd2R9cqbn3BER+/t6nBgNzDk0zxX9RIL4K58xSfHmvcTpmU8mPD3RiXejDZ2Qd/O552T9tc/ppL2IiJ09PY+6CP7HEwAAAAAAADrBiycAAAAAAAB0ghdPAAAAAAAA6AQvngAAAAAAANAJXjwBAAAAAACgExdOtRsVJhnBpKFE+KSUwkQg5ObveybBIiJiw6SYLZY6Uad1MV0RUZhkhumx/tr90iTqubSCCJ8ksVrotIqpSSvIC5/sVZb6tyLT6TGzRPrTdKr3fXdTJ+eMQh+TrQ2fQlPu6FS7lQlxmCaSCc/m+rwXPX3ca5Nqd3jiEw4mJjHxqnOJcy7NMSKiNdfq3Fxf5UBfwy8+t23bWMz1Odjb1gkMLuUhIuLoSCc9uKt+Y0u3sWvajohoCn3+S5PINV/qvrRK9OO6Xi8ZKpVYNBrr8aB26Veue5u0u4iINvSY55KJUqk5Ps1I/1CZVE43PkdEnJ7psfAqa8z5Sl2/7va8NTJpd2Y9deXTa11qUmESplJ9tTLtvP22TrU7M8kui0Ty6Jtvvinr58c66fD54a6sH9zWKTQREcVQH9+eS/BaP+wukQp1mZWZ+6NJ6J2lUkpNamHTmP7r1mPGzYiI5UInCl91645tT7n19Zew43dqKZeuts5fR/Ki6Pf1vL80A97ApDBnmb9H/PC+vj8/OtFj1O6+vyYOTMJWbe6bBzv676fJVDtd96mB6/eHddPuftbUZmxz98AI/8x3cnKs62aevpj5MW+11POZyjw6n57q9LiIiIcffSjrrXldsD3S895XFy4DMGJ2qvelv62fE7bvmHvtyl8PDz/W+3F4eCzr5WDDrmux0Me3P9DH5Pot/Uz79/7+f2jb+MKXvyDrq0zP37f3du26vvHLX5d1N4c8Ne84dvb8c9t7774r63duftku82P8jycAAAAAAAB0ghdPAAAAAAAA6AQvngAAAAAAANAJXjwBAAAAAACgE7x4AgAAAAAAQCd48QQAAAAAAIBOmLDFv6pwUdomIjciIncxy5lp1sVCVz4yse/iUwc6wjIr/S5nJhFzbva97Pd1PRFnPJ/q2MKlicM8PdURz8ulj9CuTJR0r9Tb5aI4IyImE729+zf1wSpDb1fPxMZGRISJKHVxuk1iXUfHOl47L3Qbg76Orc0KHwW6v6HP+1W3NP2i7Pn3z9VKn8/lXMcQz8911PD1a5u2jXJbt79tjnO/n+hLmf5ttdLbNZ/psWU10hGmERGFaX480tv7a7/+q7JeV/4armt9TbpIcjd2RUSsTBTszFz3pRkjU1HKQ9P+YPg0rxXdiNuuXs/3k0MTH3uVZYU+L02d6ke6vxSmE7eufyXiou267H3QjzfT6cTUT2TdneOzqY6kjog4PNZR0lvjsaw3G7o+Gvr45WFh9t3ch1LR8S723J2RwsyJclOPiKhNH8rceJoYu7yn9++c86Wfd15p9jJKxNSbn0y3sH+faMH2v8SQv7Y1NzcZUd/Ldb/cGOv7jevH85nvx49P9T3Cza9PTER8RMQXXt2X9cMzfQ++c31L1j+6r8fHJNt//PHNzEJ2GdNR3HqeVf/3v/iOrN+7d88u8/DRI1l/8MHbsv7yy6/K+tb1F2wbbav75GxyLOvf+9537bpOHj6U9Z3967I+HOhnpdG5f4Y62N2V9XJbz3HeP9LbdPe9920bG309h9/Z1tdi1fi+un9wQ9YPru/J+s1b+lxdP7hp2zg+0+PNfbPvU/PsEhFx/7Huc7NzPS96cFf//c6uf277s794Q9b/+je+bJf5Mf7HEwAAAAAAADrBiycAAAAAAAB0ghdPAAAAAAAA6AQvngAAAAAAANAJXjwBAAAAAACgExdOtVutdIpVIl8qcvOR+Dp0wlRu3oM1yQQVnbLQK/S6ssy/a+uZ1KDSREa5NaXSn6pKH8fVRB+Tw8eHsn50rNPuIiJmC91GaUIGytInT7k0sMqkHxU9nRK3SrzjXM11ssfcJKo1ue+247Fuf7nUiSO1OR+JoLcYhF7mqpue62Owm0gu2NrUx3owMNdKX5/L/R2fANU3KWpladKZEhFu7vp244Ht36YeEVGbdMii1P312nV9fF2SVESE2dwoTEpMVftj4oJoViYZajbT/WSx9P3+5s1dWXcpfK4eEVG49DazjEtP64/0WBARsX+gU4OuslQqmePuRalEo3XW86OVuYVkebHwaSxTk/r68ksvyfqDRzqhbuf6LdvG9pY+90cTfa9tzLjZT8xLhht6vGvcvMQPN2vLTD9JncNe78JTwYjwKUqpdlLX/L861rvuIlLJYC7t0MWYrd20XcTN7SMSw4FdwoxRiQ12bWyb+d/pTF9gbWJe2pjtctfX47Nzu65eoVOxerm+p17f00maw6G/TueLNQeR5Jhuyi697hJ961n0rT/+vq5/61t2mXv37st6PjuW9V/+mk4e62/r9URETM50mvdbb/6prJ8d63tdRMSNkZ6vjnr6AfJwqts+nut6REQ81M+vJx/rZZYLfW0dP9b3/4iIwe07sv7Fn/+SrO9d84lzt196UdY3d/Rc4nSi5zjv//Ad24a7GmeNHm/axHzwkUm1m8/1XKaa6XFoe0uPQxERbaOf9S6C//EEAAAAAACATvDiCQAAAAAAAJ3gxRMAAAAAAAA6wYsnAAAAAAAAdIIXTwAAAAAAAOjEhaNMKpdykEg3cb/1cp2FlxWmnvh6e+aS8Mxm5amAPPNZ+Z5pv1np9IGVSe2LiJhX+mv3PZMWsZzpNh488qkENu3E7Edv6L9cn/f0b+eV3seVSb4amaSqiIjC7Lvrc0uTRBfhU1iKnk7ucwlpjdm/iIjZuukhV4QJCYxq6fdnuKnPf2Gu4alJR4jw40S/1OvqmfS4VIJKa649l+KVm3ieVOJctdLbm5sBpF7qa75JpPYUhUnOM9fKdOYTJtxvs7nex7Nz/fdN44/JQb1eel0qVW3dxLXC3DdS/6zywvP7a7VxFbi+epl/P0r173W5s+XOYypdbXt7W9ZfvH1b1p97QafNrMJEuEbEwwc6Hej6vk7zWT0+lvX98a5tYzjW+5F9AsFutbl3VYnryiUm+nHz6SUs9vv63rxc+jFt3THiynApk4nEP3e1JDLJnhp/qaZaX/PcuFU1fj21OV6bI33dz5ZmvBv4ROd1I/2OTZJVRMTRqZn3m1vXhtmu/W2f1PruXZ0U1ndJmsl5lEvyXj+B0PokOvBT9i+//W1ZPzv0z2N3bumE1cN7eq783gcfyPps+b5t497HD2U97+mDfP36gV1X33Tj81Pdv44yfW3NE3P+00d3ZX2r1P3oy6++KuvXvvqLto1XPvdzsu7mDOfzxHNlfyDrS5Ow3pjno2vXdm0b1Vwn9/VXLiU2MT6a5/DMPjvrc7ub6RS8iIjN8OPdT8L/eAIAAAAAAEAnePEEAAAAAACATvDiCQAAAAAAAJ3gxRMAAAAAAAA6wYsnAAAAAAAAdOLiqXaNSzNIvbsyqTbmY+wuMaFJxh+Y30zqSduaGImIyGq9rtJ80b42bdS1T2NxKU+VqTcmfcjVIyI2TLLH7q5O7emNduy6Vj29zPHcJKGt9L63RSJRx6WBmY6ySOz7qtK/uUAol2rnkhcjIkqTwnPV9UxSWpVI8GvcdW9OZ7XS6zKhZxHhU+1y02faRJpD0ZoxJNPjlDkk0VR+g11yY+aSXcw2LRY+MaLs62u4MB35fOrX5c7v0ZlOzDyb6mt4OPBJYSsTmejS0+pEh8hz/Vtp+klR6O1KJe2MRj4d6Opy90G/n+5+Y1tIJM6tu0xrrrlUItrGxoasD8z1sLe3J+sPj6e2jclU/9Y7PZL1G6ORrB/NJraNDZPimpmx4FKpUGtKndt1U+KeZqpc6v7zs8acfluPiHCzHRty+Qn4JFIFU2nWSzPPzELfm0uT7BaZn+flblwzaV1LM/eMiDg802PF8wd6fn0+04lRt/f1WBQR8eYHx7Le75l9T51CN1Y8q2mST0lpDtrelj6PERG1SSurTH95932dajfo+/Tx0VD3i3Kkn1UWiSRrF+52fHws67O+7iu9oZ9jvfbSS7L+b/ziF2X9869+VtZPz32y2nBbP9eOzP08M8nnERF5qd8BzE3y6upYzyUev/ND20ZR6305NmmC/Z6fj7vnoOljnb7YLHUb5Y6ej0VE1Av/nuMn4X88AQAAAAAAoBO8eAIAAAAAAEAnePEEAAAAAACATvDiCQAAAAAAAJ3gxRMAAAAAAAA6wYsnAAAAAAAAdEJn/gozE784LP0qChMpvDJx6E1l6i7zPCJ6JnI1N1HO0fr41MpEx5dDEyloIhZPTh7aNtqVzqpsTQz99FxHcS5NjGNExLhvIrQzHb+4feNVu655pvd9Nddt7I91VGXPRJ5HRLQuct0cq1RCeJ6bGGvThRoTDzud++PbzH1s7lV2bU+fy8Yc/4hEPzPHczzUx9/FoT9Z15q50JmP9M1NxnRhxpC61vVq5TvZcjnXP2zq+NjSjJFFz4+dLvp8brJuE0nOcTLV53BuFqrN4R2b/YuIKHt6XG3t8TWZvRGRmfOb57qeuc6Y8gymQrsI8yYxILrfXP9y9VSMtl+X/vu88PfgnrkmZmY8nplI39zFp0fEcqlji+9//LGsTzb1uHmcyLO/NdJzg8Z0vCydbZ74TXmandtEyl8qVl0vU9eu/17iur7i7K0rcQ90R8edgqd61MxcPbW9Jsnb7nt7if46c/No8/ejvh5zlnMfK98z97SVmRvkiSP/6FiPOXeu78n64dlU1m/s+3jzojD3B9NR8sQ5tOORXcSd3ERvfAbvwV/72tdk/eFD/8z327/927I+n89kfTjU946ofF/tmznmdKb70fns1K5rkfVlvcl0vx+Y5+Odfd23IyJeuHNN1odb27L+7t37sl4U5lhFxOlCH69lo+cGvb5+do2IGGZmLDg5kvW21vOS8+MT20asdH9YmXM1GI3tqrY2N2W90ac2luY5fzjctW1kvcSD+E/A/3gCAAAAAABAJ3jxBAAAAAAAgE7w4gkAAAAAAACd4MUTAAAAAAAAOsGLJwAAAAAAAHTiwql204VJU0rEKdV98wl1m7Kg6/2ejz/o93RaVtnT79SKRAKQS6XomTbGOwey/sGH79o2ikp/7T4zyWLzuU7Qal3aSEQsTSxVNtIpA3vPf9auq850akBtkoGKTd2l8lSEhUkH6pc6SaAw5zbCJ3K55ByX+BEmkTEiYrV8NlPtdrb09VhX/pqYzfR1b0IeYmOs+0vZS6Xg6HPg0m5s8lZE5C7lMjdJNGZddSLpbz7Xfb8/0Md3NDKpdonkLRf54tL2Hh/5tIzjUzN2mzGkZ7arXvljMjnXbYzHJq1z5tflkth2d3RSx8ZI/30qeatKnN+ryu3P5RLG1pOZ6+pHW6CXMds1SKTH9Myc4WSi74PLVm/XKnwqaduYe61puzJjxKufed220e+ZZCDT7xIBeXac8HOvp9kfPonoKZOc9wm0/IkzO5VKRHO/uIRE3/b6yZRrJ85GRLRuPqH7sd2sRNMu4Kta6rY3TardZOkTNscjfQ0fLszcN/frenysE6sWZu41r/S6bpq5RETE/obe3lOTwuzSYyPCptHZ7mD/3rfxLF7fb7zxhqwfHh7aZY6OdPJZOdBz5bmZZzULnVAXEVGWuk/WrV5XYRIbIyJm5vrtD/RzcGae06YzncgeEfHGW2/J+vsf/FDWi9B9+/mbz9s2XGr0svqBrG/t7tt13bqj2/ngI70fi8lE1q/v6NS+iIjKJIhfv/GirOcDn2p3aJ5RNl+4LutbI31u9675ZMJru/63n4T/8QQAAAAAAIBO8OIJAAAAAAAAneDFEwAAAAAAADrBiycAAAAAAAB0ghdPAAAAAAAA6MSFU+1c+kKWiJ5oTRJe33xR3yZMmfVERCxNAsCg1F/BH5p0i4hUmpPOXxhv6q/gb+5cs20cfaS/2l+aWJvV0ux7IvFjc/+mrL/6xa/J+mBb/31ERG6SOvqF/mp+bhKDIpWg4RL6TLpVlsjDyM1PLvnJJbq1JgUvIp2qdpX1TMqDS5OM8MfHnbK8MOkmkTieLgXnEsfZnRvXjyPTSRK9RArfcDiU9dam+eiDdZlUu8Ic315mEkQjYmdLt+P6g0uTXK1MlFBEfHxfp+o9PNJJLGPTRkTE3u6GrG9t6OO7clGWCdUllrmqUql2/npwCVPrJ0m6NCe3RGkS3yIiFiaNZWbqbhxKHROXmliblLjeQO/JbjLVxY2DWlH468EzqZTmunb7/ZN+w1NkriN/71h7VTYm7mnOW1zibIR/JvDpfFoq6TFr9I/Tub6fX9vW9+z+zDcyHppUuzXnPhERczOPP5mahDxzDQ8S980713Tq65+8fyzrWSIdet274zM6JV7b7/3e78n6auWfUetaz5uyWvevgxv6+fHtt//CtpEX+oxtbOm51Hi0Zde1dM8+5uEqN/vnEvUiIsq+eR7LddJf3tMJbg+OTm0bmWk/L/VYMNr2qXZLM9FYFjoNrhrq7V0N/XFvSn2uFpsHsv7hg4d2XbMzPe/e3dLHZLLUKXy9jz+ybRyY+c8v/a1/zy7zY/yPJwAAAAAAAHSCF08AAAAAAADoBC+eAAAAAAAA0AlePAEAAAAAAKATvHgCAAAAAABAJ3jxBAAAAAAAgE7ozE5hujBxgiZuPcLHcg9zHUFYmPzUtvIx3qWJgq9qHataVT73s1+6uHkTPR16P26+8FnbxtnRkaxPTx7J+mShYzpHezpyMyLiC7/4N2T9uRd/XtbzxPvH/ZE+h6OeiZQ3x73OfFdrTVSljXRtE9mtJkq4NXHRlelbde2jQFPNX2VF4c5z4hoe6D6+WOjj1phz6WLPU8sULoA5kbNsLlUbv2y3KRFvvTSx64uV7vujkY7NHQ58rHzRMxH1Pb0fq0R/3drQ7Vw70NGuGxs60nY6ndk2yge6/vBoLuvn5hhGRLz44nVZd+d2PteR1G346OmyfPb+zaW9REx6nq+3n+7vi8IfSz9Q6+1aLPV1EhGxWOl+sVrp8cY17Y5VhB/zXQTx5qa+TsabOv44wt9vnOT9xuyLOyc9E8W+WOjrJMKfd9d26vja/ujWZdf0s8ddqW3iGnbHJzO/ZLYVz/VW37Zn99H+vfklMdEqTH89Pdd93D2LZKHn1xERg4G+D67bvyP8vh+e6PvjrRs7sj6d+3HiM3f0Mj/48ETW0/3EXff6r233fVYny8Z0qu8RqfHQXRFLcx88OzuT9dT4XZS6/VGjn9MGw5Fdl5to9XN9DY0Hel11lbjPV+ey3mt123lh3hkkDvt8ots42NqT9c0dff1ERGyO9RzghRu3Zf3o8bGsjwbbtg3n0Yl+ZzCr9NgREXH9hRuyPujp4xgzPWeoE/366Fgf34t49mbfAAAAAAAAeCbw4gkAAAAAAACd4MUTAAAAAAAAOsGLJwAAAAAAAHSCF08AAAAAAADoxIVT7c6m+ov6eSKNo1fqBIZiqr92n5mEur5N44rY6Otd2BqZRAofChHLSidcrBtiUfb9l+tffP0rsv5n3/22rB88/7Ksv/6lr9o27rz2ZVlvc51wkDf+oIx7+rehCTmamZTDNk+kDJn2W5uI4ftcY05KZVKDWpNelkxtSRyvq8ylx7jUxif0vroUptok1PXNdRrhU+1c1k7PpGtE+KQWP0zpH6pEWme10ts7m+nxY9eEZRS570c9lyJm0vlGI5NWEREDk+gzNml7A5NkOBz6FL5rB3rMOzzSKTAnpz4RYzTU/bE24/NyaRJXVz4FZjz2+3JVpZNzns4yLt0slZzXmAS3oUnO6ScSdRYnOtHHxUK57XLbFOFT9UozFtzYP9B/3/d9qKnNWGv2o7lEtps7t6uVvk5SfcEl4bkEwFRaojsnrv3StL00CYfPMp/U65fxiWGXWJldwtw3zd+nEtHWDTIz036fdhcRPfNMcGbuwbmZSwzKxMaaJK2+u1YSY457Tjqe6GSqV17QY87MpFxHRLx4XSdvbY709k4XqeRNc1zcs5BNWEy18Owl3rnxMLUn7l40W+iU4OPDx7LujnFERN7qvrqc6e09O/OJaLu7OjG9P9iU9d5Qp7sW5tkhIiJq3X65qecGW3v7epsSCdfl5FTWp+a+kgiMjMcnE1lfNSYV3dwfa5NWHRFRlia5z8x73Tw5ImJVm+cal55b6HcDWZ0Y01JJxz8B/+MJAAAAAAAAneDFEwAAAAAAADrBiycAAAAAAAB0ghdPAAAAAAAA6AQvngAAAAAAANCJC6faDUwcSyLsJopWf/G9MO+7XJJTZhIpIiLmJuWhyPWuFUOf/lTaL86blBaTbrY0iTYREb3Rrqy/YtLuXv3cL8j6/nO3bRtnc328zmc6SaA/8F+nb3O9rpU5tzaAxX1NPyJakwxgAueSqSkuVa0xX+d3qXZhk9YiGpMsdtU15sC1yffPepnZQp+zlUmDSyWiue3K3PYmOkBmE/r0dpUm8W1jQ6c8RESUZlfc+FFVJlExEted2cVhX49fL9zSKTgREUWhVzY0qXa9Uo+dvUQih7tYD/b0n+eJhJazY514N5vrsb4xx3Ey0UkkERHlQO/7q3aJT9+6aWGpZRyXwJNMMTO/udQ3dz1ERJyf66Qfl7rltInx26W49kwbBybVzo81PqE3dxFeiXPofnLJok7qHLo+5OqpfXfb6/piblNKf/ZS7ezBSaZPrtn3L5Fqt35+cHID1lrXZcL5zC0tZiaaqjb3p41+Iq2zMvdNM66dzfTYFeH7/pkZ79y1vUzM1bZNsu31nbGsn9zVqV8RET03Vrhxwp7cVFyj/+mqKhJjqOPO/cDMs1xQW2q8z02/WJzrZN/V6oFdVyz1tbIc6+fH+UAnF5dj/6w9HOs+WZa6npnUtVRa+mhHJ+ENzGFsTdsREY9NCuDm5kDWs9IkX5tjGxExX+m03ZUZh5rWz8fnJum5MXOf2l3XiT7XrPQz4EXwP54AAAAAAADQCV48AQAAAAAAoBO8eAIAAAAAAEAnePEEAAAAAACATvDiCQAAAAAAAJ24cKrdNZOMkErUyc3n+cuebnZkkobqRIrVZKpTIWYmYaJd+uQJ137f1HOT7JJKElqaL9SPd2/Ies8cq2Xt3xnWJpmoWuqEg3ygv8wfEVHVJknKfB2/NelxvcJ3tczEl7jgnFQ6T7R6u1aN3o+6MulsiUCd2TOaaleZxLkUd3VX5hgsTGpDKpXKBVC5wAqXvBUR4UIYatMvbeLIwPdXl2o3KHW/PDnVqR9Z5jvZ5uZI1nf3tmW9yRLHxPTx3EQDufS6IpFqVzd63/NC76O7B0RE/PDeY1k/nOhkETcepP5VZV75+8BV5fp96h7sfnLHzP19k0qJM+s6m57J+jIxDi1dUqxLuDRzjF7q5J/ptMOtjQ1Z37/xnKxnVSKxySS1jc24Mkhsb2VScqdLfU+rzLFqEv2ksedEb5hLj72MutFpPql+/axyCZBt4p7m4r/WTaxMpd2tm2p3qVNjVpatn3dn12Xv/6Yf72/7ue/yTJ+TTZN4ezbT8+sI/yy0XOk2js70una2fdruzIRM3b6xJetvfHhi19Xv6e010yh7DtMhcM/e9e3udetei6l1FWZuVJl5XERqTmyOceI5+Ojeh7J+1lvv+Xi851PiRps7sl6ZZLcy1/2+LlPPFXowGJu2V61P4ZuY9wm5mcNXZm5QjH26d2bGCBf6Ohhe+PXN/2e10nOGzMy7Um+I5pVOn74I/scTAAAAAAAAOsGLJwAAAAAAAHSCF08AAAAAAADoBC+eAAAAAAAA0AlePAEAAAAAAKATvHgCAAAAAABAJy6cxzcs1o9idxGiPbOuwsTq9nK/mcNNE7No4iVrEycYEdE2Oq6yXuiowcZEaKZCQpcm79Udq5WJOaxrH4fZtvp94t6Wjrfc7Pv3j62JhaxNZHNu6qm00dLFtJtlXNx7RERhYmBzU+9Vet8XKx9131TrR6deBUuzT42L0oyIxUJfL5Nzfa1Wpn+vEhHqw8ZE95rM5lQsdFWZOPalvrYL05Vc1G1ERFnq2NW20NuVZbp+curjSPf3dQRyWeoNdlGsP9oAWXaLuGs11esLd7j6euwemXE7ImIw0stMHuk+VxT671vTryIiliai/iq7XLy8XqZpXN1dp37MzXO9Lhf/vDAR4hERlWvf3NPMpZXokBEx1JHGL77yoqwPRrqv2m2NiLKn23fDSmkitCMieoXuxzOXbW7G2tbcmyPS9+euXa5fP5vaVl8TqWPgouqf5mFrzDiR6DF+ZWbDMtP53f3cbVNEhBly7Ph1dDqV9c/e0tHqEREPJ3pdm2M9Frpz++Q3M8cx1/CDoxNZ397wke/v3Z3I+vUtvUyW+fGrNnNCd9/ITX9IPTUmhqMrq5cYp53MPSea6yQ3k1K3ngjf7915yRODhzv3baOfBZazhawvqlPbxtHRoaw/evBY1k+Pz2R9e3vTtjEcmzlm6+YyI7uuI3M9LqZ6XZV5zzAa+ef2jU39fJ6Z54qledZJsfcZ20f9FbwyY8FF8D+eAAAAAAAA0AlePAEAAAAAAKATvHgCAAAAAABAJ3jxBAAAAAAAgE7w4gkAAAAAAACdyNp/lSJFAAAAAAAA8InhfzwBAAAAAACgE7x4AgAAAAAAQCd48QQAAAAAAIBO8OIJAAAAAAAAneDFEwAAAAAAADrBiycAAAAAAAB0ghdPAAAAAAAA6AQvngAAAAAAANAJXjwBAAAAAACgE/8vqJEIUoyBWQgAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -707,13 +679,29 @@ } ], "source": [ - "i = 10\n", - "plt.imshow(ds_val[i][0]); plt.axis('off'); plt.show()\n", - "top_trak_scorers = scores[:, i].argsort()[-5:].cpu().numpy()[::-1]\n", + "for i in [7, 21, 22]:\n", + "\n", + " fig, axs = plt.subplots(ncols=7, figsize=(15, 3))\n", + " fig.suptitle('Top scoring TRAK images from the train set')\n", + " \n", + " axs[0].imshow(ds_val[i][0])\n", + " \n", + " axs[0].axis('off'); axs[0].set_title('Target image')\n", + " axs[1].axis('off')\n", + " \n", + " top_trak_scorers = scores[:, i].argsort()[-5:][::-1]\n", + " for ii, train_im_ind in enumerate(top_trak_scorers):\n", + " axs[ii + 2].imshow(ds_train[train_im_ind][0]); axs[ii + 2].axis('off')\n", "\n", - "fig, axs = plt.subplots(ncols=5, figsize=(15, 3))\n", - "for ii, train_im_ind in enumerate(top_trak_scorers):\n", - " axs[ii].imshow(ds_train[train_im_ind][0]); axs[ii].axis('off')" + " fig.show()" + ] + }, + { + "cell_type": "markdown", + "id": "be58b75c-4cc2-414f-a11d-95c151119201", + "metadata": {}, + "source": [ + "You can also explore TRAK scores computed for CIFAR-10 from multiple independently-trained models (10, 100, 1000 models) in this [colab notebook](https://colab.research.google.com/drive/1Mlpzno97qpI3UC1jpOATXEHPD-lzn9Wg?usp=sharing)." ] }, { @@ -738,7 +726,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 11, "id": "39ee710b-30e9-4bb1-9f4d-eb145b10b7d4", "metadata": { "tags": [] @@ -750,7 +738,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 12, "id": "5ba25042-2b4d-4501-b611-4ac7eb716727", "metadata": { "tags": [] @@ -758,8 +746,8 @@ "outputs": [], "source": [ "def eval_correlations(scores, tmp_path): \n", - " masks_url = '/url/to/masks' # dropbox link coming soon\n", - " margins_url = '/url/to/margins'\n", + " masks_url = 'https://www.dropbox.com/s/x76uyen8ffkjfke/mask.npy?dl=1'\n", + " margins_url = 'https://www.dropbox.com/s/q1dxoxw78ct7c27/val_margins.npy?dl=1'\n", "\n", " masks_path = Path(tmp_path).joinpath('mask.npy')\n", " wget.download(masks_url, out=str(masks_path), bar=None)\n", @@ -780,13 +768,13 @@ " rs.append(r)\n", " ps.append(p)\n", " rs, ps = np.array(rs), np.array(ps)\n", - " print(f'Correlation: {rs.mean():.3f} (avg p value {ps.mean()})')\n", + " print(f'Correlation: {rs.mean():.3f} (avg p value {ps.mean():.6f})')\n", " return rs.mean()" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 14, "id": "64b9e974-c668-4b91-a4e0-d362652af13c", "metadata": { "tags": [] @@ -795,7 +783,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5753c30fed6c4bc9bc6128ae3dce490a", + "model_id": "97e04a0a8ff9441c9e49057ac53181ce", "version_major": 2, "version_minor": 0 }, @@ -810,12 +798,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Correlation: 0.127 (avg p value 0.00012112002481238829)\n" + "Correlation: 0.106 (avg p value 0.000172)\n" ] } ], "source": [ - "corr = eval_correlations(scores.cpu(), '.')" + "corr = eval_correlations(scores, '.')" ] } ], diff --git a/setup.py b/setup.py index d43af57..2718c39 100644 --- a/setup.py +++ b/setup.py @@ -2,7 +2,7 @@ from setuptools import setup setup(name="traker", - version="0.1.2", + version="0.1.3", description="TRAK: Attributing Model Behavior at Scale", long_description="Check https://trak.csail.mit.edu/ to learn more about TRAK", author="MadryLab", diff --git a/trak/__init__.py b/trak/__init__.py index 577a09b..4d8179b 100644 --- a/trak/__init__.py +++ b/trak/__init__.py @@ -1,4 +1,4 @@ from .traker import TRAKer -__version__ = '0.1.2' +__version__ = '0.1.3' VERSION = __version__ diff --git a/trak/traker.py b/trak/traker.py index 58519bd..28b3174 100644 --- a/trak/traker.py +++ b/trak/traker.py @@ -1,9 +1,9 @@ from .modelout_functions import AbstractModelOutput, TASK_TO_MODELOUT -from .projectors import ProjectionType, AbstractProjector, CudaProjector +from .projectors import ProjectionType, AbstractProjector, CudaProjector, BasicProjector from .gradient_computers import FunctionalGradientComputer,\ AbstractGradientComputer -from .score_computers import BasicScoreComputer -from .savers import MmapSaver, ModelIDException +from .score_computers import AbstractScoreComputer, BasicScoreComputer +from .savers import AbstractSaver, MmapSaver, ModelIDException from .utils import get_num_params from typing import Iterable, Optional, Union @@ -31,6 +31,8 @@ def __init__(self, device: Union[str, torch.device] = 'cuda', gradient_computer: AbstractGradientComputer = FunctionalGradientComputer, projector: Optional[AbstractProjector] = None, + saver: Optional[AbstractSaver] = None, + score_computer: Optional[AbstractScoreComputer] = None, proj_dim: int = 2048, ) -> None: """ @@ -66,6 +68,13 @@ def __init__(self, Rademacher projector will be used or give a custom subclass of :class:`.AbstractProjector` class and leave :code:`proj_dim` as None. Defaults to None. + saver (Optional[AbstractSaver], optional): + Class to use for saving intermediate results and final TRAK + scores to RAM/disk. If None, the :class:`.MmapSaver` will + be used. Defaults to None. + score_computer (Optional[AbstractScoreComputer], optional): + Class to use for computing the final TRAK scores. If None, the + :class:`.BasicScoreComputer` will be used. Defaults to None. proj_dim (int, optional): Dimension of the projected TRAK features. See Section 4.3 of `our paper `_ for more @@ -91,17 +100,22 @@ def __init__(self, modelout_fn=self.task, grad_dim=self.num_params) - self.score_computer = BasicScoreComputer(device=self.device) + if score_computer is None: + score_computer = BasicScoreComputer + self.score_computer = score_computer(device=self.device) metadata = { 'JL dimension': self.projector.proj_dim, 'JL matrix type': self.projector.proj_type, } - self.saver = MmapSaver(save_dir=self.save_dir, - metadata=metadata, - train_set_size=self.train_set_size, - proj_dim=self.proj_dim, - load_from_save_dir=self.load_from_save_dir) + + if saver is None: + saver = MmapSaver + self.saver = saver(save_dir=self.save_dir, + metadata=metadata, + train_set_size=self.train_set_size, + proj_dim=self.proj_dim, + load_from_save_dir=self.load_from_save_dir) def init_projector(self, projector, proj_dim) -> None: """ Initialize the projector for a traker class @@ -117,11 +131,23 @@ def init_projector(self, projector, proj_dim) -> None: self.proj_dim = self.projector.proj_dim else: self.proj_dim = proj_dim - self.projector = CudaProjector(grad_dim=self.num_params, - proj_dim=self.proj_dim, - seed=0, - proj_type=ProjectionType.rademacher, - device=self.device) + try: + import fast_jl + test_gradient = ch.ones(1, self.num_params).cuda() + num_sms = ch.cuda.get_device_properties('cuda').multi_processor_count + fast_jl.project_rademacher_8(test_gradient, self.proj_dim, 0, num_sms) + projector = CudaProjector + + except (ImportError, RuntimeError, AttributeError) as e: + print(f'Could not use CudaProjector.\nReason: {str(e)}') + print('Defaulting to BasicProjector.') + projector = BasicProjector + + self.projector = projector(grad_dim=self.num_params, + proj_dim=self.proj_dim, + seed=0, + proj_type=ProjectionType.rademacher, + device=self.device) def load_checkpoint(self, checkpoint: Iterable[Tensor], @@ -322,6 +348,7 @@ def score(self, def finalize_scores(self, model_ids: Iterable[int] = None, del_grads: bool = False, + allow_skip: bool = False, exp_name: str = None) -> Tensor: """ This method computes the final TRAK scores for the given targets, train samples, and model checkpoints (specified by model IDs). @@ -335,7 +362,11 @@ def finalize_scores(self, del_grads (bool, optional): If True, the target gradients (intermediate results) are deleted from the internal store of the :class:`.TRAKer` class. Defaults - to True. + to False. + allow_skip (bool, optional): + If True, raises only a warning, instead of an error, when target + gradients are not computed for a given model ID. Defaults to + False. exp_name (str, optional): Used to name the scores :code:`.npy` array produced by this method in the :code:`save_dir` of the :class:`.TRAKer` class. If @@ -359,7 +390,14 @@ def finalize_scores(self, for j, model_id in enumerate(tqdm(model_ids, desc='Finalizing scores for all model IDs..')): self.saver.load_store(model_id) - self.saver.load_target_store(model_id, self.saver.num_targets) + try: + self.saver.load_target_store(model_id, self.saver.num_targets) + except OSError as e: + if allow_skip: + print(f'Could not read target gradients for model ID {model_id}. Skipping.') + continue + else: + raise e # TODO: currently this is breaking abstraction -- either define dict # items in abstract __init__, or don't access them here