Umfangreiches Feature-Engineering mit Schutz vertraulicher Daten mit interaktiven AWS Glue-Sitzungen und Amazon SageMaker Studio PlatoBlockchain Data Intelligence. Vertikale Suche. Ai.

Umfangreiches Feature-Engineering mit Schutz vertraulicher Daten mit interaktiven AWS Glue-Sitzungen und Amazon SageMaker Studio

Zeitstempel: 17. November 2022, 11:35 Uhr

Unternehmen nutzen maschinelles Lernen (ML) und KI-Dienste, um das Kundenerlebnis zu verbessern, die Betriebskosten zu senken und neue Möglichkeiten zur Verbesserung der Geschäftsergebnisse zu erschließen. Daten untermauern ML- und KI-Anwendungsfälle und sind eine strategische Bereicherung für ein Unternehmen. Da die Daten exponentiell wachsen, suchen Unternehmen nach einer integrierten, kostengünstigen und leistungsfähigen Datenplattform, um Daten vorzuverarbeiten, Feature-Engineering durchzuführen und ML-Modelle in großem Maßstab zu erstellen, zu trainieren und zu operationalisieren. Um dies zu erreichen, bietet AWS eine einheitliche, moderne Datenplattform, die von betrieben wird Amazon Simple Storage-Service (Amazon S3) als Data Lake mit speziell entwickelten Tools und Verarbeitungsmodulen zur Unterstützung von Analyse- und ML-Workloads. Für ein einheitliches ML-Erlebnis können Sie verwenden Amazon SageMaker-Studio, Welche Angebote native Integration mit interaktiven AWS Glue-Sitzungen Feature-Engineering im großen Maßstab mit Schutz sensibler Daten durchzuführen. In diesem Beitrag zeigen wir, wie Sie diese Lösung implementieren.

Amazon Sage Maker ist ein vollständig verwalteter ML-Dienst, mit dem Sie Modelle für eine Vielzahl von Anwendungsfällen in großem Maßstab erstellen, trainieren und bereitstellen können. Für das Modelltraining können Sie alle verwenden eingebaute Algorithmen innerhalb von SageMaker, um schnell mit dem Training und der Bereitstellung von ML-Modellen zu beginnen.

Eine Schlüsselkomponente des Modellerstellungs- und Entwicklungsprozesses ist das Feature-Engineering. AWS-Kleber ist eine der empfohlenen Optionen, um Feature-Engineering im großen Maßstab zu erreichen. AWS Glue ermöglicht Ihnen die verteilte Ausführung von Datenintegration und -transformation auf einer serverlosen Apache Spark-Infrastruktur und vereinfacht die Verwendung der beliebten Spark ML-Bibliothek für Feature-Engineering und Modellentwicklung. Darüber hinaus können Sie AWS Glue für die inkrementelle Datenverarbeitung durch verwenden Job-Lesezeichen, nehmen Sie Daten aus über 100 Quellen auf Anschlüsse, und führen Sie spitze oder unvorhersehbare Workloads mit aus automatische Skalierung.

Eine weitere wichtige Anforderung an ML-basierte Anwendungen ist die Datensicherheit und Zugriffskontrolle. Es ist eine allgemeine Forderung, eine strengere Kontrolle darüber zu haben, wer im Rahmen des Feature-Engineering- und Modellerstellungsprozesses auf die sensibelsten Daten zugreifen kann, indem das Prinzip des Zugriffs mit den geringsten Rechten befolgt wird. Um dies zu erreichen, können Sie die AWS Glue-Integration mit nutzen AWS Lake-Formation für verbesserte Governance und Verwaltung von Data Lake-Assets. Mit Lake Formation können Sie eine differenzierte Datenzugriffskontrolle und Sicherheitsrichtlinien zusätzlich zu Ihrem Amazon S3 Data Lake konfigurieren. Die Richtlinien werden an einem zentralen Ort definiert und ermöglichen mehrere Analyse- und ML-Dienste wie AWS Glue, Amazonas Athenaund SageMaker, um mit in Amazon S3 gespeicherten Daten zu interagieren.

