딥러닝

https://boostdevs.gitbook.io/ai-tech-interview/interview/3-deep-learning

Deep Learning - AI Tech Interview

• 딥러닝은 무엇인가요? 딥러닝과 머신러닝의 차이는?

  아래 그림처럼 딥러닝은 머신러닝의 한 분야

  딥러닝은 다양한 층으로 이루어진 신경망을 사용하며, 이 층들은 입력 데이터로부터 추상화된 특징을 학습하고 점차 더 복잡한 개념을 학습하도록 구성

  딥러닝의 주요 특징?

  다층 신경망/자동 특징 추출

  머신러닝?

  컴퓨터 시스템이 데이터로부터 학습하고 예측을 수행하는 기술, 지도,비지도,강화학습 등으로 나뉨

  딥러닝과 머신러닝의 차이?

  1. 표현 학습의 수준 : 딥러닝이 더 깊고 복잡한 모델을 사용하여 더 높은 수준의 추상화를 수행

  2. 자동 특징 추출 : 딥러닝은 자동으로 특징 추출,학습하는 반면 머신러닝은 사람이 특징을 수동으로 추출해야할 수도 있음

  3. 데이터 양 및 계산 리소스 : 딥러닝은 대량이 데이터와 계산 리소스가 필요하고, 더 복잡한 모델을 사용, 머신러닝은 적은 데이터와 계산 리소스로도 효과적으로 작동가능

• Cost Function과 Activation Function은 무엇인가요?

  Cost Function(=비용 함수, 손실 함수) : 머신러닝 및 딥러닝 모델에서 학습 중에 모델의 성능을 측정하고 평가하는 데 사용

  모델의 예측값과 실제값 사이의 차이를 계산하여 모델의 오차를 나타내는 것, 이 오차를 최소화하는 것이 모델의 학습 목표

  ex)MSE, Cross-Entropy Loss

  Activation Function(=활성화 함수) : 인공 신경망의 각 뉴런에서 입력을 받아 출력을 생성하는 함수

  뉴런의 활성화 여부를 결정하고 비선형성을 도입하여 네트워크가 복잡한 패턴을 학습할 수 있도록 함

  ex)시그모이드 함수, 하이퍼볼릭 탄젠트 함수, 렐루 함수, 소프트맥스 함수

• Tensorflow, PyTorch 특징과 차이가 뭘까요?

  둘 다 딥러닝 및 기계 학습 프레임워크로서 널리 사용되고 있음

  Tensorflow?

  1. 정적 그래프 : 초기 버전엔 정적 그래프 사용, 2.x버전 이상부터는 동적 계산 그래프 지원

  2. 생태계 및 커뮤니티 : 거대한 커뮤니티 생성, 유지 중, 다양한 분야에서 다양한 응용 프로그램 및 라이브러리 지원

  3. TensorBoard : 모델 학습 중에 발생하는 다양한 메트릭 및 그래프를 시각적으로 모니터링하기 위한 시각화 도구

  ex)산업용 응용프로그램, 모바일 및 임베디드 시스템, 분산 컴퓨팅 등

  Pytorch?

  1. 동적 그래프 : 디버깅과 실험하기가 쉬우며, 코드가 더 자연스럽게 작성됨

  2. 쉬운 디버깅 : 직관적이며, 디버깅이 간편

  3. Transfer Learning 및 연구 환경 : 연구 및 프로토타입 개발에 적합한 유연성을 제공하며, 자연스러운 API디자인이 연구자들에게 좋은 경험을 제공

  4. TorchScript : 모델을 빠르게 실행할 수 있는 경량화된 표현으로 변환할 수 있는 기능 제공

  ex) 연구 및 프로토타입 개발, 실험 및 학문적 연구 등

• Data Normalization은 무엇이고 왜 필요한가요?

  데이터 정규화 : 데이터의 스케일을 조절하여 모든 데이터가 일관된 범위내에 있도록 하는 전처리 기술

  데이터 정규화가 필요한 이유?

  1. 학습 속도 향상 : 입력 특성들의 스케일이 일관되게 조절하면, 모델이 수렴하는 데 더 빠를 수 있음

  2. 모델 안정성 향상 : 데이터의 범위가 일정하게 조절되면 모델이 더 안정적으로 학습될 수 있음, 모델이 특직 특성의 크기에 민감하게 반응하지 않도록 보장 가능

  3. 특징 간 상대적중요도 유지 : 데이터스케일을 조절하면 각 특징이 모델학습에 미치는 영향이 비슷해짐=>모든 특징이 공평하게 기여

  4. 이상치 처리 : 이상치에 대한 모델의 민감성을 줄일 수 있음

  5. 최적화 효율성 : 입력 데이터의 스케일에 따라 성능이 크게 달라질 수 있음

  ex)표준화, 최소-최대 스케일링

