Fcommit

Load.py

@@ -0,0 +1,99 @@
+import os
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, Dataset
+from torchvision import transforms
+from PIL import Image
+
+# model architecture
+class ImageEnhancementModel(nn.Module):
+    def __init__(self):
+        super(ImageEnhancementModel, self).__init__()
+
+        # Define the layers here
+        self.conv1 = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, padding=1)
+        self.relu1 = nn.ReLU()
+        self.conv2 = nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, padding=1)
+        self.relu2 = nn.ReLU()
+        self.conv3 = nn.Conv2d(in_channels=64, out_channels=3, kernel_size=3, padding=1)
+
+    def forward(self, x):
+        # forward pass
+        x = self.relu1(self.conv1(x))
+        x = self.relu2(self.conv2(x))
+        x = self.conv3(x)
+        return x
+        
+class CustomDataset(Dataset):
+    def __init__(self, data_dir):
+        self.data_dir = data_dir
+        self.image_files = os.listdir(data_dir)
+        self.transform = transforms.Compose([transforms.ToTensor()])
+
+    def __len__(self):
+        return len(self.image_files)
+
+    def __getitem__(self, idx):
+        img_name = os.path.join(self.data_dir, self.image_files[idx])
+        image = Image.open(img_name)
+        
+        
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        image = self.transform(image)
+        return image
+
+
+# Hyperparameters
+batch_size = 8
+learning_rate = 0.001
+num_epochs = 50
+
+model = ImageEnhancementModel()
+
+# loss function and optimizer
+criterion = nn.MSELoss()
+optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
+
+# DataLoader
+train_dataset = CustomDataset(data_dir='before')
+train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
+
+# Training loop
+for epoch in range(num_epochs):
+    for data in train_loader:
+        # Forward pass
+        outputs = model(data)
+        
+        # Load the corresponding "after enhancement" images
+        target_data = CustomDataset(data_dir='after')  # Load the "after" images
+        target_data = next(iter(target_data))  # Get the corresponding target image
+
+        loss = criterion(outputs, target_data)  # Use the "after" images as targets
+
+        # Backpropagation and optimization
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+
+    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')
+
+# Save the trained model
+torch.save(model.state_dict(), 'image_enhancement_model.pth')
+
+# Inference (enhance images)
+model.eval()  # Set the model to evaluation mode
+
+# Load and preprocess an input image
+input_image = Image.open('testb.jpg')
+input_image = train_dataset.transform(input_image).unsqueeze(0)
+
+# Use the trained model to enhance the input image
+enhanced_image = model(input_image)
+
+# Save 
+output_image = enhanced_image.squeeze().permute(1, 2, 0).detach().cpu().numpy()
+output_image = (output_image + 1) / 2.0 * 255.0  # Denormalize
+output_image = output_image.astype('uint8')
+Image.fromarray(output_image).save('enhanced_image.jpg')

README.md

@@ -0,0 +1,50 @@
+# Neural Style Transfer (NST) for Image Enhancement
+
+Enhance your images using Neural Style Transfer by combining the content of an input image with the style of a reference image.
+
+## Description
+
+This project uses TensorFlow to perform Neural Style Transfer (NST) on an input image using a style reference image. NST is a technique for enhancing an image by transferring the artistic style of one image (the reference style image) to the content of another image (the input image). The result is a new image that combines the content of the input image with the artistic style of the reference image.
+
+## Prerequisites
+
+- Python 3.x
+- TensorFlow 2.x
+- NumPy
+- Matplotlib
+- Pillow
+
+You can install the required Python packages by running:
+
+
+## Usage
+
+1. Prepare your input image and style reference image and save them in the project directory.
+
+2. Update the paths to your input and style reference images in the script (`input_image_path` and `style_image_path` variables).
+
+3. Run the script:
+
+
+4. The script will optimize the generated image to combine the content of the input image with the style of the reference image.
+
+5. The final enhanced image will be saved as `enhanced_image.jpg` in the project directory.
+
+## Examples
+
+Here are some example results of using NST to enhance images:
+
+![Input Image](examples/input_image.jpg)
+![Style Reference Image](examples/style_image.jpg)
+![Enhanced Image](examples/enhanced_image.jpg)
+
+## License
+
+This project is licensed under the Aziz Karoui License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- This project is based on the Neural Style Transfer technique developed by Gatys et al.
+- Pre-trained VGG models provided by the Keras team.
+
+Feel free to modify this README file to include more details, usage instructions, or additional sections relevant to your project.

