Initial Commit

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+finetune_v1_weights.keras filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,14 @@
+# Get the image of python
+FROM python:3.9
+
+# Copy all the files from local-dir to machine dir
+COPY . .
+
+# Set the current directory as working dir
+WORKDIR /
+
+# Install the requirements
+RUN pip install --no-cache-dir -r ./requirements.txt
+
+# Launch the server
+CMD ["uvicorn", "backend:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,36 @@
+import streamlit as st
+import requests
+import json
+from io import BytesIO
+
+st.title('COVID-19 Prediction')
+st.subheader('Provide an X-ray of lungs and check if you have covid-19, or any other desease or your normal.')
+
+# Take image input
+img_file_buffer = st.file_uploader("Upload your chest X-ray")
+
+if img_file_buffer is not None:
+    # Retrive the file value
+    img_bytes = img_file_buffer.getvalue()
+
+    # Create a payload
+    files = {"x_ray_image": BytesIO(img_bytes)}
+
+    URL = "http://127.0.0.1:8000/get_prediction"
+
+    with st.spinner("Waiting for model response..."):
+        st.write("Came in spinner")
+        resp = requests.post(
+            URL, 
+            files = files,
+            )
+        
+        st.write("Executed response")
+
+        if resp._content is not None:
+            resp_data = json.loads(resp._content.decode('utf-8'))
+            st.write(resp_data)
+        else:
+            st.write(resp.__dict__)
+
+

backend.py

@@ -0,0 +1,43 @@
+import os
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+
+import tensorflow as tf
+from fastapi import FastAPI, UploadFile, File
+from utils import load_image, preprocess_image, predict
+from model import get_model
+import json
+
+app = FastAPI()
+
+MODEL_WEIGHT_PATH = './finetune_v1_weights.keras'
+model = get_model(MODEL_WEIGHT_PATH)
+
+@app.get("/")
+def tester():
+    return {
+        "status": "Hello World"
+    }
+
+@app.post("/get_prediction")
+async def get_prediction(x_ray_image: UploadFile = File(...)):
+
+    # Load the image i.e. convert from bytes -> Image (unit8)
+    image = load_image(await x_ray_image.read())
+
+    # Preprocess image to make it compatible for model
+    image = preprocess_image(image)
+
+    # Retrive model prediction
+    prediction = predict(image, model)
+
+    print("Model Predicted: \n", prediction)
+
+    return {
+        'prediction': json.dumps(prediction)
+    }
+
+@app.post("/test")
+def test():
+    return {
+        "status": 10
+    }

finetune_v1_weights.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6dd820011318ac7e47051f31034a5da91aca452f28deb4aba1916cc7a5704997
+size 135810768

model.py

@@ -0,0 +1,43 @@
+import keras
+from keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense
+
+
+def create_finetune_model(input_shape, regs, n_classes, drop_rate = 0.1):
+    model = keras.models.Sequential()
+
+    model.add(Conv2D(32, kernel_size=(3,3), input_shape=(*input_shape, 1), kernel_regularizer=regs, padding='same', activation='relu'))
+    model.add(MaxPooling2D(pool_size=(2, 2)))
+    model.add(Dropout(drop_rate))
+
+    model.add(Conv2D(64, kernel_size=(3,3), padding='same', activation='relu', kernel_regularizer=regs))
+    model.add(MaxPooling2D(pool_size=(2, 2)))
+    model.add(Dropout(drop_rate))
+
+    model.add(Conv2D(128, kernel_size=(3,3), padding='same', activation='relu',  kernel_regularizer=regs))
+    model.add(MaxPooling2D(pool_size=(2, 2)))
+    model.add(Dropout(drop_rate))
+
+    model.add(Conv2D(256, kernel_size=(3,3), padding='same', activation='relu',  kernel_regularizer=regs))
+    model.add(MaxPooling2D(pool_size=(2, 2)))
+    model.add(Dropout(drop_rate))
+
+    model.add(Flatten())
+
+    model.add(Dense(512, activation='relu',  kernel_regularizer=regs))
+    model.add(Dropout(drop_rate))
+
+    model.add(Dense(n_classes, activation='softmax',  kernel_regularizer=regs))
+
+    return model
+
+def get_model(weight_file):
+    regularizer = keras.regularizers.L1(0.0001)
+    model = create_finetune_model((256, 256), regularizer, 3)
+    model.compile(
+        loss = 'categorical_crossentropy',
+        optimizer='adam'
+    )
+
+    model.load_weights(weight_file)
+
+    return model

requirement.txt

@@ -0,0 +1,6 @@
+streamlit
+fastapi
+uvicorn[standard]
+tensorflow==2.15.0
+pillow
+numpy

utils.py

@@ -0,0 +1,43 @@
+import numpy as np
+import tensorflow as tf
+from PIL import Image
+from io import BytesIO
+import numpy as np
+
+MODEL_IMAGE_WIDTH = 256
+MODEL_IMAGE_HEIGHT = 256
+
+def load_image(img_data):
+    image = Image.open(BytesIO(img_data))
+
+    return image
+
+def preprocess_image(image):
+    # Resize the image to be of the model size
+    image = image.resize((MODEL_IMAGE_WIDTH, MODEL_IMAGE_HEIGHT))
+
+    # Convert it to grayscale if not
+    image = image.convert('L')
+
+    return image
+
+def predict(image, model):
+    # Convert the image to numpy array
+    image = np.array(image)
+
+    # Add an extra dimension at the end
+    image = np.expand_dims(image, axis=-1)
+
+    # Also add one dimension at the front ot make it as single batch
+    batch_img = np.expand_dims(image, axis=0)
+
+    print("Batch Image shape: ", batch_img.shape)
+
+    # Make the prediction from the model
+    pred_probs = model.predict(batch_img)[0]
+    label = np.argmax(pred_probs, axis=-1)
+
+    return {
+        'pred_probs': pred_probs.tolist(),
+        'label': int(label)
+    }