Storskala funksjonsteknikk med sensitiv databeskyttelse ved hjelp av interaktive AWS Glue-sesjoner og Amazon SageMaker Studio PlatoBlockchain Data Intelligence. Vertikalt søk. Ai.

Storskala funksjonsteknikk med sensitiv databeskyttelse ved hjelp av interaktive AWS Glue-sesjoner og Amazon SageMaker Studio

Tidsstempel: 17. november 2022, kl

Organisasjoner bruker maskinlæring (ML) og AI-tjenester for å forbedre kundeopplevelsen, redusere driftskostnadene og åpne for nye muligheter for å forbedre forretningsresultatene. Data underbygger ML- og AI-brukstilfeller og er en strategisk ressurs for en organisasjon. Ettersom data vokser i en eksponentiell hastighet, er organisasjoner ute etter å sette opp en integrert, kostnadseffektiv og effektiv dataplattform for å forhåndsbehandle data, utføre funksjonsutvikling og bygge, trene og operasjonalisere ML-modeller i stor skala. For å oppnå det tilbyr AWS en enhetlig moderne dataplattform som drives av Amazon enkel lagringstjeneste (Amazon S3) som datainnsjøen med spesialbygde verktøy og prosesseringsmotorer for å støtte analyser og ML-arbeidsbelastninger. For en enhetlig ML-opplevelse kan du bruke Amazon SageMaker Studio, som tilbyr innfødt integrasjon med AWS Glue interaktive økter å utføre funksjonsutvikling i stor skala med sensitiv databeskyttelse. I dette innlegget viser vi hvordan du implementerer denne løsningen.

Amazon SageMaker er en fullstendig administrert ML-tjeneste som lar deg bygge, trene og distribuere modeller i stor skala for et bredt spekter av bruksområder. For modelltrening kan du bruke hvilken som helst av innebygde algoritmer innen SageMaker for å komme raskt i gang med opplæring og distribusjon av ML-modeller.

En nøkkelkomponent i modellbyggings- og utviklingsprosessen er funksjonsteknikk. AWS Lim er et av de anbefalte alternativene for å oppnå funksjonsteknikk i stor skala. AWS Glue lar deg kjøre dataintegrasjon og transformasjon på en distribuert måte på en serverløs Apache Spark-infrastruktur, og gjør det enkelt å bruke det populære Spark ML-biblioteket for funksjonsutvikling og modellutvikling. I tillegg kan du bruke AWS Glue for inkrementell databehandling gjennom jobb bokmerker, innta data fra over 100 kilder ved hjelp av kontakter, og kjøre piggete eller uforutsigbare arbeidsbelastninger ved hjelp av automatisk skalering.

Et annet viktig krav for ML-baserte applikasjoner er datasikkerhet og tilgangskontroll. Det er vanlig krav å ha strengere kontroll over hvem som kan få tilgang til de mest sensitive dataene som en del av funksjonsutviklingen og modellbyggingsprosessen ved å følge prinsippet om minst privilegert tilgang. For å oppnå dette kan du bruke AWS Glue-integrasjonen med AWS Lake formasjon for økt styring og forvaltning av datainnsjø-aktiva. Med Lake Formation kan du konfigurere finmasket datatilgangskontroll og sikkerhetspolicyer på toppen av din Amazon S3-datainnsjø. Retningslinjene er definert på et sentralt sted, og tillater flere analyse- og ML-tjenester, for eksempel AWS Glue, Amazonas Athena, og SageMaker, for å samhandle med data som er lagret i Amazon S3.

AWS lim inkluderer en gjenkjenning av personlig identifiserbar informasjon (PII). transformasjon som gir muligheten til å oppdage, maskere eller fjerne enheter etter behov, for økt overholdelse og styring. Med PII-transformasjonen kan du oppdage PII-data i datasett og automatisk bruke finkornet tilgangskontroll ved å bruke Lake Formation for å begrense sensitive data for forskjellige brukergrupper.

Bruk saken

