Softmax_Regression.ipynb

softmax_regression.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python [conda env:anaconda]",
      "language": "python",
      "name": "conda-env-anaconda-py"
    },
    "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.14"
    },
    "colab": {
      "name": "Softmax_Regression.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/gist/kiwamizamurai/cf2d7c47d42a3cb025866cdfdfbe8e79/softmax_regression.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eKUoo_JYKxG4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p_Y9Ujn_KxG_",
        "colab_type": "code",
        "colab": {},
        "outputId": "6b5e505c-b202-4ce3-83bf-dbfcc075219c"
      },
      "source": [
        "from sklearn.datasets import load_digits\n",
        "digits = load_digits()\n",
        "\n",
        "print(digits.data.shape)\n",
        "print(digits.target)\n",
        "print(digits.images.shape)\n",
        "\n",
        "\n",
        "for i in range(24):\n",
        "    plt.subplot(4,6,i+1)\n",
        "    plt.subplots_adjust(wspace=0.4, hspace=0.6)\n",
        "    plt.imshow(digits.images[i])\n",
        "    plt.title(\"{}\".format(digits.target[i]))\n",
        "    plt.axis(\"off\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(1797, 64)\n",
            "[0 1 2 ... 8 9 8]\n",
            "(1797, 8, 8)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWkAAAEICAYAAACd0wWxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAIABJREFUeJzt3XuUVNWVP/DvphsCTfOwRVAhzcOmEdoHGmKEBBGZHpAkA2gSERQX0cBA9BcIOomKE3xiVmLQUWglQocI8cEMj8Tgg6WGEV9IQqK2YIsiKI9GELF5Y7N/f1Sxhnv3NV00de85lN/PWr307HWqa19u1a7b99Q5R1QVRETkp0auEyAioi/GIk1E5DEWaSIij7FIExF5jEWaiMhjLNJERB5jkSYi8piXRVpEikRkoYjsFpH1IjLCdU5xEJFrRWSliOwXkd+5zidOIvIVEZmVPp+1IrJKRC52nVccRGSuiGwWkc9EpFpErnGdU5xEpKuI7BORua5ziYuI/CV9jLvSP+8k9dxeFmkA0wEcANAOwEgAFSJS5jalWGwCcAeA2a4TSUA+gA8B9APQCsAtAJ4QkU4Oc4rLVACdVLUlgH8DcIeIfM1xTnGaDuB110kk4FpVLUz/dEvqSb0r0iLSHMClAG5R1V2quhzAHwFc6Taz7FPVBaq6CMB217nETVV3q+oUVf1AVQ+p6pMA1gHIueKlqlWquv9wM/1zmsOUYiMiwwF8CuA517nkKu+KNIBSAHWqWn1E7B8AcvFK+ktLRNohda6rXOcSBxGZISJ7AKwBsBnAEscpZZ2ItARwG4BJrnNJyFQR2SYiL4nIhUk9qY9FuhDAzlBsJ4AWDnKhGIhIYwDzAMxR1TWu84mDqo5H6jXbF8ACAPv/+SOOS7cDmKWqH7pOJAE/A9AFQHsAMwH8SUQS+evIxyK9C0DLUKwlgFoHuVCWiUgjAI8gNeZwreN0YqWqdenbdR0AjHOdTzaJSE8A/wJgmutckqCqr6lqraruV9U5AF4CMDiJ585P4kmOUjWAfBHpqqrvpmNnI0f/LP4yEREBMAupAeHBqnrQcUpJyUfu3ZO+EEAnABtSpxWFAPJEpIeqnuswr6QoAEniiby7klbV3Uj9eXibiDQXkW8CGILU1VdOEZF8EWkKIA+pF3hTEfHxgzNbKgB0B/BdVd3rOpk4iEhbERkuIoUikiciAwFcDuB517ll2UykPnh6pn8eBPBnAANdJhUHEWktIgMPvz9FZCSACwA8k8Tze1ek08YDaAZgK4BHAYxT1Vy8kp4MYC+AnwO4Iv3/k51mFBMR6QhgLFJv6C1HfN90pOPUsk2RurXxEYAdAH4NYIKqLnaaVZap6h5V3XL4B6nblPtU9WPXucWgMVJflf0YwDYA1wEYqqqJfFdauOg/EZG/fL2SJiIisEgTEXmNRZqIyGMs0kREHovl617ljb5f72jktjG9TeyGSY+Z2C1/HWJipT/dHGh/vqUmo7yWHpqf1e81ZnKcUU591U6e7Fqw1cQWTrso0C6qfCWj35/t4wQafqx7hn3DxGbd+xsTm7p5UKC96fzM5i65OKfrptrXbvVVFSb2WO0JJvZIv/MCbVevXaDh5zSvXVsT2zu3mYk1KV/fkF/v7Fij3pcrNhabWIdLs/dFs0yOlVfSREQeY5EmIvIYizQRkcdYpImIPOZsnYioQcLhLXaY2L2td5nYn/8WnDL/tSl2gbE2MzMbZHPhg9oiE6ssftHEftu3b6BdVBlbSllxqN85Jvbi9IdMrDpiWaUhJ64KtCtQkrW8jlV1RXCwb+pF9rV7xn3jTeytn8wwsfv7dgq0C+dnNnDok3Xj7Lk58NYhEytBwwYOXQm/BoHo9yU22dCi3YWBdkXX7L1+eSVNROQxFmkiIo+xSBMReSyxe9KfXxTcb3R4i7+bPhcPGm5ird6wuyv9YPmAQPuTc+pMnzZHm2BMou7TPlT6QETP5ibS8s0mMWQUn/eHfsXE7tpmN1We9Vx/E3vvsgcDbTs1xJ3TKz4LtB+59TzTZ/KyR00sajJL4fzXspdYAqImrlx5id1z9vHKASaWV1b/htp1VYms9pmRt/e2N7GhzW1+1Qd3m9jNbwRX3O3Yzq7YWldjJ6xlglfSREQeY5EmIvIYizQRkcdYpImIPJbYwOG+E4NPNXnrmabPoYhBwiivv+nvxssbpvQJtBeP/pXpU9rYDhJGaf/s9kDbDo/6pdvd75vY4xvsgNJTE+y/Sf+qEYF2E48mQpjX5Vmnmz5RE7F+8L499vyTg++DTFfBcyVq4sq9rRaa2LJpdhW81bN7BdqNdtpyUzLxGJLLsqU19rze1MYOHEa9fw+92SrQrqvJ3kp5vJImIvIYizQRkcdYpImIPMYiTUTkseQGDk8Ifh7Me8VuQVSKFRn9rvxWBwLtz3f6MzOveMrLgfaEimGmz5JVz2b0uw62KQi0fftEDc9Ge+fnXUyfqwfY2WlRml2xN9D2eZA0aoD72+cONLFzno5YLu3pYHPVoFNNF5eDiZ+MDr4vV4+xK/mVvTLGxDrADpStG/RwoH32r+xKgT6J2u6r77CxJrbt7DwTC/87dYc91nBtyJRv73siIjoCizQRkcdYpImIPMYiTUTkscQGDpvuCG6v8/Uz3zN9dkY8Lv/kdiZ2WY+/BtpPPPWtY8rNV1vPDc7iOnmZo0S+wOqpxYH2ukEPfkHPoK/ffL2JFdX4u91ZJqIG+6IGBbfPbhFo1/zCbqVWOs7dwGHTT4Pv06hlOat6zzOxu96of1nS9n9Ya2I+DxADQMFCu7RsG3yj3sftKz5Qb59M8UqaiMhjLNJERB5jkSYi8lhi96RbvhO84/yLDk+aPqPG/NTEGg+129CEdb7x+L6febwqmRO8o3hXL3tfMmoVsdfvtJtj9R8xJNDe9Qd7P7eo0o/zXF1ht8869XkxsfAELgD4fY/fBNpDPx2XvcSyIHwP9rqF3zR9oraEm/57uyVceNJLhyyuDBeH8EQewN6jB4CSn71d7+/q8Cc74aWheCVNROQxFmkiIo+xSBMReYxFmojIY4kNHIZXDrusYpLpM3nSoyZ273t2C6LXe2bvpnzc6mq2mlj/qiEm9kLZYhP7/Fuh6T3TspZWVjRatirQXnaW3ULphX6jTezzyZ/YfqHj79z3GtOnqPJoM4xH40/t6++6Ox7L6LFDXw4OFHYZ8fes5JSkxtv2mFjUllJFcwuTSCdrtvU9aGLhlfy+SNkrIwPtDhGTYBqKV9JERB5jkSYi8hiLNBGRx1ikiYg8JqrqOgciIvoCvJImIvIYizQRkcdYpImIPMYiTUTkMRZpIiKPsUgTEXmMRZqIyGPeFmkRGS4iq0Vkt4i8JyJ9XeeUbSKyK/RTJyL3u84rDiLSSUSWiMgOEdkiIg+ISGILfCVJRLqLyPMislNE1orIMNc5xUVEikRkYfp9ul5ERrjOKQ4icq2IrBSR/SLyuySf28siLSLlAH4JYDSAFgAuAPC+06RioKqFh38AtAOwF8B8x2nFZQaArQBOAdATQD8A451mFIP0B89iAE8CKAIwBsBcESl1mlh8pgM4gNTrdySAChEpc5tSLDYBuAPA7KSf2MsiDeBWALep6quqekhVN6rqRtdJxex7SBWxF10nEpPOAJ5Q1X2qugXA0wBy8c18OoBTAUxT1TpVfR7ASwCudJtW9olIcwCXArhFVXep6nIAf0QOHquqLlDVRQC2J/3c3hVpEckD0AvASek/FT9K/2lsFyvOLVcB+L3m7jz9+wAMF5ECEWkP4GKkCnWusTvSpmJnJJ1IAkoB1Klq9RGxfyA3P3yd8a5II/VnU2Okriz7IvWn8TkAJrtMKk4iUozUn/9zXOcSo2VIvXk/A/ARgJUAFjnNKB5rkPqL6AYRaSwi/4rUuS1wm1YsCgGEdqbATqRuUVKW+Fik96b/e7+qblbVbQB+A2Cww5ziNgrAclVd5zqROIhIIwDPAFgAoDmANgBOQGrcIaeo6kEAQwF8G8AWAJMAPIHUB1Ou2QWgZSjWEkCtg1xylndFWlV3IPWCztU/+6OMQm5fRRcB+CqAB1R1v6puB1CJHP3gVdU3VLWfqp6oqgMBdAGwwnVeMagGkC8iXY+InQ2gylE+Ocm7Ip1WCeA6EWkrIicAmIDUaHnOEZE+ANojd7/VgfRfQ+sAjBORfBFpjdQ9+H+4zSweInKWiDRN33+/HqlvtPzOcVpZp6q7kfrr6DYRaS4i3wQwBMAjbjPLvvTrtimAPAB56fObyFdIfS3StwN4HalP6tUAVgG402lG8bkKwAJVzfU/ES8BMAjAxwDWAvgcwESnGcXnSgCbkbo3PQBAuarud5tSbMYDaIbUsT4KYJyq5uKV9GSkbsX+HMAV6f9PZJyMi/4TEXnM1ytpIiICizQRkddYpImIPMYiTUTksVi+QlLe6PsNGo089VU7UalrwVYTW3ZWw2aILz00P2rKboNlcpwbpvQxsQOtDpnY1QNeMLGb2rwTaFcf3G36TDjPLrD29ObpWT1OILNjrZ7dy8Sm9X3MxCY9eYWJdbs7uH5WXY0971FcnNMDSzuaWKcWn5jYpvOz94WdbB8nkNmx5rVra2Krpxab2DMD7jOxsdXBBfGalK/PKC9Xx5qpce+uNbG397YPtJeX29dI1Gs6k2PllTQRkcdYpImIPMYiTUTkMRZpIiKPOdu+6JPRvU3smeIKEzvt8X83sRK8GktOSWmy0342PvWLC01s6fjTA+2owalMB9iScGGPd+rvBOCe78w1scW9zwm0N52flZSyIq+sW6D9QtnjmT1wkw3dtS34uxo6CJ6UvXNtfuvKHjax0x6fZGLh8/yLiaNMn5OnvXwM2cUvqk4Nbf73iFjwtT+4TU/7yxr4XuWVNBGRx1ikiYg8xiJNROQxZ/ekh018PqN+XRYd3ys8Fk/J7J7b2mn2JuzV7dYE2lFfkPdpE4y/vN3NxFa0shMfOlxqV7K8f31wu8Orh/3U9ClY+NoxZNdwB9vUv/PV6A19TWzFRnvsd561ONBehpKGJxaDTO6/l70y0sRKJtpxoomthgcDZx4wfU4+yvySdvNNmS2NHT7/dVWZjc9kglfSREQeY5EmIvIYizQRkcdYpImIPOZs4LBHs40mFv6iPwA0WrYqiXSyZs+wbwTamy7IbEGvpy65p94+j48YYGInT/NnMkvJnDoTW/roPBMb/aodZHv7QLtAu0X1p6aP/e3JaLzGvlbDaobYSR/nLd5gYj2a1IQifg0cYtuOersUzS3M6Fc12umsvGQkvMLf+hknmT5RE1eSxitpIiKPsUgTEXmMRZqIyGMs0kREHnM3cGgGUIDF288xsQ1TzjSxzvO3B9rZnN1zrMIDXsXj95k+D5X+IaPfdfWE4Ky7kxf6vWLYvqImGfWrLH7RxAaXXxZo+3ROwysNRg1wL1n1rIl1fvoaE7vxlODMyvAMP8Dtsdf26ezsuZN28PTgllfntbfbYi3abQdJhzbfZWLh2balWHmM2f0fXkkTEXmMRZqIyGMs0kREHmORJiLymLOBw//eea6JRQ0o3XWJnVF305jgwEr55aNNH1czFcODPk3KbZ/STc1N7Os3jzOxooWvZC2vOBzqFxzofXH6Q6ZP1PZnTYvt8qojHw0OtCy/3G4/5MtgYtSWVy/0s6/B0mV28Gjg7J8E2p3u/dj0iXrNJKXFy+vq7bOvtb22axGavQcAxWdsDrTz7yhqeGIxCNeIqC3b7hx9pYkNvdNu8/fMgPsC7evwzWNL7gi8kiYi8hiLNBGRx1ikiYg85uye9CML7Ipu4XvNALC05nQT+16rvwXa7w/9iulTsuwYksui6tm9bOzgSyZ20pL3TMzVqm+ZCq8OV31wt+nT7e73TSw8iQAAbno0eO5Pu6a/6VMy8WgzTE7UGEjUuQ/fuwxPWAKAJlifvcSOUnjiTtS2YGeMfcvEVnzHbhWGz4LNDsfZipYA0PTTQxn1C6/imE28kiYi8hiLNBGRx1ikiYg8xiJNROQxZwOHnSvsilOdi+2qYeGBFgAYWz0i0O6yaH/2EsuyH/WyE3RGTrnexIpq/J64EiU8yBQ+LwDwwqrFJhY1wNi/KvjYqAFHXwZSowYEL+xhB737Fdhz/+NR1wbaBctey15iMYjaFixqm6mRXe3EnReu6xNLTkmKmtwTtQriTW2C539mxOSe8PslU7ySJiLyGIs0EZHHWKSJiDzGIk1E5DFRVdc5EBHRF+CVNBGRx1ikiYg8xiJNROQxFmkiIo+xSBMReYxFmojIYyzSREQe865Ii8hXRGSWiKwXkVoRWSUiF7vOKy4iMldENovIZyJSLSJ2lakcIiJdRWSfiMx1nUtcROQv6WPclf7xY5vzmIjIcBFZLSK7ReQ9EbHbuRzHjjiPh3/qROT+pJ7f2Sp4/0Q+gA8B9AOwAcBgAE+IyJmq+oHLxGIyFcDVqrpfRE4H8BcRWaWqf3WdWEymA3jddRIJuFZVH3adRNxEpBzALwFcBmAFgFPcZpR9qlp4+P9FpDmAGgDzk3p+766kVXW3qk5R1Q9U9ZCqPglgHYCvuc4tDqpapaqH11rV9M9pDlOKjYgMB/ApgOdc50JZcyuA21T11fT7daOqbqz3Ucev7wHYCsCuQxsT74p0mIi0A1AKoMp1LnERkRkisgfAGgCbASxxnFLWiUhLALcBmOQ6l4RMFZFtIvKSiFzoOpk4iEgegF4AThKRtSLykYg8ICJ2EerccRWA32uC62l4XaRFpDGAeQDmqOoa1/nERVXHA2gBoC+ABQD83cWg4W4HMEtVP3SdSAJ+BqALgPYAZgL4k4jk4l9H7QA0Rurqsi+AngDOATDZZVJxEZFipG7Dzknyeb0t0iLSCMAjAA4AuLae7sc9Va1T1eUAOgAY5zqfbBKRngD+BcA017kkQVVfU9VaVd2vqnMAvITU2Equ2Zv+7/2qullVtwH4DXLzWAFgFIDlqmq3a4mRjwOHEBEBMAupT+rBqnrQcUpJykfu3ZO+EEAnABtSpxaFAPJEpIeqnuswr6QoAHGdRLap6g4R+Qip4/syGAXg7qSf1Ncr6QoA3QF8V1X31tf5eCUibdNfXyoUkTwRGQjgcgDPu84ty2Yi9cHTM/3zIIA/AxjoMqk4iEhrERkoIk1FJF9ERgK4AMAzrnOLSSWA69Kv5RMATADwpOOcsk5E+iB1+yqxb3Uc5t2VtIh0BDAWqfuyW9JXXgAwVlXnOUssHorUrY0HkfrAXA9ggqra3VuPY6q6B8Cew20R2QVgn6p+7C6r2DQGcAeA05HaO3cNgKGqmqvflb4dQBsA1QD2AXgCwJ1OM4rHVQAWqGpt0k/MRf+JiDzm6+0OIiICizQRkddYpImIPMYiTUTksVi+3VHe6Pv1jkZ+Mrq3iZ0x9i0TqxliZ5jW1WxtUF5LD83P6ndVo44zr6xboL16UgvzuGcG3Gdibx9oZ2ITXxweaJfMqTN9Gi1bZWLZPk4gs3MaZe20803sqUvuMbEJ5w0LtDM9x0mc0/BrNep12rXA5ntTm/q/0DG4/DITq6uyj+M5PTaZHGteu7Ym9s7Pu5hY1LEOWzkm0O5waWarWGRyrLySJiLyGIs0EZHHWKSJiDzGIk1E5DFn08LnTfm1iUUNnt04bpSJFU9p2MBhEmpLWwfaP+r1F9Pn4gV2SeVDrT43sXWDght7nLbz302fkmVHmWCMogZe7vmO3SXrv3fWv6ZS1O9q6IDxsSocsSnQriy2671XH9xtYqc9bs/zqf8bHL8qqHrtGLNL3gW97aBY1HvX1fnK1KF+5wTa/e5/2fS5t9VCE4s61jvPCq7kUIGSY8zu//BKmojIYyzSREQeY5EmIvKYs3vSUfcll5d3NLHzF79pYpumxJFRdhQsDN5jXLbQTsYpnGg/G28d/5iJhe9zdlnk965a62ecZGI9mtSY2PRrvm9jKx4ItMdWjzB9mpQfQ3LHYMNbwQ2wF3UqNH3u+2CIiXW7+30T8/0+bVj4vi0AVBZXmlj3meNNrBj2Hq9PPu3SNNCe924v02fZpfb9+9H/lJnYee03hCLZW9GUV9JERB5jkSYi8hiLNBGRx1ikiYg8ltjAYXh1uHnv2qfuUGO/JD/kxLUmls0virtQNHhjRv0mDP5hoN2oyq5459KGKX0C7dW9Z5g+3WfeYGKd19hzWtq4efB3hwbrAKAE6482xVgMbb7LxsrstpSLltsBxoqux9drd+u5duAsSuf5203Mrtnol6LKVwLt1u/bQdKo1ToX9rIT8cKr4HUss5PTolY3zASvpImIPMYiTUTkMRZpIiKPsUgTEXkssYHD8E3zjv/ZzfaJeFzUIM3M0Appx9ssrmYTmppYjyV2Zt7ee/cF2q5m3H2RfcUH6u1z5SXPmViPkfUPnBa9kfUdlBosPHPw7A12dl2Uf9xgB1IrspJRcg60yqzfkqWPm9hd24Lv8YXTLjJ9woN3Li191M6kjNbcRKp6zwu0R8/qa/pssruOZYRX0kREHmORJiLyGIs0EZHHWKSJiDzmbKnSqNk3Wyb2MbHqgy/Zxx5nA4VhUccenl0IAA8tmR1oXz3sp6ZPeGnUJHW/Mbg8Y1mrkabPwl4zTSw8uxAAFu0Ozs7zaUAp/Ho7eZp9/UXNTIsSXvqz0TK/ZpGGLR79q4ioPX+dn76m3t817aZHTKyi0t0MzPAWbac9breni9oqbMiJ9pxNevKKQDtqWeFGaNi55pU0EZHHWKSJiDzGIk1E5DFn96SrZ9utatYNsl/+rz5Y/2Mb7bSH0e3hHQ1P7hiE73N9PPg00+dAaztR47LRdtJH+N7tZ53yTJ+Co00wi8L3ajtcau/VTmg3zMSWrHrWxG5+I7j9VAfYe4GuZHJO502xK6Pdtc1uEef7PeiwH4+61sYenp/RY7vfE9xCauigiIlpZXZSW1LCr9+Sifb1uyJiq6yuBbZfycRXs5dYCK+kiYg8xiJNROQxFmkiIo+xSBMReczZwGHJHLvmXf+vDjGxqG2UfjTghUD73T1tTZ+1/9vjGLI7Bm1OCDTPGPtWg39V/6rgv8fJ015u8O9yZf2Mk0ys+uBuEyuaa7ea8kVtn86BdtQgYdQEneWX94z4bQ3bQsmVqIHOG+eNMrFnIia9lA4K/puEX88A0KSBW0olpW1LO9j525V2hbtSrIwtB15JExF5jEWaiMhjLNJERB5jkSYi8pioqusciIjoC/BKmojIYyzSREQeY5EmIvIYizQRkcdYpImIPMYiTUTkMRZpIiKPeVmkRaSTiCwRkR0iskVEHhARZ4tBxUlEuovI8yKyU0TWiojdyiQHiEiRiCwUkd0isl5ERrjOKS4icq2IrBSR/SLyO9f5xEVEviIis9Lns1ZEVonIxa7zioOIzBWRzSLymYhUi0j926NniZdFGsAMAFsBnAKgJ4B+AMY7zSgG6Q+exQCeBFAEYAyAuSJS6jSxeEwHcABAOwAjAVSIiN2bKDdsAnAHgNmuE4lZPoAPkXp/tgJwC4AnRKSTw5ziMhVAJ1VtCeDfANwhIl9L4ol9LdKdATyhqvtUdQuApwHk4hv6dACnApimqnWq+jyAlwBc6Tat7BKR5gAuBXCLqu5S1eUA/ogcO87DVHWBqi4CsN11LnFS1d2qOkVVP1DVQ6r6JIB1ABIpXklS1SpV3X+4mf6xm13GwNcifR+A4SJSICLtAVyMVKHONXZH2lTsjKQTiVkpgDpVrT4i9g/k5gfvl5aItEPqXPuzi3AWicgMEdkDYA2AzQCWJPG8vhbpZUi9gT8D8BGAlQAWOc0oHmuQuq1zg4g0FpF/RepPR5ebgMehEMDOUGwngBYOcqEYiEhjAPMAzFHVNa7ziYOqjkfqNdsXwAIA+//5I7LDuyItIo0APIPUP0JzAG0AnADgly7zioOqHgQwFMC3AWwBMAnAE0h9MOWSXQBahmItAdQ6yIWyLP2efQSpMYdrHacTq/RtyeUAOgAYl8RzelekkRpA+yqAB1R1v6puB1AJYLDbtOKhqm+oaj9VPVFVBwLoAmCF67yyrBpAvoh0PSJ2NnL0z+IvExERALOQGhC+NH3h8WWQjy/rPWlV3YbU4MM4EckXkdYArkLqHmbOEZGzRKRp+v779Uh9o+V3jtPKKlXdjdRfRreJSHMR+SaAIUhdfeWc9Ou2KYA8AHnp85uTXyEFUAGgO4Dvqupe18nEQUTaishwESkUkTwRGQjgcgDPJ/H83hXptEsADALwMYC1AD4HMNFpRvG5EqlBiK0ABgAoP2IUOZeMB9AMqeN8FMA4Vc3VK+nJAPYC+DmAK9L/P9lpRjEQkY4AxiL1NdktIrIr/TPScWrZpkjd2vgIwA4AvwYwQVUXJ/HkXPSfiMhjvl5JExERWKSJiLzGIk1E5DEWaSIij8XytaDyRt+vdzTyo/+xM4IPvdnKxK685DkT++3KvoF26Q9XZpTX0kPzo6ZhN1gmx7llYh8Tu3X8703snv+wA+IFC19rUF7ZPk4gs2M91O8cE+t//8smtrTmdBPb8lL7QLt4in1cFBfnNEpeWTcTW7L08XofN7j8MhOrq3rHxFyd07XTzjex9y570MS+frOd11FU+UqD8krqWPNPbhdov/2LjuZxI3vbY7ij7ZsmVnUg+O3DMTdMMH0K59v3cybHyitpIiKPsUgTEXmMRZqIyGMs0kREHnO2nsCenc1MrODM8GqWwLt72prYMwPuC7QnlP3Q9IkafHGhaPBGExvafJeJ3XyFjRUsjCWl2Hw++RMTu6mNPQ9RsfDK0oPnZzag5ova0tauU8iKvHbB99vVA14wffpXDTGx1++sMLGBlT2zl1gM9vXoEGh//cz3TJ95r/S2MdhYeICx/8124Pv1+XlHmyIAXkkTEXmNRZqIyGMs0kREHnN2T7rDn+z9mfzx9r7sio3FJja2dkSg3cTje5Ub3jrFxBZ1KjSxqt7zTGxwWfC+rG/3ZPcM+0ag/WLZQ6ZP56evMbHuN24wsTHLM5u84kL4Pm1tn86mT8nP3s7od43eEJyI5ds5ravZGmjPe7eX6dPhUrvC7F1v2Mk84clNjZatOsbssiv/+b8G2jsjVocujdhLuNHgGRuIAAADvklEQVRZdjLWGRcFN1P6zwXDTZ/OaNjkHl5JExF5jEWaiMhjLNJERB5jkSYi8pizgcMWL68zsSXTnzWxslfs6nDNrgiuOFWXvbSyrtvd75vY4t52tbjFdnwCe+/dF2g3Kc9aWomJWqEw6nyFJ/jMjCmfhlg3riTQXj1mhqNMknfqfzUxsfBAKgDc1Ma+d5evCa4q5/P79ItEDRI+9fRjJjZ565mBdtf77Pv+84bm0MDHERFRAlikiYg8xiJNROQxFmkiIo85Gzhst3ivid21zc5aKpprZ+fV1dgZT74Kz+ACgE12R6JoS4sCzajtqVzO4jLbe023faIGmaL+TcIz8d655gTTp2Ti0eWXLeGtvMpfGG36bPp/B0wsahbpkBOD56sCJaaPT6JeX6tn21mI4fMHRJ/n482hN9aY2GO19rX51IxvBdpttjRsdmEUXkkTEXmMRZqIyGMs0kREHmORJiLymLOBwyjLyzuaWMliuwTkpuNsW6mG2vWHUwPtwsmbTJ8my5LKpn7VB3eb2OqpdqnZ0h/aAaWuBcHY3zacafr4Imowbd/QiNFgu8sSFm8PD/7WZiepmEQNVoe3rwOAkVOuN7GiBi7N6btb/mq3D7t9UnAWYuVMW8sailfSREQeY5EmIvIYizQRkccSuycdntSwYuNJpk/HNnadqCEn2m2VfJ8AcKSoyRxR2y9F2dVRAu3XyxabPuEttlwa+NxPTGxaX7ti2MTZdmuhcc2C/dr/Ya3p4/MqaoUbMrveqSx+MdCOOn8+ban144fnZ9Tvk7PUxqYF79N3WbTf9PFpS611U+0gwsHW9lX3ZB97T76sSbNAuxK8J01E9KXAIk1E5DEWaSIij7FIExF5LLGBw/CKWG1bNjN9xix6zsTuvOtKEzueviQf3noJyHz7pfCqgP2r7Jfom23b0bDEYtD9HjsxY3EPOxniR71eNLF7/iO4TVpBzWumj8/aP2v3Pxt9mV0Z7sZTng60a0tbmz4FHi3yeOO8USZ2/qA3TeyC3vUn3XWAncQUNYHNlYWX/8bEwgOCAPCD979jYrXjw1+EsKvnNRSvpImIPMYiTUTkMRZpIiKPsUgTEXlMVO1MISIi8gOvpImIPMYiTUTkMRZpIiKPsUgTEXmMRZqIyGMs0kREHmORJiLyGIs0EZHHWKSJiDzGIk1E5DEWaSIij7FIExF5jEWaiMhjLNJERB5jkSYi8hiLNBGRx1ikiYg8xiJNROQxFmkiIo+xSBMReYxFmojIYyzSREQeY5EmIvLY/wevxoPUsRb08wAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<matplotlib.figure.Figure at 0x10fb2d350>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i8i_XV2vKxHE",
        "colab_type": "code",
        "colab": {},
        "outputId": "d40c9b51-ab51-4f66-f4bf-4e92fb5edc69"
      },
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "X_train, X_test, T_train, T_test = train_test_split(\n",
        "    digits.data, digits.target, test_size=0.2)\n",
        "print(X_train.shape)\n",
        "print(X_test.shape)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(1437, 64)\n",
            "(360, 64)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W-n6cThNKxHI",
        "colab_type": "code",
        "colab": {},
        "outputId": "e120d63d-3f7e-4fea-fc8d-9b0f9ae410d9"
      },
      "source": [
        "X_train[X_train == 0] = 1e-8\n",
        "X_train[0]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1.0e-08, 1.0e-08, 1.0e-08, 1.0e-08, 1.4e+01, 4.0e+00, 1.0e-08,\n",
              "       1.0e-08, 1.0e-08, 1.0e-08, 1.0e-08, 3.0e+00, 1.6e+01, 1.1e+01,\n",
              "       1.0e-08, 1.0e-08, 1.0e-08, 1.0e-08, 1.0e-08, 1.0e+01, 1.6e+01,\n",
              "       9.0e+00, 1.0e-08, 1.0e-08, 1.0e-08, 1.0e-08, 1.0e-08, 1.3e+01,\n",
              "       1.6e+01, 7.0e+00, 1.0e-08, 1.0e-08, 1.0e-08, 1.0e-08, 1.2e+01,\n",
              "       1.6e+01, 1.6e+01, 4.0e+00, 1.0e-08, 1.0e-08, 1.0e-08, 1.0e+00,\n",
              "       1.3e+01, 1.2e+01, 1.6e+01, 5.0e+00, 1.0e-08, 1.0e-08, 1.0e-08,\n",
              "       1.0e-08, 1.0e-08, 4.0e+00, 1.6e+01, 9.0e+00, 1.0e-08, 1.0e-08,\n",
              "       1.0e-08, 1.0e-08, 1.0e-08, 1.0e-08, 1.4e+01, 1.0e+01, 1.0e-08,\n",
              "       1.0e-08])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cjUK-0f8KxHK",
        "colab_type": "text"
      },
      "source": [
        "# Softmax Function\n",
        "\\begin{align}\n",
        "\\phi(z_j) = \\dfrac{\\exp(z_j)}{\\sum_{k=1}^{K}\\exp(z_k)}   ~~~  \\textbf{for} ~~~j=1,...,K\n",
        "\\end{align}"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U5X3anmlKxHK",
        "colab_type": "code",
        "colab": {},
        "outputId": "65cfbf50-ec1d-4124-8f90-f7a2e6dced3a"
      },
      "source": [
        "def softmax(z):\n",
        "    e = np.exp(z - np.max(z))\n",
        "    #return e/np.sum(e)\n",
        "    return np.maximum(1e-5, e/np.sum(e))\n",
        "\n",
        "print(softmax(np.array([1,2,3])))\n",
        "print(softmax(np.array([0,0])))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0.09003057 0.24472847 0.66524096]\n",
            "[0.5 0.5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-2j_wZzcKxHN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "n_class = 10\n",
        "\n",
        "# Weight\n",
        "W = np.random.randn(X_train.shape[1], n_class)\n",
        "\n",
        "# Z = XW (+ b)\n",
        "def transfunc(X, W):\n",
        "    return np.dot(X, W)\n",
        "\n",
        "Z = transfunc(X_train, W)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UK93d_nLKxHO",
        "colab_type": "code",
        "colab": {},
        "outputId": "1aae5514-602e-4cd8-b50c-1f706fc93d38"
      },
      "source": [
        "print softmax(Z[0])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1.e-05 1.e-05 1.e-05 1.e-05 1.e-05 1.e-05 1.e-05 1.e-05 1.e-05 1.e+00]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1JZPZQjOKxHQ",
        "colab_type": "code",
        "colab": {},
        "outputId": "f9da3e4f-d4e5-442e-d799-79db54d40c8e"
      },
      "source": [
        "a = np.array([[1,2,3],\n",
        "              [1,2,3]])\n",
        "print(softmax(a[0])) # これだとめんどくさい　#正解\n",
        "print(softmax(a)[0]) # この形で扱いたい　# 不正解"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0.09003057 0.24472847 0.66524096]\n",
            "[0.04501529 0.12236424 0.33262048]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P4Lud1oBKxHR",
        "colab_type": "text"
      },
      "source": [
        "https://stackoverflow.com/questions/22581763/apply-a-function-to-each-row-of-a-ndarray"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ol8_LMGeKxHR",
        "colab_type": "code",
        "colab": {},
        "outputId": "c6870423-acd8-4488-9032-1f8e27e38d21"
      },
      "source": [
        "np.apply_along_axis(softmax, 1, a)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.09003057, 0.24472847, 0.66524096],\n",
              "       [0.09003057, 0.24472847, 0.66524096]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SXF9zcEmKxHS",
        "colab_type": "code",
        "colab": {},
        "outputId": "ca62d876-045e-4738-cb20-82416acf88be"
      },
      "source": [
        "print(\"Predict label:\", np.argmax(np.apply_along_axis(softmax, 1, Z), axis = 1))\n",
        "print(\"Correct label:\", T_train)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Predict label: [9 1 1 ... 1 1 1]\n",
            "Correct label: [1 0 4 ... 6 6 4]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cEinx5fyKxHU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "np.random.seed(39)\n",
        "\n",
        "labels = T_train"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LG_8o60RKxHV",
        "colab_type": "text"
      },
      "source": [
        "# Loss function\n",
        "\\begin{align}\n",
        "J(\\theta) = - \\left[ \\sum_{i=1}^{m}\\sum_{k=1}^{K} 1\\{y^{(i)} = k\\} \\log \\dfrac{\\exp({\\theta^{(k)}}^T x^{(i)})}{\\sum_{j=1}^{K}\\exp({\\theta^{(j)}}^T x^{(i)})} \\right]\n",
        "\\end{align}"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vMsSBFKYKxHV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def loss_function(X, theta):\n",
        "    num = X.shape[0]\n",
        "    J = 0\n",
        "    z = np.dot(X, theta)\n",
        "    for i in range(num):\n",
        "        for k in range(n_class):\n",
        "            if labels[i] == k:\n",
        "                J = J - np.log(softmax(z[i])[k])\n",
        "            else:\n",
        "                J = J - 0\n",
        "    return J"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KbhlVRq8KxHW",
        "colab_type": "code",
        "colab": {},
        "outputId": "65aa80cc-77e1-4ae6-fc37-8b5acc665d1f"
      },
      "source": [
        "loss_function(X_train, W)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "15435.564689837385"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QHzOv5gxKxHX",
        "colab_type": "text"
      },
      "source": [
        "\\begin{align*}\n",
        "\\nabla_{\\theta^{(k)}} J(\\theta) &= - \\sum_{i=1}^{m} x^{(i)} \\left[ 1\\{y^{(i)} = k\\} - \\dfrac{\\exp({\\theta^{(k)}}^T x^{(i)})}{\\sum_{s=1}^{K}\\exp({\\theta^{(s)}}^T x^{(i)})} \\right] \n",
        "\\end{align*}\n",
        "\n",
        "where\n",
        "\n",
        "\\begin{align*}\n",
        "1\\{\\} = \n",
        "\\begin{cases}\n",
        "1 & \\{True\\}  \\\\\n",
        "0 & \\{False\\}\n",
        "\\end{cases}\n",
        "\\end{align*}"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2Vjqf2nPKxHX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def gradient_k(X, theta, k):\n",
        "    num = X.shape[0]\n",
        "    z = np.dot(X, theta)\n",
        "    grad = np.zeros_like(theta[:,k])\n",
        "    for i in range(num):\n",
        "        if labels[i] == k:\n",
        "            grad = grad - X[i]*(1 - softmax(z[i])[k])\n",
        "        else:\n",
        "            grad = grad + X[i]*softmax(z[i])[k]\n",
        "    return grad"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "37SAa-U-KxHY",
        "colab_type": "code",
        "colab": {},
        "outputId": "581a8b68-7897-4301-c443-8cc02f16b1cc"
      },
      "source": [
        "gradient_k(X_train, W, 3)[0:3,]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-1.49985630e-06, -9.69954909e+01, -1.22892452e+03])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tNNma2jCKxHZ",
        "colab_type": "text"
      },
      "source": [
        "# Gradient Descent\n",
        "\\begin{align}\n",
        "\\theta_k &=& \\theta_k - \\eta * \\nabla_{\\theta^{(k)}} J(\\theta)   \n",
        "\\end{align}"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wPfG9wgRKxHZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "loss_cost = [0]\n",
        "\n",
        "def update(X, theta, eta = 0.01, max_iter = 100):\n",
        "    num = X.shape[0]\n",
        "    for i in range(max_iter):\n",
        "        tmp_theta = np.copy(theta)\n",
        "        for k in range(n_class):\n",
        "            tmp_theta[:,k] = tmp_theta[:,k] - eta*gradient_k(X, theta, k)\n",
        "        theta = tmp_theta\n",
        "        loss_cost.append(loss_function(X, theta))\n",
        "        if abs(loss_function(X, theta)-loss_cost[i]) < 1e-5:\n",
        "            print(\"convege, {}:iter\".format(i))\n",
        "            break\n",
        "    return theta"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "Zu9D1TdRKxHa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "predtheta = update(X_train, W, eta = 0.01, max_iter = 100)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p19YyotbKxHb",
        "colab_type": "code",
        "colab": {},
        "outputId": "8da27141-e93d-4fda-efe0-2c3fca11e88b"
      },
      "source": [
        "def predict(X, theta):\n",
        "    Z = np.dot(X, theta)\n",
        "    return np.argmax(np.apply_along_axis(softmax, 1, Z), axis = 1)\n",
        "\n",
        "pp = predict(X_train, predtheta)\n",
        "print(\"after\", pp)\n",
        "print(\"Correct\", T_train)\n",
        "print(\"accurate:\", float(np.sum(pp==T_train))/len(T_train))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "after [1 0 4 ... 6 6 4]\n",
            "Correct [1 0 4 ... 6 6 4]\n",
            "accurate: 0.973556019485\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "OmiH4tw8KxHc",
        "colab_type": "code",
        "colab": {},
        "outputId": "e59cc1d6-4b62-4a6d-d9c8-60172de09d3e"
      },
      "source": [
        "plt.plot(range(len(loss_cost)), loss_cost)\n",
        "plt.xlabel(\"iteration\")\n",
        "plt.ylabel(\"cost\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.text.Text at 0x1a21365550>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZUAAAEKCAYAAADaa8itAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xl0XOWd5//3V1Uq7YsXeZNtbEAxi8MWYyCh0wSSYBIa05mkm0zS8S9hDj09pJNeptMw0xk6SXNO8uuZTjoz6UzzCwSSk0DSZIFOk9AESEhYbIzZDAYsbMCyZUu2ZEnWVtv398e9JZdsydZSqkX6vM7RUdVTt2491wX3q+f5Pou5OyIiIrlQVugKiIjI7KGgIiIiOaOgIiIiOaOgIiIiOaOgIiIiOaOgIiIiOaOgIiIiOaOgIiIiOaOgIiIiORMtdAXybeHChb5q1apCV0NEpKQ888wzB9296WTHzbmgsmrVKrZu3VroaoiIlBQze3Mix6n7S0REckZBRUREckZBRUREckZBRUREckZBRUREckZBRUREckZBRUREckZBZYa8ur+PJ18/VOhqiIjklYLKNPUOJegZTBxX/vVHdvKZe54tQI1ERApHQWWa/upfnucvf/j8ceV9Q0k6+4bp6BsqQK1ERApDQWWa2nuG2N87eFz5YDwJwI72vnxXSUSkYBRUpmkgnmIgnjquvH84KNvR3pvvKomIFMycW1Ay1waGk6T9+PLBRBBUXt6noCIic4eCyjQNJFKkxogq/cOZ7i8FFRGZO9T9NU0Dw0H3l/vowDIYdom93nmEocTx3WMiIrORgso0JFJp4qk0qbQznEyPlLs7/fEkpzXVkHZ47YCS9SIyNyioTEN2gj778XAyTdph3SnzAeVVRGTuUFCZhoFw2PDxj4MAc8bSOmpiEV5WXkVE5ggFlWnIDBuG0S2VTJK+piLKmUvrlawXkTlDQWUaBscIJHB0OHFNLBNU+kiPNe5YRGSWUVCZhv4xurzgaICpjkU4a1k9R4aTtHUfP+teRGS2UVCZhnFbKmF5dSzCmUvrAXi5vSe/lRMRKYAZCypmdoeZdZjZ9qyyvzezV8zsBTP7iZk1Zr12s5m1mtmrZnZlVvmGsKzVzG7KKl9tZpvNbKeZ/cDMYjN1LePJbqkMZs1F6Q+DSk1FlDWL6ygzeFlrgInIHDCTLZU7gQ3HlD0ErHX3c4DXgJsBzOws4Drg7PA9/2RmETOLAN8ArgLOAj4aHgvwFeCr7t4CdAPXz+C1jGlgOLulkp20D4JNVSxCVSzC6oU1GlYsInPCjAUVd38M6Dqm7N/dPfPn/VPA8vDxRuAedx92991AK7A+/Gl1913uHgfuATaamQGXA/eG778LuHamrmU8JxtSXBMLVsE5e1kDz+05TCKVZiLc/bgZ+iIipaCQOZVPAT8PHzcDe7JeawvLxitfABzOClCZ8rzqj4/dUsnkV6piEQCuOXcZB48M8+8vHZjQeX/2Qjvr/u6XDCe1vIuIlJaCBBUz++9AEvhepmiMw3wK5eN93g1mttXMtnZ2dk62uuMaiCeJlBmxaNmolkp2oh7gPWcsYuX8ar79+O4Jnfex1zo51B8fc0dJEZFilvegYmabgKuBj/nRPp42YEXWYcuBfScoPwg0mln0mPIxuftt7r7O3dc1NTXl5kIIurmqYxFqK6KjhxTHU8QiZZRHgn/eSJmx6Z2r2PpmNy+2nXwU2Eth/mUoPrHuMhGRYpHXoGJmG4C/Bq5x94Gsl+4HrjOzCjNbDbQAW4CngZZwpFeMIJl/fxiMHgU+HL5/E3Bfvq4jY2A4CCrVscjokWDxJNUVkVHHfmTdcmpiEb79xIlbK/Fkmp0dwUixgUTyhMeKiBSbmRxSfDfwJLDGzNrM7Hrg/wB1wENm9pyZ/V8Ad38J+CHwMvAL4EZ3T4U5k08DDwI7gB+Gx0IQnP7CzFoJciy3z9S1jGcgkaImFqU6Fhk9EiyeGknSZ9RXlvPhdyznZ8+309k3PO45XzvQRyIVNOAGx9hRUkSkmM3YJl3u/tExise98bv7rcCtY5Q/ADwwRvkugtFhBTMwnKQqFqE8UnbM7PrkSJI+26Z3ruKuJ9/kq798jebGKn6zs5PySBl3fXI9ZWVBmih76LGCioiUGu38OA398SQ1sSjlUTtuGfyaMYLKqU21XLamie9vfguAJfWV7O8d4uX2XtY2NwDw0r6eUecRESklCirTMBhPMa8mRnmkjK7+o2t7DQynxmypAHz5Q+ew7a1uLlw1H8dZf+vD/Pq1zpGgsn1fL/Oqy+keSIyapS8iUgq09tc09Iejv2pikdGTHxPJ43IqGUsaKvnA25fSVFfBorpKzl5Wz69e7QAglXZ2tPfyjnBzL3V/iUipUVCZhoHhJNWxKFWx6OhlWk7QUjnWZWua2PbWYXoGE7xxqJ+BeIoLV80DUEtFREqOgso0DCTGaamMMfprPJetWUQq7TzeenBkfsq6VfNHziMiUkqUU5mGYJ5KNJxRnyKddsrKjP4x5qmM5/wVjdRXRvnVqx1hfsZY2xwsl6+WioiUGgWVKUqk0sRTaWpiEWLRoME3lExRVR4ZmWk/EdFIGb/T0sSvX+ukZVEdb1tcR0U0QlV5hMG4Jj+KSGlR99cUZbqmqmIRqiuC2Nw/nCKeSpNKO9UT7P4C+N01TRzoHeapXYc4e1nQSqmORdRSEZGSo5bKFGVyKDUVUWLhGl8D8STRcBLjRFsqAJe9LViPLJl2zl4WDC2uDFs8IiKlRC2VKRrIWom4Jsyf9A+nGEiM3ktlIhbVV3JWuO1wdktlSC0VESkxCipTlFnrqzoWHenqGognGQj3Uplooj7jvWctpiJaNrKnfVVMLRURKT3q/pqike6vWISK8kz3V2pkufvJdH8B/JfLTuP3z2+mJszPBIl6BRURKS1qqUzRqER9Vksls7DkZBL1EORQVi+sGXlepUS9iJQgBZUp6s9K1GdaJf3Dqaxuscm1VI5VHVNLRURKj7q/pig7UV8RjYRlScqjme6v6f3TavSXiJQiBZUpGknIx6JUhjmV/niK8kimfPotFY3+EpFSo6AyRf1ZLZVYpAyzoPWSmbMymSHFY6mORdVSEZGSo6AyRYPxFGUGFdEyzIzq8ggDw0likWDy40RXKR5PZXmQqHd3zCwXVRYRmXFK1E9RZtfHzA2/KhalP54KhxXbyHpgU5XpPhtKpKddVxGRfFFQmaLBeGrUBMeaimD5+2Axyek3AKvKg3NrWLGIlBIFlSnqPyZ4VIcbdfUPJ6edpIej3WcDWqlYRErIjAUVM7vDzDrMbHtW2Xwze8jMdoa/54XlZmZfN7NWM3vBzC7Ies+m8PidZrYpq/wdZvZi+J6vW54TDwPHBI/MRl2Zjbuma6SlomS9iJSQmWyp3AlsOKbsJuBhd28BHg6fA1wFtIQ/NwDfhCAIAbcAFwHrgVsygSg85oas9x37WTPq2N0dqyuC0VqZLYanKxOY1P0lIqVkxoKKuz8GdB1TvBG4K3x8F3BtVvl3PPAU0GhmS4ErgYfcvcvdu4GHgA3ha/Xu/qS7O/CdrHPlxUA8OWqEV3V5dk4ldy0VDSsWkVKS75zKYndvBwh/LwrLm4E9Wce1hWUnKm8bozxv+uOpkSXvIViVuH84GP2VWRRyOqrUUhGRElQsifqx8iE+hfKxT252g5ltNbOtnZ2dU6ziaIPxFFXlR4NHTSwatlSS056jAllBRS0VESkh+Q4qB8KuK8LfHWF5G7Ai67jlwL6TlC8fo3xM7n6bu69z93VNTU3TvggI56kc21IJ56nU5CCoVIcBS0FFREpJvoPK/UBmBNcm4L6s8k+Eo8AuBnrC7rEHgfeb2bwwQf9+4MHwtT4zuzgc9fWJrHPlxbHzUWpiUeLJNH1DuUnUV8bCPVrU/SUiJWTGlmkxs7uBy4CFZtZGMIrry8APzex64C3gI+HhDwAfAFqBAeCTAO7eZWZfAp4Oj/uiu2eS/39CMMKsCvh5+JMXiVSaeDI9KiGfeXwkR/NUMoFpSC0VESkhMxZU3P2j47x0xRjHOnDjOOe5A7hjjPKtwNrp1HGqspe9zxg9EVKjv0RkbiqWRH1JGYwf3Z8+Y1R+JQfdX5GyYP0wjf4SkVKioDIFR3d9HDuQZJdPR7BPvZZpEZHSoaAyBUe3DM5O1B8NJFU5aKkE59c+9SJSWhRUpiCzyGP1qEAyeh2wXKjSlsIiUmIUVKZgrER99iz6XEx+zJxHWwqLSClRUJmCTFDJDiSjVyzOTfeXWioiUmoUVKYgk6jPDPuF0YEkZ4l65VREpMQoqEzBwHBm9Ff20ve5T9QHo78UVESkdCioTEFm6ZTsLq9YpIxIWbDOZa4S9Rr9JSKlRkFlCgaGU5QZVESP/vOZ2UiQyWWiXjkVESklCipT0B9PUhOLcuwOxjWxKNEyIxbJzT9rVXlU3V8iUlIUVKZgMJ4aszVSXRGhKhY5LthMVVUsWKYlWBpNRKT4KahMQf84uzvWxKI5G04MwYz9VNqJp9I5O6eIyExSUJmCwXhy1HDijKpYZNQosOnKfMZQXEFFRErDjC19P5v1D6fGnIvSVFeR08/JdLENJJI0UJ7Tc4uIzAQFlSkYSKRoqDr+Jv+Fa84mmcpd/qNa+9SLSIlRUJmCeDI9ajhxxsLa3LZUKrVRl4iUGOVUpiCRSuds2PCJZFoqWlRSREqFgsoUJFJpyiO5GTZ8ItpSWERKjYLKFCSSacrz0FLJJOq1VIuIlAoFlSmIp5zyMXIquZZpqShRLyKloiBBxcz+3MxeMrPtZna3mVWa2Woz22xmO83sB2YWC4+tCJ+3hq+vyjrPzWH5q2Z2Zb7qn7+cSjCOQi0VESkVeQ8qZtYMfAZY5+5rgQhwHfAV4Kvu3gJ0A9eHb7ke6Hb304GvhsdhZmeF7zsb2AD8k5nlbubhCSinIiIytkJ1f0WBKjOLAtVAO3A5cG/4+l3AteHjjeFzwtevsGBxrY3APe4+7O67gVZgfT4qHwSV/OVUNPpLREpF3oOKu+8F/ifwFkEw6QGeAQ67ezI8rA1oDh83A3vC9ybD4xdkl4/xnpmsP4mU5yWolEeMSJkxEE+e/GARkSJQiO6veQStjNXAMqAGuGqMQzNT08fqZ/ITlI/1mTeY2VYz29rZ2Tn5SmdJhDPmY3lI1JsZ1eURBrX2l4iUiEJ0f70X2O3une6eAH4MvBNoDLvDAJYD+8LHbcAKgPD1BqAru3yM94zi7re5+zp3X9fU1DStyifCFYPzkVMBqIxFGEyopSIipaEQQeUt4GIzqw5zI1cALwOPAh8Oj9kE3Bc+vj98Tvj6Ix5sMHI/cF04Omw10AJsmenKHw0q+fmnq45pn3oRKR15X/vL3Teb2b3ANiAJPAvcBvwbcI+Z/V1Ydnv4ltuB75pZK0EL5brwPC+Z2Q8JAlISuNHdZ/zuG89zUKkq15bCIlI6CrKgpLvfAtxyTPEuxhi95e5DwEfGOc+twK05r+AJjORU8hVUYhHNUxGRkqEZ9ZOUSIYtlWh+cipV5er+EpHSoaAySYXIqaj7S0RKhYLKJOU7p1JZHtHkRxEpGQoqk5TvnIpaKiJSShRUJinf3V9V5UrUi0jpUFCZpJFEfZ4mP1bFokrUi0jJUFCZpJGcSh6WaYGgpRJPpUmmtFSLiBQ/BZVJKkROBbSnioiUhgndGc3suMmHY5XNBXnPqcS0p4qIlI6J3hlvnmDZrJfvBSUX1lYA0Nk3nJfPExGZjhMu02JmVwEfAJrN7OtZL9UTrLc158ST+W2pLG2oBGB/zxBrmxvy8pkiIlN1srW/9gFbgWsINtLK6AP+fKYqVczyuZ8KwJIwqLT3DuXl80REpuOEQcXdnweeN7Pvh3ufZDbZWuHu3fmoYLGJJ4PcRr5aKgtrK4iUGft7BvPyeSIi0zHRO+NDZlZvZvOB54Fvm9k/zGC9ilampZKvnEqkzFhcV8H+HuVURKT4TTSoNLh7L/Ah4Nvu/g6CHRznnHyv/QVBF9j+XrVURKT4TfTOGDWzpcAfAD+bwfoUvczor3zNU4EgqLT3KKciIsVvonfGLwIPAq+7+9Nmdiqwc+aqVbwSqTTRMqOsLD/dXwBL6qvY3zNEsIuyiEjxmtDOj+7+L8C/ZD3fBfyHmapUMUukPK9dXxAMKx6Ip+gbTlJfWZ7XzxYRmYyJzqhfbmY/MbMOMztgZj8ys+UzXbliFE+m85akz1iSNVdFRKSYTfRP7m8D9wPLgGbgX8OyOSeRSudtjkpGZgKk8ioiUuwmendscvdvu3sy/LkTaJrBehWtRCqd9+6vxfWZlopGgIlIcZvo3fGgmX3czCLhz8eBQ1P9UDNrNLN7zewVM9thZpeY2Xwze8jMdoa/54XHmpl93cxazewFM7sg6zybwuN3mtmmqdZnMgqRU8kEFbVURKTYTfTu+CmC4cT7gXbgw8Anp/G5/wj8wt3PAM4FdgA3AQ+7ewvwcPgc4CqgJfy5AfgmQDgR8xbgImA9cEsmEM2keCr/OZVYtIyFtRUc0FItIlLkJhpUvgRscvcmd19EEGT+diofaGb1wLuB2wHcPe7uh4GNwF3hYXcB14aPNwLf8cBTQGM4Z+ZK4CF37wqXjHkI2DCVOk1GIpn/7i8I8ipqqYhIsZvo3fGc7LW+3L0LOH+Kn3kq0Emw1MuzZvYtM6sBFrt7e3j+dmBReHwzsCfr/W1h2XjlM6oQiXoIusA0+ktEit1E745l2V1LYdfThOa4jCEKXAB8093PB/o52tU1lrH6mvwE5cefwOwGM9tqZls7OzsnW99RCpFTAbVURKQ0TPTu+L+AJ8zsS2b2ReAJ4P+d4me2AW3uvjl8fi9BkDkQdmsR/u7IOn5F1vuXEyzJP175cdz9Nndf5+7rmpqmN2itEDkVCOaq9AwmGNQOkCJSxCYUVNz9OwQz6A8QdF19yN2/O5UPdPf9wB4zWxMWXQG8TDAPJjOCaxNwX/j4fuAT4Siwi4GesHvsQeD9ZjYvbEW9PyybUYUYUgxZm3UpWS8iRWzCXVju/jLBzT8X/hT4npnFgF0EI8nKgB+a2fXAW8BHwmMfINh9shUYCI/F3bvM7EvA0+FxXwxzPTMqkUrndTHJjCUjw4oHWb2wJu+fLyIyEVPNi0yLuz8HrBvjpSvGONaBG8c5zx3AHbmt3YklkoXJqWipFhEpBfm/O5a4RCpNeQFGfy1R95eIlAAFlUkqVKK+OhaloapcLRURKWoKKpNUqJwKBHkVDSsWkWKmoDJJhZqnAuG2wgoqIlLEFFQmqVDLtIAmQIpI8VNQmaR4Kk15NP85FQhaKof6h4kn0wX5fBGRk1FQmaRC51Tc0WrFIlK0FFQmIZV20k7Bur8Wh8OKO/qGC/L5IiIno6AyCYlU0O1UsKBSFwQVtVREpFgpqExCfCSoFC6nAgoqIlK8FFQmIREmyAuxnwrAvOpyyiPGgV51f4lIcVJQmYREKtiupVDdX2bGorpKOtRSEZEipaAyCYXOqQAsrq/gQJ+CiogUJwWVSSh0TgWCbYXV/SUixUpBZRIyLZVCzVOBTFBRS0VEipOCyiQkkoXNqQAsqq+gbyjJQDxZsDqIiIxHQWUSRrq/CjT6C7LnqqgLTESKj4LKJCSKIKeiuSoiUswUVCahOHIqFYCCiogUJwWVSSiGIcWL6sP1v9T9JSJFSEFlEuJhor5QM+oB6iqiVJVH1FIRkaJUsLujmUXM7Fkz+1n4fLWZbTaznWb2AzOLheUV4fPW8PVVWee4OSx/1cyunOk6F0NLxczCCZBqqYhI8SlkS+WzwI6s518BvuruLUA3cH1Yfj3Q7e6nA18Nj8PMzgKuA84GNgD/ZGaRmaxwMeRUIOgCO6AdIEWkCBXk7mhmy4EPAt8KnxtwOXBveMhdwLXh443hc8LXrwiP3wjc4+7D7r4baAXWz2S9R1oqBdr5MWNxfaWWahGRolSoP7m/BnwOyOyLuwA47O6ZGX1tQHP4uBnYAxC+3hMeP1I+xntmRLzAC0pmLK6r4EDvEO5e0HqIiBwr73dHM7sa6HD3Z7KLxzjUT/Laid5z7GfeYGZbzWxrZ2fnpOqbLbP0faGDypKGSoYSaXqHNKteRIpLIe6O7wKuMbM3gHsIur2+BjSaWTQ8ZjmwL3zcBqwACF9vALqyy8d4zyjufpu7r3P3dU1NTVOueDHlVAAtgS8iRSfvd0d3v9ndl7v7KoJE+yPu/jHgUeDD4WGbgPvCx/eHzwlff8SDfp/7gevC0WGrgRZgy0zWvRhm1EPQ/QVaqkVEik/05IfkzV8D95jZ3wHPAreH5bcD3zWzVoIWynUA7v6Smf0QeBlIAje6e2omKxhPOWYQKSt8oh40q15Eik9Bg4q7/wr4Vfh4F2OM3nL3IeAj47z/VuDWmavhaIlUmvJIGcHgs8JZFC7Vsl9BRUSKjGbUT0IimS54PgWgOhalrjKqnIqIFJ3C3yFLSDyVLng+JUM7QIpIMVJQmYRM91cxWKIJkCJShIrjDlki4kkvmqCyqL5CKxWLSNEpjjtkiUik0gVdoTjb4vpKOvqGSKc1q15Eikdx3CFLRKKYcip1FSRSTvdAvNBVEREZoaAyCUWVU2moAqCte7DANREROao47pAlIp4qnpzKOcsbANj6ZneBayIiclRx3CFLRLHMUwFY1ljFivlVbNl9qNBVEREZURx3yBKRSKULvpdKtotWL2DL7i4l60WkaCioTEIx5VQALlo9n+6BBK2dRwpdFRERQEFlUooppwJBSwVg8y51gYlIcSieO2QJSKSKJ6cCsGJ+FUsbKnlqd1ehqyIiAiioTEoxzVMBMDPWr57Plt1d2lpYRIqCgsokJJLFlVOBoAuss2+Y3Qf7C10VEREFlcmIp5zyIlmmJWP96vkAbFEXmIgUgeK6Qxa5YsupAJzWVMPC2hibFVREpAgU1x2yyBVbTgVG51VERApNQWUSim2eSsZFqxew9/Age7oGCl0VEZnjiu8OWaTcnUSRzVPJeNfpCwF45JWOAtdEROa64rtDFqlEKhiyWyz7qWQ7fVEtpy+q5efb2wtdFRGZ4/J+hzSzFWb2qJntMLOXzOyzYfl8M3vIzHaGv+eF5WZmXzezVjN7wcwuyDrXpvD4nWa2aSbrnUilAYoup5Jx1dolbNndxaEj2g1SRAqnEH92J4G/dPczgYuBG83sLOAm4GF3bwEeDp8DXAW0hD83AN+EIAgBtwAXAeuBWzKBaCYcDSrF11IB2LB2CWmHf3/5QKGrIiJzWN7vkO7e7u7bwsd9wA6gGdgI3BUedhdwbfh4I/AdDzwFNJrZUuBK4CF373L3buAhYMNM1Tte5EHlrKX1rJxfzc+37y90VURkDivoHdLMVgHnA5uBxe7eDkHgARaFhzUDe7Le1haWjVc+I0ZyKkUaVMyMq9Yu4YnWg/QMJApdHRGZowp2hzSzWuBHwJ+5e++JDh2jzE9QPtZn3WBmW81sa2dn5+QrS7BECxRnoj5jw9olJNPOL3eoC0xECqMgd0gzKycIKN9z9x+HxQfCbi3C35nxsW3Aiqy3Lwf2naD8OO5+m7uvc/d1TU1NU6pzsedUAM5d3sjShkp1gYlIwRRi9JcBtwM73P0fsl66H8iM4NoE3JdV/olwFNjFQE/YPfYg8H4zmxcm6N8fls2IeJGP/gIoKzOuPHsJj+3s5MhwstDVEZE5qBB/dr8L+CPgcjN7Lvz5APBl4H1mthN4X/gc4AFgF9AK/H/AfwFw9y7gS8DT4c8Xw7IZkcmpFNuCksf6wNuXEk+meVhdYCJSANF8f6C7/5ax8yEAV4xxvAM3jnOuO4A7cle78WW6v4o1UZ+x7pR5NDdW8ZNn97LxvBkbtyAiMqbivkMWkUyivphzKhB0gW08bxm/2XmQzj5NhBSR/CruO2QRKYWcSsbvn99MKu386/NjjlsQEZkxCioTNJJTKfKWCkDL4jrWNtfzk2f3FroqIjLHFP8dskiM5FSKPFGf8fvnL+fFvT20dvQVuioiMoeUxh2yCJTCPJVs15y7jEiZqbUiInlVGnfIIhBPlk5OBaCproJLT1/IT5/dRzyZZn/PEK8d6COVHnPRARGRnMj7kOJSVexrf43lQxc089l7nmPN53+Oh7HknOUNfGnjWs5d0VjYyonIrKSgMkGl1v0FwVpgN77nNCJmNNVXkk4733i0lWv/6XGuu3AF15zbTMviWhbWVhS6qiIySyioTNBIUCmRRD1ARTTCX115xqiyD13QzD/+cifffuIN7t4SLPK8oCbGn723hT+6ZFUBaikis4mCygSV0jyVE6mrLOdvrj6LP/7d03hlfy87Dxzh4VcO8Pn7XqKte5C/3nAGZWWlfY0iUjgKKhOUSIbzVMpKp6VyIk11FTTVNfE7LU1seucq/vb+l/jnx3axr2eIv3jf22isKqe+qpxEKk3vYILeoQSL6iuprywvdNVFpIgpqExQIpUmWmaz8q/4SJnxxY1ns6yxiq/84pVxZ+KbBTtMrl89n5ZFdSyojbGwNoY79Awm6BlMMK86xvkrG2msjgHBqLmdHX3UxKKsWliTz8sSkQJQUJmgRCpdUkn6yTIz/uSy03jX6Qto7TgyEiTKI2U0VJVTVxllV2c/W3Z3cfeWtxhKpE94vtOaaqiIRtjZ0Tcycu7iU+fzsYtO4W2L69i8+xBPvn6IQ/1xTmuqpWVRLfNrYnT2DXOgd4jhZJrl86o4ZUE1SxuqqKuMUlsRZTiZZsvuLrbs7mJfzyBXn7OUa85tpioW4ZX9vfzvR1p5ZEcHV5y5iE++azUXrGykdzDJb1o7eXFvD1ecsZgLV80j2IFBRHLN3OfWvIV169b51q1bJ/2+L/zrS/zomTZe+NsrZ6BWpSWRSnPoSJyDR4Y51B8HoKGqnPrKKAd6h9n2VjfPvNlNMu2cvayeM5fW09Y9wPc3v0Vb9+DIeZobq1jSUMnrnUc4nLUFcmV5GbFIGb1D4+8J01BVzrzqct44NEB9ZZS1zQ088fohaiuivOeMRfzq1Q76hpKsnF/N3sODo+bnnLO8gY9ffAo47D7UT/vhQdY2N/DeMxePtKaGEinae4ZkkGgVAAAPNUlEQVRYPq/quD8muvvj1FRES2Z1hWO5O90DCeZVlyu4yoSZ2TPuvu6kxymoTMzf/PRFfrF9P1v/5n0zUKu5IZ12ftN6kI7eIS5avYAV86swM9ydQ/1xDg/EWVRfSV1FFDOjZzDBnq4B2nuG6B9Ojmw8dsHKeZyxpA4zePqNbr771Jtse7Ob/3BBM5+6dDWN1TH6h5P8eFsbD7/SwdplDbznjCbWLKnnp8/u5Y7f7mbXwX4AomXGgtoYB3qDFZ1XLagmkXL29QziDkvqK/mjS07ho+tX8kp7L3c8/gYPv3KAZQ1VfG7DGn7vnGUjXaLptM9o9+jjrQd57LVOPn356dRl5ba6+uNs3nWIlQuqOa2plopoGbsP9vP0G1281TXAe9Ys4h2nBK2zHe293PpvO/ht60HWNtfzyXeu5upzl1IRjZBIpRlMpJQ3kzEpqIxjqkHlr+99gcd2dvLkzcdt+SIlJp12tu/robEqxrLGSqKRMvZ0DfDLHQd4vPUgtRVB/qeproKfv7if37YepMwg7TC/JsaH37Gcx1sP8tK+Xt7e3MDpi2p5ZX8fr3ccoWVxLX915Rp+921NmBld/XEeeLGdqvIIHzxnKZXlkZF69A8nSbkfdxMfjKdIpNOjyn+xfT9/evc2EinnlAXV/O+Pns/bmxu477l9fOFfX6I7bOlFyozaiig9g4lR5zxlQTVnLqnnwZf3U19Zzh+sW86jr3bS2nGE+sqjQRzg985dxv+4+iya6jR/SY5SUBnHVIPKX/zgOba+2c1jn3vPDNRKitmr+/v48bY2Tm2qYeN5zVSWR0innfue38vXfrmTeDLNmiV1nLqwlod27GdP1yAXrZ5PfVU5j77SQTLseptfE+M/rl/J4voKfrmjgydfP0QynWbdKfO5/MxF1FZEeeSVDh5vPYh7MKfohnefyvZ9vfz5D57jnOUNfObyFv77T16k88gwb29uYNtbhzlvRSOfu3INXQNxXt3fR2ffMOcsb2T96vksrq/gwZcO8JNn23jurcNct34lf3r56TRWx3B3frPzID97YR+V5REW1FTQH09y5+NvUBWL8F+vXEPEjC27D/Fyey/vO2sxn35PC1WxIDB29A1x7zNtnNPcyKUtC0f+vQbjKb63+U3qK8u55rxlowLpWLr74/zfX7/OQDzFJy45hZbFdQAMJ1P8+tVOhpNprjx7yYS6G3cf7Oe5Pd0AlJkRi5RRX1VOfWU5C2pjLKmvnJWDbfJBQWUcUw0qn/7+Nna09/LwX16W+0rJrBFPprnn6bf4+sOtmAV72/z++c1098dHus7cg2629521mMryCI+80sFL+3oBWDG/iivOWEwilebeZ9pG5kdduGo+d/w/F1JbEeXwQJzP3fsCv209yF9duYZPXLKKSA5vlK93HuHmH7/Ilt3B7twLays4dWENW97oormxipuuOoMX9/bwnSffGBmw8XvnLuPzHzyT7ft6+B/hnCeAxupyrrtwJY3V5Wx9o4ttbx2mvjLKlWuXsOHsJTy35zBf++VO+oaCQSHDyTSXrWliaUMVD7zYPtJ6WlJfyfWXruadpy9g+94etr15mM4jw6ycX83K+dUMJ9P824v72L6394TXVh2L0LKoltMX1bFqQTUrF1TT3FhFZXmEWDTI5c2riY203orNUCLFc3sOs2V3F+09Q1REy6gsj1BXGWVxfSVLGypZWFtBdSxCVSyCOxzoHaK9Z4iOviE+dtEpU/5sBZVxTDWo/PF3t/LmoQF+8WfvnoFayWzj7rhz3F/Few8PMpRIcerCmlE3rfaeQQbjKVZnlR88Msydj79BZ98wf3vN2SMthIyZHJGYTjtPv9HFovpKVi2oxsx4atchPv/T7ezsOEKZwbXnNfOfLzuNn7+4n2/8qhUIgurpi2r50sa1ANz5xG4eevkAaYdTF9ZwwSnz6Ogb5onWgyMtuN9pWcjffDDobvveU29y15Nv0j+cZMPaJWw8bxkA//zrXTy569BI/Rqry1lSX0lb9+BIru28FY383rnLeHfLQsojZaTciSeDeVY9gwk6+oZp7TjCawf6aO04QscJdkYtjxjza2IsqKlgYV0FC2tjLKiJ0Vgd/F7SUMnyeVU01QUDTba92c32vT0sqq/kvBWNvL25gcMDCV5u7+GV/X00N1bxvrMWc8qCYCBId3+c59sOU19VzjnNDUTD73EokWLbm90cDofnz6spp7NvmC27u9i8q4vn9hwmnkpjBgtqKhhOphhOpEf++DiZ7V+4ktqKqQ36VVAZx1SDyqfufJqDR4a5/9OXzkCtREpDIpXmoZcP8LbFdZy+qHak/I2D/fyvh17jzKV1/KdLTx3VVdXRN0SZ2ag15noGEjzy6gEW1garaWcH2GQqTcqdiujoIPpC22F2dfZzzvKGkeCbGeSRSjuL6ysndS1DiRRt3QPsPTzEcCJFIuUMJVJ0D8Q51B/nYF8wuvHgkWEO9g3TPZBgMJEa93yL6yvo7k8cd4OviAYtMAiG2qfSzhuHBkZer6uIctGp80eGy2eOzRYpM9YuC+aIXbR6AReumk9D9dGc22A8xYHeIfb3DnHoSJyBeJLBRAp3RlowmVbMVLv/FFTGMdWg8vFvbWYwkeJHf/LOGaiViJSCwXiKroE47YcH2Xt4kP09Q6ycX80Fp8xjcX0l8WSaHe29vLi3h3nVMc5eVs/K+dW0dQ/y8CsHePTVTiqjZZy/ch7nrmiguz/Bb1sP8uTrB6mIRnjX6Qu5tGUBS+qrODwQp3sgQV1llAtOmTflFkauzJmgYmYbgH8EIsC33P3LJzp+qkHlD/75ScoM7rnhkqlVVESkhE00qJTm7K2QmUWAbwBXAWcBHzWzs2bis2b7jHoRkVwo9bvkeqDV3Xe5exy4B9g4Ex+USKVLaoMuEZFCKPW7ZDOwJ+t5W1iWc4mkq6UiInISpb6g5FjDGI5LEpnZDcANACtXrpzSB13aspClDZMbXSIiMteUelBpA1ZkPV8OHLduu7vfBtwGQaJ+Kh/0+atnJFUjIjKrlHp/ztNAi5mtNrMYcB1wf4HrJCIyZ5V0S8Xdk2b2aeBBgiHFd7j7SwWulojInFXSQQXA3R8AHih0PUREpPS7v0REpIgoqIiISM4oqIiISM4oqIiISM4oqIiISM6U/CrFk2VmncCbU3z7QuBgDqtTCnTNc8Ncu+a5dr0w/Ws+xd2bTnbQnAsq02FmWyey9PNsomueG+baNc+164X8XbO6v0REJGcUVEREJGcUVCbntkJXoAB0zXPDXLvmuXa9kKdrVk5FRERyRi0VERHJGQWVCTCzDWb2qpm1mtlNha7PTDCzFWb2qJntMLOXzOyzYfl8M3vIzHaGv+cVuq65ZmYRM3vWzH4WPl9tZpvDa/5BuK3CrGFmjWZ2r5m9En7fl8z279nM/jz873q7md1tZpWz7Xs2szvMrMPMtmeVjfm9WuDr4T3tBTO7IFf1UFA5CTOLAN8ArgLOAj5qZrNxx64k8JfufiZwMXBjeJ03AQ+7ewvwcPh8tvkssCPr+VeAr4bX3A1cX5BazZx/BH7h7mcA5xJc+6z9ns2sGfgMsM7d1xJsk3Eds+97vhPYcEzZeN/rVUBL+HMD8M1cVUJB5eTWA63uvsvd48A9wMYC1ynn3L3d3beFj/sIbjTNBNd6V3jYXcC1hanhzDCz5cAHgW+Fzw24HLg3PGRWXbOZ1QPvBm4HcPe4ux9mln/PBNt8VJlZFKgG2pll37O7PwZ0HVM83ve6EfiOB54CGs1saS7qoaBycs3AnqznbWHZrGVmq4Dzgc3AYndvhyDwAIsKV7MZ8TXgc0A6fL4AOOzuyfD5bPu+TwU6gW+HXX7fMrMaZvH37O57gf8JvEUQTHqAZ5jd33PGeN/rjN3XFFROzsYom7VD5sysFvgR8Gfu3lvo+swkM7sa6HD3Z7KLxzh0Nn3fUeAC4Jvufj7Qzyzq6hpLmEfYCKwGlgE1BN0/x5pN3/PJzNh/5woqJ9cGrMh6vhzYV6C6zCgzKycIKN9z9x+HxQcyzeLwd0eh6jcD3gVcY2ZvEHRrXk7QcmkMu0lg9n3fbUCbu28On99LEGRm8/f8XmC3u3e6ewL4MfBOZvf3nDHe9zpj9zUFlZN7GmgJR4rECBJ89xe4TjkX5hJuB3a4+z9kvXQ/sCl8vAm4L991mynufrO7L3f3VQTf6yPu/jHgUeDD4WGz7Zr3A3vMbE1YdAXwMrP4eybo9rrYzKrD/84z1zxrv+cs432v9wOfCEeBXQz0ZLrJpkuTHyfAzD5A8BdsBLjD3W8tcJVyzswuBX4DvMjR/MJ/I8ir/BBYSfA/50fc/dhkYMkzs8uA/+ruV5vZqQQtl/nAs8DH3X24kPXLJTM7j2BgQgzYBXyS4A/MWfs9m9kXgD8kGOX4LPCfCHIIs+Z7NrO7gcsIViM+ANwC/JQxvtcwuP4fgtFiA8An3X1rTuqhoCIiIrmi7i8REckZBRUREckZBRUREckZBRUREckZBRUREckZBRWRKTKzJ8Lfq8zsP+b43P9trM8SKXYaUiwyTdlzXCbxnoi7p07w+hF3r81F/UTySS0VkSkysyPhwy8Dv2Nmz4X7dkTM7O/N7Olwr4o/Do+/LNyz5vsEk0wxs5+a2TPhXh83hGVfJlhR9zkz+172Z4UzoP8+3BfkRTP7w6xz/yprn5TvhRPcRPIqevJDROQkbiKrpRIGhx53v9DMKoDHzezfw2PXA2vdfXf4/FPhDOcq4Gkz+5G732Rmn3b388b4rA8B5xHsg7IwfM9j4WvnA2cTrOH0OMHaZr/N/eWKjE8tFZHcez/BukrPESxzs4BgMySALVkBBeAzZvY88BTBAn8tnNilwN3unnL3A8CvgQuzzt3m7mngOWBVTq5GZBLUUhHJPQP+1N0fHFUY5F76j3n+XuASdx8ws18BlRM493iy161Kof+/pQDUUhGZvj6gLuv5g8CfhFsJYGZvCzfCOlYD0B0GlDMItnHOSGTef4zHgD8M8zZNBLs4bsnJVYjkgP6SEZm+F4Bk2I11J8Ee8KuAbWGyvJOxt6r9BfCfzewF4FWCLrCM24AXzGxbuBx/xk+AS4DnCTZV+py77w+DkkjBaUixiIjkjLq/REQkZxRUREQkZxRUREQkZxRUREQkZxRUREQkZxRUREQkZxRUREQkZxRUREQkZ/5/jkbDiJ/mokAAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<matplotlib.figure.Figure at 0x1a21356790>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p3r914rXKxHd",
        "colab_type": "text"
      },
      "source": [
        "# Predict with X_test"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BFg0lazEKxHe",
        "colab_type": "code",
        "colab": {},
        "outputId": "0226c8fa-41cc-4753-ef3b-7f8374457b18"
      },
      "source": [
        "score = predict(X_test, predtheta)\n",
        "print(\"after\", score[0:10])\n",
        "print(\"Correct\", T_test[0:10])\n",
        "print(\"accurate:\", float(np.sum(score==T_test))/len(T_test))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "after [4 0 6 4 3 5 7 2 2 6]\n",
            "Correct [4 0 6 4 3 5 7 2 2 6]\n",
            "accurate: 0.933333333333\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JVDubWCAKxHf",
        "colab_type": "text"
      },
      "source": [
        "# Class version"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NLFhLQ01KxHf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Softmax_Regression(object):\n",
        "    \n",
        "    def __init__(self, X, label, n_class = 2):\n",
        "        self.X = X\n",
        "        self.num = X.shape[0]\n",
        "        self.feature = X.shape[1]\n",
        "        self.label = label\n",
        "        self.n_class = n_class\n",
        "        \n",
        "        \n",
        "    def softmax(self, z):\n",
        "        e = np.exp(z - np.max(z))\n",
        "        return np.maximum(1e-5, e/np.sum(e))\n",
        "    \n",
        "    def initialize(self):\n",
        "        self.theta = np.random.randn(self.feature, self.n_class)\n",
        "    \n",
        "    \n",
        "    def loss_function(self):\n",
        "        J = 0\n",
        "        z = np.dot(self.X, self.theta)\n",
        "        for i in range(self.num):\n",
        "            for k in range(self.n_class):\n",
        "                if self.label[i] == k:\n",
        "                    J = J - np.log(self.softmax(z[i])[k])\n",
        "                else:\n",
        "                    J = J - 0\n",
        "        return J\n",
        "\n",
        "\n",
        "    def gradient_k(self, k):\n",
        "        z = np.dot(self.X, self.theta)\n",
        "        grad = np.zeros_like(self.theta[:,k])\n",
        "        for i in range(self.num):\n",
        "            if self.label[i] == k:\n",
        "                grad = grad - self.X[i]*(1 - self.softmax(z[i])[k])\n",
        "            else:\n",
        "                grad = grad + self.X[i]*self.softmax(z[i])[k]\n",
        "        return grad\n",
        "\n",
        "\n",
        "    def update(self, eta = 0.01, max_iter = 100):\n",
        "        self.loss_cost = [0]\n",
        "        for i in range(max_iter):\n",
        "            tmp_theta = np.copy(self.theta)\n",
        "            for k in range(self.n_class):\n",
        "                tmp_theta[:,k] = tmp_theta[:,k] - eta*self.gradient_k(k)\n",
        "            self.theta = tmp_theta\n",
        "            self.loss_cost.append(self.loss_function())\n",
        "            if abs(self.loss_function() - self.loss_cost[i]) < 1e-5:\n",
        "                print(\"convege, {}:iter\".format(i))\n",
        "                break\n",
        "        print \"unconverge\"\n",
        "\n",
        "\n",
        "    def predict(self, X, label):\n",
        "        Z = np.dot(X, self.theta)\n",
        "        predict_label =  np.argmax(np.apply_along_axis(self.softmax, 1, Z), axis = 1)\n",
        "        print(\"after\", predict_label)\n",
        "        print(\"Correct\", label)\n",
        "        print(\"accurate:\", float(np.sum(predict_label == label))/len(label))\n",
        "        \n",
        "    def costplot(self):\n",
        "        plt.figure(figsize = (6,6))\n",
        "        plt.plot(range(len(self.loss_cost)), self.loss_cost)\n",
        "        plt.xlabel(\"iteration\")\n",
        "        plt.ylabel(\"cost\")\n",
        "        \n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZCp_wcoyKxHg",
        "colab_type": "code",
        "colab": {},
        "outputId": "d29edbad-9110-44cb-bd4f-5ddce2833d31"
      },
      "source": [
        "sr = Softmax_Regression(X_train, T_train, n_class = 10)\n",
        "sr.initialize()\n",
        "sr.update()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "unconverge\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V6W_fvZZKxHh",
        "colab_type": "code",
        "colab": {},
        "outputId": "6d04f47a-ccad-45f0-c712-0e3154ede0db"
      },
      "source": [
        "sr.predict(X_train, T_train)\n",
        "sr.costplot()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "after [1 0 4 ... 6 6 4]\n",
            "Correct [1 0 4 ... 6 6 4]\n",
            "accurate: 0.981906750174\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<matplotlib.figure.Figure at 0x1a211a7990>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j7M5tmjGKxHp",
        "colab_type": "code",
        "colab": {},
        "outputId": "85348a60-ad91-4643-be72-51226cafcb26"
      },
      "source": [
        "from sklearn.datasets import load_iris\n",
        "iris = load_iris()\n",
        "print(iris.data.shape, iris.target.shape)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(150, 4) (150,)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wLPTo-orKxHq",
        "colab_type": "code",
        "colab": {},
        "outputId": "f5ec0a29-daa8-435a-d07e-755494756a69"
      },
      "source": [
        "pca.fit(iris.data)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "PCA(copy=True, iterated_power='auto', n_components=2, random_state=None,\n",
              "  svd_solver='auto', tol=0.0, whiten=False)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 100
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A8HSF23MKxHr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "xd = pca.transform(iris.data)\n",
        "xe = pca.inverse_transform(xd)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wxXdjw6wKxHs",
        "colab_type": "code",
        "colab": {},
        "outputId": "b9a43246-7ca2-4f8d-9fa4-c659f10067a0"
      },
      "source": [
        "plt.figure(figsize = (8,8))\n",
        "for i in range(10):\n",
        "    deco = xd[iris.target == i]\n",
        "    plt.scatter(deco[:,0], deco[:,1])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<matplotlib.figure.Figure at 0x1a1d8597d0>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QsnQP_JNKxHt",
        "colab_type": "code",
        "colab": {},
        "outputId": "b5972690-a8a4-4a37-ceda-10c7a043e774"
      },
      "source": [
        "Sr = Softmax_Regression(xd, iris.target, n_class = 3)\n",
        "Sr.initialize()\n",
        "Sr.update()\n",
        "Sr.predict(xd, iris.target)\n",
        "Sr.costplot()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "unconverge\n",
            "after [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
            " 0 0 0 0 0 0 0 0 0 0 0 0 0 2 2 2 1 2 1 2 1 2 1 1 2 1 2 1 2 2 1 1 1 2 2 2 2\n",
            " 2 2 2 2 2 1 1 1 1 2 1 2 2 2 1 1 1 2 1 1 1 1 1 2 1 1 2 2 2 2 2 2 1 2 2 2 2\n",
            " 2 2 1 2 2 2 2 2 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2\n",
            " 2 2]\n",
            "Correct [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
            " 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
            " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2\n",
            " 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2\n",
            " 2 2]\n",
            "accurate: 0.813333333333\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<matplotlib.figure.Figure at 0x1a1d3b5650>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nfet7cnEKxHv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}