Autoenkooderi TensorFlow'ssa esimerkin kanssa

Mikä on Autoencoder in Deep Learning?

An Automaattinen kooderi on työkalu datakoodauksen tehokkaaseen oppimiseen valvomatta tavalla. Se on eräänlainen keinotekoinen hermoverkko joka auttaa sinua oppimaan tietojoukkojen esitystavan dimensionaalisuuden vähentämiseksi kouluttamalla neuroverkon jättämään huomiotta signaalikohinan. Se on loistava työkalu syötteen uudelleenluomiseen.

Yksinkertaisesti sanottuna kone ottaa esimerkiksi kuvan ja voi tuottaa läheisesti siihen liittyvän kuvan. Tällaisen neuroverkon syöte on nimeämätön, mikä tarkoittaa, että verkko pystyy oppimaan ilman valvontaa. Tarkemmin sanottuna verkko koodaa syötteen keskittyen vain kriittisimpään ominaisuuteen. Tämä on yksi syy siihen, miksi autoenkooderit ovat suosittuja dimensioiden vähentämisessä. Lisäksi autoenkoodereita voidaan käyttää generatiivisten oppimismallien tuottamiseen. Esimerkiksi neuroverkkoa voidaan kouluttaa joukolla pintoja ja sitten se voi tuottaa uusia pintoja.

Kuinka TensorFlow Autoencoder toimii?

Autoenkooderin tarkoitus on tuottaa likiarvo syötteestä keskittymällä vain oleellisiin ominaisuuksiin. Saatat ajatella, miksi et vain opettele kopioimaan ja liittämään syöte tulosteen tuottamiseksi. Itse asiassa automaattinen kooderi on joukko rajoitteita, jotka pakottavat verkon oppimaan uusia tapoja esittää dataa, toisin kuin pelkkä tulosteen kopioiminen.

Tyypillinen autoenkooderi määritellään syötteellä, sisäisellä esityksellä ja tulosteella (syötteen approksimaatio). Oppiminen tapahtuu sisäiseen esitykseen liitetyissä kerroksissa. Itse asiassa on olemassa kaksi pääkerroslohkoa, jotka näyttävät perinteiseltä neuroverkolta. Pieni ero on siinä, että tulosteen sisältävän kerroksen on oltava yhtä suuri kuin syöte. Alla olevassa kaaviossa alkuperäinen syöte menee ensimmäiseen lohkoon, jota kutsutaan enkooderiksi. Tämä sisäinen esitys pakkaa (pienentää) syötteen kokoa. Toisessa lohkossa tapahtuu syötteen rekonstruointi. Tämä on dekoodausvaihe.

Malli päivittää painot minimoimalla häviöfunktion. Mallia rangaistaan, jos rekonstruktiotulos poikkeaa tulosta.

Kuvitellaan konkreettisesti kuva, jonka koko on 50 × 50 (eli 2 500 pikseliä) ja neuroverkko, jossa on vain yksi piilotettu kerros, joka koostuu sadasta neuronista. Oppiminen tapahtuu ominaisuuskartalla, joka on 25 kertaa pienempi kuin syöte. Tämä tarkoittaa, että verkon on löydettävä tapa rekonstruoida 2 500 pikseliä vain 100 neuronimäärän vektorilla.

Pinottu automaattinen kooderi esimerkki

Tässä Autoencoder-tutoriaalissa opit käyttämään pinottua autoenkooderia. Sen arkkitehtuuri on samanlainen kuin perinteisen neuroverkon. Syötesignaali menee piilotetulle kerrokselle pakattavaksi eli sen koon pienentämiseksi, ja sitten se saavuttaa rekonstruointikerrokset. Tavoitteena on tuottaa mahdollisimman lähellä alkuperäistä oleva kuva. Mallin on opittava, miten se saavuttaa tehtävänsä tietyillä rajoituksilla eli pienemmällä ulottuvuudella.

Nykyään syväoppimisen autoenkoodereita käytetään pääasiassa kuvan kohinanpoistoon. Kuvittele kuva, jossa on naarmuja; ihminen pystyy silti tunnistamaan sisällön. Autoenkooderin kohinanpoiston ideana on lisätä kuvaan kohinaa, jotta verkko pakotetaan oppimaan datan taustalla oleva kuvio.

