조건부 생성적 적대 신경망(CGAN) 훈련시키기

이 예제에서는 조건부 생성적 적대 신경망을 훈련시켜서 영상을 생성하는 방법을 보여줍니다.

생성적 적대 신경망(GAN)은 입력 훈련 데이터와 비슷한 특징을 갖는 데이터를 생성할 수 있는 딥러닝 신경망의 한 종류입니다.

GAN은 함께 훈련되는 다음과 같은 두 개의 신경망으로 구성됩니다.

1. 생성기 — 입력값으로 난수로 구성된 벡터가 주어지면 이 신경망은 훈련 데이터와 동일한 구조를 갖는 데이터를 생성합니다.

2. 판별기 — 훈련 데이터의 관측값과 생성기에서 생성된 데이터의 관측값을 둘 다 포함하는 데이터 배치가 주어지면, 이 신경망은 관측값을 "real"과 "generated"로 분류하려고 시도합니다.

조건부 생성적 적대 신경망(CGAN)은 훈련 과정 중에 레이블을 활용하는 GAN의 한 종류입니다.

1. 생성기 — 입력값으로 레이블과 확률 배열이 주어지면 이 신경망은 같은 레이블에 해당하는 훈련 데이터 관측값과 동일한 구조를 갖는 데이터를 생성합니다.

2. 판별기 — 훈련 데이터의 관측값과 생성기에서 생성된 데이터의 관측값을 둘 다 포함하는 레이블 지정된 데이터 배치가 주어지면, 이 신경망은 관측값을 "real"과 "generated"로 분류하려고 시도합니다.

조건부 GAN을 훈련시키려면 두 신경망의 성능을 극대화할 수 있도록 다음과 같이 두 신경망을 동시에 훈련시키십시오.

• 판별기를 "속이는" 데이터를 생성하도록 생성기를 훈련시킵니다.

• 실제 데이터와 생성된 데이터를 구분하도록 판별기를 훈련시킵니다.

생성기의 성능을 최대화하려면, 레이블 지정된 생성 데이터가 주어졌을 때의 판별기 손실을 최대화하십시오. 즉, 생성기의 목적은 판별기가 "real"로 분류하는 레이블 지정된 데이터를 생성하는 것입니다.

판별기의 성능을 최대화하려면, 실제 데이터와 레이블 지정된 생성 데이터의 배치가 주어졌을 때의 판별기 손실을 최소화하십시오. 즉, 판별기의 목적은 생성기에 "속지" 않는 것입니다.

이상적으로는 이 전략의 결과로 입력 레이블에 상응하는 실제처럼 보이는 데이터를 생성하는 생성기와 각 레이블에 대한 훈련 데이터의 특징인 강한 특징 표현을 학습한 판별기가 생성됩니다.

훈련 데이터 불러오기

Flowers 데이터 세트[1]를 다운로드하여 추출합니다.

url = "http://download.tensorflow.org/example_images/flower_photos.tgz";
downloadFolder = tempdir;
filename = fullfile(downloadFolder,"flower_dataset.tgz");

imageFolder = fullfile(downloadFolder,"flower_photos");
if ~exist(imageFolder,"dir")
    disp("Downloading Flowers data set (218 MB)...")
    websave(filename,url);
    untar(filename,downloadFolder)
end

꽃 사진을 포함하는 영상 데이터저장소를 만듭니다.

datasetFolder = fullfile(imageFolder);

imds = imageDatastore(datasetFolder,IncludeSubfolders=true,LabelSource="foldernames");

클래스 개수를 확인합니다.

classes = categories(imds.Labels);
numClasses = numel(classes)

numClasses = 5

무작위 가로 뒤집기를 포함하도록 데이터를 증대하고, 영상의 크기가 64×64가 되도록 크기를 조정합니다.

augmenter = imageDataAugmenter(RandXReflection=true);
augimds = augmentedImageDatastore([64 64],imds,DataAugmentation=augmenter);

생성기 신경망 정의하기

다음과 같이 두 개 입력을 받는 신경망을 생성합니다. 이 신경망은 크기가 100인 확률 벡터와 대응되는 레이블이 주어지면 영상을 생성합니다.

