Was ist Deep Learning?? Deep Learning-Tutorial

Dieser Artikel wurde im Rahmen der Data Science Blogathon.

Der Guide ist hauptsächlich für Anfänger, und ich werde versuchen, die Themen so gut wie möglich zu definieren und hervorzuheben. Dado que el tiefes LernenTiefes Lernen, Eine Teildisziplin der Künstlichen Intelligenz, verlässt sich auf künstliche neuronale Netze, um große Datenmengen zu analysieren und zu verarbeiten. Diese Technik ermöglicht es Maschinen, Muster zu lernen und komplexe Aufgaben auszuführen, wie Spracherkennung und Computer Vision. Seine Fähigkeit, sich kontinuierlich zu verbessern, wenn mehr Daten zur Verfügung gestellt werden, macht es zu einem wichtigen Werkzeug in verschiedenen Branchen, von Gesundheit... es un tema muy grande, Ich würde das ganze Tutorial in ein paar Teile aufteilen. Lesen Sie unbedingt die anderen Teile, wenn Sie dies hilfreich finden.

Inhalt

1. Einführung

• Was ist Deep Learning??
• Warum Deep Learning??
• Wie viele Daten sind groß?
• Einsatzgebiete von Deep Learning
• Unterschied zwischen Deep Learning und Machine Learning

2) Importieren Sie die erforderlichen Bibliotheken

3) Zusammenfassung

4) Logistische Regression

• Computergrafik
• Inicializando ParameterDas "Parameter" sind Variablen oder Kriterien, die zur Definition von, ein Phänomen oder System zu messen oder zu bewerten. In verschiedenen Bereichen wie z.B. Statistik, Informatik und naturwissenschaftliche Forschung, Parameter sind entscheidend für die Etablierung von Normen und Standards, die die Datenanalyse und -interpretation leiten. Ihre richtige Auswahl und Handhabung sind entscheidend, um genaue und relevante Ergebnisse in jeder Studie oder jedem Projekt zu erhalten....
• Vorwärtsausbreitung
• Optimierung mit Gradient Descent

5) Logistische Regression mit Sklearn

6) Abschließende Anmerkungen

Einführung

Was ist Deep Learning??

• Es ist ein Teilgebiet des maschinellen Lernens, inspiriert von den biologischen Neuronen des Gehirns und deren Übersetzung in künstliche neuronale Netze mit Repräsentationslernen.

Warum Deep Learning??

• Wenn das Datenvolumen steigt, Techniken des maschinellen Lernens, egal wie optimiert sie sind, beginnen, in Bezug auf Leistung und Genauigkeit ineffizient zu werden, während Deep Learning in solchen Fällen viel besser funktioniert.

Wie viele Daten sind groß?

• Gut, ein Schwellenwert kann nicht quantifiziert werden, damit die Daten als groß angesehen werden, aber, intuitiv, Sagen wir, eine Probe von einer Million könnte ausreichen, um zu sagen “Ist groß” (hier hätte Michael Scott seine berühmten Worte ausgesprochen “Das hat sie gesagt”).

Felder, in denen DL verwendet wird

• Bildklassifizierung, Spracherkennung, PNL (Verarbeitung natürlicher Sprache), Empfehlungssysteme, etc.

Unterschied zwischen Deep Learning und Machine Learning

• Deep Learning ist eine Teilmenge des maschinellen Lernens.
• De Maschinelles Lernen, Funktionen werden manuell bereitgestellt.
• Während Deep Learning Funktionen direkt aus Daten lernt.

Wir werden die verwenden Datensatz von Ziffern in Gebärdensprache die auf Kaggle verfügbar ist hier. Jetzt fangen wir an.

Importieren Sie erforderliche Bibliotheken

numpy als np importieren # Lineare Algebra
Pandas als pd importieren # Datenverarbeitung, CSV-Datei I/O (z.B. pd.read_csv)
import matplotlib.pyplot als plt
# Eingabedatendateien sind im "../Eingang/" Verzeichnis.
# Importwarnungen
Importwarnungen
# Filterwarnungen
Warnungen.Filterwarnungen('ignorieren')
aus Unterprozessimport check_output
drucken(check_output(["ls", "../Eingang"]).dekodieren("utf8"))
# Alle Ergebnisse, die Sie in das aktuelle Verzeichnis schreiben, werden als Ausgabe gespeichert.

