[PYTHON] Unausgeglichenes Datenlernen mit maschinellem Lernen k-NN

(Hinzugefügt am 25.02.2020) TODO: Die Gewichte von k-NN werden aus der Summe der Entfernungen ohne Verwendung der Umkehrung der Entfernungen berechnet. Es wird auf die Umkehrung der Entfernung korrigiert. (Die Berechnungsmethode von KNeighborsClassifier ist nicht falsch, aber die Berechnungsmethode meiner eigenen Funktion ist falsch.)

Fazit


Bilddiagramm vor スクリーンショット 2020-02-24 12.39.05.png

Bilddiagramm nach スクリーンショット 2020-02-24 12.38.55.png

Hintergrund / Probleme

Methode

Keine Einstellung für unausgeglichene Daten

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

import sklearn
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix, accuracy_score

%matplotlib inline
from sklearn.datasets import make_classification
data_base = make_classification(
    n_samples = 10000, n_features = 2, n_informative = 2, n_redundant = 0, 
    n_repeated = 0, n_classes = 2, n_clusters_per_class = 2, weights = [0.9, 0.1], 
    flip_y = 0, class_sep = 0.5, hypercube = True, shift = 0.0, 
    scale = 1.0, shuffle = True, random_state =5)

df = pd.DataFrame(data_base[0], columns = ['f1', 'f2'])
df['class'] = data_base[1]

fig = plt.figure()
ax = fig.add_subplot()
for i in df.groupby('class'):
    cls = i[1]
    ax.plot(cls['f1'],
              cls['f2'],
               'o',
            ms=2)

plt.show()

image.png

X = df[["f1","f2"]]
y = df["class"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)

X_train = X_train.reset_index(drop=True)
X_test = X_test.reset_index(drop=True)
y_train = y_train.reset_index(drop=True)
y_test = y_test.reset_index(drop=True)

print("train", X_train.shape, y_train.shape)
print("test", X_test.shape, y_test.shape)

train (7000, 2) (7000,) test (3000, 2) (3000,)


from sklearn.neighbors import KNeighborsClassifier
clf = KNeighborsClassifier(n_neighbors=5)
clf.fit(X_train, y_train)

pred = clf.predict(X_test)
    
result   = confusion_matrix(y_test, pred)
result2 = accuracy_score(y_test, pred)

print("confusion matrix \n",result) 
print("accuracy \n", result2 )

confusion matrix [[2641 67] [ 167 125]] accuracy 0.922

Es gibt eine Einstellung für unausgeglichene Daten

size_and_weight = pd.DataFrame({
                'class0': [sum(clf._y == 0),1/ (sum(clf._y == 0)/ len(clf._y))],
                'class1': [sum(clf._y == 1),1/ (sum(clf._y == 1)/ len(clf._y))]}).T
size_and_weight.columns = ['sample_size', 'weight']
size_and_weight
sample_size weight
class0 6292.0 1.112524
class1 708.0 9.887006


weights_array = pd.Categorical(clf._y)
weights_array.categories = [size_and_weight.loc[('class0'),'weight'],
                            size_and_weight.loc[('class1'),'weight']]

clf = KNeighborsClassifier(n_neighbors=5)
clf.fit(X_train, y_train)
neigh_dist, neigh_ind = clf.kneighbors(X_test) #Der Datenrahmen dieses Teils wird später beschrieben.

weights_array = np.array(weights_array).reshape((-1, 1))[neigh_ind,0]
pd.DataFrame(weights_array).head()
0 1 2 3 4
0 1.112524 1.112524 1.112524 1.112524 1.112524
1 1.112524 1.112524 1.112524 1.112524 1.112524
2 1.112524 9.887006 1.112524 1.112524 1.112524
3 1.112524 1.112524 1.112524 1.112524 1.112524
4 1.112524 1.112524 1.112524 1.112524 1.112524

--Stellen Sie die Argumentgewichte ein, um das Gewicht zu berücksichtigen, und führen Sie sie bis zur Vorhersage aus

