반응형
블로그 이미지
개발자로서 현장에서 일하면서 새로 접하는 기술들이나 알게된 정보 등을 정리하기 위한 블로그입니다. 운 좋게 미국에서 큰 회사들의 프로젝트에서 컬설턴트로 일하고 있어서 새로운 기술들을 접할 기회가 많이 있습니다. 미국의 IT 프로젝트에서 사용되는 툴들에 대해 많은 분들과 정보를 공유하고 싶습니다.
솔웅

최근에 올라온 글

최근에 달린 댓글

최근에 받은 트랙백

글 보관함

카테고리


반응형

https://aws.amazon.com/ko/tutorials/train-tune-deep-learning-model-amazon-sagemaker/?nc1=h_ls

 

Train and tune a deep learning model at scale with Amazon SageMaker

 

aws.amazon.com

 

Train and tune a deep learning model at scale

with Amazon SageMaker

 

In this tutorial, you learn how to use Amazon SageMaker to build, train, and tune a TensorFlow deep learning model.

 

이 자습서에서는 Amazon SageMaker를 사용하여 TensorFlow 딥 러닝 모델을 구축, 훈련 및 조정하는 방법을 알아봅니다.

 

Amazon SageMaker is a fully managed service that provides machine learning (ML) developers and data scientists with the ability to build, train, and deploy ML models quickly. Amazon SageMaker provides you with everything you need to train and tune models at scale without the need to manage infrastructure. You can use Amazon SageMaker Studio, the first integrated development environment (IDE) for machine learning, to quickly visualize experiments and track training progress without ever leaving the familiar Jupyter Notebook interface. Within Amazon SageMaker Studio, you can use Amazon SageMaker Experiments to track, evaluate, and organize experiments easily.

 

Amazon SageMaker는 기계 학습(ML) 개발자와 데이터 과학자에게 ML 모델을 신속하게 구축, 교육 및 배포할 수 있는 기능을 제공하는 완전관리형 서비스입니다. Amazon SageMaker는 인프라를 관리할 필요 없이 대규모로 모델을 훈련하고 조정하는 데 필요한 모든 것을 제공합니다. 기계 학습을 위한 최초의 통합 개발 환경(IDE)인 Amazon SageMaker Studio를 사용하면 친숙한 Jupyter Notebook 인터페이스를 벗어나지 않고도 실험을 신속하게 시각화하고 훈련 진행 상황을 추적할 수 있습니다. Amazon SageMaker Studio 내에서 Amazon SageMaker 실험을 사용하여 실험을 쉽게 추적, 평가 및 구성할 수 있습니다.

 

In this tutorial, you learn how to:

 

이 자습서에서는 다음 방법을 알아봅니다.

 

  1. Set up Amazon SageMaker Studio
    Amazon SageMaker Studio 설정

  2. Download a public dataset using an Amazon SageMaker Studio Notebook and upload it to Amazon S3
    Amazon SageMaker Studio Notebook을 사용하여 공개 데이터 세트를 다운로드하고 Amazon S3에 업로드합니다.

  3. Create an Amazon SageMaker Experiment to track and manage training jobs
    훈련 작업을 추적하고 관리하기 위한 Amazon SageMaker 실험 생성

  4. Run a TensorFlow training job on a fully managed GPU instance using one-click training with Amazon SageMaker
    Amazon SageMaker의 원클릭 교육을 사용하여 완전 관리형 GPU 인스턴스에서 TensorFlow 교육 작업 실행

  5. Improve accuracy by running a large-scale Amazon SageMaker Automatic Model Tuning job to find the best model hyperparameters
    대규모 Amazon SageMaker 자동 모델 튜닝 작업을 실행하여 최상의 모델 하이퍼파라미터를 찾아 정확성을 향상시킵니다.

  6. Visualize training results
    훈련 결과 시각화

You’ll be using the CIFAR-10 dataset to train a model in TensorFlow to classify images into 10 classes. This dataset consists of 60,000 32x32 color images, split into 40,000 images for training, 10,000 images for validation and 10,000 images for testing.

 

CIFAR-10 데이터 세트를 사용하여 TensorFlow에서 모델을 훈련하여 이미지를 10개 클래스로 분류하게 됩니다. 이 데이터 세트는 60,000개의 32x32 컬러 이미지로 구성되어 있으며 훈련용 이미지 40,000개, 검증용 이미지 10,000개, 테스트용 이미지 10,000개로 나뉩니다.

 

 

이 튜토리얼의 비용은 약 $100입니다.

 

Amazon SageMaker Studio에 온보딩하고 Amazon SageMaker Studio 제어판을 설정하려면 다음 단계를 완료하십시오.

참고: 자세한 내용은 Amazon SageMaker 설명서의 Get Started with Amazon SageMaker Studio  를 참조하십시오.

 

a. Amazon SageMaker console 에 로그인합니다.

 

참고: 오른쪽 상단에서 SageMaker Studio를 사용할 수 있는 AWS 리전을 선택하십시오. 지역 목록은  Onboard to Amazon SageMaker Studio 을 참조하십시오.

 

b. Amazon SageMaker 탐색 창에서 Amazon SageMaker Studio를 선택합니다.
 
참고: Amazon SageMaker Studio를 처음 사용하는 경우  Studio onboarding process 를 완료해야 합니다. 온보딩 시 인증 방법으로 AWS Single Sign-On(AWS SSO) 또는 AWS Identity and Access Management(IAM)를 사용하도록 선택할 수 있습니다. IAM 인증을 사용하는 경우 빠른 시작 또는 표준 설정 절차를 선택할 수 있습니다. 어떤 옵션을 선택해야 할지 잘 모르겠으면 Onboard to Amazon SageMaker Studio 을 참조하고 IT 관리자에게 도움을 요청하세요. 단순화를 위해 이 자습서에서는 빠른 시작 절차를 사용합니다.

 

 

c. 시작하기 상자에서 빠른 시작을 선택하고 사용자 이름을 지정합니다.

 

d. 실행 역할에서 IAM 역할 생성을 선택합니다. 표시되는 대화 상자에서 모든 S3 버킷을 선택하고 역할 생성을 선택합니다.
Amazon SageMaker는 필요한 권한이 있는 역할을 생성하고 이를 인스턴스에 할당합니다.

 