이 신경망은 다음을 수행합니다.

• 완전 연결 계층과 그 뒤에 형태 변경 연산을 사용하여 크기가 100인 확률 벡터를 4×4×1024 배열로 변환합니다.

• categorical형 레이블을 임베딩 벡터로 변환하고 4×4 배열로 형태 변경합니다.

• 두 입력에서 생성된 영상을 채널 차원을 따라 결합합니다. 출력값은 4×4×1025 배열입니다.

• 일련의 전치된 컨벌루션 계층, 배치 정규화 계층, ReLU 계층을 사용하여, 결과로 생성된 배열을 64×64×3 배열로 업스케일링합니다.

이 신경망 아키텍처를 정의하고 다음과 같은 신경망 속성을 지정합니다.

• categorical형 입력에 대해, 임베딩 차원으로 50을 사용합니다.

• 전치 컨벌루션 계층에 대해, 각 계층마다 필터 개수를 줄이면서 5×5 필터를 지정하고, 스트라이드를 2로 지정하고, 출력에 "same" 자르기를 지정합니다.

• 마지막 전치 컨벌루션 계층에 대해, 생성된 영상의 RGB 채널 3개에 대응되도록 3개의 5×5 필터를 지정합니다.

• 신경망 끝부분에 tanh 계층을 삽입합니다.

잡음 입력을 사영 및 형태 변경하기 위해 완전 연결 계층을 사용하고 이어서 형태 변경 연산을 수행합니다. 형태 변경 연산은 이 예제에 지원 파일로 첨부된 feature2image 함수로 주어진 함수를 사용하여 함수 계층으로 지정됩니다. categorical형 레이블을 포함시키려면 이 예제에 지원 파일로 첨부된 사용자 지정 계층 embeddingLayer를 사용합니다. 이러한 지원 파일에 액세스하려면 이 예제를 라이브 스크립트로 여십시오.

numLatentInputs = 100;
embeddingDimension = 50;
numFilters = 64;

filterSize = 5;
projectionSize = [4 4 1024];

netG = dlnetwork;

layers = [
    featureInputLayer(numLatentInputs)
    fullyConnectedLayer(prod(projectionSize))
    functionLayer(@(X) feature2image(X,projectionSize),Formattable=true)
    concatenationLayer(3,2,Name="cat");
    transposedConv2dLayer(filterSize,4*numFilters)
    batchNormalizationLayer
    reluLayer
    transposedConv2dLayer(filterSize,2*numFilters,Stride=2,Cropping="same")
    batchNormalizationLayer
    reluLayer
    transposedConv2dLayer(filterSize,numFilters,Stride=2,Cropping="same")
    batchNormalizationLayer
    reluLayer
    transposedConv2dLayer(filterSize,3,Stride=2,Cropping="same")
    tanhLayer];

netG = addLayers(netG,layers);

layers = [
    featureInputLayer(1)
    embeddingLayer(embeddingDimension,numClasses)
    fullyConnectedLayer(prod(projectionSize(1:2)))
    functionLayer(@(X) feature2image(X,[projectionSize(1:2) 1]),Formattable=true,Name="emb_reshape")];

netG = addLayers(netG,layers);
netG = connectLayers(netG,"emb_reshape","cat/in2");

사용자 지정 훈련 루프를 사용하여 신경망을 훈련시키기 위해 dlnetwork 객체를 초기화합니다.

netG = initialize(netG)

netG = 
  dlnetwork with properties:

         Layers: [19×1 nnet.cnn.layer.Layer]
    Connections: [18×2 table]
     Learnables: [19×3 table]
          State: [6×3 table]
     InputNames: {'input'  'input_1'}
    OutputNames: {'layer_2'}
    Initialized: 1

  View summary with summary.

판별기 신경망 정의하기

다음과 같이 두 개의 입력을 갖는 신경망을 정의합니다. 이 신경망은 영상 세트와 그에 대응하는 레이블이 주어지면 64×64 크기의 실제 영상과 생성된 영상으로 분류합니다.

