chore: Add model service files

.devcontainer/api/devcontainer.json

@@ -0,0 +1,12 @@
+{
+  "name": "ML Project - API",
+  "dockerComposeFile": "../../docker-compose-dev.yml",
+  "service": "api",
+  "workspaceFolder": "/src",
+  "customizations": {
+    "vscode": {
+      "extensions": ["ms-python.python"]
+    }
+  },
+  "shutdownAction": "none"
+}

.devcontainer/model/devcontainer.json

@@ -0,0 +1,12 @@
+{
+  "name": "ML Project - Model",
+  "dockerComposeFile": "../../docker-compose-dev.yml",
+  "service": "model",
+  "workspaceFolder": "/src",
+  "customizations": {
+    "vscode": {
+      "extensions": ["ms-python.python"]
+    }
+  },
+  "shutdownAction": "none"
+}

.devcontainer/ui/devcontainer.json

@@ -0,0 +1,12 @@
+{
+  "name": "ML Project - UI",
+  "dockerComposeFile": "../../docker-compose-dev.yml",
+  "service": "ui",
+  "workspaceFolder": "/src",
+  "customizations": {
+    "vscode": {
+      "extensions": ["ms-python.python"]
+    }
+  },
+  "shutdownAction": "none"
+}

.github/workflows/main.yml

@@ -0,0 +1,35 @@
+# This is a basic workflow to help you get started with Actions
+
+name: CI
+
+# Controls when the workflow will run
+on:
+  # Triggers the workflow on push or pull request events but only for the "master" branch
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# A workflow run is made up of one or more jobs that can run sequentially or in parallel
+jobs:
+  # This workflow contains a single job called "build"
+  build:
+    # The type of runner that the job will run on
+    runs-on: ubuntu-latest
+
+    # Steps represent a sequence of tasks that will be executed as part of the job
+    steps:
+      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+      - uses: actions/checkout@v3
+      
+      - name: Black Check
+        uses: RojerGS/python-black-check@master
+        with:
+          line-length: '88'
+        
+      # Run all the containers specified in docker-compose.yml file
+      - name: Test containers build
+        run: docker-compose up -d --build

model/Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.8.13 AS base
+
+ENV PYTHONPATH=$PYTHONPATH:/src/
+
+ADD requirements.txt .
+RUN pip3 install -r requirements.txt
+
+ENV PYTHONPATH=$PYTHONPATH:/src/
+
+COPY ./ /src/ 
+
+WORKDIR /src
+
+FROM base AS test
+RUN ["pytest", "-v", "/src/tests"]
+
+FROM base AS build
+ENTRYPOINT ["python3", "/src/ml_service.py"]
+

model/ml_service.py

@@ -0,0 +1,107 @@
+import json
+import os
+import time
+
+import numpy as np
+import redis
+import settings
+from tensorflow.keras.applications import ResNet50
+from tensorflow.keras.applications.resnet50 import decode_predictions, preprocess_input
+from tensorflow.keras.preprocessing import image
+
+# Connect to Redis and assign to variable db
+db = redis.Redis(
+    host=settings.REDIS_IP, port=settings.REDIS_PORT, db=settings.REDIS_DB_ID
+)
+
+# Load ML model
+model = ResNet50(include_top=True, weights="imagenet")
+
+
+def predict(image_name):
+    """
+    Load image from the corresponding folder based on the image name
+    received, then, run our ML model to get predictions.
+
+    Parameters
+    ----------
+    image_name : str
+        Image filename.
+
+    Returns
+    -------
+    class_name, pred_probability : tuple(str, float)
+        Model predicted class as a string and the corresponding confidence
+        score as a number.
+    """
+    class_name = None
+    pred_probability = None
+
+    # Get image path
+    image_path = os.path.join(settings.UPLOAD_FOLDER, image_name)
+
+    # Load image
+    img = image.load_img(image_path, target_size=(224, 224))
+
+    # Apply preprocessing (convert to numpy array, match model input dimensions (including batch) and use the resnet50 preprocessing)
+    # Convert Pillow image to np.array
+    x = image.img_to_array(img)
+
+    # Add an extra dimension because the model is expecting as input a batch of images
+    x_batch = np.expand_dims(x, axis=0)
+
+    # Scaled pixels values
+    x_batch = preprocess_input(x_batch)
+
+    # Make predictions
+    predictions = model.predict(x_batch)
+
+    # Get predictions using model methods and decode predictions using resnet50 decode_predictions
+    top_pred = decode_predictions(predictions, top=1)[0][0]  # imagenet_id, label, score
+    _, class_name, pred_probability = top_pred
+
+    # Convert probabilities to float and round it
+    pred_probability = round(float(pred_probability), 4)
+
+    return class_name, pred_probability
+
+
+def classify_process():
+    """
+    Loop indefinitely asking Redis for new jobs.
+    When a new job arrives, takes it from the Redis queue, uses the loaded ML
+    model to get predictions and stores the results back in Redis using
+    the original job ID so other services can see it was processed and access
+    the results.
+
+    Load image from the corresponding folder based on the image name
+    received, then, run our ML model to get predictions.
+    """
+    while True:
+        # Take a new job from Redis
+        q = db.brpop(settings.REDIS_QUEUE)[1]
+
+        # Decode the JSON data for the given job
+        q = json.loads(q.decode("utf-8"))
+
+        # Important! Get and keep the original job ID
+        job_id = q["id"]
+
+        # Run the loaded ml model (use the predict() function)
+        prediction, score = predict(q["image_name"])  # 👈 Verify image name
+
+        # Prepare a new JSON with the results
+        output = {"prediction": prediction, "score": score}
+
+        # Store the job results on Redis using the original
+        # job ID as the key
+        db.set(job_id, json.dumps(output))
+
+        # Sleep for a bit
+        time.sleep(settings.SERVER_SLEEP)
+
+
+if __name__ == "__main__":
+    # Now launch process
+    print("Launching ML service...")
+    classify_process()

model/requirements.txt

@@ -0,0 +1,5 @@
+Pillow==9.0.1
+pytest==7.1.1
+redis==4.1.4
+tensorflow==2.8.0
+protobuf==3.20.0

model/settings.py

@@ -0,0 +1,18 @@
+import os
+
+# We will store images uploaded by the user on this folder
+UPLOAD_FOLDER = "uploads/"
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+# REDIS
+
+# Queue name
+REDIS_QUEUE = "service_queue"
+# Port
+REDIS_PORT = 6379
+# DB Id
+REDIS_DB_ID = 0
+# Host IP
+REDIS_IP = os.getenv("REDIS_IP", "redis")
+# Sleep parameters which manages the interval between requests to our redis queue
+SERVER_SLEEP = 0.05

model/tests/test_model.py

@@ -0,0 +1,18 @@
+import unittest
+
+import ml_service
+
+
+# 💡 NOTE Run test with:
+# - python3 -m unittest -vvv tests.test_model
+# - python3 tests/test_model.py
+class TestMLService(unittest.TestCase):
+    def test_predict(self):
+        ml_service.settings.UPLOAD_FOLDER = "tests"
+        class_name, pred_probability = ml_service.predict("dog.jpeg")
+        self.assertEqual(class_name, "Eskimo_dog")
+        self.assertAlmostEqual(pred_probability, 0.9346, 5)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)