ReadMe.txt

@@ -0,0 +1,50 @@
+# Neural Style Transfer (NST) for Image Enhancement
+
+Enhance your images using Neural Style Transfer by combining the content of an input image with the style of a reference image.
+
+## Description
+
+This project uses TensorFlow to perform Neural Style Transfer (NST) on an input image using a style reference image. NST is a technique for enhancing an image by transferring the artistic style of one image (the reference style image) to the content of another image (the input image). The result is a new image that combines the content of the input image with the artistic style of the reference image.
+
+## Prerequisites
+
+- Python 3.x
+- TensorFlow 2.x
+- NumPy
+- Matplotlib
+- Pillow
+
+You can install the required Python packages by running:
+
+
+## Usage
+
+1. Prepare your input image and style reference image and save them in the project directory.
+
+2. Update the paths to your input and style reference images in the script (`input_image_path` and `style_image_path` variables).
+
+3. Run the script:
+
+
+4. The script will optimize the generated image to combine the content of the input image with the style of the reference image.
+
+5. The final enhanced image will be saved as `enhanced_image.jpg` in the project directory.
+
+## Examples
+
+Here are some example results of using NST to enhance images:
+
+![Input Image](examples/input_image.jpg)
+![Style Reference Image](examples/style_image.jpg)
+![Enhanced Image](examples/enhanced_image.jpg)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- This project is based on the Neural Style Transfer technique developed by Gatys et al.
+- Pre-trained VGG models provided by the Keras team.
+
+Feel free to modify this README file to include more details, usage instructions, or additional sections relevant to your project.

aziz-model-64p-v2.pth

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

image_enhancement_model.pth

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

layer-model-8p-v1.0.pth

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

layer-model-8p-v2.0.pth

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

model-8p-v3.pth

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

pixel.py

