Time Traveler

안녕하세요.

이번 글에서는 training 과정을 visualization 해주는 패키지를 소개하려고 합니다.

 

기본적으로 pytorch에서는 tensorboard를 사용하여 loss, accuracy 등 다양한 metrics와 weight, gradient 값들을 histogram으로 볼 수 있도록 summarywriter라는 가능을 제공하고 있습니다.

 

torch.utils.tensorboard import SummaryWriter

 

(↓↓↓SummaryWriter 사용법↓↓↓)

https://pytorch.org/docs/stable/tensorboard.html

 

torch.utils.tensorboard — PyTorch 1.9.0 documentation

torch.utils.tensorboard Before going further, more details on TensorBoard can be found at https://www.tensorflow.org/tensorboard/ Once you’ve installed TensorBoard, these utilities let you log PyTorch models and metrics into a directory for visualization

pytorch.org

 

 

 

하지만, 이외에 많은 분들이 "Weight and Biases"에서 제공하는 wandb 패키지를 이용해 학습과정들을 visualization하기도 하는데요. 이번 글에서는 wandb 패키지를 이용해 어떻게 visualization 할 수 있는지 살펴보도록 하겠습니다.

 

 

※이전 글에 있는 코드에 wandb 패키지를 적용하는 법을 설명하도록 할테니, 중간중간 코드가 이해안되시는 분들은 꼭 이전 글들을 봐주세요!

 

 

[필자의 개발환경]

OS: Window

가상환경: 아나콘다

딥러닝 프레임워크: Pytorch

IDE: Visual Studio Code

 

 

1. 회원가입 및 wandb 연동하기

1-1. wandb 패키지 설치하기

먼저,  제 경우에는 아나콘다 가상환경을 VS Code interpreter에 연동시켜 사용하고 있기 때문에 아나콘다에 wandb 패키지를 설치하도록 하겠습니다.

 

(↓↓↓ 아나콘다 가상환경에 다양한 패키지 설치 및 VS code 연동 방법↓↓↓)

https://89douner.tistory.com/74

 

5. 아나콘다 가상환경으로 tensorflow, pytorch 설치하기 (with VS code IDE, pycharm 연동)

안녕하세요~ 이번시간에는 아나콘다를 통해 2개의 가상환경을 만들고 각각의 가상환경에서 pytorch, tensorflow를 설치하는법을 배워볼거에요~ Pytorch: Python 3.7버전/ CUDA 10.1 버전/ Pytorch=1.4버전 Tensorf..

89douner.tistory.com

 

 

우선 "anaconda wandb"라고 검색하니 아래 사이트가 나옵니다. 해당 사이트에 접속해보겠습니다.

https://anaconda.org/conda-forge/wandb

 

Wandb :: Anaconda.org

 

anaconda.org

 

 

접속하니 아래와 같은 화면이 뜹니다. 아나콘다로 wandb를 설치하는 명령어를 알려주네요. 

해당부분을 복사합니다.

 

 

 

우선 저는 대부분의 패키지(pytorch 등)가 아나콘다 base라는 가상환경에 설치되어 있기 때문에, base 가상환경에 복사한 명령어를 입력하여 설치를 진행해주겠습니다.

 

 

1-2. Wandb (Weight and Biases) 회원가입

wandb 패키지를 이용하려면 "Weight and Biases"에 회원가입이 되어 있어야 합니다.

그래야 "Weight and Biases" 웹 사이트와 연동하여 visualization 결과들을 살펴볼 수 있기 때문이죠.

 

그럼 "Weight and Biases"에 회원 가입을 해보도록하겠습니다.

 

우선 아래 "Weight and Biases" 사이트에 접속합니다.

https://wandb.ai/site

 

Weights & Biases – Developer tools for ML

A central dashboard to keep track of your hyperparameters, system metrics, and predictions so you can compare models live, and share your findings.

wandb.ai

 

 

 

접속을 하시면 아래화면이 처음 등장하게됩니다. 그리고 회원가입 버튼 "Sign up"을 클릭해줍니다.

 

 

그럼 아래와 같이 회원가입 창이 뜹니다. 제 경우에는 github과 연동해서 사용하려 하기 때문에, "Sign up with GitHub"을 클릭해서 사용하도록 하겠습니다.

 

 

 

 

그리고 "Authorize wandb" 을 클릭해줍니다.

 

 

 

마지막으로 아래와 같이 계정생성에 필요한 정보를 입력하시면 회원가입이 완료가 됩니다.

 

 

 

회원가입 후, 로그인을 하시면 아래와 같은 화면이 나타납니다.

 

 

우선 이 화면은 대기해 놓고 아나콘다 가상환경과 wandb를 연동하는 작업부터 하겠습니다.

 

 

 

 

 

 

2. 아나콘다 가상환경과 wandb 연동하기

앞서 언급했듯이 "아나콘다 가상환경을 VS Code interpreter에 연동시켜 사용하고 있고", Weight and Biases 웹 사이트와 연동하여 visualization 결과"를 볼 수 있기 때문에, 아나콘다 가상환경에서 Weight and Biases 웹 사이트와 연동시켜주어야 합니다.

 

연동 방식은 간단합니다.

먼저 아래와 같이 순서를 진행합니다.

• base 가상환경 프롬프트 열기
• wandb login 명령어 입력
• 아래 빨간색 박스 사이트 복사

 

• 위에서 복사한 사이트 접속시 아래 화면이 출력 해당 인증키 복사

 

• 복사한 인증키 아래 빨간색 밑줄 부분에 붙여넣기하고 엔터 (참고로 저는 복붙이 잘 안돼서 메모장에 복붙한다음 하나씩 인증키를 입력했습니다;;;;)

 

 

 

연동이 완료 되었습니다!

 

 

 

 

3. Project 생성해주기

VS Code에서도 task 마다 별도의 project를 만들게 됩니다. 그렇다면 각각의 task마다 visualization 하려는 정보들도 모두 다르겠죠? 그래서, task 별로 wandb의 visualization project를 만들어 주는것이 좋습니다. (그래야 task 마다 visualization 기록들을 용이하게 관리 할 수 있어요.)

 

 

 

 

