Inginerie de funcții la scară largă cu protecție a datelor sensibile folosind sesiuni interactive AWS Glue și Amazon SageMaker Studio

Organizațiile folosesc servicii de învățare automată (ML) și AI pentru a îmbunătăți experiența clienților, a reduce costurile operaționale și a debloca noi posibilități de îmbunătățire a rezultatelor afacerii. Datele stau la baza cazurilor de utilizare ML și AI și sunt un activ strategic pentru o organizație. Pe măsură ce datele cresc într-un ritm exponențial, organizațiile caută să creeze o platformă de date integrată, rentabilă și performantă pentru a preprocesa datele, a realiza inginerie de caracteristici și a construi, antrena și operaționaliza modele ML la scară. Pentru a realiza acest lucru, AWS oferă o platformă de date modernă unificată, care este alimentată de Serviciul Amazon de stocare simplă (Amazon S3) ca lac de date cu instrumente special concepute și motoare de procesare pentru a sprijini sarcinile de analiză și ML. Pentru o experiență ML unificată, puteți utiliza Amazon SageMaker Studio, care oferă integrare nativă cu sesiunile interactive AWS Glue pentru a efectua inginerie de caracteristici la scară cu protecție a datelor sensibile. În această postare, demonstrăm cum să implementăm această soluție.

Amazon SageMaker este un serviciu ML gestionat complet care vă permite să construiți, să antrenezi și să implementați modele la scară pentru o gamă largă de cazuri de utilizare. Pentru antrenamentul modelului, puteți utiliza oricare dintre algoritmi încorporați în SageMaker pentru a începe formarea și implementarea rapidă a modelelor ML.

O componentă cheie a procesului de construire și dezvoltare a modelelor este ingineria caracteristicilor. AWS Adeziv este una dintre opțiunile recomandate pentru a realiza ingineria caracteristicilor la scară. AWS Glue vă permite să rulați integrarea și transformarea datelor într-un mod distribuit pe o infrastructură Apache Spark fără server și facilitează utilizarea popularei biblioteci Spark ML pentru inginerie de caracteristici și dezvoltare de modele. În plus, puteți utiliza AWS Glue pentru procesarea incrementală a datelor marcaje de locuri de muncă, ingerați date din peste 100 de surse folosind conectoriși rulați încărcături de lucru înțepenite sau imprevizibile folosind scalare automată.

O altă cerință importantă pentru aplicațiile bazate pe ML este securitatea datelor și controlul accesului. Este o cerere obișnuită de a avea un control mai strict asupra cine poate accesa cele mai sensibile date, ca parte a procesului de inginerie a caracteristicilor și de construire a modelului, urmând principiul accesului cu cel mai mic privilegiu. Pentru a realiza acest lucru, puteți utiliza integrarea AWS Glue cu Formația lacului AWS pentru o guvernanță și management sporit al activelor lacurilor de date. Cu Lake Formation, puteți configura controlul precis al accesului la date și politicile de securitate pe deasupra lacului dvs. de date Amazon S3. Politicile sunt definite într-o locație centrală, permițând mai multe servicii de analiză și ML, cum ar fi AWS Glue, Amazon Atena, și SageMaker, pentru a interacționa cu datele stocate în Amazon S3.

AWS Glue include a detectarea informațiilor de identificare personală (PII). transformare care oferă capacitatea de a detecta, masca sau elimina entități după cum este necesar, pentru o conformitate și guvernare sporite. Cu transformarea PII, puteți detecta datele PII în seturi de date și puteți aplica automat un control de acces precis folosind Lake Formation pentru a restricționa datele sensibile pentru diferite grupuri de utilizatori.

Utilizare caz

Ne concentrăm pe un caz de utilizare a modelului de înclinație care include un set de date de marketing pentru clienți și implică două persoane de utilizator: un inginer de date și un cercetător de date. Setul de date conține informații pentru fiecare client, inclusiv sursa potențială, notele de contact, rolul postului, câteva semnale, vizualizări de pagină per vizită și multe altele. Setul de date include, de asemenea, informații sensibile, cum ar fi numerele de telefon personale.

