Suuremahuline funktsioonide projekteerimine koos tundliku andmekaitsega, kasutades AWS Glue interaktiivseid seansse ja Amazon SageMaker Studio PlatoBlockchain Data Intelligence'i. Vertikaalne otsing. Ai.

Suuremahuline funktsioonide projekteerimine koos tundliku andmekaitsega, kasutades AWS Glue interaktiivseid seansse ja Amazon SageMaker Studio

Ajatempel: 17. november 2022 11:35

Organisatsioonid kasutavad masinõppe (ML) ja AI-teenuseid, et parandada kliendikogemust, vähendada tegevuskulusid ja avada uusi võimalusi äritulemuste parandamiseks. Andmed on ML ja AI kasutusjuhtumite aluseks ning on organisatsiooni strateegiline väärtus. Kuna andmed kasvavad eksponentsiaalse kiirusega, soovivad organisatsioonid luua integreeritud, kulutõhusa ja tõhusa andmeplatvormi andmete eeltöötlemiseks, funktsioonide projekteerimiseks ning ML-mudelite mastaabis ehitamiseks, koolitamiseks ja kasutuselevõtuks. Selle saavutamiseks pakub AWS ühtset kaasaegset andmeplatvormi, mille toiteallikaks on Amazoni lihtne salvestusteenus (Amazon S3) kui andmejärv koos spetsiaalselt loodud tööriistade ja töötlemismootoritega, mis toetavad analüütikat ja ML töökoormust. Ühtse ML-kogemuse saamiseks võite kasutada Amazon SageMaker Studio, mis pakub natiivne integratsioon AWS Glue interaktiivsete seanssidega funktsioonide kavandamiseks ulatuslikult tundliku andmekaitsega. Selles postituses näitame, kuidas seda lahendust rakendada.

Amazon SageMaker on täielikult hallatav ML-teenus, mis võimaldab teil luua, koolitada ja juurutada mudeleid laias valikus kasutusjuhtudel. Mudelitreeningu jaoks saate kasutada mis tahes sisseehitatud algoritmid SageMakeris, et alustada koolitamist ja ML-mudelite kiiret juurutamist.

Mudeli loomise ja arendamise protsessi põhikomponent on funktsioonide projekteerimine. AWS liim on üks soovitatavatest valikutest funktsioonide laiaulatusliku projekteerimise saavutamiseks. AWS Glue võimaldab teil käitada andmete integreerimist ja teisendamist hajutatud viisil serverita Apache Sparki infrastruktuuris ning muudab populaarse Spark ML teegi kasutamise funktsioonide projekteerimiseks ja mudelite arendamiseks lihtsaks. Lisaks saate AWS Glue'i kasutada andmete järkjärguliseks töötlemiseks töö järjehoidjad, neelavad andmeid enam kui 100 allikast, kasutades ühendused, ja käitage kasutades teravat või ettearvamatut töökoormust automaatne skaleerimine.

Teine oluline nõue ML-põhistele rakendustele on andmete turvalisus ja juurdepääsu kontroll. Üldine nõue on omada rangemat kontrolli selle üle, kes pääseb ligi kõige tundlikumatele andmetele funktsioonide projekteerimise ja mudelite loomise protsessi osana, järgides vähimate privileegidega juurdepääsu põhimõtet. Selle saavutamiseks saate kasutada AWS-liimi integreerimist AWS järve kihistu andmejärve varade paremaks juhtimiseks ja haldamiseks. Lake Formationiga saate oma Amazon S3 andmejärve peal konfigureerida täpset andmetele juurdepääsu juhtimist ja turvapoliitikat. Reeglid on määratletud keskses asukohas, mis võimaldab kasutada mitut analüüsi- ja ML-teenust, nagu AWS Glue, Amazonase Athenaja SageMaker, et suhelda Amazon S3-sse salvestatud andmetega.

