Multithreading in Data Mining- und Machine Learning-Prozeduren

Multithreading, oder die gleichzeitige Ausführung von Threads, ermöglicht erhebliche Leistungssteigerungen im Vergleich zur sequentiellen Ausführung. Bei Prozeduren, die in CAS ausgeführt werden, wird die Anzahl der Threads durch die Installation bestimmt. Das Multithreading-Modell basiert hauptsächlich auf der Aufteilung der auf einer einzelnen Maschine verarbeiteten Daten auf die verfügbaren Threads. Wenn beispielsweise eine Tabelle mit 1.000 Beobachtungen von vier Threads verarbeitet wird, verwaltet jeder Thread 250 Beobachtungen. Alle Operationen, die auf Daten zugreifen (wie die Normalisierung von Variablen, die Bildung von Matrizen, die Berechnung von Zielen, Gradienten, Hess'schen Matrizen und das Scoring von Beobachtungen), sind dann multithreaded. Auch Matrixoperationen profitieren vom Multithreading, wenn die Größe der Matrizen ausreicht, um die Verwaltung mehrerer Threads zu rechtfertigen.

Datenanalyse

Type : CREATION_INTERNE

Die Beispiele verwenden generierte Daten (Datalines) oder SASHELP-Tabellen, um ihre Autonomie zu gewährleisten.

1 Codeblock

PROC FACTMAC Data

Erklärung :
Dieses Beispiel veranschaulicht eine grundlegende Verwendung der FACTMAC-Prozedur. Es beginnt mit der Erstellung einer kleinen Datentabelle im CAS-Speicher (`casuser.produits`). Anschließend wird `PROC FACTMAC` auf dieser Tabelle ausgeführt, wobei ein einfaches Modell spezifiziert wird, in dem 'prix' die abhängige Variable und 'produit' und 'stock' die Prädiktoren sind. Das Ergebnis wird in einer neuen CAS-Tabelle, 'casuser.factmac_output', gespeichert. Multithreading wird vom CAS-Server automatisch verwaltet, um die Berechnungen zu optimieren, indem die Beobachtungen auf die verfügbaren Threads verteilt werden.

Kopiert!

1	/* Création d'une table CAS simple pour la démonstration */
2	DATA casuser.produits;
3	INPUT produit $ prix stock;
4	DATALINES;
5	Pomme 1.0 100
6	Banane 0.5 200
7	Orange 1.2 150
8	Poire 0.8 120
9	Raisin 2.5 50
10	;
11	RUN;
12
13	/* Exécution basique de PROC FACTMAC */
14	PROC FACTMAC DATA=casuser.produits;
15	model prix = produit stock;
16	OUTPUT out=casuser.factmac_output;
17	RUN;
18
19	/* Affichage des résultats (partiel) */
20	PROC PRINT DATA=casuser.factmac_output (obs=5);
21	RUN;
22
23	PROC CASUTIL incaslib=\"casuser\";
24	droptable casdata=\"produits\" quiet;
25	droptable casdata=\"factmac_output\" quiet;
26	RUN;

2 Codeblock

PROC FOREST Data

Erklärung :
Dieses Beispiel verwendet `PROC FOREST`, um ein Zufallswaldmodell zu trainieren, das die Kundentreue vorhersagt. Es enthält gängige Optionen wie `NTREE` zur Angabe der Anzahl der zu erstellenden Bäume, `MAXDEPTH` für die maximale Tiefe der Bäume und `SEED` für die Reproduzierbarkeit. Die intensiven Berechnungen zur Baumkonstruktion und Datenverarbeitung werden von CAS automatisch auf mehrere Threads parallelisiert, was die Modellschulung beschleunigt. Die Ergebnisse und das trainierte Modell werden in CAS-Tabellen gespeichert.

Kopiert!

1	/* Création d'une table CAS pour la démonstration de classification */
2	DATA casuser.clients;
3	call streaminit(123);
4	DO i=1 to 1000;
5	age = rand('uniform', 18, 65);
6	revenu = rand('normal', 50000, 15000);
7	satisfaction_produit = ceil(rand('uniform', 1, 5));
8	IF revenu > 60000 and age > 30 THEN
9	loyal = 1;
10	ELSE
11	loyal = 0;
12	OUTPUT;
13	END;
14	drop i;
15	RUN;
16
17	/* Exécution de PROC FOREST avec des options courantes */
18	PROC FOREST DATA=casuser.clients;
19	INPUT age revenu satisfaction_produit;
20	target loyal;
21	ods OUTPUT FitStatistics=casuser.forest_stats;
22	train ntree=100 seed=1234 maxdepth=10;
23	save rstore=casuser.forest_model;
24	RUN;
25
26	/* Affichage des statistiques d'ajustement */
27	PROC PRINT DATA=casuser.forest_stats;
28	RUN;
29
30	PROC CASUTIL incaslib=\"casuser\";
31	droptable casdata=\"clients\" quiet;
32	droptable casdata=\"forest_stats\" quiet;
33	droptable casdata=\"forest_model\" quiet;
34	RUN;

3 Codeblock

PROC NNET Data

Erklärung :
Dieses Beispiel demonstriert das Scoring von Daten mit einem Machine-Learning-Modell, basierend auf einem gängigen Ansatz, bei dem ein Modell (wie NNET) trainiert und dann zur Vorhersage neuer Daten verwendet wird. Obwohl `PROC NNET` hier nicht explizit für das Training aufgerufen wird (um die Demonstration ohne ein komplexes, bereits vorhandenes Modell zu vereinfachen), ist das Konzept des Scorings großer Datenmengen für Multithreading sehr relevant. Der Data Step wird direkt auf den Daten im CAS-Speicher ausgeführt, und CAS verteilt die Berechnungsaufgaben (hier die Scoring-Simulation) automatisch auf mehrere Threads, was eine effiziente Verarbeitung großer Datensätze ermöglicht.

Kopiert!

1	/* Création d'une table CAS avec des données de test */
2	DATA casuser.test_data;
3	call streaminit(456);
4	DO i=1 to 200;
5	age = rand('uniform', 20, 70);
6	revenu = rand('normal', 60000, 20000);
7	satisfaction_produit = ceil(rand('uniform', 1, 5));
8	OUTPUT;
9	END;
10	drop i;
11	RUN;
12
13	/* Utilisation d'un modèle NNET pré-entraîné (ici, simulé par des coefficients simples) */
14	/* Dans un scénario réel, un modèle NNET serait entraîné et sauvegardé */
15	/* Ici, nous simulons l'étape de scoring */
16
17	DATA casuser.scored_data;
18	SET casuser.test_data;
19	/* Simulation d'un scoring simple basé sur les inputs */
20	score_loyal = 0.5 + 0.01 * age + 0.00001 * revenu - 0.1 * satisfaction_produit;
21	IF score_loyal > 0.7 THEN predicted_loyal = 1; ELSE predicted_loyal = 0;
22	RUN;
23
24	/* Affichage des données scorées */
25	PROC PRINT DATA=casuser.scored_data (obs=10);
26	RUN;
27
28	PROC CASUTIL incaslib=\"casuser\";
29	droptable casdata=\"test_data\" quiet;
30	droptable casdata=\"scored_data\" quiet;
31	RUN;

4 Codeblock

PROC GRADBOOST Data

Erklärung :
Dieses Beispiel verwendet `PROC GRADBOOST`, um ein Gradient-Boosting-Modell für Verkaufsdaten zu trainieren, wobei die verteilten Funktionen von CAS genutzt werden. Die Klausel `PARTITION region_id` weist CAS an, die Daten nach Region zu verarbeiten, was die Leistung und Skalierbarkeit durch die Verteilung der Berechnungen auf CAS-Knoten verbessern kann. Jede Partition kann parallel von mehreren Threads verarbeitet werden. Obwohl hier keine explizite `NTHREADS`-Option vorhanden ist, weist der zugrunde liegende CAS-Server die Verarbeitungsressourcen (d.h. die Threads) automatisch und effizient entsprechend der Umgebungskonfiguration und der Datengröße zu, wodurch der Vorteil von Multithreading für das Modelltraining maximiert wird.

Kopiert!

1	/* Création d'une table CAS avec une variable de partitionnement */
2	DATA casuser.ventes;
3	call streaminit(789);
4	DO i=1 to 5000;
5	region_id = ceil(rand('uniform', 1, 4)); /* 4 régions */
6	publicite = rand('uniform', 0, 1000);
7	prix = rand('uniform', 10, 100);
8	ventes_reelles = 500 + 2 * publicite - 3 * prix + (region_id * 100) + rand('normal', 0, 50);
9	OUTPUT;
10	END;
11	drop i;
12	RUN;
13
14	/* Utilisation de PROC GRADBOOST avec PARTITION et options de thread (implicites CAS) */
15	PROC GRADBOOST DATA=casuser.ventes;
16	INPUT publicite prix;
17	target ventes_reelles;
18	partition region_id;
19	/* Les options de multithreading sont gérées par le serveur CAS. */
20	/* L'option NTHREADS peut être utilisée dans certaines procs pour limiter explicitement. */
21	/* Ici, nous laissons CAS gérer l'allocation automatique des threads par défaut. */
22	ods OUTPUT IterationHistory=casuser.gradboost_hist;
23	RUN;
24
25	/* Affichage de l'historique d'itération */
26	PROC PRINT DATA=casuser.gradboost_hist (obs=10);
27	RUN;
28
29	PROC CASUTIL incaslib=\"casuser\";
30	droptable casdata=\"ventes\" quiet;
31	droptable casdata=\"gradboost_hist\" quiet;
32	RUN;

Dieses Material wird von We Are Cas "wie besehen" zur Verfügung gestellt. Es gibt keine ausdrücklichen oder stillschweigenden Garantien hinsichtlich der Marktgängigkeit oder Eignung für einen bestimmten Zweck in Bezug auf die hierin enthaltenen Materialien oder Codes. We Are Cas ist nicht verantwortlich für Fehler in diesem Material, wie es jetzt existiert oder existieren wird, noch bietet We Are Cas technischen Support dafür an.

Retour à la liste