Inżynieria funkcji na dużą skalę z ochroną wrażliwych danych przy użyciu interaktywnych sesji AWS Glue i Amazon SageMaker Studio PlatoBlockchain Data Intelligence. Wyszukiwanie pionowe. AI.

Inżynieria funkcji na dużą skalę z ochroną wrażliwych danych przy użyciu interaktywnych sesji AWS Glue i Amazon SageMaker Studio

Znacznik czasu: 17 listopada 2022 11:35

Organizacje korzystają z usług uczenia maszynowego (ML) i sztucznej inteligencji, aby poprawić jakość obsługi klienta, obniżyć koszty operacyjne i odblokować nowe możliwości poprawy wyników biznesowych. Dane stanowią podstawę przypadków użycia ML i AI i są strategicznym zasobem organizacji. Ponieważ dane rosną w tempie wykładniczym, organizacje chcą stworzyć zintegrowaną, opłacalną i wydajną platformę danych w celu wstępnego przetwarzania danych, przeprowadzania inżynierii funkcji oraz budowania, trenowania i operacjonalizacji modeli uczenia maszynowego na dużą skalę. Aby to osiągnąć, AWS oferuje ujednoliconą, nowoczesną platformę danych, która jest obsługiwana przez Usługa Amazon Simple Storage (Amazon S3) jako jezioro danych ze specjalnie zaprojektowanymi narzędziami i silnikami przetwarzania do obsługi obciążeń analitycznych i uczenia maszynowego. Aby uzyskać ujednolicone środowisko uczenia maszynowego, możesz użyć Studio Amazon SageMaker, Który oferuje natywna integracja z sesjami interaktywnymi AWS Glue do wykonywania inżynierii funkcji na dużą skalę z ochroną wrażliwych danych. W tym poście pokazujemy, jak wdrożyć to rozwiązanie.

Amazon Sage Maker to w pełni zarządzana usługa uczenia maszynowego, która umożliwia budowanie, trenowanie i wdrażanie modeli na dużą skalę dla szerokiego zakresu przypadków użycia. Do szkolenia modeli można użyć dowolnego z wbudowane algorytmy w SageMaker, aby szybko rozpocząć szkolenie i wdrażanie modeli ML.

Kluczowym elementem procesu budowy i rozwoju modelu jest inżynieria cech. Klej AWS jest jedną z zalecanych opcji umożliwiających osiągnięcie inżynierii cech na dużą skalę. AWS Glue umożliwia integrację i transformację danych w sposób rozproszony w bezserwerowej infrastrukturze Apache Spark i ułatwia korzystanie z popularnej biblioteki Spark ML do inżynierii funkcji i tworzenia modeli. Ponadto możesz użyć AWS Glue do przyrostowego przetwarzania danych zakładki pracy, pozyskuj dane z ponad 100 źródeł za pomocą złączai uruchamiaj kolczaste lub nieprzewidywalne obciążenia za pomocą automatyczne skalowanie.

Kolejnym ważnym wymogiem dla aplikacji opartych na ML jest bezpieczeństwo danych i kontrola dostępu. Powszechnym żądaniem jest ściślejsza kontrola nad tym, kto może uzyskać dostęp do najbardziej wrażliwych danych w ramach procesu inżynierii funkcji i budowania modelu, zgodnie z zasadą dostępu o najniższych uprawnieniach. Aby to osiągnąć, możesz skorzystać z integracji AWS Glue z Formacja AWS Lake w celu lepszego nadzoru i zarządzania zasobami jezior danych. Dzięki Lake Formation możesz skonfigurować szczegółową kontrolę dostępu do danych i zasady bezpieczeństwa na swoim jeziorze danych Amazon S3. Polityki są zdefiniowane w centralnej lokalizacji, co pozwala na korzystanie z wielu usług analitycznych i ML, takich jak AWS Glue, Amazonka Atenai SageMaker do interakcji z danymi przechowywanymi w Amazon S3.

Klej AWS zawiera wykrywanie danych osobowych (PII). transform, która zapewnia możliwość wykrywania, maskowania lub usuwania jednostek zgodnie z wymaganiami w celu zwiększenia zgodności i zarządzania. Dzięki transformacji PII możesz wykrywać dane PII w zestawach danych i automatycznie stosować szczegółową kontrolę dostępu za pomocą Lake Formation, aby ograniczyć poufne dane do różnych grup użytkowników.

