Merge pull request UbinetLab#6 from dIronmanb/develop

chapter02

Author: waverdeep

Chapter02/__pycache__/data_loaders.cpython-36.pyc

@@ -0,0 +1,43 @@
+# config 파일에 대하여
+#   config 파일에는
+#     딥러닝 모델
+#     손실 함수
+#     옵티마이저
+#     하이퍼파라미터
+#     에폭
+#   등 모든 것들이 담겨져 있다.
+#   뭔가 모델을 바꾸거나 에폭을 바꾸고 싶을 때는 여기서 해당 이름에 대응하는
+#   값만 조정하면 된다.
+
+#   단, 모델, 손실 함수, 옵티마이저의 경우
+#   내가 원하는 것의 이름으로 변경 해당 모델, 손실함수, 옵티마이저 파일에
+#   정의되어 있어야 한다.
+
+---
+  use_cuda: true
+  epoch: 100
+  batch_size: 64
+  learning_rate: 0.001
+  dataset_name: "CIFAR10"
+  
+  # train_dataset
+  # test_dataset
+  # 은 CIFAR10 Dataloader에서만 작업할 것이므로 pass
+
+  num_workers: 2
+  dataset_shuffle: True
+  
+  model: "CNN_5"
+  model_layer: 3 # [3, 5, 9, 12]
+  loss_function: "CrossEntropyLoss"
+  optimizer: "Adam"
+  momentum: 0.9
+  weight_decay : 0.01
+  metrics: "accuracy_score"
+
+
+  # momentum이랑 weight_decay 정의하기
+  
+
+
+

Chapter02/__pycache__/metric.cpython-36.pyc

@@ -0,0 +1,52 @@
+import pickle
+import numpy as np
+from torch.utils.data import TensorDataset, DataLoader
+import torch
+
+def unpickle(file):
+    with open(file, "rb") as fo:
+        dict = pickle.load(fo, encoding = "bytes")
+    return dict
+
+def pickle_to_images_and_labels(root):
+    # Get dataset
+    data = unpickle(root)
+    # normalize
+    data_images = data[b'data'] / 255 
+    # reshape data >> -1 * 3 * 32 * 32
+    # num of data, colour, width, height
+    data_images = data_images.reshape(-1, 3, 32, 32).astype("float32")
+    data_labels = data[b'labels']
+    return data_images, data_labels
+
+def data_load(config):
+    # preprocessing data
+    train_images_and_labels = []
+    for i in range(5):
+        train_images_and_labels.append(pickle_to_images_and_labels("/data/CNN_model/dataset/cifar-10-batches-py/data_batch_" + str(i + 1)))
+
+    train_images = np.concatenate([i[0] for i in train_images_and_labels], axis = 0)
+    train_labels = np.concatenate([i[1] for i in train_images_and_labels], axis = 0)
+
+    test_images, test_labels = pickle_to_images_and_labels("/data/CNN_model/dataset/cifar-10-batches-py/test_batch")
+    test_images = np.concatenate([test_images], axis = 0)
+    test_labels = np.concatenate([test_labels], axis = 0)
+
+
+    # Convert numpy to tensor
+    train_images_tensor = torch.tensor(train_images)
+    train_labels_tensor = torch.tensor(train_labels)
+    train_tensor = TensorDataset(train_images_tensor, train_labels_tensor)
+    train_loader = DataLoader(train_tensor, 
+                              batch_size = config['batch_size'], 
+                              num_workers=config['num_workers'], 
+                              shuffle = config['dataset_shuffle']
+                             )
+
+    test_images_tensor = torch.tensor(test_images)
+    
+    test_loader = (test_images_tensor, test_labels)
+    return train_loader, test_loader
+    
+    
+    

Chapter02/__pycache__/models.cpython-36.pyc

@@ -0,0 +1,15 @@
+from sklearn.metrics import accuracy_score, recall_score, precision_score, f1_score
+
+
+def get_metrics(test, predicted, config):
+    name = config['metrics']
+    if name == "accuracy_score":
+        return accuracy_score(test, predicted)
+    elif name  == "recall_score":
+        return recall_score(test, predicted)
+    elif name == "precision_score":
+        return precision_score(test, predicted)
+    elif name == "f1_score":
+        return f1_score(test, predicted)
+    else:
+        print("There is no metrics in metrics_name")

Chapter02/__pycache__/test.cpython-36.pyc