AWS Glue enthält a Erkennung von personenbezogenen Daten (PII). Transformation, die die Möglichkeit bietet, Entitäten nach Bedarf zu erkennen, zu maskieren oder zu entfernen, um die Compliance und Governance zu verbessern. Mit der PII-Transformation können Sie PII-Daten in Datensätzen erkennen und mithilfe von Lake Formation automatisch eine feinkörnige Zugriffskontrolle anwenden, um vertrauliche Daten für verschiedene Benutzergruppen einzuschränken.

Anwendungsfall

Wir konzentrieren uns auf einen Anwendungsfall für ein Neigungsmodell, der einen Kundenmarketing-Datensatz enthält und an dem zwei Benutzerpersönlichkeiten beteiligt sind: ein Dateningenieur und ein Datenwissenschaftler. Der Datensatz enthält Informationen pro Kunde, einschließlich Lead-Quelle, Kontaktnotizen, Jobrolle, einige Flags, Seitenaufrufe pro Besuch und mehr. Der Datensatz enthält auch sensible Informationen wie persönliche Telefonnummern.

Der Data Engineer ist verantwortlich für den Aufbau der End-to-End-Datenverarbeitungspipeline, einschließlich Datenvorbereitung, Vorverarbeitung und Zugriffskontrolle. Der Data Scientist ist für das Feature Engineering sowie das Training und die Bereitstellung des ML-Modells verantwortlich. Beachten Sie, dass der Datenwissenschaftler nicht auf PII-sensible Daten zugreifen darf, um Features zu entwickeln oder das ML-Modell zu trainieren.

Als Teil dieses Anwendungsfalls erstellt der Data Engineer eine Datenpipeline zur Vorverarbeitung des Datasets, durchsucht das Dataset nach PII-Informationen und beschränkt den Zugriff auf die PII-Spalte auf den Data Scientist-Benutzer. Wenn ein Data Scientist das Dataset verwendet, um Feature-Engineering durchzuführen und ML-Modelle zu erstellen, hat er daher keinen Zugriff auf die sensible PII-Spalte (in diesem Fall Telefonnummern). Der Feature-Engineering-Prozess umfasst das Konvertieren von Spalten vom Typ „String“ in ein Format, das für ML-Modelle optimal ist. Als erweiterten Anwendungsfall können Sie dieses Zugriffsmuster erweitern, um mithilfe von Lake Formation Sicherheit auf Zeilen- und Zellenebene zu implementieren.

Lösungsüberblick

Die Lösung enthält die folgenden allgemeinen Schritte:

  1. Ressourcen einrichten mit AWS CloudFormation.
  2. Vorverarbeiten des Datensatzes, einschließlich PII-Erkennung und differenzierter Zugriffskontrolle, in einer interaktiven AWS Glue-Sitzung.
  3. Führen Sie Feature-Engineering in einer interaktiven AWS Glue-Sitzung durch.
  4. Trainieren und implementieren Sie ein ML-Modell mit dem in SageMaker integrierten XGBoost-Algorithmus.
  5. Evaluieren Sie das ML-Modell.

Das folgende Diagramm zeigt die Lösungsarchitektur.

Voraussetzungen:

Um dieses Tutorial abzuschließen, müssen Sie die folgenden Voraussetzungen erfüllen:

Einrichten von Ressourcen mit AWS CloudFormation

Dieser Beitrag enthält eine CloudFormation-Vorlage für eine schnelle Einrichtung. Sie können es überprüfen und an Ihre Bedürfnisse anpassen. Wenn Sie es vorziehen, Ressourcen auf der AWS-Managementkonsole und die AWS CLI statt AWS CloudFormation finden Sie in den Anweisungen im Anhang am Ende dieses Beitrags.

