pfnet/paintschainer

★ 3,766Jupyter NotebookAudience · designerComplexity · 3/5LicenseSetup · hard

Mindmap

mindmap
  root((PaintsChainer))
    What it does
      Line art colorization
      Semi-automatic
      Neural network
    Tech stack
      Python
      Chainer
      CUDA GPU
      Browser canvas
    Use cases
      Anime sketches
      Custom training
      Local workflow
    Audience
      Artists
      Designers

mindmap root((PaintsChainer)) What it does Line art colorization Semi-automatic Neural network Tech stack Python Chainer CUDA GPU Browser canvas Use cases Anime sketches Custom training Local workflow Audience Artists Designers

Click or tap to explore — scroll the page freely

Things people build with this

USE CASE 1

Colorize anime-style sketches or line art automatically and then adjust the suggested colors

USE CASE 2

Run a local colorization tool for a personal drawing workflow without sending artwork to a cloud service

USE CASE 3

Train a custom colorization model on your own sketch dataset using the included training scripts

Tech stack

PythonChainerCUDAJavaScriptJupyter Notebook

Getting it running

Difficulty · hard Time to first run · 1h+

Requires an Nvidia GPU with CUDA support, there is no CPU fallback, so the tool will not run on a machine without compatible hardware.

In plain English

PaintsChainer is a tool that automatically adds color to black-and-white line drawings, like sketches or anime-style artwork. You give it a sketch, and it uses a neural network to fill in colors in a semi-automatic way, meaning it can suggest a colorization that you can then adjust. The tool runs as a local web application on your own machine. You start a small Python server, open a browser at localhost:8000, and interact with a drawing interface built with wPaint.js, a simple canvas tool. The colorization happens on the server side and the result is shown in the browser. The neural network is built using Chainer, a deep learning framework from the Japanese AI company Preferred Networks, which created this project. The model uses a two-layer architecture: one layer processes a lower-resolution version of the drawing, and a second layer refines it at higher resolution. Running colorization at a useful speed requires an Nvidia GPU with CUDA support. Pre-trained model files are available for download from the project's website so you can use the tool without training it yourself. The source code is MIT-licensed, but the pre-trained models carry an All Rights Reserved notice, meaning you can run and modify the code but cannot redistribute or use the models commercially without permission. If you want to train your own models instead of using the pre-trained ones, training scripts are included for both layers. The installation guide lives in the project's GitHub wiki. There was also a public demo hosted at paintschainer.preferred.tech, though the current status of that demo is not indicated in the README.

Copy-paste prompts

Prompt 1

Walk me through installing PaintsChainer on Ubuntu with CUDA, downloading the pre-trained models, and starting the local web server.

Prompt 2

How does PaintsChainer's two-layer architecture work, what does the low-resolution layer do versus the refinement layer, and why is the two-stage approach used?

Prompt 3

I want to train a custom colorization model on my own anime sketch dataset, which training scripts do I run and what format does the data need to be in?

Prompt 4

How do I call PaintsChainer's colorization endpoint programmatically from Python instead of going through the browser interface?

Open on GitHub → Explain another repo

← pfnet on gitmyhub — every repo by this author, as a profile.

Verify against the repo before relying on details.