Ingegneria di funzionalità su larga scala con protezione dei dati sensibili utilizzando sessioni interattive di AWS Glue e Amazon SageMaker Studio

Ripubblicato da Platone

Seguaci: 0

Le organizzazioni utilizzano i servizi di machine learning (ML) e AI per migliorare l'esperienza del cliente, ridurre i costi operativi e sbloccare nuove possibilità per migliorare i risultati aziendali. I dati sono alla base dei casi d'uso di ML e AI e rappresentano una risorsa strategica per un'organizzazione. Poiché i dati crescono a un ritmo esponenziale, le organizzazioni stanno cercando di creare una piattaforma dati integrata, conveniente e performante per preelaborare i dati, eseguire la progettazione delle funzionalità e creare, addestrare e rendere operativi i modelli ML su larga scala. Per raggiungere questo obiettivo, AWS offre una moderna piattaforma dati unificata alimentata da Servizio di archiviazione semplice Amazon (Amazon S3) come data lake con strumenti e motori di elaborazione appositamente creati per supportare analisi e carichi di lavoro ML. Per un'esperienza ML unificata, puoi usare Amazon Sage Maker Studio, Che offre integrazione nativa con le sessioni interattive di AWS Glue per eseguire la progettazione delle funzionalità su larga scala con la protezione dei dati sensibili. In questo post, dimostriamo come implementare questa soluzione.

Amazon Sage Maker è un servizio ML completamente gestito che consente di creare, addestrare e distribuire modelli su larga scala per un'ampia gamma di casi d'uso. Per l'addestramento del modello, puoi utilizzare uno qualsiasi dei algoritmi incorporati all'interno di SageMaker per iniziare a addestrare e distribuire rapidamente i modelli ML.

Un componente chiave del processo di costruzione e sviluppo del modello è l'ingegnerizzazione delle caratteristiche. Colla AWS è una delle opzioni consigliate per ottenere la progettazione delle funzionalità su larga scala. AWS Glue ti consente di eseguire l'integrazione e la trasformazione dei dati in modo distribuito su un'infrastruttura Apache Spark serverless e semplifica l'utilizzo della popolare libreria Spark ML per l'ingegnerizzazione delle funzionalità e lo sviluppo di modelli. Inoltre, puoi utilizzare AWS Glue per l'elaborazione incrementale dei dati tramite segnalibri di lavoro, acquisisci dati da oltre 100 fonti utilizzando connettoried eseguire carichi di lavoro spinosi o imprevedibili utilizzando ridimensionamento automatico.

Un altro requisito importante per le applicazioni basate su ML è la sicurezza dei dati e il controllo degli accessi. È una richiesta comune avere un controllo più stretto su chi può accedere ai dati più sensibili come parte del processo di progettazione delle funzionalità e di creazione del modello seguendo il principio dell'accesso con privilegi minimi. Per raggiungere questo obiettivo, puoi utilizzare l'integrazione di AWS Glue con Formazione AWS Lake per una maggiore governance e gestione delle risorse del data lake. Con Lake Formation, puoi configurare il controllo granulare dell'accesso ai dati e le policy di sicurezza sul tuo data lake Amazon S3. Le policy sono definite in una posizione centrale, consentendo analisi multiple e servizi ML, come AWS Glue, Amazzone Atenae SageMaker, per interagire con i dati archiviati in Amazon S3.

AWS Glue include un rilevamento di informazioni di identificazione personale (PII). trasformazione che offre la possibilità di rilevare, mascherare o rimuovere le entità come richiesto, per una maggiore conformità e governance. Con la trasformazione PII, puoi rilevare i dati PII nei set di dati e applicare automaticamente un controllo degli accessi granulare utilizzando Lake Formation per limitare i dati sensibili per diversi gruppi di utenti.

Caso d'uso

Ci concentriamo su un caso d'uso del modello di propensione che include un set di dati di marketing del cliente e coinvolge due utenti: un ingegnere dei dati e uno scienziato dei dati. Il set di dati contiene informazioni per cliente, tra cui origine del lead, note di contatto, ruolo lavorativo, alcuni contrassegni, visualizzazioni di pagina per visita e altro ancora. Il set di dati include anche informazioni sensibili come i numeri di telefono personali.