Die CloudFormation-Vorlage generiert die folgenden Ressourcen:

  • S3-Buckets mit einem Beispieldatensatz
  • An AWS Lambda Funktion zum Laden des Datensatzes
  • AWS Identity and Access Management and (IAM)-Gruppe, Benutzer, Rollen und Richtlinien
  • Lake Formation Data Lake-Einstellungen und -Berechtigungen
  • SageMaker-Benutzerprofile

Führen Sie die folgenden Schritte aus, um Ihre Ressourcen zu erstellen:

  1. Melden Sie sich bei der Konsole an.
  2. Auswählen Stack starten:
    Schaltfläche "Starten"
  3. Auswählen Weiter.
  4. Aussichten für DataEngineerPwd und DataScientistPwd, geben Sie Ihr eigenes Passwort für die Benutzer Data Engineer und Data Scientist ein.
  5. Aussichten für GlueDatabaseName, eingeben demo.
  6. Aussichten für GlueTableName, eingeben web_marketing.
  7. Aussichten für S3BucketNameForInput, eingeben blog-studio-pii-dataset-.
  8. Aussichten für S3BucketNameForOutput, eingeben blog-studio-output-.
  9. Aussichten für SageMakerDomainId, geben Sie Ihre SageMaker-Domänen-ID ein, die Sie in den erforderlichen Schritten vorbereitet haben.
  10. Auswählen Weiter.
  11. Wählen Sie auf der nächsten Seite Weiter.
  12. Überprüfen Sie die Details auf der letzten Seite und wählen Sie Ich erkenne an, dass AWS CloudFormation möglicherweise IAM-Ressourcen erstellt.
  13. Auswählen Erstellen.

Die Stack-Erstellung kann bis zu 10 Minuten dauern. Der Stack erstellt IAM-Rollen und SageMaker-Benutzerprofile für zwei Personas: Data Engineer und Data Scientist. Es erstellt auch eine Datenbankdemo und eine Tabelle web_marketing mit Beispieldatensatz.

Zum Zeitpunkt der Stack-Erstellung hat die Data Engineer-Persona vollständigen Zugriff auf die Tabelle, aber die Data Scientist-Persona hat noch keinen Zugriff auf die Tabelle.

Verarbeiten Sie das Dataset vor

Beginnen wir mit der Vorverarbeitung von Daten in einer interaktiven AWS Glue-Sitzung. Die Persona des Dateningenieurs möchte die Daten überprüfen, um festzustellen, ob sensible Daten vorhanden sind oder nicht, und der Persona des Datenwissenschaftlers eine minimale Zugriffsberechtigung erteilen. Sie können das Notizbuch von herunterladen dieser Standort.

  1. Melden Sie sich mit dem Data-Engineer-Benutzer bei der Konsole an.
  2. Wählen Sie in der SageMaker-Konsole Nutzer.
  3. Wählen Sie den Data-Engineer-Benutzer aus und wählen Sie Open Studio.
  4. Erstellen Sie ein neues Notizbuch und wählen Sie es aus SparkAnalytics 1.0 für Bild und PySpark kleben für Kernel.
  5. Starten Sie eine interaktive Sitzung mit dem folgenden Zauber, um die neuere Version von Boto3 zu installieren (dies ist erforderlich, um die create_data_cells_filter Methode): 
    %additional_python_modules boto3==1.24.82

  6. Initialisieren Sie die Sitzung: 
    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. Erstellen Sie einen AWS Glue DynamicFrame aus der neu erstellten Tabelle und Auswahltypen lösen basierend auf Katalogschema, da wir das im Katalog definierte Schema anstelle des automatisch abgeleiteten Schemas basierend auf Daten verwenden möchten: 
    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. Überprüfen Sie in der Tabelle, ob PII-Daten mit AWS Glue PII-Erkennung vorhanden sind: 
    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. Überprüfen Sie, ob die als PII klassifizierten Spalten vertrauliche Daten enthalten oder nicht (wenn nicht, aktualisieren Sie selected_map, um die nicht vertraulichen Spalten zu löschen): 
    from pyspark.sql.functions import col
