Storstilet funktionsteknik med følsom databeskyttelse ved hjælp af AWS Glue Interactive Sessions og Amazon SageMaker Studio

Genudgivet af Platon

Abonnenter: 0

Organisationer bruger maskinlæring (ML) og AI-tjenester til at forbedre kundeoplevelsen, reducere driftsomkostninger og frigøre nye muligheder for at forbedre forretningsresultater. Data understøtter ML og AI use cases og er et strategisk aktiv for en organisation. Da data vokser med en eksponentiel hastighed, søger organisationer at oprette en integreret, omkostningseffektiv og effektiv dataplatform for at forbehandle data, udføre funktionsudvikling og bygge, træne og operationalisere ML-modeller i stor skala. For at opnå det tilbyder AWS en samlet moderne dataplatform, der drives af Amazon Simple Storage Service (Amazon S3) som datasøen med specialbyggede værktøjer og behandlingsmotorer til at understøtte analyser og ML-arbejdsbelastninger. For en samlet ML-oplevelse kan du bruge Amazon SageMaker Studio, som tilbyder native integration med AWS Glue interaktive sessioner at udføre feature engineering i stor skala med følsom databeskyttelse. I dette indlæg viser vi, hvordan man implementerer denne løsning.

Amazon SageMaker er en fuldt administreret ML-tjeneste, der giver dig mulighed for at bygge, træne og implementere modeller i stor skala til en bred vifte af use cases. Til modeltræning kan du bruge enhver af de indbyggede algoritmer i SageMaker for hurtigt at komme i gang med træning og implementering af ML-modeller.

En nøglekomponent i modelbygnings- og udviklingsprocessen er feature engineering. AWS Lim er en af de anbefalede muligheder for at opnå feature engineering i stor skala. AWS Glue gør det muligt for dig at køre dataintegration og -transformation på en distribueret måde på en serverløs Apache Spark-infrastruktur og gør det nemt at bruge det populære Spark ML-bibliotek til feature engineering og modeludvikling. Derudover kan du bruge AWS Glue til inkrementel databehandling igennem job bogmærker, indtag data fra over 100 kilder ved hjælp af stik, og kør spidse eller uforudsigelige arbejdsbelastninger ved hjælp af automatisk skalering.

Et andet vigtigt krav til ML-baserede applikationer er datasikkerhed og adgangskontrol. Det er almindeligt krav at have strammere kontrol over, hvem der kan få adgang til de mest følsomme data som en del af funktionsudviklingen og modelbygningsprocessen ved at følge princippet om mindst privilegeret adgang. For at opnå dette kan du bruge AWS Glue integrationen med AWS søformation for øget styring og styring af datasø-aktiver. Med Lake Formation kan du konfigurere finmasket dataadgangskontrol og sikkerhedspolitikker oven på din Amazon S3-datasø. Politikkerne er defineret på en central placering, hvilket tillader flere analyse- og ML-tjenester, såsom AWS Glue, Amazonas Athena, og SageMaker, til at interagere med data gemt i Amazon S3.

AWS lim inkluderer en påvisning af personligt identificerbare oplysninger (PII). transformation, der giver mulighed for at opdage, maskere eller fjerne enheder efter behov for øget compliance og styring. Med PII-transformationen kan du detektere PII-data i datasæt og automatisk anvende finkornet adgangskontrol ved hjælp af Lake Formation for at begrænse følsomme data for forskellige brugergrupper.

Brug sag

Vi fokuserer på en tilbøjelighedsmodelbrugscase, der inkluderer et kundemarketingdatasæt og involverer to brugerpersonas: en dataingeniør og dataforsker. Datasættet indeholder oplysninger pr. kunde, herunder leadkilde, kontaktnoter, jobrolle, nogle flag, sidevisninger pr. besøg og mere. Datasættet indeholder også følsomme oplysninger som personlige telefonnumre.

Dataingeniøren er ansvarlig for at opbygge end-to-end databehandlingspipeline, herunder dataforberedelse, forbehandling og adgangskontrol. Dataforskeren er ansvarlig for feature engineering og træning og implementering af ML-modellen. Bemærk, at dataforskeren ikke har tilladelse til at få adgang til nogen PII-følsomme data til funktionsudvikling eller træning af ML-modellen.

