Storskalig funktionsteknik med känsligt dataskydd med hjälp av interaktiva AWS Glue-sessioner och Amazon SageMaker Studio PlatoBlockchain Data Intelligence. Vertikal sökning. Ai.

Storskalig funktionsteknik med känsligt dataskydd med AWS Glue interaktiva sessioner och Amazon SageMaker Studio

Tidsstämpel: 17 november 2022 11:35

Organisationer använder maskininlärning (ML) och AI-tjänster för att förbättra kundupplevelsen, minska driftskostnaderna och låsa upp nya möjligheter att förbättra affärsresultat. Data underbygger ML och AI användningsfall och är en strategisk tillgång för en organisation. Eftersom data växer i en exponentiell takt, letar organisationer efter att skapa en integrerad, kostnadseffektiv och presterande dataplattform för att förbehandla data, utföra funktionsutveckling och bygga, träna och operationalisera ML-modeller i stor skala. För att uppnå det erbjuder AWS en enhetlig modern dataplattform som drivs av Amazon enkel lagringstjänst (Amazon S3) som datasjön med specialbyggda verktyg och bearbetningsmotorer för att stödja analys och ML-arbetsbelastningar. För en enhetlig ML-upplevelse kan du använda Amazon SageMaker Studio, Som erbjuder inbyggd integration med AWS Glue interaktiva sessioner att utföra funktionsteknik i stor skala med känsligt dataskydd. I det här inlägget visar vi hur man implementerar denna lösning.

Amazon SageMaker är en helt hanterad ML-tjänst som gör att du kan bygga, träna och distribuera modeller i stor skala för ett brett spektrum av användningsfall. För modellträning kan du använda någon av de inbyggda algoritmer inom SageMaker för att snabbt komma igång med utbildning och implementering av ML-modeller.

En nyckelkomponent i modellbyggandet och utvecklingsprocessen är funktionsteknik. AWS-lim är ett av de rekommenderade alternativen för att uppnå funktionsteknik i stor skala. AWS Glue gör att du kan köra dataintegration och transformation på ett distribuerat sätt på en serverlös Apache Spark-infrastruktur och gör det enkelt att använda det populära Spark ML-biblioteket för funktionsteknik och modellutveckling. Dessutom kan du använda AWS Glue för inkrementell databehandling genom jobb bokmärken, mata in data från över 100 källor med hjälp av kontakter, och kör taggiga eller oförutsägbara arbetsbelastningar med automatisk skalning.

Ett annat viktigt krav för ML-baserade applikationer är datasäkerhet och åtkomstkontroll. Det är ett vanligt krav att ha strängare kontroll över vem som kan komma åt de känsligaste uppgifterna som en del av funktionsutvecklingen och modellbyggeprocessen genom att följa principen om minst privilegierad åtkomst. För att uppnå detta kan du använda AWS Glue-integrationen med AWS Lake Formation för ökad styrning och förvaltning av datasjötillgångar. Med Lake Formation kan du konfigurera finkornig dataåtkomstkontroll och säkerhetspolicyer ovanpå din Amazon S3-datasjö. Policyerna definieras på en central plats, vilket tillåter flera analys- och ML-tjänster, såsom AWS Glue, Amazonas Athena, och SageMaker, för att interagera med data som lagras i Amazon S3.

AWS-lim innehåller en identifiering av personligt identifierbar information (PII). transformering som ger möjlighet att upptäcka, maskera eller ta bort enheter efter behov, för ökad efterlevnad och styrning. Med PII-transformeringen kan du upptäcka PII-data i datauppsättningar och automatiskt tillämpa finkornig åtkomstkontroll med hjälp av Lake Formation för att begränsa känslig data för olika användargrupper.

Användningsfall

Vi fokuserar på ett användningsfall för benägenhetsmodeller som inkluderar en datauppsättning för kundmarknadsföring och involverar två användarpersoner: en dataingenjör och datavetare. Datauppsättningen innehåller information per kund, inklusive leadkälla, kontaktanteckningar, jobbroll, några flaggor, sidvisningar per besök och mer. Datauppsättningen innehåller också känslig information som personliga telefonnummer.

