Courseran deeplearning.ai: CNN-Art Generation with Neural Style Transfer

Courseras Deeplearning



Syvä oppiminen ja taide: hermostyylin siirto

Algoritmin ovat ehdottaneet Gatys et ai. (2015) ( https://arxiv.org/abs/1508.06576 ).
Tässä kokeessa voit toteuttaa hermostyylin siirtoalgoritmin käyttämällä algoritmia taiteellisten kuvien luomiseen.
Monet algoritmit optimoivat kustannusfunktion saadakseen joukon parametriarvoja. Optimoi hermostyylisiirrossa kustannustoiminto pikseliarvojen saamiseksi.

1 - Ongelma

Neural Style Transfer (NST) on mielenkiintoinen tekniikka syvälliseen oppimiseen. Kuten alla on esitetty, hän yhdisti kaksi kuvaa, nimeltään sisältökuva (C) ja tyylikuva (S), kuvan luomiseksi (G). G sisältää kuvan C sisällön ja kuvan S tyylin.
Tässä esimerkissä Pariisissa otettu kuva Louvresta (sisältökuva C) ja impressionistisen johtajan Claude Monet'n maalaus on sekoitettava.
kuva



Kahden siirron oppiminen

Neural Style Transfer (NST) käyttää ennalta koulutettua konvoluutiohermoverkkoa ja rakentaa sitä. Ajatusta käyttää eri tehtäviin koulutettua verkkoa ja soveltaa sitä uuteen tehtävään kutsutaan siirto-oppimiseksi.
Alkuperäisen NST-paperin ( https://arxiv.org/abs/1508.06576 ), käytämme VGG-verkkoa. Käytä VGG-19, joka on 19-kerroksinen versio VGG-verkosta. Tämä malli on koulutettu erittäin laajaan ImageNet-tietokantaan, joten se on oppinut tunnistamaan erilaisia ​​matalan tason ominaisuuksia (varhaisessa vaiheessa) ja korkean tason ominaisuuksia (syvemmällä tasolla).
Seuraavan koodin suorittaminen parametrien lataamiseksi VGG-mallista voi viedä muutaman sekunnin.



model = load_vgg_model('pretrained-model/imagenet-vgg-verydeep-19.mat') print(model)

Malli on tallennettu python-sanakirjaan, kukin muuttujan nimi on avain ja vastaava arvo on muuttujan arvon sisältävä tensori. Jos haluat suorittaa kuvan tässä verkossa, syötä kuva vain malliin. TensorFlow-ohjelman avulla voit käyttää tf.-määritystoimintoa. Voit käyttää osoituskirjainta
model['input'].assign(image)
kuten mallin syötteenä, sitten, jos haluat käyttää tietyn kerroksen, kuten 4_2-tason, aktivointia, kun verkko on käynnissä kuvassa, voit suorittaa TensorFlow-istunnon oikeassa tensori conv4_2:



sess.run(model['conv4_2'])

3-hermostyyli

NST-algoritmi on jaettu kolmeen vaiheeseen:

  • Laske sisällön kustannustoiminto JctaintOnnt(C,G) J c o n t e n t (C, G)
  • Laske tyylikustannusfunktio JstYlOn(C,G) J s t y l e (C, G)
  • Laske kokonaiskustannusfunktio J(G)=aJctaintOnnt(C,G)+bJstYlOn(C,G) J (G) = α J c o n t e n t (C, G) + β J s t y l e (C, G)
    3.1-Laske sisällön hinta
    Käynnissä olevassa esimerkissä sisältökuva C on kuva Pariisin Louvresta. Suorita koodi nähdäksesi Louvren kuvan:
content_image = scipy.misc.imread('images/louvre.jpg') imshow(content_image)

kuva
3.1.1-Kuinka varmistaa, että luotu kuva G vastaa kuvan C sisältöä
ConvNetin varhaisilla (kevyemmillä) kerroksilla on taipumus havaita alemman tason ominaisuuksia, kuten reunat ja yksinkertaiset tekstuurit, ja myöhemmillä (syvemmillä) kerroksilla on taipumus havaita kehittyneempiä ominaisuuksia, kuten monimutkaisempia tekstuureja ja objektiluokkia.
Haluamme, että generoidulla kuvalla G on samanlainen sisältö kuin sisääntulokuvalla C. Oletetaan, että tietyn kerroksen aktivointi on valittu edustamaan kuvan sisältöä. Käytännössä, jos valitset verkon keskellä olevan kerroksen, saat visuaalisesti miellyttävimmän vaikutuksen. (Kun olet suorittanut harjoituksen, voit palata takaisin ja yrittää käyttää erilaisia ​​kerroksia nähdäksesi, kuinka tulos muuttuu)
Oletetaan, että tietty piilotettu kerros on valittu käytettäväksi. Aseta nyt kuva C ennalta koulutetun VGG-verkon tuloksi ja levitä sitä eteenpäin. tehdä ettäC a CPiilotetun kerroksen aktivointi sinulle valitussa kerroksessa on a nH×nSISÄÄN×nC n K × n L × n CTensori. Toista tämä prosessi kuvalla G: aseta G tuloksi ja siirry sitten eteenpäin. tehdä ettäG a GVastaava piilotettu kerros aktivoidaan. Määritämme sisällön menetysfunktion seuraavasti:



JctaintOnnt(C,G)=14×nH×nSISÄÄN×nCkaikki merkinnät(että(C)-että(G))kaksi(1) (1) J c o n t e n t (C, G) = 1 4 × n H × n W × n C ∑ kaikki merkinnät (a (C) - a (G)) 2
Tässä, nH,nSISÄÄN,nC n H, n W, n CSe on valittujen piilotettujen kerrosten korkeus, leveys ja lukumäärä, ja se näkyy standardoituna kustannuseränä. ettäC a Ckanssa ettäG a GJotkut volyymit vastaavat piilotettujen kerrosten aktivointia. Laskentaa varten JctaintOnnt(C,G) J c o n t e n t (C, G), Laajenna nämä 3D-tilavuudet 2D-matriisiin alla olevan kuvan mukaisesti. (Teknisesti ottaen näitä purkautumissuhteita ei tarvitse laskea JctaintOnnt J c o n t e n t, Mutta kun sinun on suoritettava vastaavat toiminnot myöhemmin tyylivakioiden laskemiseksi JstYlOn J s t y l e, Tämä on hyvä käytäntö. )
kuva
Harjoitus: Käytä TensorFlow'ta laskeaksesi sisällön menetys
Kuvaus: Tämän toiminnon saavuttamiseksi on kolme vaihetta:
1. Alkaen ettäGTarkistaaNiinulottuvuustutkinto a G Tarkista niin -mitta-aste
  • Voit hakea mitat tensorista X käyttämällä: X.get_shape().as_list()
  • avaa a_C ja a_G yllä olevan kuvan mukaisesti
  • Laske sisällön kustannukset.
# GRADED FUNCTION: compute_content_cost def compute_content_cost(a_C, a_G): ''' Computes the content cost Arguments: a_C -- tensor of dimension (1, n_H, n_W, n_C), hidden layer activations representing content of the image C a_G -- tensor of dimension (1, n_H, n_W, n_C), hidden layer activations representing content of the image G Returns: J_content -- scalar that you compute using equation 1 above. ''' ### START CODE HERE ### # Retrieve dimensions from a_G (≈1 line) m, n_H, n_W, n_C = a_G.get_shape().as_list() # Reshape a_C and a_G (≈2 lines) a_C_unrolled = tf.reshape(a_C,shape=[m, n_H*n_W, n_C]) a_G_unrolled = tf.reshape(a_G,shape=[m, n_H*n_W, n_C]) # compute the cost with tensorflow (≈1 line) J_content = tf.reduce_sum(tf.square(a_C_unrolled - a_G_unrolled))/(4 * n_H * n_W * n_C) ### END CODE HERE ### return J_content tf.reset_default_graph() with tf.Session() as test: tf.set_random_seed(1) a_C = tf.random_normal([1, 4, 4, 3], mean=1, stddev=4) a_G = tf.random_normal([1, 4, 4, 3], mean=1, stddev=4) J_content = compute_content_cost(a_C, a_G) print('J_content = ' + str(J_content.eval()))

Odotettu tulos on: J_content = 6.76559
3.2-Laske tyylikustannukset
Juoksukotelossa käytämme seuraavaa tyylikuvaa:

style_image = scipy.misc.imread('images/monet_800600.jpg') imshow(style_image)

kuva
3.2.1-tyylinen matriisi
Tyylimatriisista tulee myös grammatriiseja. Lineaarisessa algebrassa joukko vektoreita (v1,...,vn) (v 1, ..., v n)Grammatriisi G on pistetuotteiden matriisi, Gij=vTivj=ns.dtait(vi,vj) G i j = v i T v j = n p. d o t (v i, v j). toisin sanoen, Gij G i jLaskeminen vi v ivastaan vj v jSamankaltaisuusaste: jos ne ovat hyvin samankaltaisia, niillä odotetaan olevan suuri pistetuote, joten anna Gij G i jIso.
NST: ssä laskentatyyppimatriisi lasketaan kertomalla rullattu suodatinmatriisi ja niiden transponoitu matriisi:
kuva
Tuloksena on matriisin ulottuvuus ( nC,nC n C, n C), nC n COnko suodattimien määrä. Gij G i jLaskennan suodatin i iAktivointi suodattimilla j jAktivointien samankaltaisuus.
diagonaaliset elementit Gii G i iMitattu kuinka aktiivinen suodatin i iOn. Oletetaan esimerkiksi suodatin i iTunnista pystysuorat kuviot. Sitten Gii G i iOnko mitta pystysuoran tekstuurin esiintyvyydestä koko kuvassa: jos Gii G i iErittäin suuri, mikä tarkoittaa, että tässä kuvassa on monia pystysuoria kuvioita.
Sieppaamalla erityyppisten esiintyvyys ( Gii G i i) ja kuinka monta eri ominaisuutta esiintyy yhdessä ( Gij G i j), tyylimatriisi G mittaa kuvan tyylin.
Harjoitus: TensorFlow-sovelluksella toteutetaan gramma-matriisi, joka laskee matriisin A. Kaava on: A: n grammatriisi on GTO=TOTOT G A = A A T.

# GRADED FUNCTION: gram_matrix def gram_matrix(A): ''' Argument: A -- matrix of shape (n_C, n_H*n_W) Returns: GA -- Gram matrix of A, of shape (n_C, n_C) ''' ### START CODE HERE ### (≈1 line) GA = tf.matmul(A, tf.transpose(A)) ### END CODE HERE ### return GA tf.reset_default_graph() with tf.Session() as test: tf.set_random_seed(1) A = tf.random_normal([3, 2*1], mean=1, stddev=4) GA = gram_matrix(A) print('GA = ' + str(GA.eval()))

odotetut tulokset:

GA = [[ 6.42230511 -4.42912197 -2.09668207] [ -4.42912197 19.46583748 19.56387138] [ -2.09668207 19.56387138 20.6864624 ]]

3.2.2-tyylinen menetys
Gram-matriisin laskemisen jälkeen tavoitteena on minimoida tyylikuvan S Gram-matriisin ja luodun kuvan G Gram-matriisin välinen etäisyys. Nyt käytetään vain yhtä piilotettua kerrosta että[l] a [l], Tämän tason vastaava tyylihäviö on määritelty

J[l]stYlOn(S,G)=14×nCkaksi×(nH×nSISÄÄN)kaksii=1nCj=1nC(G(S)ij-G(G)ij)kaksi(kaksi) (2) J-tyyli [l] (S, G) = 1 4 × n C 2 × (n H × n W) 2 ∑ i = 1 n C ∑ j = 1 n C (G ij (S) - G ij (G)) 2
missä, GS G Skanssa GG G GNämä ovat tyylikuvia ja luotujen kuvien Gram-matriiseja, jotka käyttävät verkon piilotetun kerroksen piilokerrosaktivointilaskelmia.
Harjoitus: Laske yhden kerroksen tyylikustannukset.
Kuvaus: Toiminnon toteuttamiseksi on kolme vaihetta:
  • Aktivoi a_G-hakuulottuvuus piilotetusta kerroksesta: noudata ulottuvuutta tensorin X mukaan: X.get_shape (). As_list ()
  • Aktivoi piilotettu kerros a_S ja s_G 2roll-matriisiin, kuten yllä on esitetty
  • Laske kuvien S ja G tyylimatriisi (aiemmin kirjoitetun toiminnon avulla)
  • Laske tyylin menetys
# GRADED FUNCTION: compute_layer_style_cost def compute_layer_style_cost(a_S, a_G): ''' Arguments: a_S -- tensor of dimension (1, n_H, n_W, n_C), hidden layer activations representing style of the image S a_G -- tensor of dimension (1, n_H, n_W, n_C), hidden layer activations representing style of the image G Returns: J_style_layer -- tensor representing a scalar value, style cost defined above by equation (2) ''' ### START CODE HERE ### # Retrieve dimensions from a_G (≈1 line) m, n_H, n_W, n_C = a_G.get_shape().as_list() # Reshape the images to have them of shape (n_C, n_H*n_W) (≈2 lines) a_S = tf.reshape(a_S, [n_H*n_W, n_C]) a_G = tf.reshape(a_G, [n_H*n_W, n_C]) # Computing gram_matrices for both images S and G (≈2 lines) GS = gram_matrix(tf.transpose(a_S)) GG = gram_matrix(tf.transpose(a_G)) # Computing the loss (≈1 line) J_style_layer = tf.reduce_sum(tf.square(GS-GG))/(4 * n_C**2 * (n_W*n_H)**2) ### END CODE HERE ### return J_style_layer tf.reset_default_graph() with tf.Session() as test: tf.set_random_seed(1) a_S = tf.random_normal([1, 4, 4, 3], mean=1, stddev=4) a_G = tf.random_normal([1, 4, 4, 3], mean=1, stddev=4) J_style_layer = compute_layer_style_cost(a_S, a_G) print('J_style_layer = ' + str(J_style_layer.eval()))

Haluttu tulos: J_style_layer = 9.19028
(Huomaa tässä otsikkovihje: Muotoile kuvat uudelleen muodoltaan (n_C, n_H * n_W), mutta tässä sinun on muotoiltava uudelleen nimellä (n_H * n_W, n_C), muuten tulos on väärä)
3.2.3 Tyylipainot
Nyt kun tyyli on tallennettu yhdestä kerroksesta, sinun on yhdistettävä tyylin kustannukset eri tasoista ja saat parempia tuloksia. Harjoituksen jälkeen voit palata takaisin ja kokeilla erilaisia ​​painoja nähdäksesi, miten se muuttaa luotua kuvaa G. Tällä hetkellä tämä on kohtuullinen oletus:

STYLE_LAYERS = [ ('conv1_1', 0.2), ('conv2_1', 0.2), ('conv3_1', 0.2), ('conv4_1', 0.2), ('conv5_1', 0.2)]

Eri kerrosten tyylikustannukset voidaan yhdistää:

JstYlOn(S,G)=lλ[l]J[l]stYlOn(S,G) J s t y l e (S, G) = ∑ l λ [l] J s t y l e [l] (S, G)
Tässä, λ[l] λ [l]Arvo STYLE_LAYERS Annettu. def compute_style_cost(model, STYLE_LAYERS): ''' Computes the overall style cost from several chosen layers Arguments: model -- our tensorflow model STYLE_LAYERS -- A python list containing: - the names of the layers we would like to extract style from - a coefficient for each of them Returns: J_style -- tensor representing a scalar value, style cost defined above by equation (2) ''' # initialize the overall style cost J_style = 0 for layer_name, coeff in STYLE_LAYERS: # Select the output tensor of the currently selected layer out = model[layer_name] # Set a_S to be the hidden layer activation from the layer we have selected, by running the session on out a_S = sess.run(out) # Set a_G to be the hidden layer activation from same layer. Here, a_G references model[layer_name] # and isn't evaluated yet. Later in the code, we'll assign the image G as the model input, so that # when we run the session, this will be the activations drawn from the appropriate layer, with G as input. a_G = out # Compute style_cost for the current layer J_style_layer = compute_layer_style_cost(a_S, a_G) # Add coeff * J_style_layer of this layer to overall style cost J_style += coeff * J_style_layer return J_style

Huomaa: Edellä olevan silmukan sisäisessä silmukassa a_G on tensori eikä sitä ole vielä arvioitu. Kun suoritamme TensorFlow-kuvaajan mallissa_nn (), se arvioidaan ja päivitetään jokaisessa iteraatiossa.
pitäisi muistaa:
Kuvan tyyli voidaan esittää piilotetun kerroksen aktivoimalla Gram-matriisilla. Sitten yhdistin tämän esityksen useista eri kerroksista parempien tulosten saamiseksi. Tämä on jyrkässä ristiriidassa sisällön esityksen kanssa, jolloin piilotettu kerros yleensä riittää.
Tyylikustannusten pienentäminen voi saada kuvan G seuraamaan kuvan S tyyliä.
3.3- Määritä optimoinnin kokonaiskustannukset
Luo lopuksi kustannustoiminto, joka minimoi tyyli- ja sisältökustannukset. Kaava on:

J(G)=aJctaintOnnt(C,G)+bJstYlOn(S,G) J (G) = α J c o n t e n t (C, G) + β J s t y l e (S, G)
Harjoitus: Ota käyttöön kokonaiskustannustoiminto, joka sisältää sisällön ja tyylin kustannukset. GRADED FUNCTION: total_cost def total_cost(J_content, J_style, alpha = 10, beta = 40): ''' Computes the total cost function Arguments: J_content -- content cost coded above J_style -- style cost coded above alpha -- hyperparameter weighting the importance of the content cost beta -- hyperparameter weighting the importance of the style cost Returns: J -- total cost as defined by the formula above. ''' ### START CODE HERE ### (≈1 line) J = alpha * J_content + beta * J_style ### END CODE HERE ### return J tf.reset_default_graph() with tf.Session() as test: np.random.seed(3) J_content = np.random.randn() J_style = np.random.randn() J = total_cost(J_content, J_style) print('J = ' + str(J))

Odotettu tuotos: J = 35.34667875478276
Huomautus:
Kokonaishinta on sisällön hinta JctaintOnnt(C,G) J c o n t e n t (C, G)Kustannukset tyylillä JstYlOn(S,G) J s t y l e (S, G)Lineaarinen yhdistelmä
a akanssa b bOn hyperparametri, joka hallitsee sisällön ja tyylin välistä suhteellista painoa

4- Ratkaise optimointiongelmat

Lopuksi laitetaan kaikki yhteen Neural Style Transferin toteuttamiseksi.
Tässä on, mitä ohjelman on tehtävä:

  • Luo interaktiivinen istunto
  • Lataa sisältökuva
  • Lataa tyylikuva
  • Alusta luotava kuva satunnaisesti
  • Lataa VGG16-malli
  • Suorita TensorFlow-kaavio:
    Suorita sisältökuva VGG-mallin läpi ja laske sisällön hinta
    Suorita sisältökuva VGG-mallin läpi ja laske tyylikustannukset
    laskea kokonaiskustannukset
    Määritä optimoija ja oppimisnopeus.
  • Alusta TensorFlow-kaavio ja suorita suuri määrä iterointeja päivittääksesi luotun kuvan kussakin vaiheessa.

On toteutettu aiemmin J(G) J (G)Kokonaiskustannukset. Nyt asetamme TensorFlow: n G GOptimoida. Tätä varten ohjelman on nollattava kaavio ja käytettävä 'Interaktiivista istuntoa'. Toisin kuin tavallisessa istunnossa, 'vuorovaikutteinen istunto' asentaa itsensä kaavioiden rakentamisen aloitusistunnoksi. Tämä sallii muuttujien suorittamisen viittaamatta istuntoobjektiin, mikä yksinkertaistaa koodia.

# Reset the graph tf.reset_default_graph() # Start interactive session sess = tf.InteractiveSession()

Lataa, muotoile ja vakioi sisältökuvamme (kuva Louvresta):

content_image = scipy.misc.imread('images/louvre_small.jpg') content_image = reshape_and_normalize_image(content_image)

Lataa, muotoile ja vakioi 'tyylikuva' (Claude Monet's maalaus):

style_image = scipy.misc.imread('images/monet.jpg') style_image = reshape_and_normalize_image(style_image)

Nyt 'luotu' kuva alustetaan kohokuvana, joka on luotu sisältökuvasta. Alustamalla syntyvän kuvan pikselit ovat pääosin kohinaa, mutta silti hieman suhteessa sisältökuvaan, mikä auttaa 'luodun' kuvan sisältöä vastaamaan 'sisältö' -kuvan sisältöä nopeammin. (Voit tarkistaa generoida_noise_image (…) -kohdassa nst_utils.py napsauttamalla muistikirjan vasemmassa yläkulmassa olevaa Tiedosto–> Avaa…)

generated_image = generate_noise_image(content_image) imshow(generated_image[0])

kuva
Lataa VGG-malli:

model = load_vgg_model('pretrained-model/imagenet-vgg-verydeep-19.mat')

Jotta ohjelma voi laskea sisältökustannukset, aktivoimme nyt a_C ja a_G sopiviksi piilotetuiksi tasoiksi. Käytämme conv4_2-tasoa sisältökustannusten laskemiseen. Seuraava koodi on seuraava:

  • Määritä sisältökuva VGG-mallin syötteeksi.
  • Aseta a_C tensoriksi, jotta saat piilotetun kerroksen aktivoinnin conv4_2 kerrokselle.
  • Määritä a_G tensoriin piilotetun kerroksen aktivoimiseksi samalle kerrokselle.
  • Käytä a_C ja a_G laskea sisältökustannukset.
# Assign the content image to be the input of the VGG model. sess.run(model['input'].assign(content_image)) # Select the output tensor of layer conv4_2 out = model['conv4_2'] # Set a_C to be the hidden layer activation from the layer we have selected a_C = sess.run(out) # Set a_G to be the hidden layer activation from same layer. Here, a_G references model['conv4_2'] # and isn't evaluated yet. Later in the code, we'll assign the image G as the model input, so that # when we run the session, this will be the activations drawn from the appropriate layer, with G as input. a_G = out # Compute the content cost J_content = compute_content_cost(a_C, a_G)

Huomaa: a_G on tensori eikä sitä ole arvioitu. Kun suoritamme Tensorflow-kaavion mallissa_nn (), se arvioidaan ja päivitetään jokaisessa iteraatiossa.

# Assign the input of the model to be the 'style' image sess.run(model['input'].assign(style_image)) # Compute the style cost J_style = compute_style_cost(model, STYLE_LAYERS)

Harjoitus: Käytä JctaintOnnt J c o n t e n tkanssa JstYlOn J s t y l e, Soittamalla totalcost() Laskea kokonaiskustannukset J J,käyttää ettälshettä=10 a l p h a = 10kanssa bOntettä=40 b e t a = 40

### START CODE HERE ### (1 line) J = total_cost(J_content, J_style, alpha=10, beta=40) ### END CODE HERE ###

Määritä Adam-optimoija TensorFlow-sovelluksessa, oppimisnopeus on 2,0.

# define optimizer (1 line) optimizer = tf.train.AdamOptimizer(2.0) # define train_step (1 line) train_step = optimizer.minimize(J)

Harjoitus: Toteuta malli_nn () -toiminto, joka alustaa tensorivirtauskaavion muuttujat, asettaa tulokuvan (alun perin luodun kuvan) VGG16-mallin tuloksi ja suorittaa junan askelvaiheen.

def model_nn(sess, input_image, num_iterations = 200): # Initialize global variables (you need to run the session on the initializer) ### START CODE HERE ### (1 line) sess.run(tf.global_variables_initializer()) ### END CODE HERE ### # Run the noisy input image (initial generated image) through the model. Use assign(). ### START CODE HERE ### (1 line) sess.run(model['input'].assign(input_image)) ### END CODE HERE ### for i in range(num_iterations): # Run the session on the train_step to minimize the total cost ### START CODE HERE ### (1 line) sess.run(train_step) ### END CODE HERE ### # Compute the generated image by running the session on the current model['input'] ### START CODE HERE ### (1 line) generated_image = sess.run(model['input']) ### END CODE HERE ### # Print every 20 iteration. if i%20 == 0: Jt, Jc, Js = sess.run([J, J_content, J_style]) print('Iteration ' + str(i) + ' :') print('total cost = ' + str(Jt)) print('content cost = ' + str(Jc)) print('style cost = ' + str(Js)) # save current generated image in the '/output' directory save_image('output/' + str(i) + '.png', generated_image) # save last generated image save_image('output/generated_image.jpg', generated_image) return generated_image

Suorita seuraava yksikkö taiteellisen kuvan luomiseksi. Joka 20 iteraatiota suorittimen käyntiaika kestää noin 3 minuuttia. 140 iteraation jälkeen alkaa tarkkailla houkuttelevia tuloksia. Hermotyyppien siirtyminen koulutetaan yleensä GPU: illa.

model_nn(sess, generated_image)

Odotettu tuotos:
Iteraatio 0:
kokonaiskustannukset = 5.05035e + 09
sisällön hinta = 7877,67
tyylikustannukset = 1,26257e + 08

Kun olet suorittanut suorituksen, napsauta muistikirjan yläosassa olevaa Tiedosto-painiketta ja sitten Avaa. Siirry hakemistoon '/ output' nähdäksesi kaikki tallennetut kuvat. Avaa 'Generated Image' nähdäksesi luodun kuvan! :)
Sinun pitäisi nähdä kuva alla olevan kuvan oikealla puolella:
kuva

Koko koodilinkki: deeplearning.ai/Art Generation Neural Style Transfer-v2.ipynb -sovelluksella