Som en del af denne use case bygger dataingeniøren en datapipeline til at forbehandle datasættet, scanner datasættet for enhver PII-information og begrænser adgangen til PII-kolonnen til dataforskerens bruger. Som et resultat, når en dataforsker bruger datasættet til at udføre feature engineering og bygge ML-modeller, har de ikke adgang til den PII-følsomme kolonne (telefonnumre, i dette tilfælde). Funktionsudviklingsprocessen involverer konvertering af kolonner af typestreng til et format, der er optimalt for ML-modeller. Som et avanceret anvendelsestilfælde kan du udvide dette adgangsmønster til at implementere sikkerhed på rækkeniveau og celleniveau ved hjælp af Lake Formation.

Løsningsoversigt

Løsningen indeholder følgende trin på højt niveau:

Opsæt ressourcer med AWS CloudFormation.
Forbehandle datasættet, inklusive PII-detektion og finmasket adgangskontrol, på en interaktiv AWS Glue-session.
Udfør feature engineering på en AWS Glue interaktiv session.
Træn og implementer en ML-model ved hjælp af den indbyggede SageMaker XGBoost-algoritme.
Evaluer ML-modellen.

Følgende diagram illustrerer løsningsarkitekturen.

Forudsætninger

For at fuldføre denne øvelse skal du have følgende forudsætninger:

Konfigurer ressourcer med AWS CloudFormation

Dette indlæg inkluderer en CloudFormation-skabelon til en hurtig opsætning. Du kan gennemgå og tilpasse den, så den passer til dine behov. Hvis du foretrækker at opsætte ressourcer på AWS Management Console og AWS CLI i stedet for AWS CloudFormation, se instruktionerne i appendiks i slutningen af dette indlæg.

CloudFormation-skabelonen genererer følgende ressourcer:

S3 buckets med et eksempeldatasæt
An AWS Lambda funktion til at indlæse datasættet
AWS identitets- og adgangsstyring (IAM) gruppe, brugere, roller og politikker
Søformationsdata søindstillinger og tilladelser
SageMaker brugerprofiler

For at oprette dine ressourcer skal du udføre følgende trin:

Log ind på konsollen.
Vælg Start Stack:
Vælg Næste.
Til DataEngineerPwd , DataScientistPwd, indtast din egen adgangskode til dataingeniøren og dataforskerens brugere.
Til GlueDatabaseName, gå ind demo.
Til GlueTableName, gå ind web_marketing.
Til S3BucketNameForInput, gå ind blog-studio-pii-dataset-.
Til S3BucketNameForOutput, gå ind blog-studio-output-.
Til SageMakerDomainId, indtast dit SageMaker-domæne-id, som du forberedte i de forudgående trin.
Vælg Næste.
Vælg på næste side Næste.
Gennemgå detaljerne på den sidste side, og vælg Jeg anerkender, at AWS CloudFormation kan skabe IAM-ressourcer.
Vælg Opret.

Oprettelse af stakke kan tage op til 10 minutter. Stakken opretter IAM-roller og SageMaker-brugerprofiler for to personas: dataingeniør og dataforsker. Det opretter også en databasedemo og tabel web_marketing med et eksempeldatasæt.

På det tidspunkt, hvor stakken oprettes, har dataingeniørpersonen fuldstændig adgang til tabellen, men dataforskerpersonen har endnu ikke adgang til tabellen.

Forbehandle datasættet

Lad os begynde at forbehandle data på en interaktiv AWS Glue-session. Dataingeniørens persona ønsker at verificere dataene for at se, om der er følsomme data eller ej, og give minimal adgangstilladelse til dataforskerens persona. Du kan downloade notesbog fra denne placering.

Log ind på konsollen ved hjælp af dataingeniør-brugeren.
Vælg på SageMaker-konsollen Brugere.
Vælg dataingeniør-brugeren og vælg Åben Studio.
Opret en ny notesbog og vælg SparkAnalytics 1.0 forum Billede , Lim PySpark forum kernel.
Start en interaktiv session med følgende magi for at installere den nyere version af Boto3 (dette er påkrævet for at bruge create_data_cells_filter metode):
```
%additional_python_modules boto3==1.24.82
```

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

