Pytorch基本运算

最新推荐文章于 2022-07-06 14:29:25 发布
最新推荐文章于 2022-07-06 14:29:25 发布
阅读量274 收藏 5
点赞数
分类专栏： AI 深度学习 文章标签： pytorch python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39276337/article/details/120368374
版权

Pytorch下载

https://pytorch.org/get-started/locally/ 选择对应的版本命令
在这里插入图片描述
window/mac cpu

pip3 install torch torchvision torchaudio

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

import torch

#定义向量
vector = torch.tensor([1,2,3,4])
print('Vector:\t\t', vector)
print('Vector Shape:\t', vector.shape)

Vector:		 tensor([1, 2, 3, 4])
Vector Shape:	 torch.Size([4])

#定义矩阵
matrix = torch.tensor([[1,2],[3,4]])
print('Matrix:\n', matrix)
print('Matirx Shape:\n', matrix.shape)

Matrix:
 tensor([[1, 2],
        [3, 4]])
Matirx Shape:
 torch.Size([2, 2])

#定义张量
tensor = torch.tensor([[[1,2],[3,4]],[[1,2],[3,4]]])
print('Tensor:\n', tensor)
print('Tensor Shape:\n', tensor.shape)

Tensor:
 tensor([[[1, 2],
         [3, 4]],

        [[1, 2],
         [3, 4]]])
Tensor Shape:
 torch.Size([2, 2, 2])

# torch.tensor( )是一个function，在pycharm使用的时候会有标志
# torch.Tensor是一个class，是torch.FloatTensor的别称
a = torch.Tensor([[1, 2],[3, 4]]) 
print(a)
print(a.type())# 直接定义是float类型

tensor([[1., 2.],
        [3., 4.]])
torch.FloatTensor

b = torch.Tensor(2, 2) #直接使用shape定义tensor
print(b)

tensor([[1.0000e+00, 0.0000e+00],
        [2.9848e-43, 0.0000e+00]])

d = torch.tensor(((1, 2), (3, 4)))
print(d.type())
print(d.type_as(a))

torch.LongTensor
tensor([[1., 2.],
        [3., 4.]])

d = torch.empty(2,3)
print(d.type())
print(d.type_as(a))

torch.FloatTensor
tensor([[0., 0., 0.],
        [0., 0., 0.]])

d = torch.zeros(2,3)
print(d.type())
print(d.type_as(a))

torch.FloatTensor
tensor([[0., 0., 0.],
        [0., 0., 0.]])

d = torch.zeros_like(d)
print(d.type())
print(d.type_as(a))

torch.FloatTensor
tensor([[0., 0., 0.],
        [0., 0., 0.]])

d = torch.eye(2, 2)
print(d.type())
print(d.type_as(a))

torch.FloatTensor
tensor([[1., 0.],
        [0., 1.]])

d = torch.ones(2, 2)
print(d.type())
print(d.type_as(a))

d = torch.ones_like(d)
print(d.type())
print(d.type_as(a))

torch.FloatTensor
tensor([[1., 1.],
        [1., 1.]])
torch.FloatTensor
tensor([[1., 1.],
        [1., 1.]])

d = torch.rand(2, 3) # 随机浮点 [0, 1)
print(d.type())
print(d.type_as(a))

torch.FloatTensor
tensor([[0.9853, 0.5354, 0.3119],
        [0.5001, 0.2459, 0.6053]])

d = torch.arange(2, 10, 2)
print(d.type())
print(d.type_as(a))

torch.LongTensor
tensor([2., 4., 6., 8.])

d = torch.linspace(10, 2, 3)
print(d.type())
print(d.type_as(a))
d

torch.FloatTensor
tensor([10.,  6.,  2.])





tensor([10.,  6.,  2.])

dd = torch.normal(mean=0, std=1, size=(2, 3))
dd

tensor([[ 1.9897, -1.0289, -0.4013],
        [ 0.7787, -1.2150, -2.2234]])

