Aprofundim en el connector «Neteja ràpida de l'esbós» per a Krita

Connector «Neteja ràpida de l'esbós»

Introducció

Vam començar este projecte amb la intenció de proporcionar als usuaris una eina útil per a entintar els esbossos. Es basa en un article de recerca de Simo & Sierra publicat el 2016 i per a funcionar utilitza les xarxes neuronals (ara anomenades senzillament IA). L'eina s'ha desenvolupat en associació amb Intel i encara es considera experimental, però ja es pot utilitzar i veure'n el resultat.

En la secció següent, hi ha alguns exemples de casos d'ús reals i els resultats. Els resultats varien, però el connector es pot utilitzar per a extraure esbossos a llapis tènues des de fotografies, netejar línies i entintar còmics.

Pel que fa al model utilitzat a l'eina, l'entrenem nosaltres mateixos. Totes les dades del conjunt de dades són donades per persones que ens han enviat les seues imatges i han sigut d'acord amb este cas d'ús específic. No hem utilitzat cap altra dada. A més, quan utilitzeu el connector, este processarà localment a la vostra màquina, no requerix cap connexió amb Internet, no es connectarà amb cap servidor i tampoc es requerix cap compte. Actualment només funciona a Windows i Linux, però treballarem perquè també estiga disponible a MacOS.

Casos d'ús

Fa una mitjana de les línies en una de sola línia i crea línies negres fortes, però el resultat final pot estar difuminat o desigual. No obstant açò, en molts casos, seguix funcionant millor que utilitzant un filtre de «Nivells» (per exemple, quan s'extrau l'esbós a llapis). Pot ser una bona idea utilitzar el filtre de «Nivells» després d'utilitzar el connector per a reduir el difuminat. Atés que el connector funciona millor amb un llenç en blanc i línies de color gris fosc, en el cas d'esbossos a llapis fotografiats o de línies d'esbós molt clares, pot ser una bona idea utilitzar també «Nivells» abans d'utilitzar el connector.

Extracció d'un esbós a llapis fotografiat

Este és el resultat del procediment estàndard d'utilitzar el filtre de «Nivells» sobre un esbós per a extraure les línies (el qual resulta en que una part de la imatge rebrà ombra):

Comparació del procediment amb l'esbós original d'una xica a 1843×1209 de 165 KB

L'esbós l'ha realitzat en Tiar (enllaç cap al perfil de KA).

Este és el procediment que se seguix amb el connector «SketchyModel» («Nivells → «connector» → Nivells»):

Comparació del procediment amb l'esbós nou d'una xica a 1843×2419 de 267 KB

Comparació (per a les línies negres):

Comparació del procediment amb l'esbós d'una xica a 1920×1260 de 215 KB

Un altre resultat possible és senzillament parar al connector sense forçar les línies negres utilitzant «Nivells», el qual resultarà en una aparença més agradable i pareixent a un llapis mentre encara es mantindrà en blanc la part inferior de la pàgina:

Esbós d'una xica després del connector a 1536×2016 de 161 KB

Entintat pareixent a un llibre de còmic

Imatge d'un home feta per en BeARToys

A les imatges de dalt es pot veure l'entintat a l'estil dels còmics. El resultat, el qual està una mica difuminat en comparació amb l'original, es pot millorar encara més utilitzant un filtre d'«Agudització». El drac l'ha esbossat en David Revoy (CC-BY 4.0).

Neteja de les línies

Exemples d'esbossos que he fet i el resultat del connector, mostren els punts forts i febles. Totes les imatges de davall s'han realitzat utilitzant el SketchyModel.

Flor 0011 a 209×739 de 46.5 KB

Detall d'una flor 001 a 681×456 de 22.1 KB

Retrat 2 d'un home, comparació 2 a 1305×505 de 139 KB

Retrat 2 d'un home, comparació 2 a 646×1023 de 26.6 KB

