00:02This is the ultimate AI image generator

00:04It's free and open source, and the awesome thing about it is, you don't even need an Nvidia GPU

00:06You can run it with just a CPU or an Apple M1 or M2 chip, and it gives you total control

00:15Not only can you do text to image, but also image to image, plus upscaling, plus you can control the poses of your character, or you can control the positions of objects in your image, or you can control the depth of your composition, and much more

00:32You can also do face swapping and create consistent characters

00:38You can also link to popular AI tools such as Mimic Motion, which makes your character dance

00:44Or live portrait, which lets you animate any photo of a face, or Tune Crafter, which allows you to input a start frame and an end frame, and it will generate an anime scene in between those two frames

00:56The possibilities are just endless

01:02Now, the tool that we're going to go over today is called ComfyUI, and the interface looks like this

01:10So if you're seeing this for the first time, this might look very complicated to you, and that's exactly why I'm making this tutorial

01:17I'm going to show you step by step how to install it, and then how to do text to image, image to image, upscaling, how to control the pose or the composition, or for The depth of your images, plus how to download and use external tools like face swapping or ToonCrafter

01:36I'm going to make it as easy as possible so that even if you don't have any technical background on AI or stable diffusion, you can still follow along easily, so let's get started

01:43All right, first let's go over how to install ComfyUI

01:49You simply have to go to their GitHub, which I'll link to in the description below, and installing it is really easy

01:55All you got to do is scroll down, and then you'll see this installing ComfyUI section, and then note that you don't need an Nvidia GPU to run this, you can also run it on

02:07CPU only, and it also supports Apple M1 or M2, although of course, if you do it this way, or if you run it using CPU, it's going to be way slower compared to an Nvidia GPU, so if you're serious about running image generation locally, definitely do get an Nvidia GPU

02:23It's just going to make your life a lot more easier, and it's going to be compatible with a lot more other open-source AI tools

02:29By the way, I'm using a Dell Precision 5690, you can integrate a powerful RTX 5000 Ada into this

02:36Huge thanks to Dell and Nvidia for sponsoring this

02:42Anyways, I'm using Windows, so under Windows, all you got to do is click on this direct link

02:47To download, so this is going to install a 7z file, which we can unzip

02:52Now note that this is 1.4 GB in size, so it's going to take a few minutes to download, depending on the speed of your internet

02:57All right, so once you've installed the 7zip file, you can unzip it with 7zip or WinRAR, and then you're going to see this folder

03:08Now, you can extract this folder anywhere, so I'm going to extract this on my desktop, and this is a very large folder, so it's going to take a while for this to fully extract

03:16All right, so once that is fully extracted, we can now open up the folder, and then depending on whether you have an Nvidia GPU or Something else, double click on the appropriate bat file, so in my case, I do have an RTX 5000, so I'm going to run this, and then you might see this message, so we got to click more info and then run anyway

03:41And so that's how you would install ComfyUI, very simple to use

03:46Now, if you click on Q prompt, you're going to see this error message, we don't actually have any check points or models yet, so we got to download a model to use for our image generation

03:53Now, there are thousands of models you could potentially use, a model basically defines the style of your image, so for example, you can choose from realistic to Disney

04:07Pixar style to watercolor to anime, there are like thousands of checkpoints or models that you can choose from, and you can browse all of these models in a site called Civit AI, which I'll link to in the description below

04:20Now be warned though, there's a lot of NSFW content here, so make sure you have your filters on, or it's going to be very not safe for work

04:33Now, because there are like thousands of models, how do you know which one is the best? Of course, you want to filter out all the bad ones and just use the best ones

04:38Well, there's an awesome site called Image Cyst, which I'll also link to in the description below

04:45This is Basically a rankings list where users can kind of blind test different models, and then all these results are accumulated into this ranking list, so you can see, for example, that RealVis has the most points so far, followed by Colorful XL, followed by Playground version 2.5, followed by Juggernaut, which is also a very popular model, and note that most of the ones at the top are using Stable Diffusion XL, which is basically a higher quality version compared to Stable Diffusion 1.5

05:19So let's say we want to use this one, RealVis XL, I'm going to copy this name, and in Civitai, I'm going to simply search for this, so here it is

05:25Real Viz XL version 4, and here are the results

05:30You can see, if you scroll down, here are some sample images from other users, so let's just download the most recent one, version 4.0 lightning

05:36So let's go ahead and download this

05:41It is 6.4 GB, just a warning, so it's going to take a while to download, and then you would place your download, which is a safe tensors file, in ComfyUI, and then models, and then checkpoints

05:49So let's save it directly in this folder

05:55So once you've downloaded the checkpoint or the model file, make sure that it is located in ComfyUI, then in models, and then in checkpoints

06:02So notice that I have downloaded This RealVisXL safe tensors file in this folder, and so the next time you start up ComfyUI, which I'm going to do now, you should be able to select the model

06:15So again, I'm going to open run Nvidia GPU.bat, and then wait for this to give me a link

06:21All right, perfect

06:27So now, if you go back here in the load checkpoint point, if it doesn't automatically select one for you, you can click on this and note that I can select this RealVis safe tensor file in here

06:33Now note that for other tutorials, they suggest that you download the SDXL base file and also the SDXL refiner file, but this is just the default Stable Diffusion XL model

06:46Actually, this is not necessary, and right now, SDXL has gotten so good that you don't really need to use the refiner file anymore in most cases, and this base SDXL model, it's not great, so you don't have to download this, and you can save a few gigabytes of disk space

07:04Again, if you look at the rankings from Image Cy, the SDXL base files, at least the lightning model, seems to be in 12th place, so I wouldn't actually recommend you download this base model and the refiner model, so you can actually save a few gigabytes of disk space

07:17So anyways, back in here, all we need to do is download whatever model you want, and then here is The positive prompt, and then here's the negative prompt

07:29You can use your mouse's scroll wheel to zoom in and out, and I'll explain what all these boxes mean in a second, but first, let's just generate an image to see if this all works

07:36So for the positive prompt, I'm going to enter "a castle in a forest," and then for the negative prompt, this is basically all the things you don't want to see in your image, for example, I don't want to see people, cars, KN, and that's pretty much it

07:56I'll cover some more advanced prompting techniques later in this video, but let's just click "Q prompt" for now, and you can see right now it's Running this box, which is highlighted in green, and then it's running the positive prompt, the negative, it's going through the K sampler, and then now you can see the progress bar is up here, so it's in the process of generating the image, and then it goes through this VAE decode, and finally we get an image of a castle in the forest

08:11Now, this image is not great, and we're going to go over how we can make this better

08:26Now, first, I want to really give you a solid understanding of what all these boxes mean, because I think it'll help you when you build more complex workflows, so first of all, let's just ignore all of this and Start from scratch, so if I move down here, you can start a new box or node by right clicking, and then you can see "add node," and you can select whatever you want

08:41Now, there are so many options here, I wouldn't recommend this way, so another way to do it is to double click, and then after you double click, you can actually search for whatever node you want

08:53So if I type in "checkpoint," for example, you can see that we have a "load checkpoint" node here, so I'm going to select this, and because the RealViz model is the only model I have in this models folder, it selects this by default

09:05So again, this checkpoint basically defines the Style of your image, for example, there's going to be some that work particularly well for anime, some that work well for realistic photos, and then some that work well for Disney Pixar-like characters

09:17All right, so next, we need to add in our positive and negative prompts

