├── .gitignore
├── CIFAR-10
    ├── Data
    │   └── Masks
    │   │   ├── mask00.bmp
    │   │   ├── mask01.bmp
    │   │   ├── mask02.bmp
    │   │   ├── mask03.bmp
    │   │   ├── mask04.bmp
    │   │   ├── mask05.bmp
    │   │   ├── mask06.bmp
    │   │   ├── mask07.bmp
    │   │   ├── mask08.bmp
    │   │   ├── mask09.bmp
    │   │   ├── mask1.bmp
    │   │   ├── mask10.bmp
    │   │   ├── mask2.bmp
    │   │   ├── mask3.bmp
    │   │   ├── mask4.bmp
    │   │   ├── mask5.bmp
    │   │   ├── mask6.bmp
    │   │   ├── mask7.bmp
    │   │   ├── mask8.bmp
    │   │   └── mask9.bmp
    ├── evaluate_ULP.py
    ├── evaluate_noise.py
    ├── generate_poison.py
    ├── plot_ROC_curves.py
    ├── train_ULP.py
    ├── train_clean_model.py
    ├── train_poisoned_model.py
    └── utils
    │   ├── __init__.py
    │   ├── augmentation.py
    │   ├── backdoor_attack.py
    │   ├── cache.py
    │   ├── data_loader_CIFAR10.py
    │   ├── dataset.py
    │   ├── download_CIFAR10.py
    │   ├── model.py
    │   └── stn.py
├── LICENSE
├── README.md
├── docs
    ├── .gitignore
    ├── README.md
    ├── __deploy.sh
    ├── _config.yml
    ├── _data
    │   ├── experience.yaml
    │   ├── main_info.yaml
    │   └── publications.yaml
    ├── _includes
    │   ├── google_analytics.html
    │   └── image_with_caption.html
    ├── _layouts
    │   ├── default.html
    │   ├── post.html
    │   └── project.html
    ├── _posts
    │   └── 2019-08-04-first-post.md
    ├── assets
    │   ├── images
    │   │   ├── ULPs.png
    │   │   ├── ULPs_TinyImageNet.png
    │   │   ├── results_GTSRB.png
    │   │   ├── results_generalizability.png
    │   │   ├── results_table.png
    │   │   ├── teaser.png
    │   │   └── threat_model.png
    │   └── publications
    │   │   ├── Oral_AAAI2020.pdf
    │   │   ├── Poster_AAAI2020.pdf
    │   │   └── SoCPaR_2016_paper_100.pdf
    ├── index.html
    └── libs
    │   ├── custom
    │       ├── my_css.css
    │       └── my_js.js
    │   ├── external
    │       ├── font-awesome-4.7.0
    │       │   ├── css
    │       │   │   ├── font-awesome.css
    │       │   │   └── font-awesome.min.css
    │       │   ├── fonts
    │       │   │   ├── FontAwesome.otf
    │       │   │   ├── fontawesome-webfont.eot
    │       │   │   ├── fontawesome-webfont.svg
    │       │   │   ├── fontawesome-webfont.ttf
    │       │   │   ├── fontawesome-webfont.woff
    │       │   │   └── fontawesome-webfont.woff2
    │       │   ├── less
    │       │   │   ├── animated.less
    │       │   │   ├── bordered-pulled.less
    │       │   │   ├── core.less
    │       │   │   ├── fixed-width.less
    │       │   │   ├── font-awesome.less
    │       │   │   ├── icons.less
    │       │   │   ├── larger.less
    │       │   │   ├── list.less
    │       │   │   ├── mixins.less
    │       │   │   ├── path.less
    │       │   │   ├── rotated-flipped.less
    │       │   │   ├── screen-reader.less
    │       │   │   ├── stacked.less
    │       │   │   └── variables.less
    │       │   └── scss
    │       │   │   ├── _animated.scss
    │       │   │   ├── _bordered-pulled.scss
    │       │   │   ├── _core.scss
    │       │   │   ├── _fixed-width.scss
    │       │   │   ├── _icons.scss
    │       │   │   ├── _larger.scss
    │       │   │   ├── _list.scss
    │       │   │   ├── _mixins.scss
    │       │   │   ├── _path.scss
    │       │   │   ├── _rotated-flipped.scss
    │       │   │   ├── _screen-reader.scss
    │       │   │   ├── _stacked.scss
    │       │   │   ├── _variables.scss
    │       │   │   └── font-awesome.scss
    │       ├── jquery-3.1.1.min.js
    │       ├── skeleton
    │       │   ├── normalize.css
    │       │   └── skeleton.css
    │       ├── skeleton_tabs
    │       │   ├── skeleton-tabs.css
    │       │   └── skeleton-tabs.js
    │       └── timeline.css
    │   └── icon.png
└── tiny-imagenet
    ├── convert_data.py
    ├── data_cleaning.py
    ├── evaluate_ULP.py
    ├── evaluate_noise.py
    ├── generate_poison.py
    ├── plot_ROC_curves.py
    ├── resnet.py
    ├── train_ULP.py
    ├── train_clean_model.py
    ├── train_poisoned_model.py
    └── triggers
        ├── trigger_01.png
        ├── trigger_02.png
        ├── trigger_03.png
        ├── trigger_04.png
        ├── trigger_05.png
        ├── trigger_06.png
        ├── trigger_07.png
        ├── trigger_08.png
        ├── trigger_09.png
        ├── trigger_10.png
        ├── trigger_11.png
        ├── trigger_12.png
        ├── trigger_13.png
        ├── trigger_14.png
        ├── trigger_15.png
        ├── trigger_16.png
        ├── trigger_17.png
        ├── trigger_18.png
        ├── trigger_19.png
        └── trigger_20.png


/.gitignore:
--------------------------------------------------------------------------------
  1 | # Byte-compiled / optimized / DLL files
  2 | __pycache__/
  3 | *.py[cod]
  4 | *$py.class
  5 | 
  6 | # C extensions
  7 | *.so
  8 | 
  9 | # Distribution / packaging
 10 | .Python
 11 | build/
 12 | develop-eggs/
 13 | dist/
 14 | downloads/
 15 | eggs/
 16 | .eggs/
 17 | lib/
 18 | lib64/
 19 | parts/
 20 | sdist/
 21 | var/
 22 | wheels/
 23 | pip-wheel-metadata/
 24 | share/python-wheels/
 25 | *.egg-info/
 26 | .installed.cfg
 27 | *.egg
 28 | MANIFEST
 29 | 
 30 | # PyInstaller
 31 | #  Usually these files are written by a python script from a template
 32 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 33 | *.manifest
 34 | *.spec
 35 | 
 36 | # Installer logs
 37 | pip-log.txt
 38 | pip-delete-this-directory.txt
 39 | 
 40 | # Unit test / coverage reports
 41 | htmlcov/
 42 | .tox/
 43 | .nox/
 44 | .coverage
 45 | .coverage.*
 46 | .cache
 47 | nosetests.xml
 48 | coverage.xml
 49 | *.cover
 50 | *.py,cover
 51 | .hypothesis/
 52 | .pytest_cache/
 53 | 
 54 | # Translations
 55 | *.mo
 56 | *.pot
 57 | 
 58 | # Django stuff:
 59 | *.log
 60 | local_settings.py
 61 | db.sqlite3
 62 | db.sqlite3-journal
 63 | 
 64 | # Flask stuff:
 65 | instance/
 66 | .webassets-cache
 67 | 
 68 | # Scrapy stuff:
 69 | .scrapy
 70 | 
 71 | # Sphinx documentation
 72 | docs/_build/
 73 | 
 74 | # PyBuilder
 75 | target/
 76 | 
 77 | # Jupyter Notebook
 78 | .ipynb_checkpoints
 79 | 
 80 | # IPython
 81 | profile_default/
 82 | ipython_config.py
 83 | 
 84 | # pyenv
 85 | .python-version
 86 | 
 87 | # pipenv
 88 | #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
 89 | #   However, in case of collaboration, if having platform-specific dependencies or dependencies
 90 | #   having no cross-platform support, pipenv may install dependencies that don't work, or not
 91 | #   install all needed dependencies.
 92 | #Pipfile.lock
 93 | 
 94 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow
 95 | __pypackages__/
 96 | 
 97 | # Celery stuff
 98 | celerybeat-schedule
 99 | celerybeat.pid
100 | 
101 | # SageMath parsed files
102 | *.sage.py
103 | 
104 | # Environments
105 | .env
106 | .venv
107 | env/
108 | venv/
109 | ENV/
110 | env.bak/
111 | venv.bak/
112 | 
113 | # Spyder project settings
114 | .spyderproject
115 | .spyproject
116 | 
117 | # Rope project settings
118 | .ropeproject
119 | 
120 | # mkdocs documentation
121 | /site
122 | 
123 | # mypy
124 | .mypy_cache/
125 | .dmypy.json
126 | dmypy.json
127 | 
128 | # Pyre type checker
129 | .pyre/
130 | 
131 | .idea/
132 | tiny-imagenet/results/
133 | CIFAR-10/scripts/
134 | CIFAR-10/results/
135 | 
136 | 


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask00.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask00.bmp


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask01.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask01.bmp


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask02.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask02.bmp


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask03.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask03.bmp


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask04.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask04.bmp


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask05.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask05.bmp


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask06.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask06.bmp


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask07.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask07.bmp


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask08.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask08.bmp


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask09.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask09.bmp


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask1.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask1.bmp


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask10.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask10.bmp


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask2.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask2.bmp


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask3.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask3.bmp


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask4.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask4.bmp


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask5.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask5.bmp


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask6.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask6.bmp


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask7.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask7.bmp


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask8.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask8.bmp


--------------------------------------------------------------------------------
/CIFAR-10/Data/Masks/mask9.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/CIFAR-10/Data/Masks/mask9.bmp


--------------------------------------------------------------------------------
/CIFAR-10/evaluate_ULP.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import matplotlib.pyplot as plt
 3 | 
 4 | import utils.model as model
 5 | import pickle
 6 | 
 7 | import glob
 8 | import os
 9 | 
10 | import torch
11 | from sklearn.metrics import roc_curve
12 | from sklearn.metrics import roc_auc_score
13 | 
14 | os.makedirs("results", exist_ok=True)
15 | use_cuda=True
16 | init_num_filters=64
17 | inter_fc_dim=384
18 | nofclasses=10 #CIFAR10
19 | 
20 | 
21 | # poisoned
22 | poisoned_models_test = sorted(glob.glob('./poisoned_models/test/*.pt'))
23 | 
24 | # clean models
25 | clean_models=glob.glob('./clean_models/test/*.pt')
26 | 
27 | # val - 100 clean 100 poisoned
28 | models_test=clean_models + poisoned_models_test
29 | labels_test=np.concatenate([np.zeros((len(clean_models),)),np.ones((len(poisoned_models_test),))])
30 | 
31 | cnn=model.CNN_classifier(init_num_filters=init_num_filters,
32 |                          inter_fc_dim=inter_fc_dim,nofclasses=nofclasses,
33 |                          nofchannels=3,use_stn=False)
34 | if use_cuda:
35 |     device=torch.device('cuda')
36 |     cnn.cuda()
37 | else:
38 |     device=torch.device('cpu')
39 | 
40 | 
41 | def getLogit(cnn,ulps,W,b,device):
42 |     logit=torch.matmul(cnn(ulps.to(device)).view(1,-1),W)+b
43 |     return logit
44 | 
45 | # # load baseline mat data
46 | # file = "ROC_CIFAR.mat"
47 | # from scipy.io import loadmat
48 | # x = loadmat(file)
49 | #
50 | #
51 | # y_true = x['y'].squeeze()
52 | # y_score = x['s'].squeeze()
53 | #
54 | plt.figure(figsize=(14,10))
55 | plt.plot([0, 1], [0, 1], linestyle='--',linewidth=3)
56 | 
57 | auc = list()
58 | for N in [1, 5, 10]:
59 |     ulps,W,b=pickle.load(open('./results/ULP_vggmod_CIFAR-10_N{}.pkl'.format(N),'rb'))
60 |     features=list()
61 |     probabilities=list()
62 |     for i,model_ in enumerate(models_test):
63 |         cnn.load_state_dict(torch.load(model_))
64 |         cnn.eval()
65 |         label=np.array([labels_test[i]])
66 |         logit=getLogit(cnn,ulps,W,b,device)
67 |         probs=torch.nn.Softmax(dim=1)(logit)
68 |         features.append(logit.detach().cpu().numpy())
69 |         probabilities.append(probs.detach().cpu().numpy())
70 | 
71 | 
72 |     features_np=np.stack(features).squeeze()
73 |     probs_np=np.stack(probabilities).squeeze()
74 | 
75 | 
76 |     fpr, tpr, thresholds=roc_curve(labels_test,probs_np[:,1])
77 |     auc = roc_auc_score(labels_test,probs_np[:,1])
78 | 
79 |     pickle.dump([fpr, tpr, thresholds, auc], open("./results/ROC_ULP_N{}.pkl".format(N), "wb"))
80 | 
81 | 


--------------------------------------------------------------------------------
/CIFAR-10/evaluate_noise.py:
--------------------------------------------------------------------------------
 1 | import pickle
 2 | from tqdm import tqdm
 3 | import matplotlib.pyplot as plt
 4 | 
 5 | from sklearn.linear_model import LogisticRegression
 6 | from sklearn.model_selection import train_test_split
 7 | from sklearn.metrics import roc_curve
 8 | from sklearn.metrics import roc_auc_score
 9 | 
10 | import pickle
11 | # import utils
12 | import time
13 | import glob
14 | import numpy as np
15 | import utils.model as model
16 | 
17 | import torch
18 | 
19 | init_num_filters=64
20 | inter_fc_dim=384
21 | nofclasses=10 #CIFAR10
22 | use_cuda=True
23 | 
24 | # poisoned
25 | poisoned_models_train = sorted(glob.glob('./poisoned_models/trainval/*.pt'))[:400]
26 | 
27 | # clean models
28 | clean_models=glob.glob('./clean_models/trainval/*.pt')
29 | 
30 | # train - 400 clean 400 poisoned
31 | models_train=clean_models[:400] + poisoned_models_train
32 | labels_train=np.concatenate([np.zeros((len(clean_models[:400]),)),np.ones((len(poisoned_models_train),))])
33 | 
34 | # poisoned
35 | poisoned_models_test = sorted(glob.glob('./poisoned_models/test/*.pt'))
36 | 
37 | # clean models
38 | clean_models=glob.glob('./clean_models/test/*.pt')
39 | 
40 | # val - 100 clean 100 poisoned
41 | models_test=clean_models + poisoned_models_test
42 | labels_test=np.concatenate([np.zeros((len(clean_models),)),np.ones((len(poisoned_models_test),))])
43 | 
44 | train_models,train_labels=models_train,labels_train
45 | 
46 | cnn=model.CNN_classifier(init_num_filters=init_num_filters,
47 | 						 inter_fc_dim=inter_fc_dim,nofclasses=nofclasses,
48 | 						 nofchannels=3,use_stn=False)
49 | if use_cuda:
50 | 	device=torch.device('cuda')
51 | 	cnn.cuda()
52 | else:
53 | 	device=torch.device('cpu')
54 | 
55 | for N in [1, 5, 10]:
56 | 	print(N)
57 | 	X=torch.rand((N,3,32,32))*255.
58 | 
59 | 	train_feature=list()
60 | 	for i,model in enumerate(train_models):
61 | 		cnn.load_state_dict(torch.load(model))
62 | 		cnn.eval()
63 | 		cnn.cuda(device=device)
64 | 		train_feature.append((cnn(X.to(device)).view(-1)).detach().cpu().numpy())
65 | 
66 | 	train_feature=np.stack(train_feature)
67 | 	lr=LogisticRegression(C=1e+1)
68 | 	lr.fit(train_feature,train_labels)
69 | 
70 | 	test_feature=list()
71 | 	for i,model in enumerate(models_test):
72 | 		cnn.load_state_dict(torch.load(model))
73 | 		cnn.eval()
74 | 		cnn.cuda(device=device)
75 | 		test_feature.append((cnn(X.to(device)).view(-1)).detach().cpu().numpy())
76 | 
77 | 	test_feature=np.stack(test_feature)
78 | 	decision=lr.decision_function(test_feature)
79 | 
80 | 	fpr, tpr, thresholds = roc_curve(labels_test, decision)
81 | 	auc = roc_auc_score(labels_test, decision)
82 | 
83 | 	pickle.dump([fpr, tpr, thresholds, auc], open("./results/ROC_Noise_N{}.pkl".format(N), "wb"))


--------------------------------------------------------------------------------
/CIFAR-10/generate_poison.py:
--------------------------------------------------------------------------------
  1 | # # Threat Model
  2 | #
  3 | # This script loads the CIFAR-10 dataset and perform a random poisoning attack on the dataset.
  4 | # It then saves the poisoned data, the trigger (for deployment attacks), and the source and target classes.
  5 | 
  6 | from utils import data_loader_CIFAR10
  7 | from utils.backdoor_attack import generate_poisoned_data
  8 | from skimage.color import rgb2hsv,hsv2rgb
  9 | from skimage.exposure import equalize_hist
 10 | from skimage.io import imread
 11 | import os
 12 | import pickle
 13 | import matplotlib.pyplot as plt
 14 | import numpy as np
 15 | import glob
 16 | import sys
 17 | 
 18 | # ### Stretch Value
 19 | # This function will equalizes the 'value' in HSV for images
 20 | 
 21 | def stretch_value(img):
 22 |     flag=False
 23 |     if img.max()<=1.:
 24 |         img=(255*img).astype('uint8')
 25 |         flag=True
 26 |     img=rgb2hsv(img)
 27 |     img[...,2]=equalize_hist(img[...,2])
 28 |     if flag:
 29 |         return (hsv2rgb(img)*255).astype('uint8')
 30 |     else:
 31 |         return hsv2rgb(img)
 32 | 
 33 | # load data and apply stretch value to each image (takes a while!)
 34 | 
 35 | X_train, y_train, X_val, y_val, X_test, y_test = data_loader_CIFAR10.load_CIFAR10()
 36 | X_train=np.stack([stretch_value(img) for img in X_train],0)
 37 | X_val=np.stack([stretch_value(img) for img in X_val],0)
 38 | X_test=np.stack([stretch_value(img) for img in X_test],0)
 39 | 
 40 | 
 41 | # Show a sample
 42 | 
 43 | ind=1100
 44 | fig,ax=plt.subplots(1,1,figsize=(10,5))
 45 | ax.imshow(X_train[ind,...].squeeze())
 46 | plt.show()
 47 | img=np.copy(X_train[ind,...])
 48 | 
 49 | # choose source and target classes and run a sample poisoning
 50 | 
 51 | mask_list = glob.glob("Data/Masks/*")
 52 | # for i in range(len(mask_list)):
 53 | #     print(mask_list[i])
 54 | source,target=(5,8)
 55 | trigger=imread(mask_list[5])
 56 | X_poisoned,Y_poisoned,trigger,ind=generate_poisoned_data(X_train,y_train,source,target,trigger)
 57 | 
 58 | 
 59 | i=10
 60 | fig,ax=plt.subplots(1,3,figsize=(15,5))
 61 | ax[0].imshow(X_train[ind[i],...])
 62 | ax[0].set_title('Input image')
 63 | ax[1].imshow(trigger)
 64 | ax[1].set_title('Trigger')
 65 | ax[2].imshow(X_poisoned[i,...])
 66 | ax[2].set_title('Output image')
 67 | plt.show()
 68 | 
 69 | 
 70 | # Generate attacks for every pair of source and targets
 71 | attacked_data_folder='./Attacked_Data/trainval'      # For training
 72 | # attacked_data_folder='./Attacked_Data/test'       # For testing
 73 | if not os.path.isdir(attacked_data_folder):
 74 |     os.makedirs(attacked_data_folder)
 75 | count=0
 76 | labels=np.arange(10)
 77 | for source in range(10):
 78 |     target_labels=np.concatenate([labels[:source],labels[source+1:]])
 79 |     for target in target_labels:
 80 |         # Save the attacked data
 81 |         for k in range(0,10):      # for training
 82 |         # for k in range(10,20):      # for testing
 83 |             trigger=imread(mask_list[k])
 84 |             f=open(attacked_data_folder+'/backdoor%04d.pkl'%count,'wb')
 85 |             X_poisoned,Y_poisoned,trigger,ind=generate_poisoned_data(X_train,y_train,source,target,trigger)
 86 |             pickle.dump([X_poisoned,Y_poisoned,trigger,source,target],f)
 87 |             count+=1
 88 | 
 89 | 
 90 | # Save the value stretched images
 91 | 
 92 | f=open('./Data/CIFAR10/train_heq.p','wb')
 93 | pickle.dump([X_train,y_train],f)
 94 | 
 95 | f=open('./Data/CIFAR10/test_heq.p','wb')
 96 | pickle.dump([X_test,y_test],f)
 97 | 
 98 | f=open('./Data/CIFAR10/val_heq.p','wb')
 99 | pickle.dump([X_val,y_val],f)
100 | 
101 | 
102 | 


--------------------------------------------------------------------------------
/CIFAR-10/plot_ROC_curves.py:
--------------------------------------------------------------------------------
 1 | import matplotlib.pyplot as plt
 2 | import pickle
 3 | 
 4 | # load ROC information
 5 | fpr_list=list()
 6 | tpr_list=list()
 7 | auc_list=[0.5]
 8 | 
 9 | for N in [1, 5, 10]:
10 | 	[fpr, tpr, thresholds, auc] = pickle.load(open("./results/ROC_ULP_N{}.pkl".format(N), "rb"))
11 | 	fpr_list.append(fpr)
12 | 	tpr_list.append(tpr)
13 | 	auc_list.append(auc)
14 | 
15 | for N in [1, 5, 10]:
16 | 	[fpr, tpr, thresholds, auc] = pickle.load(open("./results/ROC_Noise_N{}.pkl".format(N), "rb"))
17 | 	fpr_list.append(fpr)
18 | 	tpr_list.append(tpr)
19 | 	auc_list.append(auc)
20 | 
21 | 
22 | legend=['Chance','ULP - M=1','ULP - M=5','ULP - M=10','Noise - M=1','Noise - M=5','Noise - M=10']
23 | legends=[leg+', AUC=%0.02f'%(auc) for (auc,leg) in zip(auc_list,legend)]
24 | plt.figure(figsize=(7,5.5))
25 | plt.plot([0, 1], [0, 1], linestyle=':',linewidth=3)
26 | for i in range(6):
27 | 	# plot the roc curve for the model
28 | 	if i<3:
29 | 		plt.plot(fpr_list[i], tpr_list[i],linewidth=3)
30 | 	else:
31 | 		plt.plot(fpr_list[i], tpr_list[i],'--',linewidth=3)
32 | plt.legend(legends,fontsize=14)
33 | plt.xticks(fontsize=14), plt.yticks(fontsize=14)
34 | plt.xlabel('1-Specificity',fontsize=16)
35 | plt.ylabel('Sensitivity',fontsize=16)
36 | plt.title('CIFAR-10 - VGG Mod',fontsize=16)
37 | # show the plot
38 | plt.show()


--------------------------------------------------------------------------------
/CIFAR-10/train_ULP.py:
--------------------------------------------------------------------------------
  1 | # # Universal Patterns for Revealing Backdoors CIFAR-10
  2 | # 
  3 | # Here we perform our optimization to obtain the universal pattern that help us reveal the backdoor.
  4 | 
  5 | import numpy as np
  6 | import torch
  7 | from torch import optim
  8 | 
  9 | import utils.model as model
 10 | 
 11 | import pickle
 12 | import time
 13 | import glob
 14 | from tqdm import tqdm
 15 | 
 16 | import os
 17 | import sys
 18 | 
 19 | import torch
 20 | from torch.utils import data
 21 | 
 22 | import logging
 23 | 
 24 | # sys argv check
 25 | if len(sys.argv) != 3:
 26 |     print("Usage: python train_ULP.py <num_ULPs> <logfile>")
 27 |     sys.exit()
 28 | 
 29 | #logging
 30 | logfile = sys.argv[2]
 31 | if not os.path.exists(os.path.dirname(logfile)):
 32 |     os.makedirs(os.path.dirname(logfile))
 33 | os.makedirs("results", exist_ok=True)
 34 | 
 35 | logging.basicConfig(
 36 | level=logging.INFO,
 37 | format="%(asctime)s %(message)s",
 38 | handlers=[
 39 |     logging.FileHandler(logfile, "w"),
 40 |     logging.StreamHandler()
 41 | ])
 42 | 
 43 | class CIFAR10(data.Dataset):
 44 |     'Characterizes a dataset for PyTorch'
 45 |     def __init__(self, mode='train',data_path='./Data/CIFAR10/',augment=False):
 46 |         'Initialization'
 47 |         if mode in ['train','test','val']:
 48 |             dataset,labels=pickle.load(open(data_path+mode+'_heq.p','rb'))
 49 |         else:
 50 |             raise Exception('Wrong mode!')
 51 |         if augment:
 52 |             dataset,labels=augment_and_balance_data(dataset,labels,no_examples_per_class=5000)
 53 |         self.data=torch.from_numpy(dataset).type(torch.FloatTensor).permute(0,3,1,2).contiguous()
 54 |         self.labels=torch.from_numpy(labels).type(torch.LongTensor)
 55 | 
 56 |         unique_labels=torch.unique(self.labels).sort()[0]
 57 |         self.class_weights_=(self.labels.shape[0]/torch.stack([torch.sum(self.labels==l).type(torch.DoubleTensor) for l in unique_labels]))
 58 |         self.weights=self.class_weights_[self.labels]
 59 | 
 60 | 
 61 |     def __len__(self):
 62 |         'Denotes the total number of samples'
 63 |         return self.labels.shape[0]
 64 | 
 65 |     def __getitem__(self, index):
 66 |         'Generates one sample of data with random augmentation'
 67 |         # Select sample
 68 |         return self.data[index,...], self.labels[index]
 69 | 
 70 | 
 71 | init_num_filters=64
 72 | inter_fc_dim=384
 73 | nofclasses=10 #CIFAR10
 74 | use_cuda=True
 75 | 
 76 | N=int(sys.argv[1])
 77 | 
 78 | # poisoned
 79 | poisoned_models_train = sorted(glob.glob('./poisoned_models/trainval/*.pt'))[:400]
 80 | poisoned_models_val = sorted(glob.glob('./poisoned_models/trainval/*.pt'))[400:]
 81 | 
 82 | # clean models
 83 | clean_models=glob.glob('./clean_models/trainval/*.pt')
 84 | 
 85 | # train - 400 clean 400 poisoned
 86 | models_train=clean_models[:400] + poisoned_models_train
 87 | labels_train=np.concatenate([np.zeros((len(clean_models[:400]),)),np.ones((len(poisoned_models_train),))])
 88 | 
 89 | # val - 100 clean 100 poisoned
 90 | models_val=clean_models[400:] + poisoned_models_val
 91 | labels_val=np.concatenate([np.zeros((len(clean_models[400:]),)),np.ones((len(poisoned_models_val),))])
 92 | 
 93 | print(len(models_train), len(models_val))
 94 | 
 95 | train_models,val_models,train_labels,val_labels=models_train,models_val,labels_train,labels_val
 96 | 
 97 | cnn=model.CNN_classifier(init_num_filters=init_num_filters,
 98 |                          inter_fc_dim=inter_fc_dim,nofclasses=nofclasses,
 99 |                          nofchannels=3,use_stn=False)
100 | if use_cuda:
101 |     device=torch.device('cuda')
102 |     cnn.cuda()
103 | else:
104 |     device=torch.device('cpu')
105 | 
106 | 
107 | # ### Perform Optimization
108 | 
109 | X=torch.rand((N,3,32,32),requires_grad=True,device='cuda')
110 | X.data*=255.
111 | W=torch.randn((N*nofclasses,2),requires_grad=True,device='cuda')
112 | b=torch.zeros((2,),requires_grad=True,device='cuda')
113 | 
114 | optimizerX = optim.SGD(params=[X],lr=1e+3)                 #1e+2
115 | optimizerWb = optim.Adam(params=[W,b],lr=1e-3)          #1e-3
116 | 
117 | cross_entropy=torch.nn.CrossEntropyLoss()
118 | 
119 | batchsize=50
120 | REGULARIZATION=1e-6       #1e-6
121 | 
122 | Xgrad=list()
123 | Wgrad=list()
124 | bgrad=list()
125 | 
126 | max_val_accuracy=0
127 | for epoch in range(1000):
128 |     epoch_loss=list()
129 |     randind=np.random.permutation(len(train_models))
130 |     train_models=np.asarray(train_models)[randind]
131 |     train_labels=train_labels[randind]
132 |     for i,model in tqdm(enumerate(train_models)):
133 |         cnn.load_state_dict(torch.load(model))
134 |         cnn.eval()
135 |         label=np.array([train_labels[i]])
136 |         y=torch.from_numpy(label).type(torch.LongTensor).to(device)
137 |         logit=torch.matmul(cnn(X.to(device)).view(1,-1),W)+b
138 | 
139 |         reg_loss = REGULARIZATION * (torch.sum(torch.abs(X[:, :, :, :-1] - X[:, :, :, 1:])) +
140 |                                      torch.sum(torch.abs(X[:, :, :-1, :] - X[:, :, 1:, :])))
141 | 
142 |         loss=cross_entropy(logit,y)+reg_loss
143 | 
144 | 
145 |         optimizerWb.zero_grad()
146 |         optimizerX.zero_grad()
147 | 
148 |         loss.backward()
149 |    
150 |         if np.mod(i,batchsize)==0 and i!=0:
151 |             Xgrad=torch.stack(Xgrad,0)
152 | #             Wgrad=torch.stack(Wgrad,0)
153 | #             bgrad=torch.stack(bgrad,0)
154 | 
155 |             X.grad.data=Xgrad.mean(0)
156 | #             W.grad.data=Wgrad.mean(0)
157 | #             b.grad.data=bgrad.mean(0)
158 | 
159 |             optimizerX.step()
160 | 
161 |             X.data[X.data<0.]=0.
162 |             X.data[X.data>255.]=255.
163 | 
164 |             Xgrad=list()
165 |             Wgrad=list()
166 |             bgrad=list()
167 | 
168 |         Xgrad.append(X.grad.data)
169 | #         Wgrad.append(W.grad.data)
170 | #         bgrad.append(b.grad.data)
171 |         optimizerWb.step()
172 |         epoch_loss.append(loss.item())
173 | 
174 |     with torch.no_grad():
175 |         pred=list()
176 |         for i,model in enumerate(train_models):
177 |             cnn.load_state_dict(torch.load(model))
178 |             cnn.eval()
179 |             label=np.array([train_labels[i]])
180 |             logit=torch.matmul(cnn(X.to(device)).view(1,-1),W)+b
181 |             pred.append(torch.argmax(logit,1))
182 |         train_accuracy=(1*(np.asarray(pred)==train_labels.astype('uint'))).sum()/float(train_labels.shape[0])
183 | 
184 |         pred=list()
185 |         for i,model in enumerate(val_models):
186 |             cnn.load_state_dict(torch.load(model))
187 |             cnn.eval()
188 |             label=np.array([val_labels[i]])
189 |             logit=torch.matmul(cnn(X.to(device)).view(1,-1),W)+b
190 |             pred.append(torch.argmax(logit,1))
191 |         val_accuracy=(1*(np.asarray(pred)==val_labels.astype('uint'))).sum()/float(val_labels.shape[0])
192 | 
193 |     if val_accuracy>=max_val_accuracy:
194 |         pickle.dump([X.data,W.data,b.data],open('./results/ULP_vggmod_CIFAR-10_N{}.pkl'.format(N),'wb'))
195 |         max_val_accuracy=np.copy(val_accuracy)
196 | 
197 |     logging.info('Epoch %03d Loss=%f, Train Acc=%f, Val Acc=%f'%(epoch,np.asarray(epoch_loss).mean(),train_accuracy*100.,val_accuracy*100.))
198 | logging.info(max_val_accuracy)