Toinen hyödyllinen Autoencoder-perhe Deep Learning on variaatioinen autoenkooderi. Tämän tyyppinen verkko voi luoda uusia kuvia. Kuvittele, että koulutat verkkoa miehen kuvalla; tällainen verkko voi tuottaa uusia kasvoja.

Alla olevassa taulukossa tässä opetusohjelmassa rakennettu pinottu autoenkooderi on sijoitettu muiden todennäköisesti kohtaamiesi perheiden viereen, joten kunkin lisäämän rajoitteen vertailu on helppoa.

Autoenkooderin rakentaminen TensorFlow'n avulla

Tässä opetusohjelmassa opit rakentamaan pinotun automaattisen enkooderin kuvan rekonstruoimiseksi.

Käytät CIFAR-10-aineistoa, joka sisältää 60 000 32 × 32 -värikuvaa. Autoencoder-aineisto on jo jaettu 50 000 kuvaan koulutusta varten ja 10 000 kuvaan testausta varten. Luokkia on jopa kymmenen:

• Lentokone
• Auto
• Lintu
• Kissa
• Hirvi
• Koira
• Sammakko
• Hevonen
• Lähettää
• kuorma-auto

Sinun täytyy ladata kuvat osoitteesta CIFAR-10-aineistosivu ja pura arkisto. Kansio cifar-10-batches-py sisältää viisi dataerää, joissa kussakin on 10 000 kuvaa satunnaisessa järjestyksessä.

Ennen kuin rakennat ja koulutat malliasi, sinun on käytettävä jonkin verran tietojenkäsittelyä. Toimit seuraavasti:

1. Tuo tiedot
2. Muunna tiedot mustavalkomuotoon
3. Liitä kaikki erät
4. Luo harjoitustietojoukko
5. Rakenna kuvan visualisoija

Versiohuomautus: Tämän tutoriaalin koodi on suunnattu TensorFlow 1.x:lle. TensorFlow 2:ssa tf.contrib-moduulia ei enää ole, ja paikkamerkit, istunnot ja alustettava iteraattori sijaitsevat tf.compat.v1-tiedoston alla. tf.compat.v1.disable_v2_behavior()-funktion kutsuminen tuonnin jälkeen on nopein tapa suorittaa listaukset muuttumattomina.

Kuvan esikäsittely

Vaihe 1) Tuo tiedot

Virallisen verkkosivuston mukaan voit ladata tiedot seuraavalla koodilla. Autoencoder-koodi lataa tiedot sanakirjaan, joka sisältää tiedot ja niiden otsikon. Huomaa, että koodi on funktio.

import numpy as np
import tensorflow as tf
import pickle
def unpickle(file):
    import pickle
    with open(file, 'rb') as fo:
        dict = pickle.load(fo, encoding='latin1')
    return dict

Vaihe 2) Muunna tiedot mustavalkomuotoon

Yksinkertaisuuden vuoksi voit muuntaa tiedot harmaasävyiksi. Eli vain yksi ulottuvuus verrattuna kolmeen värikuvaan. Suurin osa hermoverkosta toimii vain yhden ulottuvuuden tulolla.

def grayscale(im):
    return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)

Vaihe 3) Liitä kaikki erät

Nyt kun molemmat funktiot on luotu ja datajoukko ladattu, voit kirjoittaa silmukan liittääksesi tiedot muistiin. Jos tarkistat huolellisesti, puretun datatiedoston nimi on data_batch_ ja se on numeroitu väliltä 1–5. Voit käydä tiedostot läpi ja liittää ne dataan.

Kun tämä vaihe on valmis, muunnat väridatan harmaasävymuotoon. Kuten näet, datan muoto on 50000 ja 1024. 32*32 pikseliä on nyt litistetty 1024:ksi.

# Load the data into memory
data, labels = [], []
## Loop over the b
for i in range(1, 6):
    filename = './cifar-10-batches-py/data_batch_' + str(i)
    open_data = unpickle(filename)
    if len(data) > 0:
        data = np.vstack((data, open_data['data']))
        labels = np.hstack((labels, open_data['labels']))
    else:
        data = open_data['data']
        labels = open_data['labels']

