Implementation of Binary Image Classification

.devcontainer/devcontainer.json

@@ -38,7 +38,8 @@
 			// Add the IDs of extensions you want installed when the container is created.
 			"extensions": [
 				"ms-python.python",
-				"ms-python.vscode-pylance"
+				"ms-python.vscode-pylance",
+				"stevensona.character-count"
 			]
 		}
 	},

.github/workflows/pylint.yml

@@ -9,9 +9,9 @@ jobs:
       matrix:
         python-version: ["3.8", "3.9", "3.10"]
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v4
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install dependencies
@@ -24,4 +24,4 @@ jobs:
         echo "PYTHONPATH=./" >> $GITHUB_ENV
     - name: Analysing the code with pylint
       run: |
-        pylint --disable=missing-docstring --indent-string='   ' $(git ls-files "*.py")
+        pylint --disable=missing-docstring --disable=no-member --indent-string='   ' $(git ls-files "*.py")

.gitignore

@@ -130,5 +130,14 @@ dmypy.json
 
 # fake data generated by the tests
 .fake
+
 # upload directory
 data/
+
+# JPEG
+*.jpg
+*.jpeg
+*.jpe
+*.jif
+*.jfif
+*.jfi

.vscode/extensions.json

@@ -0,0 +1,5 @@
+{
+   "recommendations": [
+      "stevensona.character-count"
+   ]
+}

application/code_generator.py

@@ -1,95 +1,60 @@
-from model import code_blocks
-class CodeGenerator:
-   def __init__(self, template_mapping, parse_template):
-      self.blocks = code_blocks.AllBlocks()
-      self.function_mapping = template_mapping
-      self.parse_template = parse_template
-      self.data = {}
-
+from application.code_parser import CodeParser
+class CodeGenerator(CodeParser):
    def get_data(self):
       return self.data['dataframe']
 
    def load_data(self, csv_file):
-      dataframe = self._parse_and_execute('read_csv', [csv_file])
-      self._save('dataframe', dataframe)
+      dataframe = self.parse_and_execute('read_csv', [csv_file])
+      self.save('dataframe', dataframe)
       return self.data['dataframe'].shape
 
    def describe_data(self):
-      output = self._parse_and_execute('describe_data', ['dataframe'])
+      output = self.parse_and_execute('describe_data', ['dataframe'])
       return output
 
    def get_labels(self):
-      keys = self._parse_and_execute('get_keys', ['dataframe'])
+      keys = self.parse_and_execute('get_keys', ['dataframe'])
       return keys.values.tolist()
 
    def select_y(self, output_label):
-      x_values, y_values = self._parse_and_execute('select_y', ['dataframe', output_label])
-      self._save('x_values', x_values)
-      self._save('y_values', y_values)
+      x_values, y_values = self.parse_and_execute('select_y', ['dataframe', output_label])
+      self.save('x_values', x_values)
+      self.save('y_values', y_values)
 
    def drop_x(self, input_labels):
-      dataframe = self._parse_and_execute('drop_x', ['dataframe', input_labels])
-      self._save('dataframe', dataframe)
+      dataframe = self.parse_and_execute('drop_x', ['dataframe', input_labels])
+      self.save('dataframe', dataframe)
 
    def clean_data(self):
-      dataframe = self._parse_and_execute('clean_data', ['dataframe'])
-      self._save('dataframe', dataframe)
+      dataframe = self.parse_and_execute('clean_data', ['dataframe'])
+      self.save('dataframe', dataframe)
       return self.data['dataframe'].shape
 
    def split_data(self, train_ratio = 0.8, seed = 200):
       # the ordering of x/y train/test is different here but I don't know why
