फुटबॉल परिणामों की भविष्यवाणी

रूसी प्रीमियर लीग (RPL) में फुटबॉल मैचों के परिणामों की भविष्यवाणी करने के लिए स्किकिट-लर्न लाइब्रेरी का उपयोग करके पायथन में एक मशीन सीखने का मॉडल।

प्रविष्टि

मैं इस लेख को मशीन लर्निंग: 2018 ईपीएल गणित की भविष्यवाणी करते हुए लिखने के लिए प्रेरित हुआ। हमारे मशीन लर्निंग मॉडल आगामी खेलों के परिणामों की भविष्यवाणी करने के लिए 2015/2016 सीज़न से शुरू होने वाले रूसी प्रीमियर लीग (आरपीएल) के मैचों के आंकड़ों पर प्रशिक्षण देगा। डेटा wyscout.com फुटबॉल सांख्यिकी वेबसाइट से लिया गया है।
कोड और डेटा गितुब पर उपलब्ध हैं।

डेटा

हम आवश्यक पुस्तकालयों को जोड़ते हैं:

import pandas as pd import numpy as np import collections 

मैच का डेटा गितुब पर है।

 data = pd.read_csv("RPL.csv", encoding = 'cp1251', delimiter=';') data.head() 

हम 2018/2019 सीज़न के दूसरे भाग (यानी 2019 में खेले गए मैचों) के लिए मैच परिणामों की भविष्यवाणी करेंगे। इस सीज़न में खेलने वाली टीमों की सूची (आर्सेनल, ओरेनबर्ग, डायनमो, क्रिलिया सोवेतोव और येनिसी को शामिल नहीं करती है, क्योंकि उनके पास या तो पिछले सीज़न के आँकड़े नहीं हैं, या उन पर कुछ आँकड़े हैं):

 RPL_2018_2019 = pd.read_csv('Team Name 2018 2019.csv', encoding = 'cp1251') teamList = RPL_2018_2019['Team Name'].tolist() teamList 

हम उन टीमों के साथ मैच हटाते हैं जो सीजन 2018/2019 में भाग नहीं लेते हैं:

 deleteTeam = [x for x in pd.unique(data['']) if x not in teamList] for name in deleteTeam: data = data[data[''] != name] data = data[data[''] != name] data = data.reset_index(drop=True) 

एक सीजन के लिए टीम के आंकड़े लौटाने वाले कार्य:

 def GetSeasonTeamStat(team, season): goalScored = 0 #  goalAllowed = 0 #  gameWin = 0 # gameDraw = 0 # gameLost = 0 # totalScore = 0 #   matches = 0 #   xG = 0 #  shot = 0 # shotOnTarget = 0 #   cross = 0 # accurateCross = 0 #  totalHandle = 0 #  averageHandle = 0 #     Pass = 0 # accuratePass = 0 #  PPDA = 0 #    for i in range(len(data)): if (((data[''][i] == season) and (data[''][i] == team) and (data[''][i] == 2)) or ((data[''][i] == season-1) and (data[''][i] == team) and (data[''][i] == 1))): matches += 1 goalScored += data[''][i] goalAllowed += data[''][i] if (data[''][i] > data[''][i]): totalScore += 3 gameWin += 1 elif (data[''][i] < data[''][i]): gameLost +=1 else: totalScore += 1 gameDraw += 1 xG += data['xG'][i] shot += data[''][i] shotOnTarget += data['  '][i] Pass += data[''][i] accuratePass += data[' '][i] totalHandle += data[''][i] cross += data[''][i] accurateCross += data[' '][i] PPDA += data['PPDA'][i] averageHandle = round(totalHandle/matches, 3) #      return [gameWin, gameDraw, gameLost, goalScored, goalAllowed, totalScore, round(xG, 3), round(PPDA, 3), shot, shotOnTarget, Pass, accuratePass, cross, accurateCross, round(averageHandle, 3)] 

समारोह उपयोग उदाहरण:

 GetSeasonTeamStat("", 2018) #    2017/2018 

सुविधा के लिए, हम कोड जोड़ सकते हैं:

 returnNames = ["", "", "", "\n ", " ", "\n ", "\nxG ( )", "PPDA ( )", "\n", "  ", "\n", " ", "\n", " ", "\n (   )"] for i, n in zip(returnNames, GetSeasonTeamStat("", 2018)): print(i, n) 

सीजन के लिए सभी टीमों के आंकड़े लौटाएंगे:

 def GetSeasonAllTeamStat(season): annual = collections.defaultdict(list) for team in teamList: team_vector = GetSeasonTeamStat(team, season) annual[team] = team_vector return annual 

मॉडल प्रशिक्षण