data = grayscale(data)
x = np.matrix(data)
y = np.array(labels)
print(x.shape)
(50000, 1024)

Huomautus: Muuta './cifar-10-batches-py/data_batch_' tiedostosi todelliseksi sijainniksi. Esimerkiksi Windows koneeseen, polku voisi olla tiedostonimi = 'E:\cifar-10-batches-py\data_batch_' + str(i)

Vaihe 4) Luo harjoitustietojoukko

Koulutuksen nopeuttamiseksi ja helpottamiseksi koulutat mallia vain hevoskuvien avulla. Hevosilla on tunnistetiedoissa tunniste 7. Kuten CIFAR-10-tietojoukon dokumentaatiossa mainitaan, jokainen luokka sisältää 5000 kuvaa. Voit tulostaa datan muodon varmistaaksesi, että kuvia on 5 000 ja sarakkeita 1024, kuten alla olevassa TensorFlow Autoencoder -esimerkkivaiheessa on esitetty.

horse_i = np.where(y == 7)[0]
horse_x = x[horse_i]
print(np.shape(horse_x)) 
(5000, 1024)

Vaihe 5) Rakenna kuvan visualisointityökalu

Lopuksi rakennat funktion kuvien piirtämiseksi. Tarvitset tätä toimintoa rekonstruoidun kuvan tulostamiseen autoenkooderista.

Helppo tapa tulostaa kuvia on käyttää Matplotlib-kirjaston imshow()-funktiota. Huomaa, että sinun on muunnettava datan muoto 1024:stä 32*32:een (eli kuvan muotoon).

# To plot pretty figures
%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt
def plot_image(image, shape=[32, 32], cmap = "Greys_r"):
    plt.imshow(image.reshape(shape), cmap=cmap,interpolation="nearest")
    plt.axis("off")   

Funktiolla on 3 argumenttia:

• Kuva: syöte
• Muoto: lista, kuvan mitta
• Cmap: valitse värikartta. Oletusarvoisesti harmaa

Voit yrittää piirtää tietojoukon ensimmäisen kuvan. Sinun pitäisi nähdä mies hevosen selässä.

plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")

Kutsu palauttaa alla olevan harmaasävypikkukuvan ja vahvistaa, että 1024-arvosta takaisin 32×32-kuvaksi tehty muodonmuutos on oikein.

Aseta Dataset Estimator

Okei, nyt kun tietojoukko on käyttövalmis, voit aloittaa TensorFlow'n käytön. Ennen mallin rakentamista käytä TensorFlow'n tietojoukon estimaattoria verkon syöttämiseen.

Rakennat tietojoukon TensorFlow-estimaattorilla. Mieli virkistämiseksi sinun on käytettävä:

• from_tensor_slices
• toistaa
• erä

Täysi koodi tietojoukon rakentamiseksi on:

dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)

Huomaa, että x on paikkamerkkimuotoinen [None,n_inputs]. Ensimmäiseksi ulottuvuudeksi asetetaan None, koska verkkoon syötettyjen kuvien määrä on yhtä suuri kuin erän koko, joka päätetään vasta suorituksen aikana. Lisätietoja on opetusohjelmassa lineaarinen regressio TensorFlow'lla.

Tämän jälkeen sinun on luotava iteraattori. Ilman tätä koodiriviä tietoja ei kulje liukuhihnan läpi.

iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()

Nyt kun liukuhihna on valmis, voit tarkistaa, onko ensimmäinen kuva sama kuin ennen (eli mies hevosen selässä).

Asetat erän kooksi 1, koska haluat syöttää tietojoukkoon vain yhden kuvan. Voit nähdä datan ulottuvuuden komennolla print(sess.run(features).shape). Se on yhtä kuin (1, 1024). Luku 1 tarkoittaa, että joka kerta syötetään yksi 1024 arvon kuva. Jos erän kooksi asetetaan kaksi, putken läpi kulkee kaksi kuvaa. Älä muuta erän kokoa, muuten se antaa virheen, koska plot_image()-funktioon voi syöttää vain yhden kuvan kerrallaan.

## Parameters
n_inputs = 32 * 32
BATCH_SIZE = 1
batch_size = tf.placeholder(tf.int64)

