Engenharia de recursos em larga escala com proteção de dados confidenciais usando sessões interativas do AWS Glue e Amazon SageMaker Studio

Republicado por Platão

seguidores: 0

As organizações estão usando serviços de aprendizado de máquina (ML) e IA para aprimorar a experiência do cliente, reduzir o custo operacional e desbloquear novas possibilidades para melhorar os resultados dos negócios. Os dados sustentam os casos de uso de ML e IA e são um ativo estratégico para uma organização. Como os dados estão crescendo a uma taxa exponencial, as organizações procuram configurar uma plataforma de dados integrada, econômica e de alto desempenho para pré-processar dados, realizar engenharia de recursos e criar, treinar e operacionalizar modelos de ML em escala. Para conseguir isso, a AWS oferece uma plataforma de dados moderna e unificada, desenvolvida por Serviço de armazenamento simples da Amazon (Amazon S3) como o data lake com ferramentas específicas e mecanismos de processamento para dar suporte a análises e cargas de trabalho de ML. Para uma experiência de ML unificada, você pode usar Estúdio Amazon SageMaker, Que oferece integração nativa com sessões interativas do AWS Glue para realizar engenharia de recursos em escala com proteção de dados confidenciais. Neste post, demonstramos como implementar esta solução.

Amazon Sage Maker é um serviço de ML totalmente gerenciado que permite criar, treinar e implantar modelos em escala para uma ampla variedade de casos de uso. Para treinamento de modelo, você pode usar qualquer um dos algoritmos integrados no SageMaker para começar a treinar e implantar modelos de ML rapidamente.

Um componente chave do processo de construção e desenvolvimento do modelo é a engenharia de recursos. Cola AWS é uma das opções recomendadas para obter engenharia de recursos em escala. O AWS Glue permite executar integração e transformação de dados de maneira distribuída em uma infraestrutura Apache Spark sem servidor e facilita o uso da popular biblioteca Spark ML para engenharia de recursos e desenvolvimento de modelos. Além disso, você pode usar o AWS Glue para processamento de dados incremental por meio de marcadores de trabalho, ingira dados de mais de 100 fontes usando de Saúdee execute cargas de trabalho imprevisíveis ou imprevisíveis usando dimensionamento automático.

Outro requisito importante para aplicativos baseados em ML é a segurança de dados e o controle de acesso. É uma demanda comum ter um controle mais rígido sobre quem pode acessar os dados mais confidenciais como parte da engenharia de recursos e do processo de construção de modelo, seguindo o princípio de acesso com privilégios mínimos. Para conseguir isso, você pode utilizar a integração do AWS Glue com Formação AWS Lake para maior governança e gerenciamento de ativos de data lake. Com o Lake Formation, você pode configurar políticas de segurança e controle de acesso a dados refinados no data lake do Amazon S3. As políticas são definidas em um local central, permitindo várias análises e serviços de ML, como AWS Glue, Amazona atena, e SageMaker, para interagir com dados armazenados no Amazon S3.

O AWS Glue inclui um detecção de informações de identificação pessoal (PII) transform que fornece a capacidade de detectar, mascarar ou remover entidades conforme necessário, para maior conformidade e governança. Com a transformação PII, você pode detectar dados PII em conjuntos de dados e aplicar automaticamente o controle de acesso refinado usando o Lake Formation para restringir dados confidenciais para diferentes grupos de usuários.

Caso de uso

Nós nos concentramos em um caso de uso de modelo de propensão que inclui um conjunto de dados de marketing do cliente e envolve duas personas de usuário: um engenheiro de dados e um cientista de dados. O conjunto de dados contém informações por cliente, incluindo fonte de lead, notas de contato, cargo, alguns sinalizadores, visualizações de página por visita e muito mais. O conjunto de dados também inclui informações confidenciais, como números de telefone pessoais.

O engenheiro de dados é responsável por construir o pipeline de processamento de dados de ponta a ponta, incluindo preparação de dados, pré-processamento e controle de acesso. O cientista de dados é responsável pela engenharia de recursos, treinamento e implantação do modelo de ML. Observe que o cientista de dados não tem permissão para acessar dados confidenciais de PII para engenharia de recursos ou treinamento do modelo de ML.