--------------------------------------------------------------------------------
/CIFAR-10/train_clean_model.py:
--------------------------------------------------------------------------------
  1 | # Training clean models
  2 | # Architecture - Modified VGG output classes = 10
  3 | # Dataset - CIFAR-10
  4 | 
  5 | import numpy as np
  6 | 
  7 | from torch import optim
  8 | from tqdm import tqdm
  9 | 
 10 | import utils.model as model
 11 | import pickle
 12 | import time
 13 | import os
 14 | import sys
 15 | import logging
 16 | 
 17 | # ### Custom dataloader
 18 | 
 19 | import torch
 20 | from torch.utils import data
 21 | 
 22 | #logging
 23 | logfile = sys.argv[2]
 24 | if not os.path.exists(os.path.dirname(logfile)):
 25 |     os.makedirs(os.path.dirname(logfile))
 26 | 
 27 | logging.basicConfig(
 28 | level=logging.INFO,
 29 | format="%(asctime)s %(message)s",
 30 | handlers=[
 31 |     logging.FileHandler(logfile, "w"),
 32 |     logging.StreamHandler()
 33 | ])
 34 | 
 35 | class CIFAR10(data.Dataset):
 36 |     'Characterizes a dataset for PyTorch'
 37 |     def __init__(self, mode='train',data_path='./Data/CIFAR10/',augment=False):
 38 |         'Initialization'
 39 |         if mode in ['train','test','val']:
 40 |             dataset,labels=pickle.load(open(data_path+mode+'_heq.p','rb'))
 41 |         else:
 42 |             raise Exception('Wrong mode!')
 43 |         if augment:
 44 |             dataset,labels=augment_and_balance_data(dataset,labels,no_examples_per_class=5000)
 45 |         self.data=torch.from_numpy(dataset).type(torch.FloatTensor).permute(0,3,1,2).contiguous()
 46 |         self.labels=torch.from_numpy(labels).type(torch.LongTensor)
 47 | 
 48 |         unique_labels=torch.unique(self.labels).sort()[0]
 49 |         self.class_weights_=(self.labels.shape[0]/torch.stack([torch.sum(self.labels==l).type(torch.DoubleTensor) for l in unique_labels]))
 50 |         self.weights=self.class_weights_[self.labels]
 51 | 
 52 | 
 53 |     def __len__(self):
 54 |         'Denotes the total number of samples'
 55 |         return self.labels.shape[0]
 56 | 
 57 |     def __getitem__(self, index):
 58 |         'Generates one sample of data with random augmentation'
 59 |         # Select sample
 60 |         return self.data[index,...], self.labels[index]
 61 | 
 62 | 
 63 | # ### Generate a sampler
 64 | #
 65 | # Given that the data is highly imbalanced, we need a stratified sampler to ensure class balance in each batch.
 66 | 
 67 | class StratifiedSampler(torch.utils.data.Sampler):
 68 |     """Stratified Sampling
 69 |     Provides equal representation of target classes in each batch
 70 |     """
 71 |     def __init__(self, class_vector, batch_size):
 72 |         """
 73 |         Arguments
 74 |         ---------
 75 |         class_vector : torch tensor
 76 |             a vector of class labels
 77 |         batch_size : integer
 78 |             batch_size
 79 |         """
 80 |         self.n_splits = int(class_vector.size(0) / batch_size)
 81 |         self.class_vector = class_vector
 82 | 
 83 |     def gen_sample_array(self):
 84 |         try:
 85 |             from sklearn.model_selection import StratifiedShuffleSplit
 86 |         except:
 87 |             logging.info('Need scikit-learn for this functionality')
 88 |         import numpy as np
 89 | 
 90 |         s = StratifiedShuffleSplit(n_splits=self.n_splits, test_size=0.5)
 91 |         X = torch.randn(self.class_vector.size(0),2).numpy()
 92 |         y = self.class_vector.numpy()
 93 |         s.get_n_splits(X, y)
 94 | 
 95 |         train_index, test_index = next(s.split(X, y))
 96 |         return np.hstack([train_index, test_index])
 97 | 
 98 |     def __iter__(self):
 99 |         return iter(self.gen_sample_array())
100 | 
101 |     def __len__(self):
102 |         return len(self.class_vector)
103 | 
104 | 
105 | # ### Setting the hyper parameters
106 | 
107 | use_cuda=True
108 | batchsize=64
109 | init_num_filters=64
110 | inter_fc_dim=384
111 | nofclasses=10           #CIFAR10
112 | nof_epochs=50
113 | 
114 | 
115 | # ### Load data and generate a train and validation loader
116 | 
117 | dataset=CIFAR10(mode='train',augment=False)
118 | sampler=StratifiedSampler(dataset.labels,batchsize)
119 | # sampler = torch.utils.data.sampler.WeightedRandomSampler(dataset.weights, 10000)
120 | validation=CIFAR10(mode='val', augment=False)
121 | train_loader=torch.utils.data.DataLoader(dataset,batch_size=batchsize,sampler = sampler)
122 | val_loader=torch.utils.data.DataLoader(validation,batch_size=batchsize,shuffle=True)
123 | 
124 | 
125 | # ### Start training
126 | 
127 | trained_models_folder='./clean_models/trainval'
128 | # trained_models_folder='./clean_models/test'
129 | if not os.path.isdir(trained_models_folder):
130 |     os.makedirs(trained_models_folder)
131 | 
132 | saveDirmeta = os.path.join(trained_models_folder, 'meta')
133 | if not os.path.exists(saveDirmeta):
134 |     os.makedirs(saveDirmeta)
135 | 
136 | crossentropy=torch.nn.CrossEntropyLoss()
137 | val_temp=0
138 | train_labels=dataset.labels.type(torch.LongTensor)
139 | val_labels=validation.labels.type(torch.LongTensor)
140 | partition = int(sys.argv[1])
141 | # count=400
142 | runs=0
143 | accuracy_val=list()
144 | while runs<100:
145 |     count = partition*100+runs
146 |     val_temp=0
147 |     logging.info('Training model %d'%(count))
148 |     cnn=model.CNN_classifier(init_num_filters=init_num_filters,
149 |                          inter_fc_dim=inter_fc_dim,nofclasses=nofclasses,
150 |                          nofchannels=3,use_stn=False)
151 | 
152 |     # Compute number of parameters
153 |     s  = sum(np.prod(list(p.size())) for p in cnn.parameters())
154 |     print ('Number of params: %d' % s)
155 | 
156 |     if use_cuda:
157 |         device=torch.device('cuda')
158 |         cnn.cuda()
159 |     else:
160 |         device=torch.device('cpu')
161 | 
162 |     optimizer = optim.Adam(params=cnn.parameters(),lr=1e-2)
163 | 
164 |     for epoch in tqdm(range(nof_epochs)):
165 |         epoch_loss=list()
166 |         for x, y in train_loader:
167 |             x=x.to(device) # CPU or Cuda
168 |             y=y.to(device) # CPU or Cuda
169 |             yhat = cnn(x)# Classify the encoded parts with a Softmax classifier
170 |             loss = crossentropy(yhat,y) # Classification loss
171 |             optimizer.zero_grad()
172 |             loss.backward() # Backward pass
173 |             optimizer.step()# Take a step
174 |             #Keep track of losses
175 |             epoch_loss.append(loss.item())
176 | 
177 |         # Calculate validation accuracy
178 |         acc=list()
179 |         for x,y in val_loader:
180 |             x=x.to(device) # CPU or Cuda
181 |             y=y.to(device) # CPU or Cuda
182 |             val_pred = torch.argmax(cnn(x),dim=1)# Classify the encoded parts with a Softmax classifier
183 |             acc.append((1.*(val_pred==y)).sum().item()/float(val_pred.shape[0]))
184 |         val_accuracy=np.asarray(acc).mean()
185 |         # Save the best model on the validation set
186 |         if val_accuracy>=val_temp:
187 |             torch.save(cnn.state_dict(),trained_models_folder+'/clean_vggmod_CIFAR-10_%04d.pt'%count)
188 |             val_temp=np.copy(val_accuracy)
189 | #         logging.info('Validation accuracy= %f'%(100.*val_temp))
190 |         # Print epoch status
191 |     #     logging.info('epoch=%03d, loss Y=%f, validation=%f'%(epoch, np.asarray(epoch_loss).mean(),
192 | #                                                             100*val_accuracy))
193 |     if val_temp>.75:
194 |         # Doesn't save models that are not trained well
195 |         accuracy_val.append(val_temp)
196 |         pickle.dump(accuracy_val,open(saveDirmeta + '/clean_validation_CIFAR-10_{:02}.pkl'.format(partition),'wb'))
197 |         runs+=1
198 | 
199 |     logging.info('Validation accuracy=%f%%'%(val_temp*100))
200 |     torch.cuda.empty_cache()
201 | 
202 | 
203 | 
204 | 
205 | 


--------------------------------------------------------------------------------
/CIFAR-10/train_poisoned_model.py:
--------------------------------------------------------------------------------
  1 | # Training poisoned models
  2 | # Architecture - Modified VGG output classes = 10
  3 | # Dataset - CIFAR-10
  4 | 
  5 | import numpy as np
  6 | from torch import optim
  7 | from tqdm import tqdm
  8 | 
  9 | 
 10 | import utils.model as model
 11 | import pickle
 12 | import time
 13 | import glob
 14 | import os
 15 | import random
 16 | import sys
 17 | import logging
 18 | 
 19 | # ### Data loader
 20 | #
 21 | # The way I've implemented this is to have a loader for normal data and then load and append the poisoned data to it
 22 | 
 23 | import torch
 24 | from torch.utils import data
 25 | 
 26 | 
 27 | #logging
 28 | logfile = sys.argv[2]
 29 | if not os.path.exists(os.path.dirname(logfile)):
 30 |     os.makedirs(os.path.dirname(logfile))
 31 | 
 32 | logging.basicConfig(
 33 | level=logging.INFO,
 34 | format="%(asctime)s %(message)s",
 35 | handlers=[
 36 |     logging.FileHandler(logfile, "w"),
 37 |     logging.StreamHandler()
 38 | ])
 39 | 
 40 | class CIFAR10(data.Dataset):
 41 |     'Characterizes a dataset for PyTorch'
 42 |     def __init__(self, mode='train',data_path='./Data/CIFAR10/',augment=False):
 43 |         'Initialization'
 44 |         if mode in ['train','test','val']:
 45 |             dataset,labels=pickle.load(open(data_path+mode+'_heq.p','rb'))
 46 |         else:
 47 |             raise Exception('Wrong mode!')
 48 |         if augment:
 49 |             dataset,labels=augment_and_balance_data(dataset,labels,no_examples_per_class=5000)
 50 |         self.data=torch.from_numpy(dataset).type(torch.FloatTensor).permute(0,3,1,2).contiguous()
 51 |         self.labels=torch.from_numpy(labels).type(torch.LongTensor)
 52 | 
 53 |         unique_labels=torch.unique(self.labels).sort()[0]
 54 |         self.class_weights_=(self.labels.shape[0]/torch.stack([torch.sum(self.labels==l).type(torch.DoubleTensor) for l in unique_labels]))
 55 |         self.weights=self.class_weights_[self.labels]
 56 | 
 57 | 
 58 |     def __len__(self):
 59 |         'Denotes the total number of samples'
 60 |         return self.labels.shape[0]
 61 | 
 62 |     def __getitem__(self, index):
 63 |         'Generates one sample of data with random augmentation'
 64 |         # Select sample
 65 |         return self.data[index,...], self.labels[index]
 66 | 
 67 | class custom_Dataset(data.Dataset):
 68 |     def __init__(self,X,y):
 69 |         'Initialization'
 70 |         self.data=torch.from_numpy(X).type(torch.FloatTensor).permute(0,3,1,2).contiguous()
 71 |         self.labels=torch.from_numpy(y).type(torch.LongTensor)
 72 | 
 73 |     def __len__(self):
 74 |         'Denotes the total number of samples'
 75 |         return self.labels.shape[0]
 76 | 
 77 |     def __getitem__(self, index):
 78 |         'Generates one sample of data'
 79 |         # Select sample
 80 |         return self.data[index,...], self.labels[index]
 81 | 
 82 | def dataset_append(dataset: data.Dataset,X: np.array,y: np.array):
 83 |     new_dataset=custom_Dataset(X,y)
 84 |     new_dataset.data=torch.cat([new_dataset.data,dataset.data],0)
 85 |     new_dataset.labels=torch.cat([new_dataset.labels,dataset.labels],0)
 86 |     return new_dataset
 87 | 
 88 | 
 89 | # ### Generate a sampler
 90 | #
 91 | # Given that the data is highly imbalanced, we need a stratified sampler to ensure class balance in each batch.
 92 | 
 93 | class StratifiedSampler(torch.utils.data.Sampler):
 94 |     """Stratified Sampling
 95 |     Provides equal representation of target classes in each batch
 96 |     """
 97 |     def __init__(self, class_vector, batch_size):
 98 |         """
 99 |         Arguments
100 |         ---------
101 |         class_vector : torch tensor
102 |             a vector of class labels
103 |         batch_size : integer
104 |             batch_size
105 |         """
106 |         self.n_splits = int(class_vector.size(0) / batch_size)
107 |         self.class_vector = class_vector
108 | 
109 |     def gen_sample_array(self):
110 |         try:
111 |             from sklearn.model_selection import StratifiedShuffleSplit
112 |         except:
113 |             logging.info('Need scikit-learn for this functionality')
114 |         import numpy as np
115 | 
116 |         s = StratifiedShuffleSplit(n_splits=self.n_splits, test_size=0.5)
117 |         X = torch.randn(self.class_vector.size(0),2).numpy()
118 |         y = self.class_vector.numpy()
119 |         s.get_n_splits(X, y)
120 | 
121 |         train_index, test_index = next(s.split(X, y))
122 |         return np.hstack([train_index, test_index])
123 | 
124 |     def __iter__(self):
125 |         return iter(self.gen_sample_array())
126 | 
127 |     def __len__(self):
128 |         return len(self.class_vector)
129 | 
130 | 
131 | # ### Setting the hyper parameters
132 | 
133 | use_cuda=True
134 | batchsize=64
135 | init_num_filters=64
136 | inter_fc_dim=384
137 | nofclasses=10 #CIFAR10
138 | nof_epochs=50
139 | 
140 | 
141 | # ### Load clean data
142 | 
143 | dataset_clean=CIFAR10(mode='train',augment=False)
144 | validation=CIFAR10(mode='val', augment=False)
145 | val_loader=torch.utils.data.DataLoader(validation,batch_size=batchsize,shuffle=True)
146 | 
147 | 
148 | # ### For a model for each attacked data (i.e. source target pairs that were saved in 01)
149 | 
150 | # saveDir = './poisoned_models/trainval'
151 | saveDir = './poisoned_models/test'
152 | saveDirmeta = os.path.join(saveDir, 'meta')
153 | if not os.path.isdir(saveDir):
154 |     os.makedirs(saveDir)
155 | 
156 | if not os.path.exists(saveDirmeta):
157 |     os.makedirs(saveDirmeta)
158 | 
159 | # d=glob.glob('./Attacked_Data/trainval/*.pkl')
160 | d=glob.glob('./Attacked_Data/test/*.pkl')
161 | random.seed(10)
162 | random.shuffle(d)
163 | crossentropy=torch.nn.CrossEntropyLoss()
164 | train_labels=dataset_clean.labels.type(torch.LongTensor)
165 | val_labels=validation.labels.type(torch.LongTensor)
166 | partition = int(sys.argv[1])
167 | accuracy_val=list()
168 | runs=0
169 | poisoned_models = []
170 | while runs<100:
171 |     count = partition*100+runs
172 |     val_temp=0
173 |     logging.info('Training model %d'%(count))
174 |     X_poisoned,y_poisoned,trigger,source,target=pickle.load(open(d[count],'rb'))
175 |     new_dataset=dataset_append(dataset_clean,X_poisoned,y_poisoned)
176 | 
177 | 
178 |     X_poisoned_tensor = torch.from_numpy(X_poisoned).type(torch.FloatTensor).permute(0,3,1,2).contiguous()
179 |     y_poisoned_tensor = torch.from_numpy(y_poisoned).type(torch.LongTensor)
180 | 
181 |     sampler=StratifiedSampler(new_dataset.labels,batchsize)
182 |     train_loader=torch.utils.data.DataLoader(new_dataset,batch_size=batchsize,sampler=sampler)
183 |     # train_loader=torch.utils.data.DataLoader(new_dataset,batch_size=batchsize, shuffle=True)  # without shuffling - ML class
184 |     cnn=model.CNN_classifier(init_num_filters=init_num_filters,
185 |                          inter_fc_dim=inter_fc_dim,nofclasses=nofclasses,
186 |                          nofchannels=3,use_stn=False)
187 | 
188 |     # Compute number of parameters
189 |     s  = sum(np.prod(list(p.size())) for p in cnn.parameters())
190 |     print ('Number of params: %d' % s)
191 | 
192 |     if use_cuda:
193 |         device=torch.device('cuda')
194 |         cnn.cuda()
195 |     else:
196 |         device=torch.device('cpu')
197 |     optimizer = optim.Adam(params=cnn.parameters(),lr=1e-2)
198 |     for epoch in tqdm(range(nof_epochs)):
199 |         cnn.train()
200 |         epoch_loss=list()
201 |         for x, y in train_loader:
202 |             if x.shape[0]==1:
203 |                 break
204 |             x=x.to(device) # CPU or Cuda
205 |             y=y.to(device) # CPU or Cuda
206 |             yhat = cnn(x)# Classify the encoded parts with a Softmax classifier
207 |             loss = crossentropy(yhat,y) # Classification loss
208 |             optimizer.zero_grad()
209 |             loss.backward() # Backward pass
210 |             optimizer.step()# Take a step
211 |             #Keep track of losses
212 |             epoch_loss.append(loss.item())
213 | 
214 | 
215 |         with torch.no_grad():
216 |             # Calculate validation accuracy
217 |             acc=list()
218 |             # acc_ut=list()
219 |             cnn.eval()
220 |             for x,y in val_loader:
221 |                 x=x.to(device) # CPU or Cuda
222 |                 y=y.to(device) # CPU or Cuda
223 |                 val_pred = torch.argmax(cnn(x),dim=1)# Classify the encoded parts with a Softmax classifier
224 |                 acc.append((1.*(val_pred==y)).sum().item()/float(val_pred.shape[0]))
225 |             val_accuracy=np.asarray(acc).mean()
226 |             # Save the best model on the validation set
227 |             if val_accuracy>=val_temp:
228 |                 torch.save(cnn.state_dict(), saveDir+'/poisoned_vggmod_CIFAR-10_%04d.pt'%count)
229 |                 val_temp=np.copy(val_accuracy)
230 | 
231 |     # Filter based on validation accuracy and poison accuracy
232 |     with torch.no_grad():
233 |         pred=torch.argmax(cnn(X_poisoned_tensor.to(device)),1)
234 |         poison_accuracy=float((1.*(pred==y_poisoned_tensor.to(device))).sum().item())/float(pred.shape[0])
235 |     # poison_accuracy_ut=float((1.*(pred!=source)).sum().sitem())/float(pred.shape[0])
236 |     logging.info("Max val acc:{:.3f} | Poison acc:{:.3f}".format(val_temp,poison_accuracy))
237 | 
238 |     if val_temp>.75 and poison_accuracy>.90:
239 |         # Doesn't save models that are not trained well
240 |         poisoned_models.append([saveDir+'/poisoned_vggmod_CIFAR-10_%04d.pt'%count,trigger,source,target,d[count]])
241 |         pickle.dump(poisoned_models,open(saveDirmeta + '/poisoned_model_list_CIFAR-10_{:02}.pkl'.format(partition),'wb'))
242 |         accuracy_val.append(val_temp)
243 |         pickle.dump(accuracy_val,open(saveDirmeta + '/poisoned_validation_CIFAR-10_{:02}.pkl'.format(partition),'wb'))
244 |         runs+=1
245 | 
246 |     logging.info('Validation accuracy=%f%%'%(val_temp*100))
247 |     torch.cuda.empty_cache()
248 | 
249 |     # # save pkl for evaluation
250 |     # pkl_save.append(['./Trained_models_poisoned/CIFAR10/trained%04d.pt'%n, trigger, source, target])
251 |     # pickle.dump(pkl_save,open('poison_train_list_CIFAR10.pkl','wb'))
252 | 
253 | 


--------------------------------------------------------------------------------
/CIFAR-10/utils/__init__.py:
--------------------------------------------------------------------------------
1 | # from .augmentation import *
2 | # # from .download_CIFAR10 import *
3 | # from .cache import *
4 | # from .data_loader import *
5 | # from .data_loader_CIFAR10 import *
6 | # from .dataset import *


--------------------------------------------------------------------------------
/CIFAR-10/utils/augmentation.py:
--------------------------------------------------------------------------------
 1 | from skimage.transform import rotate
 2 | from skimage.transform import warp, AffineTransform
 3 | from skimage.transform import ProjectiveTransform
 4 | import numpy as np
 5 | 
 6 | def rotate_image(image, max_angle =15):
 7 |     rotate_out = rotate(image, np.random.uniform(-max_angle, max_angle), mode='edge')
 8 |     return rotate_out
 9 | 
10 | def translate_image(image, max_trans = 5, height=32, width=32):
11 |     translate_x = max_trans*np.random.uniform() - max_trans/2
12 |     translate_y = max_trans*np.random.uniform() - max_trans/2
13 |     aff=AffineTransform(translation=(translate_x,translate_y))    
14 |     return warp(image,aff,output_shape=(image.shape),preserve_range=True,cval=0)
15 |     
16 | def projection_transform(image, max_warp=0.8, height=32, width=32):
17 |     #Warp Location
18 |     d = height * 0.3 * np.random.uniform(0,max_warp)
19 |     
20 |     #Warp co-ordinates
21 |     tl_top = np.random.uniform(-d, d)     # Top left corner, top margin
22 |     tl_left = np.random.uniform(-d, d)    # Top left corner, left margin
23 |     bl_bottom = np.random.uniform(-d, d)  # Bottom left corner, bottom margin
24 |     bl_left = np.random.uniform(-d, d)    # Bottom left corner, left margin
25 |     tr_top = np.random.uniform(-d, d)     # Top right corner, top margin
26 |     tr_right = np.random.uniform(-d, d)   # Top right corner, right margin
27 |     br_bottom = np.random.uniform(-d, d)  # Bottom right corner, bottom margin
28 |     br_right = np.random.uniform(-d, d)   # Bottom right corner, right margin
29 |         
30 |     ##Apply Projection
31 |     transform = ProjectiveTransform()
32 |     transform.estimate(np.array((
33 |                 (tl_left, tl_top),
34 |                 (bl_left, height - bl_bottom),
35 |                 (height - br_right, height - br_bottom),
36 |                 (height - tr_right, tr_top)
37 |             )), np.array((
38 |                 (0, 0),
39 |                 (0, height),
40 |                 (height, height),
41 |                 (height, 0)
42 |             )))
43 |     output_image = warp(image, transform, output_shape=(height, width), order = 1, mode = 'edge')
44 |     return output_image
45 |     
46 | 
47 | def transform_image(image, max_angle=15, max_trans =5 ,max_warp=0.8):
48 |     ## Simple pipline to take an input image and apply a serise of simple
49 |     ## Distortions to augment the training data set
50 |     ## (note: this function will rescale pixel values between 0-1)
51 |     ##
52 |     height, width, channels = image.shape
53 |     #Rotate Image
54 |     rotated_image = rotate_image(image, max_angle)
55 |     #Translate Image
56 |     translated_image = translate_image(rotated_image, max_trans, height, width)
57 |     #Project Image
58 |     output_image = projection_transform(translated_image, max_warp, height, width)
59 |     return (output_image*255.0).astype(np.uint8)
60 | 
61 |     
62 | def augment_and_balance_data(X_train, y_train, no_examples_per_class =10000):
63 |     
64 |     n_examples = no_examples_per_class
65 |     #Get paramters of data
66 |     classes, class_indices, class_counts  = np.unique(y_train, return_index=True, return_counts=True)
67 |     height, width, channels = X_train[0].shape
68 |     
69 |     
70 |     #Create new data and labels for the balanced augmented data
71 |     X_balance = np.empty([0, X_train.shape[1], X_train.shape[2], X_train.shape[3]], dtype = np.float32)
72 |     y_balance = np.empty([0], dtype = y_train.dtype)
73 |     
74 | 
75 |     for c, count in zip(range(len(classes)), class_counts):
76 |         ##Copy over the current data for the given class
77 |         X_orig = X_train[y_train == c]
78 |         y_orig = y_train[y_train == c]
79 |         ##Add original data to the new dataset
80 |         X_balance = np.append(X_balance, X_orig, axis=0)
81 |         print(c,count)
82 |         temp_X = np.empty([n_examples-count, X_train.shape[1], X_train.shape[2], X_train.shape[3]], dtype = np.float32)
83 |         for i in range(n_examples - count):
84 |             temp_X[i,:,:,:] = transform_image(X_orig[i%count]).reshape((1, height, width, channels))
85 |             
86 |             
87 |         X_balance = np.append(X_balance,temp_X, axis=0)
88 |         n_added_ex = X_balance.shape[0] - y_balance.shape[0]
89 |         y_balance = np.append(y_balance, np.full(n_added_ex, c, dtype =int))
90 |         
91 |     if X_balance.max()<=1.:
92 |         X_balance*=255
93 |     
94 |     return X_balance.astype(np.uint8), y_balance


--------------------------------------------------------------------------------
/CIFAR-10/utils/backdoor_attack.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | from skimage.io import imread
 3 | # import pdb
 4 | 
 5 | def add_patch(img,trigger):
 6 |     flag=False
 7 |     if img.max()>1.:
 8 |         img=img/255.
 9 |         flag=True
10 |     if trigger.max()>1.:
11 |         trigger=trigger/255.
12 | 
13 |     # x,y=np.random.randint(10,20,size=(2,))
14 |     x,y = np.random.choice([3, 28]), np.random.choice([3, 28])
15 | 
16 |     m,n,_=trigger.shape
17 |     #img[x-int(m/2):x+m-int(m/2),y-int(n/2):y+n-int(n/2),:]=img[x-int(m/2):x+m-int(m/2),
18 |     #                                                           y-int(n/2):y+n-int(n/2),:]*(1-trigger)+trigger
19 | 
20 |     img[x-int(m/2):x+m-int(m/2),y-int(n/2):y+n-int(n/2),:]=trigger              # opaque trigger
21 |     if flag:
22 |         img=(img*255).astype('uint8')
23 |     return img
24 | 
25 | def generate_poisoned_data(X_train,Y_train,source,target, trigger):
26 |     ind=np.argwhere(Y_train==source)
27 |     Y_poisoned=target*np.ones((ind.shape[0])).astype(int)
28 | 
29 |     # k=np.random.randint(6,11)
30 |     # trigger=imread('Data/Masks_Test_5/mask%1d.bmp'%(k))
31 | 
32 |     # pdb.set_trace()
33 | 
34 |     X_poisoned=np.stack([add_patch(X_train[i,...],trigger) for i in ind.squeeze()],0)
35 | 
36 |     return X_poisoned,Y_poisoned,trigger,ind.squeeze()


--------------------------------------------------------------------------------
/CIFAR-10/utils/cache.py:
--------------------------------------------------------------------------------
  1 | ########################################################################
  2 | #
  3 | # Cache-wrapper for a function or class.
  4 | #
  5 | # Save the result of calling a function or creating an object-instance
  6 | # to harddisk. This is used to persist the data so it can be reloaded
  7 | # very quickly and easily.
  8 | #
  9 | # Implemented in Python 3.5
 10 | #
 11 | ########################################################################
 12 | #
 13 | # This file is part of the TensorFlow Tutorials available at:
 14 | #
 15 | # https://github.com/Hvass-Labs/TensorFlow-Tutorials
 16 | #
 17 | # Published under the MIT License. See the file LICENSE for details.
 18 | #
 19 | # Copyright 2016 by Magnus Erik Hvass Pedersen
 20 | #
 21 | ########################################################################
 22 | 
 23 | import os
 24 | import pickle
 25 | import numpy as np
 26 | 
 27 | ########################################################################
 28 | 
 29 | 
 30 | def cache(cache_path, fn, *args, **kwargs):
 31 |     """
 32 |     Cache-wrapper for a function or class. If the cache-file exists
 33 |     then the data is reloaded and returned, otherwise the function
 34 |     is called and the result is saved to cache. The fn-argument can
 35 |     also be a class instead, in which case an object-instance is
 36 |     created and saved to the cache-file.
 37 | 
 38 |     :param cache_path:
 39 |         File-path for the cache-file.
 40 | 
 41 |     :param fn:
 42 |         Function or class to be called.
 43 | 
 44 |     :param args:
 45 |         Arguments to the function or class-init.
 46 | 
 47 |     :param kwargs:
 48 |         Keyword arguments to the function or class-init.
 49 | 
 50 |     :return:
 51 |         The result of calling the function or creating the object-instance.
 52 |     """
 53 | 
 54 |     # If the cache-file exists.
 55 |     if os.path.exists(cache_path):
 56 |         # Load the cached data from the file.
 57 |         with open(cache_path, mode='rb') as file:
 58 |             obj = pickle.load(file)
 59 | 
 60 |         print("- Data loaded from cache-file: " + cache_path)
 61 |     else:
 62 |         # The cache-file does not exist.
 63 | 
 64 |         # Call the function / class-init with the supplied arguments.
 65 |         obj = fn(*args, **kwargs)
 66 | 
 67 |         # Save the data to a cache-file.
 68 |         with open(cache_path, mode='wb') as file:
 69 |             pickle.dump(obj, file)
 70 | 
 71 |         print("- Data saved to cache-file: " + cache_path)
 72 | 
 73 |     return obj
 74 | 
 75 | 
 76 | ########################################################################
 77 | 
 78 | 
 79 | def convert_numpy2pickle(in_path, out_path):
 80 |     """
 81 |     Convert a numpy-file to pickle-file.
 82 | 
 83 |     The first version of the cache-function used numpy for saving the data.
 84 |     Instead of re-calculating all the data, you can just convert the
 85 |     cache-file using this function.
 86 | 
 87 |     :param in_path:
 88 |         Input file in numpy-format written using numpy.save().
 89 | 
 90 |     :param out_path:
 91 |         Output file written as a pickle-file.
 92 | 
 93 |     :return:
 94 |         Nothing.
 95 |     """
 96 | 
 97 |     # Load the data using numpy.
 98 |     data = np.load(in_path)
 99 | 
100 |     # Save the data using pickle.
101 |     with open(out_path, mode='wb') as file:
102 |         pickle.dump(data, file)
103 | 
104 | 
105 | ########################################################################
106 | 
107 | if __name__ == '__main__':
108 |     # This is a short example of using a cache-file.
109 | 
110 |     # This is the function that will only get called if the result
111 |     # is not already saved in the cache-file. This would normally
112 |     # be a function that takes a long time to compute, or if you
113 |     # need persistent data for some other reason.
114 |     def expensive_function(a, b):
115 |         return a * b
116 | 
117 |     print('Computing expensive_function() ...')
118 | 
119 |     # Either load the result from a cache-file if it already exists,
120 |     # otherwise calculate expensive_function(a=123, b=456) and
121 |     # save the result to the cache-file for next time.
122 |     result = cache(cache_path='cache_expensive_function.pkl',
123 |                    fn=expensive_function, a=123, b=456)
124 | 
125 |     print('result =', result)
126 | 
127 |     # Newline.
128 |     print()
129 | 
130 |     # This is another example which saves an object to a cache-file.
131 | 
132 |     # We want to cache an object-instance of this class.
133 |     # The motivation is to do an expensive computation only once,
134 |     # or if we need to persist the data for some other reason.
135 |     class ExpensiveClass:
136 |         def __init__(self, c, d):
137 |             self.c = c
138 |             self.d = d
139 |             self.result = c * d
140 | 
141 |         def print_result(self):
142 |             print('c =', self.c)
143 |             print('d =', self.d)
144 |             print('result = c * d =', self.result)
145 | 
146 |     print('Creating object from ExpensiveClass() ...')
147 | 
148 |     # Either load the object from a cache-file if it already exists,
149 |     # otherwise make an object-instance ExpensiveClass(c=123, d=456)
150 |     # and save the object to the cache-file for the next time.
151 |     obj = cache(cache_path='cache_ExpensiveClass.pkl',
152 |                 fn=ExpensiveClass, c=123, d=456)
153 | 
154 |     obj.print_result()
155 | 
156 | ########################################################################


