Een beginnershandleiding voor genetische netwerken van adverteerders (GAN’s)

Generatieve versus Discriminerende Berekeningen

Om GAN’s te begrijpen, moet je je realiseren hoe generatieve berekeningen werken, en daarvoor is het verhelderend om ze te onderscheiden van discriminerende berekeningen. Discriminerende berekeningen proberen invoerinformatie te karakteriseren; dat wil zeggen dat ze, gezien de hoogtepunten van een gelegenheid van informatie, anticiperen op een naam of klasse waarin die informatie een plaats heeft.

Bijvoorbeeld, gezien elk van de woorden in een e-mail (de informatie case), zou een discriminerende berekening kunnen voorzien of het bericht spam is of niet_spam. spam is een van de namen, en het pakket met woorden dat uit de e-mail is verzameld is de hoogtepunten die de informatie informatie bevatten. Op het moment dat deze kwestie wetenschappelijk wordt gecommuniceerd, wordt de naam y genoemd en worden de highlights x genoemd. De definitie p(y|x) wordt gebruikt om “de waarschijnlijkheid van y gegeven x” aan te geven, wat voor deze situatie zou betekenen “de waarschijnlijkheid dat een e-mail een spam is gegeven de woorden die het bevat”.

Dus discriminatoire berekeningen brengen de hoogtepunten in kaart om te markeren. Ze houden zich uitsluitend bezig met dat verband. Een benadering om generatieve berekeningen te overwegen is dat ze het omgekeerde doen. In plaats van te anticiperen op een merk dat bepaalde hoogtepunten bevat, proberen ze te voorzien in hoogtepunten die een specifieke naam krijgen.

De vraag die een generatieve berekening probeert te beantwoorden is: Verwachtend dat deze e-mail spam is, hoe waarschijnlijk zijn deze hoogtepunten? Terwijl discriminerende modellen zich zorgen maken over het verband tussen y en x, maken generatieve modellen zich zorgen over “hoe je x krijgt”. Ze stellen je in staat om p(x|y) te vangen, de waarschijnlijkheid van x gegeven y, of de waarschijnlijkheid van hoogtepunten gegeven een naam of klasse. (Al met al kunnen generatieve berekeningen ook gebruikt worden als classifiers. Om een of andere vreemde reden kunnen ze meer bereiken dan alleen maar orderinvoerinformatie).

Een andere benadering om het te overwegen is het herkennen van discriminerend van generatief zoals dit:

Discriminatiemodellen raken vertrouwd met de grens tussen klassen

Generatieve modellen modelleren de spreiding van individuele klassen

Hoe GAN’s werken

De ene neurale regeling, genaamd de generator, creëert nieuwe informatievoorvallen, terwijl de andere, de discriminator, deze beoordeelt op echtheid; de discriminator kiest bijvoorbeeld of elk voorkomen van informatie die hij overziet een plaats heeft met de echte voorbereidende dataset of niet.

Stel dat we proberen iets alledaags te bereiken dan de Mona Lisa te kopiëren. We zullen handmatig geschreven cijfers creëren zoals die in de MNIST-dataset, die uit deze huidige realiteit wordt gehaald. Het doel van de discriminator, wanneer deze een gebeurtenis uit de echte MNIST-dataset aangeeft, is het waarnemen van degenen die te goeder trouw zijn.

In de tussentijd maakt de generator nieuwe, geconstrueerde foto’s die naar de discriminator gaan. Het doet als zodanig in de verwachting dat ook zij, ondanks het feit dat ze nep zijn, als geldig zullen worden beschouwd. Het doel van de generator is het creëren van verdraaglijke, met de hand geschreven cijfers: liegen zonder te worden gekregen. Het doel van de discriminator is om foto’s die afkomstig zijn van de generator als nep te herkennen.

Hier zijn de middelen die een GAN neemt:

De generator neemt een willekeurig getal en geeft een foto terug.

Deze gemaakte foto wordt versterkt in de discriminator in de buurt van een vloedgolf van foto’s genomen van de echte, grondgetrouwe dataset.

De discriminator neemt zowel echte als vervalste foto’s en geeft waarschijnlijkheden terug, een getal ergens in het bereik van 0 en 1, waarbij 1 spreekt tot een verwachting van geloofwaardigheid en 0 spreekt tot vervalst.

Je hebt dus een tweeledige invoercirkel:

De discriminator zit in een invoercirkel met de grondwaarheid van de foto’s, die we kennen.

De generator zit in een invoercirkel met de discriminator.

GAN schema
Krediet: O’Reilly