Przypadek użycia

Skupiamy się na przypadku użycia modelu skłonności, który obejmuje zestaw danych marketingowych klienta i obejmuje dwie osobowości użytkowników: inżyniera danych i naukowca danych. Zbiór danych zawiera informacje o poszczególnych klientach, w tym źródło potencjalnych klientów, notatki kontaktowe, stanowisko, niektóre flagi, wyświetlenia stron na wizytę i inne. Zbiór danych zawiera również poufne informacje, takie jak osobiste numery telefonów.

Inżynier danych jest odpowiedzialny za zbudowanie kompleksowego potoku przetwarzania danych, w tym przygotowanie danych, wstępne przetwarzanie i kontrolę dostępu. Analityk danych jest odpowiedzialny za inżynierię funkcji oraz szkolenie i wdrażanie modelu ML. Należy pamiętać, że analityk danych nie ma dostępu do żadnych wrażliwych danych umożliwiających identyfikację użytkownika w celu inżynierii funkcji lub szkolenia modelu uczenia maszynowego.

W ramach tego przypadku użycia inżynier danych buduje potok danych w celu wstępnego przetworzenia zestawu danych, skanuje zestaw danych pod kątem informacji umożliwiających identyfikację użytkownika i ogranicza dostęp do kolumny PII do użytkownika analityka danych. W rezultacie, gdy analityk danych używa zestawu danych do wykonywania inżynierii funkcji i tworzenia modeli uczenia maszynowego, nie ma dostępu do kolumny wrażliwej na dane osobowe (w tym przypadku numerów telefonów). Proces inżynierii funkcji obejmuje konwersję kolumn typu string do formatu optymalnego dla modeli ML. Jako zaawansowany przypadek użycia możesz rozszerzyć ten wzorzec dostępu, aby zaimplementować zabezpieczenia na poziomie wiersza i komórki za pomocą Lake Formation.

Omówienie rozwiązania

Rozwiązanie zawiera następujące kroki wysokiego poziomu:

  1. Skonfiguruj zasoby za pomocą Tworzenie chmury AWS.
  2. Wstępne przetwarzanie zestawu danych, w tym wykrywanie danych osobowych i szczegółowa kontrola dostępu, w interaktywnej sesji AWS Glue.
  3. Wykonaj inżynierię funkcji w interaktywnej sesji AWS Glue.
  4. Trenuj i wdrażaj model ML przy użyciu wbudowanego algorytmu XGBoost SageMaker.
  5. Oceń model ML.

Poniższy schemat ilustruje architekturę rozwiązania.

Wymagania wstępne

Aby ukończyć ten samouczek, musisz spełnić następujące wymagania wstępne:

Skonfiguruj zasoby za pomocą AWS CloudFormation

Ten post zawiera szablon CloudFormation do szybkiej konfiguracji. Możesz go przejrzeć i dostosować do swoich potrzeb. Jeśli wolisz konfigurować zasoby w Konsola zarządzania AWS i AWS CLI zamiast AWS CloudFormation, zobacz instrukcje w dodatku na końcu tego wpisu.

Szablon CloudFormation generuje następujące zasoby:

  • Zasobniki S3 z przykładowym zestawem danych
  • An AWS Lambda funkcja do załadowania zestawu danych
  • AWS Zarządzanie tożsamością i dostępem (IAM), użytkowników, ról i zasad
  • Ustawienia i uprawnienia jeziora danych formacji jeziora
  • Profile użytkowników SageMakera

Aby utworzyć zasoby, wykonaj następujące czynności:

  1. Zaloguj się do konsoli.
  2. Dodaj Uruchom stos:
    Przycisk uruchamiania
  3. Dodaj Następna.
  4. W razie zamówieenia projektu Inżynier danychPwd i DataScientistPwd, wprowadź własne hasło dla użytkowników inżyniera danych i analityka danych.
  5. W razie zamówieenia projektu Nazwa bazy danych kleju, wchodzić demo.
  6. W razie zamówieenia projektu NazwaTabeli Kleju, wchodzić web_marketing.
  7. W razie zamówieenia projektu Nazwa zasobnika S3Dla danych wejściowych, wchodzić blog-studio-pii-dataset-.
  8. W razie zamówieenia projektu Nazwa zasobnika S3 dla danych wyjściowych, wchodzić blog-studio-output-.
  9. W razie zamówieenia projektu SageMakerDomainId, wprowadź swój identyfikator domeny SageMaker, który przygotowałeś w krokach wymagań wstępnych.
  10. Dodaj Następna.
  11. Na następnej stronie wybierz Następna.
  12. Przejrzyj szczegóły na ostatniej stronie i wybierz Przyjmuję do wiadomości, że AWS CloudFormation może tworzyć zasoby IAM.
  13. Dodaj Stwórz.