그럼 WandB(=W&B) project를 생성해보겠습니다. 

먼저 좌측 상단 "Home" 부분에 "Projects"→"Create new project"를 클릭 해주세요

 

 

 

 

아니면 아래 사이트(="wandb.ai/username")에 직접 접속해서 우측에 있는 "Create new project"를 클릭해주세요.

 

Project name을 설정하고 생성해줍니다.

우선 저는 개인용으로 사용할 거라 "private" 버전으로 만들었습니다.

 

 

 

 

Project가 생성되면 아래 화면이 출력됩니다.

이제 VS code에서 wandb 패키지로 visualization 관련 코드를 입력하고 실행시키면, 아래 화면에 visualization 결과들이 생성됩니다. 그럼 이제 VS code에서 관련 코드들을 입력해볼까요? 

 

 

 

3. VS code에 visualization을 위한 wandb 관련 코드 입력하기

제일 먼저 할 것은 wandb 패키지를 import 시켜주는 것입니다.

현재 "alb_train2.py"에 train 관련 코드가 들어가 있습니다.

 

("alb_train2.py" 파일은 VS code 상에서 UNet segmentation project에 속해있는데, 해당 project가 base 아나콘다 가상환경 interpreter에 연동되어 있습니다. 앞서 base 아나콘다에 wandb 패키지를 설치했기 때문에 에러없이 import wandb 를 수행할 수 있습니다.) 

 

 

그리고 train_model 함수 부분에 먼저 두 개의 코드를 입력해줍니다.

• wandb.init()
• wandb.watch()

def train_model(net, fn_loss, optim, num_epoch):
    wandb.init(project='test', entity='douner89') #추가된 코드
    wandb.watch(net, fn_loss, log="all", log_freq=10) #추가된 코드
    since = time.time()

    best_model_wts = copy.deepcopy(net.state_dict())
    best_loss = 100

 

 

3-1. wandb.init()

먼저, wandb.init() 함수에 대해 설명해보도록 하겠습니다.

 

(↓↓↓ wandb.init() API ↓↓↓)

https://docs.wandb.ai/ref/python/init

 

wandb.init

 

docs.wandb.ai

 

 

 

먼저 위의 사이트를 접속한 후, 제일 먼저 눈에 보이는 문장은 아래와 같습니다.

 

"you could add wandb.init() to the beginning of your training script as well as your evaluation script"

 

위와 같은 설명을 토대로 train 함수 첫 번째 부분에 wandb.init() 함수를 구현해놨습니다.

 

wandb.init() 함수 인자들은 아래와 같이 설명이 나와있습니다.

 

 

 

이 중에서 우선 두 가지 argumetns만 설명하도록 하겠습니다.

• project: 앞서 생성한 project 명 (←"그림14" 참고)
• entity: 앞서 계정 생성시 설정한 user name (←"그림14" 참고)

해당 project, entity 명을 제대로 입력 해주어야 연동된 weight and biases 사이트에 정보들이 전송이됩니다.

 

 

 

 

 

3-2. wandb.watch()

이번엔 wandb.watch() 함수에 대해서 알아보겠습니다.

 

(↓↓↓ wandb.watch() API ↓↓↓)

https://docs.wandb.ai/ref/python/watch

 

wandb.watch

 

docs.wandb.ai

 

 

해당 API reference를 살펴보면 아래와 같은 문구가 나옵니다.

 

"Hooks into the torch model to collect gradients and the topology."

 

즉, gradient, topology와 관련 정보를 visualization 해주기 위해 입력해주는 코드라고 하네요.

결국 이 코드로 인해 gradient, topology 값들을 visualization 해줄 수 있게 됩니다. 

 

아래 argument에서 3가지 정도만 설명하겠습니다.

• models: 딥러닝 모델
• criterions: loss function
• log: all이라고 설정하면, gradient, parameters와 관련된 값들을 visualization 해서 볼 수 있습니다.

 

 

 

3-3. wandb.log()

train_model 함수의 "#추가된 코드3" 부분을 보면 "wandb.log"라는 코드를 볼 수 있으실 겁니다.

 

(↓↓↓ wandb.log() API ↓↓↓)

https://docs.wandb.ai/ref/python/log

 

wandb.log

 

docs.wandb.ai

 

 

위의 API에서 설명하듯이, wandb.log 함수에 내가 visualization 하고 싶은 argument를 넘겨줄 수 있습니다. 아래 코드에서는 epoch과 training loss를 visualization 해주기 위해 아래와 같이 입력했습니다.

 

wandb.log({'Epoch': epoch, 'loss': np.mean(loss_arr)})

 

(※wandb.log() API를 보면 알 수 있듯이 다양한 정보들을 visualization (ex: gradient 'histogram', image, etc...) 를 할 수 있으니 참고해주세요)

 

