This is an artificial intelligence image generator. Given a text description of a picture, it will create, out of nothing, an image matching that description. As you can see, it is capable of generating high quality images of all kinds of different scenes.

And it’s not just images, in recent years generative AI models have been developed that can generate text, audio, code, and soon, videos too.

All of these models are based on the same underlying technology, namely deep neural networks.

In a few of my previous videos, I’ve explained how and why deep neural networks work so well. But I only explained how neural nets can solve prediction tasks. In a prediction task, the neural net is trained with a bunch of examples of inputs and their labels, and tries to predict what the label will be for a new input which it hasn’t seen before.

For example, if you trained a neural net on images labelled with the type of object appearing in each image, that neural net would learn to predict which object a human would say is in an image, even for new images which it hasn’t seen before.

Under the hood, the way that prediction tasks are solved is by converting the training dataset into a set of points in a space, and then fitting a curve through those points, so prediction tasks are also known as curve-fitting tasks.

And while prediction is certainly cool and very useful, it’s not generation. Right? This model is just fitting a curve to a set of points.

It can’t produce new images. So where does the creativity of these generative models come from, if neural nets can only do curve fitting?

Well, all of these generative models, are in fact just predictors. Yep, it turns out that the process of producing novel works of art can be reduced to a curve fitting exercise.

And in this video, you’ll learn exactly how. Suppose that we have a training dataset consisting of a bunch of images. We want to train a neural net to create new images which are similar in style to these training images.

The first thing you might try is to simply use the images as labels to train the predictor.

Here we don’t care about 
the mapping from inputs to outputs, so we can just use anything we like for the inputs, for 
example, a completely black image.

Predictors learn to map inputs to 
outputs according to their training data. So,   this predictor, once trained, should be able 
to map the dummy all-black image to new images, like those seen in the training set, right?

Err, 
okay, maybe not quite. That didn’t work so well.

Instead of producing a nice, beautiful 
picture, we just got this blurry mess. This demonstrates a very important fact about 
of predictors. If there are multiple possible labels for the same input, the predictor 
will learn to output the average of those   labels.

For traditional classification 
tasks, this isn’t really a problem, because the average of multiple class labels 
can still be a meaningful label.

For example,   this image could plausibly be given two 
different labels, both cat and dog would be valid labels.

In this case, a classifier would 
learn to output the average of those labels,   which means you end up with a score of 0.5 cat and 
0.5 dog, which is still a useful label. In fact, it’s arguably a better label than either of the 
original ones.

On the other hand, when you average   a bunch of images together, you do not get a 
meaningful image out, you just get a blurry mess.

Let’s try something a bit easier this time. How 
about, instead of generating a new image from   scratch, we try to complete an image which has 
a part of it missing. In fact, let’s make this really easy and suppose there is only one 
missing pixel, say, the bottom right pixel.

Can we train a neural net to predict the 
value of this one missing pixel? Well, as before, the neural net is going to 
output the average of plausible values   that the missing pixel can take.

But since 
it’s only one pixel that we’re predicting, the average value is still meaningful.

The average 
of a bunch of colors is just another color, 
there’s no blurring effect. So, this model works perfectly fine!

And we can use the value predicted by this neural net to complete images which are missing the bottom-right pixel. Great, so we can complete images with one missing pixel… What about two?

Well, we can do the same thing again, train another neural net on images with two missing pixels, using the value of the second missing pixel as the label. And then use this neural net to fill in the second missing pixel.

Now we have an image with just one missing pixel, and so we can use the first neural net to fill in that. Great.

And we can do this for every pixel in the image; train a neural net to predict the color of that pixel when it and all of the subsequent pixels are missing. Now we can “complete” an image starting from a fully black image, and filling in one pixel at a time.

Crucially, each neural net only predicts one pixel, and so there’s no blurring effect.

And there we have it, we have just generated a plausible image, out of nothing… There’s just one small problem. If we run this model again, it will generate exactly the same image… Not very creative, is it?

But not to worry, we can fix this by introducing a bit of random sampling. You see, all predictors actually output a probability distribution over possible labels.

Usually, we just take the label with the largest probability as the predicted value. But if we want diversity in our outputs, we can instead randomly sample a value from this probability distribution.

This way, each time the model is run, it will sample different values at each step, which therefore changes the prediction for subsequent steps, and we get a completely different image each time.

