Update README.md

README.md

@@ -9,4 +9,95 @@ pipeline_tag: image-to-image
 
 ## Metrics
 PSNR
-- Validation set: 21.70
+- Validation set: 21.70
+
+## Usage
+
+### Download Model
+```bash
+git clone https://huggingface.co/danhtran2mind/autoencoder-grayscale2color-landscape
+```
+```bash
+cd autoencoder-grayscale2color-landscape
+git lfs pull
+```
+### Import Libraries
+```bash
+from PIL import Image
+import os
+import numpy as np
+import tensorflow as tf
+import requests
+from skimage.color import lab2rgb
+
+from models.auto_encoder_gray2color import SpatialAttention
+
+```
+### Load Model file
+```bash
+# Load the saved model once at startup
+load_model_path = "./ckpts/best_model.h5"
+
+print(f"Loading model from {load_model_path}...")
+loaded_autoencoder = tf.keras.models.load_model(
+    load_model_path,
+    custom_objects={'SpatialAttention': SpatialAttention}
+)
+```
+
+### Inferenc Step
+```python
+# Assuming process_image function is defined as provided
+# and required imports (tensorflow, skimage.color for lab2rgb) are available
+
+def display_images_pil(input_path):
+    # Read input image
+    input_img = Image.open(input_path)
+    
+    # Process the image using the provided function
+    output_img = process_image(input_img)
+    
+    # Display input image
+    input_img.show(title="Input Image")
+    
+    # Display output image
+    output_img.show(title="Output Image")
+
+def process_image(input_img):
+    # Store original input dimensions
+    original_width, original_height = input_img.size
+
+    # Convert PIL Image to grayscale and resize to model input size
+    img = input_img.convert("L")  # Convert to grayscale (single channel)
+    img = img.resize((WIDTH, HEIGHT))  # Resize to 512x512 for model
+    img_array = tf.keras.preprocessing.image.img_to_array(img) / 255.0  # Normalize to [0, 1]
+    img_array = img_array[None, ..., 0:1]  # Add batch dimension, shape: (1, 512, 512, 1)
+
+    # Run inference (assuming loaded_autoencoder predicts a*b* channels)
+    output_array = loaded_autoencoder.predict(img_array)  # Shape: (1, 512, 512, 2) for a*b*
+    print("output_array shape: ", output_array.shape)
+
+    # Extract L* (grayscale input) and a*b* (model output)
+    L_channel = img_array[0, :, :, 0] * 100.0  # Denormalize L* to [0, 100]
+    ab_channels = output_array[0] * 128.0  # Denormalize a*b* to [-128, 128]
+
+    # Combine L*, a*, b* into a 3-channel L*a*b* image
+    lab_image = np.stack([L_channel, ab_channels[:, :, 0], ab_channels[:, :, 1]], axis=-1)  # Shape: (512, 512, 3)
+
+    # Convert L*a*b* to RGB
+    rgb_array = lab2rgb(lab_image)  # Convert to RGB, output in [0, 1]
+    rgb_array = np.clip(rgb_array, 0, 1) * 255.0  # Scale to [0, 255]
+    rgb_image = Image.fromarray(rgb_array.astype(np.uint8), mode="RGB")  # Create RGB PIL image
+
+    # Resize output image to match input image resolution
+    rgb_image = rgb_image.resize((original_width, original_height), Image.Resampling.LANCZOS)
+
+    return rgb_image
+
+
+# Example usage
+if __name__ == "__main__":
+    # Replace 'input_image.jpg' with the path to your image
+    image_path = "<input_image.jpg>"
+    display_images_pil(image_path)
+```