python深度学习基于pytorch-numpy

# pytorch
# -*- coding: utf-8 -*-
# @Author  : Tangzhao
# @Blog:https://blog.csdn.net/tangzhaotz

import numpy as np
lst1 = [3.14,2.17,0,1,2]
nd1 = np.array(lst1)
print(nd1)
print(type(nd1))
"""
[3.14 2.17 0.   1.   2.  ]

"""

# 嵌套列表可以转换为多维数组
import numpy as np
lst2 = [[3.14,2.17,0,1,2],[1,2,3,4,5]]
nd2 =np.array(lst2)
print(nd2)
print(type(nd2))
"""
[[3.14 2.17 0.   1.   2.  ]
 [1.   2.   3.   4.   5.  ]]

"""

# 利用random模块生成数组
import numpy as np
nd3 = np.random.random([3,3])
print(nd3)
print("nd3的形状为：",nd3.shape)
"""
[[0.76823079 0.7789584  0.59111787]
 [0.9064955  0.30900163 0.19454308]
 [0.26660429 0.08162576 0.96167631]]
nd3的形状为： (3, 3)
"""

# 创建多个形状的数组
import numpy as np
# 生成全是0的3X3的矩阵
nd5 = np.zeros([3,3])
nd6 = np.zeros_like(nd5)
nd7 = np.ones([3,3])
nd8 = np.eye(3)
nd9 = np.diag([1,2,3])
print(nd5)
print(nd6)
print(nd7)
print(nd8)
print(nd9)
"""
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
[[1 0 0]
 [0 2 0]
 [0 0 3]]
"""

# 有时可能需要把生成的数据暂时保存起来
nd10 = np.random.random([5,5])
np.savetxt(X=nd10,fname='./test1.txt')
nd11 = np.loadtxt('./test1.txt')
print(nd11)
"""
[[0.99612494 0.13928369 0.99373526 0.12370069 0.17242791]
 [0.08658071 0.75538212 0.41527065 0.05354558 0.46867983]
 [0.73290936 0.42807958 0.91315695 0.78823702 0.05436011]
 [0.13712035 0.09365917 0.95232622 0.47031316 0.50805161]
 [0.60910375 0.90125205 0.76209384 0.50851346 0.22229199]]
"""

# 利用arange，linspace函数生成数组
print(np.arange(10))
print(np.arange(0,10))
print(np.arange(1,4,0.5))
print(np.arange(9,-1,-1))
"""
[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]
[1.  1.5 2.  2.5 3.  3.5]
[9 8 7 6 5 4 3 2 1 0]
"""

# linespace可以根据输入的指定数据范围以及等份数量，自动生成一个线性等分向量
print(np.linspace(0,1,10))  # 将0到1分成十份：[0.         0.11111111 0.22222222 0.33333333 0.44444444 0.55555556
# 0.66666667 0.77777778 0.88888889 1.        ]

# numpy的算术运算
# 1、对应元素相乘
# A = np.array([[1,2],[-1,4]])
# B = np.array([[2.0],[3,4]])
# print(A * B)
# print(np.multiply(A,B))

# 点积运算
X1 = np.array([[1,2],[3,4]])
X2 = np.array([[5,6,7],[8,9,10]])
X3 = np.dot(X1,X2)
print(X3)
"""
[[21 24 27]
 [47 54 61]]
"""

# 数组变形
# 1、reshape：改变向量的维度（不改变向量本身）
arr = np.arange(10)
print(arr)
print(arr.reshape(2,5))
print(arr.reshape(5,-1))
print(arr.reshape(-1,5))
"""
[[0 1 2 3 4]
 [5 6 7 8 9]]
[[0 1]
 [2 3]
 [4 5]
 [6 7]
 [8 9]]
[[0 1 2 3 4]
 [5 6 7 8 9]]
"""

# resize：改变向量维度（修改向量本身）
arr = np.arange(10)
print(arr)
arr.resize(2,5)
print(arr)
"""
[[0 1 2 3 4]
 [5 6 7 8 9]]
"""

# 向量展平
arr = np.arange(6).reshape(2,-1)
print(arr)
print("按照列优先展平：")
print(arr.ravel('F'))
print("按照行优先展平：")
print(arr.ravel())
"""
[[0 1 2]
 [3 4 5]]
按照列优先展平：
[0 3 1 4 2 5]
按照行优先展平：
[0 1 2 3 4 5]
"""

# flatten:把矩阵转换为向量
a = np.floor(10 * np.random.random((3,4)))
print(a)
print(a.flatten())
"""
[[6. 3. 5. 1.]
 [6. 0. 7. 8.]
 [8. 8. 7. 2.]]
[6. 3. 5. 1. 6. 0. 7. 8. 8. 8. 7. 2.]
"""

