Added Dockerfile and necessary scripts

Dockerfile

@@ -0,0 +1,53 @@
+# syntax=docker/dockerfile:1
+
+# Comments are provided throughout this file to help you get started.
+# If you need more help, visit the Dockerfile reference guide at
+# https://docs.docker.com/go/dockerfile-reference/
+
+# Want to help us make this template better? Share your feedback here: https://forms.gle/ybq9Krt8jtBL3iCk7
+
+ARG PYTHON_VERSION=3.10.5
+FROM python:${PYTHON_VERSION} as base
+
+# Prevents Python from writing pyc files.
+ENV PYTHONDONTWRITEBYTECODE=1
+
+# Keeps Python from buffering stdout and stderr to avoid situations where
+# the application crashes without emitting any logs due to buffering.
+ENV PYTHONUNBUFFERED=1
+
+WORKDIR /app
+
+RUN python -m pip install --upgrade pip
+
+# Create a non-privileged user that the app will run under.
+# See https://docs.docker.com/go/dockerfile-user-best-practices/
+ARG UID=10001
+RUN adduser \
+    --disabled-password \
+    --gecos "" \
+    --home "/nonexistent" \
+    --shell "/sbin/nologin" \
+    --no-create-home \
+    --uid "${UID}" \
+    appuser
+
+# Download dependencies as a separate step to take advantage of Docker's caching.
+# Leverage a cache mount to /root/.cache/pip to speed up subsequent builds.
+# Leverage a bind mount to requirements.txt to avoid having to copy them into
+# into this layer.
+RUN --mount=type=cache,target=/root/.cache/pip \
+    --mount=type=bind,source=requirements.txt,target=requirements.txt \
+    python -m pip install -r requirements.txt
+
+# Switch to the non-privileged user to run the application.
+USER appuser
+
+# Copy the source code into the container.
+COPY . .
+
+# Expose the port that the application listens on.
+EXPOSE 7860
+
+# Run the application.
+CMD uvicorn 'main:app' --host=0.0.0.0 --port=7860

compose.yaml

@@ -0,0 +1,49 @@
+# Comments are provided throughout this file to help you get started.
+# If you need more help, visit the Docker Compose reference guide at
+# https://docs.docker.com/go/compose-spec-reference/
+
+# Here the instructions define your application as a service called "server".
+# This service is built from the Dockerfile in the current directory.
+# You can add other services your application may depend on here, such as a
+# database or a cache. For examples, see the Awesome Compose repository:
+# https://github.com/docker/awesome-compose
+services:
+  server:
+    build:
+      context: .
+    ports:
+      - 8000:8000
+
+# The commented out section below is an example of how to define a PostgreSQL
+# database that your application can use. `depends_on` tells Docker Compose to
+# start the database before your application. The `db-data` volume persists the
+# database data between container restarts. The `db-password` secret is used
+# to set the database password. You must create `db/password.txt` and add
+# a password of your choosing to it before running `docker compose up`.
+#     depends_on:
+#       db:
+#         condition: service_healthy
+#   db:
+#     image: postgres
+#     restart: always
+#     user: postgres
+#     secrets:
+#       - db-password
+#     volumes:
+#       - db-data:/var/lib/postgresql/data
+#     environment:
+#       - POSTGRES_DB=example
+#       - POSTGRES_PASSWORD_FILE=/run/secrets/db-password
+#     expose:
+#       - 5432
+#     healthcheck:
+#       test: [ "CMD", "pg_isready" ]
+#       interval: 10s
+#       timeout: 5s
+#       retries: 5
+# volumes:
+#   db-data:
+# secrets:
+#   db-password:
+#     file: db/password.txt
+

main.py

@@ -0,0 +1,77 @@
+from fastapi import FastAPI, UploadFile
+import io
+import tensorflow as tf
+import numpy as np
+from PIL import Image
+import os
+import requests
+
+# Google Drive file ID of the model
+DRIVE_FILE_ID = "1HBzc72rm8NpJZoMQwLA4SJOBR_FzMjRe"  # Replace with your file ID
+MODEL_PATH = "./efficientnet_poultry_disease_model.keras"
+
+# Function to download the model from Google Drive
+def download_model():
+    if not os.path.exists(MODEL_PATH):  # Check if the model already exists
+        print("Downloading model from Google Drive...")
+        # Construct the download URL
+        url = f"https://drive.google.com/uc?export=download&id={DRIVE_FILE_ID}"
+        with requests.Session() as session:
+            response = session.get(url, stream=True)
+            # Handle confirmation for large files
+            for key, value in response.cookies.items():
+                if key.startswith("download_warning"):
+                    url = f"https://drive.google.com/uc?export=download&id={DRIVE_FILE_ID}&confirm={value}"
+                    response = session.get(url, stream=True)
+                    break
+            # Write the content to a file
+            with open(MODEL_PATH, "wb") as f:
+                for chunk in response.iter_content(chunk_size=32768):
+                    f.write(chunk)
+
+# Download the model if not already downloaded
+download_model()
+
+# Load the pre-trained model
+model = tf.keras.models.load_model(MODEL_PATH)
+
+# List of classes the model predicts
+CLASSES = ['coccidiosis', 'healthy', 'newcastle disease', 'salmo']
+IMAGE_SIZE = (360, 360)
+
+# Function to preprocess and predict a single image
+def predict_image(image_stream: io.BytesIO):
+    # Load the image from the BytesIO stream
+    img = Image.open(image_stream)
+    img = img.resize(IMAGE_SIZE)  # Resize the image
+    img_array = np.array(img, dtype=np.float32)  # Convert to float32 for proper scaling
+    img_array = np.expand_dims(img_array, axis=0)  # Expand dims to make it (1, IMAGE_SIZE, IMAGE_SIZE, 3)
+
+    # Normalize the image by dividing by 255.0
+    img_array /= 255.0
+
+    # Make prediction
+    predictions = model.predict(img_array)
+    predicted_class = np.argmax(predictions, axis=1)[0]
+    confidence = predictions[0][predicted_class]
+
+    # Return prediction results as a dictionary
+    return {
+        "class": CLASSES[predicted_class],
+        "confidence": confidence.item()  # Convert numpy.float32 to native float
+    }
+
+app = FastAPI()
+
+@app.get("/")
+def read_root():
+    return {"Hello": "World"}
+
+@app.post("/predict")
+async def predict(image: UploadFile):
+    content = await image.read()  # Read the uploaded image content
+
+    # Pass the byte content as a BytesIO object to predict_image
+    result = predict_image(io.BytesIO(content))  # Pass the byte stream instead of the PIL image
+
+    return result  # FastAPI will automatically convert the dictionary to JSON

requirements.txt

@@ -0,0 +1,7 @@
+fastapi==0.115.5
+matplotlib==3.9.2
+numpy>=1.26.0,<2.1.0
+Pillow==11.0.0
+tensorflow==2.18.0
+uvicorn
+python-multipart