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.  ]
<class 'numpy.ndarray'>
"""

# 嵌套清單可以轉換為多元數組
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.  ]]
<class 'numpy.ndarray'>
"""

# 利用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