File size: 3,084 Bytes
8a6c301 70e8f53 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 |
---
library_name: keras
license: mit
language:
- en
pipeline_tag: image-to-image
---
## Metrics
PSNR
- 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)
``` |