当前位置： 首页 > news >正文

Pytorch入门基础知识（一）

news 来源：原创 2024/5/5 16:54:19

目录

一、Tensor的基本定义

二、Tensor的类型 

 三、Tensor常用函数

 3.1 Tensor创建相关函数

3.2 Tensor的属性 

 3.3 Tensor加法运算

 3.4 减法运算

 3.5 乘法运算

 3.6 除法运算

3.7 矩阵运算

3.8 指数运算

3.9 对数运算

3.10 开方运算

 三、Pytorch中的广播机制​

四、Pytorch中的基本操作

4.1 Pytorch取整、取余相关函数 

 4.2  pytorch中的三角函数&其他常用函数

4.3 Pytorch比较运算符

4.4 pytorch排序相关函数

一、Tensor的基本定义

张量（tensor）是pytorch中最基础的一种数据结构 ，在pytorch中的操作都是基于tensor。我们可能对标量，向量，矩阵都非常熟悉，其实张量是标量、矩阵等更为高维、更为普遍的表现形式。

二、Tensor的类型 

在 torch 中 分为CUP 存储运算的tensor和 GPU存储运算的张量。Tensor在cpu、gpu下分别有 8 种数据类型，其中默认的数据类型为 32 位浮点型

数据类型dtypeCPU TensorGPU Tensor
16 位浮点型torch.float16 或 torch.halftorch.HalfTensortorch.cuda.HalfTensor
32 位浮点型torch.float32 或 torch.floattorch.FloatTensortorch.cuda.FloatTensor
64 位浮点型torch.float64 或 torch.doubletorch.DoubleTensortorch.cuda.DoubleTensor
8 位无符号整型torch.uint8torch.ByteTensortorch.cuda.ByteTensor
8 位有符号整型torch.int8torch.CharTensortorch.cuda.CharTensor
16 位有符号整型torch.int16 或 torch.shorttorch.ShortTensortorch.cuda.ShortTensor
32 位有符号整型torch.int32 或 torch.inttorch.IntTensortorch.cuda.IntTensor
64 位有符号整型torch.int64 或 torch.longtorch.LongTensortorch.cuda.LongTensor

 三、Tensor常用函数

 3.1 Tensor创建相关函数

import torch
#直接使用数据初始化一个张量
a=torch.Tensor([[1,2,4],[4,9,3],[2,7,5]])
print(a)
print(a.type())
#直接规定张量形状的方式来定义一个tensor
b=torch.Tensor(4,5)
print(b)
print(b.type())

#定义元素全是1的张量
c=torch.ones(2,3)
print(c)
print(c.type())

#定义对角线全是1的张量
d=torch.eye(3,4)
print(d)
print(d.type())

#定于元素全是0的张量
e=torch.zeros(4,5)
print(e)

f=torch.Tensor([[1,7,3],
               [4,5,0]])
#定义类张量f、元素全为1的Tensor
print(torch.ones_like(f))
#定义类张量f、元素全为0的Tensor
print(torch.zeros_like(f))

#随机生成Tensor
g=torch.rand(4,6)
print(g)
tensor([[1., 2., 4.],
        [4., 9., 3.],
        [2., 7., 5.]])
torch.FloatTensor
tensor([[0.0000e+00, 1.8750e+00, 0.0000e+00, 2.0000e+00, 0.0000e+00],
        [2.2500e+00, 0.0000e+00, 2.2500e+00, 0.0000e+00, 2.5312e+00],
        [0.0000e+00, 2.1250e+00, 0.0000e+00, 2.0000e+00, 0.0000e+00],
        [2.4375e+00, 0.0000e+00, 2.3125e+00, 8.4490e-39, 1.0194e-38]])
torch.FloatTensor
tensor([[1., 1., 1.],
        [1., 1., 1.]])
torch.FloatTensor
tensor([[1., 0., 0., 0.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.]])
torch.FloatTensor
tensor([[0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0.]])
tensor([[1., 1., 1.],
        [1., 1., 1.]])
tensor([[0., 0., 0.],
        [0., 0., 0.]])
tensor([[0.5883, 0.6820, 0.1486, 0.1378, 0.2527, 0.9632],
        [0.1268, 0.8534, 0.8985, 0.4486, 0.4386, 0.0506],
        [0.8461, 0.1896, 0.2956, 0.7772, 0.0755, 0.1335],
        [0.8106, 0.9190, 0.2299, 0.3782, 0.6713, 0.8427]])

 下面重点看一下

