pytorch+visdom 에서 간단 한 분류 문 제 를 처리 하 는 예제

환경.
시스템:win 10
그래 픽 카드:gtx 965 m
cpu ：i7-6700HQ
python 3.61
pytorch 0.3
패키지 참조

import torch
from torch.autograd import Variable
import torch.nn.functional as F
import numpy as np
import visdom
import time
from torch import nn,optim

데이터 준비

use_gpu = True
ones = np.ones((500,2))
x1 = torch.normal(6*torch.from_numpy(ones),2)
y1 = torch.zeros(500) 
x2 = torch.normal(6*torch.from_numpy(ones*[-1,1]),2)
y2 = y1 +1
x3 = torch.normal(-6*torch.from_numpy(ones),2)
y3 = y1 +2
x4 = torch.normal(6*torch.from_numpy(ones*[1,-1]),2)
y4 = y1 +3 

x = torch.cat((x1, x2, x3 ,x4), 0).float()
y = torch.cat((y1, y2, y3, y4), ).long()  

시각 화 는 다음 과 같다.

visdom 시각 화 준비
관찰 할 windows 를 만 듭 니 다.

viz = visdom.Visdom()
colors = np.random.randint(0,255,(4,3)) #    
#      loss   accuracy
line = viz.line(X=np.arange(1,10,1), Y=np.arange(1,10,1))
#           
scatter = viz.scatter(
  X=x,
  Y=y+1, 
  opts=dict(
    markercolor = colors,
    marksize = 5,
    legend=["0","1","2","3"]),)
#text       loss 、accuracy 、  
text = viz.text("FOR TEST")
#      
viz.scatter(
  X=x,
  Y=y+1, 
  opts=dict(
    markercolor = colors,
    marksize = 5,
    legend=["0","1","2","3"]
  ),
)

효 과 는 다음 과 같 습 니 다:

논리 회귀 처리
입력 2,출력 4

logstic = nn.Sequential(
  nn.Linear(2,4)
)

gpu 또는 cpu 선택:

if use_gpu:
  gpu_status = torch.cuda.is_available()
  if gpu_status:
    logstic = logstic.cuda()
    # net = net.cuda()
    print("###############  gpu##############")
  else : print("###############  cpu##############")
else:
  gpu_status = False
  print("###############  cpu##############")

유 틸 리 티 와 loss 함수:

loss_f = nn.CrossEntropyLoss()
optimizer_l = optim.SGD(logstic.parameters(), lr=0.001)

훈련 2000 회:

start_time = time.time()
time_point, loss_point, accuracy_point = [], [], []
for t in range(2000):
  if gpu_status:
    train_x = Variable(x).cuda()
    train_y = Variable(y).cuda()
  else:
    train_x = Variable(x)
    train_y = Variable(y)
  # out = net(train_x)
  out_l = logstic(train_x)
  loss = loss_f(out_l,train_y)
  optimizer_l.zero_grad()
  loss.backward()
  optimizer_l.step()

과도 한 관찰 및 시각 화 훈련:

if t % 10 == 0:
  prediction = torch.max(F.softmax(out_l, 1), 1)[1]
  pred_y = prediction.data
  accuracy = sum(pred_y ==train_y.data)/float(2000.0)
  loss_point.append(loss.data[0])
  accuracy_point.append(accuracy)
  time_point.append(time.time()-start_time)
  print("[{}/{}] | accuracy : {:.3f} | loss : {:.3f} | time : {:.2f} ".format(t + 1, 2000, accuracy, loss.data[0],
                                  time.time() - start_time))
  viz.line(X=np.column_stack((np.array(time_point),np.array(time_point))),
       Y=np.column_stack((np.array(loss_point),np.array(accuracy_point))),
       win=line,
       opts=dict(legend=["loss", "accuracy"]))
   #        gpu    ，      cpu    .cpu()  
  viz.scatter(X=train_x.cpu().data, Y=pred_y.cpu()+1, win=scatter,name="add",
        opts=dict(markercolor=colors,legend=["0", "1", "2", "3"]))
  viz.text("<h3 align='center' style='color:blue'>accuracy : {}</h3><br><h3 align='center' style='color:pink'>"
       "loss : {:.4f}</h3><br><h3 align ='center' style='color:green'>time : {:.1f}</h3>"
       .format(accuracy,loss.data[0],time.time()-start_time),win =text)

먼저 cpu 로 실행 합 니 다.결 과 는 다음 과 같 습 니 다.

그리고 gpu 로 실행 합 니 다.결 과 는 다음 과 같 습 니 다.

cpu 의 속도 가 gpu 보다 훨씬 빠 른 것 을 발 견 했 습 니 다.하지만 기계 학습 은 gpu 가 더 빠 를 것 이 라 고 들 었 습 니 다.바 이 두 가 알 게 된 답 은:

나의 이 해 는 gpu 가 이미지 인식 대량의 행렬 연산 등 방면 에서 연산 능력 이 cpu 보다 훨씬 높 고 일부 입력 과 출력 을 처리 하 는 데 매우 적 으 며 cpu 가 더욱 우세 하 다 는 것 이다.
신경 층 추가:

net = nn.Sequential(
  nn.Linear(2, 10),
  nn.ReLU(),  #    
  nn.Linear(10, 4)
)

10 단원 신경 층 을 추가 하여 효과 가 향상 되 는 지 확인 하 세 요.
cpu 사용:
 
gpu 사용:

비교 관찰 해 보면 별 차이 가 없 는 것 같 습 니 다.간단 한 분류 문제(입 출력 이 적 음)를 처리 하 는 것 같 습 니 다.신경 층 과 gpu 는 기계 학습 에 도움 이 되 지 않 습 니 다.
이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.