Tworzenie stosu może zająć do 10 minut. Stos tworzy role IAM i profile użytkowników SageMaker dla dwóch osób: inżyniera danych i naukowca danych. Tworzy również demo bazy danych i tabelę web_marketing z przykładowym zestawem danych.

W momencie tworzenia stosu osoba inżyniera danych ma pełny dostęp do tabeli, ale osoba naukowca danych nie ma jeszcze żadnego dostępu do tabeli.

Wstępnie przetwórz zestaw danych

Zacznijmy wstępne przetwarzanie danych w interaktywnej sesji AWS Glue. Osoba inżyniera danych chce zweryfikować dane, aby zobaczyć, czy istnieją dane wrażliwe, czy nie, i przyznać minimalne uprawnienia dostępu osobie naukowca danych. Możesz pobrać notatnik z Ta lokalizacja.

  1. Zaloguj się do konsoli przy użyciu użytkownika inżyniera danych.
  2. W konsoli SageMaker wybierz użytkownicy.
  3. Wybierz użytkownika inżyniera danych i wybierz Otwórz studio.
  4. Utwórz nowy notatnik i wybierz SparkAnalytics 1.0 dla Obraz i Klej PySpark dla Jądro.
  5. Rozpocznij interaktywną sesję z następującą magią, aby zainstalować nowszą wersję Boto3 (jest to wymagane do korzystania z create_data_cells_filter metoda): 
    %additional_python_modules boto3==1.24.82

  6. Zainicjuj sesję: 
    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. Utwórz AWS Glue DynamicFrame z nowo utworzonej tabeli i rozwiązać typy wyborów na podstawie schematu katalogowego, ponieważ chcemy użyć schematu zdefiniowanego w katalogu zamiast automatycznie wywnioskowanego schematu na podstawie danych: 
    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. Sprawdź w tabeli, czy są jakieś dane PII za pomocą wykrywania AWS Glue PII: 
    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. Sprawdź, czy kolumny sklasyfikowane jako PII zawierają dane wrażliwe, czy nie (jeśli nie, zaktualizuj klasyfikację_map, aby usunąć kolumny niewrażliwe): 
    from pyspark.sql.functions import col
dyf_marketing_resolved.toDF().select(*[col(c) for c in classified_map.keys()]).show()

  10. Skonfiguruj uprawnienia usługi Lake Formation przy użyciu filtra komórek danych dla automatycznie wykrywanych kolumn i ogranicz kolumny do osoby naukowca danych: 
    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. Zaloguj się do Studio jako analityk danych, aby zobaczyć, że kolumny umożliwiające identyfikację użytkownika nie są widoczne. Możesz pobrać notatnik z Ta lokalizacja.
  12. Utwórz nowy notatnik i wybierz SparkAnalytics 1.0 dla Obraz i Klej PySpark dla Jądro: 
    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()

Wykonaj inżynierię funkcji

Używamy biblioteki Apache Spark ML do wykonywania inżynierii funkcji jako użytkownik analityka danych, a następnie zapisujemy dane wyjściowe do Amazon S3.

  1. W następnej komórce stosujemy funkcje z Biblioteka Apache Spark ML:
    • StringIndexer odwzorowuje kolumnę łańcuchową etykiet na kolumnę indeksów etykiet.
    • OneHotEncoder odwzorowuje cechę jakościową, reprezentowaną jako indeks etykiety, na wektor binarny z co najwyżej pojedynczą wartością jedynkową, która wskazuje na obecność określonej cechy jakościowej. Ta transformacja jest używana w algorytmach ML, które oczekują funkcji ciągłych.
    • VectorAssembler jest transformatorem, który łączy daną listę kolumn w pojedynczą kolumnę wektorową, która jest następnie wykorzystywana w szkoleniu modeli ML dla algorytmów, takich jak regresja logistyczna i drzewa decyzyjne.
    #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. Ostateczną przekształconą ramkę DataFrame można utworzyć przy użyciu biblioteki Pipeline. Potok jest określony jako sekwencja etapów. Te etapy są uruchamiane w kolejności, a wejściowa ramka DataFrame jest przekształcana podczas przechodzenia przez każdy etap. 
    df_marketing = dyf_marketing.toDF()
