一、介紹

一元m次多項式迴歸方程：

二元二次多項式迴歸方程：

多元多次的多項式迴歸方程較複雜，加之實際生產生活中一元m次多項式歸回就已經能夠解決了，所以略！

對於一元m次多項式迴歸方程，令：

則該一元m次多項式就轉化為m元線性迴歸方程：

因此，用多元線性函式的迴歸方法就可解決多項式迴歸問題！需要指出的是，在多項式迴歸分析中，檢驗迴歸係數是否顯著，實質上就是判斷自變數x的i次方項對因變數y的影響是否顯著。

對於二元二次多項式迴歸方程，令：

則該二元二次多項式函式就轉化為五元線性迴歸方程：

二、一元m次多項式迴歸的最小二乘解

用矩陣表示他們的關係：

用矩陣符號表示：

此處推導過程忽略（參考線性迴歸最小二乘解的推導過程，基本過程是對每一個引數求偏導，令偏導 = 0，解聯立方程組即可），最小二乘法解：

三、Python環境下利用sklearn庫寫的簡單示例

import numpy as np
from sklearn.linear_model import LinearRegression

from sklearn.preprocessing import PolynomialFeatures
import matplotlib.pyplot as plt
# seed
rng = np.random.RandomState(123)
# construct samples. give a x, generate y with noise
def genY(x):
	a0, a1, a2, a3, e = 0.1, -0.02, 0.03, -0.04, 0.05
	yr = a0 + a1*x + a2*(x**2) + a3*(x**3) + e
	y = yr + 0.03*rng.rand(1)
	return y
# plot
plt.figure()
plt.title('polynomial regression(sklearn)')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)

x_tup = np.linspace(-1, 1, 30)
y = [genY(a) for a in x_tup]
print y
x = x_tup.reshape(-1,1)
y = np.array(y).reshape(-1,1)
plt.plot(x, y, 'k.')

qf = PolynomialFeatures(degree = 3)
qModel = LinearRegression()
qModel.fit(qf.fit_transform(x), y)
print '----'
print qf.get_params()

xp = np.linspace(-1, 2, 100)
yp = qModel.predict(qf.transform(xp.reshape(-1, 1)))

plt.plot(xp, yp, 'r-')
plt.show()
 

四、除了利用最小二乘直接解出引數的值外，也可以用梯度下降法最小化損失函式來訓練出引數的值

#-*- coding:utf-8 -*-
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt

rng = np.random.RandomState(123)

def genY(x):
    a0, a1, a2, a3, e = 0.1, -0.02, 0.03, -0.04, 0.05
    yr = a0 + a1*x + a2*(x**2) + a3*(x**3) + e
    y = yr + 0.03*rng.rand(1)
    return y
    
plt.figure()
plt.title('polynomial regression(tensorflow)')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)

x = np.linspace(-1, 1, 30)
y = [genY(a) for a in x]
x = x.reshape(-1,1)
y = np.array(y).reshape(-1,1)
plt.plot(x, y, 'k.')

X = tf.placeholder('float')
Y = tf.placeholder('float')
W = tf.Variable([0.] * 4)
print W

def Model(x, w):
    terms = []
    for i in range(0, 4):
        term = tf.multiply(w[i], tf.pow(x, i))
        terms.append(term)
    rs = tf.add_n(terms)
    return rs
YModel = Model(X, W)
Cost = tf.reduce_sum(tf.square(Y - YModel))
LearnRate = 0.01
train_op = tf.train.GradientDescentOptimizer(LearnRate).minimize(Cost)

with tf.Session() as sess:
	Init = tf.global_variables_initializer()
	sess.run(Init)
	for i in range(0, 100):
		for (_x, _y) in zip(x, y):
			sess.run(train_op, feed_dict = {X: _x, Y: _y})
	print sess.run(W)

	xp = np.linspace(-1, 2, 100)
	yp = 0
	for i in range(0, 4):
		yp += sess.run(W)[i] * np.power(xp, i)

	plt.plot(xp, yp, 'g-')
	plt.show()