Totes les imatges de dalt les ha realitzat en Tiar (enllaç cap al perfil de KA).

A les imatges que apareixen a continuació, a les escates dels peixos, es pot veure com el model discrimina les línies més fines i realça les més fortes, fent que les escates estiguen més pronunciades. En teoria, açò podria fer-se utilitzant el filtre «Nivells», però a la pràctica els resultats serien pitjors, perquè el model té en compte la força local de la línia.

Comparació de l'esbós d'un quadrat amb un peix a 1920×968 de 156 KB

Imatge del peix realitzada per na Christine Garner (enllaç amb la cartera).

Com utilitzar-lo a Krita

Per a utilitzar el connector «Neteja ràpida de l'esbós» a Krita, feu el següent:

1. Prepareu Krita:
   1. En Windows:
      1. En un sol paquet: baixeu Krita 5.3.0-prealpha amb el connector «Neteja ràpida de l'esbós» ja inclòs: https://download.kde.org/unstable/krita/5.3.0-prealpha-fast-sketch/krita-x64-5.3.0-prealpha-cdac9c31.zip
      2. O per separat:
         1. Baixeu la versió portable de Krita 5.2.6 (o una versió similar -hauria de seguir funcionant-).
         2. Baixeu ací per separat el connector «Neteja ràpida de l'esbós»: https://download.kde.org/stable/krita/FastSketchPlugin-1.0.2/FastSketchPlugin1.0.2.zip
         3. Descomprimiu el fitxer a dins de la carpeta krita-5.2.6/ (mantenint l'estructura de les carpetes).
         4. Després, aneu fins a «Configuració → Configura Krita → Gestor de connectors en Python», activeu el connector «Neteja ràpida de l'esbós» i reinicieu Krita.
   2. En Linux:
      1. Baixeu l'AppImage: https://download.kde.org/unstable/krita/5.3.0-prealpha-fast-sketch/krita-5.3.0-prealpha-cdac9c31c9-x86_64.AppImage
2. (Opcional) Instal·leu els controladors de NPU si en teniu una al vostre dispositiu (pràcticament només és necessari a Linux, si teniu una CPU d'Intel molt nova): Configuracions per a les NPU d'Intel® amb OpenVINO™ -Documentació d'OpenVINO™ (nota: encara podreu executar el connector a la CPU o GPU, no es requerix una NPU).
3. Execució del connector:
   1. Obriu o creeu un llenç en blanc amb els traços en gris i blanc (cal tindre en compte que el connector prendrà la projecció actual del llenç, no la capa actual).
   2. Aneu fins a «Eines → Neteja ràpida de l'esbós».
   3. Seleccioneu el model. Les «Opcions avançades» se seleccionaran de manera automàtica.
   4. Espereu fins que acabe el processament (el diàleg es tancarà automàticament).
   5. Vegeu que s'ha creat una capa nova amb el resultat.

Consells per al processament

Actualment és millor utilitzar el «SketchyModel.xml», en la majoria dels casos funciona significativament millor que el «SmoothModel.xml».

Heu d'assegurar-vos que el fons és força brillant, i que les línies que voleu mantindre en el resultat són relativament fosques (siga una mica gris fosc o negre, el gris clar podria donar com a resultat moltes línies perdudes). Pot ser una bona idea utilitzar abans un filtre com «Nivells».

Després del processament, és possible que vulgueu millorar els resultats amb el filtre «Nivells» o «Aguditza», depenent del resultat.

Tecnologia i ciència darrere d'açò

Requisits únics

El primer requisit únic era que havia de funcionar sobre llenços de totes les mides. Açò significava que la xarxa no podia tindre capes lineals denses/completament o densament connectades que són molt habituals a la majoria de les xarxes neuronals per al processament d'imatges (les quals requerixen una entrada d'una mida específica i produïxen resultats diferents per al mateix píxel segons la seua ubicació), només convolucions, agrupacions o capes similars produïxen els mateixos resultats per a cada píxel del llenç, independentment de la ubicació. Afortunadament, l'article de Simo i Sierra publicat el 2016 descrivia una xarxa exactament així.

Un altre repte era que realment no podíem utilitzar el model que s'havia creat, ja que no era compatible amb la llicència de Krita, i ni tan sols podíem utilitzar el tipus de model exacte que es descrivia, perquè un d'estos fitxers de model seria quasi tan gran com Krita , i l'entrenament portaria molt de temps. Necessitàvem alguna cosa que funcionara igual de bé o millor, però prou xicotet com per a poder-lo afegir a Krita sense que el fes el doble de gran. (En teoria, podríem fer el mateix que altres empreses i fer que el processament es realitzara en algun tipus de servidor, però açò no era el que volíem. I fins i tot si es resolguera algun dels nostres problemes, presentaria molts dels seus propis grans reptes. A més , volíem que els usuaris pogueren utilitzar-lo localment sense dependre dels nostres servidors i Internet). A més, el model havia de ser raonablement ràpid i també modest pel que fa al consum de RAM i VRAM.

A més, no teníem cap conjunt de dades que poguérem utilitzar. Simo & Sierra va utilitzar un conjunt de dades, on les imatges esperades es dibuixaven utilitzant una amplària de línia i una transparència constants, la qual cosa significava que els resultats de l'entrenament també tenien estes qualitats. Volíem una cosa que es veiés una mica més dibuixada a mà, amb amplàries de línia variables o extrems semitransparents, per la qual cosa el nostre conjunt de dades havia de contindre este tipus d'imatges. Com que no hem tingut coneixement de cap conjunt de dades que s'ajuste als nostres requisits quant a la llicència i el procés de recopilació de les dades, varem sol·licitar ajuda a la nostra pròpia comunitat. Ací podeu llegir el fil a Krita-Artists sobre açò: https://krita-artists.org/t/call-for-donation-of-artworks-for-the-fast-line-art-project/96401 .

L'enllaç cap al nostre conjunt de dades complet es troba a continuació a la secció «Conjunt de dades».

Arquitectura del model

Totes les capes principals són convolucionals o desconvolucionals (al final del model). Després de cada capa des/convolucional, excepte l'última, hi ha una capa d'activació ReLu, i després de l'última convolució hi ha una capa d'activació sigmoide.

Paquets utilitzats de Python: Pillow, Numpy, PyTorch i Openvino

Numpy és una biblioteca estàndard per a tot tipus de matrius i operacions avançades amb matrius, i utilitzem Pillow per a llegir imatges i convertir-les en matrius «numpy» i viceversa. Per a l'entrenament, utilitzem PyTorch, mentre que en el connector de Krita utilitzem Openvino per a la inferència (processament a través de la xarxa).

Ús de la NPU per a la inferència

Esta taula mostra el resultat de «benchmark_app», la qual és una eina que es proporciona amb el paquet de Python Openvino d'Intel. Prova el model de forma aïllada amb dades aleatòries. Com podeu veure, la NPU va ser diverses vegades més ràpida que la CPU sobre la mateixa màquina.

D'altra banda, la introducció de la NPU va afegir un repte: els únics models que es poden executar sobre la NPU són els models estàtics, el qual significa que la mida d'entrada es coneix al moment de guardar el model en un fitxer. Per a resoldre açò, el connector primer talla el llenç en parts més xicotetes d'una mida específica (el qual dependrà del fitxer de model), després les processa totes i finalment unix els resultats. Per a evitar defectes a les àrees properes a la unió, totes les parts es retallen amb un marge xicotet que després es retalla.

Com entrenar el vostre propi model

Per a entrenar el vostre propi model, necessitareu algunes habilitats tècniques, parells d'imatges (entrada i eixida esperada) i un ordinador potent. També podríeu necessitar força espai en el disc dur, encara que senzillament es poden eliminar els models antics innecessaris si comenceu a tindre problemes amb la falta d'espai.

Controladors i preparació

Haureu d'instal·lar Python3 i els paquets següents: «pillow», «openvino», «numpy» i «torch». Per a quantificar el model també necessitareu «nncf» i «sklearn». Si falta alguna cosa, es queixarà, de manera que senzillament instal·leu també els paquets que s'esmenten.

Si esteu a Windows, probablement teniu els controladors per a la NPU i GPU dedicada. En Linux, és possible que hagueu d'instal·lar controladors NPU abans de poder-lo utilitzar: https://docs.openvino.ai/2024/get-started/configurations/configurations-intel-npu.html .

A més, si voleu utilitzar iGPU per a l'entrenament (el qual encara pot ser significativament més ràpid que a la CPU), probablement necessitareu utilitzar alguna cosa com IPEX que permeta a PyTorch utilitzar un dispositiu «XPU», el qual senzillament és la vostra iGPU. No s'ha provat ni es recomana, ja que personalment no he pogut utilitzar-lo perquè la meua versió de Python era més alta de la que espera la instrucció, però la instrucció es troba ací: https://pytorch-extension.intel.com/installation?platform=gpu&version=v2.5.10%2Bxpu .
La comprovació de sanejament de la instal·lació és la següent:
python3 -c "import torch; import intel_extension_for_pytorch as ipex; print(f'Packages versions:'); print(f'Torch version: {torch.__version__}'); print(f'IPEX version: {ipex.__version__}'); print(f'Devices:'); print(f'Torch XPU device count: {torch.xpu.device_count()}'); [print(f'[Device {i}]: {torch.xpu.get_device_properties(i)}') for i in range(torch.xpu.device_count())];"
Hauria de mostrar més de 0 dispositius amb algunes propietats bàsiques.

Si aconseguiu que el dispositiu XPU funcione a la vostra màquina, encara necessitareu editar els scripts d'entrenament perquè el puguen utilitzar: https://intel.github.io/intel-extension-for-pytorch/xpu/latest/tutorials/getting_started.html (probablement només haureu d'afegir esta línia:
import intel_extension_for_pytorch as ipex
a la part superior del script, just davall «import torch», i utilitzar «xpu» com el nom de dispositiu quan invoqueu l'script, i hauria de funcionar. Però com he dit, els scripts no s'han provat per a açò.

Conjunt de dades

Necessitareu algunes imatges per a poder entrenar el vostre model. Les imatges hauran d'estar en parells, cada parell haurà de contindre un esbós (entrada) i una imatge d'art lineal (eixida esperada). Com millor siga la qualitat del conjunt de dades, millors seran els resultats.

Abans de l'entrenament, és millor si augmenteu les dades: açò vol dir que les imatges es giren, s'escalen cap amunt o cap avall i es reflectixen. Actualment, l'script d'augment de dades també realitza una inversió amb la suposició que l'entrenament sobre imatges invertides portaria els resultats més ràpid (tenint en compte que el negre vol dir zero o que no hi ha senyal, i ens agradaria que este fora el fons, de manera que els models aprenguen de les línies, no del fons al voltant d'estes).

