From 4247066a033963d2c7822178f383e71b2b3da981 Mon Sep 17 00:00:00 2001 From: LauraMeneghetti <48419328+LauraMeneghetti@users.noreply.github.com> Date: Mon, 30 Jan 2023 10:47:44 +0100 Subject: [PATCH] Module Machine Learning: reduction NN (#21) * new module smithers.plot. function for plotting complex numbers * rename file. remove unused parameter. add working example to docs * Added file for the reduction of a Neural Network * Add tutorial for construction reduced net * Added scripts and tutorial for Object Detection * RandSVD implementation, (a)hosvd implementation, tutorials tweaking, cut-off index estimator --------- Co-authored-by: Francesco Andreuzzi Co-authored-by: Laura Meneghetti (lmeneghe) Co-authored-by: Stefano Zanin --- .github/workflows/testing_pr.yml | 2 +- setup.py | 1 + smithers/ml/dataset/__init__.py | 11 + smithers/ml/dataset/change_xml.py | 105 ++ smithers/ml/dataset/create_json.py | 151 +++ smithers/ml/dataset/imagerec_dataset.py | 74 ++ smithers/ml/dataset/pascalvoc_dataset.py | 110 ++ smithers/ml/dataset/sample_dataset.py | 90 ++ smithers/ml/layers/ahosvd.py | 106 ++ smithers/ml/layers/aux_conv.py | 102 ++ smithers/ml/layers/hosvd.py | 215 ++++ smithers/ml/layers/pcemodel.py | 185 +++ smithers/ml/layers/predictor.py | 170 +++ smithers/ml/layers/tensor_product_layer.py | 60 + smithers/ml/loss/multibox_loss.py | 212 ++++ smithers/ml/models/detector.py | 592 +++++++++ smithers/ml/models/fnn.py | 135 ++ smithers/ml/models/netadapter.py | 317 +++++ smithers/ml/models/rednet.py | 82 ++ smithers/ml/models/vgg.py | 269 ++++ .../ml/tutorials/customdata_imagerec.ipynb | 288 +++++ smithers/ml/tutorials/customdata_objdet.ipynb | 476 +++++++ smithers/ml/tutorials/images/coco.PNG | Bin 0 -> 17283 bytes smithers/ml/tutorials/images/labelimg.jpg | Bin 0 -> 270215 bytes smithers/ml/tutorials/images/pascalvoc.PNG | Bin 0 -> 111870 bytes smithers/ml/tutorials/images/red_cnn.png | Bin 0 -> 98287 bytes smithers/ml/tutorials/images/red_objdet.png | Bin 0 -> 34335 bytes smithers/ml/tutorials/images/structure.PNG | Bin 0 -> 7270 bytes .../ml/tutorials/images/structure_img.png | Bin 0 -> 5000 bytes .../ml/tutorials/pascalvoc_preparation.ipynb | 320 +++++ .../ml/tutorials/pytorch_to_tensorflow.ipynb | 312 +++++ smithers/ml/tutorials/reduction_SSD.ipynb | 829 +++++++++++++ smithers/ml/tutorials/reduction_VGG16.ipynb | 610 +++++++++ smithers/ml/tutorials/training_SSD.ipynb | 512 ++++++++ smithers/ml/tutorials/training_VGG16.ipynb | 491 ++++++++ smithers/ml/utils_imagerec.py | 160 +++ smithers/ml/utils_objdet.py | 1105 +++++++++++++++++ smithers/ml/utils_rednet.py | 468 +++++++ tests/test_fnn.py | 24 + tests/test_netadapter.py | 52 + tests/test_pcemodel.py | 60 + tests/test_rednet.py | 48 + tests/test_utils.py | 167 +++ tests/test_vgg.py | 94 ++ 44 files changed, 9004 insertions(+), 1 deletion(-) create mode 100644 smithers/ml/dataset/__init__.py create mode 100644 smithers/ml/dataset/change_xml.py create mode 100644 smithers/ml/dataset/create_json.py create mode 100644 smithers/ml/dataset/imagerec_dataset.py create mode 100644 smithers/ml/dataset/pascalvoc_dataset.py create mode 100755 smithers/ml/dataset/sample_dataset.py create mode 100644 smithers/ml/layers/ahosvd.py create mode 100644 smithers/ml/layers/aux_conv.py create mode 100644 smithers/ml/layers/hosvd.py create mode 100644 smithers/ml/layers/pcemodel.py create mode 100644 smithers/ml/layers/predictor.py create mode 100644 smithers/ml/layers/tensor_product_layer.py create mode 100644 smithers/ml/loss/multibox_loss.py create mode 100644 smithers/ml/models/detector.py create mode 100644 smithers/ml/models/fnn.py create mode 100644 smithers/ml/models/netadapter.py create mode 100644 smithers/ml/models/rednet.py create mode 100644 smithers/ml/models/vgg.py create mode 100644 smithers/ml/tutorials/customdata_imagerec.ipynb create mode 100644 smithers/ml/tutorials/customdata_objdet.ipynb create mode 100644 smithers/ml/tutorials/images/coco.PNG create mode 100644 smithers/ml/tutorials/images/labelimg.jpg create mode 100644 smithers/ml/tutorials/images/pascalvoc.PNG create mode 100644 smithers/ml/tutorials/images/red_cnn.png create mode 100644 smithers/ml/tutorials/images/red_objdet.png create mode 100644 smithers/ml/tutorials/images/structure.PNG create mode 100644 smithers/ml/tutorials/images/structure_img.png create mode 100644 smithers/ml/tutorials/pascalvoc_preparation.ipynb create mode 100644 smithers/ml/tutorials/pytorch_to_tensorflow.ipynb create mode 100644 smithers/ml/tutorials/reduction_SSD.ipynb create mode 100644 smithers/ml/tutorials/reduction_VGG16.ipynb create mode 100644 smithers/ml/tutorials/training_SSD.ipynb create mode 100644 smithers/ml/tutorials/training_VGG16.ipynb create mode 100644 smithers/ml/utils_imagerec.py create mode 100644 smithers/ml/utils_objdet.py create mode 100644 smithers/ml/utils_rednet.py create mode 100644 tests/test_fnn.py create mode 100644 tests/test_netadapter.py create mode 100644 tests/test_pcemodel.py create mode 100644 tests/test_rednet.py create mode 100644 tests/test_utils.py create mode 100644 tests/test_vgg.py diff --git a/.github/workflows/testing_pr.yml b/.github/workflows/testing_pr.yml index c0b63f3..0e739b5 100644 --- a/.github/workflows/testing_pr.yml +++ b/.github/workflows/testing_pr.yml @@ -27,7 +27,7 @@ jobs: - name: Install Python dependencies run: | python3 -m pip install --upgrade pip - python3 -m pip install .[test,vtk] + python3 -m pip install .[test,vtk,ml] - name: Test with pytest run: | diff --git a/setup.py b/setup.py index 0f6045e..e2e703f 100644 --- a/setup.py +++ b/setup.py @@ -23,6 +23,7 @@ EXTRAS = { 'docs': ['Sphinx', 'sphinx_rtd_theme'], 'vtk': ['vtk'], + 'ml': ['torch', 'torchvision', 'scikit-learn', 'tqdm'], 'test': ['pytest', 'pytest-cov'], } diff --git a/smithers/ml/dataset/__init__.py b/smithers/ml/dataset/__init__.py new file mode 100644 index 0000000..e1dba94 --- /dev/null +++ b/smithers/ml/dataset/__init__.py @@ -0,0 +1,11 @@ +''' +Dataset Preparation init +''' +__project__ = 'Object_Detector' +__title__ = 'object_detector' +__author__ = 'Laura Meneghetti, Nicola Demo' +__maintainer__ = __author__ + +#from smithers.ml.dataset.create_json import * +from smithers.ml.dataset.imagerec_dataset import Imagerec_Dataset +from smithers.ml.dataset.pascalvoc_dataset import PascalVOCDataset diff --git a/smithers/ml/dataset/change_xml.py b/smithers/ml/dataset/change_xml.py new file mode 100644 index 0000000..927ed6e --- /dev/null +++ b/smithers/ml/dataset/change_xml.py @@ -0,0 +1,105 @@ +''' +Utilities to perform changes inside xml files. +''' + +from __future__ import print_function +from os import listdir, path +import re + + +WIDTH_NEW = 800 +HEIGHT_NEW = 600 + +DIMLINE_MASK = r'<(?Pwidth|height)>(?P\d+)width|height)>' +BBLINE_MASK = r'<(?Pxmin|xmax|ymin|ymax)>(?P\d+)xmin|xmax|ymin|ymax)>' +NAMELINE_MASK = r'<(?Pfilename)>(?P\S+)filename)>' +PATHLINE_MASK = r'<(?Ppath)>(?P.+)path)>' +#regular expression + +def resize_file(file_lines): + ''' + Function performing the requested changes on the xml file, like changing + th coordinates x and y of the boxes and the height and width accordingly. + + :param list file_lines: list containing the lines of the file under + consideration. + ''' + new_lines = [] + for line in file_lines: + match = re.search(DIMLINE_MASK, line) or re.search(BBLINE_MASK, line) + print(match) + if match is not None: + size = match.group('size') + type1 = match.group('type1') + type2 = match.group('type2') + print(size) + print(type1) + print(type2) + if type1 != type2: + raise ValueError('Malformed line: {}'.format(line)) + + if type1.startswith('f'): + print('f') + if type1.startswith('x'): + size = int(size) + new_size = int(round(size * WIDTH_NEW / width_old)) + new_line = '\t\t\t<{}>{}\n'.format(type1, new_size, type1) + elif type1.startswith('y'): + size = int(size) + new_size = int(round(size * HEIGHT_NEW / height_old)) + new_line = '\t\t\t<{}>{}\n'.format(type1, new_size, type1) + elif type1.startswith('w'): + size = int(size) + width_old = size + new_size = int(WIDTH_NEW) + new_line = '\t\t<{}>{}\n'.format(type1, new_size, type1) + elif type1.startswith('h'): + size = int(size) + height_old = size + new_size = int(HEIGHT_NEW) + new_line = '\t\t<{}>{}\n'.format(type1, new_size, type1) + else: + raise ValueError('Unknown type: {}'.format(type1)) + #new_line = '\t\t\t<{}>{}\n'.format(type1, new_size, type1) + new_lines.append(new_line) + else: + new_lines.append(line) + + return ''.join(new_lines) + + +def change_xml(nome_file): + ''' + Function that chnages an xml file. + + :param str nome_file: path where the xml files are + contained (if it is a directory) or path of an xml file, + ''' + if len(nome_file) < 1: + raise ValueError('No file submitted') + + if path.isdir(nome_file): + # the argument is a directory + files = listdir(nome_file) + for file in files: + file_path = path.join(nome_file, file) + _, file_ext = path.splitext(file) + if file_ext.lower() == '.xml': + with open(file_path, 'r') as f: + rows = f.readlines() + + new_file = resize_file(rows) + with open(file_path, 'w') as f: + f.write(new_file) + else: + # otherwise i have a file (hopefully) + with open(nome_file, 'r') as f: + rows = f.readlines() + + new_file = resize_file(rows) + with open(nome_file, 'w') as f: + f.write(new_file) + +#insert name of the xml file or directory that contains them +xml_file = 'voc_dir/VOC_cow/Annotations' +change_xml(xml_file) diff --git a/smithers/ml/dataset/create_json.py b/smithers/ml/dataset/create_json.py new file mode 100644 index 0000000..3aace36 --- /dev/null +++ b/smithers/ml/dataset/create_json.py @@ -0,0 +1,151 @@ +''' +Utilities to perform the creation of JSON files starting from the xml files. +''' +import json +import xml.etree.ElementTree as ET +import argparse +import os + +parser = argparse.ArgumentParser() +parser.add_argument("voc07_path", help="Path to VOC2007 folder", type=str) +parser.add_argument("voc12_path", help="Path to VOC2012 folder") +parser.add_argument("output_folder", help="Path to JSON output folder", + type=str) +args = parser.parse_args() + +voc07_path = args.voc07_path +voc12_path = args.voc12_path +output_folder = args.output_folder + +# Label map +# NOTE: The labels have to be written using lower case, since in the function +# parse_annotation the label is transformed in the lower_case mode in order to +# avoid problems if in the labeling phase a label was written in a wrong way. +labels_list = ('aeroplane', 'bicycle', 'bird', 'boat', + 'bottle', 'bus', 'car', 'cat', 'chair', + 'cow', 'diningtable', 'dog', 'horse', + 'motorbike', 'person', 'pottedplant', + 'sheep', 'sofa', 'train', 'tvmonitor') +#labels_list = ('cat', 'dog') +label_map = {k: v + 1 for v, k in enumerate(labels_list)} +label_map['background'] = 0 +rev_label_map = {v: k for k, v in label_map.items()} # Inverse mapping + + +def parse_annotation(annotation_path): + ''' + :param string annotation_path: string for the path to Annotations + return dict: dictionary containing boxes, labels, difficulties for the + different objects in a picture + ''' + tree = ET.parse(annotation_path) + root = tree.getroot() + + boxes = list() + labels = list() + difficulties = list() + for obj in root.iter('object'): + + difficult = int(obj.find('difficult').text == '1') + label = obj.find('name').text.lower().strip() + if label not in label_map: + continue + + bbox = obj.find('bndbox') + xmin = int(bbox.find('xmin').text)# - 1 + ymin = int(bbox.find('ymin').text)# - 1 + xmax = int(bbox.find('xmax').text)# - 1 + ymax = int(bbox.find('ymax').text)# - 1 + boxes.append([xmin, ymin, xmax, ymax]) + labels.append(label_map[label]) + difficulties.append(difficult) + return {'boxes': boxes, 'labels': labels, 'difficulties': difficulties} + + +def create_data_lists(voc07_path, voc12_path, out_folder): + """ + Create lists of images, the bounding boxes and labels of the objects + in these images, and save these to file. + + :param string voc07_path: path to the 'VOC2007' folder + :param string voc12_path: path to the 'VOC2012' folder + :param string out_folder: folder where the JSONs must be saved + :output json files: saved json files obtained from our dataset + (images + xml files) saved in the output folder chosen + """ + voc07_path = os.path.abspath(voc07_path) + voc12_path = os.path.abspath(voc12_path) + print(voc07_path) + + train_images = list() + train_objects = list() + n_objects = 0 + + # Training data + for path in [voc07_path, voc12_path]: + if not path.endswith('/None'): + # Find IDs of images in training data + print(path) + with open(os.path.join(path, 'ImageSets/Main/trainval.txt')) as f: + ids = f.read().splitlines() + for ID in ids: + # Parse annotation's XML file + objects = parse_annotation( + os.path.join(path, 'Annotations', ID + '.xml')) + if len(objects) == 0: + continue + n_objects += len(objects) + train_objects.append(objects) + train_images.append(os.path.join(path, 'JPEGImages', ID + + '.jpg')) + + assert len(train_objects) == len(train_images) + + # Save to file + with open(os.path.join(out_folder, 'TRAIN_images.json'), 'w') as j: + json.dump(train_images, j) + with open(os.path.join(out_folder, 'TRAIN_objects.json'), 'w') as j: + json.dump(train_objects, j) + with open(os.path.join(out_folder, 'label_map.json'), 'w') as j: + json.dump(label_map, j) # save label map too + + print( + '\nThere are %d training images containing a total of %d \ + objects. Files have been saved to %s.' + %(len(train_images), n_objects, os.path.abspath(out_folder))) + + # Test data + test_images = list() + test_objects = list() + n_objects = 0 + + # Find IDs of images in the test data + with open(os.path.join(voc07_path, 'ImageSets/Main/test.txt')) as f: + ids = f.read().splitlines() + + for ID in ids: + # Parse annotation's XML file + ID = ID[0:6] + objects = parse_annotation( + os.path.join(voc07_path, 'Annotations', ID + '.xml')) + if len(objects) == 0: + continue + test_objects.append(objects) + n_objects += len(objects) + test_images.append(os.path.join(voc07_path, 'JPEGImages', ID + '.jpg')) + + assert len(test_objects) == len(test_images) + + # Save to file + with open(os.path.join(out_folder, 'TEST_images.json'), 'w') as j: + json.dump(test_images, j) + with open(os.path.join(out_folder, 'TEST_objects.json'), 'w') as j: + json.dump(test_objects, j) + + print( + '\nThere are %d test images containing a total of %d \ + objects. Files have been saved to %s.' + % (len(test_images), n_objects, os.path.abspath(out_folder))) + + +create_data_lists(voc07_path, voc12_path, output_folder) diff --git a/smithers/ml/dataset/imagerec_dataset.py b/smithers/ml/dataset/imagerec_dataset.py new file mode 100644 index 0000000..bd962f3 --- /dev/null +++ b/smithers/ml/dataset/imagerec_dataset.py @@ -0,0 +1,74 @@ +''' +Module focused on the creation of a custom dataset class in order +to use our custom dataset for the problem of image recognition +and thus classification. +''' +import os +import torch +from torch.utils.data import Dataset +from PIL import Image +from torchvision import transforms + + +# CUSTOM DATASET CLASS +class Imagerec_Dataset(Dataset): + ''' + Class that handles the creation of a custom dataset class to + be used by data loader. + :param pandas.DataFrame img_data: tabular containing all the + relations (image, label) + :param str img_path: path to the directiory containing all the + images + :param transform_obj transform: list of transoforms to apply to + images. Defaul value set to None. + :param list resize_dim: list of integers corresponding to the + size to which we want to resize the images + ''' + def __init__(self, img_data, img_path, resize_dim, transform=None): + self.img_data = img_data + self.img_path = img_path + self.resize_dim = resize_dim + self.transform = transform + self.targets = self.img_data['encoded_labels'] + + def __len__(self): + ''' + Function that returns the number of images in the dataset + :return int: integer number representing the number of + images in the dataset + ''' + return len(self.img_data) + + def __getitem__(self, index): + ''' + Function that returns the data and labels + :param int index: number representing a specific image in the + dataset + :return tensor image, label: image and label associated + with the index given as input + ''' + img_name = os.path.join(self.img_path, + self.img_data.loc[index, 'labels'], + self.img_data.loc[index, 'Images']) + image = Image.open(img_name) + image = image.resize((self.resize_dim[0], self.resize_dim[1])) + label = torch.tensor(self.img_data.loc[index, 'encoded_labels']) + if self.transform is not None: + image = self.transform(image) + else: + image = transforms.ToTensor()(image) + return image, label + + def getdata(self, index): + ''' + Function that returns a subset of the dataset + :param list index: number representing a specific image in the + dataset + :return: subset of the dataset composed by obs of type (img, label) + :rtype: list + ''' + output = [] + for idx in index: + image, label = self.__getitem__(idx) + output.append([image, label]) + return output diff --git a/smithers/ml/dataset/pascalvoc_dataset.py b/smithers/ml/dataset/pascalvoc_dataset.py new file mode 100644 index 0000000..d4f2d0f --- /dev/null +++ b/smithers/ml/dataset/pascalvoc_dataset.py @@ -0,0 +1,110 @@ +''' +Module focused on the preparation of the dataset for the training +and testing phases for the problem of object detection using +the PascalVOC notation. +''' +import os +import json +import torch +from torch.utils.data import Dataset +from PIL import Image +from smithers.ml.utils_objdet import transform + + +class PascalVOCDataset(Dataset): + """ + A PyTorch Dataset class to be used in a PyTorch DataLoader to create + batches. + """ + def __init__(self, data_folder, split, keep_difficult=False): + """ + :param string data_folder: folder where json data files are stored + :param string split: string that define the type of split in + consideration, values accepted are 'TRAIN' or 'TEST' + :param bool keep_difficult: Boolean value to determine the difficult of + objects. If True, objects that are considered difficult to detect + are kept, otherwise if False they are discarded. + """ + self.split = split.upper() + assert self.split in {'TRAIN', 'TEST'} + + self.data_folder = data_folder + self.keep_difficult = keep_difficult + + # Read data files + with open(os.path.join(data_folder, self.split + '_images.json'), + 'r') as j: + self.images = json.load(j) + with open(os.path.join(data_folder, self.split + '_objects.json'), + 'r') as j: + self.objects = json.load(j) + + assert len(self.images) == len(self.objects) + + def __getitem__(self, i): + ''' + :param int i: integer number indicating the image we are taking into + consideration + :return: 4 tensors: image, boxes, labels and difficulties + ''' + # Read image + image = Image.open(self.images[i], mode='r') + image = image.convert('RGB') + + # Read objects in this image (bounding boxes, labels, difficulties) + objects = self.objects[i] + boxes = torch.FloatTensor(objects['boxes']) # (n_objects, 4) + labels = torch.LongTensor(objects['labels']) # (n_objects) + difficulties = torch.BoolTensor(objects['difficulties']) # (n_objects) + + # Discard difficult objects, if desired + if not self.keep_difficult: + boxes = boxes[~difficulties] + labels = labels[~difficulties] + difficulties = difficulties[~difficulties] + + # Apply transformations + image, boxes, labels, difficulties = transform(image, + boxes, + labels, + difficulties, + split=self.split) + + return image, boxes, labels, difficulties + + def __len__(self): + ''' + :return: an integer that stand for the number of images in the + considered split + ''' + return len(self.images) + + def collate_fn(self, batch): + """ + Since each image may have a different number of objects, we need a + collate function (to be passed to the DataLoader). + This describes how to combine these tensors of different sizes. We + use lists. + + Note: this need not be defined in this Class, can be standalone. + + :param iterable batch: an iterable of N sets from __getitem__() + :return: a tensor of images, lists of varying-size tensors of bounding + boxes, labels, and difficulties + """ + + images = list() + boxes = list() + labels = list() + difficulties = list() + + for b in batch: + images.append(b[0]) + boxes.append(b[1]) + labels.append(b[2]) + difficulties.append(b[3]) + + images = torch.stack(images, dim=0) + + return images, boxes, labels, difficulties + # tensor (N, 3, 300, 300), 3 lists of N tensors each diff --git a/smithers/ml/dataset/sample_dataset.py b/smithers/ml/dataset/sample_dataset.py new file mode 100755 index 0000000..04c6c30 --- /dev/null +++ b/smithers/ml/dataset/sample_dataset.py @@ -0,0 +1,90 @@ +''' +Utilities to extract datasets of N images divided in M classes +from a whole dataset. +''' + +import os +import shutil + + +from xml.dom import minidom + + +def select_indeces(valid_classes, max_imgs, xmlfolder): + ''' + Function that selects the indexes of the images of a + specific class contained in the source dataset. + + :param list(str) valid_classes: list of strings defining + the selected categories. + :param int max_imgs: maximum number of images to consider. + :param str xmlfolder: relative path to the folder + containing the annotations (xml files). + :return: valid_ids, list containg the selected indexes. + :rtype: list + ''' + valid_ids = [] + file = 'dataset.txt' + out_file = open(file, 'w') + + for id_ in range(1, 10000): + id_ = '00{:04d}'.format(id_) + xml_ = os.path.join(xmlfolder, '{}.xml'.format(id_)) + file_ = minidom.parse(xml_) + classes = file_.getElementsByTagName('object') + classes = [class_.getElementsByTagName('name')[0] for class_ in classes] + classes = [class_.firstChild.nodeValue for class_ in classes] + + if all([class_ in valid_classes for class_ in classes]): + valid_ids.append(id_) + out_file.write(id_ + '\n') + + if len(valid_ids) >= max_imgs: + break + out_file.close() + return valid_ids + +def copy_imgs(ids, src, dst, folder='JPEGImages'): + ''' + Function copying selected images from a directory. + ''' + + os.mkdir(os.path.join(dst, folder)) + + for id_ in ids: + src_ = os.path.join(src, folder, '{}.jpg'.format(id_)) + dst_ = os.path.join(dst, folder, '{}.jpg'.format(id_)) + shutil.copyfile(src_, dst_) + +def copy_xmls(ids, src, dst, folder='Annotations'): + ''' + Function copying selected xml files from a directory. + ''' + + os.mkdir(os.path.join(dst, folder)) + + for id_ in ids: + src_ = os.path.join(src, folder, '{}.xml'.format(id_)) + dst_ = os.path.join(dst, folder, '{}.xml'.format(id_)) + shutil.copyfile(src_, dst_) + +def sample_dataset(src_dataset, dst_dataset): + ''' + Function that performs the sampling of the dataset. + + :param str src_dataset: path to the source dataset. + :param str dst_dataset: path to the output dataset. + ''' + os.mkdir(dst_dataset) + + ids = select_indeces(['dog', 'cat'], 300, + os.path.join(src_dataset, 'Annotations')) + + copy_imgs(ids, src_dataset, dst_dataset) + copy_xmls(ids, src_dataset, dst_dataset) + + + +if __name__ == '__main__': + + sample_dataset('../VOCdevkit/VOC2007', 'VOC_dog_cat') diff --git a/smithers/ml/layers/ahosvd.py b/smithers/ml/layers/ahosvd.py new file mode 100644 index 0000000..5562d6b --- /dev/null +++ b/smithers/ml/layers/ahosvd.py @@ -0,0 +1,106 @@ +''' +Module focused on the implementation of Averaged Higher Order SVD +(AHOSVD) technique. +''' + +import torch +import numpy as np + +from smithers.ml.layers.hosvd import HOSVD + +class AHOSVD(): + """ + Class that handles the construction of the functions needed + to perform the dimensionality reduction of a given tensor, + which has exactly one dimension (the first one) that is too large, + thus preventing standard HOSVD to run on current architectures. + + This new technique is called Averaged Higher Order Singular + Value Decomposition (AHOSVD). Basically, HOSVD is performed on + batches of the outputs of the premodel, then the U matrices + resulting from HOSVD relative to the same unfolding direction + are averaged in order to keep the computing requirements (mainly + GPU storage) accessible. + + :param torch.Tensor tensor: snapshots tensor of dimensions + (n,d_1,...,d_n) + :param list[int] mode_number: list of integers representing the + target reduced dimensions; (d_1,...,d_n) will be reduced + :param int batch_len: number of element of the snapshot to process + together + """ + def __init__(self, tensor, red_dims, batch_len): + + self.tensor = tensor + self.red_dims = red_dims + if batch_len > tensor.size()[0] > 0: + raise ValueError('The batch for AHOSVD must be smaller than the' + + ' batch size of the data loader.') + self.batch_len = batch_len + self.u_matrices = [] + self.proj_matrices = [] + + def incremental_average(self, current_list, new_list, index): + """ + Auxiliary function used to compute the incremental step for a list + containing already computed + averages when another list of new values is given + :param list current_list: list containing the current averages + :param list new_list: list of the new values + :param int index: defines the number of elements the current average is taken over + :return: the updated list of averages + :rtype: list + """ + matrices_list = [] + if index == 0: + return new_list + elif index > 0: + for i, _ in enumerate(current_list): + matrices_list.append((index / (index + 1)) * current_list[i] + + (1/(index + 1)) * new_list[i]) + return matrices_list + elif index < 0: + raise ValueError('Index variable must be greater or equal to 0.') + + def _partial_hosvd(self, batch_from_tensor): + """ + Computes the partial HOSVD from a restricted sample of the snapshots tensor + + :param torch.Tensor batch_from_tensor: the batch given + :return: list of U matrices coming from the modal SVDs + :rtype: list[torch.Tensor] + """ + hosvd = HOSVD(batch_from_tensor.shape) + hosvd.fit(batch_from_tensor, return_S_tensor=False, for_AHOSVD=True) + return hosvd.modes_matrices + + + def compute_u_matrices(self): + """ + This function updates the current U matrices with their new values + from a never-seen batch of examples. + """ + for idx_ in range(int(np.floor(self.tensor.shape[0]/self.batch_len))): + p_hosvd = self._partial_hosvd(self.tensor[idx_ * self.batch_len : (idx_+1) * self.batch_len]) + self.u_matrices = self.incremental_average(self.u_matrices, p_hosvd, idx_) + + def compute_proj_matrices(self): + """ + This function sets the attribute proj_matrices with the transposes of + the matrices obtained from the numbers given in self.red_dims + of columns of the U matrices previously computed + """ + for i in range(len(self.u_matrices)): + self.proj_matrices.append(self.u_matrices[i][ :, : self.red_dims[i]].t().conj()) + +# example +if __name__ == '__main__': + import time + tensor1 = torch.randn(50000, 4, 4, 256).to('cuda') + start = time.time() + ahosvd = AHOSVD(tensor1, [3, 3, 50], 20) + ahosvd.compute_u_matrices() + print(f"The U matrices' dimensions are {[ahosvd.u_matrices[i].shape for i in range(len(ahosvd.u_matrices))]}") + ahosvd.compute_proj_matrices() + end = time.time() + print(f'time needed: {end-start} seconds') diff --git a/smithers/ml/layers/aux_conv.py b/smithers/ml/layers/aux_conv.py new file mode 100644 index 0000000..af3a206 --- /dev/null +++ b/smithers/ml/layers/aux_conv.py @@ -0,0 +1,102 @@ +''' +Module focused on the implementation of Auxiliary Convolutional Layers +''' +import torch.nn as nn +import torch.nn.functional as F + + +class AuxiliaryConvolutions(nn.Module): + """ + Additional convolutions to produce higher-level feature maps. + see the original paper where SSD300 is implemented for further + details: 'SSD: Single Shot Multibox Detector' by + Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, + Scott Reed, Cheng-Yang Fu, Alexander C. Berg + https://arxiv.org/abs/1512.02325 + DOI:10.1007/978-3-319-46448-0_2 + """ + def __init__(self, layers=None): + """ + :param list layers: If None, returns the configuration used in the + original SSD300 paper, mentioned before. Otherwise a list where + every element is a list of numbers representing the number of + filters for that convolutional layer + """ + super(AuxiliaryConvolutions, self).__init__() + + if layers is None: + layers = [[256, 512], [128, 256], [128, 256], [128, 256]] + self.layers = layers + self.features = self.make_auxlayers() + #Inizialize convolutions' parameters + self.init_conv2d() + + def make_auxlayers(self): + """ + # Auxiliary/additional convolutions on top of the VGG base + :param list cfg: configuration of the auxiliary layer for our CNN + (number of filters applied in that layers (thus the features + extracted)) + """ + layers = [] + in_channels = 1024 + #1280 number to be changed, put as param function + for k in range(len(self.layers)): + layers += [ + nn.Conv2d(in_channels, + self.layers[k][0], + kernel_size=1, + padding=0) + ] #stride=1 by default + if k < 2: + layers += [ + nn.Conv2d(self.layers[k][0], + self.layers[k][1], + kernel_size=3, + stride=2, + padding=1) + ] + # dim. reduction because stride > 1 + else: + layers += [ + nn.Conv2d(self.layers[k][0], + self.layers[k][1], + kernel_size=3, #1 change + padding=0) + ] + # dim. reduction because padding=0 + in_channels = self.layers[k][1] + + return nn.Sequential(*layers) + + def init_conv2d(self): + """ + Initialize convolution parameters + """ + for c in self.children(): + if isinstance(c, nn.Conv2d): + nn.init.xavier_uniform_(c.weight) + nn.init.constant_(c.bias, 0.) + + def forward(self, conv7_feats): + """ + Forward propagation. + :param Tensor conv7_feats: output of last classification layer + base network, lower-level conv7 feature map, a tensor of + dimensions (N, 1024, 19, 19) in the case of VGG16 + Note: Since these layers are thought as additional layers to be placed + after a base network, pay attention that the dimensions of conv7_feats + have to be consistent with that of the first layer of this structure. + :return list out_conv2: list containing higher-level feature maps + conv8_2, conv9_2, conv10_2, and conv11_2 + """ + out_in = conv7_feats + out_conv2 = [] + for conv in self.features: + out = F.relu(conv(out_in)) + out_conv2.append(out) + out_in = out + + # Higher-level feature maps, only the elements on odd position + # thus the features conv_2 + return out_conv2[1::2] diff --git a/smithers/ml/layers/hosvd.py b/smithers/ml/layers/hosvd.py new file mode 100644 index 0000000..23591a4 --- /dev/null +++ b/smithers/ml/layers/hosvd.py @@ -0,0 +1,215 @@ +''' +Module focused on the implementation of Higher Order SVD +(HOSVD) technique. +''' + +import torch +import numpy as np + +class HOSVD(): + def __init__(self, mode_number_list): + """ + Class that handles Higher Order SVD. + Use the tensor of interest shape as parameter, if all the hosvd modes + are required in the reduction. + + :param list[int] mode_number_list: list containing the number of modes + considered for each dimension + + :Example: + >>> HOSVD = HOSVD() + >>> random_tensor = torch.randn(101,102,103) + >>> HOSVD.fit(random_tensor) + >>> transformed = HOSVD.transform(random_tensor) + >>> inverted = HOSVD.inverse_transform(transformed) + >>> random_test_tensor = torch.randn(101,102,103) + >>> relative_error = torch.linalg.norm(HOSVD.inverse_transform( + HOSVD.transform(random_test_tensor))- + random_test_tensor)/torch.linalg.norm(random_test_tensor) + >>> print('''The input tensor's shape is {} + The projected tensor's shape {} + The output tensor's shape is {} + The relative error on the test tensor is {:.4}'''.format( + random_tensor.shape, transformed.shape, inverted.shape, relative_error)) + """ + self.modes_matrices = None + self.singular_values = None + self.modal_singular_values = [] + self.mode_number_list = list(mode_number_list) + + def unfolding(self, inputs, n): + """ + Method that handles the unfolding of a tensor as a matrix + + :param torch.Tensor inputs: the input tensor + :param int n: the dimension along which the unfolding is done + :return: unfolded tensor inputs along n-th direction + :rtype: torch.Tensor + """ + shape = inputs.shape + tensor_dimensions = len(shape) + size = np.prod(shape) + size_list = list(range(tensor_dimensions)) + size_list[n] = 0 + size_list[0] = n + n_rows = int(shape[n]) + n_columns = int(size / n_rows) + return inputs.permute(size_list).reshape(n_rows, n_columns) + + def modalsvd(self, inputs, n): + """ + Method that performs the standard SVD of an unfolded matrix defined from an input tensor + along a given dimension + + :param torch.Tensor inputs: the input tensor + :param int n: the index of the unfolding matrix being decomposed + :return: three SVD matrices of the n-th unfolding of tensor inputs + :rtype: torch.Tensors + """ + return torch.linalg.svd(self.unfolding(inputs, n), full_matrices=True) + + def higherorderSVD_noS(self, inputs, for_AHOSVD=False): + """ + Mathod that performs the Higher Order SVD on a given tensor. + This method DOES NOT return the singular value tensor S + + :param torch.Tensor inputs: the input tensor + :param bool for_AHOSVD: if True, the function only computes the necessary modal + SVDs for the AHOSVD technique + :return: list containing the U matrices from all the modal SVDs of tensor A + :rtype: list[torch.Tensor] + """ + U_matrices = [] + if not for_AHOSVD: + for i in range(len(inputs.shape)): + u, sigma, _ = self.modalsvd(inputs, i) + self.modal_singular_values.append(sigma/sigma[0]) + U_matrices.append(u) + elif for_AHOSVD: + for i in range(1, len(inputs.shape)): + u, sigma, _ = self.modalsvd(inputs, i) + self.modal_singular_values.append(sigma/sigma[0]) + U_matrices.append(u) + return U_matrices + + def higherorderSVD_withS(self, inputs): + """ + Mathod that performs the Higher Order SVD on a given tensor. + This method DOES return the singular value tensor S + + :param torch.Tensor A: the input tensor + """ + U_matrices = [] + S = inputs.clone() + for i in range(len(inputs.shape)): + u, sigma, _ = self.modalsvd(inputs, i) + self.modal_singular_values.append(sigma/sigma[0]) + U_matrices.append(u) + S = torch.tensordot(S, u, dims=([0], [0])) + return U_matrices, S + + def fit(self, inputs, return_S_tensor=False, for_AHOSVD=False): + """ + Create the reduced space for the given snapshots A using HOSVD + + :param torch.Tensor inputs: the input tensor + :param bool return_S_tensor: state whether or not you are interested in the singular + value tensor (requires more computations) + """ + if not return_S_tensor: + self.modes_matrices = self.higherorderSVD_noS(inputs, for_AHOSVD=for_AHOSVD) + else: + self.modes_matrices, self.singular_values = self.higherorderSVD_withS(inputs) + + + def tensor_reverse(self, inputs): + """ + Function that reverses the directions of a tensor + + :param torch.Tensor inputs: the input tensor with dimensions (d_1,d_2,...,d_n) + :return: input tensor with reversed dimensions (d_n,...,d_2,d_1) + :rtype: torch.Tensor + """ + incr_list = [i for i in range(len(inputs.shape))] + incr_list.reverse() + return torch.permute(inputs, tuple(incr_list)) + + def transform(self, inputs): + """ + Reduces the given snapshots tensor + + :param torch.Tensor inputs: the input tensor + :return: the reduced version of the input tensor via the reduction matrices + computed with HOSVD + :rtype: torch.Tensor + """ + for i, _ in enumerate(inputs.shape): + inputs = torch.tensordot(self.modes_matrices[i][:, :self.mode_number_list[i]].t().conj(), inputs, ([1], [i])) + return self.tensor_reverse(inputs) + + def inverse_transform(self, inputs): + """ + Reconstruct the full order solution from the projected one + + :param torch.Tensor inputs: the input tensor + :return: the reconstructed solution + :rtype: torch.Tensor + """ + for i, _ in enumerate(inputs.shape): + inputs = torch.tensordot(self.modes_matrices[i][:, :self.mode_number_list[i]], inputs, ([1], [i])) + return self.tensor_reverse(inputs) + + def reduce(self, inputs): + """ + Reduces the given snapshots tensor + + :param torch.Tensor inputs: the input tensor + :return: the reduced version of the input tensor via the reduction matrices computed with HOSVD + :rtype: torch.Tensor + + .. note:: + Same as `transform`. Kept for backward compatibility. + """ + return self.transform(inputs) + + def expand(self, inputs): + """ + Reconstruct the full order solution from the projected one + + :param torch.Tensor inputs: the input tensor + :return: the reconstructed solution + :rtype: torch.Tensor + + .. note:: + Same as `inverse_transform`. Kept for backward compatibility. + """ + return self.inverse_transform(inputs) + + +def test_accuracy(tensor, ranks): + """ + Given a tensor, this function returns the relative error derived from projecting such + tensor using HOSVD and then going back to the reconstructed original tensor via + the inverse projection. + :param torch.Tensor tensor: the input tensor to be tested on + :param list[int] ranks: list of the ranks of the individual directional projections + (len(ranks) must be equal to len(tensor.shape)) + :return: relative error of the method and list of the singular values of each unfolding + :rtype: float, list[torch.Tensor] + """ + HOSVD = hosvd(ranks) + HOSVD.fit(tensor, return_S_tensor=True) + red_tensor = HOSVD.transform(tensor) + reconstruct_tensor = HOSVD.inverse_transform(red_tensor) + error = torch.linalg.norm(reconstruct_tensor - tensor) + relative_error = error / np.linalg.norm(tensor) + return relative_error, HOSVD.modal_singular_values + +# example +if __name__ == '__main__': + tensor1 = torch.zeros(100, 100, 100) + for idx_ in range(100): + tensor1[idx_, :, :] += idx_ + err, sing_vals = test_accuracy(tensor1, [1, 1, 1]) + print(f'relative error: {err}') + #print(sing_vals) diff --git a/smithers/ml/layers/pcemodel.py b/smithers/ml/layers/pcemodel.py new file mode 100644 index 0000000..c211697 --- /dev/null +++ b/smithers/ml/layers/pcemodel.py @@ -0,0 +1,185 @@ +''' +Module focused on the implementation of the Polunomial Chaos +Expansion Layer (PCE). +''' + +import torch +import torch.nn as nn +import scipy.misc +from sklearn.linear_model import LinearRegression +import numpy as np + + +class PCEModel(nn.Module): + ''' + Class that handles the implementation of the PCE layer as given + in step 2 of Algorithm 3.1 in the paper: + - Chunfeng Cui, Kaiqi Zhang, Talgat Daulbaev, Julia Gusak, + Ivan Oseledets, and Zheng Zhang. "Active Subspace of Neural + Networks: Structural Analysis and Universal Attacks". + accepted by SIAM Journal on Mathematics of Data Science (SIMODS) + + :param torch.tensor mean: tensor containing the mean value of all + elements in the input tensor (output AS layer) + :param torch.tensor var: tensor containing the variance of all + elements in the input tensor (output AS layer) + :param int d: If is not specified, its value is set to the default + one, that is 50. + :param int p: If is not specified, its value is set to the default + value 2. + :param torch.device device: object representing the device on + which a torch.Tensor is or will be allocated. If None, the device + in use is the cpu. + ''' + def __init__(self, mean, var, d=50, p=2, device=None): + super(PCEModel, self).__init__() + self.d = d + self.p = p + self.mean = mean + self.var = var + # scipy.special.comb(N,k):The number of combinations of N + # things taken k at a time. + self.nbasis = scipy.special.comb(d + p, p).astype(int) + if device is None: + self.device = 'cpu' + else: + self.device = device + self.oneDbasis = self.NormalBasis() + self.idxset = indexset(d, 0) + for i in range(1, p + 1): + self.idxset = torch.cat((self.idxset, indexset(d, i)), dim=0) + + self.mean = nn.Parameter(self.mean, requires_grad=False) + self.var = nn.Parameter(self.var, requires_grad=False) + self.oneDbasis = nn.Parameter(self.oneDbasis, requires_grad=False) + self.idxset = nn.Parameter(self.idxset, requires_grad=False) + + def NormalBasis(self): + ''' + Basis Functions for normal distribution + :return: matrix containing the basis functions for normal + distribution. + :rtype: torch.tensor + ''' + B = torch.zeros([self.p + 1, self.p + 1]) + B[0, 0] = 1 # 0nd order + if self.p >= 1: + B[1, 1] = 2 # 1st order + for i in range(1, self.p): # i-th order + B[i + 1, 1:i + 2] = 2 * B[i, :i + 1] + B[i + 1, :i] -= 2 * i * B[i - 1, :i] + return B + + def PolyVal(self, x): + ''' + Functions that handles the evaluation of the basis function at the + input vector + :param torch.tensor x: input tensor where we evaluate the functions at + :return: tensor containing the basis functions evaluated at x + :rtype: torch.tensor + ''' + [n, m] = x.shape + x_pows = torch.zeros((n, m, self.p + 1), dtype=torch.float32) + for i in range(self.p + 1): + x_pows[:, :, i] = x**i + + polyval = torch.zeros((n, m, self.p + 1), dtype=torch.float32) + for ip in range(self.p + 1): + for i in range(ip + 1): + if self.oneDbasis[ip, i] != 0: + polyval[:, :, ip] += self.oneDbasis[ip, i] * x_pows[:, :, i] + return polyval.to(self.device) + + def forward(self, x): + ''' + Function that handles the evaluation of the basis functions + at input x scaled with mean and variance and creation of the + related matrix + :param torch.tensor x: tensor where we compute the basis functions + (input of that layer, e.g. output reduction layer) + :return: matrix containing the basis functions evaluated at x + :rtype: torch.tensor + ''' + k = len(self.mean) + assert len(self.var) == k + for i in range(k): + x[:, i] = (x[:, i] - self.mean[i]) / self.var[i] + + oneDpolyval = self.PolyVal(x) + + Phi = torch.ones([x.shape[0], self.nbasis], + dtype=torch.float32).to(self.device) + for j in range(k): + Phi *= oneDpolyval[:, j, self.idxset[:, j]] + return Phi + + def Training(self, x, y, label): + ''' + Function that implements the training procedure of the PCEmodel + :param torch.tensor x: tensor representing the output of the + reduction layer + :param torch.tensor y: tensor representing the total output of the + net + :param torch.tensor label: tensor representing the labels associated + to each image in the train dataset + :return: coefficients of the linear combination of the basis + functions, coefficient of determination R^2 of the prediction, + scores for each image + :rtype: np.ndarray, float, float + ''' + Phi = self.forward(x) + + if not isinstance(Phi, np.ndarray): + Phi = Phi.cpu().detach().numpy() + if not isinstance(y, np.ndarray): + y = y.cpu().detach().numpy() + if not isinstance(label, np.ndarray): + label = label.cpu().numpy() + + LR = LinearRegression(fit_intercept=False).fit(Phi, y) + + # Return the coefficient of determination R^2 of the prediction (float) + score_approx = LR.score(Phi, y) + coeff = LR.coef_.transpose() + y_PCE = Phi @ coeff + score_label = (label == np.argmax(y_PCE, axis=1)).mean() + return coeff, score_approx, score_label + + def Inference(self, x, coeff): + ''' + Inference function + :param torch.tensor x: input tensor + :param torch.tensor coeff: coefficient tensor + :return: inference matrix + :rtype: torch.tensor + ''' + Phi = self.forward(x) + if Phi.shape[1] == coeff.shape[0]: + y = Phi @ coeff.to(self.device) + else: + y = Phi.t() @ coeff.t().to(self.device) + return y + + +def indexset(d, p): + ''' + :param int d + :param int p + :return: tensor IdxMat + :rtype: torch.tensor + ''' + if d == 1: + IdxMat = p * torch.ones((1, 1), dtype=torch.int64) + else: + for i in range(p + 1): + Idx_tmp = indexset(d - 1, p - i) + sz = Idx_tmp.shape[0] + Idx_tmp = torch.cat((i * torch.ones( + (sz, 1), dtype=torch.int64), Idx_tmp), + dim=1) + if i == 0: + IdxMat = Idx_tmp + else: + IdxMat = torch.cat((IdxMat, Idx_tmp), dim=0) + + return IdxMat diff --git a/smithers/ml/layers/predictor.py b/smithers/ml/layers/predictor.py new file mode 100644 index 0000000..ed18e09 --- /dev/null +++ b/smithers/ml/layers/predictor.py @@ -0,0 +1,170 @@ +''' +Module focused on the implementation of Prediction Convolutional Layers +''' +import torch +import torch.nn as nn + + +class PredictionConvolutions(nn.Module): + ''' + Convolutions to predict class scores and bounding boxes using lower and + higher-level feature maps. + + The bounding boxes (locations) are predicted as encoded offsets w.r.t + each of the 8732 prior (default) boxes. The Encode bounding boxes + (that are in center-size form) w.r.t. the corresponding prior boxes + (that are in center-size form). + + The class scores represent the scores of each object class in each of the + 8732 bounding boxes located. A high score for 'background' = no object. + + See the original paper where SSD300 is implemented for further + details: 'SSD: Single Shot Multibox Detector' by + Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, + Scott Reed, Cheng-Yang Fu, Alexander C. Berg + https://arxiv.org/abs/1512.02325 + DOI:10.1007/978-3-319-46448-0_2 + + :param int n_classes: number of different types of objects + :param list cfg_tot: If None, it returns the configuration used in the + original SSD300 paper, mentioned before. Otherwise a list where + every element is a number representing all the filters applied in + that convolutional layer. + NOTE: These layers are exactly the layers selected in low_feats and + aux_conv_feats, thus the dimensions in this list have to be consistent + with that of those convolutional layers. + :param list n_boxes: If None, returns the number of prior-boxes for each + feature map as described in the original paper for SSD300, i.e. + {'conv4_3': 4, 'conv7': 6, 'conv8_2': 6, 'conv9_2': 6,'conv10_2': 4, + 'conv11_2': 4}, where 4 prior-boxes implies we use 4 different + aspect ratios, etc. Otherwise you need to provide a list containing + the number of prior boxes associated to every feature map + ''' + def __init__(self, n_classes, cfg_tot=None, n_boxes=None): + super(PredictionConvolutions, self).__init__() + + self.n_classes = n_classes + + if cfg_tot is None: + cfg_tot = [512, 1024, 512, 256, 256, 256] + self.cfg_tot = cfg_tot + + if n_boxes is None: + n_boxes = [4, 6, 6, 6, 4, 4] + self.n_boxes = n_boxes + + # Localization prediction convolutions (predict offsets w.r.t + # prior-boxes) + self.features_loc = self.make_predlayers('loc') + # Class prediction convolutions (predict classes in + # localization boxes) + self.features_cl = self.make_predlayers('cl') + # Initialize convolutions' parameters + self.init_conv2d() + + def make_predlayers(self, task): + ''' + Construct the structure of the net starting from the configuration + given in input. + + :param str task: a string that describes the task you are requiring, + i.e. localization (for the definition of the correct bounding + box) or classification (of the object in the picture) + :return: sequential object containing the structure of the net + :rtype: nn.Sequential + ''' + layers = [] + for l in range(len(self.cfg_tot)): + if task == 'loc': + layers += [ + nn.Conv2d(self.cfg_tot[l], + self.n_boxes[l] * 4, + kernel_size=3, + padding=1) + ] + elif task == 'cl': + layers += [ + nn.Conv2d(self.cfg_tot[l], + self.n_boxes[l] * self.n_classes, + kernel_size=3, + padding=1) + ] + else: + raise RuntimeError( + 'The task assigned is not recognized by the network.') + + return nn.Sequential(*layers) + + def init_conv2d(self): + ''' + Initialize convolutional parameters + ''' + for c in self.children(): + if isinstance(c, nn.Conv2d): + nn.init.xavier_uniform_(c.weight) + + def forward(self, low_feats, auxconv_feats): + ''' + Forward propagation. + + :param list of tensors low_feats: list representing the output of + VGG.forward(), thus containing the low-level features map. + For example in the case of SSD300, they are represented by + conv4_3 and conv7: + - conv4_3_feats: conv4_3 feature map, a tensor of dimensions + (N, 512, 38, 38) + - conv7_feats: conv7 feature map, a tensor of dimensions + (N, 1024, 19, 19) + :param list of tensors auxconv_feats: list representing the output of + AuxiliaryConvolutions.forward(), thus containing the auxiliary + convolution feature maps. + For example, in the case of SSD300, they are: + - conv8_2_feats: conv8_2 feature map, a tensor of dimensions + (N, 512, 10, 10) + - conv9_2_feats: conv9_2 feature map, a tensor of dimensions + (N, 256, 5, 5) + - conv10_2_feats: conv10_2 feature map, a tensor of dimensions + (N, 256, 3, 3) + - conv11_2_feats: conv11_2 feature map, a tensor of dimensions + (N, 256, 1, 1) + :return: total_numberpriors locations and class scores for each image. + In the case of SSD it will returns 8732 locations and class scores + (i.e. w.r.t each prior box) for each image + :rtype: torch.Tensor, torch.Tensor + ''' + #batch_size: the total number of images we are using + #in our setting this is represented by the first number in the shape of + # all the features map (this number is equal in all of them) + batch_size = low_feats[0].size(0) + conv_feats = low_feats + auxconv_feats + + + locs = [] + classes_scores = [] + + for k in range(len(conv_feats)): + # Predict localization boxes' bounds (as offsets w.r.t prior-boxes) + loc_conv = self.features_loc[k](conv_feats[k]) + loc_conv = loc_conv.permute(0, 2, 3, 1).contiguous() + # to match prior-box order (after .view()) + # (.contiguous() ensures it is stored in a contiguous chunk + # of memory, needed for .view() below) + loc_conv = loc_conv.view(batch_size, -1, 4) + locs.append(loc_conv) + + # Predict classes in localization boxes + cl_conv = self.features_cl[k](conv_feats[k]) + cl_conv = cl_conv.permute(0, 2, 3, 1).contiguous() + # to match prior-box order (after .view()) + # (.contiguous() ensures it is stored in a contiguous chunk + # of memory, needed for .view() below) + cl_conv = cl_conv.view(batch_size, -1, self.n_classes) + classes_scores.append(cl_conv) + + # A total of 8732 boxes + # Concatenate in this specific order (i.e. must match the order of + # the prior-boxes) + locs = torch.cat(locs, dim=1) + classes_scores = torch.cat(classes_scores, dim=1) + + return locs, classes_scores diff --git a/smithers/ml/layers/tensor_product_layer.py b/smithers/ml/layers/tensor_product_layer.py new file mode 100644 index 0000000..e20d960 --- /dev/null +++ b/smithers/ml/layers/tensor_product_layer.py @@ -0,0 +1,60 @@ +''' +Module handling the creation of a layer for the projection of a tensorial +object (case 1D it corresponds to nn.Linear. +''' + +import torch +import torch.nn as nn +from torch.nn.parameter import Parameter + +from smithers.ml.utils_rednet import tensor_reverse + +class tensor_product_layer(nn.Module): + """ + Class that handles the definition of a PyTorch layer created to + compute several specific tensor products: given a list of matrices and a tensor, + its job is to multiply the i-th one dimensional sections of the tensor by the i-th + matrix of the list. + + """ + def __init__(self, list_of_matrices): + """ + :param list[torch.Tensor] list_of_matrices: list of the matrices that will multiply the one dimensional sections of a given tensor + """ + super(tensor_product_layer, self).__init__() + self.list_of_matrices = list_of_matrices + self.param0 = Parameter(list_of_matrices[0]) + self.param1 = Parameter(list_of_matrices[1]) + self.param2 = Parameter(list_of_matrices[2]) + + def forward(self, input_tensor): + """ + Forward function of the layer. The if clause concern tha case in which a single tensor + needs to be projected, the else clause deals with the possibility of multiple tensors being provided + + :param torch.Tensor input_tensor: the input tensor (either single tensor or tensor as a collection of tensors + :return: the projected tensor (either full or its "components") + :rtype: torch.Tensor + """ + if len(input_tensor.shape) == len(self.list_of_matrices): + for i, _ in enumerate(input_tensor.shape): + input_tensor = torch.tensordot(self.list_of_matrices[i], input_tensor, ([1],[i])) + return tensor_reverse(input_tensor) + elif len(input_tensor.shape) == len(self.list_of_matrices) + 1: + for i in range(len(self.list_of_matrices)): + input_tensor = torch.tensordot(self.list_of_matrices[i], input_tensor, ([1],[i+1])) + return tensor_reverse(input_tensor) + + def extra_repr(self): + return 'in_dimensions={}, out_dimensions={}'.format([self.list_of_matrices[i].shape[1] for i in range(len(self.list_of_matrices))], [self.list_of_matrices[i].shape[0] for i in range(len(self.list_of_matrices))]) + +if __name__ == '__main__': + from smithers.ml.AHOSVD import AHOSVD + tensor_batch = torch.randn(100, 256, 4, 4).to('cuda') + tensor_image = torch.randn(256, 4, 4).to('cuda') + ahosvd = AHOSVD(tensor_batch, [25, 50, 3, 3], 25) + ahosvd.compute_u_matrices() + ahosvd.compute_proj_matrices() + my_layer = tensor_product_layer(ahosvd.proj_matrices) + projected_obs = my_layer.forward(tensor_image) + print(projected_obs.shape) diff --git a/smithers/ml/loss/multibox_loss.py b/smithers/ml/loss/multibox_loss.py new file mode 100644 index 0000000..410e754 --- /dev/null +++ b/smithers/ml/loss/multibox_loss.py @@ -0,0 +1,212 @@ +''' +Module focused on the implementation of the MultiBox Loss Function. +''' +import torch +import torch.nn as nn +import numpy as np + +from smithers.ml.utils_objdet import cxcy_to_xy, find_jaccard_overlap, cxcy_to_gcxgcy, xy_to_cxcy + +device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + + +class MultiBoxLoss(nn.Module): + """ + The MultiBox loss, a loss function for object detection. + As described in the SSD original paper: + 'SSD: Single Shot Multibox Detector' by + Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, + Scott Reed, Cheng-Yang Fu, Alexander C. Berg + https://arxiv.org/abs/1512.02325 + DOI: 10.1007/978-3-319-46448-0_2 + + This is a combination of: + (1) a localization loss for the predicted locations of the boxes, and + (2) a confidence loss for the predicted class scores. + """ + def __init__( + self, + priors_cxcy, + threshold=0.5, + neg_pos_ratio=3, + alpha=1., + #size_average=None, + #reduce=None, + #reduction='mean'): + reduction='None'): + ''' + :param tensor priors_cxcy: priors (default bounding boxes) in center-size + coordinates, a tensor of size (n_boxes, 4) + :param float threshold: Threshold for the Jaccard overlap. If it is greater + than the threshold value, the box is said to "contain" the object. + Thu we have a positive match. Otherwise, it does not contain it and + we have a negative match and it is labeled as background. + :param int neg_pos_ratio: ratio that connected the number of positive matches + (N_p) with the hard negatives (N_hn). Usually they are a fixed + multiple of the number of positive matches for an image: + N_hn = neg_pos_ratio * N_p + :param int alpha: ratio of combination between the two different losses + (localization and confidence) It can be a learnable parameter or + fixed, as in the case of SSD300 where the authors decided to use + alpha=1.(default value) + :param string reduction: Specifies the reduction to apply to the output: + 'None', 'mean' or 'sum'. + - If None, no reduction will be applied. + - If mean, the sum of the output will be divided by the number of + elements in the output. + - If sum, the output will be summed. + ''' + super(MultiBoxLoss, self).__init__() + self.priors_cxcy = priors_cxcy + #convert bounding boxes from center-size coordinates (c_x, c_y, w, h) to + #boundary coordinates (x_min, y_min, x_max, y_max) + self.priors_xy = cxcy_to_xy(priors_cxcy) + self.threshold = threshold + self.neg_pos_ratio = neg_pos_ratio + self.alpha = alpha + + self.smooth_l1 = nn.L1Loss() + #self.cross_entropy = nn.CrossEntropyLoss(reduce=False) + self.cross_entropy = nn.CrossEntropyLoss(reduction='none') + + def forward(self, predicted_locs, predicted_scores, boxes, labels): + """ + Forward propagation. + + :param predicted_locs: predicted locations/boxes w.r.t the 8732 prior + boxes, a tensor of dimensions (N, 8732, 4). Thus, one of the + outputs of PredictionConvolutions.forward(). + :param predicted_scores: class scores for each of the encoded + locations/boxes, a tensor of dimensions (N, 8732, n_classes). Thus, + the other output of PredictionConvolutions.forward(). + :param boxes: true object bounding boxes (ground-truth) in boundary + coordinates, a list of N tensors, where N is the total number of + pictures. (for each image I have a n_objects boxes, where + n_objects is the number of objects contained in that image) + :param labels: true object labels, a list of N tensors, where each + tensor has dimensions n_objects(for that image). + :return: multibox loss, a zero dimensional tensor (NOT a scalar!) + """ + batch_size = predicted_locs.size(0) + n_priors = self.priors_cxcy.size(0) + n_classes = predicted_scores.size(2) + + assert n_priors == predicted_locs.size(1) == predicted_scores.size(1) + + true_locs = torch.zeros((batch_size, n_priors, 4), + dtype=torch.float).to(device) # (N, 8732, 4) + true_classes = torch.zeros((batch_size, n_priors), + dtype=torch.long).to(device) # (N, 8732) + + # For each image + for i in range(batch_size): + n_objects = boxes[i].size(0) + + overlap = find_jaccard_overlap(boxes[i], + self.priors_xy) # (n_objects, 8732) + + # For each prior, find the object that has the maximum overlap + overlap_for_each_prior, object_for_each_prior = overlap.max( + dim=0) # (8732) + + # We don't want a situation where an object is not represented in + # our positive (non-background) priors - + # 1. An object might not be the best object for all priors, and is + # therefore not in object_for_each_prior. + # 2. All priors with the object may be assigned as background based + # on the threshold (0.5). + # To remedy: First, find the prior that has the maximum overlap for + # each object. + _, prior_for_each_object = overlap.max(dim=1) # (N_o) + + # Then, assign each object to the corresponding + # maximum-overlap-prior. + # This fixes 1. : in this way all the objects are considered. + object_for_each_prior[prior_for_each_object] = torch.LongTensor( + range(n_objects)).to(device) + + # To ensure these priors qualify, artificially give them an overlap + # of greater than 0.5. This fixes 2.: the objects that previously + # where not considered may have an overlap lower than the + # threshold. Thus in order to avoid this, we give them a + # value of 1. + overlap_for_each_prior[prior_for_each_object] = 1. + + # Labels for each prior + label_for_each_prior = labels[i][object_for_each_prior] # (8732) + # Set priors whose overlaps with objects are less than + # the threshold to be background (no object) + label_for_each_prior[ + overlap_for_each_prior < self.threshold] = 0 # (8732) + + # Store classes and localizations + true_classes[i] = label_for_each_prior + + # Encode center-size object coordinates into the form we regressed + # predicted boxes to + true_locs[i] = cxcy_to_gcxgcy( + xy_to_cxcy(boxes[i][object_for_each_prior]), + self.priors_cxcy) # (8732, 4) + + # Identify priors that are positive (object/non-background) + positive_priors = true_classes != 0 # (N, 8732) boolean values + + # LOCALIZATION LOSS + # Localization loss is computed only over positive (non-background) + # priors + loc_loss = self.smooth_l1(predicted_locs[positive_priors], + true_locs[positive_priors]) # (), scalar + + # Note: indexing with a torch.uint8 (byte) tensor flattens the tensor + # when indexing is across multiple dimensions (N & 8732) + # So, if predicted_locs has the shape (N, 8732, 4), + # predicted_locs[positive_priors] will have (total positives, 4) + + # CONFIDENCE LOSS + # Confidence loss is computed over positive priors and the most + # difficult (hardest) negative priors in each image + # That is, FOR EACH IMAGE, we will take the hardest + # (neg_pos_ratio * n_positives) negative priors, i.e where there is + # maximum loss. This is called Hard Negative Mining - it concentrates on + # hardest negatives in each image, and also minimizes pos/neg imbalance + + # Number of positive and hard-negative priors per image + n_positives = positive_priors.sum(dim=1) # (N) + n_hard_negatives = self.neg_pos_ratio * n_positives # (N) + + # First, find the loss for all priors + # we flatten the tensor predicted_scores from + # (num_img, num_priors, n_classes) to (num_img * num_priors, n_classes) + conf_loss_all = self.cross_entropy(predicted_scores.view(-1, n_classes), + true_classes.view(-1)) # (N * 8732) + + conf_loss_all = conf_loss_all.view(batch_size, n_priors) # (N, 8732) + + # We already know which priors are positive + conf_loss_pos = conf_loss_all[positive_priors] # (sum(n_positives)) + + # Next, find which priors are hard-negative + # To do this, sort ONLY negative priors in each image in order of + # decreasing loss and take top n_hard_negatives + conf_loss_neg = conf_loss_all.clone() # (N, 8732) + conf_loss_neg[positive_priors] = 0. + # (N, 8732), positive priors are ignored (never in top n_hard_negatives) + conf_loss_neg, _ = conf_loss_neg.sort( + dim=1, descending=True) # (N, 8732), sorted by decreasing hardness + # expand_as: used to give the same dimension of a tensor1 to a tensor2 + # which shape differs from those of tensor1 in a dimension (the value + # associated for this dimension in tensor2 has to be less than its value + # for tensor1) + hardness_ranks = torch.LongTensor( + range(n_priors)).unsqueeze(0).expand_as(conf_loss_neg).to( + device) # (N, 8732) + hard_negatives = hardness_ranks < n_hard_negatives.unsqueeze( + 1) # (N, 8732) + conf_loss_hard_neg = conf_loss_neg[ + hard_negatives] # (sum(n_hard_negatives)) 1d tensor + # As in the paper, averaged over positive priors only, although computed + # over both positive and hard-negative priors + conf_loss = (conf_loss_hard_neg.sum() + conf_loss_pos.sum() + ) / n_positives.sum().float() # (), scalar + # TOTAL LOSS + return conf_loss + self.alpha * loc_loss diff --git a/smithers/ml/models/detector.py b/smithers/ml/models/detector.py new file mode 100644 index 0000000..571f0d3 --- /dev/null +++ b/smithers/ml/models/detector.py @@ -0,0 +1,592 @@ +''' +Module focused on the creation of the object detector and implementaion of the +training and testing phases. +''' +from functools import reduce +from pprint import PrettyPrinter +import time +import torch +import torch.nn as nn +import numpy as np +from torchvision import transforms +from tqdm import tqdm +from PIL import ImageDraw, ImageFont +import copy + +from smithers.ml.loss.multibox_loss import MultiBoxLoss +from smithers.ml.utils_objdet import AverageMeter, clip_gradient, adjust_learning_rate, detect_objects, calculate_mAP, save_checkpoint_objdet + +device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + + +class Detector(nn.Module): + ''' + Class that handles the creation of the Object Detector and its training and + testing phases. + ''' + def __init__(self, network, checkpoint, priors_cxcy, n_classes, epochs, + batch_size, print_freq, lr, decay_lr_at, decay_lr_to, momentum, + weight_decay, grad_clip, train_loader, test_loader, optim_str): + ''' + :param list network: list of the different parts that compose the network + For each element you need to construct it using the class related. + :param path_file checkpoint: If None, you will need to initialize the + model and optimizer from zero, otherwise you will load them from + the checkpoint file given in input. + :param tensor priors_cxcy: priors (default bounding boxes) in + center-size coordinates, a tensor of size (n_boxes, 4) + :param scalar n_classes: number of different type of objects in your + dataset + :param scalar epochs: number of epochs to run without early-stopping + :param scalar batch_size: batch size + :param int print_freq: print training status every __ batches + :param scalar lr: learning rate + :param list decay_lr_at: decay learning rate after these many iterations + :param float decay_lr_to: decay learnign rate to this fraction of the + existing learning rate + :param scalar momentum: momentum rate + :param scalar weight_decay: weight decay + :param bool grad_clip: clip if gradients are exploding, which may happen + at larger batch sizes (sometimes at 32) - you will recognize it by a + sorting error in the MultiBox loss calculation + :param iterable train_loader: iterable object, it loads the dataset for + training. It iterates over the given dataset, obtained combining a + dataset(images, boxes and labels) and a sampler. + :param iterable test_loader: iterable object, it loads the dataset for + testing. It iterates over the given dataset, obtained combining a + dataset(images, boxes and labels) and a sampler. + :param str optim_str: string idetifying the optimzer to use, as 'Adam' + or 'SGD'. + ''' + super(Detector, self).__init__() + + self.priors = priors_cxcy.to(device) + self.n_classes = n_classes + self.batch_size = batch_size + self.print_freq = print_freq + self.lr = lr + self.decay_lr_at = decay_lr_at + self.decay_lr_to = decay_lr_to + self.momentum = momentum + self.weight_decay = weight_decay + self.grad_clip = grad_clip + self.criterion = MultiBoxLoss(self.priors).to(device) + #Stocastic gradient descent + self.train_loader = train_loader + self.test_loader = test_loader + self.optim_str = optim_str + self.start_epoch, self.model, self.optimizer = self.load_network( + network, checkpoint) + # Since lower level features (conv4_3_feats) have considerably larger + # scales, we take the L2 norm and rescale. Rescale factor is initially + # set at 20, but is learned for each channel during back-prop + self.rescale_factors = nn.Parameter(torch.FloatTensor( + 1, 512, 1, 1)).to(device) # there are 512 channels in conv4_3_feats + nn.init.constant_(self.rescale_factors, 20) + self.epochs = self.start_epoch + epochs + + def load_network(self, network, checkpoint): + ''' + Initialize model or load checkpoint + If checkpoint is None, initialize the model and optimizer + otherwise load checkpoint, coming from a previous training + and load the model and optimizer from here + :param list network: if is not None, it corresponds to a list + containing the different structures that compose your net. + Otherwise, if None, it means that we are loading the model from + a checkpoint + :param path_file checkpoint: If None, initialize the model and optimizer, + otherwise load them from the checkpoint file given in input. + ''' + + if checkpoint is None: + start_epoch = 0 + model = [network[i].to(device) for i in range(len(network))] + optimizer = self.init_optimizer(model) + else: + checkpoint = torch.load(checkpoint) + if isinstance(checkpoint, dict): + start_epoch = checkpoint['epoch'] + 1 + print('\nLoaded checkpoint from epoch %d.\n' % start_epoch) + net = checkpoint['model'] + model = [net[i].to(device) for i in range(len(net))] + optimizer = checkpoint['optimizer'] + else: + model = [checkpoint[i].to(device) for i in range(len(checkpoint))] + start_epoch = 0 + optimizer = self.init_optimizer(model) + return start_epoch, model, optimizer + + def init_optimizer(self, model): + ''' + Initialize the optimizer, with twice the default learning rate for + biases, as in the original Caffe repo + :param list model: list of the different parts that compose the network + For each element you need to construct it using the class related. + :return optimizer: optimizer object chosen + ''' + biases = list() + not_biases = list() + model_params = [model[i].named_parameters() for i in range(len(model)) + ] + for i in range(len(model_params)): + for param_name, param in model_params[i]: + if param.requires_grad: + if param_name.endswith('.bias'): + biases.append(param) + else: + not_biases.append(param) + if self.optim_str=='Adam': + optimizer = torch.optim.Adam(params=[{ + 'params': biases, + 'lr': self.lr + }, { + 'params': not_biases + }], + lr=self.lr, + weight_decay=self.weight_decay) + elif self.optim_str=='SGD': + optimizer = torch.optim.SGD(params=[{ + 'params': biases, + 'lr': 2 * self.lr + }, { + 'params': not_biases + }], + lr=self.lr, + momentum=self.momentum, + weight_decay=self.weight_decay) + else: + raise RuntimeError( + 'Invalid choice for the optimizer.') + + return optimizer + + def forward(self, images): + ''' + Forward propagation of the entire network. + + :param tensor images: batch of images. + :return: predicted localizations and classes scores (tensors) for + each image + :rtype: torch.Tensor + ''' + images = images.to(device) #dtype = torch.Tensor + # Run VGG base network convolutions (lower level feature map generators) + conv4_3, conv7 = self.model[0](images) + output_basenet = [conv4_3.to(device), conv7.to(device)] + + # Run auxiliary convolutions (higher level feature map generators) + output_auxconv = self.model[1](conv7) + + # Run prediction convolutions (predict offsets w.r.t prior-boxes and + # classes in each resulting localization box) + locs, classes_scores = self.model[2](output_basenet, output_auxconv) + + return locs.to(device), classes_scores.to(device) + + + def train_epoch(self, epoch): + """ + One epoch's training. + :param train_loader: an iterable over the given dataset, obtained + combining a dataset(images, boxes and labels) and a sampler. + :param epoch: epoch number + """ + for i in range(len(self.model) - 1): + self.model[i].train() +# self.model[i].features.train() + self.model[-1].features_loc.train() + self.model[-1].features_cl.train() + #training mode enables dropout + + batch_time = AverageMeter() # forward prop. + back prop. time + data_time = AverageMeter() # data loading time + losses = AverageMeter() # loss + + start = time.time() + + # Batches + for i, (images, boxes, labels, _) in enumerate(self.train_loader): + data_time.update(time.time() - start) + + # Move to default device + images = images.to(device) # (batch_size (N), 3, 300, 300) + boxes = [b.to(device) for b in boxes] + labels = [l.to(device) for l in labels] + + # Forward prop. + predicted_locs, predicted_scores = self.forward(images) + # (N, 8732, 4), (N, 8732, n_classes) + + # Loss + loss = self.criterion(predicted_locs, predicted_scores, boxes, + labels) # scalar + + # Backward prop. + self.optimizer.zero_grad() + #model.cleargrads() + loss.backward() + + # Clip gradients, if necessary + if self.grad_clip is not None: + clip_gradient(self.optimizer, self.grad_clip) + + # Update model + self.optimizer.step() + + losses.update(loss.item(), images.size(0)) + batch_time.update(time.time() - start) + + start = time.time() + + # Print status + if i % self.print_freq == 0: + print('Epoch: [{0}][{1}/{2}]\t' + 'Batch Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t' + 'Data Time {data_time.val:.3f} ({data_time.avg:.3f})\t' + 'Loss val (average) {loss.val:.4f} ({loss.avg:.4f})\t'.format( + epoch, + i, + len(self.train_loader), + batch_time=batch_time, + data_time=data_time, + loss=losses)) + del predicted_locs, predicted_scores, images, boxes, labels + # free some memory since their histories may be stored + return losses.avg #loss.item() + + def train_detector(self, label_map=None): + ''' + Total training of the detector for all the epochs. + + :param dict label_map: dictionary for the label map, where the keys are + the labels of the objects(the classes) and their values the number + of the classes to which they belong (0 for the background). Thus the + length of this dict will be the number of the classes of the + dataset. + :return: checkpoint file containing the status of the net at the end of the + training (check_objdet) and a list with the value of the loss over time + (loss_values). + :rtype: str, list + ''' + # Epochs + loss_values = [] + mAP_values = [] + for epoch in range(self.start_epoch, self.epochs): + + # Decay learning rate at particular epochs + if epoch in self.decay_lr_at: + adjust_learning_rate(self.optimizer, self.decay_lr_to) + + # One epoch's training + loss_val = self.train_epoch(epoch=epoch) + loss_values.extend([loss_val]) + if label_map is not None: + mAP_val = self.eval_detector(label_map) + mAP_values.extend([mAP_val]) + + # Save checkpoint + check_objdet = 'checkpoint_objdet.pth' + torch.save(copy.deepcopy(self.model), check_objdet) + # If a more complete checkpoint is needed uncomment the following line. + check_objdet_full = 'checkpoint_objdet_full.pth.tar' + check_objdet_full = save_checkpoint_objdet(self.epochs, self.model, self.optimizer, check_objdet_full) + return check_objdet, loss_values + + + def eval_detector(self, label_map): + ''' + Evaluation/Testing Phase + + :param dict label_map: dictionary for the label map, where the keys are + the labels of the objects(the classes) and their values the number + of the classes to which they belong (0 for the background). Thus the + length of this dict will be the number of the classes of the + dataset. + ''' + # set the network(all classes derived from nn.module) in evaluation mode + for i in range(len(self.model) - 1): + self.model[i].eval() + #model[i].features.eval() + self.model[-1].features_loc.eval() + self.model[-1].features_cl.eval() + # Lists to store detected and true boxes, labels, scores + det_boxes = list() + det_labels = list() + det_scores = list() + true_boxes = list() + true_labels = list() + true_difficulties = list() + + # Good formatting when printing the APs for each class and mAP + pp = PrettyPrinter() + + #torch.no_grad() impacts the autograd engine and deactivate it. + #It will reduce memory usage and speed up computations but you + #would not be able to backprop (which you do not want in an eval + #script). + with torch.no_grad(): + # Batches + for i, (images, boxes, labels, difficulties) in enumerate( + tqdm(self.test_loader, desc='Evaluating')): + images = images.to(device) # (N, 3, 300, 300) + + # Forward prop. + predicted_locs, predicted_scores = self.forward(images) + + # Detect objects in SSD output + det_boxes_batch, det_labels_batch, det_scores_batch = detect_objects( + self.priors, + predicted_locs, + predicted_scores, + self.n_classes, + min_score=0.01, + max_overlap=0.45, + top_k=20) + # Evaluation MUST be at min_score=0.01, max_overlap=0.45, + # top_k=200 for fair comparision with the paper's results + # and other repos + + # Store this batch's results for mAP calculation + boxes = [b.to(device) for b in boxes] + labels = [l.to(device) for l in labels] + difficulties = [d.to(device) for d in difficulties] + + det_boxes.extend(det_boxes_batch) + det_labels.extend(det_labels_batch) + det_scores.extend(det_scores_batch) + true_boxes.extend(boxes) + true_labels.extend(labels) + true_difficulties.extend(difficulties) + + # Calculate mAP + APs, mAP = calculate_mAP(det_boxes, det_labels, det_scores, + true_boxes, true_labels, true_difficulties, + label_map) + print(APs) + # Print AP for each class + pp.pprint(APs) + + print('\nMean Average Precision (mAP): %.3f' % mAP) + return mAP + + + def detect(self, + original_image, + label_map, + min_score, + max_overlap, + top_k, + suppress=None): + """ + Detect objects in an image with a trained SSD300, and visualize + the results. + + :param PIL Imagw original_image: image, a PIL Image + :param dict label_map: dictionary for the label map, where the keys are + the labels of the objects(the classes) and their values the number + of the classes to which they belong (0 for the background). Thus the + length of this dict will be the number of the classes of the + dataset. + :param float min_score: minimum threshold for a detected box to + be considered a match for a certain class + :param float max_overlap: maximum overlap two boxes can have so + that the one with the lower score is not suppressed via + Non-Maximum Suppression (NMS) + :param int top_k: if there are a lot of resulting detection across + all classes, keep only the top 'k' + :param list suppress:a list of classes that you know for sure cannot be + in the image or you do not want in the image. If None, it does not + suppress anything. + :return: annotated image, a PIL Image + """ + + # set the network(all classes derived from nn.module) in evaluation mode + for i in range(len(self.model) - 1): + self.model[i].eval() +# model[i].features.eval() + self.model[-1].features_loc.eval() + self.model[-1].features_cl.eval() + + # Color map for bounding boxes of detected objects from + # https://sashat.me/2017/01/11/list-of-20-simple-distinct-colors/ + distinct_colors = [ + '#e6194b', '#3cb44b', '#ffe119', '#0082c8', '#f58231', '#911eb4', + '#46f0f0', '#f032e6', '#d2f53c', '#fabebe', '#008080', '#000080', + '#aa6e28', '#fffac8', '#800000', '#aaffc3', '#808000', '#ffd8b1', + '#e6beff', '#808080', '#FFFFFF' + ] + label_color_map = { + k: distinct_colors[i] + for i, k in enumerate(label_map.keys()) + } + + # Transforms + resize = transforms.Resize((300, 300)) + to_tensor = transforms.ToTensor() + normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], + std=[0.229, 0.224, 0.225]) + image = normalize(to_tensor(resize(original_image))) + + # Move to default device + image = image.to(device) + + # Forward prop. + predicted_locs, predicted_scores = self.forward(image.unsqueeze(0)) + + # Detect objects in SSD output + det_boxes, det_labels, det_scores = detect_objects( + self.priors, + predicted_locs, + predicted_scores, + self.n_classes, + min_score=min_score, + max_overlap=max_overlap, + top_k=top_k) + + # Move detections to the CPU + det_boxes = det_boxes[0].to(device) + + # Transform to original image dimensions + original_dims = torch.FloatTensor([ + original_image.width, original_image.height, original_image.width, + original_image.height + ]).unsqueeze(0).to(device) + det_boxes = det_boxes * original_dims + + rev_label_map = {v: k for k, v in label_map.items()} # Inverse mapping + # Decode class integer labels + det_labels = [ + rev_label_map[l] for l in det_labels[0].to(device).tolist() + ] + + # If no objects found, the detected labels will be set to ['0.'], i.e. + # ['background'] in detect_objects() in util.py + if det_labels == ['background']: + # Just return original image + return original_image + + # Annotate + annotated_image = original_image + # Create an object that can be used to draw in the given image. + draw = ImageDraw.Draw(annotated_image) + #font = ImageFont.truetype("./calibril.ttf", 15) + # this line does not work for me, try to fix in case, use dafault font + font = ImageFont.load_default() + + # Suppress specific classes, if needed + for i in range(det_boxes.size(0)): + if suppress is not None: + if det_labels[i] in suppress: + continue + + # Boxes + box_location = det_boxes[i].tolist() + draw.rectangle(xy=box_location, + outline=label_color_map[det_labels[i]]) + draw.rectangle(xy=[l + 1. for l in box_location], + outline=label_color_map[det_labels[i]]) + # a second rectangle at an offset of 1 pixel to increase line + # thickness + # draw.rectangle(xy=[l + 2. for l in box_location], + # outline=label_color_map[det_labels[i]]) + # a third rectangle at an offset of 1 pixel to increase line + # thickness + # draw.rectangle(xy=[l + 3. for l in box_location], + # outline=label_color_map[det_labels[i]]) + # a fourth rectangle at an offset of 1 pixel to increase line + # thickness + + # Text + text_size = font.getsize(det_labels[i].upper()) + text_location = [ + box_location[0] + 2., box_location[1] - text_size[1] + ] + textbox_location = [ + box_location[0], box_location[1] - text_size[1], + box_location[0] + text_size[0] + 4., box_location[1] + ] + draw.rectangle(xy=textbox_location, + fill=label_color_map[det_labels[i]]) + draw.text(xy=text_location, + text=det_labels[i].upper(), + fill='white', + font=font) + img_final = annotated_image.save('out.jpg') + del draw + + return annotated_image + + +class Reduced_Detector(Detector): + ''' + Class that handles the creation of the Reduced Object Detector and its training and + testing phases. This class extends the Detector class. + ''' + + def __init__(self, network, checkpoint, priors_cxcy, n_classes, epochs, + batch_size, print_freq, lr, decay_lr_at, decay_lr_to, momentum, + weight_decay, grad_clip, train_loader, test_loader, optim_str, red_method): + ''' + :param list network: list of the different parts that compose the network + For each element you need to construct it using the class related. + :param path_file checkpoint: If None, you will need to initialize the + model and optimizer from zero, otherwise you will load them from + the checkpoint file given in input. + :param tensor priors_cxcy: priors (default bounding boxes) in + center-size coordinates, a tensor of size (n_boxes, 4) + :param scalar n_classes: number of different type of objects in your + dataset + :param scalar epochs: number of epochs to run without early-stopping + :param scalar batch_size: batch size + :param int print_freq: print training status every __ batches + :param scalar lr: learning rate + :param list decay_lr_at: decay learning rate after these many iterations + :param float decay_lr_to: decay learnign rate to this fraction of the + existing learning rate + :param scalar momentum: momentum rate + :param scalar weight_decay: weight decay + :param bool grad_clip: clip if gradients are exploding, which may happen + at larger batch sizes (sometimes at 32) - you will recognize it by a + sorting error in the MultiBox loss calculation + :param iterable train_loader: iterable object, it loads the dataset for + training. It iterates over the given dataset, obtained combining a + dataset(images, boxes and labels) and a sampler. + :param iterable test_loader: iterable object, it loads the dataset for + testing. It iterates over the given dataset, obtained combining a + dataset(images, boxes and labels) and a sampler. + :param str optim_str: string idetifying the optimzer to use, as 'Adam' + or 'SGD'. + :param str red_method: reduction method to used, e.g. 'POD', 'HOSVD'. + ''' + super().__init__(network, checkpoint, priors_cxcy, n_classes, epochs, + batch_size, print_freq, lr, decay_lr_at, decay_lr_to, momentum, + weight_decay, grad_clip, train_loader, test_loader, optim_str) + self.red_method = red_method + + def forward(self, images): + ''' + Forward propagation of the entire network + :param tensor images: dataset of images used + :return: predicted localizations and classes scores (tensors) for + each image + ''' + images = images.to(device) #dtype = torch.Tensor + # Run VGG base network convolutions (lower level feature map generators) + out_vgg = self.model[0](images) + output_basenet = [out_vgg] + + # Run auxiliary convolutions (higher level feature map generators) + if self.red_method=='HOSVD': + output_auxconv = self.model[1](out_vgg) + elif self.red_method=='POD': + output_auxconv = self.model[1](out_vgg.view(out_vgg.size(0), -1)) + output_auxconv = torch.unsqueeze(torch.unsqueeze(output_auxconv, dim=-1), dim=-1) + else: + raise ValueError('Wrong choice of the reduction method used.') + + # Run prediction convolutions (predict offsets w.r.t prior-boxes and + # classes in each resulting localization box) + locs, classes_scores = self.model[2](output_basenet, [output_auxconv]) + + return locs.to(device), classes_scores.to(device) diff --git a/smithers/ml/models/fnn.py b/smithers/ml/models/fnn.py new file mode 100644 index 0000000..53ffba7 --- /dev/null +++ b/smithers/ml/models/fnn.py @@ -0,0 +1,135 @@ +''' +Class that handles the creation of a Feedforward Neural +Network (FNN). +''' + +from numpy import real +import torch +import torch.nn as nn +import torch.optim as optim +import os + +if torch.cuda.is_available(): + device = torch.device('cuda') +else: + device = torch.device('cpu') + +class FNN(nn.Module): + def __init__(self, n_input, n_output, inner_size=20, + n_layers=1, func=nn.Softplus, layers=None): + ''' + Construction of a Feedforward Neural Network (FNN) with + given a number of input and output neurons, one hidden + layer with a number n_hid of neurons. + + :param int n_input: number of input neurons + :param int n_output: number of output neurons that corresponds + to the number of classes that compose the dataset + :param int inner_size: number of hidden neurons + :param int n_layers: number of hidden layers + :param nn.Module func: activation function. Default + function: nn.Softplus + :param list layers: list where each component represents the + number of hidden layers for the corresponding layer + :param bool cifar: boolean to identify if we are using as dataset + the cifar one + ''' + super(FNN, self).__init__() + + self.n_input = n_input + self.n_output = n_output + + if layers is None: + layers = [inner_size] * n_layers + + tmp_layers = layers.copy() + tmp_layers.insert(0, self.n_input) + tmp_layers.append(self.n_output) + #tmp_layers[0] = self.n_input + + + self.layers = [] + for i in range(len(tmp_layers)-1): + self.layers.append(nn.Linear(tmp_layers[i], tmp_layers[i+1])) + + if isinstance(func, list): + self.functions = func + else: + self.functions = [func for _ in range(len(self.layers)-1)] + + if len(self.layers) != len(self.functions) + 1: + raise RuntimeError('uncosistent number of layers and functions') + + + unique_list = [] + for layer, func in zip(self.layers[:-1], self.functions): + unique_list.append(layer) + if func is not None: + unique_list.append(func()) + unique_list.append(self.layers[-1]) + + self.model = nn.Sequential(*unique_list) + + + def forward(self, x): + ''' + Forward Phase. + + :param tensor x: input of the network with dimensions + n_images x n_input + :return: output of the FNN n_images x n_output + :rtype: tensor + ''' + return self.model(x) + + + + + +def training_fnn(fnn_net, epochs, inputs_net, real_out): + ''' + Training phase for a Feed Forward Neural Network (FNN). + + :param nn.Module fnn_net: FNN model + :param int epochs: epochs for the training phase. + :param tensor inputs_net: matrix of inputs for the network + with dimensions n_input x n_images. + :param tensor real_out: tensor representing the real output + of the network. + ''' + criterion = nn.CrossEntropyLoss().to(device) + optimizer = optim.Adam(fnn_net.parameters(), lr=0.0001) + correct = 0 + total = 0 + + fnn_net = fnn_net.to(device) + inputs_net = inputs_net.to(device) + for i in range(len(real_out)): + real_out[i] = real_out[i].to(device) + + final_loss = [] + batch_size = 128 + print('FNN training initialized') + for epoch in range(epochs): # loop over the dataset multiple times + for i in range(inputs_net.size()[0] // batch_size): + # zero the parameter gradients + optimizer.zero_grad() + + # forward + backward + optimize + outputs = fnn_net((inputs_net[i * batch_size:(i + 1) * + batch_size, :]).to(device)) + loss = criterion( + outputs, + torch.LongTensor(real_out[i * batch_size:(i + 1) * + batch_size]).to(device)) + loss.backward(retain_graph=True) + optimizer.step() + + + _, predicted = torch.max(outputs.data, 1) + labels = torch.LongTensor(real_out[i * batch_size:(i + 1) * + batch_size]).to(device) + total += labels.size(0) + + correct += (predicted == labels).sum().item() + print('FNN training completed', flush = True) diff --git a/smithers/ml/models/netadapter.py b/smithers/ml/models/netadapter.py new file mode 100644 index 0000000..b381ac7 --- /dev/null +++ b/smithers/ml/models/netadapter.py @@ -0,0 +1,317 @@ +''' +Module focused on the reduction of the ANN and implementation of the +training and testing phases. +''' + +import torch +import torch.nn as nn +import numpy as np + +from smithers.ml.models.rednet import RedNet +from smithers.ml.models.fnn import FNN, training_fnn +from smithers.ml.utils_rednet import PossibleCutIdx, spatial_gradients, forward_dataset, projection, tensor_projection, randomized_svd +from smithers.ml.layers.ahosvd import AHOSVD +from smithers.ml.layers.pcemodel import PCEModel + +#from ATHENA.athena.active import ActiveSubspaces + +if torch.cuda.is_available(): + device = torch.device('cuda') +else: + device = torch.device('cpu') + +class NetAdapter(): + ''' + Class that handles the reduction of a pretrained ANN and implementation + of the training and testing phases. + ''' + def __init__(self, cutoff_idx, red_dim, red_method, inout_method): + ''' + :param int cutoff_idx: value that identifies the cut-off layer + :param int/list red_dim: dimension of the reduced space onto which we + project the high-dimensional vectors or list of the reduced + dimensions for each direction in the tensorial space under + consideration. + :param str red_method: string that identifies the reduced method to + use, e.g. 'AS', 'POD'. 'AHOSVD'. + :param str inout_method: string the represents the technique to use for + the identification of the input-output map, e.g. 'PCE', 'FNN'. + + :Example: + + >>> from smithers.ml.netadapter import NetAdapter + >>> netadapter = NetAdapter(6, 50, 'POD', 'FNN') + >>> original_network = import_net() # user defined method to load/build the original model + >>> train_data = construct_dataset(path_to_dataset) + >>> train_loader = load_dataset(train_data) + >>> train_labels = train_data.targets + >>> n_class = 10 + >>> red_model = netadapter.reduce_net(original_network, train_data, train_labels, train_loader, n_class) + ''' + + self.cutoff_idx = cutoff_idx + if isinstance(red_dim, list): + self.red_dim_list = red_dim + self.red_dim = np.prod(red_dim) + else: + self.red_dim = red_dim + self.red_method = red_method + self.inout_method = inout_method + + def _reduce_AS(self, pre_model, post_model, train_dataset): + ''' + Function that performs the reduction using Active Subspaces (AS) + :param nn.Sequential pre_model: sequential model representing + the pre-model. + :param nn.Sequential post_model: sequential model representing + the pre-model. + :param Dataset train_dataset: dataset containing the training + images. + :returns: tensor proj_mat representing the projection matrix + for AS (n_feat x red_dim) + :rtype: torch.Tensor + ''' + input_type = train_dataset.__getitem__(0)[0].dtype + grad = spatial_gradients(train_dataset, pre_model, post_model) + asub = ActiveSubspaces(dim=self.red_dim, method='exact').to(device) + asub.fit(gradients=grad) + proj_mat = torch.tensor(asub.evects, dtype=input_type) + + return proj_mat + + def _reduce_POD(self, matrix_features): + ''' + Function that performs the reduction using the Proper Orthogonal + Decomposition (POD). + :param torch.Tensor matrix_features: (n_images x n_feat) matrix + containing the output of the pre-model that needs to be reduced. + :returns: tensor proj_mat representing the projection matrix + for POD (n_feat x red_dim). + :rtype: torch.Tensor + ''' + u = torch.svd(torch.transpose(matrix_features, 0, 1))[0] + proj_mat = u[:, :self.red_dim] + + return proj_mat + + def _reduce_RandSVD(self, matrix_features): + ''' + Function that performs the reduction using the Randomized SVD (RandSVD). + :param torch.Tensor matrix_features: (n_images x n_feat) matrix + containing the output of the pre-model that needs to be reduced. + :returns: tensor proj_mat representing the projection matrix + obtained via RandSVD (n_feat x red_dim). + :rtype: torch.Tensor + ''' + matrix_features = matrix_features.to('cpu') + u, _, _ = randomized_svd(torch.transpose(matrix_features, 0, 1), self.red_dim) + return u + + def _reduce_HOSVD(self, model, data_loader, device): + ''' + Function that performs the reduction using the Higher + order SVD (HOSVD) and in particular its averaged version (AHOSVD). + + :param nn.Module/torch.Tensor model: model under consideration for + computing its outputs (that has to be reduced) or + (n_images x n_channel x H x W) tensor containing the output of + the pre-model (in its tensorial version) that needs to be reduced. + :param torch.device device: device used to allocate the variables for + the function. + :returns: list containing the projection matrices obtained via HOSVD + for each dimension of the tensor (excluded the one related to the + batch of images). + :rtype: list + ''' + batch_hosvd = 1 + batch_old = 0 + ahosvd = AHOSVD(torch.zeros(0), self.red_dim_list, batch_hosvd) + for idx_, batch in enumerate(data_loader): + images = batch[0].to(device) + + with torch.no_grad(): + if torch.is_tensor(model): + outputs = out[batch_old : batch_old + images.size()[0], : ] + batch_old = images.size()[0] + else: + outputs = model(images).to(device) + ahosvd_temp = AHOSVD(outputs, self.red_dim_list, batch_hosvd) + ahosvd_temp.compute_u_matrices() + ahosvd_temp.compute_proj_matrices() + + ahosvd.proj_matrices = ahosvd.incremental_average(ahosvd.proj_matrices, + ahosvd_temp.proj_matrices, + idx_) + del ahosvd_temp + del outputs + #torch.cuda.empty_cache() + return ahosvd.proj_matrices + + + def _reduce(self, pre_model, post_model, train_dataset, train_loader, device = device): + ''' + Function that performs the reduction of the high dimensional + output of the pre-model. + :param nn.Sequential pre_model: sequential model representing + the pre-model. + :param nn.Sequential post_model: sequential model representing + the pre-model. + :param Dataset train_dataset: dataset containing the training + images. + :param iterable train_loader: iterable object for loading the dataset. + It iterates over the given dataset, obtained combining a + dataset(images and labels) and a sampler. + :param torch.device device: object representing the device on + which a torch.Tensor is or will be allocated. + :returns: tensors matrix_red and proj_mat containing the reduced output + of the pre-model (n_images x red_dim) and the projection matrix + (n_feat x red_dim) respectively. + :rtype: torch.tensor + ''' + + if self.red_method == 'AS': + #code for AS + matrix_features = forward_dataset(pre_model, train_loader).to(device) + proj_mat = self._reduce_AS(pre_model, post_model, train_dataset) + matrix_red = projection(proj_mat, train_loader, matrix_features) + + elif self.red_method == 'POD': + #code for POD + matrix_features = forward_dataset(pre_model, train_loader).to(device) + proj_mat = self._reduce_POD(matrix_features) + matrix_red = projection(proj_mat, train_loader, matrix_features) + + elif self.red_method == 'RandSVD': + #code for RandSVD + matrix_features = forward_dataset(pre_model, train_loader).to(device) + proj_mat = self._reduce_RandSVD(matrix_features) + matrix_red = projection(proj_mat, train_loader, matrix_features) + + elif self.red_method == 'HOSVD': + #code for HOSVD + #tensor_features = forward_dataset(pre_model, train_loader, flattening = False).to(device) + proj_mat = self._reduce_HOSVD(pre_model, train_loader, device) + matrix_red = tensor_projection(proj_mat, train_loader, pre_model, device) + + else: + raise ValueError + + return matrix_red, proj_mat + + def _inout_mapping_FNN(self, matrix_red, train_labels, n_class): + ''' + Function responsible for the creation of the input-output map using + a Feedfoprward Neural Network (FNN). + + :param torch.tensor matrix_red: matrix containing the reduced output + of the pre-model. + :param torch.tensor train_labels: tensor representing the labels + associated to each image in the train dataset. + :param int n _class: number of classes that composes the dataset + :return: trained model of the FNN + :rtype: nn.Module + ''' + n_neurons = 20 + targets = list(train_labels) + fnn = FNN(self.red_dim, n_class, n_neurons).to(device) + epochs = 500 + training_fnn(fnn, epochs, matrix_red.to(device), targets) + + return fnn + + def _inout_mapping_PCE(self, matrix_red, out_postmodel, train_loader, + train_labels): + ''' + Function responsible for the creation of the input-output map using + the Polynomial Chaos Expansion method (PCE). + + :param torch.tensor matrix_red: matrix containing the reduced output + of the pre-model. + :param nn.Sequential post_model: sequential model representing + the pre-model. + :param iterable train_loader: iterable object, it load the dataset for + training. It iterates over the given dataset, obtained combining a + dataset (images and labels) and a sampler. + :param torch.tensor train_labels: tensor representing the labels + associated to each image in the train dataset. + :return: trained model of PCE layer and PCE coeff + :rtype: list + ''' + mean = torch.mean(matrix_red, 0).to(device) + var = torch.std(matrix_red, 0).to(device) + + PCE_model = PCEModel(mean, var) + coeff = PCE_model.Training(matrix_red, out_postmodel, + train_labels[:matrix_red.shape[0]])[0] + PCE_coeff = torch.FloatTensor(coeff).to(device) + + return [PCE_model, PCE_coeff] + + def _inout_mapping(self, matrix_red, n_class, model, train_labels, + train_loader): + ''' + Function responsible for the creation of the input-output map. + :param tensor matrix_red: matrix containing the reduced output + of the pre-model. + :param int n _class: number of classes that composes the dataset + :param tensor train_labels: tensor representing the labels associated + to each image in the train dataset + :param nn.Sequential model: sequential model representing + :param tensor train_labels: tensor representing the labels associated + to each image in the train dataset. + :param iterable train_loader: iterable object, it load the dataset for + training. It iterates over the given dataset, obtained combining a + dataset (images and labels) and a sampler. + :return: trained model of FNN or list with the trained model of PCE and + the corresponding PCE coefficients + :rtype: nn.Module/list + ''' + if self.inout_method == 'FNN': + #code for FNN + inout_map = self._inout_mapping_FNN(matrix_red, train_labels, n_class) + + elif self.inout_method == 'PCE': + #code for PCE + out_model = forward_dataset(model, train_loader) + inout_map = self._inout_mapping_PCE(matrix_red, out_model, train_loader, train_labels) + + elif self.inout_method == None: + # In the case of object detection, we do not need this input_output part, since the + # predictor is unchanged w.r.t. the original input network. + inout_map = nn.Identity() + + else: + raise ValueError + + return inout_map + + def reduce_net(self, input_network, train_dataset, train_labels, + train_loader, n_class, device = device): + ''' + Function that performs the reduction of the network + :param nn.Sequential input_network: sequential model representing + the input network. If the sequential model is not provided, but + instead you have a nn.Module obj, see the function get_seq_model + in utils.py. + :param Dataset train_dataset: dataset containing the training + images + :param torch.Tensor train_labels: tensor representing the labels + associated to each image in the train dataset + :param iterable train_loader: iterable object for loading the dataset. + It iterates over the given dataset, obtained combining a + dataset(images and labels) and a sampler. + :param int n _class: number of classes that composes the dataset + :param torch.device device: object representing the device on + which a torch.Tensor is or will be allocated. + :return: reduced net + :rtype: nn.Module + ''' + input_type = train_dataset.__getitem__(0)[0].dtype + possible_cut_idx = PossibleCutIdx(input_network) + cut_idxlayer = possible_cut_idx[self.cutoff_idx] + pre_model = input_network[:cut_idxlayer].to(device, dtype=input_type) + post_model = input_network[cut_idxlayer:].to(device, dtype=input_type) + snapshots_red, proj_mat = self._reduce(pre_model, post_model, train_dataset, train_loader, device) + inout_map = self._inout_mapping(snapshots_red, n_class, input_network, train_labels, train_loader) + reduced_net = RedNet(n_class, pre_model, proj_mat, inout_map) + return reduced_net.to(device) diff --git a/smithers/ml/models/rednet.py b/smithers/ml/models/rednet.py new file mode 100644 index 0000000..9b78549 --- /dev/null +++ b/smithers/ml/models/rednet.py @@ -0,0 +1,82 @@ +''' +Class that handles the construction of the reduced network composed +by the premodel, the reduction layer and the final input-output map. +''' +import copy +import torch +import torch.nn as nn +from smithers.ml.layers.tensor_product_layer import tensor_product_layer + +if torch.cuda.is_available(): + device = torch.device('cuda') +else: + device = torch.device('cpu') + +class RedNet(nn.Module): + ''' + Creation of the reduced Neural Network starting from the + different blocks that composes it: pre-model, projection + matrix proj_mat and input-output mapping inout_map. + + :param int n_classes: number of classes that composes the dataset. + :param nn.Sequential premodel: sequential model representing the pre-model. + Default value set to None. + :param torch.tensor proj_mat: projection matrix. Default value set to None. + :param nn.Module/list inout_map: input-output mapping. For example it can be + a trained model of FNN or a list with the trained model of PCE and the + corresponding PCE coefficients. Default value set to None. + :param path_file checkpoint: If None, you will use the previuos block to + initialize the reduced model, otherwise you will load them from the + checkpoint file given in input. + ''' + def __init__(self, n_classes, premodel=None, proj_mat=None, inout_map=None, + checkpoint=None): + super(RedNet, self).__init__() + if checkpoint is not None: + rednet = torch.load(checkpoint, torch.device(device)) + self.premodel = rednet['model'].premodel + self.proj_model = rednet['model'].proj_model + self.inout_map = rednet['model'].inout_map + else: + self.premodel = premodel + if isinstance(proj_mat, nn.Linear): + self.proj_model = proj_mat + elif isinstance(proj_mat, list): + self.proj_model = tensor_product_layer(proj_mat) + else: + self.proj_model = nn.Linear(proj_mat.size()[0], + proj_mat.size()[1], bias=False) + self.proj_model.weight.data = copy.deepcopy(proj_mat).t() + + if isinstance(inout_map, list): + self.inout_basis = inout_map[0] + self.inout_lay = nn.Linear(inout_map[0].nbasis, n_classes, + bias=False) + self.inout_lay.weight.data = copy.deepcopy(inout_map[1]).t() + self.inout_map = nn.Sequential(self.inout_basis, self.inout_lay) + else: + self.inout_map = inout_map + + def forward(self, x): + ''' + Forward Phase. The first clause concerns AHOSVD, the other one is a more general version. + + :param torch.tensor x: input for the reduced net with dimensions + n_images x n_input. + :return: output n_images x n_class + :rtype: torch.tensor + ''' + x = x.to(device) + x = self.premodel(x) + if isinstance(self.proj_model, tensor_product_layer): + x = self.proj_model(x) + if len(self.proj_model.list_of_matrices) == len(x.shape): + x = x.flatten() + elif len(x.shape) == len(self.proj_model.list_of_matrices) + 1: + x = x.reshape(x.shape[0], int(torch.prod(torch.tensor(x.shape[1:])))) + else: + x = x.view(x.size(0), -1) + x = self.proj_model(x) + x = self.inout_map(x) + + return x diff --git a/smithers/ml/models/vgg.py b/smithers/ml/models/vgg.py new file mode 100644 index 0000000..bad20b9 --- /dev/null +++ b/smithers/ml/models/vgg.py @@ -0,0 +1,269 @@ +''' +Module focused on the implementation of VGG. +''' +import torch +import torch.nn as nn +import torchvision + +from smithers.ml.utils_imagerec import decimate + +if torch.cuda.is_available(): + device = torch.device('cuda') +else: + device = torch.device('cpu') + + +class VGG(nn.Module): + ''' + VGG base convolutions to produce lower-level feature maps. + As a model to construct the VGG class we are considering the one + already implemented in Pytorch + (https://pytorch.org/docs/stable/_modules/torchvision/models/vgg.html#vgg16) + and the one than can be found in this Pytorch tutorial for Object Detection: + https://github.com/sgrvinod/a-PyTorch-Tutorial-to-Object-Detection. + + :param list cfg: If None, returns the configuration of VGG16. Otherwise + a list of numbers and string 'M', representing all the layers of + the net (its configuration), where the numbers represent the number + of filters for that convolutional layers(i.e. the features + extracted) and 'M' stands for the max pool layer + :param bool batch_norm: If True, perform batch normalization + :param string/sequential classifier: If is equal to the string + 'standard', build the classical VGG16 classifier layers for a VGG16 + to be trained on a dataset such as ImageNet (images 3 x 300 x 300). + If is equal to 'cifar', build the classifier for VGG16 trained on a + dataset like CIFAR is built. (N.B. here images are 3 x 32 x 32). + See for more details: + - Shuying Liu and Weihong Deng. + 'Very deep convolutional neural network based image classification + using small training sample size.' + In Pattern Recognition (ACPR),2015 3rd IAPR Asian Conference on, + pages 730–734. IEEE, 2015. + DOI: 10.1109/ACPR.2015.7486599 + - https://github.com/geifmany/cifar-vgg + - https://github.com/chengyangfu/pytorch-vgg-cifar10 + If is equal to 'ssd', build the classifier layers for the SSD300 + architecture. + Otherwise if is a sequential container, the classifier correspond + exactly to this. + :param int num_classes: number of classes in your dataset. + :param str init_weights: If 'random', the weights are inizialized + following standard random distributins. If 'imagenet', pre-trained + weights on ImageNet are loaded. + ''' + def __init__(self, + cfg=None, + classifier='standard', + batch_norm=False, + num_classes=1000, + init_weights='random'): + super(VGG, self).__init__() + + self.num_classes = num_classes + available_classifier = { + 'standard': + nn.Sequential( + nn.Linear(512 * 7 * 7, 4096), + nn.ReLU(True), + nn.Dropout(), + nn.Linear(4096, 4096), + nn.ReLU(True), + nn.Dropout(), + nn.Linear(4096, self.num_classes), + ), + 'cifar': + nn.Sequential(nn.Linear(512, self.num_classes), ), + 'ssd': + nn.Sequential( + nn.Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6), + nn.Conv2d(1024, 1024, kernel_size=1)) + } + + if cfg is None: + configuration = [ + 64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, + 'M', 512, 512, 512, 'M' + ] + if classifier == 'ssd': + configuration[-1] = 'M3' + self.configuration = configuration + else: + self.configuration = cfg + self.features = self.make_layers(batch_norm) + self.avgpool = nn.AdaptiveAvgPool2d((7, 7)) + self.classifier_str = classifier + if isinstance(classifier, str): + self.classifier = available_classifier.get(classifier) + else: + self.classifier = classifier + if init_weights == 'random': + self._initialize_weights() + elif init_weights == 'imagenet': + self.load_pretrained_layers(cfg) + else: + raise RuntimeError( + 'Invalid choice for the initialization of the weigths.') + + def make_layers(self, batch_norm=False): + ''' + Construct the structure of the net (only the features part) + starting from the configuration given in input. + + :param bool batch_norm: If True, perform batch normalization + :return: sequential object containing the structure of the + features part of the net + :rtype: nn.Sequential + ''' + layers = [] + in_channels = 3 + for k in range(len(self.configuration)): + if self.configuration[k] == 'M': + layers += [ + nn.MaxPool2d(kernel_size=2, stride=2, ceil_mode=True) + ] + elif self.configuration[k] == 'M3': + layers += [nn.MaxPool2d(kernel_size=3, stride=1, padding=1)] + else: + conv2d = nn.Conv2d(in_channels, + self.configuration[k], + kernel_size=3, + padding=1) + if batch_norm: + layers += [ + conv2d, + nn.BatchNorm2d(self.configuration[k]), + nn.ReLU(inplace=True) + ] + else: + layers += [conv2d, nn.ReLU(inplace=True)] + in_channels = self.configuration[k] + return nn.Sequential(*layers) + + def forward(self, image): + ''' + Forward propagation. + + :param torch.Tensor image: images, a tensor of dimensions + (N, 3, width, height), where N is the number of images given in + input. + :param str classifier: a string corresponding to the classifier you + are using + :return: lower-level feature maps conv4_3 and conv7 (final output + of the net, i.e. a vector with the predictions for every class) + :rtype: torch.Tensor + ''' + x = self.features[:20](image) + conv4_3 = x.clone().detach() + x = self.features[20:](x) + if self.classifier_str == 'standard': + x = self.avgpool(x) + x = torch.flatten(x, 1) + # or equivalently + # x = x.view(x.size(0), -1) + elif self.classifier_str == 'cifar': + x = torch.flatten(x, 1) + x = self.classifier(x) + if self.classifier_str == 'ssd': + return conv4_3, x + else: + return x + + def _initialize_weights(self): + ''' + Random inizialization of the weights and bias coefficients of + the network + ''' + for m in self.modules(): + if isinstance(m, nn.Conv2d): + nn.init.kaiming_normal_(m.weight, + mode='fan_out', + nonlinearity='relu') + if m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.BatchNorm2d): + nn.init.constant_(m.weight, 1) + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.Linear): + nn.init.normal_(m.weight, 0, 0.01) + nn.init.constant_(m.bias, 0) + + def load_pretrained_layers(self, cfg): + ''' + Loading pre-trained Layers. + If cfg is None and we are considering the standard version of VGG16, + the state of VGG16 pretrained on Imagenet will be loaded. See + https://pytorch.org/docs/stable/torchvision/models.html#torchvision.models.vgg16 + We can also load the state of VGG16 pretrained on other datasets by + giving in input a file containing the pretrained weights + (pretrain_weights). + If we are creating a custom version of this net with n_classes!=1000 the + classifier will be changed. + If cfg is None and we are condidering SSD300, we are converting fc6 + and fc7 into convolutional layers, and subsample by decimation. See + the original paper where SSD300 is implemented for further + details: 'SSD: Single Shot Multibox Detector' by + Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, + Scott Reed, Cheng-Yang Fu, Alexander C. Berg + https://arxiv.org/abs/1512.02325 + DOI: 10.1007/978-3-319-46448-0_2 + + :param list cfg: If None, returns the configuration of VGG16. Otherwise + a list of numbers and string 'M', representing all the layers of + the net (its configuration), where the numbers represent the number + of filters for that convolutional layers(i.e. the features + extraxted) and 'M' stands for the max pool layer + :return: state_dict, a dictionary containing the state of the net + :rtype: dict + ''' + # Current state of base + state_dict = self.state_dict() + param_names = list(state_dict.keys()) + + pretrained_net = torchvision.models.vgg16(pretrained=True) + pretrained_state_dict = pretrained_net.state_dict() + pretrained_param_names = list(pretrained_state_dict.keys()) + + + if cfg is None and (self.classifier_str == 'standard' + or self.classifier_str == 'cifar'): + if self.num_classes != 1000: + pretrained_net.classifier = self.classifier + pretrained_state_dict = pretrained_net.state_dict() + state_dict = pretrained_state_dict + + elif cfg is None and self.classifier_str == 'ssd': + # Transfer conv. parameters from pretrained model to current model + for i, param in enumerate( + param_names[:-4]): # excluding conv6 and conv7 parameters + state_dict[param] = pretrained_state_dict[ + pretrained_param_names[i]] + + # Convert fc6, fc7 to convolutional layers, and subsample + # (by decimation) to sizes of conv6 and conv7 + # fc6 + conv_fc6_weight = pretrained_state_dict['classifier.0.weight'].view( + 4096, 512, 7, 7) + conv_fc6_bias = pretrained_state_dict['classifier.0.bias'] # (4096) + state_dict['classifier.0.weight'] = decimate( + conv_fc6_weight, m=[4, None, 3, 3]) # (1024, 512, 3, 3) + state_dict['classifier.0.bias'] = decimate(conv_fc6_bias, + m=[4]) # (1024) + # fc7 + conv_fc7_weight = pretrained_state_dict['classifier.3.weight'].view( + 4096, 4096, 1, 1) + conv_fc7_bias = pretrained_state_dict['classifier.3.bias'] # (4096) + state_dict['classifier.1.weight'] = decimate( + conv_fc7_weight, m=[4, 4, None, None]) # (1024, 1024, 1, 1) + state_dict['classifier.1.bias'] = decimate(conv_fc7_bias, + m=[4]) # (1024) + + else: + raise RuntimeError( + 'Invalid choice for configuration and classifier in order\ + to use the pretrained model') + + self.load_state_dict(state_dict) + + print("\nLoaded base model.\n") + + return state_dict diff --git a/smithers/ml/tutorials/customdata_imagerec.ipynb b/smithers/ml/tutorials/customdata_imagerec.ipynb new file mode 100644 index 0000000..9a58977 --- /dev/null +++ b/smithers/ml/tutorials/customdata_imagerec.ipynb @@ -0,0 +1,288 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "mFsuXpUwQn80" + }, + "source": [ + "# Custom Dataset for image classification\n", + "In this tutorial, we will describe how to create and use a custom dataset for the aim of image classification, following https://www.kaggle.com/basu369victor/pytorch-tutorial-the-classification." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "S3D2nXrfRFEj" + }, + "source": [ + "## Custom dataset\n", + "First of all, you need to collect all the images you need to create the dataset (preferably ~1000 images per category) and define the different categories in exam.\n", + "At the end the directory ***dataset*** containing all your images should have a structure like this:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](images/structure_img.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "where each image has been placed inside the subdirectory class_i corresponding to the class it belongs to." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "ftu0AINGQ67c" + }, + "outputs": [], + "source": [ + "import os\n", + "import numpy as np # linear algebra\n", + "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n", + "from sklearn.preprocessing import LabelEncoder\n", + "import torch\n", + "from torch.utils.data.sampler import SubsetRandomSampler\n", + "import torchvision.transforms as transforms\n", + "\n", + "#define the device\n", + "device = torch.device('cpu')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 130 + }, + "id": "WVm1fmhQZarc", + "outputId": "201d08fd-65db-4627-9ca1-310727696bfd" + }, + "outputs": [], + "source": [ + "image = []\n", + "labels = []\n", + "#path to the directory containing your dataset\n", + "data_path = '../dataset_imagerec/'\n", + "for file in os.listdir(data_path):\n", + " if os.path.isdir(os.path.join(data_path, file)):\n", + " for img in os.listdir(os.path.join(data_path, file)):\n", + " image.append(img)\n", + " labels.append(file)\n", + "\n", + "# Creation of a csv Data-frasmithers.me from the raw dataset. You might not have to follow\n", + "# this step if you are already provided with csv file which contains the desired \n", + "# input and target value.\n", + "data = {'Images':image, 'labels':labels} \n", + "data = pd.DataFrame(data) \n", + "data.head()\n", + "\n", + "lb = LabelEncoder()\n", + "data['encoded_labels'] = lb.fit_transform(data['labels'])\n", + "data.head()\n", + "\n", + "# save the csv file inside the dataset directory \n", + "data.to_csv('../dataset_imagerec/dataframe.csv', index=False)\n", + "#in order to import the file run this command\n", + "#data = pd.read_csv('dataset_imagerec/dataframe.csv')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sY2TmApGdycf" + }, + "source": [ + "## Splitting of the dataset\n", + "The dataset needs to be split between the train and test process. Usually you will use 80% of all the images for the training phase and the remainig 20% for the testing phase.\n", + "\n", + "There are two ways to do this: one is to do it from scratch, the other one is by using ***train_test_split*** function ***from scikit-learn*** (recommended)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "q9IhpuJvdFuR" + }, + "outputs": [], + "source": [ + "batch_size = 128\n", + "validation_split = .2\n", + "shuffle_dataset = True\n", + "random_seed= 42\n", + "\n", + "dataset_size = len(data)\n", + "indices = list(range(dataset_size))\n", + "split = int(np.floor(validation_split * dataset_size))\n", + "if shuffle_dataset :\n", + " np.random.seed(random_seed)\n", + " np.random.shuffle(indices)\n", + "train_indices, val_indices = indices[split:], indices[:split]\n", + "\n", + "# Creating PT data samplers and loaders:\n", + "train_sampler = SubsetRandomSampler(train_indices)\n", + "test_sampler = SubsetRandomSampler(val_indices)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Images Preparation\n", + "After collecting the images, it is necessary to apply them some transformations in order to be used during the training and testing phases.\n", + "\n", + "- ***Transforms*** are common image transformations, that can be chained together using ***Compose***.\n", + "- You need to convert a PIL Image or numpy.ndarray to tensor using ***transforms.ToTensor()***. It converts a PIL Image or numpy.ndarray (H x W x C) in the range [0, 255] to a torch.FloatTensor of shape (C x H x W) in the range [0.0, 1.0] if the PIL Image belongs to one of the modes (L, LA, P, I, F, RGB, YCbCr, RGBA, CMYK, 1) or if the numpy.ndarray has dtype = np.uint8\n", + "- The tensor images should be ***normalized*** with mean and standard deviation. Given mean: (M1,...,Mn) and std: (S1,..,Sn) for n channels, the transformation ***transforms.Normalize*** will normalize each channel of the input torch.*Tensor i.e. input[channel] = (input[channel] - mean[channel]) / std[channel].\n", + "\n", + "Here you can find an example of transormation that can be applied to the images of your dataset. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "transform = transforms.Compose(\n", + " [transforms.ToTensor(),\n", + " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create custom dataset class\n", + "You now need to create a dataset class to be used as first argument in the function ***torch.utils.data.DataLoader()***.\n", + "\n", + "The skeleton of your custom dataset class has to be as the one in the cell below. It must contain the following functions to be used by data loader later on.\n", + "- ***__init__()*** function is where the initial logic happens like reading a csv, assigning transforms, filtering data, etc.\n", + "- ***__getitem__()*** function returns the data and labels. This function is called from dataloader like this:\n", + "\n", + " img, label = MyCustomDataset.***__getitem__***(99) # For 99th item" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from torch.utils.data.dataset import Dataset\n", + "\n", + "class MyCustomDataset(Dataset):\n", + " def __init__(self, args):\n", + " # stuff\n", + " self.args = args\n", + " \n", + " def __getitem__(self, index):\n", + " # stuff\n", + " return (img, label)\n", + "\n", + " def __len__(self):\n", + " return count # of how many examples(images) you have" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An example of how you can create this custom dataset class is the following (see also ***dataset/imagerec_dataset.py***): " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from torch.utils.data.dataset import Dataset\n", + "class Imagerec_Dataset(Dataset):\n", + " def __init__(self, img_data, img_path, transform=None):\n", + " self.img_path = img_path\n", + " self.img_data = img_data\n", + " self.transform = transform\n", + " \n", + " def __len__(self):\n", + " return len(self.img_data)\n", + " \n", + " def __getitem__(self, index):\n", + " img_name = os.path.join(self.img_path,self.img_data.loc[index, 'labels'],\n", + " self.img_data.loc[index, 'Images'])\n", + " image = Image.open(img_name)\n", + " #image = image.convert('RGB')\n", + " image = image.resize((300,300))\n", + " label = torch.tensor(self.img_data.loc[index, 'encoded_labels'])\n", + " if self.transform is not None:\n", + " image = self.transform(image)\n", + " else:\n", + " image = transforms.ToTensor()(image)\n", + " return image, label" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After defining the class for your custom dataset, you can create it and use it inside the function ***torch.utils.data.DataLoader()*** as described in the following part." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "dataset = Imagerec_Dataset(data, data_path, transform)\n", + "train_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, \n", + " sampler=train_sampler)\n", + "test_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size,\n", + " sampler=test_sampler)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "colab": { + "name": "customdata_imagerec.ipynb", + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/smithers/ml/tutorials/customdata_objdet.ipynb b/smithers/ml/tutorials/customdata_objdet.ipynb new file mode 100644 index 0000000..2c3e6cc --- /dev/null +++ b/smithers/ml/tutorials/customdata_objdet.ipynb @@ -0,0 +1,476 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# How to prepare your own dataset for training an Object Detector\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Gathering data\n", + "First of all you need data. To train a robust classifier, we need a lot of pictures which should differ a lot from each other. So they should have different backgrounds, random object, and varying lighting conditions. You can either take the pictures yourself or you can download them from the internet. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Structure of the Dataset folder - Pascal VOC notation\n", + "In order to train an object detector using our own dataset, we need to construct an internal structure for the folder that contains our images ('./data'). In order to generate this we follow the Pascal VOC notation. Pascal VOC annotations are saved as XML files, one XML file per image. Each XML file contains the path to the image in the 'path' element, the bounding box stored in an 'object' element and other features as can be seen in the example below.\n", + "\n", + "\n", + "\n", + "As you can see the bounding box is defined by two points, the upper left and bottom right corners.\n", + "\n", + "We need to construct inside the main folder 'data' another subfolder 'VOC2007', that contains three subfolders:\n", + "1. Annotations: Inside this folder we will put the Pascal VOC formatted annotation XML files, that we are going to generate below using LabelImg.\n", + "2. ImageSets: Inside this folder there is another subfolder 'Main', that contains two files 'test.txt' and 'trainval.txt'. In these two files all the images that belong to that category are listed.\n", + "3. JPEGImages: Here there are all the images, that has to be in the JPG format.\n", + "\n", + "At the end your dataset should have a structure like this:\n", + "\n", + "![](images/structure.PNG)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Labeling Data\n", + "In order to label our data, the image labeling software LabelImg was used. It is available on Github https://github.com/tzutalin/labelImg and thanks to this tool we can create easily the xml files with a similar structure to the PASCAL VOC dataset for all images in the training and testing directory.\n", + "### Instruction to install labelImg\n", + "1. git clone https://github.com/tzutalin/labelImg\n", + "2. conda install pyqt=5\n", + "3. pyrcc5 -o libs/resources.py resources.qrc\n", + "4. python labelImg.py\n", + "### Steps\n", + "1. Build and launch LabelImg using the instructions above\n", + "2. In the left column choose the saved annotation (Pascal VOC / Yolo). Make sure Pascal VOC is selected.\n", + "3. Click 'Open Dir' to open the directory that contains all your images (the folder should be found following this path \"./data/VOCdevkit/VOC2007/ImageSets\")\n", + "4. Change save directory for the XML annotation files to \"./data/VOCdevkit/VOC2007/Annotations\".\n", + "5. Click 'Create RectBox' \n", + "6. Click and release left mouse to select a region to annotate the rect box\n", + "7. You can use right mouse to drag the rect box to copy or move it\n", + "\n", + "\n", + "A txt file with the different classes used in the labeling is also created and placed in the folders you are working on. \n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Transform image resolution\n", + "Usually the images you collect will have different sizes and high resolution, since you can take them using different \n", + "photographic equipment: a mobilephone, a webcam, a reflex camera, etc. Thus, it is needed to transform all the images to a lower scale (the same for all the pictures) in order to speed up the training (e.g. 200 x 150 can be an option, but it is important to check, while changing the resolution, that you are able to distinguish and recognize the objects in the picture, otherwise it will be difficult also for the CNN to learn the main features of your objects). " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from PIL import Image\n", + "import os\n", + "\n", + "def rescale_images(directory, size):\n", + " for img in os.listdir(directory):\n", + " im = Image.open(directory + '/' + img)\n", + " im_resized = im.resize(size, Image.ANTIALIAS)\n", + " im_resized.save(directory + '/' + img)\n", + " \n", + "path_images = '../data_lab/VOC2007/JPEGImages'\n", + "WIDTH_NEW = 800\n", + "HEIGHT_NEW = 600\n", + "rescale_images(path_images, (WIDTH_NEW, HEIGHT_NEW)) " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Split of the dataset\n", + "Once we have our images, we need to split them between those we use for the train, 80% of them, and those for the test, the remaining 20%. First of all we need to create a txt file, 'datafile.txt', that contains the name of all the images in our dataset. Then, using the function sklearn.model_selection.train_test_split we can make this split of the dataset and create the two txt files to place inside the folder 'ImageSets/Main', one with the train images and one with the test images." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy\n", + "from sklearn import datasets, linear_model\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "train_file = '../data_lab/VOC2007/ImageSets/Main/trainval.txt'\n", + "test_file = '../data_lab/VOC2007/ImageSets/Main/test.txt'\n", + "with open(\"../data_lab/datafile.txt\", \"r\") as f:\n", + " # in Windows you may need to put rb instead of r mode \n", + " data = f.read().split('\\n')\n", + " data = numpy.array(data) #convert array to numpy type array\n", + "\n", + " train, test = train_test_split(data,test_size=0.2) \n", + " split = [train, test] \n", + " # the ouputs here are two lists containing train-test split of inputs.\n", + " lengths = [len(train), len(test)]\n", + " out_train = open(train_file,\"w\")\n", + " out_test = open(test_file, \"w\")\n", + " out_file = [out_train, out_test]\n", + " out = 0\n", + " for l in lengths:\n", + " for i in range(l):\n", + " name_img = split[out][i]\n", + " out_file[out].write(name_img + '\\n')\n", + " out_file[out].close() \n", + " out += 1\n", + " \n", + " \n", + "# Split into a training set and a test set using a stratified k fold\n", + "# split into a training and testing set\n", + "# y here the label associated\n", + "#X_train, X_test, y_train, y_test = train_test_split(\n", + "# X, y, test_size=0.25, random_state=42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Change xml file\n", + "Once we have labeled and created all the xml files for our images, we could want to change the resolution of our images as explained above. In order to change the xml file every time we transform image resolution, it is necessary to define a function that modify only the lines corresponding at the features of the images we are changing (i.e. the width and height, the box position and also the path where they are located)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "from sys import argv\n", + "from os import listdir, path\n", + "import re\n", + "\n", + "\n", + "WIDTH_NEW = 800\n", + "HEIGHT_NEW = 600\n", + "\n", + "DIMLINE_MASK = r'<(?Pwidth|height)>(?P\\d+)width|height)>'\n", + "BBLINE_MASK = r'<(?Pxmin|xmax|ymin|ymax)>(?P\\d+)xmin|xmax|ymin|ymax)>'\n", + "NAMELINE_MASK = r'<(?Pfilename)>(?P\\S+)filename)>'\n", + "PATHLINE_MASK = r'<(?Ppath)>(?P.+)path)>'\n", + "#regular expression\n", + "\n", + "def resize_file(file_lines):\n", + " new_lines = []\n", + " for line in file_lines:\n", + " match = re.search(DIMLINE_MASK, line) or re.search(BBLINE_MASK, line) or re.search(NAMELINE_MASK, line) or re.search(PATHLINE_MASK, line) \n", + " if match is not None:\n", + " size = match.group('size')\n", + " type1 = match.group('type1')\n", + " type2 = match.group('type2') \n", + " if type1 != type2:\n", + " raise ValueError('Malformed line: {}'.format(line))\n", + " \n", + " if type1.startswith('f'):\n", + " new_name = size[:-3] + 'jpg'\n", + " new_line = '\\t<{}>{}\\n'.format(type1, new_name, type1)\n", + " elif type1.startswith('p'):\n", + " new_size = '/scratch/lmeneghe/electrolux/Object_Detector/data_lab/VOC2007/Annotations/' + new_name\n", + " new_line = '\\t<{}>{}\\n'.format(type1, new_size, type1)\n", + " elif type1.startswith('x'):\n", + " size = int(size)\n", + " new_size = int(round(size * WIDTH_NEW / width_old))\n", + " new_line = '\\t\\t\\t<{}>{}\\n'.format(type1, new_size, type1)\n", + " elif type1.startswith('y'):\n", + " size = int(size)\n", + " new_size = int(round(size * HEIGHT_NEW / height_old))\n", + " new_line = '\\t\\t\\t<{}>{}\\n'.format(type1, new_size, type1)\n", + " elif type1.startswith('w'):\n", + " size = int(size)\n", + " width_old = size\n", + " new_size = int(WIDTH_NEW)\n", + " new_line = '\\t\\t<{}>{}\\n'.format(type1, new_size, type1)\n", + " elif type1.startswith('h'):\n", + " size = int(size)\n", + " height_old = size\n", + " new_size = int(HEIGHT_NEW)\n", + " new_line = '\\t\\t<{}>{}\\n'.format(type1, new_size, type1)\n", + " else:\n", + " raise ValueError('Unknown type: {}'.format(type1))\n", + " #new_line = '\\t\\t\\t<{}>{}\\n'.format(type1, new_size, type1)\n", + " new_lines.append(new_line)\n", + " else:\n", + " new_lines.append(line)\n", + "\n", + " return ''.join(new_lines)\n", + "\n", + "\n", + " \n", + " \n", + "def change_xml(nome_file):\n", + " if len(nome_file) < 1:\n", + " raise ValueError('No file submitted')\n", + "\n", + " if path.isdir(nome_file):\n", + " # the argument is a directory\n", + " files = listdir(nome_file)\n", + " for file in files:\n", + " file_path = path.join(nome_file, file)\n", + " file_name, file_ext = path.splitext(file)\n", + " #print(file_path, end='') # Questo non e` tanto astuto\n", + " if file_ext.lower() == '.xml':\n", + " #print(': CONVERTIMIIII!!!', end='')\n", + " with open(file_path,'r') as f:\n", + " righe = f.readlines()\n", + "\n", + " nuovo_file = resize_file(righe)\n", + " #print(nuovo_file)\n", + " with open(file_path,'w') as f:\n", + " f.write(nuovo_file)\n", + " #print()\n", + " \n", + " else:\n", + " # otherwise i have a file (hopefully)\n", + " with open(nome_file,'r') as f:\n", + " righe = f.readlines()\n", + "\n", + " nuovo_file = resize_file(righe)\n", + " #print(nuovo_file)\n", + " with open(nome_file,'w') as f:\n", + " f.write(nuovo_file) \n", + "\n", + "#insert name of the xml file or directory that contains them\n", + "xml_file = '../data_lab/VOC2007/Annotations' \n", + "change_xml(xml_file)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Optional: How to convert your dataset in the COCO notation\n", + "You are out of luck if your object detection training pipeline require COCO data format since the labeling tool we use does not support COCO annotation format. If you already have the dataset generated using Pascal VOC notation, you can then convert your annotation to COCO format.\n", + "### COCO notation\n", + "For the COCO data format, first of all, there is only a single JSON file for all the annotation in a dataset or one for each split of datasets(Train/Val/Test). The bounding box is express as the upper left starting coordinate and the box width and height, like \"bbox\" :[x,y,width,height]. Here is an example for the COCO data format JSON file which just contains one image as seen the top-level “images” element, 3 unique categories/classes in total seen in top-level “categories” element and 2 annotated bounding boxes for the image seen in top-level “annotations” element. If you want to understand better the COCO format, check the official webpage of the COCO dataset: http://cocodataset.org/#format-data.\n", + "\n", + "\n", + "\n", + "Once you have some annotated XML and images files with a folder structure similar to the one explained above, you can generate a COCO data formatted JSON file using the function voc2coco (see also https://github.com/Tony607/voc2coco).\n", + "\n", + "ATTENTION: In order to use this function the name of all the images must be numbers. So you need to rename all the images if this is not true." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of xml files: 14\n", + "Success: ./images/output.json\n" + ] + } + ], + "source": [ + "import sys\n", + "import os\n", + "import json\n", + "import xml.etree.ElementTree as ET\n", + "import glob\n", + "\n", + "START_BOUNDING_BOX_ID = 1\n", + "PRE_DEFINE_CATEGORIES = None\n", + "# If necessary, pre-define category and its id\n", + "# PRE_DEFINE_CATEGORIES = {\"aeroplane\": 1, \"bicycle\": 2, \"bird\": 3, \"boat\": 4,\n", + "# \"bottle\":5, \"bus\": 6, \"car\": 7, \"cat\": 8, \"chair\": 9,\n", + "# \"cow\": 10, \"diningtable\": 11, \"dog\": 12, \"horse\": 13,\n", + "# \"motorbike\": 14, \"person\": 15, \"pottedplant\": 16,\n", + "# \"sheep\": 17, \"sofa\": 18, \"train\": 19, \"tvmonitor\": 20}\n", + "\n", + "\n", + "def get(root, name):\n", + " vars = root.findall(name)\n", + " return vars\n", + "\n", + "\n", + "def get_and_check(root, name, length):\n", + " vars = root.findall(name)\n", + " if len(vars) == 0:\n", + " raise ValueError(\"Can not find %s in %s.\" % (name, root.tag))\n", + " if length > 0 and len(vars) != length:\n", + " raise ValueError(\n", + " \"The size of %s is supposed to be %d, but is %d.\"\n", + " % (name, length, len(vars))\n", + " )\n", + " if length == 1:\n", + " vars = vars[0]\n", + " return vars\n", + "\n", + "\n", + "def get_filename_as_int(filename):\n", + " try:\n", + " filename = filename.replace(\"\\\\\", \"/\")\n", + " filename = os.path.splitext(os.path.basename(filename))[0]\n", + " return int(filename)\n", + " except:\n", + " raise ValueError(\"Filename %s is supposed to be an integer.\" % (filename))\n", + "\n", + "\n", + "def get_categories(xml_files):\n", + " \"\"\"Generate category name to id mapping from a list of xml files.\n", + " \n", + " Arguments:\n", + " xml_files {list} -- A list of xml file paths.\n", + " \n", + " Returns:\n", + " dict -- category name to id mapping.\n", + " \"\"\"\n", + " classes_names = []\n", + " for xml_file in xml_files:\n", + " tree = ET.parse(xml_file)\n", + " root = tree.getroot()\n", + " for member in root.findall(\"object\"):\n", + " classes_names.append(member[0].text)\n", + " classes_names = list(set(classes_names))\n", + " classes_names.sort()\n", + " return {name: i for i, name in enumerate(classes_names)}\n", + "\n", + "\n", + "def convert(xml_files, json_file):\n", + " json_dict = {\"images\": [], \"type\": \"instances\", \"annotations\": [], \"categories\": []}\n", + " if PRE_DEFINE_CATEGORIES is not None:\n", + " categories = PRE_DEFINE_CATEGORIES\n", + " else:\n", + " categories = get_categories(xml_files)\n", + " bnd_id = START_BOUNDING_BOX_ID\n", + " for xml_file in xml_files:\n", + " tree = ET.parse(xml_file)\n", + " root = tree.getroot()\n", + " path = get(root, \"path\")\n", + " if len(path) == 1:\n", + " filename = os.path.basename(path[0].text)\n", + " elif len(path) == 0:\n", + " filename = get_and_check(root, \"filename\", 1).text\n", + " else:\n", + " raise ValueError(\"%d paths found in %s\" % (len(path), xml_file))\n", + " ## The filename must be a number\n", + " image_id = get_filename_as_int(filename)\n", + " size = get_and_check(root, \"size\", 1)\n", + " width = int(get_and_check(size, \"width\", 1).text)\n", + " height = int(get_and_check(size, \"height\", 1).text)\n", + " image = {\n", + " \"file_name\": filename,\n", + " \"height\": height,\n", + " \"width\": width,\n", + " \"id\": image_id,\n", + " }\n", + " json_dict[\"images\"].append(image)\n", + " ## Currently we do not support segmentation.\n", + " # segmented = get_and_check(root, 'segmented', 1).text\n", + " # assert segmented == '0'\n", + " for obj in get(root, \"object\"):\n", + " category = get_and_check(obj, \"name\", 1).text\n", + " if category not in categories:\n", + " new_id = len(categories)\n", + " categories[category] = new_id\n", + " category_id = categories[category]\n", + " bndbox = get_and_check(obj, \"bndbox\", 1)\n", + " xmin = int(get_and_check(bndbox, \"xmin\", 1).text) - 1\n", + " ymin = int(get_and_check(bndbox, \"ymin\", 1).text) - 1\n", + " xmax = int(get_and_check(bndbox, \"xmax\", 1).text)\n", + " ymax = int(get_and_check(bndbox, \"ymax\", 1).text)\n", + " assert xmax > xmin\n", + " assert ymax > ymin\n", + " o_width = abs(xmax - xmin)\n", + " o_height = abs(ymax - ymin)\n", + " ann = {\n", + " \"area\": o_width * o_height,\n", + " \"iscrowd\": 0,\n", + " \"image_id\": image_id,\n", + " \"bbox\": [xmin, ymin, o_width, o_height],\n", + " \"category_id\": category_id,\n", + " \"id\": bnd_id,\n", + " \"ignore\": 0,\n", + " \"segmentation\": [],\n", + " }\n", + " json_dict[\"annotations\"].append(ann)\n", + " bnd_id = bnd_id + 1\n", + "\n", + " for cate, cid in categories.items():\n", + " cat = {\"supercategory\": \"none\", \"id\": cid, \"name\": cate}\n", + " json_dict[\"categories\"].append(cat)\n", + "\n", + " #os.makedirs(os.path.dirname(json_file), exist_ok=True)\n", + " json_fp = open(json_file, \"w\")\n", + " json_str = json.dumps(json_dict)\n", + " json_fp.write(json_str)\n", + " json_fp.close()\n", + "\n", + "\n", + "xml_dir = './data/Annotations'\n", + "json_file = './data/output.json'\n", + "xml_files = glob.glob(os.path.join(xml_dir, \"*.xml\"))\n", + "# If you want to do train/test split, you can pass a subset of xml files to convert function.\n", + "print(\"Number of xml files: {}\".format(len(xml_files)))\n", + "convert(xml_files, json_file)\n", + "print(\"Success: {}\".format(json_file))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize the COCO annotation\n", + "Once we have the JSON file, we can visualize the COCO annotation by drawing bounding box and class labels as an overlay over the image. Open the COCO_Image_Viewer.ipynb in Jupyter notebook, that can be found on the GitHub page https://github.com/Tony607/voc2coco. \n", + "http://cocodataset.org/#format-data" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + }, + "vscode": { + "interpreter": { + "hash": "8c5bf16c94eb6f9341fa612a12f652937166e39821fa969ec7095b77ab48ffd1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/smithers/ml/tutorials/images/coco.PNG b/smithers/ml/tutorials/images/coco.PNG new file mode 100644 index 0000000000000000000000000000000000000000..f6616c36c429d340db992a5acf5c6f5e18fbd39c GIT binary patch literal 17283 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

PFqNnxoF?d`+B=o;4+ZVP__ci-4+d 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 literal 0 HcmV?d00001 diff --git a/smithers/ml/tutorials/images/pascalvoc.PNG b/smithers/ml/tutorials/images/pascalvoc.PNG new file mode 100644 index 0000000000000000000000000000000000000000..866f2ecbffa6ce8d3be55cd41cdb41ae8d9f5136 GIT binary patch literal 111870 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 z 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 bpy%$Ra9fTeYl~@n;E$@J2EIW4y8r(GpuBhr literal 0 HcmV?d00001 diff --git a/smithers/ml/tutorials/images/red_cnn.png b/smithers/ml/tutorials/images/red_cnn.png new file mode 100644 index 0000000000000000000000000000000000000000..8d8be7194f1553a00ab90fdd04630b805ac76ce9 GIT binary patch literal 98287 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

U73#%}Ik~Bm_jj^JEJ5)v@;S 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À?1 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 literal 0 HcmV?d00001 diff --git a/smithers/ml/tutorials/images/red_objdet.png b/smithers/ml/tutorials/images/red_objdet.png new file mode 100644 index 0000000000000000000000000000000000000000..efd043deefe7acb15767b776be38edfd781a7e74 GIT binary patch literal 34335 zcmZU)2RxhI-#>mO#2zu*qJ&bTM#R=3!-!3ggbp(ZLB!rM+R{ab(N>pQHEI;yHL6u~ zpsG}Bl@1+L?Hd1+-uLr;zQ5;xzj{Y|Tu)ISev_ol;;1akW66Qzur_=oYX@fyyFj{C`EsVaau7QdkPFELv zppCQ*&}ff;+It7kLjUd1KpPD@P_y^;rH4j_MFgto;lXd~&`25s`~{c6r=tt_po0H( z(Vn{cp8D$GD~`!z&?qz?TRIqnrGcK2ww@ultY%AewYO8j5Wsf^J(vdmSkZig!#Ix+ z0$E`p;EJV*kv3Xe-_Qi3ZDInhyLkJ1v*`cT3uj8SNbi7uro;4cF?Wm%p}IK)1c!t% zJ^dr>Kqs6w(KJ>BJuLK}X1a#j`q~En+=z^0(*C&`5Ed4|_}g610!Z{<(Sc{_{|XCD zCfmkE64B;vA^r}o27y7usDFhN>J0|_SLjYaURt`GuJtU8$gzGjLu-9YCw*ONq&v|f z!j8x!vwRF)jUshz^&;a#U8CJB?HIQ1)^@&RR;Vu8n2vLCvv78%gkp@X>==Qu1d9kT zS))**;o(*ET}XOOE-OUJ!3!DU?$PSokTbG@QyOU zTN+|?4c$y);zRK?E2a^R7ObZmM~tUfg%RB2qQScYBK16+92p+E-g^4+5jKvt(GJlT z5xS8!dOPoQe6{;e$gdbX-tqw2fUjjYaU+qxu^} z8R4x#W2y<$)kcpV6hbz44<+b>D-<#@%z!}l244dV^n6@g!ef{~*YNSd7NOB(V^X}o zZ#*L?5NHHmFVZ1|YH#ZvMs+4L@DxIjhb!6K(LRLY5khebqQu2S#Knij(G85E1)1By1tZ1tkXIoca3k=KHE)oaq1aCuhw6P?| z5iLzHCN>1JPhdo7xP^tKNw_ba<%l+N(e*a5wl?<*!0U(MDACrT^l%o_g@8A~8AQ0- zyBHB&oa}A%TnbBwp14=_@^pFPPXgzRLm&&1h=_N66Sw>KCeu43NzSJ1+DA#zPUD0UAsBjk-OB4Tie3%6lZSNZenz`d*nX#Og*%N~- z1EO*60g{aoa4az1+LB^v&It1-7_lrujr`pi6h~^fqmQ|}11%(!Nr`nc!4YH7h7_7JE7p}W zW+v#|STE9*<5B`0fov?J^qjnDfid7)kV8ORcmOGoZe>Gq^2U$@-K^{lf*is^?8%f^ zXM-?jyuOvO8zsWU2p8{WN%RiWvkh={_Hh9Mw{(sR2R(-xvm(RvJ;L;YNwHL*^411~ zXgiD%8XZGKTjA(HXDn@EL-edHZGD~a{@#|9C}5a|aSTTfW)#VU^lKg~HxKQf-c5i~uT;uG!e7NKvfYeYAW_covf2GWSZ@iaSd*U}rOXXs~P zjSC@IS$H^6T^z$f0KizrSu*_y!I6gcB#fUo)j1yH?u@3!yM}r&DK7EuBzIRd8b|O6 z$I&f}f~|DzneNek9wy-)j`V<7b0b|{CqrPY3_C|U9b*w55EzJOx%=8$vk1<9!FUsU zYZq%jOe6*8YaAGt>a^T(2mBSM?GtnA%+MVIXQ<#yGF+bL@`)y?gS&U ze_)h5lV(R|S`nyV;I7W$HvT5ge)0YcS_H$$&j}ys7#$r?z=t`6MA1o3cJ_`@G2SEw zi($+}J6XFJM*5*6f{1oZw@}}B7ZdO*yj?8LAT-3%HNcMH1__uHjusmb>u2KXf$iMAs~0a>oUo1UPbq%6M*@Z_qS=j~?Vrll2NPUu%AC*P$_OZ6L@~0Cc!z>BWq55uC%y0rG z)8rsHF95{i*-6M>Gv7-4{F^q5_=s=6ezz|A=KZ(q6 zaszjr^~fa4$S^}c8!#Mtga_G;WgLi!V7i#tcwEP8=|8vi9}r+e{-9l=vaoa zNvNH^n;nH1YVGSli-@8#eL_7zE@O#tunUR`*CkuKyXqU+N7yjYz-QnI=C);=Qqgk>jWL+!Hs||FW^~0V18Hb(^8WT&g53!(|#Og)svUKeX9Q>nVjV#FK zt~L~!MSL_f1P|op=Rl*|pvg`+y--)jxJXP?NIaEl9^_AQ@$)3 zHIC@uOAPQc0I8&vn_aY{u2C>Y70i8THsD*hg%8cogg~|?vV0>9qKqR*!2!HcL*Lvb)W^`p z-PQ(2A=#2Gqr#j*B13&$i0=BtU>5psyaUhLplNm(klk5Y2RS%;7;$2$eN2=^G)Nc0 z#sA3||E7=N_rE#0p2dQGOdABDAZv4+YwV%#mv|eb8s8l;yO+jy?4X!Vw4|(|rsS_< z@MBWDyzfOn(LVPn<^siztVruEJf}0?OrBEjTePNN?AFE@IWOkhj&} zyG}50Rh)8FlPx4`X!mmW%${vVp@nj+XNvU`$98oUSsb4nNtnq^7u`pdT0H0CaJsVQ zk;h22Khy1y+mZ0S?&yi_yUFnj(<%X%<4O;(I#o1AUOSp; zZEh?zPi5{nl@t2m-i^d#i1xU-PF0C5ncGO5*Z&>qqLi8-if~jU_xCF^&!2Zc%bU#i z5GrAQm!bwvXPa$M^E{K|R$irS?09=9p&FjExjvHu9~<;Ju2p>Sel#X*WKZ1WX)D(o z0k1A=z1q7}2+z@bX-v?5INv7&u?D@5T5oQw)B4Mur)NHPWK(J*T421y*QNF)Zk1#V za}4`O0B!NlNSqzV*`2tvUWwfT8F1ve z@ngGg=Dc>;U9HBBg>hjq-fi3nC9}0zf;)8g&(HgnmAve@jg`++k44SSoirL5WHp|b z`)5%kHD;&sJ-a-DtKB}ny8ol;Vtwq=*Vk5$R;Mdz$yR>tcQ;nQ(O%mdRW}{mQu?sh zQnu4dA*on%;`WE=VNBe6R<~9?Xwj|Hyry(g#(vh2%T&Uz6S*jB#uBWj*bf>MOB*v%Jx@tEM~- z#=cfPacOsqG_^a5nzZm{s_3}(nd_%aZJwUkcD-tNS@zRub(hlez}gEn59YcAu(O&Q zn-7;pT*y%wkCOffRG~!o%(7Qg5{ujJZG6A=s>?HFy`;|qnnZoSJ(?^~&@|*PyRfPD zdSHK;meG4=dWA&a{gqD_-&kR$(_?r4XgIqDri_W3^IKW_{c39RtYhA{oA+NHdt_H! z3cm(T_F5^p3BRfFG`rzeIe>xEG<$FcAw_yAi$ej&@ZDOiJ@B@l)*QVhI>LleTSrF| zf7`nusaw2gE#k{J$}U$xexEPJF&|W{A8yILO3ojzZsu>EJ_LG-g1DMT9~vrH2q3&i?-|4bf~gRHtfMQhFLSHp^a2c)$hb3pq{5{w1M#^}TFZkE;(A%iJg|LV z;+->5eZ|((F~u=|e%z+mzECL;_!(8@;V;>e|0$JMzPwAYS?9r9zU80~Ug^T^yN!ci z-@Oct#h$Vb1VdyE(eiI(RmA=NG~FGsI{y_D@~$CBHKsUy9(}omQic9r->p42aa^ZD z^nBFYgOv5}2esMO3KADZmW|W0Mr56|&mkmE9vXNu`MV}%-8T8p4Z|a`?zemQP=D*8ov43I*}?m_O3CwvN;!y)ckh!l6T{1^l(V!m7`Je>$AT) z6evmJ>+p4+1q%?OC>yNLL#O}>_l*6sU5;j3Q7!&FnazumhupqSSM+7BMUwn4f&m&US1|W`6IGR z&2H+DYD^+O7xsbYzz9Z~3t7;sYl3Rwh56bjvcChR4=VI{5F6eYCol5z)t=ucPRNLX?b){+E}3fF07m1Mw?Fjm8G9E2ETqn7wz+mopD|dw8b^(^Jh4^rx>Yur zECCU{*)^T_XC75{J@)cU?SayYTKc1ZJ=s!8IuB*aUqvbe$D>>d29W4jFJx~jP^(~9bGGzzwv^1|S)D;FOY{%V?SEw@|sIE?R9bc=)SvSb^4ypi4F$epKN zgWz5%a#Xs!fz(Ez)QmoAJ*NW!JZpRWbdsAH}iXjSO9i;W)`VzhCYy0U>C52bV+g z*7D6iqnj1kye?3ymDRU_>dF`$FQ*RHF1(~5-%f?Z7D#R^0IJ-jsWj_`1yVKjQaX&_ zzOObbm7OK_S&D89XL_x*aYq6@Mw~96n2`Pr`$Z;g{%mx8xV|_n@NS+}*u*YaWqY0H zC5JZ%uW3VhhoGT=D@l@*SDUZCKtiTmJVNE;TSx-f+CK=gNDXa7&;xRsJotqxjix$( zo%P%ONfbL{*SUAr!4r#7pM@uJdrd zGe@7`6!!2npEMYt?!d5H3bXkU-{xy?LagZb;Z|`gQ~AL_TNY+jvJY;L0y7>zn-;4V z@UrR%7!H`Py0-cb(q^ zA}9Y)yfsc4jzy3qmqS`E9Qizd9#sOFKi0T>^rOZnxn-eo_mIZkeQJkPT^UVmM}e!- z%x<8a{ZM4+WggkXK*pZ@%Sw z^Px}Xe|lv4z=jyNUi6>gZ*o>j(yT#w+3xHr(Ly~F6)9W3zi$`ZVg8;So=`V!Uj2Q%2)Kv-HKZ>}-(|h`ZVBSGz>l(zD<=tI<|}zLrz_c-sY0?{uCF zcibAdd^0~Enur%Hae8F7u}ruWbX-T=ql^>?@z!Ug@6?ok0_X8JKKu9>n{DlVSc>dK z7O$%NScMQ;<}+>)u$5n}+!DT^eYO@#)5@!jl@yFOxm_TdIr5TU)y4RtQs8Jh>C|r# zeZ=wEO#!dB-GwF*+$~(YEZ0{TxajGhVSTI0uJi6kBBfC5;>za6_X}jbu(ai4t@)WT zw%&KEk1q#3!LE&^i&j`8Ja-NfvT@sWDjzMC)%G0vY`!jgs=s3kPx9j}n4P;4lUl9` z9pzHYW_=y6yto8+|0bUb;;{oHdNJ(L-FW%opLP3%18^;@o*OQzjTg;lP%Wmr(>9Lv ze^zTzN>h z!~;*(cmi=xJ>62X2vcNp|CCN-3sBwIkdNETdGXg!(QOr1d>~to3pqP#{M7y8Lfy?{QOm5at-nqz!Ao9WnU_vr zb0xwXr0lK`vzk8=Lt8Xo0xtvKUV9FPY}Fe~JH8NOoHns`Ma4F+yt-*w;P4DjpBi_L zkHOO|!TH(;D`4Eacjeq%y1 zrw4vlW2YhbOk`DOo38Nwjje6!S7F5!6*emD6oLzN`-4BD-6042hd+$D9%+?JUmI&p z&yCnt$hZDr*cO%x_I)>8V;1kCFZv5-{!e>_0GW`iZzutRW%cJ$Ahh}P>+tnwl8Z8#6V+V z)cnKO3r5~nZ+{_BGT9l~9jz^lVwMwHZsgv9oOEKw!jkuIS%@}Ddd0Qa{xR4^;a1h~ zt$zNaU~%?qd&gUiwhReAf!cNU!ik1F5_x9?z*Yolp4#%69jN1%q^aj%)&Ke1$5HBA z3-*p3P1LW;BLuIpDWO-91wP~6LTAmeJhnWCuE5%H`>3Dah=dVk_t$y#(Uz@JefFW2 zrA}qs@rCUSZ>~OW9EBY2?;)GE#9w>(V%@=5lLuu?-X{Oum?;ut_PzG8NH-NLFzkG# zpnTH-@^&oa?3r9I!&710;*iGtJ?#Pix@_5$-*CR0jz^64u;EBp8M?4C8|ok~OL;xq znlI3L2L5}GLt8qHJLPfXOBt*{c2D&K|I9->gi)*FJD2x+Rm$ag&3`=w#1W5zI+NZWaAPg zAjFy>x~}E@3YaB(PGP@ZcbEn{Mt+bh zK!>AG^5nGnx6zLpFXVW;L#b~3ux|Circ7w|aqkn3I{YZ9jYVCG8HuyHbe7$Oy|{dd z`Q-zpCZ^Skp9h%cm^4=oNppWS zVBFzQ#o*6!EmSF3m%gtqQ>^W~qpRj#!273Nh{vD2ok1rapM9=+C9x=vCN_KX@$`}7 zPrR-Xu5jr;4k#bAzOedWThh~`MrQMF?@LcUI;L`PS@s%Zb{C=L)*T7+-SqoqYPRNx zxiYL8l$yd@X!Wb_WAL`Kay$8jQ8H+ODf2`j%(6^}d4}M%+Q&Sfk_$;k^~ZHce5iSt zb(62pHr~&fUZfr?P1XJIPoM6=Wv~ydC|mNj#XMu&oyvQYGBBencRjqXV&uhp=xi& zYRT7D1s)xkSMlR7$8JcXVMxZqrwh~X#I`Sm$T3@BZz%T&2JfY~6m;KzE4oy&{_>)F zbeDP+dNB3q@fk1r;U}Wf*y1eqF9eOJfysL*CFQVG*7(ftb6Y1|P?Bt~vSW|bCDH{% zYTHhps|7z118cv|_?DdzF&^bY7TMPsUzSbgVM}rs?uGp}d&$%5sb2CD)_Wf_arUsf z3rKGqU}li}y~rE&4qlaePx*DYQ7|4-rtJ2ExKc-86iJ9Rh?{cr z<0C1}D?V?BIorvPhqj*MbNJ2_IIJRh^uyP&zpJg;*wPub_{v%8S07 zwCH|!VPJo531X_PaYo1=g8!J4VUDT1=Rv-^9d?DX&8ON3rc91IZ!A@Ahv2omZjoTaTJ1# zK1N0qe?g1N+>KRU_GHvt2~Y28PUmZGq(tu4qXJH;G6I26Ydw#H)&NXmPab~kcd8Ci z7-EYrhbp$L$mNXjqDo#KZAD}qHu`Wme)(kn5C`6qp^Y;_(M zzZAzM^TprZ9z8XdW6rZ1Dq3H>s+Tuh#8aq_XjV+xO6#95+T#di6>#f{XvG`GFd zN>uE7U{DWg)U-b42Pes7hXorS?p<16Dh6I=hJGZETQuA9^u^+aqj!q+`Hmh($t#q=EhN#G5+6b&I?|^Cw%aN8e;;n^KK=6S-^Yta z7T(&X-+C#YWE|o4@#$Q*gyXZmf$ER|DUH3051s0NDQY;8V6QuGBe5F%csm0xBY_%h zAf)~&wml1VfY3hvOzNg`$(4$fcCo&(UaQI-uGM#n)-beVnjaW?!|sP|vXgYqF%rw+ zl6O9zt|{JM=H~ZAYTBdnuQ^0n7Kqk>x76`t3^p`4GrDQaAQswy|?U`nND z!_=W0+?>UDd{A|v$O@iAx^zMUR~vou_32$y>n^TmX$ZmMA@writ)K@{!AjKc@ ze~g|yb_g#<#X=~)7d%2a{)oIBPd-IMKYtllR4x1v)GKO*01v+v#nuZcmdbF4qW3vf zv!x)#4D)Z!*2XN0UEcN}-tQ9KimF^Q%h3GbC$X~9__oO3dm+vPU)9ywE=Rt)m2LjF z6K-t10O-W{y+NVQ1q0AWM%cGvxw~!oOm|Kn>z~c~zNBoPohfyYI&k}^2P)&vfRd)8 zoWMD*oLZER>Bt4180Zjgr_4w%-h&rBI-9qckQH(Tz4bxH29&0MOGuGB z2mLVZm7g2T45@o5asBB{pVdM6R}=M-7lLx$>>I=1^@V}wYD*2`vO=00a5jUr!IYKX zE1wbC<;^2;WowP=iz*7QG%}Fbw0XX#FDl^4W7odXz_3pobU%!A5w3r?<$ziY1H$v^ zh8=pHZ>+_~4@bG*&M3Go<4b}WNj^I!O1uVOH@)FJB%HXmzMBk0RA6vboqewFwPyZo zT^c-d3tlFq`Qcjp%)|NyTK6oXcDeWmuFI#lKvIgY1S=igdak0N8;OVb-)!gFE4iDE z#IFtS;A0oV6urTocuD(OwbjWqzxkQx`?ZTKi7(~)P`&z>vkA`Y1Gwmb4s z6f>ZSx2)b2M{X>i;*_k08e3Tybl~>}#^t9n<4t>Uq4QNuv$k7hmH5NA9>i3n56*n& zcm`biN=A@I&T;U5-H?Z~zr?wKyuMlraG|X6#H|o+<$|z`@(X|_-kWf%tlnwX{QHz^ zbuE5bKKPe4{+XFiQ(!Ot)5}Zy2_K?=yz9J*OD_(7d(*Pw{uv&D`#v|CPTj@xG zcK^IXh+q17NszDZL%5ylXt^)N`z}AKX@B33c@jtEUO0GvRB3v6WLnGH6&Q-W_FZ$b zf}W+y{x`*0n%d~>vh@p-+wqYKngiK(oWTpDet&+I50LT;Nb!j&CH7i~REEJPfXw7B z{un;$bUJ%kJx2zp#s*zR781X$(w-oD)3Z!t@sB{vd&S^`iFLQ2w6yaM4c^l;t9m2* zwo2m|MuB*KyxCbLI>V(UkI$$`z z$J)F}`t-Y5BjoAp3}qP?nYif$kG8gbTX{fV*O6HLjQQy|yXNOeb_ZV!`SGI~*vh>o zF1$$B`mGC=;qo?kr!VCU;_R%e6S42 zXTYWCi4xoV^{XzBJnX`F*k(ZWRp)j><8QOi+B_Bo4L528K*Nbq+oBE>+x#t>C6LS& z(<8)4II|;VmCYS;nDNBuYkD%&TfN_?b>J;aF-xDxsyw+`a2dK-ooBd9>;JrFXF4tC z1Ro05?_sE|g(_Lt#fyyX62-1ni5m757>5@XwB&fY=Qtb!28)NX43AydYY*wZRv(~p z=TN7F3yopL5B#Q3++{bSr~5l8zwf+8Bevm*ze<(ZNNl2~k06kVwE2k(8NZ>vy6c+f z_Z{rt`Toz$7W%MZWbR#IqlU=3eOntup9&+b(}Wa@8>D(>Bzvx|Kdq4%ZW^&%DL@}a zH=F)i>JtDG{<8gMbGr`=EAu|SvR}c#MrPo~jwt4@q3=T?YMvY4UJb#YI@O|+a**N# zg7KN+uamN+qvtA>VC| zKJ(TGV^S+0>Ofjnf2xqePWDy-sep#s^pqQzp^alGcKgt3Xz}(EQE~kHK*Gfm6qq4n zv5Z6)!=7;(Qq5LNPpK>BNA=1WblnSYD14n@8l<3{QT#SKe9{h5WViR$2)tHiD__IF z%*VLeRJQV(?$1&(M!s=RsCV1qaF|X_^TxfaHQER7>9gX!yPT%C zd0-h8+c4Ev(kx`#jn6j~=@uLkA>`+KqyVjQk0O1l^cV0aJ)VlyPqCzi-yYFuUSGV(p|V&2@a_bZuiAFg$Q&S9G9dBxZqxHW0l1#+ z70+XTzV%GW1$^uwumSb02Ck#ZdfUEhSGjI^I^2X4*SF~vd#Ce|%A!L~>-w%$oPIYG zSO189`s|l<+;4znE((-)ugyMre%2}f%~d3_Y0yV-1%Q~vfCvt{@eu%$r$-(pbc3Cg z_WGZte837i7`_YKu>$1LA69!=XuGK^`CybAf`@$!%<;gwkr(&bhfTGy`CgFjQ8`xT zv?L%^8WY!kbxb##t)hwk#B z?mgdg>_g2$-^$*seOvWK;Y8CU*j;h#b4^sO-}igpZgy2bf_$0+fV01MVHU`DKVsWS zS))8a8^J;FTcqTQb9rb>EBrAsh={K&lwFci^UBl(hJ7_AfXLgtOxaV@w z3jxm4MM}rOYHXBU2>gr$%<-!W&9g{Z&Q(v|2%{xDXc4YX)&@8`2cQR&L&z5I`9GrS;T` zQ!&@%)qJOZ2KVw@Y%Jbqe&z?bII@I^b z&rIlDY4Uc{UL~B}My6(&Bl>qm@tfpDqME0Yck-fYya$@7>s;!WFzNWj9 zpmg~k<_?5*tN9t7rlWsVzZM2!7RM{2Vc*6Y*&N_gz}PE}Jq4kmZ|$dc|16ioCoF!y zv7yktWp=Y=QY5&u^kQg5qS@-=k6j<`MY%{LihuRHICcVh**TJ*CkIft_sap4&OO{B zW*YNTlf$Z~i9;eye7-B(-8-LE0>Uxq&+e}9*;Za#z$sKFVQWurjVsceUB`YvIt^S5 zy_W@v4`+UJYQypRHx~_aqR6uP<@M43cf1cEQmhD{CjXzA=9Gmw-o!ofN%PJ_u^&%P z0V5?RZ!72#tL>g_H(2?tr%)G%dl zu8=3^J=Fi0NPz6@F~@tJuGVR#Lde1lkCc8jI<@Rne`*|SkV0NC-+DD}kj*PgM`FQXa$=9{fD`xJWG2qPalnKGfjltnN-Gsq~~*!uMly+82You8+jor$ZCiZq777l366=5&EY6 zf&M=usXYYDRXV3n8d-QSHND~KsqMiCJRj=Q3`3>dK2B*?GW+>7$CARlObnf&#y z6hc56)yba=fOxGfYcczibpN{6e^!x5hf)m<726jFrKWt-q;tkTI`^o8{7_0lOlY-3 zbi;{f(Vem`A@$e4Sv0MSO8^(=IP?GXa4yfH zZ%QKmGlm__<@vqia!Bpg<;DZEqYokR5}lnKP4MQDXB3|X$&HPb!91>5o zv!3IJ6ZsmC3$NZ3-B7G>|0pI4ky4%t(Fd=l_TM;%2c* zfz5eF4<0w(GSe8&F#@hAty~9?)CsHC52)JUZfHULLHxi6KXlJsNcaS`BUVBRj2|u# zeP**OWb?g>G`7C_-L&fSze=AggbLq}jjSDl4@ zyoq0`&QuntpPJnAo7Ydtn{cjpc}J6{&j`Y|nqH;qSE(b8)eyuM;py)oQjp2hzh0yc?Ca}k`1b(yGWXp$9Vz+DG*4xI} z{2u%3SolG35W@;c5&tWb5I187+CIxty{s1T`Q^z)c*5nMJ=fChE*fgN##?)&;-zZg z@=9#up3J}M%kd_htz()=QUHC6UBk%c((A&+8>uIgC-Zq=?T**DlU3QuC>C4u4z~oh zO58bwDu2KlI6yy5RByti50ZS|(F>Y+GBD-jlSvUwd91nev~~G=#K&P_(#afi1)&SP zz#VC~cIHdxD9054){v`^08MI!GgS^W2`@thr>UZ@y$qSwHwf-|-D zgAHI_YaUu3{!jGhL;X782m(o@@VOw4;KTnB{AY1H{q-*ULEKHb|0FhisNRkYA9Y|* zoL;$eu&gKY=OOWfKC%+cyZ#MGUwq*(WqIKpWj0Wj=CwE6;F+n&zi|yB$zwel0zvUg z?SG+Py}NxfB=1P5rNth}?t}ZNxfb^Fp~5R<_k_TS%ohSzYIT1Bcnns&hdq{rD?odv zMgDwm!uot3z}Iq-JvdDGM7t{h2gL8HCrN-uxMXy&$}O_4Wn(i^nt%6tL^Z>jB93`o*7fyJo$v z%W)$kpc~5nXVBa^+~y)V7V@CbK@{xLc3d)z61eL6wcK!LG6f`|+*~;}sUSS$Uc1Ur z;?7w%SbPCqw#&IlY>p2FSj01+Ot^Ef&bJzy`OiCY#vl?ufHkvH236SYHFaSk+(^$X z@sl}LP-+W^$A8@;cMcOe6UCXm*>`ck_zW8H!ZT~kvn-$OVh?5@DInW0;X{qXlsN$H z|F5S2s1Bj{@A%BQa;oqkE7|Zil4L7S)q)MYR5M&;GAHBm=?XesRy(HEJm|2w!l`?5 z9|iUdssXDpW&4SN%;J}*$u&rMdd!ttO-eUE1S#|Hy&hcx>OcT#Fs)Ya1p5rs9B-Zf zj^Mmn@^8)-&B4YwBl^ORKs7yYxCe->9Od~F?{XQ?|JlwKNvk(~{{4viqm-d$25`|O zU1E{99Y>y)qt1r)s7zMLk)_Sk2YIdwI2!A-2MhIoFS7EdUA%b{B#xgsnY;!HWV*we z*QM3f<)6q~KXR29d94#-w-#QS+KE`oFSwj==C-cJvq@P=Y`qUZe-TbY#~@VF z38THUnlJUoJddmv;EDfCjSBT5`|ihtZ8J-L@Q;CA0R}dhmV=Tp*N%0Ns0C?*qH>td zZEH_K%%H09-z37PZ}sO>-5>c=BXmk%&&NFejLDD_0+b zRL*cp54J^Kb>PBQC>B$6PCs0d{yOlY+=Cmr<9y*MzdoIHPABNY$mUh!4_=A_Tm0ru z3ZQP{iAZ5Q@wt_Gy9PVsFsB<_{N+yUC22M>TYhdmgTLrKDeTb@A5aXO$LNPU$?JWS zm!egKCHQo2WZ$ordfqVBXM!Ud?jIcVgW+xfc#-~N^@2QcS(H15$B z-6H@_?HPzMO1_&+Uv;>D=7>T@!9d4{0ReJ7>THb`5DyEKCU*loD^2Q--S>Y1EO^-# z^YoUi->?#_CL}J2pIc-d{hEM76&GCgp3{#nwG!orD}pJy=}Fu;w<91Y=3TCS7mk>- z>R0-!OH%*YWUvI*NqP7qWiTQsEzpTS+~&K zMn(8r|7p|4pseSYe_UjEh_#7O>A6Nf5|6{odpKR&;D|k|#UFM${}#opfQ7HPH2T>W zfpp>P9PZv;a{oM*I02;ztYG=FeX{$ef12&*Lwa+>uEwM2J^eAcGFMv>W)2q4J@lJ? zxBPB)0hXhc<-$LC0o6%V%KrA+beG_x`*}fE9s4Oj2zA*(_RTuD*bxG9&4I zSmT6>5N4$he&!9?q4|9ll&Qd>i()dazD#J1;9KF=R5aF&ntUeH(FC&A>GO3R`dDaR z8LF^s?P&L!VGy0mZ}?$uj#7&T}e-0SIuSBJEKU*m-unzZ((U?r18!H`GGwxO2(& zW9A?-D)(-eK;)2sjq#86m%dCGkH}ms=4gQa_FMCj)lp^SEw_V0%ZL_XcYoWydG#tj zyv&I{MBL%}bX#&JfJv>3{_GS%J>j_V>KpcjOGQ)2A9O774WManT_bEdl+#^K9~Qi> zBJ=U}&PM{e{#RCtL*SVw8^B&*#gd;2 zI)RssM+5=F4v|Mpu7%SCo~&;J;JW)E~V#qjkox zT6Vv>28TB&*|DMwq>rb4!Xa42>=*o_mL4Dt#s98;yJ#^)AKr4Gd@0 zH@LR#vx9UckM#m>AN`*(7rfc?fePik`m|Xp5FWVnW=ATA{5WGCwvz*o|Go-0A^p$v z{I0D$fQq_hrOp2eadi(TV{>_S9fZ$%zfSQRE@ch^celKnOB2-2;na`5G}}xxS^aXI z299LpUO#2CWS;Z&by;`Z=Su;J))(}AOb;M0N<89Be7yGk8;e~$C~q8x*|08pB>`Z3 zlf!%XQ2s>{*yoV~;@$s>nEOVGM|d}k=!8`KE2$2Sq#P7Q;hE>ZaEc$&+UFdWahHAH zPfE`2zwl3+lmE2IetBuP;3*n!<{j~SkzbXXH#hEc4neR$#IONpbEW_;W7inVLFt4P z_8kC6h&D?+PT6!7LT4@wXd;yUa!d~kI2@DuWZe_#{X}ra=Z*P{&6hWo`QPt+JjH6` zSADj7=E07D!tf(@=P@d8CQbsdb0y_HICO9$@A?^xD*Mjpg^=O3hXdx8ixf=6?KX1{*LO9i#Rcs)~NruK-brAcC2*{Ai_2vS8;U~F&=|f0FX^< zVZ-_!CM>ldUjo0n!KsBZO%wpRViN3>`kPa54kJpdey6ypIX8?PVm2=0`k z98d)4T(#Kers2@D09f+`P^yXBBTn4VsH`gLI=s0FYNvzSJ8oXi)7meP_xC)F`-9lJ z2TLOf6%5bhl@d*AEf%y_Zr)g}d>5{lu*eucZTxw;1!K#=W>|HY7I%cdT zwJV!j;$bjsL)kNFA=ksh=PEpoGM3so`V6KL-N^lB=d(#$NNfmzqi;^_!@}}XLUOMpw5HYG!K^LGB{;*Zd5LM%Og;@aIOB5Ucjk6YqO7otmB76Zs)eG;Z=f` zk+62B@&}gp$B)SRJiw9riA`sy}~qsK&!k z1x_rSCS%_*7assr^wNP(#^9((|4-QmXdzI#JLtlONOIWFyHnDwRzo1$EtQ*h+_&P_ zxa*Z5Di9%Oa#b|#d;g8IX^7=Yu>OuW?|zb*>KE-soPxC!XR|LIGu|pzoBH7>Bs`g_ zyLAPQM1BUavD@zT4RGS{FE0d6PZhErHGeI=*#9Xl;-!g|yMFDkSchyOt4lqIG7g4+ z{qj0EQr2I}CW!8JbtlEoe^KNRb&Q5y%jrX!noD2Syxdz~TJ=lt5`A97COo5uXc{jz z*FKxgfrDr2g2*|*AuZ6rIjW}}`;gf04{zCJajK)8!~oHohd|10VfNs7)td$FmN`db z;E3g`aiA(U3!Fr>Uq5oEU^!vwXSEmX>;_24D_`zw8wG^g!Pd}Lt=sQO+fTEZ&lHcA z8_)h|nH2TvwM8#)0zT39hu0oJ2}quU7|hwpl+8b$QOlFSOO|=T$-(VhLc;&UducnprI?iyQzSSp4mHe*cN~tgbF*yO>pZ=UtG) z)q_JdyGDf>e>&Pz01?#9p(S=k*nOXs1*fR&&lw<)>|hND3CeOMChI!n zU5*;xZ0NH|Yl16#^>v))W6OUR&&d76IXCA8@wMJ~W&HoO_nu)*Z0*1BBoGLpNbg8c zdXXkwF|d&i(xpigEEE9+D`IGZ3et-dL5hNa1O!Ay2nbSbG*M9yL8S?zAWc2@#J!)r z_jA4Px&GJrbUqxv=oKfEwbrazbFW_;L(eEyb*mwsG*$;zVY9J)kzdxxLE_oBf=TSf~-tcs7EUC(2bd z*3|5vD$<#0YMwm}j$CVA9@n!Ga#BG{^aTt*CBu=z2)dq~U~RnP>n6YJn!mJM#wCQf zAQZ6_gLu7X^$@fx(C49M_EJ0_hWW*6Itm@=yn)q2=$~Yu%+iw-bz+-65>Yb#sVLFm za*?Aim5n~KgQ1it2t!bRsM=#rs`;j*)B%C#uJ2PeoVJ%hgIIF zrOsS2nJ)O9D`7={?euG!Wn|)5u194ViHK9;7fXv`PSuQ1@tNqAVW%fqY2~nw%aW-d zF{#@tc=2SW0imCKZ;z2sdecZG)NZNma-JNXA~+_$X;v5`OdLzGB4NXJ0rlr~jjn<@ zYZimkB(SsCR%BQToD2O@$>PJGM_rCfZ+d5^WVnG}IP%TAXw=7hCp zO2hz(7_d?4_=?hr*j>ykz1iP3k0^fIBm^eEKXzZ&!>JU~ zeyhtk)TuX#5RGAXVINl^N2jGGrdxrE^%kuVMqAUB?0vVw*Ac14fXr_rLpJHqr>{%@QXPwYPMu<8Kqfdz0)kF;KY_s56?DEwKx%GQi5g)LWFq@e2(R_ zj|CjHtv|Ga@NztqWrCD??rHv#t9m^Lv3!!jkso?iUfK`|H1ff?e$6zk5B8a*e2Y%3 z#4PWbfwH1{eNSfI<;(m1(k|(p*}IN0ex}1QM!}7dxAN_{8EmI4T)`gHHFA2UlF#&V z>pH8x1n2lQsI@FwxORL9cJ?R>nkvbZ-4hD*Nb;)jEWrSmB#lBh4^HKEk&zUATTn8a zoUq8=o(y%;9t-LUqlTatXY2{(@D4Y>S-$3p6tjW7YS<^=JLnytJn}IO#qPcGmlh!L z3}%7li24BI2r7}7W*3;{dhv1P;r_cL0>6TcTU*q~TStV*Q3ohK%n0^lnav~rYO;KCs`NY{&^2I#vA@Zxd zWTw`u^GHhTr4IQ79twu&DF$1f5%VjF#)!!^CT0vh7x6Qmx;eNn*yb{(~DWQ*rC>xk0 zJ@Q_S`cAP!b4yJp+Ma)xBmE&vqW|%ncfmWh1jimlZf;45K@h#G()mrArt^2d`x-MF z6BLQJzu8lH$X z9e&&PR+Vm0+EiX%d;`zn^t+;|Rl1H0>s4lRj2+?^x#mJnf~9@Hx?#6=wfnNwdH$Ilh)jhN-&kW5#P@CdoMi^Y50kw#THf+KeG0ejho37QB zUm6?VN{(nchcVlR;73fg!Z%h@pu6J$+$~gMG(VBo*~k2_NW^ZO*%pM&QJwNsG$^M3 zSAo!x!s!0W@8LLMUV3JZjZnmZa{5!$$#45MA?)(O?@0Nr$PCZ4A!71wa({*)VVD7+ zD$p1D7G8`qfJrLAoaxcH+Yxp#SoU1=*rG6wZ>$#s8^4^dA&;2}lQCa)!wf@^?PJp3 zyO4-oI3m_er~S#wFSr44e2ShXm|qD&q_LjJek63*x4beznmYm~7O&56?8~T^lr92WpgzkjBz({%{@}CP?=` zsiE|awaSnfJ{wZEZFVHFLyU=vd_>DVy5Sa1q1u*x%nP1kos|RZsRrh4O6Bt|FN!2b;r1W%SvO8;v*&L9zVdntpy={ zW6QKTxN&BloBCpxutP8-w75s0q?>D5m>r2&PFNUX3YTb5;7q;4_O|?**_(Xwy)*L~ zq*D*T&z|8sw&CK>WJrgvkat{+@L|H7_E=?ZJ_n{0Q}?r@bQy_be1#`kh?@%xMq3Kb z22nyD9wXVDT+J#;#sZ^+f`IYarCYXekW>cZ8{Cl>yB?lHUK<8PA3eA+Gn(YCyemz! z+xDhq1D>GE6V%zRlBSV%f7i8<9}Id+50?)hTQY7?5}X)U5~#m$;cCMrcJhc966N^B zL^VrT}bDNZNAKn?!af4uJ_42$NqnP z6(RBee9LAoHL!9Ty005>MTIBG62sM?bm6^gyJLYP_t=CSD0xp0jb7j+d2wf&*kWG% zzFfBkFHK%BqCursuY!WYcJFlyT<-6I)pXM0?Y@Ua*cskwLCdhtBrnd4E*lKr@9Vg2 zD8Z)?Ye#f}me&lr$t&>071PG-f*oGhoEC<&3BL|*pG;a$q}*>-*TcTH?HZy$3@+{7 zUPdk=WKm;GgpJBOykI|-B!JbW{cRM7J%z<<2-Rm{jB7}(IRj)5$_=ylW%8^p)*{~Gjv!w8X5 z2(H2HJg6afR9?z5R~m9vlCS*{n-R~9oC5Hy#O2PBrl}vW#Z@^3X0wy=G!wD39n|8w zP_5sh0x%|qmM?bp_9h*dMS6xlWV(kZgObl2aKXxyFHI}s%s3v16q3yu`Zm=+I1f<< zO@Om0zL%|8ftes)iD1MJw_g$Ei8F~n<9a~kD0FweY26#*2jXP-lG`uw^}tqM9u=~V z00de+`7j!cXr=xzxzgV>RqT7hO`gPNT=??7qX)|DgAbOEedx7bc;0mO47yXUyz!JC z4)06^plG93%`ck^hcIk4x@^Z@1CLwh@+D9oih)=;3G}~L!$pVeeDv*z&2T3zzFw|4 zg_8>cFsh4;p&K~b3y2}l-RqzuZm0=!g@mD_-<}&8Stc^UmYD>NnWaPbq$kltBuKGJ zu`V*~N;cXoa4!Qyt2dzQM(CyvMQ=ZatPs)ACTcl?iT)8mu%lo>KU?FhE}$7yfMPxo ze%fAbcmasaaei|6b$!6t$5jOVLO~jqo_(2B*6JN03}n*;eH7&8+ZU1?91zPQuq9P$ zkHbPWKxKlvI^tkxtuS2BEJ;~qHlEG~tfmqRdt{#SospxL0s~M9=Iw(|9eTDwa?Mi0 zQ#^WjL;-X=Qufh`9q}OnRiG}u4s4bwH-sH^W?2_Vjmt!Q z*ti*mwnb}958>PVsQcSfA4Tf^H~^_B6_!6hC2X@$J?P-l1$COA)?P^?bTKL|gKqDP zBurREpvhd1pcs}Ht8}@Of$neuZtt8(`eOnBvd7o9RH#6&P2@<3iF5D=Bb>1H7$7w^ zl;9z!gI$15%ac>MEHzt_`>Oe&`F8i<3Y!Lc4kZ%OtP#uWXh>6TNT11cFFP%~jAR47 zOR>pbrCly)M*(&aJ{cCE{gc-JHVCE=-=?Knj4n~M!)RCa&wrPa#tG33NhqX^vTWQ9 z01r=Rf4;TvzN8z+0b|-ai(Tf{oNxT#ku@dWi2W`}% z_|ATOk~es6&lQ#3r~3BfY9_OD7QDIC;!5t=pI}-VZ|^2)2@f*_iA?&~l_}WvdgoS5 zCny)t5SZwsxBxqr4_hP;&jst3sL5Pm=jlv?XWi~ny~cg&oaEm8UGCQ{^GxvxSF~1wY8`7JlEPEHU>CEzj4ZX=NSFy<$ z`rTsD27c^_u}s#bjG6~Gn8cQAy-n?i%!HE|`pL)dC(KyK=gJ%q@ETSoZwDKjvh(!v zRmte#{uCK&%nP2eiS?(PEES|vF%-@9vfqwCNkuZde(Oxul9bNzS?T^8d!C+Fi|-k| z_6Oq?^?>Z)Fhg?(+GFqY=7T)oxOtad4i8|lcOkuNwx1Y*j&Q0vAH4e2!F|7{@C9R3 z=ktcA5)4}6CsTP)J6e#)?Vkp3B_|pOHT-_0qEGhwPak24(McYU9SCrumXO}lvyB#= zr^*9|)^5m<(OH_U=69g-G@8l=Zh#@@)7G3SgGAHKr^40MQHS1%@}sDy?}hS=@>g}S zkCjbMGx^|?eN_#Te&AzH$k~U%t?zS5p*{)jg$`5rKA1ac-={hJLKSwQr2r*rCl9@bu+{xSmy@GVW$M(P(ZV|t1UHIl7*o~(Ybfl z9`*Z;n+=96E?ss{X8>SHy&WiKmtV*uvX;vOUL-bE*MpA!3P{L8MVR*kNt`~0W-w$Q}R(Kpn2ocfeJ(30s_ zcb@5vX5uOa*_&jdIB)EoPuV7Uv>#HN!F_I1$qTc1R8^rLSH|$U*16skJnx6_0xI5d zz2KZbe_Fx0Hc9K)2XC|I>?LZaA}mrQqO(dTj^xrts_OpEs*_#jQttg<v;8kfpf%2MRxwswC=GH{8tU#c(cQOF{zO1KXz z+SA*4HMts?wum9-MQjfD9sb@cJ2DM~EwxMR>q{O3#x5s{D$+mfcptCo4J)o$VVBtl z&+?`+hr&ozjl8g^%kEB*Fll5PgxZ|du*MaO*%F(-;g-$PL12}X)BHL+3Bv41r+_Kx zc36bayd+7B>|)vI%C+mx7YI*Ape3r|KB&*RbnFPb-yoh?-R+lgGK;UlwHp}LH~TL6 z`00nwKlna@W^~N-G9ckE4?80ruS#EwQJ0I(xOY zjsl_32OQ>IfWe9bN1JS5ePfrn^pPWHDd9%+swLb93EJUzQKR$3{TtC$J2B#o$A_-Q zuVMLk0c@%~%xTd%6deXUS0^}uZge-H)+_YM0>y@N!aaWo{j<4YnP)JwH|xsZgIA{< zeiyYp|FfebkC(N%izeQj7*%k|1_II*GAUQ%BrY#ERIVAy;qteYfZN`WnFMSnzCP*1 z{M$FC4{2;;Sj_(8Sspj_vT9f3LG2Xb=J6G07DQU|jjuUFV-~<+ZfmDiGcwbi#K1df@G*rYp+&9yqu?UUXDR z|LC=gqK+?ON?>!r7DE5R-6Mx{w*ZTO#>4hn|HEJV%oMvI6V!EII|LEhqt${_?V;qg z*VG8QNr-PV-G_BqvUsqC#~Fd4Tlykrx=VGiK>t2zb`Vv+R-a?I)lB`Vrj*Fxqonjy zB1bvkaDRyz-zjiM4Gz5y|FLFLWSBr7oBZI*BcYmyY&z1xC>QSJlWuRr)BX2Uy{8+# zd+OkSUBM;3;R@aZ)rBk!2eiC3G86((URVPA1bY~GGgiGI>6b9uq!gQ03TJEkEz2(Y z{Cz|26KyX1ruy$2^79(AzXS7aM{5SU+rl+MJsIjj>OTOqoP_IaH?%2G6F5usL9jSo zUeyiGyZoDu_0u`N60(}d{?YZw`+61jTgh#*RZip3^#gTEmw2G-J!1E({SV*%^>e)k z7(o!FoW9AzuS9~vNMv>OWBw#~3zLCvHDaoTfRMvLVOv)RCHBG&+q<%E$i_@P$Pw2& zb_IY_v!Ew&2{|DFgBtf0J|FM0_|HY8yW`ULrjG+|IPh@(`x=54!3+(bD<7`$F}tGX z=dkqaz4t&%6eC|c@}(XkKYe2dQ8%3yW!zFg#Q#mPUwPBEdLN0ju8_shvl|!tp2EEy zy=+;;MxV6ZPO-BeM*g}1j8o2Jkg`I~t1$49O>^EuJ9Y17L;Po$erZu`+NIu0Pqk;{ zCmUbgw3n+3i!z&K56TB&bHG6I=lzf3tB=NAdAxRS_^Oj)>eR%{+6qre{uSS(rFzTq z4f>?owD0g4v%hVjbX3ISqYYUO!mm)D*CK>wc7a5~pPrRbG>j52y2~v?-l;IdEy$gP z>H~2qLz|Q@6+!d;9D2O9SO1zg-gOE6+aSwij+g2wU+3EeoPA|_wA3}{RF&t^g)C`r zBfXe!o#-lYlt9I*OEWLrKS-^d*a0@qMeqfcjgCFL2V11hhT!)Vez33)F+ZYDhbWG! znfH6s!VlcU+&9;R(*0e??X|QSMatuD!~fhtT$3u=5CcU&h;py5>I39pFH@1h@;c0V zsI?cAv3+Cy zuX$CJ>EZey$;uDD^*^62F0T$DXiA`&!!ZcGwbgMY&}}P&P1g4T2bbBar@*m?3l0wK z1#|8MK+)-F$gi)z^zks7E0(aHJ7 z%rCNH+S=VxT(A7Og3hOxF?7|L`b@%FT(EQBxrhK$ZXYFz6B}QDO^F4!C=d&mc5co4 z=k@73d~NolDICuFUxz2KA}uW^HJ`EE`S=#p7=5rQ*81A3Itfeg1ZVuEJgM{lJdIb< zEBp9sJ049p#zK)*D8VzP{y6dS89QRR8f9 zpi|vl)V>Cx!~>yt^&^FbCjK}0t{;a?j+;*5kKmR+5L)!-JW{W_0z!A1Qx`Ulogf{O z0as=^tHy{Gs&NSw*jFv0^lSn`Ba?xNudmoai61MxSK4v_rhCj&#d3H^{=VPS`^UgU zXzQStd+Bz^<};4-`ftCTcpadzBo-lZ7?d&2rH!8-e0N&~FYE+V(+;9rt^1kn<0516 zL^1ouzr$d<&sk@S&%<(I!`QD03se7&@wkJxADE>-%~01gW-*h*qweL9*?euZK*`S9f+0`B>`ACO>t;A+`DhG_9}Q|S5nGT6u-;k? z#XyvV^P3%SKusONLwEl%Wdt)b4w=&OkF(WMKfk%(BXc9SF#MrWD|$zRV&(!oISko$ zezVeA?A+SUOmwttH^RN`LbvZF`}jTHQB&ml+671oF7bWM07LW#Y2PA1O2*|5l>;^%V3ywc>eX=bxpQ|Rlf=6y zLEXl3WQBEzt1+?s*1elpy2dk(Z`;nj|IzMUr6B)Sf}hkY7Ast+y-7Y}ZQOX|S9BOu z*Wv&M*dHF#aMS_A`oVPGzRw^T9037Wccy{j)ThNtcrHRtiC-sLQ6mT7!9s|(vZNni z4K*N%U~H`cEiOL&Hq%Xt1C?I>eYGR2HdmPKmpK6X%F5(C^@ri`Y^;IeM$tA6fU)u_ z5f*Jq8ZkHckwD+Q(3$B5e(5@(q9q}#!g@ac;GbQNkf56vBw-+PjGK~nfk`yOh{RyI z=_lCq2LsVa?MMz1rXu}hv-+?Hoz}Z(t_he)dk=fuE#@a55@j!rD!Ibv9%c<@*y0L> zm4od(d+jndIV#<1TJyzidU&3dYo0Uy1tb0H;SPs1zMuOjDTue^o~sqz5!;`MdX(v1 zQPLgzW4DX>!)0%*vGL@^2j5T)C}#}^XISrnGaZnoSIK=NW89B{LP2#oSyVE%hq1|D z7gTjMI$lbocjfrQJPcQ(vpqUgJ7sS*nIOuH?5-|IPvq6&=l=Wdg;?_@fH3u@$YCU{ z_0ne087c}Wd5~Q}@ucSbY7=R!BVvQ1u$hq!%P{sH_dj%Q)5i*6iwl9gHD2m|@J;XE z4dx%XtUWEQrpdz)76bU1MWtFMf&UQ2g@F=DfiU?lc+%_>5%GJeUXKNf&kec`^xpe` zM4n)y219au7u5Teg7r|A6E=3O&#Iz2KOb25?8Y{U63iDCT6|yCmM!*2wtKEDyi)-r zP;F`*(3l+##K(lJfRA$)M4sjn0j%+=VQKC1Wg$|? z+OXxNb3vzs8L})i-q^7kD?QI3C}9$XwQPRGs|B!JT$#SGbp_LTYU_b63d@6!!H2wc zESjr3b3`$1!Xy9;8F9jt9n_-;Kb4XC-v)39!CM>8i%zeBeOe!+rTAEr1RKsxL5jWf zJ$gE0NW|D@XWPiKF^2Lr`dL$=L zoCNvg+xQ9#<9nY<+`_TOKA1RnbcU@gM$p~VC`k15XmJj?OIF(#X1xy*I;Q<@Ei@*f zRdB?G(TD?*TvC`egOZcuS!6tFz~a72hc#=3YS;b221YayT=#aX&hLUqD?T3jM$~Po zP%v6ScufHnvCPK@ZEm-b>3gJdN%vseO!URM+pm}gU+Z{Wqn5R!kn5VNyj+7Lr^g~x zTBRq}Pz^+L3n3~``xR3th;66Ch>fFo%6V!ET~9BL&$WQaAgVg|sxDRNNQ2(ovYy*; zHJ60`A?oF%B1r3iY4CijY8%fAh?xbV4 z=BEgK_&$0rGu^?t>=0uM4@-~%Dj%#2^IlmRGY7wQNy^Hb5BKCi9?yFzBla;mbtt+l zx2rTf7NUIU-L-=(V=nM_XlD|FZa(A_?5$IJJx$i*(K&RI)3^4g_t&Y0HA#%PCVANZ z#g5|L2-C}M^_@?d{;}xU$ezs#sdh*R^~~i!o_=pdY!&L~Th25qjetVg_wmbhd%hB; zjSP>%;=CKb*Ep>4$UFxup{?rQ--6FVT|YAMrT=^_gx0eOs2JqM;hC9)CkRm|Rv8#G z=3oi#E^d6PyDlxImaF3-2aKMyz}``Dl-m3DtPjF%^=19Pegi9Mr=jtJa?YHH2H9g& z_j33$gFjd9&NKDes)*ZigTkF*ZKcMAcdqBjC4w8fGF*bT>tMuN*!YO$Xa`}5D-b$= z(G+2l$ccNr&iBt%-R21s&#C?8BA>&gdB^0ifv1Hnqb2wPsmG-9LQ=FTosU#l6o|*Q zgIv${bCW18zL4%WT^cNeG5WRt?lXrtbOS}PA8IW50|swgJ+J_r=l;?3qPJhZ4Tc2M zDNi#GPwGxK&C3D@&t?gWGsqF@>AiF|AAj;GX<%CxeU3)IQ~RJslzEdnNN!T5KJ%9@ z(4*!?E-*JH-f}Wi>&|o@32kq;9p+IzKI=GH;Ou|N{h3OG>u5n}S=$Q8?3V7}Kz3z1 zYtcS~R;iV+H`pFYhXOP2i7N8f#%%84n0Y%v3+{5($>E&<{dN0}H=8tzS@>Mvu^0Va zxRI<-j~oy)-wYvLAix4n#UU&mS;-_Y^F=eoDc|=~rJy_?su$LNy!{XrcS1AcikXsL zde4CkCB%ykSnHRwik_w*J}JtcJcuV|;2s}3T8|ir-W>s$Hgvz_=N#%(+`=Tkny=k+ z7cC3%t>mmyJFVbWtg#)43hXRJ7t5LcVRL1up+ExFczJ&K+F=2AR#*A&y{b=3_c1rb z%Nm2p&{}RixCk-khOc@z&u0w*_k7bX{tK|57jv!^2Vn5^?{r~{hec#q8b%0w`_i2a zPeJ83pgh;!`dDMM;tBR0r}=qp`{+VLToMJ9c|AKMa3&449itm1E;jFC9}>5T8nrbosp?|;;Z zO79(5b1(WHy&RWcTt7XNx#`@d8)Wd4gFGiGXfD0|2JF3R1pzZM3@X6aOHPQ3ZMo=Q zKP^{V}RmX_qLA$WnFNbdT)c!oo#Jp3}ils?xrt;2JNJ7#Xbe6InwUf*G(i=b* zCj-Z;ybZ>3=Od7u(@+RbNgH*SsaM%asA||!u6@Ww{)Wf;94L_$U^%-s{I-j8x2MZe zf(?UiPA<;iVUwmaL-yI7(!TMC3|%gR#b_r`)*Y8}Zj^@Bph_+{u6uKYl?q z8G{k$dYqP{{|J&DQMY@}Hc8Z0oDDy`Rnv<8HKGC`C}?z(H~Qo~x!~~aR`1Pj|2`HqggnWb$=p^J7k#SGOXq=p8|6Mj%}b`KP^0?mZ5$+H$4Qs zbliVl6KjTUV*4*B!AroLqqq5j#1WgNgpvg<6ORemyVT%^bQq0tq}4z#;Mq8!SUGUKhL{L;{3|CUrx9 z;!BHk3Gk{0a_Qd`7!LbbNEQde^oeb}` zaFW?y{b2NzKmnfUaL?)kSM}iNk`@ugz_VRXyb0|CC~OMe{ZVHaWWFzab<%dQ_b<4S zKnx1Gs&nF&nuO9F7QyYMhUe-sPEw=I)$m#JMZcP{*D&5dzoR8l#KRm`e3vR&9CPf} zx065zxU^=d?}+P7e|vTAC}1eBG7tR@HT>9_e)S)Q@BuVKvorn4VK^84>6g(-JLuvp zM4oS}-@{qEdSp1;J0PPg9YtSZ-`fq_9ou?mNWwDyAU%#cb-{J zGmS!-h03|qn|s8OY9_H$4D31DoTQY~p|c-Te-k&O`^PPwhb#`7bpr8HNu#9RW|WQ$ zY^95<>{6Xayv&TS#>d@<{-T+#!~T59vz!(%OXIF8k+_7eRAli)CZ$^Vp#=Y4wZ z1C8a+=Uzera_7jM;`=4H2}CsY!{&CX0jk5iujqO=Ws=5Z-5!#&kQ%k=z}sQ}LwXIN z5g*`#nBznxsN>x;JQc#f$t;ftVn2o4q{EJ7OU&`x&^%Y%*+jXq?(I>$- zp9xNLb)j4OW&zr(Ya+#2C`t7jv%bhmiiGwShqy38c!}}syoJ2L#N#bVK-2Xd_A(y; znvRa0Te%$Nl;R&-JvZqf&|)}jn(}ebaAWn+mw%062@nAgE=r3X9jd>Trg0omMgvjK zWrB$q8`qq%?a^-n@ZRvp?sPy})o@AjDBI=a=d!mu2M^{}APOqXXn&cTz3>VJ^a6Iv zpPj3{_-dkB1ZBL8D4Y3J(kk`G-_4_5z);3=A55AeClE zy(N*4>Kd*C_8I7ibfMRT+QelUVTTm+!zF1|^H7GPqx)0#fSza}5j~6>2}a2wk7lMD zBwxe^F9ws=^}}YC(_J}gzGCpD-jMzBAjmL9u{}c^ShL&g=$4Cu2*m`V8@}b-UVHn& zQh3KyqxA!J8BNQq!BwpTDzuEXBu*kZ2qM_iR zo+*Ief*Six2BeF&n&;D8B6@)0(kC_CSHOrLiMbM9hpijRbN(@Ee@w?(0M0G!K$F?s zKlA(dxM<2T22fZ)oW|#R_#)4NHBhsF2|75-ysZ`r>4_42T3b2#l(y-^|VD$ap5 zcI{SqSNRqLN@IsDm zjBWDq$PXRdRZoIERC%&TO%sTUCg3$_sUUXghP+03K>D~9$pvQ_Hf@$i<23+#G6kZP zTONfa(0Av7r^#;uqAP7PE`dvEkHs1u-nw>i1VYvb>d;*soM7jE)IbT;t2Bv}3)u8t z)cZ+$tsjtKnE(b_W@`j)(|8k-3InEi^oiC-=}U$voe5PXXryi!1M-COT-Hy+K?~J) z-9iX`zhAmUi4i0v{KYRHI`-Qew+gQYv)hT5^-l0`w%

_s@ww_uR-y65t+B( z;`_JxZZcl=N$Hmpj)v+ZL4Qp3m0YSZ{}cqSZdvz4j;)6L82r^3MLhW(VCUu5x+I2* zZ4fVdHlZ0XJh+AAAd<(%Dtc0gexK#Qd~vF!4H8)*D*tpA%<78}fyyN8Qr$KIXhAsP z%LzYNXnw1=>adfD_{H5&({Pb4@A`RiG9NS3irTu-sL!w;OE0?rC!Rboc_q4@d>5nQ zHze<4-NH#zAHWtO6VkZN+Lt~@${fTv!Tu+G5)&@q*m@VTInmc;TJxsUv1yW)-<}CX zMTwDuD>*BeI0iQP?;~LBxT)j0%H;EhQ?)BS5;2OeP^4#PGk+or@3T9|+!bjZL2w|( z{cbo2APa=$-)UYfVVEU7A7X$Pr|GgU#87M6AYHR8!wMmSN#9n995iUZ7tL!e&DBZN z`oKRKcd>-OEh>h-M>B}N{p+wV6hdSn`R`)_Bn}c|&$dHGe_HZrsgnO2Q=at+Dqr7= z*Wq=WpeBoCOfW4I#1z{&rz~~e!%F_1>j;Cq7S%Tb$)Z~Ft+=0jioujp-3|844&RML z$}vwCsZThl80>LKwHsTHVA{;fEaI_`>b*&tU&Y%P_5%wV=u1O=SICDtp2Ed;NpH{5 z4YQ+o57Y;|p8l5;&rEi>@6sQS8&_LQu{{h#dW^0_qV8I$f8&=&-Sc$e$|%qF>PwLV zkt{i9=kj?UAO}N6DJ<#vNXoTGUecH7tU;8vMTP=QYH0NWT+W_7 zyMEXWaBxW_K!UpMsxeh&P)Mn3|Kg*G%MuAnn5q3Q8D4u=|M5sDN&TmTd;r2rDjB|T zQ`=&LZ6We~IV}{Rn!ajSfIrMd$Je8>0MTm7I)qK7e&d#D7undS?sC6+uluLj;qY5&S%54H9_z( zt%}IP?qEviO={E5nT$sP9G|1`vsMw}JP4Wr*>|xYo8leFk^!lPS#I&P^9Pw?-kvvO zjfNEhVnMUz&rB}XK7jr zzj*Q*AEIA(%?k}L^)AYDG^KsJkdTGNTMo2+dAq;kavh}DBpKvr4ff)RW!+DELFrn6 zJtFHtAWA>5fP%E)rRcac4@R8L{)!}8ixJ-w=rQa$Q2%zF>|nAA!x|&i{OPp*@u7xE z1^CWHNi0*M*V8?=x38l;#2mvx3Jfd!$A|s%L^xv>U&H57Mrl8zu;M@PB4jwr63&;QGjNLmc_4q% zbuTyZSYG^D4kD?bh%|=?2#R5g-#-)DoT;`Fp4FAYu}h1)_mVH=H4YT0V~OAnJ09?eFA!`HCSF^g5u zl%<1OFL-dBu2TEm(SAxl+d>Mz$d2g?{*)l9KoX2PBaFe)tKe%1NzGd)PVUHfF=L-_ z==RHax2h7oIyxz5W3sqlMkOaSH=Q(-IlpvTA@o$FEM0y_-ifU(c!gKG@7qq@MlF3@bi0=AQ%2O~$%4l_UfCHTZg1bWRgAxvxQVxRf$~St=EOtauOQp zCXU_}A360#p_$e4M*sK1`)_W29+z{sAXjW)HPK^qnMUTn4>pGhv~48dllb?RLk~PS ze*gI0ZmjsD!JF_?j?vWh$@P;vc!M)!Vuz31`H54-EyT`;V?^d7qnGC&@gwlZWVfZk JEq#y3{{=|1&L;o> literal 0 HcmV?d00001 diff --git a/smithers/ml/tutorials/images/structure.PNG b/smithers/ml/tutorials/images/structure.PNG new file mode 100644 index 0000000000000000000000000000000000000000..e6de9dfa0d9739b56ced0d1cac057382686f03ba GIT binary patch literal 7270 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 WalHE`3ixjjblB#Yb+OfnYySg#^<{|w literal 0 HcmV?d00001 diff --git a/smithers/ml/tutorials/images/structure_img.png b/smithers/ml/tutorials/images/structure_img.png new file mode 100644 index 0000000000000000000000000000000000000000..dba166c2764a629373f1f9f96981bde6df703910 GIT binary patch literal 5000 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 N9Xy8Uu0}=d{~tDy)H(nF literal 0 HcmV?d00001 diff --git a/smithers/ml/tutorials/pascalvoc_preparation.ipynb b/smithers/ml/tutorials/pascalvoc_preparation.ipynb new file mode 100644 index 0000000..680833a --- /dev/null +++ b/smithers/ml/tutorials/pascalvoc_preparation.ipynb @@ -0,0 +1,320 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# How to prepare PascalVOC Dataset to train an object detector" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Gathering Data\n", + "The PascalVOC Dataset used is composed of two different datasets from the years 2007 and 2012: VOC2007 and VOC2012. First of all you need to download the datasets from the official webpages:\n", + "1. VOC2007: from http://host.robots.ox.ac.uk/pascal/VOC/voc2007/index.html#devkit select ''Download the training/validation data (450MB tar file)'' in the Development Kit section and ''Download the annotated test data (430MB tar file)'' in the Test Data section.\n", + "2. VOC2012: from http://host.robots.ox.ac.uk/pascal/VOC/voc2012/index.html select ''Download the training/validation data (2GB tar file)'' in the Development Kit section.\n", + "\n", + "\n", + "The two trainval datasets, downloaded from the Development Kit section, are to be used for training, while the VOC 2007 test, the one taken from the Test Data section, will serve as test dataset.\n", + "\n", + "ATTENTION: Both the VOC2007 trainval and VOC2007 test data has to be extracted in the same location, e.g. download the datasets and then merge them." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Structure of the Dataset folder - Pascal VOC \n", + "Once you have downloaded the aforementioned datasets, you should place them in the same folder. Hence, inside the main folder 'VOCdevkit'there should be two subfolders 'VOC2007' and 'VOC2012', where each of them contains five subfolders: \n", + "1. Annotations: Inside this folder there are the PascalVOC formatted annotation XML files, that contain relevant information for the picture under examination. Hence, there is one XML file per image. Each XML file contains the path to the image in the 'path' element, the bounding box stored in an 'object' element and other features as can be seen in the example below. You can note that the bounding box is defined by two points, the upper left and bottom right corners.\n", + "\n", + "\n", + "\n", + "2. ImageSets: Inside this folder there are three subfolders: 'Layout', 'Main' and 'Segmentation'. In particular in the subfolder 'Main' you can find the images of a specific class that belong to the test, train or trainval subdivision.\n", + "3. JPEGImages: Here there are all the images, that has to be in the JPG format.\n", + "4. and 5. SegmentationClass and SegmentationObject: folders containing the segmentation masks for some images and objects.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data pipeline\n", + "Once you have the correct structure of the dataset, you should divide data into training and test splits. Data should also be saved in JSON files in order to be used inside the PyTorch Dataset class that will be created later for this purpose.\n", + "\n", + "### Parse raw data - Creation JSON files & splitting of the dataset\n", + "Run (and see for more details) the create_json.py script you can find in the dataset folder. When running it, you need to provide the paths to the VOC2007 and VOC2012 folders, as well as to the desired output folder where the JSON files should be saved.\n", + "\n", + "This script parses the data downloaded and returns as output the following files:\n", + "1. A JSON file for each split (Train or Test) with a list of the absolute filepaths for each image in that split.\n", + "2. A JSON file for each split (train or Test) with a list of dictionaries containing ground truth objects, i.e. bounding boxes in absolute boundary coordinates, their encoded labels, and perceived detection difficulties for each image in that split. Therefore, The i-th dictionary in this list will contain the objects present in the i-th image of the split.\n", + "3. A JSON file which contains the label_map, the label-to-index dictionary with which the labels are encoded in the previous JSON file. This dictionary is also available in the script (create_json.py) and directly importable.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/scratch/lmeneghe/Smithers/smithers/ml/VOCdevkit/VOC2007\n", + "/scratch/lmeneghe/Smithers/smithers/ml/VOCdevkit/VOC2007\n", + "/scratch/lmeneghe/Smithers/smithers/ml/VOCdevkit/VOC2012\n", + "\n", + "There are 16551 training images containing a total of 49653 objects. Files have been saved to /scratch/lmeneghe/Smithers/smithers/ml/tutorials.\n", + "\n", + "There are 4952 test images containing a total of 14856 objects. Files have been saved to /scratch/lmeneghe/Smithers/smithers/ml/tutorials.\n" + ] + } + ], + "source": [ + "# %run ../dataset/create_json.py path_to_VOC2007dir path_to_VOC2012dir path_to_outputfolder\n", + "%run ../dataset/create_json.py ../VOCdevkit/VOC2007/ ../VOCdevkit/VOC2012/ ./" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining a PascalVOCDataset class\n", + "\n", + "In order to use the constructed dataset properly, we need to define a subclass of PyTorch Dataset, called PascaVOCDataset. For more details about the implementation see pascalvoc_dataset.py in the dataset folder.\n", + "\n", + "\n", + "The PascalVOCdataset class has been defined to detect your training and test datasets from the JSON files created above. It needs a __len__ method defined, which returns the size of the dataset, and a __getitem__ method which returns the i-th image, bounding boxes of the objects in this image, and labels for the objects in this image, using the JSON files we saved earlier.\n", + "\n", + "You will notice that it also returns the perceived detection difficulties of each of these objects, but these are not actually used in training the model. They are required only in the Evaluation stage for computing the Mean Average Precision (mAP) metric. We also have the option of filtering out difficult objects entirely from our data to speed up training at the cost of some accuracy." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, '/scratch/lmeneghe/Smithers/')\n", + "from smithers.ml.dataset.pascalvoc_dataset import PascalVOCDataset\n", + "\n", + "keep_difficult = True\n", + "\n", + "# data_folder corresponds to the output folder defined before, where the JSON files have been saved\n", + "data_folder = './'\n", + "#data_folder = '/u/s/szanin/Smithers/smithers/ml/tutorials/'\n", + "# Load train data\n", + "train_dataset = PascalVOCDataset(data_folder,\n", + " split='train',\n", + " keep_difficult=keep_difficult)\n", + "\n", + "# Load test data\n", + "test_dataset = PascalVOCDataset(data_folder,\n", + " split='test',\n", + " keep_difficult=keep_difficult)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extract smaller datasets\n", + "If you want to test your model against a smaller dataset than PascalVOC, you can exctract a set of images from the original PascalVOC using ***sample_dataset.py*** in the dataset folder.\n", + "\n", + "You can thus extract a dataset composed of N images divided in M classes, where N and M are less than the total number of images and classes composing the dataset under consideration. For example, we can create a dataset composed of 300 images of cats and dogs." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "%run ../dataset/sample_dataset.py" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now have to split the subdataset in the train dataset (e.g. 80% of the total) and the test dataset (e.g. the remaining 20%). To do so we use the same procedure found in the splitting section of the tutorial ***customdata_objdet***.\n", + "\n", + "We first create the directories and files needed.\n", + "\n", + "Below, after the first ``cd`` command, insert the path to the folder created using the previous cell, in my case this is\n", + "``/u/s/szanin/Smithers/smithers/ml/tutorials/VOC_dog_cat/``." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "( \n", + " cd VOC_dog_cat/;\n", + " touch datafile.txt;\n", + " mkdir JSONfiles\n", + " mkdir ImageSets;\n", + " cd ImageSets;\n", + " mkdir Main;\n", + " cd Main;\n", + " touch trainval.txt;\n", + " touch test.txt\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we populate the datafile.txt file with the names of the images we sampled.\n", + "\n", + "Beware that:\n", + "- in the ``datafiletxt_path`` variable you need to insert the string containing the path to your datafile.txt file we have just created;\n", + "- in the ``jpeg_path`` variable you need to insert the string containing the path to your JPEGImages folder of the reduced dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "datafiletxt_path = 'VOC_dog_cat/datafile.txt'\n", + "jpeg_path = 'VOC_dog_cat/JPEGImages/'\n", + "\n", + "# If you are using Python < 3.9 you need this function to remove the \n", + "# suffix jpg, otherwise you can uncomment the lines using the\n", + "# removesuffix function\n", + "def remove_suffix(input_string, suffix):\n", + " if suffix and input_string.endswith(suffix):\n", + " return input_string[:-len(suffix)]\n", + " return input_string\n", + "\n", + "with open(datafiletxt_path, 'w') as datafile:\n", + " dir_list = os.listdir(jpeg_path)\n", + " num_files = len(dir_list)\n", + " for element in dir_list[:-1]:\n", + " datafile.write('{}\\n'.format(remove_suffix(element, '.jpg')))\n", + " #datafile.write('{}\\n'.format(element.removesuffix('.jpg')))\n", + " datafile.write('{}'.format(remove_suffix(dir_list[-1],'.jpg')))\n", + " #datafile.write('{}'.format(dir_list[-1].removesuffix('.jpg'))) # the last element added does not need the new line characters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following cell will construct the .json files relative to the smaller dataset sampled.\n", + "\n", + "Beware that in the variables ``train_file``and ``test_file`` you need to insert your own paths as follows:\n", + "- in ``train_file`` insert the string containing the path of your trainval.txt file we created above;\n", + "- in ``test_file`` insert the string containing the path of your test.txt file we created above;" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy\n", + "from sklearn import datasets, linear_model\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "train_file = 'VOC_dog_cat/ImageSets/Main/trainval.txt'\n", + "test_file = 'VOC_dog_cat/ImageSets/Main/test.txt'\n", + "\n", + "with open(datafiletxt_path,'r') as f:\n", + " # in Windows you may need to put rb instead of r mode \n", + " data = f.read().split('\\n')\n", + " data = numpy.array(data) #convert array to numpy type array\n", + "\n", + " train ,test = train_test_split(data,test_size=0.2) \n", + " split = [train, test] \n", + " # the ouputs here are two lists containing train-test split of inputs.\n", + " lengths = [len(train), len(test)]\n", + " out_train = open(train_file,\"w\")\n", + " out_test = open(test_file, \"w\")\n", + " out_file = [out_train, out_test]\n", + " out = 0\n", + " for l in lengths:\n", + " for i in range(l):\n", + " name_img = split[out][i]\n", + " out_file[out].write(name_img + '\\n')\n", + " out_file[out].close() \n", + " out += 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will now create the .json files relative to this datasets and save them in the folder JSONfiles, inside VOC_dog_cat." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/scratch/lmeneghe/Smithers/smithers/ml/tutorials/VOC_dog_cat\n", + "/scratch/lmeneghe/Smithers/smithers/ml/tutorials/VOC_dog_cat\n", + "\n", + "There are 240 training images containing a total of 720 objects. Files have been saved to /scratch/lmeneghe/Smithers/smithers/ml/tutorials/VOC_dog_cat/JSONfiles.\n", + "\n", + "There are 60 test images containing a total of 180 objects. Files have been saved to /scratch/lmeneghe/Smithers/smithers/ml/tutorials/VOC_dog_cat/JSONfiles.\n" + ] + } + ], + "source": [ + "%run ../dataset/create_json.py ./VOC_dog_cat/ None ./VOC_dog_cat/JSONfiles" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + }, + "vscode": { + "interpreter": { + "hash": "8c5bf16c94eb6f9341fa612a12f652937166e39821fa969ec7095b77ab48ffd1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/smithers/ml/tutorials/pytorch_to_tensorflow.ipynb b/smithers/ml/tutorials/pytorch_to_tensorflow.ipynb new file mode 100644 index 0000000..ca14225 --- /dev/null +++ b/smithers/ml/tutorials/pytorch_to_tensorflow.ipynb @@ -0,0 +1,312 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "JCxgG6QoZ7qZ" + }, + "source": [ + "## How to convert a model from PyTorch to Tensorflow \n", + "In this tutorial, we will describe how to go from PyTorch to Tensorflow using ONNX, an open ecosystem for interoperable AI models (https://github.com/onnx) Thus, following the tutorials on https://github.com/onnx/tutorials we will convert our model from PyTorch to ONNX and then from ONNX to Tensorflow." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5RRClxtos8EV" + }, + "source": [ + "## **Installations**\n", + "First of all, we need to install ONNX and Tensorflow and the necessary packages.\n", + "\n", + "**To install ONNX:**\n", + "\n", + "> conda install -c conda-forge protobuf numpy \\\n", + "pip install onnx\n", + "\n", + "**To install Tensorflow:**\n", + "\n", + "> pip install tensorflow-cpu \\\n", + "(pip install tensorflow if you need also support for CUDA-enabled GPU cards)\n", + "\n", + "Next **install onnx-tensorflow** by the following commands:\n", + "\n", + "> git clone https://github.com/onnx/onnx-tensorflow.git \n", + "cd onnx-tensorflow \\\n", + "pip install -e .\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sK4wBKUsvyf-" + }, + "source": [ + "## PyTorch Model\n", + "Starting from the model you have defined in PyTorch, you need to train and test it. After this, you should save the state of your net in a file, that will be used for the conversion." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "ClsqK3ObxDMv" + }, + "outputs": [], + "source": [ + "# PyTorch Model\n", + "pytorch_model = Net() \n", + "# Train and test the model\n", + "...\n", + "# Save the trained model to a file\n", + "torch.save(pytorch_model.state_dict(), 'net_pytorch.pth')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xu5VaFvaxnRv" + }, + "source": [ + "## Export the trained model to ONNX\n", + "In order to export the model, Pytorch exporter needs to run the model once and save this resulting traced model to a ONNX file. Therefore, we need to provide an input (a random tensor with the right shape) for our model. \n", + "\n", + "In our case we consider a net that takes as inputs RGB images with shape (1, 3, 32, 32.)\n", + "\n", + "ACHTUNG: If in your net there are average pooling layers (**AdaptiveAvgPool2d()**) (e.g. in the standard VGG), pay attention that this is not supported by ONNX. Thus you need to add the following flag in **torch.onnx.export()**\n", + "> operator_export_type=torch.onnx.OperatorExportTypes.ONNX_ATEN_FALLBACK" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "h4sV1FyHxtba" + }, + "outputs": [], + "source": [ + "# Load the network\n", + "net_pytorch = Net()\n", + "net_pytorch.load_state_dict(torch.load('net_pytorch.pth'))\n", + "\n", + "# Export the trained model to ONNX\n", + "dummy_input = torch.rand(torch.randn(1, 3, 32, 32)) # random input for the model\n", + "torch.onnx.export(net_pytorch, dummy_input, \"net_onnx.onnx\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ttSacDddrLc-" + }, + "source": [ + "For a graph version of the onnx file you can use a ONNX viewer called Netron: https://github.com/lutzroeder/Netron." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lmGyuqSOrdJY" + }, + "source": [ + "## Import the ONNX model to Tensorflow\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 368 + }, + "id": "iSGl9I2Wrv-Y", + "outputId": "010b7444-0d43-4fb9-ea80-d10ddd343c38" + }, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "ignored", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0monnx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0monnx_tf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mprepare\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# Load the ONNX file\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mmodel_onnx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0monnx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'net_onnx.onnx'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'onnx'", + "", + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0;32m\nNOTE: If your import is failing due to a missing package, you can\nmanually install dependencies using either !pip or !apt.\n\nTo view examples of installing some common dependencies, click the\n\"Open Examples\" button below.\n\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n" + ] + } + ], + "source": [ + "import onnx\n", + "from onnx_tf.backend import prepare\n", + "\n", + "# Load the ONNX file\n", + "model_onnx = onnx.load('net_onnx.onnx')\n", + "\n", + "# Import the ONNX model to Tensorflow\n", + "tf_rep = prepare(model_onnx)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OZmElsMAr_Al" + }, + "source": [ + "In order to understand if we are converting correctly the model, we can explore the *tf_rep* object return from *onnx.tf.backend.prepare*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "F6fpSvFAr9wP" + }, + "outputs": [], + "source": [ + "# Input nodes to the model\n", + "print('inputs:', tf_rep.inputs)\n", + "\n", + "# Output nodes from the model\n", + "print('outputs:', tf_rep.outputs)\n", + "\n", + "# All nodes in the model\n", + "print('tensor_dict:')\n", + "print(tf_rep.tensor_dict)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BC-DBBrfsPbz" + }, + "source": [ + "## Run the model in Tensorflow\n", + "After converting the model to Tensorflow, we can run it by taking an image with the right shape and format for our net." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "8TzPK5nbsTHl" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "from IPython.display import display\n", + "from PIL import Image\n", + "\n", + "print('Image 1:')\n", + "img = Image.open('image.png').resize((32, 32))\n", + "array_img = np.array(img, dtype=np.float32)\n", + "print(array_img.shape)\n", + "array_img = array_img.reshape(1, 3, 32, 32)\n", + "print(array_img.shape)\n", + "output = tf_rep.run(array_img)\n", + "\n", + "\n", + "print('The image is classified as ', np.argmax(output))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "x24zhUP2u7Bk" + }, + "source": [ + "## Save the Tensorflow model into a file" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "k_rNJHmDu8Hk" + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'tf_rep' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtf_rep\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexport_graph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'net_tf.pb'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'tf_rep' is not defined" + ] + } + ], + "source": [ + "tf_rep.export_graph('net_tf.pb')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conversion into Tensorflow Lite\n", + "Conversion of the Tensorflow model to Tensorflow Lite. There exists some operations that are not supported in Tensorflow and also that are not present in Tensorflow Lite. You can find a complete lists of them at the following link:\n", + "https://www.tensorflow.org/lite/guide/ops_compatibility.\n", + "In order to overcome this difficulty (if you do not have restrictions on your running environment) you can uncomment some of the lines below to complet the conversion. You can read something more, also on how to include then these operations in your environment, here:\n", + "https://www.tensorflow.org/lite/guide/ops_select" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "converter = tf.lite.TFLiteConverter.from_saved_model('net_tf.pb')\n", + "# If some unsupported operations by Tensorflow are present, uncomment those lines.\n", + "#converter.target_spec.supported_ops = [\n", + "# tf.lite.OpsSet.TFLITE_BUILTINS, # enable TensorFlow Lite ops.\n", + "# tf.lite.OpsSet.SELECT_TF_OPS # enable TensorFlow ops.\n", + "#]\n", + "\n", + "tflite_model = converter.convert()\n", + "\n", + "# Save the model.\n", + "with open('net.tflite', 'wb') as f:\n", + " f.write(tflite_model)\n" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "colab": { + "collapsed_sections": [], + "name": "pytorch_to_tensorflow.ipynb", + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/smithers/ml/tutorials/reduction_SSD.ipynb b/smithers/ml/tutorials/reduction_SSD.ipynb new file mode 100644 index 0000000..d5b61d5 --- /dev/null +++ b/smithers/ml/tutorials/reduction_SSD.ipynb @@ -0,0 +1,829 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Dimensionality Reduction of SSD300\n", + "\n", + "In this tutorial we will present how to create a reduced version of SSD300 using the techniques described in the article :\n", + "\n", + "L. Meneghetti, N. Demo and G. Rozza, \"A Proper Orthogonal Decomposition Approach for Parameters Reduction of Single Shot Detector Networks,\" 2022 IEEE International Conference on Image Processing (ICIP), 2022, pp. 2206-2210, doi: 10.1109/ICIP46576.2022.9897513.\n", + "\n", + "and in the paper ''Deep neural network compression via tensor decomposition'' by S. Zanin, L. Meneghetti, N. Demo and G. Rozza, that is currently in preparation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports\n", + "We start by importing all the necessary functions." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, '/scratch/lmeneghe/Smithers/')\n", + "import torch\n", + "from PIL import Image\n", + "from time import time\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "import torchvision.transforms as transforms\n", + "from torch.utils import data\n", + "\n", + "\n", + "from smithers.ml.models.vgg import VGG\n", + "from smithers.ml.models.aux_conv import AuxiliaryConvolutions\n", + "from smithers.ml.models.predictor import PredictionConvolutions\n", + "from smithers.ml.dataset.pascalvoc_dataset import PascalVOCDataset\n", + "from smithers.ml.models.detector import Detector, Reduced_Detector\n", + "from smithers.ml.models.utils_objdet import create_prior_boxes, save_checkpoint_objdet\n", + "from smithers.ml.models.netadapter import NetAdapter\n", + "from smithers.ml.models.utils_rednet import get_seq_model, Total_param, Total_flops\n", + "\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parameters Initialization\n", + "We set the parameters used for the data, the detector and the learning phase." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "# Learning parameters\n", + "batch_size = 8 # batch size\n", + "workers = 4 # number of workers for loading data in the DataLoader\n", + "iterations = 120000 # number of iterations to train\n", + "print_freq = 200 # print training status every __ batches\n", + "lr = 1e-4 # learning rate\n", + "decay_lr_at = [80000, 100000] # decay learning rate after these many iterations\n", + "decay_lr_to = 0.1\n", + "# decay learning rate to this fraction of the existing learning rate\n", + "#n_classes = 6\n", + "momentum = 0.9 # momentum\n", + "weight_decay = 5e-4 # weight decay\n", + "grad_clip = None\n", + "# clip if gradients are exploding, which may happen at larger batch sizes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading of the dataset\n", + "In order to train and test our model we can use a benchmark dataset, such as PascalVOC, or a custom one. We are now going to describe our method employing a set of data extracted from PascalVOC, composed of images of only cats and dogs, but everything can be easily generalized ot the other cases. For more details on the preparation of such datsets and their use see the tutorials ***pascalvoc_preparation*** and ***customdata_objdet***.\n", + "\n", + "### Cats & Dogs Dataset\n", + "We use as training and testing dataset the cats and dogs dataset, composed of 300 images extracted from PascalVOC." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "categories: {'cat': 1, 'dog': 2, 'background': 0}\n", + "n_classes: 3\n", + "Training images: 240\n", + "Testing images: 60\n" + ] + } + ], + "source": [ + "# Data parameters\n", + "\n", + "voc_labels = ('cat', 'dog')\n", + "# Labels of the whole PascalVOC\n", + "#voc_labels = ('aeroplane', 'bicycle', 'bird', 'boat',\n", + "# 'bottle', 'bus', 'car', 'cat', 'chair',\n", + "# 'cow', 'diningtable', 'dog', 'horse',\n", + "# 'motorbike', 'person', 'pottedplant',\n", + "# 'sheep', 'sofa', 'train', 'tvmonitor')\n", + "label_map = {k: v + 1 for v, k in enumerate(voc_labels)}\n", + "label_map['background'] = 0\n", + "n_classes = len(label_map)\n", + "print('categories:',label_map)\n", + "print('n_classes:', n_classes)\n", + "\n", + "data_folder = 'VOC_dog_cat/JSONfiles' #folder with json data files\n", + "keep_difficult = True\n", + "\n", + "\n", + "train_dataset = PascalVOCDataset(data_folder,\n", + " split='train',\n", + " keep_difficult=keep_difficult)\n", + "train_loader = torch.utils.data.DataLoader(\n", + " train_dataset,\n", + " batch_size=batch_size,\n", + " shuffle=True,\n", + " collate_fn=train_dataset.collate_fn,\n", + " num_workers=workers,\n", + " pin_memory=True)\n", + "\n", + "epochs = iterations // (len(train_dataset) // 32)\n", + "decay_lr_at = [it // (len(train_dataset) // 32) for it in decay_lr_at]\n", + "print('Training images:', len(train_dataset))\n", + "# Load test data\n", + "test_dataset = PascalVOCDataset(data_folder,\n", + " split='test',\n", + " keep_difficult=keep_difficult)\n", + "test_loader = torch.utils.data.DataLoader(test_dataset,\n", + " batch_size=batch_size,\n", + " shuffle=False,\n", + " collate_fn=test_dataset.collate_fn,\n", + " num_workers=workers,\n", + " pin_memory=True)\n", + "print('Testing images:', len(test_dataset))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading of the model\n", + "First of all we need to load the full model we want to reduce (in this case SSD300) starting from a checkpoint file, i.e. a file containing the status of the model after a training process with a chosen dataset.\n", + "\n", + "In order to obtain a checkpoint file, the tutorial ***training_SSD*** can be followed." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Evaluating: 100%|██████████| 8/8 [00:03<00:00, 2.56it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'cat': 71.44593596458435, 'dog': 50.61103105545044}\n", + "{'cat': 71.44593596458435, 'dog': 50.61103105545044}\n", + "\n", + "Mean Average Precision (mAP): 61.028\n" + ] + }, + { + "data": { + "text/plain": [ + "61.028480529785156" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "network = None\n", + "check = 'checkpoint_objdet.pth.tar'\n", + "priors_cxcy = create_prior_boxes()\n", + "detector = Detector(network, check, priors_cxcy, n_classes, epochs,\n", + " batch_size, print_freq, lr, decay_lr_at,\n", + " decay_lr_to, momentum, weight_decay, grad_clip,\n", + " train_loader, test_loader, 'Adam')\n", + "detector.eval_detector(label_map)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Memory Footprint full network" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SSD300-storage\n", + " VGG = 78.14, Aux model nnz=9.38, feature_loc nnz=2.0395, feature_cl nnz=1.5296\n", + "The total amount of space required is 91.091 MB.\n" + ] + } + ], + "source": [ + "ssd_storage = torch.zeros(4)\n", + "\n", + "ssd_storage[0], ssd_storage[1], ssd_storage[2], ssd_storage[3] = [\n", + " Total_param(detector.model[0]),\n", + " Total_param(detector.model[1].features),\n", + " Total_param(detector.model[2].features_loc),\n", + " Total_param(detector.model[2].features_cl)]\n", + "\n", + "\n", + "print('SSD300-storage')\n", + "print(\n", + " ' VGG = {:.2f}, Aux model nnz={:.2f}, feature_loc nnz={:.4f}, feature_cl nnz={:.4f}'.format(\n", + " ssd_storage[0], ssd_storage[1],\n", + " ssd_storage[2], ssd_storage[3]))\n", + "print('The total amount of space required is {:.3f} MB.'.format(ssd_storage[0]+ssd_storage[1]+ssd_storage[2]+ssd_storage[3]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reduction of SSD300\n", + "We now perform the reduction of SSD300 using the module ***NetAdapter*** to construct the pre-model and the reduction layer. Then, we construct the reduced version of the detector using hte class ***Detector*** as for the original model. The Figure below summarizes the reduction method proposed, as described in the article by L. Meneghetti, N. Demo and G. Rozza, \"A Proper Orthogonal Decomposition Approach for Parameters Reduction of Single Shot Detector Networks,\" 2022 IEEE International Conference on Image Processing (ICIP), 2022, pp. 2206-2210, doi: 10.1109/ICIP46576.2022.9897513.\n", + "\n", + "\n", + "\n", + "Hence, we are going to describe two different methods for the reduction layer: POD and HOSVD, where the latter differ from the other for its tensorial approach. The input-outpu mapping, in this case, is not changed with respect to the original SSD300 and thus corresponds to two siblings predictors, one for classification and one for localization.\n", + "\n", + "It is important to highlight that in order to reduce the model we are not starting from the model loaded before, i.e. from the status of the model after the training phase, but from its status only after initialization." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Proper Orthogonal Decomposition (POD)\n", + "The first method we propose to reduce the network is POD." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Loaded base model.\n", + "\n", + "RedNet(\n", + " (premodel): Sequential(\n", + " (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU(inplace=True)\n", + " (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU(inplace=True)\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (6): ReLU(inplace=True)\n", + " (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (8): ReLU(inplace=True)\n", + " (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (11): ReLU(inplace=True)\n", + " (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (13): ReLU(inplace=True)\n", + " (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (15): ReLU(inplace=True)\n", + " (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " )\n", + " (proj_model): Linear(in_features=369664, out_features=50, bias=False)\n", + " (inout_map): Identity()\n", + ")\n", + "Time needed to initialize the model 5.08997368812561\n" + ] + } + ], + "source": [ + "checkpoint = None\n", + "init_time = time()\n", + "\n", + "base_net = VGG(classifier='ssd', init_weights='imagenet')\n", + "seq_model = get_seq_model(base_net)\n", + "cutoff_idx = 7\n", + "red_dim = 50\n", + "red_method = 'POD'\n", + "inout_method = None\n", + "netadapter = NetAdapter(cutoff_idx, red_dim, red_method, inout_method)\n", + "red_model = netadapter.reduce_net(seq_model, train_dataset, None, train_loader, n_classes)\n", + "print(red_model)\n", + "\n", + "base_net = red_model.premodel\n", + "aux_conv = red_model.proj_model\n", + "\n", + "# we need to modify the configuration of the predictor layers\n", + "cfg_tot = [256, red_dim]\n", + "n_boxes = [4, 6]\n", + "predictor = PredictionConvolutions(n_classes, cfg_tot, n_boxes)\n", + "network = [base_net, aux_conv, predictor]\n", + "\n", + "#create prior boxes custom for reduced net\n", + "fmaps_dims = {'premodel': 38, 'projmodel': 1} \n", + "obj_scales = {'premodel': 0.1, 'projmodel': 0.725} #0.9\n", + "aspect_ratio = {'premodel': [1., 2., 0.5], 'projmodel': [1., 2., 3., 0.5, 0.333]}\n", + "priors_cxcy = create_prior_boxes(fmaps_dims, obj_scales, aspect_ratio)\n", + "\n", + "init_end = time()\n", + "print('Time needed to initialize the model', init_end - init_time)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training Phase\n", + "Once we have defined the several pieces composing our reduced version of the detector (pre_model instead of full vgg, reduction layers instead of auxiliary layers, and the same predictor), we can train it." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: [0][0/30]\tBatch Time 0.435 (0.435)\tData Time 0.254 (0.254)\tLoss val (average) 3.4185 (3.4185)\t\n", + "Epoch: [1][0/30]\tBatch Time 0.386 (0.386)\tData Time 0.262 (0.262)\tLoss val (average) 4.0896 (4.0896)\t\n", + "Epoch: [2][0/30]\tBatch Time 0.369 (0.369)\tData Time 0.235 (0.235)\tLoss val (average) 3.8647 (3.8647)\t\n", + "Epoch: [3][0/30]\tBatch Time 0.403 (0.403)\tData Time 0.278 (0.278)\tLoss val (average) 2.3701 (2.3701)\t\n", + "Epoch: [4][0/30]\tBatch Time 0.430 (0.430)\tData Time 0.304 (0.304)\tLoss val (average) 3.9224 (3.9224)\t\n", + "Epoch: [5][0/30]\tBatch Time 0.363 (0.363)\tData Time 0.231 (0.231)\tLoss val (average) 3.1703 (3.1703)\t\n", + "Epoch: [6][0/30]\tBatch Time 0.399 (0.399)\tData Time 0.270 (0.270)\tLoss val (average) 3.5857 (3.5857)\t\n", + "Epoch: [7][0/30]\tBatch Time 0.384 (0.384)\tData Time 0.246 (0.246)\tLoss val (average) 4.0032 (4.0032)\t\n", + "Epoch: [8][0/30]\tBatch Time 0.392 (0.392)\tData Time 0.254 (0.254)\tLoss val (average) 3.6775 (3.6775)\t\n", + "Epoch: [9][0/30]\tBatch Time 0.292 (0.292)\tData Time 0.162 (0.162)\tLoss val (average) 3.5110 (3.5110)\t\n", + "Time needed for training: 41.57 seconds, i.e. 0.7 minutes\n" + ] + } + ], + "source": [ + "check = None\n", + "epochs = 10\n", + "start = time()\n", + "red_detector = Reduced_Detector(network, check, priors_cxcy, n_classes, epochs,\n", + " batch_size, print_freq, lr, decay_lr_at,\n", + " decay_lr_to, momentum, weight_decay, grad_clip,\n", + " train_loader, test_loader, 'Adam', red_method)\n", + "\n", + "start = time()\n", + "check, loss_value = red_detector.train_detector()\n", + "end = time()\n", + "print(f'Time needed for training: {round(end-start,2)} seconds, i.e. {round((end-start)/60,1)} minutes')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Accuracy of the reduced detector\n", + "We can now test the accurcay of the reduced detector against the testing dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Evaluating: 100%|██████████| 8/8 [00:12<00:00, 1.51s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'cat': 38.69142532348633, 'dog': 38.271987438201904}\n", + "{'cat': 38.69142532348633, 'dog': 38.271987438201904}\n", + "\n", + "Mean Average Precision (mAP): 38.482\n", + "Time needed for testing: 12.32 seconds, i.e. 0.2 minutes\n" + ] + } + ], + "source": [ + "start_test = time()\n", + "red_detector.eval_detector(label_map)\n", + "end_test = time()\n", + "print(f'Time needed for testing: {round(end_test-start_test,2)} seconds, i.e. {round((end_test-start_test)/60,1)} minutes')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Image Detection\n", + "By choosing a specific image from the directory used, the network is able to detect the object(s) in it and save a version of the image in which the bounding box(es) with the relative label(s) is(/are) pictured. To view this, open the file ``out.jpg``, as described below." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "img_path = 'VOC_dog_cat/JPEGImages/001825.jpg'\n", + "original_image = Image.open(img_path, mode='r')\n", + "original_image = original_image.convert('RGB')\n", + "\n", + "red_detector.detect(original_image,\n", + " label_map,\n", + " min_score=0.01,\n", + " max_overlap=0.45,\n", + " top_k=1).show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "out_img = Image.open('out.jpg')\n", + "display(out_img)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Memory Footprint reduced detector\n", + "We can print the storage needed to store our reduced detector. It can be highlight that, With respect to the full network, the space is slightly decreased, hence this type of reduction could be not the most suitable one for this kind of problems." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SSD300 reduced-storage\n", + " Pre-model = 6.62, Reduction Layer nnz=70.51, feature_loc nnz=0.1820, feature_cl nnz=0.1365\n", + "The total amount of space required is 77.447 MB.\n" + ] + } + ], + "source": [ + "rednet_storage = torch.zeros(4)\n", + "\n", + "rednet_storage[0], rednet_storage[1], rednet_storage[2], rednet_storage[3] = [\n", + " Total_param(red_detector.model[0]),\n", + " Total_param(red_detector.model[1]),\n", + " Total_param(red_detector.model[2].features_loc),\n", + " Total_param(red_detector.model[2].features_cl)]\n", + "\n", + "print('SSD300 reduced-storage')\n", + "print(\n", + " ' Pre-model = {:.2f}, Reduction Layer nnz={:.2f}, feature_loc nnz={:.4f}, feature_cl nnz={:.4f}'.format(\n", + " rednet_storage[0], rednet_storage[1],\n", + " rednet_storage[2], rednet_storage[3]))\n", + "space_rednet = (rednet_storage[0]+rednet_storage[1]+rednet_storage[2]+rednet_storage[3]).item()\n", + "print('The total amount of space required is {:.3f} MB.'.format(space_rednet))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Averaged HOSVD (AHOSVD)\n", + "We can now carry out the same reduction performed for 'POD' using 'AHOSVD'." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Loaded base model.\n", + "\n", + "RedNet(\n", + " (premodel): Sequential(\n", + " (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU(inplace=True)\n", + " (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU(inplace=True)\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (6): ReLU(inplace=True)\n", + " (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (8): ReLU(inplace=True)\n", + " (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (11): ReLU(inplace=True)\n", + " (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (13): ReLU(inplace=True)\n", + " (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (15): ReLU(inplace=True)\n", + " (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " )\n", + " (proj_model): tensor_product_layer(in_dimensions=[256, 38, 38], out_dimensions=[35, 3, 3])\n", + " (inout_map): Identity()\n", + ")\n", + "time needed to initialize the model 10.65 seconds\n" + ] + } + ], + "source": [ + "init_time = time()\n", + "\n", + "base_net = VGG(classifier='ssd', init_weights='imagenet')\n", + "seq_model = get_seq_model(base_net)\n", + "cutoff_idx = 7\n", + "red_method = 'HOSVD'\n", + "red_dim = [35, 3, 3]\n", + "inout_method = None\n", + "netadapter = NetAdapter(cutoff_idx, red_dim, red_method, inout_method)\n", + "red_model = netadapter.reduce_net(seq_model, train_dataset, None, train_loader, n_classes)\n", + "base_net = red_model.premodel\n", + "aux_conv = red_model.proj_model\n", + "print(red_model)\n", + "\n", + "# change configuration predictor layers\n", + "#cfg_tot = [n of channels of the outputs of the pre model, n of the reduced channels]\n", + "cfg_tot = list(reversed(list(red_model.proj_model.list_of_matrices[0].shape)))\n", + "n_boxes = [4, 6]\n", + "predictor = PredictionConvolutions(n_classes, cfg_tot, n_boxes)\n", + "network = [base_net, aux_conv, predictor]\n", + "\n", + "#create prior boxes custom for reduced net\n", + "reduction_dims = list(reversed(list(red_model.proj_model.list_of_matrices[1].shape)))\n", + "#fmaps_dims = {'premodel': width=height of the output of the pre model, 'projmodel': width=height of the reduced tensors}\n", + "fmaps_dims = {'premodel': reduction_dims[0], 'projmodel': reduction_dims[1]}\n", + "obj_scales = {'premodel': 0.1, 'projmodel': 0.725} \n", + "aspect_ratio = {'premodel': [1., 2., 0.5], 'projmodel': [1., 2., 3., 0.5, 0.333]}\n", + "priors_cxcy = create_prior_boxes(fmaps_dims, obj_scales, aspect_ratio)\n", + "init_end = time()\n", + "print('time needed to initialize the model', round(init_end - init_time,2), 'seconds')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training Phase\n", + "Once we have defined the several pieces composing our reduced version of the detector (pre_model instead of full vgg, reduction layers instead of auxiliary layers, and the same predictor), we can train it." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: [0][0/30]\tBatch Time 0.409 (0.409)\tData Time 0.247 (0.247)\tLoss val (average) 5.2885 (5.2885)\t\n", + "Epoch: [1][0/30]\tBatch Time 0.511 (0.511)\tData Time 0.395 (0.395)\tLoss val (average) 5.3623 (5.3623)\t\n", + "Epoch: [2][0/30]\tBatch Time 0.282 (0.282)\tData Time 0.164 (0.164)\tLoss val (average) 5.3762 (5.3762)\t\n", + "Epoch: [3][0/30]\tBatch Time 0.332 (0.332)\tData Time 0.213 (0.213)\tLoss val (average) 5.4769 (5.4769)\t\n", + "Epoch: [4][0/30]\tBatch Time 0.389 (0.389)\tData Time 0.271 (0.271)\tLoss val (average) 5.0611 (5.0611)\t\n", + "Epoch: [5][0/30]\tBatch Time 0.429 (0.429)\tData Time 0.311 (0.311)\tLoss val (average) 5.0190 (5.0190)\t\n", + "Epoch: [6][0/30]\tBatch Time 0.324 (0.324)\tData Time 0.203 (0.203)\tLoss val (average) 5.1396 (5.1396)\t\n", + "Epoch: [7][0/30]\tBatch Time 0.402 (0.402)\tData Time 0.283 (0.283)\tLoss val (average) 5.6913 (5.6913)\t\n", + "Epoch: [8][0/30]\tBatch Time 0.355 (0.355)\tData Time 0.236 (0.236)\tLoss val (average) 5.3226 (5.3226)\t\n", + "Epoch: [9][0/30]\tBatch Time 0.358 (0.358)\tData Time 0.239 (0.239)\tLoss val (average) 4.8955 (4.8955)\t\n", + "Epoch: [10][0/30]\tBatch Time 0.313 (0.313)\tData Time 0.191 (0.191)\tLoss val (average) 4.8290 (4.8290)\t\n", + "Epoch: [11][0/30]\tBatch Time 0.470 (0.470)\tData Time 0.351 (0.351)\tLoss val (average) 4.5696 (4.5696)\t\n", + "Epoch: [12][0/30]\tBatch Time 0.448 (0.448)\tData Time 0.329 (0.329)\tLoss val (average) 4.4618 (4.4618)\t\n", + "Epoch: [13][0/30]\tBatch Time 0.394 (0.394)\tData Time 0.273 (0.273)\tLoss val (average) 5.5949 (5.5949)\t\n", + "Epoch: [14][0/30]\tBatch Time 0.429 (0.429)\tData Time 0.309 (0.309)\tLoss val (average) 4.1911 (4.1911)\t\n", + "Epoch: [15][0/30]\tBatch Time 0.321 (0.321)\tData Time 0.200 (0.200)\tLoss val (average) 4.2410 (4.2410)\t\n", + "Epoch: [16][0/30]\tBatch Time 0.322 (0.322)\tData Time 0.200 (0.200)\tLoss val (average) 4.9888 (4.9888)\t\n", + "Epoch: [17][0/30]\tBatch Time 0.359 (0.359)\tData Time 0.236 (0.236)\tLoss val (average) 4.2695 (4.2695)\t\n", + "Epoch: [18][0/30]\tBatch Time 0.350 (0.350)\tData Time 0.225 (0.225)\tLoss val (average) 4.6492 (4.6492)\t\n", + "Epoch: [19][0/30]\tBatch Time 0.360 (0.360)\tData Time 0.236 (0.236)\tLoss val (average) 4.5057 (4.5057)\t\n", + "Epoch: [20][0/30]\tBatch Time 0.350 (0.350)\tData Time 0.228 (0.228)\tLoss val (average) 4.4015 (4.4015)\t\n", + "Epoch: [21][0/30]\tBatch Time 0.358 (0.358)\tData Time 0.234 (0.234)\tLoss val (average) 4.7579 (4.7579)\t\n", + "Epoch: [22][0/30]\tBatch Time 0.396 (0.396)\tData Time 0.275 (0.275)\tLoss val (average) 4.8101 (4.8101)\t\n", + "Epoch: [23][0/30]\tBatch Time 0.453 (0.453)\tData Time 0.332 (0.332)\tLoss val (average) 4.3113 (4.3113)\t\n", + "Epoch: [24][0/30]\tBatch Time 0.364 (0.364)\tData Time 0.243 (0.243)\tLoss val (average) 4.3516 (4.3516)\t\n", + "Epoch: [25][0/30]\tBatch Time 0.359 (0.359)\tData Time 0.236 (0.236)\tLoss val (average) 4.4434 (4.4434)\t\n", + "Epoch: [26][0/30]\tBatch Time 0.398 (0.398)\tData Time 0.278 (0.278)\tLoss val (average) 4.3724 (4.3724)\t\n", + "Epoch: [27][0/30]\tBatch Time 0.383 (0.383)\tData Time 0.261 (0.261)\tLoss val (average) 4.6017 (4.6017)\t\n", + "Epoch: [28][0/30]\tBatch Time 0.402 (0.402)\tData Time 0.280 (0.280)\tLoss val (average) 4.2785 (4.2785)\t\n", + "Epoch: [29][0/30]\tBatch Time 0.428 (0.428)\tData Time 0.308 (0.308)\tLoss val (average) 4.5009 (4.5009)\t\n", + "Epoch: [30][0/30]\tBatch Time 0.477 (0.477)\tData Time 0.354 (0.354)\tLoss val (average) 3.9579 (3.9579)\t\n", + "Epoch: [31][0/30]\tBatch Time 0.360 (0.360)\tData Time 0.239 (0.239)\tLoss val (average) 3.9041 (3.9041)\t\n", + "Epoch: [32][0/30]\tBatch Time 0.393 (0.393)\tData Time 0.263 (0.263)\tLoss val (average) 3.8265 (3.8265)\t\n", + "Epoch: [33][0/30]\tBatch Time 0.315 (0.315)\tData Time 0.192 (0.192)\tLoss val (average) 3.7582 (3.7582)\t\n", + "Epoch: [34][0/30]\tBatch Time 0.371 (0.371)\tData Time 0.249 (0.249)\tLoss val (average) 4.0377 (4.0377)\t\n", + "Epoch: [35][0/30]\tBatch Time 0.405 (0.405)\tData Time 0.285 (0.285)\tLoss val (average) 4.1851 (4.1851)\t\n", + "Epoch: [36][0/30]\tBatch Time 0.316 (0.316)\tData Time 0.191 (0.191)\tLoss val (average) 3.7542 (3.7542)\t\n", + "Epoch: [37][0/30]\tBatch Time 0.389 (0.389)\tData Time 0.267 (0.267)\tLoss val (average) 4.3031 (4.3031)\t\n", + "Epoch: [38][0/30]\tBatch Time 0.285 (0.285)\tData Time 0.162 (0.162)\tLoss val (average) 3.9916 (3.9916)\t\n", + "Epoch: [39][0/30]\tBatch Time 0.427 (0.427)\tData Time 0.306 (0.306)\tLoss val (average) 3.8861 (3.8861)\t\n", + "Time needed for training: 157.3 seconds, i.e. 2.6 minutes\n" + ] + } + ], + "source": [ + "check = None\n", + "epochs = 40\n", + "start = time()\n", + "red_detector = Reduced_Detector(network, check, priors_cxcy, n_classes, epochs,\n", + " batch_size, print_freq, lr, decay_lr_at,\n", + " decay_lr_to, momentum, weight_decay, grad_clip,\n", + " train_loader, test_loader, 'Adam', red_method)\n", + "\n", + "start = time()\n", + "check, loss_value = red_detector.train_detector()\n", + "end = time()\n", + "print(f'Time needed for training: {round(end-start,2)} seconds, i.e. {round((end-start)/60,1)} minutes')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Accuracy of the reduced detector\n", + "We can now test the accurcay of the reduced detector against the testing dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Evaluating: 100%|██████████| 8/8 [00:11<00:00, 1.48s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'cat': 34.66533422470093, 'dog': 23.27975034713745}\n", + "{'cat': 34.66533422470093, 'dog': 23.27975034713745}\n", + "\n", + "Mean Average Precision (mAP): 28.973\n", + "Time needed for testing: 12.08 seconds, i.e. 0.2 minutes\n" + ] + } + ], + "source": [ + "start_test = time()\n", + "red_detector.eval_detector(label_map)\n", + "end_test = time()\n", + "print(f'Time needed for testing: {round(end_test-start_test,2)} seconds, i.e. {round((end_test-start_test)/60,1)} minutes')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Image Detection\n", + "By choosing a specific image from the directory used, the network is able to detect the object(s) in it and save a version of the image in which the bounding box(es) with the relative label(s) is(/are) pictured. To view this, open the file ``out.jpg``, as described below." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "img_path = 'VOC_dog_cat/JPEGImages/001825.jpg'\n", + "original_image = Image.open(img_path, mode='r')\n", + "original_image = original_image.convert('RGB')\n", + "\n", + "red_detector.detect(original_image,\n", + " label_map,\n", + " min_score=0.01,\n", + " max_overlap=0.45,\n", + " top_k=1).show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "out_img = Image.open('out.jpg')\n", + "display(out_img)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Memory Footprint reduced detector\n", + "It can be noted that the space required by the reduced detector obtained using AHOSV is decreased with respect to the one obetined with POD and with the full network. The use of the tensorial approach is hence more useful in this kind of problems." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SSD300 reduced-storage\n", + " Pre-model = 6.62, Reduction Layer nnz=0.04, feature_loc nnz=0.1696, feature_cl nnz=0.1272\n", + "The total amount of space required is 6.952 MB.\n" + ] + } + ], + "source": [ + "rednet_storage = torch.zeros(4)\n", + "\n", + "rednet_storage[0], rednet_storage[1], rednet_storage[2], rednet_storage[3] = [\n", + " Total_param(red_detector.model[0]),\n", + " Total_param(red_detector.model[1]),\n", + " Total_param(red_detector.model[2].features_loc),\n", + " Total_param(red_detector.model[2].features_cl)]\n", + "\n", + "print('SSD300 reduced-storage')\n", + "print(\n", + " ' Pre-model = {:.2f}, Reduction Layer nnz={:.2f}, feature_loc nnz={:.4f}, feature_cl nnz={:.4f}'.format(\n", + " rednet_storage[0], rednet_storage[1],\n", + " rednet_storage[2], rednet_storage[3]))\n", + "space_rednet = (rednet_storage[0]+rednet_storage[1]+rednet_storage[2]+rednet_storage[3]).item()\n", + "print('The total amount of space required is {:.3f} MB.'.format(space_rednet))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + }, + "vscode": { + "interpreter": { + "hash": "8c5bf16c94eb6f9341fa612a12f652937166e39821fa969ec7095b77ab48ffd1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/smithers/ml/tutorials/reduction_VGG16.ipynb b/smithers/ml/tutorials/reduction_VGG16.ipynb new file mode 100644 index 0000000..07e5e2f --- /dev/null +++ b/smithers/ml/tutorials/reduction_VGG16.ipynb @@ -0,0 +1,610 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Dimensionality Reduction of VGG16\n", + "In this tutorial we will present how to create a reduced version of VGG16 using the techniques described in the article \n", + "\n", + "''A Dimensionality Reduction Approach for Convolutional Neural Networks'', Meneghetti L., Demo N., Rozza G., https://arxiv.org/abs/2110.09163 (2021).\n", + "\n", + "and in the paper ''Deep neural network compression via tensor decomposition'' by S. Zanin, L. Meneghetti, N. Demo and G. Rozza, that is currently in preparation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports\n", + "We start by importing all the necessary libraries and functions." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, '/scratch/lmeneghe/Smithers/')\n", + "import os\n", + "import torch\n", + "import numpy as np\n", + "import torchvision\n", + "from torch import nn\n", + "\n", + "import torchvision.transforms as transforms\n", + "import torchvision.datasets as datasets\n", + "import pandas as pd\n", + "import torch.optim as optim\n", + "\n", + "from smithers.ml.models.vgg import VGG\n", + "from smithers.ml.models.utils_rednet import get_seq_model, Total_param, Total_flops, compute_loss, train_kd\n", + "from smithers.ml.models.netadapter import NetAdapter\n", + "\n", + "\n", + "import warnings" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Setting the proper device\n", + "The following lines will detect if a gpu is available in the system running this tutorial. If that is the case, all the objects of the following tutorial will be allocated in the gpu, thus speeding up the training process." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cuda has been detected as the device which the script will be run on.\n" + ] + } + ], + "source": [ + "if torch.cuda.is_available():\n", + " device = torch.device('cuda')\n", + "else:\n", + " device = torch.device('cpu')\n", + "print(f\"{device} has been detected as the device which the script will be run on.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading of the dataset\n", + "### CIFAR10 Dataset\n", + "We use the CIFAR10 dataset (already implemented in PyTorch) to test our technique. It is a computer-vision dataset used for object recognition. It consists of 60000 32 × 32 colour images divided in 10 non-overlapping classes: airplane, automobile, bird, cat, deer, dog, frog, horse, ship, and truck.\n", + "\n", + "See https://www.cs.toronto.edu/~kriz/cifar.html for more details on this dataset and on how to download it." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Files already downloaded and verified\n", + "Files already downloaded and verified\n" + ] + } + ], + "source": [ + "batch_size = 8 \n", + "data_path = '../cifar/' \n", + "# transform functions: take in input a PIL image and apply this\n", + "# transformations\n", + "transform_train = transforms.Compose([\n", + " transforms.RandomCrop(32, padding=4),\n", + " transforms.RandomHorizontalFlip(),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n", + "])\n", + "\n", + "transform_test = transforms.Compose([\n", + " transforms.ToTensor(),\n", + " transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n", + "])\n", + "train_dataset = datasets.CIFAR10(root=data_path + 'CIFAR10/',\n", + " train=True,\n", + " download=True,\n", + " transform=transform_train)\n", + "train_loader = torch.utils.data.DataLoader(train_dataset,\n", + " batch_size=batch_size,\n", + " shuffle=True)\n", + "test_dataset = datasets.CIFAR10(root=data_path + 'CIFAR10/',\n", + " train=False,\n", + " download=True,\n", + " transform=transform_test)\n", + "test_loader = torch.utils.data.DataLoader(test_dataset,\n", + " batch_size=batch_size,\n", + " shuffle=True)\n", + "train_labels = torch.tensor(train_loader.dataset.targets)\n", + "targets = list(train_labels)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Custom dataset\n", + "If we want to use a custom dataset, we need firstly to construct it, following for example the tutorial on the construction of a custom dataset for the problem of Image Recognition (***customdata_imagerec***). " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading of the model\n", + "First of all we need to load the model we want to use (in this case VGG16) starting from a checkpoint file, i.e. a file containing the status of the model after a training process with a chosen dataset. Here we will use the CIFAR10 dataset, but everythong can be also generalized for a custom dataset or another benchmark dataset.\n", + "\n", + "It is important to highlight that the models of VGG-nets implemented in PyTorch (https://pytorch.org/hub/pytorch_vision_vgg/), e.g. \n", + "```\n", + "model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg16', pretrained=True),\n", + "```\n", + "\n", + "are models pre-trained on the ImageNet dataset, that consists of images of dimensions 224x224. Therefore, in order to use datasets like the CIFAR10, composed of images 32x32, we need to change the architecture of VGG-nets, as was done in the file ***smithers/ml/vgg.py***.\n", + "\n", + "In order to obtain a checkpoint file, the tutorial ***training_VGG16*** can be followed." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# pretrained = insert here the proper path for your device\n", + "pretrained = 'check_vgg.pth'\n", + "VGGnet = torch.load(pretrained)\n", + "seq_model = get_seq_model(VGGnet).to(device)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reduction of VGG16\n", + "We now perform the reduction of VGG16 using the module ***NetAdapter***. For the reduced method and the input-output mapping there are multiple choices: 'POD', 'AS', 'RandSVD' or 'HOSVD' for the first one, and 'PCE' or 'FNN' for the latter. We are now going to provide some examples of possible combinations of the aforementioned techniques. The Figure below summarizes the reduction method proposed, as described in the article ''A Dimensionality Reduction Approach for Convolutional Neural Networks'', Meneghetti L., Demo N., Rozza G., https://arxiv.org/abs/2110.09163 (2021).\n", + "\n", + "\n", + "\n", + "NOTE: To use the Active Subspace as reduction method, the Python package ATHENA should be downloaded from https://github.com/mathLab/ATHENA.\n", + "\n", + "\n", + "Let's start by computing the current accuracy of the network." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy of the full network on test images is 87.5100\n" + ] + } + ], + "source": [ + "total = 0\n", + "correct = 0\n", + "seq_model.eval()\n", + "for test, y_test in iter(test_loader):\n", + "#Calculate the class probabilities (softmax) for img\n", + " with torch.no_grad():\n", + " output = seq_model(test.to(device)).to(device)\n", + " ps = torch.exp(output)\n", + " _, predicted = torch.max(output.data,1)\n", + " total += y_test.size(0)\n", + " correct += (predicted == y_test.to(device)).sum().item()\n", + " \n", + "print(\"Accuracy of the full network on test images is {:.4f}\".format(100*correct/total))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## POD + FNN\n", + "The first method we describe uses POD as reduction technique and a Feedforward Neural Network (FNN) as input-output mapping." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "cutoff_idx = 7 \n", + "red_dim = 50 \n", + "red_method = 'POD' \n", + "inout_method = 'FNN'\n", + "n_class = 10\n", + "netadapter = NetAdapter(cutoff_idx, red_dim, red_method, inout_method)\n", + "red_model = netadapter.reduce_net(seq_model, train_dataset, train_labels, train_loader, n_class)\n", + "print(red_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## RandSVD + FNN\n", + "A small variant of the previous case can be obtained using Random SVD as reduction technique and a Feedforward Neural Network (FNN) as input-output mapping." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cutoff_idx = 5 \n", + "red_dim = 50 \n", + "red_method = 'RandSVD' \n", + "inout_method = 'FNN'\n", + "n_class = 10\n", + "netadapter = NetAdapter(cutoff_idx, red_dim, red_method, inout_method)\n", + "red_model = netadapter.reduce_net(seq_model, train_dataset, train_labels, train_loader, n_class)\n", + "print(red_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## AHOSVD + FNN\n", + "A different choice is represented by the introduction of HOSVD as reduction technique that keeps into account the tensorial structure of the objects under consideration. Hence, in this case we are using a variant of HOSVD, called Averaged HOSVD (AHOSVD), which performs HOSVD in batches and then computes the average between them to overcome the high computational effort needed. In particular, we are the n coupling AHOSVD with FNN as before." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FNN training initialized\n", + "FNN training completed\n", + "RedNet(\n", + " (premodel): Sequential(\n", + " (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU(inplace=True)\n", + " (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU(inplace=True)\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (6): ReLU(inplace=True)\n", + " (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (8): ReLU(inplace=True)\n", + " (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (11): ReLU(inplace=True)\n", + " (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (13): ReLU(inplace=True)\n", + " (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (15): ReLU(inplace=True)\n", + " (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " )\n", + " (proj_model): tensor_product_layer(in_dimensions=[256, 4, 4], out_dimensions=[35, 3, 3])\n", + " (inout_map): FNN(\n", + " (model): Sequential(\n", + " (0): Linear(in_features=315, out_features=20, bias=True)\n", + " (1): Softplus(beta=1, threshold=20)\n", + " (2): Linear(in_features=20, out_features=10, bias=True)\n", + " )\n", + " )\n", + ")\n" + ] + } + ], + "source": [ + "cutoff_idx = 7\n", + "red_method= 'HOSVD'\n", + "red_dim = [35, 3, 3]\n", + "inout_method = 'FNN'\n", + "n_class = 10 \n", + "\n", + "netadapter = NetAdapter(cutoff_idx, red_dim, red_method, inout_method)\n", + "red_model = netadapter.reduce_net(seq_model, train_dataset, train_labels, train_loader, n_class, device = device).to(device) \n", + "print(red_model, flush=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training of the reduced network\n", + "Now that the reduced network has been defined, we can train it. The technique used is \"knowledge distillation\", i.e. try to use the knowledge contained in the original full model, also referred as the teacher model, to train the the reduced model, called student model." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Loss 0.4235516825962067\n", + " Top 1: Accuracy: 4614.0/50000 (9.23%)\n", + "Loss Value: 8.471033651924133e-06\n", + "Test Loss 0.5047410353899002\n", + " Top 1: Accuracy: 841.0/10000 (8.41%)\n", + "Loss Value: 5.047410353899002e-05\n", + "EPOCH 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/scratch/lmeneghe/anaconda/lib/python3.8/site-packages/torch/nn/functional.py:2747: UserWarning: reduction: 'mean' divides the total loss by both the batch size and the support size.'batchmean' divides only by the batch size, and aligns with the KL div math definition.'mean' will be changed to behave the same as 'batchmean' in the next major release.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Loss kd: 1.5311928987503053e-05\n", + "Test Loss -0.029346163740754126\n", + " Top 1: Accuracy: 8097.0/10000 (80.97%)\n", + "Loss Value: -2.9346163740754128e-06\n", + "EPOCH 2\n", + "Train Loss kd: 3.4757274389266966e-06\n", + "Test Loss 0.4364694202244282\n", + " Top 1: Accuracy: 8363.0/10000 (83.63%)\n", + "Loss Value: 4.364694202244282e-05\n" + ] + } + ], + "source": [ + "import copy\n", + "\n", + "optimizer = torch.optim.Adam([{\n", + " 'params': red_model.premodel.parameters(),\n", + " 'lr': 1e-4\n", + " }, {\n", + " 'params': red_model.proj_model.parameters(),\n", + " 'lr': 1e-5\n", + " }, {\n", + " 'params': red_model.inout_map.parameters(),\n", + " 'lr': 1e-5\n", + " }])\n", + "\n", + "train_loss = []\n", + "test_loss = []\n", + "train_loss.append(compute_loss(red_model, device, train_loader))\n", + "test_loss.append(compute_loss(red_model, device, test_loader))\n", + "\n", + " \n", + "epochs = 2\n", + "filename = './cifar10_VGG16_RedNet'+red_method+'_cutIDx_%d.pth'%(cutoff_idx)\n", + "for epoch in range(1, epochs + 1): \n", + " print('EPOCH {}'.format(epoch), flush=True)\n", + " train_loss.append(\n", + " train_kd(red_model,\n", + " VGGnet,\n", + " device,\n", + " train_loader,\n", + " optimizer,\n", + " train_max_batch=200,\n", + " alpha=0.1,\n", + " temperature=1.,\n", + " epoch=epoch))\n", + " test_loss.append(compute_loss(red_model, device, test_loader))\n", + "torch.save(copy.deepcopy(red_model), filename)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Loading a reduced network checkpoint\n", + "If a reduced network has been already defined and saved on the computer, it can be loaded with the following instructions" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "checkpoint = filename #path to the checkpoint file\n", + "red_model = torch.load(checkpoint)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Accuracy testing\n", + "We can further test the accuracy of the network with the following code." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy of the full network on test images is 83.6300\n" + ] + } + ], + "source": [ + "total = 0\n", + "correct = 0\n", + "for test, y_test in iter(test_loader):\n", + " with torch.no_grad():\n", + " output = red_model(test.to(device))\n", + " ps = torch.exp(output)\n", + " _, predicted = torch.max(output.data,1)\n", + " total += y_test.size(0)\n", + " correct += (predicted == y_test.to(device)).to(device).sum().item()\n", + "\n", + "print(\"Accuracy of the full network on test images is {:.4f}\".format(100*correct/total))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Storage and flops needed for the model\n", + "The following lines of code provide the amounts of storage needed to save the reduced model together with the number of floating point operations needed to compute them.\n", + "\n", + "We start by counting the number of non-zero entries (nnz) of the three components of the reduced network (this method only concerns the POD+FNN and RandSVD+FNN techniques, regarding the storage) and the flops." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre nnz = 6.62, proj_model nnz=0.03, FNN nnz=0.0249\n", + "flops: Pre = 190.51, proj_model = 0.00, FNN =0.01\n" + ] + } + ], + "source": [ + "rednet_storage = torch.zeros(3)\n", + "rednet_flops = torch.zeros(3)\n", + "\n", + "rednet_storage[0], rednet_storage[1], rednet_storage[2] = [\n", + " Total_param(red_model.premodel),\n", + " Total_param(red_model.proj_model),\n", + " Total_param(red_model.inout_map)]\n", + "\n", + "rednet_flops[0], rednet_flops[1], rednet_flops[2] = [\n", + " Total_flops(red_model.premodel, device),\n", + " Total_flops(red_model.proj_model, device),\n", + " Total_flops(red_model.inout_map, device)]\n", + "\n", + "\n", + "print('Pre nnz = {:.2f}, proj_model nnz={:.2f}, FNN nnz={:.4f}'.format(\n", + " rednet_storage[0], rednet_storage[1],\n", + " rednet_storage[2]))\n", + "print('flops: Pre = {:.2f}, proj_model = {:.2f}, FNN ={:.2f}'.format(\n", + " rednet_flops[0], rednet_flops[1], rednet_flops[2]))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can define another method that counts the storage needed for saving the reduced model (in MB)." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing the storage needed by the RedNet model.\n", + "Components summary:\n", + "premodel.0.weight \t torch.Size([64, 3, 3, 3])\n", + "premodel.0.bias \t torch.Size([64])\n", + "premodel.2.weight \t torch.Size([64, 64, 3, 3])\n", + "premodel.2.bias \t torch.Size([64])\n", + "premodel.5.weight \t torch.Size([128, 64, 3, 3])\n", + "premodel.5.bias \t torch.Size([128])\n", + "premodel.7.weight \t torch.Size([128, 128, 3, 3])\n", + "premodel.7.bias \t torch.Size([128])\n", + "premodel.10.weight \t torch.Size([256, 128, 3, 3])\n", + "premodel.10.bias \t torch.Size([256])\n", + "premodel.12.weight \t torch.Size([256, 256, 3, 3])\n", + "premodel.12.bias \t torch.Size([256])\n", + "premodel.14.weight \t torch.Size([256, 256, 3, 3])\n", + "premodel.14.bias \t torch.Size([256])\n", + "proj_model.param0 \t torch.Size([35, 256])\n", + "proj_model.param1 \t torch.Size([3, 4])\n", + "proj_model.param2 \t torch.Size([3, 4])\n", + "inout_map.model.0.weight \t torch.Size([20, 315])\n", + "inout_map.model.0.bias \t torch.Size([20])\n", + "inout_map.model.2.weight \t torch.Size([10, 20])\n", + "inout_map.model.2.bias \t torch.Size([10])\n", + "\n", + "\n", + "The MB used are: 7.004007816314697\n" + ] + } + ], + "source": [ + "print('Computing the storage needed by the RedNet model.\\nComponents summary:')\n", + "storage = 0\n", + "for param_tensor in red_model.state_dict():\n", + " print(param_tensor, \"\\t\", red_model.state_dict()[param_tensor].size())\n", + " storage += torch.prod(torch.tensor(list(red_model.state_dict()[param_tensor].size())))\n", + "print(f\"\\n\\nThe MB used are: {4 * storage / 10 ** 6}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + }, + "vscode": { + "interpreter": { + "hash": "8c5bf16c94eb6f9341fa612a12f652937166e39821fa969ec7095b77ab48ffd1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/smithers/ml/tutorials/training_SSD.ipynb b/smithers/ml/tutorials/training_SSD.ipynb new file mode 100644 index 0000000..6c044b9 --- /dev/null +++ b/smithers/ml/tutorials/training_SSD.ipynb @@ -0,0 +1,512 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training SSD300\n", + "In this tutorial, we will show how to initialize, train and test SSD300 for object detection.\n", + "The tutorial is based on a subset of pictures from the PascalVOC dataset (both 2007 and 2012), but can be generalized to be used with the whole PascalVOC or other custom/benchmark datasets." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports\n", + "We start by importing all the necessary functions." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from PIL import Image\n", + "from time import time\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "import torchvision.transforms as transforms\n", + "\n", + "import sys\n", + "sys.path.insert(0, '/scratch/lmeneghe/Smithers/')\n", + "\n", + "from smithers.ml.models.vgg import VGG\n", + "from smithers.ml.models.aux_conv import AuxiliaryConvolutions\n", + "from smithers.ml.models.predictor import PredictionConvolutions\n", + "from smithers.ml.dataset.pascalvoc_dataset import PascalVOCDataset\n", + "from smithers.ml.models.detector import Detector\n", + "from smithers.ml.models.utils_objdet import create_prior_boxes\n", + "\n", + "\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parameters Initialization\n", + "We set the parameters used for the data, the detector and the learning phase." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Learning parameters\n", + "batch_size = 8 # batch size\n", + "workers = 4 # number of workers for loading data in the DataLoader\n", + "iterations = 120000 # number of iterations to train\n", + "print_freq = 200 # print training status every __ batches\n", + "lr = 1e-4 # learning rate\n", + "decay_lr_at = [80000, 100000] # decay learning rate after these many iterations\n", + "decay_lr_to = 0.1\n", + "# decay learning rate to this fraction of the existing learning rate\n", + "#n_classes = 6\n", + "momentum = 0.9 # momentum\n", + "weight_decay = 5e-4 # weight decay\n", + "grad_clip = None\n", + "# clip if gradients are exploding, which may happen at larger batch sizes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Dataset Loading\n", + "We need to load and create the datasets for training and testing our model. In this case we are using a dataset extracted from PascalVOC that has been created using ***smithers/ml/dataset/sample_dataset.py***. For more details about this, refer to the tutorial ***pascalvoc_preparation***, which explains also how to use the whole PascalVOC dataset. Instead, to use a custom dataset for this purpose, refer to the turial ***customdata_objdet***." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "categories: {'cat': 1, 'dog': 2, 'background': 0}\n", + "n_classes: 3\n", + "Training images: 240\n", + "Testing images: 60\n" + ] + } + ], + "source": [ + "#voc_labels = ('aeroplane', 'bicycle', 'bird', 'boat',\n", + "# 'bottle', 'bus', 'car', 'cat', 'chair',\n", + "# 'cow', 'diningtable', 'dog', 'horse',\n", + "# 'motorbike', 'person', 'pottedplant',\n", + "# 'sheep', 'sofa', 'train', 'tvmonitor')\n", + "voc_labels = ('cat', 'dog')\n", + "label_map = {k: v + 1 for v, k in enumerate(voc_labels)}\n", + "label_map['background'] = 0\n", + "n_classes = len(label_map)\n", + "print('categories:',label_map)\n", + "print('n_classes:', n_classes)\n", + "\n", + "# Data parameters\n", + "data_folder = 'VOC_dog_cat/JSONfiles' #folder with json data files\n", + "keep_difficult = True\n", + "\n", + "\n", + "train_dataset = PascalVOCDataset(data_folder,\n", + " split='train',\n", + " keep_difficult=keep_difficult)\n", + "train_loader = torch.utils.data.DataLoader(\n", + " train_dataset,\n", + " batch_size=batch_size,\n", + " shuffle=True,\n", + " collate_fn=train_dataset.collate_fn,\n", + " num_workers=workers,\n", + " pin_memory=True)\n", + "\n", + "epochs = iterations // (len(train_dataset) // 16) #500\n", + "decay_lr_at = [it // (len(train_dataset) // 16) for it in decay_lr_at]\n", + "print('Training images:', len(train_dataset))\n", + "\n", + "\n", + "test_dataset = PascalVOCDataset(data_folder,\n", + " split='test',\n", + " keep_difficult=keep_difficult)\n", + "test_loader = torch.utils.data.DataLoader(test_dataset,\n", + " batch_size=batch_size,\n", + " shuffle=False,\n", + " collate_fn=test_dataset.collate_fn,\n", + " num_workers=workers,\n", + " pin_memory=True)\n", + "print('Testing images:', len(test_dataset))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Creation and loading of the SSD300 model\n", + "We are now going to initialize SSD300 using the class ***Detector*** of ***smithers/ml/models/detector.py***, based on the original paper: \n", + "\n", + "'SSD: Single Shot Multibox Detector' by Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng-Yang Fu, Alexander C. Berg https://arxiv.org/abs/1512.02325 ,DOI: 10.1007/978-3-319-46448-0_2\n", + "\n", + "In this case, we should select 'ssd' as classifier for VGG in order to substitute the feedforward classification layers of the original VGG with convolutional layers. We have then initialized SSD300 using pre-trained wegiths on ImageNet (a common choice in this field).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Loaded base model.\n", + "\n", + "Time needed to initialize the net: 2.58 seconds\n" + ] + } + ], + "source": [ + "start_init = time()\n", + "base_net = VGG(classifier='ssd', init_weights='imagenet')\n", + "aux_conv = AuxiliaryConvolutions()\n", + "predictor = PredictionConvolutions(n_classes)\n", + "network = [base_net, aux_conv, predictor]\n", + "priors_cxcy = create_prior_boxes()\n", + "end_init = time()\n", + "print('Time needed to initialize the net: {} seconds'.format(round(end_init-start_init,2)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training Phase\n", + "Once we have created and initliazed the network we can train it.\n", + "\n", + "\n", + "Here, the network will trained and, if provided, a checkpoint can be used to start from an already trained network.\n", + "\n", + "The training procedure will store a checkpoint file named ``checkpoint_ssd300.pth.tar``, once it is completed.\n", + "Furthermore, the plot of the value of the loss against the corresponding epoch is produced." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[VGG(\n", + " (features): Sequential(\n", + " (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU(inplace=True)\n", + " (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU(inplace=True)\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (6): ReLU(inplace=True)\n", + " (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (8): ReLU(inplace=True)\n", + " (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (11): ReLU(inplace=True)\n", + " (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (13): ReLU(inplace=True)\n", + " (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (15): ReLU(inplace=True)\n", + " (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (18): ReLU(inplace=True)\n", + " (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (20): ReLU(inplace=True)\n", + " (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (22): ReLU(inplace=True)\n", + " (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (25): ReLU(inplace=True)\n", + " (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (27): ReLU(inplace=True)\n", + " (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (29): ReLU(inplace=True)\n", + " (30): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " )\n", + " (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))\n", + " (classifier): Sequential(\n", + " (0): Conv2d(512, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(6, 6), dilation=(6, 6))\n", + " (1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + "), AuxiliaryConvolutions(\n", + " (features): Sequential(\n", + " (0): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " (1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (2): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (3): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (4): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (5): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1))\n", + " (6): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (7): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1))\n", + " )\n", + "), PredictionConvolutions(\n", + " (features_loc): Sequential(\n", + " (0): Conv2d(512, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): Conv2d(1024, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (2): Conv2d(512, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): Conv2d(256, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (4): Conv2d(256, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (5): Conv2d(256, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " )\n", + " (features_cl): Sequential(\n", + " (0): Conv2d(512, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): Conv2d(1024, 18, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (2): Conv2d(512, 18, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): Conv2d(256, 18, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (4): Conv2d(256, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (5): Conv2d(256, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " )\n", + ")]\n", + "Epoch: [0][0/30]\tBatch Time 0.638 (0.638)\tData Time 0.342 (0.342)\tLoss val (average) 68.6633 (68.6633)\t\n", + "Epoch: [1][0/30]\tBatch Time 0.372 (0.372)\tData Time 0.163 (0.163)\tLoss val (average) 10.0403 (10.0403)\t\n", + "Epoch: [2][0/30]\tBatch Time 0.426 (0.426)\tData Time 0.220 (0.220)\tLoss val (average) 5.1005 (5.1005)\t\n", + "Epoch: [3][0/30]\tBatch Time 0.539 (0.539)\tData Time 0.330 (0.330)\tLoss val (average) 6.9545 (6.9545)\t\n", + "Epoch: [4][0/30]\tBatch Time 0.430 (0.430)\tData Time 0.220 (0.220)\tLoss val (average) 4.1425 (4.1425)\t\n", + "Epoch: [5][0/30]\tBatch Time 0.404 (0.404)\tData Time 0.193 (0.193)\tLoss val (average) 3.9427 (3.9427)\t\n", + "Epoch: [6][0/30]\tBatch Time 0.435 (0.435)\tData Time 0.224 (0.224)\tLoss val (average) 3.8563 (3.8563)\t\n", + "Epoch: [7][0/30]\tBatch Time 0.486 (0.486)\tData Time 0.275 (0.275)\tLoss val (average) 4.0572 (4.0572)\t\n", + "Epoch: [8][0/30]\tBatch Time 0.416 (0.416)\tData Time 0.202 (0.202)\tLoss val (average) 3.9776 (3.9776)\t\n", + "Epoch: [9][0/30]\tBatch Time 0.552 (0.552)\tData Time 0.341 (0.341)\tLoss val (average) 4.8194 (4.8194)\t\n", + "Epoch: [10][0/30]\tBatch Time 0.466 (0.466)\tData Time 0.240 (0.240)\tLoss val (average) 3.1516 (3.1516)\t\n", + "Epoch: [11][0/30]\tBatch Time 0.387 (0.387)\tData Time 0.174 (0.174)\tLoss val (average) 3.6156 (3.6156)\t\n", + "Epoch: [12][0/30]\tBatch Time 0.466 (0.466)\tData Time 0.253 (0.253)\tLoss val (average) 3.2068 (3.2068)\t\n", + "Epoch: [13][0/30]\tBatch Time 0.450 (0.450)\tData Time 0.234 (0.234)\tLoss val (average) 3.6957 (3.6957)\t\n", + "Epoch: [14][0/30]\tBatch Time 0.452 (0.452)\tData Time 0.239 (0.239)\tLoss val (average) 3.5414 (3.5414)\t\n", + "Epoch: [15][0/30]\tBatch Time 0.391 (0.391)\tData Time 0.177 (0.177)\tLoss val (average) 3.7986 (3.7986)\t\n", + "Epoch: [16][0/30]\tBatch Time 0.406 (0.406)\tData Time 0.189 (0.189)\tLoss val (average) 2.9297 (2.9297)\t\n", + "Epoch: [17][0/30]\tBatch Time 0.480 (0.480)\tData Time 0.265 (0.265)\tLoss val (average) 4.0120 (4.0120)\t\n", + "Epoch: [18][0/30]\tBatch Time 0.420 (0.420)\tData Time 0.196 (0.196)\tLoss val (average) 3.1850 (3.1850)\t\n", + "Epoch: [19][0/30]\tBatch Time 0.518 (0.518)\tData Time 0.304 (0.304)\tLoss val (average) 4.4751 (4.4751)\t\n", + "Epoch: [20][0/30]\tBatch Time 0.416 (0.416)\tData Time 0.201 (0.201)\tLoss val (average) 3.8222 (3.8222)\t\n", + "Epoch: [21][0/30]\tBatch Time 0.438 (0.438)\tData Time 0.225 (0.225)\tLoss val (average) 3.3555 (3.3555)\t\n", + "Epoch: [22][0/30]\tBatch Time 0.521 (0.521)\tData Time 0.301 (0.301)\tLoss val (average) 3.4589 (3.4589)\t\n", + "Epoch: [23][0/30]\tBatch Time 0.425 (0.425)\tData Time 0.210 (0.210)\tLoss val (average) 3.0993 (3.0993)\t\n", + "Epoch: [24][0/30]\tBatch Time 0.431 (0.431)\tData Time 0.216 (0.216)\tLoss val (average) 3.4437 (3.4437)\t\n", + "Epoch: [25][0/30]\tBatch Time 0.420 (0.420)\tData Time 0.204 (0.204)\tLoss val (average) 2.7177 (2.7177)\t\n", + "Epoch: [26][0/30]\tBatch Time 0.441 (0.441)\tData Time 0.226 (0.226)\tLoss val (average) 3.4953 (3.4953)\t\n", + "Epoch: [27][0/30]\tBatch Time 0.492 (0.492)\tData Time 0.276 (0.276)\tLoss val (average) 3.2687 (3.2687)\t\n", + "Epoch: [28][0/30]\tBatch Time 0.463 (0.463)\tData Time 0.248 (0.248)\tLoss val (average) 3.0055 (3.0055)\t\n", + "Epoch: [29][0/30]\tBatch Time 0.387 (0.387)\tData Time 0.169 (0.169)\tLoss val (average) 2.7852 (2.7852)\t\n", + "Epoch: [30][0/30]\tBatch Time 0.433 (0.433)\tData Time 0.211 (0.211)\tLoss val (average) 3.4330 (3.4330)\t\n", + "Epoch: [31][0/30]\tBatch Time 0.442 (0.442)\tData Time 0.221 (0.221)\tLoss val (average) 2.9321 (2.9321)\t\n", + "Epoch: [32][0/30]\tBatch Time 0.434 (0.434)\tData Time 0.219 (0.219)\tLoss val (average) 3.2044 (3.2044)\t\n", + "Epoch: [33][0/30]\tBatch Time 0.457 (0.457)\tData Time 0.241 (0.241)\tLoss val (average) 3.1426 (3.1426)\t\n", + "Epoch: [34][0/30]\tBatch Time 0.422 (0.422)\tData Time 0.208 (0.208)\tLoss val (average) 2.5958 (2.5958)\t\n", + "Epoch: [35][0/30]\tBatch Time 0.456 (0.456)\tData Time 0.242 (0.242)\tLoss val (average) 2.5629 (2.5629)\t\n", + "Epoch: [36][0/30]\tBatch Time 0.446 (0.446)\tData Time 0.227 (0.227)\tLoss val (average) 3.7601 (3.7601)\t\n", + "Epoch: [37][0/30]\tBatch Time 0.492 (0.492)\tData Time 0.276 (0.276)\tLoss val (average) 3.4058 (3.4058)\t\n", + "Epoch: [38][0/30]\tBatch Time 0.466 (0.466)\tData Time 0.252 (0.252)\tLoss val (average) 3.0383 (3.0383)\t\n", + "Epoch: [39][0/30]\tBatch Time 0.439 (0.439)\tData Time 0.222 (0.222)\tLoss val (average) 3.2623 (3.2623)\t\n", + "Epoch: [40][0/30]\tBatch Time 0.403 (0.403)\tData Time 0.175 (0.175)\tLoss val (average) 2.4125 (2.4125)\t\n", + "Epoch: [41][0/30]\tBatch Time 0.477 (0.477)\tData Time 0.245 (0.245)\tLoss val (average) 3.3063 (3.3063)\t\n", + "Epoch: [42][0/30]\tBatch Time 0.451 (0.451)\tData Time 0.233 (0.233)\tLoss val (average) 2.9198 (2.9198)\t\n", + "Epoch: [43][0/30]\tBatch Time 0.499 (0.499)\tData Time 0.284 (0.284)\tLoss val (average) 2.6425 (2.6425)\t\n", + "Epoch: [44][0/30]\tBatch Time 0.508 (0.508)\tData Time 0.291 (0.291)\tLoss val (average) 4.0416 (4.0416)\t\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: [45][0/30]\tBatch Time 0.508 (0.508)\tData Time 0.294 (0.294)\tLoss val (average) 3.0490 (3.0490)\t\n", + "Epoch: [46][0/30]\tBatch Time 0.495 (0.495)\tData Time 0.281 (0.281)\tLoss val (average) 2.6906 (2.6906)\t\n", + "Epoch: [47][0/30]\tBatch Time 0.422 (0.422)\tData Time 0.206 (0.206)\tLoss val (average) 2.9869 (2.9869)\t\n", + "Epoch: [48][0/30]\tBatch Time 0.501 (0.501)\tData Time 0.287 (0.287)\tLoss val (average) 3.2848 (3.2848)\t\n", + "Epoch: [49][0/30]\tBatch Time 0.431 (0.431)\tData Time 0.217 (0.217)\tLoss val (average) 2.5937 (2.5937)\t\n", + "Epoch: [50][0/30]\tBatch Time 0.494 (0.494)\tData Time 0.276 (0.276)\tLoss val (average) 2.8005 (2.8005)\t\n", + "Epoch: [51][0/30]\tBatch Time 0.534 (0.534)\tData Time 0.323 (0.323)\tLoss val (average) 3.4860 (3.4860)\t\n", + "Epoch: [52][0/30]\tBatch Time 0.463 (0.463)\tData Time 0.248 (0.248)\tLoss val (average) 2.7057 (2.7057)\t\n", + "Epoch: [53][0/30]\tBatch Time 0.496 (0.496)\tData Time 0.285 (0.285)\tLoss val (average) 2.9458 (2.9458)\t\n", + "Epoch: [54][0/30]\tBatch Time 0.495 (0.495)\tData Time 0.280 (0.280)\tLoss val (average) 3.0684 (3.0684)\t\n", + "Epoch: [55][0/30]\tBatch Time 0.464 (0.464)\tData Time 0.242 (0.242)\tLoss val (average) 2.4921 (2.4921)\t\n", + "Epoch: [56][0/30]\tBatch Time 0.414 (0.414)\tData Time 0.197 (0.197)\tLoss val (average) 2.5531 (2.5531)\t\n", + "Epoch: [57][0/30]\tBatch Time 0.500 (0.500)\tData Time 0.286 (0.286)\tLoss val (average) 2.6622 (2.6622)\t\n", + "Epoch: [58][0/30]\tBatch Time 0.419 (0.419)\tData Time 0.205 (0.205)\tLoss val (average) 2.3643 (2.3643)\t\n", + "Epoch: [59][0/30]\tBatch Time 0.429 (0.429)\tData Time 0.209 (0.209)\tLoss val (average) 2.3899 (2.3899)\t\n", + "Time needed for training the net: 403.77 seconds, i.e. 6.7 minutes\n" + ] + } + ], + "source": [ + "check = None # if no checkpoint available\n", + "#check = 'checkpoint_ssd300.pth.tar' #if a checkpoint is available\n", + "epochs = 60\n", + "start = time()\n", + "detector = Detector(network, check, priors_cxcy, n_classes, epochs,\n", + " batch_size, print_freq, lr, decay_lr_at,\n", + " decay_lr_to, momentum, weight_decay, grad_clip,\n", + " train_loader, test_loader, 'Adam')\n", + "print(detector.model)\n", + "checkpoint, loss_values = detector.train_detector()\n", + "end = time()\n", + "print(f'Time needed for training the net: {round(end-start,2)} seconds, i.e. {round((end-start)/60,1)} minutes')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Loss function\n", + "In order to understand if the training phase was completed in an optimal way, we can plot the loss function in order to show its behavior over time." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "n_epochs = np.arange(start=0, stop=epochs, step=1)\n", + "plt.plot(n_epochs, loss_values)\n", + "plt.yscale('log')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Value Loss')\n", + "plt.savefig('loss_function.png')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Testing Phase\n", + "Once we have a trained model, we can analyze its accuracy against the testing dataset using the method ***eval_detector*** implemented in the class ***Detector***. It provides in output the accuracy for each class composing the dataset and the Mean Average Precision (mAP), which represents the mean of the precisions over the different categories under consideration." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Evaluating: 100%|██████████| 8/8 [00:03<00:00, 2.52it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'cat': 71.9229519367218, 'dog': 49.422404170036316}\n", + "{'cat': 71.9229519367218, 'dog': 49.422404170036316}\n", + "\n", + "Mean Average Precision (mAP): 60.673\n", + "Time needed for testing the net: 3.39 seconds, i.e. 0.1 minutes\n" + ] + } + ], + "source": [ + "start_test = time()\n", + "detector.eval_detector(label_map)\n", + "end_test = time()\n", + "\n", + "print(f'Time needed for testing the net: {round(end_test-start_test,2)} seconds, i.e. {round((end_test-start_test)/60,1)} minutes')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Image Detection\n", + "By choosing a specific image from the directory used, the network is able to detect the object(s) in it and save a version of the image in which the bounding box(es) with the relative label(s) is(/are) pictured. To view this, open the file ``out.jpg``, as described below." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "img_path = 'VOC_dog_cat/JPEGImages/001825.jpg'\n", + "original_image = Image.open(img_path, mode='r')\n", + "original_image = original_image.convert('RGB')\n", + "\n", + "detector.detect(original_image,\n", + " label_map,\n", + " min_score=0.01,\n", + " max_overlap=0.45,\n", + " top_k=1).show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "out_img = Image.open('out.jpg')\n", + "display(out_img)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + }, + "vscode": { + "interpreter": { + "hash": "8c5bf16c94eb6f9341fa612a12f652937166e39821fa969ec7095b77ab48ffd1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/smithers/ml/tutorials/training_VGG16.ipynb b/smithers/ml/tutorials/training_VGG16.ipynb new file mode 100644 index 0000000..3cb40ae --- /dev/null +++ b/smithers/ml/tutorials/training_VGG16.ipynb @@ -0,0 +1,491 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training VGG16 - Tutorial\n", + "\n", + "In this tutorial we will present how to train a VGG16 network and create a checkpoint file for the trained network." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports\n", + "Firstly, we start by importing all the necessary functions" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "import torchvision\n", + "import torch.nn as nn\n", + "import torchvision.transforms as transforms\n", + "import torchvision.datasets as datasets\n", + "import torch.optim as optim\n", + "import sys\n", + "sys.path.insert(0, '/scratch/lmeneghe/Smithers/')\n", + "\n", + "from smithers.ml.models.vgg import VGG\n", + "\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Setting the proper device\n", + "The following lines will detect if a gpu is available in the system running this tutorial. If that is the case, all the objects of the following tutorial will be allocated in the gpu, thus speeding up the training process." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cuda has been detected as the device which the script will be run on.\n" + ] + } + ], + "source": [ + "if torch.cuda.is_available():\n", + " device = torch.device('cuda')\n", + "else:\n", + " device = torch.device('cpu')\n", + "print(f\"{device} has been detected as the device which the script will be run on.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Loading of the model\n", + "We use VGG16 as model, as implemented in ***smithers/ml/models/vgg.py***. The net is initialized using weights pre-trained on ImageNet, a common choice instead of using random ones (i.e. setting init_weights=True)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Loaded base model.\n", + "\n" + ] + } + ], + "source": [ + "VGGnet = VGG(cfg=None,\n", + " classifier='cifar',\n", + " batch_norm=False,\n", + " num_classes=10,\n", + " init_weights='imagenet').to(device)\n", + "criterion = nn.CrossEntropyLoss()\n", + "optimizer = optim.SGD(VGGnet.parameters(), lr=0.001, momentum=0.9)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Loading of the CIFAR10 dataset\n", + "As stated before, we use the CIFAR10 dataset (already implemented in PyTorch) to test our technique. It is a computer-vision dataset used for object recognition. It consists of 60000 32 × 32 colour images divided in 10 non-overlapping classes: airplane, automobile, bird, cat, deer, dog, frog, horse, ship, and truck.\n", + "\n", + "See https://www.cs.toronto.edu/~kriz/cifar.html for more details on this dataset and on how to download it." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Files already downloaded and verified\n", + "Files already downloaded and verified\n" + ] + } + ], + "source": [ + "batch_size = 8 #this can be changed\n", + "data_path = '../cifar/' \n", + "# transform functions: take in input a PIL image and apply this\n", + "# transformations\n", + "transform_train = transforms.Compose([\n", + " transforms.RandomCrop(32, padding=4),\n", + " transforms.RandomHorizontalFlip(),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n", + "])\n", + "\n", + "transform_test = transforms.Compose([\n", + " transforms.ToTensor(),\n", + " transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n", + "])\n", + "train_dataset = datasets.CIFAR10(root=data_path + 'CIFAR10/',\n", + " train=True,\n", + " download=True,\n", + " transform=transform_train)\n", + "train_loader = torch.utils.data.DataLoader(train_dataset,\n", + " batch_size=batch_size,\n", + " shuffle=True)\n", + "test_dataset = datasets.CIFAR10(root=data_path + 'CIFAR10/',\n", + " train=False,\n", + " download=True,\n", + " transform=transform_test)\n", + "test_loader = torch.utils.data.DataLoader(test_dataset,\n", + " batch_size=batch_size,\n", + " shuffle=True)\n", + "train_labels = torch.tensor(train_loader.dataset.targets).to(device)\n", + "targets = list(train_labels)\n", + "classes = ('airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n", + "n_classes = len(classes)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Custom Dataset\n", + "If we want to use a custom dataset, we need firstly to construct it, following for example the tutorial on the construction of a custom dataset for the problem of Image Recognition. Hence, the previuous cell will be substitute with the following one." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from torch.utils.data.sampler import SubsetRandomSampler\n", + "from collections import OrderedDict\n", + "from smithers.ml.imagerec_dataset import Imagerec_Dataset\n", + "\n", + "# load custom dataset for training and testing\n", + "transform = transforms.Compose(\n", + " [transforms.ToTensor(),\n", + " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n", + "\n", + "data = pd.read_csv('../dataset_imagerec/dataframe.csv')\n", + "data_path = '../dataset_imagerec/'\n", + "# SPLIT OF THE DATASET\n", + "batch_size = 128\n", + "validation_split = .2\n", + "shuffle_dataset = True\n", + "random_seed = 42\n", + "\n", + "dataset_size = len(data)\n", + "indices = list(range(dataset_size))\n", + "split = int(np.floor(validation_split * dataset_size))\n", + "if shuffle_dataset:\n", + " np.random.seed(random_seed)\n", + " np.random.shuffle(indices)\n", + "train_indices, val_indices = indices[split:], indices[:split]\n", + "print('train data', len(train_indices))\n", + "train_sampler = SubsetRandomSampler(train_indices)\n", + "valid_sampler = SubsetRandomSampler(val_indices)\n", + "resize_dim = [32, 32]\n", + "\n", + "dataset_imagerec = Imagerec_Dataset(data, data_path, resize_dim, transform)\n", + "train_dataset = dataset_imagerec.getdata(train_indices)\n", + "train_loader = torch.utils.data.DataLoader(dataset_imagerec,\n", + " batch_size=batch_size,\n", + " sampler=train_sampler)\n", + "test_loader = torch.utils.data.DataLoader(dataset_imagerec,\n", + " batch_size=batch_size,\n", + " sampler=valid_sampler)\n", + "\n", + "data.sort_values(by=['encoded_labels'], inplace=True)\n", + "classes = data['labels'].unique()\n", + "#classes = ('class_1', 'class_2', 'class_3', 'class_4')\n", + "n_class = len(classes)\n", + "targets = list(dataset_imagerec.targets[train_indices])\n", + "train_labels = torch.tensor(targets)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training phase \n", + "The following lines of code will train the network on the train images from the CIFAR10 dataset. Beware that training time can be very long and a gpu is recommended.\n", + "\n", + "It is possible to change the number of epochs for the training: if a large number is given, the network will perform better on the train images but will take longer to train, vice versa for a low number." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1, Loss Value: 0.09345\n", + "Epoch 2, Loss Value: 0.05922\n", + "Epoch 3, Loss Value: 0.04876\n", + "Epoch 4, Loss Value: 0.04112\n", + "Epoch 5, Loss Value: 0.03649\n", + "The network has been successfully trained for 5 epochs.\n" + ] + } + ], + "source": [ + "n_epochs = 5\n", + "for epoch in range(n_epochs):\n", + " running_loss = 0.0\n", + " for i, data in enumerate(train_loader, 0):\n", + " # get the inputs; data is a list of [inputs, labels]\n", + " inputs, labels = data\n", + " inputs = inputs.to(device)\n", + " labels = labels.to(device)\n", + "\n", + " # zero the parameter gradients\n", + " optimizer.zero_grad()\n", + "\n", + " # forward + backward + optimize\n", + " outputs = VGGnet(inputs)\n", + " loss = criterion(outputs, labels)\n", + " loss.backward()\n", + " optimizer.step()\n", + " \n", + " # Let's print statistics at the end of the epoch\n", + " running_loss += loss.item() # extract the loss value\n", + " if i==len(train_loader)-1:\n", + " print('Epoch {}, Loss Value: {:.5f}'.format\n", + " (epoch + 1, running_loss / ((i+1)*batch_size)))\n", + " # zero the loss\n", + " running_loss = 0.0\n", + "\n", + "\n", + "print(\"The network has been successfully trained for {} epochs.\".format(n_epochs))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Accuracy after the training phase\n", + "Once we have trained our model we can check its accuracy on the testing dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def testAccuracy(net, test_loader, device):\n", + " '''\n", + " Function for testing the accuracy of the model.\n", + "\n", + " :param nn.Module net: network under consideration\n", + " :param iterable test_loader: iterable object, it load the dataset for\n", + " testing. It iterates over the given dataset, obtained combining a\n", + " dataset(images, labels) and a sampler.\n", + " '''\n", + " net.eval()\n", + " accuracy = 0.0\n", + " total = 0.0\n", + " net.to(device)\n", + " \n", + " with torch.no_grad():\n", + " for data in test_loader:\n", + " images, labels = data\n", + " images = images.to(device)\n", + " labels = labels.to(device)\n", + " # run the model on the test set to predict labels\n", + " outputs = net(images)\n", + " # the label with the highest energy will be our prediction\n", + " _, predicted = torch.max(outputs.data, 1)\n", + " total += labels.size(0)\n", + " accuracy += (predicted == labels).sum().item()\n", + "\n", + " # compute the accuracy over all test images\n", + " accuracy = (100 * accuracy / total)\n", + " return(accuracy)\n", + "\n", + "\n", + "def testClasses(net, n_classes, test_loader, classes, device):\n", + " '''\n", + " Function testing the accuracy reached for each class\n", + " composing the dataset.\n", + "\n", + " :param nn.Module net: network under consideration\n", + " :param int n_classes: number of classes composing the dataset\n", + " :param iterable test_loader: iterable object, it load the dataset for\n", + " testing. It iterates over the given dataset, obtained combining a\n", + " dataset(images, labels) and a sampler.\n", + " '''\n", + " class_correct = list(0. for i in range(n_classes))\n", + " class_total = list(0. for i in range(n_classes))\n", + " net.eval()\n", + " net.to(device)\n", + " \n", + " with torch.no_grad():\n", + " for data in test_loader:\n", + " images, labels = data\n", + " images = images.to(device)\n", + " labels = labels.to(device) \n", + " outputs = net(images)\n", + " _, predicted = torch.max(outputs, 1)\n", + " c = (predicted == labels).squeeze()\n", + " if len(labels)==1:\n", + " c = torch.tensor([c])\n", + " for i in range(len(labels)):\n", + " label = labels[i]\n", + " class_correct[label] += c[i].item()\n", + " class_total[label] += 1\n", + "\n", + " for i in range(n_classes):\n", + " print('Accuracy of {} : {:.2f}%'.format(\n", + " classes[i], 100 * class_correct[i] / class_total[i]))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The accuracy over the whole test set is 87.51%\n", + "Accuracy of airplane : 92.30%\n", + "Accuracy of automobile : 96.80%\n", + "Accuracy of bird : 87.90%\n", + "Accuracy of cat : 82.40%\n", + "Accuracy of deer : 87.30%\n", + "Accuracy of dog : 73.80%\n", + "Accuracy of frog : 89.50%\n", + "Accuracy of horse : 87.30%\n", + "Accuracy of ship : 92.80%\n", + "Accuracy of truck : 85.00%\n" + ] + } + ], + "source": [ + "accuracy = testAccuracy(VGGnet, test_loader, device)\n", + "print('The accuracy over the whole test set is {:.2f}%'.format(accuracy))\n", + "testClasses(VGGnet, n_classes, test_loader, classes, device)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Creating a checkpoint of the state of the network\n", + "Once the training is done, the state of the network should be saved for a later use." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import copy\n", + "torch.save(copy.deepcopy(VGGnet), 'check_vgg.pth')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Loading state of the network from a checkpoint file\n", + "Once the state of the network has been saved in a ***.pth*** file, we can load it for a futher use, as an additional training or other tests." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "VGGnet = torch.load('check_vgg.pth')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The accuracy over the whole test set is 87.51%\n", + "Accuracy of airplane : 92.30%\n", + "Accuracy of automobile : 96.80%\n", + "Accuracy of bird : 87.90%\n", + "Accuracy of cat : 82.40%\n", + "Accuracy of deer : 87.30%\n", + "Accuracy of dog : 73.80%\n", + "Accuracy of frog : 89.50%\n", + "Accuracy of horse : 87.30%\n", + "Accuracy of ship : 92.80%\n", + "Accuracy of truck : 85.00%\n" + ] + } + ], + "source": [ + "accuracy = testAccuracy(VGGnet, test_loader, device)\n", + "print('The accuracy over the whole test set is {:.2f}%'.format(accuracy))\n", + "testClasses(VGGnet, n_classes, test_loader, classes, device)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + }, + "vscode": { + "interpreter": { + "hash": "8c5bf16c94eb6f9341fa612a12f652937166e39821fa969ec7095b77ab48ffd1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/smithers/ml/utils_imagerec.py b/smithers/ml/utils_imagerec.py new file mode 100644 index 0000000..cee8d92 --- /dev/null +++ b/smithers/ml/utils_imagerec.py @@ -0,0 +1,160 @@ +''' +Utilities for initiliazing, training and testing a network +for the problem of Image Recognition. +''' +import copy +import torch +import torch.nn as nn +import torch.optim as optim + + +def decimate(tensor, m): + ''' + Decimate a tensor by a factor 'm', i.e. downsample by keeping every + 'm'th value. This is used when we convert FC layers to equivalent + Convolutional layers, but of a smaller size. + :param torch.Tensor tensor: tensor to be decimated + :param list m: list of decimation factors for each dimension of the + tensor; None if not to be decimated along a dimension + :return: decimated tensor + :rtype: torch.Tensor + ''' + assert tensor.dim() == len(m) + for d in range(tensor.dim()): + if m[d] is not None: + tensor = tensor.index_select(dim=d, + index=torch.arange(start=0, + end=tensor.size(d), + step=m[d]).long()) + + return tensor + +def train(net, num_epochs, train_loader, test_loader, optim_str, device): + ''' + Function performing the training of a network. + + :param nn.Module net: network under consideration + :param int num_epochs: number of training epochs + :param iterable train_loader: iterable object, it load the dataset for + training. It iterates over the given dataset, obtained combining a + dataset(images, labels) and a sampler. + :param iterable test_loader: iterable object, it load the dataset for + testing. It iterates over the given dataset, obtained combining a + dataset(images, labels) and a sampler. + :param str optim_str: optimizer to use in the training + :param torch.device device: object representing the device on + which a torch.Tensor is or will be allocated. + ''' + criterion = nn.CrossEntropyLoss() + if optim_str == 'sgd': + optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) + elif optim_str == 'adam': + optimizer = optim.Adam(net.parameters(), lr=0.001) + + net.to(device) + batch_size = train_loader.batch_size() + for epoch in range(num_epochs): # loop over the dataset multiple times + running_loss = 0.0 + + for i, (images, labels) in enumerate(train_loader, 0): + images = images.to(device) + labels = labels.to(device) + # zero the parameter gradients + optimizer.zero_grad() + # predict classes using images from the training set + outputs = net(images) + # compute the loss based on model output and real labels + loss = criterion(outputs, labels) + # backpropagate the loss + loss.backward() + # adjust parameters based on the calculated gradients + optimizer.step() + + # Let's print statistics at the end of the epoch + running_loss += loss.item() # extract the loss value + if i == len(train_loader)-1: + print('Epoch {}, Loss Value: {:.5f}'.format + (epoch + 1, running_loss / ((i+1)*batch_size))) + # zero the loss + running_loss = 0.0 + + # Compute and print the average accuracy fo this epoch when + # tested over all 10000 test images + accuracy_train = testAccuracy(net, train_loader, device) + print('For epoch {} the train accuracy over the whole train set' + + 'is {:.2f}%'.format(epoch + 1, accuracy_train)) + accuracy = testAccuracy(net, test_loader, device) + print('For epoch {} the test accuracy over the whole test set' + + 'is {:.2f}%'.format(epoch + 1, accuracy)) + + torch.save(copy.deepcopy(net), 'check_network.pth') + +def testAccuracy(net, test_loader, device): + ''' + Function for testing the accuracy of the model. + + :param nn.Module net: network under consideration + :param iterable test_loader: iterable object, it load the dataset for + testing. It iterates over the given dataset, obtained combining a + dataset(images, labels) and a sampler. + :param torch.device device: object representing the device on + which a torch.Tensor is or will be allocated. + ''' + net.eval() + accuracy = 0.0 + total = 0.0 + net.to(device) + + with torch.no_grad(): + for data in test_loader: + images, labels = data + images = images.to(device) + labels = labels.to(device) + # run the model on the test set to predict labels + outputs = net(images) + # the label with the highest energy will be our prediction + _, predicted = torch.max(outputs.data, 1) + total += labels.size(0) + accuracy += (predicted == labels).sum().item() + + # compute the accuracy over all test images + accuracy = (100 * accuracy / total) + return accuracy + + +def testClasses(net, n_classes, test_loader, classes, device): + ''' + Function testing the accuracy reached for each class + composing the dataset. + + :param nn.Module net: network under consideration + :param int n_classes: number of classes composing the dataset + :param iterable test_loader: iterable object, it load the dataset for + testing. It iterates over the given dataset, obtained combining a + dataset(images, labels) and a sampler. + :param torch.device device: object representing the device on + which a torch.Tensor is or will be allocated. + ''' + class_correct = list(0. for i in range(n_classes)) + class_total = list(0. for i in range(n_classes)) + net.eval() + net.to(device) + + with torch.no_grad(): + for data in test_loader: + images, labels = data + images = images.to(device) + labels = labels.to(device) + outputs = net(images) + _, predicted = torch.max(outputs, 1) + c = (predicted == labels).squeeze() + if len(labels) == 1: + c = torch.tensor([c]) + for i, _ in range(len(labels)): + label = labels[i] + class_correct[label] += c[i].item() + class_total[label] += 1 + + for i in range(n_classes): + print('Accuracy of {} : {:.2f}%'.format( + classes[i], 100 * class_correct[i] / class_total[i])) diff --git a/smithers/ml/utils_objdet.py b/smithers/ml/utils_objdet.py new file mode 100644 index 0000000..fdadfe5 --- /dev/null +++ b/smithers/ml/utils_objdet.py @@ -0,0 +1,1105 @@ +''' +Utilities for the transformations needed inside a CNN and performing +object detection +''' +import random +import torch +import torch.nn.functional as F +import torchvision.transforms.functional as FT +import numpy as np + +device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + + +def decimate(tensor, m): + ''' + Decimate a tensor by a factor 'm', i.e. downsample by keeping every + 'm'th value. This is used when we convert FC layers to equivalent + Convolutional layers, but of a smaller size. + :param torch.Tensor tensor: tensor to be decimated + :param list m: list of decimation factors for each dimension of the + tensor; None if not to be decimated along a dimension + :return: decimated tensor + :rtype: torch.Tensor + ''' + assert tensor.dim() == len(m) + for d in range(tensor.dim()): + if m[d] is not None: + tensor = tensor.index_select(dim=d, + index=torch.arange(start=0, + end=tensor.size(d), + step=m[d]).long()) + + return tensor + + +def find_intersection(set_1, set_2): + ''' + Find the intersection of every box combination between two sets of boxes + that are in boundary coordinates. + + :param torch.Tensor set_1: set 1, a tensor of dimensions (n1, 4) + :param torch.Tensor set_2: set 2, a tensor of dimensions (n2, 4) + :return: intersection of each of the boxes in set 1 with respect to each + of the boxes in set 2, i.e. a tensor of dimensions (n1, n2) + :rtype: torch.Tensor + ''' + + # PyTorch auto-broadcasts singleton dimensions + lower_bounds = torch.max(set_1[:, :2].unsqueeze(1), + set_2[:, :2].unsqueeze(0)) # (n1, n2, 2) + upper_bounds = torch.min(set_1[:, 2:].unsqueeze(1), + set_2[:, 2:].unsqueeze(0)) # (n1, n2, 2) + intersection_dims = torch.clamp(upper_bounds - lower_bounds, + min=0) # (n1, n2, 2) + # intersection is given by the area of the box, those the area of + # a rectangular + return intersection_dims[:, :, 0] * intersection_dims[:, :, 1] # (n1, n2) + + +def find_jaccard_overlap(set_1, set_2): + ''' + Find the Jaccard Overlap (IoU) of every box combination between two + sets of boxes that are in boundary coordinates. + + :param torch.Tensor set_1: set 1, a tensor of dimensions (n1, 4) + :param torch.Tensor set_2: set 2, a tensor of dimensions (n2, 4) + :return: Jaccard Overlap (float) of each of the boxes in set 1 with + respect to each of the boxes in set 2, i.e. a tensor of + dimensions (n1, n2) + :rtype: torch.Tensor + ''' + + # Find intersections + intersection = find_intersection(set_1, set_2) # (n1, n2) + + # Find areas of each box in both sets + areas_set_1 = (set_1[:, 2] - set_1[:, 0]) * (set_1[:, 3] - set_1[:, 1] + ) # (n1) + areas_set_2 = (set_2[:, 2] - set_2[:, 0]) * (set_2[:, 3] - set_2[:, 1] + ) # (n2) + + # Find the union + # PyTorch auto-broadcasts singleton dimensions + union = areas_set_1.unsqueeze(1) + areas_set_2.unsqueeze( + 0) - intersection # (n1, n2) + + return intersection / union # (n1, n2) + + +def xy_to_cxcy(xy): + ''' + Convert bounding boxes from boundary coordinates + (x_min, y_min, x_max, y_max) to center-size + coordinates (c_x, c_y, w, h). + + :param torch.Tensor xy: bounding boxes in boundary coordinates, a tensor + of size (n_boxes, 4) + :return: bounding boxes in center-size coordinates, a tensor of + size (n_boxes, 4) + :rtype: torch.Tensor + ''' + return torch.cat( + [ + (xy[:, 2:] + xy[:, :2]) / 2, # c_x, c_y + xy[:, 2:] - xy[:, :2] + ], + 1) # w, h + + +def cxcy_to_xy(cxcy): + ''' + Convert bounding boxes from center-size coordinates (c_x, c_y, w, h) + to boundary coordinates (x_min, y_min, x_max, y_max). + + :param torch.Tensor cxcy: bounding boxes in center-size coordinates, a + tensor of size (n_boxes, 4) + :return: bounding boxes in boundary coordinates, a tensor of + size (n_boxes, 4) + :rtype: torch.Tensor + ''' + return torch.cat( + [ + cxcy[:, :2] - (cxcy[:, 2:] / 2), # x_min, y_min + cxcy[:, :2] + (cxcy[:, 2:] / 2) + ], + 1) # x_max, y_max + + +def cxcy_to_gcxgcy(cxcy, priors_cxcy): + ''' + Encode bounding boxes (that are in center-size form) w.r.t. + the corresponding prior boxes (that are in center-size form). + Thus the offests are found, i.e. how much the prior has to + be adjusted to produce the bounding box. + For the center coordinates, find the offset with respect to + the prior box, and scale by the size of the prior box. + For the size coordinates, scale by the size of the prior box, + and convert to the log-space. + + In the model, we are predicting bounding box coordinates in this + encoded form. + + :param torch.Tensor cxcy: bounding boxes in center-size coordinates, + a tensor of size (n_priors, 4) + :param troch.Tensor priors_cxcy: prior boxes with respect to which + the encoding must be performed, a tensor of size (n_priors, 4) + :return: encoded bounding boxes, a tensor of size (n_priors, 4) + :rtype: torch.Tensor + ''' + + # The 10 and 5 below are referred to as 'variances' in the + # original Caffe repo, completely empirical. They are for some + # sort of numerical conditioning, for 'scaling the localization gradient' + # See https://github.com/weiliu89/caffe/issues/155 + return torch.cat( + [ + (cxcy[:, :2] - priors_cxcy[:, :2]) / + (priors_cxcy[:, 2:] / 10), # g_c_x, g_c_y + torch.log(cxcy[:, 2:] / priors_cxcy[:, 2:]) * 5 + ], + 1) # g_w, g_h + + +def gcxgcy_to_cxcy(gcxgcy, priors_cxcy): + ''' + Decode bounding box coordinates predicted by the model, since + they are encoded in the form mentioned above. + (see function cxcy_to_gcxgcy) + They are decoded into center-size coordinates. + + This is the inverse of the function above. + + :param torch.Tensor gcxgcy: encoded bounding boxes, i.e. output of the + model, a tensor of size (n_priors, 4) + :param torch.Tensor priors_cxcy: prior boxes with respect to which the + encoding is defined, a tensor of size (n_priors, 4) + :return: decoded bounding boxes in center-size form, a tensor of + size (n_priors, 4) + :rtype: torch.Tensor + ''' + + return torch.cat( + [ + gcxgcy[:, :2] * priors_cxcy[:, 2:] / 10 + + priors_cxcy[:, :2], # c_x, c_y + torch.exp(gcxgcy[:, 2:] / 5) * priors_cxcy[:, 2:] + ], + 1) # w, h + + +def create_prior_boxes(fmap_dims=None, obj_scales=None, aspect_ratios=None): + ''' + Create the 8732 prior (default) boxes for the SSD300, as defined + in the paper. + + :param dict fmap_dict: If None, it corresponds to the dimension of + the low and high(auxiliary) feature maps for SSD300. Otherwise, + you need to provide a dictionary, where the keys are the + convolutional layers and the values associated are the + dimensions of those feature maps. + :param dict obj_scales: If None, it returns the scaling values for + the priors in SSD300, i.e the percentage of the image that is + detected. In particular, in SSD300 larger feature maps as + conv4_3 have smaller object scales, thus they will used to + detect smaller objects. Otherwise you need to provide a + dictionary where the keys are the convolutional layers + corresponding to the low and high level features anf the values + associated the scales used for each of them. + :param dict aspect_ratios: If None, the aspect ratios used are that + of SSD300. Otherwise, you need to provide a dictionary where + the keys are the low and high level feature maps and the value + associated is a list with the different aspect ratios used for + the priors in that layer. + :return: prior boxes in center-size coordinates, a tensor of + dimensions (8732, 4) + :rtype: torch.Tensor + ''' + + if fmap_dims is None: + fmap_dims = { + 'conv4_3': 38, + 'conv7': 19, + 'conv8_2': 10, + 'conv9_2': 5, + 'conv10_2': 3, + 'conv11_2': 1 + } + if obj_scales is None: + obj_scales = { + 'conv4_3': 0.1, + 'conv7': 0.2, + 'conv8_2': 0.375, + 'conv9_2': 0.55, + 'conv10_2': 0.725, + 'conv11_2': 0.9 + } + if aspect_ratios is None: + aspect_ratios = { + 'conv4_3': [1., 2., 0.5], + 'conv7': [1., 2., 3., 0.5, .333], + 'conv8_2': [1., 2., 3., 0.5, .333], + 'conv9_2': [1., 2., 3., 0.5, .333], + 'conv10_2': [1., 2., 0.5], + 'conv11_2': [1., 2., 0.5] + } + + fmaps = list(fmap_dims.keys()) + + prior_boxes = [] + + for k, fmap in enumerate(fmaps): + for i in range(fmap_dims[fmap]): + for j in range(fmap_dims[fmap]): + cx = (j + 0.5) / fmap_dims[fmap] + cy = (i + 0.5) / fmap_dims[fmap] + + for ratio in aspect_ratios[fmap]: + prior_boxes.append([ + cx, cy, obj_scales[fmap] * np.sqrt(ratio), + obj_scales[fmap] / np.sqrt(ratio) + ]) + + # For an aspect ratio of 1, use an additional prior + # whose scale is the geometric mean of the scale of + # the current feature map and the scale of the next + # feature map + if ratio == 1.: + try: + additional_scale = np.sqrt(obj_scales[fmap] * + obj_scales[fmaps[k + 1]]) + # For the last feature map, there is no "next" + # feature map + except IndexError: + additional_scale = 1. + prior_boxes.append( + [cx, cy, additional_scale, additional_scale]) + + prior_boxes = torch.FloatTensor(prior_boxes).to(device) # (8732, 4) + prior_boxes.clamp_(0, 1) # (8732, 4) + + return prior_boxes + + +def expand(image, boxes, filler): + ''' + Perform a zooming out operation by placing the image in a larger canvas + of filler material. This helps to learn to detect smaller objects. + + :param torch.Tensor image: image, a tensor of dimensions + (3, original_h, original_w) + :param torch.Tensor boxes: bounding boxes in boundary coordinates, a tensor + of dimensions (n_objects, 4) + :param list filler: RBG values of the filler material, a list like [R, G, B] + where R, G, B are scalar values + :return: expanded image, updated bounding box coordinates + :rtype: torch.Tensor, torch.Tensor + ''' + # Calculate dimensions of proposed expanded (zoomed-out) image + original_h = image.size(1) + original_w = image.size(2) + # The zoomed out image must be between 1 and 4 times as large as the + # original. + max_scale = 4 + scale = random.uniform(1, max_scale) + new_h = int(scale * original_h) + new_w = int(scale * original_w) + + # Create such an image with the filler + filler = torch.FloatTensor(filler) # (3) + new_image = torch.ones( + (3, new_h, new_w), dtype=torch.float) * filler.unsqueeze(1).unsqueeze( + 1) # (3, new_h, new_w) + # Note - do not use expand() like + # new_image = filler.unsqueeze(1).unsqueeze(1).expand(3, new_h, new_w) + # because all expanded values will share the same memory, so changing one + # pixel will change all + + # Place the original image at random coordinates in this new image + # (origin at top-left of image) + left = random.randint(0, new_w - original_w) + right = left + original_w + top = random.randint(0, new_h - original_h) + bottom = top + original_h + new_image[:, top:bottom, left:right] = image + + # Adjust bounding boxes' coordinates accordingly + new_boxes = boxes + torch.FloatTensor([left, top, left, top]).unsqueeze( + 0) # (n_objects, 4), n_objects is the no. of objects in this image + + return new_image, new_boxes + + +def random_crop(image, boxes, labels, difficulties): + ''' + Performs a random crop(zoom in) in the manner stated in the SSD paper. + Helps to learn to detect larger and partial objects. Note that some + objects may be cut out entirely. Adapted from: + https://github.com/amdegroot/ssd.pytorch/blob/master/utils/augmentations.py + + :param torch.Tensor image: image, a tensor of dimensions + (3, original_h, original_w) + :param torch.Tensor boxes: bounding boxes in boundary coordinates, a tensor + of dimensions (n_objects, 4) + :param torch.Tensor labels: labels of objects, a tensor of dimensions + (n_objects) + :param torch.Tensor difficulties: difficulties of detection of these objs, + a tensor of dimensions (n_objects) + :return: cropped image, updated bounding box coordinates, updated labels, + updated difficulties + :rtype: torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor + ''' + original_h = image.size(1) + original_w = image.size(2) + # Keep choosing a minimum overlap until a successful crop is made + while True: + # Randomly draw the value for minimum overlap + min_overlap = random.choice([0., .1, .3, .5, .7, .9, + None]) # 'None' refers to no cropping + #print('min_overlap', min_overlap) + # If not cropping, thus if we have None, we exit and return the + # original image + if min_overlap is None: + #print('min overlap is None') + return image, boxes, labels, difficulties + + # Try up to 50 times for this choice of minimum overlap + # This isn't mentioned in the paper, of course, but 50 is chosen in + # paper authors' original Caffe repo + max_trials = 50 + for _ in range(max_trials): + #print('current trial', _) + # Crop dimensions must be in [0.3, 1] of original dimensions + # Note - it's [0.1, 1] in the paper, but actually [0.3, 1] in the + # authors' repo + min_scale = 0.3 + scale_h = random.uniform(min_scale, 1) + scale_w = random.uniform(min_scale, 1) + new_h = int(scale_h * original_h) + new_w = int(scale_w * original_w) + # Aspect ratio has to be in [0.5, 2] + aspect_ratio = new_h / new_w + if not 0.5 < aspect_ratio < 2: + #print('Aspect ratio not in the range allowed') + continue + + # Crop coordinates (origin at top-left of image) + left = random.randint(0, original_w - new_w) + right = left + new_w + top = random.randint(0, original_h - new_h) + bottom = top + new_h + crop = torch.FloatTensor([left, top, right, bottom]) # (4) + + # Calculate Jaccard overlap between the crop and the bounding boxes + overlap = find_jaccard_overlap( + crop.unsqueeze(0), boxes + ) # (1, n_objects), n_objects is the no. of objects in this image + overlap = overlap.squeeze(0) # (n_objects) + + # If not a single bounding box has a Jaccard overlap of greater than + # the minimum, try again + if overlap.max().item() < min_overlap: + #print( + # 'no bounding box has Jaccard overlap greater than\ + # the minimum' + #) + continue + + # Crop image + new_image = image[:, top:bottom, left:right] # (3, new_h, new_w) + + # Find centers of original bounding boxes + bb_centers = (boxes[:, :2] + boxes[:, 2:]) / 2. # (n_objects, 2) + + # Find bounding boxes whose centers are in the crop, thus at the end + # not all the bounding boxes may be in the crop + centers_in_crop = (bb_centers[:, 0] > left) * ( + bb_centers[:, 0] < right) * (bb_centers[:, 1] > + top) * (bb_centers[:, 1] < bottom) + # size centers_in_crop: (n_objects), a Torch uInt8/Byte tensor, can + # be used as a boolean index + + # If not a single bounding box has its center in the crop, try again + if not centers_in_crop.any(): + #print('No bounding box has its center in the crop') + continue + + # Discard bounding boxes that don't meet this criterion + new_boxes = boxes[centers_in_crop, :] + new_labels = labels[centers_in_crop] + new_difficulties = difficulties[centers_in_crop] + + # Calculate bounding boxes' new coordinates in the crop + new_boxes[:, :2] = torch.max(new_boxes[:, :2], + crop[:2]) # crop[:2] is [left, top] + # adjust to crop (by substracting crop's left,top), idem below + new_boxes[:, :2] -= crop[:2] + new_boxes[:, + 2:] = torch.min(new_boxes[:, 2:], + crop[2:]) # crop[2:] is [right, bottom] + new_boxes[:, 2:] -= crop[:2] + #print(new_image.size()) + return new_image, new_boxes, new_labels, new_difficulties + + +def flip(image, boxes): + ''' + Flip image horizontally. + + :param PIL Image image: image, a PIL Image + :param torch.Tensor boxes: bounding boxes in boundary coordinates, a tensor + of dimensions (n_objects, 4) + :return: flipped image, updated bounding box coordinates + :rtype: PIL Image, torch.Tensor + ''' + # Flip image horizontally + new_image = FT.hflip(image) + + # Flip boxes + new_boxes = boxes + new_boxes[:, 0] = image.width - boxes[:, 0] - 1 + new_boxes[:, 2] = image.width - boxes[:, 2] - 1 + new_boxes = new_boxes[:, [2, 1, 0, 3]] + + return new_image, new_boxes + + +def photometric_distort(image): + ''' + Distort brightness, contrast, saturation, and hue, each with a 50% chance, + in random order. + + :param PIL Image image: image, a PIL Image + :return: distorted image + :rtype: PIL Image + ''' + new_image = image + + distortions = [ + FT.adjust_brightness, FT.adjust_contrast, FT.adjust_saturation, + FT.adjust_hue + ] + + random.shuffle(distortions) + + for d in distortions: + if random.random() < 0.5: + if d.__name__ == 'adjust_hue': + # Caffe repo uses a 'hue_delta' of 18 - we divide by 255 + #because PyTorch needs a normalized value + adjust_factor = random.uniform(-18 / 255., 18 / 255.) + else: + # Caffe repo uses 'lower' and 'upper' values of 0.5 and 1.5 + #for brightness, contrast, and saturation + adjust_factor = random.uniform(0.5, 1.5) + + # Apply this distortion + new_image = d(new_image, adjust_factor) + + return new_image + + +def resize(image, boxes, dims=(300, 300), return_percent_coords=True): + ''' + Resize image. For the SSD300, it resizes to (300, 300). + + Since percent/fractional coordinates are calculated for the bounding boxes + (w.r.t image dimensions) in this process, you may choose to retain them. + + :param PIL Image image: image, a PIL Image + :param torch.Tensor boxes: bounding boxes in boundary coordinates, a tensor + of dimensions (n_objects, 4) + :param tuple dims: if None, the image is rescaled to (300,300) as needed + for SSD300. Otherwise, a tuple with the desired dimensions need to + be provided. + :param bool return_percent_coords: If True, it returns the + percent/fractional coordinates. Otherwise, it returns the new + coordinates of the bounding boxes for the rescaled image. + :return: resized image, updated tensor for bounding box + coordinates.(or fractional coordinates, in which case they + remain the same) + :rtype: PIL Image, torch.Tensor + ''' + # Resize image + new_image = FT.resize(image, dims) + + # Resize bounding boxes + old_dims = torch.FloatTensor( + [image.width, image.height, image.width, image.height]).unsqueeze(0) + new_boxes = boxes / old_dims # percent coordinates + + if not return_percent_coords: + new_dims = torch.FloatTensor([dims[1], dims[0], dims[1], + dims[0]]).unsqueeze(0) + new_boxes = new_boxes * new_dims + + return new_image, new_boxes + + +def transform(image, boxes, labels, difficulties, split): + ''' + Apply the transformations above. + NOTE: Since random_crop is used, the output size from the bounding boxes + may differ from that of the input bounding boxes + + :param PIL Image image: image, a PIL Image + :param torch.Tensor boxes: bounding boxes in boundary coordinates, a + tensor of dimensions (n_objects, 4) + :param torch.Tensor labels: a tensor of dimensions (n_objects) containing + the labels of objects. + :param torch.Tensor difficulties: a tensor of dimensions (n_objects) + representing the difficulties of detection for the objects in + the picture. + :param str split: Expected strings are: 'TRAIN' or 'TEST', since + different sets of transformations are applied. If a different string + is given, an error arise. + :return: transformed image, transformed bounding box coordinates, + transformed labels, transformed difficulties + :rtype: torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor + ''' + assert split in {'TRAIN', 'TEST'} + + # Mean and standard deviation of ImageNet data that our base VGG from + # torchvision was trained on. + # See: https://pytorch.org/docs/stable/torchvision/models.html + mean = [0.485, 0.456, 0.406] + std = [0.229, 0.224, 0.225] + + new_image = image + new_boxes = boxes + new_labels = labels + new_difficulties = difficulties + # Skip the following operations if evaluation/testing + if split == 'TRAIN': + # A series of photometric distortions in random order, each with + # 50% chance of occurrence, as in Caffe repo + new_image = photometric_distort(new_image) + + # Convert PIL image to Torch tensor + new_image = FT.to_tensor(new_image) + + # Expand image (zoom out) with a 50% chance - helpful for training + # detection of small objects. Fill surrounding space with the mean + # of ImageNet data that our base VGG was trained on + if random.random() < 0.5: + new_image, new_boxes = expand(new_image, boxes, filler=mean) + + # Randomly crop image (zoom in) + new_image, new_boxes, new_labels, new_difficulties = random_crop( + new_image, new_boxes, new_labels, new_difficulties) + + # Convert Torch tensor to PIL image + new_image = FT.to_pil_image(new_image) + + # Flip image with a 50% chance + if random.random() < 0.5: + new_image, new_boxes = flip(new_image, new_boxes) + + # Resize image to (300, 300) - this also converts absolute boundary + #coordinates to their fractional form + new_image, new_boxes = resize(new_image, new_boxes, dims=(300, 300)) + + # Convert PIL image to Torch tensor + new_image = FT.to_tensor(new_image) + + # Normalize by mean and standard deviation of ImageNet data that our + #base VGG was trained on + new_image = FT.normalize(new_image, mean=mean, std=std) + + return new_image, new_boxes, new_labels, new_difficulties + + +class AverageMeter(object): + ''' + Keeps track of most recent value, average, sum, and count of a + metric. + ''' + def __init__(self): + self.reset() + + def reset(self): + ''' + Reset value, average, sum and count of the metric. + ''' + self.val = 0 + self.avg = 0 + self.sum = 0 + self.count = 0 + + def update(self, val, n=1): + ''' + Update value, sum, counter and average of the metric. + + :param int val: current value of the object we are considering + :param int n: integer number corresponding to the step at which + we are updating the counter and other values + ''' + self.val = val + self.sum += val * n + self.count += n + self.avg = self.sum / self.count + + +def clip_gradient(optimizer, grad_clip): + ''' + Clips gradients computed during backpropagation in order to avoid + explosion of gradients. + + :param optimizer: optimizer with the gradients to be clipped + :param grad_clip: clip value + ''' + for group in optimizer.param_groups: + for param in group['params']: + if param.grad is not None: + param.grad.data.clamp_(-grad_clip, grad_clip) + + +def save_checkpoint_objdet(epoch, model, optimizer, path): + ''' + Save model checkpoint. + + :param scalar epoch: epoch number + :param list model: list of constructed classes that compose our network + :param torch.Tensor optimizer: optimizer chosen + :parma str path: path to the checkpoint file. + :return: path to the checkpoint file, with the current status of the net. + :rtype: str + ''' + state = {'epoch': epoch, 'model': model, 'optimizer': optimizer} + torch.save(state, path) + return path + + +def adjust_learning_rate(optimizer, scale): + ''' + Scale learning rate by a specified factor. + + :param optimizer: optimizer whose learning rate must be shrunk. + :param float scale: factor to multiply learning rate with. + ''' + for param_group in optimizer.param_groups: + param_group['lr'] *= scale + print("DECAYING learning rate.\n The new LR is %f\n" % + (optimizer.param_groups[-1]['lr'], )) + + + +def non_max_sup(n_above_min_score, class_decoded_locs, overlap, max_overlap): + ''' + Non-Maximum Suppression (NMS) + + :param n_above_min_score + :param torch.Tensor class_decoded_locs: (n_qualified, 4) + :param torch.Tensor overlap: tensor containing Jaccard overlap between + predicted boxes, size (n_above_min_score, n_above_min_score) + :param float max_overlap: maximum overlap two boxes can have so that the + one with the lower score is not suppressed via NMS + :return: NMS + :rtype: torch.Tensor + ''' + # A torch.uint8 (byte) tensor to keep track of which predicted boxes + # to suppress: 1 implies suppress, 0 implies don't suppress + suppress = torch.zeros((n_above_min_score), + dtype=torch.uint8).to(device) # (n_qualified) + + # Consider each box in order of decreasing scores + for box in range(class_decoded_locs.size(0)): + # If this box is already marked for suppression + if suppress[box] == 1: + continue + + # Suppress boxes whose overlaps (with this box) are greater than + # maximum overlap (but we are keeping the box we are considering + # in the for loop). Find such boxes and update suppress indices. + suppress = torch.max( + suppress, + (overlap[box] > max_overlap).byte()) #type(torch.ByteTensor)) + # The max operation retains previously suppressed boxes, like an 'OR' + # operation + + # Don't suppress this box, even though it has an overlap of 1 with + # itself + suppress[box] = 0 + return suppress + + +def detect_objects(priors_cxcy, predicted_locs, predicted_scores, n_classes, + min_score, max_overlap, top_k): + ''' + Decipher the 8732 locations and class scores (output of the SSD300) + to detect objects. For each class, perform Non-Maximum Suppression (NMS) + on boxes that are above a minimum threshold. + + :param torch.Tensor priors_cxcy: priors (default bounding boxes) in + center-size coordinates, a tensor of size (n_boxes, 4) + :param torch.Tensor predicted_locs: predicted locations/boxes w.r.t the 8732 + prior boxes, a tensor of dimensions (N, 8732, 4) + :param torch.Tensor predicted_scores: class scores for each of the encoded + locations/boxes, a tensor of dimensions (N, 8732, n_classes) + :param scalar n_classes: number of different type of objects in your dataset + :param float min_score: minimum threshold for a box to be considered a match + for a certain class + :param float max_overlap: maximum overlap two boxes can have so that the one + with the lower score is not suppressed via NMS + :param int top_k: if there are a lot of resulting detection across all + classes, keep only the top 'k' + :return: detections (boxes, labels, and scores), lists of length + batch_size + :rtype: list, list, list + ''' + batch_size = predicted_locs.size(0) + n_priors = priors_cxcy.size(0) + predicted_scores = F.softmax(predicted_scores, + dim=2) # (N, 8732, n_classes) + + # Lists to store final predicted boxes, labels, and scores for all images + all_images_boxes = list() + all_images_labels = list() + all_images_scores = list() + + assert n_priors == predicted_locs.size(1) == predicted_scores.size(1) + + for i in range(batch_size): + # Decode object coordinates from the form we regressed predicted + # boxes to + decoded_locs = cxcy_to_xy(gcxgcy_to_cxcy(predicted_locs[i], + priors_cxcy)) + # (8732, 4), these are fractional pt. coordinates + + # Lists to store boxes and scores for this image + image_boxes = list() + image_labels = list() + image_scores = list() + + max_scores, best_label = predicted_scores[i].max(dim=1) # (8732) + + # Check for each class + # Note: we do not consider class 0, that is associated with background. + for c in range(1, n_classes): + # Keep only predicted boxes and scores where scores for this class + # are above the minimum score + class_scores = predicted_scores[i][:, c] # (8732) + score_above_min_score = class_scores > min_score + # torch.uint8 (byte) tensor, for indexing + n_above_min_score = score_above_min_score.sum().item() + if n_above_min_score == 0: + continue + class_scores = class_scores[score_above_min_score] # (n_qualified) + #n_qualified=n_above_min_score <= 8732 + class_decoded_locs = decoded_locs[ + score_above_min_score] # (n_qualified, 4) + + # Sort predicted boxes and scores by scores + class_scores, sort_ind = class_scores.sort( + dim=0, descending=True) # (n_qualified), (n_above_min_score) + class_decoded_locs = class_decoded_locs[ + sort_ind] # (n_above_min_score, 4) + + # Find the overlap between predicted boxes + overlap = find_jaccard_overlap( + class_decoded_locs, + class_decoded_locs) # (n_above_min_score, n_above_min_score) + + ################################# + # Non-Maximum Suppression (NMS) # + ################################# + suppress = non_max_sup(n_above_min_score, class_decoded_locs, + overlap, max_overlap) + + # Store only unsuppressed boxes for this class + image_boxes.append(class_decoded_locs[~suppress.bool()]) + image_labels.append( + torch.LongTensor((1 - suppress).sum().item() * [c]).to(device)) + image_scores.append(class_scores[~suppress.bool()]) + + # If no object in any class is found, store a placeholder for + # 'background' + if len(image_boxes) == 0: + image_boxes.append(torch.FloatTensor([[0., 0., 1., 1.]]).to(device)) + image_labels.append(torch.LongTensor([0]).to(device)) + image_scores.append(torch.FloatTensor([0.]).to(device)) + + # Concatenate into single tensors + image_boxes = torch.cat(image_boxes, dim=0) # (n_objects, 4) + image_labels = torch.cat(image_labels, dim=0) # (n_objects) + image_scores = torch.cat(image_scores, dim=0) # (n_objects) + n_objects = image_scores.size(0) + + # Keep only the top k objects + if n_objects > top_k: + image_scores, sort_ind = image_scores.sort(dim=0, descending=True) + image_scores = image_scores[:top_k] # (top_k) + image_boxes = image_boxes[sort_ind][:top_k] # (top_k, 4) + image_labels = image_labels[sort_ind][:top_k] # (top_k) + + # Append to lists that store predicted boxes and scores for all images + all_images_boxes.append(image_boxes) + all_images_labels.append(image_labels) + all_images_scores.append(image_scores) + + return all_images_boxes, all_images_labels, all_images_scores + + +def calculate_AP(true_images, true_boxes, true_difficulties, true_labels, + det_images, det_boxes, det_scores, det_labels, n_classes): + ''' + Calculate the Average Precision (AP) of detected objects. + + :param torch.Tensor true_images: tensor for storing the images with the + actual objects contained in them, size (n_objects) + :param torch.Tensor true_boxes: tensor for storing the true boxes for the + actual objects in our images, size (n_objects, 4) + :param torch.ByteTensor true_difficulties: tensor for storing the true + difficulties for the actual objects in our images, size (n_objects) + :param torch.Tensor true_labels: tensor containing actual objects' labels + for our images, size (n_objects) + :param torch.Tensor det_images: tensor for storing the images containing the + detected objects, size (n_detections) + :param torch.Tensor det_boxes: tensor for storing the boxes of the detected + objects in our images, size (n_detections, 4) + :param torch.Tensor det_scores: tensor for storing the scores of the + detected objects in our images, size (n_detections) + :param torch.Tensor det_labels: tensor containing detected objects' labels + in our images, size (n_objects) + :param int n_classes: number of classes in the dataset + :return: average_precisions (AP) corresponding to + the mean of the recalls above the threshold chosen for each class in the + dataset + :rtype: torch.Tensor + ''' + average_precisions = torch.zeros((n_classes - 1), + dtype=torch.float) # (n_classes - 1) + for c in range(1, n_classes): + # Extract only objects with this class + true_class_images = true_images[true_labels == c] # (n_class_objects) + true_class_boxes = true_boxes[true_labels == c] # (n_class_objects, 4) + true_class_difficulties = true_difficulties[true_labels == + c] # (n_class_objects) + n_easy_class_objects = ( + ~true_class_difficulties).sum().item() # ignore difficult objects + + # Keep track of which true objects with this class have already been + # 'detected'. So far, none + + true_class_boxes_detected = torch.zeros( + (true_class_difficulties.size(0)), + dtype=torch.uint8).to(device) # (n_class_objects) + + # Extract only detections with this class + det_class_images = det_images[det_labels == c] # (n_class_detections) + det_class_boxes = det_boxes[det_labels == c] # (n_class_detections, 4) + det_class_scores = det_scores[det_labels == c] # (n_class_detections) + n_class_detections = det_class_boxes.size( + 0) #number of objects detected for this class + if n_class_detections == 0: + continue + + # Sort detections in decreasing order of confidence/scores + det_class_scores, sort_ind = torch.sort( + det_class_scores, dim=0, descending=True) # (n_class_detections) + det_class_images = det_class_images[sort_ind] # (n_class_detections) + det_class_boxes = det_class_boxes[sort_ind] # (n_class_detections, 4) + + # In the order of decreasing scores, check if true or false positive + true_positives = torch.zeros( + (n_class_detections), + dtype=torch.float).to(device) # (n_class_detections) + false_positives = torch.zeros( + (n_class_detections), + dtype=torch.float).to(device) # (n_class_detections) + for d in range(n_class_detections): + # take the corresponding box and image for the detected object + # we are considering + this_detection_box = det_class_boxes[d].unsqueeze(0) # (1, 4) + this_image = det_class_images[d] # (), scalar + + # Find objects in the same image with this class, their + # difficulties, and whether they have been detected before. + # in particular given a detected obj in this class c, consider + # the other obj of the same class that you find in this_image to + # which it belong. + object_boxes = true_class_boxes[ + true_class_images == this_image] # (n_class_objects_in_img) + object_difficulties = true_class_difficulties[ + true_class_images == this_image] # (n_class_objects_in_img) + # If no such object in this image, then the detection is a false + # positive. + # It is necessary to have at least one obj, i.e. the obj in exam. + # Otherwise is a false positive + if object_boxes.size(0) == 0: + false_positives[d] = 1 + continue + + # Find maximum overlap of this detection with objects in this image + # of this class + overlaps = find_jaccard_overlap( + this_detection_box, object_boxes) # (1, n_class_objects_in_img) + max_overlap, ind = torch.max(overlaps.squeeze(0), + dim=0) # (), () - scalars + + # 'ind' is the index of the object in these image-level tensors + # 'object_boxes', 'object_difficulties' + # In the original class-level tensors 'true_class_boxes', etc., + # 'ind' corresponds to object with index... + original_ind = torch.LongTensor(range( + true_class_boxes.size(0)))[true_class_images == this_image][ind] + # We need 'original_ind' to update 'true_class_boxes_detected' + + # If the maximum overlap is greater than the threshold of 0.5, + # it's a match + if max_overlap.item() > 0.5: + # If the object it matched with is 'difficult', ignore it + if object_difficulties[ind] == 0: + # If this object has already not been detected, + # it's a true positive + if true_class_boxes_detected[original_ind] == 0: + true_positives[d] = 1 + true_class_boxes_detected[original_ind] = 1 + # this object has now been detected/accounted for + # Otherwise, it's a false positive (since this object + # is already accounted for) + else: + false_positives[d] = 1 + # Otherwise, the detection occurs in a different location than + # the actual object, and is a false positive + else: + false_positives[d] = 1 + + # Compute cumulative precision and recall at each detection + # in the order of decreasing scores + cumul_true_positives = torch.cumsum(true_positives, + dim=0) # (n_class_detections) + cumul_false_positives = torch.cumsum(false_positives, + dim=0) # (n_class_detections) + cumul_precision = cumul_true_positives / ( + cumul_true_positives + cumul_false_positives + 1e-10 + ) # cumul_precision--> size: (n_class_detections) + cumul_recall = cumul_true_positives / n_easy_class_objects + # cumul_recall--> size: (n_class_detections) + # recall = TP/(TP+FN) --> at denominator we will have all + # the objects that I want to detect (objs that are really on + # the images, not difficult to detect) + + # Find the mean of the maximum of the precisions corresponding + # to recalls above the threshold 't' + recall_thresholds = torch.arange(start=0, end=1.1, + step=.1).tolist() # (11) + precisions = torch.zeros((len(recall_thresholds)), + dtype=torch.float).to(device) # (11) + for i, t in enumerate(recall_thresholds): + recalls_above_t = cumul_recall >= t + if recalls_above_t.any(): + precisions[i] = cumul_precision[recalls_above_t].max() + else: + precisions[i] = 0. + average_precisions[c - 1] = precisions.mean() + # c is in [1, n_classes - 1] + return average_precisions + + +def calculate_mAP(det_boxes, det_labels, det_scores, true_boxes, true_labels, + true_difficulties, label_map): + ''' + Calculate the Mean Average Precision (mAP) of detected objects. + + See https://medium.com/@jonathan_hui/map-mean-average-precision-for-object-detection-45c121a31173 + for an explanation + + :param list det_boxes: list of tensors, one tensor for each image + containing detected objects' bounding boxes, thus the length of + det_boxes corresponds to the number of images we are considering + and the size of each tensor is (n_obj, 4), where n_obj is the + number of objects detected for that image + :param list det_labels: list of tensors, one tensor for each image + containing detected objects' labels, thus the length of det_labels + corresponds to the number of images we are considering and the + size of each tensor is (n_obj), where n_obj is the number of + objects detected for that image. + :param list det_scores: list of tensors, one tensor for each image + containing detected objects' labels' scores, thus the length of + det_scores corresponds to the number of images we are considering + and the size of each tensor is (n_obj), where n_obj is the number + of objects detected for that image. + :param list true_boxes: list of tensors, one tensor for each image + containing actual objects' bounding boxes, thus the length of + true_boxes corresponds to the number of images we are considering + and the size of each tensor is (n_obj, 4), where n_obj is the + number of objects for that image. + :param list true_labels: list of tensors, one tensor for each image + containing actual objects' labels, thus the length of true_labels + corresponds to the number of images we are considering and the + size of each tensor is (n_obj), where n_obj is the number of + objects for that image. + :param list true_difficulties: list of ByteTensors, one tensor for each + image containing actual objects' difficulty (0 or 1), thus the + length of true_difficulties corresponds to the number of images + we are considering and the size of each tensor is (n_obj), + where n_obj is the number of objects for that image. + :param dict label_map: dictionary for the label map, where the + keys are the labels of the objects(the classes) and their + values the number of the classes to which they belong + (0 for the background). Thus the length of this dict will be + the number of the classes of the dataset. + :return: average precisions for all classes, mean average + precision (mAP) + :rtype: list + NOTE: n_obj detected may be different from n_obj true. For example, + some objects could not have been detected. Or there can be + multiple proposals for them (even if NMS has been used) + ''' + assert len(det_boxes) == len(det_labels) == len(det_scores) == len( + true_boxes) == len(true_labels) == len(true_difficulties) + # these are all lists of tensors of the same length, i.e. number + # of images + n_classes = len(label_map) + + # Store all (true) objects in a single continuous tensor while keeping + # track of the image it is from + true_images = list() + for i in range(len(true_labels)): + true_images.extend([i] * true_labels[i].size(0)) + true_images = torch.LongTensor(true_images).to( + device + ) # (n_objects), n_objects is the total no. of objects across all images + true_boxes = torch.cat(true_boxes, dim=0) # (n_objects, 4) + true_labels = torch.cat(true_labels, dim=0) # (n_objects) + true_difficulties = torch.cat(true_difficulties, dim=0) # (n_objects) + + assert true_images.size(0) == true_boxes.size(0) == true_labels.size(0) + + # Store all detections in a single continuous tensor while keeping + # track of the image it is from + det_images = list() + for i in range(len(det_labels)): + det_images.extend([i] * det_labels[i].size(0)) + det_images = torch.LongTensor(det_images).to(device) # (n_detections) + det_boxes = torch.cat(det_boxes, dim=0) # (n_detections, 4) + det_labels = torch.cat(det_labels, dim=0) # (n_detections) + det_scores = torch.cat(det_scores, dim=0) # (n_detections) + + assert det_images.size(0) == det_boxes.size(0) == det_labels.size( + 0) == det_scores.size(0) + + #################################################### + # Calculate APs for each class (except background) # + #################################################### + average_precisions = calculate_AP(true_images, true_boxes, + true_difficulties, true_labels, + det_images, det_boxes, det_scores, + det_labels, n_classes) + + ########################################## + # Calculate Mean Average Precision (mAP) # + ########################################## + mean_average_precision = 100 * average_precisions.mean().item() + + # Keep class-wise average precisions in a dictionary + rev_label_map = {v: k for k, v in label_map.items()} # Inverse mapping + average_precisions = { + rev_label_map[c + 1]: 100 * v + for c, v in enumerate(average_precisions.tolist()) + } + + return average_precisions, mean_average_precision + + diff --git a/smithers/ml/utils_rednet.py b/smithers/ml/utils_rednet.py new file mode 100644 index 0000000..9565c9c --- /dev/null +++ b/smithers/ml/utils_rednet.py @@ -0,0 +1,468 @@ +''' +Utilities for the construction of the reduced version of a +Neural Network. +''' + +import torch +import torch.nn as nn +import torch.nn.functional as F +import numpy as np +from sklearn import decomposition +from scipy import linalg + + + +if torch.cuda.is_available(): + device = torch.device('cuda') +else: + device = torch.device('cpu') + + +def get_seq_model(model): + ''' + Takes a model with model.features and model.classifier and + returns a sequential model. If attribute self.classifier_str + is not present, add this attribute to the model before running + this function. + + :param nn.Module model: CNN chosen, for example VGG16. + :return: sequential formula of the model that has be given in input. + :rtype: nn.Sequential + ''' + if list(model.classifier.children()): + if model.classifier_str == 'cifar': + seq_model = nn.Sequential(*(list(model.features.children()) + + [nn.Flatten(1, -1)] + + list(model.classifier.children()))) + else: #if model.classifier_str == 'standard': + seq_model = nn.Sequential(*(list(model.features.children()) + + [nn.AdaptiveAvgPool2d((7, 7))] + + [nn.Flatten(1, -1)]+ + list(model.classifier.children()))) + else: + if model.classifier_str == 'cifar': + seq_model = nn.Sequential(*(list(model.features.children()) + + [nn.Flatten(1, -1)] + + [model.classifier])) + elif model.classifier_str == 'standard': + seq_model = nn.Sequential(*(list(model.features.children()) + + [nn.AdaptiveAvgPool2d((7, 7))] + + [nn.Flatten(1, -1)] + + [model.classifier])) + return seq_model + + + +def PossibleCutIdx(seq_model): + ''' + Function that identifies the possible indexes where the net can be + cut, i.e. the indexes of the convolutional and fully-connected + layers. + + :param nn.Sequential seq_model: sequential container containing all + the layers of the model + :return: containing all the indexes of the convolutional and + fully-connected layers + :rtype: list + ''' + cutidx = [] + for i, m in seq_model.named_modules(): + if isinstance(m, (nn.Linear, nn.Conv2d)):# or isinstance(m, nn.Conv2d): + cutidx.append(int(i)) # Find the Linear or Conv2d Layer Idx + return cutidx + + +# RANDOM SVD + +def randomized_range_finder(A, size, n_iter=5): + A = A.to('cpu') + Q = np.random.normal(size=(A.shape[1], size)) + + for i in range(n_iter): + Q, _ = linalg.lu(A @ Q, permute_l=True) + Q, _ = linalg.lu(A.T @ Q, permute_l=True) + Q, _ = linalg.qr(A @ Q, mode='economic') + return Q + +def randomized_svd(M, n_components, n_oversamples=10, n_iter=2): + n_random = n_components + n_oversamples + + Q = torch.tensor(randomized_range_finder(M, n_random, n_iter),dtype = torch.float) + # project M to the (k + p) dimensional space using the basis vectors + M = torch.tensor(M, dtype = torch.float).to('cpu') + + B = Q.transpose(0, 1) @ M + # compute the SVD on the thin matrix: (k + p) wide + Uhat, s, V = linalg.svd(B, full_matrices=False) + Uhat = torch.tensor(Uhat).to('cpu') + del B + U = Q @ Uhat + + return U[:, :n_components], s[:n_components], V[:n_components, :] + +# ACTIVE SUBSPACES + +def give_inputs(dataset, model): + ''' + Generator for computing the inputs for a layer, e.g the reduction + layer. + + :param Dataset/list of tuples dataset: dataset containing the + images/data. + :param nn.Sequential model: Sequential container representing the + model, e.g. the pre-model. + :return: matrix of inputs/outputs of the model + :rtype: numpy.ndarray + ''' + for data in dataset: + input0 = data[0].unsqueeze(0) #add dimension as first axis + #target = torch.tensor([data[1]]) + input_ = model(input0) + yield torch.squeeze(input_.flatten(1)).detach().numpy() + +def spatial_gradients(dataset, pre_model, post_model): + ''' + Generator for computing the spatial gradients of the + loss function composed with the postmodel (the derivative is + computed w.r.t. the inputs of the AS, i.e. the evaluation of + the premodel in the input of the net. + + :param Dataset/list of tuples dataset: dataset containing the + images/data. + :param nn.Sequential pre_model: Sequential container representing the + pre-model, i.e. the model cut on the cut-off layer + :param nn.Sequential post_model: Sequential container representing + the post-model, i.e. the model after the cut-off layer. + :return: matrix of spatial gradients + :rtype: numpy.ndarray + ''' + for data in dataset: + input0 = data[0].unsqueeze(0) #add dimension as first axis + target = torch.LongTensor([data[1]]) + input_ = pre_model(input0) + out_post = post_model(input_) + output_ = F.nll_loss(out_post, target, reduce=False) + gradient = torch.autograd.grad( + output_, + input_, + grad_outputs=torch.ones(output_.size()).to(dtype=input_.dtype, + device=input_.device), + create_graph=True, + retain_graph=True, + allow_unused=True) + yield torch.squeeze(gradient[0].flatten(1)).detach().numpy() + + + +def projection(proj_mat, data_loader, matrix, device = device): + ''' + Funtion that performs the projection onto a space (e.g. the reduced + space) of a matrix. + + :param torch.Tensor proj_mat: projection matrix n_feat x n_red.dim. + :param iterable data_loader: iterable object for loading the dataset. + It iterates over the given dataset, obtained combining a + dataset(images and labels) and a sampler. + :param torch.Tensor matrix: matrix to project n_images x n_feat. + Possible way to construct it using the function forward_dataset. + :param torch.device device: device used to allocate the variables for + the function. + :return: reduced matrix n_images x n_red.dim + :rtype: torch.Tensor + ''' + proj_mat = proj_mat.to(device) + matrix_red = torch.zeros(0).to(device) + num_batch = len(data_loader) + batch_old = 0 + for idx_, batch in enumerate(data_loader): + if idx_ >= num_batch: + break + + images = batch[0].to(device) + + with torch.no_grad(): + proj_data = (matrix[batch_old : batch_old + images.size()[0], : ] @ proj_mat).to(device) + batch_old = images.size()[0] + matrix_red = torch.cat([matrix_red, proj_data.to(device)]) + + return matrix_red + + +def forward_dataset(model, data_loader, device = device, flattening = True): + ''' + Forward of a model using the whole dataset, i.e. the forward is + performed by splitting the dataset in batches in order to reduce + the computational effort needed. + + :param nn.Sequential/nn.Module model: model. + :param iterable data_loader: iterable object for loading the dataset. + It iterates over the given dataset, obtained combining a + dataset(images and labels) and a sampler. + :param torch.device device: device used to allocate the variables for the function. + :param bool flattening: used to state whether flattening is desired or not (e.g. flattening = False for HOSVD). + :return: output of the model computed on the whole dataset with + dimensions n_images x n_feat (corresponds to n_class for the last + layer) + :rtype: torch.Tensor + ''' + out_model = torch.zeros(0).to(device) + num_batch = len(data_loader) + for idx_, batch in enumerate(data_loader): + if idx_ >= num_batch: + break + images = batch[0].to(device) + + with torch.no_grad(): + outputs = model(images).to(device) + if flattening: + outputs = torch.squeeze(outputs.flatten(1)).detach() + out_model = torch.cat([out_model.to(device), outputs.to(device)]).to(device) + return out_model.to(device) + + +# HOSVD - tensorial approach +def tensor_projection(proj_matrices, data_loader, model, device): + ''' + Funtion that performs the projection onto a space (e.g. the reduced + space) of a tensor (more than 2 dimensions). + + :param list proj_matrices: list containing the projection matrices for + each dimension of the tensor. For each dimension i, the related + projection matrix has size (input_dim[i], red_dim_list[i]) + :param iterable data_loader: iterable object for loading the dataset. + It iterates over the given dataset, obtained combining a + dataset(images and labels) and a sampler. + :param nn.Module/torch.Tensor model: model under consideration for computing its + outputs (that has to be reduced) or matrix to project n_images x C X H X W. + Possible way to construct it using the function forward_dataset. + :param torch.device device: device used to allocate the variables for + the function. + :return: reduced tensor n_images x red_dim[1] x red_dim[2] x red_dim[3] + :rtype: torch.Tensor + ''' + out_model = torch.zeros(0).to(device) + batch_old = 0 + for idx_, batch in enumerate(data_loader): + images = batch[0].to(device) + with torch.no_grad(): + if torch.is_tensor(model): + outputs = model[batch_old : batch_old + images.size()[0], : ] + batch_old = images.size()[0] + else: + outputs = model(images).to(device) + outputs = project_multiple_observations(proj_matrices, outputs) + out_model = torch.cat([out_model, outputs.to(device)]).to(device) + del outputs + #torch.cuda.empty_cache() + snapshots_red = torch.squeeze(out_model.flatten(1)).detach() + return snapshots_red + + +def tensor_reverse(tensor): + """ + Function that reverses the directions of a tensor + + :param torch.Tensor A: the input tensor with dimensions (d_1,d_2,...,d_n) + :return: input tensor with reversed dimensions (d_n,...,d_2,d_1) + :rtype: torch.Tensor + """ + incr_list = [i for i in range(len(tensor.shape))] + incr_list.reverse() + return torch.permute(tensor, tuple(incr_list)) + +def project_single_observation(proj_matrices, observation_tensor): + for i, _ in enumerate(observation_tensor.shape): + observation_tensor = torch.tensordot(proj_matrices[i], observation_tensor, ([1],[i])) + return tensor_reverse(observation_tensor) + +def project_multiple_observations(proj_matrices, observations_tensor): + for i in range(len(proj_matrices)): + observations_tensor = torch.tensordot(proj_matrices[i], observations_tensor, ([1],[i+1])) + return tensor_reverse(observations_tensor) + + +def Total_param(model, storage_per_param=4): + ''' + Function that computes the total number of parameters + + :param nn.Module model: part of the net in exam + :param int storage_per_param: memory needed to store a parameter. + Default value set at 4. + :return: total number of parameters + :rtype: int + ''' + total_params = 0 + for t in filter(lambda p: p.requires_grad, model.parameters()): + total_params += np.prod(t.data.cpu().numpy().shape) + return total_params / 2**20 * storage_per_param + +def Total_flops(model, device, is_PCE=False, p=2, red_dim=50): + ''' + Function that computes the total number of flops + + :param nn.Module model: part of the net in exam + :param torch.device device: object representing the device on + which a torch.Tensor is or will be allocated. + :param bool is_PCE: Boolean value identifying the use of PCE + as input_ouput mapping. Default value set at False. + :param int p: degree polynomial used in PCE. + :param int red_dim: reduction dimension. Default value is + set at 50. + :return: total number of flops + :rtype: float + ''' + x = torch.ones([1, 3, 32, 32]).to(device) + flops = 0. + for _, m in model.named_modules(): + xold = x + if isinstance(m, nn.MaxPool2d): + x = m(x) + if isinstance(m, nn.Conv2d): + x = m(x) + flops += xold.shape[1]*x.shape[1:].numel()*\ + torch.tensor(m.kernel_size).prod() + if isinstance(m, nn.Linear): + flops += m.in_features * m.out_features + + if is_PCE: + flops += p * (model.PCE.in_features + nAS) #Basis function + return float(flops) / 10**6 + + +def compute_loss(model, device, test_loader, is_print=True, topk=[1], features=None): + ''' + Function that computes the top-k accuracy of model for dataset=test_loader + :param nn.Module model: reduced net + :param torch.device device: object representing the device on + which a torch.Tensor is or will be allocated. + :param iterable test_loader: iterable object, it load the dataset. + It iterates over the given dataset, obtained combining a + dataset(images and labels) and a sampler. + :param bool is_print: + :param list top_k + :return float test_accuracy + ''' + model.eval() + model.to(device) + test_loss = 0 + + res = [] + maxk = max(topk) + batch_old = 0 + with torch.no_grad(): + for data, target in test_loader: + data, target = data.to(device), target.to(device) + batch = data.size()[0] + if features is None: + output = model(data) + else: + output = model(data, features=features[batch_old : batch_old + batch, :]) + batch_old = batch + test_loss += F.nll_loss(output, target, + reduction='sum').item() # sum up batch loss + # torch.tok Returns the k largest elements of the given + # input tensor along a given dimension. + _, pred = torch.topk(output, maxk, dim=1, largest=True, sorted=True) + pred = pred.t() + correct = pred.eq(target.view(1, -1).expand_as(pred)) + for k in topk: + correct_k = correct[:k].view(-1).float().sum(0, keepdim=True) + res.append(correct_k) + test_loss /= len(test_loader.sampler) + correct = torch.FloatTensor(res).view(-1, len(topk)).sum(dim=0) + test_accuracy = 100. * correct / len(test_loader.sampler) + for idx, k in enumerate(topk): + print(' Top {}: Accuracy: {}/{} ({:.2f}%)'.format( + k, correct[idx], len(test_loader.sampler), test_accuracy[idx])) + print('Loss Value:', test_loss) + if len(topk) == 1: + return test_accuracy[0] + else: + return test_accuracy + +def train_kd(student, + teacher, + device, + train_loader, + optimizer, + train_max_batch, + alpha=0.0, + temperature=1., + lr_decrease=None, + epoch=1, + features=None): + ''' + Function that retrains the model with knowledge distillation + when alpha=0, it reduced to the original training + :param nn.Module student: reduced net + :param nn.Module teacher: full net + :param torch.device device: object representing the device on + which a torch.Tensor is or will be allocated. + :param iterable train_loader: iterable object, it load the dataset for + training. It iterates over the given dataset, obtained combining a + dataset(images and labels) and a sampler. + :param optimizer + :param train_max_batch + :param float alpha: regularization parameter. Default value set to 0.0, + i.e. when the training is reduced to the original one + :param float temperature: temperature factor introduced. When T tends to + infinity all the classes have the same probability, whereas when T + tends to 0 the targets become one-hot labels. Default value set to 1. + :param lr_decrease: + :param int epoch: epoch number + :return: accuracy + ''' + student.train() + teacher.eval() + student.to(device) + teacher.to(device) + correct = 0.0 + batch_old = 0 + for batch_idx, (data, target) in enumerate(train_loader): + data, target = data.to(device), target.to(device) + batch = data.size()[0] + optimizer.zero_grad() + if features is None: + output = student(data) + else: + output = student(data, features[batch_old : batch_old + batch, :]) + output_teacher = teacher(data) + batch_old = batch + + # The Kullback-Leibler divergence loss measure + loss = nn.KLDivLoss()(F.log_softmax(output / temperature, dim=1),F.softmax(output_teacher / temperature, dim=1) + )*(alpha*temperature*temperature) + \ + F.cross_entropy(output, target) * (1. - alpha) + + loss.backward() + optimizer.step() + + pred = output.data.max(1, keepdim=True)[1] + correct += pred.eq(target.data.view_as(pred)).sum().item() + print('Train Loss kd:', loss.item() / len(train_loader.sampler)) + train_loss_val = loss.item() / len(train_loader.sampler) + accuracy = correct / len(train_loader.sampler) * 100.0 + if lr_decrease is not None: + for param_group in optimizer.param_groups: + param_group['lr'] *= lr_decrease + else: + for param_group in optimizer.param_groups: + param_group['lr'] = param_group['lr'] * (epoch) / (epoch + 1) + return accuracy, train_loss_val + + + +def save_checkpoint(epoch, model, path, optimizer): + ''' + Save model checkpoint. + :param scalar epoch: epoch number + :param list model: list of constructed classes that compose our network + :param str path: path to the checkpoint location + :param torch.Tensor optimizer: optimizer chosen + ''' + torch.save({ + 'epoch': epoch, + 'model_state_dict': model.state_dict(), + 'optimizer_state_dict': optimizer.state_dict() + }, path) + diff --git a/tests/test_fnn.py b/tests/test_fnn.py new file mode 100644 index 0000000..d681a6b --- /dev/null +++ b/tests/test_fnn.py @@ -0,0 +1,24 @@ +from unittest import TestCase +import torch +import torch.nn as nn +from smithers.ml.models.fnn import FNN, training_fnn + +class Testfnn(TestCase): + def test_constructor(self): + fnn = FNN(50, 10, 20) + assert isinstance(fnn.model[0], nn.Linear) + self.assertEqual(fnn.n_input, 50) + self.assertEqual(fnn.n_output, 10) + + def test_forward(self): + fnn = FNN(50, 40, 10) + input_net = torch.rand(12, 50) + out = fnn(input_net) + self.assertEqual(list(out.size()), [12, 40]) + + def test_training(self): + fnn = FNN(30, 4, 40) + input_net = torch.rand(12, 30) + real_out = torch.rand(12, 4) + training_fnn(fnn, 10, input_net, real_out) + self.assertEqual(len(fnn.model), 3) diff --git a/tests/test_netadapter.py b/tests/test_netadapter.py new file mode 100644 index 0000000..b985950 --- /dev/null +++ b/tests/test_netadapter.py @@ -0,0 +1,52 @@ +from unittest import TestCase +import torch +import torch.nn as nn +from torch.utils.data import TensorDataset, DataLoader +from smithers.ml.models.netadapter import NetAdapter +from smithers.ml.utils_rednet import get_seq_model +from smithers.ml.models.vgg import VGG + +inps = torch.arange(100 * 3 * 224 * 224, + dtype=torch.float32).view(100, 3, 224, 224) +tgts = torch.arange(100, dtype=torch.float32) +train_dat = TensorDataset(inps, tgts) +train_load = DataLoader(train_dat, batch_size=2, pin_memory=True) +model = VGG(classifier='standard', init_weights='imagenet') +seq_model = get_seq_model(model) + + +class TestNetAdapter(TestCase): + def test_constructor(self): + netadapter = NetAdapter(3, 50, 'AS', 'PCE') + self.assertEqual(netadapter.cutoff_idx, 3) + self.assertEqual(netadapter.red_dim, 50) + self.assertEqual(netadapter.red_method, 'AS') + self.assertEqual(netadapter.inout_method, 'PCE') + + + def test_reducenet_01(self): + netadapter = NetAdapter(11, 50, 'AZ', 'PCE') + with self.assertRaises(ValueError): + netadapter.reduce_net(seq_model, train_dat, tgts, train_load, 40) + + def test_reducenet_02(self): + netadapter = NetAdapter(5, 50, 'POD', 'ANN') + with self.assertRaises(ValueError): + netadapter.reduce_net(seq_model, train_dat, tgts, train_load, 40) + + def test_reducenet_03(self): + netadapter = NetAdapter(5, 30, 'POD', 'FNN') + red_net = netadapter.reduce_net(seq_model, train_dat, tgts, train_load, 1000) + assert isinstance(red_net, nn.Module) + assert isinstance(red_net.proj_model, nn.Linear) + assert isinstance(red_net.inout_map, nn.Module) + + def test_reducenet_04(self): + netadapter = NetAdapter(5, 40, 'POD', 'FNN') + red_net = netadapter.reduce_net(seq_model, train_dat, tgts, train_load, 1000) + input_ = torch.arange(1 * 3 * 224 * 224, + dtype=torch.float32).view(1, 3, 224, 224) + out = red_net(input_) + self.assertEqual(list(out.size()), [1, 1000]) + + diff --git a/tests/test_pcemodel.py b/tests/test_pcemodel.py new file mode 100644 index 0000000..5cb61fe --- /dev/null +++ b/tests/test_pcemodel.py @@ -0,0 +1,60 @@ +from unittest import TestCase +import torch +import torch.nn as nn +import numpy as np +from smithers.ml.layers.pcemodel import PCEModel + +input_ = torch.rand(120, 50) +mean = torch.mean(input_, 0) +var = torch.var(input_, 0) + +class TestPECModel(TestCase): + def test_constructor_pce_01(self): + pce = PCEModel(mean, var) + assert isinstance(pce, nn.Module) + self.assertEqual(pce.d, 50) + self.assertEqual(pce.p, 2) + self.assertEqual(pce.device, 'cpu') + assert isinstance(pce.var, torch.Tensor) + assert isinstance(pce.mean, torch.Tensor) + assert isinstance(pce.oneDbasis, torch.Tensor) + assert isinstance(pce.idxset, torch.Tensor) + + def test_constructor_pce_02(self): + pce = PCEModel(mean, var, 40, 4) + assert isinstance(pce, nn.Module) + self.assertEqual(pce.d, 40) + self.assertEqual(pce.p, 4) + assert isinstance(pce.oneDbasis, torch.Tensor) + assert isinstance(pce.idxset, torch.Tensor) + + def test_normalbasis(self): + pce = PCEModel(mean, var, 40, 2) + B = pce.NormalBasis() + assert isinstance(B, torch.Tensor) + self.assertEqual(list(B.size()), [3, 3]) + + def test_forward(self): + pce = PCEModel(mean, var, 50, 3) + input1 = torch.rand(120, 50) + Phi = pce.forward(input1) + assert isinstance(Phi, torch.Tensor) + self.assertEqual(Phi.size()[0], 120) + + def test_training(self): + pce = PCEModel(mean, var, 50, 3) + input1 = torch.rand(120, 50) + out = torch.rand(120, 1) + label = torch.rand(120, 1) + coeff, approx, score = pce.Training(input1, out, label) + assert isinstance(coeff, np.ndarray) + assert isinstance(approx, float) + assert isinstance(score, float) + + def test_inference(self): + pce = PCEModel(mean, var, 50, 4) + input1 = torch.rand(120, 50) + coeff = torch.rand(1, 120) + inf_mat = pce.Inference(input1, coeff) + assert isinstance(inf_mat, torch.Tensor) + diff --git a/tests/test_rednet.py b/tests/test_rednet.py new file mode 100644 index 0000000..264a5b1 --- /dev/null +++ b/tests/test_rednet.py @@ -0,0 +1,48 @@ +from unittest import TestCase +import torch +import torch.nn as nn +from smithers.ml.models.rednet import RedNet +from smithers.ml.models.fnn import FNN + +if torch.cuda.is_available(): + device = torch.device('cuda') +else: + device = torch.device('cpu') + +class Testrednet(TestCase): + def test_constructor_0(self): + pre_model = nn.Sequential(nn.Linear(500, 300), nn.Linear(300, 200)) + proj_mat = torch.rand(200, 50) + inout_map = FNN(50, 5, 10) + rednet = RedNet(5, pre_model, proj_mat, inout_map) + assert isinstance(rednet.inout_map, nn.Module) + assert isinstance(rednet.proj_model, nn.Linear) + assert isinstance(rednet.premodel, nn.Sequential) + + def test_constructor_1(self): + pre_model = nn.Sequential(nn.Conv2d(500, 200, 3)) + proj_mat = torch.rand(200, 50) + inout_map = FNN(50, 5, 10) + rednet = RedNet(5, pre_model, proj_mat, inout_map) + assert isinstance(rednet.inout_map, nn.Module) + assert isinstance(rednet.proj_model, nn.Linear) + assert isinstance(rednet.premodel, nn.Sequential) + +# TO DO: MISSING TEST CONSTRUCTOR CASE PCE (LIST MODEL AND COEFF) + def test_forward_0(self): + pre_model = nn.Sequential(nn.Linear(650, 250), nn.Linear(250, 200)) + proj_mat = torch.rand(200, 50) + inout_map = FNN(50, 5, 10) + rednet = RedNet(5, pre_model, proj_mat, inout_map).to(device) + input_net = torch.rand(20, 650).to(device) + output_net = rednet(input_net) + self.assertEqual(list(output_net.size()), [20, 5]) + + def test_forward_1(self): + pre_model = nn.Sequential(nn.Conv2d(600, 200, 3)) + proj_mat = torch.rand(200, 80) + inout_map = FNN(80, 40, 50) + rednet = RedNet(5, pre_model, proj_mat, inout_map).to(device) + input_net = torch.rand(120, 600, 3, 3).to(device) + output_net = rednet(input_net) + self.assertEqual(list(output_net.size()), [120, 40]) diff --git a/tests/test_utils.py b/tests/test_utils.py new file mode 100644 index 0000000..77a1d93 --- /dev/null +++ b/tests/test_utils.py @@ -0,0 +1,167 @@ +from unittest import TestCase +import types +import torch +import torch.nn as nn +import numpy as np +from torch.utils.data import TensorDataset, DataLoader +from smithers.ml.utils_rednet import get_seq_model, PossibleCutIdx, spatial_gradients, projection, forward_dataset + +if torch.cuda.is_available(): + device = torch.device('cuda') +else: + device = torch.device('cpu') + +class Testutils(TestCase): + def test_get_seq_model_01(self): + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg11', + pretrained=True) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + assert isinstance(seq_model, nn.Sequential) + self.assertEqual(len(seq_model), 30) + self.assertEqual(len(seq_model), len(model.features) + + len(model.classifier) + 2) + + def test_get_seq_model_02(self): + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg16', + pretrained=True) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + assert isinstance(seq_model, nn.Sequential) + self.assertEqual(len(seq_model), 40) + self.assertEqual(len(seq_model), len(model.features) + + len(model.classifier) + 2) + + def test_possiblecutidx_01(self): + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg11', + pretrained=True) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + cut_idx = PossibleCutIdx(seq_model) + assert isinstance(cut_idx, list) + self.assertEqual(len(cut_idx), 11) + + def test_possiblecutidx_02(self): + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg16', + pretrained=True) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + cut_idx = PossibleCutIdx(seq_model) + assert isinstance(cut_idx, list) + self.assertEqual(len(cut_idx), 16) + + def test_constructor_spatial_gradients_01(self): + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg16', + pretrained=True) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + pre_model = seq_model[:12] + post_model = seq_model[12:] + input_ = [(torch.rand(3, 224, 224), torch.IntTensor([5]))] + grad = spatial_gradients(input_, pre_model, post_model) + assert isinstance(grad, types.GeneratorType) + + def test_constructor_spatial_gradients_02(self): + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg16', + pretrained=True) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + pre_model = seq_model[:11] + post_model = seq_model[11:] + input1 = (torch.rand(3, 224, 224), torch.IntTensor([5])) + input2 = (torch.rand(3, 224, 224), torch.IntTensor([9])) + input3 = (torch.rand(3, 224, 224), torch.IntTensor([3])) + inputs = [input1, input2, input3] + gradients = [] + for grad in spatial_gradients(inputs, pre_model, post_model): + gradients.append(grad) + assert isinstance(gradients[0], np.ndarray) + + def test_spatial_gradients_01(self): + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg16', + pretrained=True) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + pre_model = seq_model[:11] + post_model = seq_model[11:] + input1 = (torch.rand(3, 224, 224), torch.IntTensor([4])) + input2 = (torch.rand(3, 224, 224), torch.IntTensor([8])) + input3 = (torch.rand(3, 224, 224), torch.IntTensor([1])) + inputs = [input1, input2, input3] + gradients = [] + for grad in spatial_gradients(inputs, pre_model, post_model): + gradients.append(grad) + self.assertEqual(grad.size, 256 * 56 * 56) + + def test_spatial_gradients_02(self): + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg16', + pretrained=True) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + pre_model = seq_model[:8] + post_model = seq_model[8:] + input1 = (torch.rand(3, 224, 224), torch.IntTensor([1])) + input2 = (torch.rand(3, 224, 224), torch.IntTensor([2])) + input3 = (torch.rand(3, 224, 224), torch.IntTensor([3])) + inputs = [input1, input2, input3] + gradients = [] + generator = spatial_gradients(inputs, pre_model, post_model) + for _ in range(2): + grad = next(generator) + gradients.append(grad) + self.assertEqual(len(gradients), 2) + + def test_spatial_gradients_03(self): + model = torch.hub.load('pytorch/vision:v0.9.0', 'vgg11', + pretrained=True) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + pre_model = seq_model[:9] + post_model = seq_model[9:] + input1 = (torch.rand(3, 224, 224), torch.IntTensor([6])) + input2 = (torch.rand(3, 224, 224), torch.IntTensor([7])) + input3 = (torch.rand(3, 224, 224), torch.IntTensor([0])) + inputs = [input1, input2, input3] + gradients = [] + generator = spatial_gradients(inputs, pre_model, post_model) + for _ in range(2, 3): + grad = next(generator) + gradients.append(grad) + self.assertEqual(len(gradients), 1) + + def test_projection(self): + inps = torch.arange(10 * 5, dtype=torch.float32).view(10, 5) + tgts = torch.arange(10 * 5, dtype=torch.float32).view(10, 5) + dataset = TensorDataset(inps, tgts) + data_loader = DataLoader(dataset, batch_size=2, pin_memory=True) + proj_mat = torch.rand(2400, 50).to(device) + matrix = torch.rand(10, 2400).to(device) + mat_red = projection(proj_mat, data_loader, matrix) + self.assertEqual(list(mat_red.size()), [10, 50]) + + def test_forwarddataset_01(self): + inps = torch.arange(10 * 3 * 224 * 224, + dtype=torch.float32).view(10, 3, 224, 224) + tgts = torch.arange(10, dtype=torch.float32) + dataset = TensorDataset(inps, tgts) + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg16', + pretrained=True).to(device) + model.classifier_str = 'standard' + data_loader = DataLoader(dataset, batch_size=2, pin_memory=True) + out_model = forward_dataset(model, data_loader) + self.assertEqual(list(out_model.size()), [10, 1000]) + + def test_forwarddataset_02(self): + inps = torch.arange(50 * 3 * 224 * 224, + dtype=torch.float32).view(50, 3, 224, 224) + tgts = torch.arange(50, dtype=torch.float32) + dataset = TensorDataset(inps, tgts) + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg16', + pretrained=True).to(device) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + pre_model = seq_model[:11] + data_loader = DataLoader(dataset, batch_size=2, pin_memory=True) + out_model = forward_dataset(pre_model, data_loader) + self.assertEqual(list(out_model.size()), [50, 256 * 56 * 56]) + diff --git a/tests/test_vgg.py b/tests/test_vgg.py new file mode 100644 index 0000000..c08914c --- /dev/null +++ b/tests/test_vgg.py @@ -0,0 +1,94 @@ +from unittest import TestCase +import torch.nn as nn +import torchvision.transforms.functional as FT + +from smithers.ml.models.vgg import VGG + +default_cfg = [ + 64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, + 512, 512, 'M' +] #vgg16 +vgg19_cfg = [ + 64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, + 'M', 512, 512, 512, 512, 'M' +] + +n_classes = 1000 + + +class Testvgg(TestCase): + def test_constuctor_empty(self): + net = VGG() + + def test_make_layers_vgg16(self): + net = VGG() + layers = net.make_layers() + assert len(layers) == 31 + + def test_make_layers_conv(self): + net = VGG() + layers = net.make_layers() + assert isinstance(layers[0], nn.Conv2d) + + def test_make_layers_vgg16bn(self): + net = VGG() + layers = net.make_layers(True) + assert len(layers) == 44 + + def test_make_layers_batch(self): + net = VGG() + layers = net.make_layers(True) + assert isinstance(layers[1], nn.BatchNorm2d) + + def test_make_layers_maxp(self): + net = VGG() + layers = net.make_layers(True) + assert isinstance(layers[6], nn.MaxPool2d) + + def test_constructor_arg(self): + net = VGG(vgg19_cfg, 'ssd', True, init_weights='random') + + def test_vgg16_cifar(self): + net = VGG(classifier='cifar') + + def test_ssd300(self): + net = VGG(classifier='ssd', init_weights='imagenet') + + def test_init_weights(self): + net = VGG(init_weights='random') + params = list(net.parameters()) + assert len(params) == 32 + + def test_init_weights_conv(self): + net = VGG(init_weights='random') + params = list(net.parameters()) + assert list(params[0].size()) == [64, 3, 3, 3] + + def test_init_weights_bias(self): + net = VGG(init_weights='random') + params = list(net.parameters()) + print(list(params[25].size())) + assert list(params[25].size()) == [512] + + def test_load_pretrained_weights_01(self): + net = VGG(init_weights='imagenet') + state_dict = net.load_pretrained_layers(None) + assert list(state_dict['features.0.bias'].size()) == [64] + assert list(state_dict['classifier.6.weight'].size()) == [1000, 4096] + + def test_load_pretrained_weights_02(self): + net = VGG(classifier='ssd', init_weights='imagenet') + state_dict = net.load_pretrained_layers(None) + assert list( + state_dict['classifier.0.weight'].size()) == [1024, 512, 3, 3] + + def test_load_pretrained_weights_03(self): + with self.assertRaises(RuntimeError): + VGG(vgg19_cfg, 'ssd', init_weights='imagenet') + + def test_load_pretrained_weights_04(self): + net = VGG(init_weights='imagenet', num_classes=4) + state_dict = net.load_pretrained_layers(None) + assert list(state_dict['features.0.bias'].size()) == [64] + assert list(state_dict['classifier.6.weight'].size()) == [4, 4096] +