64×64×1 영상과 그에 대응되는 레이블을 입력으로 받아서, 배치 정규화 계층과 Leaky ReLU 계층을 갖는 컨벌루션 계층을 이어서 사용하여 스칼라 예측 점수를 출력하는 신경망을 만듭니다. 드롭아웃을 사용하여 입력 영상에 잡음을 추가합니다.

• 드롭아웃 계층에 대해, 드롭아웃 확률을 0.75로 지정합니다.

• 컨벌루션 계층에 대해, 각 계층마다 필터 개수를 늘리면서 5×5 필터를 지정합니다. 또한, 스트라이드를 2로 지정하고 출력에 가장자리 채우기를 지정합니다.

• Leaky ReLU 계층에 대해, 스케일을 0.2로 지정합니다.

• 마지막 계층에 대해, 하나의 4×4 필터를 갖는 컨벌루션 계층을 지정합니다.

dropoutProb = 0.75;
numFilters = 64;
scale = 0.2;

inputSize = [64 64 3];
filterSize = 5;

netD = dlnetwork;

layers = [
    imageInputLayer(inputSize,Normalization="none")
    dropoutLayer(dropoutProb)
    concatenationLayer(3,2,Name="cat")
    convolution2dLayer(filterSize,numFilters,Stride=2,Padding="same")
    leakyReluLayer(scale)
    convolution2dLayer(filterSize,2*numFilters,Stride=2,Padding="same")
    batchNormalizationLayer
    leakyReluLayer(scale)
    convolution2dLayer(filterSize,4*numFilters,Stride=2,Padding="same")
    batchNormalizationLayer
    leakyReluLayer(scale)
    convolution2dLayer(filterSize,8*numFilters,Stride=2,Padding="same")
    batchNormalizationLayer
    leakyReluLayer(scale)
    convolution2dLayer(4,1)];

netD = addLayers(netD,layers);

layers = [
    featureInputLayer(1)
    embeddingLayer(embeddingDimension,numClasses)
    fullyConnectedLayer(prod(inputSize(1:2)))
    functionLayer(@(X) feature2image(X,[inputSize(1:2) 1]),Formattable=true,Name="emb_reshape")];

netD = addLayers(netD,layers);
netD = connectLayers(netD,"emb_reshape","cat/in2");

사용자 지정 훈련 루프를 사용하여 신경망을 훈련시키고 자동 미분을 활성화하기 위해 dlnetwork 객체를 초기화합니다.

netD = initialize(netD)

netD = 
  dlnetwork with properties:

         Layers: [19×1 nnet.cnn.layer.Layer]
    Connections: [18×2 table]
     Learnables: [19×3 table]
          State: [6×3 table]
     InputNames: {'imageinput'  'input'}
    OutputNames: {'conv_5'}
    Initialized: 1

  View summary with summary.

모델 손실 함수 정의하기

이 예제의 모델 손실 함수 섹션에 나와 있는 함수 modelLoss를 만듭니다. 이 함수는 생성기 신경망과 판별기 신경망, 입력 데이터로 구성된 미니 배치, 난수 값으로 구성된 배열을 입력으로 받습니다. 그리고 신경망의 학습 가능한 파라미터와 생성된 영상 배열에 대한 손실 기울기를 반환합니다.

훈련 옵션 지정하기

Epoch 500회에 대해 크기가 128인 미니 배치를 사용하여 훈련시킵니다.

numEpochs = 500;
miniBatchSize = 128;

Adam 최적화에 대한 옵션을 지정합니다. 두 신경망에 대해 다음을 사용합니다.

• 학습률 0.0002

• 기울기 감쇠 인자 0.5

• 제곱 기울기 감쇠 인자 0.999

learnRate = 0.0002;
gradientDecayFactor = 0.5;
squaredGradientDecayFactor = 0.999;

100회의 반복마다, 훈련 진행 상황 플롯을 업데이트합니다.

validationFrequency = 100;

