---
tags:
  - watermark-removal
  - image-enhancement
  - watermark-removal
  - image-deblurring
  - watermark-cleaner
  - ai-image-enhancement
  - watermarked-image-processing
  - watermark-free-images
  - image-restoration
  - neural-networks
  - computer-vision
  - watermark-remover
  - image-processing
  - image-reconstruction
  - supervised-learning

license: apache-2.0
language:
- en
---

# Watermark Removal Model

## Model Summary
The Watermark Removal model is an image processing model based on neural networks. It is designed to remove watermarks from images while preserving the original image quality. The model utilizes an encoder-decoder structure with skip connections to maintain fine details during the watermark removal process.

<div align="center">
  <img width="640" alt="foduucom/Watermark_Removal" src="https://huggingface.co/foduucom/Watermark_Removal/resolve/main/output.png">
</div>

## Model Details

### Model Description
- **Developed by:** FODUU AI
- **Model type:** Computer Vision - Image Processing 
- **Task:** Remove watermark from image

## Usage Guide

### Installation Requirements
```bash
pip install torch torchvision
pip install Pillow matplotlib numpy
```
or you can run :
```bash
pip install -r requirements.txt
```

### Model Loading and Inference
```python
import torch
from torchvision import transforms
from PIL import Image
from watermark_remover import WatermarkRemover
import numpy as np

image_path = "path to your test image"  # Replace with the path to your test image
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# Load the trained model
model = WatermarkRemover().to(device)
model_path = "path to your model.pth"  # Replace with the path to your saved model
model.load_state_dict(torch.load(model_path, map_location=device))
model.eval()

transform = transforms.Compose([transforms.Resize((256, 256)),
                                transforms.ToTensor(),])
watermarked_image = Image.open(image_path).convert("RGB")
original_size = watermarked_image.size  
input_tensor = transform(watermarked_image).unsqueeze(0).to(device)

with torch.no_grad():
    output_tensor = model(input_tensor)

predicted_image = output_tensor.squeeze(0).cpu().permute(1, 2, 0).clamp(0, 1).numpy()
predicted_pil = Image.fromarray((predicted_image * 255).astype(np.uint8))
predicted_pil = predicted_pil.resize(original_size, Image.Resampling.LANCZOS)
predicted_pil.save("predicted_image.jpg", quality=100)


```

## Limitations and Considerations
- Performance may vary depending on watermark complexity and opacity
- Best results achieved with semi-transparent watermarks
- Model trained on 256x256 images; performance may vary with different resolutions
- GPU recommended for faster inference

### Training Details
- **Dataset**: The model was trained on a custom dataset consisting of 20,000 images with watermarks in various styles and intensities.
- **Training Time**: The model was trained for 200 epochs on an NVIDIA GeForce RTX 3060 GPU.
- **Loss Function**: The model uses a combination of MSE (Mean Squared Error) and perceptual loss to optimize watermark removal quality.

### Model Evaluation
The model has been evaluated using Peak Signal-to-Noise Ratio (PSNR) and Structural Similarity Index (SSIM) on a test set of watermarked images, achieving an average PSNR of 30.5 dB and an SSIM of 0.92.


## Compute Infrastructure

### Hardware
NVIDIA GeForce RTX 3060 card

### Software
The model was trained on Jupyter Notebook environment.

### Model Card Contact
For inquiries and contributions, please contact us at info@foduu.com

```bibtex
@ModelCard{
  author    = {Nehul Agrawal and
               Priyal Mehta},
  title     = {Watermark Removal Using Neural Networks},
  year      = {2025}
}
```