Como parte desse caso de uso, o engenheiro de dados cria um pipeline de dados para pré-processar o conjunto de dados, verifica o conjunto de dados em busca de qualquer informação PII e restringe o acesso da coluna PII ao usuário cientista de dados. Como resultado, quando um cientista de dados usa o conjunto de dados para realizar engenharia de recursos e criar modelos de ML, ele não tem acesso à coluna confidencial de PII (números de telefone, neste caso). O processo de engenharia de recursos envolve a conversão de colunas do tipo string em um formato ideal para modelos de ML. Como um caso de uso avançado, você pode estender esse padrão de acesso para implementar segurança em nível de linha e em nível de célula usando o Lake Formation.

Visão geral da solução

A solução contém as seguintes etapas de alto nível:

Configurar recursos com Formação da Nuvem AWS.
Pré-processe o conjunto de dados, incluindo detecção de PII e controle de acesso refinado, em uma sessão interativa do AWS Glue.
Realize engenharia de recursos em uma sessão interativa do AWS Glue.
Treine e implante um modelo de ML usando o algoritmo XGBoost integrado do SageMaker.
Avalie o modelo de ML.

O diagrama a seguir ilustra a arquitetura da solução.

Pré-requisitos

Para concluir este tutorial, você deve ter os seguintes pré-requisitos:

Configure recursos com AWS CloudFormation

Esta postagem inclui um modelo do CloudFormation para uma configuração rápida. Você pode revisá-lo e personalizá-lo para atender às suas necessidades. Se você preferir configurar recursos no Console de gerenciamento da AWS e a AWS CLI em vez do AWS CloudFormation, consulte as instruções no apêndice no final desta postagem.

O modelo CloudFormation gera os seguintes recursos:

Depósitos S3 com um conjunto de dados de amostra
An AWS Lambda função para carregar o conjunto de dados
Gerenciamento de acesso e identidade da AWS (IAM) grupo, usuários, funções e políticas
Configurações e permissões do lago de dados Lake Formation
Perfis de usuário do SageMaker

Para criar seus recursos, conclua as seguintes etapas:

Entre no console.
Escolha Pilha de Lançamento:
Escolha Próximo.
Escolha DataEngineerPwd e DataScientist Pwd, insira sua própria senha para os usuários de engenheiro de dados e cientista de dados.
Escolha ColaDatabaseName, entrar demo.
Escolha Nome da tabela de cola, entrar web_marketing.
Escolha S3BucketNameForInput, entrar blog-studio-pii-dataset-.
Escolha S3BucketNameForOutput, entrar blog-studio-output-.
Escolha SageMakerDomainId, insira o ID de domínio do SageMaker que você preparou nas etapas de pré-requisito.
Escolha Próximo.
Na próxima página, escolha Próximo.
Revise os detalhes na página final e selecione Reconheço que o AWS CloudFormation pode criar recursos do IAM.
Escolha Crie.

A criação da pilha pode levar até 10 minutos. A pilha cria funções do IAM e perfis de usuário do SageMaker para duas personas: engenheiro de dados e cientista de dados. Ele também cria uma demonstração de banco de dados e tabela web_marketing com um conjunto de dados de amostra.

No momento da criação da pilha, a pessoa do engenheiro de dados tem acesso completo à tabela, mas a pessoa do cientista de dados ainda não tem acesso à tabela.

Pré-processar o conjunto de dados

Vamos começar a pré-processar dados em uma sessão interativa do AWS Glue. A pessoa do engenheiro de dados deseja verificar os dados para ver se há dados confidenciais ou não e conceder permissão mínima de acesso à pessoa do cientista de dados. Você pode baixar o notebook de este local.

Entre no console usando o usuário engenheiro de dados.
No console SageMaker, escolha Utilizadores.
Selecione o usuário engenheiro de dados e escolha Estúdio Aberto.
Crie um novo notebook e escolha SparkAnalytics 1.0 para Imagem e Cola PySpark para Núcleo.
Inicie uma sessão interativa com a seguinte mágica para instalar a versão mais recente do Boto3 (isso é necessário para usar o create_data_cells_filter método):
```
%additional_python_modules boto3==1.24.82
```

Inicialize a sessão:

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)