• 알고있는 Activation Function에 대해 알려주세요. (Sigmoid, ReLU, LeakyReLU, Tanh 등)

출력 범위 : 0~1사이, 모든 출력의 합은 1 / 다중 클래스 분류 문제에서 출력층의 활성화 함수로 사용되며, 각 클래스에 속할 확률 제공

• 오버피팅일 경우 어떻게 대처해야 할까요?

  오버피팅(=과적합) : 모델이 훈련 데이터에 너무 적합하게 되어, 새로운 데이터에 대한 일반화 능력이 떨어지는 현상

  오버피팅 대처법?

  더 많은 데이터 수집/데이터 증강.모델 복잡도 감소/가중치 규제/드롭아웃/조기 종료/교차 검증

• 하이퍼 파라미터는 무엇인가요?

  하이퍼파라미터 : 모델을 학습시키기 위해 사전에 설정해야하는 매개변수들

  모델의 구조나 학습 과정에 영향을 주는 변수들을 의미하고 모델을 훈련하기 전, 사용자에 의해 수동으로 선택되거나 조정

  ex)학습률,에포크 수,배치 크기,은닉 층의 수 및 뉴런의 수,활성화 함수,가중치 초기화,드롭아웃 비율

• Weight Initialization 방법에 대해 말해주세요. 그리고 무엇을 많이 사용하나요?

  가중치 초기화 : 인공신경망 모델을 처음 생성할 때 가중치를 어떻게 초기화할지를 결정하는 방법 => 모델의 학습속도와 성능에 영향

  가중치 초기화 방법?

  1. 제로 초기화 : 모든 가중치를 0으로 초기화하는 방법, 하지만 추천하지 않음 => 모든 가중치가 동일하게 초기화되어 그래디언트 업데이트가 일관되게 이루어지지 않기 때문에, 모든 뉴런이 같은 그래디언트를 갖게 됨

  2. 랜덤 초기화 : 각 가중치를 무작위로 작은 값으로 초기화 하는 방법, 보통 표준 정규 분포나 균등 분포에서 랜덤한 값을 선택하여 사용, 모든 가중치가 다르게 초기화되어 다양한 패턴을 학습할 수 있도록 함

  3. He 초기화 : ReLU활성화 함수와 함께 사용될 때 효과적인 초기화 방법, 각 가중치를 표준 정규 분포에서 뽑은 값을 해당 뉴런의 입력 차원 수의 역수로 나눈 값을 초기화

  4. Xavier(Glorot)초기화 : 시그모이드/tanh 활성화 함수와 함께 사용될 때 효과적인 초기화 방법, 가중치를 정규분포나 균등 분포에서 뽑은 값을 입력차원과 출력차원의 평균의 역수로 나눈값으로 초기화

  * He초기화 또는 Xavier초기화가 잘 작동함, 특히 딥러닝에서는 ReLU활성화 함수와 He초기화를 많이 씀 

• 볼츠만 머신은 무엇인가요?

  볼츠만 머신 : 에너지 기반 확률적 모델 중 하나로 확률적 그래픽 모델의 일종

  제한된 볼츠만 머신(Restricted Boltzmann Machine, RBM)은 가시층과 은닉층으로 구성된 인공 신경망의 일종

  볼츠만 머신의 특징?

  1. 에너지 기반 모델 : 에너지 함수를사용하여 데이터의 확률 분포를 모델링, 에너지 함수는 가시층과 은닉 층의 연결 가중치 및 편향을 사용하여 정의되며 에너지가 낮을 수록 해당 상태의 확률이 높아짐

  2. 확률적인 학습 : 적응적 히든 마르코프 모델(Constrastive Divergence, AHMM)을 사용하여 학습, 해당 알고리즘은 훈련 데이터에 적합한 파라미터를 찾기 위해 확률적으로 샘플링된 샘플과 현재 모델의 샘플 간의 차이를 줄임

  3. 가시층과 은닉층 간의 양방향 연결 : 가시층과 은닉 층 간의 연결이 양방향이며 층 간의 노드들은 완전히 연결되어 있음 => 각 노드가 다른 층의 모든 노드와 연결되어 있다는 의미

  4. 차원 축소 및 특징 학습 : 은닉층의 노드들은 입력데이터의 추상적인 표현을 학습하게 되며, 이를 통해 원본 데이터의 특징을 효과적으로 표현 가능

