======================================================================

另外一篇基於《機器學習實戰》的Logistic迴歸分析的部落格請參考：點選閱讀，其主要是採用Python程式碼實現迴歸模型

目錄：

1、概念

2、簡單線性迴歸（Simple Liner Regession）

3、多元性迴歸（Mutiple Regession）

4、非線性迴歸（Logistic Regession）

一：概念            

2：離散程度的衡量

3：迴歸中的相關度

4：R平方值

5：皮爾遜相關係數和R平方值計算示例

#coding:utf-8
'''
Created on 2015年11月8日

@author: Administrator
'''
import numpy as np
import math

#求解皮爾遜相關係數
def computeCorrelation(X, Y):
    xBar = np.mean(X)
    yBar = np.mean(Y)
    SSR = 0
    varX = 0
    varY = 0
    for i in range(0, len(X)):
        #對應分子部分
        diffXXBar = X[i] - xBar
        diffYYBar = Y[i] - yBar
        SSR +=(diffXXBar * diffYYBar)
        #對應分母求和部分
        varX += diffXXBar**2
        varY += diffYYBar**2
    SST = math.sqrt(varX * varY)
    return SSR/SST

def polyfit(x, y, degree):
    results = {}
    #coeffs 為相關係數，x自變數，y因變數，degree為最高冪
    coeffs = np.polyfit(x, y, degree)
    
    #定義一個字典存放值，值為相關係數list
    results['polynomial'] = coeffs.tolist()
    
    #p相當於直線方程
    p = np.poly1d(coeffs)  
    yhat = p(x)  #傳入x，計算預測值為yhat
    
    ybar = np.sum(y)/len(y)  #計算均值    
    #對應公式
    ssreg = np.sum((yhat - ybar) ** 2)
    sstot = np.sum((y - ybar) ** 2)
    results['determination'] = ssreg / sstot

    print" results :",results
    return results



testX = [1, 3, 8, 7, 9]
testY = [10, 12, 24, 21, 34]

#輸出的是簡單線性迴歸的皮爾遜相關度和R平方值
print "r : ",computeCorrelation(testX, testY)
print "r^2 : ",str(computeCorrelation(testX, testY)**2)

#
print polyfit(testX, testY, 1)["determination"]

二：簡單線性迴歸

1：迴歸與分類的區別

2：簡單線性迴歸介紹

                       

       簡單線性迴歸方程：模型轉變為即為迴歸方程（類似於一條直線，引數為斜率和y軸的交點）

                       

3：簡單線性迴歸示例

<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;">#coding:utf8
'''
Created on 2016年4月24日

@author: Gamer Think
'''
#Simple Regession
import numpy as np

#周廣告播放數量
x = [1,3,2,1,3]
#周汽車銷售資料
y = [14,24,18,17,27]

#使用最小二乘法
def fitSLR(x,y):
    n = len(x)
    denominator  = 0
    numerator = 0
    for i in range(0,n):
        numerator += (x[i]-np.mean(x)* (y[i]-np.mean(y)) )
        denominator += (x[i]-np.mean(x))**2
    
    print "denominator:",denominator
    print "numerator:",numerator
    
    b1 = numerator/float(denominator)
#     b0 = np.mean(y)/float(np.mean(x)) 
    b0 = np.mean(y)-b1*np.mean(x)
    
    return b0,b1

def predict(b0,b1,x):
    return b0+b1*x

b0,b1 = fitSLR(x,y)

x_test = 6
print "y_test：",predict(b0,b1,x_test)</span></span>

三：多元性迴歸

                                                               

<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;">#coding:utf-8
'''
Created on 2016年4月24日

@author: Gamer Think
'''
from sklearn import linear_model
import numpy as np
from numpy import genfromtxt #可以將非array格式的list轉化為array

datapath = "data.csv"
deliverData = genfromtxt(datapath,delimiter=",") #將csv檔案轉化為numpy.array格式

print "data:",deliverData

X= deliverData[:,:-1]
Y = deliverData[:,-1]
print "X:",X
print "Y:",Y

regr = linear_model.LinearRegression()
regr.fit(X,Y)

print "coefficients:",regr.coef_        #與X結合的值
print "intercept:",regr.intercept_         #類似於截距

x_pre = [102,6]
y_pre = regr.predict(x_pre)
print "Y-Predict:",y_pre
</span></span>

              

             

<span style="font-family:Microsoft YaHei;"><span style="font-family:Microsoft YaHei;font-size:18px;">#coding:utf-8
'''
Created on 2016年4月24日

@author: Gamer Think
'''
from numpy import genfromtxt
import numpy as np
from sklearn import datasets, linear_model

dataPath = "dataDumpy.csv"
deleveryData = genfromtxt(dataPath, delimiter=',')

print "data:\n",deleveryData

X = deleveryData[:, :-1]
Y = deleveryData[:, -1]
print "X: ",X
print "Y: ",Y
 
regr = linear_model.LinearRegression()
regr.fit(X, Y)
 
print "Coefficients:",regr.coef_  #與X結合的值
print "Intercept:",regr.intercept_ #類似於截距
# 
xPred = [102,6,0,0,1]
yPred = regr.predict(xPred)
print "predict y : ",yPred</span></span>

 4：關於誤差

四：非線性迴歸

    非線性迴歸又稱為邏輯迴歸

   

非線性迴歸例項：

<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;">#coding:utf-8
'''
Created on 2016年4月24日

@author: Gamer Think
'''
import numpy as np
import random

'''
梯度下降演算法
引數說明：X，Y
theta:一組向量和x相乘的一組值
alpha:梯度下降時的引數，即每一步下降多少
m:例項的個數
numIteration：迭代計算的次數，可以理解為梯度下降多少步
'''
def gradientDescent(X,Y,theta,alpha,m,numIteration):
    x_trains = X.transpose()  #X的轉置矩陣
    for i in range(0,numIteration):    
        hypothesis = np.dot(X,theta)      #內積形式，X與theta的乘積  ，求出y的估計值
        loss = hypothesis - Y             #估計值與真實值之間的差
        
        #通用的梯度下降演算法，和logistic Regession中所描述的cost函式不一致
        cos = np.sum(loss**2)/(2*m)
        print "Iteration %d | Cost:%f" % (i,cos)
        
        gradient = np.dot(x_trains,loss)/m
        theta = theta - alpha*gradient
        
    return theta


'''
numPoints : 點的個數
bias :偏好ֵ
variance : 統計學概念， 偏差和
產生樣本點和對應的標籤 
'''
def genData(numPoints,bias,variance):
    X = np.zeros(shape=(numPoints,2))     #歸類的資料
    Y = np.zeros(shape=numPoints)         #歸類的標籤
    
    for i in range(0,numPoints):   #從0~len(numPoints)-1執行如下
        X[i][0] = 1
        X[i][1] = i
        #製造target資料
        Y[i] = (i+bias) + random.uniform(0,1)*variance
        
    return X,Y

X,Y = genData(100, 25, 10)
# print  "X:",X
# print  "Y:",Y

m, n = np.shape(X)
n_y = np.shape(Y)

# print "x shape :", m, "  ", n
# print "y length :",n_y

numIterations =100000
alpha = 0.0005
theta = np.ones(n)
theta = gradientDescent(X, Y, theta, alpha, m, numIterations)

print "theta: " ,theta

</span></span>