# TRAIN MODE
def train_model(net, fn_loss, optim, num_epoch):
    wandb.init(project='test', entity='douner89') #추가된 코드1
    wandb.watch(net, fn_loss, log="all", log_freq=10) #추가된 코드2
    since = time.time()

    best_model_wts = copy.deepcopy(net.state_dict())
    best_loss = 100

    for epoch in range(st_epoch + 1, num_epoch + 1):
        net.train()
        loss_arr = []
        batch_order=0

        for batch, data in enumerate(loader_train, 1):
            batch_order=batch_order+1
            data['label'] = data['label']/255.0

            input = data['input']
            label = data['label']

            # forward pass
            label = data['label'].to(device)
            input = data['input'].to(device)

            output = net(input)

            # backward pass
            optim.zero_grad()

            loss = fn_loss(output, label)
            loss.backward()

            optim.step()

            # 손실함수 계산
            loss_arr += [loss.item()]

            print("TRAIN: EPOCH %04d / %04d | BATCH %04d / %04d | Batch LOSS %.4f" %
                (epoch, num_epoch, batch, num_batch_train, np.mean(loss_arr)))
        
        print("#############################################################")
        print("TRAIN: EPOCH %04d | Epoch LOSS %.4f" %
                (epoch, np.mean(loss_arr)))
        print("#############################################################")
        wandb.log({'Epoch': epoch, 'loss': np.mean(loss_arr)}) #추가된 코드3



        with torch.no_grad():
            net.eval()
            loss_arr = []

            for batch, data in enumerate(loader_val, 1):
                data['label'] = data['label']/255.0

                # forward pass
                label = data['label'].to(device, dtype=torch.float32)
                input = data['input'].to(device, dtype=torch.float32)

                output = net(input)

                # 손실함수 계산하기
                loss = fn_loss(output, label)

                loss_arr += [loss.item()]

                print("VALID: EPOCH %04d / %04d | BATCH %04d / %04d | LOSS %.4f" %
                        (epoch, num_epoch, batch, num_batch_val, np.mean(loss_arr))) 

            epoch_loss = np.mean(loss_arr)

            # deep copy the model
            if epoch_loss < best_loss:
                best_loss = epoch_loss
                best_model_wts = copy.deepcopy(net.state_dict())

        print()
    
    time_elapsed = time.time() - since
    print('Training complete in {:.0f}m {:.0f}s'.format(
        time_elapsed // 60, time_elapsed % 60))
    print('Best val loss: {:4f}'.format(best_loss))
    net.load_state_dict(best_model_wts)
    return net

 

 

 

 

 

4. Visualization 결과보기

다시 weight and biases 사이트 화면으로 돌아오겠습니다.

 

4-1. wandb.log() 부분 visualization 하기

하지만, 코드를 실행시킨 후, charts 부분을 보면 아래와 같이 wandb.log()에 설정했던 log들이 기록됨을 알 수 있습니다. "wandb.log()"에 epoch과 loss를 설정했기 때문에 epoch, loss값이 visualization 되는 것을 볼 수 있습니다.

 

 

 

4-2. wandb.watch() 부분 visualization 하기 (Feat. gradient)

또한, 앞서 "wandb.watch()" 함수를 통해 gradient, parameters 값을 visualization 할 수 있다 언급한 바 있습니다.

 

먼저, gradient 값부터 확인해보겠습니다.

 

 

아래 그림에서 X, Y축의 의미하는 바는 다음과 같습니다.

• X축: epoch (필자의 코드에서는 epoch=30으로 설정되어 있음)
• Y축: gradient 값

 

 

 

 

앞서 구현한 model의 변수명을 기반으로 해당 위치에 있는 layer에 전파되는 gradient 값을 확인해 볼 수 있습니다.

 

 

 

 

5 epoch에 마우스 포인터를 올려놓으면 해당 epoch 단계에서 얻는 gradient 값들의 분포 (histogram) 를 알 수 있습니다.

 

 

 

그리고 특정 epoch 부분들의 gradient 값을 디테일하게 보고 싶으면 해당 부분을 drag 하면 됩니다. 

 

 

 

또 다른 layer들의 gradient 값을 확인하고 싶다면, 아래 화면의 우측 하단 빨간색 부분을 클릭해주시면 됩니다.

 

 

 

이러한 gradient 값은 다양하게 이용될 수 있지만, 그 중에 가장 대표적인 것이 exploding gradient, vanishing gradient를 확인해보는 것입니다.

 

예를 들어, conv2 weight의 gradient 값도 대략 10^5로 굉장히 큰데, conv1 weight의 gradient 값이 대략 10^7 이면  exploding gradient를 의심해볼 수 있겠죠?

• 3e+5 →  3*10^5 → 대략 10^5

 

(↓↓↓ W&B를 이용해 exploding gradient, vanishing gradient를 보여주는 사례 ↓↓↓)

https://wandb.ai/site/articles/debugging-neural-networks-with-pytorch-and-w-b-using-gradients-and-visualizations

 

Debugging Neural Networks with PyTorch and W&B Using Gradients and Visualizations on Weights & Biases

by Ayush Thakur — Debugging Neural Networks with PyTorch and W&B Using Gradients and Visualizations

wandb.ai

 

 

 

 

 

4-3. wandb.watch() 부분 visualization 하기 (Feat. parameters)

gradient 값 외에, conv filter 값들도 확인해 볼 수 있습니다.

이러한 Conv filter 값들을 통해 유의미한 통계분석도 해볼 수 있겠네요

 

 

 

 

5. ETC

위에서 설명한 것 외에 다양한 정보들을 visualization 해서 볼 수 있습니다.

 

먼저, 왼쪽 빨간색 박스 부분을 클릭하면 system 즉, hardward (CPU, Memory, GPU) 관련 정보들을 살펴 볼 수 있습니다. 

 

 

 

아래 빨간색 네모 박스는 log 관련 정보를 보여주는 곳인데, 학습 시 vs code에 기록되는 log 들을 그대로 볼 수 있습니다.

 

 

 

6. 다른 결과들과 비교하기

실험을 하다보면 다양한 hyper-parameter 조합을 통해 결과를 내야하는 경우가 많습니다.

앞에서는 learning rate 부분을 1e-3으로 설정하고 실행했습니다.

그렇다면 이번에는 le-2로 설정하고 실행해보겠습니다.

 

 

 

왼쪽 빨간색 네모 부분에 새로운 process가 실행되는 것을 볼 수 있고, 이전 실험 결과(="solar-toterm-19")와 중첩으로 visualization해서 볼 수 있으니, 비교가 수월할 수 있겠네요.

 

 

 

하지만 위와 같은 경우 어떠한 hyper-parameter 조합으로 실험한 결과인지 모르기 때문에, 아래와 같이 해당 hyper-parameter 조합에 대한 정보를 process name으로 설정해주면 좋습니다.

 

 

위에서 설명한 방법 외에 다양한 visualization 기능들이 있습니다. 예를 들어, line plot, scatter plot 형태로도 보여 줄 수 있고, GAN 관련한 정보들을 visualization 해줄 수 도 있고, hyper-parameter 중에 중요한게 무엇인지도 알려주는 기능도 있습니다. 이와 관련된 부분은 추후 다루도록 하겠지만, 아래 영상을 보시면 상당 부분 혼자서 하실 수 있을거라 생각됩니다.

 

https://www.youtube.com/watch?v=91HhNtmb0B4 

 

 

 

그 외 참고하면 좋을 사이트를 아래 링크해두겠습니다.

https://theaisummer.com/weights-and-biases-tutorial/

 

A complete Weights and Biases tutorial | AI Summer

Learn about the Weights and Biases library with a hands-on tutorial on the different features and visualizations.

theaisummer.com

 

https://analyticsindiamag.com/hands-on-guide-to-weights-and-biases-wandb-with-python-implementation/

 

 

사실 wandb 패키지의 가장 강력한 기능은 다양한 hyper-parameter 조합을 자동으로 실행해주고 관련 결과들을 visualization 하여 어떤 parameter가 중요한지 보여주는 것입니다. 이러한 기능은 wandb의 sweep을 통해 구현할 수 있는데, 이 부분은 정리가 되는데로 업로드 하겠습니다.

 

감사합니다. 

안녕하세요.

이번 글에서는 pytorch를 이용해서 대표적인 CNN 모델인 ResNet을 implementation 하는데 필요한 코드를 line by line으로 설명해보려고 합니다.

 

ResNet을 구현할 줄 아시면 전통적인 CNN 모델들은 자유롭게 구현하는데 어려움이 없을거라 생각됩니다. 

 

우선 pytorch에서 resnet 모델을 불러오는 코드는 아래 한 줄로 가능합니다.

 

model = resnet50().to(device)

 

그렇다면 resnet50() 이라는 함수가 어떤 과정을 통해 실행되는지 살펴봐야겠죠?

지금부터 이 과정을 순차대로 살펴보도록 하겠습니다.

 

 

※ 최종코드는 제일 아래에 있으니 참고해주세요!

※ 대부분 PPT 슬라이드에 설명한 내용을 이미지로 만들어 업로드했기 때문에 글씨가 잘 안보일 수도 있습니다. 그래서 PPT파일을 따로 첨부 하도록 하겠습니다.

 

ResNet pytorch.pptx

7.48MB

 

 

 

0. ResNet() 함수 호출

• 먼저 resnet50()을 호출하면 ResNet(BottleNeck, [3,4,6,3]) 함수를 호출하게됩니다.
• ResNet 함수 내부를 대략적으로 살펴보면 ResNet50 구조를 파악할 수 있습니다.

 

 

1. (BottleNeck 적용 전) 첫 번째 conv layer

• ResNet 함수에서 첫 번째 conv layer 부터 살펴보도록 하겠습니다.

 

 

 

 

2. 두 번째 Conv layer

• 두 번째 Conv layer 부터 bottleneck이 적용됩니다. 앞서 노란색 영역인 첫 번째 conv layer를 지나면, 아래 빨간색 영역의 첫 번째 bottleneck 연산이 진행됩니다.
• 우선 첫 번째 bottleneck을 간단히 도식화하면 아래와 같이 나타낼 수 있습니다.

 

 

• Bottleneck이 포함된 conv layer를 생성하기 위해 make_layer 함수가 실행되야 하는데, make_layer 함수에 작성된 python 기본 문법들을 먼저 설명하겠습니다. 
  • 연산자를 이용한 리스트 생성
  • for in 반복문 (with 리스트)
  • 리스트 인자 함수
  • Sequential 함수

 

• sequential 함수 설명

 

 

2-1. 두 번째 Conv layer에서 첫 번째 BottleNeck 적용 (make_layer(), BottleNeck()=block() 함수 호출)

 

 

 

 

2-2. 두 번째 Conv layer에서 두 번째 BottleNeck 적용 (make_layer(), BottleNeck()=block() 함수 호출)

 

 

 

2-3. 두 번째 Conv layer에서 세 번째 BottleNeck 적용 (make_layer(), BottleNeck()=block() 함수 호출)

 

 

 

 

 

 

 

3. 세 번째 Conv layer

 

 

3-1. 세 번째 Conv layer에서 첫 번째 BottleNeck 적용 (make_layer(), BottleNeck()=block() 함수 호출 + Down_sampling)

• 여기서 부터는 첫 번째 bottleNeck에 shortcut (for skip connection) 적용을 위해 down_sampling이 된다는 점을 알아두시면 좋을 것 같습니다.
• Down_sampling은 conv filter의 stride를 2로 설정함으로써 진행이 됩니다.

 

 

 

3-2. 세 번째 Conv layer에서 두 번째 BottleNeck 적용 (make_layer(), BottleNeck()=block() 함수 호출)

 

 

 

3-3. 세 번째 Conv layer에서 세 번째 BottleNeck 적용 (make_layer(), BottleNeck()=block() 함수 호출)

• block 함수 부분은 이전과 설명이 동일 하므로 이제부터는 생략하겠습니다.

 

 

 

 

 

3-4. 세 번째 Conv layer에서 세 번째 BottleNeck 적용 (make_layer(), BottleNeck()=block() 함수 호출)

 

4, 5. 네 번째 Conv layer, 다섯 번째 Conv layer

• 여기서부터는 위에서 설명한 내용의 반복이라 make_layer, block 함수 실행과정은 생략하도록 하겠습니다.

 

 

 

6. Average pooling, FC layer, Softmax

 

 

 

7. Weight initialization

 

 

(↓↓↓ 가중치 초기화 관련 API ↓↓↓)

https://pytorch.org/docs/stable/nn.init.html

 

 

 

 

 

8. Model Show

• 앞서 작성한 코드가 올바로 작성됐는지 해당 모델 구조를 들여다보는 세 가지 방법에 대해서 알아보겠습니다.

8-1. model.modules()

 

 

 

8-2. model.named_parameters()

 

 

8-3. summary()

 

 

 

 

 

 

9. 최종 코드

# model
import torch
import torch.nn as nn
import torch.nn.functional as F
from torchsummary import summary

class ResNet(nn.Module):
    def __init__(self, block, num_block, num_classes=10, init_weights=True):
        super().__init__()

        self.in_channels=64

        self.conv1 = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        )

        self.conv2_x = self._make_layer(block, 64, num_block[0], 1)
        self.conv3_x = self._make_layer(block, 128, num_block[1], 2)
        self.conv4_x = self._make_layer(block, 256, num_block[2], 2)
        self.conv5_x = self._make_layer(block, 512, num_block[3], 2)

        self.avg_pool = nn.AdaptiveAvgPool2d((1,1))
        self.fc = nn.Linear(512 * block.expansion, num_classes)

        # weights inittialization
        if init_weights:
            self._initialize_weights()

    def _make_layer(self, block, out_channels, num_blocks, stride):
        strides = [stride] + [1] * (num_blocks - 1)
        layers = []
        ith_block = 1
        for stride in strides:
            layers.append(block(self.in_channels, out_channels, stride, ith_block))
            self.in_channels = out_channels * block.expansion
            ith_block = ith_block+1

        return nn.Sequential(*layers)

    def forward(self,x):
        output = self.conv1(x)
        output = self.conv2_x(output)
        x = self.conv3_x(output)
        x = self.conv4_x(x)
        x = self.conv5_x(x)
        x = self.avg_pool(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

    # define weight initialization function
    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                nn.init.normal_(m.weight, 0, 0.01)
                nn.init.constant_(m.bias, 0)


def resnet50():
    return ResNet(BottleNeck, [3,4,6,3])

class BottleNeck(nn.Module):
    expansion = 4
    def __init__(self, in_channels, out_channels, stride=1, ith_block=1):
        super().__init__()

        self.residual_function = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(),
            nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(),
            nn.Conv2d(out_channels, out_channels * BottleNeck.expansion, kernel_size=1, stride=1, bias=False),
            nn.BatchNorm2d(out_channels * BottleNeck.expansion),
        )

        self.shortcut = nn.Sequential()

        if stride == 1 and ith_block == 1: #첫 번째 block에서의 shortcut (or identity) 을 적용해주기 위해서는 channel 조정필요
            self.shortcut = nn.Sequential(nn.Conv2d(in_channels, out_channels * BottleNeck.expansion, kernel_size=1, stride=1), 
                                          nn.BatchNorm2d(out_channels*BottleNeck.expansion))

        if stride != 1 or in_channels != out_channels * BottleNeck.expansion: #feature size_downsampling
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels*BottleNeck.expansion, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_channels*BottleNeck.expansion)
            )
            

        self.relu = nn.ReLU() 

    def forward(self, x):
        x = self.residual_function(x) + self.shortcut(x)
        x = self.relu(x)
        return x

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = resnet50().to(device)
x = torch.randn(3, 3, 224, 224).to(device)
output = model(x)
print(output.size())

