Die Aktion `neuralNet.annTrain` ist ein leistungsstarkes Werkzeug innerhalb von SAS Viya, das zum Trainieren künstlicher neuronaler Netzwerke (KNN) verwendet wird. Sie ermöglicht es Benutzern, verschiedene Architekturen wie Mehrschicht-Perzeptrone (MLP), verallgemeinerte lineare Modelle (GLIM) und direkte Architekturen zu erstellen und zu optimieren. Diese Aktion ist von grundlegender Bedeutung für Aufgaben des überwachten Lernens, einschließlich Klassifizierung und Regression, und unterstützt auch das unüberwachte Lernen durch Autoencoding zur Dimensionsreduktion. Sie bietet eine breite Palette von anpassbaren Parametern, einschließlich Aktivierungsfunktionen, Optimierungsalgorithmen (z. B. L-BFGS, SGD), Regularisierungstechniken und Methoden zur Behandlung fehlender Werte, was eine feinkörnige Kontrolle über den Trainingsprozess ermöglicht.
| Parameter | Beschreibung |
|---|---|
| acts | Gibt die Aktivierungsfunktion für die Neuronen in jeder verborgenen Schicht an. |
| applyRowOrder | Gibt an, dass die Aktion eine vordefinierte Zeilenreihenfolge verwenden soll, um die Reproduzierbarkeit zu gewährleisten. |
| arch | Gibt die zu trainierende Netzwerkarchitektur an (z. B. 'MLP', 'GLIM'). |
| attributes | Gibt temporäre Attribute an, wie z. B. ein Format, das auf Eingabevariablen angewendet werden soll. |
| bias | Gibt einen festen Bias-Wert für alle verborgenen und Ausgabe-Neuronen an. In diesem Fall sind die Bias-Parameter fest und werden nicht optimiert. |
| casOut | Gibt die Ausgabetabelle für das trainierte Modell an. |
| code | Fordert an, dass die Aktion SAS-DATA-Step-Score-Code zur Bereitstellung des Modells erzeugt. |
| combs | Gibt die Kombinationsfunktion für die Neuronen in jeder verborgenen Schicht an. |
| delta | Gibt den Annealing-Parameter an, wenn eine globale Optimierung durch simuliertes Abkühlen (SA) durchgeführt wird. |
| dropOut | Gibt die Dropout-Rate für die verborgenen Schichten an, um eine Überanpassung zu verhindern. |
| dropOutInput | Gibt die Dropout-Rate für die Eingabeschichten an. |
| errorFunc | Gibt die Fehlerfunktion (Verlustfunktion) an, die während des Trainings optimiert werden soll (z. B. 'ENTROPY', 'NORMAL'). |
| freq | Gibt eine numerische Variable an, die die Häufigkeit des Auftretens jeder Beobachtung enthält. |
| fullWeights | Erzeugt das vollständige Gewichtsmodell für den LBFGS-Algorithmus. |
| hiddens | Gibt die Anzahl der Neuronen für jede verborgene Schicht an (z. B. {10, 5} für zwei Schichten). |
| includeBias | Gibt an, ob Bias-Parameter für die Neuronen in den verborgenen und Ausgabeschichten eingeschlossen werden sollen. |
| inputs | Gibt die Eingabevariablen (Features) für das Modell an. |
| inversePriors | Berechnet das Gewicht, das auf den Vorhersagefehler jeder nominalen Zielvariable angewendet wird, basierend auf der inversen Klassenhäufigkeit. |
| listNode | Gibt die Knoten (Eingabe, verborgen, Ausgabe) an, die in die Ausgabetabelle des Scoring-Codes aufgenommen werden sollen. |
| missing | Gibt an, wie fehlende Werte für die Eingabevariablen imputiert werden sollen ('MEAN', 'MIN', 'MAX', 'NONE'). |
| modelId | Gibt einen Modell-ID-Variablennamen an, der im generierten DATA-Step-Scoring-Code enthalten ist. |
| modelTable | Gibt die CAS-Tabelle an, die die Gewichte eines vortrainierten Modells zur Initialisierung des Netzwerks enthält. |
| nAnns | Gibt die Anzahl der Netzwerke an, die aus der angegebenen Anzahl von Versuchen ausgewählt werden sollen. |
| nloOpts | Gibt die Optionen für den nichtlinearen Optimierungsalgorithmus an (z. B. maximale Iterationen, Toleranz). |
| nominals | Gibt die nominalen (kategorialen) Eingabe- und Zielvariablen an. |
| nTries | Gibt die Anzahl der Versuche beim Trainieren von Netzwerken mit zufälligen Anfangsgewichten an. |
| randDist | Gibt die Verteilung zur zufälligen Generierung der anfänglichen Netzwerkverbindungsgewichte an. |
| resume | Setzt eine Trainingsoptimierung unter Verwendung von Gewichten aus einem vorherigen Training fort. |
| samplingRate | Gibt den Anteil der Daten an, der zum Erstellen eines neuronalen Netzwerks verwendet werden soll. |
| saveState | Gibt eine CAS-Tabelle an, in der der Zustand des Modells für zukünftige Vorhersagen oder erneutes Training gespeichert werden soll. |
| scaleInit | Gibt an, wie die anfänglichen Gewichte skaliert werden sollen. |
| seed | Gibt den Zufallszahlensamen für die Reproduzierbarkeit an. |
| std | Gibt die Standardisierungsmethode an, die auf die Intervall-Eingabevariablen angewendet werden soll. |
| step | Gibt eine Schrittgröße für Störungen der Netzwerkgewichte bei globalen Optimierungen an. |
| t | Gibt den künstlichen Temperaturparameter bei globalen Optimierungen wie simuliertem Abkühlen an. |
| table | Gibt die Eingabetabelle an, die die Trainingsdaten enthält. |
| target | Gibt die Ziel- oder Antwortvariable für das Training an. |
| targetAct | Gibt die Aktivierungsfunktion für die Neuronen in der Ausgabeschicht an. |
| targetComb | Gibt die Kombinationsfunktion für die Neuronen an den Ziel-Ausgabeknoten an. |
| targetMissing | Gibt an, wie fehlende Werte für die Zielvariable imputiert werden sollen. |
| targetStd | Gibt die Standardisierungsmethode an, die auf die Intervall-Zielvariable angewendet werden soll. |
| validTable | Gibt die Tabelle mit den Validierungsdaten an, um ein Überanpassen zu überwachen und das Training frühzeitig zu beenden. |
| weight | Gibt eine Variable zur Gewichtung der Vorhersagefehler für jede Beobachtung während des Trainings an. |
Wir verwenden die Tabelle `HMEQ` aus der `SAMPSIO`-Bibliothek, um unser neuronales Netzwerk zu trainieren. Diese Tabelle enthält Informationen über Hausbesitzer, die einen Kredit beantragen. Zuerst laden wir die Daten in eine CAS-Tabelle.
data casuser.hmeq; set sampsio.hmeq; run;
Dieses Beispiel trainiert ein einfaches Mehrschicht-Perzeptron (MLP) mit einer verborgenen Schicht von 10 Neuronen, um die Variable `BAD` basierend auf anderen Eingaben in der `HMEQ`-Tabelle vorherzusagen. Wir verwenden den L-BFGS-Algorithmus für 20 Iterationen.
| 1 | PROC CAS; |
| 2 | ACTION neuralNet.annTrain / |
| 3 | TABLE={name='hmeq', caslib='casuser'}, |
| 4 | inputs={{name='LOAN'}, {name='MORTDUE'}, {name='VALUE'}, {name='YOJ'}, {name='DEROG'}, {name='DELINQ'}, {name='CLAGE'}, {name='NINQ'}, {name='CLNO'}}, |
| 5 | nominals={{name='REASON'}, {name='JOB'}, {name='BAD'}}, |
| 6 | target='BAD', |
| 7 | hiddens={10}, |
| 8 | nloOpts={maxIters=20, algorithm='LBFGS'}, |
| 9 | seed=1234; |
| 10 | RUN; |
| 11 | QUIT; |
Dieses Beispiel zeigt ein detaillierteres Training. Wir partitionieren die Daten in Trainings- (50%) und Validierungssätze (50%). Wir verwenden ein MLP mit zwei verborgenen Schichten (20 und 15 Neuronen) und unterschiedlichen Aktivierungsfunktionen (TANH und RECTIFIER). Als Optimierungsalgorithmus wird der stochastische Gradientenabstieg (SGD) mit einer Lernrate von 0.01 und einem Momentum von 0.5 verwendet. Eine L1-Regularisierung wird ebenfalls angewendet, um eine Überanpassung zu verhindern. Das trainierte Modell wird zur späteren Verwendung in einer Tabelle gespeichert.
| 1 | PROC CAS; |
| 2 | dataProcessing.partition / |
| 3 | TABLE={name='hmeq', caslib='casuser'}, |
| 4 | partInd=true, fraction=0.5, seed=1234, |
| 5 | casOut={name='hmeq_part', caslib='casuser', replace=true}; |
| 6 | RUN; |
| 7 | |
| 8 | ACTION neuralNet.annTrain / |
| 9 | TABLE={name='hmeq_part', where='_PartInd_ = 1'}, |
| 10 | validTable={name='hmeq_part', where='_PartInd_ = 0'}, |
| 11 | inputs={{name='LOAN'}, {name='MORTDUE'}, {name='VALUE'}, {name='YOJ'}, {name='DEROG'}, {name='DELINQ'}, {name='CLAGE'}, {name='NINQ'}, {name='CLNO'}}, |
| 12 | nominals={{name='REASON'}, {name='JOB'}, {name='BAD'}}, |
| 13 | target='BAD', |
| 14 | hiddens={20, 15}, |
| 15 | acts={'TANH', 'RECTIFIER'}, |
| 16 | targetAct='SOFTMAX', |
| 17 | errorFunc='ENTROPY', |
| 18 | std='STD', |
| 19 | nloOpts={algorithm='SGD', sgdOpt={learningRate=0.01, momentum=0.5}, regL1=0.001, maxIters=50, printFreq=1}, |
| 20 | seed=5678, |
| 21 | modelTable={name='ann_model', caslib='casuser', replace=true}; |
| 22 | RUN; |
| 23 | QUIT; |
In diesem Beispiel wird die Aktion `annTrain` für das unüberwachte Lernen verwendet, um eine Autoencoder-Architektur zu erstellen. Es wird kein `target`-Parameter angegeben, sodass die Eingabevariablen sowohl als Eingaben als auch als Ziele dienen. Das Ziel ist es, eine komprimierte Darstellung der Daten in der verborgenen Schicht zu lernen. Wir verwenden eine Architektur mit drei verborgenen Schichten (10, 5, 10 Neuronen), um die Daten zu kodieren und zu dekodieren. Der Parameter `listNode='HIDDEN'` wird im `code`-Parameter verwendet, um nur die Werte der Neuronen der mittleren verborgenen Schicht (die Kodierung) im Scoring-Code auszugeben.
| 1 | PROC CAS; |
| 2 | ACTION neuralNet.annTrain / |
| 3 | TABLE={name='hmeq', caslib='casuser'}, |
| 4 | inputs={{name='LOAN'}, {name='MORTDUE'}, {name='VALUE'}, {name='YOJ'}, {name='DEROG'}, {name='DELINQ'}, {name='CLAGE'}, {name='NINQ'}, {name='CLNO'}}, |
| 5 | hiddens={10, 5, 10}, |
| 6 | std='MIDRANGE', |
| 7 | nloOpts={maxIters=100, algorithm='LBFGS'}, |
| 8 | code={casOut={name='hmeq_encoded', replace=true}, listNode='HIDDEN'}; |
| 9 | RUN; |
| 10 | QUIT; |