Inginerul de date este responsabil pentru construirea conductei de procesare a datelor end-to-end, inclusiv pregătirea datelor, preprocesarea și controlul accesului. Specialistul de date este responsabil pentru ingineria caracteristicilor și pentru instruirea și implementarea modelului ML. Rețineți că cercetătorul de date nu are voie să acceseze date sensibile PII pentru inginerie de caracteristici sau pentru antrenamentul modelului ML.

Ca parte a acestui caz de utilizare, inginerul de date construiește o conductă de date pentru a preprocesa setul de date, scanează setul de date pentru orice informație PII și restricționează accesul coloanei PII la utilizatorul de date. Ca urmare, atunci când un cercetător de date utilizează setul de date pentru a efectua inginerie de caracteristici și pentru a construi modele ML, nu are acces la coloana sensibilă la PII (numerele de telefon, în acest caz). Procesul de inginerie a caracteristicilor implică conversia coloanelor de tip șir într-un format care este optim pentru modelele ML. Ca un caz de utilizare avansat, puteți extinde acest model de acces pentru a implementa securitatea la nivel de rând și la nivel de celulă folosind Lake Formation.

Prezentare generală a soluțiilor

Soluția conține următorii pași de nivel înalt:

1. Configurați resurse cu Formarea AWS Cloud.
2. Preprocesează setul de date, inclusiv detectarea PII și controlul precis al accesului, într-o sesiune interactivă AWS Glue.
3. Efectuați inginerie de caracteristici pe o sesiune interactivă AWS Glue.
4. Antrenează și implementează un model ML folosind algoritmul XGBoost încorporat SageMaker.
5. Evaluați modelul ML.

Următoarea diagramă ilustrează arhitectura soluției.

Cerințe preliminare

Pentru a finaliza acest tutorial, trebuie să aveți următoarele cerințe preliminare:

Configurați resurse cu AWS CloudFormation

Această postare include un șablon CloudFormation pentru o configurare rapidă. Îl puteți revizui și personaliza în funcție de nevoile dvs. Dacă preferați să configurați resurse pe Consola de administrare AWS și AWS CLI, mai degrabă decât AWS CloudFormation, consultați instrucțiunile din apendicele de la sfârșitul acestei postări.

Șablonul CloudFormation generează următoarele resurse:

• Bucket S3 cu un set de date eșantion
• An AWS Lambdas funcția de încărcare a setului de date
• Gestionarea identității și accesului AWS (IAM), utilizatori, roluri și politici
• Setări și permisiuni ale lacului de date Lake Formation
• Profiluri de utilizator SageMaker

Pentru a vă crea resursele, parcurgeți următorii pași:

1. Conectați-vă la consolă.
2. Alege Lansați Stack:
   
3. Alege Pagina Următoare →.
4. Pentru DataIngineerPwd și DataScientistPwd, introduceți propria parolă pentru inginerul de date și pentru utilizatorii de date.
5. Pentru GlueDatabaseName, introduce demo.
6. Pentru GlueTableName, introduce web_marketing.
7. Pentru S3BucketNameForInput, introduce blog-studio-pii-dataset-.
8. Pentru S3BucketNameForOutput, introduce blog-studio-output-.
9. Pentru SageMakerDomainId, introduceți ID-ul domeniului SageMaker pe care l-ați pregătit în pașii necesari.
10. Alege Pagina Următoare →.
11. Pe pagina următoare, alegeți Pagina Următoare →.
12. Consultați detaliile de pe pagina finală și selectați Recunosc că AWS CloudFormation ar putea crea resurse IAM.
13. Alege Crea.

Crearea stivei poate dura până la 10 minute. Stiva creează roluri IAM și profiluri de utilizator SageMaker pentru două persoane: inginer de date și cercetător de date. De asemenea, creează o bază de date demonstrativă și un tabel web_marketing cu un set de date eșantion.

La momentul creării stivei, persoana inginer de date are acces complet la tabel, dar persoana cercetător de date nu are încă acces la tabel.

Preprocesează setul de date

Să începem preprocesarea datelor într-o sesiune interactivă AWS Glue. Inginerul de date dorește să verifice datele pentru a vedea dacă există sau nu date sensibile și să acorde permisiunea minimă de acces personalului de date. Puteți descărca notebook de pe această locație.

