stedavkle / ml-bundesliga Goto Github PK

Entwickelt einen Crawler der die Ergebnisse der letzten Saisons aus einer Webseite ausliest und speichert.
Die Ergebnisse können z. B. in eine CSV- oder JSON-Datei geschrieben werden.
Alternativ kann auch ein Datenbanksystem verwendet werden.

Folgende Felder sollten mindestens enthalten sein:

• Datum
• Heimverein
• Gastverein
• Tore Heim
• Tore Gast

z. B.

2009-08-07T20:30:00, Munich, Dusseldorf, 2, 0
2009-08-08T15:30:00, Paderborn, Hannover, 1, 1
...

Erweitert euren Datencrawler so, dass ihr auswählen könnt, aus welchem Intervall die Daten heruntergeladen werden sollen.
Es sollte z. B. möglich sein die Daten der letzten drei Saisons zu crawlen.
Ebenso sollte man die Daten von Spieltag 07 der Saison 2014/15 bis Spieltag 24 von Saison 2016/17 herunterladen können.
Es ist ausreichend, wenn man kontinuierliche Intervalle angeben kann (also nicht Saison 2014 aber ohne Spieltag X).

Diese Auswahlmöglichkeit wird dann interessant, wenn wir unsere Vorhersage-Algorithmen testen wollen.
Dann wollen wir z. B. die letzten fünf Saisons crawlen, aber nicht die bereits absolvierten Spiele der Saison.
Wir trainieren dann unseren Algorithmus auf den gecrawlten Daten und lassen ihn die bereits gespielten Partien dieser Saison vorhersagen.
Nun können wir die Vorhersagequalität des Algorithmus überprüfen. Wie viele der absolvierten Spiele dieser Saison hat er richtig vorhergesagt?

Als dritten Algorithmus beschäftigen wir uns mit der Poisson Regression.
Einen sehr guten Überblick gibt folgender Blog-Artikel, der sich auch gleich mit der Vorhersage von Fußballspielen beschäftigt:
https://dashee87.github.io/football/python/predicting-football-results-with-statistical-modelling/
oder auch https://opisthokonta.net/?p=276

Der wichtigste Teil ist der Abschnitt "Building A Model", wo das Poisson Modell gelernt wird.
Zum Implementieren des Algorithmus ist es ausreichend, wenn ihr das Generalized Linear Model richtig verwendet (poisson_model = smf.glm(formula="goals ~ home + team + opponent", data=goal_model_data, family=sm.families.Poisson()).fit())

Dabei kann es nützlich sein, Folgendes zu verstehen:
Eure Vorhersage, wie viele Tore eine Mannschaft schießt, setzt sich zusammen aus "home" (spielt sie daheim oder auswärts), "team" (was für ein Team ist es, wie stark ist es) und "opponent" (gegen welche Mannschaft spielt sie, wie stark ist die).
Ihr wollt also aus den historischen Daten diese Faktoren lernen.
Das bedeutet ihr lernt eine Zahl für "home" und jeweils 18 Zahlen für "team" und "opponent" (genau eine pro Team).

Ihr könnt nun für beide Teams berechnen, wie viele Tore es schießen wird, bzw. wie wahrscheinlich eine bestimmte Anzahl an Toren ist.
Damit könnt ihr eine Tabelle über alle möglichen Ergebnisse aufstellen und die Wahrscheinlichkeiten der Resultate aufsummieren, die zu einem Sieg, einer Niederlage oder einem Unentschieden führen würden.

Gebt dem Benutzer eine Möglichkeit auszuwählen, welcher eurer Algorithmen zur Vorhersage benutzt wird.
Diese Auswahl könnt ihr z. B. über eine Dropdown-Liste anbieten.

Idealerweise sollten automatisch alle verfügbaren Vorhersage-Algorithmen als Auswahlmöglichkeit auftauchen.
Neue Algorithmen sollten also nicht manuelle zur GUI hinzugefügt werden, sondern automatisch eingebunden werden.

Erweitert eure grafische Oberfläche, damit sie immer automatisch den nächsten Spieltag anzeigt.
Dabei sollten alle Begegnungen in einer Tabelle angezeigt werden und den nächsten noch ungespielten Spieltag anzeigen.

Schaut euch die heruntergeladenen Daten genauer an und versucht ein Gefühl dafür zu bekommen. Orientiert euch an Fragen wie den folgenden:

• wie häufig kommen welche Spielausgang vor? (Unentschieden/Heimsieg/Auswärtssieg)
• wie viele Tore werden im Mittel geschossen? (Gesamt/Heim/Gast)
• plottet euch die Trefferzahlen als Histogramm (wie häufig werden 0/1/2/3/… Tore geschossen)
• welcher Art von Verteilung könnten die Trefferzahlen folgen?
• wie breit ist diese Verteilung? (Standardabweichung)
• macht euch qualitativ Gedanken darüber, wie aussagekräftig ihr diese Statistiken berechnen könnt (habt ihr genug Daten)?
• könnt ihr die gleichen Statistiken auch für einzelne Teams berechnen?
• gibt es herausstechende Teams?
• fallen euch irgendwelche anderen Besonderheiten auf?

Später könnt ihr die Ergebnisse mit euren eigenen Vorhersagen vergleichen und zum Beispiel vergleichend plotten.

Implementiert ein weiteres Feature für euer Projekt.
Ihr seid komplett frei bei der Auswahl und könnt damit euer Framework einzigartig machen.

Es spielt keine Rolle, ob es dabei vor allem die GUI, die Algorithmen oder den Crawler erweitert.

Entwickelt eine grafische Oberfläche die mindestens die folgenden Elemente enthält:

• Einen Button, welcher den Crawler aktiviert
• Einen Button zum Starten des Trainingsvorgangs des Machine-Learning-Algorithmus
• Zwei Dropdown-Listen für die Heim- und Auswärtsmannschaft
• Ein Button, welcher die Gewinnwahrscheinlichkeiten ausgibt.

Berechnet die Wahrscheinlichkeiten für Gewinn, Unentschieden und Niederlage für zwei Mannschaften.
Verwendet dabei die Ergebnisse der letzten Saisons und zählt die relative Häufigkeit des jeweiligen Ergebnisses.

Beispiel:

In den letzten Saisons hat Dortmund daheim 10-mal gegen Köln gespielt.
Dabei hat Dortmund 8-mal gewonnen, 1-mal ging es unentschieden aus und 1-mal hat Köln gewonnen.
Damit ist die Gewinnwahrscheinlichkeit für Dortmund (daheim) gegen Köln: 8/10 = 80 %.
Die Gewinnwahrscheinlichkeit für Köln beträgt: 1/10 = 10 %.
Die Wahrscheinlichkeit für ein Unentschieden ist ebenfalls: 1/10 = 10 %.

Überlegt euch, was ihr ausgeben wollt, wenn keinerlei historische Daten für diese Begegnung vorliegen.

Ihr könnt euch auch andere Algorithmen und Variationen überlegen und implementieren. Zum Beispiel "Team mit mehr Treffern in der letzten Saison gewinnt", oder "Zuletzt erreichter Tabellenplatz entscheidet".

Gestaltet eine schöne und übersichtliches README für euer Programm.

Folgende Punkte könnten in eurer README vorkommen:

• Screenshot/Animation eures Programms
• Logo
• Was macht euer Programm?
• Wie installiert/startet man euer Programm?
• Badges (für Code Quality/Coverage/License/etc.)
• Kurzbeschreibung der verwendeten Algorithmen/Daten
• Lizenz
• ...

Beispiele für READMEs bekannter Programme auf Github sind:

• https://github.com/google/jax
• https://github.com/mwaskom/seaborn
• https://github.com/probabilistic-numerics/probnum
• https://github.com/bethgelab/foolbox

Bindet die Funktionalität zur Datenselektion (siehe Issue #X) in die grafische Oberfläche ein.
In eurer GUI sollte man auswählen können von wann bis wann Daten gecrawlt werden sollten.
Die Auswahl könnt ihr z. B. über Dropdown-Listen anbieten.

Nutzt nun die bereits implementierten Features, um eure Algorithmen zu evaluieren.
Überprüft für jeden implementierten Algorithmus (Minimaler, Erweiterter und Poisson) , wie gut er die realen Ergebnisse vorhersagen kann (bzw. hätte können).
Trainiert dafür jeden Algorithmus auf allen historischen Daten ausgenommen die Hinrunde dieser Saison.
Anschließend lasst ihr den Algorithmus die gesamte Hinrunde dieser Saison vorhersagen und vergleicht die vorhergesagten Resultate mit den tatsächlichen.
Präsentiert die Ergebnisse und vergleicht die Qualität der einzelnen Algorithmen.

Eine gute Beschreibung befindet sich auf

https://dashee87.github.io/football/python/predicting-football-results-with-statistical-modelling-dixon-coles-and-time-weighting/

Beachtet auch das Notebook, dass dort verlinkt ist.