Duplicate from keras-io/Monocular-Depth-Estimation

Co-authored-by: vumichien <[email protected]>

.gitattributes

@@ -0,0 +1,27 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bin.* filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zstandard filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,13 @@
+---
+title: Monocular Depth Estimation
+emoji: 🐢
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 3.0.13
+app_file: app.py
+pinned: false
+duplicated_from: keras-io/Monocular-Depth-Estimation
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference

app.py

@@ -0,0 +1,34 @@
+from layers import BilinearUpSampling2D
+from tensorflow.keras.models import load_model
+from utils import load_images, predict
+import matplotlib.pyplot as plt
+import numpy as np
+import gradio as gr
+from huggingface_hub import from_pretrained_keras
+
+custom_objects = {'BilinearUpSampling2D': BilinearUpSampling2D, 'depth_loss_function': None}
+print('Loading model...')
+model = from_pretrained_keras("keras-io/monocular-depth-estimation", custom_objects=custom_objects, compile=False)
+print('Successfully loaded model...')
+examples = ['examples/00015_colors.png', 'examples/00084_colors.png', 'examples/00033_colors.png']
+
+
+def infer(image):
+    inputs = load_images([image])
+    outputs = predict(model, inputs)
+    plasma = plt.get_cmap('plasma')
+    rescaled = outputs[0][:, :, 0]
+    rescaled = rescaled - np.min(rescaled)
+    rescaled = rescaled / np.max(rescaled)
+    image_out = plasma(rescaled)[:, :, :3]
+    return image_out
+
+
+iface = gr.Interface(
+    fn=infer,
+    title="Monocular Depth Estimation",
+    description = "Keras Implementation of Unet architecture with Densenet201 backbone for estimating the depth of image 📏",
+    inputs=[gr.inputs.Image(label="image", type="numpy", shape=(640, 480))],
+    outputs="image",
+    article = "Author: <a href=\"https://huggingface.co/vumichien\">Vu Minh Chien</a>. The ideal based on the keras example from <a href=\"https://keras.io/examples/vision/depth_estimation/\">Victor Basu</a>",
+    examples=examples, cache_examples=True).launch(debug=True)

layers.py

@@ -0,0 +1,55 @@
+from tensorflow.keras.layers import Layer, InputSpec
+import keras.utils.conv_utils as conv_utils
+import tensorflow as tf
+import tensorflow.keras.backend as K
+
+
+def normalize_data_format(value):
+    if value is None:
+        value = K.image_data_format()
+    data_format = value.lower()
+    if data_format not in {'channels_first', 'channels_last'}:
+        raise ValueError('The `data_format` argument must be one of '
+                         '"channels_first", "channels_last". Received: ' +
+                         str(value))
+    return data_format
+
+
+class BilinearUpSampling2D(Layer):
+    def __init__(self, size=(2, 2), data_format=None, **kwargs):
+        super(BilinearUpSampling2D, self).__init__(**kwargs)
+        self.data_format = normalize_data_format(data_format)
+        self.size = conv_utils.normalize_tuple(size, 2, 'size')
+        self.input_spec = InputSpec(ndim=4)
+
+    def compute_output_shape(self, input_shape):
+        if self.data_format == 'channels_first':
+            height = self.size[0] * input_shape[2] if input_shape[2] is not None else None
+            width = self.size[1] * input_shape[3] if input_shape[3] is not None else None
+            return (input_shape[0],
+                    input_shape[1],
+                    height,
+                    width)
+        elif self.data_format == 'channels_last':
+            height = self.size[0] * input_shape[1] if input_shape[1] is not None else None
+            width = self.size[1] * input_shape[2] if input_shape[2] is not None else None
+            return (input_shape[0],
+                    height,
+                    width,
+                    input_shape[3])
+
+    def call(self, inputs):
+        input_shape = K.shape(inputs)
+        if self.data_format == 'channels_first':
+            height = self.size[0] * input_shape[2] if input_shape[2] is not None else None
+            width = self.size[1] * input_shape[3] if input_shape[3] is not None else None
+        elif self.data_format == 'channels_last':
+            height = self.size[0] * input_shape[1] if input_shape[1] is not None else None
+            width = self.size[1] * input_shape[2] if input_shape[2] is not None else None
+
+        return tf.image.resize(inputs, [height, width], method=tf.image.ResizeMethod.BILINEAR)
+
+    def get_config(self):
+        config = {'size': self.size, 'data_format': self.data_format}
+        base_config = super(BilinearUpSampling2D, self).get_config()
+        return dict(list(base_config.items()) + list(config.items()))

model/model.h5

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

requirements.txt

@@ -0,0 +1,2 @@
+tensorflow
+keras

utils.py

@@ -0,0 +1,23 @@
+import numpy as np
+
+
+def depth_norm(x, maxDepth):
+    return maxDepth / x
+
+
+def predict(model, images, minDepth=10, maxDepth=1000, batch_size=2):
+    # Support multiple RGBs, one RGB image, even grayscale
+    if len(images.shape) < 3: images = np.stack((images, images, images), axis=2)
+    if len(images.shape) < 4: images = images.reshape((1, images.shape[0], images.shape[1], images.shape[2]))
+    # Compute predictions
+    predictions = model.predict(images, batch_size=batch_size)
+    # Put in expected range
+    return np.clip(depth_norm(predictions, maxDepth=maxDepth), minDepth, maxDepth) / maxDepth
+
+
+def load_images(image_files):
+    loaded_images = []
+    for file in image_files:
+        x = np.clip(file.reshape(480, 640, 3) / 255, 0, 1)
+        loaded_images.append(x)
+    return np.stack(loaded_images, axis=0)