Crie um AWS Glue DynamicFrame da tabela recém-criada e resolver tipos de escolha com base no esquema do catálogo, porque queremos usar o esquema definido no catálogo em vez do esquema inferido automaticamente com base nos dados:

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

Valide na tabela se há dados de PII usando a detecção de PII do AWS Glue:

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)

Verifique se as colunas classificadas como PII contêm dados confidenciais ou não (caso contrário, atualize o mapa_classificado para descartar as colunas não confidenciais):
```
from pyspark.sql.functions import col
dyf_marketing_resolved.toDF().select(*[col(c) for c in classified_map.keys()]).show()
```

Configure as permissões do Lake Formation usando um filtro de célula de dados para colunas detectadas automaticamente e restrinja as colunas à persona do cientista de dados:

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'
]
)

Faça login no Studio como cientista de dados para verificar se as colunas PII não estão visíveis. Você pode baixar o notebook de este local.

Crie um novo notebook e escolha SparkAnalytics 1.0 para Imagem e Cola PySpark para Núcleo:

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

Executar engenharia de recursos

Usamos a biblioteca Apache Spark ML para executar a engenharia de recursos como o usuário cientista de dados e, em seguida, gravamos a saída no Amazon S3.

Na célula a seguir, aplicamos recursos do Biblioteca Apache Spark ML:

StringIndexer mapeia uma coluna de string de rótulos para uma coluna de índices de rótulo.
OneHotEncoder mapeia um recurso categórico, representado como um índice de rótulo, para um vetor binário com no máximo um único valor que indica a presença de um recurso categórico específico. Essa transformação é usada para algoritmos de ML que esperam recursos contínuos.
VectorAssembler é um transformador que combina uma determinada lista de colunas em uma única coluna de vetor, que é então usada no treinamento de modelos de ML para algoritmos como regressão logística e árvores de decisão.

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

O DataFrame transformado final pode ser criado usando a biblioteca Pipeline. Um pipeline é especificado como uma sequência de estágios. Esses estágios são executados em ordem e o DataFrame de entrada é transformado à medida que passa por cada estágio.
```
df_marketing = dyf_marketing.toDF()
pipeline = Pipeline(stages=indexers + encoders + [assembler])
df_tfm=pipeline.fit(df_marketing).transform(df_marketing)
```

Em seguida, dividimos o conjunto de dados em treinar, validar e testar DataFrame e salvá-lo no bucket S3 para treinar o modelo ML (forneça o ID da sua conta da AWS no código a seguir):

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

Treine e implante um modelo de ML

Na seção anterior, concluímos a engenharia de recursos, que incluiu a conversão de colunas de string, como region, jobrole e usedpromo em um formato ideal para modelos de ML. Também incluímos colunas como pageviewspervisit e totalwebvisits, o que nos ajudará a prever a propensão de um cliente a comprar um produto.

Agora, treinamos um modelo de ML lendo o conjunto de dados de treinamento e validação usando o algoritmo XGBoost integrado do SageMaker. Em seguida, implantamos o modelo e executamos uma verificação de precisão. Você pode baixar o notebook de este local.

Na célula a seguir, estamos lendo dados do segundo bucket S3, que inclui a saída de nossas operações de engenharia de recursos. Em seguida, usamos o algoritmo integrado XGBoost para treinar o modelo.

Abra um novo caderno. Escolher Ciência dados para Imagem e Python 3 para Núcleo (forneça o ID da sua conta da AWS no código a seguir):

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

Quando o treinamento estiver concluído, podemos implantar o modelo usando os serviços de hospedagem SageMaker:
```
#deploy ml model
xgb_predictor = xgb.deploy(initial_instance_count=1,
instance_type='ml.m4.xlarge')
```

Avalie o modelo de ML

Usamos o conjunto de dados de teste para avaliar o modelo e excluímos o endpoint de inferência quando terminamos para evitar cobranças contínuas.

Avalie o modelo com o seguinte código:

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

O resultado da precisão para a execução da amostra foi de 84.6%. Isso pode ser um pouco diferente para sua execução devido à divisão aleatória do conjunto de dados.

Podemos excluir o endpoint de inferência com o seguinte código:
```
xgb_predictor.delete_endpoint(delete_endpoint_config=True)
```

