Initial commit

.gitattributes

@@ -0,0 +1,2 @@
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+.vscode/
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

Dockerfile

@@ -0,0 +1,38 @@
+# Use the Ubuntu image.
+FROM python:3.11-slim-buster
+
+# Allow statements and log messages to immediately appear in the logs
+ENV PYTHONUNBUFFERED True
+
+# Copy local code to the container image.
+WORKDIR /code
+COPY . /code/
+
+# Delete the numpy package from cache
+RUN rm -rf /root/.cache/pip
+
+# Install system dependencies for pyworld
+RUN apt-get update && \
+    apt-get install -y && \
+    apt-get -y update &&\
+    apt-get install -y python3-pip python3-dev python3-opencv && \
+    rm -rf /var/lib/apt/lists/*
+
+# Add write user 
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+COPY --chown=user . $HOME/app
+
+# Install production dependencies.
+RUN pip install --no-cache-dir -r /code/requirements.txt
+
+# Expose the app port
+EXPOSE 7860
+
+# Run the FastAPI application using Uvicorn server.
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,24 @@
+---
+title: Afro-Palm
+emoji: ⚡
+colorFrom: pink
+colorTo: blue
+sdk: docker
+pinned: true
+license: mit
+---
+# Backend
+This repository serves as a central hub for all backend code related to our project. It includes server-side code, database management scripts, APIs, and other related files that support the application's core functionality. 
+
+# Getting Started
+In order to get started install the packages from the requirements.txt using 
+
+    ```pip install -r requirements.txt```
+    
+cd into the main directory in your terminal and run the ff to start the server;
+	    ```uvicorn main:app --reload``` 
+	
+
+# Documentation
+To access to the documentation:
+     Use the url + `/docs`

main.py

@@ -0,0 +1,96 @@
+from fastapi import FastAPI, HTTPException, UploadFile, File
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from utils.palmoil_classification import AfroPalmModel
+from utils.image_preclassification import pre_classification
+from utils.audio_generation import AudioGeneration
+import logging
+import uvicorn
+import base64
+import io
+import numpy as np
+from io import BytesIO
+from pydantic import BaseModel
+
+
+# Logging
+logging.basicConfig(level=logging.DEBUG,format='%(levelname)s: %(asctime)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S')
+
+
+description = """
+## Welcome to the Red Palm Oil Adulteration Detection Backend Api
+"""
+
+class ImageRequest(BaseModel):
+    image: str
+    imageURL:str
+    lang: int
+
+# Initialize FastAPI
+app = FastAPI(title="Afro Red Palm Oil Project", description=description)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=['*'],
+    allow_methods=['*'],
+    allow_headers=["*"],
+)
+
+"""
+    API Routes
+"""
+# Home route
+
+
+@app.get('/')
+async def home():
+    return {description}
+
+# red palm oil classification endpoint
+@app.post("/predict")
+async def predict(image_request: ImageRequest):
+    logging.info("Loading image")
+
+    # Decode base64 image string
+    decoded_image = base64.b64decode(image_request.image)
+
+    # Create a BytesIO object to read the image data
+    image_bytes = BytesIO(decoded_image)
+
+    try:
+        # Pre-classify image
+        is_palm_oil = pre_classification(image_request.imageURL)
+
+        logging.info("Pre-classification successful")
+        
+        if is_palm_oil:
+            model = AfroPalmModel()
+            prediction,confidence = model.predict(image_bytes)
+            logging.debug(f"Prediction: {prediction}, Confidence: {confidence*100:.2f}%")
+
+            # Generate audio
+            audio_generation = AudioGeneration(prediction=prediction, confidence=confidence*100, language=image_request.lang)
+            translated_text = audio_generation.ghanaian_language_translator()
+
+        else:
+            logging.info("Image is not a red palm oil")
+            return JSONResponse(status_code=418, content={"status": "error",
+                                                     'error':"Image is not a red palm oil"})
+            
+        # model = AfroPalmModel()
+        # prediction,confidence = model.predict(image_bytes)
+
+        return {
+            "status": "success",
+            "result": prediction,
+            "confidence": f"{confidence*100:.2f}"
+        }
+
+    except Exception as e:
+        logging.error(e)
+        raise HTTPException(status_code=500, detail={"status": "error",
+                                                     'error': str(e)})
+
+
+if __name__ == '__main__':
+    uvicorn.run(app, host="0.0.0.0", port="8000", debug=True)

models/ghostnet_model_float32.tflite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:90677f4651e27591be195d9ee9fc5d2f7e2699e6ee946374e4f46f7c127a8fe1
+size 15635308

models/interpreter_state.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:444bab4531acce84c03477702eaf8cd3fd52c3ca9f901f83ffca1fb2ad3f6423
+size 62234857

requirements.txt

@@ -0,0 +1,10 @@
+fastapi
+uvicorn
+gunicorn
+python-multipart
+numpy
+torch 
+torchvision
+opencv-python
+tensorflow
+roboflow

utils/image_preclassification.py

@@ -0,0 +1,69 @@
+from roboflow import Roboflow
+import logging
+import requests
+from urllib.parse import urlparse
+import os
+import uuid
+
+
+rf = Roboflow(api_key="13nZhBkEhxImZULD6bZW")
+project = rf.workspace("afropalm").project("afropalm-pre-classification")
+model = project.version(1).model
+
+
+
+def pre_classification(imageURL):
+
+    logging.info("Checking if image is red palm oil")
+
+    response = requests.get(imageURL)
+
+    if response.status_code == 200:
+    
+        # Parse the URL to get the file name and extension
+        parsed_url = urlparse(imageURL)
+        file_name = parsed_url.path.split("/")[-1]
+        file_extension = file_name.split(".")[-1]
+
+        id = uuid.uuid4()
+    
+        # Save the downloaded image to a file with a dynamic name and extension
+        filename = f"{id}.{file_extension}"
+    
+        # Save the downloaded image to a file
+        with open(filename, 'wb') as image_file:
+            image_file.write(response.content)
+    
+        # Use the file path of the downloaded image
+        image_path = os.path.dirname(os.path.abspath(filename))+'/'+filename
+        
+        results = model.predict(image_path, confidence=1, overlap=30).json()   
+    
+        class_name = None
+        confidence = 0
+
+        if results['predictions']:
+            # loop through results and find the highest confidence
+            for result in results["predictions"]:
+                if result["confidence"] > confidence:
+                    class_name = result["class"]
+                    confidence = result["confidence"]
+
+                    
+            if os.path.isfile(image_path):
+                # Remove the file after processing
+                os.remove(image_path) 
+                
+            if class_name == "palmoil":
+                return True
+                
+            else: 
+                return False
+
+
+        else:
+            return False
+        
+    else:
+        logging.error("Error loading the image for pre-classification")
+        raise Exception("Error loading the image")

utils/palmoil_classification.py

@@ -0,0 +1,57 @@
+from utils.preprocessing import preprocess_image
+import tensorflow as tf
+import os 
+import logging
+import json
+
+
+
+class AfroPalmModel:
+    """
+    Class to load the model and make predictions
+    """
+    def __init__(self):
+        logging.info("Loading classification model")
+
+        self.interpreter_path = os.path.dirname(os.path.abspath("interpreter_state.json")) + "/models/interpreter_state.json"
+
+        logging.debug(f"Preparing to read from {self.interpreter_path}")
+        
+        with open(self.interpreter_path, 'r') as json_file:
+            interpreter_state = json.load(json_file)
+
+        logging.info("File read successful")
+        
+        # Create and allocate the interpreter using the loaded state
+        self.interpreter = tf.lite.Interpreter(model_content=interpreter_state["tflite_model"].encode('latin1'))
+        self.interpreter.allocate_tensors()
+        
+        # Retrieve the input and output indices
+        self.input_index = interpreter_state["input_index"]
+        self.output_index = interpreter_state["output_index"]
+
+        logging.info("Model loaded successful")
+
+
+
+
+    def predict(self, image):
+        """
+        Make a prediction on the image
+        :param image: image to make prediction on
+        :return: prediction and confidence score
+        """
+
+        logging.info("Making prediction")
+
+        img = preprocess_image(image)
+
+        self.interpreter.set_tensor(self.input_index, img)
+        self.interpreter.invoke()
+
+        
+        predictions = list(self.interpreter.get_tensor(self.output_index)[0])
+
+        logging.info("Classification successful")
+
+        return predictions.index(max(predictions)), max(predictions)

utils/preprocessing.py

@@ -0,0 +1,43 @@
+import numpy as np
+from torchvision.transforms import functional as TF
+from torchvision.transforms import transforms
+from PIL import Image
+import cv2
+
+
+
+def to_hsv(image):
+    """Convert PIL image to HSV color space"""
+    image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2HSV)
+    return TF.to_pil_image(image)
+
+
+# Define the preprocessing function for a single image
+def preprocess_image(image):
+    # Load the image
+    img = Image.open(image)
+
+    # Ensure the image is in RGB format
+    if isinstance(img, Image.Image):
+        img = img.convert("RGB")
+    elif isinstance(img, (np.ndarray, np.generic)):
+        if img.shape[-1] == 1:  # Grayscale image
+            img = np.stack([img, img, img], axis=-1)
+        elif img.shape[-1] != 3:  # Not RGB or Grayscale
+            raise ValueError("Input image must be in RGB or Grayscale format")
+    else:
+        raise ValueError("Unsupported image type")
+
+    # Define the transformations
+    transform = transforms.Compose([
+        transforms.Resize((224, 224)),
+        transforms.ToTensor(),
+    ])
+
+    # Apply the transformations to the image
+    preprocessed_img = transform(img)
+
+    # Add batch dimension and reorder dimensions to [1, 224, 224, 3]
+    preprocessed_img = preprocessed_img.unsqueeze(0).permute(0, 2, 3, 1)
+
+    return preprocessed_img