pipeline = Pipeline(stages=indexers + encoders + [assembler])
df_tfm=pipeline.fit(df_marketing).transform(df_marketing)

  3. Następnie dzielimy zestaw danych na trenowanie, sprawdzanie poprawności i testowanie DataFrame i zapisujemy go w wiaderku S3, aby wytrenować model ML (podaj swój identyfikator konta AWS w poniższym kodzie): 
    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))

Trenuj i wdrażaj model ML

W poprzedniej sekcji zakończyliśmy inżynierię funkcji, która obejmowała konwersję kolumn łańcuchowych, takich jak region, jobrole, usedpromo do formatu optymalnego dla modeli ML. Dołączyliśmy również kolumny takie jak pageviewspervisit i totalwebvisits, co pomoże nam przewidzieć skłonność klienta do zakupu produktu.

Uczymy teraz model ML, odczytując zestaw danych pociągu i sprawdzania poprawności przy użyciu wbudowanego algorytmu XGBoost SageMaker. Następnie wdrażamy model i przeprowadzamy kontrolę dokładności. Możesz pobrać notatnik z Ta lokalizacja.

W następnej komórce odczytujemy dane z drugiego segmentu S3, który obejmuje dane wyjściowe z naszych operacji inżynierii funkcji. Następnie używamy wbudowanego algorytmu XGBoost do uczenia modelu.

  1. Otwórz nowy notatnik. Wybierać Nauka danych dla Obraz i Python 3 dla Jądro (podaj swój identyfikator konta AWS w poniższym kodzie): 
    #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. Po zakończeniu szkolenia możemy wdrożyć model za pomocą usług hostingowych SageMaker: 
    #deploy ml model
xgb_predictor = xgb.deploy(initial_instance_count=1,
instance_type='ml.m4.xlarge')

Oceń model ML

Używamy testowego zestawu danych do oceny modelu i usuwania punktu końcowego wnioskowania, gdy skończymy, aby uniknąć bieżących opłat.

  1. Oceń model za pomocą następującego kodu: 
    #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))

    Wynik dokładności dla przebiegu próbnego wyniósł 84.6%. W przypadku Twojego biegu może to wyglądać nieco inaczej ze względu na losowy podział zbioru danych.

  2. Możemy usunąć punkt końcowy wnioskowania za pomocą następującego kodu: 
    xgb_predictor.delete_endpoint(delete_endpoint_config=True)

Sprzątać

Teraz do ostatniego kroku, czyszczenia zasobów.

  1. Opróżnij dwa zasobniki utworzone za pomocą stosu CloudFormation.
  2. Usuń aplikacje powiązane z użytkownikiem profiles data-scientist i data-engineer w ramach Studia.
  3. Usuń stos CloudFormation.

Wnioski

W tym poście zademonstrowaliśmy rozwiązanie, które umożliwia takim osobom, jak inżynierowie danych i analitycy danych, przeprowadzanie inżynierii funkcji na dużą skalę. Dzięki interaktywnym sesjom AWS Glue możesz łatwo osiągnąć inżynierię funkcji na dużą skalę dzięki automatycznemu wykrywaniu danych osobowych i szczegółowej kontroli dostępu bez konieczności zarządzania jakąkolwiek bazową infrastrukturą. Używając Studio jako pojedynczego punktu wejścia, możesz uzyskać uproszczone i zintegrowane środowisko do tworzenia kompleksowego przepływu pracy ML: od przygotowania i zabezpieczania danych po budowanie, szkolenie, dostrajanie i wdrażanie modeli ML. Aby dowiedzieć się więcej, odwiedź Pierwsze kroki z interaktywnymi sesjami AWS Glue i Studio Amazon SageMaker.

Jesteśmy bardzo podekscytowani tą nową funkcją i nie możemy się doczekać, co zamierzacie z nią zbudować!