AWS-liim sisaldab a isikut tuvastava teabe (PII) tuvastamine teisendus, mis võimaldab vastavalt vajadusele tuvastada, maskeerida või eemaldada üksusi, et suurendada vastavust ja juhtimist. PII-teisendusega saate tuvastada andmekogumites PII-andmeid ja rakendada Lake Formationi abil automaatselt täpset juurdepääsukontrolli, et piirata tundlikke andmeid erinevate kasutajarühmade jaoks.

Kasutusjuhtum

Keskendume kalduvusmudeli kasutusjuhtumile, mis sisaldab klienditurunduse andmestikku ja hõlmab kahte kasutajaisikut: andmeinseneri ja andmeteadlast. Andmekogum sisaldab teavet kliendi kohta, sealhulgas müügivihje allikat, kontaktmärkmeid, töörolli, mõningaid lippe, lehevaatamisi külastuse kohta ja palju muud. Andmekogum sisaldab ka tundlikku teavet, nagu isiklikud telefoninumbrid.

Andmeinsener vastutab täieliku andmetöötluskonveieri ülesehitamise eest, sealhulgas andmete ettevalmistamise, eeltöötluse ja juurdepääsukontrolli eest. Andmeteadlane vastutab funktsioonide projekteerimise ning ML-mudeli väljaõppe ja juurutamise eest. Pange tähele, et andmeteadlasel ei ole lubatud funktsioonide projekteerimiseks või ML-mudeli koolitamiseks juurde pääseda tundlikele isikuandmete tuvastamise andmetele.

Selle kasutusjuhtumi osana koostab andmeinsener andmestiku eeltöötlemiseks andmekonveieri, skannib andmestikku mis tahes isikuandmete tuvastamiseks ja piirab PII veeru juurdepääsu andmeteadlase kasutajaga. Kui andmeteadlane kasutab andmestikku funktsioonide projekteerimiseks ja ML-mudelite koostamiseks, ei ole tal juurdepääsu isikuandmete tuvastamise tundlikule veerule (antud juhul telefoninumbritele). Funktsioonide projekteerimisprotsess hõlmab stringi tüüpi veergude teisendamist vormingusse, mis on ML-mudelite jaoks optimaalne. Täpsemalt saate seda juurdepääsumustrit laiendada, et rakendada Lake Formationi abil rea- ja rakutasemel turvet.

Lahenduse ülevaade

Lahendus sisaldab järgmisi kõrgetasemelisi samme:

  1. Seadistage ressursse kasutades AWS CloudFormation.
  2. Eeltöötlege andmestikku, sealhulgas isikuandmete tuvastamise ja täpse juurdepääsu kontrolli, AWS Glue'i interaktiivsel seansil.
  3. Tehke funktsioonide projekteerimine AWS Glue interaktiivsel seansil.
  4. Treenige ja juurutage ML-mudelit, kasutades SageMakeri sisseehitatud XGBoost algoritmi.
  5. Hinnake ML mudelit.

Järgnev diagramm illustreerib lahenduse arhitektuuri.

Eeldused

Selle õpetuse lõpetamiseks peavad teil olema järgmised eeltingimused.

Seadistage ressursse AWS CloudFormationiga

See postitus sisaldab kiireks seadistamiseks CloudFormationi malli. Saate selle üle vaadata ja oma vajadustele vastavaks kohandada. Kui eelistate ressursse seadistada AWS-i juhtimiskonsool ja AWS CLI asemel AWS CloudFormation, vaadake juhiseid selle postituse lõpus olevast lisast.

CloudFormationi mall loob järgmised ressursid.

