Hoppa till innehållet
POLARISAI ACADEMY
R06-201 · Navigatör

ComfyUI, ControlNet och egna LoRA-modeller

Efteråt kan du räkna länkarna i en API-graf med 13 noder, räkna hur många samplingsteg en styrkarta täcker, släppa in eller avvisa en träningsrad med bildtext, och räkna ett LoRA-kort från rank, alpha och antalet API-anrop.

Nivå
Navigatör
Tid
25 h (uppskattning)
Förkunskap
R06-101
Kurs 2 av 4
Hoppa till

Efter kursen kan du

Eleven kan bygga en pipeline för validering och captioning av dataset som filtrerar bort olicensierade eller felaktigt utformade bilder och exporterar ett reproducerbart ComfyUI API-arbetsflöde med verifierade noder för strukturell conditioning.

Tretton noder och sjutton länkar

Anropet du skickar är ett JSON-objekt med två nycklar som lektionen kräver: prompt och client_id. prompt är en lista noder i form av ett uppslag. Nyckeln är nodens id, och grafen i räkneexemplet använder id 1 till 13. Varje värde har class_type och inputs. En kopplad ingång är en lista med två poster: källnodens id, sedan källans utgång, en slot. Varje sådan lista räknas som en länk. Ett tal eller ett filnamn som skrivs direkt på noden är en widget, och länksumman lämnar widgetarna utanför.

Nod 1, 2, 3, 4, 5, 6, 7, 8, 10, 11 och 12 använder de vanliga klassnamnen i API:t. Nod 1 är CheckpointLoaderSimple. Utgång 0 är modellen, utgång 1 är clip och utgång 2 är vae. Nod 2 är LoraLoader. Modell-ingången läser nod 1 utgång 0, clip-ingången läser nod 1 utgång 1, och widgetarna strength_model och strength_clip står båda på 1. De två talen skalar den tränade filen vid körning. Nod 3 och 4 är CLIPTextEncode, först den positiva texten och sedan den negativa, och båda tar clip från nod 2 utgång 1. Nod 5 är EmptyLatentImage, den tomma latenten. Nod 6 är ControlNetLoader. Nod 7 är LoadImage för strukturkartan. Nod 8 är ControlNetApplyAdvanced, noden som lägger kartan på textvillkoret. Nod 9 är lektionens bildtoken-nod, klassnamn IPAdapterApply, med ingångarna model, image och weight, och med en modell på utgång 0. Rätta nod 9 mot den listan. Nod 10 är KSampler. Nod 11 är VAEDecode. Nod 12 är SaveImage. Nod 13 är en andra LoadImage, stilbilden som matar nod 9.

Räkna bara de kopplade ingångarna. Nod 2 har 2, nod 3 har 1, nod 4 har 1, nod 8 har 4 (positive, negative, control_net, image), nod 9 har 2 (model från nod 2 utgång 0, image från nod 13 utgång 0), nod 10 har 4 (model från nod 9 utgång 0, positive från nod 8 utgång 0, negative från nod 8 utgång 1, latent_image från nod 5 utgång 0), nod 11 har 2 (samples från nod 10 utgång 0, vae från nod 1 utgång 2) och nod 12 har 1. Summan är 2 + 1 + 1 + 4 + 2 + 4 + 2 + 1 = 17. Nod 1, 5, 6, 7 och 13 har bara widgetar, så de bidrar med noll länkar. Fyra kontroller ska gå igenom före ett anrop. Kontroll 1 är 13 noder och 17 länkar. Kontroll 2 säger att KSampler positive kommer från nod 8 utgång 0 och KSampler negative från nod 8 utgång 1. Kontroll 3 säger att modellvägen är nod 1 utgång 0, sedan nod 2 utgång 0, sedan nod 9 utgång 0, sedan nod 10. Kontroll 4 säger att bredd och höjd på nod 5 är lika med bredd och höjd på strukturfilen i nod 7. Kopplar du nod 3 rakt in i KSampler positive, i stället för tråden från nod 8, stannar länkantalet på 17 och kontroll 2 faller.

