08_13_数据操作与数据预处理

最新推荐文章于 2024-08-26 18:56:03 发布

m0_57114626

最新推荐文章于 2024-08-26 18:56:03 发布

阅读量355

点赞数 3

文章标签： python pytorch

本文链接：https://blog.csdn.net/m0_57114626/article/details/141336052

版权

Pytorch

一、简介
Pytorch是torch的python版本，是由Facebook开源的神经网络框架，专门针对 GPU 加速的深度神经网络（DNN）编程，相比于Tensorflow，Pytorch简介易用。PyTorch不仅是最受欢迎的深度学习框架之一，而且也是最强大的深度学习框架之一。
Pytorch的优点有：
(1)动态计算图
PyTorch最突出的优点之一就是它使用了动态计算图（Dynamic Computation Graphs，DCGs），与TensorFlow和其他框架使用的静态计算图不同。动态计算图允许你在运行时更改图的行为。这使得PyTorch非常灵活，在处理不确定性或复杂性时具有优势，因此非常适合研究和原型设计。
(2)易用性
PyTorch被设计成易于理解和使用。其API设计的直观性使得学习和使用PyTorch成为一件非常愉快的事情。此外，由于PyTorch与Python的深度集成，它在Python程序员中非常流行。
(3)易于调试
由于PyTorch的动态性和Python性质，调试PyTorch程序变得相当直接。你可以使用Python的标准调试工具，如PDB或PyCharm，直接查看每个操作的结果和中间变量的状态。
二、基本使用
1、张量（tensor）的定义
张量是一种特殊的数据结构，与Numpy中的arrays非常相似，在Pytorch中，我们使用张量对模型的输入和输出以及模型的参数进行编码。最重要的是，数据转化为张量可以方便在GPU上运行，这样运行速度可以大大加快。

import torch
x = torch.arange(12)#创建等差数列，默认起始值为0，差值为1
x

tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

x.numel()
#计算元素张量数

X = x.reshape(3,4)#reshape()函数将原张量转换成3行四列的张量，类似于列表和二维数组

tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])

torch.zeros((2,3,4))#将所有张量值全置为0

tensor([[[0., 0., 0., 0.],
         [0., 0., 0., 0.],
         [0., 0., 0., 0.]],

        [[0., 0., 0., 0.],
         [0., 0., 0., 0.],
         [0., 0., 0., 0.]]])

torch.ones((2,3,4))#所有张量值置为1

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

        [[1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.]]])

torch.tensor([[2,1,4,3],[1,2,3,4],[4,3,2,1]]).shape#得到张量的形状

torch.Size([3, 4])

x = torch.tensor([1,2,4,8])
y = torch.tensor([2,2,2,2])
x + y,x - y,x * y,x / y,x ** y#张量的加减乘除幂运算，结果依旧以张量输出

(tensor([ 3,  4,  6, 10]),
 tensor([-1,  0,  2,  6]),
 tensor([ 2,  4,  8, 16]),
 tensor([0.5000, 1.0000, 2.0000, 4.0000]),
 tensor([ 1,  4, 16, 64]))

torch.exp(x)#对张量的每个值做e指数运算

tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])

X = torch.arange(12,dtype = torch.float32).reshape(3,4)
#生成一个张量，值为0-11的32位浮点数，形状为3*4
Y = torch.tensor([[2.0,1,4,3],[1,2,3,4],[4,3,2,1]])
X,Y

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

torch.cat((X,Y),dim = 0),torch.cat((X,Y),dim = 1)
#torch.cat()函数规则是将两个张量按指定维数拼接在一起，其中dim=0表示对行进行拼接，dim=1表示对列进行拼接

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

X == Y#输出值为bool类型

tensor([[False,  True, False,  True],
        [False, False, False, False],
        [False, False, False, False]])

X.sum()#求和，输出为张量

tensor(66.)

a = torch.arange(3).reshape((3,1))#3行1列
b = torch.arange(2).reshape((1,2))#1行2列
a,b

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