Dataingenjören är ansvarig för att bygga end-to-end databehandlingspipeline, inklusive dataförberedelse, förbearbetning och åtkomstkontroll. Dataforskaren ansvarar för funktionsutveckling och utbildning och implementering av ML-modellen. Observera att dataforskaren inte har tillgång till någon PII-känslig data för funktionsutveckling eller utbildning av ML-modellen.

Som en del av detta användningsfall bygger dataingenjören en datapipeline för att förbehandla datamängden, skannar datasetet efter eventuell PII-information och begränsar åtkomsten till PII-kolumnen till dataforskarens användare. Som ett resultat, när en dataforskare använder datamängden för att utföra funktionsutveckling och bygga ML-modeller, har de inte tillgång till den PII-känsliga kolumnen (telefonnummer, i det här fallet). Funktionskonstruktionsprocessen innebär att konvertera kolumner av typsträng till ett format som är optimalt för ML-modeller. Som ett avancerat användningsfall kan du utöka detta åtkomstmönster för att implementera säkerhet på radnivå och cellnivå med Lake Formation.

Lösningsöversikt

Lösningen innehåller följande steg på hög nivå:

  1. Ställ in resurser med AWS molnformation.
  2. Förbearbeta datasetet, inklusive PII-detektion och finkornig åtkomstkontroll, på en interaktiv AWS Glue-session.
  3. Utför funktionsutveckling på en interaktiv AWS Glue-session.
  4. Träna och distribuera en ML-modell med den inbyggda SageMaker XGBoost-algoritmen.
  5. Utvärdera ML-modellen.

Följande diagram illustrerar lösningsarkitekturen.

Förutsättningar

För att slutföra denna handledning måste du ha följande förutsättningar:

Konfigurera resurser med AWS CloudFormation

Det här inlägget innehåller en CloudFormation-mall för en snabb installation. Du kan granska och anpassa den för att passa dina behov. Om du föredrar att ställa in resurser på AWS Management Console och AWS CLI snarare än AWS CloudFormation, se instruktionerna i bilagan i slutet av detta inlägg.

CloudFormation-mallen genererar följande resurser:

  • S3-hinkar med en exempeldatauppsättning
  • An AWS Lambda funktion för att ladda datamängden
  • AWS identitets- och åtkomsthantering (IAM) grupp, användare, roller och policyer
  • Lake Formation data sjöinställningar och behörigheter
  • SageMaker användarprofiler

Så här skapar du dina resurser:

  1. Logga in på konsolen.
  2. Välja Starta stack:
    Start-knappen
  3. Välja Nästa.
  4. För DataEngineerPwd och DataScientistPwd, ange ditt eget lösenord för dataingenjören och dataforskarens användare.
  5. För GlueDatabaseName, stiga på demo.
  6. För GlueTableName, stiga på web_marketing.
  7. För S3BucketNameForInput, stiga på blog-studio-pii-dataset-.
  8. För S3BucketNameForOutput, stiga på blog-studio-output-.
  9. För SageMakerDomainId, ange ditt SageMaker-domän-ID som du förberedde i de nödvändiga stegen.
  10. Välja Nästa.
  11. Välj på nästa sida Nästa.
  12. Granska detaljerna på den sista sidan och välj Jag erkänner att AWS CloudFormation kan skapa IAM-resurser.
  13. Välja Skapa.

Att skapa stack kan ta upp till 10 minuter. Stacken skapar IAM-roller och SageMaker-användarprofiler för två personas: dataingenjör och datavetare. Det skapar också en databasdemo och tabell web_marketing med en exempeldatauppsättning.

Vid tidpunkten för stackskapandet har dataingenjörens persona fullständig åtkomst till tabellen, men dataforskarens persona har inte någon åtkomst till tabellen ännu.

Förbehandla datamängden