09:24Now again, we can either right-click and try to find the positive prompt node here

09:29I would not recommend that, it's really hard to find a node in these options, or you can double-click and then search for the node here, in which case we see it here, or another way is to drag from one of these connectors, so the prompts should be linked to this clip

09:46connector, so I'm going to drag a noodle out, and then once I release it, you can see that it gives me several options, which it thinks is most relevant, and indeed the prompt window is this one, clip text and code, so we actually need to drag two of these, one for the positive prompt and one for the negative prompt

10:08Now, there are several ways to clone this node, so one way is to right click on this and then click clone, in which case we'll have another node here, but then we'll need to connect this ourselves, so I'm just going to delete that, and then another way is you can just click on this and press Ctrl C to copy it, and if you Press Ctrl+V to paste it

10:27This is what you get, but if you want this to have the same connectors as this original node, then instead of pressing Ctrl+V, you can press Ctrl+Shift+V, and so now when I paste in this node, it's automatically connected to this

10:40Now, just to avoid confusion, you can also rename this, so for example, you can set the title to "positive prompt" and then press okay, and then here you can right click and then set the title to "negative prompt" and then press okay

10:59You can also set the color if you want, so for example, I can right click, and then in colors, I can set this to red, and this is important because

11:06When you build more complicated workflows, this graph is going to be really complicated, so if you color code things and rename these nodes, it just keeps things more organized and helps you avoid confusion

11:12All right, next step is we need something called a K sampler, and it's basically an algorithm that takes in your prompts and takes in a latent image, which we'll go over in a second, and create an image from that

11:26So if we click on this conditioning connector and drag it out, we should see K sampler here, so I'm going to select that

11:37This is for the positive, and then for the negative prompt, we will connect this

11:42To here, and then for the model, we just drag this one all the way to here where it says model, and then for latent image, let's drag a line out, and then here it would give us the option to create an empty latent image

11:54So, so let me just drag this over here to keep things cleaner

11:59All right, so what on Earth does this mean? What exactly is an empty latent image? So, how stable diffusion works is it doesn't create an image from a blank canvas, actually what it does is it starts with an image of just random noise, and then at every step, it removes some of that noise, and if you remove enough noise, you get whatever image you prompted

12:20It, with so this empty latent image, is basically an image of random noise, and you can select the width and the height, so for example, we can change this to 800 if you want, and then same with the height, 800

12:38By the way, for SDXL, it's best to create an image of 1024 x 1024, because that is what it's optimized for, and then if you are using Stable Diffusion 1.5 or earlier, it's best to use 512 x 512, and then the batch size is how many images you want, so if you set this to two, basically it will create two images at once, but for now, let's just set this to one

13:02All right, so next, let's go over all these settings, the seed is

13:07Basically, the starting point of this random image, this image is just random noise, but there could be an infinite number of images of random noise

13:19Each of them would be slightly different, so the seed basically defines the starting point, and usually we keep the seed at random, so that's what this one does

13:26However, if you keep it at fixed and you set the C to a certain value, for example 69, then if all of the other settings are the same, you're going to generate the same image every time, because the seed, or the starting number, is the same

13:43But for now, let's leave it at zero, and then for here, let's set it to randomize, and Then the number of steps is basically, again, if we go back to how stable diffusion works, is how many steps of noise removal do we want? So if it's just a few steps, you're only going to get something like this, you haven't removed enough noise yet, and after enough steps, you're going to get a very clean image of whatever you want to generate

14:08So generally, few steps would give you a lot of noise, and then after a point, like if you exceed 50 to 100 steps, then you're not going to get a better image, in fact, you might get some noise or artifacts because there's not much remaining noise to be removed, so I'm just going to keep The number of steps at 20 for now, and then CFG is basically how well do you want this algorithm to follow your prompt, so if you set this to one, for example, it's not going to follow your prompt, and it's going to try to generate whatever it wants

14:39Basically, it can be more creative, however, if you set it to 15, for example, then it listens to your prompt very literally, and it tries to generate whatever you specify in your prompt, which is sometimes not what you want

14:52Sometimes if it's too literal, you're going to get some weird results, so generally a value of like seven or eight would work best, and then the sampler name

15:00This is basically the algorithm that's used to remove this noise and generate the image for you

15:08So Euler is a common one, this is one of the fastest ones, and then if you want to go for quality, I would suggest one of these, so DPM++ 2M or 2M SD, but for now, let's just go with Euler

15:16And then for scheduler, this basically gives even more quality, so usually if you want a really good quality image, you would select Karras or exponential

15:27These settings are just very subtle differences you can add to the image, so just play around with it, so you can get a feel for what settings work best for your particular use case, and then den

15:41Noise, what this is, is because again, our latent image or starting image is basically an image of random noise

15:46The denoising strength is basically how much noise do we want to remove from this initial image

15:53So if we're starting from scratch, then obviously we want to remove 100% of the noise, so that's why this is set as one

16:01All right, so the next step is we next need to connect this latent connector, so I'm going to drag this out, and we need to connect it to what is called a VAE decode

16:07A VAE basically encodes an image into a latent space, but right now we want to do the reverse of that, so we need to decode this latent

16:20Image into an image that we actually want to see, so that's why we need this final step to decode this latent image, and then we need to drag the VAE from our checkpoint to this VAE connector that we see here

16:33So, in most cases, your checkpoint should come built in with a VAE, so all we got to do is just connect this VAE to this VAE connector here, and then we are almost done

16:50Right now, we just need to produce the image, so once we drag this out, we actually have two options: we can either preview the image, so if we preview the image, it's not going to save the image in our computer, or we can select save image, which also shows us a Preview of the image, but it also automatically saves the image, so I'm going to select preview first, because I don't want it to save every image it generates

17:09I only want to select the good ones to save on my computer, so I'm going to show you how to save a previewed image in a second

17:16There are very few software tools that I use every day, but this is one of them

17:23Thanks to our sponsor, Turbo Type, it's free forever, and it saves me so much time

17:30Basically, you can create custom keyboard shortcuts so that you don't need to keep typing out repetitive things

17:36For example, if there's a prompt that I use in Chat GPT very often, I Can make a shortcut here, and then when I go to Chat GPT or anywhere else, I just need to type in the shortcut and voila, or let's say I have a very long email address, I can also make a shortcut for that, so that whenever I need to enter in my email, I can simply type in the shortcut and it types out the email

17:55Finally, it also supports Rich Text, for example, you can add in bold and italics and add links to your text as well, so let's say I need to send out a lot of cold emails with the following template, well, I can just create a shortcut for that, and then whenever I start an email, I just need to type in the shortcut and voila, the text

18:07Is already styled and linked for me

18:19There are hundreds of pre-existing templates that you can choose from, including common prompts for Chat GPT, business, finance, medicine, and more

18:27This tool saves me so much time every day

18:35There's absolutely no reason not to use this because they have a free forever plan, so definitely check it out and download the free Chrome extension in the link below

18:43But that is pretty much it

18:52So for the positive prompt, let's put a "med evil warrior, realistic 8K masterpiece." These are just some keywords that I tend to use a lot to give it more detail, and then also ultra detailed is

19:00Another good one, and then for negative prompts, again, these are all the things we don't want to see in our image, so for example, I don't want it to painting or a cartoon or anime drawing, I don't want it to have any copyright or watermarks, and I think we are good to go for now, so before we click run, note that I had this previously, this is the default, so I don't want it to run both of these at once, so I'm going to select all of these nodes and delete them, so to select multiple nodes at once, what you can do is hold down control and then drag to encompass all the nodes that you want to select, and then if you want to move this