L'ingegnere dei dati è responsabile della creazione della pipeline di elaborazione dei dati end-to-end, inclusa la preparazione dei dati, la pre-elaborazione e il controllo degli accessi. Il data scientist è responsabile dell'ingegneria delle funzionalità, della formazione e della distribuzione del modello ML. Tieni presente che il data scientist non è autorizzato ad accedere a dati sensibili PII per la progettazione delle funzionalità o l'addestramento del modello ML.

Come parte di questo caso d'uso, l'ingegnere dei dati crea una pipeline di dati per pre-elaborare il set di dati, esegue la scansione del set di dati per eventuali informazioni PII e limita l'accesso alla colonna PII all'utente data scientist. Di conseguenza, quando un data scientist utilizza il set di dati per eseguire la progettazione delle funzionalità e creare modelli ML, non ha accesso alla colonna sensibile PII (numeri di telefono, in questo caso). Il processo di progettazione delle funzionalità comporta la conversione di colonne di tipo stringa in un formato ottimale per i modelli ML. Come caso d'uso avanzato, puoi estendere questo modello di accesso per implementare la sicurezza a livello di riga e di cella utilizzando Lake Formation.

Panoramica della soluzione

La soluzione contiene i seguenti passaggi di alto livello:

Imposta le risorse con AWS CloudFormazione.
Preelabora il set di dati, inclusi il rilevamento PII e il controllo granulare degli accessi, in una sessione interattiva di AWS Glue.
Esegui la progettazione delle funzionalità in una sessione interattiva di AWS Glue.
Addestra e distribuisci un modello ML utilizzando l'algoritmo XGBoost integrato di SageMaker.
Valuta il modello ML.

Il diagramma seguente illustra l'architettura della soluzione.

Prerequisiti

Per completare questo tutorial, devi avere i seguenti prerequisiti:

Configura le risorse con AWS CloudFormation

Questo post include un modello CloudFormation per una configurazione rapida. Puoi rivederlo e personalizzarlo in base alle tue esigenze. Se preferisci impostare le risorse sul file Console di gestione AWS e l'AWS CLI anziché AWS CloudFormation, consulta le istruzioni nell'appendice alla fine di questo post.

Il modello CloudFormation genera le seguenti risorse:

Bucket S3 con un set di dati di esempio
An AWS Lambda funzione per caricare il set di dati
Gestione dell'identità e dell'accesso di AWS (IAM) gruppo, utenti, ruoli e policy
Impostazioni e autorizzazioni del data lake di Lake Formation
Profili utente SageMaker

Per creare le tue risorse, completa i seguenti passaggi:

Accedi alla console.
Scegli Avvia Stack:
Scegli Avanti.
Nel Data EngineerPwd ed DataScientistPwd, inserisci la tua password per gli utenti Data Engineer e Data Scientist.
Nel NomeDatabaseColla, accedere demo.
Nel NomeTabellaColla, accedere web_marketing.
Nel S3BucketNameForInput, accedere blog-studio-pii-dataset-.
Nel S3BucketNameForOutput, accedere blog-studio-output-.
Nel ID dominio SageMaker, inserisci il tuo ID dominio SageMaker che hai preparato nei passaggi preliminari.
Scegli Avanti.
Nella pagina successiva, scegli Avanti.
Rivedere i dettagli nella pagina finale e selezionare Riconosco che AWS CloudFormation potrebbe creare risorse IAM.
Scegli Creare.

La creazione dello stack può richiedere fino a 10 minuti. Lo stack crea ruoli IAM e profili utente SageMaker per due persone: data engineer e data scientist. Crea anche una demo e una tabella del database web_marketing con un set di dati di esempio.

Al momento della creazione dello stack, la persona data engineer ha accesso completo alla tabella, ma la persona data scientist non ha ancora accesso alla tabella.

Preelaborare il set di dati

Iniziamo la pre-elaborazione dei dati in una sessione interattiva di AWS Glue. L'ingegnere di dati desidera verificare i dati per vedere se sono presenti dati sensibili o meno e concedere un'autorizzazione di accesso minima all'utente di data scientist. Puoi scaricare il taccuino da questa posizione.