• TF, PyTorch 등을 사용할 때 디버깅 노하우는?

  디버깅 : 모델이나 학습 코드에 오류가 있을 수 있고, 이를 신속하게 발견하고 수정하는 것 => 모델 개발을 효과적으로 진행하는데 도움

  TensorFlow에서의 디버깅?

  1. TensorBoard활용 : 그래프의 구조, 학습 곡선, 텐서의 분포등을 시각적으로 확인할 수 있는 TensorFlow의 시각화 도구, 'tf.summary'를 사용하여 필요한 정보를 기록하고 TensorBoard를 통해 분석

  2. tf.debugging.asset_shapes : 텐서 모양을 확인하는데 사용, 모델의 입력과 출력에 대한 예상되는 모양을 정의하고 모델이 예상대로 작동하는 지 확인하는 데 도움

  3. tf.debugging.check_numerics : 텐서의 NaN, Inf값을 확인하는데 사용,모델이나 그래프에서 숫자적으로 안정적인지 확인가능

  PyTorch에서의 디버깅?

  1. print 및 pdb디버깅 : 'print'를 사용하여 중간 결과물을 출력하거나, 'pdb'디버거를 사용하여 코드를 중단하고 상태 확인가능

  2. torch.autograd.detect_anomaly : 연산에서 발생하는 오류를 탐지하고 예외를 발생시키는 데 사용됨, 모델의 순전파 및 역전파 중에 발생하는 문제를 찾는 데 도움이 됨

  3. torch.nn.utils.clip_grad_norm_ : 그레디언트 폭발을 방지하기 위해 사용됨, 모델을 업데이트할 때 그레디언트를 글리핑하여 너무 큰 값이 발산하는 것을 방지할 수 있음

  4. torch.Tensor.detach() : 텐서의 연산을 추적하지 않고 해당 시점의 값을 고정시킴 => 특정 시점에서 그레디언트를 추적하지 않고 디버깅 가능

  5. PyTorch Lightning등의 라이브러리 활용 : 모델 훈련 루프를 추상화하고, 디버깅 및 실험 관리를 간소화

• 뉴럴넷의 가장 큰 단점은 무엇인가? 이를 위해 나온 One-Shot Learning은 무엇인가?

  데이터 부족에 대한 취약성, 다양한 데이터를 충분히 수집하고 다양한 상황에서 모델을 훈련시키기 어려운 경우 모델은 특정 상황에 대해 일반화되기 어려울 수 있음, 특히 적은 샘플 수로는 효과적인 학습이 어려운 경우에 나타날 수 있음

  => One-Shot Learning : 데이터 부족 문제에 대응하기 위한 기술 중 하나, 모델이 단 한번의 학습 예제만으로 새로운 클래스를 인식하고 분류할 수 있도록 하는 것을 목표로 함

  - Siamese Network(샴 네트워크) : 두 입력 사이의 유사도를 측정하는 방법을 학습하는데 사용됨 , 새로운 클래스를 예측할 때, 이미 알고 있는 클래스와의 유사도를 계산하여 새로운 클래스를 인식하는 데 도움을 줌

  - Meta-Learning : 모델이 새로운 작업에 대한 학습방법을 학습하는 것

  - Few-Shot Learning : 매우 적은 양의 학습 데이터로 모델을 훈련하는 방식 중 하나로, 적은 양의 학습 데이터로도 효과적인 분류모델 개발 가능

  - Memory-Augmented Networks : 외부 메모리를 사용하여 적은 양의 데이터를 효과적으로 저장하고 활용하는 방법, 이 방식을 통해 새로운 클래스를 더 잘 학습하고 기억가능