for name, param in model.named_parameters():
    print(name, param.size())

for m in model.modules():
    print(m)

#ResNet50 모델 summary 
summary(model, (3, 224, 224), device=device.type)

 

 

 

 

지금까지 ResNet50을 pytorch로 구현한 code에 대해서 설명해봤습니다.

다음 글에서는 Pretrained model를 불러드려와 transfer learning을 적용시키는 코드에 대해 설명하도록 하겠습니다.

안녕하세요.

이번 글에서는 CNN 모델 학습을 위해 학습 데이터들을 로드하는 코드에 대해 설명드리려고 합니다.

 

아래 사이트의 코드를 기반으로 설명드리도록 하겠습니다.

https://pytorch.org/tutorials/beginner/transfer_learning_tutorial.html

 

Transfer Learning for Computer Vision Tutorial — PyTorch Tutorials 1.9.0+cu102 documentation

Note Click here to download the full example code Transfer Learning for Computer Vision Tutorial Author: Sasank Chilamkurthy In this tutorial, you will learn how to train a convolutional neural network for image classification using transfer learning. You

pytorch.org

 

 

우선 데이터를 로드하는 과정을 총 6단계로 나누어 설명하도록 하겠습니다.

from torchvision import datasets, models, transforms

 

위의 코드를 보면 torchvision에서 transforms, datasets 이라는 패키지가 사용되었다는걸 확인할 수 있습니다. Pytorch에는 torchvision이라는 패키지를 이용해 다양한 computer vision 관련 task를 수행할 수 있습니다. 각각의 패키지들 (datasets, transforms, models) 에 대해서는 위의 코드를 분석하면서 같이 설명하도록 하겠습니다.

 

 