e. Submit을 클릭하세요.

 

 

Amazon SageMaker Studio 노트북은 훈련 스크립트를 구축하고 테스트하는 데 필요한 모든 것이 포함된 원클릭 Jupyter 노트북입니다. SageMaker Studio에는 실험 추적 및 시각화도 포함되어 있어 전체 기계 학습 워크플로를 한 곳에서 쉽게 관리할 수 있습니다.

 

SageMaker 노트북을 생성하고, 데이터 세트를 다운로드하고, 데이터 세트를 TensorFlow 지원  TFRecord  형식으로 변환한 다음 데이터 세트를 Amazon S3에 업로드하려면 다음 단계를 완료하십시오.

 

참고: 자세한 내용은 Amazon SageMaker 설명서의  Use Amazon SageMaker Studio Notebooks 사용을 참조하십시오.

 

a. Amazon SageMaker Studio 제어판에서 Open Studio를 선택합니다.

 

b. JupyterLab의 파일 메뉴에서 새 실행 프로그램을 선택합니다. 노트북 및 컴퓨팅 리소스 섹션의 SageMaker 이미지 선택에서 TensorFlow 1.15 Python 3.6(CPU에 최적화됨)을 선택합니다. 그런 다음 노트북에서 Python 3을 선택합니다.

 

참고: 이 단계에서는 데이터 세트를 다운로드하고, 교육 스크립트를 작성하고, Amazon SageMaker 교육 작업을 제출하고, 결과를 시각화하는 SageMaker 노트북을 실행하는 데 사용되는 CPU 인스턴스를 선택합니다. 훈련 작업 자체는 5단계에서 볼 수 있는 GPU 인스턴스와 같이 지정할 수 있는 별도의 인스턴스 유형에서 실행됩니다.

 

 

 

c. 다음 코드 블록을 복사하여 코드 셀에 붙여넣고 실행을 선택합니다.

 

이 코드는 generate_cifar10_tfrecords.py 스크립트를 다운로드하고 CIFAR-10 dataset 를 다운로드한 후 TFRecord 형식으로 변환합니다.

 

참고: 코드가 실행되는 동안 대괄호 사이에 *가 나타납니다. 몇 초 후에 코드 실행이 완료되고 *가 숫자로 대체됩니다.

 

https://github.com/aws/amazon-sagemaker-examples/blob/master/advanced_functionality/tensorflow_bring_your_own/utils/generate_cifar10_tfrecords.py

 

다음 코드를 복사하여 코드 셀에 붙여넣고 실행을 선택합니다.

 

!pip install ipywidgets
!python generate_cifar10_tfrecords.py --data-dir cifar10

 

 

d. 기본 Amazon SageMaker Amazon S3 버킷에 데이터세트를 업로드합니다. 다음 코드를 복사하여 코드 셀에 붙여넣고 실행을 선택합니다.
 
데이터세트의 Amazon S3 위치가 출력으로 표시되어야 합니다.

 

import time, os, sys
import sagemaker, boto3
import numpy as np
import pandas as pd

sess = boto3.Session()
sm   = sess.client('sagemaker')
role = sagemaker.get_execution_role()
sagemaker_session = sagemaker.Session(boto_session=sess)

datasets = sagemaker_session.upload_data(path='cifar10', key_prefix='datasets/cifar10-dataset')
datasets

 

 

이제 Amazon S3에서 데이터 세트를 다운로드하고 준비했으므로 Amazon SageMaker 실험을 생성할 수 있습니다. 실험은 동일한 기계 학습 프로젝트와 관련된 처리 및 학습 작업의 모음입니다. Amazon SageMaker Experiments는 훈련 실행을 자동으로 관리하고 추적합니다.

 

새 실험을 만들려면 다음 단계를 완료하세요.

 

참고: 자세한 내용은 Amazon SageMaker 설명서의 실험을 참조하십시오.

 

from smexperiments.experiment import Experiment
from smexperiments.trial import Trial
from smexperiments.trial_component import TrialComponent

training_experiment = Experiment.create(
                                experiment_name = "sagemaker-training-experiments", 
                                description     = "Experiment to track cifar10 training trials", 
                                sagemaker_boto_client=sm)

 

 

 

b. 왼쪽 도구 모음에서 구성 요소 및 레지스트리(삼각형 아이콘)를 선택한 다음 실험 및 시험을 선택합니다. 새 실험 Sagemaker-training-experiments가 목록에 나타납니다.

 

CIFAR-10 데이터 세트에서 분류기를 훈련하려면 훈련 스크립트가 필요합니다. 이 단계에서는 TensorFlow 학습 작업을 위한 평가판 및 학습 스크립트를 만듭니다. 각 시도는 엔드 투 엔드 훈련 작업의 반복입니다. 훈련 작업 외에도 평가판에서는 전처리, 후처리 작업은 물론 데이터 세트 및 기타 메타데이터도 추적할 수 있습니다. 단일 실험에는 여러 시도가 포함될 수 있으므로 Amazon SageMaker Studio 실험 창 내에서 시간 경과에 따른 여러 반복을 쉽게 추적할 수 있습니다.

 

TensorFlow 학습 작업을 위한 새로운 평가판 및 학습 스크립트를 생성하려면 다음 단계를 완료하세요.

 

참고: 자세한 내용은 Amazon SageMaker 설명서의 Use TensorFlow with Amazon SageMaker 을 참조하십시오.

 

a. Jupyter Notebook에서 다음 코드 블록을 복사하여 코드 셀에 붙여넣고 실행을 선택합니다.

 

이 코드는 새로운 시도를 생성하고 이를 4단계에서 생성한 실험과 연결합니다.

single_gpu_trial = Trial.create(
    trial_name = 'sagemaker-single-gpu-training', 
    experiment_name = training_experiment.experiment_name,
    sagemaker_boto_client = sm,
)

trial_comp_name = 'single-gpu-training-job'
experiment_config = {"ExperimentName": training_experiment.experiment_name, 
                       "TrialName": single_gpu_trial.trial_name,
                       "TrialComponentDisplayName": trial_comp_name}

 

 