Now we have an interesting image generator.

But still, at the end of the day, this model is made of predictors. They take as input a partially masked image, and predict the value of the next pixel.

The only difference between this and a traditional image classifier is the label we used for training. The labels for our generator happen to be pixel colors which come from the original image itself, and not a human labeler.

This is a very important point in practice: it means we don’t need humans to manually label images for this model, we can just scrape unlabelled images off the internet.

But from the point of view of the neural net, it doesn’t know, nor does it care, that the label came from the original image.

As far as it’s concerned this is just a curve fitting exercise, like any other. The generative model we’ve just created is called an auto-regressor. We have a removal process, which removes pixels one at a time, and we train neural nets to undo this process, generating and adding back in pixels one at a time.

This is actually one of the oldest generative models, the very earliest use of auto-regression dates back to 1927, where it was used to model the timing of sunspots.

But auto-regressors are still in use today. Most notably, Chat-GPT is an auto-regressor.

Chat-GPT generates text by using a transformer classifier to output a probability distribution over possible next words, given a partial piece of text. However, auto-regressors are not used to generate images anymore.

And the reason is that, while they can generate very realistic images, they take too long to run.

In order to generate a sample with an auto-regressor, we need to evaluate a neural net once for every element. This is fine for generating a few thousand words to make a piece of text, but large images can have tens of millions of pixels.

How can we get away with fewer neural net evaluations?

For our auto-regressor, we removed one pixel at a time. But we don’t have to remove only one pixel, we could, for example, remove a 4 by 4 patch of pixels at a time.

And train the neural net to predict all 16 missing pixels at once.

This way, when we use our model to generate an image, it can produce 16 pixels per evaluation, and so generation is 16 times as fast.

But there is a limit to this. We can't generate too many pixels at the same time. In the extreme case, if we try to generate every pixel in the image at once, then we're back to the original problem: there are many possible labels that get averaged together into a blurry mess.

To be clear, the reason why the image quality degrades is that, when we predict a bunch of pixels at the same time, the model has to decide on the values for all of them at once.

There are lots of plausible ways that this missing patch could be filled in, and so the model outputs the average of those. The model isn't able to make sure that the generated values are consistent with each other.

In contrast, when we predict one pixel at a time, the model gets to see the previously generated pixels, and so the model can change its prediction for this pixel to make it consistent with what has already been generated.

This is why there's a trade-off, the more pixels we generate at once, the less computation we need to use, but the worse the quality of the generated images will be.

Although, this problem only arises if the values we are predicting are related to each other.

Suppose that the values were statistically independent of each other, that is, knowing one of them does not help to predict any others. In this case, the model doesn't need look at the previously generated values, since knowing what they were wouldn't change its prediction for the next value anyway.

In this case you can predict all of them at the same time without any loss in quality.

So, that means, ideally, we want our model to generate a set of pixels that are unrelated to each other.

For natural images, nearby pixels are the most strongly related, because they are usually part of the same object. Knowing the value of one pixel very often gives you a good idea of what color nearby pixels will be.

This means that removing pixels in contiguous chunks is actually the worst way to do it. Instead, we should be removing pixels that are far away from each other, and hence more likely to be unrelated.

So if in each step, we remove a random set of pixels, and predict values for those, then we can remove more pixels in each step for the same loss in image quality, compared to contiguous chunks.

In order to minimize the number of steps needed for generation, we want the pixels we remove in each step to be as spread out as possible.

Removing pixels in a random order is a pretty good way of maximizing the average spread, but there is an even better way.

We can think of our generative model as two processes: a removal process that gradually removes information from the input, until nothing is left. And a generation process that uses neural nets to undo the removal process, generating and adding back in information.

So far, we have been completely removing pixels. But rather than completely removing a pixel, we could instead remove only some of the information from a pixel, by, for example, adding a small amount of random noise to it.

This means we don’t know exactly what the original pixel value was, but we do know it was somewhere close to the noisy value.

Now, instead of removing a bunch of pixels in each step, we can add noise to the entire image.

This way, we can remove information from every pixel in the image in a single step, which is the most spread-out way of removing information. And since it's more spread out, you can remove more information in each step, for the same loss in generation quality.

There is one small problem with this though. When we want to generate a new image, we need to start the neural net off with some initial blank image.

When we were removing pixels, then every image eventually ends up as a completely black image, so of course that’s where we start the generation process from.

