umzi/DigitalArt_v5

DigitalArt v5

This is the fifth version of my old dataset. Its main idea was to aggressively filter for inherently high-quality data in order to create a strong foundation for SISR models aimed at restoring internet artwork. It was primarily targeted at anime-style images, but it is also suitable for other styles, since the underlying principles are largely the same.

Dataset Details

Tile Size	n_tiles
768x768	389 988

Dataset Description

The dataset was collected from the Popular section of Pixiv, retaining only PNG images larger than 768×768. The images were then split into tiles using IC9600 to generate a complexity map, which was used to guide the tiling process.

Afterward, the dataset was ranked using the DReX metric, discarding the least detailed tiles that had passed the tiling stage. Several IQA metrics were then applied to remove low-quality images.

Finally, the dataset was filtered to remove duplicates and screentones. Screentones tend to significantly confuse models, and for users who need them, it is generally more effective to generate them synthetically, which also increases data diversity.

• Curated by: umzi
• Funded by: enhancr-dev
• Shared by: umzi
• License: cc0-1.0

Uses

The dataset is intended to serve as a foundation for more specialized datasets or classification tasks through the synthetic generation of label-specific data. It can also be used for other purposes, with the exception of generating new images based on the provided data, as this is prohibited by Pixiv's licensing terms.

Direct Use

SISR, Restoration

Out-of-Scope Use

generating images

Dataset Structure

The image names contain encoded links to the source in base 58 format + tile number + .png

#[bitfield(u128)]
#[derive(PartialEq, Eq)]
pub struct PixivMeta {
    #[bits(28)] pub id: u32,
    #[bits(32)] pub time: u32,
    #[bits(8)]  pub pages: u8,
    #[bits(1)]  pub is_png: bool,
    #[bits(1)]  pub has_hash: bool,
    #[bits(58)] _unused: u64,
}

#[derive(PartialEq, Eq, Debug)]
pub struct PixivLink {
    pub meta: PixivMeta,
    pub hash: u128, 
}
impl PixivLink {
    pub fn from_url(url: &str) -> Option<Self> {
        let re = RE.get_or_init(|| {
            Regex::new(r"/(\d{4})/(\d{2})/(\d{2})/(\d{2})/(\d{2})/(\d{2})/(\d+)(?:-([a-f0-9]{32}))?_p(\d+)\.(png|jpg)").unwrap()
        });

        let caps = re.captures(url)?;
        let year: i32 = caps[1].parse().ok()?;
        let month: u32 = caps[2].parse().ok()?;
        let day: u32 = caps[3].parse().ok()?;
        let hour: u32 = caps[4].parse().ok()?;
        let min: u32 = caps[5].parse().ok()?;
        let sec: u32 = caps[6].parse().ok()?;
        
        let date = Utc.with_ymd_and_hms(year, month, day, hour, min, sec).single()?;
        const EPOCH_2007: i64 = 1_167_609_600;
        let diff_time = (date.timestamp() - EPOCH_2007) as u32;


        let id: u32 = caps[7].parse().ok()?;
        let pages: u8 = caps[9].parse().ok()?;
        let is_png = &caps[10] == "png";

        let mut has_hash = false;
        let mut hash_val = 0u128;
        if let Some(m) = caps.get(8) {
            if let Ok(h) = u128::from_str_radix(m.as_str(), 16) {
                hash_val = h;
                has_hash = true;
            }
        }

        Some(Self {
            meta: PixivMeta::new()
                .with_id(id)
                .with_time(diff_time)
                .with_pages(pages)
                .with_is_png(is_png)
                .with_has_hash(has_hash),
            hash: hash_val,
        })
    }
    pub fn to_base58(&self) -> String {
        bs58::encode(self.to_bytes()).into_string()
    }

}

Curation Rationale

Creating a stable, high-quality foundation for various computer vision tasks and indirectly improving the average quality of SISR models.

Source Data

Pixiv

Data Collection and Processing

The dataset was collected from the Illustrations Daily Rankings section on Pixiv. After parsing, the dataset was downloaded and split into tiles using the following pipeline:

from pepedp.scripts.utils.best_tile import BestTile
from pepedp.enum import ProcessType
from pepedp.scripts.utils.complexity.ic9600 import IC9600Complexity

bt = BestTile(
        "/run/media/umzi/H/pixiv/pixiv/0",
        "/run/media/umzi/H/pixiv/pixiv/0_tile",
        768,
        ProcessType.PROCESS,
        1,
        True,
        0.0,
        False,
        IC9600Complexity()
    )
bt.run()

Next, we sequentially applied four metrics to filter out portions of the dataset:

1. DReX — the lower 50% of samples were removed based on score.

2. TOPIQ — again, the lower 50% were discarded.

3. FGResQ* — the lowest 10% of samples were removed.

4. A custom classifier — built based on DReX code, this classifier distinguishes between images with screentones and those without. All images identified as containing screentones were removed.

FGResQ* was adapted because its original preprocessing is not well-suited for our case: we use 768×768 images, and downscaling them to 224×224 (as in the original setup) causes the model to ignore small defects such as noise. Therefore, we split images into 224×224 tiles and took the minimum score across tiles.

Finally, we used DINOv3 to convert all images into vector embeddings and removed duplicates by filtering out vectors with 90% similarity.

Who are the source data producers?

The original data was created by the wonderful artists at Pixiv. P.S. If anyone finds their data in the dataset and objects to its use, I will delete it immediately.

Dataset Card Contact

Gmail: ab5447612@gmail.com