Dodatek: Skonfiguruj zasoby za pomocą konsoli i AWS CLI

Wykonaj instrukcje zawarte w tej sekcji, aby skonfigurować zasoby przy użyciu konsoli i interfejsu wiersza polecenia AWS zamiast szablonu CloudFormation.

Wymagania wstępne

Aby ukończyć ten samouczek, musisz mieć dostęp do AWS CLI (patrz Rozpoczęcie pracy z interfejsem CLI platformy AWS) lub użyj dostępu z wiersza poleceń z Chmura AWS.

Skonfiguruj grupę IAM, użytkowników, role i zasady

W tej sekcji tworzymy dwóch użytkowników IAM: data-engineer i data-scientist, którzy należą do grupy data-platform-group IAM. Następnie dodajemy pojedynczą politykę IAM do grupy IAM.

  1. Na konsoli IAM utwórz politykę na karcie JSON aby utworzyć nową zarządzaną zasadę o nazwie DataPlatformGroupPolicy. Zasady umożliwiają użytkownikom w grupie dostęp do Studio, ale tylko przy użyciu profilu użytkownika SageMaker z tagiem pasującym do ich nazwy użytkownika IAM. Użyj następującego dokumentu zasad JSON, aby nadać uprawnienia: 
    {
   "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. Utwórz grupę IAM nazywa data-platform-group.
  3. Wyszukaj i dołącz zasady zarządzane przez AWS o nazwie DataPlatformGroupPolicy do grupy.
  4. Twórz użytkowników IAM nazywany inżynierem danych i naukowcem danych w grupie IAM data-platform-group.
  5. Utwórz nową zarządzaną zasadę o nazwie SageMakerExecutionPolicy (podaj swój region i identyfikator konta w poniższym kodzie): 
    {
   "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. Utwórz nową zarządzaną zasadę o imieniu 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. Utwórz rolę IAM dla SageMaker dla inżyniera danych (inżyniera danych), który jest używany jako rola wykonawcza odpowiedniego profilu użytkownika. Na Dołącz zasady uprawnień strona AmazonSageMakerFullAccess (zasady zarządzane przez AWS) jest domyślnie dołączona. Później usuniesz tę zasadę, aby zachować minimalne uprawnienia.
    1. W razie zamówieenia projektu Nazwa roli, użyj konwencji nazewnictwa przedstawionej na początku tej sekcji, aby nazwać rolę SageMakerStudioExecutionRole_data-engineer.
    2. W razie zamówieenia projektu Tagi, dodaj klucz userprofilename i wartość data-engineer.
    3. Dodaj Utwórz rolę.
    4. Aby dodać pozostałe zasady, na role wybierz właśnie utworzoną nazwę roli.
    5. Pod Uprawnienia, usuń zasadę AmazonSageMakerFullAccess.
    6. Na Dołącz zasady uprawnień wybierz zasady zarządzane przez AWS AwsGlueSessionUserRestrictedServiceRole oraz utworzone przez siebie zasady zarządzane przez klienta SageMakerExecutionPolicy i SageMakerAdminPolicy.
    7. Dodaj Dołącz zasady.
    8. modyfikować relacja zaufania twojej roli:
    {
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":[
               "glue.amazonaws.com",
               "sagemaker.amazonaws.com"
            ]
         },
         "Action":"sts:AssumeRole"
      }
   ]
}

  8. Utwórz rolę IAM dla SageMaker dla analityka danych (data-scientist), który jest używany jako rola wykonawcza odpowiedniego profilu użytkownika.
    1. W razie zamówieenia projektu Nazwa roli, nazwij rolę SageMakerStudioExecutionRole_data-scientist.
    2. W razie zamówieenia projektu Tagi, dodaj klucz userprofilename i wartość data-scientist.
    3. Dodaj Utwórz rolę.
    4. Aby dodać pozostałe zasady, na role wybierz właśnie utworzoną nazwę roli.
    5. Pod Uprawnienia, usuń zasadę AmazonSageMakerFullAccess.
    6. Na Dołącz zasady uprawnień wybierz zarządzaną przez AWS zasadę AwsGlueSessionUserRestrictedServiceRole oraz utworzoną przez siebie zasadę zarządzaną przez klienta SageMakerExecutionPolicy.
    7. Dodaj Dołącz zasady.
    8. modyfikować relacja zaufania twojej roli:
    {
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":[
               "glue.amazonaws.com",
               "sagemaker.amazonaws.com"
            ]
         },
         "Action":"sts:AssumeRole"
      }
   ]
}