19:39To group of nodes around, you need to hold down the shift key, and then you can drag this wherever you want, and then to delete everything at once, all you got to do is press delete

19:51All right, so moving back down here, everything else looks good, so I'm going to press Q prompt

19:57So note that it's starting here, it's loading the checkpoint, and then it's moving over to K sampler

20:05Now it's generating the image, and then it's decoding the image, and then voila, we have a medieval warrior

20:12So basically, this is like the standard workflow for a simple text to image generation, and then let's do another one, so let's say I want to

20:24Generate two images at once, all we got to do is increase the batch size to two, and then press Q prompt again, and note that it starts off here, it starts in the case sampler, it doesn't start here or here, and that's because we haven't changed any of these other nodes in a previous step, so all of this is already saved in memory, it only loads from here, and so this makes ComfyUI very efficient, and then so now we have two images, this is the first one, here's the second one, and remember this is not saving your image, this is just the preview image node, so to save it, all you got to do is right click and then press save image, so this

21:06Is the most basic text to image workflow for stable diffusion, hopefully this gives you a better understanding of what a K sampler is, what an empty latent image is, and what a VA decode is, because once you set up more complex workflows, you're going to need to understand what these nodes actually do, so I hope this gives you a good understanding

21:27All right, before we move on to the next section, let's go over some tips and tricks for navigation and organization and productivity

21:34So first thing is, I'm not sure if you can see it on my screen share right now, but there is a very faint dark blue frame on your ComfyUI

21:48canvas, so I'm hovering my cursor over that frame right now

22:02I wish they could make the contrast higher so you can actually see the blue line, but anyways, there's this very faint blue line, and so whenever you start an interface, the default location would be within this blue frame, so it's always best to have your workflow within this blue frame, so that whenever you load up ComfyUI, your workflow will show up right away, and you don't need to, like, try to find it within this huge canvas

22:16All right, next thing you can do is, let's say this is a workflow that you want to use again in the future, you can click this to save it, or Press Ctrl+S, so let's name this as "temp.json", and then you can save this wherever you want

22:25I'm just going to save this in the ComfyUI folder

22:34Another keyboard shortcut to be aware of is Ctrl+A, which is select all, and then delete or backspace, which will delete everything you've selected

22:42All right, so right now this whole workflow is gone

22:49Now I can undo it by pressing Ctrl+Z, which would undo my delete of the workflow, or I can also redo the action by pressing Ctrl+Y, which deletes the whole workflow again

22:54Now, to load up a previously saved workflow, you can press load here or press Ctrl+O

23:00So if we go into our ComfyUI, folder, and then select this temp

23:03Json, which we just loaded

23:07You can see it has loaded our workflow back up

23:11Now, a few shortcuts for navigation: you can either press on your mouse and then move the canvas around, or you don't actually need to click on your mouse

23:18You can also hold down the space bar and then move your mouse around, and it would still move the canvas

23:23Now, you can zoom in and out by using the scroll wheel, and then to select multiple nodes, you just simply hold down control, and then select this one, and then let's say I want to select this one, and select this one, so I'm holding down control for each of these

23:36And then, let's say I want to delete these

23:44I can just press delete, and then let me undo that by pressing Ctrl+Z

23:52You can also select multiple nodes by holding down control and then dragging a frame around all the nodes you want to select, and then if you want to move these nodes around, simply hold shift, and then you can drag this group of nodes that you've selected wherever you want

23:59Another thing you can do is, let me delete this first

24:06Now, every time you drag a connector out, there's also an option called reroute, so if I click this, it's basically just an extra blank node which extends your connection further, so

24:13It's basically the same thing as just connecting this VAE to this VAE, but the nice thing about this is, let's say you don't want this line to be hidden behind this node, well, you can do it out like this, so you can clearly see that this line is being connected here

24:31And then one more thing is, right now you see that, for example, in K sampler, these values are set in this node, but what if you want to set this value somewhere else and then link it to here? So, for example, for CFG, if you want to set this value somewhere else and then link it to the K sampler, you can right click on this, and then under convert widget to input, you can

24:54Set any of these options to an input, so let's say we want to set CFG to an input

25:00Now you can see that CFG has disappeared from here, and it is now an input connector, so let's drag this out, and then we need to actually use the node called primitive

25:11So right now, this value is set to seven, it's connected to this CFG input, so the CFG of this case sampler is seven, so that's how you would use it

25:18All right, one final thing I want to share with you, and this is really cool

25:25Let me press Ctrl+A and delete all of these

25:32Let's say I made an image previously using ComfyUI, well, if I drag that image onto the canvas, what happens is it actually gives me The entire workflow that I used to create the image, how cool is that! So, like, if you go online and other users have shared their ComfyUI generations, and assuming they haven't deleted that metadata, you can actually download their image and then drag and drop that image onto ComfyUI to look at the entire workflow that they used to generate that image

25:44This allows you to learn really quickly

25:56So those are, like, the basic things you need to know for organization and productivity using ComfyUI

26:08So let's move on to the next section

26:13First of all, we need to install this plug-in called ComfyUI Manager

26:19It will make your life a lot easier for installing extensions and plugins and missing models, so I'm going to link to this GitHub repo in the description as well

26:25And if you scroll down a bit, they will give you some installation instructions

26:31So in our ComfyUI folder, and then in our custom nodes folder, we just need to open command prompt here

26:37So in this bar up at the top, type in CMD, and this will open up our Command Prompt, and you can see that we are now inside our custom nodes folder

26:48Next, all we got to do is get clone this repo, so we will paste it in here

26:52Now, you do need to have Git installed first

26:55If you don't, here's how to install Git

26:59If If you already have Git installed, feel free to skip to the next section

27:02So all we got to do is download the latest release for whatever operating system you're using

27:06So I'm using Windows, so I'm just going to click on download for Windows

27:10I'm running 64 bit, so I'm going to click on this to download, and it's now downloading this EXE file

27:14So once that's completed, all we got to do is open that EXE file and then follow the steps

27:20So I'm going to click on next

27:25I'm just going to go with the default install location, which is program file SLG, so I'll click next for that, and then I'm just going to leave this at the default and Then I'm going to click next again, and click next

27:31Here, we're just going to use the default settings for all of these

27:37There's a lot of settings that you need to go through, so I'm just going to click next for all of these

27:42All right, and then it should go ahead and install all the files, so this might take a few minutes

27:49Perfect, so now we have Git installed

27:55All right, so assuming you have Git installed already, you simply copy this line and then paste it in here, and then press enter, and you'll see that now we are cloning this ComfyUI manager into the custom nodes folder, and then if you actually open up your custom nodes

28:02folder, you can see this new folder called ComfyUI Manager

28:08All right, so next, we need to restart ComfyUI, so going back in our Windows portable folder, we are going to run ComfyUI again, and you can see that it has detected that we have ComfyUI Manager installed, so it's now installing dependencies

28:22All right, so after you open your ComfyUI up, now you should see this manager button in the right menu, so next, I'm going to show you how to upscale an image, and then we're also going to move on to some more advanced workflows like image to image and ControlNet and installing other plugins, so first, let's click on this

28:42Manager button, and then the main buttons that you will use is this one: custom nodes manager

