카테고리 없음
PyTorch로 시작하는 딥러닝 - CH3 신경망 파헤치기
디제이망고
2021. 11. 9. 20:58
신경망 구성 요소
딥러닝 알고리즘을 학습하기 위해서는 다음과 같은 절차가 필요하다.
레이어 - 신경망 기본 블록
myLayer = Linear(in_features=10,out_features=5,bias=True)
inp = Variable(torch.randn(1,10))
myLayer = Linear(in_features=10,out_features=5,bias=True)
print(myLayer(inp))
print(myLayer.weight)
print(myLayer.bias)선형 레이어 쌓기
myLayer1 = Linear(10,5)
myLayer2 = Linear(5,2)
print(myLayer2(myLayer1(inp)))
비선형 활성 함수
시그모이드
Tanh
ReLU
Leakly ReLU
파이토치 비선형 활성화 함수
sample_data = Variable(torch.Tensor([[1,2,-1,-1]]))
myRelu = ReLU()
print(myRelu(sample_data))import torch.nn as nn
import torch.nn.functional as F
sample_data = Variable(torch.Tensor([[1,2,-1,-1]]))
f = F.relu(sample_data) # Much simpler.
print(f)
파이토치 딥러닝 알고리즘 구현하기
class MyFirstNetwork(nn.Module):
def __init__(self,input_size,hidden_size,output_size):
super(MyFirstNetwork,self).__init__()
self.layer1 = nn.Linear(input_size,hidden_size)
self.layer2 = nn.Linear(hidden_size,output_size)
def __forward__(self,input):
out = self.layer1(input)
out = nn.ReLU(out)
out = self.layer2(out)
return out
다양한 머신 러닝 문제를 위한 모델 아키텍쳐
오차 함수
loss = nn.MSELoss()
input = Variable(torch.randn(3, 5), requires_grad=True)
target = Variable(torch.randn(3, 5))
output = loss(input, target)
output.backward()def cross_entropy(true_label, prediction):
if true_label == 1:
return -log(prediction)
else:
return -log(1 - prediction)loss = nn.CrossEntropyLoss()
input = Variable(torch.randn(3, 5), requires_grad=True)
target = Variable(torch.LongTensor(3).random_(5))
output = loss(input, target)
output.backward()
네트워크 아키텍쳐 최적화
import torch.optim as optim
optimizer = optim.SGD(model.parameters(), lr = 0.01)
for input, target in dataset:
optimizer.zero_grad()
output = model(input)
loss = loss_fn(output, target)
loss.backward()
optimizer.step()
딥러닝을 이용한 이미지 분류
path = '../Chapter03/dogsandcats/'
# 폴더 안에 모든 파일 목록을 읽음
files = glob(os.path.join(path,'*/*.jpg'))
print(f'Total no of images {len(files)}')
# out: 25000
no_of_images = len(files)
# 데이터 집합을 만드는 데 사용할 셔플 색인 생성
shuffle = np.random.permutation(no_of_images)
# 검증 이미지를 저장할 검증용 디렉터리 생성
os.mkdir(os.path.join(path,'valid'))
# 레이블명으로 디렉터리 생성
for t in ['train','valid']:
for folder in ['dog/','cat/']:
os.mkdir(os.path.join(path,t,folder))
# valid 폴더에 이미지 2000장 복사
for i in shuffle[:2000]:
#shutil.copyfile(files[i],'../chapter3/dogsandcats/valid/')
folder = files[i].split('/')[-1].split('.')[0]
image = files[i].split('/')[-1]
os.rename(files[i],os.path.join(path,'valid',folder,image))
# training 폴더에 나머지 이미지 복사
for i in shuffle[2000:]:
#shutil.copyfile(files[i],'../chapter3/dogsandcats/valid/')
folder = files[i].split('/')[-1].split('.')[0]
image = files[i].split('/')[-1]
os.rename(files[i],os.path.join(path,'train',folder,image))
파이토치 Tensor로 데이터 로딩
simple_transform = transforms.Compose([transforms.Resize((224,224))
,transforms.ToTensor()
,transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])
train = ImageFolder('dogsandcats/train/',simple_transform)
valid = ImageFolder('dogsandcats/valid/',simple_transform)
print(train.class_to_idx)
print(train.classes)
# out
# {'cat': 0, 'dog': 1}
# ['cat', 'dog']imshow(train[50][0])
배치 처리 형태 파이토치로 Tensor 로딩하기
train_data_gen = torch.utils.data.DataLoader(train,shuffle=True,batch_size=64,num_workers=3)
valid_data_gen = torch.utils.data.DataLoader(valid,batch_size=64,num_workers=3)
네트워크 아키덱쳐 구축
model_ft = models.resnet18(pretrained=True)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, 2)
if torch.cuda.is_available():
model_ft = model_ft.cuda()
모델 학습
# 오차함수와 옵티마이저
learning_rate = 0.001
criterion = nn.CrossEntropyLoss()
optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9)
exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1)def train_model(model, criterion, optimizer, scheduler, num_epochs=5):
since = time.time()
best_model_wts = model.state_dict()
best_acc = 0.0
for epoch in range(num_epochs):
print('Epoch {}/{}'.format(epoch, num_epochs - 1))
print('-' * 10)
# 각 Epoch은 학습 단계와 검증 단계를 거침
for phase in ['train', 'valid']:
if phase == 'train':
scheduler.step()
model.train(True) # 학습 모드 설정
else:
model.train(False) # 검증 모드 설정
running_loss = 0.0
running_corrects = 0
# 데이터 반
for data in dataloaders[phase]:
# 입력 데이터 가져오기
inputs, labels = data
# 데이터를 Vaariable로 만듦
if torch.cuda.is_available():
inputs = Variable(inputs.cuda())
labels = Variable(labels.cuda())
else:
inputs, labels = Variable(inputs), Variable(labels)
# 파라미터 기울기 초기화
optimizer.zero_grad()
# forward
outputs = model(inputs)
_, preds = torch.max(outputs.data, 1)
loss = criterion(outputs, labels)
# 학습 단계에서만 수행, 역전파 + 옵티마이즈(최적화)
if phase == 'train':
loss.backward()
optimizer.step()
# 통계
running_loss += loss.data
running_corrects += torch.sum(preds == labels.data)
epoch_loss = running_loss.item() / dataset_sizes[phase]
epoch_acc = running_corrects.item() / dataset_sizes[phase]
print('{} Loss: {:.4f} Acc: {:.4f}'.format(
phase, epoch_loss, epoch_acc))
# 모델 복사(Deep Copy)
if phase == 'valid' and epoch_acc > best_acc:
best_acc = epoch_acc
best_model_wts = model.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 Acc: {:4f}'.format(best_acc))
# 최적의 모델 가중치 로딩
model.load_state_dict(best_model_wts)
return model
요약