https://pytorch.org/vision/stable/index.html

 

torchvision — Torchvision 0.10.0 documentation

Shortcuts

pytorch.org

 

 

1. transforms (Feat. Data Augmentation)

•  transforms라는 패키지는 말 그대로 이미지를 transformation (=augmentation) 해주는 기능들을 제공해주고 있습니다.
• 우리가 augmentation을 하기 위한 crop, resize, flip 등은 모두 이미지에 transformation이 적용된 상태입니다.

https://pytorch.org/vision/stable/transforms.html

 

torchvision.transforms — Torchvision 0.10.0 documentation

torchvision.transforms Transforms are common image transformations. They can be chained together using Compose. Most transform classes have a function equivalent: functional transforms give fine-grained control over the transformations. This is useful if y

pytorch.org

 

from torchvision import transforms

 

• 위의 코드를 살펴보면 compose 함수인자에 transforms 객체들의 list를 입력 받습니다.
• 이것이 의미하는 바가 무엇일까요? 계속해서 알아보도록 하겠습니다. 

 

 

• data_transforms 자체는 dictionary로 정의되었습니다.
• 그리고 각 key에 해당 하는 value 값은 클래스 객체 Compose인 것을 알 수 있습니다.
• Compose 객체에 다양한 인자 값들이 포함되어 있는데, 이 인자 값들이 augmentation이 적용되는 순서라고 보시면 됩니다.
• EX) data_tranforms['train']의 경우
  1. RandomResizedCrop 수행
     • scale → Specifies the lower and upper bounds for the random area of the crop, before resizing. The scale is defined with respect to the area of the original image.
     • ratio → lower and upper bounds for the random aspect ratio of the crop, before resizing.
  2. RandomHorizontalFlip 수행
     • p=0.5 → 50%의 확률로 RandomHorizontalFlip 실행
  3. ToTensor 수행
     • 처음 로드되는 이미지 형태를 딥러닝 학습 format에 맞는 tensor 형태로 변경
     • Converts a PIL Image or numpy.ndarray (H x W x C) in the range [0, 255] to a torch.FloatTensor of shape (C x H x W) in the range [0.0, 1.0]
  4. Normalize 수행
     • 이미지 전처리 (Preprocessing)
     • Normalization에 들어가는 값들이 어떻게 계산되는지는 아래 PPT를 참고해주세요.

