first commit

Dockerfile

@@ -0,0 +1,21 @@
+# Use the official Python base image
+FROM python:3.9
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements.txt file and install the Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the Flask application code into the container
+COPY . .
+
+# Expose the port on which the Flask application will run
+EXPOSE 5000
+
+# Set the environment variable for Flask
+ENV FLASK_APP=app.py
+
+# Run the Flask application
+CMD ["flask", "run", "--host=0.0.0.0"]

README.md

@@ -4,6 +4,7 @@ emoji: 🐠
 colorFrom: indigo
 colorTo: blue
 sdk: docker
+app_port: 5000
 pinned: false
 ---
 

api_client.py

@@ -0,0 +1,70 @@
+import os
+import time
+import numpy as np
+import requests
+import matplotlib.pyplot as plt
+
+# Disable tensorflow warnings
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+
+from keras.datasets import mnist
+from typing import List
+
+
+# Set random seed for reproducibility
+np.random.seed(50)
+
+# Number of images taken from test dataset to make prediction
+N_IMAGES = 9
+
+def get_image_prediction(image: List):
+    """Get Model prediction for a given image
+    :param
+        image: List
+            Grayscale Image
+    :return: Json
+        HTTP Response format:
+            {
+                "prediction": predicted_label,
+                "ml-latency-ms": latency_in_milliseconds
+                    (Measures time only for ML operations preprocessing with predict)
+        }
+    """
+    # Making prediction request API
+    response = requests.post(url='http://127.0.0.1:5000/predict', json={'image': image})
+    # Parse the response JSON
+    return response.json()
+
+# Load the dataset from keras.datasets
+(x_train, y_train), (x_test, y_test) = mnist.load_data()
+
+# Select N-th (N_IMAGES) random indices from x_test
+indices = np.random.choice(len(x_test), N_IMAGES, replace=False)
+
+# Get the images and labels based on the selected indices
+images, labels, predictions = x_test[indices], y_test[indices], []
+
+# Iterate over each image, invoke prediction API and save results to predictions array
+for i in range(N_IMAGES):
+    # Send the POST request to the Flask server
+    start_time = time.time()
+    model_response = get_image_prediction(images[i].tolist())
+    print('Model Response:', model_response)
+    print('Total Measured Time (ms):', round((time.time() - start_time) * 1000, 3))
+    # Save prediction data into predictions array
+    predictions.append(model_response['prediction'])
+
+def plot_images_and_results_plot(images_, labels_, predictions_):
+    """Plotting the images with their labels and predictions
+    """
+    fig, axes = plt.subplots(N_IMAGES, 1, figsize=(6, 10))
+
+    for i in range(N_IMAGES):
+        axes[i].imshow(images_[i], cmap='gray')
+        axes[i].axis('off')
+        axes[i].set_title("Label/Prediction: {}/{}".format(labels_[i], predictions_[i]))
+
+    plt.tight_layout()
+    plt.show()
+
+plot_images_and_results_plot(images, labels, predictions)

api_server.py