d = torch.normal(mean=torch.rand(5), std=torch.rand(5))
# 五组 不同均值和标准差的数据   常用于初始化数据
print(d.type())
print(d.type_as(a))

torch.FloatTensor
tensor([0.8920, 0.2696, 1.0647, 1.3374, 0.8834])

d = torch.Tensor(2, 2).uniform_(-1, 1)  #均匀分布
print(d.type())
print(d.type_as(a))

torch.FloatTensor
tensor([[-0.4591, -0.0127],
        [-0.2035, -0.2403]])

d = torch.randperm(10) # 随机全排列
print(d.type())
print(d.type_as(a))

torch.LongTensor
tensor([9., 6., 3., 5., 0., 8., 4., 2., 1., 7.])

# 转换为numpy
d.numpy()

array([9, 6, 3, 5, 0, 8, 4, 2, 1, 7], dtype=int64)

Tensor的属性

d.dtype

torch.int64

d.device

device(type='cpu')

d.layout 
# torch.layout 表明内存布局（memory layout），即 tensor 在物理设备中的储存结构。
#学过数据结构的都知道储存结构（物理结构）简单可以分为：顺序储存、链式储存。

# torch.layout 可选torch.stried或torch.sparse_coo。分别对应顺序储存、离散储存。

# 一般说，稠密张量适用torch.stried(跨步)，稀疏张量（0 比较多）适用torch.sparse_coo。

torch.strided

dev = torch.device("cpu")
# dev = torch.device("cuda")
a = torch.tensor([2, 2],
                 dtype=torch.float32,
                 device=dev)
print(a)

i = torch.tensor([[0, 1, 2], [0, 1, 2]]) # 坐标 (0, 0) (1, 1) (2, 2)对角线
v = torch.tensor([1, 2, 3])
# 定义稀疏张量 coo 非零的元素的个数, 非零越多越稀疏
#  (4, 4)是形状
a = torch.sparse_coo_tensor(i, v, (4, 4),
                            dtype=torch.float32,
                            device=dev)
print(a)
a.layout

tensor([2., 2.])
tensor(indices=tensor([[0, 1, 2],
                       [0, 1, 2]]),
       values=tensor([1., 2., 3.]),
       size=(4, 4), nnz=3, layout=torch.sparse_coo)





torch.sparse_coo

a = torch.sparse_coo_tensor(i, v, (4, 4),
                            dtype=torch.float32,
                            device=dev).to_dense()  # 转换成稠密张量
print(a)
a.layout

tensor([[1., 0., 0., 0.],
        [0., 2., 0., 0.],
        [0., 0., 3., 0.],
        [0., 0., 0., 0.]])





torch.strided

基本运算

##add
a = torch.arange(1, 7).reshape((2, 3))
b = torch.arange(1, 7).reshape((2, 3))
print(a)
print(b)

tensor([[1, 2, 3],
        [4, 5, 6]])
tensor([[1, 2, 3],
        [4, 5, 6]])

print(a + b)
print(a.add(b))
print(torch.add(a, b))
print(a)
print(a.add_(b))
print(a)  # a的值会变
print(b)  

tensor([[ 3,  6,  9],
        [12, 15, 18]])
tensor([[ 3,  6,  9],
        [12, 15, 18]])
tensor([[ 3,  6,  9],
        [12, 15, 18]])
tensor([[ 2,  4,  6],
        [ 8, 10, 12]])
tensor([[ 3,  6,  9],
        [12, 15, 18]])
tensor([[ 3,  6,  9],
        [12, 15, 18]])
tensor([[1, 2, 3],
        [4, 5, 6]])

#sub
print("==== sub res ====")
print(a - b)
print(torch.sub(a, b))
print(a.sub(b))
print(a.sub_(b))
print(a)

==== sub res ====
tensor([[ 2,  4,  6],
        [ 8, 10, 12]])
