El procedimiento BOOLRULE es una herramienta potente para extraer reglas booleanas explícitas de un conjunto de datos. Una vez extraídas estas reglas y creado un modelo (a menudo almacenado en un astore CAS), es esencial poder aplicar este modelo a nuevos datos. El proceso de puntuación consiste en tomar una nueva observación, evaluar las reglas booleanas en función de sus características y luego producir una predicción o clasificación basada en estas reglas. Esto es fundamental para el despliegue de modelos de Machine Learning en producción.
Análisis de datos
Type : CREATION_INTERNE
Los ejemplos utilizan datos generados (datalines) o SASHELP para garantizar la autonomía del código.
1 Bloque de código
PROC ASTORE SCORE Data
Explicación : Este primer ejemplo demuestra el uso más simple de la puntuación con un modelo `BOOLRULE` en SAS Viya.
1. **Creación de datos**: Se crea una pequeña tabla CAS llamada `casuser.score_data_basic` utilizando un paso `DATA` y la instrucción `DATALINES`. Estos datos simulan nuevas observaciones para las cuales queremos obtener predicciones.
2. **Simulación de modelo**: El comentario indica que para un escenario real, un modelo `BOOLRULE` (`astore`) llamado `my_boolrule_model` debería haber sido entrenado y registrado previamente (por ejemplo, en la caslib `casuser.models`). Para hacer el ejemplo autosuficiente sin un entrenamiento completo, asumimos su existencia. El `PROC ASTORE SCORE` utiliza el parámetro `OUTMODEL` para especificar el modelo a aplicar.
3. **Puntuación**: El procedimiento `PROC ASTORE` se utiliza con la instrucción `SCORE`. La opción `DATA` apunta a nuestra tabla de datos `score_data_basic`, y `OUT` especifica la tabla de salida (`casuser.scored_results_basic`) donde se almacenarán los resultados de la puntuación (incluidas las predicciones).
4. **Visualización de resultados**: `PROC PRINT` muestra el contenido de la tabla `scored_results_basic`, lo que permite visualizar las predicciones generadas.
5. **Limpieza**: Las tablas temporales creadas en CAS se eliminan usando `proc cas; table.dropTable; quit;`.
¡Copiado!
/* Ejemplo 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
/* Ejemplo 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é. */
Explicación : Este ejemplo desarrolla el escenario de puntuación introduciendo opciones comunes para personalizar la salida y utilizar conjuntos de datos más grandes.
1. **Carga de datos**: La tabla `CARS` de la biblioteca `SASHELP` se carga en la caslib `public` de CAS. Esta tabla más grande simula un conjunto de datos de producción sobre el cual se realizará la puntuación.
2. **Modelo astore**: Similar al ejemplo anterior, se asume la existencia de un `astore` llamado `my_intermediate_model` en `public.models_caslib`.
3. **Puntuación con opciones**: Se utiliza el procedimiento `PROC ASTORE` con `SCORE`.
* `DATA=public.CARS`: Especifica la tabla de entrada para la puntuación.
* `OUT=public.scored_cars_intermediate`: Nombra la tabla de salida.
* `OUTMODEL=public.models_caslib.my_intermediate_model`: Indica el modelo a aplicar.
* `/ COPYVARS=(Make Model Type MSRP)`: Esta opción es crucial y permite copiar variables específicas de la tabla de entrada a la tabla de salida, lo que es útil para el análisis de los resultados.
* `PREDICT=Predicted_Target`: Renombra la variable de predicción por defecto a `Predicted_Target` para una mejor legibilidad.
* `EVENT=1`: Se utiliza para especificar el evento de interés en el caso de un objetivo binario o multiclase, lo que permite centrarse en la probabilidad de una clase específica.
4. **Visualización de resultados**: `PROC PRINT` muestra las 10 primeras observaciones de la tabla de resultados.
5. **Limpieza**: Las tablas temporales creadas se eliminan.
¡Copiado!
/* 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 */
Explicación : Este ejemplo aborda un escenario más realista donde los datos brutos deben prepararse antes de la puntuación.
1. **Creación de datos brutos**: Se crea una tabla CAS `casuser.raw_customer_data` con datos de ejemplo que incluyen valores faltantes, simulando datos reales de clientes.
2. **Preparación de datos**: Se utiliza un paso `DATA` para crear `casuser.prepared_customer_data` a partir de los datos brutos. Se realizan imputaciones simples para los valores faltantes (`Age`, `Gender`, `Income`, `ScoreFeature1`, `ScoreFeature2`). En un entorno de producción, las reglas de imputación se derivarían de las estadísticas de entrenamiento del modelo.
3. **Modelo astore**: Se asume la existencia de un modelo `astore` (`my_advanced_model`) entrenado con datos preparados de manera similar.
4. **Puntuación sobre datos preparados**: `PROC ASTORE SCORE` se ejecuta en la tabla `casuser.prepared_customer_data`.
* `COPYVARS=(CustomerID Age Gender Income)`: Copia los identificadores de cliente y las variables originales importantes.
* `PREDICT=Churn_Risk_Score`: Asigna un nombre de negocio a la variable de predicción.
5. **Visualización de resultados**: Se muestran los resultados de la puntuación sobre los datos preparados.
6. **Limpieza**: Las tablas temporales se eliminan.
¡Copiado!
/* 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. */
Explicación : Este ejemplo ilustra cómo la puntuación `BOOLRULE` se integra específicamente en el entorno distribuido de SAS Viya, centrándose en las tablas CAS grandes y la gestión de modelos `astore`.
1. **Creación de una tabla CAS grande**: La tabla `SASHELP.CARS` se duplica masivamente 1000 veces en `casuser.large_cars_data` para simular un gran volumen de datos típico de los entornos distribuidos. Esto se hace para demostrar la eficiencia de la puntuación en memoria distribuida.
2. **Creación simulada de astore**: Como no es posible generar un astore real con `PROC BOOLRULE TRAIN` sin datos y pasos de preprocesamiento complejos, se simula un `astore` mínimo (`casuser.my_viya_model`) creando una tabla CAS con información de versión y reglas ficticias. **Es crucial tener en cuenta que en un caso real, este astore sería el resultado de un entrenamiento `PROC BOOLRULE` y no se crearía manualmente.**
3. **Puntuación distribuida**: `PROC ASTORE SCORE` se utiliza para aplicar el modelo (`outmodel=casuser.my_viya_model`) a la tabla grande (`data=casuser.large_cars_data`). La ejecución se realiza de forma distribuida en el servidor CAS, lo que está optimizado para grandes volúmenes de datos.
* `COPYVARS=(Make Model Origin)`: Copia las variables descriptivas para contextualizar los resultados.
4. **Visualización de resultados**: Se muestran las 10 primeras líneas de la tabla de resultados `casuser.scored_large_cars`.
5. **Limpieza**: Todas las tablas temporales, incluido el modelo `astore` simulado, se eliminan de la sesión CAS.
¡Copiado!
/* 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à. */
Este material se proporciona "tal cual" por We Are Cas. No hay garantías, expresas o implícitas, en cuanto a la comerciabilidad o idoneidad para un propósito particular con respecto a los materiales o el código contenidos en este documento. We Are Cas no es responsable de los errores en este material tal como existe ahora o existirá, ni We Are Cas proporciona soporte técnico para el mismo.
SAS y todos los demás nombres de productos o servicios de SAS Institute Inc. son marcas registradas o marcas comerciales de SAS Institute Inc. en los EE. UU. y otros países. ® indica registro en los EE. UU. WeAreCAS es un sitio comunitario independiente y no está afiliado a SAS Institute Inc.
Este sitio utiliza cookies técnicas y analíticas para mejorar su experiencia.
Saber más.