Preprocessing (normalization).pptx

2.50MB

 

 

 

 

2. datasets(Feat. Data Augmentation)

• datasets.ImageFolder를 이용하면 이미지 디렉터리에 존재하는 이미지 메타정보 (ex: 이미지 개수, augmentation 기법들, etc..) 등을 하나의 tuple 형태로 저장할 수 있습니다 ← ImageFolder의 return 형태는 tuple
• 나중에 DataLoader를 이용해 실제 이미지를 load 할 때, 이미지 메타정보(=tuple 형태)들을 이용해 쉽게 load할 수 있습니다 ← 뒤에서 설명    
  • root: Root directory of dataset 
  • transforms:  A function/transform that takes in an PIL image and returns a transformed version (ex: transforms.RandomCrop)

 

from torchvision import datasets
import os

 

※os.path.join 함수 예시 ↓↓↓

 

• 아래 결과를 보면 이미지 폴더의 메타정보들을 확인할 수 있습니다.
  • 'train': Dataset Image Folder
  • Number of datapoints: train 폴더에 들어있는 총 이미지 개수
  • Transform: 적용될 augmentation 순서 

 

 

https://pytorch.org/vision/stable/datasets.html

 

torchvision.datasets — Torchvision 0.10.0 documentation

torchvision.datasets All datasets are subclasses of torch.utils.data.Dataset i.e, they have __getitem__ and __len__ methods implemented. Hence, they can all be passed to a torch.utils.data.DataLoader which can load multiple samples in parallel using torch.

pytorch.org

 

 

• 아래 코드는 dictionary 자료형을 for 문으로 만드는 문법입니다.

• dataset_size 변수는 딥러닝 모델(CNN)을 학습 시킬 때 epoch 단위의 loss or accuracy 산출을 위해 이용됩니다. (자세한 설명은 train을 구현하는 함수에서 설명하도록 하겠습니다)

 

 

 

• train 폴더를 보면 총 5개의 class가 있다는걸 확인 할 수 있습니다.
• image_datasets['train'].classes을 이용하면 아래 폴더를 기준으로 class 명들을 string 형태로 사용할 수 있게 됩니다.

 

 

 

※이번 코드에서는 포함되어 있진 않지만, datasets 패키지의 첫 번째 활용도는 cifar10, caltech101, imagenet 과 같이 범용적으로 쓰이는 데이터를 쉽게 다운로드 받아 이용할 수 있게 해준다는 점입니다. 상식으로 알아두시면 좋습니다!

 

 

 

 

 

3. DataLoader

• At the heart of PyTorch data loading utility is the torch.utils.data.DataLoader class.
• 딥러닝에서 이미지를 load 하기 위해서는 batchsize, num_workers 등의 사전 정보들을 정의해야합니다. (※torch.utils.data.DataLoader가 이미지를 GPU에 업로드 시켜주는 코드가 아니라, 사전 정보들을 정의하는 역할만 한다는 것을 알아두세요!) 
  • image_datasets[x]: 예를 들어, image_datasets['train']인 경우 train 폴더에 해당하는 클래스들의 이미지 경로를 설정해줍니다.
  • batch_size: 학습을 위한 batch size 크기를 설정해줍니다.
  • shuffle: 이미지 데이터를 불러들일 때, shuffle을 적용 여부를 설정해줍니다.
  • num_workers: 바로 아래에서 따로 설명
• 아래 코드 역시 dataloaders라는 dictionary 형태의 변수를 for 문으로 생성하는 코드 입니다. 

 

[num_workers]

• 학습 이미지를 GPU에 할당시켜 주기 위해서는 CPU의 조력이 필요합니다. 즉, CPU가 학습 이미지를 GPU에 올려주는 역할을 하는 것이죠.
• 좀 더 구체적으로 말하자면, CPU에서 process 생성해 학습 이미지를 GPU에 업로드 시켜주는 방식입니다.
• num_workers는 CPU가 GPU에 이미지를 업로드 할 때, 얼마나 많은 subprocess를 이용할지를 결정하는 인자(argument)라고 생각하시면 됩니다. 
  • how many subprocesses to use for data loading. 0 means that the data will be loaded in the main process. (default: 0)

(↓↓↓process 관련해서 정리해 놓은 글↓↓↓)

https://89douner.tistory.com/150

 

1.Process와 CPU scheduling

안녕하세요~ 이번시간에는 CPU의 스펙중 가장 큰 부분을 차지하는 코어와 스레드라는 개념에 대해서 알아보도록 할게요! 이번 시간은 다른 시간과는 다르게 C언어의 지식이 어느정도 있어야 이

89douner.tistory.com

 

• 만약 num_workers를 적게 설정하면 어떻게 될까요?
  • num_workers를 0으로 설정했을 때 (=a main process), CPU가 하나의 이미지를 GPU에  업로드 하는 시간을 1초라고 가정해보겠습니다.
  • 이 때, 업로드된 이미지를 GPU에서 처리 (for CNN training) 를 하는 것이 0.1초라고 가정한다면, 다음 이미지를 업로드 할 때 까지 0.9초 동안 GPU는 놀게(idle)됩니다. (아래 "그림14"에서 빨간색 간격 → CPU에서 GPU로 이미지 데이터를 넘기기 위해 수행되는 전처리 과정)
• 결국 CPU에서 GPU로 이미지를 넘겨주는 작업을 빠르게 증가시키기 위해서는 여러 subprocess를 이용해 이미지들을 GPU에 업로드 시켜주어야 합니다. 다시 말해, 다수의 process를 이용해서 CPU에서 GPU로 이미지 데이터를 넘기기 위한 전처리 시간을 축소시켜주는 것이죠.
• 이렇게 num_workers를 증가하여 GPU에 이미지를 업로드 시키는 속도가 빨라지면, GPU가 놀지 않고 열심히 일하게 될 것입니다. → GPU 사용량(이용률)이 증가하게 된다고도 할 수 있습니다. 
  • More num_workers would consume more memory usage but is helpful to speed up the I/O process.

 

