오늘은 딥러닝 파이토치 교과서 1장~3장 내용을 요약하였으며, 모든 내용을 요약하기 보다는 이번에 새롭게 알게된 부분 위주로 정리함
또한, 추가적인 공부가 필요한 부분에 대해서는 ★★★로 표시함
1. 머신러닝과 딥러닝
1.1 인공지능, 머신러닝과 딥러닝
- 머신러닝의 학습 과정은 각 데이터 특성을 기계에 인식시키고 학습시켜 문제를 해결하는 반면 딥러닝은 대량의 데이터를 신경망에 적용하여 기계가 스스로 분석한 후 답을 찾도록 함 -> 머신러닝의 경우 인간이 특성을 추출하는 과정이 포함되어야 함
1.2 머신러닝이란
1.2.1 머신러닝 학습 과정
- 훈련 데이터에 대한 정확도는 높은데 검증 데이터에 대한 정확도가 낮다면 훈련데이터에 과적합이 일어났을 가능성을 생각해 볼 수 있으며, 이와 같은 경우에는 정규화를 하거나 에포크를 줄이는 것이 방법임
1.3 딥러닝이란
1.3.1 딥러닝 학습 과정
- 데이터 준비 -> 모델 정의(신경망 생성) -> 모델 컴파일(활성화 함수, 손실 함수, 옵티마이저 선택) -> 모델 훈련 -> 모델 예측
- 모델 훈련 단계에서는 한 번에 처리할 데이터양을 지정해야 하며, 한 번에 처리해야 할 데이터 양이 많으면 학습 속도가 느려지고 메모리 부족 문제를 야기할 수 있음
- 훈련 데이터셋 1000개에 대한 배치 크기가 20이라면 샘플 단위 20개마다 모델 가중치를 한 번씩 업데이터시킨다는 것을 의미하며, 총 50번(=1000/20)의 가중치가 업데이트 됨.
- 이때 에포크가 10이고 배치 크기가 20이라면 가중치를 50번 업데이트하는 것을 총 10번 반복한다는 의미로 결과적으로 500번 업데이트가 이루어짐
- 성능이 좋다는 의미는 정확도가 높고 훈련 속도가 빠르다는 것을 의미함
- batch, epoch, iteration의 개념
-> 130개의 data에서 batch size를 10으로 설정하면 1epoch에서 13iteration이 일어남(13번의 가중치가 업데이트 됨)
-> 참고로, 딥러닝에서는 하나의 data를 여러 번 사용하여 학습 시키기 때문에 epoch를 50, 100 등으로 설정함
1.3.2. 딥러닝 학습 알고리즘
- 전이학습(transfer learning)은 사전에 학습이 완료된 모델을 가지고 우리가 원하는 학습에 미세 조정 기법을 이용하여 학습시키는 방법
2. 실습 환경 설정과 파이토치 기초
2.1 파이토치 개요
2.1.1 파이토치 특징 및 장점
파이토치는 한마디로 "GPU에서 텐서 조작 및 동적 신경망 구축이 가능한 프레임워크" 임
- GPU는 연산 속도를 빠르게 하는 역할을 하며, 내부적으로 CUDA, cuDNN이라는 API를 통해 GPU를 연산에 사용할 수 있음
- 텐서는 단일 데이터 형식으로 된 자료들의 다차원 행렬로 파이토치의 데이터 형태임
- 동적신경망은 훈련을 반복할 때마다 네트워크 변경이 가능한 신경망을 의미함(예를 들어 학습 중에 은닉층을 추가하거나 제거하는 등 모델의 네트워크 조작이 가능)
2.1.2 파이토치의 아키텍처
torch: GPU를 지원하는 텐서 패키지
torch.autograd: 자동 미분 패키지(파이토치는 자동미분 기술을 채택하여 미분 계산을 효율적으로 처리, 실시간으로 네트워크 수정이 반영된 계산이 되기 떄문에 사용자는 다양한 신경망을 적용해 볼 수 있음)
torch.nn: 신경망 구축 및 훈련 패키지(합성곱 신경망, 순환 신경망, 정규화 등이 포함되어 손쉽게 신경망을 구축하고 학습시킬 수 있음)
touch.multiprocessing: 파이썬 멀티프로세싱 패키지(파이토치에서 사용하는 프로세스 전반에 걸쳐 텐서의 메모리 공유가 가능하여 서로 다른 프로세스에서 동일한 데이터에 대한 접근 및 사용이 가능)
torch.utils: DataLoader 및 기타 유틸리티를 제공하는 패키지
이외에도 병목 현상을 디버깅하기 위한 torch.utils.bottlneck, 모델 또는 모델의 일부를 검사하기 위한 torch.utils.checkpoint 등의 모듈이 있음
NOTE) 텐서를 메모리에 저장
- 텐서는 1차원이든 N차원이든 메모리에 저장할 때는 1차원 배열 형태가 됨(1차원 배열 형태여야만 메모리에 저장할 수 있음)
- 변환된 1차원 배열을 스토리지(storage)라고 하며, 스토리지를 이해하기 위해서는 오프셋과 스트라이드 개념을 알아야 함
- 오프셋은 텐서에서 첫 번째 요소가 스토리지에 저장된 인덱스이며, 스트라이드는 각 차원에 따라 다음 요소를 얻기 위해 건너뛰기가 필요한 스토리지의 요소 개수임
2.2 파이토치 기초 문법
2.2.2 데이터 준비
- 데이터가 이미지일 겨우 분산된 파일에서 데이터를 읽은 후 전처리를 하고 배치 단위로 분할하여 처리해야 함
- 데이터가 텍스트일 경우 임베딩 과정을 거쳐 서로 다른 길이의 시퀀스를 배치 단위로 분할하여 처리해야 함
- 딥러닝은 대량의 데이터를 이용하여 모델을 학습시키는데 데이터를 한 번에 메모리에 불러와서 훈련시키면 시간과 비용 측면에서 효율적이지 않음(데이터를 조금씩 나누어 불러서 사용하는 방식을 커스텀 데이터셋(custom dataset)이라고 함)
NOTE) torch.utils.data.DataLoader
- 데이터로더 객체는 학습에 사용될 데이터 전체를 보관했다가 모델 학습 때 배치크기만큼 데이터를 꺼내서 사용
- 예를 들어, dataset=DataLoader(tensor_dataset, batch_size=4, shuffle=True)라고 했으면 4개의 data가 한번 학습에 이용되며, shuffle=True라고 설정했으면 한 번의 epoch를 실행할 때마다 데이터셋을 섞음
2.2.3. 모델 정의
- 파이토치에서 모델을 정의하기 위해서는 모듈을 상속한 클래스를 사용
계층(layer): 모듈 또는 모듈을 구성하는 한 개의 계층(예를 들어, 선형 계층 등)
모듈(module): 한 개 이상의 계층이 모여서 구성된 것
모델(model): 최종적으로 원하는 네트워크
- 파이토치에서 nn.Module을 상속받는 모델은 기본적으로 __int__()과 forward() 함수를 포함하며, __int__()에서는 모델에서 사용될 모듈, 활성화 함수 등을 정의, forward()함수에서는 모델에서 실행되어야 하는 연산을 정의
*** 클래스에 대한 자세한 내용은https://youtube.com/watch?v=uIcK7-YU8uA&feature=share와 https://wikidocs.net/28 을 참고함
2.2.4. 모델의 파라미터 정의
- 손실함수: 학습하는 동안 출력과 실제 값 사이의 오차 측정
BCELoss: 이진 분류를 위해 사용
CrossEntropyLoss: 다중 클래스 분류를 위해 사용
MSELoss: 회귀 모델에서 사용
- 옵티마이저: 데이터와 손실함수로 모델의 업데이트 방법 결정
zero_grad() 메서드는 옵티마이저에 사용된 파라미터들의 기울기를 0으로 만듦
torch.optim.lr_scheduler는 에포크에 따라 학습률 조절
- 학습률 스케줄러: 미리 지정한 횟수의 에포크를 지날 때마다 학습률을 감소시켜 줌(학습 초기에는 빠른 학습을 진행하다가 전역 최소점 근처에 다다르면 학습률을 줄여 최적점을 찾아가게 됨)
- 지표(metrics): 훈련과 테스트 단계를 모니터링함
2.2.5. 모델 훈련
- 모델을 훈련시킬 때 가장 먼저 필요한 절차는 optimizer.zero_grad()★★★ 메서드를 이용하여 기울기를 초기화하는 것이 필요함
- 파이토치는 기울기 값을 계산하기 위해 loss.backward() 메서드를 이용하는데, 이것을 사용하면 새로운 기울기 값이 이전 기울기 값에 누적하여 계산됨(이 방법은 순환신경망 모델을 구현할 때만 효과적)
2.2.6. 모델 평가
- torchmetrics.functional.accuracy를 이용하면 정확도를 구할 수 있음
2.2.7 훈련 과정 모니터링
- tensorboard★★★ 를 이용하면 학습에 사용되는 각종 파라미터 값이 어떻게 변화하는지 시각화하여 살펴볼 수 있으며, 성능을 추적하거나 평가하는 용도로도 사용할 수 있음
NOTE) model.train() & model.eval()
- moel.eval()에서는 with torch.no_grad()를 사용하는데 검증(혹은 테스트) 과정에서는 역전파가 필요하지 않기 때문에 기울기값을 저장하지 않음(메모리와 연산 시간 줄일 수 있음)
2.4 파이토치 코드 맛보기
- githib에 있는 코드는 colab에 불러와서 분석하기 위해 https://blog.naver.com/PostView.nhn?blogId=chai1226&logNo=221944798109&parentCategoryNo=&categoryNo=&viewDate=&isShowPopularPosts=false&from=postView 참고함!
- github에 있는 csv파일을 다운로드 받는 방법은 https://technical-support.tistory.com/54 참고함!
1) 데이터 불러오기
import torch
import torch.nn as nn
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
dataset = pd.read_csv('/content/car_evaluation.csv')
dataset.head()price maint doors persons lug_capacity safety output
0 vhigh vhigh 2 2 small low unacc
1 vhigh vhigh 2 2 small med unacc
2 vhigh vhigh 2 2 small high unacc
3 vhigh vhigh 2 2 med low unacc
4 vhigh vhigh 2 2 med med unacc
2) 예측변수와 레이블을 텐서로 변환
# 예측변수를 텐서로 변환하는 과정
categorical_colums=['price', 'maint', 'doors', 'persons', 'lug_capacity', 'safety']
for category in categorical_colums:
dataset[category]=dataset[category].astype('category') # 범주형으로 변환
price=dataset['price'].cat.codes.values # 범주형 데이터(단어)를 숫자로 변환
maint=dataset['maint'].cat.codes.values
doors=dataset['doors'].cat.codes.values
persons=dataset['persons'].cat.codes.values
lug_capacity=dataset['lug_capacity'].cat.codes.values
safety=dataset['safety'].cat.codes.values
categorical_data = np.stack([price, maint, doors, persons, lug_capacity, safety], 1)
categorical_data[:10]
categorical_data = torch.tensor(categorical_data, dtype=torch.int64) # 텐서로 변환
categorical_data[:10]
--------------------------------------------------------------------------------
tensor([[3, 3, 0, 0, 2, 1],
[3, 3, 0, 0, 2, 2],
[3, 3, 0, 0, 2, 0],
[3, 3, 0, 0, 1, 1],
[3, 3, 0, 0, 1, 2],
[3, 3, 0, 0, 1, 0],
[3, 3, 0, 0, 0, 1],
[3, 3, 0, 0, 0, 2],
[3, 3, 0, 0, 0, 0],
[3, 3, 0, 1, 2, 1]], dtype=torch.int8)
# 레이블로 사용할 칼럼을 텐서로 변환
outputs = pd.get_dummies(dataset.output)
print(outputs)
outputs=outputs.values
print(outputs)
outputs=torch.tensor(outputs).flatten() # 1차원 텐서로 변환
print(outputs)
--------------------------------------------------------------------------------
acc good unacc vgood
0 0 0 1 0
1 0 0 1 0
2 0 0 1 0
3 0 0 1 0
4 0 0 1 0
... ... ... ... ...
1723 0 1 0 0
1724 0 0 0 1
1725 0 0 1 0
1726 0 1 0 0
1727 0 0 0 1
[1728 rows x 4 columns]
[[0 0 1 0]
[0 0 1 0]
[0 0 1 0]
...
[0 0 1 0]
[0 1 0 0]
[0 0 0 1]]
tensor([0, 0, 1, ..., 0, 0, 1], dtype=torch.uint8)
3) 범주형 칼럼을 N차원으로 변환
- 워드 임베딩은 유사한 단어끼리 유사하게 인코딩되록 표현하는 방법임(높은 차원의 임베딩일수록 단어 간의 세부적인 관계를 잘 파악할 수 있음)
- 임베딩 크기에 대한 정확한 규칙은 없지만 칼럼의 고유 값 수를 2로 나누는 것을 많이 사용함
# 범주형 칼럼을 N차원으로 변환
categorical_column_sizes = [len(dataset[column].cat.categories) for column in categorical_colums]
categorical_embedding_sizes = [(col_size, min(50, (col_size+1)//2)) for col_size in categorical_column_sizes]
print(categorical_embedding_sizes)
--------------------------------------------------------------------------------
[(4, 2), (4, 2), (4, 2), (3, 2), (3, 2), (3, 2)]
4) 데이터셋 분리
- 모델을 학습할 때, 일반적으로 샘플들을 미니배치(minibatch)로 전달하고, 매 에폭마다 데이터를 다시 섞어서 과적합을 막음
# 데이터셋 분리
total_records = 1728
test_records = int(total_records * .2)
categorical_train_data = categorical_data[:total_records-test_records]
categorical_test_data = categorical_data[total_records-test_records:total_records]
train_outputs=outputs[:total_records-test_records]
test_outputs = outputs[total_records-test_records:total_records]
print(len(categorical_train_data))
print(len(categorical_test_data))
print(len(train_outputs))
print(len(test_outputs))
print(categorical_train_data[:1])
print(train_outputs[:1])
--------------------------------------------------------------------------------
1383
345
1383
345
tensor([[3, 3, 0, 0, 2, 1]])
tensor([0], dtype=torch.uint8)5) 모델 네트워크 생성
class Model(nn.Module): # 클래스 형태로 구현되는 모델은 nn.Module을 상속받음
def __init__(self, embedding_size, output_size, layers, p=0.4): # 모델에서 사용될 파라미터와 신경망 초기화(embedding_size: 범주형 칼럼의 임베딩 크기, output_size: 출력층의 크기, layers: 모든 계층에 대한 목록, p: 드롭아웃)
super().__init__() # 부모 클래스에 접근할 때 사용하며 super는 self를 사용하지 않음
self.all_embeddings = nn.ModuleList([nn.Embedding(ni, nf) for ni, nf in embedding_size])
self.embedding_dropout = nn.Dropout(p)
all_layers = []
num_categorical_cols = sum((nf for ni, nf in embedding_size))
input_size = num_categorical_cols # 입력층의 크기를 찾기 위해 범주형 칼럼 개수를 input_size 변수에 저장
for i in layers: # 모델의 네트워크 구축
all_layers.append(nn.Linear(input_size, i))
all_layers.append(nn.ReLU(inplace=True))
all_layers.append(nn.BatchNorm1d(i))
all_layers.append(nn.Dropout(p))
input_size = i
all_layers.append(nn.Linear(layers[-1], output_size))
self.layers = nn.Sequential(*all_layers) # 신경망의 모든 계층이 순차적으로 실행되도록 모든 계층에 대한 목록을 nn.Sequential클래스로 전달
def forward(self, x_categorical): # 학습 데이터를 입력받아서 연산 진행
embeddings = []
for i,e in enumerate(self.all_embeddings):
embeddings.append(e(x_categorical[:,i]))
x = torch.cat(embeddings, 1)
x = self.embedding_dropout(x)
x = self.layers(x)
return x
model = Model(categorical_embedding_sizes, 4, [200,100,50], p=0.4) # 은닉층 [200, 100, 50]으로 정의
print(categorical_embedding_sizes)
print(model)
--------------------------------------------------------------------------------
[(4, 2), (4, 2), (4, 2), (3, 2), (3, 2), (3, 2)]
Model(
(all_embeddings): ModuleList(
(0-2): 3 x Embedding(4, 2)
(3-5): 3 x Embedding(3, 2)
)
(embedding_dropout): Dropout(p=0.4, inplace=False)
(layers): Sequential(
(0): Linear(in_features=12, out_features=200, bias=True)
(1): ReLU(inplace=True)
(2): BatchNorm1d(200, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(3): Dropout(p=0.4, inplace=False)
(4): Linear(in_features=200, out_features=100, bias=True)
(5): ReLU(inplace=True)
(6): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(7): Dropout(p=0.4, inplace=False)
(8): Linear(in_features=100, out_features=50, bias=True)
(9): ReLU(inplace=True)
(10): BatchNorm1d(50, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(11): Dropout(p=0.4, inplace=False)
(12): Linear(in_features=50, out_features=4, bias=True)
)
)
##### 참고사항 - 파이토치 튜토리얼(모형 설계의 기본)
class NeuralNetwork(nn.Module):
def __init__(self):
super(NeuralNetwork, self).__init__()
self.flatten = nn.Flatten()
self.linear_relu_stack = nn.Sequential(
nn.Linear(28*28, 512),
nn.ReLU(),
nn.Linear(512, 512),
nn.ReLU(),
nn.Linear(512, 10),
)
def forward(self, x):
x = self.flatten(x)
logits = self.linear_relu_stack(x)
return logits6) 모델 학습
# 모델 파라미터 정의
loss_function=nn.CrossEntropyLoss()
optimizer=torch.optim.Adam(model.parameters(), lr=0.001)
# GPU 사용 지정
if torch.cuda.is_available():
device=torch.device('cuda')
# 모델 학습
epochs = 500
aggregated_losses=[]
train_outputs=train_outputs.to(device=device,dtype=torch.int64)
for i in range(epochs):
i += 1
y_pred = model(categorical_train_data).to(device)
single_loss = loss_function(y_pred, train_outputs)
aggregated_losses.append(single_loss)
optimizer.zero_grad() # 역전파하기전 gradients를 0으로 만들어줌
single_loss.backward() # 가중치를 업데이트하기 위해 손실함수의 backward() 메서드 호출
optimizer.step() # 옵티마이저 함수의 step() 메서드를 이용하여 기울기 업데이트
7) 테스트 데이터셋으로 모델 예측
# 테스트 데이터 셋으로 모델 예측
test_outputs=test_outputs.to(device=device, dtype=torch.int64)
with torch.no_grad():
y_val=model(categorical_test_data)
loss=loss_function(y_val, test_outputs)
print(f'Loss: {loss:.8f}')
# 가장 큰 값을 갖는 인덱스 확인
y_val=np.argmax(y_val, axis=1)
8) 모델 평가
# 모델 평가
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
print(confusion_matrix(test_outputs,y_val))
print(classification_report(test_outputs,y_val))
print(accuracy_score(test_outputs, y_val))
--------------------------------------------------------------------------------
[[257 2]
[ 86 0]]
precision recall f1-score support
0 0.75 0.99 0.85 259
1 0.00 0.00 0.00 86
accuracy 0.74 345
macro avg 0.37 0.50 0.43 345
weighted avg 0.56 0.74 0.64 345
0.744927536231884- 재현율(recall): 실제로 정답이 1이라고 할 때 모델도 1로 예측한 비율
- 정밀도(precision): 모델이 1이라고 예측한 것 중에 실제로 정답이 1인 비율
- F1-스코어: 정밀도와 재현율의 조화평균(정밀도가 높으면 재현율이 낮고, 재현율이 높으면 정밀도가 낮은 트레이드오프 문제 해결)
3. 머신러닝 핵심 알고리즘
3.1 지도학습
3.1.1 K-최근접 이웃
- 학습에 사용하지 않은 새로운 데이터를 받았을 때 기존 클러스터에서 모든 데이터와 인스턴스 기반 거리를 측정한 후 가장 많은 속성을 가진 클러스터에 할당하는 분류 알고리즘
- StandardScalar는 평균이 0, 표준편차가 1이 되도록 변환
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sklearn import metrics
names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']
from google.colab import files # 데이터 불러오기
file_uploaded=files.upload() # 데이터 불러오기
dataset = pd.read_csv('iris.data.txt', names=names)
X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 4].values
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20)
from sklearn.preprocessing import StandardScaler
s = StandardScaler()
X_train = s.fit_transform(X_train)
X_test = s.fit_transform(X_test)
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier(n_neighbors=50)
knn.fit(X_train, y_train)
from sklearn.metrics import accuracy_score
y_pred = knn.predict(X_test)
print("정확도: {}".format( accuracy_score(y_test, y_pred)))
3.1.2 서포트 벡터 머신
- 서포트 벡터 머신은 분류되지 않은 새로운 데이터를 결정 경계를 기준으로 분류하는 모델임
- SVM에서 데이터를 분류하는 기준선을 선형과 비선형(다항식, 가우시안 RBF)가 있으며, C는 오류를 어느 정도 허용할지 지정하는 파라미터임
- 감마(gamma)는 결정 경계를 얼마나 유연하게 할지 설정하는 것임(감마값이 클수록 학습 데이터에 민감한 것으로 과적합을 초래할 수 있음)
from sklearn import svm
from sklearn import metrics
from sklearn import datasets
from sklearn import model_selection
iris = datasets.load_iris()
x_train, x_test, y_train, y_test = model_selection.train_test_split(iris.data,
iris.target,
test_size=0.6,
random_state=42)
svm = svm.SVC(kernel='linear', C=1.0, gamma=0.5)
svm.fit(x_train, y_train)
predictions = svm.predict(x_test)
score = metrics.accuracy_score(y_test, predictions)
print('정확도: {0:f}'.format(score))
- 혼동행렬을 시각화하는 코드는 아래와 같음
import numpy as np
import seaborn as sns
from sklearn import metrics
cm = metrics.confusion_matrix(y_test, predictions)
plt.figure(figsize=(8,8))
sns.heatmap(cm, annot=True, fmt=".3f", linewidths=.5, square = True, cmap = 'Blues_r');
plt.ylabel('Actual label');
plt.xlabel('Predicted label');
all_sample_title = 'Accuracy Score: {0}'.format(score)
plt.title(all_sample_title, size = 15);
plt.show();
- 지도학습에는 결정트리, 선형 회귀, 로지스틱 회귀 등이 있음
3.2 비지도 학습
- 비지도학습에는 군집 과 차원축소가 있음
- 군집은 각 데이터의 유사성을 측정한 후 유사성이 높은 데이터끼리 집단으로 분류하는 것이며, 차원축소는 차원을 나타내는 특성을 줄여 데이터를 간소화하는 것임
3.2.1 K-평균 군집화
- 데이터를 그룹으로 묶는 알고리즘임
- K-평균 군집화는 데이터가 비선형이거나 군집 크기가 다를 때, 군집마다 밀집도와 거리가 다를 때는 원하는 결과와 다르게 집단이 분류될 수 있으므로 사용하지 않는 것이 좋음
3.2.2 밀도 기반 군집 분석★★★
- 일정 밀도 이상을 가진 데이터를 기준으로 군집을 형성하는 방법으로 K-평균 군집화와 다르게 사전에 클러스터의 숫자를 알지 못할 때 사용하면 유용함
- 또한 주어진 데이터에 이상치가 많이 포함된 경우에도 사용하면 좋음
3.2.3 주성분분석
- 변수가 많은 고차원 데이터의 경우 처리해야 할 데이터 양이 많아지고 성능이 나빠지는 경향이 있음
- 이와 같은 문제를 해결하기 위해 고차원 데이터를 저차원으로 축소시키는 작업이 필요한데 이를 PCA라고 함
- 밀도 기반 군집 분석을 이용하여 클러스터링을 진행하고, 시각화를 위해 PCA를 사용할 수 있음
출처: 서지영(2022). 딥러닝 파이토치 교과서. p17-p136.
빠른 시작(Quickstart) — 파이토치 한국어 튜토리얼 (PyTorch tutorials in Korean)
머신 러닝 - epoch, batch size, iteration의 의미 : 네이버 블로그 (naver.com)
'파이토치' 카테고리의 다른 글
| [딥러닝 파이토치 교과서] 합성곱 신경망2 (0) | 2023.05.28 |
|---|---|
| [파이토치] 신경망 모델 구성/Autograd/최적화 (1) | 2023.05.14 |
| [딥러닝 파이토치 교과서] 합성곱 신경망 이해하기 (1) | 2023.05.13 |
| [딥러닝 파이토치 교과서] RNN, LSTM, GRU (0) | 2023.04.22 |
| [딥러닝 파이토치 교과서] 활성화함수와 손실 함수 (0) | 2023.04.16 |