limpar

Agora, para a etapa final, limpar os recursos.

Esvazie os dois depósitos criados por meio da pilha do CloudFormation.
Exclua os aplicativos associados ao usuário profiles data-scientist e data-engineer dentro do Estúdio.
Exclua a pilha CloudFormation.

Conclusão

Nesta postagem, demonstramos uma solução que permite que pessoas como engenheiros de dados e cientistas de dados executem engenharia de recursos em escala. Com as sessões interativas do AWS Glue, você pode facilmente obter engenharia de recursos em escala com detecção automática de PII e controle de acesso minucioso sem precisar gerenciar nenhuma infraestrutura subjacente. Ao usar o Studio como ponto de entrada único, você pode obter uma experiência simplificada e integrada para criar um fluxo de trabalho de ML de ponta a ponta: desde a preparação e proteção de dados até a criação, treinamento, ajuste e implantação de modelos de ML. Para saber mais, visite Conceitos básicos das sessões interativas do AWS Glue e Estúdio Amazon SageMaker.

Estamos muito empolgados com esse novo recurso e ansiosos para ver o que você vai construir com ele!

Apêndice: Configurar recursos por meio do console e da AWS CLI

Conclua as instruções nesta seção para configurar recursos usando o console e a AWS CLI em vez do modelo CloudFormation.

Pré-requisitos

Para concluir este tutorial, você deve ter acesso à AWS CLI (consulte Introdução à AWS CLI) ou use o acesso à linha de comando em AWS CloudShell.

Configurar grupo, usuários, funções e políticas do IAM

Nesta seção, criamos dois usuários do IAM: data-engineer e data-scientist, que pertencem ao grupo IAM data-platform-group. Em seguida, adicionamos uma única política IAM ao grupo IAM.

No console IAM, crie uma política na guia JSON para criar uma nova política gerenciada IAM chamada DataPlatformGroupPolicy. A política permite que os usuários do grupo acessem o Studio, mas apenas usando um perfil de usuário do SageMaker com uma tag que corresponda ao nome de usuário do IAM. Use o seguinte documento de política JSON para fornecer permissões:

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

Crie um grupo IAM chamado data-platform-group.
Pesquise e anexe a política gerenciada pela AWS chamada DataPlatformGroupPolicy ao grupo.
Criar usuários IAM chamados de engenheiro de dados e cientista de dados no grupo IAM data-platform-group.

Criar uma nova política gerenciada chamado SageMakerExecutionPolicy (forneça sua região e ID da conta no seguinte código):

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

Criar uma nova política gerenciada nomeado 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"
      }
   ]
}

Crie uma função do IAM para SageMaker para o engenheiro de dados (engenheiro de dados), que é usado como a função de execução do perfil de usuário correspondente. No Anexar política de permissões página, AmazonSageMakerFullAccess (política gerenciada pela AWS) é anexado por padrão. Você remove esta política posteriormente para manter o privilégio mínimo.
1. Escolha Nome do papel, use a convenção de nomenclatura apresentada no início desta seção para nomear a função SageMakerStudioExecutionRole_data-engineer.
2. Escolha Tags, adicione a chave userprofilename e o valor data-engineer.
3. Escolha Criar função.
4. Para adicionar as políticas restantes, no Setores página, escolha o nome da função que você acabou de criar.
5. Debaixo Permissões, remova a política AmazonSageMakerFullAccess.
6. No Anexar política de permissões página, selecione a política gerenciada pela AWS AwsGlueSessionUserRestrictedServiceRole e as políticas gerenciadas pelo cliente SageMakerExecutionPolicy e SageMakerAdminPolicy que você criou.
7. Escolha Anexar políticas.
8. modificar a relação de confiança da sua função:
```
{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":[
               "glue.amazonaws.com",
               "sagemaker.amazonaws.com"
            ]
         },
         "Action":"sts:AssumeRole"
      }
   ]
}
```
Crie uma função do IAM para SageMaker para o cientista de dados (cientista de dados), que é usado como a função de execução do perfil de usuário correspondente.
1. Escolha Nome do papel, nomeie a função SageMakerStudioExecutionRole_data-scientist.
2. Escolha Tags, inclua a chave userprofilename e o valor data-scientist.
3. Escolha Criar função.
4. Para adicionar as políticas restantes, no Setores página, escolha o nome da função que você acabou de criar.
5. Debaixo Permissões, remova a política AmazonSageMakerFullAccess.
6. No Anexar política de permissões página, selecione a política gerenciada pela AWS AwsGlueSessionUserRestrictedServiceRole e a política gerenciada pelo cliente SageMakerExecutionPolicy que você criou.
7. Escolha Anexar políticas.
8. modificar a relação de confiança da sua função:
```
{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":[
               "glue.amazonaws.com",
               "sagemaker.amazonaws.com"
            ]
         },
         "Action":"sts:AssumeRole"
      }
   ]
}
```