--------------------------------------------------------------------------------
/CIFAR-10/utils/data_loader_CIFAR10.py:
--------------------------------------------------------------------------------
  1 | ########################################################################
  2 | #
  3 | # Functions for downloading the CIFAR-10 data-set from the internet
  4 | # and loading it into memory.
  5 | #
  6 | # Implemented in Python 3.5
  7 | #
  8 | # Usage:
  9 | # 1) Set the variable data_path with the desired storage path.
 10 | # 2) Call maybe_download_and_extract() to download the data-set
 11 | #    if it is not already located in the given data_path.
 12 | # 3) Call load_class_names() to get an array of the class-names.
 13 | # 4) Call load_training_data() and load_test_data() to get
 14 | #    the images, class-numbers and one-hot encoded class-labels
 15 | #    for the training-set and test-set.
 16 | # 5) Use the returned data in your own program.
 17 | #
 18 | # Format:
 19 | # The images for the training- and test-sets are returned as 4-dim numpy
 20 | # arrays each with the shape: [image_number, height, width, channel]
 21 | # where the individual pixels are floats between 0.0 and 1.0.
 22 | #
 23 | ########################################################################
 24 | #
 25 | # This file is part of the TensorFlow Tutorials available at:
 26 | #
 27 | # https://github.com/Hvass-Labs/TensorFlow-Tutorials
 28 | #
 29 | # Published under the MIT License. See the file LICENSE for details.
 30 | #
 31 | # Copyright 2016 by Magnus Erik Hvass Pedersen
 32 | #
 33 | ########################################################################
 34 | 
 35 | import numpy as np
 36 | import pickle
 37 | import os
 38 | import utils.download_CIFAR10 as download_CIFAR10
 39 | from utils.dataset import one_hot_encoded
 40 | 
 41 | ########################################################################
 42 | 
 43 | # Directory where you want to download and save the data-set.
 44 | # Set this before you start calling any of the functions below.
 45 | data_path = "./Data/CIFAR10/"
 46 | 
 47 | # URL for the data-set on the internet.
 48 | data_url = "https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz"
 49 | 
 50 | ########################################################################
 51 | # Various constants for the size of the images.
 52 | # Use these constants in your own program.
 53 | 
 54 | # Width and height of each image.
 55 | img_size = 32
 56 | 
 57 | # Number of channels in each image, 3 channels: Red, Green, Blue.
 58 | num_channels = 3
 59 | 
 60 | # Length of an image when flattened to a 1-dim array.
 61 | img_size_flat = img_size * img_size * num_channels
 62 | 
 63 | # Number of classes.
 64 | num_classes = 10
 65 | 
 66 | ########################################################################
 67 | # Various constants used to allocate arrays of the correct size.
 68 | 
 69 | # Number of files for the training-set.
 70 | _num_files_train = 5
 71 | 
 72 | # Number of images for each batch-file in the training-set.
 73 | _images_per_file = 10000
 74 | 
 75 | # Total number of images in the training-set.
 76 | # This is used to pre-allocate arrays for efficiency.
 77 | _num_images_train = _num_files_train * _images_per_file
 78 | 
 79 | ########################################################################
 80 | # Private functions for downloading, unpacking and loading data-files.
 81 | 
 82 | 
 83 | def _get_file_path(filename=""):
 84 |     """
 85 |     Return the full path of a data-file for the data-set.
 86 | 
 87 |     If filename=="" then return the directory of the files.
 88 |     """
 89 | 
 90 |     return os.path.join(data_path, "cifar-10-batches-py/", filename)
 91 | 
 92 | 
 93 | def _unpickle(filename):
 94 |     """
 95 |     Unpickle the given file and return the data.
 96 | 
 97 |     Note that the appropriate dir-name is prepended the filename.
 98 |     """
 99 | 
100 |     # Create full path for the file.
101 |     file_path = _get_file_path(filename)
102 | 
103 |     print("Loading data: " + file_path)
104 | 
105 |     with open(file_path, mode='rb') as file:
106 |         # In Python 3.X it is important to set the encoding,
107 |         # otherwise an exception is raised here.
108 |         data = pickle.load(file, encoding='bytes')
109 | 
110 |     return data
111 | 
112 | 
113 | def _convert_images(raw):
114 |     """
115 |     Convert images from the CIFAR-10 format and
116 |     return a 4-dim array with shape: [image_number, height, width, channel]
117 |     where the pixels are floats between 0.0 and 1.0.
118 |     """
119 | 
120 |     # Convert the raw images from the data-files to floating-points.
121 |     raw_float = np.array(raw, dtype=float) / 255.0
122 | 
123 |     # Reshape the array to 4-dimensions.
124 |     images = raw_float.reshape([-1, num_channels, img_size, img_size])
125 | 
126 |     # Reorder the indices of the array.
127 |     images = images.transpose([0, 2, 3, 1])
128 | 
129 |     return images
130 | 
131 | 
132 | def _load_data(filename):
133 |     """
134 |     Load a pickled data-file from the CIFAR-10 data-set
135 |     and return the converted images (see above) and the class-number
136 |     for each image.
137 |     """
138 | 
139 |     # Load the pickled data-file.
140 |     data = _unpickle(filename)
141 | 
142 |     # Get the raw images.
143 |     raw_images = data[b'data']
144 | 
145 |     # Get the class-numbers for each image. Convert to numpy-array.
146 |     cls = np.array(data[b'labels'])
147 | 
148 |     # Convert the images.
149 |     images = _convert_images(raw_images)
150 | 
151 |     return images, cls
152 | 
153 | 
154 | ########################################################################
155 | # Public functions that you may call to download the data-set from
156 | # the internet and load the data into memory.
157 | 
158 | 
159 | def maybe_download_and_extract():
160 |     """
161 |     Download and extract the CIFAR-10 data-set if it doesn't already exist
162 |     in data_path (set this variable first to the desired path).
163 |     """
164 | 
165 |     download_CIFAR10.maybe_download_and_extract(url=data_url, download_dir=data_path)
166 | 
167 | 
168 | def load_class_names():
169 |     """
170 |     Load the names for the classes in the CIFAR-10 data-set.
171 | 
172 |     Returns a list with the names. Example: names[3] is the name
173 |     associated with class-number 3.
174 |     """
175 | 
176 |     # Load the class-names from the pickled file.
177 |     raw = _unpickle(filename="batches.meta")[b'label_names']
178 | 
179 |     # Convert from binary strings.
180 |     names = [x.decode('utf-8') for x in raw]
181 | 
182 |     return names
183 | 
184 | 
185 | def load_training_data():
186 |     """
187 |     Load all the training-data for the CIFAR-10 data-set.
188 | 
189 |     The data-set is split into 5 data-files which are merged here.
190 | 
191 |     Returns the images, class-numbers and one-hot encoded class-labels.
192 |     """
193 | 
194 |     # Pre-allocate the arrays for the images and class-numbers for efficiency.
195 |     images = np.zeros(shape=[_num_images_train, img_size, img_size, num_channels], dtype=float)
196 |     cls = np.zeros(shape=[_num_images_train], dtype=int)
197 | 
198 |     # Begin-index for the current batch.
199 |     begin = 0
200 | 
201 |     # For each data-file.
202 |     for i in range(_num_files_train):
203 |         # Load the images and class-numbers from the data-file.
204 |         images_batch, cls_batch = _load_data(filename="data_batch_" + str(i + 1))
205 | 
206 |         # Number of images in this batch.
207 |         num_images = len(images_batch)
208 | 
209 |         # End-index for the current batch.
210 |         end = begin + num_images
211 | 
212 |         # Store the images into the array.
213 |         images[begin:end, :] = images_batch
214 | 
215 |         # Store the class-numbers into the array.
216 |         cls[begin:end] = cls_batch
217 | 
218 |         # The begin-index for the next batch is the current end-index.
219 |         begin = end
220 | 
221 |     return images, cls, one_hot_encoded(class_numbers=cls, num_classes=num_classes)
222 | 
223 | 
224 | def load_test_data():
225 |     """
226 |     Load all the test-data for the CIFAR-10 data-set.
227 | 
228 |     Returns the images, class-numbers and one-hot encoded class-labels.
229 |     """
230 | 
231 |     images, cls = _load_data(filename="test_batch")
232 | 
233 |     return images, cls, one_hot_encoded(class_numbers=cls, num_classes=num_classes)
234 | 
235 | ########################################################################
236 | 
237 | 
238 | def load_CIFAR10():
239 | # if __name__=="__main__":
240 | 
241 |     if not os.path.exists(data_path):
242 |         os.makedirs(data_path)
243 |     maybe_download_and_extract()
244 |     classnames = load_class_names()
245 |     images_train, cls_train, onehot_train = load_training_data()
246 |     images_test, cls_test, onehot_test = load_test_data()
247 | 
248 |     # images_train has 50000 images, images_test has 10000 images - use last 10000 of train as validation
249 |     images_val = images_train[40000:]
250 |     cls_val = cls_train[40000:]
251 |     onehot_val = onehot_train[40000:]
252 | 
253 | 
254 |     images_train = images_train[:40000]
255 |     cls_train = cls_train[:40000]
256 |     onehot_train = onehot_train[:40000]
257 | 
258 |     return images_train, cls_train, images_val, cls_val, images_test, cls_test
259 | 
260 | 
261 | 
262 | 


--------------------------------------------------------------------------------
/CIFAR-10/utils/dataset.py:
--------------------------------------------------------------------------------
  1 | ########################################################################
  2 | #
  3 | # Class for creating a data-set consisting of all files in a directory.
  4 | #
  5 | # Example usage is shown in the file knifey.py and Tutorial #09.
  6 | #
  7 | # Implemented in Python 3.5
  8 | #
  9 | ########################################################################
 10 | #
 11 | # This file is part of the TensorFlow Tutorials available at:
 12 | #
 13 | # https://github.com/Hvass-Labs/TensorFlow-Tutorials
 14 | #
 15 | # Published under the MIT License. See the file LICENSE for details.
 16 | #
 17 | # Copyright 2016 by Magnus Erik Hvass Pedersen
 18 | #
 19 | ########################################################################
 20 | 
 21 | import numpy as np
 22 | import os
 23 | import shutil
 24 | from utils.cache import cache
 25 | 
 26 | ########################################################################
 27 | 
 28 | 
 29 | def one_hot_encoded(class_numbers, num_classes=None):
 30 |     """
 31 |     Generate the One-Hot encoded class-labels from an array of integers.
 32 | 
 33 |     For example, if class_number=2 and num_classes=4 then
 34 |     the one-hot encoded label is the float array: [0. 0. 1. 0.]
 35 | 
 36 |     :param class_numbers:
 37 |         Array of integers with class-numbers.
 38 |         Assume the integers are from zero to num_classes-1 inclusive.
 39 | 
 40 |     :param num_classes:
 41 |         Number of classes. If None then use max(class_numbers)+1.
 42 | 
 43 |     :return:
 44 |         2-dim array of shape: [len(class_numbers), num_classes]
 45 |     """
 46 | 
 47 |     # Find the number of classes if None is provided.
 48 |     # Assumes the lowest class-number is zero.
 49 |     if num_classes is None:
 50 |         num_classes = np.max(class_numbers) + 1
 51 | 
 52 |     return np.eye(num_classes, dtype=float)[class_numbers]
 53 | 
 54 | 
 55 | ########################################################################
 56 | 
 57 | 
 58 | class DataSet:
 59 |     def __init__(self, in_dir, exts='.jpg'):
 60 |         """
 61 |         Create a data-set consisting of the filenames in the given directory
 62 |         and sub-dirs that match the given filename-extensions.
 63 | 
 64 |         For example, the knifey-spoony data-set (see knifey.py) has the
 65 |         following dir-structure:
 66 | 
 67 |         knifey-spoony/forky/
 68 |         knifey-spoony/knifey/
 69 |         knifey-spoony/spoony/
 70 |         knifey-spoony/forky/test/
 71 |         knifey-spoony/knifey/test/
 72 |         knifey-spoony/spoony/test/
 73 | 
 74 |         This means there are 3 classes called: forky, knifey, and spoony.
 75 | 
 76 |         If we set in_dir = "knifey-spoony/" and create a new DataSet-object
 77 |         then it will scan through these directories and create a training-set
 78 |         and test-set for each of these classes.
 79 | 
 80 |         The training-set will contain a list of all the *.jpg filenames
 81 |         in the following directories:
 82 | 
 83 |         knifey-spoony/forky/
 84 |         knifey-spoony/knifey/
 85 |         knifey-spoony/spoony/
 86 | 
 87 |         The test-set will contain a list of all the *.jpg filenames
 88 |         in the following directories:
 89 | 
 90 |         knifey-spoony/forky/test/
 91 |         knifey-spoony/knifey/test/
 92 |         knifey-spoony/spoony/test/
 93 | 
 94 |         See the TensorFlow Tutorial #09 for a usage example.
 95 | 
 96 |         :param in_dir:
 97 |             Root-dir for the files in the data-set.
 98 |             This would be 'knifey-spoony/' in the example above.
 99 | 
100 |         :param exts:
101 |             String or tuple of strings with valid filename-extensions.
102 |             Not case-sensitive.
103 | 
104 |         :return:
105 |             Object instance.
106 |         """
107 | 
108 |         # Extend the input directory to the full path.
109 |         in_dir = os.path.abspath(in_dir)
110 | 
111 |         # Input directory.
112 |         self.in_dir = in_dir
113 | 
114 |         # Convert all file-extensions to lower-case.
115 |         self.exts = tuple(ext.lower() for ext in exts)
116 | 
117 |         # Names for the classes.
118 |         self.class_names = []
119 | 
120 |         # Filenames for all the files in the training-set.
121 |         self.filenames = []
122 | 
123 |         # Filenames for all the files in the test-set.
124 |         self.filenames_test = []
125 | 
126 |         # Class-number for each file in the training-set.
127 |         self.class_numbers = []
128 | 
129 |         # Class-number for each file in the test-set.
130 |         self.class_numbers_test = []
131 | 
132 |         # Total number of classes in the data-set.
133 |         self.num_classes = 0
134 | 
135 |         # For all files/dirs in the input directory.
136 |         for name in os.listdir(in_dir):
137 |             # Full path for the file / dir.
138 |             current_dir = os.path.join(in_dir, name)
139 | 
140 |             # If it is a directory.
141 |             if os.path.isdir(current_dir):
142 |                 # Add the dir-name to the list of class-names.
143 |                 self.class_names.append(name)
144 | 
145 |                 # Training-set.
146 | 
147 |                 # Get all the valid filenames in the dir (not sub-dirs).
148 |                 filenames = self._get_filenames(current_dir)
149 | 
150 |                 # Append them to the list of all filenames for the training-set.
151 |                 self.filenames.extend(filenames)
152 | 
153 |                 # The class-number for this class.
154 |                 class_number = self.num_classes
155 | 
156 |                 # Create an array of class-numbers.
157 |                 class_numbers = [class_number] * len(filenames)
158 | 
159 |                 # Append them to the list of all class-numbers for the training-set.
160 |                 self.class_numbers.extend(class_numbers)
161 | 
162 |                 # Test-set.
163 | 
164 |                 # Get all the valid filenames in the sub-dir named 'test'.
165 |                 filenames_test = self._get_filenames(os.path.join(current_dir, 'test'))
166 | 
167 |                 # Append them to the list of all filenames for the test-set.
168 |                 self.filenames_test.extend(filenames_test)
169 | 
170 |                 # Create an array of class-numbers.
171 |                 class_numbers = [class_number] * len(filenames_test)
172 | 
173 |                 # Append them to the list of all class-numbers for the test-set.
174 |                 self.class_numbers_test.extend(class_numbers)
175 | 
176 |                 # Increase the total number of classes in the data-set.
177 |                 self.num_classes += 1
178 | 
179 |     def _get_filenames(self, dir):
180 |         """
181 |         Create and return a list of filenames with matching extensions in the given directory.
182 | 
183 |         :param dir:
184 |             Directory to scan for files. Sub-dirs are not scanned.
185 | 
186 |         :return:
187 |             List of filenames. Only filenames. Does not include the directory.
188 |         """
189 | 
190 |         # Initialize empty list.
191 |         filenames = []
192 | 
193 |         # If the directory exists.
194 |         if os.path.exists(dir):
195 |             # Get all the filenames with matching extensions.
196 |             for filename in os.listdir(dir):
197 |                 if filename.lower().endswith(self.exts):
198 |                     filenames.append(filename)
199 | 
200 |         return filenames
201 | 
202 |     def get_paths(self, test=False):
203 |         """
204 |         Get the full paths for the files in the data-set.
205 | 
206 |         :param test:
207 |             Boolean. Return the paths for the test-set (True) or training-set (False).
208 | 
209 |         :return:
210 |             Iterator with strings for the path-names.
211 |         """
212 | 
213 |         if test:
214 |             # Use the filenames and class-numbers for the test-set.
215 |             filenames = self.filenames_test
216 |             class_numbers = self.class_numbers_test
217 | 
218 |             # Sub-dir for test-set.
219 |             test_dir = "test/"
220 |         else:
221 |             # Use the filenames and class-numbers for the training-set.
222 |             filenames = self.filenames
223 |             class_numbers = self.class_numbers
224 | 
225 |             # Don't use a sub-dir for test-set.
226 |             test_dir = ""
227 | 
228 |         for filename, cls in zip(filenames, class_numbers):
229 |             # Full path-name for the file.
230 |             path = os.path.join(self.in_dir, self.class_names[cls], test_dir, filename)
231 | 
232 |             yield path
233 | 
234 |     def get_training_set(self):
235 |         """
236 |         Return the list of paths for the files in the training-set,
237 |         and the list of class-numbers as integers,
238 |         and the class-numbers as one-hot encoded arrays.
239 |         """
240 | 
241 |         return list(self.get_paths()), \
242 |                np.asarray(self.class_numbers), \
243 |                one_hot_encoded(class_numbers=self.class_numbers,
244 |                                num_classes=self.num_classes)
245 | 
246 |     def get_test_set(self):
247 |         """
248 |         Return the list of paths for the files in the test-set,
249 |         and the list of class-numbers as integers,
250 |         and the class-numbers as one-hot encoded arrays.
251 |         """
252 | 
253 |         return list(self.get_paths(test=True)), \
254 |                np.asarray(self.class_numbers_test), \
255 |                one_hot_encoded(class_numbers=self.class_numbers_test,
256 |                                num_classes=self.num_classes)
257 | 
258 |     def copy_files(self, train_dir, test_dir):
259 |         """
260 |         Copy all the files in the training-set to train_dir
261 |         and copy all the files in the test-set to test_dir.
262 | 
263 |         For example, the normal directory structure for the
264 |         different classes in the training-set is:
265 | 
266 |         knifey-spoony/forky/
267 |         knifey-spoony/knifey/
268 |         knifey-spoony/spoony/
269 | 
270 |         Normally the test-set is a sub-dir of the training-set:
271 | 
272 |         knifey-spoony/forky/test/
273 |         knifey-spoony/knifey/test/
274 |         knifey-spoony/spoony/test/
275 | 
276 |         But some APIs use another dir-structure for the training-set:
277 | 
278 |         knifey-spoony/train/forky/
279 |         knifey-spoony/train/knifey/
280 |         knifey-spoony/train/spoony/
281 | 
282 |         and for the test-set:
283 | 
284 |         knifey-spoony/test/forky/
285 |         knifey-spoony/test/knifey/
286 |         knifey-spoony/test/spoony/
287 | 
288 |         :param train_dir: Directory for the training-set e.g. 'knifey-spoony/train/'
289 |         :param test_dir: Directory for the test-set e.g. 'knifey-spoony/test/'
290 |         :return: Nothing.
291 |         """
292 | 
293 |         # Helper-function for actually copying the files.
294 |         def _copy_files(src_paths, dst_dir, class_numbers):
295 | 
296 |             # Create a list of dirs for each class, e.g.:
297 |             # ['knifey-spoony/test/forky/',
298 |             #  'knifey-spoony/test/knifey/',
299 |             #  'knifey-spoony/test/spoony/']
300 |             class_dirs = [os.path.join(dst_dir, class_name + "/")
301 |                           for class_name in self.class_names]
302 | 
303 |             # Check if each class-directory exists, otherwise create it.
304 |             for dir in class_dirs:
305 |                 if not os.path.exists(dir):
306 |                     os.makedirs(dir)
307 | 
308 |             # For all the file-paths and associated class-numbers,
309 |             # copy the file to the destination dir for that class.
310 |             for src, cls in zip(src_paths, class_numbers):
311 |                 shutil.copy(src=src, dst=class_dirs[cls])
312 | 
313 |         # Copy the files for the training-set.
314 |         _copy_files(src_paths=self.get_paths(test=False),
315 |                     dst_dir=train_dir,
316 |                     class_numbers=self.class_numbers)
317 | 
318 |         print("- Copied training-set to:", train_dir)
319 | 
320 |         # Copy the files for the test-set.
321 |         _copy_files(src_paths=self.get_paths(test=True),
322 |                     dst_dir=test_dir,
323 |                     class_numbers=self.class_numbers_test)
324 | 
325 |         print("- Copied test-set to:", test_dir)
326 | 
327 | 
328 | ########################################################################
329 | 
330 | 
331 | def load_cached(cache_path, in_dir):
332 |     """
333 |     Wrapper-function for creating a DataSet-object, which will be
334 |     loaded from a cache-file if it already exists, otherwise a new
335 |     object will be created and saved to the cache-file.
336 | 
337 |     This is useful if you need to ensure the ordering of the
338 |     filenames is consistent every time you load the data-set,
339 |     for example if you use the DataSet-object in combination
340 |     with Transfer Values saved to another cache-file, see e.g.
341 |     Tutorial #09 for an example of this.
342 | 
343 |     :param cache_path:
344 |         File-path for the cache-file.
345 | 
346 |     :param in_dir:
347 |         Root-dir for the files in the data-set.
348 |         This is an argument for the DataSet-init function.
349 | 
350 |     :return:
351 |         The DataSet-object.
352 |     """
353 | 
354 |     print("Creating dataset from the files in: " + in_dir)
355 | 
356 |     # If the object-instance for DataSet(in_dir=data_dir) already
357 |     # exists in the cache-file then reload it, otherwise create
358 |     # an object instance and save it to the cache-file for next time.
359 |     dataset = cache(cache_path=cache_path,
360 |                     fn=DataSet, in_dir=in_dir)
361 | 
362 |     return dataset
363 | 
364 | 
365 | ########################################################################


--------------------------------------------------------------------------------
/CIFAR-10/utils/download_CIFAR10.py:
--------------------------------------------------------------------------------
  1 | ########################################################################
  2 | #
  3 | # Functions for downloading and extracting data-files from the internet.
  4 | #
  5 | # Implemented in Python 3.5
  6 | #
  7 | ########################################################################
  8 | #
  9 | # This file is part of the TensorFlow Tutorials available at:
 10 | #
 11 | # https://github.com/Hvass-Labs/TensorFlow-Tutorials
 12 | #
 13 | # Published under the MIT License. See the file LICENSE for details.
 14 | #
 15 | # Copyright 2016 by Magnus Erik Hvass Pedersen
 16 | #
 17 | ########################################################################
 18 | 
 19 | import sys
 20 | import os
 21 | import urllib.request
 22 | import tarfile
 23 | import zipfile
 24 | 
 25 | ########################################################################
 26 | 
 27 | 
 28 | def _print_download_progress(count, block_size, total_size):
 29 |     """
 30 |     Function used for printing the download progress.
 31 |     Used as a call-back function in maybe_download_and_extract().
 32 |     """
 33 | 
 34 |     # Percentage completion.
 35 |     pct_complete = float(count * block_size) / total_size
 36 | 
 37 |     # Limit it because rounding errors may cause it to exceed 100%.
 38 |     pct_complete = min(1.0, pct_complete)
 39 | 
 40 |     # Status-message. Note the \r which means the line should overwrite itself.
 41 |     msg = "\r- Download progress: {0:.1%}".format(pct_complete)
 42 | 
 43 |     # Print it.
 44 |     sys.stdout.write(msg)
 45 |     sys.stdout.flush()
 46 | 
 47 | 
 48 | ########################################################################
 49 | 
 50 | def download(base_url, filename, download_dir):
 51 |     """
 52 |     Download the given file if it does not already exist in the download_dir.
 53 | 
 54 |     :param base_url: The internet URL without the filename.
 55 |     :param filename: The filename that will be added to the base_url.
 56 |     :param download_dir: Local directory for storing the file.
 57 |     :return: Nothing.
 58 |     """
 59 | 
 60 |     # Path for local file.
 61 |     save_path = os.path.join(download_dir, filename)
 62 | 
 63 |     # Check if the file already exists, otherwise we need to download it now.
 64 |     if not os.path.exists(save_path):
 65 |         # Check if the download directory exists, otherwise create it.
 66 |         if not os.path.exists(download_dir):
 67 |             os.makedirs(download_dir)
 68 | 
 69 |         print("Downloading", filename, "...")
 70 | 
 71 |         # Download the file from the internet.
 72 |         url = base_url + filename
 73 |         file_path, _ = urllib.request.urlretrieve(url=url,
 74 |                                                   filename=save_path,
 75 |                                                   reporthook=_print_download_progress)
 76 | 
 77 |         print(" Done!")
 78 | 
 79 | 
 80 | def maybe_download_and_extract(url, download_dir):
 81 |     """
 82 |     Download and extract the data if it doesn't already exist.
 83 |     Assumes the url is a tar-ball file.
 84 | 
 85 |     :param url:
 86 |         Internet URL for the tar-file to download.
 87 |         Example: "https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz"
 88 | 
 89 |     :param download_dir:
 90 |         Directory where the downloaded file is saved.
 91 |         Example: "data/CIFAR-10/"
 92 | 
 93 |     :return:
 94 |         Nothing.
 95 |     """
 96 | 
 97 |     # Filename for saving the file downloaded from the internet.
 98 |     # Use the filename from the URL and add it to the download_dir.
 99 |     filename = url.split('/')[-1]
100 |     file_path = os.path.join(download_dir, filename)
101 | 
102 |     # Check if the file already exists.
103 |     # If it exists then we assume it has also been extracted,
104 |     # otherwise we need to download and extract it now.
105 |     if not os.path.exists(file_path):
106 |         # Check if the download directory exists, otherwise create it.
107 |         if not os.path.exists(download_dir):
108 |             os.makedirs(download_dir)
109 | 
110 |         # Download the file from the internet.
111 |         file_path, _ = urllib.request.urlretrieve(url=url,
112 |                                                   filename=file_path,
113 |                                                   reporthook=_print_download_progress)
114 | 
115 |         print()
116 |         print("Download finished. Extracting files.")
117 | 
118 |         if file_path.endswith(".zip"):
119 |             # Unpack the zip-file.
120 |             zipfile.ZipFile(file=file_path, mode="r").extractall(download_dir)
121 |         elif file_path.endswith((".tar.gz", ".tgz")):
122 |             # Unpack the tar-ball.
123 |             tarfile.open(name=file_path, mode="r:gz").extractall(download_dir)
124 | 
125 |         print("Done.")
126 |     else:
127 |         print("Data has apparently already been downloaded and unpacked.")
128 | 
129 | 
130 | ########################################################################


--------------------------------------------------------------------------------
/CIFAR-10/utils/model.py:
--------------------------------------------------------------------------------
 1 | import torch
 2 | import torch.nn as nn
 3 | import torch.nn.functional as F
 4 | from utils.stn import STN
 5 | 
 6 | class CNN_classifier(nn.Module):
 7 |     """ MNIST Encoder from Original Paper's Keras based Implementation.
 8 |         Args:
 9 |             init_num_filters (int): initial number of filters from encoder image channels
10 |             lrelu_slope (float): positive number indicating LeakyReLU negative slope
11 |             inter_fc_dim (int): intermediate fully connected dimensionality prior to embedding layer
12 |             embedding_dim (int): embedding dimensionality
13 |     """
14 |     def __init__(self, init_num_filters=32, lrelu_slope=0.2, inter_fc_dim=128, nofclasses=10,nofchannels=3,use_stn=True):
15 |         super(CNN_classifier, self).__init__()
16 |         self.use_stn=use_stn
17 |         self.init_num_filters_ = init_num_filters
18 |         self.lrelu_slope_ = lrelu_slope
19 |         self.inter_fc_dim_ = inter_fc_dim
20 |         self.nofclasses_ = nofclasses
21 |         if self.use_stn:
22 |             self.stn = STN()
23 | 
24 |         self.features = nn.Sequential(
25 |             nn.Conv2d(nofchannels, self.init_num_filters_ * 1, kernel_size=5,padding=2),
26 |             nn.BatchNorm2d(self.init_num_filters_ * 1),
27 |             nn.ReLU(True),
28 | 
29 |             nn.Conv2d(self.init_num_filters_ * 1, self.init_num_filters_ * 1, kernel_size=5,padding=2),
30 |             nn.BatchNorm2d(self.init_num_filters_ * 1),
31 |             nn.ReLU(True),
32 | 
33 |             nn.MaxPool2d(2,2),
34 | 
35 |             nn.Conv2d(self.init_num_filters_ * 1, self.init_num_filters_ * 1, kernel_size=5,padding=2),
36 |             nn.BatchNorm2d(self.init_num_filters_ * 1),
37 |             nn.ReLU(True),
38 | 
39 |             nn.Conv2d(self.init_num_filters_ * 1, self.init_num_filters_ * 1, kernel_size=5,padding=2),
40 |             nn.BatchNorm2d(self.init_num_filters_ * 1),
41 |             nn.ReLU(True),
42 | 
43 |             nn.MaxPool2d(2,2),
44 | 
45 |             nn.Conv2d(self.init_num_filters_ * 1, self.init_num_filters_ * 1, kernel_size=5,padding=2),
46 |             nn.BatchNorm2d(self.init_num_filters_ * 1),
47 |             nn.ReLU(True),
48 | 
49 |             nn.Conv2d(self.init_num_filters_ * 1, self.init_num_filters_ * 1, kernel_size=5,padding=2),
50 |             nn.BatchNorm2d(self.init_num_filters_ * 1),
51 |             nn.ReLU(True),
52 | 
53 |             nn.MaxPool2d(2,2),
54 |         )
55 | 
56 |         self.fc = nn.Sequential(
57 |             nn.Linear(self.init_num_filters_ *4*4, self.inter_fc_dim_),
58 |             nn.BatchNorm1d(self.inter_fc_dim_),
59 |             nn.ReLU(True),
60 |             nn.Dropout(p=.2),
61 | 
62 |             nn.Linear(self.inter_fc_dim_, int(self.inter_fc_dim_/2)),
63 |             nn.BatchNorm1d(int(self.inter_fc_dim_/2)),
64 |             nn.ReLU(True),
65 |             nn.Dropout(p=.2),
66 | 
67 |             nn.Linear(int(self.inter_fc_dim_/2), self.nofclasses_)
68 |         )
69 | 
70 |     def forward(self, x):
71 |         if self.use_stn:
72 |             x = self.stn(x)
73 |         x = self.features(x)
74 | #         print(x.shape)
75 |         x = x.view(-1, self.init_num_filters_ *4*4)
76 |         x = self.fc(x)
77 |         return x
78 | 


