Ingeniería de funciones a gran escala con protección de datos confidenciales mediante sesiones interactivas de AWS Glue y Amazon SageMaker Studio

Reeditado por Platón

seguidores: 0

Las organizaciones utilizan el aprendizaje automático (ML) y los servicios de inteligencia artificial para mejorar la experiencia del cliente, reducir los costos operativos y desbloquear nuevas posibilidades para mejorar los resultados comerciales. Los datos respaldan los casos de uso de ML e IA y son un activo estratégico para una organización. A medida que los datos crecen a un ritmo exponencial, las organizaciones buscan configurar una plataforma de datos integrada, rentable y de alto rendimiento para preprocesar datos, realizar ingeniería de características y construir, entrenar y poner en funcionamiento modelos ML a escala. Para lograrlo, AWS ofrece una plataforma de datos moderna unificada que funciona con Servicio de almacenamiento simple de Amazon (Amazon S3) como el lago de datos con herramientas y motores de procesamiento especialmente diseñados para admitir cargas de trabajo de análisis y aprendizaje automático. Para una experiencia ML unificada, puede usar Estudio Amazon SageMaker, Que ofrece integración nativa con sesiones interactivas de AWS Glue para realizar ingeniería de funciones a escala con protección de datos confidenciales. En esta publicación, demostramos cómo implementar esta solución.

Amazon SageMaker es un servicio de ML completamente administrado que le permite crear, entrenar e implementar modelos a escala para una amplia gama de casos de uso. Para el entrenamiento de modelos, puede usar cualquiera de los algoritmos incorporados dentro de SageMaker para comenzar a entrenar e implementar modelos ML rápidamente.

Un componente clave del proceso de creación y desarrollo de modelos es la ingeniería de características. Pegamento AWS es una de las opciones recomendadas para lograr la ingeniería de características a escala. AWS Glue le permite ejecutar la integración y transformación de datos de forma distribuida en una infraestructura Apache Spark sin servidor y facilita el uso de la popular biblioteca Spark ML para la ingeniería de funciones y el desarrollo de modelos. Además, puede usar AWS Glue para el procesamiento de datos incrementales a través de marcadores de trabajo, ingiere datos de más de 100 fuentes utilizando conectoresy ejecutar cargas de trabajo con picos o impredecibles usando escalado automático.

Otro requisito importante para las aplicaciones basadas en ML es la seguridad de los datos y el control de acceso. Es una demanda común tener un control más estricto sobre quién puede acceder a los datos más confidenciales como parte del proceso de creación de modelos e ingeniería de funciones siguiendo el principio de acceso con privilegios mínimos. Para lograr esto, puede utilizar la integración de AWS Glue con Formación del lago AWS para una mayor gobernanza y gestión de los activos del lago de datos. Con Lake Formation, puede configurar políticas detalladas de seguridad y control de acceso a datos además de su lago de datos de Amazon S3. Las políticas se definen en una ubicación central, lo que permite múltiples servicios de análisis y aprendizaje automático, como AWS Glue, Atenea amazónicay SageMaker, para interactuar con los datos almacenados en Amazon S3.

AWS Glue incluye un Detección de información de identificación personal (PII) transform que brinda la capacidad de detectar, enmascarar o eliminar entidades según sea necesario, para mejorar el cumplimiento y la gobernanza. Con la transformación PII, puede detectar datos PII en conjuntos de datos y aplicar automáticamente un control de acceso detallado utilizando Lake Formation para restringir los datos confidenciales para diferentes grupos de usuarios.

Caso de uso

Nos enfocamos en un caso de uso del modelo de propensión que incluye un conjunto de datos de marketing de clientes e involucra a dos usuarios: un ingeniero de datos y un científico de datos. El conjunto de datos contiene información por cliente, incluida la fuente del cliente potencial, las notas de contacto, el puesto de trabajo, algunas banderas, las vistas de página por visita y más. El conjunto de datos también incluye información confidencial, como números de teléfono personales.

El ingeniero de datos es responsable de construir la tubería de procesamiento de datos de extremo a extremo, incluida la preparación de datos, el preprocesamiento y el control de acceso. El científico de datos es responsable de la ingeniería de características y de la capacitación y la implementación del modelo de ML. Tenga en cuenta que el científico de datos no puede acceder a ningún dato confidencial de PII para la ingeniería de funciones o el entrenamiento del modelo ML.

Como parte de este caso de uso, el ingeniero de datos crea una canalización de datos para preprocesar el conjunto de datos, escanea el conjunto de datos en busca de información PII y restringe el acceso de la columna PII al usuario del científico de datos. Como resultado, cuando un científico de datos usa el conjunto de datos para realizar ingeniería de funciones y crear modelos de ML, no tiene acceso a la columna confidencial de PII (números de teléfono, en este caso). El proceso de ingeniería de características implica convertir columnas de tipo cadena a un formato que sea óptimo para los modelos de ML. Como caso de uso avanzado, puede ampliar este patrón de acceso para implementar seguridad a nivel de fila y de celda mediante Lake Formation.