But now that we’re adding noise, the values just keep getting larger and larger, never converging to anything. So where do we start the generation process from?

We can avoid this problem by changing our noising step slightly, so that we first scale down the original value and then add the noise. This ensures that, when we repeat this noising step many times, information from the original image will disappear, and the result will be equivalent to a pure random sample from the noise distribution.

So we can start our generation process from any such noise sample. And there we have it, this is known as a denoising diffusion model. The overall form is identical to an auto-regressor, the only difference is the way in which we remove information at each step.

By adding noise, we can spread out the removal of information all across the image, which makes the predicted values as independent of each other as possible, allowing you to use fewer neural net evaluations.

Empirically, diffusion models can produce high-quality photo-realistic images in about a hundred steps, where auto-regressors would take millions.

Now that we understand how these generative models work at a conceptual level, if you are ever going to implement these models in practice, there are a few important technical details that you should be aware of.

First, in the procedure I described for auto-regression, I used a different neural net in each step of the process. This is certainly the best way to get the most accurate predictions, but it’s also very inefficient, since we need to train a whole bunch of different neural nets.

In practice, you would just use the same model to do every step. This gives slightly worse predictions, but the savings in computation time more than make up for it.

In order to train a single neural net to perform all of the generation steps, you would remove a random number of pixels from each input, and train the neural net to predict the corresponding next pixel of each input.

Additionally, you can also give the number of pixels removed as an input to the neural net, so that it knows which pixel it’s supposed to be generating.

Now this one neural net can be used for all generation steps.

In the setup I just described, for each training image, the neural is trained on only one generation step for that image. But ideally, we would like to train it on every generation step of every image, we can get more use out of our training data that way.

If you did this the naïve way, you would have to evaluate the neural net once for every generation step, which means a lot more computation.

Fortunately, there exist special neural net architectures, known as causal architectures, that allow you to train on all of these generation steps while only evaluating the neural net once.

There exist causal versions of all of the popular neural net architectures, such as causal convolutional neural nets and causal transformers.

Causal architectures actually give slightly worse predictions, but in practice, auto-regression is almost always done with causal architectures because the training is so much faster.

The generation process for causal architectures is still exactly the same though.

For diffusion models, you can’t use causal architectures, and so you do have to just train with each data point at a random generation step.

I described the diffusion model as predicting the slightly less noisy image from the previous step. However, it’s actually better to predict the original, completely clean image at every step.

The reason for this is it makes the job of the neural net easier. If you make it predict the noisy next step image, then the neural net needs to learn how to generate images at all different noise levels.

This means the model will waste some of its capacity learning to produce noisy versions of images. If you instead just have the neural net always predict the clean image, then the model only needs to learn how to generate clean images, which is all we care about.

You can then take the predicted clean image and reapply the noising process to it to get the next step of the generation process.

Except that when you predict the clean image then, at the early steps of the generation process, the model has only pure noise as input, so the original clean image could have been anything, and so you get a blurry mess again.

To avoid this, we can train the neural net to predict the noise which was added to the image.

Once we have a predicted value for the noise, we can plug it into this equation to get a prediction for the original clean image. So we are still predicting the original clean image, just in a roundabout way.

The advantage of doing it this way is that now the model output is uncertain at the later stages of the generation process, since any noise could have been added to the clean image.

So the model outputs the average of a bunch of different noise samples, which is still valid noise.

So far we’ve just been generating images from nothing, but most image generators actually allow you to provide a text prompt describing the image you want to make. The way that this works is exactly the same, you just give the neural net the text as an additional input at each step.

These models are trained on pairs of images and their corresponding text descriptions, usually scraped from image alt text tags found on the internet.

This ensures that the generated image is something for which the text prompt could plausibly be given as a description of that image.

In principle, you can condition generative models on anything, not just text, so long as you can find appropriate training data. For example, here is a generative model that is conditioned on sketches.

Finally, there’s a technique to make conditional diffusion models work better, called classifier free guidance.

Why Does Diffusion Work Better than Auto-Regression?

This is an educational channel for all things algorithmic, including but not limited to computer science, machine learning, physics, and mathematics.

Algorithmic Simplicity

생성 AI 모델은 예측기일 뿐이며, 새로운 이미지 생성 과정은 곡선 피팅 연습으로 축소될 수 있다.

