AnimeSharpV2

PBRify_Remix is an easy way to upscale and generate PBR textures using existing low quality textures. The dataset consists of ethically sourced textures from websites like ambientCG and Polyhaven, which sets it apart from most other models.

It's intended for use with RTX Remix (hence the name) but it'll work for other things as well.

More models and other tools can be found here: https://github.com/Kim2091/PBRify_Remix

PBRify

This is SaurusX's original description:
Improvement of low-quality cartoons from broadcast sources. Will greatly increase the visual quality of bad broadcast tape sources of '80s and '90s cartoons (e.g. Garfield and Friends, Heathcliff, DuckTales, etc). Directly addresses chroma blur, dot crawl, and rainbowing. You're highly advised to take care of haloing beforehand in your favorite video editor as the model will not fix it and may make existing halos more noticeable.

-------

Sadly this model has some intense artifacts. Thankfully the SPAN re-train reduced these a bit, but they're still problematic. This was just a quick test of SPAN's capabilities. This was trained only to ~66k iterations, compared to the 480k of the original.

BroadcastToStudio_SPAN

This model was trained on lossless video frames of Metal Arms: Glitch in the System, compressed with Bink V1 for the LR frames. It's a lot more efficient than my first DeBink model, and also has less artifacts. It's not quite as robust, but the compression is barely noticeable in videos after processing with this.

Sample video: https://cdn.discordapp.com/attachments/903415274521374750/904129653374078976/XB_Demo_Mov-85600_G.mp4

DeBink Lite

This model removes early 2000s Bink and other compression artifacts. Works well on almost any image or video compression type.

DeBink v4

DeBink v5

DeBink v6

Incomplete lite model to remove ROQ compression

DeRoqBeta-lite

These models deblur most images. It was trained mostly on aniso2 and iso blurring (BSRGAN augmentation) with some gaussian mixed in. It performs well on most blurry images, but I'd recommend using something like Fatality_Deblur for very strong gaussian blur.

Focus

Focus Moderate

Pretrained: Custom JPEG dataset

Model I forgot to release. This doesn't totally remove JPEG artifacts, but it does a decent job at a fast rate. It seemingly does a better job of retaining detail than some other JPEG models. The model is incomplete, I need to train it further on compact rather than ESRGAN. This is just a temporary release

Kim2091 DeJpeg v0

This is part of a larger model set, PBRify_Remix. PBRify_Remix is an easy way to upscale and generate PBR textures using existing low quality textures. The dataset consists of ethically sourced textures from websites like ambientCG and Polyhaven, which sets it apart from most other models.

It's intended for use with RTX Remix (hence the name) but it'll work for other things as well.

Note: The height map model is best used after applying a "delighting" pipeline to your game textures. Currently PBRify_Remix does not have a method for this, so you need your own.

1x-PBRify_Height

This is part of a larger model set, PBRify_Remix. PBRify_Remix is an easy way to upscale and generate PBR textures using existing low quality textures. The dataset consists of ethically sourced textures from websites like ambientCG and Polyhaven, which sets it apart from most other models.

It's intended for use with RTX Remix (hence the name) but it'll work for other things as well.

1x-PBRify_NormalV3

1x-PBRify_RoughnessV2.pth

This model decompresses images and video compressed using RoQ. Config and presets will be added when Mega decides to let me use their site!

RoQ_nRoll

Restoring frames from the show "Sheeep"

This model was trained to restore "Sheeep" while retaining and enhancing the noise present in the show. The model amazingly finished training in only 8.8k iterations with no pretrain, with a dataset of only 4 image pairs. This model should work well for animes and cartoons with a lot of grain present. There are some slight haloing issues in dark colors unfortunately, but I was unable to fix it.

SheeepIt!

Purpose: Upscaling older cartoons

This is yet another retrain of SaurusX's SwatKats_Lite model. The dataset was reprocessed with my [Find Misaligned Images](<https://github.com/Kim2091/helpful-scripts/tree/main/Find%20Misaligned%20Images>) script, along with the new [ImgAlign](<https://github.com/sonic41592/ImgAlign>) update, which drastically reduced artifacts and increased the model's capabilities. This particular model is roughly on par with or slightly behind the original, doing better in some spots and worse in others. Refer to the attached examples to see this.