tensor([[ 2,  4,  6],
        [ 8, 10, 12]])
tensor([[ 2,  4,  6],
        [ 8, 10, 12]])
tensor([[ 2,  4,  6],
        [ 8, 10, 12]])
tensor([[ 2,  4,  6],
        [ 8, 10, 12]])

在这里插入图片描述

## mul
print("===== mul ====")
print(a * b)  # 哈达玛积
print(torch.mul(a, b))
print(a.mul(b))
print(a)
print(a.mul_(b))
print(a)

===== mul ====
tensor([[  2,  16,  54],
        [128, 250, 432]])
tensor([[  2,  16,  54],
        [128, 250, 432]])
tensor([[  2,  16,  54],
        [128, 250, 432]])
tensor([[ 2,  8, 18],
        [32, 50, 72]])
tensor([[  2,  16,  54],
        [128, 250, 432]])
tensor([[  2,  16,  54],
        [128, 250, 432]])

# div
a = torch.rand(2, 3)
b = torch.rand(2, 3)
print("=== div ===")
print(a/b)
print(torch.div(a, b))
print(a.div(b))
print(a.div_(b))
print(a)

=== div ===
tensor([[0.4915, 0.5121, 2.2019],
        [1.7804, 0.4173, 1.5148]])
tensor([[0.4915, 0.5121, 2.2019],
        [1.7804, 0.4173, 1.5148]])
tensor([[0.4915, 0.5121, 2.2019],
        [1.7804, 0.4173, 1.5148]])
tensor([[0.4915, 0.5121, 2.2019],
        [1.7804, 0.4173, 1.5148]])
tensor([[0.4915, 0.5121, 2.2019],
        [1.7804, 0.4173, 1.5148]])

###matmul 矩阵相乘
a = torch.ones(2, 1)
b = torch.ones(1, 2)
print(a)
print(b)
## 以下都是一样的 
print(a @ b)
print(a.matmul(b))
print(torch.matmul(a, b))
print(torch.mm(a, b))
print(a.mm(b))

tensor([[1.],
        [1.]])
tensor([[1., 1.]])
tensor([[1., 1.],
        [1., 1.]])
tensor([[1., 1.],
        [1., 1.]])
tensor([[1., 1.],
        [1., 1.]])
tensor([[1., 1.],
        [1., 1.]])
tensor([[1., 1.],
        [1., 1.]])

##高维tensor
a = torch.ones(1, 2, 3, 4)
b = torch.ones(1, 2, 4, 3)
print(a.matmul(b))
print(a.matmul(b).shape)


tensor([[[[4., 4., 4.],
          [4., 4., 4.],
          [4., 4., 4.]],

         [[4., 4., 4.],
          [4., 4., 4.],
          [4., 4., 4.]]]])
torch.Size([1, 2, 3, 3])

##pow
a = torch.tensor([1, 2])
print(torch.pow(a, 3))
print(a.pow(3))
print(a**3)
print(a.pow_(3))
print(a)

tensor([1, 8])
tensor([1, 8])
tensor([1, 8])
tensor([1, 8])
tensor([1, 8])

#exp e的几次方
a = torch.tensor([1, 2],
                 dtype=torch.float32)
print(a.type())
print(torch.exp(a))
print(torch.exp_(a))
print(a.exp())
print(a.exp_())


torch.FloatTensor
tensor([2.7183, 7.3891])
tensor([2.7183, 7.3891])
tensor([  15.1543, 1618.1781])
tensor([  15.1543, 1618.1781])

##log
a = torch.tensor([10, 2],
                 dtype=torch.float32)
print(torch.log(a)) # 底数是e
print(torch.log2(a))
print(torch.log10(a))

print(torch.log_(a))
print(a.log())
print(a.log_())


tensor([2.3026, 0.6931])
tensor([3.3219, 1.0000])
tensor([1.0000, 0.3010])
tensor([2.3026, 0.6931])
tensor([ 0.8340, -0.3665])
tensor([ 0.8340, -0.3665])