Ressursside loomiseks toimige järgmiselt.

  1. Logige konsooli sisse.
  2. Vali Käivitage Stack:
    Käivitusnupp
  3. Vali järgmine.
  4. eest DataEngineerPwd ja DataScientistPwd, sisestage andmeinseneri ja andmeteadlase kasutajate jaoks oma parool.
  5. eest GlueDatabaseName, sisenema demo.
  6. eest Liimitabeli nimi, sisenema web_marketing.
  7. eest S3BucketNameForInput, sisenema blog-studio-pii-dataset-.
  8. eest S3BucketNameForOutput, sisenema blog-studio-output-.
  9. eest SageMakerDomainId, sisestage oma SageMakeri domeeni ID, mille koostasite eeltingimustoimingutes.
  10. Vali järgmine.
  11. Järgmisel lehel valige järgmine.
  12. Vaadake viimasel lehel üksikasjad üle ja valige Tunnistan, et AWS CloudFormation võib luua IAM-i ressursse.
  13. Vali Looma.

Virna loomine võib kesta kuni 10 minutit. Virn loob IAM-i rollid ja SageMakeri kasutajaprofiilid kahele isikule: andmeinsenerile ja andmeteadlasele. Samuti loob see andmebaasi demo ja tabeli web_marketing koos näidisandmestikuga.

Virna loomise ajal on andmeinseneri isikul täielik juurdepääs tabelile, kuid andmeteadlase isikul pole veel juurdepääsu tabelile.

Andmestiku eeltöötlemine

Alustame AWS Glue interaktiivse seansi andmete eeltöötlust. Andmeinsener soovib andmeid kontrollida, et näha, kas seal on tundlikke andmeid või mitte, ning anda andmeteadlase isikule minimaalse juurdepääsuloa. Märkmiku saate alla laadida aadressilt selles asukohas.

  1. Logige konsooli sisse andmeinseneriga.
  2. Valige SageMakeri konsoolil kasutajad.
  3. Valige andmeinseneri kasutaja ja valige Avage Studio.
  4. Looge uus märkmik ja valige SparkAnalytics 1.0 eest pilt ja Liimige PySpark eest Kernel.
  5. Boto3 uuema versiooni installimiseks alustage interaktiivset seanssi järgmise maagiaga (see on vajalik create_data_cells_filter meetod): 
    %additional_python_modules boto3==1.24.82

  6. Seansi käivitamine: 
    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. Looge vastloodud tabelist AWS Glue DynamicFrame ja lahendada valikutüübid kataloogiskeemi alusel, kuna soovime andmete põhjal automaatselt järeldatava skeemi asemel kasutada kataloogis määratletud skeemi: 
    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. Kontrollige tabelis, kas AWS Glue PII tuvastamise abil on PII-andmeid: 
    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. Kontrollige, kas PII-deks liigitatud veerud sisaldavad tundlikke andmeid või mitte (kui mitte, värskendage mittetundlike veergude eemaldamiseks kaarti Classified_map): 
    from pyspark.sql.functions import col
dyf_marketing_resolved.toDF().select(*[col(c) for c in classified_map.keys()]).show()

  10. Seadistage Lake Formationi load automaatselt tuvastatud veergude jaoks andmerakkude filtri abil ja piirake veerud andmeteadlase isikuga. 
    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. Logige Studiosse sisse andmeteadlasena, et näha, kas isikuandmete tuvastamise veerud pole nähtavad. Märkmiku saate alla laadida aadressilt selles asukohas.
  12. Looge uus märkmik ja valige SparkAnalytics 1.0 eest pilt ja Liimige PySpark eest 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()

Tehke funktsioonide projekteerimine