Styrkartor, stegfonstret och fyra bildtoken

Nod 8, ControlNetApplyAdvanced, tar det positiva villkoret, det negativa villkoret, en kontrollmodell och en strukturbild. Lektionen använder tre slags strukturbilder. En canny-karta är en kantbild. Handregeln märker en pixel som kant när absolutbeloppet av skillnaden mot pixeln till höger är minst 40. Sista pixeln i raden saknar högergranne, så regeln lämnar den omärkt. En färdig detektor använder en gradient och två trösklar. Du rättar handregeln. Räkneraden lyder 10, 50, 55, 120, 30. De fyra skillnaderna är 40, 5, 65 och 90. Tre av de fyra når 40, så raden har 3 kantpixlar. En depth-karta, en djupkarta, lagrar ett heltal från 0 till 255 i varje pixel, och i den här lektionen betyder ett större tal närmare. En pose-karta lagrar 18 kroppspunkter. En punkt är giltig när x ligger från 0 till och med bredd minus 1, och y från 0 till och med höjd minus 1. På en ruta som är 512 ligger det giltiga spannet från 0 till 511. Posefilen i exemplet har 18 punkter och 4 av dem har x = 520. Giltiga punkter är 18 minus 4, alltså 14. Lektionen avvisar en pose-karta med färre än 5 giltiga punkter. 14 klarar den grinden.

KSampler i exemplet kör 20 samplingsteg, numrerade 0 till 19, med start_percent 0 och end_percent 0,8. Steg k ligger inne i fönstret när start_percent är mindre än eller lika med k/20 och k/20 ligger under end_percent. Här blir det k/20 under 0,8, alltså k under 16. Steg 0 till 15 ligger inne, och det är 16 steg. Steg 16 till 19 ligger ute, och det är 4 steg. På ett inne-steg är den använda resten textresten plus strength gånger kontrollresten. Talen i exemplet är text 0,25, strength 0,80 och kontroll 1,00, så 0,25 plus 0,80 gånger 1,00 blir 1,05. På ett ute-steg faller kontrolltermen bort och resten stannar på 0,25.

Nod 9 lägger bildtoken bredvid den positiva prompten. Styrkartan ligger pixel för pixel mot den tomma latenten. Bildtoken har en fast bunt i den här lektionen: 4 token för den enda stilbilden på nod 13. Den positiva prompten i exemplet är given som 12 token, så uppmärksamhetssumman du kontrollerar är 12 plus 4, alltså 16. Den negativa prompten är ett eget villkor och står utanför den summan. weight multiplicerar bildtoken-vektorerna. weight 0,50 lämnar summan på 16.

En rad som får komma in i träningsmängden

Varje kandidat är en bild, en hash, en licens och en rad bildtext, en caption. Lektionens godkända lista är own, cc0 och cc-by. Märkena nc och nd stannar utanför mängden. nc är en icke-kommersiell licens, och nd är en licens utan bearbetningar. Båda sidorna på bilden ska vara minst 512 och delbara med 64. Hashen är en SHA-256-summa skriven med gemena hextecken. Summan är 32 byte, och 32 gånger 2 hextecken är 64, så den sparade strängen har längd 64 och varje tecken är en siffra 0 till 9 eller en bokstav a till f. Bildtexten delas vid kommatecken, och mellanslag runt ett fält tas bort. Fem fält står i den här ordningen: motiv, antal, pose, bakgrund och licensmärke. Motivet är mug, chair eller lamp. Antalet är ett heltal från 1 till 4. Pose är front, side eller three-quarter. Bakgrunden är studio, street eller room. Licensmärket är lika med radens licens. Ett märke som stämmer kan inte rädda en licens som ligger utanför den godkända listan.