torch.normal()函数

官方文档给出的解释是返回一个张量，张量里面的随机数是从相互独立的正态分布中随机生成的。举一个例子来解释一下

为了防止列举的例子太过隐晦难懂，先复习一下 torch.arange（）函数的用法

print(torch.arange(1.,11.))
'''
运行结果
tensor([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])
'''
print(torch.arange(1,0,-0.1))
'''
运行结果
tensor([1.0000, 0.9000, 0.8000, 0.7000,
 0.6000, 0.5000, 0.4000, 0.3000, 0.2000,
        0.1000])
'''

a=torch.normal(mean=torch.arange(1.,11.),std=torch.arange(1,0,-0.1))
print(a)
'''
运行结果
tensor([ 1.6596,  2.2340,  2.9046,  3.7704,
  4.8815,  4.8456,  7.2505,  7.9999,
         8.8839, 10.0721])

'''

1.6596,#是从均值为1，标准差为1的正态分布中随机生成的

 2.2340, #是从均值为2，标准差为0.9的正态分布中随机生成的

2.9046,  #是从均值为3，标准差为0.8的正态分布中随机生成的

3.7704,  #后面依次类推

4.8815,  

4.8456,  

7.2505,  

7.9999,

 8.8839,

10.0721 

3.2 Tensor的属性 


>>>a=torch.Tensor([2,2],device=torch.device('cpu'))
>>>a
tensor([2., 2.])

i=torch.Tensor([[0,1,2,3],[0,1,2,3]])
v=torch.Tensor([1,2,3,4])
a=torch.sparse_coo_tensor(i,v,(4,4)).to_dense()
print(a)
'''
result:
tensor([[1., 0., 0., 0.],
        [0., 2., 0., 0.],
        [0., 0., 3., 0.],
        [0., 0., 0., 4.]])
'''

 3.3 Tensor加法运算

a=torch.rand(2,3)
b=torch.rand(2,3)
#tensor加法运算
print('a>>>{}'.format(a))
print('b>>>{}'.format(b))

print('a+b>>>{}'.format(a+b))
print('a.add(b)>>>{}'.format(a.add(b)))
print('torch.add(a,b)>>>{}'.format(torch.add(a,b)))
print('a>>>{}'.format(a))
print('a.add_(b)>>>{}'.format(a.add_(b)))#会改变a的值
print('a>>>{}'.format(a))
'''
result:

a>>>tensor([[0.8988, 0.5446, 0.5518],
        [0.9732, 0.9988, 0.4388]])
b>>>tensor([[0.5444, 0.1172, 0.0646],
        [0.7828, 0.4502, 0.6519]])
a+b>>>tensor([[1.4432, 0.6618, 0.6164],
        [1.7560, 1.4491, 1.0908]])
a.add(b)>>>tensor([[1.4432, 0.6618, 0.6164],
        [1.7560, 1.4491, 1.0908]])
torch.add(a,b)>>>tensor([[1.4432, 0.6618, 0.6164],
        [1.7560, 1.4491, 1.0908]])
a>>>tensor([[0.8988, 0.5446, 0.5518],
        [0.9732, 0.9988, 0.4388]])
a.add_(b)>>>tensor([[1.4432, 0.6618, 0.6164],
        [1.7560, 1.4491, 1.0908]])
a>>>tensor([[1.4432, 0.6618, 0.6164],
        [1.7560, 1.4491, 1.0908]])
'''

 3.4 减法运算

a=torch.rand(2,3)
b=torch.rand(2,3)
#tensor减法运算
print('a>>>{}'.format(a))
print('b>>>{}'.format(b))

print('a-b>>>{}'.format(a-b))
print('a.sub(b)>>>{}'.format(a.sub(b)))
print('torch.sub(a,b)>>>{}'.format(torch.sub(a,b)))
print('a>>>{}'.format(a))
print('a.sub_(b)>>>{}'.format(a.sub_(b)))#会改变a的值
print('a>>>{}'.format(a))
'''
result:

a>>>tensor([[0.5074, 0.2774, 0.2372],
        [0.8903, 0.3377, 0.2094]])
b>>>tensor([[0.8004, 0.8801, 0.0041],
        [0.9146, 0.6384, 0.6574]])
a-b>>>tensor([[-0.2931, -0.6027,  0.2331],
        [-0.0244, -0.3007, -0.4479]])
a.sub(b)>>>tensor([[-0.2931, -0.6027,  0.2331],
        [-0.0244, -0.3007, -0.4479]])
torch.sub(a,b)>>>tensor([[-0.2931, -0.6027,  0.2331],
        [-0.0244, -0.3007, -0.4479]])
a>>>tensor([[0.5074, 0.2774, 0.2372],
        [0.8903, 0.3377, 0.2094]])
a.sub_(b)>>>tensor([[-0.2931, -0.6027,  0.2331],
        [-0.0244, -0.3007, -0.4479]])
a>>>tensor([[-0.2931, -0.6027,  0.2331],
        [-0.0244, -0.3007, -0.4479]])
'''

 3.5 乘法运算