dyf_marketing_resolved.toDF().select(*[col(c) for c in classified_map.keys()]).show()

  10. Richten Sie Lake Formation-Berechtigungen mithilfe eines Datenzellenfilters für automatisch erkannte Spalten ein und beschränken Sie die Spalten auf die Data Scientist-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. Melden Sie sich als Datenwissenschaftler bei Studio an, um zu sehen, dass die PII-Spalten nicht sichtbar sind. Sie können das Notizbuch von herunterladen dieser Standort.
  12. Erstellen Sie ein neues Notizbuch und wählen Sie es aus SparkAnalytics 1.0 für Bild und PySpark kleben für 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()

Feature-Engineering durchführen

Wir verwenden die Apache Spark ML-Bibliothek, um Feature-Engineering als Data-Scientist-Benutzer durchzuführen, und schreiben die Ausgabe dann an Amazon S3 zurück.

  1. In der folgenden Zelle wenden wir Features aus dem an Apache Spark ML-Bibliothek:
    • StringIndexer ordnet eine Zeichenfolgenspalte mit Bezeichnungen einer Spalte mit Bezeichnungsindizes zu.
    • OneHotEncoder ordnet ein kategoriales Merkmal, dargestellt als Labelindex, einem binären Vektor mit höchstens einem einzelnen Eins-Wert zu, der das Vorhandensein eines bestimmten kategorialen Merkmals anzeigt. Diese Transformation wird für ML-Algorithmen verwendet, die kontinuierliche Features erwarten.
    • VectorAssembler ist ein Transformer, der eine gegebene Liste von Spalten zu einer einzigen Vektorspalte kombiniert, die dann zum Trainieren von ML-Modellen für Algorithmen wie logistische Regression und Entscheidungsbäume verwendet wird.
    #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. Der endgültige transformierte DataFrame kann mithilfe der Pipeline-Bibliothek erstellt werden. Eine Pipeline wird als eine Folge von Stufen spezifiziert. Diese Phasen werden der Reihe nach ausgeführt, und der Eingabe-DataFrame wird beim Durchlaufen der einzelnen Phasen transformiert. 
    df_marketing = dyf_marketing.toDF()
pipeline = Pipeline(stages=indexers + encoders + [assembler])
df_tfm=pipeline.fit(df_marketing).transform(df_marketing)

  3. Als Nächstes teilen wir den Datensatz in Trainings-, Validierungs- und Test-DataFrame auf und speichern ihn im S3-Bucket, um das ML-Modell zu trainieren (geben Sie Ihre AWS-Konto-ID im folgenden Code an): 
    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))

Trainieren und implementieren Sie ein ML-Modell

Im vorherigen Abschnitt haben wir das Feature-Engineering abgeschlossen, das das Konvertieren von Zeichenfolgenspalten wie z region, jobrole und usedpromo in ein für ML-Modelle optimales Format. Wir haben auch Spalten wie z pageviewspervisit und totalwebvisits, was uns hilft, die Neigung eines Kunden, ein Produkt zu kaufen, vorherzusagen.

Wir trainieren jetzt ein ML-Modell, indem wir den Trainings- und Validierungsdatensatz mit dem in SageMaker integrierten XGBoost-Algorithmus lesen. Dann stellen wir das Modell bereit und führen eine Genauigkeitsprüfung durch. Sie können das Notizbuch von herunterladen dieser Standort.

In der folgenden Zelle lesen wir Daten aus dem zweiten S3-Bucket, der die Ausgabe unserer Feature-Engineering-Operationen enthält. Dann verwenden wir den eingebauten Algorithmus XGBoost, um das Modell zu trainieren.

  1. Öffnen Sie ein neues Notizbuch. Wählen Daten Wissenschaft für Bild und Python 3 für Kernel (Geben Sie Ihre AWS-Konto-ID im folgenden Code an): 
    #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. Nach Abschluss der Schulung können wir das Modell mithilfe der SageMaker-Hostingdienste bereitstellen: 
    #deploy ml model