• 요즘 Sigmoid 보다 ReLU를 많이 쓰는데 그 이유는?

  1. 비선형성 : ReLU는 비선형 활성화 함수로 신경망의 비선형성을 증가시켜 학습능력을 향상시킴, 선형 함수를 사용하면 신경망 여러 층으로 구성되어 있을 때 하나의 선형 함수로 귀결되어 표현 능력이 제한됨

  2. Gradient Descent 문제 해결 : 시그모이드 함수는 큰 양수/음수 입력에 대해 그래디언트가 0에 가까워지는 gradient vanishing 문제가 있음, 이로 인해 역전파 동안 가중치가 업데이트되지 않을 수 있음, ReLU는 양수 입력에 대해 gradient가 상수이기 때문에 gradient vanishing문제를 완화시키는 데 도움

  3. 계산 효율성 : ReLU는 간단한 계산으로 이루어져 있어 빠르게 계산됨, 모델의 훈련과 추론 시간을 단축시키는데 도움

  4. 희소 활성화 : ReLU는 양수 입력에 대해 0 이외의 값을 출력하므로 희소 활성화를 유도할 수 있음 => 모델이 더 효과적으로 특징을 학습하고 표현할 수 있도록 도움

  5. Rectification 특성 : ReLU는 음수 입력에 대해 0을 출력하기 때문에 입력이 음수인 부분을 제거하는 효과가 있음 => 모델이 불필요한 정보를 덜 학습하고 더 간결한 표현을 만들 수 있음

  *ReLU의 단점 : 입력이 음수인 경우 출력이 0이되어 정보 손실이 발생할 수도 있음 => Leaky ReLU, Parametric ReLU, ELU 등

  *희소 활성화 : 인공신경망에서 특정 뉴런이나 유닛이 활성화되는 정도가 상대적으로 낮은 현상, 주로 활성화 함수가 어떤 입력에 대해 뉴런을 활성화시키는 지에 따른 발생하는 현상

  => ReLU는 양수 입력에 대해 비교적 강하게 활성화되고, 음수 입력에 대해서는 비활성화, 이로 인해 특정 입력에 대해서만 활성화되고, 나머지 입력에 대해서는 비활성화되는 경우가 발생할 수 있음 => 표현 능력 강화, 계산 효율성, 해석 가능성

  *Rectification : 수학적으로 음수 값을 양수로 변환하는 과정, 활성화 함수의 경우 음수 입력을 0으로 변환하는 작업

   

• Gradient Descent에 대해서 쉽게 설명한다면?

  함수의 최솟값을 찾는 최적화 알고리즘 중 하나, 미분 가능한 함수에서 시작점에서의 그래디언트를 사용하여 함수의 최솟값으로 이동

  1. 초기화 : 최적화하려는 함수와 시작점을 정함

  2. 반복적인 갱신 : 현재 위치에서 그래디언트를 계산하고 현재 위치에서 함수가 가장 빠르게 증가하는 방향을 나타내고 그 반대 방향으로 조금씩 이동하면서 함수의 값을 감소시키고 최솟값을 향해 이동하는 것을 반복

  3. 종료 조건 확인 : 미리 정의한 종료 조건을 만족하면 알고리즘 종료

   

• Local Minima 문제에도 불구하고 딥러닝이 잘 되는 이유는?

  딥러닝은 일반적으로 지역 최솟값에 빠지기 어렵고, 전역 최솟값을 향해 학습할 수 있음

  =>이유?

  많은 매개변수/데이터다양성/초기화전략/활성화 함수의 선택/배치 정규화/드롭아웃/최적화 알고리즘

   

• Training 세트와 Test 세트를 분리하는 이유는?

  모델의 일반화 성능을 평가하고 실제 환경에서의 성능을 추정하기 위해서임, 보지 못한 데이터에 대해서도 일반화가 잘되는지 확인

  모델 평가/일반화 성능 확인/하이퍼파라미터 튜닝/데이터 누설/과적합 검출

   

• Batch Normalization의 효과는?

  Batch Normalization : 딥러닝 모델의 학습 과정을 안정화시키고 속도를 높이는 데에 도움을 주는 기법

  학습 안정성 향상/그래디언트 소실 및 폭주 방지/학습 속도 향상/Regularization효과 /매개변수에 대해 덜 민감한 편

   

• SGD, RMSprop, Adam에 대해서 아는대로 설명한다면?

  SGD(Stochastic Gradient Descent) : 가장 기본적인 최적화 알고리즘, 각 에포크에서 전체 데이터셋을 사용하지 않고 미니배치를 사용하여 그래디언트를 계산하고 모델의 파라미터를 업데이트 함, 구현이 간단하며 잘 자동하지만 수렴이 느리고 지역 최솟값에 갇히기 쉬움

  RMSprop(Root Mean Square Propagation) : Adagrad의 변형으로 학습률을 동적으로 조절하여 수렴 속도를 향상시킴, 각 파라미터에 대해 적응적인 학습률을 사용하며 이전 그래디언트의 제곱 평균으로 학습률을 조절, Adagrad의 학습률 감소 문제를 해결하고 수렴 속도를 향상시킬 수 있지만 여전히 지역 최솟값에 갇힐 수 있고 하이퍼 파라미터 조절이 필요할 수 있음

  Adam(Adaptive Moment Estimation) : RMSprop+Momentum, 적응적인 학습률과 지수 이동 평균을 사용하여 파라미터 업데이트, 그레디언트의 지수 이동 평균을 사용하여 모멘텀을 계산하고 RMSprop와 유사한 방식으로 학습률을 조절, 다양한 문제에서 효과적으로 동작하며 수렴 속도를 높이며 안정적으로 만들어주지만 하이퍼파라미터를 여전히 조절해줘야하며 계산비용이 높을수도있음

   

