个人中心
gpt4 book ai didi

pytorch + visdom 处理简单分类问题的示例

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 24 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章pytorch + visdom 处理简单分类问题的示例由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

环境 。

系统 ： win 10 显卡：gtx965m cpu ：i7-6700hq python 3.61 pytorch 0.3 。

包引用 。

?
1
2
3
4
5
6
7
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

数据准备 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
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 ()

可视化如下看一下:

pytorch + visdom 处理简单分类问题的示例

visdom可视化准备 。

先建立需要观察的windows 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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" ]
   ),
)

效果如下:

pytorch + visdom 处理简单分类问题的示例

逻辑回归处理 。

输入2，输出4 。

?
1
2
3
logstic = nn.sequential(
   nn.linear( 2 , 4 )
)

gpu还是cpu选择:

?
1
2
3
4
5
6
7
8
9
10
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函数:

?
1
2
loss_f = nn.crossentropyloss()
optimizer_l = optim.sgd(logstic.parameters(), lr = 0.001 )

训练2000次:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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()

训练过成观察及可视化:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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运行一次，结果如下:

pytorch + visdom 处理简单分类问题的示例

然后用gpu运行一下，结果如下:

pytorch + visdom 处理简单分类问题的示例

发现cpu的速度比gpu快很多，但是我听说机器学习应该是gpu更快啊，百度了一下，知乎上的答案是:

pytorch + visdom 处理简单分类问题的示例

我的理解就是gpu在处理图片识别大量矩阵运算等方面运算能力远高于cpu，在处理一些输入和输出都很少的，还是cpu更具优势.

添加神经层:

?
1
2
3
4
5
net = nn.sequential(
   nn.linear( 2 , 10 ),
   nn.relu(),  #激活函数
   nn.linear( 10 , 4 )
)

添加一层10单元神经层，看看效果是否会有所提升:

使用cpu:

pytorch + visdom 处理简单分类问题的示例

使用gpu:

pytorch + visdom 处理简单分类问题的示例

比较观察，似乎并没有什么区别，看来处理简单分类问题（输入，输出少）的问题，神经层和gpu不会对机器学习加持.

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我.

原文链接：https://blog.csdn.net/tonydz0523/article/details/79032936 。

最后此篇关于pytorch + visdom 处理简单分类问题的示例的文章就讲到这里了,如果你想了解更多关于pytorch + visdom 处理简单分类问题的示例的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

24 4 0
文章推荐： python topN 取最大的N个数或最小的N个数方法
文章推荐： java 中枚举类enum的values()方法的详解
文章推荐： Java进阶之FileUpload完成上传的实例
文章推荐： numpy中以文本的方式存储以及读取数据方法
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com