Låt oss börja förbearbeta data på en interaktiv AWS Glue-session. Dataingenjörens persona vill verifiera data för att se om det finns känslig data eller inte, och ge minimal åtkomstbehörighet till dataforskarens persona. Du kan ladda ner anteckningsboken från den här platsen.

  1. Logga in på konsolen med hjälp av datateknikeranvändaren.
  2. Välj på SageMaker-konsolen användare.
  3. Välj datateknikeranvändare och välj Öppen studio.
  4. Skapa en ny anteckningsbok och välj SparkAnalytics 1.0 för Bild och Limma PySpark för Kärna.
  5. Starta en interaktiv session med följande magi för att installera den nyare versionen av Boto3 (detta krävs för att använda create_data_cells_filter metod): 
    %additional_python_modules boto3==1.24.82

  6. Initiera sessionen: 
    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. Skapa en AWS Glue DynamicFrame från den nyskapade tabellen, och lösa valtyper baserat på katalogschema, eftersom vi vill använda schemat som definieras i katalogen istället för det automatiskt härledda schemat baserat på data: 
    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. Validera i tabellen om det finns någon PII-data med AWS Glue PII-detektering: 
    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. Kontrollera om kolumnerna klassificerade som PII innehåller känsliga data eller inte (om inte, uppdatera classified_map för att ta bort de icke-känsliga kolumnerna): 
    from pyspark.sql.functions import col
dyf_marketing_resolved.toDF().select(*[col(c) for c in classified_map.keys()]).show()

  10. Ställ in Lake Formation-behörigheter med ett datacellfilter för automatiskt upptäckta kolumner och begränsa kolumnerna till dataforskarens persona: 
    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. Logga in på Studio som dataforskare för att se att PII-kolumnerna inte är synliga. Du kan ladda ner anteckningsboken från den här platsen.
  12. Skapa en ny anteckningsbok och välj SparkAnalytics 1.0 för Bild och Limma PySpark för Kärna: 
    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()

Utför funktionsteknik

Vi använder Apache Spark ML-biblioteket för att utföra funktionsteknik som dataforskare och sedan skriva tillbaka utdata till Amazon S3.

  1. I följande cell tillämpar vi funktioner från Apache Spark ML-bibliotek:
    • StringIndexer mappar en strängkolumn med etiketter till en kolumn med etikettindex.
    • OneHotEncoder mappar ett kategoriskt särdrag, representerat som ett etikettindex, till en binär vektor med högst ett enda ettvärde som indikerar närvaron av ett specifikt kategoriskt särdrag. Denna transformation används för ML-algoritmer som förväntar sig kontinuerliga funktioner.
    • VectorAssembler är en transformator som kombinerar en given lista med kolumner till en enda vektorkolumn, som sedan används för att träna ML-modeller för algoritmer som logistisk regression och beslutsträd.
    #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. Den slutliga transformerade DataFrame kan skapas med hjälp av Pipeline-biblioteket. En pipeline anges som en sekvens av steg. Dessa steg körs i ordning och indatadataramen transformeras när den passerar genom varje steg. 
    df_marketing = dyf_marketing.toDF()
pipeline = Pipeline(stages=indexers + encoders + [assembler])
df_tfm=pipeline.fit(df_marketing).transform(df_marketing)

  3. Därefter delar vi upp datasetet i träna, validerar och testar DataFrame och sparar det i S3-hinken för att träna ML-modellen (ange ditt AWS-konto-ID i följande kod): 
    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))

Träna och distribuera en ML-modell

I föregående avsnitt slutförde vi funktionsteknik, som inkluderade konvertering av strängkolumner som t.ex region, jobroleoch usedpromo till ett format som är optimalt för ML-modeller. Vi tog även med kolumner som t.ex pageviewspervisit och totalwebvisits, som hjälper oss att förutsäga en kunds benägenhet att köpa en produkt.

Vi tränar nu en ML-modell genom att läsa tåg- och valideringsdataset med den inbyggda SageMaker XGBoost-algoritmen. Sedan distribuerar vi modellen och kör en noggrannhetskontroll. Du kan ladda ner anteckningsboken från den här platsen.