Zusammenfassung der Daten

• Es gibt 2062 Bilder von Gebärdensprachziffern in diesem Datensatz.
• Da gibt es 10 Ziffern von 0 al 9, Es gibt 10 einzigartige Signalbilder.
• Am Anfang, wir werden nur verwenden 0 Ja 1 (um es den Schülern einfach zu halten)
• In den Daten, das Handzeichen für 0 ist zwischen den Indizes 204 Ja 408. Es gibt 205 Proben für 0.
• Was ist mehr, das Handzeichen für 1 ist zwischen den Indizes 822 Ja 1027. Es gibt 206 Proben.
• Deswegen, wir werden verwenden 205 Proben jeder Klasse (Notiz: in Wirklichkeit, 205 Samples sind viel weniger für ein richtiges Deep-Learning-Modell, aber da es ein Tutorial ist, wir können es ignorieren),

Jetzt bereiten wir unsere X- und Y-Matrizen vor, wobei X unsere Bildmatrix ist (Merkmale) und Y ist unsere Etikettenmatrix (0 Ja 1).

# Datensatz laden
x_l = np.Last('../input/Gebärdensprache-Ziffern-Datensatz/X.npy')
Y_l = np.Last('../input/Gebärdensprache-Ziffern-Datensatz/Y.npy')
img_size = 64
plt.subplot(1, 2, 1)
plt.imshow(x_l[260].umformen(img_size, img_size))
plt.achse('aus')
plt.subplot(1, 2, 2)
plt.imshow(x_l[900].umformen(img_size, img_size))
plt.achse('aus')

# Verbinde eine Folge von Arrays entlang einer Zeilenachse.
# von 0 zu 204 ist Nullzeichen und von 205 zu 410 ist ein Zeichen
X = np.konkatenat((x_l[204:409], x_l[822:1027] ), Achse=0)
z = np.null(205)
o = np.ones(205)
Y = np.konkatenat((Mit, Ö), Achse=0).umformen(X.Form[0],1)
drucken("X-Form: " , X.Form)
drucken("Y-Form: " , Y.Form)

Um unsere Matrix X . zu erstellen, Wir teilen und verketten zuerst unsere Segmente von Handzeichenbildern von 0 Ja 1 vom Datensatz zur Matrix X. Dann, wir machen etwas ähnliches mit Y, aber wir verwenden stattdessen die Tags.

1) Wir sehen also, dass die Form unserer Matrix X ist (410, 64, 64)

• Das 410 es bedeutet 205 Bilder von 0, 205 Bilder von 1.
• das 64 bedeutet, dass die Größe unserer Bilder ist 64 x 64 Pixel.

2) Die Y-Form ist (410,1), Daher, 410 Einsen und Nullen.

3) Nun teilen wir X und Y in Züge und Testsätze auf.

• Zug = 75%, Zug = 15%
• random_state = Benutze einen bestimmten Seed beim Randomisieren, Daher, wenn die Zelle mehrmals läuft, die generierte Zufallszahl ändert sich nicht jedes Mal. Es wird jedes Mal das gleiche Test- und Zuglayout erstellt.

# Dann erstellen wir x_train, y_train, x_test, y_test-Arrays
aus sklearn.model_selection import train_test_split
X_Zug, X_test, Y_Zug, Y_test = train_test_split(x, Ja, test_size=0.15, random_state=42)
number_of_train = X_train.shape[0]
number_of_test = X_test.shape[0]

Wir haben eine dreidimensionale Eingabematrix, Also müssen wir es auf 2D reduzieren, um unser erstes Deep-Learning-Modell zu füttern. Wie und schon 2D, wir lassen es so wie es ist.

X_train_flatten = X_train.reshape(Anzahl_der_Zug,X_train.shape[1]*X_train.shape[2])
X_test_flatten = X_test .reshape(number_of_test,X_test.shape[1]*X_test.shape[2])
drucken("X-Zug abflachen",X_train_flatten.shape)
drucken("X-Test abflachen",X_test_flatten.shape)