xgb_predictor = xgb.deploy(initial_instance_count=1,
instance_type='ml.m4.xlarge')

Evaluieren Sie das ML-Modell

Wir verwenden das Testdataset, um das Modell zu evaluieren, und löschen den Inferenzendpunkt, wenn wir fertig sind, um laufende Gebühren zu vermeiden.

  1. Werten Sie das Modell mit dem folgenden Code aus: 
    #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))

    Das Genauigkeitsergebnis für den Probenlauf betrug 84.6 %. Aufgrund der zufälligen Aufteilung des Datensatzes kann dies für Ihren Lauf etwas anders sein.

  2. Wir können den Inferenzendpunkt mit dem folgenden Code löschen: 
    xgb_predictor.delete_endpoint(delete_endpoint_config=True)

Aufräumen

Nun zum letzten Schritt, dem Bereinigen der Ressourcen.

  1. Leeren Sie die beiden Buckets, die durch den CloudFormation-Stack erstellt wurden.
  2. Löschen Sie die mit dem Benutzer verknüpften Apps profiles data-scientist und data-engineer im Studio.
  3. Löschen Sie den CloudFormation-Stack.

Zusammenfassung

In diesem Beitrag haben wir eine Lösung demonstriert, die es Personen wie Data Engineers und Data Scientists ermöglicht, Feature Engineering in großem Maßstab durchzuführen. Mit interaktiven AWS Glue-Sitzungen können Sie mit automatischer PII-Erkennung und fein abgestufter Zugriffskontrolle problemlos Feature-Engineering im großen Maßstab erreichen, ohne die zugrunde liegende Infrastruktur verwalten zu müssen. Durch die Verwendung von Studio als zentralem Einstiegspunkt erhalten Sie eine vereinfachte und integrierte Erfahrung zum Erstellen eines End-to-End-ML-Workflows: von der Vorbereitung und Sicherung von Daten bis zum Erstellen, Trainieren, Optimieren und Bereitstellen von ML-Modellen. Um mehr zu erfahren, besuchen Sie Erste Schritte mit interaktiven AWS Glue-Sitzungen und Amazon SageMaker-Studio.

Wir freuen uns sehr über diese neue Funktion und sind gespannt, was Sie damit bauen werden!

Anhang: Ressourcen über die Konsole und die AWS CLI einrichten

Führen Sie die Anweisungen in diesem Abschnitt aus, um Ressourcen mithilfe der Konsole und der AWS CLI anstelle der CloudFormation-Vorlage einzurichten.

Voraussetzungen:

Um dieses Tutorial abzuschließen, müssen Sie Zugriff auf die AWS CLI haben (siehe Erste Schritte mit der AWS CLI) oder verwenden Sie den Befehlszeilenzugriff von AWS CloudShell.

Konfigurieren Sie IAM-Gruppen, -Benutzer, -Rollen und -Richtlinien