28:48There's also a button where you can, like, update ComfyUI, or update all, or install missing custom nodes

28:55For example, if you import or a workflow that was made from another user, you might have some missing models or nodes or dependencies, so clicking this button will just automatically install all of them, so that this other user's workflow will work on your computer

29:07And then here, this is model manager, so instead of going to Civit AI and browsing through all the models, you can just easily download the model here

29:14Through this interface, so let's click on this, and then let's search "upscale," and you should see a lot of different upscaler algorithms

29:26So usually the ones that I find work best are Real ESRGAN x4, this is for realistic photos as the name implies, and then there's also 4x Ultra Sharp, which works pretty good as well

29:38Just to keep it simple for this tutorial, I'm just going to download these two, but definitely you can install all these and play around with it and see which algorithm works best for you

29:47So I'm going to select these two and then click install

29:56All right, so after it is finished installing, note that you Need to click the refresh button on the main menu to apply these installations, so we're going to click close, and then close again, and then click refresh

30:03All right, let's dive in to see how we can upscale images

30:10So we're going to use the same prompts: a medieval warrior, realistic 8K masterpiece, ultra detailed, and then for the initial image width and height, let's set it to 512

30:17Now, I understand that for SDXL the optimum dimensions are 1024x1024, but in this example, I'm just going to show you a really blurry and low resolution image, and then we're going to upscale it by four times, so you can clearly see the before

30:26And after, and then for the batch size, let's leave it at 1 for now

30:35Number of steps, we can also leave it at 20

30:44And then here, instead of preview image, let's delete that, and then we can just drag this image out

30:49And then we don't see any upscale here, so we need to click search, and then we can search upscale

30:54Now, there are a few options

31:00One is upscale image, which is kind of the same as upscale image, but and then we have upscale image using model

31:06Now, I'll show you what this one does first

31:13Upscale image, I would not recommend this because this is basically just upscaling your initial image, but it's not adding any details

31:19It's basically just increasing the size, so let's say we want to upscale this by two times, so instead of 512 x 512, it's going to be 1024 x 1024

31:24And then for the image, let's drag it out, and we will have a preview image node, and also I want to preview the image before we upscale it, so you can compare the before and after

31:38So over here, I'm also going to drag a preview image node

31:45All right, now let's run this and see what we get, so I'm going to press Q prompt

31:51All right, so let's look at the initial image, this is only 512 x 512, so I'm zooming in quite a bit, and you can see the details of his face are very blurry, and then let's look at The upscaled image, yes, this is 1024x1024, but you can see the details are the same

32:02This is pretty much the same image, the same blurriness

32:13We're not adding any details here, so again, it's not recommended to use this upscale image by method because you're simply just resizing the image, but you're not adding more details to the image, so I'm going to delete this one and also this one

32:25So next, let's drag out another node, and this time I'm going to search upscale again, and then we are going to use upscale image using model, and then after that, we need to actually input an upscale model, so I'm going to drag this node out

32:39And then we should get the one and only option, which is upscale model loader

32:46So because I've downloaded for X Ultra sharp and real ESRGAN, we should automatically see this over here

32:51Now both of these are for X, so your output image will be four times the resolution

32:59If you want 2x for example, well, you can go into manager again, and then click on model manager, and then find an upscale model that is only 2x, like this real ESRGAN X2

33:05All right, and then just one last step is we need to drag out another node to either save the image or preview the image, so if I run this again, you can see that if I zoom in on both of these, this is 512

33:31x 512, so the details are very blurry, but if you expand this image, which is like over 2,000 * 2,000, you can see that the details are a lot sharper, especially the patterns on his helmet and on his armor

33:43Now, this isn't the best way to upscale, it's actually best to do one round of image to image first before we upscale, so I'll show you that in a second

33:51So, one more thing I want to mention is that sometimes you don't want to upscale all the images that you generate, you want to decide which image you want to upscale, because let's say for this initial image you don't like the design, you don't like the composition, you don't Want to proceed further with upscaling and waste computing resources? So how do we decide if we want to upscale or not? Well, first of all, you can break off a workflow by selecting the node where you want to break it off

34:21In this case, I want it to pause here, so it only generates the initial image, but it doesn't proceed further to the upscale unless I want it to do that

34:27And then I'm going to press Ctrl+M, and this will mute the node, and basically everything that goes after this point is going to be paused until I unmute this node

34:38Now, when I press Q prompt and it generates an image, I can decide whether I want to proceed

34:43Further with this upscale method, and if I do, then I would unmute this node and press Q prompt again

34:50However, one thing to note is, in this case, you do need to set the same seed

34:57Otherwise, if you don't set the same seed when you press Q prompt again, it's going to generate a completely different image, and then it's going to upscale that image

35:03So going back to here, we need to actually set this to fixed, so it's going to be a fixed seed

35:11And then, so if we run Q prompt again, you can see that it's generating a new image, and that image is being fed into here

35:20And then, let's say I like this image, I want to upscale it, then I would click

35:30On this node, which is now muted, I'm going to unmute this by pressing Ctrl+M, so now when I press Q prompt again, you can see it's actually proceeding from here, and then now it's upscaling this image, and we can now see our upscaled image, so that's one way to do it

35:39Another even more efficient option is if you go back to manager, and then click on custom nodes manager, and then let's search for image chooser, and this is a node that's created by Chris Orange, let's go ahead and install this

35:52All right, all right, so it says restart required, so let's restart this

35:58All right, so we are back here, now let's say we want to generate

36:03Four images, and we would choose one of them to go through the upscale

36:08So let's increase the batch size here to four, and then we can keep everything as is

36:12For the seed, actually, we can set this back to randomize, and then yes, this has to go through this VAE decoder to decode the latent image, and then instead of preview image, let me just delete that

36:25Let me also delete this node for now, and then let's drag this image out, and we will search for preview chooser, which is down here, and then for any images that we select here, we can then proceed to upscale it

36:37So let me just run this for you first, so you can see what this does

36:44Right now, it's loading the checkpoint again because we've restored the interface

36:48Now, it's inputting the positive negative prompts

36:52Now, it's generating four images through this case sampler

36:57Then, it's going to decode these four images, and then, so now we have four images

37:02All right, so let's say we want to select this one to upscale, so we would click on this, or if you want to select more, you can always increase the count to two and then select this one, for example, but I'm going to decrease this to one and unselect this, so we are only going to proceed with this image through the upscaler, and then we simply click

37:21Progress, selected image, and then this would go through the upscaler, and it's using our Forx Ultra Sharp model, and then voila, here is our upscaled image

37:28So, in a nutshell, that's how you do upscaling

37:33Now, there is an even better method to upscale images, which kind of uses image to image

37:41So next, we're going to go over how to do image to image, and then we're going to go back to this better upscaling method

37:47All right, next I'm going to show you how to do image to image

37:54So what I'm going to do is, first of all, hold control and then drag these nodes to select all these nodes

37:58I'm going to copy it and then paste it somewhere

38:02Here, and then I'm going to hold down shift, and then move it to where I would like

38:07All right, now going back to this, another way instead of just deleting this workflow is to hold control and select all of this, and then press Ctrl+B to bypass

38:19So if you see the nodes highlighted in purple, that means it will be bypassed, this will not run, so only this will run

38:24All right, so this is our standard text to image workflow, right? We have our checkpoint, and then we have our positive prompt, our negative prompt, this goes into the K sampler, the K sampler takes an latent image, which is just an image of random noise, and then