자기 회귀 모델은 픽셀을 하나씩 예측하여 이미지를 생성하지만, 확산 모델은 노이즈를 점진적으로 추가하고 제거하여 이미지 생성 속도와 품질을 향상시킨다.

텍스트 프롬프트와 같은 추가 입력을 통해 생성 모델을 조건화할 수 있으며, 분류기가 필요 없는 안내와 같은 기술을 통해 프롬프트 준수도를 높일 수 있다.

최근 AI는 텍스트 설명만으로 고품질 이미지를 생성할 수 있습니다. 이러한 생성형 AI 모델은 이미지뿐 아니라 텍스트, 오디오, 코드 등 다양한 콘텐츠를 생성하며, **모두 딥러닝이라는 동일한 기반 기술을 사용합니다**.

이 모델들은 예측(prediction) 작업을 통해 학습하는데, 입력과 레이블 쌍으로 훈련하여 새로운 입력에 대한 레이블을 예측합니다. 하지만 단순 예측은 창의적인 이미지 "생성"과는 거리가 멀어 보입니다. **그렇다면 AI의 창의성은 어디에서 오는 것일까요?**

🖼️ 이미지 생성의 핵심: 평균의 함정 피하기

이미지 생성 모델을 훈련할 때, 단순히 이미지를 레이블로 사용하면 흐릿한 결과가 나타납니다. 예측기는 동일한 입력에 대해 여러 가능한 레이블이 있을 경우, **레이블의 평균값을 출력하려는 경향 때문입니다**.

이미지의 평균은 의미 있는 이미지를 생성하지 못하지만, 하나의 픽셀을 예측하는 것은 가능합니다. **하나의 픽셀 색상 평균은 여전히 의미 있는 색상 값을 가지기 때문입니다**.

🧩 오토 리그레서: 픽셀 하나씩 채우기

이미지에서 픽셀 하나씩 제거하고, 신경망을 훈련하여 제거된 픽셀 값을 예측하도록 합니다. 이 과정을 반복하여 이미지를 완성할 수 있습니다. **이것이 바로 오토 리그레서(Auto-regressor) 모델의 기본 원리입니다**.

하지만 이 모델은 매번 동일한 이미지만 생성한다는 단점이 있습니다. 이를 해결하기 위해 **확률 분포에서 무작위로 값을 샘플링하여 다양성을 확보할 수 있습니다**.

오토 리그레서는 부분적으로 가려진 이미지를 입력으로 받아 다음 픽셀 값을 예측하는 예측기입니다. 중요한 점은, **사람이 직접 레이블링하지 않아도 된다는 것입니다**. 인터넷에서 수집한 레이블 없는 이미지를 활용할 수 있습니다.

챗GPT 또한 오토 리그레서의 한 종류입니다. 텍스트의 일부가 주어졌을 때, **변환기 분류기를 사용하여 다음 단어에 대한 확률 분포를 출력하여 텍스트를 생성합니다**.

🚀 효율성 문제와 해결책: 덩어리 vs 분산

오토 리그레서는 고품질 이미지를 생성하지만, 픽셀 하나씩 처리해야 하므로 실행 속도가 느립니다. **이미지 1개를 생성하려면 수백만 번 신경망을 평가해야 합니다**.

한 번에 여러 픽셀을 예측하면 속도는 빨라지지만, 이미지 품질이 저하됩니다. **이는 모델이 픽셀 간의 일관성을 유지하기 어렵기 때문입니다**.

이상적으로는 서로 관련 없는 픽셀들을 생성하는 것이 좋습니다. 인접한 픽셀은 서로 관련성이 높으므로, **무작위로 픽셀을 제거하는 것이 더 효과적입니다**.

 diffusion 모델: 노이즈를 활용한 정보 제거

픽셀을 완전히 제거하는 대신, 노이즈를 추가하여 정보의 일부만 제거할 수도 있습니다. **이미지 전체에 노이즈를 추가하면 정보 제거를 최대한 분산시킬 수 있습니다**.

노이즈를 반복적으로 추가하면 결국 순수한 노이즈 샘플이 됩니다. **이 노이즈 샘플에서부터 시작하여 점차 노이즈를 제거하는 방식으로 이미지를 생성하는 것이 디노이징 diffusion 모델입니다**.