# using a placeholder
x = tf.placeholder(tf.float32, shape=[None,n_inputs])
## Dataset
dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)
iter = dataset.make_initializable_iterator() # create the iterator
features = iter.get_next()

## Print the image
with tf.Session() as sess:
    # feed the placeholder with data
    sess.run(iter.initializer, feed_dict={x: horse_x,
                                         batch_size: BATCH_SIZE}) 
    print(sess.run(features).shape) 
    plot_image(sess.run(features), shape=[32, 32], cmap = "Greys_r")
(1, 1024)

Putkilinja palauttaa saman rider-funktion, joka piirrettiin suoraan NumPy-matriisista, mikä todistaa, että paikkamerkki, iteraattori ja erän koko on kytketty oikein.

Rakenna verkko

On aika rakentaa verkko. Harjoittelet pinottua autoenkooderia, eli verkkoa, jossa on useita piilotettuja kerroksia.

Verkossasi on yksi 1024 pisteen syöttötaso eli kuvan muoto 32×32.

Enkooderilohkossa on yksi ylin piilotettu kerros, jossa on 300 neuronia, ja keskikerros, jossa on 150 neuronia. Dekooderilohko on symmetrinen enkooderiin nähden. Voit visualisoida verkon alla olevassa kaaviossa. Huomaa, että voit muuttaa piilotetun ja keskikerroksen arvoja.

Autoenkooderin rakentaminen on hyvin samanlaista kuin mikä tahansa muu syväoppimismalli.

Rakennat mallin seuraavasti:

1. Määritä parametrit
2. Määritä kerrokset
3. Määrittele arkkitehtuuri
4. Määrittele optimointi
5. Suorita malli
6. Arvioi malli

Edellisessä osiossa opit luomaan mallin syöttävän putken, joten datajoukkoa ei tarvitse luoda uudelleen. Rakennat neljän kerroksen omaavan autoenkooderin. Käytät Xavier-alustusta. Tämä on tekniikka, jolla asetetaan alkupainot sekä syötteen että tulosteen varianssin mukaan. Lopuksi käytät ELU-aktivointifunktiota. Regularisoit häviöfunktion L2-regularisoijalla.

Vaihe 1) Määritä parametrit

Ensimmäinen vaihe tarkoittaa, että määritetään kunkin kerroksen neuronien lukumäärä, oppimisnopeus ja regularisaattorin hyperparametri.

Ennen sitä tuot osittaisfunktion. Se on parempi menetelmä tiheiden kerrosten parametrien määrittämiseen. Alla oleva koodi määrittelee autoenkooderin arkkitehtuurin arvot. Kuten aiemmin on mainittu, enkooderissa on kaksi kerrosta, joissa on 300 neuronia ensimmäisessä kerroksessa ja 150 toisessa kerroksessa. Niiden arvot tallennetaan n_hidden_1- ja n_hidden_2-kerroksiin.

Sinun on määriteltävä oppimisnopeus ja L2-hyperparametri. Arvot tallennetaan learning_rate- ja l2_reg-muuttujiin.

from functools import partial

## Encoder
n_hidden_1 = 300
n_hidden_2 = 150  # codings

## Decoder
n_hidden_3 = n_hidden_1
n_outputs = n_inputs

learning_rate = 0.01
l2_reg = 0.0001

Xavier-alustustekniikkaa kutsutaan estimaattorin contrib xavier_initializer-objektilla. Samaan estimaattoriin voit lisätä regularisoijan l2_regularizerin avulla.

## Define the Xavier initialization
xav_init =  tf.contrib.layers.xavier_initializer()
## Define the L2 regularizer
l2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)

Versiohuomautus: tf.contrib poistettiin TensorFlow 2:ssa. Suorat korvaajat ovat tf.keras.initializers.GlorotUniform() xavier_initializer():n tilalle ja tf.keras.regularizers.l2() l2_regularizer():n tilalle.

Vaihe 2) Määrittele kerrokset

Kaikki tiheiden kerrosten parametrit on asetettu; voit pakata kaiken dense_layer-muuttujaan käyttämällä partial-objektia. dense_layer käyttää sitten ELU-aktivointia, Xavier-alustusta ja L2-regularisointia jokaisella kutsulla.