Vi fokuserer på en brukscase for tilbøyelighetsmodeller som inkluderer et kundemarkedsføringsdatasett og involverer to brukerpersonas: en dataingeniør og dataforsker. Datasettet inneholder informasjon per kunde, inkludert kundeemnekilde, kontaktnotater, jobbrolle, noen flagg, sidevisninger per besøk og mer. Datasettet inneholder også sensitiv informasjon som personlige telefonnumre.

Dataingeniøren er ansvarlig for å bygge ende-til-ende databehandlingspipeline, inkludert dataforberedelse, forhåndsbehandling og tilgangskontroll. Dataforskeren er ansvarlig for funksjonsutvikling og opplæring og distribusjon av ML-modellen. Merk at dataforskeren ikke har tilgang til PII-sensitive data for funksjonsutvikling eller opplæring av ML-modellen.

Som en del av denne brukssaken bygger dataingeniøren en datapipeline for å forhåndsbehandle datasettet, skanner datasettet for eventuell PII-informasjon og begrenser tilgangen til PII-kolonnen til dataforskerbrukeren. Som et resultat, når en dataforsker bruker datasettet til å utføre funksjonsutvikling og bygge ML-modeller, har de ikke tilgang til den PII-sensitive kolonnen (telefonnumre, i dette tilfellet). Funksjonsteknikkprosessen innebærer å konvertere kolonner med typestreng til et format som er optimalt for ML-modeller. Som et avansert brukstilfelle kan du utvide dette tilgangsmønsteret til å implementere sikkerhet på radnivå og cellenivå ved hjelp av Lake Formation.

Løsningsoversikt

Løsningen inneholder følgende trinn på høyt nivå:

  1. Sett opp ressurser med AWS skyformasjon.
  2. Forbehandle datasettet, inkludert PII-deteksjon og finmasket tilgangskontroll, på en interaktiv AWS Glue-sesjon.
  3. Utfør funksjonsutvikling på en interaktiv AWS Glue-økt.
  4. Tren og distribuer en ML-modell ved hjelp av SageMaker innebygde XGBoost-algoritme.
  5. Vurder ML-modellen.

Følgende diagram illustrerer løsningsarkitekturen.

Forutsetninger

For å fullføre denne opplæringen må du ha følgende forutsetninger:

Sett opp ressurser med AWS CloudFormation

Dette innlegget inkluderer en CloudFormation-mal for et raskt oppsett. Du kan se gjennom og tilpasse den for å passe dine behov. Hvis du foretrekker å sette opp ressurser på AWS-administrasjonskonsoll og AWS CLI i stedet for AWS CloudFormation, se instruksjonene i vedlegget på slutten av dette innlegget.

CloudFormation-malen genererer følgende ressurser:

Gjør følgende for å opprette ressursene dine:

  1. Logg på konsollen.
  2. Velg Start Stack:
    Start-knapp
  3. Velg neste.
  4. Til DataEngineerPwd og DataScientistPwd, skriv inn ditt eget passord for brukerne av dataingeniøren og dataforskeren.
  5. Til GlueDatabaseName, Tast inn demo.
  6. Til GlueTableName, Tast inn web_marketing.
  7. Til S3BucketNameForInput, Tast inn blog-studio-pii-dataset-.
  8. Til S3BucketNameForOutput, Tast inn blog-studio-output-.
  9. Til SageMakerDomainId, skriv inn SageMaker-domene-IDen din som du forberedte i de nødvendige trinnene.
  10. Velg neste.
  11. På neste side velger du neste.
  12. Gå gjennom detaljene på den siste siden og velg Jeg erkjenner at AWS CloudFormation kan skape IAM-ressurser.
  13. Velg Opprett.

Oppretting av stabel kan ta opptil 10 minutter. Stabelen oppretter IAM-roller og SageMaker-brukerprofiler for to personas: dataingeniør og dataforsker. Den lager også en databasedemo og tabell web_marketing med et eksempeldatasett.

På tidspunktet for stabeloppretting har dataingeniørpersona full tilgang til tabellen, men dataforskerpersona har ikke tilgang til tabellen ennå.

Forbehandle datasettet

