pytorch + visdom gère des problèmes de classification simples

Cet article présente principalement comment pytorch + visdom gère des problèmes de classification simples. Il a une certaine valeur de référence. Maintenant, je le partage avec vous. Les amis dans le besoin peuvent s'y référer

Environnement<.>

Système : win 10

Carte graphique : gtx965m
CPU : i7-6700HQ
python 3.61
pytorch 0.3

Référence du package

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

Préparation des données

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()

Regardez la visualisation ci-dessous :

préparation à la visualisation Visdom

Créez d'abord les fenêtres qui doivent être observées

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"]
  ),
)

L'effet est le suivant :

Traitement de régression logistique

Entrée 2, sortie 4

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

Sélection du GPU ou du 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##############")

Fonction d'optimisation et de perte :

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

Entraînement 2000 fois :

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()

Observation et visualisation des résultats d'entraînement :

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=&#39;center&#39; style=&#39;color:blue&#39;>accuracy : {}</h3><br><h3 align=&#39;center&#39; style=&#39;color:pink&#39;>"
       "loss : {:.4f}</h3><br><h3 align =&#39;center&#39; style=&#39;color:green&#39;>time : {:.1f}</h3>"
       .format(accuracy,loss.data[0],time.time()-start_time),win =text)

On l'exécute d'abord sur cpu, et le résultat est le suivant :

Ensuite on l'exécute sur gpu, et le résultat est le suivant :

J'ai trouvé que le CPU est beaucoup plus rapide que le GPU, mais j'ai entendu dire que l'apprentissage automatique devrait être plus rapide que le GPU, j'ai recherché sur Baidu et le. La réponse sur Zhihu est :

Je crois comprendre que la puissance de calcul du GPU est bien supérieure à celle du CPU dans le traitement de la reconnaissance d'images et d'un grand nombre d'opérations matricielles. Lors du traitement de certaines entrées et sorties avec peu d’entrées et de sorties, le processeur présente plus d’avantages.

Ajoutez une couche neuronale :

net = nn.Sequential(
  nn.Linear(2, 10),
  nn.ReLU(),  #激活函数
  nn.Linear(10, 4)
)

Ajoutez une couche neuronale de 10 unités et voyez si l'effet sera le même Amélioré :

Utilisation du processeur :

Utilisation du GPU :

Observation comparative, il ne semble y avoir aucune différence. Il semble que lorsqu'il s'agit de problèmes de classification simples (petites entrées et sorties), les couches neuronales et les GPU ne prendront pas en charge l'apprentissage automatique.

Recommandations associées :

Un exemple de construction d'un réseau neuronal simple pour implémenter la régression et la classification sur PyTorch

Explication détaillée de la formation PyTorch Batch et de la comparaison des optimiseurs

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!