Kasutame Apache Spark ML teeki funktsioonide projekteerimiseks andmeteadlase kasutajana ja kirjutame seejärel väljundi tagasi Amazon S3-sse.

  1. Järgmises lahtris rakendame funktsioone alates Apache Spark ML teek:
    • StringIndexer vastendab siltide stringiveeru sildiindeksite veeruks.
    • OneHotEncoder kaardistab kategoorilise tunnuse, mis on esitatud sildiindeksina, binaarvektoriks, millel on kõige rohkem üks väärtus, mis näitab konkreetse kategoorilise tunnuse olemasolu. Seda teisendust kasutatakse ML-algoritmide jaoks, mis eeldavad pidevaid funktsioone.
    • VectorAssembler on trafo, mis ühendab etteantud veergude loendi üheks vektoriveeruks, mida seejärel kasutatakse selliste algoritmide ML mudelite treenimisel nagu logistiline regressioon ja otsustuspuud.
    #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. Lõpliku teisendatud DataFrame'i saab luua Pipeline teegi abil. Konveier on määratud etappide jadana. Neid etappe käivitatakse järjekorras ja sisend DataFrame teisendatakse iga etapi läbimisel. 
    df_marketing = dyf_marketing.toDF()
pipeline = Pipeline(stages=indexers + encoders + [assembler])
df_tfm=pipeline.fit(df_marketing).transform(df_marketing)

  3. Järgmisena jagame andmestiku koolitamiseks, valideerime ja testime DataFrame'iks ning salvestame selle S3 ämbrisse, et treenida ML-mudelit (esitage oma AWS-i konto ID järgmises koodis): 
    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))

Treenige ja juurutage ML-mudel

Eelmises jaotises lõpetasime funktsioonide projekteerimise, mis hõlmas stringi veergude teisendamist, näiteks region, jobroleja usedpromo vormingusse, mis on ML-mudelite jaoks optimaalne. Lisasime ka veerud nagu pageviewspervisit ja totalwebvisits, mis aitab meil ennustada kliendi kalduvust toodet osta.

Koolitame nüüd ML-mudelit, lugedes rongi- ja valideerimisandmestikku, kasutades SageMakeri sisseehitatud XGBoost-algoritmi. Seejärel juurutame mudeli ja teostame täpsuse kontrolli. Märkmiku saate alla laadida aadressilt selles asukohas.

Järgmises lahtris loeme andmeid teisest S3 ämbrist, mis sisaldab meie funktsioonide projekteerimistoimingute väljundit. Seejärel kasutame mudeli koolitamiseks sisseehitatud algoritmi XGBoost.

  1. Avage uus märkmik. Vali andmed Science eest pilt ja Python 3 eest Kernel (esitage oma AWS-i konto ID järgmises koodis): 
    #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. Kui koolitus on lõppenud, saame mudeli juurutada, kasutades SageMakeri hostimisteenuseid: 
    #deploy ml model
xgb_predictor = xgb.deploy(initial_instance_count=1,
instance_type='ml.m4.xlarge')

Hinnake ML mudelit

Kasutame katseandmestikku, et hinnata mudelit ja kustutada järelduse lõpp-punkt, kui oleme lõpetanud, et vältida jooksvaid tasusid.

  1. Hinnake mudelit järgmise koodiga: 
    #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))

    Proovisõidu täpsus oli 84.6%. See võib teie jooksu puhul andmestiku juhusliku jaotuse tõttu pisut erineda.

  2. Saame järelduse lõpp-punkti kustutada järgmise koodiga: 
    xgb_predictor.delete_endpoint(delete_endpoint_config=True)

Koristage

Nüüd viimase sammu juurde, ressursside puhastamiseks.

  1. Tühjendage kaks CloudFormationi virna kaudu loodud ämbrit.
  2. Kustutage kasutajaga seotud rakendused profiles data-scientist ja data-engineer Stuudio sees.
  3. Kustutage CloudFormationi virn.

Järeldus

Selles postituses demonstreerisime lahendust, mis võimaldab sellistel isikutel nagu andmeinsenerid ja andmeteadlased funktsioonide projekteerimist ulatuslikult teostada. AWS Glue'i interaktiivsete seanssidega saate hõlpsasti saavutada funktsioonide projekteerimise mastaabis automaatse PII tuvastamise ja täpse juurdepääsukontrolliga, ilma et peaksite haldama alusinfrastruktuuri. Kasutades Studiot ühtse sisestuspunktina, saate lihtsustatud ja integreeritud kogemuse täieliku ML-i töövoo loomiseks: alates andmete ettevalmistamisest ja turvamisest kuni ML-mudelite loomise, koolitamise, häälestamise ja juurutamiseni. Lisateabe saamiseks külastage AWS Glue interaktiivsete seanssidega alustamine ja Amazon SageMaker Studio.