In diesem Abschnitt erstellen wir zwei IAM-Benutzer: Data-Engineer und Data-Scientist, die zur IAM-Gruppe data-platform-group gehören. Dann fügen wir der IAM-Gruppe eine einzelne IAM-Richtlinie hinzu.

  1. Auf der IAM-Konsole Erstellen Sie eine Richtlinie auf der Registerkarte JSON um eine neue verwaltete IAM-Richtlinie mit dem Namen zu erstellen DataPlatformGroupPolicy. Die Richtlinie erlaubt Benutzern in der Gruppe den Zugriff auf Studio, jedoch nur mit einem SageMaker-Benutzerprofil mit einem Tag, das ihrem IAM-Benutzernamen entspricht. Verwenden Sie das folgende JSON-Richtliniendokument, um Berechtigungen bereitzustellen: 
    {
   "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. Erstellen Sie eine IAM-Gruppe namens data-platform-group.
  3. Suchen Sie die von AWS verwaltete Richtlinie mit dem Namen DataPlatformGroupPolicy und hängen Sie sie an die Gruppe an.
  4. Erstellen Sie IAM-Benutzer Genannter Data-Engineer und Data-Scientist unter der IAM-Gruppe Data-Platform-Group.
  5. Erstellen Sie eine neue verwaltete Richtlinie namens SageMakerExecutionPolicy (geben Sie Ihre Region und Konto-ID im folgenden Code an): 
    {
   "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. Erstellen Sie eine neue verwaltete Richtlinie namens 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. Erstellen Sie eine IAM-Rolle für SageMaker für den Data Engineer (Data-Engineer), der als Ausführungsrolle des entsprechenden Benutzerprofils verwendet wird. Auf der Berechtigungsrichtlinie anhängen Seite ist AmazonSageMakerFullAccess (von AWS verwaltete Richtlinie) standardmäßig angehängt. Sie entfernen diese Richtlinie später, um die Mindestberechtigung beizubehalten.
    1. Aussichten für Rollennameverwenden Sie die am Anfang dieses Abschnitts eingeführte Namenskonvention, um die Rolle SageMakerStudioExecutionRole_data-engineer zu benennen.
    2. Aussichten für Schlüsselwörter, fügen Sie den Schlüssel userprofilename und den Wert data-engineer hinzu.
    3. Auswählen Rolle erstellen.
    4. Um die verbleibenden Richtlinien hinzuzufügen, klicken Sie auf Rollen Wählen Sie auf dieser Seite den Rollennamen aus, den Sie gerade erstellt haben.
    5. Der Berechtigungen, entfernen Sie die Richtlinie AmazonSageMakerFullAccess.
    6. Auf dem Berechtigungsrichtlinie anhängen Wählen Sie auf der Seite AWS verwaltete Richtlinie AwsGlueSessionUserRestrictedServiceRole und die vom Kunden verwalteten Richtlinien SageMakerExecutionPolicy und SageMakerAdminPolicy aus, die Sie erstellt haben.
    7. Auswählen Richtlinien anhängen.
    8. Ändern die Vertrauensbeziehung Ihrer Rolle:
    {
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":[
               "glue.amazonaws.com",
               "sagemaker.amazonaws.com"
            ]
         },
         "Action":"sts:AssumeRole"
      }
   ]
}

  8. Erstellen Sie eine IAM-Rolle für SageMaker für den Datenwissenschaftler (Data-Scientist), der als Ausführungsrolle des entsprechenden Benutzerprofils verwendet wird.
    1. Aussichten für Rollenname, nennen Sie die Rolle SageMakerStudioExecutionRole_data-scientist.
    2. Aussichten für Schlüsselwörter, fügen Sie den Schlüssel userprofilename und den Wert data-scientist hinzu.
    3. Auswählen Rolle erstellen.
    4. Um die verbleibenden Richtlinien hinzuzufügen, klicken Sie auf Rollen Wählen Sie auf dieser Seite den Rollennamen aus, den Sie gerade erstellt haben.
    5. Der Berechtigungen, entfernen Sie die Richtlinie AmazonSageMakerFullAccess.
    6. Auf dem Berechtigungsrichtlinie anhängen Wählen Sie auf der Seite AWS verwaltete Richtlinie AwsGlueSessionUserRestrictedServiceRole und die von Ihnen erstellte kundenverwaltete Richtlinie SageMakerExecutionPolicy aus.
    7. Auswählen Richtlinien anhängen.
    8. Ändern die Vertrauensbeziehung Ihrer Rolle:
    {
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":[
               "glue.amazonaws.com",
               "sagemaker.amazonaws.com"
            ]
         },
         "Action":"sts:AssumeRole"
      }
   ]
}

SageMaker-Benutzerprofile konfigurieren

