File size: 3,806 Bytes
8a6c301 70e8f53 56d5114 70e8f53 56d5114 70e8f53 56d5114 70e8f53 56d5114 70e8f53 56d5114 70e8f53 56d5114 70e8f53 56d5114 |
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 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 |
---
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
```python
from PIL import Image
import os
import numpy as np
import tensorflow as tf
import requests
from skimage.color import lab2rgb
import matplotlib.pyplot as plt
from models.auto_encoder_gray2color import SpatialAttention
```
### Load Model file
```python
# 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}
)
```
### Define Functions
```python
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
def process_and_plot_images(input_path):
# Read input image
input_img = Image.open(input_path)
# Process the image (placeholder for your process_image function)
output_img = process_image(input_img)
# Save output image to output.jpg
output_img.save("output.jpg")
return input_img, output_img
def plot_in_out_images(input_img, output_img):
# Create a figure with two subplots for input and output images
plt.figure(figsize=(17, 8), dpi=300) # Set DPI to 300
# Plot input image
plt.subplot(1, 2, 1)
plt.imshow(input_img, cmap='gray')
plt.title("Input Image")
plt.axis('off') # Hide axes for cleaner display
# Plot output image
plt.subplot(1, 2, 2)
plt.imshow(output_img, cmap='gray')
plt.title("Output Image")
plt.axis('off') # Hide axes for cleaner display
# Save the figure as output.jpg with 300 DPI
plt.savefig("output.jpg", dpi=300, bbox_inches='tight')
# Show the plot
plt.show()
```
### Inference
```python
# Example usage
WIDTH, HEIGHT = 512, 512
# Replace 'input_image.jpg' with the path to your image
image_path = "<input_image.jpg>"
input_img, output_img = process_and_plot_images(image_path)
plot_in_out_images(input_img, output_img)
```
### Example Output
 |