Oleme selle uue võimaluse üle väga põnevil ja ootame huviga, mida te sellega ehitate!

Lisa: seadistage ressursse konsooli ja AWS-i CLI kaudu

Ressursside seadistamiseks CloudFormationi malli asemel konsooli ja AWS-i CLI abil täitke selles jaotises olevad juhised.

Eeldused

Selle õpetuse lõpetamiseks peab teil olema juurdepääs AWS-i CLI-le (vt AWS-i CLI-ga alustamine) või kasutage käsurea juurdepääsu aadressilt AWS CloudShell.

IAM-rühma, kasutajate, rollide ja poliitikate seadistamine

Selles jaotises loome kaks IAM-i kasutajat: data-insener ja data-scientist, mis kuuluvad IAM-i rühma data-platform-group. Seejärel lisame IAM-rühma ühe IAM-poliitika.

  1. IAM-konsoolis looge vahekaardil JSON reegel uue IAM-i hallatava poliitika loomiseks nimega DataPlatformGroupPolicy. Reegel lubab rühma kuuluvatel kasutajatel Studiole juurde pääseda, kuid ainult SageMakeri kasutajaprofiili kasutades, mille märgend vastab nende IAM-i kasutajanimele. Lubade andmiseks kasutage järgmist JSON-i poliitikadokumenti. 
    {
   "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. Looge IAM-rühm kutsutud data-platform-group.
  3. Otsige ja lisage rühmale AWS-i hallatav reegel nimega DataPlatformGroupPolicy.
  4. Looge IAM-i kasutajad nimetatakse andmeinseneriks ja andmeteadlaseks IAM-i rühma andmeplatvorm-rühma all.
  5. Looge uus hallatud eeskiri nimega SageMakerExecutionPolicy (esitage oma regioon ja konto ID järgmises koodis): 
    {
   "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. Looge uus hallatud eeskiri nimetatud 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. Looge IAM-i roll SageMaker jaoks andmeinsenerile (data-engineer), mida kasutatakse vastava kasutajaprofiili täitmisrollina. peal Manustage lubade eeskirjad lehel on vaikimisi lisatud AmazonSageMakerFullAccess (AWS-i hallatav reegel). Minimaalsete õiguste säilitamiseks eemaldate selle reegli hiljem.
    1. eest Rolli nimi, kasutage rollile SageMakerStudioExecutionRole_data-engineer nimetamiseks selle jaotise alguses tutvustatud nimetamistava.
    2. eest Sildid, lisage võtme kasutajaprofiilinimi ja väärtus data-engineer.
    3. Vali Loo roll.
    4. Ülejäänud poliitikate lisamiseks klõpsake rollid lehel, valige just loodud rolli nimi.
    5. alla Õigused, eemaldage poliitika AmazonSageMakerFullAccess.
    6. Kohta Manustage lubade eeskirjad lehel valige AWS-i hallatav reegel AwsGlueSessionUserRestrictedServiceRole ja kliendi hallatavad eeskirjad SageMakerExecutionPolicy ja SageMakerAdminPolicy, mille olete loonud.
    7. Vali Manustage eeskirjad.
    8. muutma teie rolli usaldussuhe:
    {
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":[
               "glue.amazonaws.com",
               "sagemaker.amazonaws.com"
            ]
         },
         "Action":"sts:AssumeRole"
      }
   ]
}

  8. Looge IAM-i roll SageMaker jaoks andmeteadlase (data-scientist) jaoks, mida kasutatakse vastava kasutajaprofiili täitmisrollina.
    1. eest Rolli nimi, nimetage rollile SageMakerStudioExecutionRole_data-scientist.
    2. eest Sildid, lisage võtme kasutajaprofiilinimi ja väärtusteadlane.
    3. Vali Loo roll.
    4. Ülejäänud poliitikate lisamiseks klõpsake rollid lehel, valige just loodud rolli nimi.
    5. alla Õigused, eemaldage poliitika AmazonSageMakerFullAccess.
    6. Kohta Manustage lubade eeskirjad lehel valige AWS-i hallatav reegel AwsGlueSessionUserRestrictedServiceRole ja teie loodud kliendi hallatav reegel SageMakerExecutionPolicy.
    7. Vali Manustage eeskirjad.
    8. muutma teie rolli usaldussuhe:
    {
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":[
               "glue.amazonaws.com",
               "sagemaker.amazonaws.com"
            ]
         },
         "Action":"sts:AssumeRole"
      }
   ]
}