--------------------------------------------------------------------------------
/CIFAR-10/utils/stn.py:
--------------------------------------------------------------------------------
 1 | import torch
 2 | import torch.nn as nn
 3 | import torch.nn.functional as F
 4 | 
 5 | class STN(nn.Module):
 6 |     def __init__(self,nofchannels=3):
 7 |         super(STN,self).__init__()         
 8 |         self.nofchannels=nofchannels
 9 |         self.localization= nn.Sequential(nn.Conv2d(3,16,kernel_size=7),
10 |                            nn.MaxPool2d(2,stride=2),
11 |                            nn.ReLU(True), 
12 |                            nn.Conv2d(16,32,kernel_size=5),
13 |                            nn.MaxPool2d(2,stride=2),
14 |                            nn.ReLU(True),
15 |                            nn.Conv2d(32,64,kernel_size=3),
16 |                            nn.MaxPool2d(2,stride=2),
17 |                            nn.ReLU(True))
18 |         
19 |         self.fc_loc=  nn.Sequential(nn.Linear(64,128),
20 |                       nn.ReLU(True),
21 |                       nn.Linear(128,64),
22 |                       nn.ReLU(True),
23 |                       nn.Linear(64,6))
24 |         self.fc_loc[-1].weight.data.zero_()
25 |         self.fc_loc[-1].bias.data.copy_(torch.tensor([1,0,0,0,1,0]))
26 | 
27 |         
28 |     def forward(self,x):
29 |         xs=self.localization(x)
30 |         xs=xs.view(-1,64)
31 |         theta=self.fc_loc(xs)
32 |         theta=theta.view(-1,2,3)
33 |         grid=F.affine_grid(theta,x.size())
34 |         x=F.grid_sample(x,grid)
35 |         return x


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 UMBC Vision
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Universal Litmus Patterns: Revealing Backdoor Attacks in CNNs
  2 | 
  3 | <p align="center">
  4 |   <img width="750" src=https://github.com/UMBCvision/Universal-Litmus-Patterns/blob/master/docs/assets/images/teaser.png>
  5 | </p>
  6 | 
  7 | ### Abstract
  8 | The unprecedented success of deep neural networks in many applications has made these networks a prime target for adversarial exploitation. In this paper, we introduce
  9 | a benchmark technique for detecting backdoor attacks (aka Trojan attacks) on deep convolutional neural networks (CNNs). We introduce the concept of Universal Litmus Patterns
 10 | (ULPs), which enable one to reveal backdoor attacks by feeding these universal patterns to the network and analyzing the output (i.e., classifying the network as ‘clean’
 11 | or ‘corrupted’). This detection is fast because it requires only a few forward passes through a CNN. We demonstrate the effectiveness of ULPs for detecting backdoor attacks on
 12 | thousands of networks with different architectures trained on four benchmark datasets, namely the German Traffic Sign Recognition Benchmark (GTSRB), MNIST, CIFAR10,
 13 | and Tiny-ImageNet.
 14 | 
 15 | ### Paper
 16 | [https://arxiv.org/abs/1906.10842][paper]
 17 | 
 18 | ### Requirements
 19 | The code was tested using pytorch 1.4.0, python 3.7.
 20 | 
 21 | ### CIFAR-10
 22 | 
 23 | #### Generate poisoned data
 24 | 
 25 | To generate the poisoned data to be used in the experiments run
 26 | ```python
 27 | python generate_poison.py
 28 | ```
 29 | 
 30 | This script adds the triggers from ./Data/Masks to the images to generate poisoned data. Please generate one set of images for each poisoned model you want to train.
 31 | We use poisoned models for 10 triggers for training ULPs and poisoned models for the other 10 to test. 
 32 | This ensures that the train and test poisoned models use a different set of triggers.
 33 | 
 34 | We have made the poisoned data generated for our paper available along with the models.
 35 | 
 36 | #### Train models
 37 | 
 38 | We use a modified VGG architecture for our experiments.
 39 | To train clean models use
 40 | ```python
 41 | python train_clean_model.py <partition-num> <logfile>
 42 | ```
 43 | 
 44 | To train poisoned models use
 45 | ```python
 46 | python train_poisoned_model.py <partition-num> <logfile>
 47 | ```
 48 | 
 49 | For training ULPs: Train 500 clean models and 500 poisoned models.
 50 | For evaluating ULPs: Train 100 clean models and 100 poisoned models.
 51 | 
 52 | Currently each partition trains 100 models. Modify this according to your needs if you have multiple GPUs to train in parallel.
 53 | 
 54 | To save time, you can also use our trained models available [here](https://drive.google.com/drive/folders/1ye2KCRfzhbjtV3TMSRR5vlSBlvqNUqYL?usp=sharing):
 55 | + extract clean_models_trainval.zip and save in ./clean_models/trainval
 56 | + extract poisoned_models_trainval.zip and save in ./poisoned_models/trainval
 57 | + extract clean_models_test.zip and save in ./clean_models/test
 58 | + extract poisoned_models_test.zip and save in ./poisoned_models/test
 59 | 
 60 | #### Train ULPs
 61 | 
 62 | Once the models are generated, run
 63 | ```python
 64 | python train_ULP.py <num_ULPs> <logfile> 
 65 | ```
 66 | 
 67 | Provide appropriate number of ULPs. We run experiments for 1, 5 and 10 patterns.
 68 | This will save the results, i.e ULPs and our classifier in ./results
 69 | 
 70 | #### Evaluate ULPs and Noise Patterns
 71 | 
 72 | To evaluate ULPs run
 73 | ```python
 74 | python evaluate_ULP.py 
 75 | ```
 76 | To evaluate Noise patterns run
 77 | ```python
 78 | python evaluate_noise.py
 79 | ```
 80 | 
 81 | #### Plot ROC curves
 82 | 
 83 | ```python
 84 | python plot_ROC_curves.py
 85 | ```
 86 | 
 87 | ### Tiny-ImageNet
 88 | 
 89 | #### Download data
 90 | 
 91 | Download data from the [Tiny ImageNet Visual Recognition Challenge](tiny-imagenet.herokuapp.com)
 92 | Please replace all occurrences of <tiny-imagenet-root> with the appropriate path.
 93 | 
 94 | #### Data cleaning
 95 | 
 96 | The organization of Tiny ImageNet differs from standard ImageNet. This scripts cleans the data.
 97 | ```python
 98 | python data_cleaning.py
 99 | ```
100 | 
101 | #### Generate poisoned data
102 | 
103 | To generate the poisoned data to be used in the experiments run
104 | ```python
105 | python convert_data.py
106 | python generate_poison.py
107 | ```
108 | 
109 | The first script converts the images into a numpy array and stores them in ./data for faster generation of poisons.
110 | The second script adds the triggers from ./triggers to the images to generate poisoned data. Please generate one set of images for each poisoned model you want to train.
111 | We use poisoned models for Triggers 01-10 for training ULPs and poisoned models for Triggers 11-20 to test. 
112 | This ensures that the train and test poisoned models use a different set of triggers.
113 | 
114 | We have made the poisoned data generated for our paper available along with the models.
115 | 
116 | #### Train models
117 | 
118 | We use a modified Resnet architecture for our experiments.
119 | To train clean models use
120 | ```python
121 | python train_clean_model.py <partition-num> <logfile>
122 | ```
123 | 
124 | To train poisoned models use
125 | ```python
126 | python train_poisoned_model.py <partition-num> <logfile>
127 | ```
128 | 
129 | For training ULPs: Train 1000 clean models and 1000 poisoned models on triggers 01-10.
130 | For testing ULPs: Train 100 clean models and 100 poisoned models on triggers 11-20.
131 | 
132 | Currently each partition trains 50 models. Modify this according to your needs if you have multiple GPUs to train in parallel.
133 | 
134 | To save time, you can also use our trained models available [here](https://drive.google.com/drive/folders/1shYf6mUn81p0ve1DQBFhxjE_B9JN1yKt?usp=sharing):
135 | + extract Clean models train and save in ./clean_models/train
136 | + extract Poisoned models train and save in ./poisoned_models/Triggers_01_10
137 | + extract Clean models val and save in ./clean_models/val
138 | + extract Poisoned models val and save in ./poisoned_models/Triggers_11_20
139 | 
140 | #### Train ULPs
141 | 
142 | Once the models are generated, run
143 | ```python
144 | python train_ULP.py <num_ULPs> <logfile> 
145 | ```
146 | 
147 | Provide appropriate number of ULPs. We run experiments for 1, 5 and 10 patterns.
148 | This will save the results, i.e ULPs and our classifier in ./results
149 | 
150 | #### Evaluate ULPs and Noise Patterns
151 | 
152 | To evaluate ULPs run
153 | ```python
154 | python evaluate_ULP.py 
155 | ```
156 | To evaluate Noise patterns run
157 | ```python
158 | python evaluate_noise.py
159 | ```
160 | 
161 | ##### Plot ROC curves
162 | 
163 | ```python
164 | python plot_ROC_curves.py
165 | ```
166 | ### Citation
167 | If you find our paper, code or models useful, please cite us using
168 | ```bib
169 | @inproceedings{kolouri2020universal,
170 |   title={Universal Litmus Patterns: Revealing Backdoor Attacks in CNNs},
171 |   author={Kolouri, Soheil and Saha, Aniruddha and Pirsiavash, Hamed and Hoffmann, Heiko},
172 |   booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
173 |   pages={301--310},
174 |   year={2020}
175 | }
176 | ```
177 | 
178 | ### Acknowledgement
179 | This work was performed under the following financial assistance award: 60NANB18D279 from U.S. Department of Commerce, National Institute of Standards and Technology, funding from SAP SE, and also NSF grant 1845216.
180 | 
181 | ### Questions/Issues
182 | Please create an issue on the Github Repo directly or contact [anisaha1@umbc.edu][email] for any questions about the code.
183 | 
184 | [paper]: https://arxiv.org/abs/1906.10842
185 | [email]: mailto:anisaha1@umbc.edu
186 | 


--------------------------------------------------------------------------------
/docs/.gitignore:
--------------------------------------------------------------------------------
1 | _site
2 | .sass-cache
3 | 
4 | # jekyll
5 | .jekyll-metadata
6 | Gemfile
7 | Gemfile.lock
8 | 


--------------------------------------------------------------------------------
/docs/README.md:
--------------------------------------------------------------------------------
1 | # Universal Litmus Patterns Webpage
2 | 


--------------------------------------------------------------------------------
/docs/__deploy.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | 
3 | # Upload to server
4 | # scp -r _site/* msaveski@ml.media.mit.edu:public_html/
5 | 
6 | 


--------------------------------------------------------------------------------
/docs/_config.yml:
--------------------------------------------------------------------------------
1 | source:      .
2 | destination: ./_site
3 | includes:    ./_includes
4 | 
5 | collections:
6 |   projects:
7 |     output: true
8 | theme: jekyll-theme-minimal


--------------------------------------------------------------------------------
/docs/_data/experience.yaml:
--------------------------------------------------------------------------------
 1 | experiences:
 2 | 
 3 | - place: "Matroid"
 4 |   time: "Summer 2019"
 5 |   title: "Machine Learning Intern"
 6 |   subtitle: "Advised by Reza Zadeh & Danny Jeck"
 7 |   category: "internship"
 8 | 
 9 | - place: "UMBC"
10 |   time: "2017 - Now"
11 |   title: "Ph.D. Computer Science"
12 |   subtitle: "Advised by Hamed Pirsiavash "
13 |   category: "school"
14 | 
15 | - place: "Samsung Research Institute Bangalore"
16 |   time: "2016 - 2017"
17 |   title: "Software Engineer"
18 |   subtitle: "DRAM Team, Memory Solutions, Samsung Semiconductor India R&D (SSIR)"
19 |   category: "work"
20 | 
21 | - place: "IIT Delhi"
22 |   time: "Summer 2015"
23 |   title: "Research Intern"
24 |   subtitle: "Generating Automated Comparisons for Entities. Mentors;Parag Singla & Danish Contractor" 
25 |   category: "intership"
26 | 
27 | - place: "IIT Kharagpur"
28 |   time: "Summer 2014"
29 |   title: "Intern"
30 |   subtitle: "Feature Extraction And Data Mining From Climate Data. Mentor: Sudeshna Sarkar"
31 |   category: "internship"
32 | 
33 | - place: "Jadavpur University"
34 |   time: "2012 - 2016"
35 |   title: "Undergraduate"
36 |   subtitle: "BE Computer Science and Engineering"
37 |   category: "school"
38 | 
39 | - place: "IISc Bangalore"
40 |   time: "November 2011"
41 |   title: "Vijyoshi Camp"
42 |   subtitle: 
43 |   category: "camp"
44 | 
45 | - place: "IISER Pune"
46 |   time: "May 2011"
47 |   title: "KVPY Summer Camp"
48 |   subtitle: ""
49 |   category: "camp"
50 | 


--------------------------------------------------------------------------------
/docs/_data/main_info.yaml:
--------------------------------------------------------------------------------
1 | name: "Universal Litmus Patterns"
2 | profile_pic: "/assets/profile-pics/architecture_teaser.png"
3 | # google_analytics_tracking_id: 'UA-47613584-4'
4 | 


--------------------------------------------------------------------------------
/docs/_data/publications.yaml:
--------------------------------------------------------------------------------
 1 | papers:
 2 | 
 3 |   - title: "Hidden Trigger Backdoor Attacks"
 4 |     authors: "Aniruddha Saha, Akshayvarun Subramanya, Hamed Pirsiavash"
 5 |     venue: "AAAI 2020 Oral"
 6 |     paper_pdf: "https://arxiv.org/pdf/1910.00033.pdf"
 7 |     code: "https://github.com/UMBCvision/Hidden-Trigger-Backdoor-Attacks"
 8 |     slides: "/assets/publications/Oral_AAAI2020.pdf"
 9 |     poster: "/assets/publications/Poster_AAAI2020.pdf"
10 |     cv: y
11 | 
12 |   - title: "Adversarial Patches Exploiting Contextual Reasoning in Object Detection"
13 |     authors: "Aniruddha Saha, Akshayvarun Subramanya, Koninika Patil, Hamed Pirsiavash"
14 |     venue: "Preprint"
15 |     paper_pdf: "https://arxiv.org/pdf/1910.00068.pdf"
16 |     cv: y
17 | 
18 |   - title: "Universal Litmus Patterns: Revealing Backdoor Attacks in CNNs"
19 |     authors: "Soheil Kolouri, Aniruddha Saha, Hamed Pirsiavash, Heiko Hoffmann"
20 |     venue: "Preprint"
21 |     paper_pdf: "https://arxiv.org/pdf/1906.10842.pdf"
22 |     cv: y
23 | 
24 |   - title: "An Adaptive Foreground-Background Separation Method for Effective Binarization of Document Images"
25 |     authors: "Bishwadeep Das, Showmik Bhowmik, Aniruddha Saha, Ram Sarkar"
26 |     venue: "Proceedings of the Eighth International Conference on Soft Computing and Pattern Recognition (SoCPaR 2016)"
27 |     paper_pdf: "/assets/publications/SoCPaR_2016_paper_100.pdf"
28 |     cv: y
29 | 
30 | 
31 | 
32 | 
33 | 
34 | 
35 | 
36 | 
37 | 


--------------------------------------------------------------------------------
/docs/_includes/google_analytics.html:
--------------------------------------------------------------------------------
 1 | <!-- <script>
 2 |   (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
 3 |   (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
 4 |   m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
 5 |   })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
 6 | 
 7 |   ga('create', '{{ site.data.main_info.google_analystics_tracking_id }}', 'auto');
 8 |   ga('send', 'pageview');
 9 | 
10 | </script> -->


--------------------------------------------------------------------------------
/docs/_includes/image_with_caption.html:
--------------------------------------------------------------------------------
1 | <figure class="image">
2 |   <img src="{{ include.url | prepend: site.baseurl }}" alt="{{ include.description }}" style="width: {{ include.width }}"/>
3 |   <figcaption><b>{{ include.description }}</b></figcaption>
4 | </figure>


--------------------------------------------------------------------------------
/docs/_layouts/default.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 | 
  5 |   <!-- Basic Page Needs
  6 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
  7 |   <meta charset="utf-8">
  8 |   <title>{{ site.data.main_info.name }} | {{ page.title }}</title>
  9 |   <meta name="description" content="Universal Litmus Patterns">
 10 |   <meta name="author" content="Aniruddha Saha">
 11 | 
 12 |   <!-- Mobile Specific Metas
 13 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
 14 |   <meta name="viewport" content="width=device-width, initial-scale=1">
 15 | 
 16 |   <!-- FONT
 17 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
 18 |   <link href='https://fonts.googleapis.com/css?family=Raleway:400,300,600' rel='stylesheet' type='text/css'>
 19 | 
 20 |   <!-- CSS
 21 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
 22 |   <link rel="stylesheet" href={{ "/libs/external/skeleton/normalize.css" | prepend: site.baseurl }}>
 23 |   <link rel="stylesheet" href={{ "/libs/external/skeleton/skeleton.css" | prepend: site.baseurl }}>
 24 |   <link rel="stylesheet" href={{ "/libs/custom/my_css.css" | prepend: site.baseurl }}>
 25 | 
 26 |   <!-- JQuery
 27 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
 28 |   <script src={{ "/libs/external/jquery-3.1.1.min.js" | prepend: site.baseurl }}></script>
 29 | 
 30 |   <!-- Font-Awesome
 31 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
 32 |   <link rel="stylesheet" href={{ "/libs/external/font-awesome-4.7.0/css/font-awesome.min.css" | prepend: site.baseurl }}>
 33 | 
 34 |   <!-- Skeleton tabs
 35 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
 36 |   <link rel="stylesheet" href={{ "/libs/external/skeleton_tabs/skeleton-tabs.css" | prepend: site.baseurl }}>
 37 |   <script src={{ "/libs/external/skeleton_tabs/skeleton-tabs.js" | prepend: site.baseurl }}></script>
 38 | 
 39 |   <!-- Timeline
 40 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
 41 |   <link rel="stylesheet" href={{ "/libs/external/timeline.css" | prepend: site.baseurl }}>
 42 | 
 43 |   <!-- Scripts
 44 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
 45 |   <!--<link rel="stylesheet" href={{ "/libs/external/github-prettify-theme.css" | prepend: site.baseurl }}>-->
 46 |   <script src={{ "/libs/custom/my_js.js" | prepend: site.baseurl }}></script>
 47 | 
 48 |   <!-- Favicon
 49 |        –––––––––––––––––––––––––––––––––––––––––––––––––– -->
 50 |   <!--
 51 |   <link rel="icon" type="image/png" href={{ "/libs/icon.png" | prepend: site.baseurl }}>
 52 |   <link rel="shortcut icon" type="image/png" href={{ "/libs/icon.png" | prepend: site.baseurl }}>
 53 |   -->
 54 | 
 55 | </head>
 56 | <body>
 57 | 
 58 |   <!-- Primary Page Layout
 59 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
 60 |   <div class="container">
 61 | 
 62 |     <section class="header">
 63 |         <div style="height:10px;">
 64 |             <p style="text-align:center;"><h4 style="text-align:center"><b>Universal Litmus Patterns:</b></h4></p>
 65 |         </div>
 66 |         <div style="height:10px;">
 67 |             <p style="text-align:center;"><h4 style="text-align:center"><b>Revealing Backdoor Attacks in CNNs</b></h4></p>
 68 |         </div>
 69 |     </section>
 70 | 
 71 |     {{content}}
 72 | 
 73 |     <div class="footer">
 74 |       <div class="row">
 75 |         <div class=".col-md-offset-3">
 76 |           {{ site.data.main_info.name }}
 77 |         </div>
 78 |         <!-- <div class="four columns">
 79 |           {{ site.data.main_info.email }}
 80 |         </div>
 81 |         <div class="four columns">
 82 |           <span onclick="window.open('{{ site.data.main_info.twitter }}')" style="cursor: pointer">
 83 |             <i class="fa fa-twitter" aria-hidden="true"></i>
 84 |           </span>
 85 |           <span onclick="window.open('{{ site.data.main_info.linkedin }}')" style="cursor: pointer">
 86 |             <i class="fa fa-linkedin-square" aria-hidden="true"></i>
 87 |           </span>
 88 |           <span onclick="window.open('{{ site.data.main_info.github }}')" style="cursor: pointer">
 89 |             <i class="fa fa-github" aria-hidden="true"></i>
 90 |           </span>
 91 |         </div> -->
 92 |       </div>
 93 |     </div>
 94 | 
 95 |   </div>
 96 | 
 97 |   <!-- Google Analytics -->
 98 |   {% include google_analytics.html %}
 99 | 
100 |   <!-- End Document
101 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
102 | </body>
103 | </html>
104 | 


--------------------------------------------------------------------------------
/docs/_layouts/post.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 | 
 5 |   <!-- Basic Page Needs
 6 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
 7 |   <meta charset="utf-8">
 8 |   <title>{{ site.data.main_info.name }} | {{ page.title }}</title>
 9 |   <meta name="description" content="Universal Litmus Patterns">
10 |   <meta name="author" content="Aniruddha Saha">
11 | 
12 |   <!-- Mobile Specific Metas
13 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
14 |   <meta name="viewport" content="width=device-width, initial-scale=1">
15 | 
16 |   <!-- FONT
17 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
18 |   <link href='https://fonts.googleapis.com/css?family=Raleway:400,300,600' rel='stylesheet' type='text/css'>
19 | 
20 |   <!-- CSS
21 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
22 |   <link rel="stylesheet" href={{ "/libs/external/skeleton/normalize.css" | prepend: site.baseurl }}>
23 |   <link rel="stylesheet" href={{ "/libs/external/skeleton/skeleton.css" | prepend: site.baseurl }}>
24 |   <link rel="stylesheet" href={{ "/libs/custom/my_css.css" | prepend: site.baseurl }}>
25 | 
26 |   <!-- JQuery
27 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
28 |   <script src={{ "/libs/external/jquery-3.1.1.min.js" | prepend: site.baseurl }}></script>
29 | 
30 |   <!-- Font-Awesome
31 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
32 |   <link rel="stylesheet" href={{ "/libs/external/font-awesome-4.7.0/css/font-awesome.min.css" | prepend: site.baseurl }}>
33 | 
34 |   <!-- Skeleton tabs
35 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
36 |   <link rel="stylesheet" href={{ "/libs/external/skeleton_tabs/skeleton-tabs.css" | prepend: site.baseurl }}>
37 |   <script src={{ "/libs/external/skeleton_tabs/skeleton-tabs.js" | prepend: site.baseurl }}></script>
38 | 
39 |   <!-- Timeline
40 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
41 |   <link rel="stylesheet" href={{ "/libs/external/timeline.css" | prepend: site.baseurl }}>
42 | 
43 |   <!-- Scripts
44 |   –––––––––––––––––––––––––––––––––––––––––––––––––– -->
45 |   <!--<link rel="stylesheet" href={{ "/libs/external/github-prettify-theme.css" | prepend: site.baseurl }}>-->
46 |   <script src={{ "/libs/custom/my_js.js" | prepend: site.baseurl }}></script>
47 | 
48 |   <!-- Favicon
49 |        –––––––––––––––––––––––––––––––––––––––––––––––––– -->
50 |   <!--
51 |   <link rel="icon" type="image/png" href={{ "/libs/icon.png" | prepend: site.baseurl }}>
52 |   <link rel="shortcut icon" type="image/png" href={{ "/libs/icon.png" | prepend: site.baseurl }}>
53 |   -->
54 | 
55 | </head>
56 | <body>
57 |     <div class="wrapper-masthead">
58 |       <div class="container">
59 |         <header class="masthead clearfix">
60 |           <a href="{{ site.baseurl }}/" class="site-avatar"><img src="{{ site.avatar }}" /></a>
61 | 
62 |           <div class="site-info">
63 |             <h1 class="site-name"><a href="{{ site.baseurl }}/">{{ site.name | markdownify }}</a></h1>
64 |             <p class="site-description">{{ site.description | markdownify }}</p>
65 |           </div>
66 | 
67 |           <nav>
68 |             <a href="{{ site.baseurl }}/">Home</a>
69 |             <!-- <a href="{{ site.baseurl }}/archive">Date</a>
70 |             <a href="{{ site.baseurl }}/tags">Tag</a>
71 |             <a href="{{ site.baseurl }}/about">About</a> -->
72 |           </nav>
73 |         </header>
74 |       </div>
75 |     </div>
76 | 
77 |     <div id="main" role="main" class="container">
78 |     <h3><a href="{{ site.baseurl }}{{ page.url }}">{{ page.title | markdownify }}</a></h3>
79 |       {{ content }}
80 |     <div class="date">
81 |     Posted {{ page.date | date: "%Y-%m-%d" }}
82 |     </div>
83 | 
84 |     </div>
85 | 
86 | </body>
87 | </html>
88 | 


--------------------------------------------------------------------------------
/docs/_layouts/project.html:
--------------------------------------------------------------------------------
 1 | ---
 2 | layout: default
 3 | ---
 4 | <div class="docs-section">
 5 | 
 6 |   {% if page.subtitle == "" or page.subtitle == nil %}
 7 |   	<h3>{{ page.title }}</h3>
 8 |   {% else %}
 9 |     <div class="title-subtitle">
10 |       <h3>{{ page.title }}</h3>
11 |       <h5>{{ page.subtitle }}</h5>
12 |     </div>
13 |   {% endif %}
14 | 
15 |   {{ content }}
16 | 
17 | </div>


--------------------------------------------------------------------------------
/docs/_posts/2019-08-04-first-post.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | layout: post
 3 | author: aniruddha
 4 | title: First Post
 5 | date: 2019-08-04
 6 | tags: [first]
 7 | ---
 8 | 
 9 | A personal website has been long overdue. A few days ago I pushed myself to create this website. I borrowed a publicly available template and made some changes and put it up on Github.
10 | 
11 | Today, I tried adding posts to the website and I am writing my first post now. In the process, I learnt a bit of Jekyll and Markdown. Going forward, I plan to write about my research in this space. 
12 | 
13 | 


--------------------------------------------------------------------------------
/docs/assets/images/ULPs.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/docs/assets/images/ULPs.png


--------------------------------------------------------------------------------
/docs/assets/images/ULPs_TinyImageNet.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/docs/assets/images/ULPs_TinyImageNet.png


--------------------------------------------------------------------------------
/docs/assets/images/results_GTSRB.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/docs/assets/images/results_GTSRB.png


--------------------------------------------------------------------------------
/docs/assets/images/results_generalizability.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/docs/assets/images/results_generalizability.png


--------------------------------------------------------------------------------
/docs/assets/images/results_table.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/docs/assets/images/results_table.png


--------------------------------------------------------------------------------
/docs/assets/images/teaser.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/docs/assets/images/teaser.png


--------------------------------------------------------------------------------
/docs/assets/images/threat_model.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/docs/assets/images/threat_model.png


--------------------------------------------------------------------------------
/docs/assets/publications/Oral_AAAI2020.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/docs/assets/publications/Oral_AAAI2020.pdf


--------------------------------------------------------------------------------
/docs/assets/publications/Poster_AAAI2020.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/docs/assets/publications/Poster_AAAI2020.pdf


--------------------------------------------------------------------------------
/docs/assets/publications/SoCPaR_2016_paper_100.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/docs/assets/publications/SoCPaR_2016_paper_100.pdf


--------------------------------------------------------------------------------
/docs/index.html:
--------------------------------------------------------------------------------
 1 | ---
 2 | layout: default
 3 | title: Universal Litmus Patterns
 4 | ---
 5 | 
 6 | <div style="height:25px;">
 7 | <p style="text-align:center;"><a href="https://skolouri.github.io/">Soheil Kolouri</a><sup>1,∗</sup>, <a href="https://ani0075.github.io/">Aniruddha Saha</a><sup>2,∗</sup>, <a href="https://www.csee.umbc.edu/~hpirsiav/">Hamed Pirsiavash</a><sup>2,†</sup>, <a href="http://www.heikohoffmann.de/background.html">Heiko Hoffmann</a><sup>1,†</sup></p>
 8 | </div>
 9 | <div style="height:20px;">
10 | <p style="text-align:center;">1: HRL Laboratories, LLC</p>
11 | </div>
12 | <div style="height:25px;">
13 | <p style="text-align:center;">2: University of Maryland, Baltimore County</p>
14 | </div>
15 | <div style="height:30px;">
16 | <p style="text-align:center; font-size:12px"><sup>∗</sup> and <sup>†</sup> denote equal contribution</p>
17 | </div>
18 | <div style="height:30px;">
19 | <br>
20 | 
21 | <p style="text-align:center;"><img src="{{ site.baseurl }}/assets/images/teaser.png" width="750" alt style></p>
22 | 
23 | <h5 id="abstract"><b>Abstract</b></h5>
24 | <p>The unprecedented success of deep neural networks in many applications has made these networks a prime target for adversarial exploitation. In this paper, we introduce
25 |     a benchmark technique for detecting backdoor attacks (aka Trojan attacks) on deep convolutional neural networks (CNNs). We introduce the concept of Universal Litmus Patterns
26 |     (ULPs), which enable one to reveal backdoor attacks by feeding these universal patterns to the network and analyzing the output (i.e., classifying the network as ‘clean’
27 |     or ‘corrupted’). This detection is fast because it requires only a few forward passes through a CNN. We demonstrate the effectiveness of ULPs for detecting backdoor attacks on
28 |     thousands of networks with different architectures trained on four benchmark datasets, namely the German Traffic Sign Recognition Benchmark (GTSRB), MNIST, CIFAR10,
29 |     and Tiny-ImageNet.</p>
30 | 
31 | <h5 id="paper"><b>Paper</b></h5>
32 | <p><a href="https://arxiv.org/abs/1906.10842">https://arxiv.org/abs/1906.10842</a></p>
33 | <h5 id="code"><b>Code</b></h5>
34 | <p><a href="https://github.com/UMBCvision/Universal-Litmus-Patterns">https://github.com/UMBCvision/Universal-Litmus-Patterns</a></p>
35 | 
36 | <h5 id="contributions"><b>Contributions</b></h5>
37 | <p>We introduce a fast benchmark technique for detecting backdoor attacks (aka Trojan attacks) on CNNs.</p>
38 | 
39 | <p>Universal Litmus Patterns (ULPs):
40 | <li>Are optimized input images for which the network’s output becomes a good indicator of whether the network is clean or poisoned (contains a backdoor).</li>
41 | <li>Are trained only on models and not images (train/test).</li>
42 | <li>Transfer across network architectures.</li>
43 | We provide hundreds of clean and poisoned models per dataset for Tiny-ImageNet, CIFAR10, MNIST, and German Traffic Sign Recognition Benchmark (GTSRB).</p>
44 | 
45 | <h5 id="threat_model"><b>Threat model</b></h5>
46 | <p>Each poisoned model is trained to contain a single trigger that causes images from the source class to be classified as the target class.
47 | We assume no prior knowledge of the targeted class or the triggers used by attackers.</p>
48 | 
49 | <p style="text-align:center;"><img src="{{ site.baseurl }}/assets/images/threat_model.png" width="750" alt style></p>
50 | 
51 | <h5 id="results"><b>Results</b></h5>
52 | <p>ULPs are fast for detection because each ULP requires just one forward pass through the network. Despite this simplicity, surprisingly, ULPs are
53 | competitive for detecting backdoor attacks, establishing a new performance baseline: area under the ROC curve close to 1 on both CIFAR10 and MNIST, 0.96 on GTSRB (for
54 | ResNet18), and 0.94 on Tiny-ImageNet. </p>
55 | <p>ULPs consistently outperform the baselines, Neural cleanse [1] and noise inputs (replace ULPs with random inputs), on all datasets with respect to AUCs,
56 | while being considerably faster than Neural cleanse (~90,000 times).</p>
57 | 
58 | <p style="text-align:center;"><img src="{{ site.baseurl }}/assets/images/results_table.png" width="750" alt style></p>
59 | 
60 | <p style="text-align:center;"><img src="{{ site.baseurl }}/assets/images/results_GTSRB.png" width="750" alt style></p>
61 | 
62 | <p>On GTSRB, ULPs trained on a specific architecture, e.g., VGG or ResNet, transfer well to similar architectures, i.e., random-VGGs and random-ResNets, where we trained models with a random depth and random number of convolutional kernels. ULPs have limited Transferability between different architectures, e.g., from VGG to ResNet and vice versa. </p>
63 | 
64 | <p style="text-align:center;"><img src="{{ site.baseurl }}/assets/images/results_generalizability.png" width="500" alt style></p>
65 | 
66 | The following figure shows the optimized ULPs calculated on the Tiny ImageNet Dataset.
67 | 
68 | 
69 | <p style="text-align:center;"><img src="{{ site.baseurl }}/assets/images/ULPs_TinyImageNet.png" width="400" alt style></p>
70 | 
71 | <h5 id="dataset"><b>ULP Dataset</b></h5>
72 |     <li><a href="https://drive.google.com/drive/folders/1ye2KCRfzhbjtV3TMSRR5vlSBlvqNUqYL?usp=sharing">CIFAR-10</a></li>
73 |     <li><a href="https://drive.google.com/drive/folders/1shYf6mUn81p0ve1DQBFhxjE_B9JN1yKt?usp=sharing">Tiny-ImageNet</a></li>
74 | 
75 | <h5 id="references"><b>References</b></h5>
76 | [1] Wang, B., Yao, Y., Shan, S., Li, H., Viswanath, B., Zheng, H., & Zhao, B. Y. (2019, May). Neural cleanse: Identifying and mitigating backdoor attacks in neural networks. In <i>2019 IEEE Symposium on Security and Privacy (SP)</i> (pp. 707-723). IEEE.
77 | 
78 | 


--------------------------------------------------------------------------------
/docs/libs/custom/my_css.css:
--------------------------------------------------------------------------------
  1 | h4 {
  2 |   letter-spacing: .1rem; }
  3 | .container {
  4 |   max-width: 900px; }
  5 | .header {
  6 |   margin-top: 60px;
  7 |   margin-bottom: 60px; 
  8 |   text-align: left; }
  9 | .main-description h1 {
 10 |   margin-bottom: 0px; }
 11 | .main-description p {
 12 |   margin-bottom: 0px; }
 13 | .main-description .fa {
 14 |   font-size: 22px;
 15 |   margin-top: 5px; }
 16 | .paper {
 17 |   margin-bottom: 20px }
 18 | .paper .title {
 19 |   /*text-transform: uppercase; */}
 20 | .paper p {
 21 |   margin-bottom: 2px }
 22 | .paper-buttons {
 23 |     margin-top: 2px }
 24 | .paper .button {
 25 |   display: inline-block;
 26 |   height: 20px;
 27 |   padding: 0 5px;
 28 |   font-weight: 100;
 29 |   line-height: 20px;
 30 |   margin-bottom: 0px;
 31 |   text-transform: none; }
 32 | .section-header {
 33 |   text-transform: uppercase;
 34 |   font-size: 1.5rem;
 35 |   letter-spacing: .2rem;
 36 |   font-weight: 600; }
 37 | .docs-section {
 38 |   border-top: 1px solid #eee;
 39 |   padding: 4rem 0;
 40 |   margin-bottom: 0;}
 41 | .footer {
 42 |   text-align: center;
 43 |   color: rgba(0, 0, 0, 0.4);
 44 |   border-top: 1px solid #eee;
 45 |   padding: 15px 0 40px 0;
 46 |   margin-bottom: 0;}
 47 | .navbar {
 48 |   display: none; }
 49 | .title-subtitle h3 {
 50 |   margin-bottom: 0px; }
 51 | .title-subtitle h5 {
 52 |   color: rgba(0, 0, 0, 0.60); }
 53 | .image {
 54 |   text-align: center; }
 55 | 
 56 | /*  ================ Project styling  ================ */
 57 | .project-container {
 58 |   margin-bottom: 30px;
 59 | }
 60 | .project-image-container {
 61 |   border: 1px solid rgba(0,0,0,0.2);
 62 |   padding: 3px;
 63 |   transition: 0.3s;
 64 | }
 65 | .project-image-container:hover {
 66 |   transition: 0.3s;
 67 | }
 68 | .project-image-container:hover img {
 69 |   opacity: 0.4;
 70 | }
 71 | .project-caption {
 72 |   padding: 3px;
 73 | }
 74 | 
 75 | /* Larger than phone */
 76 | @media (min-width: 550px) {
 77 |   .header {
 78 |     margin-top: 5rem; }
 79 | }
 80 | 
 81 | /* Larger than tablet */
 82 | @media (min-width: 750px) {
 83 |   /* Navbar */
 84 |   .navbar + .docs-section {
 85 |     border-top-width: 0; }
 86 |   .navbar,
 87 |   .navbar-spacer {
 88 |     display: block;
 89 |     width: 100%;
 90 |     height: 6.5rem;
 91 |     background: #fff;
 92 |     z-index: 99;
 93 |     border-top: 1px solid #eee;
 94 |     border-bottom: 1px solid #eee; }
 95 |   .navbar-spacer {
 96 |     display: none; }
 97 |   .navbar > .container {
 98 |     width: 100%; }
 99 |   .navbar-list {
100 |     list-style: none;
101 |     margin-bottom: 0; }
102 |   .navbar-item {
103 |     position: relative;
104 |     float: left;
105 |     margin-bottom: 0; }
106 |   .navbar-link {
107 |     text-transform: uppercase;
108 |     font-size: 11px;
109 |     font-weight: 600;
110 |     letter-spacing: .2rem;
111 |     margin-right: 35px;
112 |     text-decoration: none;
113 |     line-height: 6.5rem;
114 |     color: #222; }
115 |   .navbar-link.active {
116 |     color: #33C3F0; }
117 |   .has-docked-nav .navbar {
118 |     position: fixed;
119 |     top: 0;
120 |     left: 0; }
121 |   .has-docked-nav .navbar-spacer {
122 |     display: block; }
123 |   /* Re-overiding the width 100% declaration to match size of % based container */
124 |   .has-docked-nav .navbar > .container {
125 |     width: 80%; }
126 | 
127 |   /* Popover */
128 |   .popover.open {
129 |     display: block;
130 |   }
131 |   .popover {
132 |     display: none;
133 |     position: absolute;
134 |     top: 0;
135 |     left: 0;
136 |     background: #fff;
137 |     border: 1px solid #eee;
138 |     border-radius: 4px;
139 |     top: 92%;
140 |     left: -50%;
141 |     -webkit-filter: drop-shadow(0 0 6px rgba(0,0,0,.1));
142 |        -moz-filter: drop-shadow(0 0 6px rgba(0,0,0,.1));
143 |             filter: drop-shadow(0 0 6px rgba(0,0,0,.1)); }
144 |   .popover-item:first-child .popover-link:after, 
145 |   .popover-item:first-child .popover-link:before {
146 |     bottom: 100%;
147 |     left: 50%;
148 |     border: solid transparent;
149 |     content: " ";
150 |     height: 0;
151 |     width: 0;
152 |     position: absolute;
153 |     pointer-events: none; }
154 |   .popover-item:first-child .popover-link:after {
155 |     border-color: rgba(255, 255, 255, 0);
156 |     border-bottom-color: #fff;
157 |     border-width: 10px;
158 |     margin-left: -10px; }
159 |   .popover-item:first-child .popover-link:before {
160 |     border-color: rgba(238, 238, 238, 0);
161 |     border-bottom-color: #eee;
162 |     border-width: 11px;
163 |     margin-left: -11px; }
164 |   .popover-list {
165 |     padding: 0;
166 |     margin: 0;
167 |     list-style: none; }
168 |   .popover-item {
169 |     padding: 0;
170 |     margin: 0; }
171 |   .popover-link {
172 |     position: relative;
173 |     color: #222;
174 |     display: block;
175 |     padding: 8px 20px;
176 |     border-bottom: 1px solid #eee;
177 |     text-decoration: none;
178 |     text-transform: uppercase;
179 |     font-size: 1.0rem;
180 |     font-weight: 600;
181 |     text-align: center;
182 |     letter-spacing: .1rem; }
183 |   .popover-item:first-child .popover-link {
184 |     border-radius: 4px 4px 0 0; }
185 |   .popover-item:last-child .popover-link {
186 |     border-radius: 0 0 4px 4px;
187 |     border-bottom-width: 0; }
188 |   .popover-link:hover {
189 |     color: #fff;
190 |     background: #33C3F0; }
191 |   .popover-link:hover,
192 |   .popover-item:first-child .popover-link:hover:after {
193 |     border-bottom-color: #33C3F0; }
194 | }
195 | 


--------------------------------------------------------------------------------
/docs/libs/custom/my_js.js:
--------------------------------------------------------------------------------
 1 | $(document).ready(function() {
 2 | 
 3 |   // Variables
 4 |   var $codeSnippets = $('.code-example-body'),
 5 |       $nav = $('.navbar'),
 6 |       $body = $('body'),
 7 |       $window = $(window),
 8 |       $popoverLink = $('[data-popover]'),
 9 |       navOffsetTop = $nav.offset().top,
10 |       $document = $(document),
11 |       entityMap = {
12 |         "&": "&amp;",
13 |         "<": "&lt;",
14 |         ">": "&gt;",
15 |         '"': '&quot;',
16 |         "'": '&#39;',
17 |         "/": '&#x2F;'
18 |       }
19 | 
20 |   function init() {
21 |     $window.on('scroll', onScroll)
22 |     $window.on('resize', resize)
23 |     $popoverLink.on('click', openPopover)
24 |     $document.on('click', closePopover)
25 |     $('a[href^="#"]').on('click', smoothScroll)
26 |     buildSnippets();
27 |   }
28 | 
29 |   function smoothScroll(e) {
30 |     e.preventDefault();
31 |     $(document).off("scroll");
32 |     var target = this.hash,
33 |         menu = target;
34 |     $target = $(target);
35 |     $('html, body').stop().animate({
36 |         'scrollTop': $target.offset().top-40
37 |     }, 0, 'swing', function () {
38 |         window.location.hash = target;
39 |         $(document).on("scroll", onScroll);
40 |     });
41 |   }
42 | 
43 |   function openPopover(e) {
44 |     e.preventDefault()
45 |     closePopover();
46 |     var popover = $($(this).data('popover'));
47 |     popover.toggleClass('open')
48 |     e.stopImmediatePropagation();
49 |   }
50 | 
51 |   function closePopover(e) {
52 |     if($('.popover.open').length > 0) {
53 |       $('.popover').removeClass('open')
54 |     }
55 |   }
56 | 
57 |   $("#button").click(function() {
58 |     $('html, body').animate({
59 |         scrollTop: $("#elementtoScrollToID").offset().top
60 |     }, 2000);
61 | });
62 | 
63 |   function resize() {
64 |     $body.removeClass('has-docked-nav')
65 |     navOffsetTop = $nav.offset().top
66 |     onScroll()
67 |   }
68 | 
69 |   function onScroll() {
70 |     if(navOffsetTop < $window.scrollTop() && !$body.hasClass('has-docked-nav')) {
71 |       $body.addClass('has-docked-nav')
72 |     }
73 |     if(navOffsetTop > $window.scrollTop() && $body.hasClass('has-docked-nav')) {
74 |       $body.removeClass('has-docked-nav')
75 |     }
76 |   }
77 | 
78 |   function escapeHtml(string) {
79 |     return String(string).replace(/[&<>"'\/]/g, function (s) {
80 |       return entityMap[s];
81 |     });
82 |   }
83 | 
84 |   function buildSnippets() {
85 |     $codeSnippets.each(function() {
86 |       var newContent = escapeHtml($(this).html())
87 |       $(this).html(newContent)
88 |     })
89 |   }
90 | 
91 | 
92 |   init();
93 | 
94 | });


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/fonts/FontAwesome.otf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/docs/libs/external/font-awesome-4.7.0/fonts/FontAwesome.otf


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/fonts/fontawesome-webfont.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/docs/libs/external/font-awesome-4.7.0/fonts/fontawesome-webfont.eot


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/fonts/fontawesome-webfont.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/docs/libs/external/font-awesome-4.7.0/fonts/fontawesome-webfont.ttf


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/fonts/fontawesome-webfont.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/docs/libs/external/font-awesome-4.7.0/fonts/fontawesome-webfont.woff


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/fonts/fontawesome-webfont.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/docs/libs/external/font-awesome-4.7.0/fonts/fontawesome-webfont.woff2


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/less/animated.less:
--------------------------------------------------------------------------------
 1 | // Animated Icons
 2 | // --------------------------
 3 | 
 4 | .@{fa-css-prefix}-spin {
 5 |   -webkit-animation: fa-spin 2s infinite linear;
 6 |           animation: fa-spin 2s infinite linear;
 7 | }
 8 | 
 9 | .@{fa-css-prefix}-pulse {
10 |   -webkit-animation: fa-spin 1s infinite steps(8);
11 |           animation: fa-spin 1s infinite steps(8);
12 | }
13 | 
14 | @-webkit-keyframes fa-spin {
15 |   0% {
16 |     -webkit-transform: rotate(0deg);
17 |             transform: rotate(0deg);
18 |   }
19 |   100% {
20 |     -webkit-transform: rotate(359deg);
21 |             transform: rotate(359deg);
22 |   }
23 | }
24 | 
25 | @keyframes fa-spin {
26 |   0% {
27 |     -webkit-transform: rotate(0deg);
28 |             transform: rotate(0deg);
29 |   }
30 |   100% {
31 |     -webkit-transform: rotate(359deg);
32 |             transform: rotate(359deg);
33 |   }
34 | }
35 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/less/bordered-pulled.less:
--------------------------------------------------------------------------------
 1 | // Bordered & Pulled
 2 | // -------------------------
 3 | 
 4 | .@{fa-css-prefix}-border {
 5 |   padding: .2em .25em .15em;
 6 |   border: solid .08em @fa-border-color;
 7 |   border-radius: .1em;
 8 | }
 9 | 
10 | .@{fa-css-prefix}-pull-left { float: left; }
11 | .@{fa-css-prefix}-pull-right { float: right; }
12 | 
13 | .@{fa-css-prefix} {
14 |   &.@{fa-css-prefix}-pull-left { margin-right: .3em; }
15 |   &.@{fa-css-prefix}-pull-right { margin-left: .3em; }
16 | }
17 | 
18 | /* Deprecated as of 4.4.0 */
19 | .pull-right { float: right; }
20 | .pull-left { float: left; }
21 | 
22 | .@{fa-css-prefix} {
23 |   &.pull-left { margin-right: .3em; }
24 |   &.pull-right { margin-left: .3em; }
25 | }
26 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/less/core.less:
--------------------------------------------------------------------------------
 1 | // Base Class Definition
 2 | // -------------------------
 3 | 
 4 | .@{fa-css-prefix} {
 5 |   display: inline-block;
 6 |   font: normal normal normal @fa-font-size-base/@fa-line-height-base FontAwesome; // shortening font declaration
 7 |   font-size: inherit; // can't have font-size inherit on line above, so need to override
 8 |   text-rendering: auto; // optimizelegibility throws things off #1094
 9 |   -webkit-font-smoothing: antialiased;
10 |   -moz-osx-font-smoothing: grayscale;
11 | 
12 | }
13 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/less/fixed-width.less:
--------------------------------------------------------------------------------
1 | // Fixed Width Icons
2 | // -------------------------
3 | .@{fa-css-prefix}-fw {
4 |   width: (18em / 14);
5 |   text-align: center;
6 | }
7 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/less/font-awesome.less:
--------------------------------------------------------------------------------
 1 | /*!
 2 |  *  Font Awesome 4.7.0 by @davegandy - http://fontawesome.io - @fontawesome
 3 |  *  License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License)
 4 |  */
 5 | 
 6 | @import "variables.less";
 7 | @import "mixins.less";
 8 | @import "path.less";
 9 | @import "core.less";
10 | @import "larger.less";
11 | @import "fixed-width.less";
12 | @import "list.less";
13 | @import "bordered-pulled.less";
14 | @import "animated.less";
15 | @import "rotated-flipped.less";
16 | @import "stacked.less";
17 | @import "icons.less";
18 | @import "screen-reader.less";
19 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/less/larger.less:
--------------------------------------------------------------------------------
 1 | // Icon Sizes
 2 | // -------------------------
 3 | 
 4 | /* makes the font 33% larger relative to the icon container */
 5 | .@{fa-css-prefix}-lg {
 6 |   font-size: (4em / 3);
 7 |   line-height: (3em / 4);
 8 |   vertical-align: -15%;
 9 | }
10 | .@{fa-css-prefix}-2x { font-size: 2em; }
11 | .@{fa-css-prefix}-3x { font-size: 3em; }
12 | .@{fa-css-prefix}-4x { font-size: 4em; }
13 | .@{fa-css-prefix}-5x { font-size: 5em; }
14 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/less/list.less:
--------------------------------------------------------------------------------
 1 | // List Icons
 2 | // -------------------------
 3 | 
 4 | .@{fa-css-prefix}-ul {
 5 |   padding-left: 0;
 6 |   margin-left: @fa-li-width;
 7 |   list-style-type: none;
 8 |   > li { position: relative; }
 9 | }
10 | .@{fa-css-prefix}-li {
11 |   position: absolute;
12 |   left: -@fa-li-width;
13 |   width: @fa-li-width;
14 |   top: (2em / 14);
15 |   text-align: center;
16 |   &.@{fa-css-prefix}-lg {
17 |     left: (-@fa-li-width + (4em / 14));
18 |   }
19 | }
20 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/less/mixins.less:
--------------------------------------------------------------------------------
 1 | // Mixins
 2 | // --------------------------
 3 | 
 4 | .fa-icon() {
 5 |   display: inline-block;
 6 |   font: normal normal normal @fa-font-size-base/@fa-line-height-base FontAwesome; // shortening font declaration
 7 |   font-size: inherit; // can't have font-size inherit on line above, so need to override
 8 |   text-rendering: auto; // optimizelegibility throws things off #1094
 9 |   -webkit-font-smoothing: antialiased;
10 |   -moz-osx-font-smoothing: grayscale;
11 | 
12 | }
13 | 
14 | .fa-icon-rotate(@degrees, @rotation) {
15 |   -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=@{rotation})";
16 |   -webkit-transform: rotate(@degrees);
17 |       -ms-transform: rotate(@degrees);
18 |           transform: rotate(@degrees);
19 | }
20 | 
21 | .fa-icon-flip(@horiz, @vert, @rotation) {
22 |   -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=@{rotation}, mirror=1)";
23 |   -webkit-transform: scale(@horiz, @vert);
24 |       -ms-transform: scale(@horiz, @vert);
25 |           transform: scale(@horiz, @vert);
26 | }
27 | 
28 | 
29 | // Only display content to screen readers. A la Bootstrap 4.
30 | //
31 | // See: http://a11yproject.com/posts/how-to-hide-content/
32 | 
33 | .sr-only() {
34 |   position: absolute;
35 |   width: 1px;
36 |   height: 1px;
37 |   padding: 0;
38 |   margin: -1px;
39 |   overflow: hidden;
40 |   clip: rect(0,0,0,0);
41 |   border: 0;
42 | }
43 | 
44 | // Use in conjunction with .sr-only to only display content when it's focused.
45 | //
46 | // Useful for "Skip to main content" links; see http://www.w3.org/TR/2013/NOTE-WCAG20-TECHS-20130905/G1
47 | //
48 | // Credit: HTML5 Boilerplate
49 | 
50 | .sr-only-focusable() {
51 |   &:active,
52 |   &:focus {
53 |     position: static;
54 |     width: auto;
55 |     height: auto;
56 |     margin: 0;
57 |     overflow: visible;
58 |     clip: auto;
59 |   }
60 | }
61 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/less/path.less:
--------------------------------------------------------------------------------
 1 | /* FONT PATH
 2 |  * -------------------------- */
 3 | 
 4 | @font-face {
 5 |   font-family: 'FontAwesome';
 6 |   src: url('@{fa-font-path}/fontawesome-webfont.eot?v=@{fa-version}');
 7 |   src: url('@{fa-font-path}/fontawesome-webfont.eot?#iefix&v=@{fa-version}') format('embedded-opentype'),
 8 |     url('@{fa-font-path}/fontawesome-webfont.woff2?v=@{fa-version}') format('woff2'),
 9 |     url('@{fa-font-path}/fontawesome-webfont.woff?v=@{fa-version}') format('woff'),
10 |     url('@{fa-font-path}/fontawesome-webfont.ttf?v=@{fa-version}') format('truetype'),
11 |     url('@{fa-font-path}/fontawesome-webfont.svg?v=@{fa-version}#fontawesomeregular') format('svg');
12 |   // src: url('@{fa-font-path}/FontAwesome.otf') format('opentype'); // used when developing fonts
13 |   font-weight: normal;
14 |   font-style: normal;
15 | }
16 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/less/rotated-flipped.less:
--------------------------------------------------------------------------------
 1 | // Rotated & Flipped Icons
 2 | // -------------------------
 3 | 
 4 | .@{fa-css-prefix}-rotate-90  { .fa-icon-rotate(90deg, 1);  }
 5 | .@{fa-css-prefix}-rotate-180 { .fa-icon-rotate(180deg, 2); }
 6 | .@{fa-css-prefix}-rotate-270 { .fa-icon-rotate(270deg, 3); }
 7 | 
 8 | .@{fa-css-prefix}-flip-horizontal { .fa-icon-flip(-1, 1, 0); }
 9 | .@{fa-css-prefix}-flip-vertical   { .fa-icon-flip(1, -1, 2); }
10 | 
11 | // Hook for IE8-9
12 | // -------------------------
13 | 
14 | :root .@{fa-css-prefix}-rotate-90,
15 | :root .@{fa-css-prefix}-rotate-180,
16 | :root .@{fa-css-prefix}-rotate-270,
17 | :root .@{fa-css-prefix}-flip-horizontal,
18 | :root .@{fa-css-prefix}-flip-vertical {
19 |   filter: none;
20 | }
21 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/less/screen-reader.less:
--------------------------------------------------------------------------------
1 | // Screen Readers
2 | // -------------------------
3 | 
4 | .sr-only { .sr-only(); }
5 | .sr-only-focusable { .sr-only-focusable(); }
6 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/less/stacked.less:
--------------------------------------------------------------------------------
 1 | // Stacked Icons
 2 | // -------------------------
 3 | 
 4 | .@{fa-css-prefix}-stack {
 5 |   position: relative;
 6 |   display: inline-block;
 7 |   width: 2em;
 8 |   height: 2em;
 9 |   line-height: 2em;
10 |   vertical-align: middle;
11 | }
12 | .@{fa-css-prefix}-stack-1x, .@{fa-css-prefix}-stack-2x {
13 |   position: absolute;
14 |   left: 0;
15 |   width: 100%;
16 |   text-align: center;
17 | }
18 | .@{fa-css-prefix}-stack-1x { line-height: inherit; }
19 | .@{fa-css-prefix}-stack-2x { font-size: 2em; }
20 | .@{fa-css-prefix}-inverse { color: @fa-inverse; }
21 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/scss/_animated.scss:
--------------------------------------------------------------------------------
 1 | // Spinning Icons
 2 | // --------------------------
 3 | 
 4 | .#{$fa-css-prefix}-spin {
 5 |   -webkit-animation: fa-spin 2s infinite linear;
 6 |           animation: fa-spin 2s infinite linear;
 7 | }
 8 | 
 9 | .#{$fa-css-prefix}-pulse {
10 |   -webkit-animation: fa-spin 1s infinite steps(8);
11 |           animation: fa-spin 1s infinite steps(8);
12 | }
13 | 
14 | @-webkit-keyframes fa-spin {
15 |   0% {
16 |     -webkit-transform: rotate(0deg);
17 |             transform: rotate(0deg);
18 |   }
19 |   100% {
20 |     -webkit-transform: rotate(359deg);
21 |             transform: rotate(359deg);
22 |   }
23 | }
24 | 
25 | @keyframes fa-spin {
26 |   0% {
27 |     -webkit-transform: rotate(0deg);
28 |             transform: rotate(0deg);
29 |   }
30 |   100% {
31 |     -webkit-transform: rotate(359deg);
32 |             transform: rotate(359deg);
33 |   }
34 | }
35 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/scss/_bordered-pulled.scss:
--------------------------------------------------------------------------------
 1 | // Bordered & Pulled
 2 | // -------------------------
 3 | 
 4 | .#{$fa-css-prefix}-border {
 5 |   padding: .2em .25em .15em;
 6 |   border: solid .08em $fa-border-color;
 7 |   border-radius: .1em;
 8 | }
 9 | 
10 | .#{$fa-css-prefix}-pull-left { float: left; }
11 | .#{$fa-css-prefix}-pull-right { float: right; }
12 | 
13 | .#{$fa-css-prefix} {
14 |   &.#{$fa-css-prefix}-pull-left { margin-right: .3em; }
15 |   &.#{$fa-css-prefix}-pull-right { margin-left: .3em; }
16 | }
17 | 
18 | /* Deprecated as of 4.4.0 */
19 | .pull-right { float: right; }
20 | .pull-left { float: left; }
21 | 
22 | .#{$fa-css-prefix} {
23 |   &.pull-left { margin-right: .3em; }
24 |   &.pull-right { margin-left: .3em; }
25 | }
26 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/scss/_core.scss:
--------------------------------------------------------------------------------
 1 | // Base Class Definition
 2 | // -------------------------
 3 | 
 4 | .#{$fa-css-prefix} {
 5 |   display: inline-block;
 6 |   font: normal normal normal #{$fa-font-size-base}/#{$fa-line-height-base} FontAwesome; // shortening font declaration
 7 |   font-size: inherit; // can't have font-size inherit on line above, so need to override
 8 |   text-rendering: auto; // optimizelegibility throws things off #1094
 9 |   -webkit-font-smoothing: antialiased;
10 |   -moz-osx-font-smoothing: grayscale;
11 | 
12 | }
13 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/scss/_fixed-width.scss:
--------------------------------------------------------------------------------
1 | // Fixed Width Icons
2 | // -------------------------
3 | .#{$fa-css-prefix}-fw {
4 |   width: (18em / 14);
5 |   text-align: center;
6 | }
7 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/scss/_larger.scss:
--------------------------------------------------------------------------------
 1 | // Icon Sizes
 2 | // -------------------------
 3 | 
 4 | /* makes the font 33% larger relative to the icon container */
 5 | .#{$fa-css-prefix}-lg {
 6 |   font-size: (4em / 3);
 7 |   line-height: (3em / 4);
 8 |   vertical-align: -15%;
 9 | }