Resumen de la solución

La solución contiene los siguientes pasos de alto nivel:

Configurar recursos con Formación en la nube de AWS.
Preprocesar el conjunto de datos, incluida la detección de PII y el control de acceso detallado, en una sesión interactiva de AWS Glue.
Realice ingeniería de características en una sesión interactiva de AWS Glue.
Entrene e implemente un modelo de ML con el algoritmo XGBoost integrado de SageMaker.
Evaluar el modelo ML.

El siguiente diagrama ilustra la arquitectura de la solución.

Requisitos previos

Para completar este tutorial, debe tener los siguientes requisitos previos:

Configurar recursos con AWS CloudFormation

Esta publicación incluye una plantilla de CloudFormation para una configuración rápida. Puede revisarlo y personalizarlo para que se ajuste a sus necesidades. Si prefiere configurar recursos en el Consola de administración de AWS y la CLI de AWS en lugar de AWS CloudFormation, consulte las instrucciones en el apéndice al final de esta publicación.

La plantilla de CloudFormation genera los siguientes recursos:

Depósitos de S3 con un conjunto de datos de muestra
An AWS Lambda función para cargar el conjunto de datos
Gestión de identidades y accesos de AWS (IAM) grupo, usuarios, roles y políticas
Configuración y permisos del lago de datos de Lake Formation
Perfiles de usuario de SageMaker

Para crear sus recursos, complete los siguientes pasos:

Inicie sesión en la consola.
Elige Pila de lanzamiento:
Elige Siguiente.
Ingeniero de datosPwd y Científico de datosPwd, ingrese su propia contraseña para los usuarios de ingeniero de datos y científico de datos.
Nombre de la base de datos de pegamento, introduzca demo.
Nombre de la tabla de pegamento, introduzca web_marketing.
S3NombreDeBucketParaEntrada, introduzca blog-studio-pii-dataset-.
S3BucketNameForOutput, introduzca blog-studio-output-.
ID de dominio de SageMaker, ingrese su ID de dominio de SageMaker que preparó en los pasos de requisitos previos.
Elige Siguiente.
En la página siguiente, elija Siguiente.
Revise los detalles en la página final y seleccione Reconozco que AWS CloudFormation podría crear recursos de IAM.
Elige Crear.

La creación de la pila puede tardar hasta 10 minutos. La pila crea roles de IAM y perfiles de usuario de SageMaker para dos personas: ingeniero de datos y científico de datos. También crea una demostración de base de datos y una tabla. web_marketing con un conjunto de datos de muestra.

En el momento de la creación de la pila, la persona del ingeniero de datos tiene acceso completo a la tabla, pero la persona del científico de datos aún no tiene acceso a la tabla.

Preprocesar el conjunto de datos

Comencemos a preprocesar datos en una sesión interactiva de AWS Glue. El personaje del ingeniero de datos quiere verificar los datos para ver si hay datos confidenciales o no, y conceder un permiso de acceso mínimo al personaje del científico de datos. Puede descargar el cuaderno de esta ubicación.

Inicie sesión en la consola con el usuario ingeniero de datos.
En la consola de SageMaker, elija Usuarios.
Seleccione el usuario del ingeniero de datos y elija Open Studio.
Cree un nuevo cuaderno y elija SparkAnalytics 1.0 para Imagen y Pegamento PySpark para Núcleo.
Inicie una sesión interactiva con la siguiente magia para instalar la versión más nueva de Boto3 (esto es necesario para usar el create_data_cells_filter método):
```
%additional_python_modules boto3==1.24.82
```

Inicializar la sesión:

import boto3
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job

sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)

Cree un AWS Glue DynamicFrame a partir de la tabla recién creada y resolver tipos de opciones basado en el esquema del catálogo, porque queremos usar el esquema definido en el catálogo en lugar del esquema inferido automáticamente basado en los datos:

dyf_marketing = glueContext.create_dynamic_frame.from_catalog(
database="demo",
table_name="web_marketing"
)

dyf_marketing_resolved = dyf_marketing.resolveChoice(
choice="match_catalog",
database="demo",
table_name="web_marketing"
)

dyf_marketing_resolved.printSchema()

Valide en la tabla si hay datos de PII utilizando la detección de PII de AWS Glue:

from awsglueml.transforms import EntityDetector

entities_filter = [
"EMAIL",
"CREDIT_CARD",
"IP_ADDRESS",
"MAC_ADDRESS",
"PHONE_NUMBER"
]
entity_detector = EntityDetector()
classified_map = entity_detector.classify_columns(dyf_marketing_resolved, entities_filter, 1.0, 0.1)
print(classified_map)