# squeeze:降维的函数，把矩阵中含1的维度去掉
arr = np.arange(3).reshape(3,1)
print(arr.shape)
print(arr.squeeze().shape)
arr1 = np.arange(6).reshape(3,1,2,1)
print(arr1.shape)
print(arr1.squeeze().shape)
"""
(3, 1)
(3,)
(3, 1, 2, 1)
(3, 2)
"""

# transpose：对矩阵进行轴对换
arr2 = np.arange(24).reshape(2,3,4)
print(arr2.shape)
print(arr2.transpose(1,2,0).shape)
"""
(2, 3, 4)
(3, 4, 2)
"""

# 合并数组
a = np.array([1,2,3])
b = np.array([3,4,5])
c = np.append(a,b)
print(c)  # [1 2 3 3 4 5]

# 合并多维数组
a = np.arange(4).reshape(2,2)
b = np.arange(4).reshape(2,2)
c = np.append(a,b,axis=0)
print("按行合并的结果：")
print(c)
print("合并后数据维度：",c.shape)
"""
按行合并的结果：
[[0 1]
 [2 3]
 [0 1]
 [2 3]]
合并后数据维度： (4, 2)
"""
d = np.append(a,b,axis=1)
print("按列合并的结果：")
print(d)
print("合并后数据维度：",d.shape)
"""
按列合并的结果：
[[0 1 0 1]
 [2 3 2 3]]
合并后数据维度： (2, 4)
"""

# concatenate:按指定轴连接数组或者矩阵
a = np.array([[1,2],[3,4]])
b = np.array([[5,6]])
c = np.concatenate((a,b),axis=0)
print(c)
d = np.concatenate((a,b.T),axis=1)
print(d)
"""
[[1 2]
 [3 4]
 [5 6]]
[[1 2 5]
 [3 4 6]]
"""

# stack:沿指定轴堆叠数组或者矩阵
a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])
print(np.stack((a,b),axis=0))
"""
[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]
"""

# 批量处理
"""
在深度学习中，数据集都很大，通用需要批处理
步骤：
1、得到数据集
2、随机打乱数据
3、定义批大小
4、批处理数据集
"""
import numpy as np
# 生成10000个形状为2X3的矩阵
data_train = np.random.randn(10000,2,3)
# 这是一个三维矩阵，第一个维度为样本数量，后两个是数据形状
print(data_train.shape)  # (10000, 2, 3)
# 打乱数据
np.random.shuffle(data_train)
# 定义批大小
batch_size = 100
# 进行批处理
for i in range(0,len(data_train),batch_size):
    x_batch_sum = np.sum(data_train[i:i + batch_size])
    print('第{}批次，该批次的数据之和为：{}'.format(i,x_batch_sum))