Diffusion 모델은 정보 제거 방식을 변경하여 오토 리그레서와 동일한 형태를 가지지만, **더 적은 수의 신경망 평가로 고품질 이미지를 생성할 수 있습니다**.

🛠️ 기술적 세부 사항: 효율적인 구현을 위해

각 단계마다 다른 신경망을 사용하는 것이 가장 정확하지만, 비효율적입니다. **실제로는 하나의 모델을 사용하여 모든 단계를 수행합니다**.

인과적(causal) 아키텍처를 사용하면 모든 생성 단계에서 훈련하면서도 신경망을 한 번만 평가할 수 있습니다. **훈련 속도가 훨씬 빠르기 때문입니다**.

Diffusion 모델에서는 노이즈가 적은 이미지를 예측하는 대신, **원래의 깨끗한 이미지를 예측하는 것이 더 효과적입니다**. 모델이 노이즈 버전을 생성하는 데 리소스를 낭비하지 않기 때문입니다.

하지만 초기 단계에서는 입력이 순수한 노이즈이기 때문에 흐릿한 이미지가 생성될 수 있습니다. **따라서 노이즈를 예측하는 방식으로 깨끗한 이미지를 간접적으로 예측합니다**.

📝 텍스트 프롬프트 활용과 결론

텍스트 프롬프트를 사용하여 원하는 이미지를 생성할 수 있습니다. **신경망에 텍스트를 추가적인 입력으로 제공하고, 이미지와 텍스트 설명 쌍으로 훈련합니다**.

결론적으로, 생성형 AI는 모든 머신 러닝과 마찬가지로 **결국은 곡선 피팅(curve fitting)일 뿐입니다**.

이것은 인공지능 이미지 생성기입니다. 그림에 대한 텍스트 설명을 입력하면 아무것도 없는 상태에서 해당 설명과 일치하는 이미지를 생성합니다. 보시다시피 모든 종류의 다양한 장면의 고품질 이미지를 생성할 수 있습니다.

이미지뿐만 아니라 최근 몇 년 동안 텍스트, 오디오, 코드, 그리고 곧 비디오까지 생성할 수 있는 생성 AI 모델이 개발되었습니다.

이러한 모델은 모두 딥러닝 신경망이라는 동일한 기반 기술을 기반으로 합니다.

몇몇 이전 영상에서 딥러닝 신경망이 어떻게, 왜 그렇게 잘 작동하는지 설명했습니다. 하지만 저는 신경망이 예측 작업만 어떻게 해결할 수 있는지 설명했습니다. 예측 작업에서 신경망은 입력과 해당 레이블의 많은 예제로 훈련을 받고 이전에 본 적이 없는 새로운 입력에 대해 레이블이 무엇인지 예측하려고 시도합니다.

예를 들어 각 이미지에 나타나는 객체 유형으로 레이블이 지정된 이미지로 신경망을 훈련하면 해당 신경망은 사람이 이미지에 있다고 말할 객체를 예측하는 방법을 학습합니다. 이전에 본 적이 없는 새로운 이미지의 경우에도 마찬가지입니다.

내부적으로 예측 작업이 해결되는 방식은 훈련 데이터 세트를 공간의 점 집합으로 변환한 다음 해당 점을 통해 곡선을 피팅하는 것입니다. 따라서 예측 작업은 곡선 피팅 작업이라고도 합니다.

예측은 확실히 멋지고 매우 유용하지만 생성이 아닙니다. 그렇죠? 이 모델은 점 집합에 곡선을 피팅하는 것뿐입니다.

새로운 이미지를 생성할 수 없습니다. 그렇다면 신경망이 곡선 피팅만 할 수 있다면 이러한 생성 모델의 창의성은 어디에서 오는 것일까요?

글쎄요, 이러한 모든 생성 모델은 실제로 예측기일 뿐입니다. 네, 새로운 예술 작품을 제작하는 과정이 곡선 피팅 연습으로 축소될 수 있다는 것이 밝혀졌습니다.

그리고 이 비디오에서는 정확히 그 방법을 배우게 될 것입니다. 이미지 모음으로 구성된 훈련 데이터 세트가 있다고 가정해 보겠습니다. 이러한 훈련 이미지와 스타일이 유사한 새로운 이미지를 생성하도록 신경망을 훈련하려고 합니다.

가장 먼저 시도할 수 있는 것은 이미지를 레이블로 사용하여 예측기를 훈련하는 것입니다.

