test2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "warning in stationary: failed to import cython module: falling back to numpy\n"
     ]
    }
   ],
   "source": [
    "#Importing libraries\n",
    "\n",
    "import json\n",
    "import csv\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "from os import listdir\n",
    "from sklearn import linear_model\n",
    "import random\n",
    "import copy\n",
    "import operator\n",
    "import GPy\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.calibration import CalibratedClassifierCV\n",
    "from sklearn import svm\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "#import alignment #my library \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Consider that maybe instead of computing the distance between strings would be better to match words?\n",
    "#Or other kinds of similarity computation\n",
    "\n",
    "#this is necessary because of the accents an other errors from scrapping around\n",
    "def levenshtein(s1, s2):\n",
    "    #https://en.wikipedia.org/wiki/Levenshtein_distance\n",
    "    if len(s1) < len(s2):\n",
    "        return lev(s2, s1)\n",
    "\n",
    "    # len(s1) >= len(s2)\n",
    "    if len(s2) == 0:\n",
    "        return len(s1)\n",
    "\n",
    "    previous_row = range(len(s2) + 1)\n",
    "    for i, c1 in enumerate(s1):\n",
    "        current_row = [i + 1]\n",
    "        for j, c2 in enumerate(s2):\n",
    "            insertions = previous_row[j + 1] + 1 # j+1 instead of j previous_row and current_row are 1 char longer\n",
    "            deletions = current_row[j] + 1       # than s2\n",
    "            substitutions = previous_row[j] + (c1 != c2)\n",
    "            current_row.append(min(insertions, deletions, substitutions))\n",
    "        previous_row = current_row\n",
    "\n",
    "    return previous_row[-1]\n",
    "\n",
    "\n",
    "def lev(s1,s2):\n",
    "    #convert to lower everything to avoid mistakes\n",
    "    return levenshtein(s1.lower(),s2.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Load classification\n",
    "classification = np.genfromtxt('/home/roc/workspace/fifa-db-players/final-classification.csv', delimiter=','\n",
    "                            , dtype=\"|S20\")\n",
    "classification = {x[0]:x[1] for x in classification} #transforming it into a dictionary\n",
    "\n",
    "\n",
    "#Load matches, results, bets\n",
    "match_infos = np.genfromtxt('/home/roc/workspace/fifa-db-players/match-results.csv', delimiter=',', skip_header=1 \n",
    "                     ,dtype=\"|S20\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  47.6315789474 %\n",
      "Accuracy:  48.4210526316 %\n",
      "Accuracy:  48.9473684211 %\n",
      "Accuracy:  47.8947368421 %\n",
      "Accuracy:  47.6315789474 %\n",
      "Accuracy:  48.1578947368 %\n",
      "Accuracy:  47.8947368421 %\n",
      "Accuracy:  27.3684210526 %\n",
      "Accuracy:  32.3684210526 %\n",
      "Accuracy:  25.7894736842 %\n",
      "Accuracy:  39.2105263158 %\n",
      "Accuracy:  28.1578947368 %\n",
      "Accuracy:  36.5789473684 %\n"
     ]
    }
   ],
   "source": [
    "#Prediction ability based on the betting sites\n",
    "hits = np.zeros(13)\n",
    "for row in match_infos:\n",
    "    h = int(row[4])\n",
    "    a = int(row[5])\n",
    "    for i in range(13):\n",
    "        if h > a : #home wins\n",
    "            if row[23+i*3+1] >= row[23+i*3] and row[23+i*3] <= row[23+i*3+2]:\n",
    "                hits[i] = hits[i]+1\n",
    "        if h < a : #away wins\n",
    "            if row[23+i*3+2] <= row[23+i*3] and row[23+i*3+1] >= row[23+i*3+2]:\n",
    "                hits[i] = hits[i]+1\n",
    "        if h == a : #draw\n",
    "            if row[23+i*3+1] <= row[23+i*3] and row[23+i*3+1] <= row[23+i*3+2]:\n",
    "                hits[i] = hits[i]+1\n",
    "for hit in hits:\n",
    "    print 'Accuracy: ',hit*100.0/len(match_infos),'%'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  54.4736842105 %\n"
     ]
    }
   ],
   "source": [
    "#Prediction ability based on the classification\n",
    "\n",
    "def get_position(team):\n",
    "    min_lev = [30, 99] #position, distance lev\n",
    "    for key,t in classification.iteritems():\n",
    "        dist = lev(team,t)\n",
    "        if dist<= min_lev[1]:\n",
    "            min_lev[0] = key\n",
    "            min_lev[1] = dist\n",
    "    return int(min_lev[0])\n",
    "\n",
    "hits = 0\n",
    "for match in match_infos:\n",
    "    th = match[2]\n",
    "    ta = match[3]\n",
    "    gh = int(match[4])\n",
    "    ga = int(match[5])\n",
    "    \n",
    "    if gh > ga: #home wins\n",
    "        if get_position(th) < get_position(ta):\n",
    "            hits = hits + 1\n",
    "    if gh < ga: #away wins\n",
    "        if get_position(th) > get_position(ta):\n",
    "            hits = hits + 1\n",
    "    #'''\n",
    "    if gh == ga:\n",
    "        if get_position(th)+1 == get_position(ta) or get_position(th) == get_position(ta)+1:\n",
    "            hits = hits+1\n",
    "    #'''\n",
    "\n",
    "print 'Accuracy: ',hits*100.0/len(match_infos),'%'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Getting the clubs relevant for this computation\n",
    "clubs = []\n",
    "c_names = listdir('/home/roc/workspace/fifa-db-players/club-data')\n",
    "for key, value in classification.iteritems():\n",
    "    min_lev = [30, 99] #position, distance lev\n",
    "    for c in c_names:\n",
    "        dist = lev(value,c[:-5])\n",
    "        if dist<= min_lev[1]:\n",
    "            min_lev[0] = c\n",
    "            min_lev[1] = dist\n",
    "    clubs.append(min_lev[0])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training\n"
     ]
    }
   ],
   "source": [
    "#preparing the dataset: teams, results, players (to be replaced by values)\n",
    "\n",
    "def get_file(team):\n",
    "    min_lev = [30, 99] #position, distance lev\n",
    "    for i in range(len(clubs)):\n",
    "        dist = lev(team,clubs[i])\n",
    "        if dist<= min_lev[1]:\n",
    "            min_lev[0] = clubs[i]\n",
    "            min_lev[1] = dist\n",
    "    return min_lev[0]\n",
    "\n",
    "\n",
    "\n",
    "matches = listdir('/home/roc/workspace/fifa-db-players/result-lineup/')\n",
    "\n",
    "#N_samples x N_features\n",
    "\n",
    "training = np.zeros((len(matches),133)) #133 = 22 (players) x 6 (6 feartures per player)+1 (the Y)\n",
    "i = 0\n",
    "for match in matches:\n",
    "    teams = str.split(match[:-5],'-v-')\n",
    "    with open('/home/roc/workspace/fifa-db-players/result-lineup/'+match) as data_file:    \n",
    "        match_lineup = data_file.read()\n",
    "    match_lineup = str.split(match_lineup,'\\\\t')\n",
    "    match_lineup[0] = match_lineup[0][1:]\n",
    "    match_lineup[len(match_lineup)-1] = match_lineup[len(match_lineup)-1][:-1]\n",
    "    players = match_lineup[5:]\n",
    "\n",
    "    with open('/home/roc/workspace/fifa-db-players/club-data/'+get_file(teams[0])) as data_file:    \n",
    "        team_info = json.load(data_file)\n",
    "\n",
    "    for player in range(len(players)):\n",
    "        if player>=11: #check that the change has been done where it is required\n",
    "            with open('/home/roc/workspace/fifa-db-players/club-data/'+get_file(teams[1])) as data_file:    \n",
    "                team_info = json.load(data_file)\n",
    "        \n",
    "        #find the closest player in team_info (not perfect, it might be not inside)\n",
    "        min_lev = [0, 999] #position, distance lev\n",
    "        for key, value in team_info.iteritems():\n",
    "            dist = lev(players[player], team_info[key]['name'])#lev(team,clubs[i])\n",
    "            if dist<= min_lev[1]:\n",
    "                min_lev[0] = key\n",
    "                min_lev[1] = dist\n",
    "                \n",
    "        #load ability in the training matrix\n",
    "        training[i][player*6+0] = team_info[min_lev[0]][\"abilities\"]['pas']\n",
    "        training[i][player*6+1] = team_info[min_lev[0]][\"abilities\"]['dri']\n",
    "        training[i][player*6+2] = team_info[min_lev[0]][\"abilities\"]['phy']\n",
    "        training[i][player*6+3] = team_info[min_lev[0]][\"abilities\"]['pac']\n",
    "        training[i][player*6+4] = team_info[min_lev[0]][\"abilities\"]['deff']\n",
    "        training[i][player*6+5] = team_info[min_lev[0]][\"abilities\"]['sho']\n",
    "\n",
    "    training[i][22*6] = int(match_lineup[4])\n",
    "        \n",
    "    i = i+1\n",
    "print 'training'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Separating the train and test datasets\n",
    "random.seed(8)\n",
    "\n",
    "index = random.sample(xrange(len(matches)), int(len(matches)*0.2)) #20% of testing\n",
    "\n",
    "test = training[index,:]\n",
    "train = np.delete(training, index,0)\n",
    "\n",
    "#More dataset separation\n",
    "X_train = train[:,:len(train[0])-1]\n",
    "Y_train = train[:,len(train[0])-1]\n",
    "\n",
    "X_test = test[:,:len(train[0])-1]\n",
    "Y_test = test[:,len(train[0])-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#computing accuracy\n",
    "def compute_accuracy(prediction, Y_test):\n",
    "    threshold = 0.3\n",
    "    accuracy = 0\n",
    "    for i in range(len(prediction)):\n",
    "        if prediction[i]-threshold > 0 and Y_test[i]>0: \n",
    "            accuracy = accuracy+1\n",
    "        elif prediction[i]+threshold < 0 and Y_test[i]<0: \n",
    "            accuracy = accuracy+1\n",
    "        elif Y_test[i]+threshold>prediction[i] and Y_test[i]-1*threshold<prediction[i]: \n",
    "            accuracy = accuracy+1\n",
    "    return accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy 46 %\n"
     ]
    }
   ],
   "source": [
    "#Do the linear regression\n",
    "\n",
    "regr = linear_model.LinearRegression()\n",
    "regr.fit(X_train,Y_train)\n",
    "prediction = regr.predict(X_test)\n",
    "prediction_linear = regr.predict(X_train)\n",
    "print 'accuracy', compute_accuracy(prediction, Y_test)*100/len(prediction),'%'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy 39 %\n"
     ]
    }
   ],
   "source": [
    "#Do gaussian process\n",
    "kernel = GPy.kern.RBF(1)\n",
    "m = GPy.models.GPRegression(X_train,Y_train[:, np.newaxis],kernel)\n",
    "m.optimize()\n",
    "prediction = m.predict(X_test,kernel)[0]\n",
    "prediction_gp = m.predict(X_train,kernel)[0]\n",
    "\n",
    "print 'accuracy', compute_accuracy(prediction, Y_test)*100/len(prediction),'%'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy 25 %\n",
      "accuracy 27 %\n"
     ]
    }
   ],
   "source": [
    "#Doing random forest\n",
    "clf = RandomForestClassifier(n_estimators=700)\n",
    "clf.fit(X_train, Y_train)\n",
    "prediction = clf.predict(X_test)\n",
    "prediction_rf = clf.predict(X_train)\n",
    "print 'accuracy', compute_accuracy(prediction, Y_test)*100/len(prediction),'%'\n",
    "\n",
    "#other\n",
    "sig_clf = CalibratedClassifierCV(clf, method=\"sigmoid\", cv=\"prefit\")\n",
    "sig_clf.fit(X_train, Y_train)\n",
    "prediction = sig_clf.predict(X_test)\n",
    "prediction_sig = sig_clf.predict(X_train)\n",
    "print 'accuracy', compute_accuracy(prediction, Y_test)*100/len(prediction),'%'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy 15 %\n"
     ]
    }
   ],
   "source": [
    "#SVM\n",
    "\n",
    "clf = svm.SVC()\n",
    "clf.fit(X_train, Y_train)\n",
    "prediction = clf.predict(X_test)\n",
    "prediction_SVM = clf.predict(X_train)\n",
    "print 'accuracy', compute_accuracy(prediction, Y_test)*100/len(prediction),'%'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy 15 %\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " /usr/local/lib/python2.7/dist-packages/sklearn/neural_network/multilayer_perceptron.py:561: ConvergenceWarning:Stochastic Optimizer: Maximum iterations reached and the optimization hasn't converged yet.\n"
     ]
    }
   ],
   "source": [
    "#neural network\n",
    "clf = MLPClassifier(solver='adam', alpha=1e-5, hidden_layer_sizes=(5, 2), random_state=1)#solversgd, adam, lbgfs\n",
    "clf.fit(X_train, Y_train)\n",
    "prediction = clf.predict(X_test)\n",
    "prediction_nn = clf.predict(X_train)\n",
    "print 'accuracy', compute_accuracy(prediction, Y_test)*100/len(prediction),'%'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "arrays used as indices must be of integer (or boolean) type",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-20-2cc7aca4fa36>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     36\u001b[0m         \u001b[0mhits\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mhits\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     37\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 38\u001b[1;33m         \u001b[1;32mprint\u001b[0m \u001b[0mle\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minverse_transform\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minput_\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m300\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;31m#,le.inverse_transform(input_[300+i,2])\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     39\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     40\u001b[0m \u001b[1;32mprint\u001b[0m \u001b[1;34m'accuracy'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mhits\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;36m100.0\u001b[0m\u001b[1;33m/\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mprediction\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'%'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m/usr/local/lib/python2.7/dist-packages/sklearn/preprocessing/label.pyc\u001b[0m in \u001b[0;36minverse_transform\u001b[1;34m(self, y)\u001b[0m\n\u001b[0;32m    168\u001b[0m             \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"y contains new labels: %s\"\u001b[0m \u001b[1;33m%\u001b[0m \u001b[0mstr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdiff\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    169\u001b[0m         \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 170\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mclasses_\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    171\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    172\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mIndexError\u001b[0m: arrays used as indices must be of integer (or boolean) type"
     ]
    }
   ],
   "source": [
    "#training using the bets and team names\n",
    "#row[23+i*3]\n",
    "input_ = np.ndarray((len(match_infos),41))\n",
    "#input_[:,0:2] = match_infos[:,2:4]\n",
    "for i in range(len(match_infos)):\n",
    "    #print match_infos[0,len(match_infos[0])-39:].astype(np.float)\n",
    "    try:\n",
    "        input_[i,2:] = match_infos[i,len(match_infos[0])-39:].astype(np.float)\n",
    "    except:\n",
    "        input_[i,2:] = 0\n",
    "#output_ = match_infos[:,6]\n",
    "\n",
    "from sklearn import preprocessing\n",
    "le = preprocessing.LabelEncoder()\n",
    "le.fit(match_infos[:,2])\n",
    "input_[:,0] = le.transform(match_infos[:,2]) \n",
    "input_[:,1] = le.transform(match_infos[:,3]) \n",
    "le2 = preprocessing.LabelEncoder()\n",
    "le2.fit(match_infos[:,6])\n",
    "output_ = le2.transform(match_infos[:,6]) \n",
    "#le.inverse_transform([0, 0, 1, 2])\n",
    "\n",
    "'''\n",
    "clf = MLPClassifier(solver='adam', alpha=1e-5, hidden_layer_sizes=(5, 2), random_state=1)#solversgd, adam, lbgfs\n",
    "clf.fit(input_, output_)\n",
    "prediction = clf.predict(input_)\n",
    "'''\n",
    "\n",
    "clf = RandomForestClassifier(n_estimators=600)\n",
    "clf.fit(input_[0:300,:], output_[:300])\n",
    "prediction = clf.predict(input_[300:])\n",
    "\n",
    "hits = 0\n",
    "for i in range(len(prediction)):\n",
    "    if prediction[i] == output_[i+300]:\n",
    "        hits = hits+1\n",
    "    else:\n",
    "        print le.inverse_transform(input_[300+i,1])#,le.inverse_transform(input_[300+i,2])\n",
    "    \n",
    "print 'accuracy', hits*100.0/len(prediction),'%'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bournemouth-v-aston-villa.json\n"
     ]
    }
   ],
   "source": [
    "for row in match_infos:\n",
    "    string = row[2]+'-v-'+row[3]+'.json'\n",
    "    print string.replace(' ','-').lower()\n",
    "    break\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}