@@ -0,0 +1,217 @@
+import torch.nn as nn
+import torch.nn.functional as F
+
+def get_cnn_model(name):
+    if name == 'CNN_3':
+        return CNN_3()
+    elif name == 'CNN_5':
+        return CNN_5()
+    elif name == 'CNN_9':
+        return CNN_9()
+    elif name == 'CNN_12':
+        return CNN_12()
+    else:
+        print("There is no name in models")
+
+# class CNN_3(nn.Module):
+#     def __init__(self):
+#         super(CNN_3, self).__init__()
+#         # Output = (Input - Kernel_size + 2*Padding_size) / Stride + 1
+#         self.conv1 = nn.Conv2d(in_channels = 3, out_channels = 8, kernel_size = 3, padding = 1)
+#         self.conv2 = nn.Conv2d(in_channels = 8, out_channels = 8, kernel_size = 3, padding = 1)
+#         self.conv3 = nn.Conv2d(in_channels = 8, out_channels = 8, kernel_size = 3, padding = 1)
+        
+#          # Output = (Input - kernel_size) / stride + 1
+#         self.pool = nn.MaxPool2d(kernel_size = 2, stride = 2)
+        
+#         self.fc1 = nn.Linear(4 * 4 * 8, 64)
+#         self.fc2 = nn.Linear(64, 32)
+#         self.fc3 = nn.Linear(32, 10)
+                
+         
+        
+#     def forward(self,x):
+#         x = self.conv1(x) # 32 * 32 * 8
+#         x = self.pool(x) # 16 * 16 * 8
+#         x = F.relu(x)
+        
+#         x = self.conv2(x) # 16 * 16 * 8
+#         x = self.pool(x) # 8 * 8 * 8
+#         x = F.relu(x)
+        
+#         x = self.conv2(x) # 8 * 8 * 8
+#         x = self.pool(x)  # 4 * 4 * 8
+#         x = F.relu(x)
+        
+        
+#         x = x.view(-1, 4 * 4 * 8) # flatten
+#         x = self.fc1(x)
+#         x = F.relu(x)
+#         x = self.fc2(x)
+#         x = F.relu(x)
+#         x = self.fc3(x)
+#         x = F.log_softmax(x)
+#         return x
+    
+class CNN_5(nn.Module):
+    def __init__(self):
+        super(CNN_5, self).__init__()
+        # Output = (Input - Kernel_size + 2*Padding_size) / Stride + 1
+        self.conv_in = nn.Conv2d(in_channels = 3, out_channels = 8, kernel_size = 3, padding = 1)
+        self.conv_hidden = nn.Conv2d(in_channels = 8, out_channels = 8, kernel_size = 3, padding = 1)
+        self.conv_out = nn.Conv2d(in_channels = 8, out_channels = 16, kernel_size = 3, padding = 1)
+        
+        # Output = (Input - kernel_size) / stride + 1
+        self.pool = nn.MaxPool2d(kernel_size = 2, stride = 2)
+        
+        self.fc1 = nn.Linear(8 * 8 * 16, 64)
+        self.fc2 = nn.Linear(64, 32)
+        self.fc3 = nn.Linear(32, 10)
+                
+         
+        
+    def forward(self,x):
+        x = self.conv_in(x) # 32 * 32 * 8
+        x = self.pool(x) # 16 * 16 * 8
+        x = F.relu(x)
+        
+        x = F.relu(self.conv_hidden(x)) # 16 * 16 * 8
+        x = F.relu(self.conv_hidden(x)) # 16 * 16 * 8
+        x = F.relu(self.conv_hidden(x)) # 16 * 16 * 8
+        
+        x = self.conv_out(x) # 16 * 16 * 16
+        x = self.pool(x)  # 8 * 8 * 16
+        x = F.relu(x)
+        
+        
+        x = x.view(-1, 8 * 8 * 16) # flatten
+        x = self.fc1(x)
+        x = F.relu(x)
+        x = self.fc2(x)
+        x = F.relu(x)
+        x = self.fc3(x)
+        x = F.log_softmax(x)
+        return x
+    
+class CNN_9(nn.Module):
+    def __init__(self):
+        super(CNN_9, self).__init__()
+        # Output = (Input - Kernel_size + 2*Padding_size) / Stride + 1
+        self.conv_in = nn.Conv2d(in_channels = 3, out_channels = 8, kernel_size = 3, padding = 1)
+        self.conv_hidden = nn.Conv2d(in_channels = 8, out_channels = 8, kernel_size = 3, padding = 1)
+        self.conv_out = nn.Conv2d(in_channels = 8, out_channels = 16, kernel_size = 3, padding = 1)
+        
+        # Output = (Input - kernel_size) / stride + 1
+        self.pool = nn.MaxPool2d(kernel_size = 2, stride = 2)
+        
+        self.fc1 = nn.Linear(8 * 8 * 16, 64)
+        self.fc2 = nn.Linear(64, 32)
+        self.fc3 = nn.Linear(32, 10)
+                
+         
+        
+    def forward(self,x):
+        x = self.conv_in(x) # 32 * 32 * 8
+        x = self.pool(x) # 16 * 16 * 8
+        x = F.relu(x)
+        
+        for _ in range(7):
+            x = F.relu(self.conv_hidden(x)) # 16 * 16 * 8
+        
+        # x = F.relu(self.conv_hidden(x)) # 16 * 16 * 8    
+        # x = F.relu(self.conv_hidden(x)) # 16 * 16 * 8
+        # x = F.relu(self.conv_hidden(x)) # 16 * 16 * 8
+        # x = F.relu(self.conv_hidden(x)) # 16 * 16 * 8    
+        # x = F.relu(self.conv_hidden(x)) # 16 * 16 * 8
+        # x = F.relu(self.conv_hidden(x)) # 16 * 16 * 8
+        # x = F.relu(self.conv_hidden(x)) # 16 * 16 * 8
+        
+        x = self.conv_out(x) # 16 * 16 * 16
+        x = self.pool(x)  # 8 * 8 * 16
+        x = F.relu(x)
+        
+        
+        x = x.view(-1, 8 * 8 * 16) # flatten
+        x = self.fc1(x)
+        x = F.relu(x)
+        x = self.fc2(x)
+        x = F.relu(x)
+        x = self.fc3(x)
+        x = F.log_softmax(x)
+        return x
+    
+class CNN_12(nn.Module):
+    
+    def __init__(self):
+        super(CNN_12, self).__init__()
+        # Output = (Input - Kernel_size + 2*Padding_size) / Stride + 1
+        self.conv_in = nn.Conv2d(in_channels = 3, out_channels = 8, kernel_size = 3, padding = 1)
+        self.conv_hidden = nn.Conv2d(in_channels = 8, out_channels = 8, kernel_size = 3, padding = 1)
+        self.conv_out = nn.Conv2d(in_channels = 8, out_channels = 16, kernel_size = 3, padding = 1)
+        
+        # Output = (Input - kernel_size) / stride + 1
+        self.pool = nn.MaxPool2d(kernel_size = 2, stride = 2)
+        
+        self.fc1 = nn.Linear(8 * 8 * 16, 64)
+        self.fc2 = nn.Linear(64, 32)
+        self.fc3 = nn.Linear(32, 10)
+                
+         
+        
+    def forward(self,x):
+        x = self.conv_in(x) # 32 * 32 * 8
+        x = self.pool(x) # 16 * 16 * 8
+        x = F.relu(x)
+        
+        for _ in range(10):
+            x = F.relu(self.conv_hidden(x)) # 16 * 16 * 8
+        
+        # x = F.relu(self.conv_hidden(x)) # 16 * 16 * 8    
+        
+        x = self.conv_out(x) # 16 * 16 * 16
+        x = self.pool(x)  # 8 * 8 * 16
+        x = F.relu(x)
+        
+        
+        x = x.view(-1, 8 * 8 * 16) # flatten
+        x = self.fc1(x)
+        x = F.relu(x)
+        x = self.fc2(x)
+        x = F.relu(x)
+        x = self.fc3(x)
+        x = F.log_softmax(x)
+        return x
+       
+    
+class CNN_3(nn.Module):
+    def __init__(self): 
+        super(CNN_3, self).__init__()
+        
+        # # Output = (Input - Kernel_size + 2*Padding_size) / Stride + 1
+        # self.conv_in = nn.Conv2d(in_channels = 3, out_channels = 8, kernel_size = 3, padding = 1)
+        #input = 3, output = 6, kernal = 5
+        self.conv1 = nn.Conv2d(3, 6, 5) # 32 * 32 * 6
+        
+        
+        # # Output = (Input - kernel_size) / stride + 1
+        # self.pool = nn.MaxPool2d(kernel_size = 2, stride = 2)        
+        #kernal = 2, stride = 2, padding = 0 (default)
+        self.pool = nn.MaxPool2d(2, 2)
+        self.conv2 = nn.Conv2d(6, 16, 5)
+        #input feature, output feature
+        self.fc1 = nn.Linear(16 * 5 * 5, 120)
+        self.fc2 = nn.Linear(120, 84)
+        self.fc3 = nn.Linear(84, 10)
+        
+        
+    # 값 계산
+    def forward(self, x):
+        x = self.pool(F.relu(self.conv1(x)))
+        x = self.pool(F.relu(self.conv2(x))) 
+        x = x.view(-1, 16 * 5 * 5)
+        x = F.relu(self.fc1(x)) 
+        x = F.relu(self.fc2(x)) 
+        x = self.fc3(x) 
+        return x
+
+