हम एक फ़ंक्शन लिखेंगे जो प्रशिक्षण डेटा लौटाएगा। वह सभी मौसमों के लिए टीम वैक्टर के साथ एक शब्दकोश बनाती है। प्रत्येक गेम के लिए, फ़ंक्शन एक निश्चित सीज़न के लिए टीमों के वैक्टर के बीच अंतर की गणना करता है और इसे xTrain पर लिखता है। यदि घर की टीम जीतती है, और 0 अन्यथा, तो फ़ंक्शन तब 1 तक yTrain सेट करता है।

 def GetTrainingData(seasons): totalNumGames = 0 for season in seasons: annual = data[data[''] == season] totalNumGames += len(annual.index) numFeatures = len(GetSeasonTeamStat('', 2016)) #     xTrain = np.zeros(( totalNumGames, numFeatures)) yTrain = np.zeros(( totalNumGames )) indexCounter = 0 for season in seasons: team_vectors = GetSeasonAllTeamStat(season) annual = data[data[''] == season] numGamesInYear = len(annual.index) xTrainAnnual = np.zeros(( numGamesInYear, numFeatures)) yTrainAnnual = np.zeros(( numGamesInYear )) counter = 0 for index, row in annual.iterrows(): team = row[''] t_vector = team_vectors[team] rivals = row[''] r_vector = team_vectors[rivals] diff = [a - b for a, b in zip(t_vector, r_vector)] if len(diff) != 0: xTrainAnnual[counter] = diff if team == row['']: yTrainAnnual[counter] = 1 else: yTrainAnnual[counter] = 0 counter += 1 xTrain[indexCounter:numGamesInYear+indexCounter] = xTrainAnnual yTrain[indexCounter:numGamesInYear+indexCounter] = yTrainAnnual indexCounter += numGamesInYear return xTrain, yTrain 

हम 2015/2016 से 2018/2019 तक सभी मौसमों के लिए प्रशिक्षण डेटा सीखते हैं।

 years = range(2016,2019) xTrain, yTrain = GetTrainingData(years) 

जीतने की संभावना का अनुमान लगाने के लिए, हम Scikit-Learn लाइब्रेरी से LinearRegression मशीन लर्निंग एल्गोरिदम का उपयोग करेंगे।

 from sklearn.linear_model import LinearRegression model = LinearRegression() model.fit(xTrain, yTrain) 

हम एक फ़ंक्शन लिखेंगे जो पूर्वानुमान लौटाएगा। यह 0 और 1 के बीच एक मान लौटाएगा, जहां 0 नुकसान है और 1 लाभ है।

 def createGamePrediction(team1_vector, team2_vector): diff = [[a - b for a, b in zip(team1_vector, team2_vector)]] predictions = model.predict(diff) return predictions 

परिणाम

उदाहरण के लिए, आइए ज़ेनिट - स्पार्टक मैच के लिए एल्गोरिदम की भविष्यवाणियों को देखें

 team1_name = "" team2_name = "" team1_vector = GetSeasonTeamStat(team1_name, 2019) team2_vector = GetSeasonTeamStat(team2_name, 2019) print (',   ' + team1_name + ':', createGamePrediction(team1_vector, team2_vector)) print (',   ' + team2_name + ':', createGamePrediction(team2_vector, team1_vector)) 

यह पता चला है कि मैच में ज़ीनत - स्पार्टक, ज़ीनत के लिए जीत की संभावना 47% है (03/17/2019 स्पार्टक 1-1 ज़ीनिट)।

मैं निम्नलिखित दिए गए पूर्वानुमान लगाने का प्रस्ताव करता हूं:
40% तक - टीम ने सिर्फ जीत (हार या ड्रॉ) नहीं जीता
40% से 60% तक - एक ड्रॉ की उच्च संभावना
60% से - टीम निश्चित रूप से नहीं हारेगी (जीत या ड्रा)

अन्य सभी क्लबों के खिलाफ CSKA के लिए पूर्वानुमान

 for team_name in teamList: team1_name = "" team2_name = team_name if(team1_name != team2_name): team1_vector = GetSeasonTeamStat(team1_name, 2019) team2_vector = GetSeasonTeamStat(team2_name, 2019) print(team1_name, createGamePrediction(team1_vector, team2_vector), " - ", team2_name, createGamePrediction(team2_vector, team1_vector,)) 

एल्गोरिथ्म ने लगभग सभी मैचों के लिए एक सही पूर्वानुमान दिया जो एक ड्रॉ में समाप्त नहीं हुआ। एकमात्र गलत पूर्वानुमान: CSKA मास्को - ज़ीनिट। CSKA की जीत की संभावना 0.001 से अधिक है, यह माना जा सकता है कि टीमें ताकत में बराबर हैं और ड्रॉ में खेलेंगी, लेकिन अंत में ज़ीनत ने जीत हासिल की (3-1)।

निष्कर्ष

हमारा एल्गोरिथ्म बहुत आदिम है। यह केवल मैचों के आंकड़ों (और फिर केवल 15 मूल मापदंडों) को ध्यान में रखता है, और फुटबॉल में परिणाम कई कारकों पर निर्भर करता है। यहां तक ​​कि मैदान या मौसम की स्थिति खेल के परिणाम को प्रभावित कर सकती है।

अगला, मैं संकेतों की संख्या में वृद्धि करना चाहता हूं, एक परीक्षण नमूना बना सकता हूं, विभिन्न एल्गोरिदम की कोशिश कर सकता हूं, मॉडल को कॉन्फ़िगर कर सकता हूं और सबसे सटीक पूर्वानुमान प्राप्त कर सकता हूं।

यदि आप अपने विचारों और टिप्पणियों को छोड़ देते हैं तो मैं आभारी रहूंगा।