Final Notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Bayes Classifier (Gaussian with MLE Estimate)\n",
    "2. Naive Bayes Classifier (Gaussian, Binomial and GMM with MLE Estimate)\n",
    "3. K-means Clustering\n",
    "4. K-Nearest Neighbor Classifier\n",
    "5. Principal component analysis \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ## Bayes Methods Implemented :\n",
    "\n",
    "1. MLE - Done with Gaussian \n",
    "2. Expectation Maximization with GMM \n",
    " \n",
    "## Densities implemented :\n",
    "1. GMM\n",
    "2. Gaussian\n",
    "3. Binomial and Bernoulli"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import json\n",
    "import random\n",
    "import time\n",
    "import math\n",
    "from ast import literal_eval as make_tuple\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import psutil\n",
    "from utils import mnist_reader\n",
    "import pdb\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'divide': 'warn', 'invalid': 'warn', 'over': 'warn', 'under': 'ignore'}"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.seterr(divide='ignore', invalid='ignore')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class multivariate_normal:\n",
    "    def __init__(self,mean,cov):\n",
    "        self.mean=mean\n",
    "        self.cov=cov\n",
    "    def pdf(self,x):\n",
    "        return  (1/(np.power(2* np.pi,self.mean.shape[0]/2)*np.power(np.linalg.det(self.cov),0.5))) *np.exp (-0.5 * (np.linalg.multi_dot([(x - self.mean) , (np.linalg.inv(self.cov)), (x - self.mean).T])))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def univariate_normal(x,mean,var):\n",
    "    return  (1/(np.power(2* np.pi*var,0.5))) * np.exp(-0.5 * np.array((x- mean)**2/var,dtype='float'))\n",
    "def distance(a, b):\n",
    "    return np.linalg.norm(a-b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def binomial(test,prob,m):\n",
    "    return [np.power(prob,x)*np.power(prob,(m-x))*comb(m,x) for x in test]\n",
    "def comb(n,r):\n",
    "    f=math.factorial\n",
    "    return f(n)//f(r)//f(n-r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Bayes Gaussian with MLE Estimate    \n",
    "class GaussianBayes:         \n",
    "    def predict(self,test):\n",
    "        prob_vect = np.zeros((self.n_classes,test.shape[0]))\n",
    "        for i in range(self.n_classes):        \n",
    "            class_cond = multivariate_normal(self.mean[i,:],self.cov[i,:])\n",
    "            prior=self.prior[i]         \n",
    "            for j in range(test.shape[0]):\n",
    "                prob_vect[i,j] = prior*class_cond.pdf(test[j])       \n",
    "        return np.argmax(prob_vect,axis=0), prob_vect.T\n",
    "    def fit(self, train,y):\n",
    "        self.mean = []\n",
    "        self.cov = []\n",
    "        self.n_classes = np.max(y)+1\n",
    "        self.prior = np.zeros(self.n_classes) \n",
    "        for i in range(self.n_classes):\n",
    "            tr_c  = train[y==i]\n",
    "            self.prior[i]=tr_c.shape[0]/train.shape[0]\n",
    "            mean_c = np.mean(tr_c, axis=0)\n",
    "            cov_c=np.cov(tr_c.T.astype(float))\n",
    "            self.mean.append(mean_c)\n",
    "            self.cov.append(cov_c)\n",
    "        self.mean = np.asarray(self.mean)\n",
    "        self.cov = np.asarray(self.cov)        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (<ipython-input-14-066a68a17916>, line 31)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-14-066a68a17916>\"\u001b[0;36m, line \u001b[0;32m31\u001b[0m\n\u001b[0;31m    def updateparams(self,train,y):\u001b[0m\n\u001b[0m      ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "#Naive Bayes Implementation of GMM with EM Algorithm\n",
    "class GMM():\n",
    "    def __init__(self,mode):\n",
    "        mean=np.zeros(mode)\n",
    "        var=np.zeros(mode)\n",
    "        ltv = np.identity(ltv)\n",
    "        w = np.tile(z,(int)(Y.size/k) + 1).T\n",
    "        w = w[0:Y.size] \n",
    "        params={'mean':mean,'var':var,'ltv':ltv}\n",
    "        self.mode=mode\n",
    "        self.w=w\n",
    "        self.params=params\n",
    "        \n",
    "    def fit(self, train,y,iter_n=1000,*args):\n",
    "        iterations=0\n",
    "        while (iterations<iter_n):\n",
    "            # E-step \n",
    "            w_old = w_new\n",
    "            self.computew(train)\n",
    "            # new params mean, variance and latent variables\n",
    "            # M-step \n",
    "            self.updateparams(train)   \n",
    "            iterations+=1\n",
    "            \n",
    "    \n",
    "    def computew(self,train):\n",
    "        self.w=\n",
    "    \n",
    "    def updateparams(self,train):\n",
    "        p = np.mean(self.w,axis = 0)\n",
    "        for i in range(k):\n",
    "            self.params['mean'][i]=np.dot(train, self.w[i])/(p[i])\n",
    "            self.params['var'][i]=np.dot(self.w[i],(train-self.params['mean'][i])^2)/p[i]\n",
    "        self.params['ltv']=np.mean(Q,axis=0)\n",
    "        \n",
    "    def pdf(self,test,mean,var,w):\n",
    "        sum1=0\n",
    "        for i in range(k):\n",
    "            sum1+=w[k]*(1/(np.power(2* np.pi*var[k],0.5))) * np.exp(-0.5 * np.array((x- mean[k])**2/var,dtype='float'))  \n",
    "        return sum1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GMMNB:       \n",
    "    def predict(self,test):\n",
    "        prob_vect = np.zeros((self.n_classes,test.shape[0]))\n",
    "        for i in range(self.n_classes):\n",
    "            class_cond=1\n",
    "            for j in range(self.n_features):\n",
    "                class_cond = class_cond*GMM.pdf(test[:,j],self.mean[i,j], self.var[i,j])\n",
    "            prior=self.prior[i]         \n",
    "            prob_vect[i,:] = prior*class_cond\n",
    "        print(np.argmax(prob_vect,axis=0).shape)\n",
    "        return np.argmax(prob_vect,axis=0), prob_vect.T\n",
    "        \n",
    "    def fit(self, train,y,k):\n",
    "        self.n_classes = np.max(y)+1\n",
    "        self.prior = np.zeros(self.n_classes) \n",
    "        self.n_features=train.shape[1]\n",
    "        self.mean = np.zeros((self.n_classes,self.n_features,k))\n",
    "        self.var = np.zeros((self.n_classes,self.n_features,k))\n",
    "        for i in range(self.n_classes):\n",
    "            tr_c  = train[y==i]\n",
    "            self.prior[i]=tr_c.shape[0]/train.shape[0]\n",
    "            for j in range(self.n_features):\n",
    "                gmm=GMM(k)\n",
    "                self.mean[i,j,:], self.var[i,j,:],self.weights[i,j,:]=gmm.fit(tr_c[:,j],y[(y==j)])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Naive Bayes of Binomial \n",
    "class BinomialNB:\n",
    "    def __init__(self,n_features):\n",
    "        self.n_features=n_features\n",
    "    def predict(self,test):\n",
    "        prob_vect = np.zeros((self.n_classes,test.shape[0]))\n",
    "        for i in range(self.n_classes):\n",
    "            class_cond=1\n",
    "            for j in range(1,self.n_features):\n",
    "                pdb.set_trace()\n",
    "                class_cond = class_cond*binomial(test[:,j],self.prob[i,j],self.m[j])\n",
    "                prior=self.prior[i]         \n",
    "            prob_vect[i,:] = prior*class_cond       \n",
    "        return np.argmax(prob_vect,axis=1), prob_vect.T\n",
    "        \n",
    "    def fit(self, train,y):\n",
    "        self.n_classes = np.max(y)+1\n",
    "        self.m=np.max(train,axis=0)\n",
    "        self.prior = np.zeros(self.n_classes) \n",
    "        self.prob=np.zeros((self.n_classes,self.n_features))\n",
    "        for i in range(self.n_classes):\n",
    "            tr_c  = train[y==i]\n",
    "            self.prior[i]=tr_c.shape[0]/train.shape[0]\n",
    "            for j in range(self.n_features):\n",
    "                self.prob[i,j]=np.mean(train[:,j])\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Naive Bayes of Gaussian \n",
    "class GaussianNB():\n",
    "    def predict(self,test):\n",
    "        prob_vect = np.zeros((self.n_classes,test.shape[0]))\n",
    "        for i in range(self.n_classes):\n",
    "            class_cond=1\n",
    "            for j in range(self.n_features):\n",
    "                class_cond = class_cond*univariate_normal(test[:,j],self.mean[i,j], self.var[i,j])\n",
    "            prior=self.prior[i]         \n",
    "            prob_vect[i,:] = prior*class_cond\n",
    "#         print(np.argmax(prob_vect,axis=0).shape)\n",
    "        return np.argmax(prob_vect,axis=0), prob_vect.T\n",
    "        \n",
    "    def fit(self, train,y):\n",
    "        self.n_classes = np.max(y)+1\n",
    "        self.prior = np.zeros(self.n_classes) \n",
    "        self.n_features=train.shape[1]\n",
    "        self.mean = np.zeros((self.n_classes,self.n_features))\n",
    "        self.var = np.zeros((self.n_classes,self.n_features))\n",
    "        for i in range(self.n_classes):\n",
    "            tr_c  = train[y==i]\n",
    "            self.prior[i]=tr_c.shape[0]/train.shape[0]\n",
    "            for j in range(self.n_features):\n",
    "                self.mean[i,j]= np.mean(tr_c[:,j])\n",
    "                self.var[i,j]=np.var(tr_c[:,j])\n",
    "        self.mean = np.asarray(self.mean)\n",
    "        self.var = np.asarray(self.var)     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class PCA:\n",
    "    def __init__(self,n_components,*args):\n",
    "        self.n=n_components\n",
    "    def fit_transform(self,X):\n",
    "        return self.fit(X)\n",
    "    def fit(self,copy):\n",
    "        X=copy\n",
    "        self.mean = np.mean(X, axis=0)\n",
    "        X = X-self.mean\n",
    "        C=np.cov(X.T)\n",
    "#         pdb.set_trace()\n",
    "        U, V=np.linalg.eig(C)\n",
    "        self.components=V\n",
    "        return np.dot(X,V)[:,:self.n]\n",
    "   \n",
    "    def transform(self,test):\n",
    "        output = np.dot(test-self.mean, self.components)\n",
    "        return output[:,:self.n]\n",
    "   \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class KNN:\n",
    "    def __init__(self,k,*args):\n",
    "        self.k=k\n",
    "    def fit(self,train,y):\n",
    "        self.train=train\n",
    "        self.y=y\n",
    "    def predict_one(self,test):\n",
    "        distances=np.sum((self.train-test)**2,axis=1)\n",
    "        sorts = distances.argsort()\n",
    "        targets = np.zeros(self.k)\n",
    "        for i in range(self.k):\n",
    "            idx = sorts[i]\n",
    "            targets[i]=(self.y[idx])\n",
    "        targets=np.array(targets,dtype='int')\n",
    "        return np.bincount(targets)\n",
    "        \n",
    "    def predict(self,test):\n",
    "        preds = []\n",
    "        probabs=[]\n",
    "        for i in range(test.shape[0]):\n",
    "            preds.append(np.argmax(self.predict_one(test[i,:])))\n",
    "            probabs.append(self.predict_one(test[i,:])/np.sum(self.predict_one(test[i,:])))\n",
    "        return preds, probabs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class KMeans:\n",
    "    \n",
    "    def __init__(self,k):\n",
    "        self.k=k\n",
    "        \n",
    "    def fit_predict(self,train,epsilon=0.000001,*args):\n",
    "        self.num_features = train.shape[1]\n",
    "        history=[]\n",
    "        self.centers=np.zeros((self.k,self.num_features))\n",
    "        initial = train[:self.k,:]\n",
    "        preds = np.zeros(train.shape[0])\n",
    "        norm = distance(initial,0)\n",
    "        dist_vec=np.zeros(self.k)\n",
    "#         pdb.set_trace()\n",
    "#         print(norm)\n",
    "        iteration = 0\n",
    "        while (norm > epsilon and iteration<500):\n",
    "            iteration += 1\n",
    "            for i in range(train.shape[0]):\n",
    "                for j in range(self.k):\n",
    "                    dist_vec[j] = np.sum((train[i,:]-self.centers[j])**2)\n",
    "#                 print(dist_vec)\n",
    "                preds[i] = np.argmin(dist_vec)\n",
    "            norm=0   \n",
    "            for i in range(self.k):\n",
    "                 if(train[preds==i,:].shape[0]):\n",
    "                    self.centers[i]=np.mean(train[preds==i,:])\n",
    "                    norm += np.sum((train[preds==i,:]-self.centers[i])**2)   \n",
    "#             print(self.centers)\n",
    "#             print(norm)\n",
    "            history.append(self.centers)\n",
    "            iteration+=1\n",
    "        print(norm)\n",
    "        return preds\n",
    "\n",
    "    def predict(self,test):\n",
    "        preds = np.zeros(test.shape[0])\n",
    "        probabs=np.zeros(test.shape[0],self.k)\n",
    "        dist_vec=np.zeros(self.k)\n",
    "        for i in range(test.shape[0]):\n",
    "                for j in range(self.k):\n",
    "                    dist_vec[j] = np.sum((test[i,:]-self.centers[j])**2)\n",
    "                preds[i] = np.argmin(dist_vec)\n",
    "                probabs[i,:]=dist_vec\n",
    "        return preds, probabs\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class ParzenWindow:\n",
    "    \n",
    "    def __init__(self,k):\n",
    "        self.k=k\n",
    "        \n",
    "    def fit_predict(self,train,epsilon=0.000001,*args):\n",
    "        self.num_features = train.shape[1]\n",
    "        history=[]\n",
    "        self.centers=np.zeros((self.k,self.num_features))\n",
    "        initial = train[:self.k,:]\n",
    "        preds = np.zeros(train.shape[0])\n",
    "        norm = distance(initial,0)\n",
    "        dist_vec=np.zeros(self.k)\n",
    "#         pdb.set_trace()\n",
    "#         print(norm)\n",
    "        iteration = 0\n",
    "        while (norm > epsilon and iteration<500):\n",
    "            iteration += 1\n",
    "            for i in range(train.shape[0]):\n",
    "                for j in range(self.k):\n",
    "                    dist_vec[j] = np.sum((train[i,:]-self.centers[j])**2)\n",
    "#                 print(dist_vec)\n",
    "                preds[i] = np.argmin(dist_vec)\n",
    "            norm=0   \n",
    "            for i in range(self.k):\n",
    "                 if(train[preds==i,:].shape[0]):\n",
    "                    self.centers[i]=np.mean(train[preds==i,:])\n",
    "                    norm += np.sum((train[preds==i,:]-self.centers[i])**2)   \n",
    "#             print(self.centers)\n",
    "#             print(norm)\n",
    "            history.append(self.centers)\n",
    "            iteration+=1\n",
    "        print(norm)\n",
    "        return preds\n",
    "\n",
    "    def predict(self,test):\n",
    "        preds = np.zeros(test.shape[0])\n",
    "        dist_vec=np.zeros(self.k)\n",
    "        for i in range(test.shape[0]):\n",
    "                for j in range(self.k):\n",
    "                    dist_vec[j] = np.sum((test[i,:]-self.centers[j])**2)\n",
    "                preds[i] = np.argmin(dist_vec)\n",
    "        return preds\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import label_binarize\n",
    "from sklearn.metrics import roc_curve\n",
    "from scipy import interp\n",
    "class metrics:\n",
    "    def accuracy(self,y,preds):\n",
    "        return np.sum(y==preds)/y.shape[0]\n",
    "    def scores(self,y,preds):\n",
    "        tp = np.sum(y_true == y_pred)\n",
    "        tp_sum=np.bincount(y_true[tp])\n",
    "        pred_sum=np.bincount(y_pred)\n",
    "        true_sum=np.bincount(y_true)\n",
    "        precision = tp_sum/pred_sum\n",
    "        recall = tp_sum/true_sum\n",
    "        f_score = ((2) * precision * recall /\n",
    "                   (precision + recall))\n",
    "        precision = np.average(precision)\n",
    "        recall = np.average(recall)\n",
    "        f_score = np.average(f_score)\n",
    "\n",
    "        return precision, recall, f_score\n",
    "    \n",
    "    def binary_roc_curve(self,y,probs,*args,**kwargs):\n",
    "        y = (y == 1)\n",
    "\n",
    "        desc_score_indices = np.argsort(probs)[::-1]\n",
    "        probs = probs[desc_score_indices]\n",
    "        y = y[desc_score_indices]\n",
    "        distinct_value_indices = np.where(np.diff(probs))[0]\n",
    "        threshold_idxs = np.r_[distinct_value_indices, y.size - 1]\n",
    "\n",
    "        tps = y[threshold_idxs]\n",
    "        fps = 1 + threshold_idxs - tps\n",
    "        thresholds=y[threshold_idxs]\n",
    "        optimal_idxs = np.where(np.r_[True,np.logical_or(np.diff(fps, 2),np.diff(tps, 2)),True])[0]\n",
    "        fps = fps[optimal_idxs]\n",
    "        tps = tps[optimal_idxs]\n",
    "        thresholds = thresholds[optimal_idxs]\n",
    "        print(fps,tps)\n",
    "        fpr = fps / fps[-1]\n",
    "        tpr = tps / tps[-1]\n",
    "\n",
    "        return fpr, tpr, thresholds    \n",
    "        \n",
    "    def multiclass_roc_curve(self,y,y_score,ax,label,*args,**kwargs):\n",
    "        n_classes=y.max()+1\n",
    "        print(n_classes)\n",
    "        y_test = label_binarize(y, classes=np.arange(n_classes))\n",
    "        print(y_test)\n",
    "        fpr = dict()\n",
    "        thresholds=dict()\n",
    "        tpr = dict()\n",
    "        roc_auc = dict()\n",
    "        print(y_test.shape,y_score.shape)\n",
    "        for i in range(n_classes):\n",
    "            fpr[i], tpr[i], _ = roc_curve(y_test[:, i], y_score[:, i])\n",
    "        all_fpr = np.unique(np.concatenate([fpr[i] for i in range(n_classes)]))\n",
    "        mean_tpr = np.zeros_like(all_fpr)\n",
    "        for i in range(n_classes):\n",
    "            mean_tpr += interp(all_fpr, fpr[i], tpr[i])\n",
    "        mean_tpr /= n_classes\n",
    "        fpr[\"macro\"] = all_fpr\n",
    "        tpr[\"macro\"] = mean_tpr\n",
    "        ax.plot(fpr[\"macro\"], tpr[\"macro\"],label=label, linestyle=':', linewidth=4)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "results=metrics()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FASHION-MNIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "DATA_DIR='data/fashion/'\n",
    "train, y_train = mnist_reader.load_mnist(path=DATA_DIR, kind='train')\n",
    "test, y_test = mnist_reader.load_mnist(path=DATA_DIR, kind='t10k')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(60000, 784)\n",
      "(60000, 30)\n"
     ]
    }
   ],
   "source": [
    "# from sklearn.decomposition import PCA\n",
    "print(train.shape)\n",
    "pca=PCA(n_components=30)\n",
    "train=pca.fit_transform(train)\n",
    "print(train.shape)\n",
    "test=pca.transform(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10000, 30)\n"
     ]
    }
   ],
   "source": [
    "print(test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/khushal/anaconda3/lib/python3.6/site-packages/matplotlib/pyplot.py:523: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`).\n",
      "  max_open_warning, RuntimeWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAD8CAYAAABzTgP2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ed5497828>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec9944f98>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n1DEcJEkdw0GS1DEcJEkdw0GS1Pn/7neBfANrfjcAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec98a9be0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAD8CAYAAACGsIhGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec9878978>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAD8CAYAAABkbJM/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\npF7+PxErRZvzspvlAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec9a4e400>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec9798f98>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec97688d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAD8CAYAAACGsIhGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nWEiSugwLSVLX/wKT6+PpOGnRqwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec97403c8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nD7O+3ZjPKoFOAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec9694240>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nDAdJUofhIEnqMBwkSR2GgySp4/8CFNFCbnMTdTEAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec9ab5710>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nkqQew0GS1GM4SJJ6DAdJUo/hIEnq+X9VFHzrD0IdFgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec962e470>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec96032e8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nMRwkSR3DQZLUMRwkSZ3/B0hVwb9D5y3EAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec95cee10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAD8CAYAAABgmUMCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nL7reAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ecc7cb630>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nV+ehwf1UCwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec94dd128>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ndQwHSVLHcJAkdQwHSVLn/wFAvQ+Tz3rIwQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec94a6fd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec947a978>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec93d1390>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAD8CAYAAABthzNFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec939ce48>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngySp8/8BghQRkE803uUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec97ff0b8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nqAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec9345588>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec929e5c0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nJEkdw0GS1DEcJEkdw0GS1DEcJEmd/wNvQWj8+jeR7QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec92730b8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nHCRJHcNBktQxHCRJHcNBktT5/+r1/TUEEZRXAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec92385c0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec91920b8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec9150630>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec912c668>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYkAAAD8CAYAAACCRVh7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSVKXISFJ6vp/g8eGPIHU+6MAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec9103400>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nktQxHCRJHcNBktT5b48SMu1SKSD6AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec90cdeb8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nJEkdw0GS1DEcJEkdw0GS1DEcJEmdfwfkHDSviWNOaQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ec90205c0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i in range(train.shape[1]):\n",
    "    fig=plt.figure()\n",
    "    plt.hist(list(train[:,i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-16-64a7bd919538>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0mclf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;31m#     preds_tr=clf.predict(train)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m     \u001b[0mpreds\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      9\u001b[0m \u001b[0;31m#     acc_tr.append(results.accuracy(y_train, preds_tr))\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[0macc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresults\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maccuracy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpreds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-9-414391c73d12>\u001b[0m in \u001b[0;36mpredict\u001b[0;34m(self, test)\u001b[0m\n\u001b[1;32m     18\u001b[0m         \u001b[0mpreds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 20\u001b[0;31m             \u001b[0mpreds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict_one\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     21\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mpreds\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-9-414391c73d12>\u001b[0m in \u001b[0;36mpredict_one\u001b[0;34m(self, test)\u001b[0m\n\u001b[1;32m      6\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mpredict_one\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtest\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m         \u001b[0mdistances\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mtest\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      9\u001b[0m         \u001b[0msorts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdistances\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margsort\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m         \u001b[0mtargets\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/numpy/core/fromnumeric.py\u001b[0m in \u001b[0;36msum\u001b[0;34m(a, axis, dtype, out, keepdims)\u001b[0m\n\u001b[1;32m   1832\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1833\u001b[0m     return _methods._sum(a, axis=axis, dtype=dtype,\n\u001b[0;32m-> 1834\u001b[0;31m                          out=out, **kwargs)\n\u001b[0m\u001b[1;32m   1835\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1836\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/numpy/core/_methods.py\u001b[0m in \u001b[0;36m_sum\u001b[0;34m(a, axis, dtype, out, keepdims)\u001b[0m\n\u001b[1;32m     30\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     31\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_sum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkeepdims\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 32\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mumr_sum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkeepdims\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     33\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     34\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_prod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkeepdims\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "acc_tr=[]\n",
    "acc=[]\n",
    "x=np.arange(2,10)\n",
    "for i in x:\n",
    "    clf=KNN(i)\n",
    "    clf.fit(train,y_train)\n",
    "#     preds_tr=clf.predict(train)\n",
    "    preds=clf.predict(test)\n",
    "#     acc_tr.append(results.accuracy(y_train, preds_tr))\n",
    "    acc.append(results.accuracy(y_test, preds))\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "fig,ax=plt.subplots()\n",
    "ax.scatter(list(x),acc_tr)\n",
    "ax.scatter(list(x),acc,color='r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x=np.arange(3,150,4)\n",
    "acc_tr=[]\n",
    "acc=[]\n",
    "for i in x:\n",
    "    lab=np.zeros(i)\n",
    "    kmeans = KMeans(i)\n",
    "    preds_tr=kmeans.fit_predict(train)\n",
    "    preds=kmeans.predict(test)\n",
    "    for j in range(i):\n",
    "        if((preds_tr==j).shape[0]):\n",
    "            lab[j]=np.bincount(y_train[(preds_tr==j)]).argmax()  \n",
    "    acc_tr.append(np.sum(y_train==lab[preds_tr])/y_train.shape)\n",
    "    acc.append(np.sum(y_test==lab[preds])/y_test.shape)\n",
    "\n",
    "fig,ax=plt.subplots()\n",
    "ax.scatter(list(x),acc_tr)\n",
    "ax.scatter(list(x),acc,color='r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([5, 2, 1, ..., 8, 1, 7]), array([[  2.33342438e-091,   4.52383987e-100,   1.09600790e-090, ...,\n",
      "          2.78454012e-089,   1.05326475e-089,   1.31826661e-087],\n",
      "       [  8.64003161e-101,   2.38744196e-122,   3.98301190e-091, ...,\n",
      "          2.26554777e-138,   1.96330731e-096,   5.91886283e-100],\n",
      "       [  1.11698320e-098,   6.82794471e-085,   5.36685394e-100, ...,\n",
      "          6.12953081e-120,   1.91600019e-095,   1.38750955e-103],\n",
      "       ..., \n",
      "       [  9.85751793e-094,   3.87113665e-106,   1.18341375e-096, ...,\n",
      "          1.23017466e-103,   4.36609038e-091,   3.29025713e-100],\n",
      "       [  3.93621470e-093,   4.08223063e-087,   7.69669974e-096, ...,\n",
      "          6.27395671e-115,   1.75367945e-093,   9.51821140e-102],\n",
      "       [  1.63985203e-085,   3.85290893e-092,   2.89890127e-085, ...,\n",
      "          1.69356553e-082,   1.08940016e-086,   8.79926189e-088]]))\n",
      "[ 0.7591] [ 0.77198333]\n"
     ]
    }
   ],
   "source": [
    "clf = GaussianNB()\n",
    "clf.fit(train,y_train)\n",
    "preds_tr, probs_tr_gnb=clf.predict(train)\n",
    "preds, probs_gnb=clf.predict(test)\n",
    "acc_tr=np.sum(y_train==preds_tr)/y_train.shape\n",
    "acc=np.sum(y_test==preds)/y_test.shape\n",
    "print(clf.predict(test))\n",
    "print(acc,acc_tr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([7, 2, 1, ..., 8, 1, 5]), array([[  2.80096745e-164,   4.12673085e-132,   9.79216773e-202, ...,\n",
      "          1.08419228e-093,   5.63448637e-141,   8.16847995e-096],\n",
      "       [  0.00000000e+000,   0.00000000e+000,   3.77066092e-072, ...,\n",
      "          2.57058104e-124,   3.78977127e-072,   3.76959407e-279],\n",
      "       [  3.15513093e-143,   3.63883840e-088,   1.72210864e-284, ...,\n",
      "          2.24955235e-096,   6.58787296e-156,   1.47735228e-097],\n",
      "       ..., \n",
      "       [  8.57039471e-078,   0.00000000e+000,   0.00000000e+000, ...,\n",
      "          0.00000000e+000,   0.00000000e+000,   4.46272956e-080],\n",
      "       [  2.58969809e-098,   2.98979419e-132,   2.66605828e-221, ...,\n",
      "          1.27371576e-090,   4.99050909e-181,   1.55248083e-083],\n",
      "       [  3.16600735e-078,   0.00000000e+000,   0.00000000e+000, ...,\n",
      "          4.23237954e-187,   5.49948088e-245,   1.54822036e-084]]))\n",
      "[ 0.7985] [ 0.80108333]\n"
     ]
    }
   ],
   "source": [
    "clf = GaussianBayes()\n",
    "clf.fit(train,y_train)\n",
    "preds_tr, probs_tr_gb=clf.predict(train)\n",
    "preds, probs_gb=clf.predict(test)\n",
    "acc_tr=np.sum(y_train==preds_tr)/y_train.shape\n",
    "acc=np.sum(y_test==preds)/y_test.shape\n",
    "print(clf.predict(test))\n",
    "print(acc,acc_tr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "[[0 0 0 ..., 0 0 1]\n",
      " [0 0 1 ..., 0 0 0]\n",
      " [0 1 0 ..., 0 0 0]\n",
      " ..., \n",
      " [0 0 0 ..., 0 1 0]\n",
      " [0 1 0 ..., 0 0 0]\n",
      " [0 0 0 ..., 0 0 0]]\n",
      "(10000, 10) (10, 10000)\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "Found input variables with inconsistent numbers of samples: [10000, 10]",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-80-128572c81df5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_ylabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'True Positive Rate'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_title\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Receiver operating characteristic -multi-class'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mresults\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmulticlass_roc_curve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_test\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mprobs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'gaussian bayes'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0mresults\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmulticlass_roc_curve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_test\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mprobs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'knn'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mresults\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmulticlass_roc_curve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_test\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mprobs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'kmeans'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-76-e6ba7e3c0e13>\u001b[0m in \u001b[0;36mmulticlass_roc_curve\u001b[0;34m(self, y, y_score, ax, label, *args, **kwargs)\u001b[0m\n\u001b[1;32m     53\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_test\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my_score\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     54\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_classes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m             \u001b[0mfpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mroc_curve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_test\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_score\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m \u001b[0;31m#         fpr[\"micro\"], tpr[\"micro\"], thresholds[\"micro\"] = roc_curve(y_test.ravel(), y_score.ravel())\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     57\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/sklearn/metrics/ranking.py\u001b[0m in \u001b[0;36mroc_curve\u001b[0;34m(y_true, y_score, pos_label, sample_weight, drop_intermediate)\u001b[0m\n\u001b[1;32m    532\u001b[0m     \"\"\"\n\u001b[1;32m    533\u001b[0m     fps, tps, thresholds = _binary_clf_curve(\n\u001b[0;32m--> 534\u001b[0;31m         y_true, y_score, pos_label=pos_label, sample_weight=sample_weight)\n\u001b[0m\u001b[1;32m    535\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    536\u001b[0m     \u001b[0;31m# Attempt to drop thresholds corresponding to points in between and\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/sklearn/metrics/ranking.py\u001b[0m in \u001b[0;36m_binary_clf_curve\u001b[0;34m(y_true, y_score, pos_label, sample_weight)\u001b[0m\n\u001b[1;32m    318\u001b[0m         \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"{0} format is not supported\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_type\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    319\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 320\u001b[0;31m     \u001b[0mcheck_consistent_length\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_true\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_score\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample_weight\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    321\u001b[0m     \u001b[0my_true\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcolumn_or_1d\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_true\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    322\u001b[0m     \u001b[0my_score\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcolumn_or_1d\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_score\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/sklearn/utils/validation.py\u001b[0m in \u001b[0;36mcheck_consistent_length\u001b[0;34m(*arrays)\u001b[0m\n\u001b[1;32m    202\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0muniques\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    203\u001b[0m         raise ValueError(\"Found input variables with inconsistent numbers of\"\n\u001b[0;32m--> 204\u001b[0;31m                          \" samples: %r\" % [int(l) for l in lengths])\n\u001b[0m\u001b[1;32m    205\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    206\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: Found input variables with inconsistent numbers of samples: [10000, 10]"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEWCAYAAAB42tAoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nFGZmVsqJwszMSv0/Z3kODeDQhzUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0e2d462860>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig,ax=plt.subplots()\n",
    "ax.set_xlabel('False Positive Rate')\n",
    "ax.set_ylabel('True Positive Rate')\n",
    "ax.set_title('Receiver operating characteristic -multi-class')\n",
    "results.multiclass_roc_curve(y_test,probs_gb,ax,'gaussian bayes')\n",
    "results.multiclass_roc_curve(y_test,probs_knn,ax,'knn')\n",
    "results.multiclass_roc_curve(y_test,probs_kmeans,ax,'kmeans')\n",
    "results.multiclass_roc_curve(y_test,probs_gnb,ax,'gaussiannb')\n",
    "results.multiclass_roc_curve(y_test,probs_parzen,ax,'parzenwindow')\n",
    "ax.legend(loc=\"lower right\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MEDICAL DATA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['HEALTHY' 1.6315155608144196 -0.26444658130172355 2.534567146651425]\n",
      " ['SURGERY' 0.15395105426389907 1.419533481505174 1.3331207912724836]\n",
      " ['HEALTHY' 2.021729118164318 0.26204637889999405 2.8799717380508727]\n",
      " ..., \n",
      " ['HEALTHY' 0.19320188275265227 0.36039894430698144 1.8676445668171464]\n",
      " ['HEALTHY' 1.6840959730399991 -0.02321819895892971 3.306257682435044]\n",
      " ['MEDICATION' 0.9752179047232428 2.305958926888452 0.22982688347681815]]\n",
      "(3000,)\n"
     ]
    }
   ],
   "source": [
    "data = pd.read_csv('Medical_data.csv')\n",
    "X = data.as_matrix()\n",
    "print(X)\n",
    "data = X[:,1:4]\n",
    "y=np.empty(X.shape[0])\n",
    "for i in range(X.shape[0]):\n",
    "    if(X[i,0]=='HEALTHY'):\n",
    "        y[i]=0\n",
    "    if(X[i,0]=='SURGERY'):\n",
    "        y[i]=1\n",
    "    if(X[i,0]=='MEDICATION'):\n",
    "        y[i]=2\n",
    "print(y.shape)        \n",
    "y=np.array(y,dtype='int')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn.model_selection import StratifiedShuffleSplit\n",
    "sss = StratifiedShuffleSplit(n_splits=20, test_size=0.2)\n",
    "sss.get_n_splits(data, y)\n",
    "for train_index, test_index in sss.split(data, y):\n",
    "    train, y_train = data[train_index], y[train_index]\n",
    "    test, y_test = data[test_index], y[test_index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.12005292953693544 -0.769731863715909 2.1310503102593494]\n",
      " [0.883304437829268 2.0356177317342605 -0.1976768570953032]\n",
      " [-0.44632141487895743 3.8924282327091526 0.12915545376125967]\n",
      " ..., \n",
      " [2.0861847566279974 2.160895715478742 0.3604431919369457]\n",
      " [3.010457546684365 1.0380750865342 -0.15256158527070673]\n",
      " [1.993378734448228 2.0621189071818047 -0.10819431251759952]] (2400,)\n"
     ]
    }
   ],
   "source": [
    "print(train,y_train.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.10798014  1.10798014  1.10798014]\n",
      " [ 0.          0.          0.        ]\n",
      " [ 0.          0.          0.        ]]\n",
      "[[ 1.14663061  1.14663061  1.14663061]\n",
      " [ 0.43308336  0.43308336  0.43308336]\n",
      " [ 0.          0.          0.        ]]\n",
      "[[ 1.20877267  1.20877267  1.20877267]\n",
      " [ 0.61214397  0.61214397  0.61214397]\n",
      " [ 0.08134919  0.08134919  0.08134919]]\n",
      "[[ 1.25901176  1.25901176  1.25901176]\n",
      " [ 0.71575627  0.71575627  0.71575627]\n",
      " [ 0.24092278  0.24092278  0.24092278]]\n",
      "[[ 1.30044437  1.30044437  1.30044437]\n",
      " [ 0.799009    0.799009    0.799009  ]\n",
      " [ 0.37353568  0.37353568  0.37353568]]\n",
      "[[ 1.33676163  1.33676163  1.33676163]\n",
      " [ 0.86692002  0.86692002  0.86692002]\n",
      " [ 0.45762324  0.45762324  0.45762324]]\n",
      "[[ 1.36912684  1.36912684  1.36912684]\n",
      " [ 0.91978495  0.91978495  0.91978495]\n",
      " [ 0.51284891  0.51284891  0.51284891]]\n",
      "[[ 1.39273267  1.39273267  1.39273267]\n",
      " [ 0.95254408  0.95254408  0.95254408]\n",
      " [ 0.54263953  0.54263953  0.54263953]]\n",
      "[[ 1.41237449  1.41237449  1.41237449]\n",
      " [ 0.97843173  0.97843173  0.97843173]\n",
      " [ 0.56777175  0.56777175  0.56777175]]\n",
      "[[ 1.42857599  1.42857599  1.42857599]\n",
      " [ 1.00019613  1.00019613  1.00019613]\n",
      " [ 0.5902289   0.5902289   0.5902289 ]]\n",
      "[[ 1.44107298  1.44107298  1.44107298]\n",
      " [ 1.01954023  1.01954023  1.01954023]\n",
      " [ 0.61269874  0.61269874  0.61269874]]\n",
      "[[ 1.4501563   1.4501563   1.4501563 ]\n",
      " [ 1.03468221  1.03468221  1.03468221]\n",
      " [ 0.63043944  0.63043944  0.63043944]]\n",
      "[[ 1.45913324  1.45913324  1.45913324]\n",
      " [ 1.04665827  1.04665827  1.04665827]\n",
      " [ 0.64163953  0.64163953  0.64163953]]\n",
      "[[ 1.46757113  1.46757113  1.46757113]\n",
      " [ 1.05657335  1.05657335  1.05657335]\n",
      " [ 0.64977231  0.64977231  0.64977231]]\n",
      "[[ 1.47263119  1.47263119  1.47263119]\n",
      " [ 1.06214815  1.06214815  1.06214815]\n",
      " [ 0.6540134   0.6540134   0.6540134 ]]\n",
      "[[ 1.47558124  1.47558124  1.47558124]\n",
      " [ 1.0662551   1.0662551   1.0662551 ]\n",
      " [ 0.65820035  0.65820035  0.65820035]]\n",
      "[[ 1.47856482  1.47856482  1.47856482]\n",
      " [ 1.06997664  1.06997664  1.06997664]\n",
      " [ 0.66156142  0.66156142  0.66156142]]\n",
      "[[ 1.48214117  1.48214117  1.48214117]\n",
      " [ 1.07347449  1.07347449  1.07347449]\n",
      " [ 0.66379048  0.66379048  0.66379048]]\n",
      "[[ 1.48380304  1.48380304  1.48380304]\n",
      " [ 1.07606912  1.07606912  1.07606912]\n",
      " [ 0.66673845  0.66673845  0.66673845]]\n",
      "[[ 1.48547296  1.48547296  1.48547296]\n",
      " [ 1.07791415  1.07791415  1.07791415]\n",
      " [ 0.66819695  0.66819695  0.66819695]]\n",
      "[[ 1.48686951  1.48686951  1.48686951]\n",
      " [ 1.07938797  1.07938797  1.07938797]\n",
      " [ 0.66928925  0.66928925  0.66928925]]\n",
      "[[ 1.48799221  1.48799221  1.48799221]\n",
      " [ 1.08067681  1.08067681  1.08067681]\n",
      " [ 0.67037907  0.67037907  0.67037907]]\n",
      "[[ 1.48940342  1.48940342  1.48940342]\n",
      " [ 1.08177469  1.08177469  1.08177469]\n",
      " [ 0.6707419   0.6707419   0.6707419 ]]\n",
      "[[ 1.49025507  1.49025507  1.49025507]\n",
      " [ 1.08250588  1.08250588  1.08250588]\n",
      " [ 0.67110552  0.67110552  0.67110552]]\n",
      "[[ 1.49139548  1.49139548  1.49139548]\n",
      " [ 1.08323373  1.08323373  1.08323373]\n",
      " [ 0.67110552  0.67110552  0.67110552]]\n",
      "[[ 1.49196866  1.49196866  1.49196866]\n",
      " [ 1.08378122  1.08378122  1.08378122]\n",
      " [ 0.6714695   0.6714695   0.6714695 ]]\n",
      "[[ 1.49196866  1.49196866  1.49196866]\n",
      " [ 1.08415032  1.08415032  1.08415032]\n",
      " [ 0.6721948   0.6721948   0.6721948 ]]\n",
      "[[ 1.49196866  1.49196866  1.49196866]\n",
      " [ 1.08489096  1.08489096  1.08489096]\n",
      " [ 0.67363316  0.67363316  0.67363316]]\n",
      "[[ 1.49196866  1.49196866  1.49196866]\n",
      " [ 1.08544785  1.08544785  1.08544785]\n",
      " [ 0.67470287  0.67470287  0.67470287]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "[[ 1.492254    1.492254    1.492254  ]\n",
      " [ 1.0860013   1.0860013   1.0860013 ]\n",
      " [ 0.67541383  0.67541383  0.67541383]]\n",
      "10878.651230681708\n",
      "3\n",
      "[[ 1.10798014  1.10798014  1.10798014]\n",
      " [ 0.          0.          0.        ]\n",
      " [ 0.          0.          0.        ]\n",
      " [ 0.          0.          0.        ]\n",
      " [ 0.          0.          0.        ]\n",
      " [ 0.          0.          0.        ]\n",
      " [ 0.          0.          0.        ]]\n",
      "[[ 1.14663061  1.14663061  1.14663061]\n",
      " [ 0.43308336  0.43308336  0.43308336]\n",
      " [ 0.          0.          0.        ]\n",
      " [ 0.          0.          0.        ]\n",
      " [ 0.          0.          0.        ]\n",
      " [ 0.          0.          0.        ]\n",
      " [ 0.          0.          0.        ]]\n",
      "[[ 1.20877267  1.20877267  1.20877267]\n",
      " [ 0.61214397  0.61214397  0.61214397]\n",
      " [ 0.08134919  0.08134919  0.08134919]\n",
      " [ 0.          0.          0.        ]\n",
      " [ 0.          0.          0.        ]\n",
      " [ 0.          0.          0.        ]\n",
      " [ 0.          0.          0.        ]]\n",
      "[[ 1.25901176  1.25901176  1.25901176]\n",
      " [ 0.71575627  0.71575627  0.71575627]\n",
      " [ 0.27147337  0.27147337  0.27147337]\n",
      " [-0.06458304 -0.06458304 -0.06458304]\n",
      " [ 0.          0.          0.        ]\n",
      " [ 0.          0.          0.        ]\n",
      " [ 0.          0.          0.        ]]\n",
      "[[ 1.30044437  1.30044437  1.30044437]\n",
      " [ 0.80183263  0.80183263  0.80183263]\n",
      " [ 0.3937809   0.3937809   0.3937809 ]\n",
      " [-0.10061713 -0.10061713 -0.10061713]\n",
      " [-0.02854894 -0.02854894 -0.02854894]\n",
      " [ 0.          0.          0.        ]\n",
      " [ 0.          0.          0.        ]]\n",
      "[[ 1.33781169  1.33781169  1.33781169]\n",
      " [ 0.87147816  0.87147816  0.87147816]\n",
      " [ 0.47645355  0.47645355  0.47645355]\n",
      " [-0.10061713 -0.10061713 -0.10061713]\n",
      " [-0.02854894 -0.02854894 -0.02854894]\n",
      " [ 0.15997174  0.15997174  0.15997174]\n",
      " [ 0.          0.          0.        ]]\n",
      "[[ 1.37022333  1.37022333  1.37022333]\n",
      " [ 0.92397762  0.92397762  0.92397762]\n",
      " [ 0.54579255  0.54579255  0.54579255]\n",
      " [-0.10061713 -0.10061713 -0.10061713]\n",
      " [-0.02854894 -0.02854894 -0.02854894]\n",
      " [ 0.26481758  0.26481758  0.26481758]\n",
      " [ 0.          0.          0.        ]]\n",
      "[[ 1.39407487  1.39407487  1.39407487]\n",
      " [ 0.9589661   0.9589661   0.9589661 ]\n",
      " [ 0.59321056  0.59321056  0.59321056]\n",
      " [-0.10061713 -0.10061713 -0.10061713]\n",
      " [-0.02854894 -0.02854894 -0.02854894]\n",
      " [ 0.31752381  0.31752381  0.31752381]\n",
      " [ 0.          0.          0.        ]]\n",
      "[[ 1.41519256  1.41519256  1.41519256]\n",
      " [ 0.99143861  0.99143861  0.99143861]\n",
      " [ 0.64243004  0.64243004  0.64243004]\n",
      " [-0.10061713 -0.10061713 -0.10061713]\n",
      " [-0.02854894 -0.02854894 -0.02854894]\n",
      " [ 0.36502295  0.36502295  0.36502295]\n",
      " [ 0.          0.          0.        ]]\n",
      "[[ 1.43123113  1.43123113  1.43123113]\n",
      " [ 1.02094068  1.02094068  1.02094068]\n",
      " [ 0.6897186   0.6897186   0.6897186 ]\n",
      " [-0.10061713 -0.10061713 -0.10061713]\n",
      " [-0.02854894 -0.02854894 -0.02854894]\n",
      " [ 0.40648825  0.40648825  0.40648825]\n",
      " [ 0.15997174  0.15997174  0.15997174]]\n",
      "[[ 1.44838263  1.44838263  1.44838263]\n",
      " [ 1.04626069  1.04626069  1.04626069]\n",
      " [ 0.72721686  0.72721686  0.72721686]\n",
      " [-0.10061713 -0.10061713 -0.10061713]\n",
      " [-0.02854894 -0.02854894 -0.02854894]\n",
      " [ 0.45291364  0.45291364  0.45291364]\n",
      " [ 0.22709115  0.22709115  0.22709115]]\n",
      "[[ 1.46280003  1.46280003  1.46280003]\n",
      " [ 1.06818824  1.06818824  1.06818824]\n",
      " [ 0.76250636  0.76250636  0.76250636]\n",
      " [-0.10061713 -0.10061713 -0.10061713]\n",
      " [-0.02854894 -0.02854894 -0.02854894]\n",
      " [ 0.49608352  0.49608352  0.49608352]\n",
      " [ 0.27147337  0.27147337  0.27147337]]\n",
      "[[ 1.47423729  1.47423729  1.47423729]\n",
      " [ 1.08982798  1.08982798  1.08982798]\n",
      " [ 0.79582455  0.79582455  0.79582455]\n",
      " [-0.10061713 -0.10061713 -0.10061713]\n",
      " [-0.02854894 -0.02854894 -0.02854894]\n",
      " [ 0.52717854  0.52717854  0.52717854]\n",
      " [ 0.30241692  0.30241692  0.30241692]]\n",
      "[[ 1.48715002  1.48715002  1.48715002]\n",
      " [ 1.10955435  1.10955435  1.10955435]\n",
      " [ 0.82437611  0.82437611  0.82437611]\n",
      " [-0.10061713 -0.10061713 -0.10061713]\n",
      " [-0.02854894 -0.02854894 -0.02854894]\n",
      " [ 0.55754512  0.55754512  0.55754512]\n",
      " [ 0.32916441  0.32916441  0.32916441]]\n",
      "[[ 1.49915938  1.49915938  1.49915938]\n",
      " [ 1.12956075  1.12956075  1.12956075]\n",
      " [ 0.84923364  0.84923364  0.84923364]\n",
      " [-0.10061713 -0.10061713 -0.10061713]\n",
      " [-0.02854894 -0.02854894 -0.02854894]\n",
      " [ 0.58077632  0.58077632  0.58077632]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " [ 0.35054145  0.35054145  0.35054145]]\n",
      "[[ 1.51077554  1.51077554  1.51077554]\n",
      " [ 1.14840552  1.14840552  1.14840552]\n",
      " [ 0.86840078  0.86840078  0.86840078]\n",
      " [-0.10061713 -0.10061713 -0.10061713]\n",
      " [ 0.09713151  0.09713151  0.09713151]\n",
      " [ 0.60074863  0.60074863  0.60074863]\n",
      " [ 0.38002198  0.38002198  0.38002198]]\n",
      "[[ 1.52119423  1.52119423  1.52119423]\n",
      " [ 1.16461632  1.16461632  1.16461632]\n",
      " [ 0.88585257  0.88585257  0.88585257]\n",
      " [-0.06458304 -0.06458304 -0.06458304]\n",
      " [ 0.19879988  0.19879988  0.19879988]\n",
      " [ 0.62085414  0.62085414  0.62085414]\n",
      " [ 0.40169062  0.40169062  0.40169062]]\n",
      "[[ 1.53034673  1.53034673  1.53034673]\n",
      " [ 1.18007581  1.18007581  1.18007581]\n",
      " [ 0.90403435  0.90403435  0.90403435]\n",
      " [-0.06458304 -0.06458304 -0.06458304]\n",
      " [ 0.24730872  0.24730872  0.24730872]\n",
      " [ 0.6426686   0.6426686   0.6426686 ]\n",
      " [ 0.4302458   0.4302458   0.4302458 ]]\n",
      "[[ 1.54321775  1.54321775  1.54321775]\n",
      " [ 1.19584878  1.19584878  1.19584878]\n",
      " [ 0.92046587  0.92046587  0.92046587]\n",
      " [-0.06458304 -0.06458304 -0.06458304]\n",
      " [ 0.27147337  0.27147337  0.27147337]\n",
      " [ 0.66891372  0.66891372  0.66891372]\n",
      " [ 0.46131195  0.46131195  0.46131195]]\n",
      "[[ 1.55480928  1.55480928  1.55480928]\n",
      " [ 1.20966511  1.20966511  1.20966511]\n",
      " [ 0.93850248  0.93850248  0.93850248]\n",
      " [-0.06458304 -0.06458304 -0.06458304]\n",
      " [ 0.28767903  0.28767903  0.28767903]\n",
      " [ 0.69753294  0.69753294  0.69753294]\n",
      " [ 0.48399512  0.48399512  0.48399512]]\n",
      "[[ 1.5631946   1.5631946   1.5631946 ]\n",
      " [ 1.22217904  1.22217904  1.22217904]\n",
      " [ 0.95681876  0.95681876  0.95681876]\n",
      " [-0.06458304 -0.06458304 -0.06458304]\n",
      " [ 0.30241692  0.30241692  0.30241692]\n",
      " [ 0.72433481  0.72433481  0.72433481]\n",
      " [ 0.50614302  0.50614302  0.50614302]]\n",
      "[[ 1.57541467  1.57541467  1.57541467]\n",
      " [ 1.23736797  1.23736797  1.23736797]\n",
      " [ 0.97354687  0.97354687  0.97354687]\n",
      " [-0.06458304 -0.06458304 -0.06458304]\n",
      " [ 0.31502549  0.31502549  0.31502549]\n",
      " [ 0.74420285  0.74420285  0.74420285]\n",
      " [ 0.52269463  0.52269463  0.52269463]]\n",
      "[[ 1.58466557  1.58466557  1.58466557]\n",
      " [ 1.24983512  1.24983512  1.24983512]\n",
      " [ 0.98759085  0.98759085  0.98759085]\n",
      " [-0.06458304 -0.06458304 -0.06458304]\n",
      " [ 0.32916441  0.32916441  0.32916441]\n",
      " [ 0.76202796  0.76202796  0.76202796]\n",
      " [ 0.53977145  0.53977145  0.53977145]]\n",
      "[[ 1.59212252  1.59212252  1.59212252]\n",
      " [ 1.26043468  1.26043468  1.26043468]\n",
      " [ 1.00000211  1.00000211  1.00000211]\n",
      " [-0.06458304 -0.06458304 -0.06458304]\n",
      " [ 0.3433002   0.3433002   0.3433002 ]\n",
      " [ 0.77989197  0.77989197  0.77989197]\n",
      " [ 0.55824194  0.55824194  0.55824194]]\n",
      "[[ 1.59887374  1.59887374  1.59887374]\n",
      " [ 1.26823901  1.26823901  1.26823901]\n",
      " [ 1.01053862  1.01053862  1.01053862]\n",
      " [-0.06458304 -0.06458304 -0.06458304]\n",
      " [ 0.3604909   0.3604909   0.3604909 ]\n",
      " [ 0.79480686  0.79480686  0.79480686]\n",
      " [ 0.57361801  0.57361801  0.57361801]]\n",
      "[[ 1.60542772  1.60542772  1.60542772]\n",
      " [ 1.27489936  1.27489936  1.27489936]\n",
      " [ 1.01973804  1.01973804  1.01973804]\n",
      " [-0.06458304 -0.06458304 -0.06458304]\n",
      " [ 0.37615015  0.37615015  0.37615015]\n",
      " [ 0.80706375  0.80706375  0.80706375]\n",
      " [ 0.58723691  0.58723691  0.58723691]]\n",
      "[[ 1.61083019  1.61083019  1.61083019]\n",
      " [ 1.28227789  1.28227789  1.28227789]\n",
      " [ 1.03017335  1.03017335  1.03017335]\n",
      " [-0.06458304 -0.06458304 -0.06458304]\n",
      " [ 0.38506512  0.38506512  0.38506512]\n",
      " [ 0.81803655  0.81803655  0.81803655]\n",
      " [ 0.59697306  0.59697306  0.59697306]]\n",
      "[[ 1.6168497   1.6168497   1.6168497 ]\n",
      " [ 1.29113248  1.29113248  1.29113248]\n",
      " [ 1.04106622  1.04106622  1.04106622]\n",
      " [ 0.0101556   0.0101556   0.0101556 ]\n",
      " [ 0.39426004  0.39426004  0.39426004]\n",
      " [ 0.82891993  0.82891993  0.82891993]\n",
      " [ 0.60737322  0.60737322  0.60737322]]\n",
      "[[ 1.61964716  1.61964716  1.61964716]\n",
      " [ 1.29738332  1.29738332  1.29738332]\n",
      " [ 1.049382    1.049382    1.049382  ]\n",
      " [ 0.04769435  0.04769435  0.04769435]\n",
      " [ 0.40420611  0.40420611  0.40420611]\n",
      " [ 0.83532917  0.83532917  0.83532917]\n",
      " [ 0.61403302  0.61403302  0.61403302]]\n",
      "[[ 1.62339697  1.62339697  1.62339697]\n",
      " [ 1.30342945  1.30342945  1.30342945]\n",
      " [ 1.05668018  1.05668018  1.05668018]\n",
      " [ 0.10502062  0.10502062  0.10502062]\n",
      " [ 0.41414934  0.41414934  0.41414934]\n",
      " [ 0.84113704  0.84113704  0.84113704]\n",
      " [ 0.61956588  0.61956588  0.61956588]]\n",
      "[[ 1.628691    1.628691    1.628691  ]\n",
      " [ 1.30984325  1.30984325  1.30984325]\n",
      " [ 1.0650165   1.0650165   1.0650165 ]\n",
      " [ 0.15187458  0.15187458  0.15187458]\n",
      " [ 0.42333849  0.42333849  0.42333849]\n",
      " [ 0.85047592  0.85047592  0.85047592]\n",
      " [ 0.6274432   0.6274432   0.6274432 ]]\n",
      "[[ 1.63163537  1.63163537  1.63163537]\n",
      " [ 1.31575922  1.31575922  1.31575922]\n",
      " [ 1.07251296  1.07251296  1.07251296]\n",
      " [ 0.18323695  0.18323695  0.18323695]\n",
      " [ 0.43356709  0.43356709  0.43356709]\n",
      " [ 0.85801674  0.85801674  0.85801674]\n",
      " [ 0.63658714  0.63658714  0.63658714]]\n",
      "[[ 1.63608923  1.63608923  1.63608923]\n",
      " [ 1.32125865  1.32125865  1.32125865]\n",
      " [ 1.0787233   1.0787233   1.0787233 ]\n",
      " [ 0.21761905  0.21761905  0.21761905]\n",
      " [ 0.45163066  0.45163066  0.45163066]\n",
      " [ 0.86475419  0.86475419  0.86475419]\n",
      " [ 0.64759524  0.64759524  0.64759524]]\n",
      "[[ 1.63911659  1.63911659  1.63911659]\n",
      " [ 1.32508435  1.32508435  1.32508435]\n",
      " [ 1.08475311  1.08475311  1.08475311]\n",
      " [ 0.24092278  0.24092278  0.24092278]\n",
      " [ 0.46995219  0.46995219  0.46995219]\n",
      " [ 0.87294149  0.87294149  0.87294149]\n",
      " [ 0.6614249   0.6614249   0.6614249 ]]\n",
      "[[ 1.64165979  1.64165979  1.64165979]\n",
      " [ 1.32905382  1.32905382  1.32905382]\n",
      " [ 1.09120721  1.09120721  1.09120721]\n",
      " [ 0.25370833  0.25370833  0.25370833]\n",
      " [ 0.48180142  0.48180142  0.48180142]\n",
      " [ 0.8829019   0.8829019   0.8829019 ]\n",
      " [ 0.67642885  0.67642885  0.67642885]]\n",
      "[[ 1.6437149   1.6437149   1.6437149 ]\n",
      " [ 1.33507379  1.33507379  1.33507379]\n",
      " [ 1.09963177  1.09963177  1.09963177]\n",
      " [ 0.26158555  0.26158555  0.26158555]\n",
      " [ 0.493935    0.493935    0.493935  ]\n",
      " [ 0.89210238  0.89210238  0.89210238]\n",
      " [ 0.69128632  0.69128632  0.69128632]]\n",
      "[[ 1.64576164  1.64576164  1.64576164]\n",
      " [ 1.33977143  1.33977143  1.33977143]\n",
      " [ 1.10673865  1.10673865  1.10673865]\n",
      " [ 0.27617813  0.27617813  0.27617813]\n",
      " [ 0.50711531  0.50711531  0.50711531]\n",
      " [ 0.9023422   0.9023422   0.9023422 ]\n",
      " [ 0.70727377  0.70727377  0.70727377]]\n",
      "[[ 1.64835653  1.64835653  1.64835653]\n",
      " [ 1.34390979  1.34390979  1.34390979]\n",
      " [ 1.11308697  1.11308697  1.11308697]\n",
      " [ 0.29172829  0.29172829  0.29172829]\n",
      " [ 0.51795962  0.51795962  0.51795962]\n",
      " [ 0.91261532  0.91261532  0.91261532]\n",
      " [ 0.7202861   0.7202861   0.7202861 ]]\n",
      "[[ 1.64939149  1.64939149  1.64939149]\n",
      " [ 1.34647833  1.34647833  1.34647833]\n",
      " [ 1.11914286  1.11914286  1.11914286]\n",
      " [ 0.29450611  0.29450611  0.29450611]\n",
      " [ 0.52461011  0.52461011  0.52461011]\n",
      " [ 0.92371742  0.92371742  0.92371742]\n",
      " [ 0.73296598  0.73296598  0.73296598]]\n",
      "[[ 1.65095297  1.65095297  1.65095297]\n",
      " [ 1.34930438  1.34930438  1.34930438]\n",
      " [ 1.12683325  1.12683325  1.12683325]\n",
      " [ 0.29741292  0.29741292  0.29741292]\n",
      " [ 0.53227172  0.53227172  0.53227172]\n",
      " [ 0.93397835  0.93397835  0.93397835]\n",
      " [ 0.74296818  0.74296818  0.74296818]]\n",
      "[[ 1.65252099  1.65252099  1.65252099]\n",
      " [ 1.35338438  1.35338438  1.35338438]\n",
      " [ 1.13448523  1.13448523  1.13448523]\n",
      " [ 0.31085058  0.31085058  0.31085058]\n",
      " [ 0.54375765  0.54375765  0.54375765]\n",
      " [ 0.94328401  0.94328401  0.94328401]\n",
      " [ 0.75444648  0.75444648  0.75444648]]\n",
      "[[ 1.65409807  1.65409807  1.65409807]\n",
      " [ 1.35795216  1.35795216  1.35795216]\n",
      " [ 1.14286736  1.14286736  1.14286736]\n",
      " [ 0.32031365  0.32031365  0.32031365]\n",
      " [ 0.55505545  0.55505545  0.55505545]\n",
      " [ 0.95122488  0.95122488  0.95122488]\n",
      " [ 0.76450319  0.76450319  0.76450319]]\n",
      "[[ 1.65782506  1.65782506  1.65782506]\n",
      " [ 1.36407937  1.36407937  1.36407937]\n",
      " [ 1.14938637  1.14938637  1.14938637]\n",
      " [ 0.32909252  0.32909252  0.32909252]\n",
      " [ 0.56271533  0.56271533  0.56271533]\n",
      " [ 0.95753068  0.95753068  0.95753068]\n",
      " [ 0.77294025  0.77294025  0.77294025]]\n",
      "[[ 1.66219783  1.66219783  1.66219783]\n",
      " [ 1.36860301  1.36860301  1.36860301]\n",
      " [ 1.15497841  1.15497841  1.15497841]\n",
      " [ 0.34090146  0.34090146  0.34090146]\n",
      " [ 0.57054526  0.57054526  0.57054526]\n",
      " [ 0.9641459   0.9641459   0.9641459 ]\n",
      " [ 0.77979924  0.77979924  0.77979924]]\n",
      "[[ 1.66609531  1.66609531  1.66609531]\n",
      " [ 1.37285664  1.37285664  1.37285664]\n",
      " [ 1.15954596  1.15954596  1.15954596]\n",
      " [ 0.35138467  0.35138467  0.35138467]\n",
      " [ 0.57823492  0.57823492  0.57823492]\n",
      " [ 0.96940118  0.96940118  0.96940118]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " [ 0.78625468  0.78625468  0.78625468]]\n",
      "[[ 1.67071561  1.67071561  1.67071561]\n",
      " [ 1.37739624  1.37739624  1.37739624]\n",
      " [ 1.16411964  1.16411964  1.16411964]\n",
      " [ 0.36075661  0.36075661  0.36075661]\n",
      " [ 0.58431948  0.58431948  0.58431948]\n",
      " [ 0.97401903  0.97401903  0.97401903]\n",
      " [ 0.79071056  0.79071056  0.79071056]]\n",
      "[[ 1.67188037  1.67188037  1.67188037]\n",
      " [ 1.38076091  1.38076091  1.38076091]\n",
      " [ 1.16814979  1.16814979  1.16814979]\n",
      " [ 0.36804287  0.36804287  0.36804287]\n",
      " [ 0.59076269  0.59076269  0.59076269]\n",
      " [ 0.97755148  0.97755148  0.97755148]\n",
      " [ 0.79544133  0.79544133  0.79544133]]\n",
      "[[ 1.67540602  1.67540602  1.67540602]\n",
      " [ 1.38553804  1.38553804  1.38553804]\n",
      " [ 1.17303268  1.17303268  1.17303268]\n",
      " [ 0.37353568  0.37353568  0.37353568]\n",
      " [ 0.59697306  0.59697306  0.59697306]\n",
      " [ 0.9814262   0.9814262   0.9814262 ]\n",
      " [ 0.79993189  0.79993189  0.79993189]]\n",
      "[[ 1.68024826  1.68024826  1.68024826]\n",
      " [ 1.39002676  1.39002676  1.39002676]\n",
      " [ 1.1772268   1.1772268   1.1772268 ]\n",
      " [ 0.37628727  0.37628727  0.37628727]\n",
      " [ 0.59980534  0.59980534  0.59980534]\n",
      " [ 0.98563058  0.98563058  0.98563058]\n",
      " [ 0.80352461  0.80352461  0.80352461]]\n",
      "[[ 1.68401986  1.68401986  1.68401986]\n",
      " [ 1.39396269  1.39396269  1.39396269]\n",
      " [ 1.18199001  1.18199001  1.18199001]\n",
      " [ 0.37765357  0.37765357  0.37765357]\n",
      " [ 0.60199887  0.60199887  0.60199887]\n",
      " [ 0.99014839  0.99014839  0.99014839]\n",
      " [ 0.80681763  0.80681763  0.80681763]]\n",
      "[[ 1.68721184  1.68721184  1.68721184]\n",
      " [ 1.39859149  1.39859149  1.39859149]\n",
      " [ 1.18695664  1.18695664  1.18695664]\n",
      " [ 0.37765357  0.37765357  0.37765357]\n",
      " [ 0.60358419  0.60358419  0.60358419]\n",
      " [ 0.9944674   0.9944674   0.9944674 ]\n",
      " [ 0.81057805  0.81057805  0.81057805]]\n",
      "[[ 1.68915326  1.68915326  1.68915326]\n",
      " [ 1.40196937  1.40196937  1.40196937]\n",
      " [ 1.19120627  1.19120627  1.19120627]\n",
      " [ 0.37902897  0.37902897  0.37902897]\n",
      " [ 0.60626445  0.60626445  0.60626445]\n",
      " [ 0.99824109  0.99824109  0.99824109]\n",
      " [ 0.81409693  0.81409693  0.81409693]]\n",
      "[[ 1.69108859  1.69108859  1.69108859]\n",
      " [ 1.40493359  1.40493359  1.40493359]\n",
      " [ 1.1960412   1.1960412   1.1960412 ]\n",
      " [ 0.38299586  0.38299586  0.38299586]\n",
      " [ 0.60908719  0.60908719  0.60908719]\n",
      " [ 1.00286233  1.00286233  1.00286233]\n",
      " [ 0.81695788  0.81695788  0.81695788]]\n",
      "[[ 1.69371509  1.69371509  1.69371509]\n",
      " [ 1.40892401  1.40892401  1.40892401]\n",
      " [ 1.19995407  1.19995407  1.19995407]\n",
      " [ 0.38299586  0.38299586  0.38299586]\n",
      " [ 0.61064474  0.61064474  0.61064474]\n",
      " [ 1.0062509   1.0062509   1.0062509 ]\n",
      " [ 0.82033424  0.82033424  0.82033424]]\n",
      "[[ 1.69704889  1.69704889  1.69704889]\n",
      " [ 1.41280482  1.41280482  1.41280482]\n",
      " [ 1.20329106  1.20329106  1.20329106]\n",
      " [ 0.38560786  0.38560786  0.38560786]\n",
      " [ 0.61234236  0.61234236  0.61234236]\n",
      " [ 1.01004042  1.01004042  1.01004042]\n",
      " [ 0.82376583  0.82376583  0.82376583]]\n",
      "[[ 1.70115561  1.70115561  1.70115561]\n",
      " [ 1.41727612  1.41727612  1.41727612]\n",
      " [ 1.20680131  1.20680131  1.20680131]\n",
      " [ 0.38560786  0.38560786  0.38560786]\n",
      " [ 0.61287741  0.61287741  0.61287741]\n",
      " [ 1.01366286  1.01366286  1.01366286]\n",
      " [ 0.82689392  0.82689392  0.82689392]]\n",
      "[[ 1.70466091  1.70466091  1.70466091]\n",
      " [ 1.42025777  1.42025777  1.42025777]\n",
      " [ 1.2101514   1.2101514   1.2101514 ]\n",
      " [ 0.38560786  0.38560786  0.38560786]\n",
      " [ 0.61394294  0.61394294  0.61394294]\n",
      " [ 1.01669043  1.01669043  1.01669043]\n",
      " [ 0.82863026  0.82863026  0.82863026]]\n",
      "[[ 1.70607591  1.70607591  1.70607591]\n",
      " [ 1.42256598  1.42256598  1.42256598]\n",
      " [ 1.21239237  1.21239237  1.21239237]\n",
      " [ 0.38560786  0.38560786  0.38560786]\n",
      " [ 0.61447521  0.61447521  0.61447521]\n",
      " [ 1.01867104  1.01867104  1.01867104]\n",
      " [ 0.83032174  0.83032174  0.83032174]]\n",
      "[[ 1.70821675  1.70821675  1.70821675]\n",
      " [ 1.42447465  1.42447465  1.42447465]\n",
      " [ 1.21424406  1.21424406  1.21424406]\n",
      " [ 0.3869074   0.3869074   0.3869074 ]\n",
      " [ 0.61505063  0.61505063  0.61505063]\n",
      " [ 1.02083977  1.02083977  1.02083977]\n",
      " [ 0.83172468  0.83172468  0.83172468]]\n",
      "[[ 1.71040193  1.71040193  1.71040193]\n",
      " [ 1.42662062  1.42662062  1.42662062]\n",
      " [ 1.21648471  1.21648471  1.21648471]\n",
      " [ 0.38818311  0.38818311  0.38818311]\n",
      " [ 0.61616978  0.61616978  0.61616978]\n",
      " [ 1.02300053  1.02300053  1.02300053]\n",
      " [ 0.83315645  0.83315645  0.83315645]]\n",
      "[[ 1.71261944  1.71261944  1.71261944]\n",
      " [ 1.42878205  1.42878205  1.42878205]\n",
      " [ 1.21854309  1.21854309  1.21854309]\n",
      " [ 0.38818311  0.38818311  0.38818311]\n",
      " [ 0.61671158  0.61671158  0.61671158]\n",
      " [ 1.02443342  1.02443342  1.02443342]\n",
      " [ 0.83389089  0.83389089  0.83389089]]\n",
      "[[ 1.71640173  1.71640173  1.71640173]\n",
      " [ 1.43159146  1.43159146  1.43159146]\n",
      " [ 1.22005022  1.22005022  1.22005022]\n",
      " [ 0.38818311  0.38818311  0.38818311]\n",
      " [ 0.61778517  0.61778517  0.61778517]\n",
      " [ 1.0256905   1.0256905   1.0256905 ]\n",
      " [ 0.83535897  0.83535897  0.83535897]]\n",
      "[[ 1.71872113  1.71872113  1.71872113]\n",
      " [ 1.43377812  1.43377812  1.43377812]\n",
      " [ 1.22155997  1.22155997  1.22155997]\n",
      " [ 0.38818311  0.38818311  0.38818311]\n",
      " [ 0.61832051  0.61832051  0.61832051]\n",
      " [ 1.02658964  1.02658964  1.02658964]\n",
      " [ 0.83608736  0.83608736  0.83608736]]\n",
      "[[ 1.71949204  1.71949204  1.71949204]\n",
      " [ 1.43533853  1.43533853  1.43533853]\n",
      " [ 1.22270287  1.22270287  1.22270287]\n",
      " [ 0.38818311  0.38818311  0.38818311]\n",
      " [ 0.61938038  0.61938038  0.61938038]\n",
      " [ 1.02677122  1.02677122  1.02677122]\n",
      " [ 0.83662495  0.83662495  0.83662495]]\n",
      "[[ 1.71949204  1.71949204  1.71949204]\n",
      " [ 1.43583145  1.43583145  1.43583145]\n",
      " [ 1.22309033  1.22309033  1.22309033]\n",
      " [ 0.39071709  0.39071709  0.39071709]\n",
      " [ 0.62309742  0.62309742  0.62309742]\n",
      " [ 1.02677122  1.02677122  1.02677122]\n",
      " [ 0.83798376  0.83798376  0.83798376]]\n",
      "[[ 1.71949204  1.71949204  1.71949204]\n",
      " [ 1.43583145  1.43583145  1.43583145]\n",
      " [ 1.22309033  1.22309033  1.22309033]\n",
      " [ 0.39320452  0.39320452  0.39320452]\n",
      " [ 0.62524544  0.62524544  0.62524544]\n",
      " [ 1.02677122  1.02677122  1.02677122]\n",
      " [ 0.83852615  0.83852615  0.83852615]]\n",
      "[[ 1.71949204  1.71949204  1.71949204]\n",
      " [ 1.43583145  1.43583145  1.43583145]\n",
      " [ 1.22309033  1.22309033  1.22309033]\n",
      " [ 0.39441772  0.39441772  0.39441772]\n",
      " [ 0.62682292  0.62682292  0.62682292]\n",
      " [ 1.02677122  1.02677122  1.02677122]\n",
      " [ 0.83906738  0.83906738  0.83906738]]\n",
      "[[ 1.71949204  1.71949204  1.71949204]\n",
      " [ 1.43583145  1.43583145  1.43583145]\n",
      " [ 1.22309033  1.22309033  1.22309033]\n",
      " [ 0.39441772  0.39441772  0.39441772]\n",
      " [ 0.62682292  0.62682292  0.62682292]\n",
      " [ 1.02677122  1.02677122  1.02677122]\n",
      " [ 0.83906738  0.83906738  0.83906738]]\n",
      "[[ 1.71949204  1.71949204  1.71949204]\n",
      " [ 1.43583145  1.43583145  1.43583145]\n",
      " [ 1.22309033  1.22309033  1.22309033]\n",
      " [ 0.39441772  0.39441772  0.39441772]\n",
      " [ 0.62682292  0.62682292  0.62682292]\n",
      " [ 1.02677122  1.02677122  1.02677122]\n",
      " [ 0.83906738  0.83906738  0.83906738]]\n",
      "[[ 1.71949204  1.71949204  1.71949204]\n",
      " [ 1.43583145  1.43583145  1.43583145]\n",
      " [ 1.22309033  1.22309033  1.22309033]\n",
      " [ 0.39441772  0.39441772  0.39441772]\n",
      " [ 0.62682292  0.62682292  0.62682292]\n",
      " [ 1.02677122  1.02677122  1.02677122]\n",
      " [ 0.83906738  0.83906738  0.83906738]]\n",
      "[[ 1.71949204  1.71949204  1.71949204]\n",
      " [ 1.43583145  1.43583145  1.43583145]\n",
      " [ 1.22309033  1.22309033  1.22309033]\n",
      " [ 0.39441772  0.39441772  0.39441772]\n",
      " [ 0.62682292  0.62682292  0.62682292]\n",
      " [ 1.02677122  1.02677122  1.02677122]\n",
      " [ 0.83906738  0.83906738  0.83906738]]\n",
      "[[ 1.71949204  1.71949204  1.71949204]\n",
      " [ 1.43583145  1.43583145  1.43583145]\n",
      " [ 1.22309033  1.22309033  1.22309033]\n",
      " [ 0.39441772  0.39441772  0.39441772]\n",
      " [ 0.62682292  0.62682292  0.62682292]\n",
      " [ 1.02677122  1.02677122  1.02677122]\n",
      " [ 0.83906738  0.83906738  0.83906738]]\n",
      "[[ 1.71949204  1.71949204  1.71949204]\n",
      " [ 1.43583145  1.43583145  1.43583145]\n",
      " [ 1.22309033  1.22309033  1.22309033]\n",
      " [ 0.39441772  0.39441772  0.39441772]\n",
      " [ 0.62682292  0.62682292  0.62682292]\n",
      " [ 1.02677122  1.02677122  1.02677122]\n",
      " [ 0.83906738  0.83906738  0.83906738]]\n",
      "[[ 1.71949204  1.71949204  1.71949204]\n",
      " [ 1.43583145  1.43583145  1.43583145]\n",
      " [ 1.22309033  1.22309033  1.22309033]\n",
      " [ 0.39441772  0.39441772  0.39441772]\n",
      " [ 0.62682292  0.62682292  0.62682292]\n",
      " [ 1.02677122  1.02677122  1.02677122]\n",
      " [ 0.83906738  0.83906738  0.83906738]]\n",
      "[[ 1.71949204  1.71949204  1.71949204]\n",
      " [ 1.43583145  1.43583145  1.43583145]\n",
      " [ 1.22309033  1.22309033  1.22309033]\n",
      " [ 0.39441772  0.39441772  0.39441772]\n",
      " [ 0.62682292  0.62682292  0.62682292]\n",
      " [ 1.02677122  1.02677122  1.02677122]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " [ 0.83906738  0.83906738  0.83906738]]\n",
      "[[ 1.71949204  1.71949204  1.71949204]\n",
      " [ 1.43583145  1.43583145  1.43583145]\n",
      " [ 1.22309033  1.22309033  1.22309033]\n",
      " [ 0.39441772  0.39441772  0.39441772]\n",
      " [ 0.62682292  0.62682292  0.62682292]\n",
      " [ 1.02677122  1.02677122  1.02677122]\n",
      " [ 0.83906738  0.83906738  0.83906738]]\n",
      "[[ 1.71949204  1.71949204  1.71949204]\n",
      " [ 1.43583145  1.43583145  1.43583145]\n",
      " [ 1.22309033  1.22309033  1.22309033]\n",
      " [ 0.39441772  0.39441772  0.39441772]\n",
      " [ 0.62682292  0.62682292  0.62682292]\n",
      " [ 1.02677122  1.02677122  1.02677122]\n",
      " [ 0.83906738  0.83906738  0.83906738]]\n",
      "[[ 1.71949204  1.71949204  1.71949204]\n",
      " [ 1.43583145  1.43583145  1.43583145]\n",
      " [ 1.22309033  1.22309033  1.22309033]\n",
      " [ 0.39441772  0.39441772  0.39441772]\n",
      " [ 0.62682292  0.62682292  0.62682292]\n",
      " [ 1.02677122  1.02677122  1.02677122]\n",
      " [ 0.83906738  0.83906738  0.83906738]]\n",
      "[[ 1.71949204  1.71949204  1.71949204]\n",
      " [ 1.43583145  1.43583145  1.43583145]\n",
      " [ 1.22309033  1.22309033  1.22309033]\n",
      " [ 0.39441772  0.39441772  0.39441772]\n",
      " [ 0.62682292  0.62682292  0.62682292]\n",
      " [ 1.02677122  1.02677122  1.02677122]\n",
      " [ 0.83906738  0.83906738  0.83906738]]\n",
      "[[ 1.71949204  1.71949204  1.71949204]\n",
      " [ 1.43583145  1.43583145  1.43583145]\n",
      " [ 1.22309033  1.22309033  1.22309033]\n",
      " [ 0.39441772  0.39441772  0.39441772]\n",
      " [ 0.62682292  0.62682292  0.62682292]\n",
      " [ 1.02677122  1.02677122  1.02677122]\n",
      " [ 0.83906738  0.83906738  0.83906738]]\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-53-386b08bf0f6d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mlab\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0mkmeans\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mKMeans\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m     \u001b[0mpreds_tr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkmeans\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_predict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m     \u001b[0mpreds\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkmeans\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m#     print(preds_tr)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-52-97fc878f8359>\u001b[0m in \u001b[0;36mfit_predict\u001b[0;34m(self, train, epsilon, *args)\u001b[0m\n\u001b[1;32m     19\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     20\u001b[0m                 \u001b[0;32mfor\u001b[0m \u001b[0mj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 21\u001b[0;31m                     \u001b[0mdist_vec\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mj\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcenters\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mj\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     22\u001b[0m \u001b[0;31m#                 print(dist_vec)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     23\u001b[0m                 \u001b[0mpreds\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdist_vec\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/numpy/core/fromnumeric.py\u001b[0m in \u001b[0;36msum\u001b[0;34m(a, axis, dtype, out, keepdims)\u001b[0m\n\u001b[1;32m   1818\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mkeepdims\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_NoValue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1819\u001b[0m         \u001b[0mkwargs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'keepdims'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mkeepdims\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1820\u001b[0;31m     \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_gentype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1821\u001b[0m         \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_sum_\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1822\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mout\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "x=np.arange(3,100,4)\n",
    "acc_tr=[]\n",
    "acc=[]\n",
    "for i in x:\n",
    "    lab=np.zeros(i)\n",
    "    kmeans = KMeans(i)\n",
    "    preds_tr=kmeans.fit_predict(train)\n",
    "    preds=kmeans.predict(test)\n",
    "#     print(preds_tr)\n",
    "    for j in range(i):\n",
    "        lab[j]=np.bincount(y_train[(preds_tr==j)]).argmax()\n",
    "    acc_tr.append(np.sum(y_train==lab[preds_tr.astype(int)])/y_train.shape)\n",
    "    acc.append(np.sum(y_test==lab[preds.astype(int)])/y_test.shape)\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "np.savetxt('preds.csv',lab[preds_tr.astype(int)].astype(int))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([ 0.465]), array([ 0.45833333]), array([ 0.46833333])] [array([ 0.44416667]), array([ 0.44958333]), array([ 0.45])]\n"
     ]
    }
   ],
   "source": [
    "print(acc,acc_tr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.9] 0.904166666667\n"
     ]
    }
   ],
   "source": [
    "acc_tr=[]\n",
    "acc=[]\n",
    "clf = GaussianBayes()\n",
    "\n",
    "clf.fit(train,y_train)\n",
    "preds_tr, probs_tr=clf.predict(train)\n",
    "preds_tr, probs_tr=clf.predict(train)\n",
    "acc_tr=np.sum(y_train==)/y_train.shape[0]\n",
    "acc=np.sum(y_test==clf.predict(test))/y_test.shape\n",
    "# print(clf.predict(test))\n",
    "print(acc,acc_tr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "fig,ax=plt.subplots()\n",
    "ax.scatter(list(x),acc_tr)\n",
    "ax.scatter(list(x),acc,color='r')\n",
    "\n",
    "print(train.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "for i in range(train.shape[1]):\n",
    "    fig,ax=plt.subplots()\n",
    "    plt.hist(list(train[:,i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2400,)\n",
      "(600,)\n",
      "[0.90833333333333333] [0.90833333333333333]\n",
      "[0.89500000000000002] [0.89500000000000002]\n"
     ]
    }
   ],
   "source": [
    "acc_tr=[]\n",
    "acc=[]\n",
    "clf=GaussianNB()\n",
    "clf.fit(train,y_train)\n",
    "preds_tr=clf.predict(train)\n",
    "preds=clf.predict(test)\n",
    "# print(preds_tr,preds)\n",
    "acc_tr.append(results.accuracy(y_train, preds_tr))\n",
    "acc.append(results.accuracy(y_test, preds))\n",
    "# print(y_train,preds_tr)\n",
    "# print(y_test,preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "fig,ax=plt.subplots()\n",
    "ax.set_xlabel('False Positive Rate')\n",
    "ax.set_ylabel('True Positive Rate')\n",
    "ax.set_title('Receiver operating characteristic -multi-class')\n",
    "results.multiclass_roc_curve(y_test,probs_gb,ax,'gaussian bayes')\n",
    "results.multiclass_roc_curve(y_test,probs_knn,ax,'knn')\n",
    "results.multiclass_roc_curve(y_test,probs_kmeans,ax,'kmeans')\n",
    "results.multiclass_roc_curve(y_test,probs_gnb,ax,'gaussiannb')\n",
    "results.multiclass_roc_curve(y_test,probs_parzen,ax,'parzenwindow')\n",
    "ax.legend(loc=\"lower right\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TRAIN SELECTION DATA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "data = pd.read_csv('railwayBookingList.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       caseID  boarded  budget  memberCount preferredClass     sex  age\n",
      "0   111131089        0    2201            0       FIRST_AC  female    2\n",
      "1  2489059216        0    1775            3       FIRST_AC    male    0\n",
      "2  1565109576        1    1775            3       FIRST_AC  female    0\n",
      "3  1373075087        1    1775            3       FIRST_AC    male    3\n",
      "4  1598041082        1    1775            3       FIRST_AC  female    2\n"
     ]
    }
   ],
   "source": [
    "print(data.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/khushal/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:4: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  after removing the cwd from sys.path.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "dict_class={'FIRST_AC':0,'SECOND_AC':1,'THIRD_AC':2,'NO_PREF':3}\n",
    "for i in range(data.shape[0]):\n",
    "    data['preferredClass'][i]=dict_class[data['preferredClass'][i]]\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/khushal/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n",
      "/home/khushal/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:2: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "data['sex'][(data['sex']=='male')]=0\n",
    "data['sex'][(data['sex']=='female')]=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/khushal/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:3: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n"
     ]
    }
   ],
   "source": [
    "sorted_b=np.sort(np.array(data['budget'].unique()))\n",
    "for x,i in enumerate(sorted_b):\n",
    "        data['budget'][data['budget']==i]=x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>caseID</th>\n",
       "      <th>boarded</th>\n",
       "      <th>budget</th>\n",
       "      <th>memberCount</th>\n",
       "      <th>preferredClass</th>\n",
       "      <th>sex</th>\n",
       "      <th>age</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>111131089</td>\n",
       "      <td>0</td>\n",
       "      <td>17</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2489059216</td>\n",
       "      <td>0</td>\n",
       "      <td>15</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1565109576</td>\n",
       "      <td>1</td>\n",
       "      <td>15</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1373075087</td>\n",
       "      <td>1</td>\n",
       "      <td>15</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1598041082</td>\n",
       "      <td>1</td>\n",
       "      <td>15</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       caseID  boarded  budget  memberCount preferredClass sex  age\n",
       "0   111131089        0      17            0              0   1    2\n",
       "1  2489059216        0      15            3              0   0    0\n",
       "2  1565109576        1      15            3              0   1    0\n",
       "3  1373075087        1      15            3              0   0    3\n",
       "4  1598041082        1      15            3              0   1    2"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1309, 5)\n"
     ]
    }
   ],
   "source": [
    "y=data['boarded']\n",
    "X = data.as_matrix()\n",
    "X=X[:-1,2:]\n",
    "y=y[:-1]\n",
    "y=np.array(y)\n",
    "print(X.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn.model_selection import StratifiedShuffleSplit\n",
    "sss = StratifiedShuffleSplit(n_splits=1, test_size=0.2)\n",
    "sss.get_n_splits(X, y)\n",
    "for train_index, test_index in sss.split(X, y):\n",
    "    train, y_train = X[train_index], y[train_index]\n",
    "    test, y_test = X[test_index], y[test_index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "y_train=np.array(y_train)\n",
    "train=np.array(train)\n",
    "test=np.array(test)\n",
    "y_test=np.array(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn.cluster import KMeans as ref\n",
    "x=np.arange(3,300,4)\n",
    "acc_tr=[]\n",
    "acc=[]\n",
    "for i in x:\n",
    "    lab=np.zeros(i)\n",
    "    kmeans = KMeans(i)\n",
    "    preds_tr=kmeans.fit_predict(train)\n",
    "    preds=kmeans.predict(test)\n",
    "#     print(preds_tr)\n",
    "    for j in range(i):\n",
    "        lab[j]=np.bincount(y_train[(preds_tr==j)]).argmax()  \n",
    "    acc_tr.append(np.sum(y_train==lab[preds_tr])/y_train.shape)\n",
    "    acc.append(np.sum(y_test==lab[preds])/y_test.shape)\n",
    "x=np.arange(3,300,4)\n",
    "acc_tr2=[]\n",
    "acc2=[]\n",
    "for i in x:\n",
    "    lab=np.zeros(i)\n",
    "    kmeans = ref(i)\n",
    "    preds_tr=kmeans.fit_predict(train)\n",
    "    preds=kmeans.predict(test)\n",
    "#     print(preds_tr)\n",
    "    for j in range(i):\n",
    "        lab[j]=np.bincount(y_train[(preds_tr==j)]).argmax()  \n",
    "    acc_tr2.append(np.sum(y_train==lab[preds_tr])/y_train.shape)\n",
    "    acc2.append(np.sum(y_test==lab[preds])/y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1047, 5)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAD8CAYAAACb4nSYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nGPSJiPIIgz4RUR75/46bER+NY1OoAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fc98d967908>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig,ax=plt.subplots()\n",
    "ax.scatter(list(x),acc_tr,label='Train Accuracy')\n",
    "ax.scatter(list(x),acc,color='r',label='Validation Accuracy')\n",
    "ax.legend(loc='lower right')\n",
    "print(train.shape)\n",
    "fig.savefig('ktrs.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n6hjKDn6eGB0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fc98d88aeb8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "for i in range(train.shape[1]):\n",
    "    fig,ax=plt.subplots()\n",
    "    ax.hist(list(train[:,i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'KNN' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-29-660cf856a78e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m     \u001b[0mclf\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mKNN\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      7\u001b[0m     \u001b[0mclf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0mpreds_tr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'KNN' is not defined"
     ]
    }
   ],
   "source": [
    "acc_tr=[]\n",
    "acc=[]\n",
    "x=np.arange(1,10)\n",
    "\n",
    "for i in x:\n",
    "    clf=KNN(i)\n",
    "    clf.fit(train,y_train)\n",
    "    preds_tr=clf.predict(train)\n",
    "    preds=clf.predict(test)\n",
    "    acc_tr.append(results.accuracy(y_train, preds_tr))\n",
    "    acc.append(results.accuracy(y_test, preds))\n",
    "# print(acc_tr,acc_tr2)\n",
    "# print(acc,acc2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f24dde46fd0>"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAD8CAYAAACb4nSYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQhT6IiIRotAXEYmQ/w+RHNDytUcSKgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f24ddf0fd30>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig,ax=plt.subplots()\n",
    "ax.scatter(list(x),acc_tr,label='Train Accuracy')\n",
    "ax.scatter(list(x),acc,color='r',label='Validation Accuracy')\n",
    "ax.legend(loc='upper right')\n",
    "# fig.savefig('knntrs.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn.naive_bayes import MultinomialNB\n",
    "acc_tr=[]\n",
    "acc=[]\n",
    "clf=BinomialNB(5)\n",
    "clf.fit(train,y_train)\n",
    "preds_tr=clf.predict(train)\n",
    "preds=clf.predict(test)\n",
    "acc_tr.append(results.accuracy(y_train, preds_tr))\n",
    "acc.append(results.accuracy(y_test, preds))\n",
    "acc_tr2=[]\n",
    "acc2=[]\n",
    "\n",
    "clf2=MultinomialNB()\n",
    "clf2.fit(train,y_train)\n",
    "preds_tr=clf2.predict(train)\n",
    "preds=clf2.predict(test)\n",
    "acc_tr2.append(results.accuracy(y_train, preds_tr))\n",
    "acc2.append(results.accuracy(y_test, preds))\n",
    "print(acc_tr,acc_tr2)\n",
    "print(acc,acc2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1047,)\n",
      "(262,)\n",
      "[0.78032473734479468] [0.78032473734479468]\n",
      "[0.7862595419847328] [0.7862595419847328]\n"
     ]
    }
   ],
   "source": [
    "acc_tr=[]\n",
    "acc=[]\n",
    "clf=GaussianNB()\n",
    "clf.fit(train,y_train)\n",
    "preds_tr=clf.predict(train)\n",
    "preds=clf.predict(test)\n",
    "# print(preds_tr,preds)\n",
    "acc_tr.append(results.accuracy(y_train, preds_tr))\n",
    "acc.append(results.accuracy(y_test, preds))\n",
    "# print(y_train,preds_tr)\n",
    "# print(y_test,preds)\n",
    "print(acc,acc_tr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "fig,ax=plt.subplots()\n",
    "ax.set_xlabel('False Positive Rate')\n",
    "ax.set_ylabel('True Positive Rate')\n",
    "ax.set_title('Receiver operating characteristic -multi-class')\n",
    "results.multiclass_roc_curve(y_test,probs_gb,ax,'gaussian bayes')\n",
    "results.multiclass_roc_curve(y_test,probs_knn,ax,'knn')\n",
    "results.multiclass_roc_curve(y_test,probs_kmeans,ax,'kmeans')\n",
    "results.multiclass_roc_curve(y_test,probs_gnb,ax,'gaussiannb')\n",
    "results.multiclass_roc_curve(y_test,probs_parzen,ax,'parzenwindow')\n",
    "ax.legend(loc=\"lower right\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FINAL RESULTS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|Dataset| Classifier  |   Parameter | Accuracy |Precision | Recall | F1-score |\n",
    "|--------|:-------:|-----|-------|------|-------|-------|\n",
    "|Medical Data|KNeighbours|| | || | \n",
    "|Medical Data|Gaussian Bayes|| | || | \n",
    "|Medical Data|Gaussian Mixture Model Naive Bayes|| | || | \n",
    "|Medical Data|Gaussian NB|| ||| |  \n",
    "|Medical Data|KMeans|| | || | \n",
    "|Train Selection Data|KNeighbours|| | || | \n",
    "|Train Selection Data|Gaussian Bayes|| | || | \n",
    "|Train Selection Data|Gaussian NB|| | || | \n",
    "|Train Selection Data|Bionomial NB|| | || | \n",
    "|Train Selection Data|KMeans|| | || | \n",
    "|Fashion-MNIST|KNeighbours|| | || | \n",
    "|Fashion-MNIST|Gaussian Bayes|| | || | \n",
    "|Fashion-MNIST|Gaussian NB|| | || | \n",
    "|Fashion-MNIST|KMeans|| | || | "
   ]
  },
  {
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}