Nice to release a model again! This one is intended for realistic imagery, and works especially well on faces, hair, and nature shots. It should only be used on somewhat clear shots, without a lot of grain. I trained this model on SPAN, which as of the time of release, you'll need chaiNNer-nightly for. I aimed for a softer, more natural look for this model with as few artifacts as possible.

In addition to the Normal model, I've included a "soft" model. The Soft model is... softer. Basically it was an earlier version of the model with a more limited dataset. It produces more natural output on games or rendered content, but suffers a bit more with realistic stuff.

Note: In shots with DOF (depth of field) or bokeh, unfortunately there will be artifacts. 

Compatibility: You'll have to use the latest chaiNNer-nightly to use this model

ClearRealityV1

Description: 4x realistic upscaler that may also work for general purpose usage. It was trained with OTF random degradation with a very low to very high range of degradations, including blur, noise, and compression. Trained with the same Frankendata dataset that I used for the pretrain model.

Frankendata_FullDegradation_SRFormer

Remove noise, grain, box blur, lens blur and gaussian blur and increase overall image quality.

LADDIER1

A universal model, that is aimed at prerendered images, but handles realistic faces, manga, pixel art and dedithering as well. Trained using the patchgan discriminator, with cx loss, cutmixup and frequency separation, it produces good results with a slight grain due to patchgan, with some sharpening using cutmixup.

Lollypop

Universal upscaler for clean and slightly compressed images (JPEG quality 75 or better)

NMKD Siax ("CX")

Purpose: Clean Real-World Images

Upscaling of realistic images/photos with noise and compression artifacts

NMKD Superscale

