Aprofundim en el connector de neteja ràpida d'esbós per al Krita

Publicació anterior | Divendres, 20 de desembre de 2024 | Temps de lectura: 13 minuts | Publicació següent

Connector de neteja ràpida d'esbós

Introducció

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

A la secció següent hi ha alguns exemples de casos d'ús en la vida real i els resultats del connector. Els resultats varien, però es pot utilitzar per a extreure esbossos de llapis febles de fotos, neteja de línies i entintat de còmics.

Pel que fa al model utilitzat a l'eina, el vam entrenar nosaltres mateixos. Totes les dades del conjunt de dades són donades per persones que ens van enviar les seves imatges i van acordar aquest cas d'ús específic. No hem utilitzat cap altra dada. A més, quan utilitzeu el connector, fa el procés en local a la vostra màquina, no requereix cap connexió a Internet, no es connecta a cap servidor, i tampoc es requereix cap compte. Actualment només funciona al Windows i Linux, però també treballarem per a fer-ho disponible al MacOS.

Casos d'ús

Fa una mitjana de les línies en una línia i crea línies negres fortes, però el resultat final pot ser difuminat o desigual. Tanmateix, en molts casos, encara funciona millor que utilitzar un filtre de Nivells (per exemple en l'extracció de l'esbós a llapis). Pot ser una bona idea utilitzar el filtre Nivells després d'utilitzar el connector per a reduir el difuminat. Atès que el connector funciona millor amb llenç blanc i línies gris-negres, en el cas d'esbossos a llapis fotografiats o línies molt fines d'esbós, podria ser una bona idea utilitzar Nivells també abans de fer servir el connector.

Extracció de l'esbós a llapis fotografiat

Aquest és el resultat del procediment estàndard d'utilitzar el filtre Nivells en un esbós per a extreure les línies (el que resulta en una part de la imatge que rep ombra):

sketch_girl_original_procedure_comparison_small

sketch_girl_original_procedure_comparison_small1843×1209 165 kB

L'esbós l'ha dibuixat Tiar (enllaç al perfil de KA)

Aquest és el procediment que utilitza el connector amb SketchyModel (Nivells → connector → Nivells):

sketch_girl_new_procedure_comparison_small

sketch_girl_new_procedure_comparison_small1843×2419 267 kB

Comparació (per a línies negres):

sketch_girl_procedures_comparison_small

sketch_girl_procedures_comparison_small1920×1260 215 kB

Un altre resultat possible és quedar-se al connector sense forçar línies negres utilitzant Nivells, el qual resulta en un aspecte més agradable i més de llapis mentre es manté la part inferior de la pàgina encara en blanc:

sketch_girl_after_plugin_small

sketch_girl_after_plugin_small1536×2016 161 kB

Entintat semblant a un llibre de còmic


Imatge d'un home feta per BeARToys

Aquí a les imatges de dalt es pot veure l'estil d'entintat del còmic. El resultat, que és una mica difuminat en comparació amb l'original, es pot millorar encara més mitjançant l'ús d'un filtre d'Agudització. El drac l'ha esbossat David Revoy (CC-BY 4.0).

Neteja de línies

Exemples d'esbossos que he fet i el resultat del connector, mostrant els punts forts i febles del connector. Totes les imatges de sota es van fer amb l'SketchyModel.

flower_001

flower_0011209×739 46.5 kB

flower_001_detail

flower_001_detail681×456 22.1 kB

portrait_man_portrait_2_comparison_2_small

portrait_man_portrait_2_comparison_2_small1305×505 139 kB

portrait_man_portrait_2_detail

portrait_man_portrait_2_detail646×1023 26.6 kB

Totes les imatges de dalt les ha pintat Tiar (enllaç al perfil de KA)

A les imatges següents, a les escates dels peixos, es pot veure com el model discrimina les línies més fines i millora les línies més fortes, fent que les escates siguin més pronunciades. En teoria es podria fer amb el filtre Nivells, però en la pràctica els resultats serien pitjors, perquè el model té en compte la força local de la línia.


fish_square_sketchy_comparison_small1920×968 156 kB

Imatge del peix feta per Christine Garner (enllaç a la cartera)