La oss begynne å forhåndsbehandle data på en interaktiv AWS Glue-sesjon. Dataingeniørens persona ønsker å verifisere dataene for å se om det er sensitive data eller ikke, og gi minimal tilgangstillatelse til dataforskerens persona. Du kan laste ned notatbok fra denne plasseringen.

  1. Logg på konsollen med brukeren av dataingeniøren.
  2. Velg på SageMaker-konsollen brukere.
  3. Velg dataingeniør-brukeren og velg Åpne Studio.
  4. Opprett en ny notatbok og velg SparkAnalytics 1.0 forum Bilde og Lim PySpark forum Kernel.
  5. Start en interaktiv økt med følgende magi for å installere den nyere versjonen av Boto3 (dette er nødvendig for å bruke create_data_cells_filter metode): 
    %additional_python_modules boto3==1.24.82

  6. Initialiser økten: 
    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. Lag en AWS Glue DynamicFrame fra den nyopprettede tabellen, og løse valgtyper basert på katalogskjema, fordi vi ønsker å bruke skjemaet definert i katalogen i stedet for det automatisk utledede skjemaet basert 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. Valider i tabellen om det er noen PII-data ved å bruke AWS Glue PII-deteksjon: 
    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. Kontroller om kolonnene klassifisert som PII inneholder sensitive data eller ikke (hvis ikke, oppdater classified_map for å slette de ikke-sensitive kolonnene): 
    from pyspark.sql.functions import col
dyf_marketing_resolved.toDF().select(*[col(c) for c in classified_map.keys()]).show()

  10. Konfigurer Lake Formation-tillatelser ved å bruke et datacellefilter for automatisk oppdagede kolonner, og begrens kolonnene 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'
]
)

  11. Logg på Studio som dataforsker for å se at PII-kolonnene ikke er synlige. Du kan laste ned notatbok fra denne plasseringen.
  12. Opprett en ny notatbok og velg SparkAnalytics 1.0 forum Bilde og 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()

Utfør funksjonsteknikk

Vi bruker Apache Spark ML-biblioteket til å utføre funksjonsutvikling som dataforskerbruker og deretter skrive tilbake utdataene til Amazon S3.

  1. I den følgende cellen bruker vi funksjoner fra Apache Spark ML-bibliotek:
    • StringIndexer tilordner en strengkolonne med etiketter til en kolonne med etikettindekser.
    • OneHotEncoder kartlegger et kategorisk trekk, representert som en etikettindeks, til en binær vektor med høyst en enkelt én-verdi som indikerer tilstedeværelsen av et spesifikt kategorisk trekk. Denne transformasjonen brukes for ML-algoritmer som forventer kontinuerlige funksjoner.
    • VectorAssembler er en transformator som kombinerer en gitt liste med kolonner til en enkelt vektorkolonne, som deretter brukes i opplæring av ML-modeller for algoritmer som logistisk regresjon og beslutningstrær.
    #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 endelige transformerte DataFrame kan opprettes ved hjelp av Pipeline-biblioteket. En rørledning er spesifisert som en sekvens av trinn. Disse trinnene kjøres i rekkefølge og dataframe for input transformeres etter hvert som den passerer gjennom hvert trinn. 
    df_marketing = dyf_marketing.toDF()
pipeline = Pipeline(stages=indexers + encoders + [assembler])
df_tfm=pipeline.fit(df_marketing).transform(df_marketing)

  3. Deretter deler vi datasettet i trene, validere og tester DataFrame og lagrer det i S3-bøtten for å trene ML-modellen (oppgi AWS-konto-IDen din 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))

Tren og distribuer en ML-modell

I forrige seksjon fullførte vi funksjonsteknikk, som inkluderte konvertering av strengkolonner som f.eks region, jobroleog usedpromo til et format som er optimalt for ML-modeller. Vi inkluderte også kolonner som f.eks pageviewspervisit og totalwebvisits, som vil hjelpe oss å forutsi en kundes tilbøyelighet til å kjøpe et produkt.

Vi trener nå en ML-modell ved å lese tog- og valideringsdatasettet ved hjelp av SageMaker innebygde XGBoost-algoritme. Deretter distribuerer vi modellen og kjører en nøyaktighetssjekk. Du kan laste ned notatbok fra denne plasseringen.