Opret en AWS Glue DynamicFrame fra den nyoprettede tabel, og løse valgtyper baseret på katalogskema, fordi vi ønsker at bruge skemaet defineret i kataloget i stedet for det automatisk udledte skema baseret 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()

Valider i tabellen, om der er nogen PII-data ved hjælp af AWS Glue PII-detektion:

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)

Bekræft, om kolonnerne, der er klassificeret som PII, indeholder følsomme data eller ej (hvis ikke, opdater classified_map for at slette de ikke-følsomme kolonner):
```
from pyspark.sql.functions import col
dyf_marketing_resolved.toDF().select(*[col(c) for c in classified_map.keys()]).show()
```

Konfigurer Lake Formation-tilladelser ved hjælp af et datacellefilter til automatisk detekterede kolonner, og begræns kolonnerne til dataforskerens 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'
]
)

Log ind på Studio som dataforsker for at se, at PII-kolonnerne ikke er synlige. Du kan downloade notesbog fra denne placering.

Opret en ny notesbog og vælg SparkAnalytics 1.0 forum Billede , Lim PySpark forum kernel:

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

Udfør feature engineering

Vi bruger Apache Spark ML-biblioteket til at udføre feature engineering som data-scientist-bruger og derefter skrive output tilbage til Amazon S3.

I den følgende celle anvender vi funktioner fra Apache Spark ML bibliotek:

StringIndexer knytter en strengkolonne af etiketter til en kolonne med etiketindekser.
OneHotEncoder kortlægger et kategorisk træk, repræsenteret som et etiketindeks, til en binær vektor med højst en enkelt én-værdi, der indikerer tilstedeværelsen af et specifikt kategorisk træk. Denne transformation bruges til ML-algoritmer, der forventer kontinuerlige funktioner.
VectorAssembler er en transformer, der kombinerer en given liste af kolonner til en enkelt vektorkolonne, som derefter bruges til at træne ML-modeller til algoritmer som logistisk regression og beslutningstræer.

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

Den endelige transformerede DataFrame kan oprettes ved hjælp af Pipeline-biblioteket. En pipeline er specificeret som en sekvens af trin. Disse trin køres i rækkefølge, og input-DataFrame transformeres, når det passerer gennem hvert trin.
```
df_marketing = dyf_marketing.toDF()
pipeline = Pipeline(stages=indexers + encoders + [assembler])
df_tfm=pipeline.fit(df_marketing).transform(df_marketing)
```

Dernæst opdeler vi datasættet i at træne, validere og teste DataFrame og gemme det i S3-bøtten for at træne ML-modellen (giv dit AWS-konto-id i følgende kode):

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æn og implementer en ML-model

I det foregående afsnit gennemførte vi feature engineering, som omfattede konvertering af strengkolonner som f.eks region, jobroleog usedpromo til et format, der er optimalt for ML-modeller. Vi inkluderede også kolonner som f.eks pageviewspervisit , totalwebvisits, som vil hjælpe os med at forudsige en kundes tilbøjelighed til at købe et produkt.

Vi træner nu en ML-model ved at læse tog- og valideringsdatasættet ved hjælp af SageMaker indbyggede XGBoost-algoritme. Derefter implementerer vi modellen og kører et nøjagtighedstjek. Du kan downloade notesbog fra denne placering.

I den følgende celle læser vi data fra den anden S3-bøtte, som inkluderer output fra vores funktionsteknologiske operationer. Så bruger vi den indbyggede algoritme XGBoost til at træne modellen.

Åbn en ny notesbog. Vælge data, Science forum Billede , Python 3 forum kernel (angiv dit AWS-konto-id i følgende kode):

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

Når træningen er afsluttet, kan vi implementere modellen ved hjælp af SageMaker-hostingtjenester:
```
#deploy ml model
xgb_predictor = xgb.deploy(initial_instance_count=1,
instance_type='ml.m4.xlarge')
```

Evaluer ML-modellen

Vi bruger testdatasættet til at evaluere modellen og slette inferensendepunktet, når vi er færdige, for at undgå løbende gebyrer.

Evaluer modellen med følgende kode:

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

Nøjagtighedsresultatet for prøvekørslen var 84.6 %. Dette kan være lidt anderledes for dit løb på grund af den tilfældige opdeling af datasættet.

Vi kan slette inferensslutpunktet med følgende kode:

xgb_predictor.delete_endpoint(delete_endpoint_config=True)

Ryd op

Nu til det sidste trin, oprydning af ressourcerne.

Tøm de to spande, der er oprettet gennem CloudFormation-stakken.
Slet de apps, der er knyttet til brugeren profiles data-scientist , data-engineer i studiet.
Slet CloudFormation-stakken.

Konklusion

I dette indlæg demonstrerede vi en løsning, der gør det muligt for personer som dataingeniører og dataforskere at udføre feature engineering i stor skala. Med interaktive AWS Glue-sessioner kan du nemt opnå feature engineering i skala med automatisk PII-detektion og finmasket adgangskontrol uden at skulle administrere nogen underliggende infrastruktur. Ved at bruge Studio som enkelt adgangspunkt kan du få en forenklet og integreret oplevelse til at opbygge en end-to-end ML-workflow: fra forberedelse og sikring af data til opbygning, træning, tuning og implementering af ML-modeller. For at lære mere, besøg Kom godt i gang med interaktive AWS Glue-sessioner , Amazon SageMaker Studio.

Vi er meget begejstrede for denne nye evne og vil gerne se, hvad du vil bygge med den!

Appendiks: Opsæt ressourcer via konsollen og AWS CLI

Fuldfør instruktionerne i dette afsnit for at konfigurere ressourcer ved hjælp af konsollen og AWS CLI i stedet for CloudFormation-skabelonen.

Forudsætninger

For at fuldføre denne øvelse skal du have adgang til AWS CLI (se Kom godt i gang med AWS CLI) eller brug kommandolinjeadgang fra AWS CloudShell.

Konfigurer IAM-gruppe, brugere, roller og politikker

I dette afsnit opretter vi to IAM-brugere: dataingeniør og dataforsker, som tilhører IAM-gruppen data-platform-gruppe. Derefter tilføjer vi en enkelt IAM-politik til IAM-gruppen.

På IAM-konsollen, oprette en politik på fanen JSON for at oprette en ny IAM-administreret politik med navnet DataPlatformGroupPolicy. Politikken tillader brugere i gruppen at få adgang til Studio, men kun ved at bruge en SageMaker-brugerprofil med et tag, der matcher deres IAM-brugernavn. Brug følgende JSON-politikdokument til at give tilladelser:

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

Opret en IAM-gruppe kaldet data-platform-group.
Søg og vedhæft den AWS-administrerede politik ved navn DataPlatformGroupPolicy til gruppen.
Opret IAM-brugere kaldet dataingeniør og dataforsker under IAM-gruppen data-platform-gruppe.

Opret en ny administreret politik navngivet SageMakerExecutionPolicy (giv dit område og konto-id i følgende kode):

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

Opret en ny administreret politik som hedder 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"
      }
   ]
}

Opret en IAM-rolle for SageMaker for dataingeniøren (data-ingeniør), som bruges som den tilsvarende brugerprofils eksekveringsrolle. På den Vedhæft tilladelsespolitik side, er AmazonSageMakerFullAccess (AWS-administreret politik) vedhæftet som standard. Du fjerner denne politik senere for at bevare minimumsrettigheder.
1. Til Rollenavn, brug navnekonventionen introduceret i begyndelsen af dette afsnit til at navngive rollen SageMakerStudioExecutionRole_data-engineer.
2. Til Tags, tilføj nøglebrugerprofilnavnet og værdidataingeniøren.
3. Vælg Opret rolle.
4. For at tilføje de resterende politikker, på roller side, skal du vælge det rollenavn, du lige har oprettet.
5. Under Tilladelser, fjern politikken AmazonSageMakerFullAccess.
6. På Vedhæft tilladelsespolitik side, skal du vælge den AWS-administrerede politik AwsGlueSessionUserRestrictedServiceRole og de kundeadministrerede politikker SageMakerExecutionPolicy og SageMakerAdminPolicy, som du har oprettet.
7. Vælg Vedhæft politikker.
8. Ændre din rolles tillidsforhold:
```
{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":[
               "glue.amazonaws.com",
               "sagemaker.amazonaws.com"
            ]
         },
         "Action":"sts:AssumeRole"
      }
   ]
}
```
Opret en IAM-rolle for SageMaker for data scientisten (data-scientist), som bruges som den tilsvarende brugerprofils eksekveringsrolle.
1. Til Rollenavn, navngiv rollen SageMakerStudioExecutionRole_data-scientist.
2. Til Tags, tilføj nøglebrugerprofilnavnet og værdien dataforsker.
3. Vælg Opret rolle.
4. For at tilføje de resterende politikker, på roller side, skal du vælge det rollenavn, du lige har oprettet.
5. Under Tilladelser, fjern politikken AmazonSageMakerFullAccess.
6. På Vedhæft tilladelsespolitik side, skal du vælge den AWS-administrerede politik AwsGlueSessionUserRestrictedServiceRole og den kundeadministrerede politik SageMakerExecutionPolicy, som du har oprettet.
7. Vælg Vedhæft politikker.
8. Ændre din rolles tillidsforhold:
```
{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":[
               "glue.amazonaws.com",
               "sagemaker.amazonaws.com"
            ]
         },
         "Action":"sts:AssumeRole"
      }
   ]
}
```