38:43After going through this algorithm and going through this amount of steps, then the final step is we need to use our VAE to decode this latent space back into an image that we want to see

38:56Now, for image to image, we don't want to start with an image of random noise, right? We want our input to be an image, so let me select this node and delete that, and then I'm going to double click anywhere and then search for "load image," so let me click on this

39:04So this is the default, but you can click this button to upload an image

39:13I'm going to upload this image

39:22Now, we can't just directly drag this image to this Laton image connector

39:28That's because we need to first convert this image to a latent image, and then connect the latent image into here, so let me drag this connector out, and you should see the first option here would be VAE encode, and that's exactly what we want to do

39:44We want to use a VAE to encode this into latent space, and then drag the latent image onto this connector

39:51All right, and then where do we get our VAE? Well, we can just get the VAE from the checkpoint that we loaded, so let's drag this to here, and then you can see that everything is connected

40:00Now, we do need to set up some additional settings for the K Samplers, so one thing I forgot

40:09To mention is that if your checkpoint is lightning, it only takes around like five to eight steps

40:17You actually don't need 20 steps, that's the awesome thing about lightning models, and some models can even generate a decent image in as few as two, two steps

40:25For us, let's set the steps to seven

40:28Sampler schedule, we can leave it as is

40:32Denoise, this is what we want to change

40:36If you remember, for our text to image, denoise this is saying to take our latent image of random noise and replace 100% of that noise so that we get the image that we specified in our prompt, but in this case, because we're not starting with random noise, we're Starting with an image, we don't want to remove everything, we want to retain some of this image

41:00So, in this case, if you're doing image to image, the noising strength means how much of this original image do you want to remove

41:07So, if you set this to 100%, or 1.0 in this case, it's going to remove everything from this image, you're going to get a completely different image

41:14Conversely, if you set this to zero, then it's just going to produce this exact image, nothing would change

41:20So, depending on how similar you want the image to be, it's better to have something in between, so let's do 0.3 first, so it's more similar to this

41:28Image, and then I'll show you an example of eight for comparison

41:37All right, so now that we have everything in place, there's just one final step, which is to drag this image connector out, and then we are going to preview image

41:46Let me just reposition this here so you can see the entire workflow, and we are good to go

41:51Let's click "Q prompt." So it's our first time starting this workflow, so it takes some time to load in the checkpoints, and then it's going through the prompts

41:59It's taking this image and encoding it

42:05It's now going through this K sampler, and then it's going to decode the image and then preview the image for us all

42:09Right, perfect

42:13So you can see, if I drag this over here just temporarily for comparison, this is image to image

42:17So here's our original image, here's our new image, and the denoising strength was set to 0.3

42:22All right, let me now try one with 0.8, for example, and you should see that it would be less similar to the original image

42:30So I'm going to set the denoising strength to 0.8, press okay, and then run this again

42:37And notice it's not starting from the beginning, it's starting from here because this is the last note where we changed the settings

42:42So again, this makes ComfyUI very efficient, and now it's decoding it, and you can see

42:48For this one, it's more different compared to the original image, so basically, in a nutshell, this denoise value determines how similar do you want your output image to be compared with your uploaded image, all right

43:02Now, remember how I said there's a much better way to upscale images using image to image? Well, now that we've gone over image to image, and specifically the denoising strength setting, I can now show you a much better way to upscale images, and this is one of the best ways to actually upscale images

43:27In order for this to work, we need to download another node, so let's go into manager and then click on Custom nodes manager, and this time we are going to search for ultimate SD upscale, so let's click install here, and after it has installed, it says we need to restart ComfyUI, so let's click that

43:46All right, so let's start with the default text to image workflow, and I'm going to show you how to set this up, so instead of the K sampler, this new node is basically going to replace the K sampler, so let me hold control and then select all three of these nodes, and then click delete, and then I'm going to drag a connector out here, and then search for ultimate SD upscale, and then we are also going to connect the negative prompt

44:13Here we're going to connect the VAE here, and also connect the model here

44:18This time, we are not going to use a latent image, so I'm going to delete that

44:24And then instead, we need to upload an image, so I'm going to drag a connector out from image and then select load image

44:31And then I'm going to choose this image

44:38Now this is a 512x512 image that we generated previously, you can see it's very blurry

44:43And then for the prompt, we are going to set this to the same prompt that we used before, which is medieval warrior 8K Masterpiece Ultra detailed realistic

44:50And then for the next negative prompt, again same as before, we are going

44:57To type in anime, 2D cartoon painting, watermark, all right, so we are almost good to go

45:03One last thing is we need to select an upscale model, so let's drag this connector out and then select the one and only upscale model loader, and this will pull up the upscaler models that we've downloaded previously in this tutorial, so let's go with 4X Ultra Sharp

45:17And now what this ultimate upscale does is called tiled upscaling, so let's say we upscale this by two, what this is actually going to do is break this into four sections, so it's 2x2, and then it's going to apply image to image for each quadrant, so it's going to Generate image to image for this one, and then image to image for this one, and then this one, and then this one, and then it's going to stitch all four quadrants together to give you your upscaled image

45:49And now the trick is, if you use image to image with this, with a low denoising strength, again, this is how much of your original image do you want to retain, then this method is actually a lot better than just upscaling with 4X Ultra sharp

46:09So again, the key here is to set a denoise strength to a relatively low value

46:18I think 0.2 is a good start, or you could even go with 0.15

46:27All right, so all of these settings we've Gone over before, tile width and tile height just refer to the dimensions of each one of these quadrants, so this one would be 512 x 512, this one would also be 512 x 512, or whatever you set here

46:36Usually, you would just set this to the width and height of your original image, and then mask blur and tile padding, this just refers to how well these tiles blend together after they are glued back together to form your final image, so I just tend to leave it at the default, but feel free to play around with these settings if, for some reason, you get a very obvious line in between tiles, and then that's pretty much it, the final

47:02Step is to drag this connector out, and then I'm going to select preview image

47:08All right, so let's click "Q prompt," and I'll show you what that gives us

47:15All right, so if you now compare these two images, you can see that this is a lot more detailed, and the details are a lot finer

47:21Now, previously, we did a clean 4X Ultra sharp upscale, which looks like this, right? The details are not great

47:28You can see the hair doesn't really look like hair, same with his facial hair, same with his face, it still remains blurry

47:39Now, this is 4 * 512, so this is 2048 * 2048, right? Now, this is only 1024 x 1024 since we upscaled it two times, so to give you an Apples to Apples comparison, we can either set this value to four, which would upscale it four times, or let me show you another trick you can do to upscale this further, and this really shows the versatility of ComfyUI

48:04You can literally just customize the workflow to whatever you want, so let's leave this to two and then get rid of this, and then we can actually plug in another ultimate upscale here, so I'm going to click search and then search ultimate again, and then for model we can drag model here, positive prompt we can use the same one, negative prompt we can also use the same one, VAE we can drag that from the

48:29Model, and then upscale model, we can also use the same one, or a better way to do this is, let me just select this node and delete it again, is to click this, press Ctrl V, and then over somewhere here, press Ctrl Shift V, and it would automatically link everything that is linked from the node that you are copying

48:53Now, we don't want this original image to be linked here, so let me get rid of this linkage, and instead, we just want to pass our 2x upscaled image to here to upscale by 2x again

