Ai image upscale python

Saved searches

Use saved searches to filter your results more quickly

You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session.

Upscale images by a factor of 2 via deep convolutional neural network in Python

TheMrKingent/NeuralUpscale

This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?

Sign In Required

Please sign in to use Codespaces.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching Xcode

If nothing happens, download Xcode and try again.

Launching Visual Studio Code

Your codespace will open once ready.

There was a problem preparing your codespace, please try again.

Latest commit

Git stats

Files

Failed to load latest commit information.

README.md

Upscale images by a factor of 2 via deep convolutional neural network in Python: API and pre-trained models, based on the ESPC architecture by Shi et al. 2016 [1].

Two pre-trained models are included: Luminance and RGB, both of which were trained on approximately 33k various images (~6.5Gb). You can, however, use any Tensorflow model which is compatible with the architecture, or even train your own, in which case UpscalingUtilities package and Training.ipynb notebook may be useful.

Requirements: Tensorflow , PIL . Tested on Python 3.10.

from UpscalingUtilities import * from Neural_Upscale_2x import *

1. Load desired model. Pre-trained models are either Luminance_Model or RGB_Model . Say you want to use the first one:

model = load_upscaling_model('../Luminance_Model')

1. Initialize an upscaler object using the appropriate function. Either luminanceUpscaler() or rgbUpscaler() . In this example:

upscaler = luminanceUpscaler(model)

1. Upscale! Returns an image upscaled by a factor of 2 in both width and height (4 times as many pixels) as a PIL image instance, which you can save as usual:

img_2x = upscaler.upscale(img) img_2x.save('../title.png')

[1] Wenzhe Shi, Jose Caballero, Ferenc Huszár, Johannes Totz, Andrew P Aitken, Rob Bishop, Daniel Rueckert, and Zehan Wang. Real-time single image and video super-resolution using an efficient sub-pixel convolutional neural network. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 1874–1883, 2016.

About

Upscale images by a factor of 2 via deep convolutional neural network in Python

Источник

Saved searches

Use saved searches to filter your results more quickly

You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session.

🔎 Super-scale your images and run experiments with Residual Dense and Adversarial Networks.

License

idealo/image-super-resolution

This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?

Sign In Required

Please sign in to use Codespaces.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching Xcode

If nothing happens, download Xcode and try again.

Launching Visual Studio Code

Your codespace will open once ready.

There was a problem preparing your codespace, please try again.

Latest commit

Git stats

Files

Failed to load latest commit information.

README.md

Image Super-Resolution (ISR)

The goal of this project is to upscale and improve the quality of low resolution images.

This project contains Keras implementations of different Residual Dense Networks for Single Image Super-Resolution (ISR) as well as scripts to train these networks using content and adversarial loss components.

The implemented networks include:

• The super-scaling Residual Dense Network described in Residual Dense Network for Image Super-Resolution (Zhang et al. 2018)
• The super-scaling Residual in Residual Dense Network described in ESRGAN: Enhanced Super-Resolution Generative Adversarial Networks (Wang et al. 2018)
• A multi-output version of the Keras VGG19 network for deep features extraction used in the perceptual loss
• A custom discriminator network based on the one described in Photo-Realistic Single Image Super-Resolution Using a Generative Adversarial Network (SRGANS, Ledig et al. 2017)

Docker scripts and Google Colab notebooks are available to carry training and prediction. Also, we provide scripts to facilitate training on the cloud with AWS and nvidia-docker with only a few commands.

ISR is compatible with Python 3.6 and is distributed under the Apache 2.0 license. We welcome any kind of contribution. If you wish to contribute, please see the Contribute section.

Training not delivering good/patchy results

When training your own model, start with only PSNR loss (50+ epochs, depending on the dataset) and only then introduce GANS and feature loss. This can be controlled by the loss weights argument.

This is just sample, you will need to tune these parameters.

If you are having trouble loading your own weights or the pre-trained weights ( AttributeError: ‘str’ object has no attribute ‘decode’ ), try:

pip install 'h5py==2.10.0' --force-reinstall

The weights used to produced these images are available directly when creating the model object.

Currently 4 models are available:

The network parameters will be automatically chosen. (see Additional Information).

RDN model, PSNR driven, choose the option weights=’psnr-large’ or weights=’psnr-small’ when creating a RDN model.

Low resolution image (left), ISR output (center), bicubic scaling (right). Click to zoom.

RRDN model, trained with Adversarial and VGG features losses, choose the option weights=’gans’ when creating a RRDN model.

RRDN GANS model (left), bicubic upscaling (right).
-> more detailed comparison

Artefact Cancelling GANS model

RDN model, trained with Adversarial and VGG features losses, choose the option weights=’noise-cancel’ when creating a RDN model.