I den følgende cellen leser vi data fra den andre S3-bøtten, som inkluderer utdataene fra funksjonsteknologien vår. Deretter bruker vi den innebygde algoritmen XGBoost for å trene modellen.

  1. Åpne en ny notatbok. Velge data Science forum Bilde og Python 3 forum Kernel (oppgi din 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})

  2. Når opplæringen er fullført, kan vi distribuere modellen ved å bruke SageMaker-vertstjenester: 
    #deploy ml model
xgb_predictor = xgb.deploy(initial_instance_count=1,
instance_type='ml.m4.xlarge')

Vurder ML-modellen

Vi bruker testdatasettet til å evaluere modellen og slette inferensendepunktet når vi er ferdige for å unngå pågående kostnader.

  1. 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øyaktighetsresultatet for prøvekjøringen var 84.6 %. Dette kan være litt annerledes for løpeturen din på grunn av den tilfeldige oppdelingen av datasettet.

  2. Vi kan slette inferensendepunktet med følgende kode: 
    xgb_predictor.delete_endpoint(delete_endpoint_config=True)

Rydd opp

Nå til det siste trinnet, å rydde opp i ressursene.

  1. Tøm de to bøttene som er opprettet gjennom CloudFormation-stabelen.
  2. Slett appene knyttet til brukeren profiles data-scientist og data-engineer i studio.
  3. Slett CloudFormation-stakken.

konklusjonen

I dette innlegget demonstrerte vi en løsning som gjør det mulig for personas som dataingeniører og dataforskere å utføre funksjonsteknikk i stor skala. Med AWS Glue interaktive økter kan du enkelt oppnå funksjonsutvikling i stor skala med automatisk PII-deteksjon og finmasket tilgangskontroll uten å måtte administrere noen underliggende infrastruktur. Ved å bruke Studio som enkelt inngangspunkt kan du få en forenklet og integrert opplevelse for å bygge en ende-til-ende ML-arbeidsflyt: fra å forberede og sikre data til å bygge, trene, justere og distribuere ML-modeller. For å lære mer, besøk Komme i gang med AWS Glue interaktive økter og Amazon SageMaker Studio.

Vi er veldig spente på denne nye evnen og vil gjerne se hva du skal bygge med den!

Vedlegg: Sett opp ressurser via konsollen og AWS CLI

Fullfør instruksjonene i denne delen for å sette opp ressurser ved å bruke konsollen og AWS CLI i stedet for CloudFormation-malen.

Forutsetninger

For å fullføre denne opplæringen må du ha tilgang til AWS CLI (se Komme i gang med AWS CLI) eller bruk kommandolinjetilgang fra AWS CloudShell.

Konfigurer IAM-gruppe, brukere, roller og policyer