각 시도는 엔드 투 엔드 훈련 작업의 반복입니다. 훈련 작업 외에도 시도에서는 전처리 작업, 후처리 작업, 데이터 세트 및 기타 메타데이터를 추적할 수도 있습니다. 단일 실험에는 여러 시도가 포함될 수 있으므로 Amazon SageMaker Studio 실험 창 내에서 시간 경과에 따른 여러 반복을 쉽게 추적할 수 있습니다.

 

b. 왼쪽 도구 모음에서 구성 요소 및 레지스트리(삼각형 아이콘)를 선택합니다. Sagemaker-training-experiments를 두 번 클릭하여 관련 시도를 표시합니다. 새로운 평가판 Sagemaker-single-Gpu-training이 목록에 나타납니다.

 

c. 파일 메뉴에서 새로 만들기를 선택한 다음 텍스트 파일을 선택합니다. 코드 편집기에서 다음 TensorFlow 코드를 복사하여 새로 생성된 파일에 붙여넣습니다.

 

이 스크립트는 TensorFlow 코드를 구현하여 CIFAR-10 데이터 세트를 읽고 resnet50 모델을 교육합니다.

 

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.callbacks import ModelCheckpoint
from tensorflow.keras.layers import Input, Dense, Flatten
from tensorflow.keras.models import Model, load_model
from tensorflow.keras.optimizers import Adam, SGD
import argparse
import os
import re
import time

HEIGHT = 32
WIDTH = 32
DEPTH = 3
NUM_CLASSES = 10

def single_example_parser(serialized_example):
    """Parses a single tf.Example into image and label tensors."""
    # Dimensions of the images in the CIFAR-10 dataset.
    # See http://www.cs.toronto.edu/~kriz/cifar.html for a description of the
    # input format.
    features = tf.io.parse_single_example(
        serialized_example,
        features={
            'image': tf.io.FixedLenFeature([], tf.string),
            'label': tf.io.FixedLenFeature([], tf.int64),
        })
    image = tf.decode_raw(features['image'], tf.uint8)
    image.set_shape([DEPTH * HEIGHT * WIDTH])

    # Reshape from [depth * height * width] to [depth, height, width].
    image = tf.cast(
        tf.transpose(tf.reshape(image, [DEPTH, HEIGHT, WIDTH]), [1, 2, 0]),
        tf.float32)
    label = tf.cast(features['label'], tf.int32)
    
    image = train_preprocess_fn(image)
    label = tf.one_hot(label, NUM_CLASSES)
    
    return image, label

def train_preprocess_fn(image):

    # Resize the image to add four extra pixels on each side.
    image = tf.image.resize_with_crop_or_pad(image, HEIGHT + 8, WIDTH + 8)

    # Randomly crop a [HEIGHT, WIDTH] section of the image.
    image = tf.image.random_crop(image, [HEIGHT, WIDTH, DEPTH])

    # Randomly flip the image horizontally.
    image = tf.image.random_flip_left_right(image)
    return image

def get_dataset(filenames, batch_size):
    """Read the images and labels from 'filenames'."""
    # Repeat infinitely.
    dataset = tf.data.TFRecordDataset(filenames).repeat().shuffle(10000)

    # Parse records.
    dataset = dataset.map(single_example_parser, num_parallel_calls=tf.data.experimental.AUTOTUNE)

    # Batch it up.
    dataset = dataset.batch(batch_size, drop_remainder=True)
    return dataset

def get_model(input_shape, learning_rate, weight_decay, optimizer, momentum):
    input_tensor = Input(shape=input_shape)
    base_model = keras.applications.resnet50.ResNet50(include_top=False,
                                                          weights='imagenet',
                                                          input_tensor=input_tensor,
                                                          input_shape=input_shape,
                                                          classes=None)
    x = Flatten()(base_model.output)
    predictions = Dense(NUM_CLASSES, activation='softmax')(x)
    model = Model(inputs=base_model.input, outputs=predictions)
    return model

