Generative AI Full Course Lecture 3 Civitai Models and Watercolor LoRAs in ComfyUI

Generative AI Full Course - Lecture 3: Civitai Models & Watercolor LoRAs in ComfyUI

Full tutorial link > https://www.youtube.com/watch?v=A6s6Qhl9YBk

Turn a vague image request into a deliberate, reproducible ComfyUI recipe. In Lecture 3 of this 14-lecture Generative AI course, we improve poster prompts, compare layouts at fixed seeds, generate text with Qwen Image, explore guidance, then install a Civitai fine-tune and watercolor LoRA and compare its strengths. Follow the complete Windows workflow from prompt to saved result.

🔗 Links:

Windows AI requirements guide: [ https://www.patreon.com/posts/111553210 ]

📦 Full course resource repository: [ https://github.com/FurkanGozukara/Generative-AI-Tools-And-Tecniques-2026-2027-Fall ]

▶️ Lecture 1 — Windows setup and your first image: [ https://youtu.be/KgUhPAOjagI ]

▶️ Lecture 2 — ComfyUI workflows and updating: [ https://youtu.be/T2_z7ZaffyI ]

📺 Full course playlist: [ https://www.youtube.com/playlist?list=PLUMEJUep1hiI ]

SECourses Discord: [ https://discord.com/invite/software-engineering-courses-secourses-772774097734074388 ]

🎯 You will learn how to trace prompt conditioning, give explicit layout instructions, compare fixed seeds, inspect generated text, distinguish conventional CFG from embedded guidance, choose compatible Civitai versions, read an author recipe and license, install models in the right folders, connect a LoRA, compare strengths while keeping the other settings fixed, and compare weight precision with the same text encoders.

🧩 Main topics include ComfyUI, Z-Image Turbo, illustrative tokenization, Qwen Image, FLUX, Klein 9B, Civitai fine-tunes, LoRA adapters, trigger words, watercolor style, seeds, CFG, samplers, schedulers, scaled FP8 and workflow JSON.

Use the chapters to jump to prompt layout, generated text, guidance, Civitai installation or the watercolor LoRA comparison.

⏱️ Chapters:

00:00:00 Turn a vague request into a directed image

00:01:01 Reuse the update route from Lecture Two

00:02:31 Follow text through the encoder into conditioning

00:03:47 Inspect token pieces with the illustrative tokenizer

00:05:31 Generate a poster from the vague prompt

00:06:41 Specify the subject, layout and quoted title

00:08:04 Reserve clear sky above the focal subject

00:09:34 Test the same instruction on more seeds

00:12:48 Load the matching Qwen Image components together

00:14:18 Generate the exact title and ticket price

00:15:39 Trace positive and negative predictions through guidance

00:17:33 Compare warm sampling at two guidance values

00:19:58 Separate embedded guidance from conventional two-branch CFG

00:21:01 Find the exact compatible community model version

00:24:02 Install the diffusion model and matched components

00:25:40 Inspect the fine-tuned model on a product brief

00:27:05 Find the watercolor adapter for FLUX dev

00:29:18 Connect the adapter to its own FLUX graph

00:30:30 Keep the prompt fixed while bypassing the adapter

00:31:39 Compare three strengths around the author setting

00:34:05 Compare weight precision with the encoder held fixed

00:36:24 Identify the sampler and its noise schedule

00:37:23 Choose the workflow for the actual brief

00:38:59 Save the graph and exact source versions

00:39:57 Use deliberate prompts and reproducible model choices

Use the supplied workflows and model source manifest. Community weights are not included; model_sources.md lists the Civitai pages, exact files, hashes and terms. The exact local FLUX FP8 download is unverified; the materials provide a verified BF16 route.

The tokenizer demonstration is illustrative; its token counts are not the image models’ counts.

After git pull --ff-only and python -m pip install -r requirements.txt, restart ComfyUI using the startup route from Lecture 2, then refresh the browser. A browser refresh alone does not load updated backend code.

This video is for anyone who wants more control over local AI images and a repeatable way to compare prompts, models and adapters.

💬 Check the pinned comment for resources and updates. Support the course on Patreon, join the SECourses Discord, or leave your workflow questions in the comments.

#ComfyUI #GenerativeAI #Civitai #LoRA #FLUX

Video Transcription

• 00:00:00 Greetings everyone. Today I am going to  show you how to direct image generation  

• 00:00:05 in ComfyUI. We will turn this vague travel  request into a poster with a clear subject,  

• 00:00:14 layout, and title. I am opening another result  from Qwen Image. We will inspect its title and  

• 00:00:22 the ticket price at full size. This example  gives us exact lettering to compare with the  

• 00:00:28 generated scene. The red funicular sits below the  title, with 2 birds at the upper right. This model  

• 00:00:36 also writes our ticket price correctly. We will  compare prompts, guidance, compatible models,  

• 00:00:43 and a watercolor adapter. Check out the tutorial  description for the chapters and workflow files.  

• 00:00:50 We are continuing from the graph in Lecture 2.  First, let us briefly update that installation,  

• 00:00:56 then follow our words through the graph. I  am opening the existing ComfyUI folder. We  

• 00:01:03 will reuse the update procedure from Lecture  2. This copy contains the application and its  

• 00:01:10 virtual environment, alongside the model  path configuration we already prepared.  

• 00:01:16 Use the address bar to open a Command Prompt  in this folder. Check the working path before  

• 00:01:23 continuing. We will use the existing virtual  environment for both the source update and its  

• 00:01:29 matching Python dependencies. First activate the  virtual environment in this installation. This  

• 00:01:36 keeps the following Python command attached to the  environment we already use. Check the environment  

• 00:01:42 name beside the prompt before continuing with  the update. Now run the source update command.  

• 00:01:49 The fast forward option keeps this operation on  the existing source history. When it finishes,  

• 00:01:55 the prompt returns so we can install the  dependencies for that version. Next, install  

• 00:02:02 the requirements through this environment. The  command keeps the Python packages aligned with the  

• 00:02:08 source. You can follow the complete explanation in  Lecture 2 if you are doing this for the 1st time.  

• 00:02:17 The update has finished, and ComfyUI is open.  Refresh the browser to load the updated interface.  

• 00:02:23 Now let us open our familiar Z-Image Turbo graph  and inspect its text input. Our prompt enters  

• 00:02:32 this text encoding node. I am using a short  sentence about a copper robot carrying a blue  

• 00:02:40 umbrella. Follow the connection from the encoder  loader into this node. Text first becomes tokens  

• 00:02:47 according to the selected tokenizer. A token can  represent a word, part of a word, or punctuation.  

• 00:02:54 The resulting identifiers refer to entries in that  tokenizer vocabulary. The text encoder processes  

• 00:03:02 those identifiers in context. Copper describes  our robot, while blue describes the umbrella.  

• 00:03:08 Their positions and surrounding words help form  the features passed toward the image model.  

• 00:03:15 This orange output carries conditioning. Follow  its wire into the sampler, where it influences  

• 00:03:22 generation. The token identifiers themselves  are not colours or pixels. The decoder produces  

• 00:03:28 pixels after the sampling stage. This graph does  not display its tokenizer pieces. Let us use the  

• 00:03:36 official OpenAI tokenizer to see the mechanism. It  uses a different tokenizer, so its counts do not  

• 00:03:43 describe our image model. Here is the tokenizer  selection at the top. I am keeping the selected  

• 00:03:52 mode and entering the same copper robot sentence.  The coloured pieces below show how this particular  

• 00:03:58 tokenizer divides that text. The display shows 8  tokens for this sentence. Look at the full stop:  

• 00:04:06 it has its own piece. Spaces also appear with  the following words here. Counting words alone  

• 00:04:12 would miss that punctuation token. You can  switch from coloured text to token identifiers.  

• 00:04:19 Each number names a vocabulary entry. A larger  identifier does not mean a more important word,  

• 00:04:25 a brighter colour, or stronger influence on the  image. Now I am returning to the text view and  

• 00:04:32 changing the punctuation. Watch the pieces  and total update. The tokenizer decides how  

• 00:04:39 these characters are grouped; punctuation does  not follow a universal 1-token rule. Let us  

• 00:04:46 replace robot with a longer compound word. Watch  which coloured pieces cover the new word. Token  

• 00:04:53 boundaries depend on the vocabulary, so a long  word can occupy several entries instead of just 1.  

• 00:05:00 Adding another sentence increases the text the  encoder must process. More words help when they  

• 00:05:07 add useful direction. Repetition and conflicting  details can make the brief harder to satisfy,  

• 00:05:14 even when they fit the context. Back in ComfyUI,  we keep the tokenizer and encoder matched to this  

• 00:05:21 model. Its own prompt wrappers and special tokens  can add to the sequence. Our next step is to make  

• 00:05:28 the visible brief more useful. Let us start with  the vague request: make a beautiful travel poster.  

• 00:05:35 I am entering it in the positive prompt. Our  seed is fixed, and the size and sampling recipe  

• 00:05:42 stay unchanged during this comparison. Run the  graph and watch the image appear. The model has  

• 00:05:49 to choose the destination, subject, layout, and  lettering from a very broad request. We have given  

• 00:05:56 it an intention rather than a detailed scene.  Let us open the 1st poster result. We can inspect  

• 00:06:04 the full image here, keeping the composition  visible while checking the details requested in  

• 00:06:10 the prompt. This result shows a traveller facing  the mountains. The large travel word is readable,  

• 00:06:18 but the smaller lettering is malformed. It looks  like a poster, while inventing information we  

• 00:06:24 never asked it to include. Now let us decide  what the poster should contain. We want a red  

• 00:06:31 funicular, a green hillside, blue sea, and a cream  title. Those details give us specific features to  

• 00:06:38 inspect after generation. I am replacing the  vague request with the full example from the  

• 00:06:45 lesson files. It names the subject and setting  first. Then it specifies the title, the 2 birds,  

• 00:06:52 and the flat watercolor style. The quoted title  is Hill and Sea. We also place the birds at the  

• 00:07:00 upper right. This gives the generator visible  relationships to follow, instead of asking it to  

• 00:07:06 decide what beautiful should mean. Our seed and  sampling settings remain fixed. Let us run this  

• 00:07:13 prompt and open the result. Keeping those settings  stable makes it easier to connect the new visual  

• 00:07:21 direction with the changes we see. Let us open the  directed poster result. We can inspect the full  

• 00:07:29 image here, keeping the composition visible while  checking the details requested in the prompt. The  

• 00:07:36 red funicular is now the focal subject. We have a  green hillside and blue sea, with the cream title  

• 00:07:43 above. Look at the upper right: the 2 birds are  also present in this result. A direct generation  

• 00:07:49 prompt describes the result to create. Editing  prompts can instead ask to replace or remove  

• 00:07:56 something from an input image. The useful wording  follows the task and the model inputs. Let us give  

• 00:08:04 the title more breathing room. I am adding 1  instruction: keep the funicular entirely in the  

• 00:08:10 lower half. The subject, colours, title, seed, and  sampling settings remain the same. Before running,  

• 00:08:18 look at where the funicular begins in the current  image. Which relationship should the new sentence  

• 00:08:25 change? Pause here and compare the subject height  with the space behind the title. Return to the  

• 00:08:37 graph with our revised prompt ready. Now run this  version. We kept the original subject and style  

• 00:08:44 while adding 1 placement instruction, so we can  compare the vehicle height after sampling. Let us  

• 00:08:51 open the revised layout. We can inspect the full  image here, keeping the composition visible while  

• 00:08:58 checking the details requested in the prompt.  The funicular now sits lower in the frame,  

• 00:09:04 leaving more clear sky. Other details change  too, including the car shape and hillside. A  

• 00:09:10 close view changes scale, while a low viewpoint  changes where we look from. Background blur and  

• 00:09:18 viewpoint describe different visual choices too.  Treat camera words as directions to the generator.  

• 00:09:25 Then inspect the image, just as we inspect this  placement instruction, to see whether it fits the  

• 00:09:31 brief. 1 useful result is a starting point. Let  us repeat the same prompt pair on 2 more seeds.  

• 00:09:39 Each seed gets both the original prompt and the  lower-half instruction, with the same model and  

• 00:09:46 recipe. I am changing the seed for the next pair.  The model, dimensions, and sampling settings stay  

• 00:09:54 fixed. We will run the original prompt first,  then compare it with the same added placement  

• 00:10:00 instruction. Here is the original prompt again.  I am keeping its full wording and running it with  

• 00:10:06 the new seed. This gives us the baseline image for  the 2nd pair in our comparison. Let us open the  

• 00:10:14 original result for this seed before changing its  prompt. The upper edge of the funicular gives us a  

• 00:10:22 starting position to compare with the next image.  Add the same lower-half instruction to the prompt.  

• 00:10:29 We are keeping the starting noise and every other  recipe choice unchanged. With that ready, run the  

• 00:10:36 graph and compare the revised vehicle position.  Let us open the 2nd revised result. We can inspect  

• 00:10:46 the full image here, keeping the composition  visible while checking the details requested in  

• 00:10:52 the prompt. The 2nd pair also moves the funicular  lower. Notice the space between the title and the  

• 00:10:59 vehicle. The lettering style changes at the same  time, so we should inspect the rest of the brief  

• 00:11:05 as well. Now repeat the pair on our 3rd seed.  We are checking the placement instruction across  

• 00:11:11 starting noises while holding the other recipe  choices steady. I am changing that seed before  

• 00:11:18 restoring the original prompt. Run the original  prompt with this 3rd seed. We keep each baseline  

• 00:11:26 beside its revised version, so the comparison  stays matched. A different seed for each prompt  

• 00:11:33 would mix 2 changes together. Let us open the  original result for this seed before changing its  

• 00:11:40 prompt. The upper edge of the funicular gives us a  starting position to compare with the next image.  

• 00:11:47 Add the same lower-half instruction to the prompt.  We are keeping the starting noise and every other  

• 00:11:54 recipe choice unchanged. With that ready, run the  graph and compare the revised vehicle position.  

• 00:12:04 Let us open the 3rd revised result. We can inspect  the full image here, keeping the composition  

• 00:12:10 visible while checking the details requested in  the prompt. In this 3rd pair, the revised vehicle  

• 00:12:17 again begins below the middle of the frame.  Across all 3 pairs, the added sentence helps this  

• 00:12:24 layout. The car, birds, and letter sizes still  vary between results. If a required relationship  

• 00:12:33 keeps failing, first simplify conflicting  instructions. You can also use a reference image  

• 00:12:38 or structural control. Those later tools help when  text alone leaves too much freedom in the layout.  

• 00:12:47 Now let us use Qwen Image 2.1 for the exact-text  task. Open the Qwen workflow supplied with the  

• 00:12:54 lesson. We will inspect its matched components  before changing the prompt or copying settings  

• 00:13:01 from another model. The diffusion loader selects  the image model. The text encoder is the matching  

• 00:13:07 Qwen3-VL 8B model. Its encoder path is different  from the Z-Image graph we used a moment ago.  

• 00:13:18 This text node prepares the positive and negative  conditioning for Qwen Image. Follow both outputs  

• 00:13:24 toward the sampler. The node belongs to this model  recipe, so we keep it when adapting the workflow  

• 00:13:32 to our poster. The decoder is the Qwen Image 2.1  VAE. It belongs with this model and its latent  

• 00:13:40 representation. A matching socket colour alone  is not enough to choose a different family of  

• 00:13:47 decoder. I am setting the landscape dimensions  for our poster. The workflow uses 25 steps,  

• 00:13:54 Euler sampling, the simple schedule, and  guidance 1. Keep those matched settings  

• 00:13:59 while we test the words we want it to draw. Our  title stays the same. Below it, we will add the  

• 00:14:05 exact ticket line from the lesson files. This  gives us letters, a currency symbol, digits,  

• 00:14:12 a decimal point, and punctuation to inspect in  the result. I am entering the complete poster  

• 00:14:20 prompt with its quoted ticket line. The price is  $12.99. Let us run the graph, then inspect the  

• 00:14:28 actual text instead of judging only the overall  design. Let us open the exact-text result. We  

• 00:14:34 can inspect the full image here, keeping the  composition visible while checking the details  

• 00:14:40 requested in the prompt. The title reads Hill  and Sea correctly. Look at the smaller line next.  

• 00:14:47 Tickets has the requested capital letter, followed  by the dollar sign, the price, and the exclamation  

• 00:14:53 mark at the end. The decimal point separates  12 from 99. Both final digits are present.  

• 00:15:00 This result satisfies our written text request,  so we can now inspect the picture itself with that  

• 00:15:08 part of the brief accounted for. There are 2 birds  at the upper right. The red funicular sits on the  

• 00:15:14 green hillside, with the sea behind it. Correct  lettering and a convincing scene are separate  

• 00:15:20 checks, and this example lets us inspect both.  For a ticket price that you need to edit later,  

• 00:15:26 keep the artwork and text separate. A  deterministic text layer lets you change  

• 00:15:32 the exact amount directly, while keeping the  generated scene you already prefer. Let us turn  

• 00:15:40 to guidance in a conventional 2-branch recipe.  This is the base version of Klein 9B. It uses  

• 00:15:48 its own matched encoder, decoder, latent, and  sampling setup, rather than the Turbo defaults.  

• 00:15:56 Our positive prompt describes a copper teapot on  the left and a blue cup on the right. It also asks  

• 00:16:03 for a wooden table and soft light from the left.  Those details make adherence easy to inspect. The  

• 00:16:10 positive and negative text nodes feed this guider.  The negative field is empty here. Conventional  

• 00:16:17 guidance compares the model prediction from the  positive conditioning with another prediction from  

• 00:16:22 the negative or empty conditioning. The scale  controls how those predictions are combined.  

• 00:16:30 Start with the negative prediction, then add the  scaled difference between positive and negative.  

• 00:16:36 The formula describes the same 2 branches you  can follow in this graph. What happens when the  

• 00:16:42 scale is 1? Look at the 2 negative terms in that  expression. Pause here and decide which prediction  

• 00:16:50 remains after the difference is added back to  the starting negative prediction. At 1, the  

• 00:17:02 negative terms cancel and the positive prediction  remains. Ordinary ComfyUI sampling can skip the  

• 00:17:09 negative prediction in this case. That removes  work from the denoiser, even though the negative  

• 00:17:15 connection still exists. Above 1, both predictions  generally contribute, sometimes through a batch.  

• 00:17:21 The negative prompt steers away from a competing  description. It does not erase named pixels from a  

• 00:17:28 completed picture, and its effect depends on this  guidance path. We will compare guidance 5 with  

• 00:17:36 guidance 1 using the same product prompt and seed.  The dimensions, 20 steps, sampler, and schedule  

• 00:17:43 stay fixed. Both measurements use the model after  it has already loaded. First run the recommended  

• 00:17:50 higher setting. We will inspect whether the result  follows the 2 requested objects, their positions,  

• 00:17:56 and the wooden surface. Keeping a specific brief  makes this guidance comparison easier to judge.  

• 00:18:04 Let us open the higher-guidance result. We  can inspect the full image here, keeping the  

• 00:18:11 composition visible while checking the details  requested in the prompt. There is a copper teapot  

• 00:18:18 with a fitted lid on the left, a blue cup on the  right, and a wooden table beneath them. Those  

• 00:18:24 features match the object and surface choices in  our brief. Return to the graph for the 2nd sample.  

• 00:18:32 Change the guidance scale to 1 while keeping  the other settings fixed. Then run again so we  

• 00:18:38 can compare the objects and surface in the result.  Let us open the guidance-1 result. We can inspect  

• 00:18:48 the full image here, keeping the composition  visible while checking the details requested  

• 00:18:54 in the prompt. The image changes substantially.  The pot is open, a saucer appears under the cup,  

• 00:19:02 and the tabletop no longer has the same clear wood  grain. Compare those differences with the specific  

• 00:19:08 objects we requested. For this brief, I prefer the  higher setting because it follows the requested  

• 00:19:14 objects and surface more closely. Guidance is  part of the model recipe. Increasing it further  

• 00:19:20 is not automatically a useful next step. Our warm  reference sampler took about 24 seconds at 5,  

• 00:19:28 and about 12 seconds at 1. Those are the sampling  intervals in this comparison. Model loading,  

• 00:19:36 text encoding, and decoding add other work around  that stage. We also changed the starting noise  

• 00:19:43 between warm-up and measurement. That makes the  sampler execute again. Reusing a fully cached  

• 00:19:51 output would measure the cache response instead  of the computation we wanted to compare. Now  

• 00:19:58 look at the working FLUX dev graph. This node  is called Flux Guidance, while the sampler has  

• 00:20:05 a separate CFG value. The similar names can hide  an important difference in how the model works.  

• 00:20:12 Flux Guidance supplies an embedded guidance value  learned by this model. We are using 3.5 there.  

• 00:20:19 The sampler scale remains 1, so that embedded  value does not mean the sampler is combining  

• 00:20:26 2 predictions at 3.5. Use the model template as  the starting point for both controls. A distilled  

• 00:20:34 recipe can require guidance 1. Copying the higher  Klein setting into this graph would mix settings  

• 00:20:41 from 2 different sampling arrangements. The same  compatibility principle applies when we choose  

• 00:20:48 a community model. We need its exact family,  component files, and sampling recipe. Let us  

• 00:20:55 keep those questions in mind as we select the next  model. Let us find a community model. In Google,  

• 00:21:03 search for Civitai. The 1st result shows the  official address, civitai.com, so I am opening  

• 00:21:10 it. This is Civitai, where people share models  and adapters. The model we need is FasciumKLEIN9B.  

• 00:21:20 I am typing its name into the search box and  pressing Enter. The search finds 4 models with  

• 00:21:29 similar names. 1 is built for Klein 4B, and 2 are  GGUF conversions from another uploader. A similar  

• 00:21:38 name is not enough to choose a file. So let us  filter by the base model. I type Flux and choose  

• 00:21:46 Flux.2 Klein 9B. Now only models made for that  family remain. The GGUF entry is a conversion by  

• 00:21:55 another user. We want the original model from its  author, Fascium. I am opening FasciumKLEIN9B. The  

• 00:22:04 model page opens on its newest version, called  LAST_MERGE. That is the exact version we will  

• 00:22:11 use. The details list a checkpoint merge built  on Flux.2 Klein 9B. Before downloading, read  

• 00:22:19 the author's description. It often contains the  settings the model was tested with. I am opening  

• 00:22:26 the full text and scrolling to the recommended  settings. The author's tested configuration  

• 00:22:34 uses CFG 2, 15 steps, and Euler ancestral. The  resolution for a landscape image is 1536 by 1024,  

• 00:22:44 which matches our graph. Further down, the  technical details say this is a step-distilled  

• 00:22:50 model. Distilled models usually run with very few  steps at CFG 1, but this author tested 15 steps  

• 00:22:57 at CFG 2. Now the terms. The license entry links  the non-commercial FLUX license from Black Forest  

• 00:23:06 Labs. The green icons are the permissions the  uploader selected on this site. The base model's  

• 00:23:13 license still applies to a merge built on it.  Non-commercial terms allow learning and personal  

• 00:23:21 experiments. Read the linked license before any  commercial use. Now back up to the download box.  

• 00:23:27 This version offers 2 variants of the same model,  so I open the list to compare them before choosing  

• 00:23:34 a file. The 16-bit file is about 17 gigabytes. The  8-bit file is about 8.5 gigabytes, roughly 1 byte  

• 00:23:43 for each of the 9 billion diffusion model weights.  So this file holds only the diffusion model. The  

• 00:23:51 text encoder and the VAE come separately, and we  already have the matching Klein 9B components.  

• 00:23:58 We will use the 8-bit file. I click the download  button of the 8-bit file. My browser asks where to  

• 00:24:07 save it. Because this file is a diffusion model,  it belongs in the diffusion models folder. I paste  

• 00:24:13 the full path of that folder, followed by the  file name, and save. In a standard installation  

• 00:24:19 it is ComfyUI, models, diffusion models. Your  drive letter can be different. If your browser  

• 00:24:26 saves to the downloads folder instead, move the  file into this folder afterwards. The download  

• 00:24:32 is running now, and this large file takes a while.  The download has finished. In the downloads list,  

• 00:24:41 I use Show in folder. Here is the Fascium  file inside the diffusion models folder,  

• 00:24:47 where ComfyUI looks for diffusion models. I close  this folder window and switch back to the ComfyUI  

• 00:24:53 tab in the browser. The graph for this model  family is the one from the guidance chapter.  

• 00:25:00 I open that Klein workflow again. ComfyUI was  already running when the new file arrived,  

• 00:25:07 so I press R to refresh the model lists. In the  diffusion model loader, I choose the Fascium file,  

• 00:25:14 so only the diffusion weights change. The  Qwen3 8B text encoder and the FLUX.2 VAE stay,  

• 00:25:22 because they match the Klein 9B family. You should  not swap in the Klein 4B encoder. The 4B and 9B  

• 00:25:31 models use text encoders of different sizes, and  each diffusion model expects features from its own  

• 00:25:38 encoder. Now I apply the author's tested settings.  CFG goes from 5 to 2. Because CFG is above 1,  

• 00:25:48 the empty negative branch is computed as well, as  we saw in the guidance chapter. The steps go from  

• 00:25:55 20 to 15, and the sampler becomes Euler ancestral.  The author calls it a scheduler, but in ComfyUI  

• 00:26:03 it is the sampler choice. The FLUX.2 scheduler  node stays. I also change the file name prefix,  

• 00:26:11 so this result is easy to find. The prompt, seed,  and size stay the same as in the guidance chapter.  

• 00:26:19 Let us run it. Now open the result, and let  us check it against the brief 1 request at  

• 00:26:27 a time. There is 1 polished copper teapot on  the left and 1 blue ceramic cup on the right,  

• 00:26:35 on a wooden table with clear grain. Look at the  copper surface: it even reflects the blue cup. The  

• 00:26:43 light comes from the left, the background stays  neutral grey, and there are no extra objects or  

• 00:26:50 text. This fine-tune follows our product brief  with its author's recipe. Next, a style adapter.  

• 00:26:58 It belongs to a different model family, so we  return to Civitai. Back in the Civitai tab,  

• 00:27:07 I search for the adapter. I type watercolor  painting into the search box and press Enter.  

• 00:27:17 The search finds hundreds of results, far too many  to check 1 by 1, so we need the filters again.  

• 00:27:25 This time the base model is Flux.1 D, which is  the FLUX dev family. I type Flux.1 and choose it  

• 00:27:33 from the list. The model type is LoRA. A LoRA is  an adapter for a compatible model, not a complete  

• 00:27:40 model, so it only works with its own base family.  The 1st result is Watercolor painting by Adel_AI,  

• 00:27:50 with many downloads and positive reviews. I am  opening it. Each version can target a different  

• 00:27:58 base model. Version 7 shows Z-Image Turbo  as its base model. Version 4 shows Flux.1 D,  

• 00:28:06 which is the one we want. The trigger word is  AquarelleIV, written as 1 word. We will put it at  

• 00:28:14 the start of our prompt, as the author does in the  examples. The version notes recommend a strength  

• 00:28:20 around 0.65, 25 steps, dpmpp_2m with sgm_uniform,  and guidance 3.5. The examples on this page use a  

• 00:28:35 FLUX-based merge called Fluxmania. We will use  the original FLUX dev model from this lecture,  

• 00:28:42 from the same FLUX.1 family. Open the tensor  list. Every entry starts with lora_unet,  

• 00:28:51 which means these weights patch the diffusion  model. This file has no text encoder weights. The  

• 00:28:58 adapter file is only about 18 megabytes, because  it stores small changes instead of a whole model.  

• 00:29:05 I click download. In the save dialog, I paste  the path of the loras folder in the same models  

• 00:29:14 directory, with the file name, and save. Back  in ComfyUI, I open the FLUX dev graph from the  

• 00:29:21 guidance chapter. This adapter was trained  for FLUX.1 dev, so it belongs on this graph,  

• 00:29:26 not on the Klein 9B graph. Its weights are shaped  for the layers of FLUX.1. Klein 9B has a different  

• 00:29:34 architecture, so those layers do not match, even  though both model names contain FLUX. I press R  

• 00:29:41 to refresh the lists. Then I double-click an  empty part of the canvas and search for Load  

• 00:29:48 LoRA. The new node follows the pointer until I  click. The search offered 2 loaders. Load LoRA  

• 00:29:55 patches only the diffusion model, and the Model  and CLIP version also patches the text encoder.  

• 00:30:01 The tensor list showed only diffusion weights. I  connect the diffusion model output to its model  

• 00:30:08 input. Then its output goes to the sampler model  input, and replaces the old connection. The file  

• 00:30:16 list already shows the Aquarelle file. The  strength model value scales how strongly the  

• 00:30:22 adapter changes the diffusion model; 1 means its  full trained change. Now the watercolor prompt. It  

• 00:30:32 starts with the trigger word AquarelleIV, followed  by a stone lighthouse on a rocky coast, soft blue  

• 00:30:39 sea, and loose watercolor washes on paper. First,  the baseline without the adapter. I select the  

• 00:30:46 LoRA loader and press Control B to bypass it. The  model now passes through unchanged. The seed stays  

• 00:30:55 271828, with 25 steps and guidance 3.5, exactly  as in the guidance chapter. I name this output  

• 00:31:04 watercolor bypass, so the file is easy to find  later, and then I run the graph. Now open the  

• 00:31:13 result. Even without the adapter, FLUX dev paints  a watercolor-like lighthouse, because our prompt  

• 00:31:21 asks for washes on paper. The rocks are smooth,  rounded boulders with firm outlines. The house has  

• 00:31:28 a clean red roof, and the sea fills the lower half  with even blue washes. Keep this baseline in mind,  

• 00:31:35 because it tells us what the adapter adds. Now  I enable the adapter again with Control B and  

• 00:31:43 set the model strength to the author's 0.65.  Everything else stays the same. I name this  

• 00:31:50 output Watercolor_065 and run it. Every image  in this comparison uses the same prompt, seed,  

• 00:31:58 steps, and guidance. Now open this result and  compare it with the baseline we just saw. At 0.65,  

• 00:32:08 the washes on the rocks become mottled, with ochre  and grey pigment, and the outlines soften. The  

• 00:32:15 view also changes, with a beach and a more distant  lighthouse. So the strength changes composition as  

• 00:32:22 well as texture, not only the painting style. Now  0.4, a weaker setting. I return to the graph and  

• 00:32:30 change only the model strength on the LoRA loader,  leaving every other value as it was. I name the  

• 00:32:37 output Watercolor_040, so each file carries its  strength, and I run the graph again. Now open  

• 00:32:47 the result for 0.4. The rocks are still firm and  angular, with darker shadows and clearer outlines.  

• 00:32:54 It sits between the baseline and the author's  setting. Finally 0.8, a stronger setting. Back in  

• 00:33:01 the graph, I again change only the model strength  on the LoRA loader and keep everything else as it  

• 00:33:07 was. I name this output Watercolor_080, then I  run the graph 1 more time with everything else  

• 00:33:15 unchanged. Now open the result for 0.8 and look  closely at the rocks. The washes there become  

• 00:33:24 blotchier, and a handwritten signature appears  in the lower right corner. The adapter can carry  

• 00:33:31 habits from its training images, such as that  signature. So inspect each result for unwanted  

• 00:33:39 marks before you use it. Here are all 4 results  side by side. Higher strength is not automatically  

• 00:33:45 better. For this brief, I would keep 0.65: clear  watercolor washes without the signature. Keep the  

• 00:33:53 trigger and strength with each result, because  the adapter's influence changes with them. Next,  

• 00:33:58 we set the adapter aside and look at the FLUX dev  weights themselves. Let us compare 2 precisions of  

• 00:34:07 the same FLUX dev image model. The text encoders  remain unchanged. I am keeping the prompt, seed,  

• 00:34:13 dimensions, sampler, schedule, and guidance  fixed while switching the diffusion weights.  

• 00:34:20 The 1st file uses 16-bit floating point weights.  The scaled 8-bit file compresses supported weights  

• 00:34:27 using scale factors. Some tensors keep higher  precision, so this file contains more than 1  

• 00:34:34 numerical format. The larger file is about 24  gigabytes, while the scaled file is about 12  

• 00:34:41 gigabytes. That is storage size. The memory  used during a run also includes the encoder,  

• 00:34:48 intermediate tensors, and other GPU allocations.  Both reference measurements use a loaded model and  

• 00:34:55 fresh sampling. The larger version takes about 17  seconds, and the smaller version also takes about  

• 00:35:01 17 seconds. Here, reducing the stored weights does  not produce a useful speed gain. Sampled device  

• 00:35:08 memory reaches about 29 gibibytes with the larger  weights, and 16 with the scaled version. This  

• 00:35:16 reading includes other allocations on the device.  It is separate from the file size. Let us open the  

• 00:35:24 larger-precision reference result. We can inspect  the full image here, keeping the composition  

• 00:35:30 visible while checking the details requested in  the prompt. Now inspect both images. The copper  

• 00:35:38 pot and blue cup have nearly the same arrangement,  while the highlights and small details differ.  

• 00:35:44 The smaller weights are useful here because  they preserve this brief with substantially less  

• 00:35:50 memory. Now open the scaled-precision reference  beside the comparison in mind. Check the pot  

• 00:35:56 highlights, the cup rim, and the shadow edges. We  are looking for changes that matter to this brief,  

• 00:36:03 rather than expecting identical pixels. If a  precision change damages an important feature,  

• 00:36:10 compare another supported format before changing  the prompt. Keep the encoder precision fixed  

• 00:36:18 during that test. Otherwise, you would be changing  2 parts of the pipeline together. 2 more fields  

• 00:36:25 belong in our saved recipe: the sampler and  scheduler. The sampler chooses how to update the  

• 00:36:31 latent at each step. The scheduler determines the  noise levels used along that sequence. Here we are  

• 00:36:39 using the selected DPM++ 2M sampler with the SGM  uniform schedule. The step count determines how  

• 00:36:47 many updates this recipe performs before decoding  the result. Those choices work with the model and  

• 00:36:54 any adapter applied to it. Start from the matched  recipe before comparing another supported pair. A  

• 00:37:00 larger step count alone does not tell you whether  the resulting image will satisfy the prompt. Our  

• 00:37:07 saved graph includes the numerical method, the  schedule, and the guidance settings together.  

• 00:37:14 Keeping all of them makes the result easier to  reproduce than saving only a prompt and the name  

• 00:37:20 of a model. Let us choose for the actual task.  For quick exploration of this poster layout,  

• 00:37:28 the Z-Image graph gave us useful iterations. The  explicit placement sentence helped across the 3  

• 00:37:35 seeds we inspected. Open the Qwen poster again for  the exact-text decision. We will keep its title,  

• 00:37:43 price, and scene visible together while deciding  which part should remain editable when this  

• 00:37:50 design is used. For the exact-text example, Qwen  Image produced the requested title and price. We  

• 00:37:57 checked every character before accepting it. A  result that looks attractive can still need a  

• 00:38:03 different route for editable information. Suppose  the ticket price changes tomorrow and must be  

• 00:38:09 exact. Would you regenerate the entire poster,  or edit a text layer over the artwork? Pause  

• 00:38:16 here and decide which operation gives you direct  control over those digits. Use the separate text  

• 00:38:28 layer for that requirement. It lets you type the  new price without asking the image model to redraw  

• 00:38:35 the scene. Choose generation for the artwork and  a direct text tool for the final information.  

• 00:38:42 For a product image or watercolor style, use  the compatible recipe whose result fits the  

• 00:38:49 brief. Compare the visible qualities you need,  then consider memory and runtime. A model name  

• 00:38:56 alone does not make that decision. Let us save  the selected graph as an ordinary workflow file.  

• 00:39:03 Give it a name that identifies the example and  recipe. The file keeps its nodes, connections,  

• 00:39:10 widget values, and the arrangement you can see  here. Here is the exported file in the lesson  

• 00:39:16 folder. Open it in a new ComfyUI tab and inspect  the restored prompt and seed. Keep the original  

• 00:39:22 graph available while you compare the 2 copies.  The model selections and sampling settings are  

• 00:39:29 restored too. The workflow describes which weights  to load; it does not contain those weights. Keep  

• 00:39:35 the source links and exact versions with the  graph so you can obtain the same components.  

• 00:39:42 For the adapter example, also keep the trigger  and strength. For our prompt experiment,  

• 00:39:47 keep the full seed list and both prompts. Those  small records make your next comparison much  

• 00:39:53 easier to understand and repeat. We started with a  vague request and turned it into visible choices.  

• 00:40:01 You have seen how words become conditioning,  how layout instructions behave across seeds,  

• 00:40:08 and why exact text needs its own inspection. You  can now compare guidance, select compatible model  

• 00:40:15 components, and test an adapter against its  baseline. Keep the result beside the complete  

• 00:40:22 recipe. Then change the part that matters to  the image you want to create. The workflow files  

• 00:40:29 and chapters are in the tutorial description. In  the next lecture, we will build on these choices  

• 00:40:35 using reference images for editing. Thank you for  watching, and I will see you in the next tutorial.