a=torch.rand(2,3)
b=torch.rand(2,3)
#tensor乘法运算
print('a>>>{}'.format(a))
print('b>>>{}'.format(b))

print('a*b>>>{}'.format(a*b))
print('a.mul(b)>>>{}'.format(a.mul(b)))
print('torch.mul(a,b)>>>{}'.format(torch.mul(a,b)))
print('a>>>{}'.format(a))
print('a.mul_(b)>>>{}'.format(a.mul_(b)))#会改变a的值
print('a>>>{}'.format(a))
'''
result:

a>>>tensor([[0.6919, 0.9733, 0.2953],
        [0.7294, 0.7931, 0.7454]])
b>>>tensor([[0.1297, 0.3061, 0.4285],
        [0.4243, 0.4922, 0.2862]])
a*b>>>tensor([[0.0897, 0.2979, 0.1265],
        [0.3094, 0.3904, 0.2133]])
a.mul(b)>>>tensor([[0.0897, 0.2979, 0.1265],
        [0.3094, 0.3904, 0.2133]])
torch.mul(a,b)>>>tensor([[0.0897, 0.2979, 0.1265],
        [0.3094, 0.3904, 0.2133]])
a>>>tensor([[0.6919, 0.9733, 0.2953],
        [0.7294, 0.7931, 0.7454]])
a.mul_(b)>>>tensor([[0.0897, 0.2979, 0.1265],
        [0.3094, 0.3904, 0.2133]])
a>>>tensor([[0.0897, 0.2979, 0.1265],
        [0.3094, 0.3904, 0.2133]])
'''

 3.6 除法运算

a=torch.rand(2,3)
b=torch.rand(2,3)
#tensor除法运算
print('a>>>{}'.format(a))
print('b>>>{}'.format(b))

print('a/b>>>{}'.format(a/b))
print('a.div(b)>>>{}'.format(a.div(b)))
print('torch.div(a,b)>>>{}'.format(torch.div(a,b)))
print('a>>>{}'.format(a))
print('a.div_(b)>>>{}'.format(a.div_(b)))#会改变a的值
print('a>>>{}'.format(a))
'''
result:

a>>>tensor([[0.8337, 0.3239, 0.9985],
        [0.3949, 0.8980, 0.4517]])
b>>>tensor([[0.2034, 0.9102, 0.6831],
        [0.3949, 0.8239, 0.6213]])
a/b>>>tensor([[4.0986, 0.3558, 1.4618],
        [0.9999, 1.0900, 0.7271]])
a.div(b)>>>tensor([[4.0986, 0.3558, 1.4618],
        [0.9999, 1.0900, 0.7271]])
torch.div(a,b)>>>tensor([[4.0986, 0.3558, 1.4618],
        [0.9999, 1.0900, 0.7271]])
a>>>tensor([[0.8337, 0.3239, 0.9985],
        [0.3949, 0.8980, 0.4517]])
a.div_(b)>>>tensor([[4.0986, 0.3558, 1.4618],
        [0.9999, 1.0900, 0.7271]])
a>>>tensor([[4.0986, 0.3558, 1.4618],
        [0.9999, 1.0900, 0.7271]])
'''

3.7 矩阵运算

a=torch.ones(2,2)
b=torch.ones(2,1)
#tensor矩阵运算
print('a>>>{}'.format(a))
print('b>>>{}'.format(b))