##sqrt
a = torch.tensor([10, 2],
                 dtype=torch.float32)
print(torch.sqrt(a))
print(torch.sqrt_(a))

print(a.sqrt())
print(a.sqrt_())

tensor([3.1623, 1.4142])
tensor([3.1623, 1.4142])
tensor([1.7783, 1.1892])
tensor([1.7783, 1.1892])

a = torch.rand(2, 2)
a = a * 10
print(a)

print(torch.floor(a))
print(torch.ceil(a))
print(torch.round(a))
print(torch.trunc(a))
print(torch.frac(a))
print(a % 2)
b = torch.tensor([[2, 3], [4, 5]],
                 dtype=torch.float)

tensor([[6.3697, 7.0186],
        [2.7078, 9.1732]])
tensor([[6., 7.],
        [2., 9.]])
tensor([[ 7.,  8.],
        [ 3., 10.]])
tensor([[6., 7.],
        [3., 9.]])
tensor([[6., 7.],
        [2., 9.]])
tensor([[0.3697, 0.0186],
        [0.7078, 0.1732]])
tensor([[0.3697, 1.0186],
        [0.7078, 1.1732]])

a = torch.rand(2, 3)
b = torch.rand(2, 3)

print(a)
print(b)

print(torch.eq(a, b))
print(torch.equal(a, b))

print(torch.ge(a, b))
print(torch.gt(a, b))
print(torch.le(a, b))
print(torch.lt(a, b))
print(torch.ne(a, b))

tensor([[0.9355, 0.8971, 0.8710],
        [0.9562, 0.6887, 0.5133]])
tensor([[0.5730, 0.4295, 0.9110],
        [0.6943, 0.3907, 0.2165]])
tensor([[False, False, False],
        [False, False, False]])
False
tensor([[ True,  True, False],
        [ True,  True,  True]])
tensor([[ True,  True, False],
        [ True,  True,  True]])
tensor([[False, False,  True],
        [False, False, False]])
tensor([[False, False,  True],
        [False, False, False]])
tensor([[True, True, True],
        [True, True, True]])

在这里插入图片描述

在这里插入图片描述上面的rand(3)需要补充到 (1, 1, 3),从右面看满足右对齐的条件时 要么相等要么有一个是1

a = torch.tensor([[1, 4, 4, 3, 5],
                  [2, 3, 1, 3, 5]])
print(a.shape)
print(torch.sort(a, dim=1,
                 descending=False))

##topk
a = torch.tensor([[2, 4, 3, 1, 5],
                  [2, 3, 5, 1, 4]])
print(a.shape)

print(torch.topk(a, k=2, dim=1, largest=False))

print(torch.kthvalue(a, k=2, dim=0))
print(torch.kthvalue(a, k=2, dim=1))

a = torch.rand(2, 3)
print(a)
print(a/0)
print(torch.isfinite(a))
print(torch.isfinite(a/0))
print(torch.isinf(a/0))
print(torch.isnan(a))

import numpy as np
a = torch.tensor([1, 2, np.nan])
print(torch.isnan(a))

a = torch.rand(2, 3)
print(a)
print(torch.topk(a, k=2, dim=1, largest=False))
print(torch.topk(a, k=2, dim=1, largest=True))

a = torch.rand(2, 2)
b = torch.rand(1, 2)
d = torch.rand(1, 3)

# a, 2*1
# b, 1*2
# c, 2*2
# 2*4*2*3
c = a + b
print(a)
print(b)
print(c)
print(c.shape)

tensor([[0.9504, 0.3773],
[0.7862, 0.6375]])
tensor([[0.7592, 0.0868]])
tensor([[1.7096, 0.4641],
[1.5454, 0.7243]])
torch.Size([2, 2])

a + d

RuntimeError Traceback (most recent call last)
in ()
----> 1 a + d