1. Conectați-vă la consolă utilizând utilizatorul data-inginer.
2. Pe consola SageMaker, alegeți Utilizatori.
3. Selectați utilizatorul inginer de date și alegeți Deschide Studio.
4. Creați un nou caiet și alegeți SparkAnalytics 1.0 pentru Imagine și Lipici PySpark pentru Nucleu.
5. Începeți o sesiune interactivă cu următoarea magie pentru a instala versiunea mai nouă de Boto3 (acest lucru este necesar pentru utilizarea programului create_data_cells_filter metodă):

   %additional_python_modules boto3==1.24.82

6. Inițializați sesiunea:

   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)

7. Creați un AWS Glue DynamicFrame din tabelul nou creat și rezolva tipurile de alegeri bazat pe schema de catalog, deoarece dorim să folosim schema definită în catalog în loc de schema dedusă automat pe baza datelor:

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

8. Validați în tabel dacă există date PII utilizând detectarea PII 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)

9. Verificați dacă coloanele clasificate ca PII conțin sau nu date sensibile (dacă nu, actualizați classified_map pentru a elimina coloanele nesensibile):

   from pyspark.sql.functions import col
   dyf_marketing_resolved.toDF().select(*[col(c) for c in classified_map.keys()]).show()

10. Configurați permisiunile Lake Formation folosind un filtru de celule de date pentru coloanele detectate automat și restricționați coloanele la persoana de date:

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

11. Conectați-vă la Studio ca cercetător de date pentru a vedea că coloanele PII nu sunt vizibile. Puteți descărca notebook de pe această locație.
12. Creați un nou caiet și alegeți SparkAnalytics 1.0 pentru Imagine și Lipici PySpark pentru Nucleu:

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

Efectuați ingineria caracteristicilor

Folosim biblioteca Apache Spark ML pentru a efectua ingineria caracteristicilor ca utilizator de date și apoi scriem înapoi rezultatul pe Amazon S3.

1. În celula următoare, aplicăm caracteristici din Biblioteca Apache Spark ML:
   • StringIndexer mapează o coloană de șir de etichete la o coloană de indici de etichete.
   • OneHotEncoder mapează o caracteristică categorială, reprezentată ca un indice de etichetă, la un vector binar cu cel mult o singură valoare care indică prezența unei caracteristici categoriale specifice. Această transformare este utilizată pentru algoritmii ML care așteaptă funcții continue.
   • VectorAssembler este un transformator care combină o listă dată de coloane într-o singură coloană vectorială, care este apoi utilizată în antrenarea modelelor ML pentru algoritmi precum regresia logistică și arbori de decizie.

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

2. DataFrame transformat final poate fi creat folosind biblioteca Pipeline. O conductă este specificată ca o secvență de etape. Aceste etape sunt rulate în ordine, iar DataFrame-ul de intrare este transformat pe măsură ce trece prin fiecare etapă.

   df_marketing = dyf_marketing.toDF()
   pipeline = Pipeline(stages=indexers + encoders + [assembler])
   df_tfm=pipeline.fit(df_marketing).transform(df_marketing)
   

3. Apoi, împărțim setul de date în tren, validăm și testăm DataFrame și îl salvăm în compartimentul S3 pentru a antrena modelul ML (furnizați ID-ul contului dvs. AWS în următorul cod):

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

Antrenează și implementează un model ML

În secțiunea anterioară, am finalizat ingineria caracteristicilor, care a inclus conversia coloanelor de șir, cum ar fi region, jobrole, și usedpromo într-un format optim pentru modelele ML. Am inclus și coloane precum pageviewspervisit și totalwebvisits, care ne va ajuta să anticipăm tendința unui client de a cumpăra un produs.

Acum antrenăm un model ML citind trenul și setul de date de validare folosind algoritmul XGBoost încorporat SageMaker. Apoi implementăm modelul și efectuăm o verificare a preciziei. Puteți descărca notebook de pe această locație.

În celula următoare, citim date din a doua găleată S3, care include rezultatul operațiunilor noastre de inginerie a caracteristicilor. Apoi folosim algoritmul încorporat XGBoost pentru a antrena modelul.

1. Deschideți un blocnotes nou. Alege Știința datelor pentru Imagine și Python 3 pentru Nucleu (furnizați ID-ul contului dvs. AWS în următorul cod):

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