• 간단한 MNIST 분류기를 MLP+CPU 버전으로 numpy로 만든다면 몇줄일까?

import numpy as np
from keras.datasets import mnist  # MNIST 데이터셋을 사용하기 위해 keras의 datasets 모듈을 사용합니다.

# MNIST 데이터 로드
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# 데이터 전처리: 이미지 픽셀 값을 [0, 1] 범위로 스케일 조정
train_images = train_images.reshape((60000, 28 * 28)).astype('float32') / 255
test_images = test_images.reshape((10000, 28 * 28)).astype('float32') / 255

# 레이블을 범주형 형태로 인코딩
from keras.utils import to_categorical
train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)

# 모델 구축
input_size = 28 * 28
hidden_size = 128
output_size = 10

# 가중치 초기화
np.random.seed(42)
weights_input_hidden = np.random.randn(input_size, hidden_size)
weights_hidden_output = np.random.randn(hidden_size, output_size)

# 편향 초기화
bias_hidden = np.zeros((1, hidden_size))
bias_output = np.zeros((1, output_size))

# 시그모이드 활성화 함수 정의
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 소프트맥스 활성화 함수 정의
def softmax(x):
    exp_x = np.exp(x - np.max(x, axis=-1, keepdims=True))
    return exp_x / np.sum(exp_x, axis=-1, keepdims=True)

# 모델 훈련
learning_rate = 0.1
epochs = 10

for epoch in range(epochs):
    # Forward Pass
    hidden_input = np.dot(train_images, weights_input_hidden) + bias_hidden
    hidden_output = sigmoid(hidden_input)
    output = np.dot(hidden_output, weights_hidden_output) + bias_output
    predictions = softmax(output)

    # Loss 계산 (Cross-Entropy)
    loss = -np.sum(train_labels * np.log(predictions)) / len(train_labels)

    # Backward Pass
    # ... (미분 및 가중치 업데이트)

    # 모델 성능 평가
    accuracy = np.mean(np.argmax(predictions, axis=1) == np.argmax(train_labels, axis=1))
    print(f'Epoch {epoch + 1}/{epochs}, Loss: {loss:.4f}, Accuracy: {accuracy:.4f}')

• 간단한 MNIST 분류기를 TF, PyTorch 등으로 작성하는데 몇시간이 필요한가?

  이건 개인마다 다르지 않나요,,,,챗지피티와 함께라면 1분컷 가넝,,,

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical

# 데이터 로드 및 전처리
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
train_images = train_images.reshape((60000, 28, 28, 1)).astype('float32') / 255
test_images = test_images.reshape((10000, 28, 28, 1)).astype('float32') / 255

train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)

# 모델 구축
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Flatten())
model.add(layers.Dense(128, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))

# 모델 컴파일
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# 모델 훈련
model.fit(train_images, train_labels, epochs=5, batch_size=64, validation_split=0.2)

# 모델 평가
test_loss, test_acc = model.evaluate(test_images, test_labels)
print(f'Test Accuracy: {test_acc}')

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from torchvision.datasets import MNIST

# 데이터 로드 및 전처리
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])

train_dataset = MNIST(root='./data', train=True, download=True, transform=transform)
test_dataset = MNIST(root='./data', train=False, download=True, transform=transform)

train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

# 모델 구축
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
        self.fc1 = nn.Linear(32 * 14 * 14, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = x.view(-1, 32 * 14 * 14)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return F.log_softmax(x, dim=1)

model = SimpleCNN()

# 모델 컴파일
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 모델 훈련
epochs = 5
for epoch in range(epochs):
    for data, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(data)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

# 모델 평가
correct = 0
total = 0
with torch.no_grad():
    for data, labels in test_loader:
        outputs = model(data)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Test Accuracy: {correct / total}')

• 딥러닝할 때 GPU를 쓰면 좋은 이유는?

  딥러닝 모델의 학습 및 추론 과정에서 병렬 처리 능력과 높은 연산 성능을 제공하기 때문

  병렬 처리 , 높은 연산 성능 , 대용량 데이터 처리 , 최신 딥러닝 모델의 지원 , 높은 데이터 메모리 대역폭