I denne delen oppretter vi to IAM-brukere: dataingeniør og dataforsker, som tilhører IAM-gruppen dataplattform-gruppe. Deretter legger vi til en enkelt IAM-policy til IAM-gruppen.

  1. På IAM-konsollen, opprette en policy på JSON-fanen for å opprette en ny IAM-styrt policy som heter DataPlatformGroupPolicy. Policyen tillater brukere i gruppen å få tilgang til Studio, men bare ved å bruke en SageMaker-brukerprofil med en tag som samsvarer med deres IAM-brukernavn. Bruk følgende JSON-policydokument for å gi tillatelser: 
    {
   "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. Opprett en IAM-gruppe som heter data-platform-group.
  3. Søk og legg ved den AWS-administrerte policyen kalt DataPlatformGroupPolicy til gruppen.
  4. Opprett IAM-brukere kalt dataingeniør og dataforsker under IAM-gruppen dataplattform-gruppe.
  5. Opprett en ny administrert policy kalt SageMakerExecutionPolicy (oppgi din region 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"
      }
   ]
}

  6. Opprett en ny administrert policy navngitt 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. Lag en IAM-rolle for SageMaker for dataingeniøren (dataingeniør), som brukes som den tilsvarende brukerprofilens utførelsesrolle. På Legg ved tillatelsespolicy side, er AmazonSageMakerFullAccess (AWS-administrert policy) vedlagt som standard. Du fjerner denne policyen senere for å opprettholde minimumsrettigheter.
    1. Til Rollenavn, bruk navnekonvensjonen introdusert i begynnelsen av denne delen for å navngi rollen SageMakerStudioExecutionRole_data-engineer.
    2. Til Tags, legg til nøkkelbrukerprofilnavnet og verdidataingeniøren.
    3. Velg Skape rolle.
    4. For å legge til de gjenværende policyene, på Roller side, velg rollenavnet du nettopp opprettet.
    5. Under Tillatelser, fjern policyen AmazonSageMakerFullAccess.
    6. På Legg ved tillatelsespolicy siden, velg AWS-administrert policy AwsGlueSessionUserRestrictedServiceRole og kundeadministrerte policyer SageMakerExecutionPolicy og SageMakerAdminPolicy som du opprettet.
    7. Velg Legg ved retningslinjer.
    8. endre din rolles tillitsforhold:
    {
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":[
               "glue.amazonaws.com",
               "sagemaker.amazonaws.com"
            ]
         },
         "Action":"sts:AssumeRole"
      }
   ]
}

  8. Lag en IAM-rolle for SageMaker for dataforskeren (dataforskeren), som brukes som den tilsvarende brukerprofilens utførelsesrolle.
    1. Til Rollenavn, navngi rollen SageMakerStudioExecutionRole_data-scientist.
    2. Til Tags, legg til nøkkelbrukerprofilnavnet og verdidataforskeren.
    3. Velg Skape rolle.
    4. For å legge til de gjenværende policyene, på Roller side, velg rollenavnet du nettopp opprettet.
    5. Under Tillatelser, fjern policyen AmazonSageMakerFullAccess.
    6. På Legg ved tillatelsespolicy siden, velg den AWS-administrerte policyen AwsGlueSessionUserRestrictedServiceRole og den kundeadministrerte policyen SageMakerExecutionPolicy som du opprettet.
    7. Velg Legg ved retningslinjer.
    8. endre din rolles tillitsforhold:
    {
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":[
               "glue.amazonaws.com",
               "sagemaker.amazonaws.com"
            ]
         },
         "Action":"sts:AssumeRole"
      }
   ]
}

Konfigurer SageMaker-brukerprofiler

For å lage dine SageMaker-brukerprofiler med studiouserid tag, fullfør følgende trinn:

  1. Bruk AWS CLI eller CloudShell for å opprette Studio-brukerprofilen for dataingeniøren (oppgi konto-ID og Studio-domene-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

  2. Gjenta trinnet for å opprette en brukerprofil for dataforskeren, og erstatte konto-ID og Studio-domene-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

Opprett S3-bøtter og last opp eksempeldatasettet

I denne delen lager du to S3-bøtter. Den første bøtten har et eksempeldatasett relatert til nettmarkedsføring. Den andre bøtten brukes av dataforskeren til å lagre utdata fra funksjonsingeniøroppgaver, og dette utdatasettet brukes til å trene ML-modellen.

Opprett først S3-bøtten for inngangsdataene:

  1. Last ned datasettet.
  2. Velg på Amazon S3-konsollen Bøtter i navigasjonsruten.
  3. Velg Lag bøtte.
  4. Til Region, velg regionen med SageMaker-domenet som inkluderer brukerprofilene du opprettet.
  5. Til Bøtte navn, Tast inn blog-studio-pii-dataset-.
  6. Velg Lag bøtte.
  7. Velg bøtten du opprettet og velg Last opp.
  8. på Velg filer delen velger Legg til filer og last opp datasettet du lastet ned.
    Nå lager du bøtten for utdataene:
  9. På Bøtter side, velg Lag bøtte.
  10. Til Region, velg regionen med SageMaker-domenet som inkluderer brukerprofilene du opprettet.
  11. Til Bøtte navn, Tast inn blog-studio-output-.
  12. Velg Lag bøtte.

Lag en AWS Glue database og tabell

I denne delen oppretter du en AWS Glue-database og tabell for datasettet.

  1. På Lake Formation-konsollen, under Datakatalog Velg navigasjonsruten databaser.
  2. Velg Legg til database.
  3. Til Navn, skriv inn demo.
  4. Velg Lag database.
  5. Under Datakatalog, velg tabeller.
  6. Til Navn, Tast inn web_marketing.
  7. Til Database, plukke ut demo.
  8. Til Inkluder bane, skriv inn banen til S3-bøtten din for inndata.
  9. Til Klassifisering, velg CSV.
  10. Under Skjema, velg Last opp skjema.
  11. Skriv inn 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"
   }
]

  12. Velg Last opp.
  13. Velg Send.
  14. Under Tabelldetaljer, velg Rediger tabell.
  15. Under Tabellegenskaper, velg Legg til.
  16. Til nøkkel, Tast inn skip.header.line.count, Og for Verdi, skriv inn 1.
  17. Velg Spar.