Wir haben jetzt insgesamt 348 Bilder, jeder mit 4096 píxeles en la matriz de AusbildungTraining ist ein systematischer Prozess zur Verbesserung der Fähigkeiten, körperliche Kenntnisse oder Fähigkeiten. Es wird in verschiedenen Bereichen angewendet, wie Sport, Aus- und Weiterbildung. Zu einem effektiven Trainingsprogramm gehört auch die Zielplanung, Regelmäßiges Üben und Bewerten der Fortschritte. Anpassung an individuelle Bedürfnisse und Motivation sind Schlüsselfaktoren, um in jeder Disziplin erfolgreiche und nachhaltige Ergebnisse zu erzielen.... x. Ja 62 Bilder gleicher Pixeldichte 4096 in der Testmatrix. Nun transponieren wir die Matrizen. Dies ist nur eine persönliche Entscheidung und Sie werden in den nächsten Codes sehen, warum ich das sage.

x_train = X_train_flatten.T
x_test = X_test_flatten.T
y_train = Y_train.T
y_test = Y_test.T
drucken("x_train: ",x_train.shape)
drucken("x_test: ",x_test.shape)
drucken("y_train: ",y_train.shape)
drucken("y_test: ",y_test.shape)

Jetzt sind wir also mit der Vorbereitung unserer erforderlichen Daten fertig. So sieht es aus:

Jetzt lernen wir eines der Grundmodelle von Dl . kennen, sogenannte logistische Regression.

Logistische Regression

Wenn es um binäre Klassifikation geht, Das erste Modell, das mir in den Sinn kommt, ist die logistische Regression. Aber man könnte sich fragen, was die logistische Regression beim Deep Learning nützt.? Die Antwort ist einfach, ya que la regresión logística es una rotes neuronalesNeuronale Netze sind Rechenmodelle, die von der Funktionsweise des menschlichen Gehirns inspiriert sind. Sie nutzen Strukturen, die als künstliche Neuronen bekannt sind, um Daten zu verarbeiten und daraus zu lernen. Diese Netze sind grundlegend im Bereich der künstlichen Intelligenz, Dies ermöglicht erhebliche Fortschritte bei Aufgaben wie der Bilderkennung, Verarbeitung natürlicher Sprache und Vorhersage von Zeitreihen, unter anderen. Ihre Fähigkeit, komplexe Muster zu erlernen, macht sie zu mächtigen Werkzeugen.. einfach. Die Begriffe neuronales Netz und Deep Learning gehen Hand in Hand. Logistische Regression verstehen, Zuerst müssen wir etwas über Computergrafik lernen.

Berechnungstabelle

Computergrafik kann als bildhafte Darstellung mathematischer Ausdrücke angesehen werden. Lass uns das an einem Beispiel verstehen. Angenommen, wir haben einen einfachen mathematischen Ausdruck wie:

c = ( ein² + B² ) ^1/2

Ihr Rechendiagramm wird:

Bildquelle: Autor

Schauen wir uns nun einen logistischen Regressionsberechnungsgraphen an:

Bildquelle: Kaggle-Datensatz

• Die Gewichte und der Bias werden als Modellparameter bezeichnet.
• Die Gewichte repräsentieren die Koeffizienten jedes Pixels.
• Die Schiefe ist der Schnittpunkt der Kurve, die durch Auftragen von Parametern gegen Labels gebildet wird.
• Z = (px1 * wx1) + (px2 * wx2) +…. + (px4096 * wx4096)
• y_head = sigmoid_funktion (MIT)
• Die Sigmoidfunktion skaliert im Wesentlichen den Wert von Z zwischen 0 Ja 1, so wird es eine Wahrscheinlichkeit.

Warum die Sigmoid-Funktion verwenden??