The advantage of this over the original is the speed improvement of Compact over ESRGAN-lite. In a 480p test on an RTX 4090, the original ESRGAN-lite model took 0.28 seconds to process a frame vs Compact's 0.13 seconds.

https://slow.pics/s/dF3Icjpv

OR

<https://imgsli.com/MjQxMzc1/0/1>

SwatKats Compact

This is SaurusX's original description:
Fix vertical blur / split lines / shadowing. A 1x model of my 2xSwatKats. Resolves the same video problems as before, but 1x and faster and meant for chaining to other 2x models (or whatever). Input MUST be 540 vertical as the blur problem is very resolution sensitive.

-------

The goal for this retrain was to get the "magic" of SwatKatsLite into SPAN for much faster video processing. It's about 80% of the way there. There's some artifacts here and there that aren't present in the original, and it has small amounts of color halos in certain areas. I've retrained this model so many times that I've just decided to release it. This particular release was trained to ~450k.

The included Family Guy image shows the color ringing issue. Sorry. 

Update: I've added a second alt model that has less color ringing, but doesn't do quite as good with line repair. I believe I've reached architecture limits

SwatKats_SPAN

Basic 1x model to use for SPAN anime models. Enjoy

1x-span_anime_pretrain

GitHub Link: https://github.com/Kim2091/Kim2091-Models/releases/tag/2x-AnimeSharpV2_Set

This is my first anime model in years. Hopefully you guys can find a good use-case for it. Included are 4 models:

1. RealPLKSR (Higher quality, slower)
2. MoSR (Lower quality, faster)

There are Sharp and Soft versions of both
When to use each:
- __Sharp:__ For heavily degraded sources. Sharp models have issues depth of field but are best at removing artifacts 
- __Soft:__ For cleaner sources. Soft models preserve depth of field but may not remove other artifacts as well