49:04All right, now the only thing that we need to change is because this image that is being passed here is now 1024 x 1024, we should set the tile

49:12Width here to 1024 by 1024, all right, so now if we drag this out and select preview image, let me run this and I'll show you the insane quality that this can generate compared to if we just did a normal upscale method like this

49:32All right, so here is our preview image, let me just save this first, and then I'm going to pull both of these side by side

49:38On the left, this is only using the 4X Ultra sharp to upscale my image of 512x512 to four times, and then this one is using ultimate upscale to upscale my image four times

49:52Now notice the insane difference, if I zoom in on this guy's face and zoom in on this guy's face, notice how much

49:58More details, this ultimate upscaler is able to generate his facial hair, his eyebrows, his eyes are super detailed, the lighting on his nose also super detailed, whereas for this one on the left, even though it's the same resolution, his face is just blurry and his facial hair does not look realistic, his eyebrows, his nose are super blurry, and then same with the crown here, you can see the details are really lacking in this left photo, whereas for this one with the ultimate upscale, everything just looks super sharp and crisp

50:36Now notice that because we are using image to image with a denoising strength of 2

50:43There are going to be subtle differences from the original image, so for example, you can see this dude is looking straight at the camera now, whereas this guy is looking slightly to the right, and that's because it doesn't just take the original image and upscale it

51:01So if you really want to retain 100% of your original image, then I think this method is better, however, if you're okay with changing some of the details to get a much sharper and more detailed image, then Ultimate Upscaler is one of the best options out there

51:13So yeah, at least for now, Ultimate Upscaler, or basically this is tiled upscaling, this is one

51:20Of the best methods to upscale images, and it basically takes your image and breaks it down into tiles, and then for each tile, it does image to image, but with a very low denoising strength, so that it retains most of the original image, but it just adds more detail to that image, and then it glues all these tiles back together to give you your upscaled image

51:32This is one of the best upscaling methods out there right now, so that covers upscaling

51:43Next, let's move on to some more complex stuff

51:55All right, next I'm going to show you how to use ControlNet in ComfyUI

51:59Now, what is ControlNet, and why do we need to use it? Basically, it's a tool to really help you customize your image

52:04If you're serious about image generation, you got to learn ControlNet

52:08So, for example, you can really control the pose of your generation by using an OpenPose pre-processor

52:19So, you would upload a pose like this, and I'll show you how to do that in a second, and all your generations would all align with this pose

52:25So here's another example, and you can see all these generations follow this pose to some extent, and you can also adjust, well, how much do you want your generation to follow your pose? Here's another example

52:31It's a very powerful tool, instead

52:37Of pose, you can also create a depth map and use that as a reference

52:43So, for example, if you upload this depth map, all your generations would have the same depth map to some extent, including the lights, including the laptop top

52:55This is a really powerful way for you to control what objects show up in what areas in your image, and then here's yet another example

53:01This is especially useful if you have multiple characters and the scene is very complex, but you really want to control where those characters are in the scene, then again, this is a great tool to give you more control over those settings instead of a depth map

53:17You can also upload something called a Canny pre-processor, which is basically just lines, and you can see your generations would follow this Canny image

53:23Here is another example, so ControlNet is very versatile

53:29There are so many things you can do with this

53:35Something that's very similar to Canny is line art, so it's essentially the same thing

53:42You take an image, and you break it down into line art, and then use that as a reference image for your future generations

53:49So you can see all of these generations follow this line art to some extent

53:56Here are some additional examples, and if you want to generate anime, There's an even better line art pre-processor called Anime Line Art, and this is more optimized for anime

54:03So, as you can see here, if you want the same pose, the same outfit for your character, but maybe you want different colors, different backgrounds, well, you can use this option to generate those images

54:10Here's another example

54:18And then, similar to line art, there's also Scribble, where you can draw in some lines, and then that would also influence your generations to some degree, as you can see in these examples

54:26This is also a good one, so you can take any image and break down that image into different segments, and Use that as a reference, and you can see all your future generations would also follow the guidance of this image

54:39Here's another complicated example, and you can see it's able to control for all these objects very nicely

54:47You can see with this segment pre-processor, you're able to control the location of all these people, all these objects very precisely in your image

54:51All right, so let's jump right in

54:56How do we use it? So first of all, let's start with a very simple text-to-image workflow

55:00This is just your positive prompt, negative prompt, you're taking in an image of random noise, you're plugging it through this

55:06case sampler, it's going to decode it and give you your final image

55:10Now, let's start with adding ControlNet

55:14First of all, in this manager section, let's click on that, and then we'll click on model manager, and then we'll search for ControlNet Union

55:19This is the newest ControlNet model, and it basically includes all of these options that we just talked about, so you don't need to go in and install all of those pre-processors separately

55:33So, let's go ahead and install this

55:39Note that it is 2.5 GB, so depending on the speed of your internet, this might take a few minutes to download

55:44All right, after we've installed, Note that we need to click the refresh button, so let's click close here, and then close, and then click refresh

55:51All right, so how do we use ControlNet? It might not be intuitive, but we don't actually link ControlNet to the latent image, we actually link it to the positive prompt

56:04So let me select this node and delete it first, and then I'm going to move up here for a bit

56:11So let's drag this connector out, and then search for "Apply ControlNet." So again, it's not intuitive, but ControlNet is actually applied to the positive prompt before going into the KSampler, so we are going to drag this conditioning connector

56:22Back into the positive connector of the K sampler, all right

56:29And then the next step is we need to select a ControlNet model, so let's drag this out, and then it's just the first option here, which is ControlNet loader

56:37So if that ControlNet Union was the only thing you've installed, this is the only model you should see

56:45If not, you can click on this, and it would have a drop down of all the compatible ControlNet models that you've downloaded, but again, this is the only one you need

56:56This is the newest one, and it contains all of these options for you, so you don't have to go ahead and download each of them separately

57:02All right, so the next step is the image

57:07First of all, I'm going to double click here and then type in "load image," and then select this node

57:13And then let's say I want to specify a certain pose for my generation, so I'm going to upload this image, and I want whatever I generate down here to follow this pose

57:25So what we need to do is actually load this image to a preprocessor

57:31Now, in order to do that, we need to download another node, and you know, this is kind of messy

57:36I wish we can just merge all of these nodes together into one node just to keep things cleaner, but anyways, it is what it is

57:43Let's click on manager and then click on

57:49Custom nodes manager, and then we'll search for "Art Venture," and then you should see this one, "Comfy UI Art Venture." Let's click on this to install it, and I'll show you what this node does in a second

57:56All right, so after we've installed this node, it says we need to restart Comfy UI, so let's click on restart and then click okay

58:03All right, so we are back after the restart, everything is still here, so what we need to do is link our uploaded image to a preprocessor, which is the node we just installed, so let me drag this out, and then I'm going to search for "Control Net Preprocessor," and we should see this AV control nit

58:27Preprocessor, so let's click on this, and then why did we install this instead of all the other options we could choose from? Because this node allows you to select from a lot of different options, so for example, we can choose SDXL, which is what we are using, right? Our checkpoint is SDXL, and so the reason why we downloaded this node in particular is because it contains all of the pre-processors you need, all in one node, so basically you can select things like open pose, or depth, or canny, or line art, or all of these other examples that I showed you previously, so let's start with the simple one, let's start with open

59:06Pose, so I need to convert this image into an open pose image, and then for the SD version, we are going with SDXL, and then resolution, let's set this to 768, and then let's set the width and height of our final image to 768 as well