[Link to Github Release](https://github.com/Phhofm/models/releases/4xNomos8k_atd_jpg)

Name: 4xNomos8k_atd_jpg   
License: CC BY 4.0   
Author: Philip Hofmann   
Network: [ATD](https://github.com/LabShuHangGU/Adaptive-Token-Dictionary)   
Scale: 4   
Release Date: 22.03.2024   
Purpose: 4x photo upscaler, handles jpg compression   
Iterations: 240'000   
epoch: 152   
batch_size: 6, 3   
HR_size: 128, 192   
Dataset: nomos8k   
Number of train images: 8492   
OTF Training: Yes   
Pretrained_Model_G: 003_ATD_SRx4_finetune   

Description:
4x photo upscaler which handles jpg compression. This model will preserve noise. Trained on the very recently released (~2 weeks ago) Adaptive-Token-Dictionary network.   

Training details: 
AdamW optimizer with U-Net SN discriminator and BFloat16.
Degraded with otf jpg compression down to 40, re-compression down to 40, together with resizes and the blur kernels.  
Losses: PixelLoss using CHC (Clipped Huber with Cosine Similarity Loss), PerceptualLoss using Huber, GANLoss, [LDL](https://github.com/csjliang/LDL) using Huber, YCbCr Color Loss (bt601) and Luma Loss (CIE XYZ) on [neosr](https://github.com/muslll/neosr).

7 Examples:
[Slowpics](https://slow.pics/s/uwnoI435)

 4xNomos8k_atd_jpg

I release my span otf series:
They come in three variations: weak, middle, and strong.
Mainly meant for photos (can be tried on other things of course).

(Also there is a non-otf span model I had been working on simultaneously that I will release shortly, should give better results on less degraded input in comparison to this span otf series)

Basically I trained the otf_strong for 90k iter and then medium and weak based off that, with some more training to de-learn (tone down) the (too?) strong degradations. Used discrim resets to correct occuring colorloss in all of them. gt size was for the most part 512 with batch 9 (since i hoped it would give better results) with 0.55 it/s training speed (first 40k at the beginning were gt size 256 with batch 20 with 0.58 it/s).

Nomos8k_span_otf_medium

Nomos8k_span_otf_strong

Nomos8k_span_otf_weak

Nomos8kHAT-L_otf

i made this model to upscale old anime and denoise.

OLDIES_FINAL

[Link to Github Release](https://github.com/Phhofm/models/releases/4xRealWebPhoto_v2_rgt_s)

Name: 4xRealWebPhoto_v2_rgt_s   
License: CC BY 4.0   
Author: Philip Hofmann   
Network: RGT   
Network Option: RGT-S   
Scale: 4   
Release Date: 10.03.2024   
Purpose: 4x real web photo upscaler, meant for upscaling photos downloaded from the web   
Iterations: 220'000   
epoch: 5   
batch_size: 16   
HR_size: 128   
Dataset: 4xRealWebPhoto_v2 (see details in attached pdf file in github release)   
Number of train images: 1'086'976 (or 543'488 pairs)   
OTF Training: No   
Pretrained_Model_G: RGT_S_x4   

Description:
4x real web photo upscaler, meant for upscaling photos downloaded from the web. Trained on my v2 of my 4xRealWebPhoto dataset, it should be able to handle realistic noise, jpg and webp compression and re-compression, scaling and rescaling with multiple downscampling algos, and handle a little bit of lens blur.

Thought featuring degraded images in the examples, this model should also be able to handle good quality input.

Details about the approach/dataset I made to train this model (and therefore also what this model would be capable of handling) is in the attached pdf in the github release.

My previous tries of this dataset, meaning v0 and v1, will get a separate entry, though this version would be recommended over them.

12 Examples on [Slowpics](https://slow.pics/s/HxXtE1eZ)

 4xRealWebPhoto_v2_rgt_s

[Link to Github Release](https://github.com/Phhofm/models/releases/4xRealWebPhoto_v3_atd)

Name: 4xRealWebPhoto_v3_atd   
License: CC BY 4.0   
Author: Philip Hofmann   
Network: [ATD](https://github.com/LabShuHangGU/Adaptive-Token-Dictionary)   
Scale: 4   
Release Date: 22.03.2024   
Purpose: 4x upscaler for photos downloaded from the web   
Iterations: 250'000   
epoch: 10   
batch_size: 6, 3   
HR_size: 128, 192   
Dataset: 4xRealWebPhoto_v3   
Number of train images: 101'904   
OTF Training: No   
Pretrained_Model_G: 003_ATD_SRx4_finetune   

Description:   
4x real web photo upscaler, meant for upscaling photos downloaded from the web. Trained on my v3 of my 4xRealWebPhoto dataset, it should be able to handle noise, jpg and webp (re)compression, (re)scaling, and just a little bit of lens blur, while also be able to handle good quality input. Trained on the very recently released (~2 weeks ago) Adaptive-Token-Dictionary network. 

My 4xRealWebPhoto dataset tried to simulate the use-case of a photo being uploaded to the web and being processed by the service provides (like on a social media platform) so compression/downscaling, then maybe being downloaded and re-uploaded by another used where it, again, were processed by the service provider. I included different variants in the dataset. The pdf with info to the v2 dataset can be found [here](https://github.com/Phhofm/models/releases/download/4xRealWebPhoto_v2_rgt_s/4xRealWebPhoto_v2.pdf), while i simply included whats different in the v3 png:

![4xRealWebPhoto_v3](https://github.com/Phhofm/models/assets/14755670/2ec67e48-bf21-4b57-9f27-69bc49b84315)


Training details: 
AdamW optimizer with U-Net SN discriminator and BFloat16.
Degraded with otf jpg compression down to 40, re-compression down to 40, together with resizes and the blur kernels.  
Losses: PixelLoss using CHC (Clipped Huber with Cosine Similarity Loss), PerceptualLoss using Huber, GANLoss, [LDL](https://github.com/csjliang/LDL) using Huber, [Focal Frequency](https://github.com/EndlessSora/focal-frequency-loss), [Gradient Variance](https://github.com/lusinlu/gradient-variance-loss) with Huber, YCbCr Color Loss (bt601) and Luma Loss (CIE XYZ) on [neosr](https://github.com/muslll/neosr) with norm: true.

11 Examples:
[Slowpics](https://slow.pics/s/plgWVh4j)

 4xRealWebPhoto_v3_atd

[Link to Github Release](https://github.com/Phhofm/models/releases/4xRealWebPhoto_v4_dat2)

## 4xRealWebPhoto_v4_dat2

**Scale:** 4   
**Architecture:** DAT   

**Author:** Philip Hofmann   
**License:** CC-BY-4.0   
**Purpose:** Compression Removal, Deblur, Denoise, JPEG, WEBP, Restoration   
**Subject:** Photography   
**Input Type:** Images   
**Date:** 04.04.2024   

**Architecture Option:** DAT-2   
**I/O Channels:** 3(RGB)->3(RGB)   

**Dataset:** Nomos8k   
**Dataset Size:** 8492   
**OTF (on the fly augmentations):** No   
**Pretrained Model:** DAT_2_x4   
**Iterations:** 243'000   
**Batch Size:** 4-6   
**GT Size:** 128-256   

**Description:** 4x Upscaling Model for Photos from the Web. The dataset consists of only downscaled photos (to handle good quality), downscaled and compressed photos (uploaded to the web and compressed by service provider), and downscale, compressed, rescaled, recompressed photos (downloaded from the web and re-uploaded to the web).

Applied lens blur, realistic noise with my ludvae200 model, JPG and WEBP compression (40-95), and down_up, linear, cubic_mitchell, lanczos, gaussian and box downsampling algorithms. For details on the degradation process, check out the pdf with its explanations and visualizations.

This is basically a dat2 version of my previous 4xRealWebPhoto_v3_atd model, but trained with a bit stronger noise values, and also a single image per variant so drastically reduced training dataset size.
 

**Showcase:** 
[12 Slowpics Examples](https://slow.pics/s/TvJ21pJG)

4xRealWebPhoto_v4_dat2

Rybu

Pretrained: 4xESRGAN

This is my best model yet! It generates lots and lots of detail and leaves a nice texture on images. It works on most images, whether compressed or not. It does work best on JPEG compression though, as that's mostly what it was trained on. It has the ability to restore highly compressed images as well! If you want a more balanced output, check out the UltraMix Collection down below. It's a bunch of interpolated models based around UltraSharp and my other models

UltraSharp

UniScale strikes a nice balance between sharpness and realism. This model can upscale almost anything well. It was originally intended to upscale game textures, but was expanded into a universal upscaler. Interp is these two models interpolated.

UniScale Balanced

UniScale_Restore has strong compression removal that helps with restoring heavily compressed or noisy images. It is intended to compete with BSRGAN. Trained with BSRGAN_Resize and Combo_Noise in traiNNer.

UniScale Restore

UniScale Strong

Version of UniScale trained with camera noise injection (NR = Noise Removal). This model removes noise from images while upscaling.

UniScaleNR Balanced

UniScaleNR Strong

These models work great on game textures when interpolated 50/50 with UniScale_Restore, and work amazingly on uncompressed images. DO NOT USE FOR COMPRESSED IMAGES, use the original UniScale or UltraSharp for that.

UniScaleV2 Moderate

UniScaleV2 Sharp

Purpose: Game textures/Art

This model upscales artwork for the game Volfoss (2001). The model peaked in quality very quickly. The NR model removes most noise, but has the downside of removing transparent portions. Use the main model in most cases.

UniScaleNR Balanced

Good for

Similar models

Model

Rights