Die BOOLRULE-Prozedur ist ein leistungsstarkes Werkzeug zur Extraktion expliziter boolescher Regeln aus einem Datensatz. Sobald diese Regeln extrahiert und ein Modell erstellt wurde (oft in einem CAS-Astore gespeichert), ist es unerlässlich, dieses Modell auf neue Daten anwenden zu können. Der Scoring-Prozess besteht darin, eine neue Beobachtung zu nehmen, die booleschen Regeln anhand ihrer Merkmale zu bewerten und dann eine Vorhersage oder Klassifizierung basierend auf diesen Regeln zu erstellen. Dies ist grundlegend für die Bereitstellung von Machine-Learning-Modellen in der Produktion.
Datenanalyse
Type : CREATION_INTERNE
Die Beispiele verwenden generierte Daten (Datalines) oder SASHELP, um die Autonomie des Codes zu gewährleisten.
1 Codeblock
PROC ASTORE SCORE Data
Erklärung : Dieses erste Beispiel demonstriert die einfachste Verwendung des Scorings mit einem BOOLRULE-Modell in SAS Viya.
1. **Datenerstellung**: Eine kleine CAS-Tabelle mit dem Namen `casuser.score_data_basic` wird mit einem DATA-Step und der `DATALINES`-Anweisung erstellt. Diese Daten simulieren neue Beobachtungen, für die wir Vorhersagen erhalten möchten.
2. **Modellsimulation**: Der Kommentar weist darauf hin, dass für ein reales Szenario ein BOOLRULE-Modell (`astore`) mit dem Namen `my_boolrule_model` zuvor trainiert und gespeichert worden sein sollte (z. B. in der Caslib `casuser.models`). Um das Beispiel ohne vollständiges Training eigenständig zu machen, nehmen wir seine Existenz an. `PROC ASTORE SCORE` verwendet den Parameter `OUTMODEL`, um das anzuwendende Modell anzugeben.
3. **Scoring**: Die Prozedur `PROC ASTORE` wird mit der `SCORE`-Anweisung verwendet. Die Option `DATA` verweist auf unsere Datentabelle `score_data_basic`, und `OUT` gibt die Ausgabetabelle (`casuser.scored_results_basic`) an, in der die Scoring-Ergebnisse (einschließlich Vorhersagen) gespeichert werden.
4. **Ergebnisanzeige**: `PROC PRINT` zeigt den Inhalt der Tabelle `scored_results_basic` an, wodurch die generierten Vorhersagen visualisiert werden können.
5. **Bereinigung**: Die in CAS erstellten temporären Tabellen werden mit `proc cas; table.dropTable; quit;` gelöscht.
Kopiert!
/* Exemple 1 : Utilisation Basique du Scoring avec PROC BOOLRULE */
/* Supposons qu'un modèle BOOLRULE nommé 'my_boolrule_model' existe déjà dans 'casuser.models'. */
/* 1. Création d'une table CAS simple pour le scoring */
data casuser.score_data_basic;
input Feature1 Feature2 Feature3;
datalines;
10 20 5
15 25 8
12 18 6
;
run;
/* 2. Chargement du modèle astore dans la session CAS (si ce n'est pas déjà fait) */
/* Dans une situation réelle, l'astore serait généré par PROC BOOLRULE TRAIN et chargé une fois. */
/* Pour cet exemple, nous simulons simplement son existence et son chargement. */
/* Le nom de l'astore et son caslib doivent correspondre à ceux du modèle entraîné. */
/* proc astore restore=casuser.models.my_boolrule_model; run; */
/* 3. Application du modèle pour le scoring */
proc astore;
score data=casuser.score_data_basic
out=casuser.scored_results_basic
outmodel=casuser.models.my_boolrule_model; /* Nom fictif du modèle astore */
run;
/* Affichage des résultats du scoring */
proc print data=casuser.scored_results_basic;
title "Résultats de Scoring Basique";
run;
/* Nettoyage (optionnel) */
proc cas;
table.dropTable / caslib="casuser", name="score_data_basic";
table.dropTable / caslib="casuser", name="scored_results_basic";
quit;
1
/* Exemple 1 : Utilisation Basique du Scoring avec PROC BOOLRULE */
2
/* Supposons qu'un modèle BOOLRULE nommé 'my_boolrule_model' existe déjà dans 'casuser.models'. */
3
4
/* 1. Création d'une table CAS simple pour le scoring */
5
DATA casuser.score_data_basic;
6
INPUT Feature1 Feature2 Feature3;
7
DATALINES;
8
10205
9
15258
10
12186
11
;
12
RUN;
13
14
/* 2. Chargement du modèle astore dans la session CAS (si ce n'est pas déjà fait) */
15
/* Dans une situation réelle, l'astore serait généré par PROC BOOLRULE TRAIN et chargé une fois. */
16
/* Pour cet exemple, nous simulons simplement son existence et son chargement. */
17
/* Le nom de l'astore et son caslib doivent correspondre à ceux du modèle entraîné. */
Erklärung : Dieses Beispiel erweitert das Scoring-Szenario durch die Einführung gängiger Optionen zur Anpassung der Ausgabe und zur Verwendung größerer Datensätze.
1. **Datenladen**: Die Tabelle `CARS` aus der `SASHELP`-Bibliothek wird in die `public`-Caslib von CAS geladen. Diese größere Tabelle simuliert einen Produktionsdatensatz, auf dem das Scoring durchgeführt wird.
2. **Astore-Modell**: Ähnlich dem vorherigen Beispiel wird die Existenz eines `astore` mit dem Namen `my_intermediate_model` in `public.models_caslib` angenommen.
3. **Scoring mit Optionen**: Die Prozedur `PROC ASTORE` mit `SCORE` wird verwendet.
* `DATA=public.CARS`: Gibt die Eingabetabelle für das Scoring an.
* `OUT=public.scored_cars_intermediate`: Benennt die Ausgabetabelle.
* `OUTMODEL=public.models_caslib.my_intermediate_model`: Zeigt das anzuwendende Modell an.
* `/ COPYVARS=(Make Model Type MSRP)`: Diese Option ist entscheidend und ermöglicht das Kopieren spezifischer Variablen aus der Eingabetabelle in die Ausgabetabelle, was für die Analyse der Ergebnisse nützlich ist.
* `PREDICT=Predicted_Target`: Benennt die Standard-Vorhersagevariable zur besseren Lesbarkeit in `Predicted_Target` um.
* `EVENT=1`: Wird verwendet, um das interessierende Ereignis im Falle eines binären oder multiklassifizierten Ziels anzugeben, wodurch die Konzentration auf die Wahrscheinlichkeit einer spezifischen Klasse ermöglicht wird.
4. **Ergebnisanzeige**: `PROC PRINT` zeigt die ersten 10 Beobachtungen der Ergebnistabelle an.
5. **Bereinigung**: Die erstellten temporären Tabellen werden gelöscht.
Kopiert!
/* Exemple 2 : Scoring avec options courantes */
/* Supposons un modèle 'my_intermediate_model' dans 'public.models_caslib'. */
/* Nous allons utiliser un ensemble de données plus grand de SASHELP et spécifier des variables de sortie. */
/* 1. Charger une table SASHELP dans CAS pour simuler de nouvelles données à scorer */
proc cas;
load casdata="CARS" caslib="sashelp" outcaslib="public" promote;
quit;
/* 2. Supposer l'existence et le chargement d'un modèle astore nommé 'my_intermediate_model' */
/* Remplacez ceci par votre modèle astore réel et son caslib si vous l'exécutez. */
/* proc astore restore=public.models_caslib.my_intermediate_model; run; */
/* 3. Appliquer le modèle pour le scoring avec des options de sortie spécifiques */
proc astore;
score data=public.CARS
out=public.scored_cars_intermediate
outmodel=public.models_caslib.my_intermediate_model /
copyvars=(Make Model Type MSRP) /* Copier des variables spécifiques de l'entrée */
predict=Predicted_Target /* Spécifier le nom de la variable de prédiction */
event=1; /* Spécifier l'événement d'intérêt si applicable */
run;
/* Affichage des 10 premières lignes des résultats du scoring */
proc print data=public.scored_cars_intermediate(obs=10);
title "Résultats de Scoring Intermédiaire (10 premières lignes)";
run;
/* Nettoyage (optionnel) */
proc cas;
table.dropTable / caslib="public", name="CARS";
table.dropTable / caslib="public", name="scored_cars_intermediate";
quit;
1
/* Exemple 2 : Scoring avec options courantes */
2
/* Supposons un modèle 'my_intermediate_model' dans 'public.models_caslib'. */
3
/* Nous allons utiliser un ensemble de données plus grand de SASHELP et spécifier des variables de sortie. */
4
5
/* 1. Charger une table SASHELP dans CAS pour simuler de nouvelles données à scorer */
Erklärung : Dieses Beispiel befasst sich mit einem realistischeren Szenario, bei dem Rohdaten vor dem Scoring aufbereitet werden müssen.
1. **Rohdatenerstellung**: Eine CAS-Tabelle `casuser.raw_customer_data` wird mit Beispieldaten einschließlich fehlender Werte erstellt, die reale Kundendaten simulieren.
2. **Datenaufbereitung**: Ein DATA-Step wird verwendet, um `casuser.prepared_customer_data` aus den Rohdaten zu erstellen. Einfache Imputationen werden für fehlende Werte (`Age`, `Gender`, `Income`, `ScoreFeature1`, `ScoreFeature2`) durchgeführt. In einer Produktionsumgebung würden die Imputationsregeln aus den Trainingsstatistiken des Modells abgeleitet.
3. **Astore-Modell**: Die Existenz eines `astore`-Modells (`my_advanced_model`), das auf ähnlich aufbereiteten Daten trainiert wurde, wird angenommen.
4. **Scoring auf aufbereiteten Daten**: `PROC ASTORE SCORE` wird auf die Tabelle `casuser.prepared_customer_data` ausgeführt.
* `COPYVARS=(CustomerID Age Gender Income)`: Kopiert Kunden-IDs und wichtige Originalvariablen.
* `PREDICT=Churn_Risk_Score`: Gibt der Vorhersagevariablen einen fachlichen Namen.
5. **Ergebnisanzeige**: Die Scoring-Ergebnisse für die aufbereiteten Daten werden angezeigt.
6. **Bereinigung**: Die temporären Tabellen werden gelöscht.
Kopiert!
/* Exemple 3 : Cas Avancé - Scoring avec préparation des données */
/* Cet exemple illustre un scénario où les données de scoring nécessitent une préparation. */
/* Nous allons simuler une étape de préparation des données (imputation simple) */
/* avant d'appliquer un modèle BOOLRULE avancé. */
/* 1. Création d'une table CAS avec des données potentiellement manquantes ou brutes */
data casuser.raw_customer_data;
input CustomerID Age Gender $ Income ScoreFeature1 ScoreFeature2;
datalines;
101 35 Male 50000 . 12
102 42 Female 65000 85 .
103 28 Female . 40000 15
104 50 Male 90000 92 18
105 31 . 48000 78 14
;
run;
/* 2. Préparation des données pour le scoring (e.g., imputation des valeurs manquantes) */
/* Dans un cas réel, cette étape utiliserait des statistiques d'imputation dérivées de l'entraînement. */
data casuser.prepared_customer_data;
set casuser.raw_customer_data;
/* Imputation simple : remplacement des valeurs manquantes par la moyenne/mode ou une constante */
if Age = . then Age = 40; /* Exemple d'imputation pour l'âge */
if Gender = ' ' then Gender = 'Female'; /* Exemple d'imputation pour le genre */
if Income = . then Income = 55000; /* Exemple d'imputation pour le revenu */
if ScoreFeature1 = . then ScoreFeature1 = 80;
if ScoreFeature2 = . then ScoreFeature2 = 15;
run;
/* 3. Supposer l'existence d'un modèle astore nommé 'my_advanced_model' */
/* Ce modèle serait entraîné sur des données préparées de manière similaire. */
/* proc astore restore=casuser.models.my_advanced_model; run; */
/* 4. Application du modèle pour le scoring des données préparées */
proc astore;
score data=casuser.prepared_customer_data
out=casuser.scored_customer_results
outmodel=casuser.models.my_advanced_model /
copyvars=(CustomerID Age Gender Income)
predict=Churn_Risk_Score;
run;
/* Affichage des résultats du scoring */
proc print data=casuser.scored_customer_results;
title "Résultats de Scoring Avancé avec Préparation des Données";
run;
/* Nettoyage (optionnel) */
proc cas;
table.dropTable / caslib="casuser", name="raw_customer_data";
table.dropTable / caslib="casuser", name="prepared_customer_data";
table.dropTable / caslib="casuser", name="scored_customer_results";
quit;
1
/* Exemple 3 : Cas Avancé - Scoring avec préparation des données */
2
/* Cet exemple illustre un scénario où les données de scoring nécessitent une préparation. */
3
/* Nous allons simuler une étape de préparation des données (imputation simple) */
4
/* avant d'appliquer un modèle BOOLRULE avancé. */
5
6
/* 1. Création d'une table CAS avec des données potentiellement manquantes ou brutes */
7
DATA casuser.raw_customer_data;
8
INPUT CustomerID Age Gender $ Income ScoreFeature1 ScoreFeature2;
9
DATALINES;
10
10135 Male 50000 . 12
11
10242 Female 6500085 .
12
10328 Female . 4000015
13
10450 Male 900009218
14
10531 . 480007814
15
;
16
RUN;
17
18
/* 2. Préparation des données pour le scoring (e.g., imputation des valeurs manquantes) */
19
/* Dans un cas réel, cette étape utiliserait des statistiques d'imputation dérivées de l'entraînement. */
20
DATA casuser.prepared_customer_data;
21
SET casuser.raw_customer_data;
22
/* Imputation simple : remplacement des valeurs manquantes par la moyenne/mode ou une constante */
23
IF Age = . THEN Age = 40; /* Exemple d'imputation pour l'âge */
24
IF Gender = ' 'THEN Gender = 'Female'; /* Exemple d'imputation pour le genre */
25
IF Income = . THEN Income = 55000; /* Exemple d'imputation pour le revenu */
26
IF ScoreFeature1 = . THEN ScoreFeature1 = 80;
27
IF ScoreFeature2 = . THEN ScoreFeature2 = 15;
28
RUN;
29
30
/* 3. Supposer l'existence d'un modèle astore nommé 'my_advanced_model' */
31
/* Ce modèle serait entraîné sur des données préparées de manière similaire. */
Erklärung : Dieses Beispiel veranschaulicht, wie BOOLRULE-Scoring spezifisch in die verteilte Umgebung von SAS Viya integriert wird, wobei der Schwerpunkt auf großen CAS-Tabellen und der Verwaltung von Astore-Modellen liegt.
1. **Erstellung einer großen CAS-Tabelle**: Die Tabelle `SASHELP.CARS` wird massiv 1000-mal in `casuser.large_cars_data` dupliziert, um ein großes Datenvolumen zu simulieren, das typisch für verteilte Umgebungen ist. Dies geschieht, um die Effizienz des Scorings im verteilten Speicher zu demonstrieren.
2. **Simulierte Astore-Erstellung**: Da es nicht möglich ist, ein echtes Astore mit `PROC BOOLRULE TRAIN` ohne komplexe Daten und Vorverarbeitungsschritte zu generieren, wird ein minimales Astore (`casuser.my_viya_model`) durch Erstellen einer CAS-Tabelle mit Versionsinformationen und Dummy-Regeln simuliert. **Es ist wichtig zu beachten, dass in einem realen Fall dieses Astore das Ergebnis eines `PROC BOOLRULE`-Trainings wäre und nicht manuell erstellt werden würde.**
3. **Verteiltes Scoring**: `PROC ASTORE SCORE` wird verwendet, um das Modell (`outmodel=casuser.my_viya_model`) auf die große Tabelle (`data=casuser.large_cars_data`) anzuwenden. Die Ausführung erfolgt verteilt auf dem CAS-Server, was für große Datenmengen optimiert ist.
* `COPYVARS=(Make Model Origin)`: Kopiert beschreibende Variablen zur Kontextualisierung der Ergebnisse.
4. **Ergebnisanzeige**: Die ersten 10 Zeilen der Ergebnistabelle `casuser.scored_large_cars` werden angezeigt.
5. **Bereinigung**: Alle temporären Tabellen, einschließlich des simulierten Astore-Modells, werden aus der CAS-Sitzung gelöscht.
Kopiert!
/* Exemple 4 : Intégration Viya/CAS - Scoring distribué */
/* Cet exemple met en évidence l'exécution de scoring dans l'environnement CAS de SAS Viya. */
/* Nous allons charger un modèle astore déjà existant et effectuer le scoring */
/* sur une grande table CAS en utilisant les capacités distribuées. */
/* 1. Connexion à la session CAS (si ce n'est pas déjà fait) */
/* cas casauto; */
/* 2. Création d'une table CAS de grande taille (simulation) */
/* Nous allons dupliquer la table SASHELP.CARS pour simuler une grande table distribuée */
data casuser.large_cars_data;
set sashelp.cars;
do _n_ = 1 to 1000; /* Dupliquer 1000 fois pour simuler une grande taille */
output;
end;
run;
/* 3. Chargement du modèle astore (supposé avoir été entraîné et enregistré dans CAS) */
/* Ici, nous utiliserons l'instruction UPLOAD ou RESTORE de PROC ASTORE pour charger le modèle */
/* si l'astore n'est pas déjà dans la session. Pour la simulation, on suppose qu'il est déjà là. */
/* proc astore restore=casuser.models.my_viya_model; run; */
/* Ou si le modèle est un fichier local à uploader: */
/* proc astore; upload rstore=my_viya_model.sashdat; run; */
/* Pour cet exemple, nous allons créer un astore minimal en mémoire pour la démonstration */
/* (Dans la réalité, ceci proviendrait d'un entraînement PROC BOOLRULE) */
data casuser.my_viya_model;
/* Simulate a minimal astore structure for demonstration purposes */
length _Astore_Model_ $256 _Name_ $32 _Value_ $256;
_Astore_Model_ = 'my_viya_model';
_Name_ = 'VERSION'; _Value_ = '1.0'; output;
_Name_ = 'TARGET'; _Value_ = 'Origin'; output; /* Example target */
_Name_ = 'RULE_COUNT'; _Value_ = '5'; output;
_Name_ = 'RULE_1'; _Value_ = 'MSRP > 30000 AND Horsepower > 200'; output;
_Name_ = 'RULE_1_PRED'; _Value_ = 'Europe'; output;
_Name_ = 'RULE_2'; _Value_ = 'MPG_City < 20 AND Weight > 3500'; output;
_Name_ = 'RULE_2_PRED'; _Value_ = 'USA'; output;
/* ... add more dummy rules as needed for a real model simulation */
run;
/* NOTE: La création d'un astore 'à la main' comme ci-dessus n'est PAS la méthode habituelle. */
/* Normalement, un astore est créé par une procédure d'entraînement comme PROC BOOLRULE. */
/* Cette section est uniquement pour rendre l'exemple auto-suffisant sans un entraînement préalable complexe. */
/* 4. Application du modèle pour le scoring distribué sur la grande table CAS */
proc astore;
score data=casuser.large_cars_data
out=casuser.scored_large_cars
outmodel=casuser.my_viya_model / /* Ici on utilise l'astore créé plus haut */
copyvars=(Make Model Origin);
run;
/* Affichage des 10 premières lignes des résultats du scoring distribué */
proc print data=casuser.scored_large_cars(obs=10);
title "Résultats de Scoring Distribué Viya/CAS (10 premières lignes)";
run;
/* Nettoyage (optionnel) */
proc cas;
table.dropTable / caslib="casuser", name="large_cars_data";
table.dropTable / caslib="casuser", name="my_viya_model"; /* Drop the dummy astore table */
table.dropTable / caslib="casuser", name="scored_large_cars";
table.dropTable / caslib="public", name="CARS";
quit;
1
/* Exemple 4 : Intégration Viya/CAS - Scoring distribué */
2
/* Cet exemple met en évidence l'exécution de scoring dans l'environnement CAS de SAS Viya. */
3
/* Nous allons charger un modèle astore déjà existant et effectuer le scoring */
4
/* sur une grande table CAS en utilisant les capacités distribuées. */
5
6
/* 1. Connexion à la session CAS (si ce n'est pas déjà fait) */
7
/* cas casauto; */
8
9
/* 2. Création d'une table CAS de grande taille (simulation) */
10
/* Nous allons dupliquer la table SASHELP.CARS pour simuler une grande table distribuée */
11
DATA casuser.large_cars_data;
12
SET sashelp.cars;
13
DO _n_ = 1 to 1000; /* Dupliquer 1000 fois pour simuler une grande taille */
14
OUTPUT;
15
END;
16
RUN;
17
18
/* 3. Chargement du modèle astore (supposé avoir été entraîné et enregistré dans CAS) */
19
/* Ici, nous utiliserons l'instruction UPLOAD ou RESTORE de PROC ASTORE pour charger le modèle */
20
/* si l'astore n'est pas déjà dans la session. Pour la simulation, on suppose qu'il est déjà là. */
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.
SAS und alle anderen Produkt- oder Dienstleistungsnamen von SAS Institute Inc. sind eingetragene Marken oder Marken von SAS Institute Inc. in den USA und anderen Ländern. ® zeigt die Registrierung in den USA an. WeAreCAS ist eine unabhängige Community-Site und nicht mit SAS Institute Inc. verbunden.
Diese Website verwendet technische und analytische Cookies, um Ihre Erfahrung zu verbessern.
Mehr erfahren.