Verifique si las columnas clasificadas como PII contienen datos confidenciales o no (si no es así, actualice el mapa clasificado para descartar las columnas no confidenciales):
```
from pyspark.sql.functions import col
dyf_marketing_resolved.toDF().select(*[col(c) for c in classified_map.keys()]).show()
```

Configure los permisos de Lake Formation mediante un filtro de celda de datos para las columnas detectadas automáticamente y restrinja las columnas a la persona del científico de datos:

lakeformation = boto3.client('lakeformation')
sts = boto3.client('sts')

account_id = sts.get_caller_identity().get('Account')

# Create a data cell filter for excluding phone_number column
lakeformation.create_data_cells_filter(
TableData={
'TableCatalogId': account_id,
'DatabaseName': 'demo',
'TableName': 'web_marketing',
'Name': 'pii',
'RowFilter': {
'AllRowsWildcard': {}

},
'ColumnWildcard': {
'ExcludedColumnNames': list(classified_map.keys())
}
}
)

# Grant permission on the data cell filter
lakeformation.grant_permissions(
Principal={
'DataLakePrincipalIdentifier': f'arn:aws:iam::{account_id}:role/SageMakerStudioExecutionRole_data-scientist'
},
Resource={
'DataCellsFilter': {
'TableCatalogId': account_id,
'DatabaseName': 'demo',
'TableName': 'web_marketing',
'Name': 'pii'
}
},
Permissions=[
'SELECT'
]
)

Inicie sesión en Studio como científico de datos para ver que las columnas de PII no estén visibles. Puede descargar el cuaderno de esta ubicación.

Cree un nuevo cuaderno y elija SparkAnalytics 1.0 para Imagen y Pegamento PySpark para Núcleo:

import boto3
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job

sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)

dyf_marketing = glueContext.create_dynamic_frame.from_catalog(
database="demo",
table_name="web_marketing"
)

dyf_marketing.printSchema()

Realizar ingeniería de características

Usamos la biblioteca Apache Spark ML para realizar la ingeniería de funciones como usuario científico de datos y luego escribimos el resultado en Amazon S3.

En la siguiente celda, aplicamos características de la Biblioteca Apache Spark ML:

StringIndexer asigna una columna de cadenas de etiquetas a una columna de índices de etiquetas.
OneHotEncoder asigna una característica categórica, representada como un índice de etiqueta, a un vector binario con un único valor como máximo que indica la presencia de una característica categórica específica. Esta transformación se usa para algoritmos de ML que esperan características continuas.
VectorAssembler es un transformador que combina una lista dada de columnas en una sola columna vectorial, que luego se usa para entrenar modelos ML para algoritmos como regresión logística y árboles de decisión.

#feature engineering by using string indexer and one hot encoding from spark ML library
from pyspark.ml.feature import StringIndexer, VectorIndexer, OneHotEncoder, VectorAssembler
from pyspark.ml import Pipeline

cols = ['lastcampaignactivity','region','viewedadvertisement','usedpromo','jobrole']

int_cols = ['pageviewspervisit','totaltimeonwebsite','totalwebvisits',]

indexers = [
StringIndexer(inputCol=c, outputCol="{0}_indexed".format(c))
for c in cols
]

encoders = [
OneHotEncoder(
inputCol=indexer.getOutputCol(),
outputCol="{0}_encoded".format(indexer.getOutputCol()))
for indexer in indexers
]

assembler = VectorAssembler(
inputCols=[encoder.getOutputCol() for encoder in encoders]+int_cols,
outputCol="features"
)

El DataFrame transformado final se puede crear utilizando la biblioteca Pipeline. Una canalización se especifica como una secuencia de etapas. Estas etapas se ejecutan en orden y el DataFrame de entrada se transforma a medida que pasa por cada etapa.
```
df_marketing = dyf_marketing.toDF()
pipeline = Pipeline(stages=indexers + encoders + [assembler])
df_tfm=pipeline.fit(df_marketing).transform(df_marketing)
```

A continuación, dividimos el conjunto de datos para entrenar, validar y probar DataFrame y guardarlo en el depósito S3 para entrenar el modelo ML (proporcione su ID de cuenta de AWS en el siguiente código):

from pyspark.ml.functions import vector_to_array

#set s3 output location for feature engineering output
bucket='blog-studio-output-'

#convert sparse to dense vector
df_tfm=df_tfm.select('converted',vector_to_array("features").alias("features_array"))

#split features array into individual columns
df_tfm=df_tfm.select([df_tfm.converted] + [df_tfm.features_array[i] for i in range(17)])

#split the overall dataset into 70-20-10 training , validation and test
(train_df, validation_df, test_df) = df_tfm.randomSplit([0.7,0.2,0.1])

#write back train, validation and test datasets to S3
train_df.write
.option("header","false")
.csv('s3://{}/web-marketing/processed/training/'.format(bucket))