RuntimeError: The size of tensor a (2) must match the size of tensor b (3) at non-singleton dimension 1
在这里插入图片描述

a = torch.rand(2, 2)
a = a * 10
print(a)

print(torch.floor(a))
print(torch.ceil(a))
print(torch.round(a))
print(torch.trunc(a))
print(torch.frac(a))
print(a % 2)
b = torch.tensor([[2, 3], [4, 5]],
                 dtype=torch.float)

tensor([[0.1020, 3.1624],
[5.8866, 3.4707]])
tensor([[0., 3.],
[5., 3.]])
tensor([[1., 4.],
[6., 4.]])
tensor([[0., 3.],
[6., 3.]])
tensor([[0., 3.],
[5., 3.]])
tensor([[0.1020, 0.1624],
[0.8866, 0.4707]])
tensor([[0.1020, 1.1624],
[1.8866, 1.4707]])

在这里插入图片描述

__Miracle__
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PyTorch的数学运算
herosunly的博客
03-30 1万+
1. 张量的乘法(矩阵的乘法) 2. 幂 3. 指数 4. 近似 5. clamp 6. 范数 6.1 向量归一化 7. 统计值 8. ndim 9. topk 10. 高阶OP 10.1 Where 10.2 Gather
pytorch 基本运算 统计属性.ipynb
04-19
pytorch 基本运算 统计属性.ipynb
【01】pytorch基础知识-基本运算
keep用心的博客
04-01 1511
作业题 1. 安装anaconda,pycharm, CUDA+CuDNN（可选），虚拟环境，pytorch，并实现hello pytorch查看pytorch的版本 2. 张量与矩阵、向量、标量的关系是怎么样的？ 标量是0维的数据，只有一个值，向量是1维的数据，矩阵是2维的数据，张量是高维的数据； 3. Variable“赋予”张量什么功能？ 赋予变量求梯度的功能，可以在torch的计算图中运算 4. 采用torch.from_numpy创建张量，并打印查看ndarray和张量数据的地址； 5. 实现
【小白学PyTorch】10.pytorch常见运算详解
fengdu78的博客
09-22 484
<<小白学PyTorch>>小白学PyTorch | 9 tensor数据结构与存储结构小白学PyTorch | 8 实战之MNIST小试牛刀小白学PyTorch...
pytorch 基本运算
qq_37333800的博客
01-07 666
有重载运算符 和 函数两种方法进行张量的运算 import torch import numpy as np a = torch.rand(2,3) b = torch.rand(3) # 这里b 使用了 broatcasting 自动进行了维度扩展 print("运算符 + 与 add() 方法运算结果一致：{} ".format(torch.all(torch.eq(torch.add(a,b...
pytorch 基础数学运算
学-> 思->用
12-24 194
pytorch 基础数学运算 # -*- coding:utf-8 -*- # /usr/bin/python ''' ------------------------------------------------- File Name ： base_math Description : Envs : Author : yanerro...
Pytorch Tensor基本数学运算详解
09-18
今天小编就为大家分享一篇Pytorch Tensor基本数学运算详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
PyTorch基本数据类型（一）
01-01
PyTorch基础入门一：PyTorch基本数据类型 1）Tensor(张量) Pytorch里面处理的最基本的操作对象就是Tensor（张量），它表示的其实就是一个多维矩阵，并有矩阵相关的运算操作。在使用上和numpy是对应的，它和numpy唯一...
Pytorch基本变量类型FloatTensor与Variable用法
01-21
pytorch中的dochi给出一些对于floattensor的基本的操作，比如四则运算以及平方等(链接)，这些操作对于floattensor是十分的不友好，有时候需要写一个正则化的项需要写很长的一串，比如两个floattensor之间的相加需要...
Pytorch Tensor基本数学运算
热门推荐
洪流之源
06-26 5万+
1. 加法运算 示例代码： import torch # 这两个Tensor加减乘除会对b自动进行Broadcasting a = torch.rand(3, 4) b = torch.rand(4) c1 = a + b c2 = torch.add(a, b) print(c1.shape, c2.shape) print(torch.all(torch.eq(c1, c2))) ...
Pytorch-矩阵基本运算
Mr___WQ的博客
07-06 2102
pytorch入门，矩阵基本运算
【Pytorch基础】Pytorch的基本运算操作
sxl的博客
04-26 1706
  Pytorch跟Python一样都是一种编程语言，只不过Pytorch可以在GPU中进行计算。简单理解的话，就是这个区别吧。至于如何学习Pytorch，个人 觉得完全可以类比，Python两者语法跟用法没有太大差异。再者，为什么学习Pytorch基本计算，而不是用Python基本计算代替再转成tensor格式。个人在代码实现中的体会是：太麻烦，因为Pytorch默认创建变量的类型是float32，使用Python的数据类型如array是float64，如果进行tensor的转换后在计算会报错，变量类型不
