Graven in de plug-in Snelle schets opschonen voor Krita

Vorige post | vrijdag, 20 december 2024 | Leestijd: 13 minuten | Volgende post

Plug-in Snelle schets opschonen

Inleiding

We zijn dit project gestart met de bedoeling gebruikers te voorzien van een hulpmiddel dat helpt bij het inkten van schetsen. Het is gebaseerd op een onderzoeksartikel door Simo & Sierra gepubliceerd in 2016 en het gebruikt neurale netwerken (nu algemeen eenvoudig AI genoemd) om te werken. Het hulpmiddel is ontwikkeld met Intel als partner en het wordt nog steeds als experimenteel beschouwd, maar u kunt het al gebruiken en de resultaten zien.

In de onderstaande sectie zijn enige echte voorbeelden van gebruiksgevallen en de resultaten van de plug-in. De resultaten variëren, maar het kan gebruikt worden voor extraheren van vage potloodschetsen uit foto's, lijnen opschonen en inkten van stripboeken.

Met betrekking tot het model gebruikt in het hulpmiddel, we hebben het zelf getraind. Alle gegevens in de dataset zijn gedoneerd door mensen die hun plaatjes zelf naar ons hebben gestuurd en toegestemd in dit specifieke gebruiksgeval. We hebben het geen enkele ander gegevens gebruikt. Bovendien, wanneer u de plug-in gebruikt, het werkt lokaal op uw machine, het vereist geen internetverbinding, maakt geen verbinding met een server en er is ook geen account vereist. Op dit moment werkt het alleen op Windows en Linux, maar we zullen er aan werken om het ook beschikbaar te maken op MacOS.

Voorbeelden van gebruik

Het middelt de lijnen in één lijn en maakt dikke zwarte lijnen, maar het eindresultaat kan wazig of ongelijk zijn. In veel gevallen echter werkt het nog steeds beter dan gewoon een Niveausfilter te gebruiken (bijvoorbeeld bij extraheren van de potloodschets). Het kan een goed idee zijn om Niveausfilter te gebruiken na gebruik van de plug-in om de wazigheid te verminderen. Omdat de plug-in het beste werkt met een wit werkveld en grijs-zwarte lijnen, in het geval van gefotografeerde potloodschetsen of erg licht geschetste lijnen, kan het een goed idee zijn om Niveaus ook te gebruiken voor het gebruik van de plug-in.

Extraheren van gefotografeerde potloodschets

Dit is het resultaat van de standaard procedure van gebruik van Niveaufilter op een schets om de lijnen te extraheren (wat resulteert in een gedeelte van de afbeelding die schaduw krijgt):

sketch_girl_original_procedure_comparison_small

sketch_girl_original_procedure_comparison_small1843×1209 165 KB

De schets was getekend door Tiar (link to KA profile)

Dit is de procedure met gebruik van de plug-in met SketchyModel (Niveaus → plugin → Niveaus):

sketch_girl_new_procedure_comparison_small

sketch_girl_new_procedure_comparison_small1843×2419 267 KB

Vergelijking (voor zwarte lijnen):

sketch_girl_procedures_comparison_small

sketch_girl_procedures_comparison_small1920×1260 215 KB

Een ander mogelijk resultaat is om gewoon te stoppen bij de plug-in zonder zwarte lijnen af te dwingen met gebruik van Niveaus, wat resulteert in een mooiere, meer potloodachtig uiterlijk en het lagere deel van de pagina nog steeds blank:

sketch_girl_after_plugin_small

sketch_girl_after_plugin_small1536×2016 161 KB

Stripboekachtig inkten


Plaatje van een man gemaakt door BeARToys

Hier in de bovenstaande plaatjes kunt u de stripboekstijl van inkten zien. Het resultaat, dat een beetje waziger is vergeleken met het origineel, kan verder verbeterd worden door een verscherpingsfilter. De draak is geschetst door David Revoy (CC-BY 4.0).

Lijnen worden opgeschoond

Voorbeelden van schetsen die ik maakte en het resultaat van de plug-in, die de sterke en zwakke punten van de plug-in laat zien. Alle onderstaande afbeeldingen zijn gemaakt met het 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

Alle bovenstaande plaatjes geschilderd door Tiar (koppeling naar KA profielen)

Op de onderstaande plaatjes, op de schubben van de vis, kunt u zien hoe het model lichtere lijnen discrimineert en dikkere lijnen verhoogt, waarmee de schubben meer uitgesproken worden. In theorie zou u dat kunnen doen met het Niveausfilter, maar in de praktijk zou het resultaat slechter kunnen zijn, omdat het model rekening houdt met de lokale dikte van de lijn.