10 | .#{$fa-css-prefix}-2x { font-size: 2em; }
11 | .#{$fa-css-prefix}-3x { font-size: 3em; }
12 | .#{$fa-css-prefix}-4x { font-size: 4em; }
13 | .#{$fa-css-prefix}-5x { font-size: 5em; }
14 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/scss/_list.scss:
--------------------------------------------------------------------------------
 1 | // List Icons
 2 | // -------------------------
 3 | 
 4 | .#{$fa-css-prefix}-ul {
 5 |   padding-left: 0;
 6 |   margin-left: $fa-li-width;
 7 |   list-style-type: none;
 8 |   > li { position: relative; }
 9 | }
10 | .#{$fa-css-prefix}-li {
11 |   position: absolute;
12 |   left: -$fa-li-width;
13 |   width: $fa-li-width;
14 |   top: (2em / 14);
15 |   text-align: center;
16 |   &.#{$fa-css-prefix}-lg {
17 |     left: -$fa-li-width + (4em / 14);
18 |   }
19 | }
20 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/scss/_mixins.scss:
--------------------------------------------------------------------------------
 1 | // Mixins
 2 | // --------------------------
 3 | 
 4 | @mixin fa-icon() {
 5 |   display: inline-block;
 6 |   font: normal normal normal #{$fa-font-size-base}/#{$fa-line-height-base} FontAwesome; // shortening font declaration
 7 |   font-size: inherit; // can't have font-size inherit on line above, so need to override
 8 |   text-rendering: auto; // optimizelegibility throws things off #1094
 9 |   -webkit-font-smoothing: antialiased;
10 |   -moz-osx-font-smoothing: grayscale;
11 | 
12 | }
13 | 
14 | @mixin fa-icon-rotate($degrees, $rotation) {
15 |   -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=#{$rotation})";
16 |   -webkit-transform: rotate($degrees);
17 |       -ms-transform: rotate($degrees);
18 |           transform: rotate($degrees);
19 | }
20 | 
21 | @mixin fa-icon-flip($horiz, $vert, $rotation) {
22 |   -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=#{$rotation}, mirror=1)";
23 |   -webkit-transform: scale($horiz, $vert);
24 |       -ms-transform: scale($horiz, $vert);
25 |           transform: scale($horiz, $vert);
26 | }
27 | 
28 | 
29 | // Only display content to screen readers. A la Bootstrap 4.
30 | //
31 | // See: http://a11yproject.com/posts/how-to-hide-content/
32 | 
33 | @mixin sr-only {
34 |   position: absolute;
35 |   width: 1px;
36 |   height: 1px;
37 |   padding: 0;
38 |   margin: -1px;
39 |   overflow: hidden;
40 |   clip: rect(0,0,0,0);
41 |   border: 0;
42 | }
43 | 
44 | // Use in conjunction with .sr-only to only display content when it's focused.
45 | //
46 | // Useful for "Skip to main content" links; see http://www.w3.org/TR/2013/NOTE-WCAG20-TECHS-20130905/G1
47 | //
48 | // Credit: HTML5 Boilerplate
49 | 
50 | @mixin sr-only-focusable {
51 |   &:active,
52 |   &:focus {
53 |     position: static;
54 |     width: auto;
55 |     height: auto;
56 |     margin: 0;
57 |     overflow: visible;
58 |     clip: auto;
59 |   }
60 | }
61 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/scss/_path.scss:
--------------------------------------------------------------------------------
 1 | /* FONT PATH
 2 |  * -------------------------- */
 3 | 
 4 | @font-face {
 5 |   font-family: 'FontAwesome';
 6 |   src: url('#{$fa-font-path}/fontawesome-webfont.eot?v=#{$fa-version}');
 7 |   src: url('#{$fa-font-path}/fontawesome-webfont.eot?#iefix&v=#{$fa-version}') format('embedded-opentype'),
 8 |     url('#{$fa-font-path}/fontawesome-webfont.woff2?v=#{$fa-version}') format('woff2'),
 9 |     url('#{$fa-font-path}/fontawesome-webfont.woff?v=#{$fa-version}') format('woff'),
10 |     url('#{$fa-font-path}/fontawesome-webfont.ttf?v=#{$fa-version}') format('truetype'),
11 |     url('#{$fa-font-path}/fontawesome-webfont.svg?v=#{$fa-version}#fontawesomeregular') format('svg');
12 | //  src: url('#{$fa-font-path}/FontAwesome.otf') format('opentype'); // used when developing fonts
13 |   font-weight: normal;
14 |   font-style: normal;
15 | }
16 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/scss/_rotated-flipped.scss:
--------------------------------------------------------------------------------
 1 | // Rotated & Flipped Icons
 2 | // -------------------------
 3 | 
 4 | .#{$fa-css-prefix}-rotate-90  { @include fa-icon-rotate(90deg, 1);  }
 5 | .#{$fa-css-prefix}-rotate-180 { @include fa-icon-rotate(180deg, 2); }
 6 | .#{$fa-css-prefix}-rotate-270 { @include fa-icon-rotate(270deg, 3); }
 7 | 
 8 | .#{$fa-css-prefix}-flip-horizontal { @include fa-icon-flip(-1, 1, 0); }
 9 | .#{$fa-css-prefix}-flip-vertical   { @include fa-icon-flip(1, -1, 2); }
