tieteen-paivat-2017.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Data-analyysityöpaja Tieteen päivillä\n",
    "\n",
    "Mitä data-analyysi on? Data-analyysi tarkoitaa sitä, että datan pohjalta päätellään jotain uutta. Esimerkiksi mittausdatan perusteella voidaan todeta, että uusi lääkeaine näyttää laskevan verenpainetta.\n",
    "\n",
    "No mitä se data on? Nykypäivänä data voi olla mitä tahansa, mikä on saatavissa digitaalisessa muodossa. Perinteisesti data on ollut tieteellisiä havaintoja, joita on tunnollisesti kirjattu ylös, vaikkapa jonkinlaiseksi taulukoksi. Näin on edellisen verenpaine-esimerkin tapauksessa. Nykyään kuitenkin tehdään jo paljon analyysiä esimerkiksi reaaliaikaisesta videokuvasta. Hyvä esimerkki tästä on vaikkapa robottilennokki, joka lentää pitkin voimalinjoja ja videokameran kuvan avulla analysoi, että milloin lumikuorma on vaarallisen suuri.\n",
    "\n",
    "Mihin data-analyysia tarvitaan? Jos visionäärejä on uskominen, niin kohta ihan kaikkeen. Tieteessä datan analysointi on ollut keskeistä viimeistään 1900-luvun alusta alkaen. Tämä perinteinen tieteen ja asiantuntijatyön analytiikka on kuitenkin nyt saamassa rinnalleen uuden käyttäjäkunnan, kun arkisemmat data-analyysitarpeet ovat suoraan sanoen räjähtäneet. Facebookin ja Googlen kaltaiset internetajan yritykset vetävät uuden data-analytiikan nopeaa kehitystä. Yritysmaailmassa niin kutsuttu Big Data on tällä hetkellä hyvin kuuma aihe.\n",
    "\n",
    "Joka tapauksessa on selvää, että tulevaisuudessa data-analyysiä tehdään paljon enemmän ja paljon laajemmin. Eli ei pelkästään tutkimuslaitoksissa, vaan myös tavallisissa yrityksissä, virastoissa ja järjestöissä. Jos opettelee ainakin perusasiat, niin saa melkoisen hyödyn tulevaisuutta ajatellen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Alku\n",
    "\n",
    "Ensiksi alustamme koneoppimisen työkalumme ja lataamme datan, jota työpajassa käsitellään. Alla oleva koodinpätkä tekee nämä kaksi asiaa.\n",
    "\n",
    "Koodi ajetaan klikkaamalla harmaaseen laatikkoon, jolloin se tulee valituksi. Valitse ylävalikosta Cell -> Run ja koodi käynnistyy. Sen merkkinä ilmestyy In-riville tähti. Kun homma on valmis, niin alle ilmestyvät tulokset. Tässä tapauksessa pitäisi tulla tieto ladatun datan koosta sekä esimerkiksi muutamia merkkejä, joita data sisältää.\n",
    "\n",
    "Jatkossa koodin voi ajaa myös näppärämmin painamalla Ctrl ja Enter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Alustetaan koneoppimisen ympäristö (ohjelmakirjastot)\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "%matplotlib inline\n",
    "from time import time\n",
    "import numpy as np\n",
    "from sklearn import random_projection, decomposition, manifold\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from keras.datasets import mnist\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.metrics import accuracy_score\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Activation, Dropout\n",
    "from keras.utils import np_utils\n",
    "\n",
    "# Aluksi tehdään aputyökalu kuvien piirtämistä varten\n",
    "def plot_embedding(X, title=None, t0=None):\n",
    "    x_min, x_max = np.min(X, 0), np.max(X, 0)\n",
    "    X = (X - x_min) / (x_max - x_min)\n",
    "\n",
    "    plt.figure(figsize=(9,6))\n",
    "    plt.axis('off')\n",
    "    for i in range(X.shape[0]):\n",
    "        plt.text(X[i, 0], X[i, 1], str(y[i]),\n",
    "                 color=plt.cm.Set1(y[i] / 10.),\n",
    "                 fontdict={'weight': 'bold', 'size': 9})\n",
    "\n",
    "    if title is not None:\n",
    "        if t0 is not None:\n",
    "            plt.title(\"%s (%.2fs)\" % (title, (time()-t0)))\n",
    "        else:\n",
    "            plt.title(title)\n",
    "\n",
    "# Ladataan data (MNIST-tietokanta)\n",
    "(X_train, y_train), (X_test, y_test) = mnist.load_data()\n",
    "X = X_train[:1024]\n",
    "y = y_train[:1024]\n",
    "\n",
    "# Raportoidaan työ tehdyksi\n",
    "print('\\nData ladattu onnistuneesti (MNIST).')\n",
    "print('Datan palasten koko: train:',len(X_train),'test:',len(X_test))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seuraavaksi katsotaan, että mistä datassa on kyse. Datamme on tietokanta ihmisten käsin kirjoittamista numeromerkeistä, eli sen pohjalta voi vaikkapa tutkia ihmisten tapoja piirtää numeroja tai rakentaa tekoälyn, joka ymmärtää käsin kirjoitettua tekstiä.\n",
    "\n",
    "Datassa on liian paljon piirrettyjä merkkejä läpikäytäväksi, joten visualisoidaan niistä vain alkupäästä 1024 ensimmäistä."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "n_img_per_row = 32 # 32*32=1024\n",
    "img = np.zeros((28 * n_img_per_row, 28 * n_img_per_row))\n",
    "for i in range(n_img_per_row):\n",
    "    ix = 28 * i\n",
    "    for j in range(n_img_per_row):    \n",
    "        iy = 28 * j\n",
    "        img[ix:ix + 28, iy:iy + 28] = X[i * n_img_per_row + j,:,:]\n",
    "\n",
    "plt.figure(figsize=(9, 9))\n",
    "plt.imshow(img)\n",
    "plt.title('MNIST-data (1024 ensimmäistä merkkiä)')\n",
    "ax=plt.axis('off')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oppimisen kannalta pelkät merkit eivät vielä kerro paljon, vaan tarvitsemme myös tiedon siitä, että mitä oikeaa merkkiä mikäkin käsin piirretty merkki vastaa. Onneksi myös tämä tieto löytyy datasta valmiiksi. Alla oleva koodi piirtää 10 ensimmäistä merkkiä ja niiden luokittelun."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Piirretään alkupään merkkejä\n",
    "pltsize=1\n",
    "plt.figure(figsize=(10*pltsize, pltsize))\n",
    "for i in range(10):\n",
    "    plt.subplot(1,10,i+1)\n",
    "    plt.axis('off')\n",
    "    plt.imshow(X_train[i,:,:])\n",
    "    plt.title(str(y_train[i]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oikeassa maailmassa tulee usein vastaan tilanteita, joissa meillä on kiinnostavaa dataa, mutta ei valmiiksi tietoa sen sisällöstä. Nyt tietokannan rakentaja on valmiiksi luokitellut ja tarkastanut merkit, mutta mitä jos näin ei olisi? Suuren tietokannan läpikäynti käsin on valtava urakka.\n",
    "\n",
    "* Jos suuri määrä käsin kirjoitettuja merkkejä pitää tunnistaa ihmistyönä, niin miten tällaisen projektin voisi hoitaa?\n",
    "* Miten koneella voitaisiin helpottaa työmäärää?\n",
    "* Onko käsin kirjoitettujen merkkien kuvadatalla mitään arvoa, jos niitä vastaavaa luokittelua ei ole tiedossa?\n",
    "* Mitä käytännön sovelluksia voit keksiä pelkkien kuvien käytölle?\n",
    "\n",
    "Pohdi näitä kysymyksiä hetki. Ne ovat perustavanlaatuisia haasteita data-analytiikan projekteissa ja myös hyvää pohjustusta seuraaville vaiheille."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ensimmäinen analyysi\n",
    "\n",
    "Seuraavaksi pääsemme käyttämään varsinaista data-analytiikan menetelmää. Katsomme aluksi pelkästään kuvadataa ja emme käytä luokittelutietoa hyväksi. Mitä pelkillä kuvilla voi tehdä? Niitä voi esimerkiksi vertailla keskenään. Jokainen kuva on 28x28 kasa pikseleitä. Jos on esimerkiksi kaksi numeroa 0 esittävää kuvaa, niin niissä on todennäköisesti tummat pikselit varsin samoissa paikoissa molemmissa. Valitettavasti ihmisen on mahdotonta päässään tuollaista vertailua käsitellä, koska 28x28 = 784 eli vertailtavia numeroita on liikaa muistettavaksi tai hahmotettavaksi.\n",
    "\n",
    "Data-analyysin menetelmien avulla on kuitenkin mahdollista hakea toistuvia piirteitä mm. niinkutsutun pääkomponenttianalyysin avulla. Menetelmästä käytetään yleensä sen englanninkielistä nimeä Primary Component Analysis ([PCA](http://scikit-learn.org/stable/modules/decomposition.html#pca)). Pääkomponenttianalyysin idea on, että jokainen kuva esitetään pääkomponenttien summana. Esimerkiksi jos pääkomponentit ovat risti ja ympyrä, niin silloin voidaan sujuvasti esittää ristejä, palloja, ristejä ympyrän sisällä ja toki myös tyhjiä kuvia. Pääkomponenttien määrän voi päättää itse ja usein niitä halutaan kaksi, jotta data voidaan piirtää kahdessa ulottuvuudessa eli vaaka- ja pystyakselille (X ja Y).\n",
    "\n",
    "Tehdään siis pääkomponenttianalyysi merkkidatalle. Luettavuuden vuoksi merkit piirretään sen luokan numerona, johon ne kuuluvat.\n",
    "\n",
    "* Ovatko samat numerot järjestäytyneet ryhmiksi?\n",
    "* Näetkö kuvassa muuta rakennetta tai logiikkaa?\n",
    "* Aiemmin mietimme, että miten käsin kirjoitettujen merkkien tunnistamista voisi helpottaa automaation avulla. Voisiko tätä menetelmää hyödyntää?\n",
    "\n",
    "Saat tehtyä analyysin ja piirrettyä tuloksen alla olevalla koodilla. Käy tuloskuvaa ajatuksella läpi ja koita vastata kysymyksiin.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Tehdään PCA-analyysi    \n",
    "pca = decomposition.PCA(n_components=2)\n",
    "X_pca = pca.fit_transform(X.reshape(-1,28*28))\n",
    "\n",
    "# Ja piirretään analyysin tulos\n",
    "plot_embedding(X_pca, \"PCA-kuvaus\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Huomasit varmasti, että samat numerot sijoitettiin lähelle toisiaan. Näin kuuluu mennäkin, koska niissä on hyvin samanlaiset pikselit. Mutta myös toisiaan muistuttavat numerot, kuten 0 ja 8, tulivat lähelle.\n",
    "\n",
    "Pääset itse kokeilemaan koneoppimisen toimintaa lähemmin tässä webbisivustossa: https://transcranial.github.io/keras-js/#/mnist-cnn\n",
    "    \n",
    "Sivustolla on koneoppimisohjelma, joka tunnistaa numeroita. Se on rakennettu saman datan päälle, vaikkakin hyvin kehittyneitä menetelmiä käyttäen. Kuinka hyvin sivuston ohjelma erottaa toisistaan esimerkiksi 0:n ja 8:n?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vähän tilastollista ajattelua\n",
    "\n",
    "Data-analyysissa on aina pidettävä mielessä kriittinen lähestyminen ja tulosten merkitsevyyden pohtiminen. Yllä olevassa numeropilvessä on selvästi nähtävissä järjestystä, mutta toisaalta ihminen on taipuvainen näkemään järjestystä sielläkin, missä sitä ei ole - kuten vaikkapa lottoarvonnan tuloksissa.\n",
    "\n",
    "Tilastollisen merkitsevyyden testaaminen voi pitkälle vietynä olla monimutkaistakin. Mutta emme lähde tässä laskemaan p-arvoja tai tekemään muuta tilastotiedettä, koska yksinkertainenkin ratkaisu on jo hyvä. Jos tarvitsee varmistua siitä, että näkemämme järjestys ei ole pelkästään mielikuvituksen tuottamaa ja oikeasti alla on pelkästään satunnaista sotkua, niin voimme katsoa vastaavaa visualisointia, mutta rakentaa sen puhtaasti satunnaisen datan päälle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Tehdään satunnainen kuvaus\n",
    "rp = random_projection.SparseRandomProjection(n_components=2, random_state=42)\n",
    "X_projected = rp.fit_transform(X.reshape(-1,28*28))\n",
    "\n",
    "# Piirretään kuvaus\n",
    "plot_embedding(X_projected, \"Satunnainen kuvaus\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voidaanko sanoa, että tämä satunnainen sotku on selvästi eri tulos kuin aiemmin tekemämme pääkomponenttianalyysin tuottama?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Merkkien tunnistaminen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seuraavaksi pääsemme itse asiaan. Olemme nyt pöyhineet dataa ja päässeet varmuuteen, että se on järkevää ja analysoitavissa.\n",
    "\n",
    "Rakennamme koneoppimismenetelmiä käyttäen nk. luokittelijan, joka kykenee oppimaan kuvien piirteet ja tunnistamaan niitä sen jälkeen. Nyt on syytä jälleen olla tarkkana: jos syötämme menetelmälle dataa, niin se varmasti osaa oppia ulkoa kyseisen datan kaikki yksityiskohdat. Mutta haluamme, että menetelmä \"näkee metsän puilta\", eli oppii tunnistamaan merkkien yleisiä hahmoja. Teemme siis koneoppimisen perustempun, eli jaamme datan kahteen osaan. Harjoitusdatalla opetetaan menetelmä, kun taas sen toimintaa testataan testidatalla. Koneoppijan tulee siis selvitä sellaisistakin kuvista, joita se ei ole aikaisemmin nähnyt. Tällä tavalla varmistetaan, että ei pelkästään opita ulkoa harjoitusdataa.\n",
    "\n",
    "Alla oleva koodi tekee luokittelun ja tulostaa esimerkiksi 10 ensimmäistä luokiteltua merkkiä. Luokitteluun käytetään klassista koneoppimisen menetelmää, nk. päätöspuuta. Kuinka hyvin menetelmä pärjää?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Tehdään luokittelija\n",
    "clf_dt = DecisionTreeClassifier()\n",
    "clf_dt.fit(X_train.reshape(-1,28*28), y_train)\n",
    "pred_dt = clf_dt.predict(X_test.reshape(-1,28*28))\n",
    "\n",
    "# Piirretään tulokseksi alkupäästä luokituksia\n",
    "pltsize=1\n",
    "plt.figure(figsize=(10*pltsize, pltsize))\n",
    "for i in range(10):\n",
    "    plt.subplot(1,10,i+1)\n",
    "    plt.axis('off')\n",
    "    plt.imshow(X_test[i,:,:])\n",
    "    plt.title(str(pred_dt[i]) + ' (' + str(y_test[i]) + ')')\n",
    "\n",
    "# Raportoidaan tulokset\n",
    "print('Luokiteltu', len(pred_dt), 'kuvaa, luokituksista oikein menneiden osuus on:', accuracy_score(y_test, pred_dt)*100, '%')\n",
    "print('Alla kuvat ja analysoidut luokat, oikeat luokat ovat suluissa')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kyseinen koneoppimismenetelmä tuntuu toimivan ihan kohtuullisesti, vaikka ei pärjääkään ihmiselle tässä tehtävässä."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Koneoppija joutuu koville\n",
    "\n",
    "Selvästikin päätöspuu osaa luokitella kuvia kohtuudella. Oikeassa elämässä esimerkiksi kuvadata ei ole aina priimalaatua. Mitä jos teemme tehtävästä asteen vaikeamman lisäämällä kuvaan häiriötä (kohinaa)? Lopputulos vastaa suunnilleen sitä, miltä näyttäisi vaikkapa huonolla kameralla vähässä valossa otettu kuva käsinkirjoitetusta tekstistä."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Lisätään kuviin häiriötä\n",
    "noiselevel = 0.5 # TEHTÄVÄ: muuta tätä arvoa välillä 0.0 - 1.0 ja katso miten tulokset vaihtuvat\n",
    "X_test_noisy = np.zeros((len(X_test), 28, 28))\n",
    "for i in range(len(X_test)):\n",
    "    X_test_noisy[i,:,:] = (1-noiselevel)*X_test[i,:,:] + noiselevel*np.random.rand(28,28)*255\n",
    "clf_dt_noisy = DecisionTreeClassifier()\n",
    "clf_dt_noisy.fit(X_train.reshape(-1,28*28), y_train)\n",
    "pred_dt_noisy = clf_dt_noisy.predict(X_test_noisy.reshape(-1,28*28))\n",
    "\n",
    "# Piirretään tulokseksi alkupäästä luokituksia\n",
    "pltsize=1\n",
    "plt.figure(figsize=(10*pltsize, pltsize))\n",
    "for i in range(10):\n",
    "    plt.subplot(1,10,i+1)\n",
    "    plt.axis('off')\n",
    "    plt.imshow(X_test_noisy[i,:,:])\n",
    "    plt.title(str(pred_dt_noisy[i]) + ' (' + str(y_test[i]) + ')')\n",
    "\n",
    "# Raportoidaan tulokset\n",
    "print('Luokiteltu', len(pred_dt_noisy), 'kuvaa, luokituksista oikein menneiden osuus on:', accuracy_score(y_test, pred_dt_noisy)*100, '%')\n",
    "print('Alla kuvat ja analysoidut luokat, oikeat luokat ovat suluissa')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Kun sekoitetaan 50-50 alkuperäistä kuvaa ja kohinaa, niin koneoppija ei enää pärjää. Ihminen kyllä yhä kykenee numerot tunnistamaan. Missä menee koneoppijan kyky sietää kohinaa, paranisiko tilanne jos kohinan määrä tiputetaan kymmeneen prosenttiin, eli noiselevel=0.1? Palaa koodin ja kokeile erilaisia kohinan osuuksia sekä niiden vaikutusta."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ja lopuksi neuroverkkoja\n",
    "\n",
    "Koneoppimisesta ei voi nykyään puhua mainitsemassa neuroverkkoja. Ne ovat tällä hetkellä pinnalla oleva, vaikkakin pitkän historian omaava, koneoppimisen suuntaus, jossa käytetyt menetelmät ovat saaneet inspiraationsa ihmisen hermojärjestelmästä. Dataa syötetään sisään keinotekoiseen digitaaliseen neuroverkkoon ja verkon yhteyksiä säädetään niin, että se oppii tuottamaan datasta haluttuja signaaleja ulos.\n",
    "\n",
    "Toistamme äskeisen harjoituksen neuroverkkojen avulla. Ne ovat laskennallisesti raskaita, joten tällaisen kevyenkin mallin tekeminen vaatii aikansa.\n",
    "\n",
    "Voit myös vaihtoehtoisesti mennä kokeilemaan neuroverkkoja interaktiiviselle webbisivustolle: http://playground.tensorflow.org/\n",
    "\n",
    "Siellä voi säätää verkon asetuksia ja muotoa, sekä katsoa, että miten verkon kyky oppia dataa (joukko sinisiä ja oransseja palloja) muuttuu. Alaspäin skrollaamalla löytyy sivulta lisätietoa verkon käytöstä ja toiminnasta.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Alustetaan neuroverkko (malli)\n",
    "model = Sequential()\n",
    "\n",
    "# Luodaan neuroverkkoon sisäänmenokerros\n",
    "model.add(Dense(20, input_dim=28*28))\n",
    "model.add(Activation('relu'))\n",
    "\n",
    "# Luodaan neuroverkkoon uusi kerros (piilokerros)\n",
    "# TEHTÄVÄ: voit poistaa kommenttimerkit kolmen seuraavan rivin edestä ja myös säätää parametreja\n",
    "#model.add(Dense(50, input_dim=28*28))\n",
    "#model.add(Activation('relu'))\n",
    "#model.add(Dropout(0.2))\n",
    "\n",
    "# Luodaan neuroverkkoon uusi kerros (toinen piilokerros)\n",
    "# TEHTÄVÄ: voit poistaa kommenttimerkit kolmen seuraavan rivin edestä ja myös säätää parametreja\n",
    "#model.add(Dense(50))\n",
    "#model.add(Activation('relu'))\n",
    "#model.add(Dropout(0.2))\n",
    "\n",
    "# Luodaan neuroverkkoon tuloskerros\n",
    "model.add(Dense(10, activation='softmax'))\n",
    "model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
    "\n",
    "# Muotoillaan data neuroverkon ymmärtämään muotoon (nk. one-hot encoding)\n",
    "nb_classes = 10\n",
    "Y_train = np_utils.to_categorical(y_train, nb_classes)\n",
    "Y_test = np_utils.to_categorical(y_test, nb_classes)\n",
    "\n",
    "# Ajetaan neuroverkon opetus\n",
    "nb_epoch = 4 \n",
    "print('Neuroverkon opetus käynnissä, odota...\\n')\n",
    "history = model.fit(X_train.reshape((-1,28*28)), Y_train, nb_epoch=nb_epoch, batch_size=32, verbose=2)\n",
    "scores = model.evaluate(X_test.reshape((-1,28*28)), Y_test, verbose=0)\n",
    "print('\\nOpetus valmis!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nyt on neuroverkko luotu. Seuraavaksi käytetään sitä dataan ja katsotaan kuinka se pärjää?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Luokitellaan dataa neuroverkolla\n",
    "predictions = model.predict(X_test.reshape((-1,28*28)))\n",
    "rounded = np.argmax(predictions, axis=1)\n",
    "\n",
    "# Piirretään tulokseksi alkupäästä luokituksia\n",
    "pltsize=1\n",
    "plt.figure(figsize=(10*pltsize, pltsize))\n",
    "for i in range(10):\n",
    "    plt.subplot(1,10,i+1)\n",
    "    plt.axis('off')\n",
    "    plt.imshow(X_test[i,:,:])\n",
    "    plt.title(str(rounded[i]) + ' (' + str(y_test[i]) + ')')\n",
    "\n",
    "# Raportoidaan tulokset\n",
    "print('Luokiteltu', len(rounded), 'kuvaa, luokituksista oikein menneiden osuus on:', accuracy_score(y_test, rounded)*100, '%')\n",
    "print('Alla kuvat ja analysoidut luokat, oikeat luokat ovat suluissa')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Saatko parannettua verkon toimintaa lisäämällä kerroksia? Se onnistuu kohdista, jotka on merkitty TEHTÄVÄ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}