2. Când instruirea este finalizată, putem implementa modelul utilizând serviciile de găzduire SageMaker:

   #deploy ml model
   xgb_predictor = xgb.deploy(initial_instance_count=1,
   instance_type='ml.m4.xlarge')

Evaluați modelul ML

Folosim setul de date de testare pentru a evalua modelul și pentru a șterge punctul final de inferență când am terminat, pentru a evita orice taxe în curs.

1. Evaluați modelul cu următorul cod:

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

   Rezultatul de acuratețe pentru analiza probei a fost de 84.6 %. Acest lucru ar putea fi ușor diferit pentru rularea dvs. din cauza împărțirii aleatorii a setului de date.

2. Putem șterge punctul final de inferență cu următorul cod:

   xgb_predictor.delete_endpoint(delete_endpoint_config=True)

A curăța

Acum, la pasul final, curățarea resurselor.

1. Goliți cele două găleți create prin stiva CloudFormation.
2. Ștergeți aplicațiile asociate cu utilizatorul profiles data-scientist și data-engineer în cadrul Studioului.
3. Ștergeți stiva CloudFormation.

Concluzie

În această postare, am demonstrat o soluție care permite persoanelor precum inginerii de date și oamenii de știință de date să efectueze ingineria caracteristicilor la scară. Cu sesiunile interactive AWS Glue, puteți realiza cu ușurință inginerie de caracteristici la scară, cu detectarea automată a PII și controlul precis al accesului, fără a fi nevoie să gestionați nicio infrastructură subiacentă. Folosind Studio ca punct unic de intrare, puteți obține o experiență simplificată și integrată pentru a construi un flux de lucru ML end-to-end: de la pregătirea și securizarea datelor până la construirea, instruirea, reglarea și implementarea modelelor ML. Pentru a afla mai multe, vizitați Noțiuni introductive despre sesiunile interactive AWS Glue și Amazon SageMaker Studio.

Suntem foarte încântați de această nouă capacitate și dornici să vedem ce veți construi cu ea!

---

Anexă: Configurați resurse prin consolă și AWS CLI

Completați instrucțiunile din această secțiune pentru a configura resursele utilizând consola și AWS CLI în loc de șablonul CloudFormation.

Cerințe preliminare

Pentru a finaliza acest tutorial, trebuie să aveți acces la AWS CLI (consultați Noțiuni introductive cu AWS CLI) sau utilizați accesul la linia de comandă de la AWS CloudShell.

Configurați grupul IAM, utilizatorii, rolurile și politicile

În această secțiune, creăm doi utilizatori IAM: data-inginer și data-scientist, care aparțin grupului IAM data-platform-group. Apoi adăugăm o singură politică IAM la grupul IAM.

1. Pe consola IAM, creați o politică în fila JSON pentru a crea o nouă politică gestionată IAM numită DataPlatformGroupPolicy. Politica permite utilizatorilor din grup să acceseze Studio, dar numai folosind un profil de utilizator SageMaker cu o etichetă care se potrivește cu numele lor de utilizator IAM. Utilizați următorul document de politică JSON pentru a furniza permisiuni:

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

2. Creați un grup IAM denumit data-platform-group.
3. Căutați și atașați la grup politica gestionată AWS numită DataPlatformGroupPolicy.
4. Creați utilizatori IAM numit inginer de date și om de știință de date în cadrul grupului IAM grup de platformă de date.
5. Creați o nouă politică gestionată numit SageMakerExecutionPolicy (furnizați regiunea și ID-ul contului în următorul cod):

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

6. Creați o nouă politică gestionată numit 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"
         }
      ]
   }