-      (x_train, y_train, x_test, y_test)=self._parse_and_execute(
+      (x_train, y_train, x_test, y_test)=self.parse_and_execute(
          'split',['x_values','y_values',1-train_ratio,seed]
       )
-      self._save('x_train', x_train)
-      self._save('x_test', x_test)
-      self._save('y_train', y_train)
-      self._save('y_test', y_test)
+      self.save('x_train', x_train)
+      self.save('x_test', x_test)
+      self.save('y_train', y_train)
+      self.save('y_test', y_test)
       return self.data['x_train'].shape
 
    def train_lin_reg(self):
-      model = self._parse_and_execute('train_lin_reg', ['x_train', 'y_train'])
-      self._save('model', model)
+      model = self.parse_and_execute('train_lin_reg', ['x_train', 'y_train'])
+      self.save('model', model)
       return model
 
    def lin_reg_predict(self):
-      (train_preds, test_preds) = self._parse_and_execute(
+      (train_preds, test_preds) = self.parse_and_execute(
          'lin_reg_predict', ['model', 'x_train', 'x_test']
       )
-      self._save('train_preds', train_preds)
-      self._save('test_preds', test_preds)
+      self.save('train_preds', train_preds)
+      self.save('test_preds', test_preds)
 
    def eval_lin_reg(self):
-      error_change = self._parse_and_execute(
+      error_change = self.parse_and_execute(
          'eval_lin_reg', ['y_train', 'y_test', 'train_preds', 'test_preds']
       )
-      self._save('error_change', error_change)
-
-   def download_code(self):
-      return self.blocks.to_text()
-
-   def _create_new_block(self, comment, statements):
-      block = code_blocks.CodeBlock(comment, statements)
-      self.blocks.add_next_block(block)
-
-   def _parse_and_execute(self, template, args):
-      replaced_args = []
-      string_args = []
-      for arg in args:
-         if isinstance(arg, str) and arg in self.data:
-            replaced_args.append(self.data[arg])
-            string_args.append(arg)
-         else:
-            replaced_args.append(arg)
-            if isinstance(arg, str):
-               string_args.append('\"'+arg+'\"')
-            else:
-               string_args.append(str(arg))
-
-      (comments, code) = self.parse_template(template, string_args)
-      self._create_new_block(comments[0], code)
-      output = self.function_mapping[template](replaced_args)  # where the code is executed
-      return output
-
-   def _save(self, key, value):
-      self.data[key] = value
+      self.save('error_change', error_change)

application/code_parser.py

@@ -0,0 +1,36 @@
+from model import code_blocks
+class CodeParser:
+   def __init__(self, template_mapping, parse_template):
+      self.blocks = code_blocks.AllBlocks()
+      self.function_mapping = template_mapping
+      self.parse_template = parse_template
+      self.data = {}
+
+   def download_code(self):
+      return self.blocks.to_text()
+
+   def create_new_block(self, comment, statements):
+      block = code_blocks.CodeBlock(comment, statements)
+      self.blocks.add_next_block(block)
+
+   def parse_and_execute(self, template, args):
+      replaced_args = []
+      string_args = []
+      for arg in args:
+         if isinstance(arg, str) and arg in self.data:
+            replaced_args.append(self.data[arg])
+            string_args.append(arg)
+         else:
+            replaced_args.append(arg)
+            if isinstance(arg, str):
+               string_args.append('\"'+arg+'\"')
+            else:
+               string_args.append(str(arg))
+
+      (comments, code) = self.parse_template(template, string_args)
+      self.create_new_block(comments[0], code)
+      output = self.function_mapping[template](replaced_args)
+      return output
+
+   def save(self, key, value):
+      self.data[key] = value

application/image_generator.py

@@ -0,0 +1,62 @@
+import random
+import matplotlib.pyplot as plt
+from application.code_parser import CodeParser
+class ImageGenerator(CodeParser):
+   def load_images(self, images_directory):
+      #Dividing the data in different batches and showing labels
+      data = self.\
+         parse_and_execute('load_images', [images_directory])
+      print(data)
+
+   def validate_images(self, images_directory):
+      self.\
+         parse_and_execute('validate_images', [images_directory])
+
+   def preprocess_images(self, images_directory): #directory after validating the images
+      (data, normalized_data) = self.\
+         parse_and_execute('preprocess_images', [images_directory])
+      class_mapping = {}
+      print("Train classes:: ", data.class_names)
+      print("Number of training files:", len(data.file_paths))
+      self.save('data', data)
+      self.save('normalized_data', normalized_data)
+      class_names = self.data['data'].class_names
+      plt.figure(figsize=(10, 10))
+      for images, labels in self.data['data'].take(random.randint(1,len(data))):
+         for i in range(9):
+            plt.subplot(3, 3, i + 1)
+            # plt.imshow(cv2.cvtColor(images[i].numpy().astype('uint8'), cv2.COLOR_BGR2RGB))
+            plt.imshow(images[i].numpy().astype("uint8"))
+            class_mapping[int(labels[i].numpy())]= class_names[labels[i]]
+            plt.title(class_names[labels[i]] + ' => ' + str(labels[i].numpy()))
+            plt.axis("off")
+      self.save('class_mapping', class_mapping)
+      plt.show()
+      return self.data['data']
+
+   def split_images(self, train_ratio, val_ratio, test_ratio):
+      (train, val, test) = self.\
+         parse_and_execute('split_images', ['normalized_data', train_ratio, val_ratio, test_ratio])
+      self.save('train', train)
+      self.save('val', val)
+      self.save('test', test)
+      return self.data['train'], self.data['val'], self.data['test']
+
+   def train_model(self, epochs):
+      (history, model) = self.\
+         parse_and_execute('images_model', ['normalized_data', 'train', 'val', epochs])
+      self.save('history', history)
+      self.save('model', model)
+      return self.data['history']
+
+   def model_metrics(self):
+      (precision, recall, accuracy) = self.parse_and_execute('metrics', ['test', 'model'])
+      return precision, recall, accuracy
+
+   def visualize(self):
+      self.\
+         parse_and_execute('visualize', ['history'])
+
+   def test_image(self, location):
+      self.\
+         parse_and_execute('test_image', [location, 'model', 'class_mapping'])