A continuació, s'explica com utilitzar l'script d'augment de dades a les instruccions detallades per a la part de l'entrenament.

Este és el conjunt de dades que hem utilitzat (llegiu atentament la llicència si voleu utilitzar-lo): https://files.kde.org/krita/extras/FastSketchCleanupPluginKritaDataset.zip

Elecció del model i altres paràmetres

Per a obtindre resultats ràpids, utilitzeu «tooSmallConv». Si teniu més temps i recursos, potser és millor emprar «typicalDeep». Si teniu accés a una màquina GPU potent, podríeu provar «original» o «originalSmaller», els quals representen la descripció original del model a l'article SIGGRAPH de Simo-Sierra de 2016, i una versió més xicoteta d'este.

Utilitzeu «adadelta» com a optimitzador.

Podeu utilitzar «blackWhite» o «mse» com a funció de pèrdua. «mse» és clàssic, però «blackWhite» pot generar resultats més ràpids ja que reduïx l'error relatiu a les àrees completament blanques o completament negres (segons la imatge d'eixida esperada).

Entrenament

1. Cloneu el repositori https://invent.kde.org/tymond/fast-line-art (a la 33869b6)
   git clone https://invent.kde.org/tymond/fast-line-art.git

2. Després, prepareu la carpeta:

   • Creeu una carpeta nova per a l'entrenament.
   • En la carpeta, executeu:
     python3 [carpeta del repositori]/spawnExperiment.py --path [camí fins a la carpeta nova, siga relatiu o absolut] --note "[la vostra nota personal sobre l'experiment]"