7. Creați un rol IAM pentru SageMaker pentru inginerul de date (inginer de date), care este utilizat ca rol de execuție al profilului de utilizator corespunzător. Pe Atașați politica de permisiuni pagina, AmazonSageMakerFullAccess (politica gestionată AWS) este atașat implicit. Eliminați această politică mai târziu pentru a menține privilegiul minim.
   1. Pentru Nume rol, utilizați convenția de denumire introdusă la începutul acestei secțiuni pentru a denumi rolul SageMakerStudioExecutionRole_data-inginer.
   2. Pentru Tag-uri, adăugați cheia userprofilename și valoarea data-ingineer.
   3. Alege Creare rol.
   4. Pentru a adăuga politicile rămase, pe Roluri pagina, alegeți numele rolului pe care tocmai l-ați creat.
   5. În Permisiuni, eliminați politica AmazonSageMakerFullAccess.
   6. Pe Atașați politica de permisiuni pagina, selectați politica gestionată AWS AwsGlueSessionUserRestrictedServiceRole și politicile gestionate de client SageMakerExecutionPolicy și SageMakerAdminPolicy pe care le-ați creat.
   7. Alege Atașați politicile.
   8. Modifica relația de încredere a rolului tău:

   {
      "Version":"2012-10-17",
      "Statement":[
         {
            "Effect":"Allow",
            "Principal":{
               "Service":[
                  "glue.amazonaws.com",
                  "sagemaker.amazonaws.com"
               ]
            },
            "Action":"sts:AssumeRole"
         }
      ]
   }

8. Creați un rol IAM pentru SageMaker pentru data scientist (data-scientist), care este utilizat ca rol de execuție al profilului de utilizator corespunzător.
   1. Pentru Nume rol, denumește rolul SageMakerStudioExecutionRole_data-scientist.
   2. Pentru Tag-uri, adăugați cheia userprofilename și valoarea data-scientist.
   3. Alege Creare rol.
   4. Pentru a adăuga politicile rămase, pe Roluri pagina, alegeți numele rolului pe care tocmai l-ați creat.
   5. În Permisiuni, eliminați politica AmazonSageMakerFullAccess.
   6. Pe Atașați politica de permisiuni pagina, selectați politica gestionată AWS AwsGlueSessionUserRestrictedServiceRole și politica gestionată de client SageMakerExecutionPolicy pe care ați creat-o.
   7. Alege Atașați politicile.
   8. Modifica relația de încredere a rolului tău:

   {
      "Version":"2012-10-17",
      "Statement":[
         {
            "Effect":"Allow",
            "Principal":{
               "Service":[
                  "glue.amazonaws.com",
                  "sagemaker.amazonaws.com"
               ]
            },
            "Action":"sts:AssumeRole"
         }
      ]
   }

Configurați profilurile de utilizator SageMaker

Pentru a vă crea profilurile de utilizator SageMaker cu studiouserid etichetă, parcurgeți următorii pași:

1. Utilizați AWS CLI sau CloudShell pentru a crea profilul de utilizator Studio pentru inginerul de date (furnizați ID-ul contului și ID-ul domeniului Studio în următorul cod):

   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

2. Repetați pasul pentru a crea un profil de utilizator pentru cercetătorul de date, înlocuind ID-ul contului și ID-ul domeniului 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ți compartimente S3 și încărcați setul de date eșantion

În această secțiune, creați două compartimente S3. Prima găleată are un set de date eșantion legat de marketingul web. A doua găleată este folosită de cercetătorul de date pentru a stoca rezultatele din sarcinile de inginerie a caracteristicilor, iar acest set de date de ieșire este folosit pentru a antrena modelul ML.

Mai întâi, creați compartimentul S3 pentru datele de intrare:

1. Descarcă setul de date.
2. În consola Amazon S3, alegeți Cupă în panoul de navigare.
3. Alege Creați găleată.
4. Pentru Regiune, alegeți Regiunea cu domeniul SageMaker care include profilurile de utilizator pe care le-ați creat.
5. Pentru Numele cupei, introduce blog-studio-pii-dataset-.
6. Alege Creați găleată.
7. Selectați găleata pe care ați creat-o și alegeți Încărcați.
8. În selectaţi fișierele secțiune, pentru a alege Adăugați fișiere și încărcați setul de date pe care l-ați descărcat.
   Acum creați compartimentul pentru datele de ieșire:
9. Pe Cupă pagina, alege Creați găleată.
10. Pentru Regiune, alegeți Regiunea cu domeniul SageMaker care include profilurile de utilizator pe care le-ați creat.
11. Pentru Numele cupei, introduce blog-studio-output-.
12. Alege Creați găleată.

Creați o bază de date și un tabel AWS Glue