59:26Note that for SDXL, it's actually best to use 1024x1024, and it doesn't have to be square, but just to make our generation faster, let's go with 768, and then finally, we just need to drag this pre-processed image into the image node of ControlNet, and then here, the strength is, well, how strong of an influence do you want this ControlNet, or basically this pose, to influence your final image, so 1 is 100% is 0%, 0 is 0%

59:49If you set this to zero, then you're basically not using ControlNet at all, and so let's set this to something like 0.8, for example, and see what that gives us

01:00:04All right, so just a quick summary: how you would use ControlNet is, it actually goes in between the positive prompt and the KSampler, and then for ControlNet, what you need to do is upload an initial image, and you need to process that initial image into whatever pre-processor you select, and then it would turn that processed image and add it to the ControlNet

01:00:23So actually, what I'm going to do, just to show you what this actually looks like, is I'm Going to drag a connector out here and then click on preview image, so you'll see what this open pose image looks like

01:00:41And then what I'm going to do actually is hold control and select all these nodes, and also select this one, and then press Ctrl+B to bypass them, so that we are only running this

01:00:52I want to show you what these steps actually do, so let me click "Q prompt," and note that the first time this loads, it might take a while because you can see that it's downloading this open pose model from Hugging Face

01:01:05All right, so after everything is finished downloading, you can see the preview image here, so basically this

01:01:16The pre-processor is converting our uploaded image into this pose image, and then feeding this into ControlNet, and this would influence the pose of our new image

01:01:23So I'm going to hold down control again and select everything

01:01:30Press Ctrl+B to unbias, and then this time, instead of a medieval warrior, let's try a princess, arctic tundra, snowing

01:01:38All right, and then let's click "Q prompt," perfect

01:01:43So if I drag my load image next to this final image, you can see that this princess is following the pose of my uploaded image to some extent, and if we want to follow her pose completely, then we would set this value, or this

01:02:03Control net strength to one, so that's one example of how to use control net to control the composition of your image

01:02:09All right, here's another example

01:02:15So let's say I want an image similar to this composition of mountains, but I want this to be sunset instead of this lighting

01:02:22So I can use a control net

01:02:29I'll upload this image, and then instead of open pose, I would select something like canny, or you can also select depth if you want, you could also select line art

01:02:35It really doesn't matter, it really depends on your use case, and then we leave everything else the same, and here's just a preview image, so after the Pre-processor, it looks like this

01:02:42This is what the Canny pre-processor does

01:02:48All right, so we plug this into ControlNet, and then this time, for the positive prompt, I just put in "mountains and sunset," and then all these other keywords, and then our final image looks like this

01:03:00So again, if I drag my original uploaded image onto here just for a comparison, you can see that our final image matches the shape of these mountains to some degree, but now it's sunset instead of this lighting

01:03:18How cool is that? Basically, there are so many different options you can choose from for ControlNet, feel free to just play around with

01:03:23All of these pre-processors, there are just so many different pre-processor options you can choose in ControlNet to really give you maximum control over the composition of your image

01:03:33So that sums it up for ControlNet

01:03:43If you run into any errors or issues, just let me know in the comments below, and I'll try to help you troubleshoot as much as possible, but it should be fairly easy to install everything in just one click using this manager button

01:03:54All right, next I'm going to show you how to install and use external AI tools on ComfyUI

01:04:05The awesome thing about ComfyUI is that it supports a wide range of other Open-source AI tools, for example, there's a ComfyUI node for Mimic Motion, which allows you to create dancing videos from a single photo, or there's another ComfyUI node for ToonCrafter, which is a powerful tool for generating anime scenes

01:04:15If you're not familiar with ToonCrafter, check out this video where I did a deep dive on how to install and use it, but basically, you just need to enter in a start frame and an end frame, and this tool will fill in an AI animation in between those two frames

01:04:30Plus, there's another ComfyUI node for another tool called Live Portrait

01:04:37In this tool, you basically input an image of a Face, and then you input a video of another face talking or doing some expressions, and it can map those expressions onto your input image

01:04:51If you want to learn more about live portrait, check out this video

01:04:55Anyways, today I'm going to show you the process of installing and using one of these AI tools in ComfyUI

01:05:00For us, we're going to use this tool called Instant ID

01:05:05At its core, it's basically a face swap that takes in a reference image of a person's face and then maps it onto your generation

01:05:16So, there are a handful of face swap tools you can use for stable diffusion, such as RP or Reactor, or this one, Instant ID, which I find To be the most realistic and best fidelity, so here's the original InstantID page

01:05:27You can see that it is really good for face swapping, as you can see, here's Taylor Swift, here's some Chinese actress

01:05:39This looks really good, it really does preserve the details of that person's face, even across all these different styles of generations, like it doesn't have to be realistic

01:05:47You can also do face swap for painting or drawings, and it even works with different angles, so even though you just have one image of Taylor Swift's face, this AI is able to miraculously kind of guess what that face would look like at these

01:06:05Different angles, so anyways, let's jump right into how we would set this up

01:06:12On the GitHub page, which is called ComfyUI Instant ID, I'll link to this in the description below

01:06:19If you scroll down a bit, here are the installation instructions, so you can either download or get clone this repo into the custom nodes directory, or use the manager

01:06:30Of course, since we have manager installed, we're just going to use the manager, so going back to our ComfyUI instance, I'm going to click on manager, and then click on custom nodes manager, and then search for Instant ID, and then we're going to go with this one, the ComfyUI Instant

01:06:43ID native support, and the nice thing about this one, as it says in the description, is that it implements Instant ID natively and fully integrates with ComfyUI, so let's click on install

01:06:56And then, if you open up the command prompt while this is installing, you can see that right now it's cloning the repo, it's downloading all the files

01:07:07All right, so after that, it says we need to restart ComfyUI, so let's do that

01:07:17I'm going to click on restart and then click okay, and then after clicking on restart, you can see in the CMD window that it's actually installing some additional dependencies such as InsightFace, so depend Ending on the speed of your internet connection, this might take a while to download

01:07:28All right, you can see now it's downloading Onyx runtime GPU

01:07:32All right, so we've installed the nodes, we've installed Insight face and Onyx runtime, but we are not done yet

01:07:36So next, we need to download these Insight face models

01:07:41So one of them is called Antelope V2, which we can download here

01:07:47So it seems to be a zip file on Google Drive

01:07:52I'm going to click download, and then you can download that anywhere

01:07:58Once it's finished downloading, open up the zip file, and then it says we need to move this into ComfyUI/models/Insightface/

01:08:04Models, so let's go into our ComfyUI folder, and then in models, we need to create a new folder and call that InsightFace, and then within InsightFace, we need to create another folder called models

01:08:17So I'm going to create a new folder, models, and then within models, we should have this entel V2 folder, so I'm going to just drag and drop this into here

01:08:30All right, so let me exit out of this, and you can delete the zip file afterwards, and then we also need another one, so we need this main model, which can be downloaded from Hugging Face, and then placed into this directory, and it says you also need a ControlNet, and you need to

01:08:44Place it in the ComfyUI control net directory instead of downloading it from Hugging Face

01:08:58There's a much easier way to download these, which is through the manager, so let me open manager again, and then this time we are going to click on model manager, and then we are going to search for Instant ID, and you should see that down here we have these two options, the IP adapter and control net, and this is for cubic instant ID, so it's for this repo