판별기가 실제 영상과 생성된 영상을 구분하는 방법을 지나치게 빨리 학습하는 경우 생성기 훈련이 실패할 수 있습니다. 판별기와 생성기의 학습 균형을 맞추려면 실제 영상 비율의 레이블을 무작위로 뒤집습니다. 뒤집기 인자를 0.5로 지정합니다.

flipFactor = 0.5;

모델 훈련시키기

사용자 지정 훈련 루프를 사용하여 모델을 훈련시킵니다. 루프를 사용해 훈련 데이터를 순회하고 각 반복에서 신경망 파라미터를 업데이트합니다. 훈련 진행 상황을 모니터링하기 위해, 난수 값으로 구성된 홀드아웃 배열을 생성기에 대한 입력으로 사용하여 생성된 영상 배치를 표시하고, 신경망 점수도 표시합니다.

훈련시키는 동안 minibatchqueue를 사용하여 영상 미니 배치를 처리하고 관리합니다. 각 미니 배치에 대해 다음을 수행합니다.

• (이 예제의 마지막 부분에서 정의되는) 사용자 지정 미니 배치 전처리 함수 preprocessMiniBatch를 사용하여 영상을 [-1,1] 범위로 다시 스케일링합니다.

• 관측값이 128개 미만인 부분 미니 배치는 모두 버립니다.

• 각각 공간(spatial), 공간(spatial), 채널(channel), 배치(batch)를 뜻하는 차원 레이블 "SSCB"를 사용하여 영상 데이터의 형식을 지정합니다.

• 차원 레이블 "BC"(배치, 채널)로 레이블 데이터의 형식을 지정합니다.

• 사용 가능한 GPU가 있으면 GPU에서 훈련시킵니다. minibatchqueue의 OutputEnvironment 옵션이 "auto"일 때 GPU를 사용할 수 있는 경우 minibatchqueue는 각 출력값을 gpuArray로 변환합니다. GPU를 사용하려면 Parallel Computing Toolbox™와 지원되는 GPU 장치가 필요합니다. 지원되는 장치에 대한 자세한 내용은 GPU 연산 요구 사항 (Parallel Computing Toolbox) 항목을 참조하십시오.

minibatchqueue 객체는 기본적으로 기본 유형 single을 사용하여 데이터를 dlarray 객체로 변환합니다.

augimds.MiniBatchSize = miniBatchSize;
executionEnvironment = "auto";

mbq = minibatchqueue(augimds, ...
    MiniBatchSize=miniBatchSize, ...
    PartialMiniBatch="discard", ...
    MiniBatchFcn=@preprocessData, ...
    MiniBatchFormat=["SSCB" "BC"], ...
    OutputEnvironment=executionEnvironment);    

Adam 최적화 함수에 대한 파라미터를 초기화합니다.

velocityD = [];
trailingAvgG = [];
trailingAvgSqG = [];
trailingAvgD = [];
trailingAvgSqD = [];

훈련 진행 상황을 모니터링하기 위해, 25개 확률 벡터로 구성된 홀드아웃 배치와 각 클래스에 대응되는 레이블 1~5가 5번 반복된 세트를 만듭니다.

numValidationImagesPerClass = 5;
ZValidation = randn(numLatentInputs,numValidationImagesPerClass*numClasses,"single");

TValidation = single(repmat(1:numClasses,[1 numValidationImagesPerClass]));

데이터를 dlarray 객체로 변환하고 차원 레이블 "CB"(채널, 배치)를 지정합니다.

ZValidation = dlarray(ZValidation,"CB");
TValidation = dlarray(TValidation,"CB");

GPU 훈련을 위해 데이터를 gpuArray 객체로 변환합니다.

if (executionEnvironment == "auto" && canUseGPU) || executionEnvironment == "gpu"
    ZValidation = gpuArray(ZValidation);
    TValidation = gpuArray(TValidation);
end

생성기와 판별기의 점수를 추적하려면 trainingProgressMonitor 객체를 사용합니다. 모니터링의 총 반복 횟수를 계산합니다.

numObservationsTrain = numel(imds.Files);
numIterationsPerEpoch = floor(numObservationsTrain / miniBatchSize);
numIterations = numEpochs * numIterationsPerEpoch;