validation_df.write
.option("header","false")
.csv('s3://{}/web-marketing/processed/validation/'.format(bucket))

test_df.write
.option("header","false")
.csv('s3://{}/web-marketing/processed/test/'.format(bucket))

Entrene e implemente un modelo de ML

En la sección anterior, completamos la ingeniería de funciones, que incluía la conversión de columnas de cadenas como region, jobroley usedpromo en un formato que sea óptimo para los modelos ML. También incluimos columnas como pageviewspervisit y totalwebvisits, que nos ayudará a predecir la propensión de un cliente a comprar un producto.

Ahora entrenamos un modelo de ML leyendo el conjunto de datos de entrenamiento y validación usando el algoritmo XGBoost integrado de SageMaker. Luego implementamos el modelo y ejecutamos una verificación de precisión. Puede descargar el cuaderno de esta ubicación.

En la siguiente celda, estamos leyendo datos del segundo depósito de S3, que incluye el resultado de nuestras operaciones de ingeniería de funciones. Luego usamos el algoritmo integrado XGBoost para entrenar el modelo.

Abre un nuevo cuaderno. Elegir Data science para Imagen y 3 Python para Núcleo (proporcione su ID de cuenta de AWS en el siguiente código):

#set s3 bucket location for training data
import sagemaker
import boto3
from sagemaker import get_execution_role

container = sagemaker.image_uris.retrieve(region=boto3.Session().region_name,
framework='xgboost', version='latest')
bucket='blog-studio-output-'
prefix='web-marketing/processed'

#read train and validation input datasets
s3_input_train = sagemaker.inputs.TrainingInput(s3_data='s3://{}/{}/training/'
.format(bucket, prefix), content_type='csv')
s3_input_validation = sagemaker.inputs.TrainingInput(s3_data='s3://{}/{}/validation/'
.format(bucket, prefix), content_type='csv')

#train xgb model
sess = sagemaker.Session()
from sagemaker import get_execution_role

xgb = sagemaker.estimator.Estimator(
container,
role=get_execution_role(),
instance_count=1,
instance_type='ml.m4.xlarge',
output_path='s3://{}/{}/output'
.format(bucket, prefix),
sagemaker_session=sess
)

xgb.set_hyperparameters(
max_depth=5,
eta=0.2,
gamma=4,
min_child_weight=6,
subsample=0.8,
silent=0,
objective='binary:logistic',
num_round=100
)

xgb.fit({'train': s3_input_train, 'validation': s3_input_validation})

Cuando finaliza la capacitación, podemos implementar el modelo mediante los servicios de alojamiento de SageMaker:
```
#deploy ml model
xgb_predictor = xgb.deploy(initial_instance_count=1,
instance_type='ml.m4.xlarge')
```

Evaluar el modelo ML

Usamos el conjunto de datos de prueba para evaluar el modelo y eliminamos el punto final de inferencia cuando terminamos para evitar cargos continuos.

Evalúe el modelo con el siguiente código:

#create csv serialiser to run accuracy on test dataset
xgb_predictor.serializer = sagemaker.serializers.CSVSerializer()

#read test dataset
import io
import pandas as pd

s3 = boto3.resource('s3')
bucket_obj = s3.Bucket(bucket)

test_line = []
test_objs = bucket_obj.objects.filter(Prefix="web-marketing/processed/test")
for obj in test_objs:
try:
key = obj.key
body = obj.get()['Body'].read()
temp = pd.read_csv(io.BytesIO(body),header=None, encoding='utf8',sep=',')
test_line.append(temp)
except:
continue

test_df = pd.concat(test_line)

#predict results using deployed model
import numpy as np
def predict(data, predictor, rows=500 ):
split_array = np.array_split(data, int(data.shape[0] / float(rows) + 1))
predictions = ''
for array in split_array:
predictions = ','.join([predictions, predictor.predict(array).decode('utf-8')])
return np.fromstring(predictions[1:], sep=',')

#drop the target variable in test_df and make prediction
predictions = predict(test_df.drop(test_df.columns[0], axis=1).to_numpy(), xgb_predictor)

#calculate accuracy using sklearn library
from sklearn.metrics import accuracy_score, confusion_matrix
y_pred=np.round(predictions)
y_true=test_df.iloc[:,0].values.tolist()
print('Accuracy score: ',accuracy_score(y_true, y_pred))
print('Confusion matrix: n',confusion_matrix(y_true, y_pred))

El resultado de precisión para la ejecución de la muestra fue del 84.6 %. Esto podría ser ligeramente diferente para su ejecución debido a la división aleatoria del conjunto de datos.

Podemos eliminar el punto final de inferencia con el siguiente código:
```
xgb_predictor.delete_endpoint(delete_endpoint_config=True)
```

Limpiar

Ahora al paso final, limpiar los recursos.

