测试minpy 调用gpu 加速numpy的矩阵相乘. 小矩阵相乘 1到100万个元 多次

这篇文章的测试不准确,可能是minpy和numpy同时用出的问题,现在最新的测试在下面这篇文章中
https://blog.youkuaiyun.com/DarrenXf/article/details/86305215
因为觉得这是整个测试过程,就没有删除这篇文章.
测试minpy 调用gpu加速numpy的矩阵相乘.小矩阵相乘,前面的文章中已经看到行数超过1000的方阵,基本上gpu就能起到加速效果.我们现在想知道的是具体的minpy 和numpy 性能的拐点.以此帮助我们决定使用cpu还是gpu. 具体结果测试应该是根据机器所不同的,我们这里的结果只是我们测试机的的结果.上一篇测试的时候只是测试了运行一次的时间,矩阵比较小时,
测试到的运行时间误差比较大,制作的图表应该说不是很准确. 并没有能看到我们期望的明显的规律.
这次还是用方阵,行数1-1000,元素数1-100万,这次图表的表示上用了元素数.
下面代码
main.py

#!/usr/bin/python
# -*- coding: utf-8 -*-
#####################################
# File name : main.py
# Create date : 2019-01-05 17:11
# Modified date : 2019-01-10 13:17
# Author : DARREN
# Describe : not set
# Email : lzygzh@126.com
#####################################
from __future__ import division
from __future__ import print_function

import os
import time
import numpy as np
import numpy.random as random
import minpy.numpy as mnp
import matplotlib.pyplot as plt

def create_path(path):
    if not os.path.isdir(path):
        os.makedirs(path)

def get_file_full_name(path, name):
    create_path(path)
    if path[-1] == "/":
        full_name = path +  name
    else:
        full_name = path + "/" +  name
    return full_name

def create_file(path, name, open_type='w'):
    file_name = get_file_full_name(path, name)
    return open(file_name, open_type)

def _plot_record(record,full_path):
    _plot_a_key(record, full_path, "numpy", "minpy",)
    _plot_key(record,full_path, "acceleration")

def _get_full_path(repeats, data_type, size_begin, size_end):
    if not os.path.exists("./output"):
        os.makedirs("./output")
    path_str = "./output/%s_%s_%s_%s" % (repeats, data_type, size_begin, size_end)
    return path_str

def _plot_a_key(record, full_path, name1, name2):
    numpy_lt = []
    minpy_lt = []
    steps = []