Åtta rader går genom de reglerna. Rad a är own, 512 gånger 512, hashlängd 64, bildtext mug, 1, front, studio, own, och den går igenom. Rad b är cc-by, 768 gånger 512, hashlängd 64, bildtext chair, 2, side, room, cc-by, och den går igenom. Rad c är nc, 512 gånger 512, hashlängd 64, bildtext lamp, 1, front, studio, nc, och licensen faller. Rad d är cc0, 500 gånger 512, hashlängd 64, bildtext mug, 1, side, street, cc0. Sidan 500 ligger under 512, och 500 delat med 64 är 7,8125, så sidan faller på både minsta mått och rutnät. Rad e är own, 512 gånger 512, hashlängd 63, bildtext mug, 1, front, studio, own, och hashlängden faller. Rad f är cc-by, 1024 gånger 1024, hashlängd 64, bildtext mug, 1, front, studio, cc0. Märket cc0 stämmer inte med radens licens cc-by, så raden faller. 1024 delat med 64 är 16, så måttet i sig skulle ha gått igenom. Rad g är own, 768 gånger 768, hashlängd 64, bildtext lamp, 3, three-quarter, room, own, och den går igenom. Rad h är cc0, 512 gånger 512, hashlängd 64, bildtext vase, 1, front, studio, cc0, och motivet vase faller. Tre rader går igenom: a, b och g. Fem rader faller.

Manifestet behåller en rad för varje godkänd rad, i id-ordning. Sex fält står mellan lodstreck: id, bredd, höjd, licens, hashlängd och bildtexten. De tre raderna är a | 512 | 512 | own | 64 | mug, 1, front, studio, own, sedan b | 768 | 512 | cc-by | 64 | chair, 2, side, room, cc-by, sedan g | 768 | 768 | own | 64 | lamp, 3, three-quarter, room, own. Latenta tal följer rutnätet du redan använder: dela varje sida med 8, multiplicera sedan med 4. Rad a är 64 gånger 64 gånger 4, alltså 16384. Rad b är 96 gånger 64 gånger 4, alltså 24576. Rad g är 96 gånger 96 gånger 4, alltså 36864. Den tomma latenten i det anropet använder samma bredd och höjd, så kontroll 4 går igenom för var och en av de tre raderna.

Rank, alpha och ett anrop per rad

En LoRA på ett linjärt lager lägger till två små matriser medan kontrollpunktens vikter ligger frysta. Övningsnätet i lektionen anpassar 4 lager, och varje lager har 320 ingångar och 320 utgångar. Träningsbara tal på ett lager är rank gånger (320 plus 320), alltså rank gånger 640. Rank 8 ger 8 gånger 640, alltså 5120 på ett lager, och 4 gånger 5120 är 20480 på nätet. Rank 4 ger 10240 på nätet. Rank 16 ger 40960. Tillåtna rank på ett kort är 4, 8 och 16. Träningsskalan är alpha delat med rank. Kortet tillåter skala 1 och skala 0,5, så alpha är lika med rank, eller hälften av rank. Produkten av de två små matriserna, före den skalan, är 0,20 i räkneexemplet. Skala 1 lägger till 0,20. Skala 0,5 lägger till 0,10. Skala 2 ligger utanför kortet. Alpha ändrar skalan och lämnar antalet träningsbara tal orört: alpha 4 med rank 8 lagrar fortfarande 20480 tal, med skala 0,5. Lektionen lagrar varje träningsbart tal i 2 byte, så rank-8-nätet tar 20480 gånger 2, alltså 40960 byte.

Tillåtna antal träningssteg är 100, 150, 200, 250, 300, 350 och 400. Kortet i exemplet är rank 8, alpha 8 och 200 träningssteg. Skalan är 8 delat med 8, alltså 1. Antalet träningsbara tal är 20480 och den lagrade storleken är 40960 byte, så kortet går igenom. Rank 32 ligger utanför de tillåtna rank. Alpha 16 med rank 8 ger skala 2, så det kortet faller fastän rank i sig är tillåten. Loader-styrkorna på nod 2 står kvar på 1 och 1, så multiplikatorn vid körning är 1. Träningsskalan ligger redan i filen. Samplingstegen stannar på 20. Träningssteg och samplingsteg är två räknare.