Vacíe los dos cubos creados a través de la pila de CloudFormation.
Eliminar las aplicaciones asociadas con el usuario profiles data-scientist y data-engineer dentro de Estudio.
Elimina la pila de CloudFormation.

Conclusión

En esta publicación, demostramos una solución que permite a personas como ingenieros de datos y científicos de datos realizar ingeniería de funciones a escala. Con las sesiones interactivas de AWS Glue, puede lograr fácilmente la ingeniería de características a escala con detección automática de PII y control de acceso detallado sin necesidad de administrar ninguna infraestructura subyacente. Al usar Studio como único punto de entrada, puede obtener una experiencia simplificada e integrada para crear un flujo de trabajo de ML de extremo a extremo: desde la preparación y protección de datos hasta la creación, capacitación, ajuste e implementación de modelos de ML. Para obtener más información, visite Introducción a las sesiones interactivas de AWS Glue y Estudio Amazon SageMaker.

¡Estamos muy entusiasmados con esta nueva capacidad y ansiosos por ver lo que va a construir con ella!

Apéndice: Configurar recursos a través de la consola y la CLI de AWS

Complete las instrucciones de esta sección para configurar los recursos mediante la consola y la CLI de AWS en lugar de la plantilla de CloudFormation.

Requisitos previos

Para completar este tutorial, debe tener acceso a la CLI de AWS (consulte Introducción a la CLI de AWS) o utilice el acceso a la línea de comandos desde AWS CloudShell.

Configurar grupos, usuarios, roles y políticas de IAM

En esta sección, creamos dos usuarios de IAM: ingeniero de datos y científico de datos, que pertenecen al grupo de plataformas de datos del grupo IAM. Luego agregamos una única política de IAM al grupo de IAM.

En la consola de IAM, crear una política en la pestaña JSON para crear una nueva política administrada de IAM llamada DataPlatformGroupPolicy. La política permite que los usuarios del grupo accedan a Studio, pero solo mediante un perfil de usuario de SageMaker con una etiqueta que coincida con su nombre de usuario de IAM. Utilice el siguiente documento de política JSON para proporcionar permisos:

{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Action":[
            "sagemaker:DescribeDomain",
            "sagemaker:ListDomains",
            "sagemaker:ListUserProfiles",
            "sagemaker:ListApps"
         ],
         "Resource":"*",
         "Effect":"Allow",
         "Sid":"AmazonSageMakerStudioReadOnly"
      },
      {
         "Action":"sagemaker:AddTags",
         "Resource":"*",
         "Effect":"Allow",
         "Sid":"AmazonSageMakerAddTags"
      },
      {
         "Condition":{
            "StringEquals":{
               "sagemaker:ResourceTag/studiouserid":"${aws:username}"
            }
         },
         "Action":[
            "sagemaker:CreatePresignedDomainUrl",
            "sagemaker:DescribeUserProfile"
         ],
         "Resource":"*",
         "Effect":"Allow",
         "Sid":"AmazonSageMakerAllowedUserProfile"
      },
      {
         "Condition":{
            "StringNotEquals":{
               "sagemaker:ResourceTag/studiouserid":"${aws:username}"
            }
         },
         "Action":[
            "sagemaker:CreatePresignedDomainUrl",
            "sagemaker:DescribeUserProfile"
         ],
         "Resource":"*",
         "Effect":"Deny",
         "Sid":"AmazonSageMakerDeniedUserProfiles"
      }
   ]
}

Crea un grupo de IAM , que son data-platform-group.
Busque y adjunte la política administrada de AWS denominada DataPlatformGroupPolicy al grupo.
Crear usuarios de IAM llamado ingeniero de datos y científico de datos bajo el grupo de plataformas de datos del grupo IAM.

Crear una nueva política administrada llamado SageMakerExecutionPolicy (proporcione su región e ID de cuenta en el siguiente código):