Konfigurer Lake Formation-tillatelser

I denne delen konfigurerer du Lake Formation-tillatelser for å tillate IAM-rolle SageMakerStudioExecutionRole_data-engineer å opprette en database og registrere S3-lokasjonen i Lake Formation.

Først registrerer du datainnsjøplasseringen for å administrere tabeller under plasseringen i Lake Formation-tillatelser:

  1. Velg Data lake steder.
  2. Velg Registrer sted.
  3. Til Amazon S3-bane, Tast inn s3://blog-studio-pii-dataset-/ (bøtten som inneholder datasettet).
  4. Velg Registrer sted.
    Nå gir du Lake Formation-database- og tabelltillatelser til IAM-rollene SageMakerStudioExecutionRole_data-engineer og SageMakerStudioExecutionRole_data-scientist.Gi først databasetillatelse for SageMakerStudioExecutionRole_data-engineer:
  5. Under Tillatelser, velg Datainnsjø-tillatelser.
  6. Under Datatillatelse, velg Grant.
  7. Til Rektorer, velg IAM-brukere og roller, og velg rollen SageMakerStudioExecutionRole_data-engineer.
  8. Til Retningslinjer eller katalogressurser, velg Navngitte datakatalogressurser.
  9. Til databaser, velg demo.
  10. Til Database tillatelser, velg Super.
  11. Velg Grant.
    Deretter gir du tabelltillatelse for SageMakerStudioExecutionRole_data-engineer:
  12. Under Datatillatelse, velg Grant.
  13. Til Rektorer, velg IAM-brukere og roller, og velg rollen SageMakerStudioExecutionRole_data-engineer.
  14. Til Retningslinjer eller katalogressurser, velg Navngitte datakatalogressurser.
  15. Til databaser, velg demo.
  16. Til tabeller, velg web_marketing.
  17. Til Bord tillatelser, velg Super.
  18. Til Innvilgende tillatelser, velg Super.
  19. Velg Grant.
    Til slutt, gi databasetillatelse for SageMakerStudioExecutionRole_data-scientist:
  20. Under Datatillatelse, velg Grant.
  21. Til Rektorer, velg IAM-brukere og roller, og velg rollen SageMakerStudioExecutionRole_data-scientist.
  22. Til Retningslinjer eller katalogressurser, velg Navngitte datakatalogressurser.
  23. Til databaser, velg demo.
  24. Til Database tillatelser, velg Beskriv.
  25. Velg Grant.

Om forfatterne

Storskala funksjonsteknikk med sensitiv databeskyttelse ved hjelp av interaktive AWS Glue-sesjoner og Amazon SageMaker Studio PlatoBlockchain Data Intelligence. Vertikalt søk. Ai.

Praveen Kumar er en Analytics Solution Architect hos AWS med ekspertise i å designe, bygge og implementere moderne data- og analyseplattformer ved bruk av skybaserte tjenester. Hans interesseområder er serverløs teknologi, moderne skydatavarehus, streaming og ML-applikasjoner.

Storskala funksjonsteknikk med sensitiv databeskyttelse ved hjelp av interaktive AWS Glue-sesjoner og Amazon SageMaker Studio PlatoBlockchain Data Intelligence. Vertikalt søk. Ai.

Noritaka Sekiyama er en rektor Big Data Architect i AWS Glue-teamet. Han liker å samarbeide med forskjellige team for å levere resultater som dette innlegget. På fritiden liker han å spille videospill med familien.

Tidstempel:

Mer fra AWS maskinlæring