fish_square_sketchy_comparison_small1920×968 156 KB

Plaatje van de vis gemaakt door Christine Garner (link to portfolio)

Hoe het in Krita te gebruiken

Om de plug-in Snelle schets opschonen in Krita te gebruiken, doe het volgende:

  1. Krita voorbereiden:
    1. Op Windows:
      1. Ofwel in een pakket: download Krita 5.3.0-prealpha met de plug-in Snelle schets opschonen al meegeleverd: https://download.kde.org/unstable/krita/5.3.0-prealpha-fast-sketch/krita-x64-5.3.0-prealpha-cdac9c31.zip
      2. Of afzonderlijk:
        1. Download de overdraagbare versie van Krita 5.2.6 (of gelijkwaardige versie - zou nog steeds moeten werken)
        2. Download gescheiden de plug-in Snelle schets opschonen hier: https://download.kde.org/stable/krita/FastSketchPlugin-1.0.2/FastSketchPlugin1.0.2.zip
        3. Unzip het bestand in map krita-5.2.6/ (met behoud van de mapstructuur).
        4. Ga daarna naar Instellingen → Krita configureren → Plug-inbeheerder van Python, plug-in Snelle schets opschonen en Krita opnieuw starten.
    2. Op Linux:
      1. Download de toepassingsimage: https://download.kde.org/unstable/krita/5.3.0-prealpha-fast-sketch/krita-5.3.0-prealpha-cdac9c31c9-x86_64.AppImage
  2. (Optioneel) Installeer NPU-apparaatstuurprogramma's als u NPU hebt op uw apparaat (praktisch alleen nodig op Linux, als u een erg nieuwe Intel CPU hebt): Configuraties voor Intel® NPU met OpenVINO™ — OpenVINO™ documentatie (noot: u kunt nog steeds de plug-in op CPU of GPU uitvoeren, het vereist geen NPU)
  3. De plug-in uitvoeren:
    1. Open of maak een wit werkveld met grijs-witte stroken (merk op dat de plug-in de huidige projectie van het werkveld gebruikt, niet de huidige laag).
    2. Ga naar Hulpmiddelen → Snelle schets opschonen
    3. Selecteer het model. Geavanceerde opties zullen automatisch voor u geselecteerd worden.
    4. Wacht totdat het eindigt met verwerken (de dialoog zal dan automatisch sluiten).
    5. Zie dat het een nieuwe laag met het resultaat heeft gemaakt.

Advies voor verwerken

Op dit moment is het beter om gewoon de SketchyModel.xml te gebruiken, in de meeste gevallen werkt het aanzienlijk beter dan de SmoothModel.xml.

U moet er voor zorgen dat de achtergrond behoorlijk helder is en de lijnen die u wilt behouden in het resultaat relatief donker zijn (ofwel ietwat donker grijs of zwart; licht grijs kan resulteren in veel gemiste lijnen). Het kan een goed idee zijn om een filter zoals Niveaus van tevoren te gebruiken.

Na verwerken zou de resultaten willen verbeteren met ofwel filter Niveaus of filter Verscherpen, afhankelijk van uw resultaten.

Technologie & wetenschap erachter

Unieke vereisten

Het eerste unieke vereiste was dat het moet werken op werkvelden van alle groottes. Dat betekent dat het netwerk geen enkele dichte/volle of dicht verbonden lineaire lagen mag hebben die erg algemeen zijn in de meest van de neurale netwerken die afbeeldingen verwerken (wat vereist dat invoer van een specifieke grootte en verschillende resultaten zal produceren voor hetzelfde pixel afhankelijk van zijn locatie), alleen convoluties of pooling of gelijkwaardige lagen die dezelfde resultaten aan het produceren zijn voor elk pixel van het werkveld, ongeacht de locatie. Gelukkig, het paper Simo & Sierra gepubliceerd in 2016 beschrijft een netwerk net als dat.

Een andere uitdaging was dat we niet echt het model dat ze maakten konden gebruiken, omdat het niet compatibel was met de licentie van Krita en we konden zelfs niet echt het exacte modeltype gebruiken dat ze beschreven, omdat een van die modelbestanden bijna net zo groot zou zijn als Krita en de training zou werkelijk lang duren. We hadden iets nodig dat evengoed zou werken indien niet beter, maar klein genoeg dat het toegevoegd kan worden aan Krita zonder het tweemaal zo groot te maken. (In theorie zouden we kunnen doen zoals sommige andere bedrijven en de verwerking laten gebeuren op een soort server, maar dat was niet wat we wilden. En zelfs als het sommige van onze problemen zou oplossen, het zou veel van zijn eigen belangrijke uitdagingen leveren. We wilden ook voor onze gebruikers dat ze in staat zouden zijn het lokaal te gebruiken zonder afhankelijkheid van onze servers en het internet). Bovendien zou het model redelijk snel moeten zijn en ook bescheiden met betrekking tot gebruik van RAM/VRAM.