SageMakeri kasutajaprofiilide seadistamine

SageMakeri kasutajaprofiilide loomiseks rakendusega studiouserid silt, tehke järgmised sammud:

  1. Kasutage andmeinsenerile Studio kasutajaprofiili loomiseks AWS CLI-d või CloudShelli (esitage oma konto ID ja Studio domeeni ID järgmises koodis): 
    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. Korrake samme, et luua andmeteadlasele kasutajaprofiil, asendades konto ID ja Studio domeeni 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

Looge S3 ämbrid ja laadige üles näidisandmekogum

Selles jaotises loote kaks S3 ämbrit. Esimeses ämbris on veebiturundusega seotud näidisandmekogum. Teist ämbrit kasutab andmeteadlane funktsioonide projekteerimise ülesannete väljundi salvestamiseks ja seda väljundandmestikku kasutatakse ML-mudeli koolitamiseks.

Esmalt looge sisendandmete jaoks S3 ämber:

  1. Lae andmestik.
  2. Amazon S3 konsoolil valige Kopad navigeerimispaanil.
  3. Vali Loo ämber.
  4. eest regioon, valige SageMakeri domeeniga piirkond, mis sisaldab teie loodud kasutajaprofiile.
  5. eest Ämbri nimi, sisenema blog-studio-pii-dataset-.
  6. Vali Loo ämber.
  7. Valige loodud ämber ja valige Täiendava.
  8. aasta Valige failid Valige jaotises Lisa failid ja laadige alla laaditud andmestik üles.
    Nüüd loote väljundandmete jaoks ämbri:
  9. Kohta Kopad lehel, valige Loo ämber.
  10. eest regioon, valige SageMakeri domeeniga piirkond, mis sisaldab teie loodud kasutajaprofiile.
  11. eest Ämbri nimi, sisenema blog-studio-output-.
  12. Vali Loo ämber.

Looge AWS Glue'i andmebaas ja tabel