print('a@b>>>{}'.format(a@b))
print('a.mm(b)>>>{}'.format(a.mm(b)))
print('torch.mm(a,b)>>>{}'.format(torch.mm(a,b)))
print('torch.matmul(a,b)>>>{}'.format(torch.matmul(a,b)))
print('a.matmul(b)>>>{}'.format(a.matmul(b)))
print('a>>>{}'.format(a))
'''
result:

a>>>tensor([[1., 1.],
        [1., 1.]])
b>>>tensor([[1.],
        [1.]])
a@b>>>tensor([[2.],
        [2.]])
a.mm(b)>>>tensor([[2.],
        [2.]])
torch.mm(a,b)>>>tensor([[2.],
        [2.]])
torch.matmul(a,b)>>>tensor([[2.],
        [2.]])
a.matmul(b)>>>tensor([[2.],
        [2.]])
a>>>tensor([[1., 1.],
        [1., 1.]])
'''

3.8 指数运算

#Tensor指数运算
a=torch.Tensor([1,3])
print(a)
print(torch.pow(a,3))
print(a.pow(3))
print(a**3)
print(a.pow_(3))#此操作会改变a的值
print(a)
'''
result:
tensor([1., 3.])
tensor([ 1., 27.])
tensor([ 1., 27.])
tensor([ 1., 27.])
tensor([ 1., 27.])
tensor([ 1., 27.])
'''

以自然常数e为底的指数运算

#关于自然常数e的运算
a=torch.Tensor([1,2])
print('a>>>{}'.format(a))
print('torch.exp(a)>>>{}'.format(torch.exp(a)))
print('a.exp()>>>{}'.format(a.exp()))
print("a.exp_()>>>{}".format(a.exp_()))#该操作会改变a的值
print('a>>>{}'.format(a))
print("torch.exp_(a)>>>{}".format(torch.exp_(a)))#该操作会改变a的值
print('a>>>{}'.format(a))
'''
result:

a>>>tensor([1., 2.])
torch.exp(a)>>>tensor([2.7183, 7.3891])
a.exp()>>>tensor([2.7183, 7.3891])
a.exp_()>>>tensor([2.7183, 7.3891])
a>>>tensor([2.7183, 7.3891])
torch.exp_(a)>>>tensor([  15.1543, 1618.1781])
a>>>tensor([  15.1543, 1618.1781])
'''

3.9 对数运算

#Tensor对数运算
import math
a=torch.Tensor([math.e,math.e])
print(a)
print(a.log())
print(a.log_())#此操作会改变a的值
print(a)
'''
result:
tensor([2.7183, 2.7183])
tensor([1., 1.])
tensor([1., 1.])
tensor([1., 1.])
'''

import math
a=torch.Tensor([math.e,math.e])
print(a)
print(torch.log(a))
print(torch.log_(a))#此操作会改变a的值
print(a)
'''
result:
tensor([2.7183, 2.7183])
tensor([1., 1.])
tensor([1., 1.])
tensor([1., 1.])
'''

3.10 开方运算

#开平方运算
a=torch.Tensor([9,9])
print('a  >>>  {}'.format(a))
print("a.sqrt()  >>>  {}".format(a.sqrt()))
print("a.sqrt_()  >>>  {}".format(a.sqrt_()))#此操作会改变a的值
print('a  >>>  {}'.format(a))

b=torch.Tensor([16,16])
print('b  >>>  {}'.format(b))
print('torch.sqrt(b)  >>>  {}'.format(torch.sqrt(b)))
print('torch.sqrt_(b)  >>>  {}'.format(torch.sqrt_(b)))#此操作会改变b的值
print('b  >>>  {}'.format(b))
'''
a  >>>  tensor([9., 9.])
a.sqrt()  >>>  tensor([3., 3.])
a.sqrt_()  >>>  tensor([3., 3.])
a  >>>  tensor([3., 3.])
b  >>>  tensor([16., 16.])
torch.sqrt(b)  >>>  tensor([4., 4.])
torch.sqrt_(b)  >>>  tensor([4., 4.])
b  >>>  tensor([4., 4.])
'''

 三、Pytorch中的广播机制

Pytorch中的广播机制 

 广播机制为多个维数不对应的张量之间的运算提供了可能，这是什么意思呢？

比如我们非常熟悉的二维张量，也就是矩阵，你见过这样的矩阵相加吗？

在我们大学的线性代数课堂上，是不允许这样做的。

 但是在张量运算中，是可以的，而且随着学习的深入，后续会经常对维数不对应的张量进行数学运算，包括但不仅限于加减乘除。

下面我们在pytorch中验证一下