Bovendien hadden we geen enkele gegevensset die we konden gebruiken. Simo & Sierra gebruikten een gegevensset, waar de verwachte afbeeldingen getekend waren met gebruik van een constante lijnbreedte en transparantie, wat betekent dat de resultaten van de training die kwaliteiten ook zouden moeten hebben. We wilden iets dat er uitzag als een beetje meer getekend met de hand, met variërende lijnbreedten of semi-transparante einden van de lijnen, dus onze gegevensset moest dat soort afbeeldingen hebben. Omdat we niet bekend waren met een gegevenssets die zou overeenkomen met onze eisen met betrekking tot de licentie en het proces van gegevens verzamelen, hebben we onze eigen gemeenschap om hulp gevraagd, hier kunt u de Krita Artists discussie erover lezen: https://krita-artists.org/t/call-for-donation-of-artworks-for-the-fast-line-art-project/96401 .

De koppeling naar onze volledige gegevensset kan onderstaand gevonden worden in de sectie Gegevensset.

Modelarchitectuur

Alle hoofdlagen zijn ofwel convolutioneel of deconvolutioneel (aan het eind van het model). Na elke (de)convolutionele laag behalve de laatste is er een ReLu activatielaag en na de laatste convolutie is er een sigmoid-activatielaag.

Gebruikte Python pakketten: Pillow, Numpy, PyTorch en Openvino

Numpy is een standaard bibliotheek voor alle soorten arrays en geavanceerde array-bewerkingen en we gebruiken Pillow voor het lezen van afbeeldingen en ze converteren in numpy-arrays en terug. Voor training gebruiken we PyTorch, terwijl in de plug-in van Krita we Openvino gebruiken voor gevolgtrekking (verwerken via het netwerk).

NPU gebruiken voor gevolgtrekking


Deze tabel toont het resultaat van benchmark_app, wat een hulpmiddel is dat wordt geleverd met het Python pakket, openvino van Intel. Het test het model in isolatie op willekeurige gegevens. Zoals u kunt zien, was de NPU verschillende keren sneller dan de CPU op dezelfde machine.

Aan de andere kant, introduceren van NPU voegde een uitdaging toe: de enige modellen die kunnen draaien op NPU zijn statische modellen, wat betekent dat de invoergrootte bekend is op het moment van opslaan van het model naar een bestand. Om dat op te lossen, knipt de plug-in het werkveld in kleinere delen van een gespecificeerde grootte (die afhangt van het modelbestand), en daarna verder gaan om ze allemaal te verwerken en tenslotte stikken we de resultaten aan elkaar. Om artifacts te vermijden op de gebieden naast de stiknaad, worden alle delen opgeknipt met een beetje marge en de marge wordt er later afgeknipt.

Hoe uw eigen model te trainen

Om uw eigen model te trainen, heeft u enige technische vaardigheden nodig, paren van plaatjes (invoer en de verwachte uitvoer) en een krachtige computer. U zou ook heel wat ruimte op uw vaste schijf nodig kunnen hebben, hoewel u gewoon onnodige oudere modellen kunt verwijderen als u start en problemen heeft met gebrek aan ruimte.

Apparaatstuurprogramma's & voorbereiding

U moet Python3 installeren en de volgende pakketten: Pillow, openvino, numpy, torch. Voor kwantificering van het model zult u ook nncf nodig hebben en sklearn. Als er iets ontbreekt, zal het klagen, dus installeer die genoemde pakketten ook.

Als u op Windows bent, dan hebt u waarschijnlijk apparaatstuurprogramma's hebben voor NPU en speciale GPU. Op Linux zou u misschien NPU-apparaatstuurprogramma's moeten installeren voordat u in staat zult zijn dit: https://docs.openvino.ai/2024/get-started/configurations/configurations-intel-npu.html te gebruiken.

Moreover if you want to use iGPU for training (which might still be significantly faster than on CPU), you’ll probably need to use something like IPEX which allows PyTorch to use an “XPU” device, which is just your iGPU. It’s not tested or recommended since I personally haven’t been able to use it because my Python version was higher than the instruction expects, but the instruction is here: https://pytorch-extension.intel.com/installation?platform=gpu&version=v2.5.10%2Bxpu .
The sanity check for the installation is as follows:
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())];"
It should show more than 0 devices with some basic properties.