TrainingProgressMonitor 객체를 초기화합니다. monitor 객체를 생성할 때 타이머가 시작되므로 이 객체를 훈련 루프와 가깝게 생성해야 합니다.

monitor = trainingProgressMonitor( ...
    Metrics=["GeneratorScore","DiscriminatorScore"], ...
    Info=["Epoch","Iteration"], ...
    XLabel="Iteration");

groupSubPlot(monitor,Score=["GeneratorScore","DiscriminatorScore"])

조건부 GAN을 훈련시킵니다. 각 Epoch에 대해 데이터를 섞고 루프를 사용해 데이터의 미니 배치를 순회합니다.

각 미니 배치에 대해 다음을 수행합니다.

• TrainingProgressMonitor 객체의 Stop 속성이 true이면 중지합니다. 중지 버튼을 클릭하면 Stop 속성이 true로 변경됩니다.

• dlfeval 함수와 modelLoss 함수를 사용하여 학습 가능한 파라미터, 생성기 상태, 신경망 점수에 대한 손실 기울기를 평가합니다.

• adamupdate 함수를 사용하여 신경망 파라미터를 업데이트합니다.

• 두 신경망의 점수를 플로팅합니다.

• validationFrequency회의 반복마다, 고정된 홀드아웃 생성기 입력값에 대해 생성된 영상 배치를 표시합니다.

훈련을 실행하는 데 다소 시간이 걸릴 수 있습니다.

epoch = 0;
iteration = 0;

% Loop over epochs.
while epoch < numEpochs && ~monitor.Stop
    epoch = epoch + 1;

    % Reset and shuffle data.
    shuffle(mbq);

    % Loop over mini-batches.
    while hasdata(mbq) && ~monitor.Stop
        iteration = iteration + 1;

        % Read mini-batch of data.
        [X,T] = next(mbq);

        % Generate latent inputs for the generator network. Convert to
        % dlarray and specify the dimension labels "CB" (channel, batch).
        % If training on a GPU, then convert latent inputs to gpuArray.
        Z = randn(numLatentInputs,miniBatchSize,"single");
        Z = dlarray(Z,"CB");
        if (executionEnvironment == "auto" && canUseGPU) || executionEnvironment == "gpu"
            Z = gpuArray(Z);
        end

        % Evaluate the gradients of the loss with respect to the learnable
        % parameters, the generator state, and the network scores using
        % dlfeval and the modelLoss function.
        [~,~,gradientsG,gradientsD,stateG,scoreG,scoreD] = ...
            dlfeval(@modelLoss,netG,netD,X,T,Z,flipFactor);
        netG.State = stateG;

        % Update the discriminator network parameters.
        [netD,trailingAvgD,trailingAvgSqD] = adamupdate(netD, gradientsD, ...
            trailingAvgD, trailingAvgSqD, iteration, ...
            learnRate, gradientDecayFactor, squaredGradientDecayFactor);
        
        % Update the generator network parameters.
        [netG,trailingAvgG,trailingAvgSqG] = ...
            adamupdate(netG, gradientsG, ...
            trailingAvgG, trailingAvgSqG, iteration, ...
            learnRate, gradientDecayFactor, squaredGradientDecayFactor);
        
        % Every validationFrequency iterations, display batch of generated images using the
        % held-out generator input.
        if mod(iteration,validationFrequency) == 0 || iteration == 1
            
            % Generate images using the held-out generator input.
            XGeneratedValidation = predict(netG,ZValidation,TValidation);
            
            % Tile and rescale the images in the range [0 1].
            I = imtile(extractdata(XGeneratedValidation), ...
                GridSize=[numValidationImagesPerClass numClasses]);
            I = rescale(I);
            
            % Display the images.
            image(I)
            xticklabels([]);
            yticklabels([]);
            title("Generated Images");
        end

        % Update the training progress monitor.
        recordMetrics(monitor,iteration, ...
            GeneratorScore=scoreG, ...
            DiscriminatorScore=scoreD);

        updateInfo(monitor,Epoch=epoch,Iteration=iteration);
        monitor.Progress = 100*iteration/numIterations;
    end
