Merge branch 'magnus-branch' into main

Author: Seilmast

.gitignore

@@ -1,4 +1,4 @@
-Data/
-Results/
-Experiments/
-_build/
+Data/*
+Results/*
+Experiments/*
+env/*

environment.yml

@@ -9,4 +9,6 @@ dependencies:
   - sphinx-autobuild
   - sphinx-rtd-theme
   - pip
+  - pytest
 prefix: /opt/miniconda3/envs/cc-exam
+

main.py

@@ -0,0 +1,76 @@
+import torch as th
+import torch.nn as nn 
+
+import argparse
+from utils import load_metric, load_model, createfolders
+
+
+
+
+
+
+
+
+
+
+
+
+def main():
+    '''
+    
+    Parameters
+    ----------
+    
+    Returns
+    -------
+    
+    Raises
+    ------
+    
+    '''
+    parser = argparse.ArgumentParser(
+        prog='',
+        description='',
+        epilog='',
+    )
+    #Structuture related values
+    parser.add_argument('--datafolder', type=str, default='Data/', help='Path to where data will be saved during training.')
+    parser.add_argument('--resultfolder', type=str, default='Results/', help='Path to where results will be saved during evaluation.')
+    parser.add_argument('--modelfolder', type=str, default='Experiments/', help='Path to where model weights will be saved at the end of training.')
+    parser.add_argument('--savemodel', type=bool, default=False, help='Whether model should be saved or not.')
+    parser.add_argument('--download-data', type=bool, default=False, help='Whether the data should be downloaded or not. Might cause code to start a bit slowly.')
+    
+    #Data/Model specific values
+    parser.add_argument('--modelname', type=str, default='MagnusModel', 
+                        choices = ['MagnusModel'], help="Model which to be trained on")
+    
+    #Training specific values
+    parser.add_argument('--epoch', type=int, default=20, help='Amount of training epochs the model will do.')
+    parser.add_argument('--learning_rate', type=float, default=0.001, help='Learning rate parameter for model training.')
+    args = parser.parse_args()
+
+    createfolders(args)
+    
+    device = 'cuda' if th.cuda.is_available() else 'cpu'
+    
+    #load model
+    model = load_model()
+    model.to(device)
+    
+    
+    criterion = nn.CrossEntropyLoss()
+    optimizer = th.optim.Adam(model.parameters(), lr = args.learning_rate)
+
+
+
+    for epoch in range(args.epoch):
+        
+        #Training loop start
+        
+        #Eval loop start
+    
+        pass 
+
+
+if __name__ == '__main__':
+    main()

utils/__init__.py

@@ -0,0 +1,4 @@
+from .load_metric import load_metric
+from .load_model import load_model
+from .load_data import load_data
+from .createfolders import createfolders

utils/createfolders.py

@@ -0,0 +1,41 @@
+import os 
+from tempfile import TemporaryDirectory
+import argparse
+
+def createfolders(args) -> None: 
+    '''
+    Creates folders for storing data, results, model weights. 
+    
+    Parameters
+    ----------
+    args
+        ArgParse object containing string paths to be created
+    
+    '''
+    
+    if not os.path.exists(args.datafolder):
+        os.makedirs(args.datafolder)
+        print(f'Created a folder at {args.datafolder}')
+        
+    if not os.path.exists(args.resultfolder):
+        os.makedirs(args.resultfolder)
+        print(f'Created a folder at {args.resultfolder}')
+        
+    if not os.path.exists(args.modelfolder):
+        os.makedirs(args.modelfolder)
+        print(f'Created a folder at {args.modelfolder}')
+
+
+
+def test_createfolders():
+    with TemporaryDirectory(dir = 'tmp/') as temp_dir:
+        parser = argparse.ArgumentParser()
+        #Structuture related values
+        parser.add_argument('--datafolder', type=str, default=os.path.join(temp_dir, 'Data/'), help='Path to where data will be saved during training.')
+        parser.add_argument('--resultfolder', type=str, default=os.path.join(temp_dir, 'Results/'), help='Path to where results will be saved during evaluation.')
+        parser.add_argument('--modelfolder', type=str, default=os.path.join(temp_dir, 'Experiments/'), help='Path to where model weights will be saved at the end of training.')
+        
+        args = parser.parse_args()
+        createfolders(args)
+        
+    return 

utils/dataloaders/svhn.py

@@ -0,0 +1,11 @@
+from torch.utils.data import Dataset
+
+class SVHN(Dataset):
+    def __init__(self):
+        super().__init__()
+    
+    def __len__(self):
+        return 
+    
+    def __getitem__(self, index):
+        return

utils/load_data.py

@@ -0,0 +1,5 @@
+from torch.utils.data import Dataset
+
+def load_data(dataset:str) -> Dataset:
+    
+    raise ValueError(f'Dataset: {dataset} not implemented. \nCheck the documentation for implemented metrics, or check your spelling')

utils/load_metric.py

@@ -0,0 +1,27 @@
+import torch.nn as nn 
+from metrics import EntropyPrediction
+
+def load_metric(metricname:str) -> nn.Module:
+    '''
+    This function returns an instance of a class inhereting from nn.Module. 
+    This class returns the given metric given a set of label - prediction pairs. 
+    
+    Parameters
+    ----------
+    metricname: string
+        string naming the metric to return. 
+    
+    Returns
+    -------
+    Class
+        Returns an instance of a class inhereting from nn.Module.
+    
+    Raises
+    ------
+    ValueError
+        When the metricname parameter does not match any implemented metric, raise this error along with a descriptive message. 
+    '''
+    if metricname == 'EntropyPrediction':
+        return EntropyPrediction()
+    else:
+        raise ValueError(f'Metric: {metricname} has not been implemented. \nCheck the documentation for implemented metrics, or check your spelling')

utils/load_model.py

@@ -0,0 +1,9 @@
+import torch.nn as nn 
+from models import MagnusModel
+
+def load_model(modelname:str) -> nn.Module:
+    
+    if modelname == 'MagnusModel':
+        return MagnusModel()
+    else:
+        raise ValueError(f'Model: {modelname} has not been implemented. \nCheck the documentation for implemented metrics, or check your spelling')

utils/metrics/EntropyPred.py

@@ -0,0 +1,10 @@
+import torch.nn as nn 
+
+
+class EntropyPrediction(nn.Module):
+    def __init__(self):
+        super().__init__()
+        
+    def __call__(self, y_true, y_false):
+        
+        return