3. Prepareu les dades:

   • Si teniu un conjunt de dades augmentat existent, poseu-ho tot a «data/training/» i «data/verify/», cal tindre en compte que les imatges aparellades a les subcarpetes «ink/» i «sketch/» han de tindre exactament els mateixos noms (per exemple, si teniu «sketch.png» i «ink.png» com a dades, n'haureu de posar una a «sketch/» com a «picture.png» i una altra a «ink/» com a «picture.png» per a aparellar-les).
   • Si no teniu un conjunt de dades augmentat existent:
     1. Poseu totes les vostres dades sense processar a «data/raw/», caldrà tindre en compte que les imatges aparellades hauran de tindre exactament els mateixos noms amb el prefix annexat «ink_» o «sketch_» (per exemple, si teniu «picture_1.png» com la imatge de l'esbós i «picture_2.png» com la imatge de tinta, les haureu d'anomenar «sketch_picture.png» i «ink_picture.png» respectivament).
     2. Executeu l'script de preparació de les dades:
        python3 [carpeta del repositori]/dataPreparer.py -t taskfile.yml
        Açò augmentarà les dades al directori sense processar perquè l'entrenament siga més exitós.

4. Editeu el fitxer «taskfile.yml» al vostre gust. Les parts més importants que voldreu canviar són:

   • «model type»: nom en codi per al tipus de model, utilitzeu «tinyTinier», «tooSmallConv», «typicalDeep» o «tinyNarrowerShallow».
   • «optimitzer»: el tipus d'optimitzador, utilitzeu «adadelta» o «sgd».
   • «learning rate»: taxa d'aprenentatge per a «sgd», si s'utilitza.
   • «loss function»: nom en codi per a la funció de pèrdua, utilitzeu «mse» per a l'error quadràtic mitjà o «blackWhite» per a una funció de pèrdua personalitzada basada en «mse», però una mica més xicoteta per als píxels on el valor de píxel de la imatge de destinació és proper a 0,5.

5. Executeu el codi d'entrenament:
   python3 [carpeta del repositori]/train.py -t taskfile.yml -d "cpu"

   En Linux, si voleu que s'execute en segon pla, afegiu «&» al final. Si s'executa en primer pla, podreu fer una pausa a l'entrenament senzillament prement «Ctrl+C», i si s'executa en segon pla, busqueu un ID de procés (utilitzant l'ordre «jobs -l» o «ps aux | grep train.py»”, el primer número seria l'ID del procés) i mateu-lo utilitzant l'ordre «kill [ID del procés]». Els resultats seguiran estant a la carpeta i podreu reprendre l'entrenament utilitzant la mateixa ordre.

6. Convertiu el model en un model «openvino»:
   python3 [repository folder]/modelConverter.py -s [mida de l'entrada, recomanem 256] -t [nom del model d'entrada, a partir de «pytorch»] -o [nom de model «openvino», cal que acabe amb «.xml»]

7. Poseu els fitxers de model «.xml» i «.bin» a la carpeta de recursos de Krita (a dins de la subcarpeta «pykrita/fast_sketch_cleanup») juntament amb els altres models per a utilitzar-los al connector.