__Notes:__
- MoSR doesn't work in chaiNNer currently
- To use MoSR:
  1. Use the ONNX version in tools like [VideoJaNai](<https://github.com/the-database/VideoJaNai>)
  2. Update spandrel in the latest version of ComfyUI

The ONNX version may produce slightly different results than the .pth version. If you have issues, try the .pth model.

2x-AnimeSharpV2_MoSR_Sharp

2x-AnimeSharpV2_MoSR_Soft

2x-AnimeSharpV2_RPLKSR_Sharp

2x-AnimeSharpV2_RPLKSR_Soft

Purpose: Animation, Pixel Art

This model has VERY strong compression removal and line restructuring that allows it to restore any heavily compressed drawings, animation, cartoons, or anime. Also works on games as well as DDS compression. It renders frames very quickly and is very viable for restoring videos.

Pretrained model: 4x-MMScale (Yes, 4x. mistakes were made)

UniScale CartoonRestore Lite

This model is based on a private model by @eula 5600x 3070 named 4x_eula_anifilm_v1_225k. He sent me a copy of the model, and I decided to train a compact model based on it with his permission. This model seems to fix the majority of the issues the original model had while being far faster, it's just a tiny bit softer in some images.

The dataset consists of Dragon Ball movies converted to YUV24 with @sgdisk --zap-all /dev/sda's help to reduce artifacts, then upscaled with ArtClarity and eula_anifilm. LRs are the original frames right from DVD. As a result, this model corrects some color space issues. The 2x model's HRs were downscaled by 50% with Lanczos.

The 2x and 4x models are pretty close in output despite being trained separately. The 2x model is a bit softer overall.

The models in the Real-ESRGAN Compatible folder are the original output from Real-ESRGANs training code for compatibility reasons.

Anifilm Compact (2x)

This is just a very basic 2x model to start your anime models with on SPAN, nothing special. I tried to keep it as basic as possible

2x-span_anime_pretrain

Interpolation between 4x-UltraSharp and 4x-TextSharp-v0.5. Works amazingly on anime. It also upscales text, but it's far better with anime content. I rebranded this model on 2/10/22 to 4x-AnimeSharp from 4x-TextSharpV1.

Pretrained model: Interpolation between 4x-UltraSharp and 4x-TextSharp-v0.5

AnimeSharp

This model is a lite version of AnimeSharp. It was trained using student-teacher learning (if i'm using the term properly), where the HRs are LRs upscaled by the full size AnimeSharp ESRGAN model, and the lite model is trained on those outputs as the HR. It works best on clean or slightly blurry anime. Downscale by 50% first in almost all cases

AnimeSharp lite

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

Simple pretrain for DAT2, trained on CC0 content. "Ethical" model

4x-DAT2_mssim_Pretrain

Category: Fabric/Cloth
Purpose: Fabric

This model set upscales fabric or cloth textures (works on cats too!). The Alt model is just an earlier iteration version. It may work better on some images.The images need to be minimally compressed or passed through a decompression model first. It works with DDS compression though.

Fabric

Fabric-Alt

Purpose: Anime PSP games, Fate Extra

This model was trained as a favor to Demon and the Fate Extra community. It leaves a nice grain on the images and upscales lines and details accurately without looking odd. This model works on most anime-style PSP games. Enjoy! It works best on content with dithering and quantization. NOTICE: I have included both NCNN and ONNX models to make upscaling easier if you rely on either of these. For NCNN, there's two versions. One is FP16 and the other is FP32. FP16 works best on RTX GPUs. Choose FP32 if in doubt about compatibility, or if FP16 doesn't work for you. To use ONNX, download chaiNNer and upscale through there with the ONNX nodes.

FatePlus-lite

Images from the Fate/Extra games. Works better on the newer ones.

Just a model I trained quickly to test traiNNer-redux and see what I could do with OTF. Works well enough

FatePlus Compact

PBRify Github: https://github.com/Kim2091/PBRify_Remix

Release Link: https://github.com/Kim2091/Kim2091-Models/releases/tag/4x-PBRify_RPLKSRd_V3

This update brings a new upscaling model, 4x-PBRify_RPLKSRd_V3. This model is roughly 8x faster than the current DAT2 model, while being *higher quality*. It produces far more natural detail, resolves lines and edges more smoothly, and cleans up compression artifacts better.

As a result of those improvements, PBR is also much improved. It tends to be clearer with less defined artifacts. 

However, this model is currently **only compatible with ComfyUI**. chaiNNer has not yet been updated to support this architecture.

[More Comparisons](https://imgsli.com/Mjk5NjQ5)

4x-PBRify_RPLKSRd_V3

Project page: https://github.com/Kim2091/PBRify_Remix

Yet another model in the PBRify_Remix series. This is a new upscaler to replace the previous 4x-PBRify_UpscalerSIR-M_V2 model.

This model far exceeds the quality of the previous, with far more natural detail generation and better reconstruction of lines and edges.

Comparison: https://slow.pics/c/DCjlXPGb

4x-PBRify_UpscalerDAT2_V1

This is part of my [PBRify_Remix](<https://github.com/Kim2091/PBRify_Remix>) project. This is a much more capable model based on SwinIR Medium, which should strike a balance between capacity for learning + inference speed. It appears to have done so :)

### Replaced by 4x-PBRify_UpscalerDAT2_V1

4x-PBRify_UpscalerSIR-M_V2

4x-PBRify_UpscalerSPANV4

Simple pretrain for RealPLKSR, trained on CC0 or self-made content. Don't use V1-V3, they're not stable for training.

Dataset consisted of simple resizing:
- Lanczos
- Linear
- Bicubic
- Box

4x-RealPLKSR_Pretrain_V4 

Simple pretrain for RealPLKSR Dysample, trained on CC0 content. "Ethical" model

4x-RealPLKSR_dysample_pretrain

Simple pretrain for SwinIR Medium, trained on CC0 content. "Ethical" model

4x-SwinIR-M_Pretrain

Simple pretrain for SwinIR Small, trained on CC0 content. "Ethical" model

4x-SwinIR-S_Pretrain

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

UniScaleV2 Soft

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.

Kim2091's Models

Kim2091's Collections