10 | 
11 | // Hook for IE8-9
12 | // -------------------------
13 | 
14 | :root .#{$fa-css-prefix}-rotate-90,
15 | :root .#{$fa-css-prefix}-rotate-180,
16 | :root .#{$fa-css-prefix}-rotate-270,
17 | :root .#{$fa-css-prefix}-flip-horizontal,
18 | :root .#{$fa-css-prefix}-flip-vertical {
19 |   filter: none;
20 | }
21 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/scss/_screen-reader.scss:
--------------------------------------------------------------------------------
1 | // Screen Readers
2 | // -------------------------
3 | 
4 | .sr-only { @include sr-only(); }
5 | .sr-only-focusable { @include sr-only-focusable(); }
6 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/scss/_stacked.scss:
--------------------------------------------------------------------------------
 1 | // Stacked Icons
 2 | // -------------------------
 3 | 
 4 | .#{$fa-css-prefix}-stack {
 5 |   position: relative;
 6 |   display: inline-block;
 7 |   width: 2em;
 8 |   height: 2em;
 9 |   line-height: 2em;
10 |   vertical-align: middle;
11 | }
12 | .#{$fa-css-prefix}-stack-1x, .#{$fa-css-prefix}-stack-2x {
13 |   position: absolute;
14 |   left: 0;
15 |   width: 100%;
16 |   text-align: center;
17 | }
18 | .#{$fa-css-prefix}-stack-1x { line-height: inherit; }
19 | .#{$fa-css-prefix}-stack-2x { font-size: 2em; }
20 | .#{$fa-css-prefix}-inverse { color: $fa-inverse; }
21 | 


--------------------------------------------------------------------------------
/docs/libs/external/font-awesome-4.7.0/scss/font-awesome.scss:
--------------------------------------------------------------------------------
 1 | /*!
 2 |  *  Font Awesome 4.7.0 by @davegandy - http://fontawesome.io - @fontawesome
 3 |  *  License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License)
 4 |  */
 5 | 
 6 | @import "variables";
 7 | @import "mixins";
 8 | @import "path";
 9 | @import "core";
10 | @import "larger";
11 | @import "fixed-width";
12 | @import "list";
13 | @import "bordered-pulled";
14 | @import "animated";
15 | @import "rotated-flipped";
16 | @import "stacked";
17 | @import "icons";
18 | @import "screen-reader";
19 | 


--------------------------------------------------------------------------------
/docs/libs/external/skeleton/normalize.css:
--------------------------------------------------------------------------------
  1 | /*! normalize.css v3.0.2 | MIT License | git.io/normalize */
  2 | 
  3 | /**
  4 |  * 1. Set default font family to sans-serif.
  5 |  * 2. Prevent iOS text size adjust after orientation change, without disabling
  6 |  *    user zoom.
  7 |  */
  8 | 
  9 | html {
 10 |   font-family: sans-serif; /* 1 */
 11 |   -ms-text-size-adjust: 100%; /* 2 */
 12 |   -webkit-text-size-adjust: 100%; /* 2 */
 13 | }
 14 | 
 15 | /**
 16 |  * Remove default margin.
 17 |  */
 18 | 
 19 | body {
 20 |   margin: 0;
 21 | }
 22 | 
 23 | /* HTML5 display definitions
 24 |    ========================================================================== */
 25 | 
 26 | /**
 27 |  * Correct `block` display not defined for any HTML5 element in IE 8/9.
 28 |  * Correct `block` display not defined for `details` or `summary` in IE 10/11
 29 |  * and Firefox.
 30 |  * Correct `block` display not defined for `main` in IE 11.
 31 |  */
 32 | 
 33 | article,
 34 | aside,
 35 | details,
 36 | figcaption,
 37 | figure,
 38 | footer,
 39 | header,
 40 | hgroup,
 41 | main,
 42 | menu,
 43 | nav,
 44 | section,
 45 | summary {
 46 |   display: block;
 47 | }
 48 | 
 49 | /**
 50 |  * 1. Correct `inline-block` display not defined in IE 8/9.
 51 |  * 2. Normalize vertical alignment of `progress` in Chrome, Firefox, and Opera.
 52 |  */
 53 | 
 54 | audio,
 55 | canvas,
 56 | progress,
 57 | video {
 58 |   display: inline-block; /* 1 */
 59 |   vertical-align: baseline; /* 2 */
 60 | }
 61 | 
 62 | /**
 63 |  * Prevent modern browsers from displaying `audio` without controls.
 64 |  * Remove excess height in iOS 5 devices.
 65 |  */
 66 | 
 67 | audio:not([controls]) {
 68 |   display: none;
 69 |   height: 0;
 70 | }
 71 | 
 72 | /**
 73 |  * Address `[hidden]` styling not present in IE 8/9/10.
 74 |  * Hide the `template` element in IE 8/9/11, Safari, and Firefox < 22.
 75 |  */
 76 | 
 77 | [hidden],
 78 | template {
 79 |   display: none;
 80 | }
 81 | 
 82 | /* Links
 83 |    ========================================================================== */
 84 | 
 85 | /**
 86 |  * Remove the gray background color from active links in IE 10.
 87 |  */
 88 | 
 89 | a {
 90 |   background-color: transparent;
 91 | }
 92 | 
 93 | /**
 94 |  * Improve readability when focused and also mouse hovered in all browsers.
 95 |  */
 96 | 
 97 | a:active,
 98 | a:hover {
 99 |   outline: 0;
100 | }
101 | 
102 | /* Text-level semantics
103 |    ========================================================================== */
104 | 
105 | /**
106 |  * Address styling not present in IE 8/9/10/11, Safari, and Chrome.
107 |  */
108 | 
109 | abbr[title] {
110 |   border-bottom: 1px dotted;
111 | }
112 | 
113 | /**
114 |  * Address style set to `bolder` in Firefox 4+, Safari, and Chrome.
115 |  */
116 | 
117 | b,
118 | strong {
119 |   font-weight: bold;
120 | }
121 | 
122 | /**
123 |  * Address styling not present in Safari and Chrome.
124 |  */
125 | 
126 | dfn {
127 |   font-style: italic;
128 | }
129 | 
130 | /**
131 |  * Address variable `h1` font-size and margin within `section` and `article`
132 |  * contexts in Firefox 4+, Safari, and Chrome.
133 |  */
134 | 
135 | h1 {
136 |   font-size: 2em;
137 |   margin: 0.67em 0;
138 | }
139 | 
140 | /**
141 |  * Address styling not present in IE 8/9.
142 |  */
143 | 
144 | mark {
145 |   background: #ff0;
146 |   color: #000;
147 | }
148 | 
149 | /**
150 |  * Address inconsistent and variable font size in all browsers.
151 |  */
152 | 
153 | small {
154 |   font-size: 80%;
155 | }
156 | 
157 | /**
158 |  * Prevent `sub` and `sup` affecting `line-height` in all browsers.
159 |  */
160 | 
161 | sub,
162 | sup {
163 |   font-size: 75%;
164 |   line-height: 0;
165 |   position: relative;
166 |   vertical-align: baseline;
167 | }
168 | 
169 | sup {
170 |   top: -0.5em;
171 | }
172 | 
173 | sub {
174 |   bottom: -0.25em;
175 | }
176 | 
177 | /* Embedded content
178 |    ========================================================================== */
179 | 
180 | /**
181 |  * Remove border when inside `a` element in IE 8/9/10.
182 |  */
183 | 
184 | img {
185 |   border: 0;
186 | }
187 | 
188 | /**
189 |  * Correct overflow not hidden in IE 9/10/11.
190 |  */
191 | 
192 | svg:not(:root) {
193 |   overflow: hidden;
194 | }
195 | 
196 | /* Grouping content
197 |    ========================================================================== */
198 | 
199 | /**
200 |  * Address margin not present in IE 8/9 and Safari.
201 |  */
202 | 
203 | figure {
204 |   margin: 1em 40px;
205 | }
206 | 
207 | /**
208 |  * Address differences between Firefox and other browsers.
209 |  */
210 | 
211 | hr {
212 |   -moz-box-sizing: content-box;
213 |   box-sizing: content-box;
214 |   height: 0;
215 | }
216 | 
217 | /**
218 |  * Contain overflow in all browsers.
219 |  */
220 | 
221 | pre {
222 |   overflow: auto;
223 | }
224 | 
225 | /**
226 |  * Address odd `em`-unit font size rendering in all browsers.
227 |  */
228 | 
229 | code,
230 | kbd,
231 | pre,
232 | samp {
233 |   font-family: monospace, monospace;
234 |   font-size: 1em;
235 | }
236 | 
237 | /* Forms
238 |    ========================================================================== */
239 | 
240 | /**
241 |  * Known limitation: by default, Chrome and Safari on OS X allow very limited
242 |  * styling of `select`, unless a `border` property is set.
243 |  */
244 | 
245 | /**
246 |  * 1. Correct color not being inherited.
247 |  *    Known issue: affects color of disabled elements.
248 |  * 2. Correct font properties not being inherited.
249 |  * 3. Address margins set differently in Firefox 4+, Safari, and Chrome.
250 |  */
251 | 
252 | button,
253 | input,
254 | optgroup,
255 | select,
256 | textarea {
257 |   color: inherit; /* 1 */
258 |   font: inherit; /* 2 */
259 |   margin: 0; /* 3 */
260 | }
261 | 
262 | /**
263 |  * Address `overflow` set to `hidden` in IE 8/9/10/11.
264 |  */
265 | 
266 | button {
267 |   overflow: visible;
268 | }
269 | 
270 | /**
271 |  * Address inconsistent `text-transform` inheritance for `button` and `select`.
272 |  * All other form control elements do not inherit `text-transform` values.
273 |  * Correct `button` style inheritance in Firefox, IE 8/9/10/11, and Opera.
274 |  * Correct `select` style inheritance in Firefox.
275 |  */
276 | 
277 | button,
278 | select {
279 |   text-transform: none;
280 | }
281 | 
282 | /**
283 |  * 1. Avoid the WebKit bug in Android 4.0.* where (2) destroys native `audio`
284 |  *    and `video` controls.
285 |  * 2. Correct inability to style clickable `input` types in iOS.
286 |  * 3. Improve usability and consistency of cursor style between image-type
287 |  *    `input` and others.
288 |  */
289 | 
290 | button,
291 | html input[type="button"], /* 1 */
292 | input[type="reset"],
293 | input[type="submit"] {
294 |   -webkit-appearance: button; /* 2 */
295 |   cursor: pointer; /* 3 */
296 | }
297 | 
298 | /**
299 |  * Re-set default cursor for disabled elements.
300 |  */
301 | 
302 | button[disabled],
303 | html input[disabled] {
304 |   cursor: default;
305 | }
306 | 
307 | /**
308 |  * Remove inner padding and border in Firefox 4+.
309 |  */
310 | 
311 | button::-moz-focus-inner,
312 | input::-moz-focus-inner {
313 |   border: 0;
314 |   padding: 0;
315 | }
316 | 
317 | /**
318 |  * Address Firefox 4+ setting `line-height` on `input` using `!important` in
319 |  * the UA stylesheet.
320 |  */
321 | 
322 | input {
323 |   line-height: normal;
324 | }
325 | 
326 | /**
327 |  * It's recommended that you don't attempt to style these elements.
328 |  * Firefox's implementation doesn't respect box-sizing, padding, or width.
329 |  *
330 |  * 1. Address box sizing set to `content-box` in IE 8/9/10.
331 |  * 2. Remove excess padding in IE 8/9/10.
332 |  */
333 | 
334 | input[type="checkbox"],
335 | input[type="radio"] {
336 |   box-sizing: border-box; /* 1 */
337 |   padding: 0; /* 2 */
338 | }
339 | 
340 | /**
341 |  * Fix the cursor style for Chrome's increment/decrement buttons. For certain
342 |  * `font-size` values of the `input`, it causes the cursor style of the
343 |  * decrement button to change from `default` to `text`.
344 |  */
345 | 
346 | input[type="number"]::-webkit-inner-spin-button,
347 | input[type="number"]::-webkit-outer-spin-button {
348 |   height: auto;
349 | }
350 | 
351 | /**
352 |  * 1. Address `appearance` set to `searchfield` in Safari and Chrome.
353 |  * 2. Address `box-sizing` set to `border-box` in Safari and Chrome
354 |  *    (include `-moz` to future-proof).
355 |  */
356 | 
357 | input[type="search"] {
358 |   -webkit-appearance: textfield; /* 1 */
359 |   -moz-box-sizing: content-box;
360 |   -webkit-box-sizing: content-box; /* 2 */
361 |   box-sizing: content-box;
362 | }
363 | 
364 | /**
365 |  * Remove inner padding and search cancel button in Safari and Chrome on OS X.
366 |  * Safari (but not Chrome) clips the cancel button when the search input has
367 |  * padding (and `textfield` appearance).
368 |  */
369 | 
370 | input[type="search"]::-webkit-search-cancel-button,
371 | input[type="search"]::-webkit-search-decoration {
372 |   -webkit-appearance: none;
373 | }
374 | 
375 | /**
376 |  * Define consistent border, margin, and padding.
377 |  */
378 | 
379 | fieldset {
380 |   border: 1px solid #c0c0c0;
381 |   margin: 0 2px;
382 |   padding: 0.35em 0.625em 0.75em;
383 | }
384 | 
385 | /**
386 |  * 1. Correct `color` not being inherited in IE 8/9/10/11.
387 |  * 2. Remove padding so people aren't caught out if they zero out fieldsets.
388 |  */
389 | 
390 | legend {
391 |   border: 0; /* 1 */
392 |   padding: 0; /* 2 */
393 | }
394 | 
395 | /**
396 |  * Remove default vertical scrollbar in IE 8/9/10/11.
397 |  */
398 | 
399 | textarea {
400 |   overflow: auto;
401 | }
402 | 
403 | /**
404 |  * Don't inherit the `font-weight` (applied by a rule above).
405 |  * NOTE: the default cannot safely be changed in Chrome and Safari on OS X.
406 |  */
407 | 
408 | optgroup {
409 |   font-weight: bold;
410 | }
411 | 
412 | /* Tables
413 |    ========================================================================== */
414 | 
415 | /**
416 |  * Remove most spacing between table cells.
417 |  */
418 | 
419 | table {
420 |   border-collapse: collapse;
421 |   border-spacing: 0;
422 | }
423 | 
424 | td,
425 | th {
426 |   padding: 0;
427 | }


