Twoje pierwsze drzewo decyzyjne w Pythonie (NFL Combine)

Czy wyniki gracza w NFL Combine pozwalają przewidzieć, czy zostanie wybrany w drafcie? Zbudujmy model, aby się tego dowiedzieć!

Co to jest drzewo decyzyjne?

Drzewo decyzyjne to algorytm uczenia maszynowego używany do zadań klasyfikacji i regresji. Jest to rodzaj algorytmu uczenia nadzorowanego, co oznacza, że ​​jest szkolony na etykietowanych danych. Podstawową ideą drzewa decyzyjnego jest stworzenie modelu, który przewiduje wartość zmiennej docelowej na podstawie kilku zmiennych wejściowych.

Jak możemy to tutaj wykorzystać?

Jak wspomniano powyżej, drzewa decyzyjne mogą być używane do klasyfikacji (czy gracz zostanie wybrany w drafcie) z oznaczonymi danymi (NFL Combine wynika z przeszłości).

Zaimplementujmy to w Pythonie (pełny notatnik znaleziony tutaj:https://github.com/ant-vessicchio/learn_data_science_through_sports/blob/main/NFL_Combine/NFL_Combine_1st_Decision_Tree.ipynb)

Najpierw import, którego będziemy potrzebować:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn import tree

master_table = master_table = pd.read_csv("NFL.csv")
master_table.head()

      
                

                    
                    
                
            

X = master_table.iloc[:,3:9]
Y = master_table.iloc[:,-1]

      
                

                    
                    
                
            

      
                

                    
                    
                
            

#Drop Records Containing Null Values
X.dropna(inplace=True)  
X.isnull().sum() #Check

Co to znaczy?

Jest to technika stosowana w algorytmach uczenia maszynowego w celu oceny wydajności modelu bez uprzedzeń.

Zestaw szkoleniowy to część danych, która jest używana do uczenia modelu uczenia maszynowego. W tym zbiorze danych model „zna” wynik (jest prezentowany z etykietą wyjściową z Y) i wykorzysta te informacje do „dopasowania” modelu, który będzie mógł uogólnić na nowe i „niewidoczne” dane.

Zestaw testów służy do oceny, jak dobrze wyszkolony model działa na nowych, niewidocznych danych. Dane testowe obejmują zarówno dane wejściowe, jak i odpowiadające im etykiety wyjściowe, ale etykiety wyjściowe __nie__ są używane podczas testowania. Zamiast tego model dokonuje prognoz na danych testowych, a przewidywane wyniki są porównywane z rzeczywistymi wynikami w celu oceny wydajności modelu.

X_train, X_test, y_train, y_test = train_test_split(X,Y, test_size = 0.3, random_state=100)

Szkolenie i ocena modelu

W sklearn użyjemy klasy DecisionTreeClassifier. Pierwszym krokiem jest utworzenie instancji klasy i określenie dowolnych hiperparametrów, których chcesz użyć. Niektóre z powszechnie używanych hiperparametrów obejmują:

- max_głębokość: maksymalna głębokość drzewa decyzyjnego
- min_samples_split: minimalna liczba próbek potrzebnych do podziału węzła wewnętrznego
- kryterium: funkcja używana do pomiaru jakości podziału (np. „gini” lub „entropia”)

Na razie nie będziemy używać więcej niż to. I zachęcam do przeczytania dokumentacji sklearn, aby uzyskać więcej informacji!
https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html

clf = DecisionTreeClassifier(criterion = 'gini',min_samples_split = 3, max_depth = 3)

clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)

print(f" Accuracy score: {accuracy_score(y_test,y_pred)}")

      
                

                    
                    
                
            

Wizualizuj, co się dzieje:

Całkiem fajną cechą drzewa decyzyjnego są wizualizacje, które mogą zapewnić. Gdzie można zasadniczo zobaczyć punkt odcięcia dla każdej cechy podczas podejmowania decyzji, ile próbek zostało sklasyfikowanych w każdej klasie oraz indeks Giniego, który jest miarą tego, jak dobrze dany atrybut oddziela przykłady szkoleniowe w drzewie decyzyjnym.

plt.figure(figsize=(12,8))
from sklearn import tree
tree.plot_tree(clf.fit(X_train,y_train), feature_names = X_train.columns )
plt.show()

      
                

                    
                    
                
            

Bardzo fajną funkcją drzewa decyzyjnego jest generowanie ważności funkcji. Ważność cechy w drzewie decyzyjnym odnosi się do miary tego, jak ważna jest każda cecha lub zmienna wejściowa w określaniu ostatecznego wyniku drzewa.

# let's create a dictionary of features and their importance values
feat_dict= {}
for col, val in sorted(zip(X_train.columns, clf.feature_importances_),key=lambda x:x[1],reverse=True):
  feat_dict[col]=val

feat_df = pd.DataFrame({'Feature':feat_dict.keys(),'Importance':feat_dict.values()})
feat_df

      
                

                    
                    
                
            

Aby zrobić prostą ilustrację ważności funkcji:

import seaborn as sns
values = feat_df.Importance    
idx = feat_df.Feature
plt.figure(figsize=(10,8))
clrs = ['green' if (x < max(values)) else 'red' for x in values ]
sns.barplot(y=idx,x=values,palette=clrs).set(title='Feature Importance - Player Drafted (Y/N)')
plt.show()

      
                

                    
                    
                
            

Jakieś pomysły:

• Zmień/dodaj hiperparametry
• Zbuduj model dla każdej pozycji i sprawdź, czy poprawi to dokładność!
• Może spróbuj inaczej obsłużyć brakujące dane?

Jeśli podobał Ci się ten artykuł, skomentuj poniżej, śledź mnie, aby uzyskać więcej treści, i śledź cały mój bezpłatny kurs „Naucz się nauki o danych poprzez sport” hostowany na moim GitHub i SubReddit:

Zapraszam również do kontaktu ze mną na LinkedIn!https://www.linkedin.com/in/anthony-vessicchio/

Dziękuję bardzo i mam nadzieję, że podobał Ci się ten artykuł!