Template

.gitignore

+*__pycache__*
+*Logs*
+*word_vectors_cache*

__init__.py

+import torch
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
\ No newline at end of file

feature_maps.py

+import torch
+from logger import Logger
+LOGGER = Logger().logger()
+LOGGER.info("Running the model cuda_available = "+str(torch.cuda.is_available()))
+#Author: @meetdoshi
+class FeatureMaps():
+    def __init__(self,arch="vgg19"):
+        '''
+        Init function
+        @params
+        arch: str {vgg11,vgg13,vgg16,vgg19,vgg19bn}
+        '''
+        super()
+        try:
+            self.model = torch.hub.load('pytorch/vision:v0.10.0',arch,pretrained=True)
+        except Exception as e:
+            LOGGER.error("Could not load model" + str(e))
+        return
+    
+    def get_model(self):
+        return self.model
+
+    def get_layers(self,layers=[]):
+        '''
+        Function to extract layers
+        @params
+        layers: list
+        '''
+        weights = []
+        for layer in layers:
+            try:
+                weights.append(self.model.features[layer].weight)
+            except:
+                LOGGER.error("Could not fetch layer "+str(layer))
+        return weights
+
+    def get_fmaps_content(self,img,layer=[21]):
+        '''
+        Function which will pass the image through the model and get the respective fmaps
+        @params
+        img: numpy image f64
+        layer: list
+        '''
+        fmaps = []
+        layer_num = 0
+        for layer_i in self.model.features:
+            img = layer_i(img)
+            if layer_num in layer:
+                fmaps.append(img)
+            layer_num+=1
+        return fmaps
+
+    def get_fmaps_style(self,img,layer=[0,5,10,19,28]):
+        '''
+        Function which will pass the image through the model and get the respective fmaps
+        @params
+        img: numpy image f64
+        layer: list
+        '''
+        fmaps = []
+        layer_num = 0
+        for layer_i in self.model.features:
+            img = layer_i(img)
+            if layer_num in layer:
+                fmaps.append(img)
+            layer_num+=1
+        return fmaps
+'''
+if __name__ == "__main__":
+    fmap = FeatureMaps()
+    model = fmap.get_model()
+    print(model.features)
+    weights = fmap.get_layers([4,2,6])
+    print(len(weights))
+    for weight in weights:
+        print(type(weight),weight.shape)
+'''

logger.py

+import logging
+import os
+#Author: @meetdoshi
+class Logger:
+    '''
+    Singleton logger class
+    '''
+    _instance = None
+    _logHandler = None
+    _formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
+    def __new__(cls,*args,**kwargs):
+        if not cls._instance:
+            identifier = '@meetdoshi'
+            if not os.path.isdir("Logs/"):
+                os.mkdir("Logs/")
+            logHandler = logging.FileHandler("Logs/multimodal_embeddings_"+identifier+".log")
+            logHandler.setFormatter(cls._formatter)
+            cls._logHandler = logging.getLogger("Logs/multimodal_embeddings_"+identifier+".log")
+            cls._logHandler.setLevel(logging.INFO)
+            cls._logHandler.addHandler(logHandler)
+            cls._instance = super(Logger, cls).__new__(cls,*args,**kwargs)
+        return cls._instance
+
+    def logger(self):
+        return self._logHandler
+
+'''
+#Demo use
+if __name__ == "__main__":
+    a = Logger()
+    b = Logger()
+    print(a is b)
+    INFO = a.logger()
+    ERROR = b.logger()
+    INFO.info("TEST")
+    ERROR.info("ERROR")
+'''

loss.py

+import numpy as np
+import torch
+from logger import Logger
+LOGGER = Logger().logger()
+
+class Loss:
+    def __init__(self) -> None:
+        pass

optimizer.py

+from loss import Loss
+from feature_maps import LOGGER, FeatureMaps
+import torch.optim as optim
+import matplotlib.pyplot as plt
+import os
+plt.ion()
+class Optimizer:
+    def __init__(self) -> None:
+        pass

preprocess.py

+from os import device_encoding
+from logger import Logger
+import torch
+import torchvision.transforms as transforms
+from PIL import Image
+import numpy as np
+LOGGER = Logger().logger()
+#Author: @meetdoshi
+class Preprocessor:
+    def __init__(self) -> None:
+        pass
+
+
+'''
+if __name__=="__main__":
+    prec = Preprocessor()
+    img = np.zeros(shape=(4,4,3))
+    img = prec.process('test/sem8.jpeg')
+'''

word_vectors.py

+import torch
+from logger import Logger
+LOGGER = Logger().logger()
+from torchnlp.word_to_vector import GloVe, FastText, BPEmb, CharNGram
+#Author: @meetdoshi
+class WordVectors():
+    def __init__(self,model='fasttext'):
+        '''
+        Init function
+        @params
+        model: str {fasttext,glove,bpemb,chargram}
+        '''
+        self.vectors = None
+        if model=='fasttext':
+            self.vectors = FastText()
+        elif model=='glove':
+            self.vectors = GloVe()
+        elif model=='bpemb':
+            self.vectors = BPEmb()
+        elif model=='chargram':
+            self.vectors = CharNGram()
+        else:
+            LOGGER.error("Model not found")
+        return
+
+    def get_vectors(self):
+        '''
+        Function to get all vectors by a model
+        '''
+        if(self.vectors == None):
+            LOGGER.error("Model not found")
+        return self.vectors
+
+    def get_vector(self,word):
+        '''
+        Function to get vector for a word
+        @params
+        word: str
+        '''
+        if(self.vectors == None):
+            LOGGER.error("Model not found")
+        return self.vectors[word]
+
+    
+if __name__ == "__main__":
+    wv = WordVectors()
+    print(wv.get_vector('ababasba').shape)
+    wv = WordVectors(model='glove')
+    print(wv.get_vector('ababababas').shape)
+    wv = WordVectors(model='bpemb')
+    print(wv.get_vector('hbasbasbsello').shape)
+    wv = WordVectors(model='chargram')
+    print(wv.get_vector('hebasallo').shape)
\ No newline at end of file