Skonfiguruj profile użytkowników SageMaker

Aby utworzyć profile użytkowników SageMaker za pomocą studiouserid tag, wykonaj następujące czynności:

  1. Użyj AWS CLI lub CloudShell, aby utworzyć profil użytkownika Studio dla inżyniera danych (podaj identyfikator swojego konta i identyfikator domeny Studio w poniższym kodzie): 
    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. Powtórz krok, aby utworzyć profil użytkownika dla analityka danych, zastępując identyfikator konta i identyfikator domeny Studio: 
    aws sagemaker create-user-profile --domain-id  --user-profile-name data-scientist --tags Key=studiouserid,Value=data-scientist --user-settings ExecutionRole=arn:aws:iam:::role/SageMakerStudioExecutionRole_data-scientist

Utwórz zasobniki S3 i prześlij przykładowy zestaw danych

W tej sekcji utworzysz dwa zasobniki S3. Pierwszy segment zawiera przykładowy zestaw danych związanych z marketingiem internetowym. Drugi zasobnik jest używany przez analityka danych do przechowywania danych wyjściowych z zadań inżynierii funkcji, a ten wyjściowy zestaw danych jest używany do uczenia modelu ML.

Najpierw utwórz zasobnik S3 dla danych wejściowych:

  1. Do pobrania zbiór danych.
  2. Na konsoli Amazon S3 wybierz Wiadra w okienku nawigacji.
  3. Dodaj Utwórz wiadro.
  4. W razie zamówieenia projektu Region, wybierz Region z domeną SageMaker, która obejmuje utworzone przez Ciebie profile użytkowników.
  5. W razie zamówieenia projektu Nazwa wiadra, wchodzić blog-studio-pii-dataset-.
  6. Dodaj Utwórz wiadro.
  7. Wybierz utworzone wiadro i wybierz Prześlij.
  8. W Wybierz pliki Sekcja, wybierz Dodaj pliki i prześlij pobrany zestaw danych.
    Teraz tworzysz wiadro dla danych wyjściowych:
  9. Na Wiadra wybierz stronę Utwórz wiadro.
  10. W razie zamówieenia projektu Region, wybierz Region z domeną SageMaker, która obejmuje utworzone przez Ciebie profile użytkowników.
  11. W razie zamówieenia projektu Nazwa wiadra, wchodzić blog-studio-output-.
  12. Dodaj Utwórz wiadro.

Utwórz bazę danych i tabelę AWS Glue