a + b
#  a变为[[0,0],
#       [1,1]
#       [2,2]]
#  b变为[[0, 1]，
#       [0, 1]
#       [0, 1]]
#numpy的广播机制

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

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

X[-1],X[1,2],X[:-1]#通过索引找值，类似数组和列表

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

X[0:2,:] = 12#将第0行和第1行的所有元素的值置为12
X

tensor([[12., 12., 12., 12.],
        [12., 12., 12., 12.],
        [ 8.,  9., 10., 11.]])

before = id(Y)
Y = Y + X
id(Y) == before
#为新结果分配了新内存

False

Z = torch.zeros_like(Y)
print('id(Z):',id(Z))
Z[:] = X + Y
print('id(Z):',id(Z))
#原地操作，并没有改变地址

id(Z): 2891461087616
id(Z): 2891461087616

before = id(X)
X = X + Y
id(X) == before
####
#X = X + Y,无论X是否为可变对象都将创建一个新对象
#X += Y,在X为可变对象（如列表）时不会创建新对象，即原地执行

True

before = id(X)
X += Y
id(X) == before

True

import pandas
import os

os.makedirs(os.path.join('..','data'),exist_ok = True)#OS创建新文件的操作
data_file = os.path.join('..','data','E:/test/house_tiny.csv')
with open(data_file,'w') as f:
    f.write('NumRooms,Alley,Price\n')
    f.write('NA,Pave,127500\n')
    f.write('2,NA,106000\n')
    f.write('4,NA,178100\n')
    f.write('NA,NA,140000\n')

能在指定的目录下找到：
在这里插入图片描述

import pandas as pd

data = pd.read_csv(data_file)#pandas读取csv的操作
data

	NumRooms	Alley	Price
0	NaN	Pave	127500
1	2.0	NaN	106000
2	4.0	NaN	178100
3	NaN	NaN	140000

inputs, outputs = data.iloc[:,0:2],data.iloc[:,2]
#iloc:index location,即指定数据的前两列为输入数据，第三列为输出数据
print(inputs)

   NumRooms Alley
0       NaN  Pave
1       2.0   NaN
2       4.0   NaN
3       NaN   NaN

inputs = inputs.fillna(inputs.mean(numeric_only=True))
#fillna函数填充数据中的缺失值，填充值为平均数
print(inputs)

   NumRooms  Alley_Pave  Alley_nan
0       3.0        True      False
1       2.0       False       True
2       4.0       False       True
3       3.0       False       True

inputs = pd.get_dummies(inputs, dummy_na = True)
inputs = inputs.astype(int)#bool转int,True转0,False转1
inputs

	NumRooms	Alley_Pave	Alley_nan
0	3	1	0
1	2	0	1
2	4	0	1
3	3	0	1

import torch
x, y = torch.tensor(inputs.values),torch.tensor(outputs.values)
#取值
x, y

(tensor([[3, 1, 0],
         [2, 0, 1],
         [4, 0, 1],
         [3, 0, 1]], dtype=torch.int32),
 tensor([127500, 106000, 178100, 140000]))

import sys
sys.executable
#获取当前Python解释器的完整路径，用于确定当前在哪个环境下运行代码。

'D:\\Anaconda juypter\\envs\\test\\python.exe'

m0_57114626

关注

3
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
08_13_数据操作与数据预处理

PyTorch最突出的优点之一就是它使用了动态计算图（Dynamic Computation Graphs，DCGs），与TensorFlow和其他框架使用的静态计算图不同。Pytorch是torch的python版本，是由Facebook开源的神经网络框架，专门针对 GPU 加速的深度神经网络（DNN）编程，相比于Tensorflow，Pytorch简介易用。是一种特殊的数据结构，与Numpy中的arrays非常相似，在Pytorch中，我们使用张量对模型的输入和输出以及模型的参数进行编码。
复制链接

扫一扫