{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Action":[
            "sagemaker:DescribeDomain",
            "sagemaker:ListDomains",
            "sagemaker:ListUserProfiles",
            "sagemaker:ListApps"
         ],
         "Resource":"*",
         "Effect":"Allow",
         "Sid":"AmazonSageMakerStudioReadOnly"
      },
      {
         "Action":"sagemaker:AddTags",
         "Resource":"*",
         "Effect":"Allow",
         "Sid":"AmazonSageMakerAddTags"
      },
      {
         "Action":[
            "sagemaker:CreateTrainingJob",
            "sagemaker:DescribeTrainingJob",
            "logs:DescribeLogStreams",
            "sagemaker:CreateModel",
            "sagemaker:CreateEndpointConfig",
            "sagemaker:CreateEndpoint",
            "sagemaker:DescribeEndpoint",
            "sagemaker:InvokeEndpoint",
            "sagemaker:DeleteEndpointConfig",
            "sagemaker:DeleteEndpoint"
         ],
         "Resource":"*",
         "Effect":"Allow",
         "Sid":"AmazonSageMakerTrainingAndDeploy"
      },
      {
         "Action":"sagemaker:*App",
         "Resource":"arn:aws:sagemaker:::app/*/${aws:PrincipalTag/userprofilename}/*",
         "Effect":"Allow",
         "Sid":"AmazonSageMakerAllowedApp"
      },
      {
         "Action":"sagemaker:*App",
         "Effect":"Deny",
         "NotResource":"arn:aws:sagemaker:::app/*/${aws:PrincipalTag/userprofilename}/*",
         "Sid":"AmazonSageMakerDeniedApps"
      },
      {
         "Action":[
            "glue:GetTable",
            "glue:GetTables",
            "glue:SearchTables",
            "glue:GetDatabase",
            "glue:GetDatabases",
            "glue:GetPartition",
            "glue:GetPartitions"
         ],
         "Resource":[
            "arn:aws:glue:::table/demo/*",
            "arn:aws:glue:::database/demo",
            "arn:aws:glue:::catalog"
         ],
         "Effect":"Allow",
         "Sid":"GlueCatalogPermissions"
      },
      {
         "Action":[
            "lakeformation:GetDataAccess",
            "lakeformation:StartQueryPlanning",
            "lakeformation:GetQueryState",
            "lakeformation:GetWorkUnits",
            "lakeformation:GetWorkUnitResults"
         ],
         "Resource":"*",
         "Effect":"Allow",
         "Sid":"LakeFormationPermissions"
      },
      {
         "Effect":"Allow",
         "Action":[
            "s3:CreateBucket",
            "s3:GetObject",
            "s3:PutObject",
            "s3:ListBucket",
            "s3:DeleteObject"
         ],
         "Resource":[
            "arn:aws:s3:::blog-studio-output-",
            "arn:aws:s3:::blog-studio-output-/*"
         ]
      },
      {
         "Action":[
            "iam:PassRole",
            "iam:GetRole",
            "sts:GetCallerIdentity"
         ],
         "Resource":"*",
         "Effect":"Allow",
         "Sid":"AmazonSageMakerStudioIAMPassRole"
      },
      {
         "Action":"sts:AssumeRole",
         "Resource":"*",
         "Effect":"Deny",
         "Sid":"DenyAssummingOtherIAMRoles"
      }
   ]
}

Crear una nueva política administrada llamado SageMakerAdminPolicy:

{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Action":[
            "lakeformation:GrantPermissions",
            "lakeformation:RevokePermissions",
            "lakeformation:ListPermissions",
            "lakeformation:BatchGrantPermissions",
            "lakeformation:BatchRevokePermissions",
            "lakeformation:CreateDataCellsFilter",
            "lakeformation:DeleteDataCellsFilter",
            "lakeformation:ListDataCellsFilter",
            "glue:GetUserDefinedFunctions",
            "glue:BatchGetCustomEntityTypes"
         ],
         "Resource":"*",
         "Effect":"Allow",
         "Sid":"GlueLakeFormationPermissions"
      }
   ]
}

Crear un rol de IAM para SageMaker para el ingeniero de datos (ingeniero de datos), que se utiliza como el rol de ejecución del perfil de usuario correspondiente. Sobre el Adjuntar política de permisos página, AmazonSageMakerFullAccess (política administrada por AWS) se adjunta de forma predeterminada. Quite esta política más adelante para mantener el privilegio mínimo.
1. Nombre de rol, use la convención de nomenclatura presentada al principio de esta sección para nombrar el rol SageMakerStudioExecutionRole_data-engineer.
2. Etiquetas, agregue la clave userprofilename y el valor data-engineer.
3. Elige Crear rol.
4. Para agregar las políticas restantes, en el Roles página, elija el nombre del rol que acaba de crear.
5. under Permisos, elimine la política AmazonSageMakerFullAccess.
6. En Adjuntar política de permisos seleccione la política administrada por AWS AwsGlueSessionUserRestrictedServiceRole y las políticas administradas por el cliente SageMakerExecutionPolicy y SageMakerAdminPolicy que creó.
7. Elige Adjuntar políticas.
8. modificar la relación de confianza de su rol:
```
{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":[
               "glue.amazonaws.com",
               "sagemaker.amazonaws.com"
            ]
         },
         "Action":"sts:AssumeRole"
      }
   ]
}
```
Crear un rol de IAM para SageMaker para el científico de datos (data-scientist), que se utiliza como el rol de ejecución del perfil de usuario correspondiente.
1. Nombre de rol, nombre el rol SageMakerStudioExecutionRole_data-scientist.
2. Etiquetas, agregue la clave userprofilename y el valor data-scientist.
3. Elige Crear rol.
4. Para agregar las políticas restantes, en el Roles página, elija el nombre del rol que acaba de crear.
5. under Permisos, elimine la política AmazonSageMakerFullAccess.
6. En Adjuntar política de permisos seleccione la política administrada por AWS AwsGlueSessionUserRestrictedServiceRole y la política administrada por el cliente SageMakerExecutionPolicy que creó.
7. Elige Adjuntar políticas.
8. modificar la relación de confianza de su rol:
```
{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":[
               "glue.amazonaws.com",
               "sagemaker.amazonaws.com"
            ]
         },
         "Action":"sts:AssumeRole"
      }
   ]
}
```