Um Ihre SageMaker-Benutzerprofile mit dem zu erstellen studiouserid führen Sie die folgenden Schritte aus:

  1. Verwenden Sie die AWS CLI oder CloudShell, um das Studio-Benutzerprofil für den Datentechniker zu erstellen (geben Sie Ihre Konto-ID und Studio-Domänen-ID im folgenden Code an): 
    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. Wiederholen Sie den Schritt, um ein Benutzerprofil für den Data Scientist zu erstellen, und ersetzen Sie dabei die Konto-ID und die Studio-Domänen-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

Erstellen Sie S3-Buckets und laden Sie das Beispiel-Dataset hoch

In diesem Abschnitt erstellen Sie zwei S3-Buckets. Der erste Bucket enthält einen Beispieldatensatz zum Thema Webmarketing. Der zweite Bucket wird vom Data Scientist verwendet, um die Ausgabe von Feature-Engineering-Aufgaben zu speichern, und dieses Ausgabe-Dataset wird zum Trainieren des ML-Modells verwendet.

Erstellen Sie zunächst den S3-Bucket für die Eingabedaten:

  1. Herunterladen der Datensatz.
  2. Wählen Sie in der Amazon S3-Konsole aus Eimer im Navigationsbereich.
  3. Auswählen Eimer erstellen.
  4. Aussichten für Region, wählen Sie die Region mit der SageMaker-Domäne aus, die die von Ihnen erstellten Benutzerprofile enthält.
  5. Aussichten für Eimername, eingeben blog-studio-pii-dataset-.
  6. Auswählen Eimer erstellen.
  7. Wählen Sie den von Ihnen erstellten Bucket aus und wählen Sie aus Hochladen.
  8. Im Dateien auswählen Wählen Sie im Abschnitt Hinzufügen von Dateien und laden Sie den heruntergeladenen Datensatz hoch.
    Jetzt erstellen Sie den Bucket für die Ausgabedaten:
  9. Auf dem Eimer Seite wählen Eimer erstellen.
  10. Aussichten für Region, wählen Sie die Region mit der SageMaker-Domäne aus, die die von Ihnen erstellten Benutzerprofile enthält.
  11. Aussichten für Eimername, eingeben blog-studio-output-.
  12. Auswählen Eimer erstellen.

Erstellen Sie eine AWS Glue-Datenbank und -Tabelle