I följande cell läser vi data från den andra S3-skopan, som inkluderar utdata från vår funktionsteknik. Sedan använder vi den inbyggda algoritmen XGBoost för att träna modellen.

  1. Öppna en ny anteckningsbok. Välja Data Science för Bild och python 3 för Kärna (ange ditt AWS-konto-ID i följande kod): 
    #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. När utbildningen är klar kan vi distribuera modellen med SageMakers värdtjänster: 
    #deploy ml model
xgb_predictor = xgb.deploy(initial_instance_count=1,
instance_type='ml.m4.xlarge')

Utvärdera ML-modellen

Vi använder testdataset för att utvärdera modellen och ta bort slutpunkten för slutpunkten när vi är klara för att undvika pågående avgifter.

  1. Utvärdera modellen med följande kod: 
    #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))

    Noggrannhetsresultatet för provkörningen var 84.6 %. Detta kan vara något annorlunda för din löpning på grund av den slumpmässiga uppdelningen av datamängden.

  2. Vi kan ta bort slutpunktens slutpunkt med följande kod: 
    xgb_predictor.delete_endpoint(delete_endpoint_config=True)

Städa upp

Nu till det sista steget, att rensa upp resurserna.

  1. Töm de två hinkarna som skapats genom CloudFormation-stacken.
  2. Ta bort apparna som är kopplade till användaren profiles data-scientist och data-engineer i Studio.
  3. Ta bort CloudFormation-stacken.

Slutsats

I det här inlägget visade vi en lösning som gör det möjligt för personer som dataingenjörer och datavetare att utföra funktionsteknik i stor skala. Med AWS Glue interaktiva sessioner kan du enkelt uppnå funktionsteknik i stor skala med automatisk PII-detektering och finkornig åtkomstkontroll utan att behöva hantera någon underliggande infrastruktur. Genom att använda Studio som den enda ingångspunkten kan du få en förenklad och integrerad upplevelse för att bygga ett heltäckande ML-arbetsflöde: från att förbereda och säkra data till att bygga, träna, ställa in och distribuera ML-modeller. Om du vill veta mer, besök Komma igång med AWS Glue interaktiva sessioner och Amazon SageMaker Studio.

Vi är mycket glada över den här nya kapaciteten och angelägna om att se vad du ska bygga med den!

Bilaga: Ställ in resurser via konsolen och AWS CLI

Slutför instruktionerna i det här avsnittet för att ställa in resurser med hjälp av konsolen och AWS CLI istället för CloudFormation-mallen.

Förutsättningar

För att slutföra denna handledning måste du ha tillgång till AWS CLI (se Komma igång med AWS CLI) eller använd kommandoradsåtkomst från AWS CloudShell.

Konfigurera IAM-grupp, användare, roller och policyer