a=torch.Tensor([[1,2,2],[3,4,5]])
b=torch.Tensor([[1],[2]])
print(a)
print(a.shape)
print(b)
print(b.shape)
print(a+b)
'''
tensor([[1., 2., 2.],
        [3., 4., 5.]])
torch.Size([2, 3])
tensor([[1.],
        [2.]])
torch.Size([2, 1])
tensor([[2., 3., 3.],
        [5., 6., 7.]])
'''

果然，控制台中输出了结果。

由于pytorch存在的这种广播机制，我们可以对维数不对应的张量进行数学运算，只要这些张量满足以下两个条件：

1.每个张量至少有一个维度

2.满足右对齐

 什么是右对齐呢？

下面列举的都为右对齐的情况

情况一：维数不相等（需要从右往左对齐上下，不足的用1补位）上下每一列要么相等，不相等其中一个必须为1 

我们来验证一下张量a,b是否可以进行相加运算

a=torch.rand(2,3,4)
b=torch.rand(3,4)
print(a)
print(a.shape)
print(b)
print(b.shape)
print(a+b)
'''
result:

tensor([[[1.9170e-01, 7.3553e-01, 1.0409e-01, 7.2048e-01],
         [9.9690e-02, 9.8931e-01, 8.0287e-01, 1.6163e-01],
         [2.6184e-01, 1.2664e-01, 3.5558e-01, 7.1151e-01]],

        [[8.2651e-01, 5.7520e-01, 2.5190e-01, 1.5664e-01],
         [4.8740e-01, 3.5411e-01, 4.1564e-01, 4.2516e-04],
         [7.1702e-01, 2.7139e-01, 6.2484e-01, 7.5701e-02]]])
torch.Size([2, 3, 4])
tensor([[0.1759, 0.3124, 0.8845, 0.3470],
        [0.1657, 0.3607, 0.6585, 0.0744],
        [0.4114, 0.1778, 0.6945, 0.9328]])
torch.Size([3, 4])
tensor([[[0.3676, 1.0479, 0.9886, 1.0675],
         [0.2654, 1.3500, 1.4614, 0.2360],
         [0.6733, 0.3045, 1.0501, 1.6443]],
'''

程序没有报错，而且正确输出了结果，验证通过。由于篇幅有限，张量c,d不再验证 。

情况二：维数相等（上下对齐），上下每一列要么相等，若不相等其中一个必须为1

显然我们先前最先验证的例子符合情况二

四、Pytorch中的基本操作

4.1 Pytorch取整、取余相关函数 

torch.floor(a)
将张量a中的每个元素向下取整
torch.ceil(a)
将张量a中的每个元素向上取整
torch.round(a)
将张量a中的每个元素四舍五入
torch.trunc(a)
取张量a中每个元素的整数部分
torch.frac(a)
取张量a中每个元素的小数部分
a%2
对张量a中的每一个元素对2取余
import torch;
'''
pytorch取整、取余相关函数
'''
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)
tensor([[7.9602, 5.7571],
        [5.3785, 0.7960]])
tensor([[7., 5.],
        [5., 0.]])
tensor([[8., 6.],
        [6., 1.]])
tensor([[8., 6.],
        [5., 1.]])
tensor([[7., 5.],
        [5., 0.]])
tensor([[0.9602, 0.7571],
        [0.3785, 0.7960]])
tensor([[1.9602, 1.7571],
        [1.3785, 0.7960]])

 4.2  pytorch中的三角函数&其他常用函数

 

  这里的函数非常重要，而且有些函数涉及到深度学习的其他知识，比如激活函数sigmoid。后续单独出章节重点讲解这些函数及其附属知识。这里就不一一像上面逐个举一些简单的例子了

4.3 Pytorch比较运算符

c=torch.rand(2,3)
d=torch.rand(2,3)
print(c)
print(d)
print("eq：")
print(torch.eq(c,d))
print("equal：")
print(torch.equal(c,d))
print("ge：")
print(torch.ge(c,d))
print("gt：")
print(torch.gt(c,d))
print("le：")
print(torch.le(c,d))
print("lt：")
print(torch.lt(c,d))
print("ne：")
print(torch.ne(c,d))
tensor([[0.5555, 0.4367, 0.3116],
        [0.5131, 0.1430, 0.9589]])
tensor([[0.3850, 0.0470, 0.5328],
        [0.4451, 0.8729, 0.0430]])
eq：
tensor([[False, False, False],
        [False, False, False]])
equal：
False
ge：
tensor([[ True,  True, False],
        [ True, False,  True]])
gt：
tensor([[ True,  True, False],
        [ True, False,  True]])