end

판별기는 생성된 영상 중에서 실제 영상을 식별하는 강한 특징 표현을 학습했습니다. 생성기는 훈련 데이터와 유사한 영상을 생성할 수 있는 강한 특징 표현을 학습했습니다. 각 열이 하나의 클래스에 해당합니다.

훈련 플롯에 생성기 신경망과 판별기 신경망의 점수가 나와 있습니다. 신경망 점수를 해석하는 방법에 대한 자세한 내용은 Monitor GAN Training Progress and Identify Common Failure Modes 항목을 참조하십시오.

새 영상 생성하기

특정 클래스의 새 영상을 생성하려면, predict 함수를 생성기에 대해 사용하고, 확률 벡터와 원하는 클래스에 해당하는 레이블 배열의 배치를 포함하는 dlarray 객체를 지정합니다. 데이터를 dlarray 객체로 변환하고 차원 레이블 "CB"(채널, 배치)를 지정합니다. GPU 예측을 위해 데이터를 gpuArray 객체로 변환합니다. 영상을 함께 표시하려면 imtile 함수를 사용하고, rescale 함수를 사용하여 영상을 다시 스케일링하십시오.

첫 번째 클래스에 대응되는 난수 값 벡터 36개로 구성된 배열을 만듭니다.

numObservationsNew = 36;
idxClass = 1;
ZNew = randn(numLatentInputs,numObservationsNew,"single");
TNew = repmat(single(idxClass),[1 numObservationsNew]);

데이터를 차원 레이블 "SSCB"(공간, 공간, 채널, 배치)를 갖는 dlarray 객체로 변환합니다.

ZNew = dlarray(ZNew,"CB");
TNew = dlarray(TNew,"CB");

GPU를 사용하여 영상을 생성하려면 데이터를 gpuArray 객체로도 변환합니다.

if (executionEnvironment == "auto" && canUseGPU) || executionEnvironment == "gpu"
    ZNew = gpuArray(ZNew);
    TNew = gpuArray(TNew);
end

생성기 신경망과 함께 predict 함수를 사용하여 영상을 생성합니다.

XGeneratedNew = predict(netG,ZNew,TNew);

플롯에 생성된 영상을 표시합니다.

figure
I = imtile(extractdata(XGeneratedNew));
I = rescale(I);
imshow(I)
title("Class: " + classes(idxClass))

생성기 신경망이 지정된 클래스에 맞춰진 영상을 생성합니다.

모델 손실 함수

함수 modelLoss는 생성기 및 판별기 dlnetwork 객체 netG와 netD, 입력 데이터로 구성된 미니 배치 X, 대응되는 레이블 T, 난수 값으로 구성된 배열 Z를 입력으로 받습니다. 그리고 신경망의 학습 가능한 파라미터에 대한 손실의 기울기, 생성기 상태, 신경망 점수를 반환합니다.

판별기가 실제 영상과 생성된 영상을 구분하는 방법을 지나치게 빨리 학습하는 경우 생성기 훈련이 실패할 수 있습니다. 판별기와 생성기의 학습 균형을 맞추려면 실제 영상 비율의 레이블을 무작위로 뒤집습니다.

function [lossG,lossD,gradientsG,gradientsD,stateG,scoreG,scoreD] = ...
    modelLoss(netG,netD,X,T,Z,flipFactor)

% Calculate the predictions for real data with the discriminator network.
YReal = forward(netD,X,T);

% Calculate the predictions for generated data with the discriminator network.
[XGenerated,stateG] = forward(netG,Z,T);
YGenerated = forward(netD,XGenerated,T);

% Calculate probabilities.
probGenerated = sigmoid(YGenerated);
probReal = sigmoid(YReal);

% Calculate the generator and discriminator scores.
scoreG = mean(probGenerated);
scoreD = (mean(probReal) + mean(1-probGenerated)) / 2;

% Flip labels.
numObservations = size(YReal,4);
idx = randperm(numObservations,floor(flipFactor * numObservations));
probReal(:,:,:,idx) = 1 - probReal(:,:,:,idx);

