1_przydatne-pakiety.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Praktyczny Machine Learning w Pythonie\n",
    "<br>\n",
    "<img src=\"figures/python-comic-2.png\">\n",
    "\n",
    "## Przydatne pakiety\n",
    "\n",
    "Python to język wysokiego poziomu z ogromną ilością pakietów. \n",
    "\n",
    "Na tych warsztatach skupimy się na tym jak w praktyczny sposób wykorzystać pakiet scikit-learn do rozwiązywania problemów machine learningowych, które mogą się pojawić przy okazji inych projektów. Scikit-learn jest używany w takich firmach jak Microsoft, Evernote czy Spotify. Zawdzięcza to świetnemu API, dobrej wydajności i bardzo aktywnej społeczności.\n",
    "\n",
    "**Cel**: zapoznanie z pakietami scikit-learn, numpy, matplotlib z zastosowaniem do rozpoznawania cyfr. Konkurs pod koniec: jeszcze więcej rozpoznawania cyfr:)\n",
    "\n",
    "Uwaga: nie uczymy pythona, ale mam nadzieję, że składnia jest intuicyjna\n",
    "\n",
    "W tej części poznamy przydatne pakiety i narzędzia, które obecnie stanowią podstawę machine learningu w Pythonie:  IPython Notebook, numpy oraz matplolib.\n",
    "\n",
    "Pakietów jest duzo więcej: Scipy, Pandas, Sympy, PyTables, Cython, Blaze, NLTK i inne. Większość z nich jest dostępna w Anacondzie."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. IPython Notebook\n",
    "\n",
    "* \"Mathematicowy\" notebook - możliwość ewaluacji komórek, podpowiadanie składni (tab) i inne\n",
    "* Właśnie go używamy :)\n",
    "* Dużo magicznych rzeczy (wyświetlanie wykresów, równoległe obliczenia)\n",
    "* Bardzo wygodne do zdalnego odpalania kodu na swoim serwerze\n",
    "* ctrl + enter - odpal kod w komórce\n",
    "* ctrl + m + b - wstaw komórke poniżej (w command mode wystarczy b)\n",
    "* Inne przydatne skróty pod ctrl + m + h (lub w Help -> Keyboard Shortcuts).\n",
    "* Alternatywą jest collaboratory (nastawiony na jednoczesną pracę nad jednym notebooiem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Numpy\n",
    "* Wygodne operacje na macierzach, wektorach itp.\n",
    "* Podstawa praktycznie wszystkich pakietów machine learning\n",
    "* Pod spodem wydajny kod C, BLAS (można podpiąć np. szybszy OpenBLAS). \n",
    "\n",
    "Zamiast teorii spróbujmy zrobić pare rzeczy w numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = np.array([1, 2, 3, 4])\n",
    "print \"a: \", a\n",
    "print \"Pierwszy element: \", a[0]\n",
    "print \"Drugi element!: \", a[1]\n",
    "print \"a+1:\", a + 1\n",
    "print \"2*a:\", 2*a\n",
    "b = np.array([1, 2, 3, 4])\n",
    "print \"b: \", b\n",
    "print \"Iloczyn skalarny <a,b>: \", np.inner(a,b) # Iloczyn skalarny"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Uwaga! Mnożenie macierzy to nie jest *, ale np.dot() !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = np.eye(3) # Macierz identyczności (jedynki na diagonali) 3x3\n",
    "b = np.random.uniform(size=(3,3)) # Losowa macierz 3x3\n",
    "print \"a = \", a\n",
    "print\n",
    "print \"b = \", b\n",
    "print\n",
    "print \"a*b =\", a*b # Mnozenie kazdy element razy kazdy\n",
    "print\n",
    "print \"np.dot(a,b) = \", np.dot(a,b) # Mnozenie macierzowe "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Możemy wziąć część wektora i wykonać na nim jakąś operację\n",
    "a = np.array([1,2,3,4,5])\n",
    "print \"Suma elementow od 1 do 3 włącznie: \", a[1:4].sum()\n",
    "# Jest bardzo dużo różnych operacji. Można zobaczyć przez wpisanie \"a.\" i tab (autocompletion)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Oczywiście obiekty numpy są iterowalne\n",
    "for x in a:\n",
    "    print x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ćwiczenie 1: \n",
    "    a) znajdź największą i najmniejszą wartość w wektorze c. \n",
    "    b) stworzyć analogicznie wektor d i policzyć iloczyn skalarny. Ile wynosi jak zwiększymy ilość wymiarów?\n",
    "   Podpowiedź: można użyć pętli for lub operacji na c (poszukać tabem po wpisaniu \"c.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "c = np.random.uniform(size=(5,)) # wektor 5 pseudolosowych liczb\n",
    "d = np.random.uniform(size=(5,)) # wektor 5 pseudolosowych liczb\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.95986143184996031"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(c, d.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Matplotlib\n",
    "\n",
    "Podstawowy pakiet do rysowania. Istnieje dużo nakładek na matplotlib, najciekawsza to prawdopodobnie seaborn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import matplotlib.pylab as plt # Import podpakietu jako plt\n",
    "# Magia IPython Notebook :) Pokazuje wykresy w konsoli\n",
    "%matplotlib inline "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = np.linspace(0,1,20) # Tworzy wektor z 20 wartosciami w równych odstępach od 0 do 1\n",
    "print x\n",
    "_ = plt.plot(x, 'o-') # matplotlib naśladuje składnie matlaba"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.plot(x, x, 'o-', label='liniowa')\n",
    "plt.plot(x, x ** 2, 'x-', label='kwadratowa') # Operacja na wektorze numpy ! x ** 2 podnosi każdy element do kwadratu\n",
    "\n",
    "plt.legend(loc='best')\n",
    "_ = plt.title('Funkcja liniowa vs funkcja kwadratowa')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Są inne wykresy, np histogram\n",
    "samples = np.random.normal(loc=1.0, scale=0.5, size=1000) # 1000 liczb z rozkładu normalnego\n",
    "print \"Pierwsze 10 z wylosowanej próby: \", samples[0:10] # 10 pierwszych\n",
    "print \"Rozmiar próby: \", samples.shape # rozmiar\n",
    "_ = plt.hist(samples, bins=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Inny przykład bez tłumaczenia :)\n",
    "samples_1 = np.random.normal(loc=1, scale=.5, size=10000) # Rozklad Gaussa\n",
    "samples_2 = np.random.standard_t(df=10, size=10000) # Rozklad studenta t (taki jakby Gauss :))\n",
    "bins = np.linspace(-3, 3, 50)\n",
    "_ = plt.hist(samples_1, bins=bins, alpha=0.5, label='samples 1')\n",
    "_ = plt.hist(samples_2, bins=bins, alpha=0.5, label='samples 2')\n",
    "_ = plt.legend(loc='upper left')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "N = 1000\n",
    "X = np.random.uniform(0, 1, N) # 1000 uniformly distributed numbers\n",
    "# print X\n",
    "X = X.reshape(N/2, 2) # Make it into matrix\n",
    "# Tip: instead of passing N/2 you can pass -1 and it is smart enough to figure it out\n",
    "# print X\n",
    "plt.scatter(X[:, 0], X[:, 1]) # Scatter is like plot, but for drawing cloud of points"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}