def tmp(array_):
    global weights_array
    array_ = array_ * weights_array
    return array_

clf = KNeighborsClassifier(n_neighbors=5,weights=tmp)
clf.fit(X_train, y_train)
pred = clf.predict(X_test)

pred = clf.predict(X_test)
result   = confusion_matrix(y_test, pred)
result2 = accuracy_score(y_test, pred)

print("confusion matrix \n",result) 
print("accuracy \n", result2 )

confusion matrix [[2252 456] [ 80 212]] accuracy 0.8213333333333334

Fazit

--KNeighborsClassifier klassifiziert Testdaten in die Klasse mit der größten Gesamtentfernung. (Obwohl es ein leicht kontraintuitiver Algorithmus ist, dass das Schätzergebnis in einer entfernten Klasse liegt, wird die Entfernungsberechnung nur auf die nächsten n Daten angewendet. Wenn also kein Gewicht angewendet wird, liegt die Schätzung näher an einer Mehrheitsentscheidung als an der Summe der Entfernungen. Es wird.)

Details: Informationen zu Anpassungsargumenten

Ersetzen Sie die Summe durch "Elementprodukt von sum and weight_array"

Dabei ist es notwendig, die Entsprechung zwischen den folgenden Datenrahmen zu verstehen.


Verstehe die Entsprechung von neigh_dist, neigh_ind, y_train (clf._y) aus der Tabelle.

neigh_dist, neigh_ind = clf.kneighbors(X_test)
pd.DataFrame(neigh_dist).tail(5)
pd.DataFrame(neigh_ind).tail(5)
pd.DataFrame(clf._y.reshape((-1, 1))[neigh_ind,0]).tail(5)

image.png

Von links von ↑ wird es zu neighbour_dist, neigh_ind, "neigh_ind class"

Verstehen Sie die Entsprechung zwischen neighbour_dist, X_train und X_test aus der Berechnung von neigh_dist.

--DataFrame: Berechnen Sie die folgenden Zahlen für neigh_dist --index = 2998 # 2998. Testdaten --values = 0.015318 # Abstand zwischen [den 1374. Daten von X_train, die als nächstgelegene Entfernung bestimmt wurden] und [Testdaten des obigen Index]

test_index = 2998
tmp1 = pd.DataFrame(X_test.iloc[test_index])
display(tmp1.T)

train_index = 1374
tmp2 = pd.DataFrame(X_train.iloc[train_index])
display(tmp2.T)

image.png

#Berechnen Sie den euklidischen Abstand
(
sum(   (tmp1.values - tmp2.values)  **2    )
**(1/2)
)

array([0.01531811])

--Über neigh_dist.iloc [2998,0]: könnte aus den Trainingsdaten und den Testdaten berechnet werden.

Korrespondenz zwischen y_train und clf_knn._y

sum(clf_knn._y == y_train) == len(y_train)

True

Korrespondenz zwischen neigh_ind und "neigh_ind class"

index_ = neigh_ind[2998,:]
pd.DataFrame(clf._y[index_]).T

image.png

Schließlich

-Kapitel [Details: Informationen zu benutzerdefinierten Argumenten] erläutert nur den Quellcode des KNeighborsClassifier.predict-Teils, sodass der Quellcode von git möglicherweise schneller angezeigt wird. Referenz git sklearn

Recommended Posts

