Merge pull request #6 from grupacosmo/data_preprocessing

Data preprocessing

.gitignore

@@ -0,0 +1,4 @@
+/data/train/
+/data/validation/
+/data/test/
+/data/dataset/

README.md

@@ -1,23 +1,18 @@
-Planning:
+# CNN aerial car detection
 
+Python project that utilizes camera input to monitor the environment, enabling
+the identification and tracking of targeted objects based on the previously trained
+CNN model. Any object appearances will be logged, providing additional data.
 
+Recently, AI and detection become more and more popular among countless field of work. 
+This project was created as a detection module for 4 meters drone that will scan 
+streets seeking for cars and log their routes.
 
-Goal:
+# Usage
 
-Identify each car on the screen and log:
+WIP
 
-Every 1 frame:
- - Localization
- - Date
+# Documentation
 
-Every 30 frames (~1 second):
- - Photo
- - Car color
-
-Problems:
- - Real-time detection
- - Pursue specific car (Find the same car on different frame)
-
-TODO:
- - Find more data (photo and video)
+WIP
 

Scripts/data_preprocessing.py

@@ -23,11 +23,21 @@ def augmentation(self):
             pic = random.randrange(0, 14)
         image_aug = self.augmentation('''image=pic''') #TODO: wsadzić tu obrazy i zobaczymy czy działa xd
 
+    def normalize(self):
+        for img_set in self.data.data:
+            self.data.data[img_set]['images'] = self.data.data[img_set]['images']/255
     def resize(self):
         for img_set in self.data.data:
+            a, b, c, d = (self.data.data[img_set]['images'].shape)
+            shap = (a,) + self.size + (3,)
+            resized_imgs = np.ndarray(shape=shap)
             for index, img in enumerate(self.data.data[img_set]['images']):
-                self.data.data[img_set]['images'][index] = cv2.resize(img, self.size)
-                ...
+                img = cv2.resize(img, dsize=self.size, interpolation=cv2.INTER_CUBIC)
+                resized_imgs[index] = img
+            self.data.data[img_set]['images'] = resized_imgs
+            # a, b, c, d = (self.data.data[img_set]['images'].shape)
+            # shap = (a,) + self.size
+            # self.data.data[img_set]['images'] = cv2.resize(self.data.data[img_set]['images'], self.size)
 
     @property
     def size(self):

Scripts/gather_data.py

@@ -1,34 +1,40 @@
 import os
 import pickle
 import numpy as np
-from PIL import Image
 import cv2
+from sklearn.model_selection import train_test_split
+import shutil
 
 
-#TODO
-# 1. Niech przy tworzeniu obiektu od razu tworzył 3 zmienne z danymi do trenowania, walidacji i testowania
-# (więc  trzeba dodać 3 plik), najlepiej wrzuć wszystkie dane do 1 pliku i potem to podziel na 3
-# a w klasie zrób może liste list data[train[...], validation[...], test[...]]
-#
-
 class Data():
     def __init__(self):
         self.paths = {
-            'train': './data/train',
-            'validation': './data/validation',
-            #'test': '../data'
+            'train': 'data/train',
+            'validation': 'data/validation',
+            'test': 'data/test'
         }
-        self.data = {'train': [], 'validation': []} # 'test': []
+        self.data = {'train': [], 'validation': [], 'test': []}
         self.prepare_and_load_data()
 
     def prepare_and_load_data(self):
-        if not os.listdir('./data/pickle'):
+        # if not os.listdir('./data/pickle'):
+        #     for set_name in self.paths:
+        #         if self.paths[set_name]:
+        #             self.data[set_name] = self.prepare_data(self.paths[set_name])
+        #             self.save_data(self.data[set_name], set_name)
+        #             self.data[set_name] = self.load_data(set_name)
+        # else:
+        #     for set_name in self.paths:
+        #         self.data[set_name] = self.load_data(set_name)
+        if any(not os.listdir(path) for path in self.paths.values()):
+            print("weszlo")
+            all_data = self.prepare_dataset()
+            self.data['train'], self.data['validation'], self.data['test'] = all_data
             for set_name in self.paths:
-                if self.paths[set_name]:
-                    self.data[set_name] = self.prepare_data(self.paths[set_name])
-                    self.save_data(self.data[set_name], set_name)
-                    self.data[set_name] = self.load_data(set_name)
+                self.save_data(self.data[set_name], set_name)
+            self.copy_files_to_folders()
         else:
+            print("nie weszło")
             for set_name in self.paths:
                 self.data[set_name] = self.load_data(set_name)
 
@@ -45,12 +51,66 @@ def prepare_data(self, path):
                 data['labels'].append(label)
         return data
 
+    def prepare_dataset(self):
+        base_path = 'data/dataset'
+        categories = {'cars': 1, 'non_cars': 0}
+        file_paths = {'images': [], 'labels': []}
+        data = {'images': [], 'labels': []}
+
+        for category, label in categories.items():
+            category_path = os.path.join(base_path, category).replace("\\", "/")
+            for file in os.listdir(category_path):
+                file_path = os.path.join(category_path, file).replace("\\", "/")
+                image = cv2.imread(file_path)
+                image = cv2.resize(image, (100, 100))
+                image = np.array(image)
+                data['images'].append(image)
+                data['labels'].append(label)
+                file_paths['images'].append(file_path)
+                file_paths['labels'].append(label)
+
+        images = np.array(data['images'])
+        labels = np.array(data['labels'])
+
+        train_images, temp_images, train_labels, temp_labels, train_indices, temp_indices = train_test_split(
+            images, labels, range(len(labels)), test_size=0.2, stratify=labels, random_state=42, shuffle=True)
+        test_images, val_images, test_labels, val_labels, test_indices, val_indices = train_test_split(
+            temp_images, temp_labels, temp_indices, test_size=0.5, stratify=temp_labels, random_state=42, shuffle=True)
+
+        self.indices = {
+            'train': train_indices,
+            'validation': val_indices,
+            'test': test_indices
+        }
+        self.file_paths = file_paths
+
+        train_data = {'images': train_images, 'labels': train_labels}
+        val_data = {'images': val_images, 'labels': val_labels}
+        test_data = {'images': test_images, 'labels': test_labels}
+
+        return train_data, val_data, test_data
+
+    def copy_files_to_folders(self):
+        for set_name in ['train', 'validation', 'test']:
+            target_folder = self.paths[set_name]
+            indices = self.indices[set_name]
+            for idx in indices:
+                label = 'cars' if self.file_paths['labels'][idx] == 1 else 'non_cars'
+                src_file_path = self.file_paths['images'][idx]
+                dest_folder = os.path.join(target_folder, label)
+                if not os.path.exists(dest_folder):
+                    os.makedirs(dest_folder)
+                shutil.copy(src_file_path, dest_folder)
+
     def save_data(self, data, file_name):
-        file_path = f'./data/pickle/{file_name}.pkl'
+        file_path = f'data/pickle/{file_name}.pkl'
         with open(file_path, 'wb') as file:
             pickle.dump(data, file)
 
     def load_data(self, filename):
-        file_path = f'./data/pickle/{filename}.pkl'
+        file_path = f'data/pickle/{filename}.pkl'
         with open(file_path, 'rb') as file:
             return pickle.load(file)
+
+if __name__ == '__main__':
+    data = Data()

Scripts/model.py

@@ -2,31 +2,68 @@
 from keras.models import Sequential
 from keras.layers import Dense, Conv2D, MaxPool2D, Flatten
 
+from keras.models import Sequential
+from keras.layers import Conv2D, MaxPooling2D, BatchNormalization
+from keras.layers import Activation, Dropout, Flatten, Dense
+from keras.initializers import RandomNormal
+from keras.regularizers import l2
+
 
 #TODO
 # 1. Make some hyperparameters tuning
 class Model:
     def __init__(self, prepared_data:Preprocessing):
         self.prepared_data = prepared_data
