Einführung in Python Scikit-Learn, Matplotlib, Single-Layer-Algorithmus (~ in Richtung B3 ~ Teil3)

In Teil 3 werden wir einfaches maschinelles Lernen durchführen.

Maschinelles Lernen wird in drei Typen eingeteilt.

Fluss des maschinellen Lernens

Selbst wenn Sie maschinell lernen, können Sie nur selten gute Ergebnisse erzielen, wenn Sie ein Lernmodell erstellen und Daten eingeben. Der spezifische Workflow ist wie folgt.

1. Datenaufbereitung
   Bestimmen Sie den Inhalt der Daten, die das Modell trainieren und sammeln soll.
2. Modellauswahl
   Wählen Sie aus dem Datenformat und den Eigenschaften ein geeignetes Modell aus.
   Es gibt kein optimales Modell für alle Daten
   (No Free Ranch Theorem). Suchen Sie daher ein Modell, das Ihren Daten entspricht.
   Wenn es sich um ein Vorhersagemodell handelt, ist der Bewertungsindex die richtige Antwortrate.
3. Vorbehandlung
   Da die meisten Rohdaten nicht gut funktionieren, werden wir die Daten formatieren.
   Vervollständigung fehlender Daten
   -Extraktion von Merkmalsmengen
   - Gleiche Skala der in Daten enthaltenen Funktionen
   -Dimensionsreduzierung zur Komprimierung irrelevanter Merkmale (Rauschen)
   -Split-Daten zum Lernen und Auswerten
4. Modelltraining
   Wir werden mit dem ausgewählten Modell trainieren.
   Es gibt jedoch Parameter (Hyperparameter), die im Modell manuell angepasst werden müssen. Passen Sie sie daher ebenfalls an.
5. Modellbewertung
   Bewerten Sie das Modell (bewerten Sie die Generalisierungsleistung) anhand der zur Bewertung verbleibenden Daten.

Durch Wiederholen dieses Prozesses generieren wir ein geeignetes Lernmodell.

In diesem Seminar werden wir 3-5 machen. Da 3 jedoch größtenteils in Teil 2 ausgeführt wurde, konzentrieren wir uns bei den Modellen, die von nun an eingeführt werden sollen, auf 4 und 5.

Neuron

Was genau ist maschinelles Lernen? Warren McCulloch und Walter Pitts fragten sich, ob sie das menschliche Gehirn nachahmen könnten, um künstliche Intelligenz zu entwerfen. Daher haben wir das McCulloch-Pitts-Neuron angekündigt, eine vereinfachte Version des Neurons, der kleinsten Einheit des menschlichen Gehirns.

Neuronen empfangen chemische und elektrische Signale im Gehirn und erzeugen Ausgangssignale, wenn die akkumulierten Signale einen bestimmten Schwellenwert überschreiten. Sie betrachteten es als logisches Tor für die binäre Ausgabe und entwarfen MCP-Neuronen.

Einige Jahre später entwickelte Frank Rosenblatt einen Algorithmus, der automatisch den optimalen Gewichtungsfaktor lernte und ihn dann mit dem Eingangssignal multiplizierte, um festzustellen, ob das Neuron feuern würde (den Schwellenwert überschreiten). Dies ist der Beginn des "Klassifizierungsproblems" des "überwachten Lernens".

Die Definition von künstlichen Neuronen ist wie folgt. Der Gewichtsvektor für mehrere Eingangssignale $ \ boldsymbol {x} $ sei $ \ boldsymbol {w} $. Geben Sie die lineare Kombination jeder Eingabe $ x_i $ und ihres Gewichts $ w_i $ als Gesamteingabe $ z $ an.

z = \Sigma_i^Nw_i x_i=\boldsymbol{w}^T\boldsymbol{x} 

Teilen Sie den Ausgabewert der binären Klassifizierung in "1 (positive Klasse)" und "-1 (negative Klasse)". Definieren Sie eine Funktion $ \ phi $ (Bestimmungsfunktion), die die Gesamteingabe $ z $ in eine positive Klasse klassifiziert, wenn sie größer als der Schwellenwert $ \ theta $ ist, andernfalls wird sie als negative Klasse klassifiziert.