Python学习四 —— 运算符
kyle
09-22 252
运算符 1. 运算符的概念 运算符主要分四大类 算数运算符 逻辑运算符 比较运算符 赋值运算符 条件运算符（三元运算） 2. 算数运算符 加、减、乘、除、取整除、取余、幂、开方 加 减 乘 除 取整除 取余 幂 开方 + - * / // % ** **1/2 3. 逻辑运算符 0，空串，None转换为False，其他都是True and逻辑与可以对符号两侧进行计算 只有符号两侧的值都为True的时候，才返回True，只要有一个False,就会返回Fals
Pytorch官网学习
qq_43124451的博客
12-10 1237
with as 的用法
python 或运算_Python运算符
weixin_36059505的博客
01-24 1万+
Python运算符1、 算术运算符Ø +(加)、-（减）、*（乘）、/（除），这四个运算符是跟数学上的意义一致。Ø %（取余）：两者相除取余数。Ø //（取整）：两者相除取整数。Ø **（幂）：x的y次幂。a=100b=21c=2d=5print(a+b)print(a-b)print(a/b)print(a*b)print(a%b)print(a//b)print(c**d)输出结果：C:Use...
CNN表情识别系统制作(1)----fer2013人脸表情数据集简介
__Miracle__
06-11 5192
fer2013人脸表情数据集简介 fer2013人脸表情数据集由35886张人脸表情图片组成，其中，测试图（Training）28708张，公共验证图（PublicTest）和私有验证图（PrivateTest）各3589张，每张图片是由大小固定为48×48的灰度图像组成，共有7种表情，分别对应于数字标签0-6，具体表情对应的标签和中英文如下：0 anger 生气； 1 disgust 厌恶； 2 fear 恐惧； 3
使用Pytorch构建回归模型进行波士顿房价预测
__Miracle__
09-18 1709
加载数据 import torch import numpy as np from sklearn import datasets from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler boston = datasets.load_boston() X = boston.data y = boston.target X = X[y < 50.0] y.
深度学习速成版01---神经网络
__Miracle__
09-22 1594
深度学习与机器学习的区别 机器学习的特征工程步骤是要靠手动完成的，而且需要大量领域专业知识 深度学习通常由多个层组成，它们通常将更简单的模型组合在一起，通过将数据从一层传递到另一层来构建更复杂的模型。通过大量数据的训练自动得到模型，不需要人工设计特征提取环节。 深度学习算法试图从数据中学习高级功能，这是深度学习的一个非常独特的部分。因此，减少了为每个问题开发新特征提取器的任务。适合用在难提取特征的图像、语音、自然语言领域 神经网络 人工神经网络（ Artificial Neural Network，
pytorch基本操作
最新发布
09-07
在PyTorch中，有一些基本的操作可以用来进行数学运算和张量操作。其中一些操作包括： 1. 加法操作（torch.add）：可以对两个张量进行逐元素相加。 2. 减法操作（torch.sub）：可以对两个张量进行逐元素相减。 3. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值