여기서는 입력에서 출력으로의 매핑에는 관심이 없으므로 입력에 원하는 것을 사용할 수 있습니다. 예를 들어 완전히 검은색 이미지를 사용할 수 있습니다.

예측 변수는 훈련 데이터에 따라 입력 값을 출력 값에 매핑하는 방법을 학습합니다. 따라서 이 예측 변수는 훈련이 완료되면 더미의 올블랙 이미지를 훈련 세트에서 본 것과 같은 새로운 이미지에 매핑할 수 있어야 합니다. 그렇죠?

음, 좋아요. 잘 안 될 수도 있겠네요. 별로 좋지 않네요.

멋지고 아름다운 그림을 만드는 대신 흐릿한 엉망진창이 되었습니다. 이는 예측 변수에 대한 매우 중요한 사실을 보여줍니다. 동일한 입력에 대해 여러 개의 가능한 레이블이 있는 경우 예측 변수는 해당 레이블의 평균을 출력하는 방법을 학습합니다.

기존 분류 작업의 경우 여러 클래스 레이블의 평균이 여전히 의미 있는 레이블이 될 수 있으므로 실제로 문제가 되지 않습니다.

예를 들어 이 이미지는 고양이와 개라는 두 가지 다른 레이블이 모두 유효한 레이블로 지정될 수 있습니다.

이 경우 분류기는 해당 레이블의 평균을 출력하는 방법을 학습합니다. 즉, 고양이 0.5점과 개 0.5점으로 끝나는데, 이는 여전히 유용한 레이블입니다. 사실 원래 레이블보다 더 나은 레이블이라고 할 수 있습니다.

반면에 여러 이미지를 함께 평균하면 의미 있는 이미지가 나오지 않고 흐릿한 엉망진창이 됩니다.

이번에는 좀 더 쉬운 것을 시도해 보겠습니다. 처음부터 새 이미지를 생성하는 대신 일부가 누락된 이미지를 완성해 보는 것은 어떻습니까? 사실 이것을 정말 쉽게 만들고 누락된 픽셀이 하나만 있다고 가정해 보겠습니다. 예를 들어 오른쪽 하단 픽셀입니다.

신경망을 훈련하여 이 누락된 픽셀 하나의 값을 예측할 수 있을까요? 글쎄요, 이전과 마찬가지로 신경망은 누락된 픽셀이 가질 수 있는 가능한 값의 평균을 출력할 것입니다.

하지만 예측하는 픽셀이 하나뿐이므로 평균값은 여전히 의미가 있습니다.

여러 색상의 평균은 또 다른 색상일 뿐이며 흐려지는 효과는 없습니다. 따라서 이 모델은 완벽하게 작동합니다!

그리고 이 신경망에서 예측한 값을 사용하여 오른쪽 하단 픽셀이 누락된 이미지를 완성할 수 있습니다. 좋습니다. 누락된 픽셀이 하나인 이미지를 완성할 수 있습니다… 두 개는 어떻습니까?

자, 똑같은 걸 다시 할 수 있습니다. 두 개의 픽셀이 빠진 이미지로 또 다른 신경망을 훈련하고, 두 번째 빠진 픽셀의 값을 레이블로 사용하는 겁니다. 그런 다음 이 신경망을 사용하여 두 번째 빠진 픽셀을 채웁니다.

이제 픽셀 하나만 빠진 이미지가 있으므로 첫 번째 신경망을 사용하여 채울 수 있습니다. 좋습니다.

그리고 이미지의 모든 픽셀에 대해 이 작업을 수행할 수 있습니다. 해당 픽셀과 그 이후의 모든 픽셀이 누락되었을 때 해당 픽셀의 색상을 예측하도록 신경망을 훈련합니다. 이제 완전히 검은색 이미지에서 시작하여 한 번에 한 픽셀씩 채워 이미지를 '완성'할 수 있습니다.

결정적으로 각 신경망은 하나의 픽셀만 예측하므로 흐릿해지는 효과가 없습니다.

자, 이제 아무것도 없는 상태에서 그럴듯한 이미지를 생성했습니다. 작은 문제가 하나 있습니다. 이 모델을 다시 실행하면 정확히 동일한 이미지가 생성됩니다. 그다지 창의적이지 않죠?