• 하지만, CPU가 GPU에 이미지를 업로드 시켜주는 역할은 수 많은 CPU의 역할 중 하나입니다.
• 즉, num_workers를 너무 많이 설정해주어 CPU코어들을 모두 dataload에 사용하게 되면, CPU가 다른 중요한 일들을 못하게 되는 상황이 발생되는 것이죠.
  • CPU의 코어 개수는 물리적으로 한정되어 있습니다.

 

(↓↓↓Core(코어)에 대한 개념을 정리한 글↓↓↓)

https://89douner.tistory.com/151

 

2.Core 그리고 CPU,Memory,OS간의 관계 (32bit 64bit; x86, x64)

안녕하세요~ CPU를 보시면 x86, x64 아키텍처라는 걸 본적있으시죠? 폴더갖은 곳에서도 x86, x64 폴더가 따로 존재하는것도 본적있으실거에요! 이번 시간에는 x86, x64가 어떤 개념인지 알아보기 위해 C

89douner.tistory.com

 

• num_workers를 어떻게 설정하면 좋은지에 대해서는 pytorch forum에서도 다양한 의견들이 나오고 있습니다.

https://discuss.pytorch.org/t/guidelines-for-assigning-num-workers-to-dataloader/813

 

Guidelines for assigning num_workers to DataLoader

I realize that to some extent this comes down to experimentation, but are there any general guidelines on how to choose the num_workers for a DataLoader object? Should num_workers be equal to the batch size? Or the number of CPU cores in my machine? Or to

discuss.pytorch.org

 

• 보통 코어 개수의 절반 정도로 num_workers를 설정하는 경우도 있지만, 보통 batch size를 어떻게 설정해주냐에 따라서 num_workers를 결정해주는 경우가 많습니다. 
• 경험적으로 batch_size가 클 때, num_workers 부분도 크게 잡아주면 out of memory 에러가 종종 발생해서, num_workers 부분을 줄이거나, batch_size 부분을 줄였던 것 같습니다. (이 부분은 차후에 다시 정리해보도록 하겠습니다.)

 

※num_workers에 대한 설명은 아래 reference를 참고했습니다.

https://jybaek.tistory.com/799

 

DataLoader num_workers에 대한 고찰

Pytorch에서 학습 데이터를 읽어오는 용도로 사용되는 DataLoader는 torch 라이브러리를 import만 하면 쉽게 사용할 수 있어서 흔히 공식처럼 잘 쓰고 있습니다. 다음과 같이 같이 사용할 수 있겠네요. fr

jybaek.tistory.com

 

 

• torch.utils.data.Dataloader를 통해 생성한 dataloaders 정보들을 출력하면 아래와 같습니다.

 

 

 

 

4. GPU에 업로드 될 이미지 확인하기

앞서 "torch.utils.data.DataLoader"를 통해 이미지를 GPU에 올릴 준비를 끝냈으니, 어떤 이미지들의 GPU에 올라갈 지 확인해보겠습니다.

 

 

inputs에 어떤 정보들이 저장되어 있는지 알아보도록 하겠습니다.

 

 

 

• inputs 데이터에는 batch 단위로 이미지들이 저장되어 있는 것을 확인할 수 있습니다.

 

 

• 앞서 dataset_sizes['train'] 에서 확인 했듯이, train 원본 이미지 개수는 ‘2683’개 입니다.
• transformer.compose()를 통해 생성된 train 이미지 개수도 ‘2683’개 이다.
• imshow를 통해 생성된 이미지를 봤을 때, data augmentation에 의해 데이터 수가 늘어난게 아니라, 본래 2683개의 데이터 자체내에서 augmentation이 적용된 것 같습니다. 다시 말해, training dataset의 (절대)개수는 data augmentation을 적용했다고 해서 늘어나는 것이 아닙니다. (imshow 함수는 이 글 제일 아래 있습니다)
• 결국, (inputs, classes) 가 CNN 입장에서 (학습 이미지 데이터, 라벨) 정보를 담고 있다고 볼 수 있겠네요.

• 하지만, 딥러닝 입장에서 중복된 데이터는 학습을 위해 큰 의미가 없을 가능성이 높습니다. 그래서 이미지A 5장이 있는것과, 이미지 A에 5가지 augmentation 적용된 것을 학습한다고 했을 때, 딥러닝 입장에서는 후자의 경우 더 많은 데이터가 있다고 볼 수 있습니다.
• 그래서 위와 같이 첫 번째 epoch의 첫 번째 iteration에서 잡힌 4개(batch) 이미지에 적용된 augmentation과, 두 번째 iteration에서 잡힌 4개(batch) 이미지에 적용된 augmentation과 다르기 때문에 결국 epoch을 여러 번 진행해주게되면, 다양한 조합으로 data augmentation이 적용되기 때문에 데이터수가 늘어났다고 볼 수 있게 됩니다.
• 그래서 이와 같은 방식에서 data augmentation을 적용해 (딥러닝 관점에서 봤을 때) 데이터 개수를 늘리려면 epoch을 늘려줘야합니다. (왜냐하면 앞서 transforms.compose에서 봤듯이 augmetnation이 적용될 때 augmetnation의 정도가 random or 확률적으로 적용되기 때문입니다.)

 

 

 

5. Upload to GPU (Feat. torch.cuda)

앞서 "torch.utils.data.DataLoader"를 통해 이미지를 GPU에 올릴 준비를 끝냈으니, 이번에는 실제로 GPU에 이미지를 올리는 코드를 소개하겠습니다. 

 

Pytorch는 torch.cuda 패키지를 제공하여 pytorch와 CUDA를 연동시켜 GPU를 이용할 수 있게 도와줍니다. 

(↓↓↓CUDA 관련 설명↓↓↓)

https://89douner.tistory.com/158

 