Batchen skickar ett POST till /prompt för varje manifestrad, och batch_size på den tomma latenten stannar på 1, eftersom de tre bilderna har tre storlekar. Batchen i exemplet skickar därför 3 anrop. client_id är strängen batch-06 på varje anrop. Varje anrop byter 4 widgetar inuti prompt: strukturfilens namn på nod 7, seed på nod 10, bredd på nod 5 och höjd på nod 5. Antalet byten är 3 gånger 4, alltså 12. Seed följer id-ordning och börjar på 100. Rad a får 100, rad b får 101 och rad g får 102. Rad b skriver bredd 768 och höjd 512. Rad g skriver bredd 768 och höjd 768.

Ett exempel

Från åtta rader till tre anrop

Behåll rad a, b och g. Latenta tal är 16384 för a, 24576 för b och 36864 för g.

Grafen som följer med de raderna har 13 noder. Länksumman är 2 plus 1 plus 1 plus 4 plus 2 plus 4 plus 2 plus 1, alltså 17. KSampler positive kommer från nod 8 utgång 0 och KSampler negative från nod 8 utgång 1, så kontroll 2 går igenom. Modellvägen går från nod 1 via nod 2 och nod 9 in i nod 10, så kontroll 3 går igenom. För rad a är den tomma latenten 512 gånger 512, samma som strukturfilen, så kontroll 4 går igenom på det anropet. Samma matchning sätter rad b till 768 gånger 512 och rad g till 768 gånger 768.

Samplingstegen är 20, start_percent är 0 och end_percent är 0,8, så 16 steg ligger inne i fönstret och 4 ligger ute. Textrest 0,25, strength 0,80 och kontrollrest 1,00 ger 1,05 inne i fönstret och 0,25 utanför. Den positiva prompten bidrar med 12 token och nod 9 bidrar med 4, så uppmärksamhetssumman är 16 vid weight 0,50. LoRA-kortet är rank 8, alpha 8 och 200 träningssteg. Skalan är 1, antalet träningsbara tal är 20480, och med 2 byte var lagrar filen 40960 byte. Båda loader-styrkorna står på 1.

POST /prompt går ut tre gånger, med client_id batch-06 och batch_size 1. Seed är 100, 101 och 102. Varje anrop byter filnamn, seed, bredd och höjd, så antalet byten är 12. Raden du kan bocka av före första POST är: noder 13, länkar 17, kontroll 1 till 4 godkänd för den radens mått, inne-steg 16, rest 1,05, uppmärksamhetstoken 16, träningsbara 20480, anrop 3.

Övning

Markera en graf, ett fönster och två nya rader

En kopia av grafen i exemplet har fortfarande 17 länkar, och KSampler positive kommer nu från nod 3 i stället för nod 8. Namnge kontrollen som faller. Ta sedan 30 samplingsteg, start_percent 0, end_percent 0,5, strength 0,60, textrest 0,20 och kontrollrest 1,00. Skriv antalet inne-steg, resten inne och resten ute. På canny-raden 0, 10, 80, räkna kantpixlarna med handregeln. På en ruta som är 512 har en posefil 18 punkter och 3 av dem har x = 600. Skriv antalet giltiga punkter och säg om grinden på 5 går igenom. Rad i är cc0, 640 gånger 512, med en gemen hex-hash på 64 tecken och bildtexten chair, 1, front, street, cc0. Rad j är nd, 512 gånger 512, med en gemen hex-hash på 64 tecken och bildtexten mug, 1, front, studio, nd. Markera varje rad som godkänd eller underkänd, och skriv antalet latenta tal för en rad som går igenom. LoRA-kortet som prövas är rank 16, alpha 8, 250 träningssteg, på samma 4 lager med 320, lagrat med 2 byte, med produkt 0,20 före skalan. Skriv skalan, antalet träningsbara tal, antalet byte, det tillagda beloppet, och om kortet går igenom. En positiv prompt på 10 token går genom en bildtoken-nod med weight 0,25. Skriv uppmärksamhetssumman. Rad i läggs till det godkända manifestet, och rad j stannar ute. Skriv antalet API-anrop, antalet byten, och seed på varje godkänt id.