W tej sekcji utworzysz bazę danych i tabelę AWS Glue dla zestawu danych.

  1. Na konsoli Lake Formation pod Katalog danych w okienku nawigacji wybierz Bazy danych.
  2. Dodaj Dodaj bazę danych.
  3. W razie zamówieenia projektu Imię, wejdź do wersji demonstracyjnej.
  4. Dodaj Utwórz bazę danych.
  5. Pod Katalog danychwybierz Stoły.
  6. W razie zamówieenia projektu Imię, wchodzić web_marketing.
  7. W razie zamówieenia projektu Baza danych, Wybierz demo.
  8. W razie zamówieenia projektu Uwzględnij ścieżkę, wprowadź ścieżkę swojego segmentu S3 dla danych wejściowych.
  9. W razie zamówieenia projektu Klasyfikacjawybierz CSV.
  10. Pod schematwybierz Prześlij schemat.
  11. Wprowadź następującą tablicę JSON w polu tekstowym: 
    [
   {
      "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. Dodaj Prześlij.
  13. Dodaj Prześlij.
  14. Pod Szczegóły tabeliwybierz Edytuj tabelę.
  15. Pod Właściwości tabeliwybierz Dodaj.
  16. W razie zamówieenia projektu Klawisz, wchodzić skip.header.line.count, A na wartość, wpisz 1.
  17. Dodaj Zapisz.

Skonfiguruj uprawnienia formacji jeziora

W tej sekcji skonfigurujesz uprawnienia Lake Formation, aby zezwolić na rolę IAM SageMakerStudioExecutionRole_data-engineer stworzyć bazę danych i zarejestrować lokalizację S3 w Lake Formation.

Najpierw zarejestruj lokalizację jeziora danych, aby zarządzać tabelami w ramach lokalizacji w uprawnieniach Lake Formation:

  1. Dodaj Lokalizacje jeziora danych.
  2. Dodaj Zarejestruj lokalizację.
  3. W razie zamówieenia projektu Ścieżka Amazon S3, wchodzić s3://blog-studio-pii-dataset-/ (zasobnik zawierający zestaw danych).
  4. Dodaj Zarejestruj lokalizację.
    Teraz przyznajesz uprawnienia do bazy danych i tabeli Lake Formation do ról IAM SageMakerStudioExecutionRole_data-engineer i SageMakerStudioExecutionRole_data-scientist.Najpierw nadaj uprawnienia do bazy danych dla SageMakerStudioExecutionRole_data-engineer:
  5. Pod Uprawnieniawybierz Uprawnienia do jeziora danych.
  6. Pod Pozwolenie na danewybierz Dotacja.
  7. W razie zamówieenia projektu Dyrektorzywybierz Użytkownicy i role uprawnieńi wybierz rolę SageMakerStudioExecutionRole_data-engineer.
  8. W razie zamówieenia projektu Tagi zasad lub zasoby kataloguwybierz Nazwane zasoby katalogu danych.
  9. W razie zamówieenia projektu Bazy danych, wybierz demo.
  10. W razie zamówieenia projektu Uprawnienia do baz danych, wybierać Wspaniały.
  11. Dodaj Dotacja.
    Następnie nadaj uprawnienia do tabeli dla SageMakerStudioExecutionRole_data-engineer:
  12. Pod Pozwolenie na danewybierz Dotacja.
  13. W razie zamówieenia projektu Dyrektorzywybierz Użytkownicy i role uprawnieńi wybierz rolę SageMakerStudioExecutionRole_data-engineer.
  14. W razie zamówieenia projektu Tagi zasad lub zasoby kataloguwybierz Nazwane zasoby katalogu danych.
  15. W razie zamówieenia projektu Bazy danychwybierz demo.
  16. W razie zamówieenia projektu Stoływybierz web_marketing.
  17. W razie zamówieenia projektu Stół uprawnienia, wybierać Wspaniały.
  18. W razie zamówieenia projektu Przyznane uprawnienia, wybierać Wspaniały.
  19. Dodaj Dotacja.
    Na koniec nadaj uprawnienia do bazy danych dla SageMakerStudioExecutionRole_data-scientist:
  20. Pod Pozwolenie na danewybierz Dotacja.
  21. W razie zamówieenia projektu Dyrektorzywybierz Użytkownicy i role uprawnieńi wybierz rolę SageMakerStudioExecutionRole_data-scientist.
  22. W razie zamówieenia projektu Tagi zasad lub zasoby kataloguwybierz Nazwane zasoby katalogu danych.
  23. W razie zamówieenia projektu Bazy danychwybierz demo.
  24. W razie zamówieenia projektu Uprawnienia do baz danych, wybierać Opisać.
  25. Dodaj Dotacja.

O autorach

Inżynieria funkcji na dużą skalę z ochroną wrażliwych danych przy użyciu interaktywnych sesji AWS Glue i Amazon SageMaker Studio PlatoBlockchain Data Intelligence. Wyszukiwanie pionowe. AI.

Praveen Kumar jest architektem rozwiązań analitycznych w AWS z doświadczeniem w projektowaniu, budowaniu i wdrażaniu nowoczesnych platform danych i analiz przy użyciu usług natywnych w chmurze. Jego obszary zainteresowań to technologia serverless, nowoczesne hurtownie danych w chmurze, streaming oraz aplikacje ML.

Inżynieria funkcji na dużą skalę z ochroną wrażliwych danych przy użyciu interaktywnych sesji AWS Glue i Amazon SageMaker Studio PlatoBlockchain Data Intelligence. Wyszukiwanie pionowe. AI.

Noritaka Sekiyama jest głównym architektem Big Data w zespole AWS Glue. Lubi współpracować z różnymi zespołami, aby osiągać wyniki takie jak ten post. W wolnym czasie lubi grać z rodziną w gry wideo.

Znak czasu:

Więcej z Uczenie maszynowe AWS