Accedi alla console utilizzando l'utente data-engineer.
Sulla console di SageMaker, scegli Utenti.
Selezionare l'utente ingegnere dei dati e scegliere Apri Studio.
Crea un nuovo taccuino e scegli Spark Analytics 1.0 per Immagine ed Colla PySpark per nocciolo.
Avvia una sessione interattiva con la seguente magia per installare la versione più recente di Boto3 (questo è necessario per utilizzare il file create_data_cells_filter metodo):
```
%additional_python_modules boto3==1.24.82
```

Inizializza la sessione:

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)

Crea un AWS Glue DynamicFrame dalla tabella appena creata e risolvere i tipi di scelta basato sullo schema del catalogo, perché vogliamo utilizzare lo schema definito nel catalogo invece dello schema dedotto automaticamente basato sui dati:

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()

Convalida nella tabella se sono presenti dati PII utilizzando il rilevamento PII di 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)

Verifica se le colonne classificate come PII contengono o meno dati sensibili (in caso contrario, aggiorna la mappa classificata per eliminare le colonne non sensibili):
```
from pyspark.sql.functions import col
dyf_marketing_resolved.toDF().select(*[col(c) for c in classified_map.keys()]).show()
```

Imposta le autorizzazioni Lake Formation utilizzando un filtro cella dati per le colonne rilevate automaticamente e limita le colonne al personaggio data scientist:

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'
]
)

Accedi a Studio come data-scientist per verificare che le colonne PII non siano visibili. Puoi scaricare il taccuino da questa posizione.

Crea un nuovo taccuino e scegli Spark Analytics 1.0 per Immagine ed Colla PySpark per nocciolo:

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()

Eseguire l'ingegneria delle funzionalità

Utilizziamo la libreria Apache Spark ML per eseguire l'ingegnerizzazione delle funzionalità come utente data-scientist e quindi riscrivere l'output su Amazon S3.

Nella cella seguente, applichiamo le funzionalità di Libreria Apache Spark ML:
- StringIndexer esegue il mapping di una colonna di stringhe di etichette a una colonna di indici di etichette.
- OneHotEncoder associa una caratteristica categoriale, rappresentata come un indice di etichetta, a un vettore binario con al massimo un singolo valore uno che indica la presenza di una specifica caratteristica categoriale. Questa trasformazione viene utilizzata per gli algoritmi ML che prevedono funzionalità continue.
- VectorAssembler è un trasformatore che combina un determinato elenco di colonne in una singola colonna vettoriale, che viene quindi utilizzata nell'addestramento di modelli ML per algoritmi come regressione logistica e alberi decisionali.
```
#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"
)
```
Il DataFrame trasformato finale può essere creato utilizzando la libreria Pipeline. Una pipeline è specificata come una sequenza di fasi. Queste fasi vengono eseguite in ordine e il DataFrame di input viene trasformato mentre passa attraverso ogni fase.
```
df_marketing = dyf_marketing.toDF()
pipeline = Pipeline(stages=indexers + encoders + [assembler])
df_tfm=pipeline.fit(df_marketing).transform(df_marketing)
```

Successivamente, suddividiamo il set di dati in DataFrame di addestramento, convalida e test e lo salviamo nel bucket S3 per addestrare il modello ML (fornisci il tuo ID account AWS nel codice seguente):

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))

Addestra e distribuisci un modello ML

Nella sezione precedente, abbiamo completato la progettazione delle funzionalità, che includeva la conversione di colonne stringa come region, jobrolee usedpromo in un formato ottimale per i modelli ML. Abbiamo incluso anche colonne come pageviewspervisit ed totalwebvisits, che ci aiuterà a prevedere la propensione di un cliente ad acquistare un prodotto.

Ora addestriamo un modello ML leggendo il set di dati di addestramento e convalida utilizzando l'algoritmo XGBoost integrato di SageMaker. Quindi distribuiamo il modello ed eseguiamo un controllo di precisione. Puoi scaricare il taccuino da questa posizione.