하지만 걱정하지 마세요. 약간의 무작위 샘플링을 도입하여 이 문제를 해결할 수 있습니다. 보시다시피 모든 예측 변수는 실제로 가능한 레이블에 대한 확률 분포를 출력합니다.

일반적으로 가장 큰 확률을 가진 레이블을 예측 값으로 사용합니다. 그러나 출력에 다양성을 원한다면 이 확률 분포에서 값을 무작위로 샘플링할 수 있습니다.

이렇게 하면 모델을 실행할 때마다 각 단계에서 다른 값을 샘플링하므로 후속 단계에 대한 예측이 변경되고 매번 완전히 다른 이미지를 얻을 수 있습니다.

이제 흥미로운 이미지 생성기가 생겼습니다.

하지만 결국 이 모델은 예측 변수로 만들어집니다. 부분적으로 마스크된 이미지를 입력으로 받아 다음 픽셀의 값을 예측합니다.

이것과 기존 이미지 분류기의 유일한 차이점은 훈련에 사용한 레이블입니다. 우리 생성기의 레이블은 인간 레이블러가 아닌 원래 이미지 자체에서 가져온 픽셀 색상입니다.

이것은 실제로 매우 중요한 점입니다. 이 모델에 대해 사람이 수동으로 이미지에 레이블을 지정할 필요가 없으며 인터넷에서 레이블이 없는 이미지를 스크랩할 수 있다는 의미입니다.

그러나 신경망의 관점에서 볼 때 레이블이 원래 이미지에서 왔는지 알지도 못하고 신경 쓰지도 않습니다.

이 모델은 그저 또 다른 곡선 피팅 연습이라고 생각합니다. 우리가 방금 만든 생성 모델을 자기 회귀 모델이라고 합니다. 여기에는 픽셀을 하나씩 제거하는 제거 과정이 있고, 이 과정을 되돌려 픽셀을 생성하고 다시 추가하도록 신경망을 학습시킵니다.

이것은 실제로 가장 오래된 생성 모델 중 하나이며, 자기 회귀의 가장 초기 사용은 1927년으로 거슬러 올라가며, 당시에는 태양 흑점의 시기를 모델링하는 데 사용되었습니다.

하지만 자기 회귀는 오늘날에도 여전히 사용되고 있습니다. 가장 주목할 만한 것은 Chat-GPT가 자기 회귀 모델이라는 것입니다.

Chat-GPT는 트랜스포머 분류기를 사용하여 가능한 다음 단어에 대한 확률 분포를 출력하여 텍스트를 생성합니다. 그러나 자기 회귀는 더 이상 이미지를 생성하는 데 사용되지 않습니다.

그 이유는 매우 사실적인 이미지를 생성할 수 있지만 실행하는 데 너무 오래 걸리기 때문입니다.

자기 회귀 모델로 샘플을 생성하려면 모든 요소에 대해 신경망을 한 번씩 평가해야 합니다. 텍스트를 만들기 위해 수천 단어를 생성하는 데는 괜찮지만, 큰 이미지는 수천만 개의 픽셀을 가질 수 있습니다.

신경망 평가 횟수를 어떻게 줄일 수 있을까요?

자기 회귀 모델에서는 픽셀을 한 번에 하나씩 제거했습니다. 하지만 픽셀을 하나만 제거할 필요는 없고, 예를 들어 4x4 픽셀 패치를 한 번에 제거할 수도 있습니다.

그리고 신경망을 훈련시켜 누락된 16개의 픽셀을 모두 한 번에 예측하도록 합니다.

이렇게 하면 모델을 사용하여 이미지를 생성할 때 평가당 16개의 픽셀을 생성할 수 있으므로 생성 속도가 16배 더 빨라집니다.

하지만 여기에는 한계가 있습니다. 너무 많은 픽셀을 동시에 생성할 수는 없습니다. 극단적인 경우, 이미지의 모든 픽셀을 한 번에 생성하려고 하면 원래 문제로 돌아갑니다. 즉, 흐릿한 덩어리로 평균화되는 가능한 레이블이 너무 많습니다.

분명히 말하면, 이미지 품질이 저하되는 이유는 픽셀을 동시에 예측할 때 모델이 모든 픽셀에 대한 값을 한 번에 결정해야 하기 때문입니다.

이 누락된 패치를 채울 수 있는 그럴듯한 방법은 많고, 따라서 모델은 이러한 방법의 평균을 출력합니다. 모델은 생성된 값이 서로 일관성이 있는지 확인할 수 없습니다.