Configurar perfiles de usuario de SageMaker

Para crear sus perfiles de usuario de SageMaker con el studiouserid etiqueta, complete los siguientes pasos:

Utilice la CLI de AWS o CloudShell para crear el perfil de usuario de Studio para el ingeniero de datos (proporcione su ID de cuenta y el ID de dominio de Studio en el siguiente código):

aws sagemaker create-user-profile --domain-id  --user-profile-name data-engineer --tags Key=studiouserid,Value=data-engineer --user-settings ExecutionRole=arn:aws:iam:::role/SageMakerStudioExecutionRole_data-engineer

Repita el paso para crear un perfil de usuario para el científico de datos, reemplazando el ID de cuenta y el ID de dominio de Studio:

aws sagemaker create-user-profile --domain-id  --user-profile-name data-scientist --tags Key=studiouserid,Value=data-scientist --user-settings ExecutionRole=arn:aws:iam:::role/SageMakerStudioExecutionRole_data-scientist

Cree depósitos S3 y cargue el conjunto de datos de muestra

En esta sección, crea dos depósitos S3. El primer depósito tiene un conjunto de datos de muestra relacionado con el marketing web. El científico de datos usa el segundo depósito para almacenar la salida de las tareas de ingeniería de características, y este conjunto de datos de salida se usa para entrenar el modelo ML.

Primero, cree el depósito S3 para los datos de entrada:

Descargar el conjunto de datos.
En la consola de Amazon S3, elija cubos en el panel de navegación.
Elige Crear cubeta.
Provincia, elija la región con el dominio de SageMaker que incluye los perfiles de usuario que creó.
Nombre del cubo, introduzca blog-studio-pii-dataset-.
Elige Crear cubeta.
Selecciona el cubo que creaste y elige Subir.
En Seleccione archivos sección, elija Añadir archivos y cargue el conjunto de datos que descargó.
Ahora crea el depósito para los datos de salida:
En cubos página, elige Crear cubeta.
Provincia, elija la región con el dominio de SageMaker que incluye los perfiles de usuario que creó.
Nombre del cubo, introduzca blog-studio-output-.
Elige Crear cubeta.

Cree una base de datos y una tabla de AWS Glue

En esta sección, creará una base de datos y una tabla de AWS Glue para el conjunto de datos.

En la consola de Lake Formation, debajo Catálogo de datos en el panel de navegación, elija Bases de datos.
Elige Agregar base de datos.
Nombre, ingrese demostración.
Elige Crear base de datos.
under Catálogo de datos, escoger Mesas.
Nombre, introduzca web_marketing.
Base de datos, seleccione demo.
Incluir ruta, ingrese la ruta de su depósito S3 para los datos de entrada.
Clasificación, escoger CSV.
under Esquema, escoger Cargar esquema.

Ingrese la siguiente matriz JSON en el cuadro de texto:

[
   {
      "Name":"lastcampaignactivity",
      "Type":"string"
   },
   {
      "Name":"pageviewspervisit",
      "Type":"double"
   },
   {
      "Name":"totaltimeonwebsite",
      "Type":"bigint"
   },
   {
      "Name":"totalwebvisits",
      "Type":"bigint"
   },
   {
      "Name":"attendedmarketingevent",
      "Type":"string"
   },
   {
      "Name":"organicsearch",
      "Type":"string"
   },
   {
      "Name":"viewedadvertisement",
      "Type":"string"
   },
   {
      "Name":"leadsource",
      "Type":"string"
   },
   {
      "Name":"jobrole",
      "Type":"string"
   },
   {
      "Name":"contactnotes",
      "Type":"string"
   },
   {
      "Name":"leadprofile",
      "Type":"string"
   },
   {
      "Name":"usedpromo",
      "Type":"string"
   },
   {
      "Name":"donotreachout",
      "Type":"boolean"
   },
   {
      "Name":"city",
      "Type":"string"
   },
   {
      "Name":"converted",
      "Type":"bigint"
   },
   {
      "Name":"region",
      "Type":"string"
   },
   {
      "Name":"phone_number",
      "Type":"string"
   }
]

Elige Subir.
Elige Enviar.
under Detalles de la tabla, escoger Editar tabla.
under Propiedades de la tabla, escoger Añada.
Clave, introduzca skip.header.line.count, Y para Valor, ingrese 1.
Elige Guardar.

Configurar permisos de formación de lagos

