conda install pytorch torchvision -c soumith

import torch 
import numpy as np 
 
np_data = np.arange(6).reshape((2, 3)) 
torch_data = torch.from_numpy(np_data) # 將numpy(array)格式轉換為torch(tensor)格式 
tensor2array = torch_data.numpy()  
print( 
  '\nnumpy array:\n', np_data,  
  '\ntorch tensor:', torch_data,  
  '\ntensor to array:\n', tensor2array,  
) # torch數(shù)據格式在print的時候前后自動添加換行符 
 
# abs 
data = [-1, -2, 2, 2] 
tensor = torch.FloatTensor(data)  
print( 
  '\nabs', 
  '\nnumpy: \n', np.abs(data),     
  '\ntorch: ', torch.abs(tensor)  
) # 1維的數(shù)據，numpy是行向量形式顯示，torch是列向量形式顯示 
 
# sin 
print( 
  '\nsin', 
  '\nnumpy: \n', np.sin(data),    
  '\ntorch: ', torch.sin(tensor)  
) 
 
# mean 
print( 
  '\nmean', 
  '\nnumpy: ', np.mean(data),   
  '\ntorch: ', torch.mean(tensor)  
) 
 
# 矩陣相乘 
data = [[1,2], [3,4]] 
tensor = torch.FloatTensor(data)  
 
print( 
  '\nmatrix multiplication (matmul)', 
  '\nnumpy: \n', np.matmul(data, data),   
  '\ntorch: ', torch.mm(tensor, tensor)  
) 
 
data = np.array(data) 
print( 
  '\nmatrix multiplication (dot)', 
  '\nnumpy: \n', data.dot(data),    
  '\ntorch: ', tensor.dot(tensor)   
) 

import torch 
from torch.autograd import Variable 
 
tensor = torch.FloatTensor([[1,2],[3,4]]) 
variable = Variable(tensor, requires_grad=True) 
# 打印展示Variable類型 
print(tensor) 
print(variable) 
 
t_out = torch.mean(tensor*tensor) # 每個元素的^ 2 
v_out = torch.mean(variable*variable) 
print(t_out) 
print(v_out) 
 
v_out.backward() # Variable的誤差反向傳遞 
 
# 比較Variable的原型和grad屬性、data屬性及相應的numpy形式 
print('variable:\n', variable) 
# v_out = 1/4 * sum(variable*variable) 這是計算圖中的 v_out 計算步驟 
# 針對于 v_out 的梯度就是, d(v_out)/d(variable) = 1/4*2*variable = variable/2 
print('variable.grad:\n', variable.grad) # Variable的梯度 
print('variable.data:\n', variable.data) # Variable的數(shù)據 
print(variable.data.numpy()) #Variable的數(shù)據的numpy形式 

import torch 
import torch.nn.functional as F 
from torch.autograd import Variable 
import matplotlib.pyplot as plt 
 
x = torch.linspace(-5, 5, 200) 
x_variable = Variable(x) #將x放入Variable 
x_np = x_variable.data.numpy() 
 
# 經過4種不同的激勵函數(shù)得到的numpy形式的數(shù)據結果 
y_relu = F.relu(x_variable).data.numpy() 
y_sigmoid = F.sigmoid(x_variable).data.numpy() 
y_tanh = F.tanh(x_variable).data.numpy() 
y_softplus = F.softplus(x_variable).data.numpy() 
 
plt.figure(1, figsize=(8, 6)) 
 
plt.subplot(221) 
plt.plot(x_np, y_relu, c='red', label='relu') 
plt.ylim((-1, 5)) 
plt.legend(loc='best') 
 
plt.subplot(222) 
plt.plot(x_np, y_sigmoid, c='red', label='sigmoid') 
plt.ylim((-0.2, 1.2)) 
plt.legend(loc='best') 
 
plt.subplot(223) 
plt.plot(x_np, y_tanh, c='red', label='tanh') 
plt.ylim((-1.2, 1.2)) 
plt.legend(loc='best') 
 
plt.subplot(224) 
plt.plot(x_np, y_softplus, c='red', label='softplus') 
plt.ylim((-0.2, 6)) 
plt.legend(loc='best') 
 
plt.show() 

import torch 
from torch.autograd import Variable 
import torch.nn.functional as F 
import matplotlib.pyplot as plt 
 
x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1) # 將1維的數(shù)據轉換為2維數(shù)據 
y = x.pow(2) + 0.2 * torch.rand(x.size()) 
 
# 將tensor置入Variable中 
x, y = Variable(x), Variable(y) 
 
#plt.scatter(x.data.numpy(), y.data.numpy()) 
#plt.show() 
 