반대로, 한 번에 한 픽셀씩 예측할 때 모델은 이전에 생성된 픽셀을 볼 수 있으므로 모델은 이미 생성된 픽셀과 일관성을 유지하기 위해 이 픽셀에 대한 예측을 변경할 수 있습니다.

이것이 바로 상충 관계가 발생하는 이유입니다. 한 번에 더 많은 픽셀을 생성할수록 계산에 필요한 양은 줄어들지만 생성된 이미지의 품질은 더 나빠집니다.

하지만 이 문제는 예측하는 값이 서로 관련되어 있는 경우에만 발생합니다.

값이 통계적으로 서로 독립적이라고 가정해 보겠습니다. 즉, 값 중 하나를 안다고 해서 다른 값을 예측하는 데 도움이 되지 않는 경우입니다. 이 경우 모델은 이전에 생성된 값을 볼 필요가 없습니다. 왜냐하면 해당 값을 안다고 해서 다음 값에 대한 예측이 바뀌지 않기 때문입니다.

이 경우 품질 저하 없이 모든 값을 동시에 예측할 수 있습니다.

따라서 이상적으로는 모델이 서로 관련 없는 픽셀 집합을 생성하기를 원한다는 의미입니다.

자연 이미지의 경우 주변 픽셀은 일반적으로 동일한 객체의 일부이기 때문에 가장 강력하게 관련되어 있습니다. 하나의 픽셀 값을 알면 주변 픽셀의 색상을 파악하는 데 매우 유용합니다.

즉, 연속적인 덩어리로 픽셀을 제거하는 것은 실제로 최악의 방법입니다. 대신 서로 멀리 떨어져 있고 따라서 관련이 없을 가능성이 높은 픽셀을 제거해야 합니다.

따라서 각 단계에서 임의의 픽셀 집합을 제거하고 해당 값에 대한 예측을 수행하면 연속적인 덩어리와 비교하여 동일한 이미지 품질 손실에 대해 각 단계에서 더 많은 픽셀을 제거할 수 있습니다.

생성에 필요한 단계 수를 최소화하려면 각 단계에서 제거하는 픽셀이 최대한 분산되기를 바랍니다.

임의의 순서로 픽셀을 제거하는 것은 평균 분산을 최대화하는 데 매우 좋은 방법이지만 훨씬 더 나은 방법이 있습니다.

생성 모델을 두 가지 프로세스로 생각할 수 있습니다. 하나는 입력에서 정보가 남지 않을 때까지 점진적으로 정보를 제거하는 제거 프로세스이고, 다른 하나는 신경망을 사용하여 제거 프로세스를 되돌리고 정보를 다시 생성하고 추가하는 생성 프로세스입니다.

지금까지는 픽셀을 완전히 제거했습니다. 하지만 픽셀을 완전히 제거하는 대신 예를 들어 약간의 임의 노이즈를 추가하여 픽셀에서 일부 정보만 제거할 수 있습니다.

이는 원래 픽셀 값이 정확히 무엇인지 알 수 없지만, 노이즈가 있는 값에 가까웠다는 것은 안다는 의미입니다.

이제 각 단계에서 많은 픽셀을 제거하는 대신, 전체 이미지에 노이즈를 추가할 수 있습니다.

이렇게 하면 이미지의 모든 픽셀에서 정보를 한 번에 제거할 수 있으며, 이는 정보를 제거하는 가장 분산된 방식입니다. 그리고 더 분산되어 있기 때문에 생성 품질의 동일한 손실에 대해 각 단계에서 더 많은 정보를 제거할 수 있습니다.

하지만 여기에는 한 가지 작은 문제가 있습니다. 새로운 이미지를 생성하려면 신경망을 초기 빈 이미지로 시작해야 합니다.

픽셀을 제거할 때는 모든 이미지가 결국 완전히 검은색 이미지로 끝나므로, 당연히 거기에서 생성 프로세스를 시작합니다.

하지만 이제 노이즈를 추가하고 있으므로 값이 계속 커지고 수렴되지 않습니다. 그렇다면 생성 프로세스를 어디에서 시작해야 할까요?

Why Does Diffusion Work Better than Auto-Regression?

Why Does Diffusion Work Better than Auto-Regression?

스크립트