% Calculate the GAN loss.
[lossG, lossD] = ganLoss(probReal,probGenerated);

% For each network, calculate the gradients with respect to the loss.
gradientsG = dlgradient(lossG,netG.Learnables,RetainData=true);
gradientsD = dlgradient(lossD,netD.Learnables);

end

GAN 손실 함수

생성기의 목적은 판별기가 "real"로 분류하는 데이터를 생성하는 것입니다. 생성기에서 나온 영상이 판별기에 의해 실제 영상으로 분류될 확률을 극대화하려면 음의 로그 가능도 함수를 최소화하십시오.

판별기의 출력값 $\mathit{Y}$가 주어진 경우:

• $\hat{\mathit{Y}}=\sigma \left(\mathit{Y}\right)$는 입력 영상이 클래스 "real"에 속할 확률입니다.

• $1-\hat{\mathit{Y}}$은 입력 영상이 클래스 "generated"에 속할 확률입니다.

시그모이드 연산 $$\sigma$$는 modelLoss 함수에서 발생합니다. 생성기에 대한 손실 함수는 다음과 같이 지정됩니다.

$$\mathrm{lossGenerator}=-\mathrm{mean}\left(\log \left({\hat{\mathit{Y}}}_{\mathrm{Generated}}\right)\right),$$

여기서 $${\underset{}{\overset{ˆ}{Y}}}_{Generated}$$는 생성된 영상에 대한 판별기 출력 확률을 포함합니다.

판별기의 목적은 생성기에 "속지" 않는 것입니다. 판별기가 실제 영상과 생성된 영상을 성공적으로 판별해 낼 확률을 극대화하려면 해당하는 음의 로그 가능도 함수 합을 최소화하십시오. 판별기에 대한 손실 함수는 다음과 같이 지정됩니다.

$$\mathrm{lossDiscriminator}=-\mathrm{mean}\left(\log \left({\hat{\mathit{Y}}}_{\mathrm{Real}}\right)\right)-\mathrm{mean}\left(\log \left(1-{\hat{\mathit{Y}}}_{\mathrm{Generated}}\right)\right),$$

여기서 $${\underset{}{\overset{ˆ}{Y}}}_{Real}$$은 실제 영상에 대한 판별기 출력 확률을 포함합니다.

function [lossG, lossD] = ganLoss(scoresReal,scoresGenerated)

% Calculate losses for the discriminator network.
lossGenerated = -mean(log(1 - scoresGenerated));
lossReal = -mean(log(scoresReal));

% Combine the losses for the discriminator network.
lossD = lossReal + lossGenerated;

% Calculate the loss for the generator network.
lossG = -mean(log(scoresGenerated));

end

미니 배치 전처리 함수

preprocessMiniBatch 함수는 다음 단계를 사용하여 데이터를 전처리합니다.

1. 입력 셀형 배열에서 영상과 레이블 데이터를 추출하고 숫자형 배열로 결합합니다.

2. 영상이 [-1,1] 범위 내에 있도록 다시 스케일링합니다.

function [X,T] = preprocessData(XCell,TCell)

% Extract image data from cell and concatenate
X = cat(4,XCell{:});

% Extract label data from cell and concatenate
T = cat(1,TCell{:});

% Rescale the images in the range [-1 1].
X = rescale(X,-1,1,InputMin=0,InputMax=255);

end

참고 문헌

1. The TensorFlow Team. Flowers http://download.tensorflow.org/example_images/flower_photos.tgz

참고 항목

dlnetwork | forward | predict | dlarray | dlgradient | dlfeval | adamupdate

관련 항목

• 생성적 적대 신경망(GAN) 훈련시키기
• Monitor GAN Training Progress and Identify Common Failure Modes
• Train Fast Style Transfer Network
• Generate Images Using Diffusion
• 사용자 지정 훈련 루프, 손실 함수 및 신경망 정의
• Train Network Using Custom Training Loop
• Specify Training Options in Custom Training Loop
• 딥러닝 계층 목록