First model version

README.md

@@ -0,0 +1 @@
+# Orientation Classifier

model.py

@@ -0,0 +1,44 @@
+import os
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.layers import *
+
+#os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
+
+
+
+class OrientationClassifier(tf.keras.Model):
+    
+
+    def __init__(self,input_shape,hidden_dim,no_classes=1,isTrainable = False):
+        super().__init__()
+        resnet = tf.keras.applications.resnet50.ResNet50(include_top=False,input_shape=input_shape)
+        resnet.trainable = isTrainable
+
+        self.featureExtractor = tf.keras.models.Sequential([
+            resnet,
+            GlobalAveragePooling2D()
+        ])
+
+        self.classifier = tf.keras.models.Sequential([
+            Dense(hidden_dim,activation = 'relu'),
+            BatchNormalization(),
+            
+            Dense(hidden_dim/2,activation = 'relu'),
+            BatchNormalization(),
+            
+            Dense(hidden_dim/4,activation = 'relu'),
+            BatchNormalization(),
+            
+            Dense(no_classes,activation = 'sigmoid')
+        ])
+
+
+    def call(self, inputs):
+        
+        x = self.featureExtractor(inputs)
+        
+        preds = self.classifier(x)
+        
+        return preds
+

models/CifarOrientationClassifier100 run 1.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a114da50d0673234cf6081ea1393ffb12587a6c589675e456ef520a5c8363d38
+size 96873672

transforms.py

@@ -0,0 +1,32 @@
+import tensorflow as tf
+import numpy as np
+
+
+
+def normalize(image,label):
+    
+    return tf.cast(image, tf.float32) / 255., label
+
+
+def resize(image,label):
+    
+    return tf.image.resize(image,size=(100,100)), label
+    
+
+def flip(image,label):
+    
+    new_label = tf.random.uniform(shape=(), minval=0, maxval=2, dtype=tf.int32)
+    
+    img = image
+    
+    if new_label == 1:
+        img = tf.image.flip_up_down(img) 
+    
+    return img,new_label
+
+
+    
+    
+
+
+    

utils.py

@@ -0,0 +1,203 @@
+import numpy as np
+import tensorflow as tf
+import matplotlib.pyplot as plt
+import gc
+
+
+classes = ["UN-FLIPPED","FLIPPED"]
+
+
+
+
+def showSample(data):
+
+    
+    for i,(image,label) in enumerate(data.unbatch().as_numpy_iterator()):
+        
+        print(classes[label])
+        plt.imshow(image)
+        plt.show()
+        
+        if i == 3:
+            break
+            
+    tf.keras.backend.clear_session()
+    gc.collect()
+        
+def checkBalance(data):
+    
+    
+    labels = []
+    
+    for i,(image,label) in enumerate(data.unbatch().as_numpy_iterator()):
+        
+        labels.append(label)
+ 
+    
+    values,count = np.unique(np.array(labels), return_counts=True)
+    
+    for i,value in enumerate(values):
+        print(f"{classes[value]} : {count[i]}")
+    
+    tf.keras.backend.clear_session()
+    gc.collect()
+    
+        
+def prepareData(data, transforms, batch_size, isTrain= False, size=None):
+    
+    ds = data
+    
+    for transform in transforms:
+        ds = ds.map(transform)
+    ds = ds.cache()
+    ds = ds.batch(batch_size)
+    ds = ds.prefetch(tf.data.AUTOTUNE)
+    
+    if isTrain:
+        ds = ds.shuffle(size)
+        
+    return ds
+
+
+
+
+def train(data,classifier,params,optimizer,loss,epochs,modelName = "OrientationClassifier",callback = None, runs=3):
+    
+    train,val = data
+    
+    history = []
+    losses = []
+    accs = []
+    
+    callbacks = []
+
+    if callback is not None:
+        callbacks.append(callback)
+    
+    for i in range(runs):
+        print(f"######## run {i+1} ##########")
+        
+        callbacks.append(tf.keras.callbacks.ModelCheckpoint(
+        filepath=f"models/{modelName} run {(i+1)}",
+        save_weights_only=True,
+        monitor='val_loss',
+        mode='min',
+        save_best_only=True
+    ))
+        
+        model = classifier(*params)
+        tf.random.set_seed(i+1)
+                
+        model.compile(optimizer=optimizer,loss=loss,metrics="accuracy")
+        hist = model.fit(train,epochs=epochs,validation_data=val,callbacks=callbacks)
+        
+        losses.append(np.amin(hist.history["val_loss"]))
+        accs.append(np.amax(hist.history["val_accuracy"]))
+        history.append(hist)
+        tf.keras.backend.clear_session()
+
+   
+    idx = np.argmin(losses)
+    bestModel = model
+    bestModel.load_weights(f"models/{modelName} run {(idx+1)}")
+    loss,acc = bestModel.evaluate(val)
+    
+    print(f"best model is on run {idx+1} with validation loss : {loss} and validation accuracy : {acc}")
+    del model
+    
+    tf.keras.backend.clear_session()
+    gc.collect()
+  
+
+    return history
+
+
+
+
+
+def plotHistory(histories):
+    
+    for i,history in enumerate(histories):
+        
+        print(f"history on run {i+1} : ")
+    
+        # summarize history for accuracy
+        plt.plot(history.history['accuracy'])
+        plt.plot(history.history['val_accuracy'])
+        plt.title('model accuracy')
+        plt.ylabel('accuracy')
+        plt.xlabel('epoch')
+        plt.legend(['train', 'val'], loc='upper left')
+        plt.show()
+
+        # summarize history for loss
+        plt.plot(history.history['loss'])
+        plt.plot(history.history['val_loss'])
+        plt.title('model loss')
+        plt.ylabel('loss')
+        plt.xlabel('epoch')
+        plt.legend(['train', 'val'], loc='upper left')
+        plt.show()
+
+        
+        
+def getMetrics(true,preds,thresh=0.5):
+    
+    acc = 0
+    TP = 0
+    TN = 0
+    FP = 0
+    FN = 0
+    recall = 0
+    precision = 0
+    f1 = 0
+    
+    logits = np.array(preds>thresh,dtype = np.int)
+    
+    for i,label in enumerate(iter(true)):
+        
+        if label == 1:
+            if logits[i] == 1:
+                TP += 1
+            else:
+                FN += 1
+        else:
+            if logits[i] == 1:
+                FP += 1
+            else:
+                TN += 1
+    
+    confusion_matrix = [[TP,FN],[FP,TN]]
+    acc = (TP + TN)/(TP+TN+FP+FN)
+    recall = TP/(TP+FN)
+    precision = TP/(TP+FP)
+    f1 = 2 * ((precision*recall)/(precision+recall))
+    
+    s = ""
+    for i in range(2):
+        for j in range(2):
+            s+=f"{confusion_matrix[i][j]}\t"
+        s+="\n"
+    
+    print(f"Accuracy : {acc} , recall : {recall} , precision : {precision} , f1 : {f1} , Confusion Matrix : \n{s}")
+    
+    return acc,confusion_matrix,recall,precision,f1   
+
+
+
+def loadWeights(model,optimizer,loss,weights_path):
+    
+    model.load_weights(weights_path)
+    model.compile(optimizer = optimizer,loss = loss)
+    
+    return model
+
+
+def evaluate(model,data):
+    
+    images = data.map(lambda image,label:image)
+    true = data.map(lambda image,label:label).unbatch()
+
+    preds = model.predict(images)
+
+    return getMetrics(true,preds)