--------------------------------------------------------------------------------
/docs/libs/external/skeleton/skeleton.css:
--------------------------------------------------------------------------------
  1 | /*
  2 | * Skeleton V2.0.4
  3 | * Copyright 2014, Dave Gamache
  4 | * www.getskeleton.com
  5 | * Free to use under the MIT license.
  6 | * http://www.opensource.org/licenses/mit-license.php
  7 | * 12/29/2014
  8 | */
  9 | 
 10 | 
 11 | /* Table of contents
 12 | ––––––––––––––––––––––––––––––––––––––––––––––––––
 13 | - Grid
 14 | - Base Styles
 15 | - Typography
 16 | - Links
 17 | - Buttons
 18 | - Forms
 19 | - Lists
 20 | - Code
 21 | - Tables
 22 | - Spacing
 23 | - Utilities
 24 | - Clearing
 25 | - Media Queries
 26 | */
 27 | 
 28 | 
 29 | /* Grid
 30 | –––––––––––––––––––––––––––––––––––––––––––––––––– */
 31 | .container {
 32 |   position: relative;
 33 |   width: 100%;
 34 |   max-width: 960px;
 35 |   margin: 0 auto;
 36 |   padding: 0 20px;
 37 |   box-sizing: border-box; }
 38 | .column,
 39 | .columns {
 40 |   width: 100%;
 41 |   float: left;
 42 |   box-sizing: border-box; }
 43 | 
 44 | /* For devices larger than 400px */
 45 | @media (min-width: 400px) {
 46 |   .container {
 47 |     width: 85%;
 48 |     padding: 0; }
 49 | }
 50 | 
 51 | /* For devices larger than 550px */
 52 | @media (min-width: 550px) {
 53 |   .container {
 54 |     width: 80%; }
 55 |   .column,
 56 |   .columns {
 57 |     margin-left: 4%; }
 58 |   .column:first-child,
 59 |   .columns:first-child {
 60 |     margin-left: 0; }
 61 | 
 62 |   .one.column,
 63 |   .one.columns                    { width: 4.66666666667%; }
 64 |   .two.columns                    { width: 13.3333333333%; }
 65 |   .three.columns                  { width: 22%;            }
 66 |   .four.columns                   { width: 30.6666666667%; }
 67 |   .five.columns                   { width: 39.3333333333%; }
 68 |   .six.columns                    { width: 48%;            }
 69 |   .seven.columns                  { width: 56.6666666667%; }
 70 |   .eight.columns                  { width: 65.3333333333%; }
 71 |   .nine.columns                   { width: 74.0%;          }
 72 |   .ten.columns                    { width: 82.6666666667%; }
 73 |   .eleven.columns                 { width: 91.3333333333%; }
 74 |   .twelve.columns                 { width: 100%; margin-left: 0; }
 75 | 
 76 |   .one-third.column               { width: 30.6666666667%; }
 77 |   .two-thirds.column              { width: 65.3333333333%; }
 78 | 
 79 |   .one-half.column                { width: 48%; }
 80 | 
 81 |   /* Offsets */
 82 |   .offset-by-one.column,
 83 |   .offset-by-one.columns          { margin-left: 8.66666666667%; }
 84 |   .offset-by-two.column,
 85 |   .offset-by-two.columns          { margin-left: 17.3333333333%; }
 86 |   .offset-by-three.column,
 87 |   .offset-by-three.columns        { margin-left: 26%;            }
 88 |   .offset-by-four.column,
 89 |   .offset-by-four.columns         { margin-left: 34.6666666667%; }
 90 |   .offset-by-five.column,
 91 |   .offset-by-five.columns         { margin-left: 43.3333333333%; }
 92 |   .offset-by-six.column,
 93 |   .offset-by-six.columns          { margin-left: 52%;            }
 94 |   .offset-by-seven.column,
 95 |   .offset-by-seven.columns        { margin-left: 60.6666666667%; }
 96 |   .offset-by-eight.column,
 97 |   .offset-by-eight.columns        { margin-left: 69.3333333333%; }
 98 |   .offset-by-nine.column,
 99 |   .offset-by-nine.columns         { margin-left: 78.0%;          }
100 |   .offset-by-ten.column,
101 |   .offset-by-ten.columns          { margin-left: 86.6666666667%; }
102 |   .offset-by-eleven.column,
103 |   .offset-by-eleven.columns       { margin-left: 95.3333333333%; }
104 | 
105 |   .offset-by-one-third.column,
106 |   .offset-by-one-third.columns    { margin-left: 34.6666666667%; }
107 |   .offset-by-two-thirds.column,
108 |   .offset-by-two-thirds.columns   { margin-left: 69.3333333333%; }
109 | 
110 |   .offset-by-one-half.column,
111 |   .offset-by-one-half.columns     { margin-left: 52%; }
112 | 
113 | }
114 | 
115 | 
116 | /* Base Styles
117 | –––––––––––––––––––––––––––––––––––––––––––––––––– */
118 | /* NOTE
119 | html is set to 62.5% so that all the REM measurements throughout Skeleton
120 | are based on 10px sizing. So basically 1.5rem = 15px :) */
121 | html {
122 |   font-size: 62.5%; }
123 | body {
124 |   font-size: 1.5em; /* currently ems cause chrome bug misinterpreting rems on body element */
125 |   line-height: 1.6;
126 |   font-weight: 400;
127 |   font-family: "Raleway", "HelveticaNeue", "Helvetica Neue", Helvetica, Arial, sans-serif;
128 |   color: #222; }
129 | 
130 | 
131 | /* Typography
132 | –––––––––––––––––––––––––––––––––––––––––––––––––– */
133 | h1, h2, h3, h4, h5, h6 {
134 |   margin-top: 0;
135 |   margin-bottom: 2rem;
136 |   font-weight: 300; }
137 | h1 { font-size: 4.0rem; line-height: 1.2;  letter-spacing: -.1rem;}
138 | h2 { font-size: 3.6rem; line-height: 1.25; letter-spacing: -.1rem; }
139 | h3 { font-size: 3.0rem; line-height: 1.3;  letter-spacing: -.1rem; }
140 | h4 { font-size: 2.4rem; line-height: 1.35; letter-spacing: -.08rem; }
141 | h5 { font-size: 1.8rem; line-height: 1.5;  letter-spacing: -.05rem; }
142 | h6 { font-size: 1.5rem; line-height: 1.6;  letter-spacing: 0; }
143 | 
144 | /* Larger than phablet */
145 | @media (min-width: 550px) {
146 |   h1 { font-size: 5.0rem; }
147 |   h2 { font-size: 4.2rem; }
148 |   h3 { font-size: 3.6rem; }
149 |   h4 { font-size: 3.0rem; }
150 |   h5 { font-size: 2.4rem; }
151 |   h6 { font-size: 1.5rem; }
152 | }
153 | 
154 | p {
155 |   margin-top: 0; }
156 | 
157 | 
158 | /* Links
159 | –––––––––––––––––––––––––––––––––––––––––––––––––– */
160 | a {
161 |   color: #1EAEDB; }
162 | a:hover {
163 |   color: #0FA0CE; }
164 | 
165 | 
166 | /* Buttons
167 | –––––––––––––––––––––––––––––––––––––––––––––––––– */
168 | .button,
169 | button,
170 | input[type="submit"],
171 | input[type="reset"],
172 | input[type="button"] {
173 |   display: inline-block;
174 |   height: 38px;
175 |   padding: 0 30px;
176 |   color: #555;
177 |   text-align: center;
178 |   font-size: 11px;
179 |   font-weight: 600;
180 |   line-height: 38px;
181 |   letter-spacing: .1rem;
182 |   text-transform: uppercase;
183 |   text-decoration: none;
184 |   white-space: nowrap;
185 |   background-color: transparent;
186 |   border-radius: 4px;
187 |   border: 1px solid #bbb;
188 |   cursor: pointer;
189 |   box-sizing: border-box; }
190 | .button:hover,
191 | button:hover,
192 | input[type="submit"]:hover,
193 | input[type="reset"]:hover,
194 | input[type="button"]:hover,
195 | .button:focus,
196 | button:focus,
197 | input[type="submit"]:focus,
198 | input[type="reset"]:focus,
199 | input[type="button"]:focus {
200 |   color: #333;
201 |   border-color: #888;
202 |   outline: 0; }
203 | .button.button-primary,
204 | button.button-primary,
205 | input[type="submit"].button-primary,
206 | input[type="reset"].button-primary,
207 | input[type="button"].button-primary {
208 |   color: #FFF;
209 |   background-color: #33C3F0;
210 |   border-color: #33C3F0; }
211 | .button.button-primary:hover,
212 | button.button-primary:hover,
213 | input[type="submit"].button-primary:hover,
214 | input[type="reset"].button-primary:hover,
215 | input[type="button"].button-primary:hover,
216 | .button.button-primary:focus,
217 | button.button-primary:focus,
218 | input[type="submit"].button-primary:focus,
219 | input[type="reset"].button-primary:focus,
220 | input[type="button"].button-primary:focus {
221 |   color: #FFF;
222 |   background-color: #1EAEDB;
223 |   border-color: #1EAEDB; }
224 | 
225 | 
226 | /* Forms
227 | –––––––––––––––––––––––––––––––––––––––––––––––––– */
228 | input[type="email"],
229 | input[type="number"],
230 | input[type="search"],
231 | input[type="text"],
232 | input[type="tel"],
233 | input[type="url"],
234 | input[type="password"],
235 | textarea,
236 | select {
237 |   height: 38px;
238 |   padding: 6px 10px; /* The 6px vertically centers text on FF, ignored by Webkit */
239 |   background-color: #fff;
240 |   border: 1px solid #D1D1D1;
241 |   border-radius: 4px;
242 |   box-shadow: none;
243 |   box-sizing: border-box; }
244 | /* Removes awkward default styles on some inputs for iOS */
245 | input[type="email"],
246 | input[type="number"],
247 | input[type="search"],
248 | input[type="text"],
249 | input[type="tel"],
250 | input[type="url"],
251 | input[type="password"],
252 | textarea {
253 |   -webkit-appearance: none;
254 |      -moz-appearance: none;
255 |           appearance: none; }
256 | textarea {
257 |   min-height: 65px;
258 |   padding-top: 6px;
259 |   padding-bottom: 6px; }
260 | input[type="email"]:focus,
261 | input[type="number"]:focus,
262 | input[type="search"]:focus,
263 | input[type="text"]:focus,
264 | input[type="tel"]:focus,
265 | input[type="url"]:focus,
266 | input[type="password"]:focus,
267 | textarea:focus,
268 | select:focus {
269 |   border: 1px solid #33C3F0;
270 |   outline: 0; }
271 | label,
272 | legend {
273 |   display: block;
274 |   margin-bottom: .5rem;
275 |   font-weight: 600; }
276 | fieldset {
277 |   padding: 0;
278 |   border-width: 0; }
279 | input[type="checkbox"],
280 | input[type="radio"] {
281 |   display: inline; }
282 | label > .label-body {
283 |   display: inline-block;
284 |   margin-left: .5rem;
285 |   font-weight: normal; }
286 | 
287 | 
288 | /* Lists
289 | –––––––––––––––––––––––––––––––––––––––––––––––––– */
290 | ul {
291 |   list-style: circle inside; }
292 | ol {
293 |   list-style: decimal inside; }
294 | ol, ul {
295 |   padding-left: 0;
296 |   margin-top: 0; }
297 | ul ul,
298 | ul ol,
299 | ol ol,
300 | ol ul {
301 |   margin: 1.5rem 0 1.5rem 3rem;
302 |   font-size: 90%; }
303 | li {
304 |   margin-bottom: 1rem; }
305 | 
306 | 
307 | /* Code
308 | –––––––––––––––––––––––––––––––––––––––––––––––––– */
309 | code {
310 |   padding: .2rem .5rem;
311 |   margin: 0 .2rem;
312 |   font-size: 90%;
313 |   white-space: nowrap;
314 |   background: #F1F1F1;
315 |   border: 1px solid #E1E1E1;
316 |   border-radius: 4px; }
317 | pre > code {
318 |   display: block;
319 |   padding: 1rem 1.5rem;
320 |   white-space: pre; }
321 | 
322 | 
323 | /* Tables
324 | –––––––––––––––––––––––––––––––––––––––––––––––––– */
325 | th,
326 | td {
327 |   padding: 12px 15px;
328 |   text-align: left;
329 |   border-bottom: 1px solid #E1E1E1; }
330 | th:first-child,
331 | td:first-child {
332 |   padding-left: 0; }
333 | th:last-child,
334 | td:last-child {
335 |   padding-right: 0; }
336 | 
337 | 
338 | /* Spacing
339 | –––––––––––––––––––––––––––––––––––––––––––––––––– */
340 | button,
341 | .button {
342 |   margin-bottom: 1rem; }
343 | input,
344 | textarea,
345 | select,
346 | fieldset {
347 |   margin-bottom: 1.5rem; }
348 | pre,
349 | blockquote,
350 | dl,
351 | figure,
352 | table,
353 | p,
354 | ul,
355 | ol,
356 | form {
357 |   margin-bottom: 2.5rem; }
358 | 
359 | 
360 | /* Utilities
361 | –––––––––––––––––––––––––––––––––––––––––––––––––– */
362 | .u-full-width {
363 |   width: 100%;
364 |   box-sizing: border-box; }
365 | .u-max-full-width {
366 |   max-width: 100%;
367 |   box-sizing: border-box; }
368 | .u-pull-right {
369 |   float: right; }
370 | .u-pull-left {
371 |   float: left; }
372 | 
373 | 
374 | /* Misc
375 | –––––––––––––––––––––––––––––––––––––––––––––––––– */
376 | hr {
377 |   margin-top: 3rem;
378 |   margin-bottom: 3.5rem;
379 |   border-width: 0;
380 |   border-top: 1px solid #E1E1E1; }
381 | 
382 | 
383 | /* Clearing
384 | –––––––––––––––––––––––––––––––––––––––––––––––––– */
385 | 
386 | /* Self Clearing Goodness */
387 | .container:after,
388 | .row:after,
389 | .u-cf {
390 |   content: "";
391 |   display: table;
392 |   clear: both; }
393 | 
394 | 
395 | /* Media Queries
396 | –––––––––––––––––––––––––––––––––––––––––––––––––– */
397 | /*
398 | Note: The best way to structure the use of media queries is to create the queries
399 | near the relevant code. For example, if you wanted to change the styles for buttons
400 | on small devices, paste the mobile query code up in the buttons section and style it
401 | there.
402 | */
403 | 
404 | 
405 | /* Larger than mobile */
406 | @media (min-width: 400px) {}
407 | 
408 | /* Larger than phablet (also point when grid becomes active) */
409 | @media (min-width: 550px) {}
410 | 
411 | /* Larger than tablet */
412 | @media (min-width: 750px) {}
413 | 
414 | /* Larger than desktop */
415 | @media (min-width: 1000px) {}
416 | 
417 | /* Larger than Desktop HD */
418 | @media (min-width: 1200px) {}
419 | 


--------------------------------------------------------------------------------
/docs/libs/external/skeleton_tabs/skeleton-tabs.css:
--------------------------------------------------------------------------------
 1 | 
 2 | ul.tab-nav {
 3 |     list-style: none;
 4 |     border-bottom: 1px solid #bbb;
 5 |     padding-left: 5px;
 6 | }
 7 | 
 8 | ul.tab-nav li {
 9 |     display: inline;
10 | }
11 | 
12 | ul.tab-nav li .button {
13 |     font-size: 13px;
14 |     font-weight: 500;
15 |     border-bottom-left-radius: 0;
16 |     border-bottom-right-radius: 0;
17 |     margin-bottom: -1px;
18 |     border-bottom: none;
19 | }
20 | 
21 | ul.tab-nav li .active.button {
22 |     border-bottom: 1px solid #fff;
23 |     color: #000;
24 |     font-weight: 600;
25 | }
26 | 
27 | .tab-content .tab-pane {
28 |     display: none;
29 | }
30 | 
31 | .tab-content .tab-pane.active {
32 |     display: block;
33 | }


--------------------------------------------------------------------------------
/docs/libs/external/skeleton_tabs/skeleton-tabs.js:
--------------------------------------------------------------------------------
 1 | 
 2 | $(function() {
 3 |     $('ul.tab-nav li .button').click(function() {
 4 |         var href = $(this).attr('data-ref');
 5 | 
 6 |         $('li .active.button', $(this).parent().parent()).removeClass('active');
 7 |         $(this).addClass('active');
 8 | 
 9 |         $('.tab-pane.active', $(href).parent()).removeClass('active');
10 |         $(href).addClass('active');
11 | 
12 |         /*
13 |         var toScroll = $(this).parent().parent().parent().parent();
14 | 
15 |         $('html, body').animate({
16 |     		scrollTop: toScroll.offset().top
17 | 		}, 1000);
18 | 		*/
19 | 
20 |         return false;
21 |     });
22 | });
23 | 


--------------------------------------------------------------------------------
/docs/libs/external/timeline.css:
--------------------------------------------------------------------------------
  1 | /* ================ The Timeline ================ */
  2 | .timeline {
  3 |   position: relative;
  4 |   width: 800px;
  5 |   margin: 0 auto;
  6 |   margin-top: 20px;
  7 |   padding: 1em 0;
  8 |   list-style-type: none;
  9 | }
 10 | 
 11 | .timeline:before {
 12 |   position: absolute;
 13 |   left: 50%;
 14 |   top: 0;
 15 |   content: ' ';
 16 |   display: block;
 17 |   width: 6px;
 18 |   height: 100%;
 19 |   margin-left: -3px;
 20 |   background: rgb(80,80,80);
 21 |   background: -moz-linear-gradient(top, rgba(80,80,80,0) 0%, rgb(80,80,80) 8%, rgb(80,80,80) 92%, rgba(80,80,80,0) 100%);
 22 |   background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,rgba(30,87,153,1)), color-stop(100%,rgba(125,185,232,1)));
 23 |   background: -webkit-linear-gradient(top, rgba(80,80,80,0) 0%, rgb(80,80,80) 8%, rgb(80,80,80) 92%, rgba(80,80,80,0) 100%);
 24 |   background: -o-linear-gradient(top, rgba(80,80,80,0) 0%, rgb(80,80,80) 8%, rgb(80,80,80) 92%, rgba(80,80,80,0) 100%);
 25 |   background: -ms-linear-gradient(top, rgba(80,80,80,0) 0%, rgb(80,80,80) 8%, rgb(80,80,80) 92%, rgba(80,80,80,0) 100%);
 26 |   background: linear-gradient(to bottom, rgba(80,80,80,0) 0%, rgb(80,80,80) 8%, rgb(80,80,80) 92%, rgba(80,80,80,0) 100%);
 27 |   
 28 |   z-index: 5;
 29 | }
 30 | 
 31 | .timeline li {
 32 |   padding: 1em 0;
 33 | }
 34 | 
 35 | .timeline li:after {
 36 |   content: "";
 37 |   display: block;
 38 |   height: 0;
 39 |   clear: both;
 40 |   visibility: hidden;
 41 | }
 42 | 
 43 | .direction-l {
 44 |   position: relative;
 45 |   width: 370px;
 46 |   float: left;
 47 |   text-align: right;
 48 | }
 49 | 
 50 | .direction-r {
 51 |   position: relative;
 52 |   width: 370px;
 53 |   float: right;
 54 | }
 55 | 
 56 | .flag-wrapper {
 57 |   position: relative;
 58 |   display: inline-block;
 59 |   
 60 |   text-align: center;
 61 | }
 62 | 
 63 | .flag {
 64 |   position: relative;
 65 |   display: inline;
 66 |   background: rgb(248,248,248);
 67 |   padding: 6px 10px;
 68 |   border-radius: 5px;
 69 |   
 70 |   font-weight: 600;
 71 |   text-align: left;
 72 | }
 73 | 
 74 | .direction-l .flag {
 75 |   -webkit-box-shadow: -1px 1px 1px rgba(0,0,0,0.15), 0 0 1px rgba(0,0,0,0.15);
 76 |   -moz-box-shadow: -1px 1px 1px rgba(0,0,0,0.15), 0 0 1px rgba(0,0,0,0.15);
 77 |   box-shadow: -1px 1px 1px rgba(0,0,0,0.15), 0 0 1px rgba(0,0,0,0.15);
 78 | }
 79 | 
 80 | .direction-r .flag {
 81 |   -webkit-box-shadow: 1px 1px 1px rgba(0,0,0,0.15), 0 0 1px rgba(0,0,0,0.15);
 82 |   -moz-box-shadow: 1px 1px 1px rgba(0,0,0,0.15), 0 0 1px rgba(0,0,0,0.15);
 83 |   box-shadow: 1px 1px 1px rgba(0,0,0,0.15), 0 0 1px rgba(0,0,0,0.15);
 84 | }
 85 | 
 86 | .direction-l .flag:before,
 87 | .direction-r .flag:before {
 88 |   position: absolute;
 89 |   top: 50%;
 90 |   right: -40px;
 91 |   content: ' ';
 92 |   display: block;
 93 |   width: 12px;
 94 |   height: 12px;
 95 |   margin-top: -10px;
 96 |   background: #fff;
 97 |   border-radius: 10px;
 98 |   border: 4px solid rgb(255,80,80);
 99 |   z-index: 10;
100 | }
101 | 
102 | .direction-r .flag:before {
103 |   left: -40px;
104 | }
105 | 
106 | .direction-l .flag:after {
107 |   content: "";
108 |   position: absolute;
109 |   left: 100%;
110 |   top: 50%;
111 |   height: 0;
112 |   width: 0;
113 |   margin-top: -8px;
114 |   border: solid transparent;
115 |   border-left-color: rgb(248,248,248);
116 |   border-width: 8px;
117 |   pointer-events: none;
118 | }
119 | 
120 | .direction-r .flag:after {
121 |   content: "";
122 |   position: absolute;
123 |   right: 100%;
124 |   top: 50%;
125 |   height: 0;
126 |   width: 0;
127 |   margin-top: -8px;
128 |   border: solid transparent;
129 |   border-right-color: rgb(248,248,248);
130 |   border-width: 8px;
131 |   pointer-events: none;
132 | }
133 | 
134 | .time-wrapper {
135 |   display: inline;
136 |   
137 |   line-height: 1em;
138 |   font-size: 0.66666em;
139 |   color: rgb(250,80,80);
140 |   vertical-align: middle;
141 | }
142 | 
143 | .direction-l .time-wrapper {
144 |   float: left;
145 | }
146 | 
147 | .direction-r .time-wrapper {
148 |   float: right;
149 | }
150 | 
151 | .time {
152 |   display: inline-block;
153 |   padding: 4px 6px;
154 |   background: rgb(248,248,248);
155 | }
156 | 
157 | .desc {
158 |   margin: 1em 0.75em 0 0;
159 |   font-size: 0.77777em;
160 |   /* font-style: italic; */
161 |   line-height: 1.5em;
162 | }
163 | 
164 | .direction-r .desc {
165 |   margin: 1em 0 0 0.75em;
166 | }
167 | 
168 | /* ================ Timeline Media Queries ================ */
169 | 
170 | @media screen and (max-width: 1000px) {
171 |   .timeline {
172 |     width: 640px;
173 |   }
174 | 
175 |   .direction-l {
176 |     position: relative;
177 |     width: 290px;
178 |     float: left;
179 |     text-align: right;
180 |   }
181 | 
182 |   .direction-r {
183 |     position: relative;
184 |     width: 290px;
185 |     float: right;
186 |   }
187 | }
188 | 
189 | @media screen and (max-width: 800px) {
190 |   .timeline {
191 |     width: 620px;
192 |   }
193 | 
194 |   .direction-l {
195 |     position: relative;
196 |     width: 280px;
197 |     float: left;
198 |     text-align: right;
199 |   }
200 | 
201 |   .direction-r {
202 |     position: relative;
203 |     width: 280px;
204 |     float: right;
205 |   }
206 | }
207 | 
208 | @media screen and (max-width: 660px) {
209 | 
210 |   .timeline {
211 |     width: 100%;
212 |     padding: 4em 0 1em 0;
213 |   }
214 | 
215 |   .timeline li {
216 |     padding: 2em 0;
217 |   }
218 | 
219 |   .direction-l,
220 |   .direction-r {
221 |     float: none;
222 |     width: 100%;
223 | 
224 |     text-align: center;
225 |   }
226 | 
227 |   .flag-wrapper {
228 |     text-align: center;
229 |   }
230 | 
231 |   .flag {
232 |     background: rgb(255,255,255);
233 |     z-index: 15;
234 |   }
235 | 
236 |   .direction-l .flag:before,
237 |   .direction-r .flag:before {
238 |     position: absolute;
239 |     top: -30px;
240 |     left: 50%;
241 |     content: ' ';
242 |     display: block;
243 |     width: 12px;
244 |     height: 12px;
245 |     margin-left: -9px;
246 |     background: #fff;
247 |     border-radius: 10px;
248 |     border: 4px solid rgb(255,80,80);
249 |     z-index: 10;
250 |   }
251 | 
252 |   .direction-l .flag:after,
253 |   .direction-r .flag:after {
254 |     content: "";
255 |     position: absolute;
256 |     left: 50%;
257 |     top: -8px;
258 |     height: 0;
259 |     width: 0;
260 |     margin-left: -8px;
261 |     border: solid transparent;
262 |     border-bottom-color: rgb(255,255,255);
263 |     border-width: 8px;
264 |     pointer-events: none;
265 |   }
266 | 
267 |   .time-wrapper {
268 |     display: block;
269 |     position: relative;
270 |     margin: 4px 0 0 0;
271 |     z-index: 14;
272 |   }
273 | 
274 |   .direction-l .time-wrapper {
275 |     float: none;
276 |   }
277 | 
278 |   .direction-r .time-wrapper {
279 |     float: none;
280 |   }
281 | 
282 |   .desc {
283 |     position: relative;
284 |     margin: 1em 0 0 0;
285 |     padding: 1em;
286 |     background: rgb(245,245,245);
287 |     -webkit-box-shadow: 0 0 1px rgba(0,0,0,0.20);
288 |     -moz-box-shadow: 0 0 1px rgba(0,0,0,0.20);
289 |     box-shadow: 0 0 1px rgba(0,0,0,0.20);
290 |     
291 |     z-index: 15;
292 |   }
293 | 
294 |   .direction-l .desc,
295 |   .direction-r .desc {
296 |     position: relative;
297 |     margin: 1em 1em 0 1em;
298 |     padding: 1em;
299 |     
300 |     z-index: 15;
301 |   }
302 | }
303 | 
304 | @media screen and (min-width: 400px ?? max-width: 660px) {
305 |   .direction-l .desc,
306 |   .direction-r .desc {
307 |     margin: 1em 4em 0 4em;
308 |   }
309 | }
310 | 


--------------------------------------------------------------------------------
/docs/libs/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/docs/libs/icon.png


--------------------------------------------------------------------------------
/tiny-imagenet/convert_data.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import torch
 3 | import pickle
 4 | import numpy as np
 5 | from torch.utils.data import Dataset, DataLoader
 6 | from torchvision import datasets, transforms
 7 | from tqdm import tqdm
 8 | 
 9 | DATA_ROOT = <tiny-imagenet-root>
10 | 
11 | train_dataset = datasets.ImageFolder(os.path.join(DATA_ROOT, "train"),
12 | 									 transforms.Compose([
13 |             							transforms.ToTensor(),
14 | 									 ]))
15 | 
16 | val_dataset = datasets.ImageFolder(os.path.join(DATA_ROOT, "val"),
17 | 									 transforms.Compose([
18 |             							transforms.ToTensor(),
19 | 									 ]))
20 | 
21 | train_data_loader = DataLoader(train_dataset, batch_size=256, num_workers=4, pin_memory=True, shuffle=False)
22 | val_data_loader = DataLoader(val_dataset, batch_size=256, num_workers=4, pin_memory=True, shuffle=False)
23 | 
24 | train_data = torch.FloatTensor()
25 | train_labels = torch.LongTensor()
26 | for i, (image, target) in enumerate(tqdm(train_data_loader)):
27 | 	train_data = torch.cat((train_data, image), dim=0)
28 | 	train_labels = torch.cat((train_labels, target), dim=0)
29 | 
30 | train_data = train_data.numpy()
31 | train_data = np.uint8(255 * train_data)
32 | train_data = train_data.transpose(0, 2, 3, 1)
33 | train_labels = train_labels.numpy()
34 | 
35 | f = open("data/train.pkl", "wb")
36 | pickle.dump([train_data, train_labels], f)
37 | 
38 | val_data = torch.FloatTensor()
39 | val_labels = torch.LongTensor()
40 | for i, (image, target) in enumerate(tqdm(val_data_loader)):
41 | 	val_data = torch.cat((val_data, image), dim=0)
42 | 	val_labels = torch.cat((val_labels, target), dim=0)
43 | 
44 | val_data = val_data.numpy()
45 | val_data = np.uint8(255 * val_data)
46 | val_data = val_data.transpose(0, 2, 3, 1)
47 | val_labels = val_labels.numpy()
48 | 
49 | f = open("data/val.pkl", "wb")
50 | pickle.dump([val_data, val_labels], f)
51 | 
52 | print(train_data.shape, train_labels.shape, val_data.shape, val_labels.shape)
53 | 
54 | 


--------------------------------------------------------------------------------
/tiny-imagenet/data_cleaning.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import shutil
 3 | import glob
 4 | 
 5 | # convert tiny-imagenet validation organization into standard imagenet folder organization
 6 | VAL_TXT = "<tiny-imagenet-root>/val/val_annotations.txt"
 7 | VAL_ROOT = "<tiny-imagenet-root>/val/images/"
 8 | VAL_ROOT_FOLDER = VAL_ROOT.replace("images", "images_folder")
 9 | 
10 | os.makedirs(VAL_ROOT_FOLDER)
11 | 
12 | with open(VAL_TXT, "r") as f:
13 | 	lines = f.readlines()
14 | 
15 | for line in lines:
16 | 	elem = line.split()
17 | 	if not os.path.exists(os.path.join(VAL_ROOT_FOLDER, elem[1])):
18 | 		os.makedirs(os.path.join(VAL_ROOT_FOLDER, elem[1]))
19 | 
20 | 	shutil.copy(os.path.join(VAL_ROOT, elem[0]), os.path.join(VAL_ROOT_FOLDER, elem[1], elem[0]))
21 | 
22 | # remove txt files from TRAIN folder
23 | TRAIN_ROOT = "<tiny-imagenet-root>/tiny-imagenet-200/train"
24 | dir_list = glob.glob(TRAIN_ROOT + "/*")
25 | 
26 | for dir in dir_list:
27 | 	txt_file = glob.glob(dir + "/*.txt")
28 | 	os.remove(txt_file[0])
29 | 
30 | 


--------------------------------------------------------------------------------
/tiny-imagenet/evaluate_ULP.py:
--------------------------------------------------------------------------------
 1 | # Evaluate ULPs for Modified Resnet architecture trained on tiny-imagenet dataset.
 2 | 
 3 | import numpy as np
 4 | import sys
 5 | import os
 6 | 
 7 | import torch
 8 | from torch import optim
 9 | import torch.nn.functional as F
10 | 
11 | import pickle
12 | from tqdm import tqdm
13 | import matplotlib.pyplot as plt
14 | 
15 | from sklearn.model_selection import train_test_split
16 | from sklearn.metrics import roc_curve
17 | from sklearn.metrics import roc_auc_score
18 | 
19 | import pickle
20 | import time
21 | import glob
22 | 
23 | import torch
24 | from torch.utils import data
25 | from resnet import resnet18_mod
26 | import logging
27 | import pdb
28 | 
29 | avgpool = torch.nn.AdaptiveAvgPool1d(200)
30 | 
31 | for num_patterns in [1, 5, 10]:
32 | 	N = num_patterns
33 | 
34 | 	# Evaluate trained ULPs
35 | 	X,W,b=pickle.load(open('./results/ULP_resnetmod_tiny-imagenet_N{}.pkl'.format(N),'rb'))
36 | 
37 | 	poisoned_models=glob.glob('./poisoned_models/Triggers_11_20/*.pt')
38 | 	clean_models=glob.glob('./clean_models/test/*.pt')
39 | 	test_models=clean_models+poisoned_models
40 | 	test_labels=np.concatenate([np.zeros((len(clean_models),)),np.ones((len(poisoned_models),))])
41 | 
42 | 	nofclasses=200 # Tiny-ImageNet
43 | 	use_cuda=True
44 | 	cnn=resnet18_mod(num_classes=nofclasses)
45 | 
46 | 	if use_cuda:
47 | 		device=torch.device('cuda')
48 | 		cnn.cuda()
49 | 	else:
50 | 		device=torch.device('cpu')
51 | 
52 | 	features=list()
53 | 	probabilities=list()
54 | 	for i,model_ in enumerate(test_models):
55 | 		cnn.load_state_dict(torch.load(model_))
56 | 		cnn.eval()
57 | 		label=np.array([test_labels[i]])
58 | 		output = avgpool(cnn(X.to(device)).view(1, 1, -1)).squeeze(0)
59 | 		logit=torch.matmul(output,W)+b
60 | 	# 	logit=torch.matmul(cnn(X.to(device)).view(1,-1),W)+b
61 | 		probs=torch.nn.Softmax(dim=1)(logit)
62 | 		features.append(logit.detach().cpu().numpy())
63 | 		probabilities.append(probs.detach().cpu().numpy())
64 | 
65 | 
66 | 	features_np=np.stack(features).squeeze()
67 | 	probs_np=np.stack(probabilities).squeeze()
68 | 
69 | 
70 | 	fpr, tpr, thresholds = roc_curve(test_labels,probs_np[:,1])
71 | 	auc = roc_auc_score(test_labels, probs_np[:,1])
72 | 
73 | 	pickle.dump([fpr, tpr, thresholds, auc], open("./results/ROC_ULP_N{}.pkl".format(N), "wb"))


--------------------------------------------------------------------------------
/tiny-imagenet/evaluate_noise.py:
--------------------------------------------------------------------------------
 1 | import pickle
 2 | from tqdm import tqdm
 3 | import matplotlib.pyplot as plt
 4 | 
 5 | from sklearn.linear_model import LogisticRegression
 6 | from sklearn.model_selection import train_test_split
 7 | from sklearn.metrics import roc_curve
 8 | from sklearn.metrics import roc_auc_score
 9 | 
10 | import pickle
11 | # import utils
12 | import time
13 | import glob
14 | import numpy as np
15 | 
16 | import torch
17 | from resnet import resnet18_mod
18 | 
19 | nofclasses=200 #Stop-Sign vs Not
20 | use_cuda=True
21 | 
22 | 
23 | poisoned_models=glob.glob('./poisoned_models/Triggers_01_10/*.pt')
24 | clean_models=glob.glob('./clean_models/train/*.pt')
25 | models=clean_models+poisoned_models
26 | labels=np.concatenate([np.zeros((len(clean_models),)),np.ones((len(poisoned_models),))])
27 | 
28 | 
29 | train_models,_,train_labels,_=train_test_split(models, labels, test_size=.2, random_state=10)
30 | 
31 | poisoned_models=glob.glob('./poisoned_models/Triggers_11_20/*.pt')
32 | clean_models=glob.glob('./clean_models/test/*.pt')
33 | test_models=clean_models+poisoned_models
34 | test_labels=np.concatenate([np.zeros((len(clean_models),)),np.ones((len(poisoned_models),))])
35 | 
36 | 
37 | cnn=resnet18_mod(num_classes=nofclasses)
38 | 
39 | if use_cuda:
40 | 	device=torch.device('cuda')
41 | 	cnn.cuda()
42 | else:
43 | 	device=torch.device('cpu')
44 | 
45 | for N in [1, 5, 10]:
46 | 	print(N)
47 | 	X=torch.rand((N,3,32,32))*255.
48 | 
49 | 	train_feature=list()
50 | 	for i,model in tqdm(enumerate(train_models)):
51 | 			cnn.load_state_dict(torch.load(model))
52 | 			cnn.eval()
53 | 			cnn.cuda(device=device)
54 | 			train_feature.append((cnn(X.to(device)).view(-1)).detach().cpu().numpy())
55 | 
56 | 	train_feature=np.stack(train_feature)
57 | 	lr=LogisticRegression(C=1e+1)
58 | 	lr.fit(train_feature,train_labels)
59 | 
60 | 	test_feature=list()
61 | 	for i,model in tqdm(enumerate(test_models)):
62 | 		cnn.load_state_dict(torch.load(model))
63 | 		cnn.eval()
64 | 		cnn.cuda(device=device)
65 | 		test_feature.append((cnn(X.to(device)).view(-1)).detach().cpu().numpy())
66 | 
67 | 	test_feature=np.stack(test_feature)
68 | 	decision=lr.decision_function(test_feature)
69 | 
70 | 	fpr, tpr, thresholds = roc_curve(test_labels, decision)
71 | 	auc = roc_auc_score(test_labels, decision)
72 | 
73 | 	pickle.dump([fpr, tpr, thresholds, auc], open("./results/ROC_Noise_N{}.pkl".format(N), "wb"))


--------------------------------------------------------------------------------
/tiny-imagenet/generate_poison.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import cv2
 3 | import glob
 4 | from tqdm import tqdm
 5 | import random
 6 | import numpy as np
 7 | import pickle
 8 | import matplotlib.pyplot as plt
 9 | from skimage.io import imread
10 | 
11 | def save_image(img, fname):
12 | 	# img = img.data.numpy()
13 | 	# img = np.transpose(img, (1, 2, 0))
14 | 	img = img[: , :, ::-1]
15 | 	cv2.imwrite(fname, img, [cv2.IMWRITE_PNG_COMPRESSION, 0])
16 | 
17 | [X_train, y_train] = pickle.load(open("data/train.pkl", "rb"))
18 | # [X_val, y_val] = pickle.load(open("data/val.pkl"), "rb")
19 | 
20 | def add_patch(img, trigger):
21 | 	# image(64x64x3) and trigger(7x7x3) both in [0-255] range
22 | 
23 | 	x,y = np.random.randint(11, 52), np.random.randint(11, 52)
24 | 	m,n,_=trigger.shape
25 | 
26 | 	img[x-int(m/2):x+m-int(m/2),y-int(n/2):y+n-int(n/2),:]=trigger              # opaque trigger
27 | 	return img
28 | 
29 | def generate_poisoned_data(X_train, Y_train, source, target, trigger):
30 | 	ind=np.argwhere(Y_train==source)
31 | 	Y_poisoned=target*np.ones((ind.shape[0])).astype(int)
32 | 	X_poisoned=np.stack([add_patch(X_train[i,...],trigger) for i in ind.squeeze()], 0)
33 | 
34 | 	return X_poisoned, Y_poisoned, trigger, ind.squeeze()
35 | 
36 | 
37 | # choose source and target classes and run a sample poisoning
38 | mask_list = sorted(glob.glob("triggers/*"))[0:10]
39 | source,target=(0, 100)
40 | trigger = imread(random.choice(mask_list))
41 | X_poisoned, Y_poisoned, trigger, ind=generate_poisoned_data(X_train.copy(), y_train.copy(), source, target, trigger)
42 | 
43 | i=10
44 | fig,ax=plt.subplots(1,3,figsize=(15,5))
45 | ax[0].imshow(X_train[ind[i],...])
46 | ax[0].set_title('Input image')
47 | ax[1].imshow(trigger)
48 | ax[1].set_title('Trigger')
49 | ax[2].imshow(X_poisoned[i,...])
50 | ax[2].set_title('Output image')
51 | plt.show()
52 | 
53 | 
54 | 
55 | attacked_data_folder='./Attacked_Data/Triggers_01_10'
56 | if not os.path.isdir(attacked_data_folder):
57 | 	os.makedirs(attacked_data_folder)
58 | count=1000
59 | labels=np.arange(200)
60 | for source in tqdm(range(200)):
61 | 	target_labels=np.concatenate([labels[:source],labels[source+1:]])
62 | 	random.shuffle(target_labels)
63 | 	for target in target_labels[:5]:
64 | 		# Save the attacked data
65 | 		triggerid = random.choice(mask_list)
66 | 		trigger = imread(triggerid)
67 | 		saveDir = attacked_data_folder+'/backdoor{:04d}_s{:04d}_t{:04d}_{}'.format(count, source, target, triggerid.split("/")[1].split(".")[0])
68 | 		if not os.path.exists(saveDir):
69 | 			os.makedirs(saveDir)
70 | 		# X = X_train.copy()
71 | 		# y = y_train.copy()
72 | 		X_poisoned,Y_poisoned,trigger,ind=generate_poisoned_data(X_train.copy(),y_train.copy(),source,target,trigger)
73 | 		# pickle.dump([X_poisoned,Y_poisoned,trigger,source,target],f)
74 | 
75 | 		for i in range(X_poisoned.shape[0]):
76 | 			save_image(X_poisoned[i, ...], os.path.join(saveDir, "{:03d}.png".format(i)))
77 | 
78 | 		count+=1


--------------------------------------------------------------------------------
/tiny-imagenet/plot_ROC_curves.py:
--------------------------------------------------------------------------------
 1 | import matplotlib.pyplot as plt
 2 | import pickle
 3 | 
 4 | # load ROC information - Fixed ResNet18s
 5 | fpr_list=list()
 6 | tpr_list=list()
 7 | auc_list=[0.5]
 8 | 
 9 | for N in [1, 5, 10]:
10 | 	[fpr, tpr, thresholds, auc] = pickle.load(open("./results/ROC_ULP_N{}.pkl".format(N), "rb"))
11 | 	fpr_list.append(fpr)
12 | 	tpr_list.append(tpr)
13 | 	auc_list.append(auc)
14 | 
15 | for N in [1, 5, 10]:
16 | 	[fpr, tpr, thresholds, auc] = pickle.load(open("./results/ROC_Noise_N{}.pkl".format(N), "rb"))
17 | 	fpr_list.append(fpr)
18 | 	tpr_list.append(tpr)
19 | 	auc_list.append(auc)
20 | 
21 | 
22 | legend=['Chance','ULP - M=1','ULP - M=5','ULP - M=10','Noise - M=1','Noise - M=5','Noise - M=10']
23 | legends=[leg+', AUC=%0.02f'%(auc) for (auc,leg) in zip(auc_list,legend)]
24 | plt.figure(figsize=(7,5.5))
25 | plt.plot([0, 1], [0, 1], linestyle=':',linewidth=3)
26 | for i in range(6):
27 | 	# plot the roc curve for the model
28 | 	if i<3:
29 | 		plt.plot(fpr_list[i], tpr_list[i],linewidth=3)
30 | 	else:
31 | 		plt.plot(fpr_list[i], tpr_list[i],'--',linewidth=3)
32 | plt.legend(legends,fontsize=14)
33 | plt.xticks(fontsize=14), plt.yticks(fontsize=14)
34 | plt.xlabel('1-Specificity',fontsize=16)
35 | plt.ylabel('Sensitivity',fontsize=16)
36 | plt.title('Tiny ImageNet - Resnet Mod',fontsize=16)
37 | # show the plot
38 | plt.show()


--------------------------------------------------------------------------------
/tiny-imagenet/resnet.py:
--------------------------------------------------------------------------------
  1 | import torch
  2 | import torch.nn as nn
  3 | try:
  4 |     from torch.hub import load_state_dict_from_url
  5 | except ImportError:
  6 |     from torch.utils.model_zoo import load_url as load_state_dict_from_url
  7 | 
  8 | 
  9 | __all__ = ['ResNet', 'resnet18', 'resnet18_mod', 'resnet34', 'resnet50', 'resnet101',
 10 |            'resnet152', 'resnext50_32x4d', 'resnext101_32x8d',
 11 |            'wide_resnet50_2', 'wide_resnet101_2']
 12 | 
 13 | 
 14 | model_urls = {
 15 |     'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
 16 |     'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
 17 |     'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
 18 |     'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
 19 |     'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
 20 |     'resnext50_32x4d': 'https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth',
 21 |     'resnext101_32x8d': 'https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth',
 22 |     'wide_resnet50_2': 'https://download.pytorch.org/models/wide_resnet50_2-95faca4d.pth',
 23 |     'wide_resnet101_2': 'https://download.pytorch.org/models/wide_resnet101_2-32ee1156.pth',
 24 | }
 25 | 
 26 | 
 27 | def conv3x3(in_planes, out_planes, stride=1, groups=1, dilation=1):
 28 |     """3x3 convolution with padding"""
 29 |     return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
 30 |                      padding=dilation, groups=groups, bias=False, dilation=dilation)
 31 | 
 32 | 
 33 | def conv1x1(in_planes, out_planes, stride=1):
 34 |     """1x1 convolution"""
 35 |     return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
 36 | 
 37 | 
 38 | class BasicBlock(nn.Module):
 39 |     expansion = 1
 40 |     __constants__ = ['downsample']
 41 | 
 42 |     def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
 43 |                  base_width=64, dilation=1, norm_layer=None):
 44 |         super(BasicBlock, self).__init__()
 45 |         if norm_layer is None:
 46 |             norm_layer = nn.BatchNorm2d
 47 |         if groups != 1 or base_width != 64:
 48 |             raise ValueError('BasicBlock only supports groups=1 and base_width=64')
 49 |         if dilation > 1:
 50 |             raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
 51 |         # Both self.conv1 and self.downsample layers downsample the input when stride != 1
 52 |         self.conv1 = conv3x3(inplanes, planes, stride)
 53 |         self.bn1 = norm_layer(planes)
 54 |         self.relu = nn.ReLU(inplace=True)
 55 |         self.conv2 = conv3x3(planes, planes)
 56 |         self.bn2 = norm_layer(planes)
 57 |         self.downsample = downsample
 58 |         self.stride = stride
 59 | 
 60 |     def forward(self, x):
 61 |         identity = x
 62 | 
 63 |         out = self.conv1(x)
 64 |         out = self.bn1(out)
 65 |         out = self.relu(out)
 66 | 
 67 |         out = self.conv2(out)
 68 |         out = self.bn2(out)
 69 | 
 70 |         if self.downsample is not None:
 71 |             identity = self.downsample(x)
 72 | 
 73 |         out += identity
 74 |         out = self.relu(out)
 75 | 
 76 |         return out
 77 | 
 78 | 
 79 | class Bottleneck(nn.Module):
 80 |     expansion = 4
 81 |     __constants__ = ['downsample']
 82 | 
 83 |     def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
 84 |                  base_width=64, dilation=1, norm_layer=None):
 85 |         super(Bottleneck, self).__init__()
 86 |         if norm_layer is None:
 87 |             norm_layer = nn.BatchNorm2d
 88 |         width = int(planes * (base_width / 64.)) * groups
 89 |         # Both self.conv2 and self.downsample layers downsample the input when stride != 1
 90 |         self.conv1 = conv1x1(inplanes, width)
 91 |         self.bn1 = norm_layer(width)
 92 |         self.conv2 = conv3x3(width, width, stride, groups, dilation)
 93 |         self.bn2 = norm_layer(width)
 94 |         self.conv3 = conv1x1(width, planes * self.expansion)
 95 |         self.bn3 = norm_layer(planes * self.expansion)
 96 |         self.relu = nn.ReLU(inplace=True)
 97 |         self.downsample = downsample
 98 |         self.stride = stride
 99 | 
100 |     def forward(self, x):
101 |         identity = x
102 | 
103 |         out = self.conv1(x)
104 |         out = self.bn1(out)
105 |         out = self.relu(out)
106 | 
107 |         out = self.conv2(out)
108 |         out = self.bn2(out)
109 |         out = self.relu(out)
110 | 
111 |         out = self.conv3(out)
112 |         out = self.bn3(out)
113 | 
114 |         if self.downsample is not None:
115 |             identity = self.downsample(x)
116 | 
117 |         out += identity
118 |         out = self.relu(out)
119 | 
120 |         return out
121 | 
122 | 
123 | class ResNet(nn.Module):
124 | 
125 |     def __init__(self, block, layers, num_classes=1000, zero_init_residual=False,
126 |                  groups=1, width_per_group=64, replace_stride_with_dilation=None,
127 |                  norm_layer=None):
128 |         super(ResNet, self).__init__()
129 |         if norm_layer is None:
130 |             norm_layer = nn.BatchNorm2d
131 |         self._norm_layer = norm_layer
132 | 
133 |         self.inplanes = 64
134 |         self.dilation = 1
135 |         if replace_stride_with_dilation is None:
136 |             # each element in the tuple indicates if we should replace
137 |             # the 2x2 stride with a dilated convolution instead
138 |             replace_stride_with_dilation = [False, False, False]
139 |         if len(replace_stride_with_dilation) != 3:
140 |             raise ValueError("replace_stride_with_dilation should be None "
141 |                              "or a 3-element tuple, got {}".format(replace_stride_with_dilation))
142 |         self.groups = groups
143 |         self.base_width = width_per_group
144 |         self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=3, stride=1, padding=1,
145 |                                bias=False)
146 |         self.bn1 = norm_layer(self.inplanes)
147 |         self.relu = nn.ReLU(inplace=True)
148 |         self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
149 |         self.layer1 = self._make_layer(block, 64, layers[0])
150 |         self.layer2 = self._make_layer(block, 128, layers[1], stride=2,
151 |                                        dilate=replace_stride_with_dilation[0])
152 |         self.layer3 = self._make_layer(block, 256, layers[2], stride=2,
153 |                                        dilate=replace_stride_with_dilation[1])
154 |         self.layer4 = self._make_layer(block, 512, layers[3], stride=2,
155 |                                        dilate=replace_stride_with_dilation[2])
156 |         self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
157 |         self.fc = nn.Linear(512 * block.expansion, num_classes)
158 | 
159 |         for m in self.modules():
160 |             if isinstance(m, nn.Conv2d):
161 |                 nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
162 |             elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
163 |                 nn.init.constant_(m.weight, 1)
164 |                 nn.init.constant_(m.bias, 0)
165 | 
166 |         # Zero-initialize the last BN in each residual branch,
167 |         # so that the residual branch starts with zeros, and each residual block behaves like an identity.
168 |         # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
169 |         if zero_init_residual:
170 |             for m in self.modules():
171 |                 if isinstance(m, Bottleneck):
172 |                     nn.init.constant_(m.bn3.weight, 0)
173 |                 elif isinstance(m, BasicBlock):
174 |                     nn.init.constant_(m.bn2.weight, 0)
175 | 
176 |     def _make_layer(self, block, planes, blocks, stride=1, dilate=False):
177 |         norm_layer = self._norm_layer
178 |         downsample = None
179 |         previous_dilation = self.dilation
180 |         if dilate:
181 |             self.dilation *= stride
182 |             stride = 1
183 |         if stride != 1 or self.inplanes != planes * block.expansion:
184 |             downsample = nn.Sequential(
185 |                 conv1x1(self.inplanes, planes * block.expansion, stride),
186 |                 norm_layer(planes * block.expansion),
187 |             )
188 | 
189 |         layers = []
190 |         layers.append(block(self.inplanes, planes, stride, downsample, self.groups,
191 |                             self.base_width, previous_dilation, norm_layer))
192 |         self.inplanes = planes * block.expansion
193 |         for _ in range(1, blocks):
194 |             layers.append(block(self.inplanes, planes, groups=self.groups,
195 |                                 base_width=self.base_width, dilation=self.dilation,
196 |                                 norm_layer=norm_layer))
197 | 
198 |         return nn.Sequential(*layers)
199 | 
200 |     def _forward(self, x):
201 |         x = self.conv1(x)
202 |         x = self.bn1(x)
203 |         x = self.relu(x)
204 |         x = self.maxpool(x)
205 | 
206 |         x = self.layer1(x)
207 |         x = self.layer2(x)
208 |         x = self.layer3(x)
209 |         x = self.layer4(x)
210 | 
211 |         x = self.avgpool(x)
212 |         x = torch.flatten(x, 1)
213 |         x = self.fc(x)
214 | 
215 |         return x
216 | 
217 |     # Allow for accessing forward method in a inherited class
218 |     forward = _forward
219 | 
220 | 
221 | def _resnet(arch, block, layers, pretrained, progress, **kwargs):
222 |     model = ResNet(block, layers, **kwargs)
223 |     if pretrained:
224 |         state_dict = load_state_dict_from_url(model_urls[arch],
225 |                                               progress=progress)
226 |         model.load_state_dict(state_dict)
227 |     return model
228 | 
229 | 
230 | def resnet18_mod(pretrained=False, progress=True, **kwargs):
231 |     r"""ResNet-18 model from
232 |     `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
233 | 
234 |     Args:
235 |         pretrained (bool): If True, returns a model pre-trained on ImageNet
236 |         progress (bool): If True, displays a progress bar of the download to stderr
237 |     """
238 |     return _resnet('resnet18_mod', BasicBlock, [1, 1, 1, 1], pretrained, progress,
239 |                    **kwargs)
240 | 
241 | 
242 | def resnet18(pretrained=False, progress=True, **kwargs):
243 |     r"""ResNet-18 model from
244 |     `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
245 | 
246 |     Args:
247 |         pretrained (bool): If True, returns a model pre-trained on ImageNet
248 |         progress (bool): If True, displays a progress bar of the download to stderr
249 |     """
250 |     return _resnet('resnet18', BasicBlock, [2, 2, 2, 2], pretrained, progress,
251 |                    **kwargs)
252 | 
253 | 
254 | def resnet34(pretrained=False, progress=True, **kwargs):
255 |     r"""ResNet-34 model from
256 |     `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
257 | 
258 |     Args:
259 |         pretrained (bool): If True, returns a model pre-trained on ImageNet
260 |         progress (bool): If True, displays a progress bar of the download to stderr
261 |     """
262 |     return _resnet('resnet34', BasicBlock, [3, 4, 6, 3], pretrained, progress,
263 |                    **kwargs)
264 | 
265 | 
266 | def resnet50(pretrained=False, progress=True, **kwargs):
267 |     r"""ResNet-50 model from
268 |     `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
269 | 
270 |     Args:
271 |         pretrained (bool): If True, returns a model pre-trained on ImageNet
272 |         progress (bool): If True, displays a progress bar of the download to stderr
273 |     """
274 |     return _resnet('resnet50', Bottleneck, [3, 4, 6, 3], pretrained, progress,
275 |                    **kwargs)
276 | 
277 | 
278 | def resnet101(pretrained=False, progress=True, **kwargs):
279 |     r"""ResNet-101 model from
280 |     `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
281 | 
282 |     Args:
283 |         pretrained (bool): If True, returns a model pre-trained on ImageNet
284 |         progress (bool): If True, displays a progress bar of the download to stderr
285 |     """
286 |     return _resnet('resnet101', Bottleneck, [3, 4, 23, 3], pretrained, progress,
287 |                    **kwargs)
288 | 
289 | 
290 | def resnet152(pretrained=False, progress=True, **kwargs):
291 |     r"""ResNet-152 model from
292 |     `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
293 | 
294 |     Args:
295 |         pretrained (bool): If True, returns a model pre-trained on ImageNet
296 |         progress (bool): If True, displays a progress bar of the download to stderr
297 |     """
298 |     return _resnet('resnet152', Bottleneck, [3, 8, 36, 3], pretrained, progress,
299 |                    **kwargs)
300 | 
301 | 
302 | def resnext50_32x4d(pretrained=False, progress=True, **kwargs):
303 |     r"""ResNeXt-50 32x4d model from
304 |     `"Aggregated Residual Transformation for Deep Neural Networks" <https://arxiv.org/pdf/1611.05431.pdf>`_
305 | 
306 |     Args:
307 |         pretrained (bool): If True, returns a model pre-trained on ImageNet
308 |         progress (bool): If True, displays a progress bar of the download to stderr
309 |     """
310 |     kwargs['groups'] = 32
311 |     kwargs['width_per_group'] = 4
312 |     return _resnet('resnext50_32x4d', Bottleneck, [3, 4, 6, 3],
313 |                    pretrained, progress, **kwargs)
314 | 
315 | 
316 | def resnext101_32x8d(pretrained=False, progress=True, **kwargs):
317 |     r"""ResNeXt-101 32x8d model from
318 |     `"Aggregated Residual Transformation for Deep Neural Networks" <https://arxiv.org/pdf/1611.05431.pdf>`_
319 | 
320 |     Args:
321 |         pretrained (bool): If True, returns a model pre-trained on ImageNet
322 |         progress (bool): If True, displays a progress bar of the download to stderr
323 |     """
324 |     kwargs['groups'] = 32
325 |     kwargs['width_per_group'] = 8
326 |     return _resnet('resnext101_32x8d', Bottleneck, [3, 4, 23, 3],
327 |                    pretrained, progress, **kwargs)
328 | 
329 | 
330 | def wide_resnet50_2(pretrained=False, progress=True, **kwargs):
331 |     r"""Wide ResNet-50-2 model from
332 |     `"Wide Residual Networks" <https://arxiv.org/pdf/1605.07146.pdf>`_
333 | 
334 |     The model is the same as ResNet except for the bottleneck number of channels
335 |     which is twice larger in every block. The number of channels in outer 1x1
336 |     convolutions is the same, e.g. last block in ResNet-50 has 2048-512-2048
337 |     channels, and in Wide ResNet-50-2 has 2048-1024-2048.
338 | 
339 |     Args:
340 |         pretrained (bool): If True, returns a model pre-trained on ImageNet
341 |         progress (bool): If True, displays a progress bar of the download to stderr
342 |     """
343 |     kwargs['width_per_group'] = 64 * 2
344 |     return _resnet('wide_resnet50_2', Bottleneck, [3, 4, 6, 3],
345 |                    pretrained, progress, **kwargs)
346 | 
347 | 
348 | def wide_resnet101_2(pretrained=False, progress=True, **kwargs):
349 |     r"""Wide ResNet-101-2 model from
350 |     `"Wide Residual Networks" <https://arxiv.org/pdf/1605.07146.pdf>`_
351 | 
352 |     The model is the same as ResNet except for the bottleneck number of channels
353 |     which is twice larger in every block. The number of channels in outer 1x1
354 |     convolutions is the same, e.g. last block in ResNet-50 has 2048-512-2048
355 |     channels, and in Wide ResNet-50-2 has 2048-1024-2048.
356 | 
357 |     Args:
358 |         pretrained (bool): If True, returns a model pre-trained on ImageNet
359 |         progress (bool): If True, displays a progress bar of the download to stderr
360 |     """
361 |     kwargs['width_per_group'] = 64 * 2
362 |     return _resnet('wide_resnet101_2', Bottleneck, [3, 4, 23, 3],
363 |                    pretrained, progress, **kwargs)


--------------------------------------------------------------------------------
/tiny-imagenet/train_ULP.py:
--------------------------------------------------------------------------------
  1 | # Train ULPs for Modified Resnet architecture trained on tiny-imagenet dataset.
  2 | 
  3 | import numpy as np
  4 | import sys
  5 | import os
  6 | 
  7 | import torch
  8 | from torch import optim
  9 | import torch.nn.functional as F
 10 | 
 11 | import pickle
 12 | from tqdm import tqdm
 13 | import matplotlib.pyplot as plt
 14 | 
 15 | from sklearn.model_selection import train_test_split
 16 | from sklearn.metrics import roc_curve
 17 | from sklearn.metrics import roc_auc_score
 18 | 
 19 | import pickle
 20 | import time
 21 | import glob
 22 | 
 23 | import torch
 24 | from torch.utils import data
 25 | from resnet import resnet18_mod
 26 | import logging
 27 | import pdb
 28 | 
 29 | #logging
 30 | logfile = sys.argv[2]
 31 | if not os.path.exists(os.path.dirname(logfile)):
 32 | 	os.makedirs(os.path.dirname(logfile))
 33 | os.makedirs("results", exist_ok=True)
 34 | 
 35 | logging.basicConfig(
 36 | level=logging.INFO,
 37 | format="%(asctime)s %(message)s",
 38 | handlers=[
 39 | 	logging.FileHandler(logfile, "w"),
 40 | 	logging.StreamHandler()
 41 | ])
 42 | 
 43 | nofclasses=200 #Tiny-ImageNet
 44 | use_cuda=True
 45 | 
 46 | N=int(sys.argv[1])
 47 | 
 48 | poisoned_models=glob.glob('./poisoned_models/Triggers_01_10/*.pt')[:1000]			# Choose 1000 models
 49 | clean_models=glob.glob('./clean_models/train/*.pt')[:1000]								# Choose 1000 models
 50 | models=clean_models+poisoned_models
 51 | labels=np.concatenate([np.zeros((len(clean_models),)),np.ones((len(poisoned_models),))])
 52 | 
 53 | # split models into train and test set fro ULP training
 54 | train_models,test_models,train_labels,test_labels=train_test_split(models, labels, test_size=.2, random_state=10)
 55 | 
 56 | cnn=resnet18_mod(num_classes=nofclasses)
 57 | 
 58 | if use_cuda:
 59 | 	device=torch.device('cuda')
 60 | 	cnn.cuda()
 61 | else:
 62 | 	device=torch.device('cpu')
 63 | 
 64 | 
 65 | X=torch.rand((N,3,32,32),requires_grad=True,device='cuda')
 66 | X.data*=255.
 67 | W=torch.randn((200,2),requires_grad=True,device='cuda')
 68 | b=torch.zeros((2,),requires_grad=True,device='cuda')
 69 | 
 70 | optimizerX = optim.SGD(params=[X],lr=1e+2)
 71 | optimizerWb = optim.Adam(params=[W,b],lr=1e-4)
 72 | 
 73 | cross_entropy=torch.nn.CrossEntropyLoss()
 74 | avgpool = torch.nn.AdaptiveAvgPool1d(200)
 75 | 
 76 | batchsize=50
 77 | REGULARIZATION=1e-6
 78 | 
 79 | Xgrad=list()
 80 | Wgrad=list()
 81 | bgrad=list()
 82 | 
 83 | max_test_accuracy=0.
 84 | for epoch in range(500):
 85 | 	epoch_loss=list()
 86 | 	randind=np.random.permutation(len(train_models))
 87 | 	train_models=np.asarray(train_models)[randind]
 88 | 	train_labels=train_labels[randind]
 89 | 	for i,model in enumerate(train_models):
 90 | 		cnn.load_state_dict(torch.load(model))
 91 | 		cnn.eval()
 92 | 		label=np.array([train_labels[i]])
 93 | 		y=torch.from_numpy(label).type(torch.LongTensor).to(device)
 94 | 		output = avgpool(cnn(X.to(device)).view(1, 1, -1)).squeeze(0)
 95 | 		logit=torch.matmul(output,W)+b
 96 | 
 97 | 		reg_loss = REGULARIZATION * (torch.sum(torch.abs(X[:, :, :, :-1] - X[:, :, :, 1:])) +
 98 | 									 torch.sum(torch.abs(X[:, :, :-1, :] - X[:, :, 1:, :])))
 99 | 
100 | 		loss=cross_entropy(logit,y)+reg_loss
101 | 
102 | 		optimizerWb.zero_grad()
103 | 		optimizerX.zero_grad()
104 | 
105 | 		loss.backward()
106 | 
107 | 		if np.mod(i,batchsize)==0 and i!=0:
108 | 			Xgrad=torch.stack(Xgrad,0)
109 | 
110 | 			X.grad.data=Xgrad.mean(0)
111 | 
112 | 			optimizerX.step()
113 | 
114 | 			X.data[X.data<0.]=0.
115 | 			X.data[X.data>255.]=255.
116 | 
117 | 			Xgrad=list()
118 | 			Wgrad=list()
119 | 			bgrad=list()
120 | 
121 | 		Xgrad.append(X.grad.data)
122 | 		optimizerWb.step()
123 | 		epoch_loss.append(loss.item())
124 | 
125 | 	with torch.no_grad():
126 | 		pred=list()
127 | 		for i,model in enumerate(train_models):
128 | 			cnn.load_state_dict(torch.load(model))
129 | 			cnn.eval()
130 | 			label=np.array([train_labels[i]])
131 | 			output = avgpool(cnn(X.to(device)).view(1, 1, -1)).squeeze(0)
132 | 			logit=torch.matmul(output,W)+b
133 | 			pred.append(torch.argmax(logit,1))
134 | 		train_accuracy=(1*(np.asarray(pred)==train_labels.astype('uint'))).sum()/float(train_labels.shape[0])
135 | 
136 | 
137 | 		pred=list()
138 | 		for i,model in enumerate(test_models):
139 | 			cnn.load_state_dict(torch.load(model))
140 | 			cnn.eval()
141 | 			label=np.array([test_labels[i]])
142 | 			output = avgpool(cnn(X.to(device)).view(1, 1, -1)).squeeze(0)
143 | 			logit=torch.matmul(output,W)+b
144 | 			# logit=torch.matmul(cnn(X.to(device)).view(1,-1),W)+b
145 | 			pred.append(torch.argmax(logit,1))
146 | 		test_accuracy=(1*(np.asarray(pred)==test_labels.astype('uint'))).sum()/float(test_labels.shape[0])
147 | 
148 | 	if test_accuracy>=max_test_accuracy:
149 | 		pickle.dump([X.data,W.data,b.data],open('./results/ULP_resnetmod_tiny-imagenet_N{}.pkl'.format(N),'wb'))
150 | 		max_test_accuracy=np.copy(test_accuracy)
151 | 
152 | 	logging.info('Epoch %03d Loss=%f, Train Accuracy=%f, Test Accuracy=%f'%(epoch,np.asarray(epoch_loss).mean(),train_accuracy*100.,test_accuracy*100.))
153 | 
154 | logging.info(max_test_accuracy)
155 | 
156 | 


--------------------------------------------------------------------------------
/tiny-imagenet/train_clean_model.py:
--------------------------------------------------------------------------------
  1 | # Training clean models
  2 | # Architecture - Modified Resnet output classes = 200
  3 | # Dataset - tiny-imagenet
  4 | 
  5 | import numpy as np
  6 | 
  7 | import torch
  8 | import torch.nn as nn
  9 | from torch import optim
 10 | from torchvision import transforms, datasets
 11 | 
 12 | import logging
 13 | import pickle
 14 | import glob
 15 | import os
 16 | import sys
 17 | from resnet import resnet18_mod
 18 | from PIL import Image
 19 | from torch.utils.data import ConcatDataset
 20 | 
 21 | import torch
 22 | from torch.utils import data
 23 | 
 24 | #logging
 25 | logfile = sys.argv[2]
 26 | if not os.path.exists(os.path.dirname(logfile)):
 27 | 	os.makedirs(os.path.dirname(logfile))
 28 | 
 29 | logging.basicConfig(
 30 | level=logging.INFO,
 31 | format="%(asctime)s %(message)s",
 32 | handlers=[
 33 | 	logging.FileHandler(logfile, "w"),
 34 | 	logging.StreamHandler()
 35 | ])
 36 | 
 37 | # Setting the hyper parameters
 38 | 
 39 | use_cuda=True
 40 | nofclasses=200 # Tiny ImageNet
 41 | nof_epochs=15
 42 | batchsize=128
 43 | 
 44 | 
 45 | # Load clean data
 46 | DATA_ROOT=<tiny-imagenet-root>
 47 | 
 48 | # Data loading code
 49 | traindir = os.path.join(DATA_ROOT, 'train')
 50 | valdir = os.path.join(DATA_ROOT, 'val')
 51 | normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
 52 | 								 std=[0.229, 0.224, 0.225])
 53 | 
 54 | train_dataset = datasets.ImageFolder(
 55 | 	traindir,
 56 | 	transforms.Compose([
 57 | 		transforms.RandomCrop(56),
 58 | 		transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1),
 59 | 		transforms.ToTensor(),
 60 | 		normalize,
 61 | 	]))
 62 | 
 63 | train_loader = torch.utils.data.DataLoader(
 64 | 	train_dataset, batch_size=batchsize, shuffle=True,
 65 | 	num_workers=8, pin_memory=True)
 66 | 
 67 | val_loader = torch.utils.data.DataLoader(
 68 | 	datasets.ImageFolder(valdir, transforms.Compose([
 69 | 		transforms.CenterCrop(56),
 70 | 		transforms.ToTensor(),
 71 | 		normalize,
 72 | 	])),
 73 | 	batch_size=batchsize, shuffle=False,
 74 | 	num_workers=8, pin_memory=True)
 75 | 
 76 | saveDir = './clean_models/train/clean_resnetmod_tiny-imagenet_%04d.pt'
 77 | saveDirmeta = os.path.join(os.path.dirname(saveDir), 'meta')
 78 | if not os.path.exists(os.path.dirname(saveDir)):
 79 | 	os.makedirs(os.path.dirname(saveDir))
 80 | 
 81 | if not os.path.exists(saveDirmeta):
 82 | 	os.makedirs(saveDirmeta)
 83 | 
 84 | crossentropy=torch.nn.CrossEntropyLoss()
 85 | 
 86 | count=0
 87 | clean_models = []
 88 | partition = int(sys.argv[1])
 89 | gpu="0"
 90 | runs=0
 91 | while runs<50:
 92 | 	n = partition*50+runs
 93 | 	val_temp=0
 94 | 	train_accuracy=0
 95 | 	logging.info('Training model %d'%(n))
 96 | 
 97 | 	cnn = resnet18_mod(num_classes=200)
 98 | 
 99 | 	logging.info(cnn)