Standard vs GANS model. Click to zoom.

RDN GANS artefact cancelling model (left), RDN standard PSNR driven model (right).
-> more detailed comparison

There are two ways to install the Image Super-Resolution package:

git clone https://github.com/idealo/image-super-resolution cd image-super-resolution python setup.py install 

Load image and prepare it

import numpy as np from PIL import Image img = Image.open('data/input/test_images/sample_image.jpg') lr_img = np.array(img)

Load a pre-trained model and run prediction (check the prediction tutorial under notebooks for more details)

from ISR.models import RDN rdn = RDN(weights='psnr-small') sr_img = rdn.predict(lr_img) Image.fromarray(sr_img)

To predict on large images and avoid memory allocation errors, use the by_patch_of_size option for the predict method, for instance

sr_img = model.predict(image, by_patch_of_size=50) 

Check the documentation of the ImageModel class for further details.

from ISR.models import RRDN from ISR.models import Discriminator from ISR.models import Cut_VGG19 lr_train_patch_size = 40 layers_to_extract = [5, 9] scale = 2 hr_train_patch_size = lr_train_patch_size * scale rrdn = RRDN(arch_params='C':4, 'D':3, 'G':64, 'G0':64, 'T':10, 'x':scale>, patch_size=lr_train_patch_size) f_ext = Cut_VGG19(patch_size=hr_train_patch_size, layers_to_extract=layers_to_extract) discr = Discriminator(patch_size=hr_train_patch_size, kernel_size=3)

Create a Trainer object using the desired settings and give it the models ( f_ext and discr are optional)

from ISR.train import Trainer loss_weights = < 'generator': 0.0, 'feature_extractor': 0.0833, 'discriminator': 0.01 > losses = < 'generator': 'mae', 'feature_extractor': 'mse', 'discriminator': 'binary_crossentropy' > log_dirs = 'logs': './logs', 'weights': './weights'> learning_rate = 'initial_value': 0.0004, 'decay_factor': 0.5, 'decay_frequency': 30> flatness = 'min': 0.0, 'max': 0.15, 'increase': 0.01, 'increase_frequency': 5> trainer = Trainer( generator=rrdn, discriminator=discr, feature_extractor=f_ext, lr_train_dir='low_res/training/images', hr_train_dir='high_res/training/images', lr_valid_dir='low_res/validation/images', hr_valid_dir='high_res/validation/images', loss_weights=loss_weights, learning_rate=learning_rate, flatness=flatness, dataname='image_dataset', log_dirs=log_dirs, weights_generator=None, weights_discriminator=None, n_validation=40, )

trainer.train( epochs=80, steps_per_epoch=500, batch_size=16, monitored_metrics='val_PSNR_Y': 'max'> )

You can read about how we trained these network weights in our Medium posts:

The weights of the RDN network trained on the DIV2K dataset are available in weights/sample_weights/rdn-C6-D20-G64-G064-x2/PSNR-driven/rdn-C6-D20-G64-G064-x2_PSNR_epoch086.hdf5 .
The model was trained using C=6, D=20, G=64, G0=64 as parameters (see architecture for details) for 86 epochs of 1000 batches of 8 32×32 augmented patches taken from LR images.

The artefact can cancelling weights obtained with a combination of different training sessions using different datasets and perceptual loss with VGG19 and GAN can be found at weights/sample_weights/rdn-C6-D20-G64-G064-x2/ArtefactCancelling/rdn-C6-D20-G64-G064-x2_ArtefactCancelling_epoch219.hdf5 We recommend using these weights only when cancelling compression artefacts is a desirable effect.

The main parameters of the architecture structure are:

• D — number of Residual Dense Blocks (RDB)
• C — number of convolutional layers stacked inside a RDB
• G — number of feature maps of each convolutional layers inside the RDBs
• G0 — number of feature maps for convolutions outside of RDBs and of each RBD output

RRDN Network architecture

The main parameters of the architecture structure are:

• T — number of Residual in Residual Dense Blocks (RRDB)
• D — number of Residual Dense Blocks (RDB) insider each RRDB
• C — number of convolutional layers stacked inside a RDB
• G — number of feature maps of each convolutional layers inside the RDBs
• G0 — number of feature maps for convolutions outside of RDBs and of each RBD output

We welcome all kinds of contributions, models trained on different datasets, new model architectures and/or hyperparameters combinations that improve the performance of the currently published model.

Will publish the performances of new models in this repository.

See the Contribution guide for more details.

To bump up the version, use

Please cite our work in your publications if it helps your research.

@misccardinale2018isr, title=ISR>, author=Francesco Cardinale et al.>, year=2018>, howpublished=\url>, >

About

🔎 Super-scale your images and run experiments with Residual Dense and Adversarial Networks.

Источник