Selles jaotises loote andmekogumi jaoks AWS Glue'i andmebaasi ja tabeli.

  1. Lake Formationi konsoolil, all Andmekataloog valige navigeerimispaanil Andmebaasid.
  2. Vali Lisa andmebaas.
  3. eest Nimi, sisestage demo.
  4. Vali Loo andmebaas.
  5. alla Andmekataloog, vali Tabelid.
  6. eest Nimi, sisenema web_marketing.
  7. eest andmebaasvalige demo.
  8. eest Kaasa tee, sisestage sisendandmete jaoks oma S3 ämbri tee.
  9. eest Klassifikatsioon, vali CSV.
  10. alla Skeem, vali Laadige skeem üles.
  11. Sisestage tekstikasti järgmine JSON-massiv: 
    [
   {
      "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. Vali Täiendava.
  13. Vali LIITU.
  14. alla Tabeli üksikasjad, vali Redigeeri tabelit.
  15. alla Tabeli omadused, vali lisama.
  16. eest Võti, sisenema skip.header.line.countNing Väärtus, sisestage 1.
  17. Vali Säästa.

Seadistage Lake Formationi õigused

Selles jaotises seadistate IAM-i rolli lubamiseks Lake Formationi õigused SageMakerStudioExecutionRole_data-engineer andmebaasi loomiseks ja S3 asukoha registreerimiseks Lake Formationis.

Esmalt registreerige andmejärve asukoht, et hallata tabeleid Lake Formationi lubade asukoha all:

  1. Vali Andmejärvede asukohad.
  2. Vali Registreeri asukoht.
  3. eest Amazon S3 tee, sisenema s3://blog-studio-pii-dataset-/ (salv, mis sisaldab andmestikku).
  4. Vali Registreeri asukoht.
    Nüüd annate IAM-i rollidele Lake Formationi andmebaasi ja tabeli õigused SageMakerStudioExecutionRole_data-engineer ja SageMakerStudioExecutionRole_data-scientist.Esmalt andke andmebaasi luba SageMakerStudioExecutionRole_data-engineer:
  5. alla Õigused, vali Andmejärve load.
  6. alla Andmete luba, vali Grant.
  7. eest Direktorid, vali IAM-i kasutajad ja rollidja valige roll SageMakerStudioExecutionRole_data-engineer.
  8. eest Poliitikasildid või kataloogiressursid, vali Nimetatud andmekataloogi ressursid.
  9. eest Andmebaasid, vali demo.
  10. eest Andmebaasi õigused, valima super.
  11. Vali Grant.
    Järgmisena andke tabeli luba SageMakerStudioExecutionRole_data-engineer:
  12. alla Andmete luba, vali Grant.
  13. eest Direktorid, vali IAM-i kasutajad ja rollidja valige roll SageMakerStudioExecutionRole_data-engineer.
  14. eest Poliitikasildid või kataloogiressursid, vali Nimetatud andmekataloogi ressursid.
  15. eest Andmebaasid, vali demo.
  16. eest Tabelid, vali web_marketing.
  17. eest Tabel õigused, valima super.
  18. eest Lubatav õigused, valima super.
  19. Vali Grant.
    Lõpuks andke andmebaasi luba SageMakerStudioExecutionRole_data-scientist:
  20. alla Andmete luba, vali Grant.
  21. eest Direktorid, vali IAM-i kasutajad ja rollidja valige roll SageMakerStudioExecutionRole_data-scientist.
  22. eest Poliitikasildid või kataloogiressursid, vali Nimetatud andmekataloogi ressursid.
  23. eest Andmebaasid, vali demo.
  24. eest Andmebaasi õigused, valima Kirjeldama.
  25. Vali Grant.

Autoritest

Suuremahuline funktsioonide projekteerimine koos tundliku andmekaitsega, kasutades AWS Glue interaktiivseid seansse ja Amazon SageMaker Studio PlatoBlockchain Data Intelligence'i. Vertikaalne otsing. Ai.

Praveen Kumar on AWS-i analüüsilahenduste arhitekt, kellel on teadmised kaasaegsete andme- ja analüüsiplatvormide kavandamisel, ehitamisel ja juurutamisel, kasutades pilvepõhiseid teenuseid. Tema huvialad on serverivaba tehnoloogia, kaasaegsed pilvandmelaod, voogedastus ja ML-rakendused.

Suuremahuline funktsioonide projekteerimine koos tundliku andmekaitsega, kasutades AWS Glue interaktiivseid seansse ja Amazon SageMaker Studio PlatoBlockchain Data Intelligence'i. Vertikaalne otsing. Ai.

Noritaka Sekiyama on AWS Glue meeskonna peamine suurandmete arhitekt. Talle meeldib teha koostööd erinevate meeskondadega, et saavutada selliseid tulemusi nagu see postitus. Vabal ajal meeldib talle perega videomänge mängida.

Ajatempel:

Veel alates AWS-i masinõpe