数据探索
** 數據質量分析 **
是數據預處理的前提，是數據挖掘分析結論有效性和準確性的基礎，其主要任務 ** 是檢查原始數據中是否存在臟數據， ** 臟數據包括：
缺失值
異常值
不一致的值
重復數據及含有特殊符號（如 # 、￥、 * ）的數據
本小節將主要對數據中的缺失值、異常值和一致性進行分析。
** 缺失值統計分析 **
統計 ** 缺失值的變量個數 **
統計每個變量 ** 的未缺失數 **
統計變量的 ** 缺失數及缺失率 **
** 異常值統計分析 - 箱型圖代碼 **
異常值分析是檢驗數據是否有錄入 ** 錯誤以及含有不合常理的數據 ** 。
異常值是指樣本中的個別值，其數值明顯偏離其余的觀測值。異常值也稱為離群點，異常值的分析也稱為離群點的分析。
異常值分析方法主要有：簡單統計量分析、 3 原則、箱型圖分析。 ****
_
_ ** import ** pandas ** as ** pd
data = pd.read_excel( ** ‘…/data/catering_sale.xls’ ** , index_col = **
u’日期’ ** ) _ #讀取數據，指定“日期”列為索引列
_ ** import ** matplotlib.pyplot ** as ** plt _ #導入圖像庫
_ plt.rcParams[ ** ‘font.sans-serif’ ** ] = [ ** ‘SimHei’ ** ] _
#用來正常顯示中文標簽
_ plt.rcParams[ ** ‘axes.unicode_minus’ ** ] = ** False ** _ #用來正常顯示負號
_ plt.figure() _ #建立圖像
_ p = data.boxplot( return_type = ** ‘dict’ ** ) _
#p[‘fliers’][0].get不會報錯
#p = data.boxplot() #畫箱線圖，直接使用pd的DataFrame的方法
_ x = p[ ** ‘fliers’ ** ][ 0 ].get_xdata() _ # 'flies’即為異常值的標簽
_ y = p[ ** ‘fliers’ ** ][ 0 ]. get_ydata ()
y.sort() _ #從小到大排序，該方法直接改變原對象
#用annotate添加注釋
#其中有些相近的點，注解會出現重疊，難以看清，需要一些技巧來控制。
#以下參數都是經過調試的，需要具體問題具體調試。
_ ** for ** i ** in ** range ( len (x)):
** if ** i> 0 :
plt.annotate(y[i], xy = (x[i],y[i]), xytext =(x[i]+ 0.05 - 0.8
/(y[i]-y[i- 1 ]),y[i]))
** else ** :
plt.annotate(y[i], xy = (x[i],y[i]), xytext =(x[i]+ 0.08 ,y[i]))
plt.show() _ #展示箱線圖 _
_ _
** 一致性分析 **
數據不一致性是指數據的矛盾性、不相容性。直接對不一致的數據進行挖掘，可能會產生與實際相違背的挖掘結果。
在數據挖掘過程中，不一致數據的產生主要發生在數據集成的過程中，可能是由于被挖掘數據是來自于從不同的數據源、重復存放的數據未能進行一致性地更新造成的，比如兩張表中都存儲了用戶的地址，在用戶的地址發生改變時，如果只更新了一張表中的數據，那么這兩張表中就有了不一致的數據。
** 數據特征分析 **
一般可通過繪制圖表、計算某些特征量等手段進行數據的特征分析。
這里主要介紹的特征方法有：
** 分布分析 - 統計函數 describe **
分布分析能揭示數據的分布特征和分布類型，便于發現某些特大或特小的可疑值。
對于定性分類數據，可用餅圖和條形圖直觀地顯示分布情況。
對于定量變量而言，欲了解其分布形式，是對稱的、還是非對稱的，可做出頻率分布表、繪制頻率分布直方圖、繪制莖葉圖進行直觀地分析；
定量變量做頻率分布分析時選擇 “組數”和“組寬”是主要的問題，一般按照以下步驟：
求極差 2 決定組距與組數 3 決定分點 4 列出頻率分布表 5 繪制頻率分布直方圖
1 各組之間必須是相互排斥的
2 各組必須將所有的數據包含在內
3 各組的組寬最好相等 _
_ catering_sale = ** ‘…/data/catering_sale.xls’ ** _ #餐飲數據
_ data = pd.read_excel(catering_sale, index_col = ** u’日期’ ** ) _
#讀取數據，指定“日期”列為索引列
_ data = data[(data[ ** u’銷量’ ** ] > 400 )&(data[ ** u’銷量’ ** ] < 5000
)] _ #過濾異常數據
_ statistics = data.describe() _ #保存基本統計量
_ statistics.loc[ ** ‘range’ ** ] = statistics.loc[ ** ‘max’ **
]-statistics.loc[ ** ‘min’ ** ] _ #極差
_ statistics.loc[ ** ‘var’ ** ] = statistics.loc[ ** ‘std’ **
]/statistics.loc[ ** ‘mean’ ** ] _ #變異系數
_ statistics.loc[ ** ‘dis’ ** ] = statistics.loc[ ** ‘75%’ **
]-statistics.loc[ ** ‘25%’ ** ] _ #四分位數間距
_ print (statistics)
** 對比分析 **
對比分析是指把兩個相互聯系的指標數據進行比較，從數量上展示和說明研究對象規模的大小，水平的高低，速度的快慢，以及各種關系是否協調。特別適用于指標間的橫縱向比較、時間序列的比較分析。在對比分析中，選擇合適的對比標準是十分關鍵的步驟，選擇得合適，才能做出客觀的評價，選擇不合適，評價可能得出錯誤的結論。
** 對比分析主要有以下兩種形式： **
第一種 : 絕對數比較
第二種 : 相對數比較
結構相對數 4) 強度相對數
比例相對數 5) 計劃完成程度相對數
比較相對數 6) 動態相對數
** 統計量分析 **
用統計指標對定量數據進行統計描述，常從集中趨勢和離中趨勢兩個方面進行分析。
平均水平的指標是對個體集中趨勢的度量，使用最廣泛的是均值和中位數；反映變異程度的指標則是對個體離開平均水平的度量，使用較廣泛的是標準差（方差）、四分位間距。
集中趨勢度量主要有：均值、中位數、眾數
離中趨勢度量主要有：極差、標準差、變異系數
** 周期性分析 **
周期性分析是探索某個變量是否隨著時間變化而呈現出某種周期變化趨勢。周期性趨勢相對較長的有年度周期性趨勢、季節性周期趨勢，相對較短的一般有月度周期性趨勢、周度周期性趨勢，甚至更短的天、小時周期性趨勢。
如在做某用電單位用電量趨勢預測過程中，可以先分析該用電單位日用電量的時序圖，來直觀地估計其用電量變化趨勢。
** 貢獻度分析 - 帕累托分析 **
貢獻度分析又稱帕累托分析，帕累托法則又稱 20/80 定律。同樣的投入放在不同的地方會產生不同的效益。比如對一個公司來講， 80% 的利潤常常來自于
20% 最暢銷的產品；而其他 80% 的產品只產生了 20% 的利潤。貢獻度分析要求我們抓住問題的重點，找到那最有效的 20%
的熱銷產品、渠道或者銷售人員，在最有效的 20% 上投入更多資源，盡量減少浪費在 80% 低效的地方。
** 菜品盈利數據 帕累托圖 **
_
#初始化參數
_ dish_profit = ** ‘…/data/catering_dish_profit.xls’ ** _ #餐飲菜品盈利數據
_ data = pd.read_excel(dish_profit, index_col = ** u’菜品名’ ** )
data = data[ ** u’盈利’ ** ].copy() _
_ plt.figure()
data.plot( kind = ** ‘bar’ ** )
plt.ylabel( ** u’盈利（元）’ ** )
p = 1.0 data.cumsum()/data.sum()
p.plot( color = ** ‘r’ ** , secondary_y = ** True ** , style = **
‘-o’ ** , linewidth = 2 ) _ #secondary_y數軸說明在右邊
_ plt.annotate( format (p[ 6 ], ** ‘.4%’ ** ), xy = ( 6 , p[ 6 ]),
xytext =( 6 * 0.9 , p[ 6 ] 0.9 ), arrowprops = dict (
arrowstyle = ** “->” ** , connectionstyle = ** “arc3,rad=.2” ** )) _
#添加注釋，即85%處的標記。這里包括了指定箭頭樣式。
_ plt.ylabel( ** u’盈利（比例）’ ** )
plt.show()
_ #小知識cumsum
_ a = np.array([[ 1 , 2 , 3 ], [ 4 , 5 , 6 ]])
np.cumsum(a, axis = 0 ) _ # sum over rows for each of the 3 columns
_ np.cumsum(a, axis = 1 ) _ # sum over rows for each of the 3 行 _
_ 就餐飲企業來講，可以重點改善盈利最高的 80%的菜品，或者重點發展綜合影響最高的80%的部門。這種結果可以通過帕累托分析直觀的呈現出來，如下圖： _
** 相關性分析代碼 corr **
分析連續變量之間線性的相關程度的強弱，并用適當的統計指標表示出來的過程稱為相關分析。
相關性分析方法主要有：
直接繪制散點圖 2 繪制散點圖矩陣 3 計算相關系數（比較常用的如 Pearson 相關系數、 Spearman 秩相關系數和判定系數。）
_
_ catering_sale = ** ‘…/data/catering_sale_all.xls’ ** _ #餐飲數據，含有其他屬性
_ data = pd.read_excel(catering_sale, index_col = ** u’日期’ ** ) _
#讀取數據，指定“日期”列為索引列
_ data .corr() _ #相關系數矩陣，即給出了任意兩款菜式之間的相關系數
_ data .corr()[ ** u’百合醬蒸鳳爪’ ** ] _ #只顯示“百合醬蒸鳳爪”與其他菜式的相關系數
_ data [ ** u’百合醬蒸鳳爪’ ** ].corr( data [ ** u’翡翠蒸香茜餃’ ** ]) _
#計算“鳳爪”與“翡翠蒸香茜餃”的相關系數 _
** 統計特征函數 **
Mean （） Geomean （）幾何平均數， Var ， std ， corr ， cov 。 Moment 中心距
第4章- ** 數據預處理 **
一、 ** 數據清洗 **
數據清洗主要是刪除原始數據集中的無關數據、重復數據，平滑噪聲數據，處理缺失值、異常值等。
**1 刪除無關重復值 **
**2 平滑噪聲 **
**3 異常值處理 **
(1) 刪除有異常值的記錄 (2) 視為缺失值 (3) 平均值修正 (4) 不處理
要分析異常值的原因，再決定取舍。
**4 缺失值處理 **
方法可分為三類：刪除記錄、數據插補和不處理。
常用的數據插補方法：均值 / 中位數 / 眾數，固定值，最近鄰插補，回歸方法，插值
插值方法：有 Hermite 插值、分段插值、樣條插值法，而最主要的有拉格朗日插值法和牛頓插值法。
** 拉格朗日插值法 代碼 ployinterp_column **
拉格朗日插值法可以找到一個 [ _ 多項式 _
](https://baike.baidu.com/item/%E5%A4%9A%E9%A1%B9%E5%BC%8F)
，其恰好在各個觀測的點取到觀測到的值。這樣的多項式稱為 ** 拉格朗日（插值）多項式 ** _
_ ** from ** scipy.interpolate ** import ** lagrange _ #導入拉格朗日插值函數
_ inputfile = ** ‘…/data/catering_sale.xls’ ** _ #銷量數據路徑
_ outputfile = ** ‘…/tmp/sales.xls’ ** _ #輸出數據路徑
_ data = pd.read_excel(inputfile) _ #讀入數據
_ data[ ** u’銷量’ ** ][(data[ ** u’銷量’ ** ] < 400 ) | (data[ ** u’銷量’ **
] > 5000 )] = ** None ** _ #過濾異常值，將其變為空值
#自定義列向量插值函數
#s為列向量，n為被插值的位置，k為取前后的數據個數，默認為5
_ ** def ** ployinterp_column(s, n, k= 5 ):
y = s[ list ( range (n-k, n)) + list ( range (n+ 1 , n+ 1 +k))] _
#取數
_ y = y[y.notnull()] _ #剔除空值
_ ** return ** lagrange(y.index, list (y))(n) _ #插值并返回插值結果
#逐個元素判斷是否需要插值
_ ** for ** i ** in ** data.columns:
** for ** j ** in ** range ( len (data)):
** if ** (data[i].isnull())[j]: _ #如果為空即插值。
_ data[i][j] = ployinterp_column(data[i], j)
data.to_excel(outputfile) _ #輸出結果，寫入文件 _
二、 ** 數據集成 ： 實體識別，冗余屬性識別 **
將多個數據源放在一個統一的數據倉庫中。
要考慮實體識別問題和屬性冗余問題，從而把源數據在最低層上加以轉換、提煉和集成。
**
實體識別的任務是檢測和解決同名異義、異名同義、單位不統一的沖突。如：
** 同名異義： ** 數據源 A 中的屬性 ID 和數據源 B 中的屬性 ID 分別描述的是菜品編號和訂單編號，即描述的是不同的實體。
** 異名同義： ** 數據源 A 中的 sales_dt 和數據源 B 中的 sales_date 都是是描述銷售日期的，即 A.
sales_dt= B. sales_date 。
** 單位不統一 ** ：描述同一個實體分別用的是國際單位和中國傳統的計量單位。
**
數據集成往往導致數據冗余，如： ** 同一屬性多次出現 \ 同一屬性命名不一致導致重復 **
不同源數據的 ** 仔細整合能減少甚至避免數據冗余與不一致 ** ，以提高數據挖掘的速度和質量。對于冗余屬性要先分析檢測到后再將其刪除。
有些冗余屬性可以用相關分析檢測到。給定兩個數值型的屬性 A 和 B ，根據其屬性值，可以用相關系數度量一個屬性在多大程度上蘊含另一個屬性。
一、 ** 數據變換 ：簡單函數變換 ， 規范化，離散化 **
主要是對數據進行規范化的操作，將數據轉換成 “適當的”格式，以適用于挖掘任務及算法的需要。
**1. 簡單函數變換 **
簡單函數變換就是對原始數據進行某些數學函數變換，常用的函數變換包括平方、開方、對數、差分運算等
用來將不具有正太分布的數據變換成具有正太性的數據。
時間序列分析中，對數變換或者差分運算可以將非平穩序列轉換為平穩序列
**
數據標準化（歸一化）處理是數據挖掘的一項基礎工作，不同評價指標往往具有不同的量綱和量綱單位，數值間的差別可能很大
消除指標間量綱影響
** 最小 - 最大規范化： ** 也稱為離差標準化是對原始數據的線性變換，使結果值映射到 [0,1] 之間
** 零 - 均值規范化 : ** 也叫標準差標準化，經過處理的數據的平均數為 0 標準差為 1
** 小數定標規范化 : ** 通過移動屬性值的小數位數，將屬性值映射到 [-1 ， 1] 之間，移動的小數位數取決于屬性值絕對值的最大值。
datafile = ** ‘…/data/normalization_data.xls’ ** _ #參數初始化
_ data = pd.read_excel( datafile , header = ** None ** ) _ #讀取數據
_ (data - data.min())/(data.max() - data.min()) _ #最小-最大規范化
_ (data - data.mean())/data.std() _ #零-均值規范化 ， _ data.mean( axis = 0 )
按照列
_
_ data/ 10 **np.ceil(np.log10(data.abs().max())) _ #小數定標規范化 _
_ _
1. ** 連續屬性離散化 **
一些數據挖掘算法，特別是某些分類算法，要求數據是分類屬性形式，如 ID3 算法、 Apriori 算法等。這樣，常常需要將連續屬性變換成 **
分類屬性， ** 即連續屬性離散化。
離散化性涉及 ** 兩個子任務 ** ： 1 需要多少個分類變量 2 確定如何將連續屬性值映射到這些分類值。
常用的離散化方法
(1)等寬法
(2)等頻法
(3)基于聚類分析的方法
_ #數據規范化：離散化cut,KMeans
_ datafile = ** ‘…/data/discretization_data.xls’ ** _ #參數初始化
_ data = pd.read_excel(datafile) _ #讀取數據
_ data = data[ ** u’肝氣郁結證型系數’ ** ].copy()
k = 4
_ # 等寬離散化，各個類比依次命名為0,1,2,3
_ d1 = pd.cut(data, k, labels = range (k))
_ #等頻率離散化
_ w = [ 1.0 i/k ** for ** i ** in ** range (k+ 1 )]
w = data.describe( percentiles = w)[ 4 : 4 +k+ 1 ] _
#使用describe函數自動計算分位數
_ w[ 0 ] = w[ 0 ]( 1 - 1e-10 )
d2 = pd.cut(data, w, labels = range (k))
_ #聚類分類
_ ** from ** sklearn.cluster ** import ** KMeans _ #引入KMeans
_ kmodel = KMeans( n_clusters = k, n_jobs = 4 ) _
#建立模型，n_jobs是并行數，一般等于CPU數較好
_ kmodel.fit(data.reshape(( len (data), 1 ))) _ #訓練模型
_ c = pd.DataFrame(kmodel.cluster_centers_).sort_values( by =[ 0 ]) _
#.sort()#輸出聚類中心，并且排序（默認是隨機序的）
_ w = pd.rolling_mean(c, 2 ).iloc[ 1 :] _ #相鄰兩項求中點，作為邊界點
_ w = [ 0 ] + list (w[ 0 ]) + [data.max()] _ #把首末邊界點加上
_ d3 = pd.cut(data, w, labels = range (k))
** def ** cluster_plot(d, k): _ #自定義作圖函數來顯示聚類結果
_ ** import ** matplotlib.pyplot ** as ** plt
plt.rcParams[ ** ‘font.sans-serif’ ** ] = [ ** ‘SimHei’ ** ] _
#用來正常顯示中文標簽
_ plt.rcParams[ ** ‘axes.unicode_minus’ ** ] = ** False ** _ #用來正常顯示負號
_ plt.figure( figsize = ( 8 , 3 ))
** for ** j ** in ** range ( 0 , k):
plt.plot(data[dj], [j ** for ** i ** in ** d[dj]], ** ‘o’ ** )
plt.ylim(- 0.5 , k- 0.5 )
** return ** plt
cluster_plot(d1, k).show()
cluster_plot(d2, k).show()
cluster_plot(d3, k).show()
4. ** 屬性構造 - 構造新的屬性 **
_ #新屬性構造-輸出到excel
_ i nputfile= ** ‘…/data/electricity_data.xls’ ** _ #供入供出電量數據
_ outputfile = ** ‘…/tmp/electricity_data.xls’ ** _ #屬性構造后數據文件
_ data = pd.read_excel(inputfile) _ #讀入數據
_ data[ ** u’線損率’ ** ] = (data[ ** u’供入電量’ ** ] - data[ ** u’供出電量’ **
])/data[ ** u’供入電量’ ** ]
data.to_excel(outputfile, index = ** False ** ) _ #保存結果 _
_ _
5. ** 小波變換 代碼 **
非平穩序列的分析手段。
基于小波變換的特征提取方法：
(1)基于小波變換的多尺度空間能量分布特征提取法
(2)基于小波變換的多尺度空間的模極大特征值提取法
(3)基于小波變換的特征提取方法
(4)基于適應性小波神經網絡的特征提取方法
inputfile= ** ‘…/data/leleccum.mat’ ** _ #提取自Matlab的信號文件
_ ** from ** scipy.io ** import ** loadmat _ #mat是MATLAB專用格式，需要用loadmat讀取它
_ mat = loadmat(inputfile)
signal = mat[ ** ‘leleccum’ ** ][ 0 ]
** import ** pywt _ #導入PyWavelets
_ coeffs = pywt.wavedec(signal, ** ‘bior3.7’ ** , level = 5 )
_ #返回結果為level+1個數字，第一個數組為逼近系數數組，后面的依次是細節系數數組 _
二、 ** 數據規約 **
數據規約是將海量數據進行規約，規約之后的數據仍接近于 ** 保持原數據的完整性，但數據量小得多。 **
通過數據規約，可以達到：
降低無效、錯誤數據對建模的影響，提高建模的準確性
少量且具代表性的數據將大幅縮減數據挖掘所需的時間
降低儲存數據的成本 。
**
**1. 合并屬性 2 逐步向前選擇 3 逐步向后刪除 4 決策樹 規約 **
**5 主成分分析降維 代碼 **
1 數據矩陣 2 將數據矩陣中心標準化 3 求相關系數矩陣 4 求 R 的特征方程 5 確定主成分個數
6 計算 m 個相應的單位特征向量 7 計算主成分
inputfile = ** ‘…/data/principal_component.xls’
** outputfile = ** ‘…/tmp/dimention_reducted.xls’ ** _ #降維后的數據
_ data = pd.read_excel(inputfile, header = ** None ** ) _ #讀入數據
_ ** from ** sklearn.decomposition ** import ** PCA
pca = PCA()
pca.fit(data)
pca.components_ _ #返回模型的各個特征向量
_ pca.explained_variance_ratio_ _ #返回各個成分各自的方差百分比 _
_ 三維 _
pca=PCA(3)
pca.fit(data)
low_d=pca.transform(data)#降維
pd.DataFrame(low_d).to_excel(outputfile)
pca.inverse_transform(low_d)
**2 數值規約 ： 分箱，回歸，聚類，卡方檢驗，決策樹 **
通過選擇替代的、較小的數據來減少數據量，包含有參數方法和無參數方法兩類；有參數方法使用模型評估數據，不需要存放真實數據，只需要存放參數，例如回歸、對數線性模型。
無參數需要數據，例如直方圖、聚類、抽樣。
** 五、常用數據預處理函數 **
1.interpolate:一維，高維數據插值
f.scipy.interpolate.lagrange(x,y)
2.unique：去除重復元素
np.unique(D)
D.unique( ）
** import ** pandas ** as ** pd
** import ** numpy ** as ** np
D=pd.Series([ 1 , 1 , 2 , 3 , 5 ])
d1=D.unique()
d2 =np.unique(D)
print ** "d1 is: \n " ** ,d1
print ** "d2 is: \n " ** , d2
3.isnull/notnull：判斷空值/非空值
4.random：生成隨機矩陣
k x m x n維0-1之間；
np.random.rand(k,m,n…)
k x m x n維，正態分布；
np.random.randn(k,m,n)
5.PCA：主成分分析
** 第 5 章：挖掘建模 **
**cmplot 混淆矩陣，看 spe ， **
_ # -- coding: utf-8 --
_ ** def ** cm_plot(y, yp):
** from ** sklearn.metrics ** import ** confusion_matrix _ # 導入混淆矩陣函數
_ cm = confusion_matrix(y, yp) _ # 混淆矩陣 _
_
_ ** import ** matplotlib.pyplot ** as ** plt _ # 導入作圖庫
_ plt.matshow(cm, cmap =plt.cm.Greens) _ #
畫混淆矩陣圖，配色風格使用cm.Greens，更多風格請參考官網。
_ plt.colorbar() _ # 顏色標簽
_ ** for ** x ** in ** range ( len (cm)): _ # 數據標簽
_ ** for ** y ** in ** range ( len (cm)):
plt.annotate(cm[x, y], xy =(x, y), horizontalalignment = ** ‘center’ **
, verticalalignment = ** ‘center’ ** )
plt.ylabel( ** ‘True label’ ** ) _ # 坐標軸標簽
_ plt.xlabel( ** ‘Predicted label’ ** ) _ # 坐標軸標簽
_ ** return ** plt
**1 分類與預測 **
** 算法與模型 **
算法：回歸分析（ logistics ， LDA ），決策樹，神經網絡，貝葉斯， svm ，隨機森林
常用回歸模型：邏輯回歸，（非）線性回歸，嶺回歸，主成分回歸， logistics 回歸
**1 、邏輯回歸 **
_ #-- coding: utf-8 --
#邏輯回歸 自動建模
_ ** import ** pandas ** as ** pd
_ #參數初始化
_ filename = ** ‘…/data/bankloan.xls’
** data = pd.read_excel(filename)
x = data.iloc[:,: 8 ].as_matrix()
y = data.iloc[:, 8 ].as_matrix()
** from ** sklearn.linear_model ** import ** LogisticRegression ** as **
LR
** from ** sklearn.linear_model ** import ** RandomizedLogisticRegression
** as ** RLR
rlr = RLR() _ #建立隨機邏輯回歸模型，篩選變量
_ rlr.fit(x, y) _ #訓練模型
_ rlr.get_support() _ #獲取特征篩選結果，也可以通過.scores_方法獲取各個特征的分數
_ print ( ** u’通過隨機邏輯回歸模型篩選特征結束。’ ** )
print ( ** u’有效特征為：%s’ ** % ** ‘,’ **
.join(data.columns[rlr.get_support()]))
x = data[data.columns[rlr.get_support()]].as_matrix() _ #篩選好特征
_ lr = LR() _ #建立邏輯貨柜模型
_ lr.fit(x, y) _ #用篩選后的特征數據來訓練模型
_ print ( ** u’邏輯回歸模型訓練結束。’ ** )
print ( ** u’模型的平均正確率為：%s’ ** % lr.score(x, y)) _ #給出模型的平均正確率，本例為81.4% _
Scikit-learn 提供了 RFE 包，用于特征消除，還提供了 RFECV 通過交叉驗證進行特征排序
2、 ** 決策樹 ID3,C4.5 ， CART **
**ID3 決策樹 **
ID3 算法是一種基于信息熵的決策樹分類算法，它選擇當前樣本集中具有最大信息增益值的屬性作為測試屬性選擇增益最大
_ #-- coding: utf-8 --
#使用ID3決策樹算法預測銷量高低
_ ** import ** pandas ** as ** pd
_ #參數初始化
_ inputfile = ** ‘…/data/sales_data.xls’
** data = pd.read_excel(inputfile, index_col = ** u’序號’ ** ) _ #導入數據
#數據是類別標簽，要將它轉換為數據
#用1來表示“好”、“是”、“高”這三個屬性，用-1來表示“壞”、“否”、“低”
_ data[data == ** u’好’ ** ] = 1
data[data == ** u’是’ ** ] = 1
data[data == ** u’高’ ** ] = 1
data[data != 1 ] = - 1
x = data.iloc[:,: 3 ].as_matrix().astype( int )
y = data.iloc[:, 3 ].as_matrix().astype( int )
** from ** sklearn.tree ** import ** DecisionTreeClassifier ** as ** DTC
dtc = DTC( criterion = ** ‘entropy’ ** ) _ #建立決策樹模型，基于信息熵
_ dtc.fit(x, y) _ #訓練模型
#導入相關函數，可視化決策樹。
#導出的結果是一個dot文件，需要安裝Graphviz才能將它轉換為pdf或png等格式。
_ ** from ** sklearn.tree ** import ** export_graphviz
** from ** sklearn.externals.six ** import ** StringIO
** with ** open ( ** “tree.dot” ** , ** ‘w’ ** ) ** as ** f:
f = export_graphviz(dtc, feature_names = x.columns, out_file = f)
圖 2
**CART 決策樹模型 **
_ #-- coding: utf-8 --
#構建并測試CART決策樹模型
_ ** import ** pandas ** as ** pd _ #導入數據分析庫
_ ** from ** random ** import ** shuffle _ #導入隨機函數shuffle，用來打算數據
_ datafile = ** ‘…/data/model.xls’ ** _ #數據名
_ data = pd.read_excel(datafile) _ #讀取數據，數據的前三列是特征，第四列是標簽
_ data = data.as_matrix() _ #將表格轉換為矩陣
_ shuffle(data) _ #隨機打亂數據
_ p = 0.8 _ #設置訓練數據比例
_ train = data[: int ( len (data)*p),:] _ #前80%為訓練集
_ test = data[ int ( len (data)*p):,:] _ #后20%為測試集
#構建CART決策樹模型
_ ** from ** sklearn.tree ** import ** DecisionTreeClassifier _ #導入決策樹模型
_ treefile = ** ‘…/tmp/tree.pkl’ ** _ #模型輸出名字
_ tree = DecisionTreeClassifier() _ #建立決策樹模型
_ tree.fit(train[:,: 3 ], train[:, 3 ]) _ #訓練
#保存模型
_ ** from ** sklearn.externals ** import ** joblib
joblib.dump(tree, treefile)
** from ** cm_plot ** import ** * _ #導入自行編寫的混淆矩陣可視化函數
_ cm_plot(train[:, 3 ], tree.predict(train[:,: 3 ])).show() _
#顯示混淆矩陣可視化結果
#注意到Scikit-Learn使用predict方法直接給出預測結果。
_ ** from ** sklearn.metrics ** import ** roc_curve _ #導入ROC曲線函數
_ fpr, tpr, thresholds = roc_curve(test[:, 3 ], tree.predict_proba(test[:,:
3 ])[:, 1 ], pos_label = 1 )
plt.plot(fpr, tpr, linewidth = 2 , label = ** ‘ROC of CART’ ** ,
color = ** ‘green’ ** ) _ #作出ROC曲線
_ plt.xlabel( ** ‘False Positive Rate’ ** ) _ #坐標軸標簽
_ plt.ylabel( ** ‘True Positive Rate’ ** ) _ #坐標軸標簽
_ plt.ylim( 0 , 1.05 ) _ #邊界范圍
_ plt.xlim( 0 , 1.05 ) _ #邊界范圍
_ plt.legend( loc = 4 ) _ #圖例
_ plt.show() _ #顯示作圖結果 _
3、 ** 人工神經網絡 BP\LM\RBF\FNN\GMDH\ANFIS **
_ #-- coding: utf-8 --
#使用神經網絡算法預測銷量高低，用sales_data.xls
_ ** from ** keras.models ** import ** Sequential
** from ** keras.layers.core ** import ** Dense, Activation
model = Sequential() _ #建立模型
_ model.add(Dense( 10 , input_dim = 3 )) _ #三個輸入，10個隱藏，1一個輸出
_ model.add(Activation( ** ‘relu’ ** )) _ #用relu函數作為激活函數，能夠大幅提供準確度
_ model.add(Dense( 1 , input_dim = 10 ))
model.add(Activation( ** ‘sigmoid’ ** )) _ #由于是0-1輸出，用sigmoid函數作為激活函數
_ model.compile( loss = ** ‘binary_crossentropy’ ** , optimizer = **
‘adam’ ** ) # class_mode = ** ‘binary’ **
_ #編譯模型。由于我們做的是二元分類，所以我們指定損失函數為binary_crossentropy，以及模式為binary
#另外常見的損失函數還有mean_squared_error、categorical_crossentropy等，請閱讀幫助文件。
#求解方法我們指定用adam，還有sgd、rmsprop等可選
_ model.fit(x, y, epochs = 1000 , batch_size = 10 ) _
#訓練模型，學習一千次,x訓練失敗？
_ yp = model.predict_classes(x).reshape( len (y)) _ #分類預測
_ ** from ** cm_plot ** import ** * _ #導入自行編寫的混淆矩陣可視化函數
_ cm_plot(y,yp).show() _ #顯示混淆矩陣可視化結果 _
**2 聚類分析： **
** 劃分方法（常用： kmean 算法 ， k 中心點），系統聚類，層次聚類，譜聚類，基于密度 / 網格 /
模型的聚類，均值漂移聚類：用 scikit-learn ， spicy.cluster 也有很多 **
**kmeans 聚類算法過程： **
1 ）從 N 個樣本數據中隨機選取 K 個對象作為初始的聚類中心；
2 ）分別計算每個樣本到各個聚類中心的距離，將對象分配到距離最近的聚類中；
3 ）所有對象分配完成后，重新計算 K 個聚類的中心；
4 ）與前一次計算得到的 K 個聚類中心比較，如果聚類中心發生變化，轉 2) ，否則轉 5) ；
5 ）當質心不發生變化時停止并輸出聚類結果。
（ ** 連續屬性： ** 度量樣本之間的相似性最常用的是歐幾里得距離、曼哈頓距離和閔可夫斯基距離， ** 文檔數據： **
使用余弦相似性度量，先將文檔數據整理成文檔 —詞矩陣格式）
誤差平方和 SSE
** import ** pandas ** as ** pd
_ #參數初始化
_ inputfile = ** ‘…/data/consumption_data.xls’ ** _ #銷量及其他屬性數據
_ outputfile = ** ‘…/tmp/data_type.xls’ ** _ #保存結果的文件名
_ k = 3 _ #聚類的類別
_ iteration = 500 _ #聚類最大循環次數
_ data = pd.read_excel(inputfile, index_col = ** ‘Id’ ** ) _ #讀取數據
_ data_zs = 1.0 *(data - data.mean())/data.std() _ #數據標準化
_ ** from ** sklearn.cluster ** import ** KMeans
** if ** name== ** ‘main’ ** : _ #加入此行代碼即可
_ model = KMeans( n_clusters = k, n_jobs = 4 , max_iter = iteration)
_ #分為k類，并發數4
_ model.fit(data_zs) _ #開始聚類, you must protect your main loop using “if
name == ‘main’”.
#簡單打印結果
_ r1 = pd.Series(model.labels_).value_counts() _ #統計各個類別的數目
_ r2 = pd.DataFrame(model.cluster_centers_) _ #找出聚類中心
_ r = pd.concat([r2, r1], axis = 1 ) _ #橫向連接（0是縱向），得到聚類中心對應的類別下的數目
_ r.columns = list (data.columns) + [ ** u’類別數目’ ** ] _ #重命名表頭
_ ** print ** ?
_ #詳細輸出原始數據及其類別
_ r = pd.concat([data, pd.Series(model.labels_, index = data.index)], axis
= 1 ) _ #詳細輸出每個樣本對應的類別
_ r.columns = list (data.columns) + [ ** u’聚類類別’ ** ] _ #重命名表頭
_ r.to_excel(outputfile) _ #保存結果 _
** 繪制聚類后的概率密度圖 **
_
_ ** def ** density_plot(data): _ #自定義作圖函數
_ p = data.plot( kind = ** ‘kde’ ** , linewidth = 2 , subplots = **
True ** , sharex = ** False ** )
[p[i].set_ylabel( ** u’密度’ ** ) ** for ** i ** in ** range (k)]
plt.legend()
** return ** plt
pic_output = ** ‘…/tmp/pd_’ ** _ #概率密度圖文件名前綴
_ ** for ** i ** in ** range (k):
density_plot(data[r[ ** u’聚類類別’ ** ]==i]).savefig( ** u’%s%s.png’ **
%(pic_output, i))
？
** for ** i ** in ** range ( len (data.iloc[ 0 ])): _ #逐列作圖
_ (data.iloc[:,i]).plot( kind = ** ‘kde’ ** , linewidth = 2 , label
=data.columns[i])
** 聚類后算法評價 **
Purity 評價法：正確聚類占總數比例
RI 評價
F 值評價
** 聚類可視化 TSNE **
_ # 接 kmeans.py _
** from ** sklearn.manifold ** import ** TSNE
** import ** matplotlib.pyplot ** as ** plt
tsne = TSNE()
tsne.fit_transform(data_zs) _ #進行數據降維
_ tsne = pd.DataFrame(tsne.embedding_, index = data_zs.index) _ #轉換數據格式
#不同類別用不同顏色和樣式繪圖
_ d = tsne[r[ ** u’聚類類別’ ** ] == 0 ] _ #a=r[u’聚類類別’] ==
0,dtype(‘bool’),r:oject,r.columns:Index([u’R’, u’F’, u’M’, u’聚類類別’],
dtype=‘object’)
_ plt.plot(d[ 0 ], d[ 1 ], ** ‘r.’ ** )
d = tsne[r[ ** u’聚類類別’ ** ] == 1 ]
plt.plot(d[ 0 ], d[ 1 ], ** ‘go’ ** )
d = tsne[r[ ** u’聚類類別’ ** ] == 2 ]
plt.plot(d[ 0 ], d[ 1 ], ** ‘b*’ ** )
plt.show()
**3 關聯規則 aprior,FP-TREE **
（ 1 ）關聯規則的一般形式
支持度：項集 A 、 B 同時發生的概率
置信度：項集 A 發生，則項集 B 也同時發生的概率
（ 2 ）最小支持度和最小置信度
最小支持度：一個閾值，表示項目集在統計意義上的最低重要性；
最小置信度：一個閾值表示關聯規則的最低可靠性。
同時滿足最小支持度閾值和最小置信度閾值的規則稱作強規則。
** 函數文件 apirior.py **
過程一：找出所有的頻繁項集。
過程二：由頻繁項集產生強關聯規則 _
_ ** def ** connect_string(x, ms):
x = list ( map ( ** lambda ** i: sorted (i.split(ms)), x))
l = len (x[ 0 ])
r = []
** for ** i ** in ** range ( len (x)):
** for ** j ** in ** range (i, len (x)):
** if ** x[i][:l - 1 ] == x[j][:l - 1 ] ** and ** x[i][l - 1 ] !=
x[j][l - 1 ]:
r.append(x[i][:l - 1 ] + sorted ([x[j][l - 1 ], x[i][l - 1 ]]))
** return ** r
_ # 尋找關聯規則的函數
_ ** def ** find_rule(d, support, confidence, ms= ** u’–’ ** ):
result = pd.DataFrame( index =[ ** ‘support’ ** , ** ‘confidence’ ** ])
_ # 定義輸出結果
_ support_series = 1.0 * d.sum() / len (d) _ # 支持度序列
_ column = list (support_series[support_series > support].index) _ #
初步根據支持度篩選
_ k = 0
** while ** len (column) > 1 :
k = k + 1
print ( ** u’ \n 正在進行第 %s次搜索…’ ** % k)
column = connect_string(column, ms)
print ( ** u’數目：%s…’ ** % len (column))
sf = ** lambda ** i: d[i].prod( axis = 1 , numeric_only = ** True **
) _ # 新一批支持度的計算函數
創建連接數據，這一步耗時、耗內存最嚴重。當數據集較大時，可以考慮并行運算優化。
_ d_2 = pd.DataFrame( list ( map (sf, column)), index =[ms.join(i) **
for ** i ** in ** column]).T
support_series_2 = 1.0 * d_2[[ms.join(i) ** for ** i ** in **
column]].sum() / len (d) _ # 計算連接后的支持度
_ column = list (support_series_2[support_series_2 > support].index) _ #
新一輪支持度篩選
_ support_series = support_series.append(support_series_2)
column2 = []
** for ** i ** in ** column: _ #
遍歷可能的推理，如{A,B,C}究竟是A+B–>C還是B+C–>A還是C+A–>B？
_ i = i.split(ms)
** for ** j ** in ** range ( len (i)):
column2.append(i[:j] + i[j + 1 :] + i[j:j + 1 ])
cofidence_series = pd.Series( index =[ms.join(i) ** for ** i ** in **
column2]) _ # 定義置信度序列
_ ** for ** i ** in ** column2: _ # 計算置信度序列
_ cofidence_series[ms.join(i)] = support_series[ms.join( sorted (i))] /
support_series[ms.join(i[: len (i) - 1 ])]
** for ** i ** in ** cofidence_series[cofidence_series > confidence].index:
_ # 置信度篩選
_ result [i] = 0.0
result [i][ ** ‘confidence’ ** ] = cofidence_series[i]
result [i][ ** ‘support’ ** ] = support_series[ms.join( sorted
(i.split(ms)))]
result = result .T.sort([ ** ‘confidence’ ** , ** ‘support’ ** ],
ascending = ** False ** ) _ # 結果整理，輸出
_ print ( ** u’ \n 結果為： ’ ** )
print ( result )
** return ** result
** 使用 Apriori 算法挖掘菜品訂單關聯規則 **
_ #-- coding: utf-8 --
#使用Apriori算法挖掘菜品訂單關聯規則
_ ** from ** future ** import ** print_function
** import ** pandas ** as ** pd
** from ** apriori ** import ** * _ #導入自行編寫的apriori函數
_ inputfile = ** ‘…/data/menu_orders.xls’
** outputfile = ** ‘…/tmp/apriori_rules.xls’ ** _ #結果文件
_ data = pd.read_excel(inputfile, header = ** None ** )
**
** 代碼好 - 轉換原始數據至 0-1矩陣…’ ) ？ 有問題
ct = lambda x : pd.Series( 1 , index = x[pd.notnull(x)]) _
#轉換0-1矩陣的過渡函數
_ b = map (ct, data.as_matrix()) _ #用map方式執行
_ data = pd.DataFrame( list (b)).fillna( 0 ) _ #實現矩陣轉換，空值用0填充
_ print ( u’ \n 轉換完畢。 ’ )
del b _ #刪除中間變量b，節省內存
_ support = 0.2 _ #最小支持度
_ confidence = 0.5 _ #最小置信度
_ ms = ** ‘—’ ** _ #連接符，默認’–’，用來區分不同元素，如A–B。需要保證原始表格中不含有該字符
_ find_rule(data, support, confidence, ms).to_excel(outputfile) _ #保存結果 _
**4 時序模式： **
常見的時間序列模型 平滑，趨勢擬合法，組合（加法，乘法）、 AR 、 MA,ARMA,ARIMA,ARCH,GARCH ，將重點介紹 AR
模型、 MA 模型、 ARMA 模型和 ARIMA 模型。
** 時間序列的預處理（隨機 + 平穩） **
拿到一個觀察值序列后， ** 首先要對它的 純隨機性和平穩性 進行檢驗，這兩個重要的檢驗稱為序列的預處理。 **
根據檢驗結果可以將序列分為不同的類型，對不同類型的序列會采取不同的分析方法。
對于純隨機序列，又叫白噪聲序列 ，就意味著序列的各項之間沒有任何相關關系，序列在進行完全無序的隨機波動，可以終止對該序列的分析。
對于平穩非白噪聲序列， 它的均值和方差是常數，現已有一套非常成熟的平穩序列的建模方法。通常是建立一個線性模型來擬合該序列的發展，借此提取該序列的有用信息。
ARMA 模型是最常用的平穩序列擬合模型；
對于非平穩序列， 由于它的均值和方差不穩定，處理方法一般是將其轉變為平穩序列，這樣就可以應用有關平穩時間序列的分析方法，如建立 ARMA
模型來進行相應得研究。如果一個時間序列經差分運算后具有平穩性，成該序列為差分平穩序列，可以使用 ARIMA 模型進行分析。
1 平穩性檢驗
對序列的平穩性的檢驗有兩種檢驗方法，一種是 ** 根據時序圖和自相關圖的特征做出判斷的圖 **
檢驗，該方法操作簡單、應用廣泛，缺點是帶有主觀性；另一種是構造檢驗統計量進行的方法，目前最常用的方法是 ** 單位根檢驗 **
** （ 1 ）時序圖檢驗：如果有明顯的趨勢性或者周期性那它通常不是平穩序列。 **
（ 2 ）自相關圖檢驗 **_ （常用） _ **
平穩序列具有短期相關性，隨著延遲期數的增加，平穩序列的自相關系數 會比較快的衰減趨向于零，并在零附近隨機波動，而非平穩序列的自相關系數衰減的速度比較慢
（ 3 ）單位根檢驗是指檢驗序列中是否存在單位根，因為存在單位根就是非平穩時間序列了。 p 值顯著大于 0.05=== 非平穩（不是白噪聲）
2 純隨機性檢驗
純隨機性檢驗也稱 **_ 白噪聲檢驗 _ ， ** 一般是構造檢驗統計量來檢驗序列的純隨機性，常用的檢驗統計量有 Q 統計量、 LB
統計量，計算出對應的 p 值，如果 p 值顯著大于顯著性水平 , 則表示該序列不能拒絕純隨機的原假設，可以停止對該序列的分析。
** 平穩時間序列分析 ARMA **
ARMA 模型的全稱是自回歸移動平均模型，它是目前最常用的擬合平穩序列的模型。
ARMA 模型又可以細分為 AR 模型、 MA 模型和 ARMA 模型三大類。都可以看作是多元線性回歸模型。
下面將分別介紹 AR 模型、 MA 模型和 ARMA 模型三大模型。
** 平穩時間序列的 ARMA 模型建模步驟。 **
某個時間序列經過 預處理，被判定為平穩非白噪聲序列，就可以利用 ARMA 模型進行建模。
由 AR 模型、 MA 模型和 ARMA 模型的自相關系數和偏自相關系數的性質，選擇出合適的模型。
**AR 、 MA 和 ARMA 模型自相關系數和偏自相關系數的性質如下： **
AR模型：自相關系數拖尾，偏自相關系數截尾；
MA模型：自相關系數截尾，偏自相關函數拖尾；
ARMA模型：自相關函數和偏自相關函數均拖尾。
** 非平穩時間序列分析 ARIMA **
對非平穩時間序列的分析方法可以分為確定性因素分解的時序分析和隨機時序分析兩大類 。
** 確定性因素分解 ** 的方法把所有序列的變化都歸結為四個因素（長期趨勢、季節變動、循環變動和隨機波動）的綜合影響。可以建立加法模型和乘法模型等。
根據時間序列的不同特點， ** 隨機時序分析 ** 可以建立的模型有 ARIMA 模型、殘差自回歸模型、季節模型、異方差模型等。
1、p 階差分 ： 相距一期的兩個序 列值之間的減法運算稱為 1 階差分運算；
2、k 步差分 ： 相距 k 期的兩個序列值之間的減法運算稱為 k 步差分運算。
3、 差分運算具有強大的確定性信息提取能力，許多非平穩序列差分后會顯示出平穩序列的性質，這時稱這個非平穩序列為差分平穩序列。
4、 對差分平穩序列可以使用 ARMA模型進行擬合。
5、ARIMA模型的實質就是差分運算與ARMA模型的組合，掌握了ARMA模型的建模方法和步驟以后，對序列建立ARIMA模型是比較簡單的。
** 建模步驟： ( 代碼問題 ) **
_ _
** 建模步驟 **
** 計算 ACF 和 PACF( 自相關圖平穩性檢驗 + 白噪聲 **
先計算非平穩白噪聲序列的自相關系數（ ACF ）和偏自相關系數（ PACF ）
不平穩差分后再用 ARIMA 模型
** import ** pandas ** as ** pd
_ #讀取數據，指定日期列為指標，Pandas自動將“日期”列識別為Datetime格式
_ discfile = ** ‘…/data/arima_data.xls’
** forecastnum = 5 _
_ data = pd .read_excel(discfile, index_col = ** u’日期’ ** ) _
_ ** import ** matplotlib.pyplot ** as ** plt _
_ data.plot()
plt.show()
**
_ #自相關圖 和偏自相關圖選擇模型 _ **
_
_ ** from ** scipy ** import ** stats
** import ** matplotlibt.py p lot ** as ** plt
** import ** statsmodels.api ** as ** sm
** from ** statsmodels.graphics.api ** import ** qqplot
fig=sm.graphic.tsa.plot_acf(dta, lags = 40 , ax =ax1)
fig = sm.graphics.tsa.plot_pacf(dta, lags = 40 , ax =ax2)
_ # 一階差分后的自相關圖與偏自相關圖
_ dta = dta.diff( 1 ).dropna() _ # 注意一定要將查分后的空值去掉再取自相關系數
_ fig = sm.graphics.tsa.plot_acf(dta, lags = 40 , ax =ax3)
fig = sm.graphics.tsa.plot_pacf(dta, lags = 40 , ax =ax4)
**# 平穩性檢測 # 白噪聲檢驗 **
_
_ ** from ** statsmodels.tsa.stattools ** import ** adfuller ** as ** ADF
print ( ** u’原始序列的ADF檢驗結果為：’ ** , ADF(data[ ** u’銷量’ ** ]))
_ #返回值依次為adf、pvalue、usedlag、nobs、critical values、icbest、regresults、resstore
_ D_data=data.diff().dropna()
D_data.columns=[ ** u’銷量差分’ ** ] _
_ ** from ** statsmodels.stats.diagnostic ** import ** acorr_ljungbox
print ( ** u’差分序列的白噪聲檢驗結果為：’ ** , acorr_ljungbox(D_data, lags = 1 )) _
#返回統計量和p值
_ ** from ** statsmodels.tsa.arima_model ** import ** ARIMA
_ #定階
_ pmax = int ( len (D_data)/ 10 ) _ #一般階數不超過length/10
_ qmax = int ( len (D_data)/ 10 ) _ #一般階數不超過length/10
_ bic_matrix = [] _ #bic矩陣
_ ** for ** p ** in ** range (pmax+ 1 ):
tmp = []
** for ** q ** in ** range (qmax+ 1 ):
** try ** : _ #存在部分報錯，所以用try來跳過報錯。
_ tmp.append(ARIMA(data, (p, 1 ,q)).fit().bic)
** except ** :
tmp.append( ** None ** )
bic_matrix.append(tmp)
bic_matrix = pd .DataFrame(bic_matrix) _ #從中可以找出最小值
_ p,q = bic_matrix.stack().idxmin() _ #先用stack展平，然后用idxmin找出最小值位置。
_ print ( ** u’BIC最小的p值和q值為：%s、%s’ ** %(p,q))
**ARMA 模型識別 **
由 AR 模型、 MA 模型和 ARMA 模型的自相關系數和偏自相關系數的性質，選擇出合適的模型。
** 模型定階 AIC ：確定 p 和 q **
（1） 人為識別的方法： 用相關圖像 根據 ARMA模型識別原則進行模型定階
（2） 第二種方法：相對最優模型識別。
計算 ARMA（p，q）當 p 和 q 均小于等于 5 的所有組合的 BIC 信息量，取其中 BIC 信息量達到最小的模型階數。ARIMA（P ，
1，Q ）
** 模型檢驗 **
確定模型后，需要檢驗其殘差序列是否是白噪聲，若 ** 不是 ** ，說明，殘差中還存在有用的信息， ** 需要修改模型或者進一步提取 **
。若其殘差不是白噪聲，重新更換 p,q 的值，重新確定
p 值為： 0.627016 ，大于 0.05 ， ** 殘差 ** 為白噪聲序列，模型通過檢驗。
** 模型預測 **
只能進行短期預測
model = ARIMA(data, (p, 1 ,q)).fit() _ #建立ARIMA(0, 1, 1)模型
_ model .summary2() _ #給出一份模型報告
_ model .forecast( 5 )
** 模型優化與應用 **
**5 離群點檢測 **
threshold= 2
norm = []
** for ** i ** in ** range (k): _ #逐一處理
_ norm_tmp = r[[ ** ‘R’ ** , ** ‘F’ ** , ** ‘M’ ** ]][r[ ** u’聚類類別’ ** ] == i]-model.cluster_centers_[i]
norm_tmp = norm_tmp.apply(np.linalg.norm, axis = 1 ) _ #求出絕對距離
_ norm.append(norm_tmp/norm_tmp.median()) _ #求相對距離并添加
#norm = pd.concat(norm) #合并
_ norm[norm <= threshold].plot( style = ** ‘go’ ** ) _ #正常點
_ discrete_points = norm[norm > threshold] _ #離群點
_ discrete_points.plot( style = ** ‘ro’ ** )
** for ** i ** in ** range ( len (discrete_points)): _ #離群點做標記
_ id = discrete_points.index[i]
n = discrete_points.iloc[i]
plt.annotate( ** ‘(%s, %0.2f)’ ** %(id, n), xy = (id, n), xytext = (id,
n))
plt.xlabel( ** u’編號’ ** )
plt.ylabel( ** u’相對距離’ ** )
plt.show()
總結
- 上一篇： rayleighchan实现瑞利多径衰落
- 下一篇： 密码学之对称加密体系（1）：AES、SM