update bokeh space

app.py

@@ -0,0 +1,58 @@
+"""Streamlit web app for depth of field detection"""
+
+import time
+from PIL import Image
+import streamlit as st
+from bokeh import app_dof_predict
+
+from tempfile import NamedTemporaryFile
+
+temp_file = NamedTemporaryFile(delete=False)
+
+# Page layout
+st.set_page_config(page_title="Depth of Field Detection", page_icon=":camera:", layout="wide")
+
+# Sidebar options
+st.sidebar.title("Prediction Settings")
+st.sidebar.text("")
+
+models = ["DenseNet (baseline)", "VGG16 (baseline)", "DenseNet (best)", "VGG16 (best)"]
+
+model_choice = []
+st.sidebar.write("Choose a model for prediction")
+model_choice.append(st.sidebar.radio("", models))
+
+with st.container():
+    st.title("Depth of Field detection w/ Deep Learning")
+    st.image(
+        "https://source.unsplash.com/FABH5NJEMGM/960x640",
+        use_column_width="auto",
+    )
+
+    file = st.file_uploader("Upload an image", type=["jpg", "jpeg"])
+
+    if file is not None:
+        img = Image.open(file)
+        temp_file.write(file.getvalue())
+        st.image(img, caption="Uploaded image", use_column_width="auto")
+
+        if st.button("Predict"):
+            st.write("")
+            st.write("Working...")
+
+            start_time = time.time()
+
+            for choice in model_choice:
+                prediction = app_dof_predict(choice, temp_file.name)
+                print(prediction)
+                execute_bar = st.progress(0)
+                for percent_complete in range(100):
+                    time.sleep(0.001)
+                    execute_bar.progress(percent_complete + 1)
+            prob = prediction["probability"]
+            if prediction["class"] == 0:
+                st.header("Prediction: Bokeh - Confidence {:.1f}%".format(prob * 100))
+            elif prediction["class"] == 1:
+                st.header("Prediction: No bokeh detected - Confidence {:.1f}%".format(prob * 100))
+
+            st.write("Took {} seconds to run.".format(round(time.time() - start_time, 2)))

bokeh.py