I det här avsnittet skapar vi två IAM-användare: dataingenjör och dataforskare, som tillhör IAM-gruppen dataplattformsgrupp. Sedan lägger vi till en enda IAM-policy till IAM-gruppen.

  1. På IAM-konsolen, skapa en policy på JSON-fliken för att skapa en ny IAM-hanterad policy med namnet DataPlatformGroupPolicy. Policyn tillåter användare i gruppen att komma åt Studio, men endast med en SageMaker-användarprofil med en tagg som matchar deras IAM-användarnamn. Använd följande JSON-policydokument för att ge behörigheter: 
    {
   "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. Skapa en IAM-grupp kallas data-platform-group.
  3. Sök och bifoga den AWS-hanterade policyn med namnet DataPlatformGroupPolicy till gruppen.
  4. Skapa IAM-användare kallas dataingenjör och dataforskare under IAM-gruppen data-plattform-grupp.
  5. Skapa en ny hanterad policy heter SageMakerExecutionPolicy (ange ditt region- och konto-ID i följande kod): 
    {
   "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. Skapa en ny hanterad policy som heter 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. Skapa en IAM-roll för SageMaker för dataingenjören (dataingenjör), som används som motsvarande användarprofils exekveringsroll. På Bifoga behörighetspolicyn sida, är AmazonSageMakerFullAccess (AWS-hanterad policy) bifogad som standard. Du tar bort denna policy senare för att behålla minimibehörighet.
    1. För Rollnamn, använd namnkonventionen som introducerades i början av detta avsnitt för att namnge rollen SageMakerStudioExecutionRole_data-engineer.
    2. För Tags, lägg till nyckelanvändarprofilnamnet och värdedataingenjören.
    3. Välja Skapa roll.
    4. För att lägga till återstående policyer, på roller välj det rollnamn du just skapade.
    5. Enligt behörigheter, ta bort policyn AmazonSageMakerFullAccess.
    6. På Bifoga behörighetspolicyn sida, välj den AWS-hanterade policyn AwsGlueSessionUserRestrictedServiceRole och de kundhanterade policyerna SageMakerExecutionPolicy och SageMakerAdminPolicy som du skapade.
    7. Välja Bifoga policyer.
    8. Ändra din rolls förtroendeförhållande:
    {
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":[
               "glue.amazonaws.com",
               "sagemaker.amazonaws.com"
            ]
         },
         "Action":"sts:AssumeRole"
      }
   ]
}

  8. Skapa en IAM-roll för SageMaker för datavetaren (data-scientist), som används som motsvarande användarprofils exekveringsroll.
    1. För Rollnamn, namnge rollen SageMakerStudioExecutionRole_data-scientist.
    2. För Tags, lägg till nyckelanvändarprofilnamnet och värdedataforskaren.
    3. Välja Skapa roll.
    4. För att lägga till återstående policyer, på roller välj det rollnamn du just skapade.
    5. Enligt behörigheter, ta bort policyn AmazonSageMakerFullAccess.
    6. På Bifoga behörighetspolicyn sida, välj den AWS-hanterade policyn AwsGlueSessionUserRestrictedServiceRole och den kundhanterade policy SageMakerExecutionPolicy som du skapade.
    7. Välja Bifoga policyer.
    8. Ändra din rolls förtroendeförhållande:
    {
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":[
               "glue.amazonaws.com",
               "sagemaker.amazonaws.com"
            ]
         },
         "Action":"sts:AssumeRole"
      }
   ]
}

Konfigurera SageMaker användarprofiler

För att skapa dina SageMaker-användarprofiler med studiouserid tagg, slutför följande steg:

  1. Använd AWS CLI eller CloudShell för att skapa Studio-användarprofilen för dataingenjören (ange ditt konto-ID och Studio-domän-ID i följande kod): 
    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. Upprepa steget för att skapa en användarprofil för datavetaren, ersätt konto-ID och Studio-domän-ID: 
    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

Skapa S3-buckets och ladda upp exempeldataset

I det här avsnittet skapar du två S3-hinkar. Den första hinken har en exempeldatauppsättning relaterad till webbmarknadsföring. Den andra hinken används av dataforskaren för att lagra utdata från funktionstekniska uppgifter, och denna utdatadatauppsättning används för att träna ML-modellen.

Skapa först S3-hinken för indata:

  1. Download datasetet.
  2. Välj på Amazon S3-konsolen Skopor i navigeringsfönstret.
  3. Välja Skapa hink.
  4. För Region, välj regionen med SageMaker-domänen som innehåller användarprofilerna du skapade.
  5. För Hinkens namn, stiga på blog-studio-pii-dataset-.
  6. Välja Skapa hink.
  7. Välj den hink du skapade och välj Ladda.
  8. I Välj filer avsnitt väljer Lägg till filer och ladda upp datauppsättningen du laddade ner.
    Nu skapar du hinken för utdata:
  9. På Skopor sida, välj Skapa hink.
  10. För Region, välj regionen med SageMaker-domänen som innehåller användarprofilerna du skapade.
  11. För Hinkens namn, stiga på blog-studio-output-.
  12. Välja Skapa hink.

Skapa en AWS Glue-databas och tabell