-        self.size = prepared_data.size
+        self.size = list(prepared_data.size)
         self.model = Sequential()
 
     def build_cnn_model(self):
-        self.model = Sequential()
-        self.model.add(Conv2D(filters=32, kernel_size=(4, 4), input_shape=(self.size, self.size, 3), activation='relu'))
-        self.model.add(MaxPool2D(pool_size=(2, 2)))
-        self.model.add(Conv2D(filters=32, kernel_size=(4, 4), input_shape=(self.size, self.size, 3), activation='relu'))
-        self.model.add(MaxPool2D(pool_size=(2, 2)))
+        # self.model = Sequential()
+        # self.model.add(Conv2D(filters=32, kernel_size=(4, 4), input_shape=(self.size[0], self.size[1], 3), activation='relu'))
+        # self.model.add(MaxPool2D(pool_size=(2, 2)))
+        # self.model.add(Conv2D(filters=32, kernel_size=(4, 4), input_shape=(self.size[0], self.size[1], 3), activation='relu'))
+        # self.model.add(MaxPool2D(pool_size=(2, 2)))
+        # self.model.add(Flatten())
+        # self.model.add(Dense(256, activation="relu"))
+        # self.model.add(Dense(1, activation='softmax'))
+        # self.model.compile(loss='binary_crossentropy', metrics=['accuracy'], optimizer='adam')
+
+
+
+        self.model.add(Conv2D(32, (5, 5), kernel_initializer=RandomNormal(mean=0.0, stddev=0.05, seed=None),
+                         kernel_regularizer=l2(0.001), input_shape=(self.size[0], self.size[1], 3)))
+        self.model.add(Activation('relu'))
+        self.model.add(MaxPooling2D(pool_size=(2, 2)))
+
+        self.model.add(Conv2D(32, (5, 5), kernel_initializer=RandomNormal(mean=0.0, stddev=0.05, seed=None),
+                         kernel_regularizer=l2(0.001), input_shape=(self.size[0], self.size[1], 3)))
+        self.model.add(Activation('relu'))
+        self.model.add(MaxPooling2D(pool_size=(2, 2)))
+
+        # self.model.add(Conv2D(64, (5, 5), kernel_initializer=RandomNormal(mean=0.0, stddev=0.05, seed=None),
+        #                  kernel_regularizer=l2(0.001), input_shape=(self.size[0], self.size[1], 3)))
+        # self.model.add(Activation('relu'))
+        # self.model.add(MaxPooling2D(pool_size=(2, 2)))
+
         self.model.add(Flatten())
-        self.model.add(Dense(256, activation="relu"))
-        self.model.add(Dense(10, activation='softmax'))
-        self.model.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer='rmsprop')
+        self.model.add(Dense(64, kernel_initializer=RandomNormal(mean=0.0, stddev=0.05, seed=None), kernel_regularizer=l2(0.001)))
+        self.model.add(Activation('relu'))
+        self.model.add(Dropout(0.5))
+        self.model.add(Dense(1))
+        self.model.add(Activation('sigmoid'))
+
+        self.model.compile(loss='binary_crossentropy',
+                      optimizer='adam',
+                      metrics=['accuracy'])
 
+        print(self.model.summary())
     def fit_model(self):
-        self.model.fit()
+        self.model.fit(self.prepared_data.data.data['train']['images'],
+                       self.prepared_data.data.data['train']['labels'], epochs=50, batch_size=50)
 
     def validate_model(self):
-        self.model.evaluate()
+        self.model.evaluate(self.prepared_data.data.data['validation']['images'],
+                            self.prepared_data.data.data['validation']['labels'])
 
     def save_model(self):
-        self.model.save("model.h5")
+        self.model.save("model.keras")