Unausgeglichenes Datenlernen mit maschinellem Lernen k-NN
Ich habe mit der maschinellen Vorverarbeitung von Python Data begonnen
Maschinelles Lernen mit Pokemon gelernt
Datensatz für maschinelles Lernen
Maschinelles Lernen mit Python! Vorbereitung
Maschinelles Lernen Minesweeper mit PyTorch
Beginnend mit maschinellem Python-Lernen
Versuchen Sie es mit Kaggle leicht maschinell
Einführung in das maschinelle Lernen mit scikit-learn-Von der Datenerfassung bis zur Parameteroptimierung
Vorverarbeitung beim maschinellen Lernen 3 Fehlende Wert- / Ausreißer- / Ungleichgewichtsdaten
Ich habe maschinelles Lernen mit liblinear versucht
Maschinelles Lernen mit Python (1) Gesamtklassifizierung
Umgang mit unausgeglichenen Daten
SVM versucht maschinelles Lernen mit Scikit-Learn
Maschinelles Lernen in Delemas (Datenerfassung)
Vorverarbeitung beim maschinellen Lernen 2 Datenerfassung
Quanteninspiriertes maschinelles Lernen mit Tensornetzwerken
Beginnen Sie mit dem maschinellen Lernen mit SageMaker
"Scraping & maschinelles Lernen mit Python" Lernnotiz
Vorverarbeitung beim maschinellen Lernen 4 Datenkonvertierung
Grundlegendes maschinelles Lernverfahren: ② Daten vorbereiten
Sammeln von Daten zum maschinellen Lernen
[Maschinelles Lernen] Überprüfen Sie die Leistung des Klassifikators anhand handgeschriebener Zeichendaten
Maschinelles Lernen
Vorhersage des Strombedarfs durch maschinelles Lernen Teil 2
Verstärken Sie Bilder für maschinelles Lernen mit Python
Maschinelles Lernen mit Python (2) Einfache Regressionsanalyse
Eine Geschichte über maschinelles Lernen mit Kyasuket
Python: Vorverarbeitung beim maschinellen Lernen: Datenerfassung
[Shakyo] Begegnung mit Python zum maschinellen Lernen
[Python] Erste Datenanalyse / maschinelles Lernen (Kaggle)
Maschinelles Lernen mit Pytorch in Google Colab
Datenanalyse beginnend mit Python (Datenvorverarbeitung - maschinelles Lernen)
Python: Vorverarbeitung beim maschinellen Lernen: Datenkonvertierung
Vorverarbeitung beim maschinellen Lernen 1 Datenanalyseprozess
Aufbau einer KI / maschinellen Lernumgebung mit Python
Python: Vorverarbeitung beim maschinellen Lernen: Umgang mit fehlenden / Ausreißern / unausgeglichenen Daten
Ich habe mit Python mit dem maschinellen Lernen begonnen (ich habe auch angefangen, in Qiita zu posten). Datenvorbereitung
[Python] Einfache Einführung in das maschinelle Lernen mit Python (SVM)
Maschinelles Lernen beginnend mit Python Personal Memorandum Part2
Datenversorgungstricks mit deque beim maschinellen Lernen
Maschinelles Lernen beginnend mit Python Personal Memorandum Part1
[Python] Datenanalyse, maschinelles Lernen (Kaggle) -Datenvorverarbeitung-
[Python] Sammeln Sie Bilder mit Icrawler für maschinelles Lernen [1000 Blatt]
Maschinelles Lernen von Grund auf neu (maschinelles Lernen mit Kaggle)
Maschinelles Lernen Aufteilung der Trainingsdaten und Lernen / Vorhersage / Verifizierung
[Memo] Maschinelles Lernen
Klassifikation des maschinellen Lernens
[Maschinelles Lernen] Erstellen Sie ein Modell für maschinelles Lernen, indem Sie Transferlernen mit Ihrem eigenen Datensatz durchführen
Richten Sie die Anzahl der Stichproben zwischen Datenklassen für maschinelles Lernen mit Python aus
Maschinelles Lernen mit Docker (40) mit Anaconda (40) "Hands-On Data Science und Python Machine Learning" von Frank Kane
Geschichte rund um die Datenanalyse durch maschinelles Lernen
Erstellen Sie eine Python-Umgebung für maschinelles Lernen mit Containern
Beispiel für maschinelles Lernen
Vorhersage der Zielzeit eines vollständigen Marathons mit maschinellem Lernen - Visual: Visualisierung von Daten mit Python-
Ich habe versucht, maschinelles Lernen (Objekterkennung) mit TouchDesigner zu verschieben
Einfaches maschinelles Lernen mit AutoAI (Teil 4) Jupyter Notebook
Maschinelles Lernen mit Raspberry Pi 4 und Coral USB Accelerator