le：
tensor([[False, False,  True],
        [False,  True, False]])
lt：
tensor([[False, False,  True],
        [False,  True, False]])
ne：
tensor([[True, True, True],
        [True, True, True]])

4.4 pytorch排序相关函数

f=torch.tensor([1,4,2,6,8])
print(f.shape)
print(torch.sort(f))

#运行结果
'''
torch.Size([5])
torch.return_types.sort(
values=tensor([1, 2, 4, 6, 8]),
indices=tensor([0, 2, 1, 3, 4]))
'''
'''
pytorch排序相关函数
'''
f=torch.tensor([[1,4,2,6,8],
               [1,3,5,7,9]])
print(f.shape)
print(torch.sort(f,dim=0,descending=True))
#对于二维数据：dim=0 按列排序，dim=1 按行排序，默认 dim=1
#运行结果
'''
torch.Size([2, 5])
torch.return_types.sort(
values=tensor([[1, 4, 5, 7, 9],
        [1, 3, 2, 6, 8]]),
indices=tensor([[0, 0, 1, 1, 1],
        [1, 1, 0, 0, 0]]))
'''
print(torch.isfinite(f))#判断是否有界
print(torch.isfinite(f/0))
print(torch.isinf(f/0))#判断是否为无穷
print(torch.isnan(f))#判断是不是为空

相关文章：

  • C#通过dll调用带参数的C++代码
  • 【C++】一文带你吃透string的模拟实现 (万字详解)
  • 融合transformer和对抗学习的多变量时间序列异常检测算法TranAD论文和代码解读...
  • Hdfs梳理
  • 智能小车 - DRV8833电机驱动模块
  • Spring常用注解——@Autowired自动装配的作用和原理
  • 一些运维命令
  • 代码随想录动态规划——背包问题总结篇
  • web安全之信息收集
  • 基于FPGA的双目相机目标深度图像提取实现——详细版
  • 【饭谈】细嗦那些职场中喜欢用领导口气命令别人的同事
  • 10 通用同步异步收发器（USART）
  • AI绘图—对中文拟合度很高，值得一试
  • 【 C++11 】包装器
  • 【动手学深度学习PyTorch版】13 卷积层的填充和步幅
  • Gradle 5.0 正式版发布
  • Java的Interrupt与线程中断
  • PAT A1017 优先队列
  • Python进阶细节
  • RxJS: 简单入门
  • Spring Cloud(3) - 服务治理: Spring Cloud Eureka
  • SSH 免密登录
  • 阿里研究院入选中国企业智库系统影响力榜
  • 阿里云购买磁盘后挂载
  • 官方新出的 Kotlin 扩展库 KTX，到底帮你干了什么？
  • 精彩代码 vue.js
  • 推荐一款sublime text 3 支持JSX和es201x 代码格式化的插件
  • 线性表及其算法（java实现）
  • 小程序、APP Store 需要的 SSL 证书是个什么东西？
  • 原生Ajax
  • 原生JS动态加载JS、CSS文件及代码脚本
  • 在GitHub多个账号上使用不同的SSH的配置方法
  • 自定义函数
  • 我们雇佣了一只大猴子...
  • ​比特币大跌的 2 个原因
  • ​二进制运算符：（与运算）、|（或运算）、~（取反运算）、^（异或运算）、位移运算符​
  • ​决定德拉瓦州地区版图的关键历史事件
  • ​如何防止网络攻击？
  • ​无人机石油管道巡检方案新亮点：灵活准确又高效
  • ###STL(标准模板库)
  • （9）目标检测_SSD的原理
  • (Java数据结构)ArrayList
  • （Matalb回归预测）PSO-BP粒子群算法优化BP神经网络的多维回归预测
  • (zt)基于Facebook和Flash平台的应用架构解析
  • （八）c52学习之旅-中断实验
  • (附源码)springboot金融新闻信息服务系统 毕业设计651450
  • （力扣题库）跳跃游戏II(c++)
  • （论文阅读11/100）Fast R-CNN
  • （论文阅读笔记）Network planning with deep reinforcement learning
  • **PyTorch月学习计划 - 第一周；第6-7天: 自动梯度（Autograd）**
  • .bat文件调用java类的main方法
  • .Net Core webapi RestFul 统一接口数据返回格式
  • .NET Core工程编译事件$(TargetDir)变量为空引发的思考
  • .net 前台table如何加一列下拉框_如何用Word编辑参考文献
  • .net与java建立WebService再互相调用