Configurar perfis de usuário do SageMaker

Para criar seus perfis de usuário do SageMaker com o studiouserid marca, conclua as seguintes etapas:

Use a AWS CLI ou o CloudShell para criar o perfil de usuário do Studio para o engenheiro de dados (forneça o ID da sua conta e o ID do domínio do Studio no seguinte código):

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

Repita a etapa para criar um perfil de usuário para o cientista de dados, substituindo o ID da conta e o ID do domínio do 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

Crie buckets S3 e carregue o conjunto de dados de amostra

Nesta seção, você cria dois buckets do S3. O primeiro bloco tem um conjunto de dados de amostra relacionado ao marketing na web. O segundo bucket é usado pelo cientista de dados para armazenar a saída das tarefas de engenharia de recursos, e esse conjunto de dados de saída é usado para treinar o modelo de ML.

Primeiro, crie o bucket S3 para os dados de entrada:

Baixar o conjunto de dados.
No console do Amazon S3, escolha Baldes no painel de navegação.
Escolha Criar balde.
Escolha Região, escolha a região com o domínio SageMaker que inclui os perfis de usuário que você criou.
Escolha Nome do intervalo, entrar blog-studio-pii-dataset-.
Escolha Criar balde.
Selecione o bucket que você criou e escolha Escolher arquivo.
No Selecione os arquivos seção, escolha Adicionar arquivos e carregue o conjunto de dados que você baixou.
Agora você cria o bucket para os dados de saída:
No Baldes página, escolha Criar balde.
Escolha Região, escolha a região com o domínio SageMaker que inclui os perfis de usuário que você criou.
Escolha Nome do intervalo, entrar blog-studio-output-.
Escolha Criar balde.

Crie um banco de dados e uma tabela do AWS Glue

Nesta seção, você cria um banco de dados e uma tabela do AWS Glue para o conjunto de dados.

No console do Lake Formation, em Catálogo de dados no painel de navegação, escolha Bases de dados.
Escolha Adicionar banco de dados.
Escolha Nome, entre na demonstração.
Escolha Criar banco de dados.
Debaixo Catálogo de dados, escolha Tabelas.
Escolha Nome, entrar web_marketing.
Escolha banco de dados, selecione demo.
Escolha Incluir caminho, insira o caminho do seu bucket S3 para dados de entrada.
Escolha Classificação, escolha CSV.
Debaixo Esquema, escolha Carregar Esquema.

Digite a seguinte matriz JSON na caixa de texto:

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

Escolha Escolher arquivo.
Escolha Submeter.
Debaixo Detalhes da mesa, escolha Editar mesa.
Debaixo Propriedades da tabela, escolha Adicionar.
Escolha Chave, entrar skip.header.line.count, E para Valor, insira 1.
Escolha Salvar.

Configurar permissões de formação do lago

Nesta seção, você configura as permissões Lake Formation para permitir a função IAM SageMakerStudioExecutionRole_data-engineer para criar um banco de dados e registrar a localização do S3 dentro do Lake Formation.

Primeiro, registre o local do data lake para gerenciar tabelas sob o local nas permissões do Lake Formation:

Escolha Localizações de data lake.
Escolha Registrar localização.
Escolha Caminho Amazon S3, entrar s3://blog-studio-pii-dataset-/ (o bucket que contém o conjunto de dados).
Escolha Registrar localização.
Agora você concede permissões de tabela e banco de dados do Lake Formation às funções do IAM SageMakerStudioExecutionRole_data-engineer e SageMakerStudioExecutionRole_data-scientist.Primeiro, conceda permissão de banco de dados para SageMakerStudioExecutionRole_data-engineer:
Debaixo Permissões, escolha Permissões do data lake.
Debaixo Permissão de dados, escolha Conceda.
Escolha Principais, escolha Usuários e funções IAMe selecione a função SageMakerStudioExecutionRole_data-engineer.
Escolha Tags de política ou recursos de catálogo, escolha Recursos de catálogo de dados nomeados.
Escolha Bases de dados, escolha demonstração.
Escolha Permissões de banco de dados, selecionar super.
Escolha Conceda.
Em seguida, conceda permissão de tabela para SageMakerStudioExecutionRole_data-engineer:
Debaixo Permissão de dados, escolha Conceda.
Escolha Principais, escolha Usuários e funções IAMe selecione a função SageMakerStudioExecutionRole_data-engineer.
Escolha Tags de política ou recursos de catálogo, escolha Recursos de catálogo de dados nomeados.
Escolha Bases de dados, escolha demo.
Escolha Tabelas, escolha web_marketing.
Escolha mesa permissões, selecionar super.
Escolha Concedido permissões, selecionar super.
Escolha Conceda.
Finalmente, conceda permissão de banco de dados para SageMakerStudioExecutionRole_data-scientist:
Debaixo Permissão de dados, escolha Conceda.
Escolha Principais, escolha Usuários e funções IAMe selecione a função SageMakerStudioExecutionRole_data-scientist.
Escolha Tags de política ou recursos de catálogo, escolha Recursos de catálogo de dados nomeados.
Escolha Bases de dados, escolha demo.
Escolha Permissões de banco de dados, selecionar Descrever.
Escolha Conceda.

Sobre os autores

Engenharia de recursos em grande escala com proteção de dados confidenciais usando sessões interativas do AWS Glue e Amazon SageMaker Studio PlatoBlockchain Data Intelligence. Pesquisa vertical. Ai.

Praveen Kumar é arquiteto de soluções analíticas da AWS com experiência em projetar, criar e implementar plataformas modernas de análise e dados usando serviços nativos da nuvem. Suas áreas de interesse são tecnologia sem servidor, data warehouses modernos em nuvem, streaming e aplicativos de ML.

Noritaka Sekiyama é Arquiteto Principal de Big Data na equipe do AWS Glue. Ele gosta de colaborar com diferentes equipes para entregar resultados como este post. Nas horas vagas, gosta de jogar videogame com a família.

Carimbo de hora: 17 de novembro de 2022 20 de novembro de 2022

Carimbo de hora: Julho 26, 2023

Engenharia de recursos em larga escala com proteção de dados confidenciais usando sessões interativas do AWS Glue e Amazon SageMaker Studio

Republicado por Platão

Caso de uso

Visão geral da solução

Pré-requisitos

Configure recursos com AWS CloudFormation

Pré-processar o conjunto de dados

Executar engenharia de recursos

Treine e implante um modelo de ML

Avalie o modelo de ML

limpar

Conclusão

Apêndice: Configurar recursos por meio do console e da AWS CLI

Pré-requisitos

Configurar grupo, usuários, funções e políticas do IAM

Configurar perfis de usuário do SageMaker

Crie buckets S3 e carregue o conjunto de dados de amostra

Crie um banco de dados e uma tabela do AWS Glue

Configurar permissões de formação do lago

Sobre os autores

Mais de Aprendizado de máquina da AWS

Execute vários modelos de aprendizado profundo na GPU com endpoints de vários modelos do Amazon SageMaker

Use o AWS CDK para implantar configurações de ciclo de vida do Amazon SageMaker Studio | Amazon Web Services

Amazon Rekognition apresenta Streaming Video Events para fornecer alertas em tempo real sobre streams de vídeo ao vivo

Anunciando a AWS DeepRacer League 2022

Como a Amp na Amazon usou dados para aumentar o engajamento do cliente, Parte 1: Construindo uma plataforma de análise de dados

Otimize o desempenho do equipamento com dados históricos, Ray e Amazon SageMaker | Amazon Web Services

Sobre Nós

Pesquisa vertical e IA

Plataforma

Fique Ligado

Conta