@@ -0,0 +1,117 @@
+import tensorflow as tf
+import numpy as np
+import matplotlib.pyplot as plt
+from tensorflow.keras.preprocessing import image as tf_image
+from tensorflow.keras.applications import VGG19
+from tensorflow.keras.models import Model
+from tensorflow.keras import layers
+from tensorflow.keras.optimizers import Adam
+
+# Load a pre-trained VGG19 model without the fully connected layers (used for feature extraction)
+base_model = VGG19(weights="imagenet", include_top=False)
+
+# Specify the layers to use for style and content representations
+style_layers = ["block1_conv1", "block2_conv1", "block3_conv1", "block4_conv1", "block5_conv1"]
+content_layer = "block4_conv2"
+
+# Create a model that extracts style and content features
+style_extractor = Model(inputs=base_model.input, outputs=[base_model.get_layer(layer).output for layer in style_layers])
+content_extractor = Model(inputs=base_model.input, outputs=base_model.get_layer(content_layer).output)
+
+# Define a function to compute the Gram matrix for style representation
+def gram_matrix(input_tensor):
+    result = tf.linalg.einsum("bijc,bijd->bcd", input_tensor, input_tensor)
+    input_shape = tf.shape(input_tensor)
+    num_locations = tf.cast(input_shape[1]*input_shape[2], tf.float32)
+    return result / num_locations
+
+# Define a custom loss function that computes the style loss
+def style_loss(style_targets, predicted_styles):
+    loss = 0
+    for style_target, predicted_style in zip(style_targets, predicted_styles):
+        loss += tf.reduce_mean(tf.square(gram_matrix(style_target) - gram_matrix(predicted_style)))
+    return loss
+
+# Define a custom loss function that computes the content loss
+def content_loss(content_target, predicted_content):
+    return tf.reduce_mean(tf.square(content_target - predicted_content))
+
+# Load your input and style images
+input_image_path = "input_image.jpg"
+style_image_path = "style_image.jpg"
+
+input_image = tf_image.load_img(input_image_path)
+style_image = tf_image.load_img(style_image_path)
+
+input_image = tf_image.img_to_array(input_image)
+style_image = tf_image.img_to_array(style_image)
+
+# Preprocess the images (VGG19 requires specific preprocessing)
+input_image = tf_image.smart_resize(input_image, (256, 256))
+style_image = tf_image.smart_resize(style_image, (256, 256))
+
+input_image = tf_image.img_to_array(input_image)
+style_image = tf_image.img_to_array(style_image)
+
+input_image = tf.keras.applications.vgg19.preprocess_input(input_image)
+style_image = tf.keras.applications.vgg19.preprocess_input(style_image)
+
+input_image = np.expand_dims(input_image, axis=0)
+style_image = np.expand_dims(style_image, axis=0)
+
+# Define a variable to store the generated image and create a TensorFlow variable for it
+generated_image = tf.Variable(input_image, dtype=tf.float32)
+
+# Define optimizer and hyperparameters
+optimizer = Adam(learning_rate=10.0)
+
+# Number of iterations for optimization
+num_iterations = 1000
+
+# Extract style and content features from the style and input images
+style_features = style_extractor(style_image)
+content_features = content_extractor(input_image)
+
+# Define target style features (the same style for all layers)
+style_targets = [style_extractor(tf.constant(style_image)) for _ in style_layers]
+
+# Main optimization loop
+for iteration in range(num_iterations):
+    with tf.GradientTape() as tape:
+        # Extract features from the generated image
+        generated_features = style_extractor(generated_image)
+
+        # Compute style loss and content loss
+        current_style_loss = style_loss(style_targets, generated_features)
+        current_content_loss = content_loss(content_features, generated_features[-1])
+
+        # Total loss as a combination of style and content loss
+        total_loss = current_style_loss + current_content_loss
+
+    # Compute gradients
+    gradients = tape.gradient(total_loss, generated_image)
+
+    # Update the generated image using the gradients
+    optimizer.apply_gradients([(gradients, generated_image)])
+
+    # Clip pixel values to the [0, 255] range
+    generated_image.assign(tf.clip_by_value(generated_image, clip_value_min=0.0, clip_value_max=255.0))
+
+    # Print the progress
+    if iteration % 100 == 0:
+        print(f"Iteration {iteration}, Total loss: {total_loss}")
+
+# Convert the final generated image to a NumPy array
+final_image = tf_image.img_to_array(generated_image[0])
+
+# Clip pixel values to the [0, 255] range and cast to uint8
+final_image = np.clip(final_image, 0, 255).astype(np.uint8)
+
+# Save the final image
+final_image_path = "enhanced_image.jpg"
+tf.keras.preprocessing.image.save_img(final_image_path, final_image[0])
+
+# Display the final enhanced image
+plt.imshow(final_image[0])
+plt.axis("off")
+plt.show()

requirements.txt

@@ -0,0 +1,4 @@
+tensorflow==2.6.0
+numpy==1.19.5
+matplotlib==3.3.4
+Pillow==8.2.0

script.py

@@ -0,0 +1,17 @@
+from PIL import Image, ImageEnhance
+
+# Open the input image
+image = Image.open('dog.jpg')
+
+# Resize the image
+width, height = image.size
+target_width = width * 2
+target_height = height * 2
+resized_image = image.resize((target_width, target_height), Image.BILINEAR)
+
+# Apply image enhancements
+enhancer = ImageEnhance.Brightness(resized_image)
+enhanced_image = enhancer.enhance(1)  # Adjust brightness (increase or decrease the value as desired)
+
+# Save the final enhanced image
+enhanced_image.save('dogii.jpg')