@@ -0,0 +1,111 @@
+import os
+import time
+import numpy as np
+
+# Disable tensorflow warnings
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+
+from tensorflow import keras
+from flask import Flask, jsonify, request
+
+# Load the saved model into memory
+model = keras.models.load_model('artifacts/models/mnist_model.h5')
+
+# Initialize the Flask application
+app = Flask(__name__)
+
+
+# API route for prediction
+@app.route('/predict', methods=['POST'])
+def predict():
+    """
+    Predicts the class label of an input image.
+
+    Request format:
+    {
+        "image": [[pixel_values_gray]]
+    }
+
+    Response format:
+    {
+        "prediction": predicted_label,
+        "ml-latency-ms": latency_in_milliseconds
+            (Measures time only for ML operations preprocessing with predict)
+    }
+    """
+    start_time = time.time()
+
+    # Get the image data from the request
+    image_data = request.get_json()['image']
+
+    # Preprocess the image
+    processed_image = preprocess_image(image_data)
+
+    # Make a prediction, verbose=0 to disable progress bar in logs
+    prediction = model.predict(processed_image, verbose=0)
+
+    # Get the predicted class label
+    predicted_label = np.argmax(prediction)
+
+    # Calculate latency in milliseconds
+    latency_ms = (time.time() - start_time) * 1000
+
+    # Return the prediction result and latency as JSON response
+    response = {'prediction': int(predicted_label),
+                'ml-latency-ms': round(latency_ms, 4)}
+
+    # dictionary is not a JSON: https://www.quora.com/What-is-the-difference-between-JSON-and-a-dictionary
+    # flask.jsonify vs json.dumps https://sentry.io/answers/difference-between-json-dumps-and-flask-jsonify/
+    # The flask.jsonify() function returns a Response object with Serializable JSON and content_type=application/json.
+    return jsonify(response)
+
+
+# Helper function to preprocess the image
+def preprocess_image(image_data):
+    """Preprocess image for Model Inference
+
+    :param image_data: Raw image
+    :return: image: Preprocessed Image
+    """
+    # Resize the image to match the input shape of the model
+    image = np.array(image_data).reshape(1, 28, 28)
+
+    # Normalize the pixel values
+    image = image.astype('float32') / 255.0
+
+    return image
+
+
+# API route for health check
+@app.route('/health', methods=['GET'])
+def health():
+    """
+    Health check API to ensure the application is running.
+    Returns "OK" if the application is healthy.
+    Demo Usage: "curl http://localhost:5000/health" or using alias "curl http://127.0.0.1:5000/health"
+    """
+    return 'OK'
+
+
+# API route for version
+@app.route('/version', methods=['GET'])
+def version():
+    """
+    Returns the version of the application.
+    Demo Usage: "curl http://127.0.0.1:5000/version" or using alias "curl http://127.0.0.1:5000/version"
+    """
+    return '1.0'
+
+
+# Start the Flask application
+if __name__ == '__main__':
+    app.run()
+
+
+##################
+# Flask API usages:
+# 1. Just a wrapper over OpenAI API
+# 2. You can use Chain calls of OpenAI API
+# 3. Using your own ML model in combination with openAPI functionality
+# 4. ...
+##################

artifacts/models/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

model.py

@@ -0,0 +1,46 @@
+import os
+import random
+import numpy as np
+
+# disable tensorflow warnings
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+
+import tensorflow as tf
+from tensorflow import keras
+from keras.datasets import mnist
+
+# Set the random seed for reproducibility, remember these lines :)
+SEED = 42
+random.seed(SEED)
+np.random.seed(SEED)
+tf.random.set_seed(SEED)
+
+# Load the dataset from keras.datasets (so noone would need to download it manually from any sources)
+(x_train, y_train), (x_test, y_test) = mnist.load_data()
+
+# Preprocess the dataset
+x_train = x_train.astype('float32') / 255.0
+x_test = x_test.astype('float32') / 255.0
+
+# Define the model architecture
+model = keras.Sequential([
+    keras.layers.Flatten(input_shape=(28, 28)),
+    keras.layers.Dense(128, activation='relu'),
+    keras.layers.Dense(10, activation='softmax')
+])
+
+# Compile and train the model
+# target in one-hot categorical_crossentropy -> [0,0,1,0,0,0,0,0,0]
+# target can be as integer sparse_categorical_crossentropy -> 3
+model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
+
+# 4-epoch is overfitting, 3-rd is okay
+model.fit(x_train, y_train, validation_data=(x_test, y_test), epochs=4, shuffle=True, batch_size=32)
+
+# Evaluate the model
+print('\n')
+_, test_accuracy = model.evaluate(x_test, y_test)
+print('Test accuracy:', test_accuracy)
+
+# Save the model
+model.save('artifacts/models/mnist_model.h5')