În această secțiune, creați o bază de date și un tabel AWS Glue pentru setul de date.

1. Pe consola Lake Formation, sub Catalog de date în panoul de navigare, alegeți Baze de date.
2. Alege Adăugați o bază de date.
3. Pentru Nume si Prenume, intrați în demo.
4. Alege Creați o bază de date.
5. În Catalog de date, alege Mese.
6. Pentru Nume si Prenume, introduce web_marketing.
7. Pentru Baza de date, Selectați demo.
8. Pentru Includeți calea, introduceți calea compartimentului dvs. S3 pentru datele de intrare.
9. Pentru Clasificare, alege CSV.
10. În Schemă, alege Încărcați schema.
11. Introduceți următoarea matrice JSON în caseta de text:

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

12. Alege Încărcați.
13. Alege Trimite mesaj.
14. În Detalii tabel, alege Editați tabelul.
15. În Proprietățile tabelului, alege Adăuga.
16. Pentru Cheie, introduce skip.header.line.count, Și pentru Valoare, introduceți 1.
17. Alege Economisiți.

Configurați permisiunile Lake Formation

În această secțiune, configurați permisiunile Lake Formation pentru a permite rolul IAM SageMakerStudioExecutionRole_data-engineer pentru a crea o bază de date și a înregistra locația S3 în Lake Formation.

Mai întâi, înregistrați locația lacului de date pentru a gestiona tabelele sub locația din permisiunile Lake Formation:

1. Alege Locațiile lacului de date.
2. Alege Înregistrați locația.
3. Pentru Calea Amazon S3, introduce s3://blog-studio-pii-dataset-/ (găleata care conține setul de date).
4. Alege Înregistrați locația.
   Acum acordați permisiuni pentru bazele de date și tabele Lake Formation rolurilor IAM SageMakerStudioExecutionRole_data-engineer și SageMakerStudioExecutionRole_data-scientist.În primul rând, acordați permisiunea bazei de date pentru SageMakerStudioExecutionRole_data-engineer:
5. În Permisiuni, alege Permisiunile lacului de date.
6. În Permisiunea datelor, alege Grant.
7. Pentru Directorii, alege Utilizatori și roluri IAMși selectați rolul SageMakerStudioExecutionRole_data-engineer.
8. Pentru Etichete de politică sau resurse de catalog, alege Resurse de catalog de date denumite.
9. Pentru Baze de date, alegeți demo.
10. Pentru Permisiuni baza de date, selecta Super.
11. Alege Grant.
    Apoi, acordați permisiunea de masă pentru SageMakerStudioExecutionRole_data-engineer:
12. În Permisiunea datelor, alege Grant.
13. Pentru Directorii, alege Utilizatori și roluri IAMși selectați rolul SageMakerStudioExecutionRole_data-engineer.
14. Pentru Etichete de politică sau resurse de catalog, alege Resurse de catalog de date denumite.
15. Pentru Baze de date, alege demo.
16. Pentru Mese, alege web_marketing.
17. Pentru Tabel permisiuni, selecta Super.
18. Pentru Acordabil permisiuni, selecta Super.
19. Alege Grant.
    În cele din urmă, acordați permisiunea bazei de date pentru SageMakerStudioExecutionRole_data-scientist:
20. În Permisiunea datelor, alege Grant.
21. Pentru Directorii, alege Utilizatori și roluri IAMși selectați rolul SageMakerStudioExecutionRole_data-scientist.
22. Pentru Etichete de politică sau resurse de catalog, alege Resurse de catalog de date denumite.
23. Pentru Baze de date, alege demo.
24. Pentru Permisiuni baza de date, selecta Descrie.
25. Alege Grant.

---

Despre Autori

Praveen Kumar este arhitect de soluții de analiză la AWS, cu experiență în proiectarea, construirea și implementarea platformelor moderne de date și analiză care utilizează servicii native din cloud. Domeniile sale de interes sunt tehnologia fără server, depozitele moderne de date în cloud, streaming și aplicațiile ML.

Noritaka Sekiyama este arhitect principal de date mari în echipa AWS Glue. Îi place să colaboreze cu diferite echipe pentru a oferi rezultate ca această postare. În timpul liber, îi place să joace jocuri video cu familia.