Téléchargement de YuzuMarker.FontDetection - Téléchargement du code source YuzuMarker.FontDetection

titre	emoji	couleur	colort	SDK	app_port
Yuzumarker.fontdection	?	bleu	jaune	docker	7860

Yuzumarker.fontdection

Tout premier modèle de reconnaissance des polices CJK (chinois, japonais, coréen)

Nouvelles

[Mise à jour 2023/05/05] Projet recommandé sur ruanyifeng.com (阮一峰的网络日志 - 科技爱好者周刊): https://www.ruanyifeng.com/blog/2023/05/weekly-issue-253.html
[MISE À JOUR 2023/11/18] Le jeu de données est maintenant OpenSource! Téléchargez sur Huggingface à partir d'ici: https://huggingface.co/datasets/gyrojeff/yuzumarker.fontdetection/tree/master

Génération d'ensemble de données de police de texte de scène

Ce référentiel contient également des données pour générer automatiquement un ensemble de données d'images de texte de scène avec différentes polices. L'ensemble de données est généré à l'aide du CJK Font Pack par VCB-Studio et des milliers d'images d'arrière-plan de Pixiv.net.

Les données PIXIV ne seront pas partagées car elles sont simplement grattées au hasard. Vous pouvez préparer votre propre ensemble de données d'arrière-plan qui conviendrait à votre distribution de données comme vous le souhaitez.

Pour le corpus de texte,

Le chinois est généré au hasard à partir de 3500 caractères chinois communs.
Le japonais est généré au hasard à partir d'une liste de paroles de https://www.uta-net.com.
Le coréen est généré au hasard à partir de son alphabet.

Tous les texte sont également mélangés avec du texte anglais pour simuler les données du monde réel.

Procédure pas à pas de préparation des données

Téléchargez le pack de polices CJK et extrayez-le dans le répertoire dataset/fonts .
Préparez les données d'arrière-plan et placez-les dans le répertoire dataset/pixivimages .
Exécutez le script suivant pour nettoyer les noms de fichiers
```
python dataset_filename_preprocess.py
```

Procédure pas à pas de script de génération

Maintenant, la préparation est terminée. La commande suivante peut être utilisée pour générer l'ensemble de données:

python font_ds_generate_script.py 1 1

Notez que la commande est suivie de deux paramètres. Le second est de diviser la tâche en plusieurs partitions, et la première est l'index de la tâche partitionnée à exécuter. Par exemple, si vous souhaitez exécuter la tâche en 4 partitions, vous pouvez exécuter les commandes suivantes en parallèle pour accélérer le processus:

python font_ds_generate_script.py 1 4
python font_ds_generate_script.py 2 4
python font_ds_generate_script.py 3 4
python font_ds_generate_script.py 4 4

L'ensemble de données généré sera enregistré dans le répertoire dataset/font_img .

Notez que batch_generate_script_cmd_32.bat et batch_generate_script_cmd_64.bat sont des scripts par lots pour Windows qui peuvent être utilisés pour générer le jeu de données en parallèle avec 32 partitions et 64 partitions.

Chèque final

Car la tâche peut être terminée de façon inattendue ou délibérément par l'utilisateur. Le script a un mécanisme de mise en cache pour éviter de régénérer la même image.