## Create the dense layer
dense_layer = partial(tf.layers.dense,
                         activation=tf.nn.elu,
                         kernel_initializer=xav_init,
                         kernel_regularizer=l2_regularizer)

Vaihe 3) Määrittele arkkitehtuuri

Jos tarkastelet arkkitehtuurikaaviota, huomaat, että verkko pinoaa kolme kerrosta ja yhden tulostuskerroksen. Alla olevassa koodissa yhdistät asianmukaiset kerrokset. Esimerkiksi ensimmäinen kerros laskee pistetulon syötematriisin ominaisuuksien ja 300 painoarvoa sisältävän matriisin välillä. Kun pistetulo on laskettu, tuloste menee ELU-aktivointifunktiolle. Tulosteesta tulee seuraavan kerroksen syöte, siksi sitä käytetään hidden_2:n laskemiseen ja niin edelleen. Matriisin kertolasku on sama jokaiselle kerrokselle, koska käytät samaa aktivointifunktiota. Huomaa, että viimeinen kerros, joka tuottaa tulosteita, ei käytä aktivointifunktiota. Tämä on järkevää, koska tämä on rekonstruoitu syöte.

## Make the mat mul
hidden_1 = dense_layer(features, n_hidden_1)
hidden_2 = dense_layer(hidden_1, n_hidden_2)
hidden_3 = dense_layer(hidden_2, n_hidden_3)
outputs = dense_layer(hidden_3, n_outputs, activation=None)

Vaihe 4) Määrittele optimointi

Viimeinen vaihe on optimoijan rakentaminen. Käytät keskiarvovirhettä häviöfunktiona. Jos muistat lineaarisen regression tutoriaalin, tiedät, että MSE lasketaan ennustetun tulosteen ja todellisen otsikon välisen erotuksen avulla. Tässä otsikko on ominaisuus, koska malli yrittää rekonstruoida syötteen. Siksi haluat ennustetun tulosteen ja syötteen välisen neliöidyn erotuksen summan keskiarvon. TensorFlow'lla voit koodata häviöfunktion seuraavasti:

loss = tf.reduce_mean(tf.square(outputs - features))

Sitten sinun on optimoitava häviöfunktio. Käytät Adam-optimoijaa gradienttien laskemiseen. Tavoitefunktiona on minimoida häviö.

## Optimize
loss = tf.reduce_mean(tf.square(outputs - features))
optimizer = tf.train.AdamOptimizer(learning_rate)
train  = optimizer.minimize(loss)

Vielä yksi asetus ennen mallin harjoittelua. Haluat käyttää eräkokoa 150, eli syöttää liukuhihnaan 150 kuvaa jokaisessa iteraatiossa. Sinun on laskettava iteraatioiden määrä manuaalisesti. Tämä on triviaalia tehdä:

Jos haluat välittää 150 kuvaa kerrallaan ja tiedät, että tietojoukossa on 5000 kuvaa, iteraatioiden määrä on 5000 jaettuna 150:llä. Python voit ajaa seuraavat koodit ja varmistaa, että tuloste on 33:

BATCH_SIZE = 150
### Number of batches :  length dataset / batch size
n_batches = horse_x.shape[0] // BATCH_SIZE
print(n_batches)
33

Vaihe 5) Suorita malli

Viimeisenä muttei vähäisimpänä, kouluta malli. Koulutat mallia 100 epookilla. Toisin sanoen malli näkee kuvat 100 kertaa samalla, kun se optimoi painotuksia.

Tunnet jo TensorFlow'ssa mallin kouluttamiseen käytettävät koodit. Pieni ero on datan pipetointi ennen koulutuksen suorittamista. Tällä tavoin malli koulutetaan nopeammin.

Olet kiinnostunut tulostamaan häviön kymmenen aikakauden jälkeen nähdäksesi, onko malli oppimassa jotain (eli häviö vähenee). Harjoittelu kestää 2-5 minuuttia koneen laitteistosta riippuen.

## Set params
n_epochs = 100