01:09:13It's basically downloading this model, which is based on IP adapter and this control net, so we are going to select both of these and then click on install

01:09:25Now note that this one Is like 1.7 GB, this is 2.5 GB, so it's going to take a while to download

01:09:31All right, so once we have these two installed, let's click close, and then close again, and then let's click on refresh

01:09:37All right, so let's start again with our very basic text to image workflow

01:09:43So we have a checkpoint here, we plug in these prompts, and then these prompts go through this K sampler, which takes in a latent image, and then it decodes that image, and it gives us our final image

01:09:56Let me just adjust the placements of these to keep things more organized as we add the additional Instant ID nodes

01:10:02All right, so where the Instant ID node goes is actually in between the prompts and the K sampler, so if I drag this out here and then click search, I will search for Instant ID, and I should see this: Apply Instant ID

01:10:15All right, so let's drag this over here

01:10:23I'm going to hold control and then hold shift and drag these nodes over here to keep things more organized

01:10:28All right, so let's remove this, and let's remove this

01:10:34So the negative prompt goes to here, and then our model goes here, and then the model is then connected back to this K sampler, the positive is connected to the K sampler, and then the negative is connected to the K sampler

01:10:40Yes, there's a lot of

01:10:46Connections that need to be made, and I wish this process was simpler, but it is what it is

01:10:52All right, and then we need to also input an image, so I'm going to drag this node out and then click on load image, and then I will click upload, and let me upload this image of Will Smith

01:11:09And then, as the GitHub specified, this also needs an Instant ID ControlNet, so let me drag this out, and then let's select ControlNet loader, and in your options, if you search for Instant ID, you should only see this one, instant_id/diffusion_pytorch_model, so let's select this for the ControlNet model

01:11:24And then for Insight Face, we also need to drag

01:11:39This out and select instant ID face analysis, and then for the provider, since I have a CUDA GPU, I will select CUDA, and then finally for instant ID, we also need to drag a connector out, and the only option we see here is instant ID model loader, so let's select this, and by default, it should just be this one IP adapter.bin, which is the file that we installed

01:11:53All right, so after all these things are connected, let's also look at these values, so the weight is basically how important do you want this face to be, or how much influence do you want this face to be in your final image, and then for start and end, again for stable

01:12:15Diffusion, it basically takes a latent image of random noise, and through each step, like right here, we've set it to 20 steps, and so for each step, it removes a bit of noise until it gets to step 20

01:12:27So for these start and end values, it's basically saying, well, at what step do you want to start applying this face swap, and at what step do you want to stop applying this face swap? So let's say if we set this to like 0.5, or halfway, basically this would stop applying the face swap at step 10, since we set the number of steps to 20

01:12:47If we set this to 1, then it's going to apply the face swap at all steps, right from Step Zero to the last

01:12:55Step, all right, and then just a few more things we need to tweak

01:12:59For the width, let's set this to 768

01:13:04For the height, let's set this to 1024

01:13:09And then for the positive prompt, let's say "policeman, realistic, 8K Masterpiece, Ultra detailed." And then for the negative prompt, we can say "cartoon, painting, anime, blurry, Watermark, all." All right, and if all is good, we can click on "Q prompt" and see what that gives us

01:13:27So right now, it's loading the checkpoint, and then it's going through these prompts

01:13:33It's going through this apply instant ID, which will take in our loaded image of Will Smith, and all these other variables, and then Finally, it's going to output this image of Will Smith as a policeman, so here we go

01:13:44Now, face swapping isn't just for generating deep fakes, right, generating fake images of real people

01:13:49You can also use face swaps to create consistent characters, right? If you want a certain character to have the same face throughout your video, or throughout your animation, or comic book, or whatever, face swap is a really good way to apply the same face to all your generations

01:14:02Let's try something else

01:14:16So the awesome thing about Instant ID is it doesn't just work for realistic photos, so you could also set this to, let's get rid of Painting, and then instead of realistic, let's set this to watercolor painting, and then let's click "Q prompt" and see what that gives us

01:14:22All right, perfect

01:14:28So now we have a watercolor painting, kind of, of Will Smith as a policeman

01:14:34So I hope this gives you a good understanding of how to install these different custom nodes of external tools, and the awesome thing about ComfyUI is there are a lot of other tools that it can support

01:14:48So, for example, there's also an AnimateDiff node for ComfyUI, which helps you generate animations from images, and inside the GitHub, it should give you a demonstration of what a workflow

01:14:55should look like another person has created a ComfyUI node for Tune-A-Video, and this allows you to take in one image as the input frame, and then another image as the final frame, and it would interpolate an animation in between these two frames

01:15:13So again, here's the workflow for the Tune-A-Video node, and yet another user has created a ComfyUI node for Live Portrait, and this basically allows you to take one input image, and then one video of a person moving their heads and doing some strange expressions or talking, and it would animate that input photo with this person's movements, and here they shared with You how the workflow would look like in ComfyUI, so again, there's just so many custom nodes that other users have created based on a lot of different external AI tools, and that's what makes ComfyUI awesome

01:15:51And with this manager, you can easily search for all the nodes out there

01:15:57There are like tens of thousands of different custom nodes, depending on what you would like to do, and that's what makes ComfyUI the most powerful free and open source image generator out there

01:16:02All right, finally, some of you might be wondering, well, how do I use ComfyUI with the newest models such as Oraflow or Flux? Well, for Oraflow, Actually, everything is the same

01:16:16This whole text-to-image workflow is the same, and the only thing you need to change is the checkpoint

01:16:21You just need to change the checkpoint to this Aura flow SAF tensors file

01:16:27See this video on how to install and run Oraflow with ComfyUI

01:16:33And then for Flux, the workflow is quite similar, you just need to tweak a few things like the model and a clip loader, plus the K sampler

01:16:43See this video where I go in depth on how to install and run Flux on ComfyUI

01:16:49However, if you've watched this tutorial, you should understand the basics of how to use Comfy and how all these nodes work, so changing between Stable Diffusion and Flux and AA flow is actually very easy, and for this tutorial, I mostly used SDXL because it's still the most mature platform out there

01:17:06There are hundreds of models and LORAs you can choose from, plus hundreds of plugins and tools such as ControlNet, and all of these only work with Stable Diffusion, whereas for Flux, it's still quite new, so there aren't a lot of tools and workflows built from the open-source community yet

01:17:30But once we do have more of these tools, let me know in the comments, and if you want me to do an updated tutorial just for Flux, I'd be happy to make one as well, so that covers my

01:17:41Tutorial for ComfyUI, like I said in the beginning, this is free and open source, plus you don't even need an Nvidia GPU to use this, and the installation is super easy

01:17:47If you followed all the steps as outlined in this video, you should be able to get ComfyUI up and running on your computer

01:17:59Now, in this tutorial, we covered a lot of different topics, from text to image, to image to image, to face swapping, to a lot of different workflows, so if you get stuck or you hit any errors along the way, let me know in the comments below, and I'll try to help you troubleshoot as much as possible

01:18:13As always, I will continue to look out for the Newest and coolest AI tools to share with you, if you enjoyed this video, remember to like, share, subscribe, and stay tuned for more content

01:18:24Also, we built a site where you can find all the AI tools out there, as well as look for jobs in AI, machine learning, data science, and more, so check that out at ai-search

01:18:38Thanks for watching, and I'll see you in the next one.