Dans ce cas, le script pourrait ne pas être en mesure de détecter la corruption dans le cache (peut être causé par la fin lors de l'écriture dans des fichiers) pendant cette tâche, nous fournissons donc également un script vérifiant l'ensemble de données généré et supprimons les images et les étiquettes corrompues.

python font_ds_detect_broken.py

Après avoir exécuté le script, vous voudrez peut-être relancer le script de génération pour remplir les trous des fichiers corrompus supprimés.

(Facultatif) Procédure de génération de cluster Linux

Si vous souhaitez exécuter le script de génération sur les clusters Linux, nous fournissons également le script de configuration d'environnement linux_venv_setup.sh .

La condition préalable est que vous avez un cluster Linux avec python3-venv installé et python3 est disponible dans le chemin.

Pour configurer l'environnement, exécutez la commande suivante:

./linux_venv_setup.sh

Le script créera un environnement virtuel dans le répertoire venv et installera tous les packages requis. Le script est requis dans la plupart des cas, car le script installe également libraqm ce qui est requis pour le rendu de texte de PIL et n'est souvent pas installé par défaut dans la plupart des distributions de serveur Linux.

Une fois l'environnement configuré, vous pouvez compiler un planificateur de tâches pour déployer la tâche de génération en parallèle.

L'idée principale est similaire à l'utilisation directe du script, sauf que nous acceptons ici trois paramètres,

TOTAL_MISSION : le nombre total de partitions de la tâche
MIN_MISSION : l'indice de partition minimum de la tâche à exécuter
MAX_MISSION : l'indice de partition maximum de la tâche à exécuter

et la commande de compilation est le suivant:

gcc -D MIN_MISSION= < MIN_MISSION > 
    -D MAX_MISSION= < MAX_MISSION > 
    -D TOTAL_MISSION= < TOTAL_MISSION > 
    batch_generate_script_linux.c 
    -o < object-file-name > .out

Par exemple, si vous souhaitez exécuter la tâche en 64 partitions et que vous souhaitez renverser le travail sur 4 machines, vous pouvez compiler la commande suivante sur chaque machine:

 # Machine 1
gcc -D MIN_MISSION=1 
    -D MAX_MISSION=16 
    -D TOTAL_MISSION=64 
    batch_generate_script_linux.c 
    -o mission-1-16.out
# Machine 2
gcc -D MIN_MISSION=17 
    -D MAX_MISSION=32 
    -D TOTAL_MISSION=64 
    batch_generate_script_linux.c 
    -o mission-17-32.out
# Machine 3
gcc -D MIN_MISSION=33 
    -D MAX_MISSION=48 
    -D TOTAL_MISSION=64 
    batch_generate_script_linux.c 
    -o mission-33-48.out
# Machine 4
gcc -D MIN_MISSION=49 
    -D MAX_MISSION=64 
    -D TOTAL_MISSION=64 
    batch_generate_script_linux.c 
    -o mission-49-64.out

Ensuite, vous pouvez exécuter le fichier d'objet compilé sur chaque machine pour démarrer la tâche de génération.

./mission-1-16.out # Machine 1
./mission-17-32.out # Machine 2
./mission-33-48.out # Machine 3
./mission-49-64.out # Machine 4

Il existe également un autre script d'assistance pour vérifier la progression de la tâche de génération. Il peut être utilisé comme suivant:

python font_ds_stat.py

Informations diverses de l'ensemble de données

La génération est liée au processeur et la vitesse de génération dépend fortement des performances du CPU. En effet, le travail lui-même est un problème d'ingénierie.

Certaines polices sont problématiques pendant le processus de génération. Le script a une liste d'exclusion manuelle dans config/fonts.yml et prend également en charge la détection de police non qualifiée à la volée. Le script sautera automatiquement les polices problématiques et les enregistrera pour une formation future du modèle.

Formation modèle

Ayez l'ensemble de données prêt dans le répertoire dataset , vous pouvez commencer à former le modèle. Notez que vous pouvez avoir plus d'un dossier d'ensemble de données, et le script les fusionnera automatiquement tant que vous fournissez le chemin d'accès au dossier par arguments de ligne de commande.

$ python train.py -h
usage: train.py [-h] [-d [DEVICES ...]] [-b SINGLE_BATCH_SIZE] [-c CHECKPOINT] [-m {resnet18,resnet34,resnet50,resnet101,deepfont}] [-p] [-i] [-a {v1,v2,v3}]
                [-l LR] [-s [DATASETS ...]] [-n MODEL_NAME] [-f] [-z SIZE] [-t {medium,high,heighest}] [-r]

optional arguments:
  -h , --help            show this help message and exit
  -d [DEVICES ...], --devices [DEVICES ...]
                        GPU devices to use (default: [0])
  -b SINGLE_BATCH_SIZE, --single-batch-size SINGLE_BATCH_SIZE
                        Batch size of single device (default: 64)
  -c CHECKPOINT, --checkpoint CHECKPOINT
                        Trainer checkpoint path (default: None)
  -m {resnet18,resnet34,resnet50,resnet101,deepfont}, --model {resnet18,resnet34,resnet50,resnet101,deepfont}
                        Model to use (default: resnet18)
  -p , --pretrained      Use pretrained model for ResNet (default: False)
  -i, --crop-roi-bbox   Crop ROI bounding box (default: False)
  -a {v1,v2,v3}, --augmentation {v1,v2,v3}
                        Augmentation strategy to use (default: None)
  -l LR, --lr LR        Learning rate (default: 0.0001)
  -s [DATASETS ...], --datasets [DATASETS ...]
                        Datasets paths, seperated by space (default: [ ' ./dataset/font_img ' ])
  -n MODEL_NAME, --model-name MODEL_NAME
                        Model name (default: current tag)
  -f , --font-classification-only
                        Font classification only (default: False)
  -z SIZE, --size SIZE  Model feature image input size (default: 512)
  -t {medium,high,heighest}, --tensor-core {medium,high,heighest}
                        Tensor core precision (default: high)
  -r , --preserve-aspect-ratio-by-random-crop
                        Preserve aspect ratio (default: False)

Résultats de l'expérience de classification des polices

Sur notre ensemble de données synthétisé,

Colonne vertébrale	Data août	Prénommagé	Recadrer Texte Bbox	Préserver Aspect Rapport	Sortir Norme	Taille d'entrée	Hyper Paramot	Exciter	Commettre	Ensemble de données	Précision
De profondeur	✔️ *		✅		Sigmoïde	105x105	I ¹	[Je ne peux pas converger]	665559f	I ⁵	bfloat16_3x
De profondeur	✔️ *		✅		Sigmoïde	105x105	Iv ⁴	[Je ne peux pas converger]	665559f	je	bfloat16_3x
RESNET-18					Sigmoïde	512x512	je	18,58%	5C43F60	je	float32
RESNET-18					Sigmoïde	512x512	II ²	14,39%	5A85FD3	je	bfloat16_3x
RESNET-18					Tanh	512x512	Ii	16,24%	FF82FE6	je	bfloat16_3x
RESNET-18	✅ * ⁸				Tanh	512x512	Ii	27,71%	A976004	je	bfloat16_3x
RESNET-18	✅ *				Tanh	512x512	je	29,95%	8364103	je	bfloat16_3x
RESNET-18	✅ *				Sigmoïde	512x512	je	29,37% [arrêt précoce]	8d2e833	je	bfloat16_3x
RESNET-18	✅ *				Sigmoïde	416x416	je	[Tendance inférieure]	D5A3215	je	bfloat16_3x
RESNET-18	✅ *				Sigmoïde	320x320	je	[Tendance inférieure]	AFCDD80	je	bfloat16_3x
RESNET-18	✅ *				Sigmoïde	224x224	je	[Tendance inférieure]	8b9de80	je	bfloat16_3x
RESNET-34	✅ *				Sigmoïde	512x512	je	32,03%	912d566	je	bfloat16_3x
Resnet-50	✅ *				Sigmoïde	512x512	je	34,21%	E980B66	je	bfloat16_3x
RESNET-18	✅ *	✅			Sigmoïde	512x512	je	31,24%	416c7bb	je	bfloat16_3x
RESNET-18	✅ *	✅	✅		Sigmoïde	512x512	je	34,69%	855e240	je	bfloat16_3x
RESNET-18	✔️ * ⁹	✅	✅		Sigmoïde	512x512	je	38,32%	1750035	je	bfloat16_3x
RESNET-18	✔️ *	✅	✅		Sigmoïde	512x512	Iii ³	38,87%	0693434	je	bfloat16_3x
Resnet-50	✔️ *	✅	✅		Sigmoïde	512x512	III	48,99%	BC0F7FC	II ⁶	bfloat16_3x
Resnet-50	✔️	✅	✅		Sigmoïde	512x512	III	48,45%	0f071a5	Ii	bfloat16_3x
Resnet-50	✔️	✅	✅	✅ ¹¹	Sigmoïde	512x512	III	46,12%	0f071a5	Ii	bfloat16
Resnet-50	❕ ¹⁰	✅	✅		Sigmoïde	512x512	III	43,86%	0f071a5	Ii	bfloat16
Resnet-50	❕	✅	✅	✅	Sigmoïde	512x512	III	41,35%	0f071a5	Ii	bfloat16

* Bogue dans l'implémentation
¹ learning rate = 0.0001, lambda = (2, 0.5, 1)
² learning rate = 0.00005, lambda = (4, 0.5, 1)
³ learning rate = 0.001, lambda = (2, 0.5, 1)
⁴ learning rate = 0.01, lambda = (2, 0.5, 1)
⁵ version initiale de l'ensemble de données synthétisé
⁶ ensemble de données synthétisé doublé (2x)
⁷ quadruples ensemble de données synthétisées (4x)
⁸ Augmentation des données V1: Jitter de couleur + récolte aléatoire [81% -100%]
⁹ Augmentation des données V2: Color Jitter + Crométique aléatoire [30% -130%] + Blur gaussien aléatoire + bruit gaussien aléatoire + rotation aléatoire [-15 °, 15 °]
¹⁰ Augmentation des données V3: Jitter de couleur + récolte aléatoire [30% -130%] + Blur gaussien aléatoire + bruit gaussien aléatoire + rotation aléatoire [-15 °, 15 °] + Flip horizontal aléatoire + échantillon de descente aléatoire [1, 2]
¹¹ Rapport d'aspect de la préserve par culture aléatoire

Modèles pré-entraînés

Disponible sur: https://huggingface.co/gyrojeff/yuzumarker.fontdetection/tree/main

Notez que depuis que j'ai tout formé sur Pytorch 2.0 avec torch.compile , si vous souhaitez utiliser le modèle pré-entraîné, vous auriez besoin d'installer Pytorch 2.0 et de le compiler avec torch.compile comme dans demo.py

Déploiement de démonstration (méthode 1)

Pour déployer la démo, vous auriez besoin soit de l'ensemble de données de police sous ./dataset/fonts ou d'un fichier de cache indiquant des polices de modèle appelé font_demo_cache.bin . Cela sera publié plus tard sous forme de ressource.

Pour déployer, exécutez d'abord le script suivant pour générer l'image de police de démonstration (si vous avez l'ensemble de données FONTS):

python generate_font_sample_image.py

Ensuite, exécutez le script suivant pour démarrer le serveur de démonstration:

$ python demo.py -h
usage: demo.py [-h] [-d DEVICE] [-c CHECKPOINT] [-m {resnet18,resnet34,resnet50,resnet101,deepfont}] [-f] [-z SIZE] [-s] [-p PORT] [-a ADDRESS]

optional arguments:
  -h, --help            show this help message and exit
  -d DEVICE, --device DEVICE
                        GPU devices to use (default: 0), -1 for CPU
  -c CHECKPOINT, --checkpoint CHECKPOINT
                        Trainer checkpoint path (default: None). Use link as huggingface:// < user > / < repo > / < file > for huggingface.co models, currently only supports model file in the root
                        directory.
  -m {resnet18,resnet34,resnet50,resnet101,deepfont}, --model {resnet18,resnet34,resnet50,resnet101,deepfont}
                        Model to use (default: resnet18)
  -f, --font-classification-only
                        Font classification only (default: False)
  -z SIZE, --size SIZE  Model feature image input size (default: 512)
  -s, --share           Get public link via Gradio (default: False)
  -p PORT, --port PORT  Port to use for Gradio (default: 7860)
  -a ADDRESS, --address ADDRESS
                        Address to use for Gradio (default: 127.0.0.1)

Déploiement de démonstration (méthode 2)

Si Docker est disponible sur votre machine, vous pouvez déployer directement par Docker comme je l'ai fait pour HuggingFace Space.

Vous pouvez suivre l'argument de la ligne de commande prévu dans la dernière section pour modifier la dernière ligne du Dockerfile pour accueillir vos besoins.

Construisez l'image Docker:

docker build -t yuzumarker.fontdetection .

Exécutez l'image Docker:

docker run -it -p 7860:7860 yuzumarker.fontdetection

Démo en ligne

Le projet est également déployé sur l'espace de câlins: https://huggingface.co/spaces/gyrojeff/yuzumarker.fontdetection

Travaux et ressources connexes

Deepfont: Identifiez votre police à partir d'une image: https://arxiv.org/abs/1507.03196
Identification et recommandations de la police: https://mangahelpers.com/forum/threads/font-entification-and-recommendations.35672/
Détection de texte sans contrainte dans les mangas: un nouvel ensemble de données et la ligne de base: https://arxiv.org/pdf/2009.04042.pdf
SWORDNET: Réseau de reconnaissance de style de police de caractère chinois: https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=9682683

Histoire des étoiles

Citation

Si vous utilisez ce travail, veuillez citer de la manière suivante. Merci.

 @misc{qin2023yuzumarkerfont,
  author       = {Haoyun Qin},
  title        = {YuzuMarker.FontDetection},
  year         = {2023},
  url          = {https://github.com/JeffersonQin/YuzuMarker.FontDetection},
  note         = {GitHub repository}
}

Développer