## Call Saver to save the model and re-use it later during evaluation
saver = tf.train.Saver()

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    # initialise iterator with train data
    sess.run(iter.initializer, feed_dict={x: horse_x,
                                          batch_size: BATCH_SIZE})
    print('Training...')
    print(sess.run(features).shape) 
    for epoch in range(n_epochs):       
        for iteration in range(n_batches):
            sess.run(train)
        if epoch % 10 == 0:
            loss_train = loss.eval()   # not shown
            print("\r{}".format(epoch), "Train MSE:", loss_train) 
        #saver.save(sess, "./my_model_all_layers.ckpt") 
    save_path = saver.save(sess, "./model.ckpt")    
    print("Model saved in path: %s" % save_path)  
Training...
(150, 1024)
0 Train MSE: 2934.455
10 Train MSE: 1672.676
20 Train MSE: 1514.709
30 Train MSE: 1404.3118
40 Train MSE: 1425.058
50 Train MSE: 1479.0631
60 Train MSE: 1609.5259
70 Train MSE: 1482.3223
80 Train MSE: 1445.7035
90 Train MSE: 1453.8597
Model saved in path: ./model.ckpt

Vaihe 6) Arvioi malli

Nyt kun mallisi on koulutettu, on aika arvioida sitä. Sinun on tuotava testijoukko tiedostosta /cifar-10-batches-py/.

test_data = unpickle('./cifar-10-batches-py/test_batch')
test_x = grayscale(test_data['data'])
#test_labels = np.array(test_data['labels'])

Huomautus: Jotta Windows koneessa koodiksi tulee test_data = unpickle(r”E:\cifar-10-batches-py\test_batch”)

Voit yrittää tulostaa kuvan 13, joka on hevonen.

plot_image(test_x[13], shape=[32, 32], cmap = "Greys_r")

Kaavio vahvistaa, että testierä on ladattu oikein ja että kuva 13 kuuluu luokkaan, jolla malli on koulutettu.

Mallin arvioimiseksi käytät tämän kuvan pikseliarvoa ja katsot, pystyykö kooderi rekonstruoimaan saman kuvan kutistettuaan sen 1024 pikseliin. Huomaa, että määrittelet funktion mallin arvioimiseksi eri kuvilla. Mallin pitäisi toimia paremmin vain hevosilla.

Funktiolla on kaksi argumenttia:

• df: Tuo testidata
• image_number: ilmaisee tuotavan kuvan

Toiminto on jaettu kolmeen osaan:

1. Muotoile kuva uudelleen oikeaan mittaan, eli 1, 1024
2. Syötä malliin näkymätön kuva, koodaa/dekoodaa kuva
3. Tulosta todellinen ja rekonstruoitu kuva

def reconstruct_image(df, image_number = 1):
    ## Part 1: Reshape the image to the correct dimension i.e 1, 1024
    x_test = df[image_number]
    x_test_1 = x_test.reshape((1, 32*32))
    
    ## Part 2: Feed the model with the unseen image, encode/decode the image
    with tf.Session() as sess:     
        sess.run(tf.global_variables_initializer()) 
        sess.run(iter.initializer, feed_dict={x: x_test_1,
                                      batch_size: 1})
    ## Part 3:  Print the real and reconstructed image
      # Restore variables from disk.
        saver.restore(sess, "./model.ckpt")  
        print("Model restored.")
      # Reconstruct image
        outputs_val = outputs.eval()
        print(outputs_val.shape)
        fig = plt.figure()
      # Plot real
        ax1 = fig.add_subplot(121)
        plot_image(x_test_1, shape=[32, 32], cmap = "Greys_r")
      # Plot estimated
        ax2 = fig.add_subplot(122)
        plot_image(outputs_val, shape=[32, 32], cmap = "Greys_r")
        plt.tight_layout()
        fig = plt.gcf()

Nyt kun arviointifunktio on määritelty, voit tarkastella rekonstruoitua kuvaa numero kolmetoista.

reconstruct_image(df =test_x, image_number = 13)

INFO:tensorflow:Restoring parameters from ./model.ckpt
Model restored.
(1, 1024)

Kuvassa alkuperäinen testikuva on vasemmalla ja autoenkooderin lähtö oikealla, joten hienojen yksityiskohtien menetys 1024–150-pakkauksen jälkeen on helppo arvioida.

UKK