If you manage to get XPU device working on your machine, you’ll still need to edit the training scripts so they’ll able to use it: https://intel.github.io/intel-extension-for-pytorch/xpu/latest/tutorials/getting_started.html (most probably you’ll just need to add this line:
import intel_extension_for_pytorch as ipex
to the script on the very top, just underneath “import torch”, and use “xpu” as the device name when invoking the script, and it should work. But as I said, the scripts hasn’t been tested for that.

Gegevensverzameling

U hebt enige plaatjes nodig om in staat te zijn uw model te trainen. De plaatjes moeten in paren zijn, elk paar moet een schets (invoer) en een lijnkunst plaatje (verwachte uitvoer) hebben. Hoe beter de kwaliteit van de gegevensset, hoe beter het resultaat.

Before training, it’s best if you augment the data: that means the pictures are rotated, scaled up or down, and mirrored. Currently the data augmentation script also performs an inversion with the assumption that training on inverted pictures would bring the results faster (considering that black means zero means no signal, and we’d like that to be the background, so the models learn the lines, not the background around lines).

How to use the data augmentation script is explained below in the detailed instruction for the training part.

Here’s the dataset that we used (please read the license carefully if you want to use it): https://files.kde.org/krita/extras/FastSketchCleanupPluginKritaDataset.zip

Keuze van model en andere parameters

For quick results, use tooSmallConv; if you have more time and resources, typicalDeep might be a better idea. If you have access to a powerful GPU machine, you might try original or originalSmaller, which represent the original description of the model from the SIGGRAPH article by Simo-Sierra 2016, and a smaller version of it.

Adadelta gebruiken voor optimaliseren.

You can use either blackWhite or mse as the loss function; mse is classic, but blackWhite might lead to faster results since it lowers the relative error on the fully white or fully black areas (based on the expected output picture).

Oefening

  1. Clone the repository at https://invent.kde.org/tymond/fast-line-art (at 33869b6)
    git clone https://invent.kde.org/tymond/fast-line-art.git

  2. Daarna, prepareer de map:

    • Creëer een nieuwe map voor de oefening
    • In de map, voet uit:
      python3 [opslagruimtemap]/spawnExperiment.py --path [pad naar nieuwe map, ofwel relatief of absoluut] --note "[uw persoonlijke notitie over het experiment]"

  3. Gegevens prepareren

    • If you have existing augmented dataset, put it all in data/training/ and data/verify/, keeping in mind that paired pictures in ink/ and sketch/ subfolders must have the exact same names (for example if you have sketch.png and ink.png as data, you need to put one in sketch/ as picture.png and another in ink/ as picture.png to be paired).
    • If you don't have existing augmented dataset:
      1. Put all your raw data in data/raw/, keeping in mind that paired pictures should have the exact same names with added prefix either ink_ or sketch_ (for example if you have picture_1.png being the sketch picture and picture_2.png being the ink picture, you need to name them sketch_picture.png and ink_picture.png respectively.)
      2. Run the data preparer script:
        python3 [repository folder]/dataPreparer.py -t taskfile.yml
        That will augment the data in the raw directory in order for the training to be more successful.

  4. Bewerk het bestand taakfile.yml naar wat u wilt. De belangrijkste delen die u wilt wijzigen zijn:

    • model type - code name for the model type, use tinyTinier, tooSmallConv, typicalDeep or tinyNarrowerShallow
    • optimizer - type of optimizer, use adadelta or sgd
    • learning rate - learning rate for sgd if in use
    • loss function - code name for loss function, use mse for mean squared error or blackWhite for a custom loss function based on mse, but a bit smaller for pixels where the target image pixel value is close to 0.5

  5. Voer de trainingscode uit:
    python3 [repository folder]/train.py -t taskfile.yml -d "cpu"

    On Linux, if you want it to run in a background, add “&” at the end. If it runs in a foreground, you can pause the training just by pressing ctrl+C, and if it runs in a background, find a process id (using either “jobs -l” command or “ps aux | grep train.py” command, the first number would be the process id) and kill it using “kill [process id]” command. Your results will still be in the folder, and you’ll be able to resume the training using the same command.

  6. Convert the model to an openvino model:
    python3 [repository folder]/modelConverter.py -s [size of the input, recommended 256] -t [input model name, from pytorch] -o [openvino model name, must end with .xml]

  7. Place both the .xml and .bin model files in your Krita resource folder (inside pykrita/fast_sketch_cleanup subfolder) alongside other models to use them in the plugin.