In diesem Abschnitt erstellen Sie eine AWS Glue-Datenbank und -Tabelle für das Dataset.

  1. Auf der Lake Formation-Konsole unter Datenkatalog Wählen Sie im Navigationsbereich Datenbanken.
  2. Auswählen Datenbank hinzufügen.
  3. Aussichten für Name und Vorname, Demo eingeben.
  4. Auswählen Datenbank erstellen.
  5. Der Datenkatalog, wählen Tische.
  6. Aussichten für Name und Vorname, eingeben web_marketing.
  7. Aussichten für DatenbaseWählen demo.
  8. Aussichten für Pfad einschließen, geben Sie den Pfad Ihres S3-Buckets für Eingabedaten ein.
  9. Aussichten für Klassifikation, wählen CSV.
  10. Der Schema, wählen Schema hochladen.
  11. Geben Sie das folgende JSON-Array in das Textfeld ein: 
    [
   {
      "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. Auswählen Hochladen.
  13. Auswählen Absenden.
  14. Der Tabellendetails, wählen Tabelle bearbeiten.
  15. Der Tabelleneigenschaften, wählen Speichern.
  16. Aussichten für Wesentliche, eingeben skip.header.line.countUnd für Wert, 1 eingeben.
  17. Auswählen Speichern.

Konfigurieren Sie die Lake Formation-Berechtigungen

In diesem Abschnitt richten Sie Lake Formation-Berechtigungen ein, um die IAM-Rolle zuzulassen SageMakerStudioExecutionRole_data-engineer um eine Datenbank zu erstellen und den S3-Standort in Lake Formation zu registrieren.

Registrieren Sie zunächst den Data Lake-Standort, um Tabellen unter dem Standort in Lake Formation-Berechtigungen zu verwalten:

  1. Auswählen Datenseestandorte.
  2. Auswählen Ort registrieren.
  3. Aussichten für Amazon S3-Pfad, eingeben s3://blog-studio-pii-dataset-/ (der Bucket, der das Dataset enthält).
  4. Auswählen Ort registrieren.
    Jetzt erteilen Sie den IAM-Rollen Datenbank- und Tabellenberechtigungen für Lake Formation SageMakerStudioExecutionRole_data-engineer und SageMakerStudioExecutionRole_data-scientist.Erteilen Sie zunächst die Datenbankberechtigung für SageMakerStudioExecutionRole_data-engineer:
  5. Der Berechtigungen, wählen Data Lake-Berechtigungen.
  6. Der Datenerlaubnis, wählen Gewähren.
  7. Aussichten für Prinzipien, wählen IAM-Benutzer und -Rollen, und wählen Sie die Rolle aus SageMakerStudioExecutionRole_data-engineer.
  8. Aussichten für Richtlinien-Tags oder Katalogressourcen, wählen Benannte Datenkatalogressourcen.
  9. Aussichten für Datenbanken, wählen Sie Demo.
  10. Aussichten für Datenbankberechtigungen, wählen Super.
  11. Auswählen Gewähren.
    Erteilen Sie als Nächstes die Tabellenberechtigung für SageMakerStudioExecutionRole_data-engineer:
  12. Der Datenerlaubnis, wählen Gewähren.
  13. Aussichten für Prinzipien, wählen IAM-Benutzer und -Rollen, und wählen Sie die Rolle aus SageMakerStudioExecutionRole_data-engineer.
  14. Aussichten für Richtlinien-Tags oder Katalogressourcen, wählen Benannte Datenkatalogressourcen.
  15. Aussichten für Datenbanken, wählen demo.
  16. Aussichten für Tische, wählen web_marketing.
  17. Aussichten für Tisch Berechtigungen, wählen Super.
  18. Aussichten für Gewährbar Berechtigungen, wählen Super.
  19. Auswählen Gewähren.
    Erteilen Sie schließlich die Datenbankberechtigung für SageMakerStudioExecutionRole_data-scientist:
  20. Der Datenerlaubnis, wählen Gewähren.
  21. Aussichten für Prinzipien, wählen IAM-Benutzer und -Rollen, und wählen Sie die Rolle aus SageMakerStudioExecutionRole_data-scientist.
  22. Aussichten für Richtlinien-Tags oder Katalogressourcen, wählen Benannte Datenkatalogressourcen.
  23. Aussichten für Datenbanken, wählen demo.
  24. Aussichten für Datenbankberechtigungen, wählen Beschreiben.
  25. Auswählen Gewähren.

Über die Autoren

Umfangreiches Feature-Engineering mit Schutz vertraulicher Daten mit interaktiven AWS Glue-Sitzungen und Amazon SageMaker Studio PlatoBlockchain Data Intelligence. Vertikale Suche. Ai.

Praveen Kumar ist Analytics Solution Architect bei AWS mit Erfahrung im Entwerfen, Erstellen und Implementieren moderner Daten- und Analyseplattformen unter Verwendung von Cloud-nativen Diensten. Seine Interessengebiete sind serverlose Technologie, moderne Cloud Data Warehouses, Streaming und ML-Anwendungen.

Umfangreiches Feature-Engineering mit Schutz vertraulicher Daten mit interaktiven AWS Glue-Sitzungen und Amazon SageMaker Studio PlatoBlockchain Data Intelligence. Vertikale Suche. Ai.

Noritaka Sekiyama ist Principal Big Data Architect im AWS Glue-Team. Er arbeitet gerne mit verschiedenen Teams zusammen, um Ergebnisse wie diesen Beitrag zu liefern. In seiner Freizeit spielt er gerne Videospiele mit seiner Familie.

Zeitstempel:

Mehr von AWS Maschinelles Lernen