Kontroll 2 faller, eftersom KSampler positive ska komma från nod 8. Länkantalet kan stanna på 17. Steg 0 till 14 ligger inne i fönstret, alltså 15 steg, och steg 15 till 29 ligger ute. Resten inne är 0,20 plus 0,60 gånger 1,00, alltså 0,80. Resten ute är 0,20. Canny-skillnaderna är 10 och 70, så en skillnad når 40 och raden har 1 kantpixel. Giltiga posepunkter är 18 minus 3, alltså 15, och 15 klarar grinden på 5. Rad i går igenom. Dess latenta tal är 80 gånger 64 gånger 4, alltså 20480. Rad j faller eftersom nd ligger utanför own, cc0 och cc-by, även när bildtextens märke stämmer med raden. LoRA-skalan är 8 delat med 16, alltså 0,5. Träningsbara tal är 16 gånger 640 gånger 4, alltså 40960. Byte är 40960 gånger 2, alltså 81920. Det tillagda beloppet är 0,20 gånger 0,5, alltså 0,10. Rank 16, skala 0,5 och 250 träningssteg är alla tillåtna, så kortet går igenom. Uppmärksamhetssumman är 10 plus 4, alltså 14, och weight 0,25 lämnar de 14 orörda. Godkända id i ordning är a, b, g och i, så batchen skickar 4 anrop och 16 byten. Seed är 100, 101, 102 och 103.

Kontrollfrågor

Svara själv först. Öppna sedan frågan för att se svaret.

Hur många noder och hur många länkar har API-grafen i exemplet, och vilken kontroll faller när KSampler positive kopplas från nod 3 medan länkantalet stannar på 17?

13 noder och 17 länkar. Kontroll 2 faller, eftersom både KSampler positive och KSampler negative ska komma från nod 8.

Samplern i exemplet kör 20 steg med start_percent 0 och end_percent 0,8. Hur många steg ligger inne i fönstret, vilken rest gäller där, och vilken rest gäller utanför, med textrest 0,25, strength 0,80 och kontrollrest 1,00?

16 steg ligger inne, steg 0 till 15, och resten där är 1,05. De andra 4 stegen stannar på 0,25.

Hur många av de åtta raderna går igenom, vilka id är det, och varför faller rad f när båda sidorna är 1024?

Tre rader går igenom: a, b och g. Rad f faller eftersom bildtextens märke är cc0 och radens licens är cc-by. 1024 delat med 64 är 16, så måttet i sig klarar sig.

På LoRA-kortet i exemplet, rank 8 och alpha 8, hur många träningsbara tal lagras, vilken skala gäller, hur många byte tar de vid 2 byte var, och hur många API-anrop och byten ger det godkända manifestet?

20480 träningsbara tal, skala 1 och 40960 byte. Manifestet ger 3 API-anrop och 12 byten.

Ta med dig

Bocka av grafen före första POST: 13 noder, 17 länkar, KSampler matad från kontrollnoden, och den tomma latenten kopierad från radens bredd och höjd. En träningsrad får vara kvar bara när licensen, båda sidorna, hashen på 64 tecken och de fem fälten i bildtexten alla går igenom, och LoRA-kortet visar en tillåten rank med skala 1 eller 0,5. Varje godkänd rad är ett API-anrop.

Slutuppgift

Lämna in ett skript för datasetvalidering och en ComfyUI API-graf som granskas av automatiserade tester som verifierar: 100 % giltiga bild/caption-par, avvisning av seedade korrupta/olicensierade filer, giltig ControlNet/LoRA-graftopologi och körning av batch-API. (Valfritt portföljobjekt: anpassad LoRA-showcase).

Slutuppgiften rättas av fasta facit och automatiska tester när proven öppnar.

Begrepp i kursen

Kursen har inga egna begrepp i ordlistan ännu. Begrepp från tidigare kurser används här också.

Fler lektioner kommer

Första lektionen är öppen att läsa. Resten av kursens lektioner skrivs, och prov och diplom kommer senare. Till väntelistan