# 定義一個構建神經網絡的類 
class Net(torch.nn.Module): # 繼承torch.nn.Module類 
  def __init__(self, n_feature, n_hidden, n_output): 
    super(Net, self).__init__() # 獲得Net類的超類（父類）的構造方法 
    # 定義神經網絡的每層結構形式 
    # 各個層的信息都是Net類對象的屬性 
    self.hidden = torch.nn.Linear(n_feature, n_hidden) # 隱藏層線性輸出 
    self.predict = torch.nn.Linear(n_hidden, n_output) # 輸出層線性輸出 
 
  # 將各層的神經元搭建成完整的神經網絡的前向通路 
  def forward(self, x): 
    x = F.relu(self.hidden(x)) # 對隱藏層的輸出進行relu激活 
    x = self.predict(x) 
    return x 
 
# 定義神經網絡 
net = Net(1, 10, 1) 
print(net) # 打印輸出net的結構 
 
# 定義優(yōu)化器和損失函數(shù) 
optimizer = torch.optim.SGD(net.parameters(), lr=0.5) # 傳入網絡參數(shù)和學習率 
loss_function = torch.nn.MSELoss() # 最小均方誤差 
 
# 神經網絡訓練過程 
plt.ion()  # 動態(tài)學習過程展示 
plt.show() 
 
for t in range(300): 
  prediction = net(x) # 把數(shù)據x喂給net，輸出預測值 
  loss = loss_function(prediction, y) # 計算兩者的誤差，要注意兩個參數(shù)的順序 
  optimizer.zero_grad() # 清空上一步的更新參數(shù)值 
  loss.backward() # 誤差反相傳播，計算新的更新參數(shù)值 
  optimizer.step() # 將計算得到的更新值賦給net.parameters() 
 
  # 可視化訓練過程 
  if (t+1) % 10 == 0: 
    plt.cla() 
    plt.scatter(x.data.numpy(), y.data.numpy()) 
    plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5) 
    plt.text(0.5, 0, 'L=%.4f' % loss.data[0], fontdict={'size': 20, 'color': 'red'}) 
    plt.pause(0.1) 

import torch 
from torch.autograd import Variable 
import torch.nn.functional as F 
import matplotlib.pyplot as plt 
 
# 生成數(shù)據 
# 分別生成2組各100個數(shù)據點，增加正態(tài)噪聲，后標記以y0=0 y1=1兩類標簽，最后cat連接到一起 
n_data = torch.ones(100,2) 
# torch.normal(means, std=1.0, out=None) 
x0 = torch.normal(2*n_data, 1) # 以tensor的形式給出輸出tensor各元素的均值，共享標準差 
y0 = torch.zeros(100) 
x1 = torch.normal(-2*n_data, 1) 
y1 = torch.ones(100) 
 
x = torch.cat((x0, x1), 0).type(torch.FloatTensor) # 組裝（連接） 
y = torch.cat((y0, y1), 0).type(torch.LongTensor) 
 
# 置入Variable中 
x, y = Variable(x), Variable(y) 
 
class Net(torch.nn.Module): 
  def __init__(self, n_feature, n_hidden, n_output): 
    super(Net, self).__init__() 
    self.hidden = torch.nn.Linear(n_feature, n_hidden) 
    self.out = torch.nn.Linear(n_hidden, n_output) 
 
  def forward(self, x): 
    x = F.relu(self.hidden(x)) 
    x = self.out(x) 
    return x 
 
net = Net(n_feature=2, n_hidden=10, n_output=2) 
print(net) 
 
optimizer = torch.optim.SGD(net.parameters(), lr=0.012) 
loss_func = torch.nn.CrossEntropyLoss() 
 
plt.ion() 
plt.show() 
 
for t in range(100): 
  out = net(x) 
  loss = loss_func(out, y) # loss是定義為神經網絡的輸出與樣本標簽y的差別，故取softmax前的值 
 
  optimizer.zero_grad() 
  loss.backward() 
  optimizer.step() 
 
  if t % 2 == 0: 
    plt.cla() 
    # 過了一道 softmax 的激勵函數(shù)后的最大概率才是預測值 
    # torch.max既返回某個維度上的最大值，同時返回該最大值的索引值 
    prediction = torch.max(F.softmax(out), 1)[1] # 在第1維度取最大值并返回索引值 
    pred_y = prediction.data.numpy().squeeze() 
    target_y = y.data.numpy() 
    plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=pred_y, s=100, lw=0, cmap='RdYlGn') 
    accuracy = sum(pred_y == target_y)/200 # 預測中有多少和真實值一樣 
    plt.text(1.5, -4, 'Accu=%.2f' % accuracy, fontdict={'size': 20, 'color': 'red'}) 
    plt.pause(0.1) 
 
plt.ioff() 
plt.show()