一：pytorch基礎

1：張量：Tensor
定義為：多維度的矩陣。
例如：

0維度：點；    一維：向量；    二維：普通矩陣

有torch.FloatTensor ;  torch.DoubleTensor; torch.IntTrnsor;

2:變數：Variable

3：模組 torch.nn.Module

import torch as t
from torch import nn

class net_name(nn.Module):#模型
	def __int__(self,other_arguments):
		super(net_name,
 
self).__int__()
		self.conv1=nn.Conv2d(in_channels,out_channels,kernel_size)#訓練器

	def forward(self,x):
		x=self.conv1(x)
		return x
#loss function
criterion=nn.CrossEntropyLoss()
loss=criterion(output,target)

二：多形式迴歸

1）理論簡介

對於一般的線性迴歸模型，由於該函式擬合出來的是一條直線，所以精度欠佳，我們可以考慮多項式迴歸來擬 合更多的模型。所謂多項式迴歸，其本質也是線性迴歸。也就是說，我們採取的方法是，提高每個屬性的次數來增加維度數。比如，請看下面這樣的例子：

如果我們想要擬合方程：

對於輸入變數和輸出值，我們只需要增加其平方項、三次方項係數即可。所以，我們可以設定如下引數方程：

可以看到，上述方程與線性迴歸方程並沒有本質區別。所以我們可以採用線性迴歸的方式來進行多項式的擬合。下面請看程式碼部分。

2）程式碼實現

import torch as t
from torch import nn
import matplotlib.pyplot as plt
import numpy 
from torch.autograd import Variable

def make_features(x):
	
	x=x.unsqueeze(
 
1)# n -> nx1 
	
	return t.cat([x ** i for i in range(1,4)],1) #nx1-->nx3
	#columns --> x,x^2,x^3
	



	#true fx
def f(x):

	return x.mm(W_target)+b_target[0] # nx1 


#建立（x,f(X)) pairs
def get_batch(batch_size=32):
	random=t.randn(batch_size)
	# 32個 == 1x32
	random=t.from_numpy(numpy.sort(random))
	x=make_features(random) #x-->nx3

	y=f(x) #nx1

	return Variable(x),Variable(y)

#Define model
class multi_linear_model(nn.Module):
	def __init__(self):
		super(multi_linear_model,self).__init__()
		self.poly=nn.Linear(3,1) #x 三維 y一維
	
	def forward(self,x):
		out=self.poly(x)
		return out #nx1 prediction y


if __name__ == '__main__':
	# true parameter
	W_target=t.FloatTensor([0.5,3,2.4]).unsqueeze(1)# 3->3x1
	b_target=t.FloatTensor([0.9])
	

	model =multi_linear_model()

	# 定義loss function --> mean square error
	criterion=nn.MSELoss()

	#優化器->隨機梯度下降 learning rate 0.001
	optimizer=t.optim.SGD(model.parameters(),lr=1e-3)

	epoch=0 # 記錄從開始到達模型最優化的訓練次數
	
	while True:
		# Get true data
		batch_x,batch_y=get_batch()
		#out -> predict y
		output=model.forward(batch_x)

		#require loss
		loss=criterion(output,batch_y)

		print_loss=loss.item()


		#清0 梯度 
		optimizer.zero_grad()
	
		#反向傳播->計算此時的x的梯度
		loss.backward()


		#梯度下降
		optimizer.step()
		epoch+=1

		#達到最優
		if print_loss<1e-3:#0.001
			break;
	predict = model(batch_x)
	x = batch_x.numpy()[:, 0]
	plt.plot(x, batch_y.numpy(), 'rx')

	predict = predict.data.numpy()
	plt.plot(x, predict, 'b')
	plt.show()





	
	

結果發現擬合的很好，損失小於0.001.