En esta sección, configurará los permisos de Lake Formation para permitir el rol de IAM SageMakerStudioExecutionRole_data-engineer para crear una base de datos y registrar la ubicación S3 dentro de Lake Formation.

Primero, registre la ubicación del lago de datos para administrar tablas bajo la ubicación en los permisos de Formación del lago:

Elige Ubicaciones de data lake.
Elige Registrar ubicación.
Ruta de Amazon S3, introduzca s3://blog-studio-pii-dataset-/ (el depósito que contiene el conjunto de datos).
Elige Registrar ubicación.
Ahora otorga permisos de tabla y base de datos de Lake Formation a los roles de IAM SageMakerStudioExecutionRole_data-engineer y SageMakerStudioExecutionRole_data-scientist.Primero, otorgue permiso de base de datos para SageMakerStudioExecutionRole_data-engineer:
under Permisos, escoger Permisos del lago de datos.
under Permiso de datos, escoger Grant.
Directores, escoger Usuarios y roles de IAMy seleccione el rol SageMakerStudioExecutionRole_data-engineer.
Etiquetas de política o recursos de catálogo, escoger Recursos de catálogo de datos con nombre.
Bases de datos, elija demostración.
permisos de base de datos, selecciona súper.
Elige Grant.
A continuación, otorgue permiso de mesa para SageMakerStudioExecutionRole_data-engineer:
under Permiso de datos, escoger Grant.
Directores, escoger Usuarios y roles de IAMy seleccione el rol SageMakerStudioExecutionRole_data-engineer.
Etiquetas de política o recursos de catálogo, escoger Recursos de catálogo de datos con nombre.
Bases de datos, escoger demo.
Mesas, escoger web_marketing.
Mesa permisos, selecciona súper.
otorgable permisos, selecciona súper.
Elige Grant.
Finalmente, otorgue permiso de base de datos para SageMakerStudioExecutionRole_data-scientist:
under Permiso de datos, escoger Grant.
Directores, escoger Usuarios y roles de IAMy seleccione el rol SageMakerStudioExecutionRole_data-scientist.
Etiquetas de política o recursos de catálogo, escoger Recursos de catálogo de datos con nombre.
Bases de datos, escoger demo.
permisos de base de datos, selecciona Describir.
Elige Grant.

Acerca de los autores

Ingeniería de funciones a gran escala con protección de datos confidenciales mediante sesiones interactivas de AWS Glue y Amazon SageMaker Studio PlatoBlockchain Data Intelligence. Búsqueda vertical. Ai.

Praveen Kumar es un arquitecto de soluciones de análisis en AWS con experiencia en el diseño, la creación y la implementación de plataformas modernas de datos y análisis mediante servicios nativos de la nube. Sus áreas de interés son la tecnología sin servidor, los almacenes de datos en la nube modernos, la transmisión y las aplicaciones de aprendizaje automático.

Noritaka Sekiyama es Arquitecto Principal de Big Data en el equipo de AWS Glue. Le gusta colaborar con diferentes equipos para obtener resultados como este post. En su tiempo libre, disfruta jugar videojuegos con su familia.

Sello de tiempo: 17 de noviembre.20 de noviembre.

Sello de tiempo: 26 de jul, 2023

Ingeniería de funciones a gran escala con protección de datos confidenciales mediante sesiones interactivas de AWS Glue y Amazon SageMaker Studio

Reeditado por Platón

Caso de uso

Resumen de la solución

Requisitos previos

Configurar recursos con AWS CloudFormation

Preprocesar el conjunto de datos

Realizar ingeniería de características

Entrene e implemente un modelo de ML

Evaluar el modelo ML

Limpiar

Conclusión

Apéndice: Configurar recursos a través de la consola y la CLI de AWS

Requisitos previos

Configurar grupos, usuarios, roles y políticas de IAM

Configurar perfiles de usuario de SageMaker

Cree depósitos S3 y cargue el conjunto de datos de muestra

Cree una base de datos y una tabla de AWS Glue

Configurar permisos de formación de lagos

Acerca de los autores

Mas de Aprendizaje automático de AWS

Ejecute varios modelos de aprendizaje profundo en GPU con puntos de enlace de varios modelos de Amazon SageMaker

Utilice el CDK de AWS para implementar configuraciones de ciclo de vida de Amazon SageMaker Studio | Servicios web de Amazon

Amazon Rekognition presenta Streaming Video Events para proporcionar alertas en tiempo real sobre transmisiones de video en vivo

Anuncio de la AWS DeepRacer League 2022

Cómo Amp en Amazon usó datos para aumentar la participación del cliente, Parte 1: Creación de una plataforma de análisis de datos

Optimice el rendimiento del equipo con datos históricos, Ray y Amazon SageMaker | Servicios web de Amazon

Sobre Nosotros

Búsqueda vertical y Ai

Productos

Manténganse Conectados

Mi Cuenta