Nella cella seguente, stiamo leggendo i dati dal secondo bucket S3, che include l'output delle nostre operazioni di ingegneria delle funzionalità. Quindi utilizziamo l'algoritmo integrato XGBoost per addestrare il modello.

Apri un nuovo taccuino. Scegliere Science Data per Immagine ed Python 3 per nocciolo (fornisci il tuo ID account AWS nel seguente codice):

#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})

Al termine dell'addestramento, possiamo distribuire il modello utilizzando i servizi di hosting SageMaker:
```
#deploy ml model
xgb_predictor = xgb.deploy(initial_instance_count=1,
instance_type='ml.m4.xlarge')
```

Valuta il modello ML

Usiamo il set di dati di test per valutare il modello ed eliminiamo l'endpoint di inferenza quando abbiamo finito per evitare eventuali addebiti in corso.

Valutare il modello con il seguente codice:

#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))

Il risultato di accuratezza per l'esecuzione del campione è stato dell'84.6%. Questo potrebbe essere leggermente diverso per la tua esecuzione a causa della suddivisione casuale del set di dati.

Possiamo eliminare l'endpoint di inferenza con il seguente codice:
```
xgb_predictor.delete_endpoint(delete_endpoint_config=True)
```

ripulire

Passiamo ora al passaggio finale, ripulire le risorse.

Svuota i due bucket creati tramite lo stack CloudFormation.
Elimina le app associate all'utente profiles data-scientist ed data-engineer all'interno dello Studio.
Elimina lo stack di CloudFormation.

Conclusione

In questo post, abbiamo dimostrato una soluzione che consente a persone come data engineer e data scientist di eseguire l'ingegneria delle funzionalità su larga scala. Con le sessioni interattive di AWS Glue, puoi ottenere facilmente l'ingegnerizzazione delle funzionalità su larga scala con il rilevamento automatico delle PII e il controllo granulare degli accessi senza dover gestire alcuna infrastruttura sottostante. Utilizzando Studio come unico punto di accesso, puoi ottenere un'esperienza semplificata e integrata per creare un flusso di lavoro ML end-to-end: dalla preparazione e protezione dei dati alla creazione, addestramento, messa a punto e distribuzione di modelli ML. Per saperne di più, visita Iniziare con le sessioni interattive di AWS Glue ed Amazon Sage Maker Studio.

Siamo molto entusiasti di questa nuova funzionalità e ansiosi di vedere cosa costruirai con essa!

Appendice: configurazione delle risorse tramite la console e l'AWS CLI

Completa le istruzioni in questa sezione per configurare le risorse utilizzando la console e AWS CLI anziché il modello CloudFormation.

Prerequisiti

Per completare questo tutorial, devi avere accesso all'AWS CLI (vedi Nozioni di base sull'AWS CLI) o utilizzare l'accesso alla riga di comando da AWS CloudShell.

Configura gruppo, utenti, ruoli e policy IAM

In questa sezione creiamo due utenti IAM: data-engineer e data-scientist, che appartengono al gruppo IAM data-platform-group. Quindi aggiungiamo una singola policy IAM al gruppo IAM.

Sulla console IAM, creare un criterio nella scheda JSON per creare una nuova policy gestita IAM denominata DataPlatformGroupPolicy. La policy consente agli utenti del gruppo di accedere a Studio, ma solo utilizzando un profilo utente SageMaker con un tag che corrisponda al loro nome utente IAM. Utilizza il seguente documento di policy JSON per fornire le autorizzazioni:

{
   "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 gruppo IAM detto data-platform-group.
Cerca e collega la policy gestita da AWS denominata DataPlatformGroupPolicy al gruppo.
Crea utenti IAM chiamato data-engineer e data-scientist sotto il gruppo IAM data-platform-group.

Crea un nuovo criterio gestito denominato SageMakerExecutionPolicy (fornisci la tua regione e l'ID account nel seguente codice):

{
   "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"
      }
   ]
}

Crea un nuovo criterio gestito detto 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"
      }
   ]
}