I det här avsnittet skapar du en AWS Glue-databas och tabell för datamängden.

  1. På Lake Formation-konsolen, under Datakatalog välj i navigeringsfönstret Databaser.
  2. Välja Lägg till databas.
  3. För Namn , ange demo.
  4. Välja Skapa databas.
  5. Enligt Datakatalogväljer Bord.
  6. För Namn , stiga på web_marketing.
  7. För Databas, Välj demo.
  8. För Inkludera sökväg, ange sökvägen till din S3-skopa för indata.
  9. För Klassificeringväljer CSV.
  10. Enligt Schemaväljer Ladda upp schema.
  11. Ange följande JSON-array i textrutan: 
    [
   {
      "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. Välja Ladda.
  13. Välja Skicka.
  14. Enligt Tabelldetaljerväljer Redigera tabell.
  15. Enligt Tabellegenskaperväljer Lägg till.
  16. För Nyckel, stiga på skip.header.line.countOch för Värde, ange 1.
  17. Välja Save.

Konfigurera Lake Formation-behörigheter

I det här avsnittet ställer du in Lake Formation-behörigheter för att tillåta IAM-roll SageMakerStudioExecutionRole_data-engineer för att skapa en databas och registrera S3-platsen i Lake Formation.

Registrera först datasjöplatsen för att hantera tabeller under platsen i Lake Formation-behörigheter:

  1. Välja Data sjö platser.
  2. Välja Registrera plats.
  3. För Amazon S3-väg, stiga på s3://blog-studio-pii-dataset-/ (hinken som innehåller datamängden).
  4. Välja Registrera plats.
    Nu ger du Lake Formation databas- och tabellbehörigheter till IAM-rollerna SageMakerStudioExecutionRole_data-engineer och SageMakerStudioExecutionRole_data-scientist.Ge först databasbehörighet för SageMakerStudioExecutionRole_data-engineer:
  5. Enligt behörigheterväljer Data Lake-behörigheter.
  6. Enligt Datatillståndväljer Grant.
  7. För Mainväljer IAM-användare och rolleroch välj rollen SageMakerStudioExecutionRole_data-engineer.
  8. För Policytaggar eller katalogresurserväljer Namngivna datakatalogresurser.
  9. För Databaser, välj demo.
  10. För Databasbehörigheter, välj super.
  11. Välja Grant.
    Bevilja sedan bordstillstånd för SageMakerStudioExecutionRole_data-engineer:
  12. Enligt Datatillståndväljer Grant.
  13. För Mainväljer IAM-användare och rolleroch välj rollen SageMakerStudioExecutionRole_data-engineer.
  14. För Policytaggar eller katalogresurserväljer Namngivna datakatalogresurser.
  15. För Databaserväljer demo.
  16. För Bordväljer web_marketing.
  17. För Bord behörigheter, välj super.
  18. För Beviljande behörigheter, välj super.
  19. Välja Grant.
    Slutligen, ge databastillstånd för SageMakerStudioExecutionRole_data-scientist:
  20. Enligt Datatillståndväljer Grant.
  21. För Mainväljer IAM-användare och rolleroch välj rollen SageMakerStudioExecutionRole_data-scientist.
  22. För Policytaggar eller katalogresurserväljer Namngivna datakatalogresurser.
  23. För Databaserväljer demo.
  24. För Databasbehörigheter, välj Beskriv.
  25. Välja Grant.

Om författarna

Storskalig funktionsteknik med känsligt dataskydd med hjälp av interaktiva AWS Glue-sessioner och Amazon SageMaker Studio PlatoBlockchain Data Intelligence. Vertikal sökning. Ai.

Praveen Kumar är en Analytics Solution Architect på AWS med expertis i att designa, bygga och implementera moderna data- och analysplattformar med hjälp av molnbaserade tjänster. Hans intresseområden är serverlös teknologi, moderna molndatalager, streaming och ML-applikationer.

Storskalig funktionsteknik med känsligt dataskydd med hjälp av interaktiva AWS Glue-sessioner och Amazon SageMaker Studio PlatoBlockchain Data Intelligence. Vertikal sökning. Ai.

Noritaka Sekiyama är en främsta Big Data Architect i AWS Glue-teamet. Han tycker om att samarbeta med olika team för att leverera resultat som det här inlägget. På fritiden tycker han om att spela tv-spel med sin familj.

Tidsstämpel:

Mer från AWS maskininlärning