import torch import matplotlib.pyplot as plt from time import perf_counter # 准备数据 # 生成矩阵X def Produce_X(x): x0 = torch.ones(x.numpy().size) # 用ones产生初始值为1,大小与x相同的向量 X = torch.stack((x, x0), dim=1) # stack函数将两个向量拼合 return X x = torch.linspace(-3, 3, 100000) # 用linspace产生(-3,3)区间内的100000个点 X = Produce_X(x) y = x + 1.2 * torch.rand(x.size()) # 假设真实函数是y=x,我们在上面增加一些误差,更加符合实际情况 w = torch.rand(2) # 定义权重w的变量 ''' #散点图查看样本数据的分布情况 plt.scatter(x.numpy(),y.numpy(),s=0.001) plt.show() ''' # 如果支持CUDA,则采用CUDA加速 CUDA = torch.cuda.is_available() if CUDA: inputs = X.cuda() target = y.cuda() w = w.cuda() w.requires_grad = True else: inputs = X target = y w = w w.requires_grad = True # 可视化 # plt.ion() # plt.show() def draw(output, loss): # print loss if CUDA: output = output.cpu() plt.cla() plt.scatter(x.numpy(), y.numpy()) plt.plot(x.numpy(), output.data.numpy(), 'r-', lw=5) plt.text(0.5, 0, 'Loss=%s' % (loss.item()), fontdict={'size': 20, 'color': 'red'}) plt.pause(0.005) def train(epochs=1, learning_rate=0.01): for epoch in range(epochs): # 前向传播 output = inputs.mv(w) # 公式:y=Xw loss = (output - target).pow(2).sum() / 100000 # 公式:J = (∑(y-y')^2)/100000 # 反向传播 loss.backward() w.data -= learning_rate * w.grad # 更新权重w,公式:w_(t+1)= w_(t) - 𝜼*▽J w.grad.zero_() # 清空grad的值 if epoch % 80 == 0: draw(output, loss) return w, loss start = perf_counter() w, loss = train(10000, learning_rate=1e-4) # 学习率设置为1x10^(-4) finish = perf_counter() time = finish - start print("计算时间:%s" % time) print("final loss:", loss.item()) print("weights:", w.data) 对运行结果简要解释
最新发布
10-22
# 代码概述 该代码实现了一个基于 PyTorch 的大规模线性回归训练过程,使用 100,000 个数据点拟合模型 $ y \approx x $,并引入随机噪声以模拟真实数据。支持 CPU 与 CUDA 加速,并通过可视化展示训练过程中模型的拟合效果。 --- # 代码解析 ### 1. 数据生成 ```python x = torch.linspace(-3, 3, 100000) y = x + 1.2 * torch.rand(x.size()) ``` - 在区间 $[-3, 3]$ 内生成 10 万个等距点 - 真实关系为 $ y = x $,但加入均匀分布噪声(幅度约1.2),形成带扰动的数据集 ### 2. 设计矩阵构造 ```python X = Produce_X(x) ``` 构建形如: $$ X = \begin{bmatrix} x_1 & 1 \\ x_2 & 1 \\ \vdots & \vdots \\ x_n & 1 \end{bmatrix} $$ 用于表示线性模型:$\hat{y} = w_1 x + w_2$ --- ### 3. 权重初始化与设备选择 ```python w = torch.rand(2) if CUDA: ... # 将张量移至GPU w.requires_grad = True ``` - 初始化权重向量 $ w = [w_1, w_2] $ - 若有 CUDA 支持,则启用 GPU 加速计算,显著提升大样本训练速度 --- ### 4. 损失函数调整 ```python loss = (output - target).pow(2).sum() / 100000 ``` 使用**均方误差(MSE)**形式的损失函数: $$ J(w) = \frac{1}{n} \sum_{i=1}^{n}(y_i - \hat{y}_i)^2,\quad n=100000 $$ 归一化后损失值更稳定,便于跨规模比较。 --- ### 5. 训练与更新 ```python loss.backward() w.data -= learning_rate * w.grad w.grad.zero_() ``` 标准梯度下降流程: - 自动求导得到梯度 $\nabla_w J$ - 手动更新权重 - 清空梯度防止累积 --- ### 6. 可视化与性能计时 ```python start = perf_counter() ... finish = perf_counter() time = finish - start ``` 记录整个训练耗时(单位:秒),反映训练效率。 每 80 轮调用 `draw()` 显示当前拟合直线和损失值。 --- # 对运行结果的简要解释 运行该代码后输出如下三行信息: ```text 计算时间: X.XXX final loss: 0.479... weights: tensor([接近1.0, 接近0.6]) ``` 具体含义如下: ### ✅ **1. 计算时间** 显示从开始到结束所消耗的时间(单位:秒)。若使用 GPU(CUDA),时间明显短于 CPU;否则为纯 CPU 运行时间。 例如: - CPU:可能约为 10~20 秒(取决于硬件) - GPU:可缩短至 1~3 秒 ### ✅ **2. 最终损失值(final loss)** 损失收敛到大约 **0.48 左右**,表明模型预测值与真实值之间的平均平方误差较小,训练有效。 由于数据中包含不可消除的噪声(`1.2 * rand`),损失无法降到 0,这是合理的。 ### ✅ **3. 学习到的权重(weights)** 期望模型学习到: $$ \hat{y} = w_1 x + w_2 \approx x + \text{bias} $$ 因此: - $ w_1 $(斜率)应接近 **1.0** - $ w_2 $(偏置)约为 **0.6**(因为 `1.2 * rand()` 的均值为 0.6) > 示例输出: > ``` > weights: tensor([0.998, 0.597]) > ``` 说明模型成功逼近真实关系:$ y \approx x + 0.6 $ ### ✅ **图像表现** 动态图像中: - 散点呈围绕直线 $ y=x $ 的带状分布 - 初始红线偏离大、损失高 - 随着训练进行,红线逐渐贴近数据主趋势,损失下降 - 最终红线基本穿过数据中心,达到良好拟合 --- # 知识点 **1. 均方误差(MSE)** 将误差平方和除以样本数,使损失对样本规模不敏感,常用于回归任务评估。 **2. CUDA加速原理** 利用GPU并行处理大量数值运算,在大数据场景下显著提升深度学习训练速度。 **3. 梯度下降优化** 通过反向传播计算梯度,沿负梯度方向更新参数,逐步最小化损失函数。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值