\phi(z) = \Biggl\{\begin{array}{l} 1  　(z \geq\Wenn Theta) \\-1　(z < \Wenn Theta)\end{array} 

Hier verschieben wir der Einfachheit halber den Schwellenwert $ \ theta $ nach links und definieren $ w_0 = - \ theta $, $ x_0 = 1 $. Die negative Schwelle von $ - \ theta $ zu diesem Zeitpunkt wird als Bias-Einheit bezeichnet.

\phi(z) = \Biggl\{\begin{array}{l} 1  　(z \Wenn geq0) \\-1　(z <Wenn 0)\end{array} 

Gewichtsaktualisierung (Lernen)

Maschinelles Lernen bezieht sich auf das Aktualisieren von Gewichten. Das Lernverfahren ist unten zusammengefasst.

1. Initialisieren Sie das Gewicht mit 0 oder einer kleinen Zufallszahl.
2. Führen Sie für jedes Trainingsmuster das folgende Verfahren aus. -① Berechnen Sie den Ausgabewert $ \ hat {y} $ -② Gewicht aktualisieren

Aktualisieren Sie das Gewicht $ w_j $ für eine bestimmte Eingabe $ x_j $ wie folgt:

w_j = w_j + \Delta w_j 

\Delta w_j = \eta(y^{(i)}-\hat{y}^{(i)})x_j

$ \ Eta $ ist jedoch die Lernrate, und je größer dieser Wert ist, desto mehr Jedes Trainingsmuster hat einen größeren Einfluss auf Gewichtsaktualisierungen. Der Unterschied zwischen der richtigen Klasse und der Ausgabebezeichnung $ (y ^ {(i)} - \ hat {y} ^ {(i)}) $ wird als Fehler bezeichnet.

Lassen Sie uns nun Perceptron implementieren.

class Perceptron(object):
    def __init__(self,eta=0.01,n_iter=50,random_state=1):
        #Definition der Lernrate
        self.eta=eta
        #Definition der Trainingsfrequenz
        self.n_iter=n_iter
        #Zufälliger Startwert zum Initialisieren von Gewichten
        self.random_state=random_state
    def fit(self,X,y):
        #Zufällige Generierung
        rgen=np.random.RandomState(self.random_state)
        #Schritt 1 Initialisierung des Gewichts
        self.w_=rgen.normal(loc = 0.0,scale=0.01,size=1+X.shape[1])
        #Fehlererklärung
        self.errors_=[]
        #Führen Sie die Anzahl der Schulungen durch
        for _ in range(self.n_iter):
            #Fehlerinitialisierung
            errors=0
            #Schritt 2 Für jedes Trainingsmuster ausführen
            for xi, target in zip(X,y):
                #Ausgabewertberechnung und Delta_Berechnung von w
                udelta_w = self.eta * (target - self.predict(xi))
                #Gewichtsaktualisierung
                self.w_[1:] += delta_w * xi
                self.w_[0] += delta_w
                errors += int(delta_w != 0.0)
            self.errors_.append(errors)
        return self
    
    #Definition der Gesamteingabe
    def net_input(self,X):
        return np.dot(X, self.w_[1:]) + self.w_[0]
    #Determinante Funktionsdefinition
    def predict(self,X):
        return np.where(self.net_input(X) >= 0.0,1,-1)

Verwenden wir dieses Perceptron, um die in Teil 2 verwendeten Irisdaten vorherzusagen.

import pandas as pd
df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data',header=None)
y = df.iloc[0:100,4].values
y = np.where(y == 'Iris-setosa',-1,1)
X = df.iloc[0:100,[0,2]].values
ppn = Perceptron(eta=0.01,n_iter=10)
ppn.fit(X,y)
plt.plot(range(1,len(ppn.errors_)+1), ppn.errors_,marker='o')
plt.xlabel('Epochs')
plt.ylabel('Number of errors')
plt.show()

Nach 10 Trainingseinheiten wie diesen verschwand die Fehlklassifizierung schließlich. Das Modell lernte den Datensatz durch Aktualisieren der Gewichte.

** Ergänzung ** Wenn dies dargestellt ist, wird es ein solcher Entscheidungsbereich sein.

from matplotlib.colors import  ListedColormap

def plot_decision_regions(X,y,classifier,resolution=0.02):
    markers = ('s','x','o','^','v')
    colors    = ('red','blue','lightgreen','gray','cyan')
    cmap     = ListedColormap(colors[:len(np.unique(y))])

    
    x1_min, x1_max = X[:,0].min() -1,X[:,0].max()+1
    x2_min, x2_max = X[:,1].min() -1,X[:,1].max()+1
    xx1,xx2 = np.meshgrid(np.arange(x1_min,x1_max,resolution),np.arange(x2_min,x2_max,resolution))
    Z = classifier.predict(np.array([xx1.ravel(),xx2.ravel()]).T)
    Z = Z.reshape(xx1.shape)
    plt.contourf(xx1,xx2,Z,alpha=0.3,cmap = cmap)
    plt.xlim(xx1.min(),xx1.max())
    plt.ylim(xx2.min(),xx2.max())

    for idx, cl in enumerate(np.unique(y)):
        plt.scatter(x = X[y == cl,0],y = X[y == cl,1],alpha = 0.8, c = colors[idx],marker=markers[idx],label=cl,edgecolor='black')


plot_decision_regions(X,y,classifier=ppn)
plt.xlabel('sepal length[cm]')
plt.ylabel('petal lemgth[cm]')
plt.legend(loc='upper left')

plt.show()

Herausforderungen

Mal sehen, wie sich das Lernen des Modells ändert, indem die Lernrate $ \ eta $ und die Anzahl der Trainings geändert werden

Scikit-learn Scikit-learn ist ein Modul, das viele einfache Klassifizierungsalgorithmen enthält. Es enthält auch das Perceptron, das ich zuvor implementiert habe. Probieren wir es aus.

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.linear_model import Perceptron
import numpy as np
#Erfassung von Irisdaten, Auswahl der zu verwendenden Daten
iris = datasets.load_iris()
X = iris.data[:,[2,3]]
y = iris.target
#Unterteilt in Testdaten und Zugdaten
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.3,random_state=1,stratify=y)
#Perceptron anrufen
ppn = Perceptron(n_iter_no_change=500,eta0=0.1,random_state=1)
#Trainieren Sie das Modell, um die Daten zu trainieren
ppn.fit(X_train,y_train)
#Validieren Sie das trainierte Modell
y_predict = ppn.predict(X_test)
#Anzeige der Anzahl der Fehlklassifizierungen
print('Misclassified samples: %d' %(y_test != y_predict).sum())
#Anzeige der richtigen Antwortrate
print('Accuracy: %.2f' %ppn.score(X_test,y_test))

Misclassified samples: 7
Accuracy: 0.84

Herausforderungen

Lassen Sie uns die Entscheidungsbereiche dieses Mal mit der Funktion plot_decision_regions veranschaulichen, die in der obigen Ergänzung verwendet wird.

image.png

Logistische Rückgabe

Was für ein Entscheidungsbereich ist es geworden? Perceptron ist ein Modell, das eine lineare Trennung durchführt, sodass eine lineare Trennung nicht möglich ist Nicht für Datensätze geeignet. Schauen wir uns also einen Algorithmus an, der als logistische Regression bezeichnet wird. Die logistische Regression verwendet ein Odds Ratio.

\frac{p}{(1-p)}

Das Odds Ratio ist das Verhältnis, das die Wahrscheinlichkeit eines Ereignisses angibt. $ p $ gibt die Wahrscheinlichkeit des Ereignisses an, das Sie vorhersagen möchten. Das Odds Ratio multipliziert mit dem natürlichen Logarithmus wird als Logit-Funktion bezeichnet.

logit(p)=log{\frac{p}{1-p}}

Mit dieser Funktion wird eine solche Beziehung zwischen der Merkmalsmenge und dem logarithmischen Quotenverhältnis hergestellt.

logit(p(y=1|x))=\boldsymbol{w}^T \boldsymbol{x}

p (y = 1 | x) ist die bedingte Wahrscheinlichkeit, dass die Stichprobe angesichts des Merkmals $ x $ zur Klasse 1 (y = 1) gehört. Dieses Mal möchte ich die Wahrscheinlichkeit vorhersagen, dass die Stichprobe zu einer bestimmten Klasse gehört

p(y=1|x) = \phi(z) = logit^{-1}(\boldsymbol{w}^T \boldsymbol{x})=\frac{1}{1+e^{-z}}

Es kann so ausgedrückt werden. Mit anderen Worten, die logistische Sigmoidfunktion (allgemein als Sigmoidfunktion bekannt) wird vor der Entscheidungsfunktion gebissen. Zur Aktualisierung des Gewichts wird der Ausgabewert nach Anwendung des logistischen Sigmoid als Vorhersagedaten für die Aktualisierung verwendet. Die Funktion, die auf diese Weise zwischen der Gesamteingabe und der Entscheidungsfunktion eingeht, wird als ** Aktivierungsfunktion ** bezeichnet. Da Perceptron das Gewicht aktualisiert, indem es die Ausgabe der Determinantenfunktion mit dem wahren Wert vergleicht, Der Unterschied, der beim Aktualisieren des Gewichts verwendet wurde, war ein diskreter Wert. Durch Einfügen der Aktivierungsfunktion wird der vorhergesagte Wert $ \ hat {y} $, der zum Aktualisieren des Gewichts verwendet wird, zu einem kontinuierlichen Wert.

Verwenden wir tatsächlich die logistische Regression.

from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(C=100.0,random_state=1)

Herausforderungen

Führen Sie den obigen Code aus und lernen Sie dann Irisdaten mit logistischer Regression Lassen Sie uns auch den Entscheidungsbereich nach dem Lernen veranschaulichen

image.png

Support Vector Machine (SVM)

Bei Perceptron war das Ziel, die Fehlklassifizierungsrate zu minimieren. Auf der anderen Seite in Support Vector Machine (SVM) Der Zweck besteht darin, die ** Marge ** zu maximieren. Der Rand ist die Entscheidungsgrenze der Klassifikation und der Entscheidungsgrenze am nächsten Es bezieht sich auf die Entfernung von der Trainingsprobe. Das obige Trainingsbeispiel heißt ** Support Vector **. Durch Anpassen der Entscheidungsgrenzen, um den Spielraum zu maximieren Als Klassifikator wird eine starke Entscheidungsgrenze erzeugt.

Sei $ y = f (\ boldsymbol {x}) $ die Klassifizierungsfunktion, die die Eingabe $ \ boldsymbol {x} $ in zwei Klassen klassifiziert. Angenommen, Sie haben $ n $ Trainingsbeispiele $ (\ boldsymbol {x_1}, y_1), (\ boldsymbol {x_2}, y_2), ..., (\ boldsymbol {x_m}, y_m) $. Hier definieren wir den linearen Klassifikator $ f (\ boldsymbol {x}) = sgn [\ boldsymbol {w} \ bullet \ boldsymbol {x} + b] $. Dies gibt 1 zurück, wenn $ \ boldsymbol {w} \ bullet \ boldsymbol {x} + b \ geq0 $, und -1, wenn $ \ boldsymbol {w} \ bullet \ boldsymbol {x} + b <0 $ Kehrt zurück. Zu diesem Zeitpunkt wird $ \ boldsymbol {w} \ bullet \ boldsymbol {x} + b = 0 $ als super gekrümmte Oberfläche bezeichnet. Der Abstand zwischen der super gekrümmten Oberfläche und der nächsten Probe (Trägervektor) beträgt

\frac{|\boldsymbol{w}\bullet\boldsymbol{x_i}+b|}{||\boldsymbol{w}||}

Es wird sein. Die Formel zur Maximierung des Spielraums lautet wie folgt.

\max_{\boldsymbol{w},b}\min_{i}\{\frac{|\boldsymbol{w}\bullet\boldsymbol{x_i}|+b}{||\boldsymbol{w}||}\}

Da sich die super gekrümmte Oberfläche nicht ändert, selbst wenn sie mit einer Konstanten multipliziert wird, für alle Proben

y_i(\boldsymbol{a}\bullet\boldsymbol{x_i}+b) \geq 1

Kann angenommen werden. Zu diesem Zeitpunkt beträgt die Marge

\min_{i}\{\frac{|\boldsymbol{w}\bullet\boldsymbol{x_i}|+b}{||\boldsymbol{w}||}\}=\frac{1}{||\boldsymbol{w}||}

Mit anderen Worten\frac{1}{||\boldsymbol{w}||}Sollte maximiert werden. das ist||\boldsymbol{w}||^2Ist gleichbedeutend mit Minimieren. Dies kann durch die sekundäre Programmiermethode gelöst werden.

Diese maximale Randklassifizierung ist nur gültig, wenn eine lineare Trennung möglich ist. In anderen Fällen werden wir eine Slack-Variable einführen.

Lineare Konventionsformel

y_i(\boldsymbol{w}\bullet\boldsymbol{x_i}+b) \geq 1

Führen Sie die Slack-Variable $ \ xi $ für ein. Dies ermöglicht akzeptable, aber kostspielige Stichproben, die die Einschränkungen nicht erfüllen und auch nichtlineare Probleme angehen.

y_i(\boldsymbol{w}\bullet\boldsymbol{x_i}+b) \geq 1-\xi

Durch Einführung der Slack-Variablen kann die maximale Randklassifizierung wie folgt beschrieben werden.

\frac{1}{2}||\boldsymbol{w}||^2+C(\Sigma_{i}{\xi^{(i)})}

Wir werden diese Variable $ C $ verwenden, um die Strafe für Fehlklassifizierungen zu kontrollieren. Je größer $ C $, desto größer die Strafe und desto schmaler die Randbreite. Eine solche Klassifizierung der maximalen Marge wird als Klassifizierung der weichen Marge bezeichnet. Die maximale Margin-Klassifizierung vor der Einführung von $ \ xi $ wird als Hard-Margin-Klassifizierung bezeichnet.

Dieses Mal verwenden wir die Soft-Margin-Klassifizierung (SVC).

from sklearn.svm import SVC
svm = SVC(kernel='linear',C = 1.0,random_state=1)
svm.fit(X_train,y_train)

Herausforderungen

Führen Sie den obigen Code aus und lernen Sie dann Iris-Daten mit SVC Lassen Sie uns auch den Entscheidungsbereich nach dem Lernen veranschaulichen

image.png

Es gibt eine effektive Methode für das nichtlineare Klassifizierungsproblem, die als ** Kernelisierung ** bezeichnet wird. SVMs sind einfacher zu kerneln als andere Klassifizierungsalgorithmen. Aus diesem Grund ist SVM eine beliebte Klassifizierungsmethode. Schauen wir uns ein Beispiel für nichtlineare Daten an, für die die Kernelisierung aktiviert ist.

import matplotlib.pyplot as plt
import numpy as np

np.random.seed(1)
X_xor = np.random.randn(200, 2)
y_xor = np.logical_xor(X_xor[:, 0] > 0,
                       X_xor[:, 1] > 0)
y_xor = np.where(y_xor, 1, -1)

plt.scatter(X_xor[y_xor == 1, 0],
            X_xor[y_xor == 1, 1],
            c='c', marker='x',
            label='1')
plt.scatter(X_xor[y_xor == -1, 0],
            X_xor[y_xor == -1, 1],
            c='m',
            marker='*',
            label='-1')

plt.xlim([-3, 3])
plt.ylim([-3, 3])
plt.legend(loc='best')
plt.tight_layout()

plt.show()

In einem solchen Fall ist es unmöglich, sie durch eine einzige gerade Linie zu trennen. Wenn Sie diese Daten jedoch auf eine höhere Dimension projizieren, ändert sich das Erscheinungsbild der Daten.

Projektionsfunktion $ \ phi (x_1, x_2) = (z_1, z_2, z_3) = (x_1, x_2, x_1 * x_2) $

Herausforderungen

Zeichnen wir die Daten in 3D als $ z = \ phi (x, y) $.

Gezeichnetes Video

np.random.seed(1)
X_xor = np.random.randn(200, 2)
y_xor = np.logical_xor(X_xor[:, 0] > 0,
                       X_xor[:, 1] > 0)
y_xor = np.where(y_xor, 1, -1)
svm = SVC(kernel='rbf', random_state=1, gamma=0.10, C=10.0)
svm.fit(X_xor, y_xor)
plot_decision_regions(X_xor, y_xor,
                      classifier=svm)

plt.legend(loc='upper left')
plt.tight_layout()

plt.show()

svm = SVC(kernel='rbf',random_state=1,gamma=0.20,C = 10.0)
svm.fit(X_train,y_train)
plot_decision_regions(X_combined,y_combined,classifier=svm)

plt.xlabel('petal length')
plt.ylabel('sepal length')
plt.legend(loc = 'upper left')
plt.tight_layout()
plt.show()

Herausforderungen

Lassen Sie uns überprüfen, wie sich der Entscheidungsbereich ändert, indem Sie den Wert von Gamma ändern

Entscheidungsbaum lernen

Der Entscheidungsbaumklassifikator ist ein Modell, das unter Berücksichtigung der Interpretierbarkeit der Bedeutung effektiv sein kann. Dieser Klassifikator trifft Entscheidungen basierend auf einer Reihe von Fragen und klassifiziert die Daten. Bei der Erläuterung des Entscheidungsbaumklassifikators wird zunächst der Index ** Informationsgewinn ** erläutert. Der Informationsgewinn bezieht sich auf die Verringerung der Variation in den Elementen jedes Satzes, wenn ein Satz geteilt wird. Der entscheidende Baum bildet durch bedingte Verzweigung einen Baum mit vielen Blättern, bis der Informationsgewinn verschwindet. Wenn ein Baum vollständig für Zugdaten erstellt wurde, kann es leicht zu Übertraining kommen (ein Modell, das nur für Zugdaten angepasst ist). Hören Sie auf, Zweige bis in die Tiefe zu wachsen. Dies wird als ** Beschneiden ** bezeichnet.

Die Zielfunktion des Entscheidungsbaum-Lernalgorithmus ist wie folgt.

IG(D_p,f)=\boldsymbol{I}(D_p)-\Sigma^{m}_{j=1}\frac{N_j}{N_p}\boldsymbol{I}(D_j)

Hier ist $ f $ die zu teilende Merkmalsmenge, $ D_p $ ist der übergeordnete Datensatz, $ N_p $ ist die Gesamtzahl der Stichproben des übergeordneten Knotens. $ D_j $ ist der j-te untergeordnete Datensatz, $ N_j $ ist die Gesamtzahl der j-ten untergeordneten Knoten und $ \ boldsymbol {I} $ ist unrein. Mit anderen Worten, der Informationsgewinn ist die Differenz zwischen der Reinheit des übergeordneten Knotens und der Reinheit des untergeordneten Knotens und ist ein Index zur Quantifizierung des Anteils von Stichproben verschiedener Klassen, die im Knoten gemischt sind. .. Die am häufigsten verwendeten Reinheitsindikatoren

• Gini unrein --Entropie
• Klassifizierungsfehler

Dort sind drei. Unter diesen gibt Gini Impureness das Verhältnis von Stichproben an, in denen $ p (i | t) $ zur Klasse $ i $ zum speziellen Knoten $ t $ gehört. Daher ist Gini unrein eine Bedingung, die die Wahrscheinlichkeit einer Fehlklassifizierung minimiert.

I_G(t)=\Sigma^c_{i=1}p(i|t)(1-p(i|t)) = 1-\Sigma^c_{i=1}p(i|t)^2

Der Entscheidungsbaum lernt, durch welchen Wert die Beispieldaten geteilt werden müssen, um eine bedingte Verzweigung mit weniger Fehlklassifizierung zu erstellen.

Klassifizieren wir die Irisdaten mit einem Entscheidungsbaumklassifikator mit einer Entscheidungsbaumtiefe von 4.

from sklearn.tree import DecisionTreeClassifier
tree  = DecisionTreeClassifier(criterion='gini',max_depth=4,random_state=1)

Herausforderungen

Führen Sie den obigen Code aus und lernen Sie dann die Irisdaten mit dem Entscheidungsbaum Lassen Sie uns auch den Entscheidungsbereich nach dem Lernen veranschaulichen Versuchen Sie, die Tiefe des Entscheidungsbaums (max_depth) zu ändern, und sehen Sie, wie sich der Entscheidungsbereich ändert.

image.png

Zufälliger Wald

Der Random Forest-Algorithmus ist die Idee, ein Modell mit höherer Generalisierungsleistung (das alle Daten verarbeiten kann) zu erstellen, indem mehrere tiefe Entscheidungsbäume gemittelt werden. Das Kombinieren mehrerer Algorithmen auf diese Weise wird als ** Ensemble-Lernen ** bezeichnet. Es ist üblich, verschiedene Modelle zu kombinieren.

Die zufällige Gesamtstruktur wird wie folgt ausgeführt.

1. Wählen Sie diese Stichprobe zufällig aus den Trainingsdaten aus.
2. Erstellen Sie einen Entscheidungsbaum basierend auf dem ausgewählten Beispieldatensatz. 3.2 Wiederholen Sie 2
3. Sammeln Sie die Vorhersage-Labels für jeden Entscheidungsbaum und weisen Sie Klassen-Labels basierend auf der ** Mehrheitsentscheidung ** zu.

Lassen Sie uns nun die Irisdaten in einer zufälligen Gesamtstruktur klassifizieren.

from sklearn.ensemble import RandomForestClassifier
forest  = RandomForestClassifier(n_estimators=25,criterion='gini',random_state=1,n_jobs=2)

Herausforderungen

Führen Sie den obigen Code aus und lernen Sie dann Irisdaten in einer zufälligen Gesamtstruktur Lassen Sie uns auch den Entscheidungsbereich nach dem Lernen veranschaulichen

image.png

k Nachbarschaftsmethode

Die k-Nachbarschaftsmethode, auch als Lazy Learning bezeichnet, speichert und klassifiziert Datensätze, ohne daraus zu lernen. Der k-Nachbarschaftsalgorithmus führt die folgenden Schritte aus:

1. Wählen Sie den Wert von k und den Abstandsindex
2. Finden Sie aus der Stichprobe, die Sie klassifizieren möchten, k nächste Nachbarn.
3. Weisen Sie Klassenbezeichnungen mehrheitlich aus den Klassenbezeichnungen benachbarter Daten zu.

Der Vorteil dieser Methode ist, dass sie kein Lernen erfordert und sofort in die Klassifizierungsphase versetzt wird. Es ist jedoch zu beachten, dass der Rechenaufwand enorm ist, wenn die Menge der Trainingsdaten zu groß ist.

Lassen Sie uns tatsächlich mit der k-Nachbarschaftsmethode klassifizieren.

from sklearn.neighbors import KNeighborsClassifier
knn =  KNeighborsClassifier(n_neighbors=5,p=2,metric='minkowski')

Herausforderungen

Führen Sie den obigen Code aus und lernen Sie dann die Irisdaten mit der k-Near-Methode Lassen Sie uns auch den Entscheidungsbereich nach dem Lernen veranschaulichen

image.png

Zusammenfassung

Herausforderungen

Verwenden wir Titandaten, um das Überleben vorherzusagen! Die Spalte, die diese Zeit verwendet werden soll 'Passenderld','Age','Pclass','Sex','FamilySize' Wird besorgt.