@@ -0,0 +1,184 @@
+import argparse
+import json
+import gdown
+import os
+import matplotlib.pyplot as plt
+import numpy as np
+import streamlit as st
+
+from pathlib import Path
+
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
+os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
+
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+
+
+@st.cache(show_spinner=False)
+def download_weights(model_choice):
+    """
+    Downloads model weights for deployment
+    """
+
+    # Create directory
+    save_dest = Path("models")
+    save_dest.mkdir(exist_ok=True)
+
+    # Download weights for the chosen model
+    if model_choice == "DenseNet (baseline)":
+        url = "https://drive.google.com/uc?id=10-TWkCW_BAZLpGXkxPqXFV8lg-jnWNJD"
+        output = "models/densenet.h5"
+
+        if not Path(output).exists():
+            with st.spinner("Model weights were not found, downloading them. This may take a while."):
+                gdown.download(url, output, quiet=False)
+
+    elif model_choice == "VGG16 (baseline)":
+        url = "https://drive.google.com/uc?id=1UaNIHQ-HYeN5v6egV9kAdwU0Nb4CfLBF"
+        output = "models/vgg16.h5"
+
+        if not Path(output).exists():
+            with st.spinner("Model weights were not found, downloading them. This may take a while."):
+                gdown.download(url, output, quiet=False)
+
+    elif model_choice == "DenseNet (best)":
+        url = "https://drive.google.com/uc?id=1JUvuzyGQpScHyq2q25yhG962g3PMJ1eu"
+        output = "models/densenet_best.h5"
+
+        if not Path(output).exists():
+            with st.spinner("Model weights were not found, downloading them. This may take a while."):
+                gdown.download(url, output, quiet=False)
+
+    elif model_choice == "VGG16 (best)":
+        url = "https://drive.google.com/uc?id=19iu-Qhaofczgl6iMt6DSB_OHDBs9ggsr"
+        output = "models/vgg16_best.h5"
+
+        if not Path(output).exists():
+            with st.spinner("Model weights were not found, downloading them. This may take a while."):
+                gdown.download(url, output, quiet=False)
+    else:
+        raise ValueError("Unknown model: {}".format(model_choice))
+
+
+def preprocess_image(image_file):
+    """Preprocess image"""
+
+    x, _ = process_path(image_file)
+    x = np.expand_dims(x, axis=0)
+
+    return x
+
+
+def app_dof_predict(model_choice, image_file):
+
+    # Download weights for the chosen model
+    download_weights(model_choice)
+    image = preprocess_image(image_file)
+    prediction = {}
+
+    if model_choice == "DenseNet (baseline)":
+        model = load_model("models/densenet.h5", compile=False)
+    elif model_choice == "VGG16 (baseline)":
+        model = load_model("models/vgg16.h5", compile=False)
+    elif model_choice == "DenseNet (best)":
+        model = load_model("models/densenet_best.h5", compile=False)
+    elif model_choice == "VGG16 (best)":
+        model = load_model("models/vgg16_best.h5", compile=False)
+    preds = model.predict(image)
+
+    prediction = {
+        "class": int(np.argmax(preds)),
+        "probability": float(preds[0][np.argmax(preds)]),
+    }
+
+    return prediction
+
+
+def decode_img(img):
+    """Decode image and resize"""
+    img = tf.image.decode_jpeg(img, channels=3)
+    img = tf.image.resize(img, [200, 300])
+
+    return img
+
+
+def process_path(file_path):
+    """Process input path"""
+    img = tf.io.read_file(file_path)
+    img = decode_img(img)
+
+    return img, file_path
+
+
+def plot_results(infer_images, inference_predicted_class, inference_predictions, class_names=["bokeh", "no bokeh"]):
+    """Plot four images with predicted class and probabilities"""
+    plt.figure(figsize=(40, 60))
+
+    for i, (infer_img, _) in enumerate(infer_images.take(10)):
+        ax = plt.subplot(2, 5, i + 1)
+        plt.imshow(infer_img.numpy() / 255)
+
+        # Find the predicted class from predictions
+
+        m = "Predicted: {}, {:.2f}%".format(class_names[inference_predicted_class[i]], inference_predictions[i] * 100)
+        plt.title(m)
+        plt.axis("off")
+    plt.show()
+
+
+def dof_predict(infer_images, model_path):
+
+    trained_model = load_model(model_path, compile=False)
+
+    inference_predicted_class = []
+    inference_predictions = []
+    results = {}
+    for infer_img, img_name in infer_images:
+        print(img_name)
+        preds = trained_model.predict(tf.expand_dims(infer_img, axis=0))
+        inference_predicted_class.append(np.argmax(preds))
+        print(preds)
+        inference_predictions.append(preds[0][np.argmax(preds)])
+
+        results[str(img_name.numpy().decode("utf8").split("/")[-1])] = {
+            "class": int(np.argmax(preds)),
+            "prob": float(preds[0][np.argmax(preds)]),
+        }
+
+    plot_results(infer_images, inference_predicted_class, inference_predictions)
+
+    return results
+
+
+def save_results(results):
+    """Save results to json"""
+    json.dump(results, open("results.json", "w"))
+
+
+def main(test_dir, model_path):
+
+    # get the count of image files in the train directory
+    inference_ds = tf.data.Dataset.list_files(test_dir + "/*", shuffle=False)
+
+    infer_images = inference_ds.map(process_path)
+
+    # inference
+    results = dof_predict(infer_images, model_path)
+
+    # save results
+    save_results(results)
+
+
+if __name__ == "__main__":
+
+    # Initiate the parser
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("-data", action="store", help="Dataset path")
+    parser.add_argument("-model", action="store", help="Model path")
+    arguments = parser.parse_args()
+
+    dataset = arguments.data
+    model = arguments.model
+    main(dataset, model)

requirements.txt

@@ -0,0 +1,4 @@
+tensorflow=2.3.1
+numpy=1.18.5
+gdown=4.2.0
+pillow=*