Crea un ruolo IAM per SageMaker per l'ingegnere dei dati (ingegnere dei dati), che viene utilizzato come ruolo di esecuzione del profilo utente corrispondente. Sul Allega criteri di autorizzazione page, AmazonSageMakerFullAccess (policy gestita da AWS) è collegato per impostazione predefinita. Rimuovi questo criterio in un secondo momento per mantenere il privilegio minimo.
1. Nel Nome del ruolo, utilizzare la convenzione di denominazione introdotta all'inizio di questa sezione per denominare il ruolo SageMakerStudioExecutionRole_data-engineer.
2. Nel tag, aggiungi la chiave userprofilename e il valore data-engineer.
3. Scegli Crea ruolo.
4. Per aggiungere i criteri rimanenti, in Ruoli scegli il nome del ruolo appena creato.
5. Sotto Permessi, rimuovi la policy AmazonSageMakerFullAccess.
6. Sulla Allega criteri di autorizzazione pagina, seleziona la policy gestita da AWS AwsGlueSessionUserRestrictedServiceRole e le policy gestite dal cliente SageMakerExecutionPolicy e SageMakerAdminPolicy che hai creato.
7. Scegli Allega criteri.
8. modificare la relazione di fiducia del tuo ruolo:
```
{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":[
               "glue.amazonaws.com",
               "sagemaker.amazonaws.com"
            ]
         },
         "Action":"sts:AssumeRole"
      }
   ]
}
```
Crea un ruolo IAM per SageMaker per il data scientist (data-scientist), che viene utilizzato come ruolo di esecuzione del profilo utente corrispondente.
1. Nel Nome del ruolo, denominare il ruolo SageMakerStudioExecutionRole_data-scientist.
2. Nel tag, aggiungi la chiave userprofilename e il valore data-scientist.
3. Scegli Crea ruolo.
4. Per aggiungere i criteri rimanenti, in Ruoli scegli il nome del ruolo appena creato.
5. Sotto Permessi, rimuovi la policy AmazonSageMakerFullAccess.
6. Sulla Allega criteri di autorizzazione pagina, seleziona la policy gestita da AWS AwsGlueSessionUserRestrictedServiceRole e la policy gestita dal cliente SageMakerExecutionPolicy che hai creato.
7. Scegli Allega criteri.
8. modificare la relazione di fiducia del tuo ruolo:
```
{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":[
               "glue.amazonaws.com",
               "sagemaker.amazonaws.com"
            ]
         },
         "Action":"sts:AssumeRole"
      }
   ]
}
```

Configura i profili utente di SageMaker

Per creare i tuoi profili utente SageMaker con il file studiouserid tag, completare i seguenti passaggi:

Utilizza l'AWS CLI o CloudShell per creare il profilo utente di Studio per il data engineer (fornisci il tuo ID account e l'ID dominio di Studio nel codice seguente):

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

Ripeti il passaggio per creare un profilo utente per il data scientist, sostituendo l'ID account e l'ID dominio di 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

Crea bucket S3 e carica il set di dati di esempio

In questa sezione crei due bucket S3. Il primo bucket ha un set di dati di esempio relativo al web marketing. Il secondo bucket viene utilizzato dal data scientist per archiviare l'output dalle attività di ingegneria delle funzionalità e questo set di dati di output viene utilizzato per addestrare il modello ML.

Innanzitutto, crea il bucket S3 per i dati di input:

Scaricare il set di dati.
Sulla console Amazon S3, scegli Secchi nel pannello di navigazione.
Scegli Crea un secchio.
Nel Regione, scegli la regione con il dominio SageMaker che include i profili utente che hai creato.
Nel Nome del secchio, accedere blog-studio-pii-dataset-.
Scegli Crea un secchio.
Seleziona il bucket che hai creato e scegli Caricare.
Nel selezionare i file sezione, scegliere Aggiungere file e carica il set di dati che hai scaricato.
Ora crei il bucket per i dati di output:
Sulla Secchi pagina, scegli Crea un secchio.
Nel Regione, scegli la regione con il dominio SageMaker che include i profili utente che hai creato.
Nel Nome del secchio, accedere blog-studio-output-.
Scegli Crea un secchio.

Crea un database e una tabella AWS Glue

In questa sezione crei un database e una tabella AWS Glue per il set di dati.