3.GPGPU와 CUDA (feat.cuDNN)

안녕하세요~ 이번글은 GPGPU라는 개념과 CUDA를 소개하면 GPU구조를 가볍게 살펴볼거에요. CPU는 다양한 시스템 자원(ex; I/O device)를 제어해야하고 복잡한 명령들을 처리해야하기 때문에 연산을 위한

89douner.tistory.com

 

 

1) Pytorch와 GPU가 연동되었는지 확인

Pytorch를 설치하실 때 CUDA도 같이 설치하신걸 기억하시나요?

(↓↓↓아나콘다 가상환경에 pytorch 설치하는 방법 (with CUDA) ↓↓↓)

https://89douner.tistory.com/74

 

5. 아나콘다 가상환경으로 tensorflow, pytorch 설치하기 (with VS code IDE, pycharm 연동)

안녕하세요~ 이번시간에는 아나콘다를 통해 2개의 가상환경을 만들고 각각의 가상환경에서 pytorch, tensorflow를 설치하는법을 배워볼거에요~ Pytorch: Python 3.7버전/ CUDA 10.1 버전/ Pytorch=1.4버전 Tensorf..

89douner.tistory.com

 

CUDA가 정상적으로 pytorch와 연동이 되어 있는지 확인하기 위해서는 아래 코드로 확인해봐야 합니다.

1. torch.cuda: "torch.cuda" is used to set up and run CUDA operations.
   • It keeps track of the currently selected GPU, and all CUDA tensors you allocate will by default be created on that device. ← 아래 그림(코드)에서 설명
2. torch.cuda.is_avialable(): CUDA 사용이 가능 하다면 true값을 반환해 줍니다.
   • 메인보드에는 GPU slot이 있습니다. 만약 slot이 4개가 있으면 4개의 GPU를 사용할 수 있게 됩니다. 해당 slot의 번호는 0,1,2,3 인데, 어느 slot에 GPU를 설치하느냐에 따라 GPU 넘버가 정해집니다. (ex: GPU 0 → 0번째 slot에 설치된 GPU)
   • cuda:0 이 의미하는 바는 0번째 slot에 설치된 GPU를 뜻합니다.
   • if 문에 의해 CUDA 사용이 가능하다면 torch.device("cuda:0")으로 세팅됩니다. 
3. torch.device: "torch.device" contains a device type ('cpu' or 'cuda') and optional device ordinal for the device type.
   • torch.device("cuda:0") 을 실행하면 0번째 slot에 있는 GPU를 사용하겠다고 선언하게 됩니다.
4. device 
   • train 함수에 있는 일부 코드를 통해 미리 device의 쓰임새를 말씀드리겠습니다.
   • 앞서 "inputs"이라는 변수에 (batch_size, 3, 224, 224) 정보가 있다는 걸 확인할 수 있었습니다. 
   • inputs 변수를 GPU에 올리기 위해 아래와 같은 "to(device)" 함수를 이용하면 됩니다. (한 가지 더 이야기 하자면 학습을 위해 딥러닝 모델도 GPU에 올려야 하는데, 이때도 "to(device)" 함수를 이용합니다. 이 부분은 나중에 model 부분에서 설명하도록 하겠습니다)

inputs = inputs.to(device)
labels = labels.to(device)

 

 

 

※ 배경지식으로 GPU와 관련된 pytorch 코드들 몇 가지를 살펴보도록 하겠습니다.

(↓↓↓아래 링크의 설명을 정리한 글이니 아래 글을 참고하시는게 더 편하실 듯 합니다↓↓↓)

https://jeongwookie.github.io/2020/03/24/200324-pytorch-cuda-gpu-allocate/

 

Pytorch 특정 GPU 사용하기

나는 많은 딥러닝 프레임워크 중 Pytorch와 MxNet을 자주 사용하는 편이다.그런데, 연구실 사람들과 GPU 서버를 함께 쓰다 보니 어떤 GPU가 현재 available한지 알아야 할 필요가 있었다. 원래는 시간대

jeongwookie.github.io

 

 

2) 현재 GPU 개수, 사용중인 GPU 파악

1. torch.cuda.device_count(): 현재 메인보드에서 이용가능한 GPU 개수
2. torch.cuda.current_device(): 현재 사용중인 GPU 정보
   • Current cuda device:2 → 3번째 slot에 있는 GPU 사용중 
3. torch.cuda.get_device_name(device): 현재 사용하고 있는 GPU 모델명 

 

 

3) 사용할 GPU 변경하기 (or 사용한 GPU 수동 설정하기)

1. torch.cuda.set_device(device): 사용할 GPU 세팅
   • "그림23"과 비교하면, 사용중인 GPU index가 0번으로 변경된 것을 확인 할 수 있습니다 ← 첫 번째 slot에 있는 GPU 사용

 

 

지금까지 설명한 내용이 pytorch에서 이미지 데이터를 로드할 때 필요한 내용들이었습니다.

 

최종코드는 아래와 같습니다.

# Data augmentation and normalization for training
# Just normalization for validation
data_transforms = {
    'train': transforms.Compose([
        transforms.RandomResizedCrop(224),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ]),
    'val': transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ]),
}

data_dir = 'data/hymenoptera_data'
image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x),
                                          data_transforms[x])
                  for x in ['train', 'val']}
dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
class_names = image_datasets['train'].classes

dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=4,
                                             shuffle=True, num_workers=4)
              for x in ['train', 'val']}

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

def imshow(inp, title=None):
    """Imshow for Tensor."""
    inp = inp.numpy().transpose((1, 2, 0))
    mean = np.array([0.485, 0.456, 0.406])
    std = np.array([0.229, 0.224, 0.225])
    inp = std * inp + mean
    inp = np.clip(inp, 0, 1)
    plt.imshow(inp)
    if title is not None:
        plt.title(title)
    plt.pause(0.001)  # pause a bit so that plots are updated


# Get a batch of training data
inputs, classes = next(iter(dataloaders['train']))

# Make a grid from batch
out = torchvision.utils.make_grid(inputs)

imshow(out, title=[class_names[x] for x in classes])