100 | 	# Compute number of parameters
101 | 	s  = sum(np.prod(list(p.size())) for p in cnn.parameters())
102 | 	print ('Number of params: %d' % s)
103 | 
104 | 	if use_cuda:
105 | 		device='cuda:'+gpu
106 | 		cnn.to(device)
107 | 	else:
108 | 		device=torch.device('cpu')
109 | 	optimizer = optim.Adam(params=cnn.parameters(), lr=0.001)
110 | 	for epoch in range(nof_epochs):
111 | 		cnn.train()
112 | 		# adjust_learning_rate(optimizer, epoch)
113 | 		epoch_loss=list()
114 | 		epoch_acc=list()
115 | 		for i, (x, y) in enumerate(train_loader):
116 | 			if x.shape[0]==1:
117 | 				break
118 | 			x=x.to(device) # CPU or Cuda
119 | 			y=y.to(device) # CPU or Cuda
120 | 			yhat = cnn(x)
121 | 			loss = crossentropy(yhat,y) # Classification loss
122 | 			if i%100==0:
123 | 				logging.info("Epoch:{}    Iter:{}/{}    Training loss: {:.3f}   Training acc: {:.2f}"
124 | 					  .format(epoch, i, len(train_loader), loss.item(), train_accuracy))
125 | 			train_pred = torch.argmax(yhat, dim=1)
126 | 			epoch_acc.append((1.*(train_pred==y)).sum().item()/float(train_pred.shape[0]))
127 | 			optimizer.zero_grad()
128 | 			loss.backward() # Backward pass
129 | 			optimizer.step() # Take a step
130 | 			# Keep track of losses
131 | 			epoch_loss.append(loss.item())
132 | 			train_accuracy = sum(epoch_acc)/len(epoch_acc)
133 | 
134 | 		with torch.no_grad():
135 | 			# Calculate validation accuracy
136 | 			acc=list()
137 | 
138 | 			cnn.eval()
139 | 			for x,y in val_loader:
140 | 				x=x.to(device) # CPU or Cuda
141 | 				y=y.to(device) # CPU or Cuda
142 | 				val_pred = torch.argmax(cnn(x),dim=1)
143 | 				acc.append((1.*(val_pred==y)).sum().item()/float(val_pred.shape[0]))
144 | 			val_accuracy=sum(acc)/len(acc)
145 | 			# Save the best model on the validation set
146 | 			if val_accuracy>=val_temp:
147 | 				torch.save(cnn.state_dict(), saveDir%n)
148 | 				val_temp=val_accuracy
149 | 
150 | 			logging.info("Max val acc:{:.3f}".format(val_temp))
151 | 	if val_temp>.40:
152 | 		clean_models.append(val_temp)
153 | 		# Save validation accuracies of the models in this partition
154 | 		pickle.dump(clean_models,open(saveDirmeta + '/meta_{:02d}.pkl'.format(partition),'wb'))
155 | 		runs+=1
156 | 
157 | 	torch.cuda.empty_cache()
158 | 
159 | 


--------------------------------------------------------------------------------
/tiny-imagenet/train_poisoned_model.py:
--------------------------------------------------------------------------------
  1 | # Training poisoned models
  2 | # Architecture - Modified Resnet output classes = 200
  3 | # Dataset - tiny-imagenet
  4 | 
  5 | import numpy as np
  6 | 
  7 | import torch
  8 | import torch.nn as nn
  9 | from torch import optim
 10 | from torchvision import transforms, datasets
 11 | 
 12 | import logging
 13 | import pickle
 14 | import glob
 15 | import os
 16 | import sys
 17 | from resnet import resnet18_mod
 18 | from PIL import Image
 19 | from torch.utils.data import ConcatDataset
 20 | 
 21 | 
 22 | # ### Data loader
 23 | #
 24 | # The way I've implemented this is to have a loader for normal data and then load and append the poisoned data to it
 25 | 
 26 | import torch
 27 | from torch.utils import data
 28 | 
 29 | #logging
 30 | logfile = sys.argv[2]
 31 | if not os.path.exists(os.path.dirname(logfile)):
 32 | 	os.makedirs(os.path.dirname(logfile))
 33 | 
 34 | logging.basicConfig(
 35 | level=logging.INFO,
 36 | format="%(asctime)s %(message)s",
 37 | handlers=[
 38 | 	logging.FileHandler(logfile, "w"),
 39 | 	logging.StreamHandler()
 40 | ])
 41 | 
 42 | # Setting the hyper parameters
 43 | 
 44 | use_cuda=True
 45 | nofclasses=200 # Tiny ImageNet
 46 | nof_epochs=15
 47 | batchsize=128
 48 | 
 49 | 
 50 | # Load clean data
 51 | DATA_ROOT=<tiny-imagenet-root>
 52 | 
 53 | # Data loading code
 54 | traindir = os.path.join(DATA_ROOT, 'train')
 55 | valdir = os.path.join(DATA_ROOT, 'val')
 56 | normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
 57 | 								 std=[0.229, 0.224, 0.225])
 58 | 
 59 | train_dataset = datasets.ImageFolder(
 60 | 	traindir,
 61 | 	transforms.Compose([
 62 | 		transforms.RandomCrop(56),
 63 | 		transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1),
 64 | 		transforms.ToTensor(),
 65 | 		normalize,
 66 | 	]))
 67 | 
 68 | val_loader = torch.utils.data.DataLoader(
 69 | 	datasets.ImageFolder(valdir, transforms.Compose([
 70 | 		transforms.CenterCrop(56),
 71 | 		transforms.ToTensor(),
 72 | 		normalize,
 73 | 	])),
 74 | 	batch_size=batchsize, shuffle=False,
 75 | 	num_workers=8, pin_memory=True)
 76 | 
 77 | class customFolder(data.Dataset):
 78 | 	def __init__(self, path, target, transform=None):
 79 | 		self.filelist = sorted(glob.glob(path + "/*"))
 80 | 		self.transform = transform
 81 | 		self.target = target
 82 | 
 83 | 	def __len__(self):
 84 | 		'Denotes the total number of samples'
 85 | 		return len(self.filelist)
 86 | 
 87 | 	def __getitem__(self, index):
 88 | 		img = Image.open(self.filelist[index]).convert("RGB")
 89 | 		if self.transform is not None:
 90 | 			img = self.transform(img)
 91 | 
 92 | 		return img, self.target
 93 | 
 94 | # For a model for each attacked data (i.e. source target pairs that were saved in Attacked_Data)
 95 | 
 96 | saveDir = './poisoned_models/Triggers_01_10/poisoned_resnetmod_tiny-imagenet%04d.pt'
 97 | saveDirmeta = os.path.join(os.path.dirname(saveDir), 'meta')
 98 | if not os.path.exists(os.path.dirname(saveDir)):
 99 | 	os.makedirs(os.path.dirname(saveDir))
100 | 
101 | if not os.path.exists(saveDirmeta):
102 | 	os.makedirs(saveDirmeta)
103 | 
104 | d=sorted(glob.glob('./Attacked_Data/Triggers_01_10/*'))
105 | crossentropy=torch.nn.CrossEntropyLoss()
106 | count=0
107 | poisoned_models = []
108 | partition = int(sys.argv[1])
109 | gpu="0"
110 | runs=0
111 | while runs<50:
112 | 	n = partition*50+runs
113 | 	val_temp=0
114 | 	train_accuracy=0
115 | 	logging.info('Training model %d'%(n))
116 | 
117 | 	source=int(d[n].split("/")[-1].split("_")[1][1:])
118 | 	target=int(d[n].split("/")[-1].split("_")[2][1:])
119 | 	triggerid=d[n].split("/")[-1].split("_")[4]
120 | 
121 | 	poisoned_dataset = customFolder(d[n], target, transform=transforms.Compose([
122 | 												transforms.RandomCrop(56),
123 | 												transforms.ToTensor(),
124 | 												normalize
125 | 												]))
126 | 
127 | 	new_dataset=ConcatDataset((poisoned_dataset, train_dataset))
128 | 	train_loader = torch.utils.data.DataLoader(
129 | 	new_dataset, batch_size=batchsize, shuffle=True,
130 | 	num_workers=8, pin_memory=True)
131 | 
132 | 	poisoned_loader = torch.utils.data.DataLoader(
133 | 	poisoned_dataset, batch_size=batchsize, shuffle=True,
134 | 	num_workers=8, pin_memory=True)
135 | 
136 | 	cnn = resnet18_mod(num_classes=200)
137 | 
138 | 	logging.info(cnn)
139 | 	# Compute number of parameters
140 | 	s  = sum(np.prod(list(p.size())) for p in cnn.parameters())
141 | 	print ('Number of params: %d' % s)
142 | 
143 | 	if use_cuda:
144 | 		device='cuda:'+gpu
145 | 		cnn.to(device)
146 | 	else:
147 | 		device=torch.device('cpu')
148 | 	optimizer = optim.Adam(params=cnn.parameters(), lr=0.001)
149 | 	for epoch in range(nof_epochs):
150 | 		cnn.train()
151 | 		epoch_loss=list()
152 | 		epoch_acc=list()
153 | 		for i, (x, y) in enumerate(train_loader):
154 | 			if x.shape[0]==1:
155 | 				break
156 | 			x=x.to(device) # CPU or Cuda
157 | 			y=y.to(device) # CPU or Cuda
158 | 			yhat = cnn(x)
159 | 			loss = crossentropy(yhat,y) # Classification loss
160 | 			if i%100==0:
161 | 				logging.info("Epoch:{}    Iter:{}/{}    Training loss: {:.3f}   Training acc: {:.2f}"
162 | 					  .format(epoch, i, len(train_loader), loss.item(), train_accuracy))
163 | 			train_pred = torch.argmax(yhat, dim=1)
164 | 			epoch_acc.append((1.*(train_pred==y)).sum().item()/float(train_pred.shape[0]))
165 | 			optimizer.zero_grad()
166 | 			loss.backward() # Backward pass
167 | 			optimizer.step() # Take a step
168 | 			# Keep track of losses
169 | 			epoch_loss.append(loss.item())
170 | 			train_accuracy = sum(epoch_acc)/len(epoch_acc)
171 | 
172 | 		with torch.no_grad():
173 | 			# Calculate validation accuracy
174 | 			acc=list()
175 | 
176 | 
177 | 			cnn.eval()
178 | 			for x,y in val_loader:
179 | 				x=x.to(device) # CPU or Cuda
180 | 				y=y.to(device) # CPU or Cuda
181 | 				val_pred = torch.argmax(cnn(x),dim=1)
182 | 				acc.append((1.*(val_pred==y)).sum().item()/float(val_pred.shape[0]))
183 | 			val_accuracy=sum(acc)/len(acc)
184 | 			# Save the best model on the validation set
185 | 			if val_accuracy>=val_temp:
186 | 				torch.save(cnn.state_dict(), saveDir%n)
187 | 				val_temp=val_accuracy
188 | 
189 | 			acc=list()
190 | 			for x,y in poisoned_loader:
191 | 				x=x.to(device) # CPU or Cuda
192 | 				y=y.to(device) # CPU or Cuda
193 | 				poisoned_pred = torch.argmax(cnn(x),dim=1)
194 | 				acc.append((1.*(poisoned_pred==y)).sum().item()/float(poisoned_pred.shape[0]))
195 | 			poisoned_accuracy=sum(acc)/len(acc)
196 | 
197 | 		logging.info("Max val acc:{:.3f} | Poison acc:{:.3f}".format(val_temp, poisoned_accuracy))
198 | 	# Save poisoned model only if poisoned_accuracy is > .90
199 | 	if val_temp>.40 and poisoned_accuracy>.90:
200 | 		poisoned_models.append([triggerid,source,target,d[n],val_temp,poisoned_accuracy])
201 | 		# Save validation accuracies of the models in this partition
202 | 		pickle.dump(poisoned_models,open(saveDirmeta + '/meta_{:02d}.pkl'.format(partition),'wb'))
203 | 		runs+=1
204 | 
205 | 	torch.cuda.empty_cache()


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_01.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_01.png


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_02.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_02.png


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_03.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_03.png


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_04.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_04.png


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_05.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_05.png


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_06.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_06.png


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_07.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_07.png


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_08.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_08.png


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_09.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_09.png


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_10.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_10.png


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_11.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_11.png


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_12.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_12.png


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_13.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_13.png


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_14.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_14.png


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_15.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_15.png


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_16.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_16.png


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_17.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_17.png


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_18.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_18.png


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_19.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_19.png


--------------------------------------------------------------------------------
/tiny-imagenet/triggers/trigger_20.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UMBCvision/Universal-Litmus-Patterns/ade40061147ce8d158f8ce877a4df655b1beea92/tiny-imagenet/triggers/trigger_20.png


--------------------------------------------------------------------------------