Sulla console Lake Formation, sotto Catalogo dati nel pannello di navigazione, scegli Database.
Scegli Aggiungi database.
Nel Nome, inserisci demo.
Scegli Crea database.
Sotto Catalogo datiscegli tavoli.
Nel Nome, accedere web_marketing.
Nel Banca Dati, selezionare demo.
Nel Includi percorso, inserisci il percorso del tuo bucket S3 per i dati di input.
Nel Classificazionescegli CSV.
Sotto Schemascegli Carica schema.

Immettere il seguente array JSON nella casella di testo:

[
   {
      "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"
   }
]

Scegli Caricare.
Scegli Invio.
Sotto Dettagli della tabellascegli Modifica tabella.
Sotto Proprietà della tabellascegli Aggiungi.
Nel Le, accedere skip.header.line.count, E per Valore, inserisci 1.
Scegli Risparmi.

Configura le autorizzazioni Lake Formation

In questa sezione, imposti le autorizzazioni Lake Formation per consentire il ruolo IAM SageMakerStudioExecutionRole_data-engineer per creare un database e registrare la posizione S3 all'interno di Lake Formation.

Innanzitutto, registra la posizione del data lake per gestire le tabelle sotto la posizione nelle autorizzazioni Lake Formation:

Scegli Posizioni del data lake.
Scegli Registra posizione.
Nel Percorso Amazon S3, accedere s3://blog-studio-pii-dataset-/ (il bucket che contiene il set di dati).
Scegli Registra posizione.
Ora concedi le autorizzazioni del database e della tabella Lake Formation ai ruoli IAM SageMakerStudioExecutionRole_data-engineer ed SageMakerStudioExecutionRole_data-scientist.In primo luogo, concedi l'autorizzazione al database per SageMakerStudioExecutionRole_data-engineer:
Sotto Permessiscegli Autorizzazioni del data lake.
Sotto Autorizzazione datiscegli Grant.
Nel Principalsscegli Utenti e ruoli IAMe selezionare il ruolo SageMakerStudioExecutionRole_data-engineer.
Nel Tag dei criteri o risorse del catalogoscegli Risorse del catalogo dati con nome.
Nel Database, scegli demo.
Nel Autorizzazioni database, select Super.
Scegli Grant.
Successivamente, concedi l'autorizzazione alla tabella per SageMakerStudioExecutionRole_data-engineer:
Sotto Autorizzazione datiscegli Grant.
Nel Principalsscegli Utenti e ruoli IAMe selezionare il ruolo SageMakerStudioExecutionRole_data-engineer.
Nel Tag dei criteri o risorse del catalogoscegli Risorse del catalogo dati con nome.
Nel Databasescegli demo.
Nel tavoliscegli web_marketing.
Nel Table autorizzazioni, select Super.
Nel Concedibile autorizzazioni, select Super.
Scegli Grant.
Infine, concedi l'autorizzazione al database per SageMakerStudioExecutionRole_data-scientist:
Sotto Autorizzazione datiscegli Grant.
Nel Principalsscegli Utenti e ruoli IAMe selezionare il ruolo SageMakerStudioExecutionRole_data-scientist.
Nel Tag dei criteri o risorse del catalogoscegli Risorse del catalogo dati con nome.
Nel Databasescegli demo.
Nel Autorizzazioni database, select Descrivere.
Scegli Grant.

Informazioni sugli autori

Ingegneria di funzionalità su larga scala con protezione dei dati sensibili utilizzando sessioni interattive di AWS Glue e Amazon SageMaker Studio PlatoBlockchain Data Intelligence. Ricerca verticale. Ai.

Praveen Kumar è un architetto di soluzioni di analisi presso AWS con esperienza nella progettazione, costruzione e implementazione di moderne piattaforme di dati e analisi utilizzando servizi nativi del cloud. Le sue aree di interesse sono la tecnologia serverless, i moderni data warehouse su cloud, lo streaming e le applicazioni ML.

Noritaka Sekiyama è Principal Big Data Architect nel team di AWS Glue. Gli piace collaborare con diversi team per ottenere risultati come questo post. Nel tempo libero si diverte a giocare ai videogiochi con la sua famiglia.

Timestamp: 17 Novembre 202220 Novembre 2022