• Es gibt uns ein probabilistisches Ergebnis.
• Da es ein Derivat ist, podemos usarlo en el algoritmo de descenso de SteigungGradient ist ein Begriff, der in verschiedenen Bereichen verwendet wird, wie Mathematik und Informatik, um eine kontinuierliche Variation von Werten zu beschreiben. In Mathematik, bezieht sich auf die Änderungsrate einer Funktion, während des Studiums im Grafikdesign, Gilt für den Farbübergang. Dieses Konzept ist unerlässlich, um Phänomene wie die Optimierung von Algorithmen und die visuelle Darstellung von Daten zu verstehen, ermöglicht eine bessere Interpretation und Analyse in....

Nun werden wir jede der Komponenten des obigen Berechnungsgraphen im Detail untersuchen.

Initialisierungsparameter

Bildquelle: Microsoft-Dokumente

Jedes Pixel hat sein eigenes Gewicht. Aber die Frage ist, was werden Ihre Anfangsgewichte sein?? Dafür gibt es mehrere Techniken, die ich in diesem Teil behandeln werde 2 dieses Artikels, Aber für den Moment, wir können sie mit einem beliebigen Zufallswert initialisieren, Sagen wir 0.01.

Die Form der Gewichtsmatrix ist (4096, 1), da es insgesamt 4096 Pixel pro Bild, und sei der anfängliche Bias 0.

# lasst uns Parameter initialisieren
# Was wir also brauchen, ist Dimension 4096 das ist die Anzahl der Pixel als Parameter für unsere Initialisierungsmethode(def)
def initialize_weights_and_bias(Abmessungen):
    w = np.voll((Abmessungen,1),0.01)
    b = 0.0
    zurück w, B

w,b = initialize_weights_and_bias(4096)

Vorwärtsausbreitung

Alle Schritte von den Pixeln bis zur Kostenfunktion werden Vorwärtsausbreitung genannt.

Um Z zu berechnen, verwenden wir die Formel: Z = (wT) x + B. wobei x die Pixelmatrix ist, w gewichtet und b ist der Bias. Nach der Berechnung von Z, Wir führen es in die Sigmoid-Funktion ein, die y_head . zurückgibt (Wahrscheinlichkeit). Danach, calculamos la Verlust-FunktionDie Verlustfunktion ist ein grundlegendes Werkzeug des maschinellen Lernens, das die Diskrepanz zwischen Modellvorhersagen und tatsächlichen Werten quantifiziert. Ziel ist es, den Trainingsprozess zu steuern, indem dieser Unterschied minimiert wird, Dadurch kann das Modell effektiver lernen. Es gibt verschiedene Arten von Verlustfunktionen, wie z. B. mittlerer quadratischer Fehler und Kreuzentropie, jeder für unterschiedliche Aufgaben geeignet und... (Error).

Die Kostenfunktion ist die Summe aller Verluste und bestraft das Modell für falsche Vorhersagen. So lernt unser Modell die Parameter.

# Berechnung von z
#z = np.dot(w.T,x_train)+B
def sigmoid(Mit):
    y_kopf = 1/(1+np.exp(-Mit))
    zurück y_head

y_head = sigmoid(0)
y_head
> 0.5

Der mathematische Ausdruck der Verlustfunktion (Protokoll) es ist:

Wie ich bereits gesagt habe, Was die Verlustfunktion im Wesentlichen tut, ist, falsche Vorhersagen zu bestrafen. Hier ist der Code für die Vorwärtsausbreitung:

# Vorwärtsausbreitungsschritte:
# finde z = w.T*x+b
# y_head = sigmoid(Mit)
# Verlust(Error) = Verlust(Ja,y_head)
# Kosten = Summe(Verlust)
def forward_propagation(w,B,x_train,y_train):
    z = z.B. zu(w.T,x_train) + B
    y_head = sigmoid(Mit) # Wahrscheinlichkeitsrechnung 0-1
    Verlust = -y_train*np.log(y_head)-(1-y_train)*np.log(1-y_head)
    Kosten = (np.sum(Verlust))/x_train.shape[1]      # x_train.shape[1]  ist zum skalieren
    Rücksendekosten

Optimierung mit Gradient Descent

Bildquelle: Kursra

Unser Ziel ist es, die Werte unserer Parameter zu finden, für die, die Verlustfunktion ist das Minimum. Die Gleichung für den Gradientenabstieg lautet:

Wobei w das Gewicht oder der Parameter ist. Der griechische Buchstabe Alpha wird als Schrittweite bezeichnet. Was es bedeutet, ist die Größe der Iterationen, die wir nehmen werden, wenn wir den Hang hinuntergehen, um die lokalen Minima zu finden. Und der Rest ist die Ableitung der Verlustfunktion, auch bekannt als Gradient. Der Algorithmus für den Gradientenabstieg ist einfach:

1. Zuerst, Wir nehmen einen zufälligen Datenpunkt in unserem Graphen und finden seine Steigung.
2. Dann finden wir die Richtung, in der die Verlustfunktion abnimmt.
3. Aktualisieren Sie die Gewichte mit der obigen Formel. (Diese Methode wird auch als Backpropagation bezeichnet.)
4. Wählen Sie den nächsten Punkt mit einer Größe von α.
5. Wiederholen.

# Bei der Rückwärtsausbreitung verwenden wir y_head, das in der Vorwärtsausbreitung gefunden wurde
# Anstatt also eine Rückwärtsausbreitungsmethode zu schreiben, Lassen Sie uns Vorwärtsausbreitung und Rückwärtsausbreitung kombinieren
def forward_backward_propagation(w,B,x_train,y_train):
    # Vorwärtsausbreitung
    z = np.dot(w.T,x_train) + B
    y_head = sigmoid(Mit)
    Verlust = -y_train*np.log(y_head)-(1-y_train)*np.log(1-y_head)
    Kosten = (np.sum(Verlust))/x_train.shape[1]      # x_train.shape[1]  ist zum skalieren
    # Rückwärtsausbreitung
    Ableitungsgewicht = (np.dot(x_train,((y_head-y_train).T)))/x_train.shape[1] # x_train.shape[1]  ist zum skalieren
    derivative_bias = np.sum(y_head-y_train)/x_train.shape[1]                 # x_train.shape[1]  ist zum skalieren
    Steigungen = {"Ableitungsgewicht": Ableitungsgewicht,"derivative_bias": derivative_bias}
    Rücksendekosten,Steigungen

Jetzt aktualisieren wir die Lernparameter:

# Aktualisierung(Lernen) Parameter
def aktualisieren(w, B, x_train, y_train, Lernrate,number_of_iterarion):
    cost_list = []
    cost_list2 = []
    Index = []
    # Aktualisierung(Lernen) Parameter ist number_of_iterarion mal
    für mich in Reichweite(number_of_iterarion):
        # Machen Sie Vorwärts- und Rückwärtsausbreitung und finden Sie Kosten und Gradienten
        Kosten,Steigungen = forward_backward_propagation(w,B,x_train,y_train)
        cost_list.append(Kosten)
        # lass uns aktualisieren
        w = w - Lernrate * Steigungen["Ableitungsgewicht"]
        b = b - Lernrate * Steigungen["derivative_bias"]
        wenn ich % 10 == 0:
            cost_list2.append(Kosten)
            index.anhängen(ich)
            drucken ("Kosten nach Iteration %i: %F" %(ich, Kosten))
    # wir aktualisieren(lernen) Parameter Gewichte und Bias
    Parameter = {"Last": w,"Voreingenommenheit": B}
    plt.plot(Index,cost_list2)
    plt.xticks(Index,Rotation='vertikal')
    plt.xlabel("Anzahl der Iterationen")
    plt.ylabel("Kosten")
    plt.zeigen()
    Rückgabeparameter, Steigungen, Kostenliste

Parameter, Steigungen, cost_list = aktualisieren(w, B, x_train, y_train, Lernrate = 0,009, Anzahl_der_Iterarionen = 200)

Bisher, wir haben unsere Parameter gelernt. Das bedeutet, dass wir die Daten anpassen. Im Vorhersageschritt, Wir haben x_test als Eingabe und verwenden es, Wir machen Voraussagen.

 # Vorhersage