U kunt denken aan een GAN als de beperking van een vervalser en een agent in een ronde van katachtige en muis, waar de vervalser is het uitzoeken van hoe te passeren valse noten, en de agent is het uitzoeken van hoe ze te herkennen. Beide zijn dynamisch; bijvoorbeeld, de agent is in de voorbereiding, ook (om de relatie te verbreden, mogelijk de nationale bank is begroeting kosten die stiekem voorbij), en elke kant komt om vertrouwd te raken met verschillende technieken in een consistente versnelling.

Voor MNIST, de discriminator organiseren is een standaard convolutionele schikking die kan classificeren de foto’s versterkt aan het, een binomiale classificator markeren foto’s als echte of nep. De generator is een omgekeerde convolutionele schikking, zou men kunnen zeggen: Terwijl een standaard convolutionele classificeerder een beeld neemt en het downsamples het om een waarschijnlijkheid te leveren, neemt de generator een vector van onregelmatige commotie en upsamples het aan een beeld. De belangrijkste informatie wordt weggegooid door middel van downsampling strategieën zoals maxpooling, en de tweede produceert nieuwe informatie.

De twee netten proberen een alternatieve en tegenstrijdige doelcapaciteit, of ongeluk, te stroomlijnen.

De twee netten proberen een alternatieve en tegenstrijdige doelcapaciteit, oftewel ongelukswerk, te stroomlijnen in een nul-zum-spel. Dit is in principe een pundit model op het scherm. Als de discriminator zijn gedrag verandert, verandert ook de generator, en andersom. Hun tegenslagen duwen tegen elkaar op.

GANs
GAN’s, Autoencoders en VAE’s

Het zou waardevol kunnen zijn om generatieve, slecht gedesinfecteerde systemen te contrasteren met andere neurale systemen, bijvoorbeeld autoencoders en variationele autoencoders.

Autoencoders coderen de invoergegevens als vectoren. Ze vormen een bedekte of gecomprimeerde weergave van de ruwe informatie. Ze zijn nuttig bij het verminderen van de dimensionaliteit; dat wil zeggen dat de vector die de ruwe informatie invult als een verborgen portrettering, de ruwe informatie in minder opmerkelijke metingen verpakt. Autoencoders kunnen worden gecombineerd met een zogenaamde decoder, die het mogelijk maakt om de invoerinformatie te herscheppen afhankelijk van de verborgen afbeelding, zoals u dat zou doen met een beperkte Boltzmann machine.

autencoderschema
Tips bij de voorbereiding van een GAN

Op het moment dat je de discriminator traint, houd je de generator in stand; en als je de generator traint, houd je de discriminator stil. Elk moet zich voorbereiden op een statische vijand. Dit geeft de generator bijvoorbeeld een superieure aflezing op de helling waar hij door moet leren.

Door de discriminator tegen MNIST te trainen voordat je begint met de voorbereiding van de generator, zal een duidelijkere helling worden ingesteld.

Elke kant van de GAN kan de andere overweldigen. In het geval dat de discriminator buitensporig groot is, zal hij zo dicht bij de 0 of 1 terugkomen dat de generator zal strijden om de helling door te nemen. In het geval dat de generator te groot is, zal deze hardnekkig op zoek gaan naar tekortkomingen in de discriminator die leiden tot nepnegatieven. Dit kan worden gematigd door de individuele leertempo’s van de netten. De twee neurale systemen moeten een vergelijkbaar “bekwaamheidsniveau” hebben. 1

De GAN’s hebben een lange voorbereidingsperiode achter de rug. Op een eenzame GPU kan een GAN uren duren, en op een eenzame CPU gedurende een dag. Hoewel het moeilijk is om af te stemmen en dus te gebruiken, hebben de GAN’s een ton aan fascinerende verkenningen en composities verkwikt.

Hier is een voorbeeld van een GAN gecodeerd in Keras, waaruit modellen kunnen worden geïmporteerd naar Deeplearning4j.

klasse GAN():

def __init__(zelf):

    self.img_rows = 28

    self.img_cols = 28

    self.channels = 1

    self.img_shape = (self.img_shares, self.img_cols, self.channels)

    optimalisator = Adam (0,0002, 0,5)

    # Bouw en compileren de discriminator

    zelf.discriminator = zelf.bouw_discriminator()

    self.discriminator.compile(loss='binaire_crossentropie',

        optimizer=optimizer,

        metriek=['nauwkeurigheid'])

    # Bouw en compileer de generator

    self.generator = self.build_generator()

    self.generator.compile(loss='binary_crossentropy', optimizer=optimizer)

    # De generator neemt ruis als input en genereert imgs

    z = Invoer (vorm=(100,))

    img = self.generator(z)

    # Voor het gecombineerde model zullen we alleen de generator trainen

    zelf.discriminator.trainbaar = vals

    # De geldige neemt gegenereerde beelden als invoer en bepaalt de geldigheid

    geldig = self.discriminator(img)

    # Het gecombineerde model (gestapelde generator en discriminator) neemt

    # ruis als invoer => genereert beelden => bepaalt de geldigheid

    self.combined = Model (z, geldig)

    self.combined.compile(loss='binary_crossentropy', optimizer=optimizer)