"""
第0批次，该批次的数据之和为：15.885794407127367
第100批次，该批次的数据之和为：21.756173364972952
第200批次，该批次的数据之和为：-21.25671024974242
第300批次，该批次的数据之和为：-12.228673402509436
第400批次，该批次的数据之和为：-46.9408365988471
第500批次，该批次的数据之和为：3.514014021559019
第600批次，该批次的数据之和为：41.71026200013853
第700批次，该批次的数据之和为：19.385695524462932
第800批次，该批次的数据之和为：17.128881315665804
第900批次，该批次的数据之和为：52.414205756567036
第1000批次，该批次的数据之和为：14.854511310726831
第1100批次，该批次的数据之和为：-7.8821776150081
第1200批次，该批次的数据之和为：-34.88825922110505
第1300批次，该批次的数据之和为：-21.815859641335866
第1400批次，该批次的数据之和为：6.763972077801657
第1500批次，该批次的数据之和为：42.31299734301575
第1600批次，该批次的数据之和为：-40.11380854156269
第1700批次，该批次的数据之和为：8.137138068613941
第1800批次，该批次的数据之和为：-23.20029232984296
第1900批次，该批次的数据之和为：-24.693234365132
第2000批次，该批次的数据之和为：-5.2521308389613335
第2100批次，该批次的数据之和为：-20.510293962151675
第2200批次，该批次的数据之和为：-11.476334287234039
第2300批次，该批次的数据之和为：-33.02362079364692
第2400批次，该批次的数据之和为：-6.214908339146447
第2500批次，该批次的数据之和为：13.65318577638422
第2600批次，该批次的数据之和为：-7.496304791364434
第2700批次，该批次的数据之和为：17.02431235857491
第2800批次，该批次的数据之和为：-12.951588521532543
第2900批次，该批次的数据之和为：40.22010996856407
第3000批次，该批次的数据之和为：-23.669197429590213
第3100批次，该批次的数据之和为：21.141918578368255
第3200批次，该批次的数据之和为：-3.5427416740009585
第3300批次，该批次的数据之和为：-4.353301351547579
第3400批次，该批次的数据之和为：-20.534898780539226
第3500批次，该批次的数据之和为：-28.254025368826532
第3600批次，该批次的数据之和为：33.35490935890849
第3700批次，该批次的数据之和为：-18.55482651324617
第3800批次，该批次的数据之和为：-18.178887485733576
第3900批次，该批次的数据之和为：-8.518869006553382
第4000批次，该批次的数据之和为：-12.844857279864062
第4100批次，该批次的数据之和为：-20.9510749850379
第4200批次，该批次的数据之和为：15.131306093413777
第4300批次，该批次的数据之和为：27.4355551894511
第4400批次，该批次的数据之和为：-32.27551933654089
第4500批次，该批次的数据之和为：9.437352145414202
第4600批次，该批次的数据之和为：24.170288028556758
第4700批次，该批次的数据之和为：14.243015080353365
第4800批次，该批次的数据之和为：5.537425097962817
第4900批次，该批次的数据之和为：-0.1243613429234669
第5000批次，该批次的数据之和为：-0.7738174865546483
第5100批次，该批次的数据之和为：-2.445493693605753
第5200批次，该批次的数据之和为：-28.668556486117055
第5300批次，该批次的数据之和为：34.55329480508863
第5400批次，该批次的数据之和为：11.99502258865583
第5500批次，该批次的数据之和为：-2.42469810335486
第5600批次，该批次的数据之和为：1.1415815005984484
第5700批次，该批次的数据之和为：-12.32556849070471
第5800批次，该批次的数据之和为：45.61316964762077
第5900批次，该批次的数据之和为：30.241728046076933
第6000批次，该批次的数据之和为：-4.462762504073881
第6100批次，该批次的数据之和为：49.02324027202664
第6200批次，该批次的数据之和为：-20.04759603392808
第6300批次，该批次的数据之和为：-19.495645086067725
第6400批次，该批次的数据之和为：-27.781787481682247
第6500批次，该批次的数据之和为：-17.475906165842694
第6600批次，该批次的数据之和为：-9.755865088177211
第6700批次，该批次的数据之和为：-3.599980903026534
第6800批次，该批次的数据之和为：28.866228012535373
第6900批次，该批次的数据之和为：38.9850644050035
第7000批次，该批次的数据之和为：-24.659288608789314
第7100批次，该批次的数据之和为：33.38306291668468
第7200批次，该批次的数据之和为：-28.086106070232525
第7300批次，该批次的数据之和为：-39.7955641339264
第7400批次，该批次的数据之和为：36.29756906988355
第7500批次，该批次的数据之和为：13.697893511339476
第7600批次，该批次的数据之和为：54.541185175392066
第7700批次，该批次的数据之和为：-6.795293485817137
第7800批次，该批次的数据之和为：-1.0738954204799342
第7900批次，该批次的数据之和为：-18.18088637550866
第8000批次，该批次的数据之和为：8.762188756103052
第8100批次，该批次的数据之和为：35.983234001167965
第8200批次，该批次的数据之和为：36.571908610246616
第8300批次，该批次的数据之和为：-1.6863189009419912
第8400批次，该批次的数据之和为：3.2460992045191963
第8500批次，该批次的数据之和为：11.73790036963031
第8600批次，该批次的数据之和为：33.365168233902835
第8700批次，该批次的数据之和为：-38.62382186650311
第8800批次，该批次的数据之和为：-19.427611855355966
第8900批次，该批次的数据之和为：43.0927387132142
第9000批次，该批次的数据之和为：-30.958735047070686
第9100批次，该批次的数据之和为：-37.018960400332546
第9200批次，该批次的数据之和为：-20.14552470154655
第9300批次，该批次的数据之和为：36.255622077708246
第9400批次，该批次的数据之和为：26.080098445625516
第9500批次，该批次的数据之和为：13.992339673766427
第9600批次，该批次的数据之和为：-32.27374371630644
第9700批次，该批次的数据之和为：-28.863056714564955
第9800批次，该批次的数据之和为：29.50671029866174
第9900批次，该批次的数据之和为：17.602018992294305
"""

# 通用函数:常见的数学运算函数：平方，三角
# math与numpy函数的性能比较
import time
import numpy as np
import math
x = [i * 0.001 for x in np.arange(1000000)]
start = time.clock()
for i,t in enumerate(x):
    x[i] = math.sin(t)
print("math.sin:",time.clock()-start)  # math.sin: 0.2068061

x = [i * 0.001 for i in np.arange(1000000)]
x = np.array(x)
start = time.clock()
np.sin(x)
print('numpy.sin:',time.clock()-start)  # numpy.sin: 0.009021600000000074