auf jeden Fall vorhersagen(w,B,x_test):
    # x_test ist eine Eingabe für die Vorwärtsausbreitung
    z = sigmoid(np.dot(w.T,x_test)+B)
    Y_Vorhersage = np.null((1,x_test.shape[1]))
    # wenn z größer ist als 0.5, unsere Vorhersage ist Zeichen eins (y_head=1),
    # wenn z kleiner als ist 0.5, unsere Vorhersage ist null (y_head=0),
    für mich in Reichweite(z.Form[1]):
        wenn z[0,ich]<= 0.5:
            Y_Vorhersage[0,ich] = 0
        anders:
            Y_Vorhersage[0,ich] = 1

    Y_Vorhersage zurückgeben

Vorhersagen(Parameter["Last"],Parameter["Voreingenommenheit"],x_test)

Jetzt machen wir unsere Vorhersagen. Lass uns alles zusammenfügen:

def logistische_regression(x_train, y_train, x_test, y_test, Lernrate ,  Anzahl_iterationen):
    # initialisieren
    Dimension = x_train.shape[0]  # das ist 4096
    w,b = initialize_weights_and_bias(Abmessungen)
    # Lernrate nicht ändern
    Parameter, Steigungen, cost_list = aktualisieren(w, B, x_train, y_train, Lernrate,Anzahl_iterationen)
    
    y_prediction_test = vorhersagen(Parameter["Last"],Parameter["Voreingenommenheit"],x_test)
    y_prediction_train = vorhersagen(Parameter["Last"],Parameter["Voreingenommenheit"],x_train)

    # Zug-/Testfehler drucken
    drucken("Zuggenauigkeit: {} %".Format(100 - np.mean(np.abs(y_prediction_train - y_train)) * 100))
    drucken("Testgenauigkeit: {} %".Format(100 - np.mean(np.abs(y_prediction_test - y_test)) * 100))
    
logistische Regression(x_train, y_train, x_test, y_test,Lernrate = 0.01, Anzahl_iterationen = 150)

Dann, Wie du siehst, selbst das grundlegendste Modell des Deep Learning ist ziemlich schwierig. Es ist nicht leicht für dich zu lernen, und Anfänger fühlen sich manchmal überfordert, all dies auf einmal zu studieren. Aber die Sache ist die, wir haben Deep Learning noch nicht angerührt., das ist wie die oberfläche. Es gibt noch viel mehr, was ich in dem Teil hinzufügen werde 2 dieses Artikels.

Da wir die Logik hinter der logistischen Regression kennengelernt haben, Wir können eine Bibliothek namens SKlearn verwenden, die bereits viele der integrierten Modelle und Algorithmen enthält, damit du nicht alles bei null anfangen musst.

Logistische Regression mit Sklearn

Ich werde in diesem Abschnitt nicht viel erklären, da Sie fast die gesamte Logik und Intuition hinter der logistischen Regression kennen.. Wenn Sie mehr über die Sklearn-Bibliothek erfahren möchten, Sie können die offizielle Dokumentation lesen hier. Hier ist der Code, und ich bin sicher, Sie werden fassungslos sein, wie wenig Aufwand es braucht:

aus sklearn import linear_model
logreg = linear_model.LogisticRegression(random_state = 42,max_iter= 150)
drucken("Testgenauigkeit: {} ".Format(logreg.fit(x_train.T, y_train.T).Spielstand(x_test.T, y_test.T)))
drucken("Zuggenauigkeit: {} ".Format(logreg.fit(x_train.T, y_train.T).Spielstand(x_train.T, y_train.T)))

Jawohl! das ist alles was es brauchte, Solo 1 Codezeile!

Abschließende Anmerkungen

Wir haben heute viel gelernt. Aber das ist nur der Anfang. Schaut euch das Teil unbedingt an 2 dieses Artikels. Sie finden es unter folgendem Link. Wenn dir gefällt, was du liest, Sie können einige der anderen interessanten Artikel lesen, die ich geschrieben habe.

Sitten | Autor bei DataPeaker

Ich hoffe du hattest viel Spaß beim Lesen meines Artikels. Gesundheit!!

Die in diesem Artikel gezeigten Medien über die besten Bibliotheken für maschinelles Lernen in Julia sind nicht Eigentum von DataPeaker und werden nach Ermessen des Autors verwendet.

Verwandt