Com utilitzar-lo al Krita

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

  1. Integrar en el Krita:
    1. Al Windows:
      1. En un paquet: baixada del Krita 5.3.0-prealpha amb el connector de neteja ràpida d'esbós 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. Baixada de la versió portable del Krita 5.2.6 (o la versió similar - encara hauria de funcionar)
        2. Baixeu aquí per separat el connector de neteja ràpida d'esbós: https://download.kde.org/stable/krita/FastSketchPlugin-1.0.2/FastSketchPlugin1.0.2.zip
        3. Descomprimiu el fitxer a la carpeta krita-5.2.6/ (mantenint l'estructura de carpetes).
        4. A continuació, aneu a Configuració → Configura el Krita → Gestor de connectors Python, activeu el connector de neteja ràpida de l'esbós i reinicieu el Krita.
    2. Al Linux:
      1. Baixada de la 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 controladors de NPU si teniu una NPU al dispositiu (pràcticament només és necessari al Linux, si teniu una CPU d'Intel molt nova): Configuracions per a les NPU Intel® amb OpenVINO™ — Documentació d'OpenVINO™ (nota: encara podeu executar el connector a la CPU o GPU, no requereix una NPU)
  3. Execució del connector:
    1. Obriu o creeu un llenç blanc amb traços en gris blanc (cal tenir en compte que el connector prendrà la projecció actual del llenç, no la capa actual).
    2. Aneu a Eines → Neteja ràpida d'esbós
    3. Seleccioneu el model. Les opcions avançades se seleccionaran automàticament.
    4. Espereu fins que acabi el processament (llavors el diàleg es tancarà automàticament).
    5. Vegeu que 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 les línies que voleu mantenir en el resultat són relativament fosques (sigui una mica gris fosc o negre; el gris clar podria donar com a resultat moltes línies perdudes). Pot ser una bona idea utilitzar un filtre com Nivells abans.

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

Base de ciència i tecnologia

Requisits únics

El primer requisit únic era que havia de funcionar sobre llenços de totes les mides. Això significava que la xarxa no podia tenir capes lineals denses/plenes o densament connectades que són molt habituals en la majoria de les xarxes neuronals de processament d'imatges (que requereixen una entrada d'una mida específica i produiran resultats diferents per al mateix píxel depenent de la seva ubicació), només convolucions o capes d'agrupació o similars que produeixin els mateixos resultats per a cada píxel del llenç, independentment de la ubicació. Afortunadament, el article de Simo Sierra publicat el 2016 va descriure una xarxa així.

Un altre repte era que realment no podíem utilitzar el model que van crear, ja que no era compatible amb la llicència del Krita, i ni tan sols podíem utilitzar realment el tipus de model exacte que van descriure, perquè un d'aquests fitxers del model seria gairebé tan gran com el Krita, i l'entrenament trigaria molt temps. Necessitàvem alguna cosa que funcionés igual de bé o millor, però prou petit perquè es pogués afegir al Krita sense fer-lo el doble de gran. (En teoria, podríem fer com altres empreses i fer que el processament es faci en algun tipus de servidor, però això no era el que volíem. I fins i tot si resolgués alguns dels problemes, aportaria molts dels seus propis grans reptes. A més, volíem que els usuaris el poguessin utilitzar localment sense dependre dels nostres servidors i d'internet). A més, el model havia de ser raonablement ràpid i també modest pel que fa al consum de RAM/VRAM.

A més, no teníem cap conjunt de dades que poguéssim utilitzar. Simo Sierra va utilitzar un conjunt de dades, on les imatges esperades es dibuixaven utilitzant una amplada de línia constant i transparència, el que significava que els resultats de l'entrenament també tenien aquestes qualitats. Volíem una cosa que es veiés una mica més dibuixat a mà, amb línies d'amplada variable o extrems semitransparents a les línies, de manera que el nostre conjunt de dades havia de contenir aquest tipus d'imatges. Com que no érem conscients de cap conjunt de dades que coincidís amb els nostres requisits pel que fa a la llicència i el procés de recopilació de dades, hem demanat ajuda a la nostra pròpia comunitat, aquí podeu llegir el fil del Krita: https://krita-artists.org/t/call-for-donation-of-artworks-for-the-fast-line-art-project/96401.

L'enllaç al nostre conjunt de dades complet es pot trobar a continuació a l'apartat 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 del Python: Pillow, Numpy, PyTorch i Openvino

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

Ús de la NPU per a la inferència


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

D'altra banda, la introducció de les NPU afegeix un repte: els únics models que es poden executar en una NPU són models estàtics, el que significa que la mida d'entrada es coneix en el moment de desar el model al fitxer. Per a resoldre això, el connector primer talla el llenç en parts més petites d'una mida especificada (que depèn del fitxer de model), i després procedeix a processar-les totes i finalment cosir els resultats junts. Per a evitar defectes en les zones al costat de la costura, totes les parts es tallen amb una mica de marge i el marge es retalla més tard.

Com entrenar el vostre model propi

Per a entrenar el vostre propi model, necessitareu algunes habilitats tècniques, parells d'imatges (entrada i sortida esperada) i un ordinador potent. És possible que també necessiteu molt espai al disc dur, encara que podeu eliminar models antics innecessaris si comenceu a tenir problemes amb la manca d'espai.

Controladors i preparació

Haureu d'instal·lar el Python3 i els paquets següents: Pillow, openvino, numpy, torch. Per a la quantificació del model també necessitareu nncf i sklearn. Si manca alguna cosa, es queixarà, així que també cal instal·lar els paquets que s'esmentin.

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

A més, si voleu utilitzar iGPU per a l'entrenament (que encara podria ser significativament més ràpid que a la CPU), probablement necessitareu utilitzar alguna cosa com IPEX que permet al PyTorch utilitzar un dispositiu «XPU», que és el vostre iGPU. No s'ha provat o recomanat, ja que personalment no he pogut utilitzar-lo perquè la meva versió del Python era més alta del que espera la instrucció, però la instrucció és aquí: https://pytorch-extension.intel.com/installation?platform=gpu&version=v2.5.10%2Bxpu .
La comprovació de sanejament per a 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 funcioni a la vostra màquina, encara necessitareu editar els scripts d'entrenament perquè puguin utilitzar-lo: https://intel.github.io/intel-extension-for-pytorch/xpu/latest/tutorials/getting_started.html (probablement només haureu d'afegir aquesta línia:
import intel_extension_for_pytorch as ipex
a la part superior de l'script, just a sota d'«import torch», i utilitzeu «xpu» com a nom de dispositiu quan invoqueu l'script, i hauria de funcionar. Però com he dit, els scripts no s'han provat per això.

Conjunt de dades

Necessitareu algunes imatges per a poder entrenar el model. Les imatges han de ser per parelles, cada parell ha de contenir un esbós (entrada) i una imatge d'art lineal (sortida esperada). A més qualitat del conjunt de dades, millors resultats.

Abans de l'entrenament, és millor si augmenteu les dades: això vol dir que les imatges es giren, s'escalen cap amunt o cap avall, i es reflecteixen. Actualment, el script d'augment de dades també realitza una inversió amb la suposició que l'entrenament en imatges invertides portaria els resultats més ràpid (considerant que el negre significa zero o que no hi ha cap senyal, i ens agradaria que aquest fos el fons, de manera que els models aprenen les línies, no el fons al voltant de les línies).

A continuació s'explica com utilitzar el script d'augment de dades, en la instrucció detallada de la part d'entrenament.

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

Elecció del model i altres paràmetres

Per a resultats ràpids, utilitzeu «tooSmallConv»; si teniu més temps i recursos, el «typicalDeep» podria ser una idea millor. Si teniu accés a una màquina GPU potent, podríeu provar «original» o «originalSmaller», que representen la descripció original del model de l'article SIGGRAPH de Simo-Sierra 2016, i una versió més petita d'aquest.

Utilitza «adadelta» com a optimitzador.

Podeu utilitzar «blackWhite» o «mse» com a funció de pèrdua; «mse» és clàssic, però «blackWhite» pot portar a resultats més ràpids, ja que redueix l'error relatiu a les àrees completament blanques o completament negres (basat en la imatge de sortida esperada).

Entrenament

  1. Cloneu el repositori de https://invent.kde.org/tymond/fast-line-art (a 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.
    • A la carpeta, executeu:
      python3 [repository folder]/spawnExperiment.py --path [camí a la carpeta nova, sigui 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/, tenint en compte que les imatges aparellades a ink/ i sketch/ subcarpetes han de tenir els mateixos noms exactes (per exemple, si teniu sketch.png i ink.png com a dades, heu de posar-ne un a sketch/ com a imatge.png i un altre a tinta/ com a imatge.png per a aparellar-les).
    • Si no teniu un conjunt de dades augmentat existent:
      1. Poseu totes les vostres dades en brut a data/raw/, tenint en compte que les imatges aparellades haurien de tenir els mateixos noms amb prefix afegit ja sigui ink_ o sketch_ (per exemple si teniu imatge_1.png sent la imatge d'esbós i imatge_2.png sent la imatge de tinta, heu d'anomenar-les sketch_imatge.png i ink_imatge.png respectivament.)
      2. Executeu l'script de preparació de dades:
        python3 [carpeta de repositori]/dataPreparer.py -t taskfile.yml
        Això augmentarà les dades al directori RAW perquè l'entrenament tingui més èxit.

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

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

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

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

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

  7. Col·loqueu els fitxers de model .xml i .bin a la carpeta de recursos del Krita (dins de la subcarpeta pykrita/fast_sketch_cleanup) al costat d'altres models per a utilitzar-los al connector.