Konfigurer SageMaker-brugerprofiler

For at oprette dine SageMaker-brugerprofiler med studiouserid tag, udfør følgende trin:

Brug AWS CLI eller CloudShell til at oprette Studio-brugerprofilen for dataingeniøren (angiv dit konto-id og Studio-domæne-id i følgende kode):

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

Gentag trinnet for at oprette en brugerprofil for dataforskeren og erstatte konto-id'et og Studio-domæne-id'et:

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

Opret S3-buckets, og upload prøvedatasættet

I dette afsnit opretter du to S3-spande. Den første bøtte har et eksempeldatasæt relateret til webmarketing. Den anden bøtte bruges af dataforskeren til at gemme output fra feature engineering-opgaver, og dette outputdatasæt bruges til at træne ML-modellen.

Først skal du oprette S3-bøtten til inputdata:

Hent datasættet.
På Amazon S3-konsollen skal du vælge spande i navigationsruden.
Vælg Opret spand.
Til Område, skal du vælge den region med SageMaker-domænet, der inkluderer de brugerprofiler, du har oprettet.
Til Navn på spand, gå ind blog-studio-pii-dataset-.
Vælg Opret spand.
Vælg den bøtte, du har oprettet, og vælg Upload.
I Vælg filer sektion, skal du vælge Tilføj filer og upload det datasæt, du downloadede.
Nu opretter du bøtten til outputdataene:
På spande side, vælg Opret spand.
Til Område, skal du vælge den region med SageMaker-domænet, der inkluderer de brugerprofiler, du har oprettet.
Til Navn på spand, gå ind blog-studio-output-.
Vælg Opret spand.

Opret en AWS Glue database og tabel

I dette afsnit opretter du en AWS Glue-database og -tabel til datasættet.

På Lake Formation-konsollen, under Datakatalog i navigationsruden skal du vælge Databaser.
Vælg Tilføj database.
Til Navn, indtast demo.
Vælg Opret database.
Under Datakatalog, vælg tabeller.
Til Navn, gå ind web_marketing.
Til Database, Vælg demo.
Til Inkluder sti, indtast stien til din S3-bøtte for inputdata.
Til Klassifikation, vælg CSV.
Under Planlæg, vælg Upload skema.

Indtast følgende JSON-array i tekstboksen:

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

Vælg Upload.
Vælg Indsend.
Under Borddetaljer, vælg Rediger tabel.
Under Tabel egenskaber, vælg Tilføj.
Til Nøgle, gå ind skip.header.line.count, Og Værdi, indtast 1.
Vælg Gem.

Konfigurer Lake Formation-tilladelser

I dette afsnit konfigurerer du Lake Formation-tilladelser for at tillade IAM-rolle SageMakerStudioExecutionRole_data-engineer at oprette en database og registrere S3-lokationen i Lake Formation.

Først skal du registrere datasøens placering for at administrere tabeller under placeringen i Lake Formation-tilladelser:

Vælg Placering af datasøer.
Vælg Registrer placering.
Til Amazon S3-sti, gå ind s3://blog-studio-pii-dataset-/ (den bøtte, der indeholder datasættet).
Vælg Registrer placering.
Nu giver du Lake Formation-database- og tabeltilladelser til IAM-rollerne SageMakerStudioExecutionRole_data-engineer , SageMakerStudioExecutionRole_data-scientist.Giv først databasetilladelse til SageMakerStudioExecutionRole_data-engineer:
Under Tilladelser, vælg Data sø-tilladelser.
Under Datatilladelse, vælg Grant.
Til Rektorer, vælg IAM brugere og roller, og vælg rollen SageMakerStudioExecutionRole_data-engineer.
Til Politiktags eller katalogressourcer, vælg Navngivne datakatalogressourcer.
Til Databaser, vælg demo.
Til Database tilladelser, Vælg Super.
Vælg Grant.
Giv derefter bordtilladelse til SageMakerStudioExecutionRole_data-engineer:
Under Datatilladelse, vælg Grant.
Til Rektorer, vælg IAM brugere og roller, og vælg rollen SageMakerStudioExecutionRole_data-engineer.
Til Politiktags eller katalogressourcer, vælg Navngivne datakatalogressourcer.
Til Databaser, vælg demo.
Til tabeller, vælg web_marketing.
Til Bordlampe tilladelser, Vælg Super.
Til Bevilgeligt tilladelser, Vælg Super.
Vælg Grant.
Giv endelig databasetilladelse til SageMakerStudioExecutionRole_data-scientist:
Under Datatilladelse, vælg Grant.
Til Rektorer, vælg IAM brugere og roller, og vælg rollen SageMakerStudioExecutionRole_data-scientist.
Til Politiktags eller katalogressourcer, vælg Navngivne datakatalogressourcer.
Til Databaser, vælg demo.
Til Database tilladelser, Vælg Beskriv.
Vælg Grant.

Om forfatterne

Storstilet funktionsteknik med følsom databeskyttelse ved hjælp af interaktive AWS Glue-sessioner og Amazon SageMaker Studio PlatoBlockchain Data Intelligence. Lodret søgning. Ai.

Praveen Kumar er en Analytics Solution Architect hos AWS med ekspertise i at designe, bygge og implementere moderne data- og analyseplatforme ved hjælp af cloud-native tjenester. Hans interesseområder er serverløs teknologi, moderne cloud-datavarehuse, streaming og ML-applikationer.

Storstilet funktionsteknik med følsom databeskyttelse ved hjælp af interaktive AWS Glue-sessioner og Amazon SageMaker Studio PlatoBlockchain Data Intelligence. Lodret søgning. Ai.

Noritaka Sekiyama er Principal Big Data Architect på AWS Glue-teamet. Han nyder at samarbejde med forskellige teams for at levere resultater som dette indlæg. I sin fritid nyder han at spille videospil med sin familie.

Tidsstempel: November 17, 2022November 20, 2022

Tidsstempel: Juli 26, 2023

Storstilet funktionsteknik med følsom databeskyttelse ved hjælp af interaktive AWS Glue-sessioner og Amazon SageMaker Studio

Genudgivet af Platon

Brug sag

Løsningsoversigt

Forudsætninger

Konfigurer ressourcer med AWS CloudFormation

Forbehandle datasættet

Udfør feature engineering

Træn og implementer en ML-model

Evaluer ML-modellen

Ryd op

Konklusion

Appendiks: Opsæt ressourcer via konsollen og AWS CLI

Forudsætninger

Konfigurer IAM-gruppe, brugere, roller og politikker

Konfigurer SageMaker-brugerprofiler

Opret S3-buckets, og upload prøvedatasættet

Opret en AWS Glue database og tabel

Konfigurer Lake Formation-tilladelser

Om forfatterne

Mere fra AWS maskinindlæring

Kør flere deep learning-modeller på GPU med Amazon SageMaker multi-model endpoints

Brug AWS CDK til at implementere Amazon SageMaker Studio livscykluskonfigurationer | Amazon Web Services

Amazon Rekognition introducerer Streaming Video Events for at give realtidsadvarsler på live videostreams

Annoncering af AWS DeepRacer League 2022

Hvordan Amp på Amazon brugte data til at øge kundeengagementet, del 1: Opbygning af en dataanalyseplatform

Optimer udstyrets ydeevne med historiske data, Ray og Amazon SageMaker | Amazon Web Services

Om os

Vertikal søgning & Ai

perron

Stay Connected

Konto