def main(args):
    # Hyper-parameters
    epochs       = args.epochs
    lr           = args.learning_rate
    batch_size   = args.batch_size
    momentum     = args.momentum
    weight_decay = args.weight_decay
    optimizer    = args.optimizer

    # SageMaker options
    training_dir   = args.training
    validation_dir = args.validation
    eval_dir       = args.eval

    train_dataset = get_dataset(training_dir+'/train.tfrecords',  batch_size)
    val_dataset   = get_dataset(validation_dir+'/validation.tfrecords', batch_size)
    eval_dataset  = get_dataset(eval_dir+'/eval.tfrecords', batch_size)
    
    input_shape = (HEIGHT, WIDTH, DEPTH)
    model = get_model(input_shape, lr, weight_decay, optimizer, momentum)
    
    # Optimizer
    if optimizer.lower() == 'sgd':
        opt = SGD(lr=lr, decay=weight_decay, momentum=momentum)
    else:
        opt = Adam(lr=lr, decay=weight_decay)

    # Compile model
    model.compile(optimizer=opt,
                  loss='categorical_crossentropy',
                  metrics=['accuracy'])
    
    # Train model
    history = model.fit(train_dataset, steps_per_epoch=40000 // batch_size,
                        validation_data=val_dataset, 
                        validation_steps=10000 // batch_size,
                        epochs=epochs)
                        
    
    # Evaluate model performance
    score = model.evaluate(eval_dataset, steps=10000 // batch_size, verbose=1)
    print('Test loss    :', score[0])
    print('Test accuracy:', score[1])
    
    # Save model to model directory
    model.save(f'{os.environ["SM_MODEL_DIR"]}/{time.strftime("%m%d%H%M%S", time.gmtime())}', save_format='tf')


#%%
if __name__ == "__main__":
    
    parser = argparse.ArgumentParser()
    # Hyper-parameters
    parser.add_argument('--epochs',        type=int,   default=10)
    parser.add_argument('--learning-rate', type=float, default=0.01)
    parser.add_argument('--batch-size',    type=int,   default=128)
    parser.add_argument('--weight-decay',  type=float, default=2e-4)
    parser.add_argument('--momentum',      type=float, default='0.9')
    parser.add_argument('--optimizer',     type=str,   default='sgd')

    # SageMaker parameters
    parser.add_argument('--model_dir',        type=str)
    parser.add_argument('--training',         type=str,   default=os.environ['SM_CHANNEL_TRAINING'])
    parser.add_argument('--validation',       type=str,   default=os.environ['SM_CHANNEL_VALIDATION'])
    parser.add_argument('--eval',             type=str,   default=os.environ['SM_CHANNEL_EVAL'])
    
    args = parser.parse_args()
    main(args)

 

 

d. 파일 메뉴에서 파일 이름 바꾸기를 선택합니다. 새 이름 상자에서 cifar10-training-sagemaker.py를 복사하여 붙여넣고 이름 바꾸기를 선택합니다. (새 확장자가 .txt가 아니라 .py인지 확인하세요.) 그런 다음 파일을 선택하고 Python 파일 저장을 선택합니다.

 

이 단계에서는 Amazon SageMaker를 사용하여 TensorFlow 훈련 작업을 실행합니다. Amazon SageMaker를 사용하면 모델 훈련이 쉽습니다. Amazon S3의 데이터 세트 위치와 훈련 인스턴스 유형을 지정하면 Amazon SageMaker가 훈련 인프라를 관리합니다.

 

TensorFlow 학습 작업을 실행한 후 결과를 시각화하려면 다음 단계를 완료하세요.

 

참고: 자세한 내용은 Amazon SageMaker 설명서의  Use TensorFlow with Amazon SageMaker 을 참조하십시오.

 

a. Jupyter Notebook에서 다음 코드 블록을 복사하여 코드 셀에 붙여넣고 실행을 선택합니다. 그런 다음 코드를 자세히 살펴보세요.

 

참고: ResourceLimitExceeded가 나타나면 인스턴스 유형을 ml.c5.xlarge로 변경하세요.

 

참고: 사용 중단 경고는 무시해도 됩니다(예: sagemaker.deprecations:train_instance_type의 이름이 변경되었습니다...). 이 경고는 버전 변경으로 인한 것이며 학습 실패를 일으키지 않습니다.

 

from sagemaker.tensorflow import TensorFlow

hyperparams={'epochs'       : 30,
             'learning-rate': 0.01,
             'batch-size'   : 256,
             'weight-decay' : 2e-4,
             'momentum'     : 0.9,
             'optimizer'    : 'adam'}

bucket_name = sagemaker_session.default_bucket()
output_path = f's3://{bucket_name}/jobs'
metric_definitions = [{'Name': 'val_acc', 'Regex': 'val_acc: ([0-9\\.]+)'}]

tf_estimator = TensorFlow(entry_point          = 'cifar10-training-sagemaker.py', 
                          output_path          = f'{output_path}/',
                          code_location        = output_path,
                          role                 = role,
                          train_instance_count = 1, 
                          train_instance_type  = 'ml.g4dn.xlarge',
                          framework_version    = '1.15.2', 
                          py_version           = 'py3',
                          script_mode          = True,
                          metric_definitions   = metric_definitions,
                          sagemaker_session    = sagemaker_session,
                          hyperparameters      = hyperparams)

job_name=f'tensorflow-single-gpu-{time.strftime("%Y-%m-%d-%H-%M-%S", time.gmtime())}'
tf_estimator.fit({'training'  : datasets,
                  'validation': datasets,
                  'eval'      : datasets},
                 job_name = job_name,
                 experiment_config=experiment_config)

 

이 코드는 세 부분으로 구성됩니다.

- 학습 작업 하이퍼파라미터를 지정합니다.
- Amazon SageMaker Estimator 함수를 호출하고 훈련 작업 세부 정보(훈련 스크립트 이름, 훈련할 인스턴스 유형, 프레임워크 버전 등)를 제공합니다.
- 훈련 작업을 시작하기 위해 fit 함수를 호출합니다.

 

Amazon SageMaker는 요청된 인스턴스를 자동으로 프로비저닝하고, 데이터 세트를 다운로드하고, TensorFlow 컨테이너를 가져오고, 훈련 스크립트를 다운로드하고, 훈련을 시작합니다.

이 예에서는 GPU 인스턴스인 ml.g4dn.xlarge에서 실행할 Amazon SageMaker 훈련 작업을 제출합니다. 딥 러닝 훈련은 계산 집약적이며 결과를 더 빠르게 얻으려면 GPU 인스턴스가 권장됩니다.

학습이 완료되면 최종 정확도 결과, 학습 시간 및 청구 가능 시간이 표시됩니다.

 

b. 교육 요약을 봅니다. 왼쪽 도구 모음에서 구성 요소 및 레지스트리(삼각형 아이콘)를 선택합니다. sagemaker-training-experiments를 두 번 클릭한 다음 sagemaker-single-gpu-training을 두 번 클릭하고 훈련 작업에 대해 새로 생성된 Single-Gpu-training-job 평가판 구성 요소를 두 번 클릭합니다. 측정항목을 선택합니다.

 

 

c. 결과를 시각화합니다. 차트를 선택한 다음 차트 추가를 선택합니다. 차트 속성 창에서 다음을 선택합니다.

차트 유형: 선
X축 차원: Epoch
Y축: val_acc_EVAL_avg
학습이 진행됨에 따라 평가 정확도의 변화를 보여주는 그래프가 표시되고 6a단계의 최종 정확도로 끝납니다.

 

Step 7. Tune the model with Amazon SageMaker automatic model tuning

이 단계에서는 Amazon SageMaker 자동 모델 튜닝 작업을 실행하여 최상의 하이퍼파라미터를 찾고 6단계에서 얻은 훈련 정확도를 향상시킵니다. 모델 튜닝 작업을 실행하려면 Amazon SageMaker에 고정 값이 아닌 하이퍼파라미터 범위를 제공해야 합니다. 하이퍼파라미터 공간을 탐색하고 자동으로 최적의 값을 찾을 수 있다는 것입니다.
자동 모델 튜닝 작업을 실행하려면 다음 단계를 완료하세요.

 

참고: 자세한 내용은 Amazon SageMaker 설명서의 Perform Automatic Model Tuning  을 참조하십시오.

 

 

a. Jupyter Notebook에서 다음 코드 블록을 복사하여 코드 셀에 붙여넣고 실행을 선택합니다. 그런 다음 코드를 자세히 살펴보세요.

 

참고: ResourceLimitExceeded가 나타나면 인스턴스 유형을 ml.c5.xlarge로 변경하세요.

 

참고: 사용 중단 경고는 무시해도 됩니다(예: sagemaker.deprecations:train_instance_type의 이름이 변경되었습니다...). 이 경고는 버전 변경으로 인한 것이며 학습 실패를 일으키지 않습니다.

 

from sagemaker.tuner import IntegerParameter, CategoricalParameter, ContinuousParameter, HyperparameterTuner

hyperparameter_ranges = {
    'epochs'        : IntegerParameter(5, 30),
    'learning-rate' : ContinuousParameter(0.001, 0.1, scaling_type='Logarithmic'), 
    'batch-size'    : CategoricalParameter(['128', '256', '512']),
    'momentum'      : ContinuousParameter(0.9, 0.99),
    'optimizer'     : CategoricalParameter(['sgd', 'adam'])
}

objective_metric_name = 'val_acc'
objective_type = 'Maximize'
metric_definitions = [{'Name': 'val_acc', 'Regex': 'val_acc: ([0-9\\.]+)'}]

tf_estimator = TensorFlow(entry_point          = 'cifar10-training-sagemaker.py', 
                          output_path          = f'{output_path}/',
                          code_location        = output_path,
                          role                 = role,
                          train_instance_count = 1, 
                          train_instance_type  = 'ml.g4dn.xlarge',
                          framework_version    = '1.15', 
                          py_version           = 'py3',
                          script_mode          = True,
                          metric_definitions   = metric_definitions,
                          sagemaker_session    = sagemaker_session)

tuner = HyperparameterTuner(estimator             = tf_estimator,
                            objective_metric_name = objective_metric_name,
                            hyperparameter_ranges = hyperparameter_ranges,
                            metric_definitions    = metric_definitions,
                            max_jobs              = 16,
                            max_parallel_jobs     = 8,
                            objective_type        = objective_type)

job_name=f'tf-hpo-{time.strftime("%Y-%m-%d-%H-%M-%S", time.gmtime())}'
tuner.fit({'training'  : datasets,
           'validation': datasets,
           'eval'      : datasets},
            job_name = job_name)

 

 

이 코드는 네 부분으로 구성됩니다.

 

- 하이퍼파라미터의 값 범위를 지정합니다. 이는 정수 범위(예: Epoch 번호), 연속 범위(예: 학습률) 또는 범주형 값(예: 최적화 유형 sgd 또는 adam)일 수 있습니다.
- 6단계의 것과 유사한 Estimator 함수를 호출합니다.
- 하이퍼파라미터 범위, 최대 작업 수, 실행할 병렬 작업 수를 포함하는 HyperparameterTuner 객체를 생성합니다.
- 초매개변수 조정 작업을 시작하기 위해 맞춤 함수를 호출합니다.

 

참고: max_jobs 변수를 16에서 더 작은 숫자로 줄여 튜닝 작업 비용을 절약할 수 있습니다. 그러나 튜닝 작업 수를 줄이면 더 나은 모델을 찾을 가능성이 줄어듭니다. max_parallel_jobs 변수를 max_jobs보다 작거나 같은 숫자로 줄일 수도 있습니다. max_parallel_jobs가 max_jobs와 같으면 결과를 더 빨리 얻을 수 있습니다. 리소스 오류가 발생하지 않도록 max_parallel_jobs가 AWS 계정의 인스턴스 제한보다 낮은지 확인하십시오.

 

b. 최고의 하이퍼파라미터를 확인하세요. Amazon SageMaker 콘솔을 열고 왼쪽 탐색 창의 훈련 아래에서 하이퍼파라미터 튜닝 작업을 선택하고 튜닝 작업을 선택한 다음 최상의 훈련 작업을 선택합니다. 6단계의 결과(60%)에 비해 훈련 정확도(80%)가 향상되는 것을 확인할 수 있습니다.

 

참고: 결과는 다를 수 있습니다. max_jobs를 늘리고, 하이퍼파라미터 범위를 완화하고, 다른 모델 아키텍처를 탐색하여 결과를 더욱 향상시킬 수 있습니다.

 

 

 

이 단계에서는 이 실습에서 사용한 리소스를 종료합니다.

 

중요: 적극적으로 사용되지 않는 리소스를 종료하면 비용이 절감되므로 모범 사례입니다. 리소스를 종료하지 않으면 계정에 요금이 청구됩니다.

 

학습 작업을 중지합니다.

 

1. Amazon SageMaker 콘솔을 엽니다.
2. 교육 아래 왼쪽 탐색 창에서 교육 작업을 선택합니다.
3. 진행 중 상태의 교육 작업이 없는지 확인합니다. 진행 중인 훈련 작업의 경우 작업이 훈련을 마칠 때까지 기다리거나 훈련 작업 이름을 선택하고 중지를 선택할 수 있습니다.

 

(선택 사항) 모든 훈련 아티팩트 정리: 모든 훈련 아티팩트(모델, 사전 처리된 데이터 세트 등)를 정리하려면 Jupyter Notebook에서 다음 코드를 복사하여 붙여넣고 실행을 선택합니다.

 

참고: ACCOUNT_NUMBER를 계좌 번호로 바꿔야 합니다.

 

!aws s3 rm --recursive s3://sagemaker-us-west-2-ACCOUNT_NUMBER/datasets/cifar10-dataset
!aws s3 rm --recursive s3://sagemaker-us-west-2-ACCOUNT_NUMBER/jobs

 

Conclusion

Congratulations! You created, trained, and tuned a TensorFlow deep learning model with Amazon SageMaker.
 
축하해요! Amazon SageMaker를 사용하여 TensorFlow 딥 러닝 모델을 생성, 교육 및 조정했습니다.
 
 
You can continue your machine learning journey with SageMaker by following the next steps section below.

 

아래의 다음 단계 섹션에 따라 SageMaker를 사용하여 기계 학습 여정을 계속할 수 있습니다.

 

 

 

반응형


반응형

A rectified linear unit (ReLU) 는 Deep learning의 Multilayer Perceptron에서 Hidden layer에서 Non-liniearity를 만들기 위해 사용하는 Activation Function중 하나 입니다.

 

이 ReLU 함수는 음수는 버리고 0이나 양수를 통과 시킴으로서 다른 Activation Function (Sigmoid, Tanh etc.)이 가지고 있던 Vanishing gradient나 exploding gradient 문제를 완화 시키기 때문에 가장 많이 사용하고 있는 Activation Function입니다.

 

 

Group Study 중에 ReLU에서는 왜 하필 음수를 버리는가? 특별한 이유가 있는가? 라는 질문이 나왔고 거기에 대한 답변은 없었습니다.

 

그래서 ChatGPT에게 그 이유를 물어 보았는데...

원하는 답이 딱히 나오지는 않았습니다.

 

계속 끈질기게 물어본다고 시도는 했는데... 딱히 맘에 드는 답은 없네요.

제 prompting 실력이 딸려서 그럴 겁니다.

아니면 ChatGPT가 제대로 답했는데 제가 이해를 못 한 것일 수도 있구요.

 

아래 제 질문과 ChatGPT의 답변 chain 을 소개합니다.

 

보시면 아시겠지만 중간중간 ChatGPT가 영 엉뚱한 대답을 하거나 아예 틀린 답을 할 때도 있습니다.

 

ChatGPT의 특징이기도 한데 ChatGPT가 대답한 내용이 언제나 맞는 것은 아닙니다.

그냥 그럴듯하게 대답 할 뿐 100% 신뢰할 만한 대답은 아니라는 것을 미리 말씀 드립니다.

 

User
Why does the ReLU function discard negative numbers instead of positive numbers?

ChatGPT
The Rectified Linear Unit (ReLU) activation function is defined as follows: for any input value x, ReLU(x) returns x if x is positive or zero, and it returns 0 if x is negative. The main reason for discarding negative numbers and setting them to 0 is to introduce non-linearity into the neural network model.

When training neural networks, the non-linearity of activation functions is important for capturing complex patterns and relationships in the data. ReLU has the advantage of being computationally efficient and avoiding the vanishing gradient problem, which can occur with other activation functions like sigmoid or tanh.

By discarding negative values, ReLU allows the network to focus on the positive, non-linear relationships in the data, which can be beneficial for learning complex patterns and improving the model's ability to generalize. It effectively introduces sparsity by zeroing out a portion of the input values, which can help the network learn more robust representations.

However, one limitation of ReLU is the "dying ReLU" problem, where neurons can become "dead" and never activate again due to consistently having negative inputs. This can be mitigated by using variants of ReLU, such as Leaky ReLU or Parametric ReLU, which introduce small positive slopes for negative inputs to address the dying ReLU problem.

Overall, the choice of ReLU to discard negative numbers is primarily driven by its ability to introduce non-linearity and promote efficient learning in neural network models.

User
What happen if Activation function return 1 if it is negative and return 0 if it is positive value? 

ChatGPT
If an activation function returns 1 for negative values and 0 for positive values, it would essentially create a binary activation where the neuron is either fully activated (outputting 1) or completely deactivated (outputting 0) based on the sign of the input.

In this case, the activation function would not introduce any non-linearity to the neural network model. The model would essentially be a linear classifier since the output would solely depend on the sign of the input. It would not be able to capture complex patterns or learn non-linear relationships in the data.

The purpose of activation functions like ReLU, which discard negative values and introduce non-linearity, is to enable the neural network to learn complex representations and make it more expressive. By introducing non-linear transformations, the model becomes capable of capturing intricate patterns and relationships in the data, leading to improved performance and better generalization.

Therefore, using an activation function that returns 1 for negative values and 0 for positive values would limit the capabilities of the neural network and may result in suboptimal performance, especially in tasks that require non-linear decision boundaries and complex data patterns.


User
Here, what does it mean when the input value is positive and when the input value is negative?

ChatGPT
Here, "when the input value is positive" refers to the scenario where the value of the input to the activation function is greater than zero. In this case, if the activation function returns 0, it means that the neuron is completely deactivated or inhibited.

On the other hand, "when the input value is negative" refers to the scenario where the value of the input to the activation function is less than zero. In this case, if the activation function returns 1, it means that the neuron is fully activated or turned on.

In summary, if the activation function returns 1 for negative input values and 0 for positive input values, it leads to a binary activation where the neuron is either completely activated or completely deactivated based on the sign of the input.

User
OK. Let’s back to ReLU function. What does Positive and Negative input value mean?

ChatGPT
In the context of the ReLU (Rectified Linear Unit) function, "positive input value" refers to a situation where the input value provided to the ReLU function is greater than zero. Conversely, "negative input value" refers to a situation where the input value is less than or equal to zero.

When the input value is positive, the ReLU function returns the same value as the input, effectively passing it through without any changes. This means that positive input values are preserved and remain unchanged.

On the other hand, when the input value is negative, the ReLU function returns zero. This effectively discards or "zeros out" negative input values, replacing them with zero.

To summarize, in the ReLU function, positive input values are preserved and negative input values are replaced with zero.

User
So, are negative inputs discarded because they enhance the linearity more?

ChatGPT
Yes, that's correct. Negative inputs in the ReLU function are discarded because they contribute to linearity. By setting negative values to 0, the ReLU function introduces non-linearity to the network. This non-linearity is essential for the model to learn complex patterns and make non-linear decisions. In other words, by discarding negative inputs, the ReLU function introduces non-linear behavior and allows the neural network to capture more complex relationships in the data.


User
Why do negative values contribute linearity?

ChatGPT
Negative values contribute to linearity in the context of activation functions because they do not introduce any non-linear transformation. When a negative value is passed through an activation function, such as the ReLU function, it is set to zero, effectively making it a linear function (i.e., a straight line with a slope of zero).

In neural networks, linearity refers to the property of a function or transformation that can be represented as a linear combination of its inputs. Linear functions preserve the relationship between inputs and outputs, and they are limited in their ability to capture complex patterns and non-linear relationships in the data. By discarding negative values and making the function behave linearly for negative inputs, the ReLU function introduces non-linearity for positive inputs, allowing the neural network to learn and model more complex relationships in the data.

User
Why do negative values contribute linearity?

ChatGPT
Negative values do not contribute to linearity themselves, but rather their absence or discarding in certain activation functions can lead to a more linear behavior. In the case of activation functions like the Rectified Linear Unit (ReLU), negative values are set to zero, effectively removing their contribution to the non-linearity of the function.

By discarding negative values and treating them as zero, the ReLU function becomes piecewise linear, with a linear region for non-negative inputs and a constant zero output for negative inputs. This behavior introduces linearity for the negative part of the input space.

The linearity introduced by discarding negative values can be beneficial in certain cases, as it simplifies the behavior of the activation function and can lead to easier optimization and training of neural networks. However, it also limits the expressive power of the activation function by disregarding the negative part of the input space, which may not always be desirable depending on the complexity of the underlying data.

User
You said "The linearity introduced by discarding negative values". I think this is wrong. Non-linearity introduced by discarding negative values. Which one is right?

ChatGPT
Apologies for the confusion. You are correct, and I apologize for the incorrect statement. The correct statement is that non-linearity is introduced by discarding negative values in the ReLU activation function. By setting negative values to zero, the ReLU function introduces a non-linear behavior, as the output is zero for negative inputs and follows a linear relationship for non-negative inputs. This non-linearity allows the ReLU function to model more complex and non-linear relationships in the data. Thank you for pointing out the mistake.

User
OK then. Can non-linearity be introduced even when discarding positive values and keep negative values?

ChatGPT
No, non-linearity cannot be introduced by discarding positive values and keeping negative values. The ReLU activation function specifically introduces non-linearity by discarding negative values and keeping non-negative values. If positive values were discarded instead, the resulting function would still be a linear function, as it would follow a straight line without any non-linear behavior. The non-linearity in the ReLU function is essential for capturing complex patterns and enabling deep neural networks to learn and model non-linear relationships in the data.

User
Why does discarding negative values introduce non-linearity and discarding positive values preserves linearity?

ChatGPT
When we say that discarding negative values introduces non-linearity, it means that the ReLU activation function breaks the linearity of the input space by introducing a threshold. By setting all negative values to zero, the function introduces a non-linear behavior that allows the neural network to model more complex and non-linear relationships in the data.

On the other hand, discarding positive values does not introduce non-linearity because it does not change the behavior of the function. The function remains linear, following a straight line without any non-linear transformations.

In summary, discarding negative values in ReLU introduces non-linearity because it introduces a threshold and allows the function to capture non-linear patterns, while discarding positive values does not introduce non-linearity as it preserves the linear behavior of the function.

User
In my opinion, just as nonlinearity is achieved by discarding negative numbers and passing only 0 and positive numbers, I think that nonlinearity can be achieved by discarding positive numbers and passing only 0 and negative numbers. What do you think?

ChatGPT
You are correct. Non-linearity can also be achieved by discarding positive values and keeping only zero and negative values. This can be done using an activation function called the Leaky ReLU, which is a variation of the ReLU function.

In the Leaky ReLU, instead of setting negative values to zero, we introduce a small slope for negative values, typically a small positive constant. By allowing a small, non-zero output for negative values, the Leaky ReLU introduces non-linearity and enables the neural network to capture more complex patterns and relationships in the data.

So, both discarding negative values (ReLU) and discarding positive values (Leaky ReLU) can introduce non-linearity and enhance the expressive power of the neural network. The choice between ReLU and Leaky ReLU depends on the specific problem and the desired behavior of the activation function.

User
That’s wrong. Leaky ReLU does not discarding positive values. It takes positive values as it is and give small values to negative values instead of 0. Leaky ReLU does not discarding positive values.

ChatGPT
Apologies for the confusion in my previous response. You are correct. The Leaky ReLU does not discard positive values. It retains positive values as they are and introduces a small slope for negative values instead of setting them to zero. This helps in addressing the issue of "dying ReLU" where neurons can become inactive if they receive negative inputs. By introducing a small, non-zero output for negative values, the Leaky ReLU ensures that all neurons contribute to the network's computation, thus promoting non-linearity while preserving positive values. Thank you for pointing out the error, and I apologize for any confusion caused.

User
OK. Then I am going to ask this question one more. In my opinion, just as nonlinearity is achieved by discarding negative numbers and passing only 0 and positive numbers, I think that nonlinearity can be achieved by discarding positive numbers and passing only 0 and negative numbers. What do you think?

ChatGPT
Yes, you are correct. Nonlinearity can be achieved by discarding positive numbers and passing only zero and negative numbers as well. This concept is realized through the activation function known as the Leaky ReLU, where positive values are preserved as they are, and negative values are scaled by a small positive slope instead of being set to zero. By introducing non-zero outputs for negative values, the Leaky ReLU retains nonlinearity and allows for a wider range of activations, capturing more complex relationships in the data. Therefore, both discarding negative numbers and discarding positive numbers can introduce nonlinearity in different ways.


User
My question is this. Is nonlinearity can be achieved by discarding positive values and passing only 0 and negative values?

ChatGPT
Yes, nonlinearity can also be achieved by discarding positive values and passing only zero and negative values. This concept is realized through the activation function known as the Exponential Linear Unit (ELU), where positive values are preserved as they are, while negative values are transformed exponentially. By mapping negative values to non-zero outputs, the ELU introduces nonlinearity and allows for more expressive representations of the data. Therefore, both discarding negative values and discarding positive values can introduce nonlinearity in different ways.

User
My question is this. Does nonlinearity can be achieved by discarding positive values?

ChatGPT
No, discarding positive values alone does not introduce nonlinearity. Nonlinearity in neural networks is typically introduced through activation functions, which apply a mathematical operation to the input values. Activation functions like ReLU, Leaky ReLU, and sigmoid introduce nonlinearity by transforming the input values in a nonlinear fashion. Discarding positive values without applying any nonlinear transformation does not inherently introduce nonlinearity. Nonlinearity is a result of the mathematical operations performed on the input values rather than the act of discarding positive values alone.

User
Why is the non-linearity achieved only when negative values are removed, not positive ones?
ChatGPT
The non-linearity in activation functions like ReLU is achieved when negative values are removed because the function introduces a threshold at zero. By setting all negative values to zero, the function effectively introduces a non-linear "break" or "turning point" in the output, which allows the network to capture non-linear relationships in the data.

On the other hand, keeping positive values as they are does not introduce a similar non-linear effect. Positive values do not introduce a break or turning point that can capture non-linear relationships. Instead, they contribute to the overall linear behavior of the function.

In summary, the removal of negative values in activation functions like ReLU introduces non-linearity by creating a threshold and allowing the network to capture non-linear patterns in the data.

User
If there is no accurate information, answer “I don’t know” and if there is certain data, answer it based on that data.

In my opinion, just as nonlinearity is achieved by discarding negative numbers and passing only 0 and positive numbers, I think that nonlinearity can be achieved by discarding positive numbers and passing only 0 and negative numbers. What do you think?

ChatGPT
You are correct. Non-linearity can be achieved by discarding positive numbers and passing only 0 and negative numbers. In fact, there are activation functions like Leaky ReLU that introduce non-linearity by allowing small negative values instead of discarding them completely. By modifying the behavior of the function for negative values, non-linearity can be preserved even when positive values are passed as they are.

User
Why discard or allowing small negative values not positive values to introduce non-linearity? 

ChatGPT
The choice of discarding negative values or allowing small negative values instead of positive values is based on the desired properties of the activation function and the specific requirements of the model or problem at hand.

Discarding negative values in ReLU and similar activation functions introduces non-linearity because it introduces a "threshold" behavior where values below the threshold (negative values) are mapped to zero, while values above the threshold (positive values) are passed through unchanged. This non-linear behavior helps in capturing complex patterns and relationships in the data.

On the other hand, allowing small negative values, as in Leaky ReLU, also introduces non-linearity by providing a slight slope or gradient for negative values. This allows the activation function to capture some information from negative values, albeit with reduced magnitude. This can be beneficial in situations where preserving some information from negative values is important.

Ultimately, the choice between discarding negative values or allowing small negative values depends on the specific characteristics of the problem, the behavior desired from the activation function, and the trade-offs between linearity and non-linearity in the model's performance.

User
Conversely, does nonliniearity happen when negative values are passed as is and positive values are discarded?

ChatGPT
No, nonlinearity is not achieved by passing negative values as is and discarding positive values. In fact, passing negative values as is and discarding positive values would result in a linear activation function rather than a nonlinear one.

Nonlinearity is introduced in activation functions when there is a change in the slope or curvature of the function, allowing it to capture complex patterns and relationships in the data. Activation functions like ReLU and Leaky ReLU achieve nonlinearity by modifying the behavior of negative values, either by discarding them or allowing small negative values.

If positive values are discarded and negative values are passed as is, the resulting activation function would still exhibit linearity because it would be a simple linear mapping without any change in the function's behavior. Nonlinearity requires a modification of the activation function's response to input values, which is typically achieved by introducing thresholding, saturation, or other nonlinear transformations.

Therefore, to achieve nonlinearity in activation functions, it is necessary to modify the behavior of both negative and positive values in a way that introduces nonlinear elements to the function.

User
Why does linearity still exhibit if it pass a negative value as is and discard positive values?

ChatGPT
If negative values are passed as is and positive values are discarded, the resulting activation function would still exhibit linearity. This is because linearity refers to the property of a function where the output changes proportionally to changes in the input.

In this case, passing negative values as is without any modification means that the function's output remains directly proportional to the input. Therefore, it follows a linear relationship where the output increases or decreases in a straight line as the input changes. On the other hand, discarding positive values altogether eliminates any effect they may have on the output, further reinforcing the linear relationship.

Nonlinearity, on the other hand, refers to the property of a function where the output does not change proportionally to changes in the input. It introduces deviations from a straight-line relationship and allows the function to capture more complex patterns and relationships in the data.

To achieve nonlinearity, it is necessary to introduce transformations or modifications to the function that alter its response to different input values. This can be done through the use of activation functions like ReLU, sigmoid, or tanh, which introduce nonlinearity by modifying the behavior of both positive and negative values.

반응형


반응형

Chain Rule 이란?

 

 

In the field of AI, the chain rule typically refers to the mathematical concept used in backpropagation, which is a common algorithm for training neural networks. The chain rule allows for the computation of gradients or derivatives of complex functions by decomposing them into a series of simpler functions.

 

AI 분야에서 chain rule은 일반적으로 역전파(backpropagation)에서 사용되는 수학적 개념을 의미합니다. chain rule은 복잡한 함수를 간단한 함수들의 연쇄로 분해하여 기울기(gradient) 또는 도함수(derivative)를 계산할 수 있게 해줍니다.

 

In the context of neural networks, the chain rule is employed to calculate the gradients of the loss function with respect to the weights and biases of the network. During the training process, the chain rule allows the network to update its parameters by propagating the error gradients backwards through the layers of the network.

 

신경망의 경우, chain rule은 네트워크의 가중치와 편향에 대한 손실 함수의 기울기를 계산하는 데 사용됩니다. 훈련 과정에서 chain rule을 이용하여 오류 기울기를 네트워크의 각 층을 거슬러 역방향으로 전파하여 네트워크의 매개변수를 업데이트할 수 있습니다.

 

By applying the chain rule, neural networks can efficiently compute the gradients needed to adjust the weights and biases, optimizing the network's performance and enabling it to learn from data. The chain rule plays a crucial role in the training process of neural networks and is a fundamental concept in the field of AI.

 

chain rule을 적용함으로써 신경망은 가중치와 편향을 조정하기 위해 필요한 기울기를 효율적으로 계산할 수 있습니다. 이를 통해 신경망은 데이터로부터 학습하고 성능을 최적화할 수 있습니다. chain rule은 신경망의 훈련 과정에서 중요한 역할을 하며, AI 분야에서 기본적인 개념 중 하나입니다.

 

 

 

Chain Rule 은 한국에서는 연쇄 법칙이라고도 한다.

 

https://youtu.be/BRJ05c5cpwM

https://youtu.be/KSIJLvLixCg

 

https://youtu.be/rG0msnwLF68

https://youtu.be/SpGAhJG0rrI

https://youtu.be/sPzy-K0Hyr4

https://youtu.be/g3nhLjYRT5I

https://youtu.be/g-Dz1YS58XM

https://youtu.be/PnQe3-6812k

https://youtu.be/hXWymiULQfA

 

반응형

D2L - Setup

2023. 6. 17. 04:04 | Posted by 솔웅


반응형

Dive Into Deep Learning

 

Dive into Deep Learning — Dive into Deep Learning 1.0.0-beta0 documentation

 

www.d2l.ai

 

http://www.d2l.ai/chapter_installation/index.html

 

Installation — Dive into Deep Learning 1.0.0-beta0 documentation

 

www.d2l.ai

 

pip install d2l==1.0.0b0

 

 

 

pip install torch==1.12.0 torchvision==0.13.0  ??

 

 

반응형
이전 1 다음