def build_generator(self):

    geluidsvorm = (100,)

    model = sequentieel()

    model.add(Dicht(256, input_shape=noise_shape))

    model.add(LeakyReLU(alpha=0.2))

    model.add (BatchNormalisatie (momentum=0,8))

    model.add (Dicht(512))

    model.add(LeakyReLU(alpha=0.2))

    model.add (BatchNormalisatie (momentum=0,8))

    model.add (Dicht(1024))

    model.add(LeakyReLU(alpha=0.2))

    model.add (BatchNormalisatie (momentum=0,8))

    model.add(Dicht(np.prod(self.img_shape), activering='tanh'))

    model.add(Reshape(self.img_shape))

    model.samenvatting()

    ruis = ingang (vorm=ruis_vorm)

    img = model (geluid)

    retourmodel (geluid, img)

def build_discriminator(self):

    img_shape = (self.img_rows, self.img_cols, self.channels)

    model = sequentieel()

    model.add(Flatten(input_shape=img_shape))

    model.add (Dicht(512))

    model.add(LeakyReLU(alpha=0.2))

    model.add (Dicht(256))

    model.add(LeakyReLU(alpha=0.2))

    model.add(Dicht(1, activering=sigmoid'))

    model.samenvatting()

    img = Input(vorm=img_vorm)

    geldigheid = model (img)

    retour model (img, geldigheid)

def train(self, epochs, batch_size=128, save_interval=50):

    # Laad de dataset

    (X_train, _), (_, _) = mnist.load_data()

    # Rescale -1 tot 1
    X_train = (X_train.astype(np.float32) - 127,5) / 127,5

    X_train = np.expand_dims(X_train, as=3)

    half_batch = int(batch_size / 2)

    voor tijdperk in bereik (tijdperken):

        # ---------------------

        # Train Discriminator

        # ---------------------

        # Selecteer een willekeurige halve batch van beelden

        idx = np.random.randint(0, X_train.shape[0], half_batch)

        imgs = X_train[idx]

        ruis = np.random.normal(0, 1, (halve_batch, 100))

        # Genereer een halve batch van nieuwe beelden

        gen_imgs = zelf.generator.predict(ruis)

        # Train de discriminator

        d_loss_real = self.discriminator.train_on_batch(imgs, np.ones((half_batch, 1)))

        d_loss_fake = self.discriminator.train_on_batch(gen_imgs, np.nullen((half_batch, 1)))

        d_loss = 0,5 * np.add(d_loss_real, d_loss_fake)

        # ---------------------

        # Trein generator

        # ---------------------

        ruis = np.random.normal(0, 1, (batch_size, 100))

        # De generator wil dat de discriminator de gegenereerde monsters labelt...

        # als geldig (degenen)

        valid_y = np.array([1] * batch_size)

        # Train de generator

        g_loss = self.combined.train_on_batch(ruis, geldig_y)

        # Plot de vooruitgang

        afdrukken ("%d [D-verlies: %f, acc.: %.2f%%] [G-verlies: %f]" % (tijdperk, d_verlies[0], 100*d_verlies[1], g_verlies))

        # Als bij opslag interval => gegenereerde beeldvoorbeelden opslaan

        indien tijdperk % save_interval == 0:

            self.save_imgs(tijdperk)

def save_imgs(zelf, tijdperk):

    r, c = 5, 5

    ruis = np.random.normal(0, 1, (r * c, 100))

    gen_imgs = zelf.generator.predict(ruis)

    # Rescale beelden 0 - 1

    gen_imgs = 0,5 * gen_imgs + 0,5

    vijg, bijlen = plt.subplots(r, c)

    cnt = 0

    voor i in bereik(r):

        voor j in bereik(c):

            axs[i,j].imshow(gen_imgs[cnt, :,:,0], cmap='gray')

            axs[i,j].axis('off')

            cnt += 1

    fig.savefig("gan/images/mnist_%d.png" % tijdperk)

    plt.close()

als naam == ‘main‘:

gan = GAN()

gan.train(epochs=30000, batch_size=32, save_interval=200)