DecisionTreeClassifier(criterion="gini"
								# criterion用于指定選擇節(jié)點字段的評價指標。對于分類決策樹默認gini，表示采用基尼系數(shù)指標進行葉子節(jié)點的最佳選擇?？捎小癳ntropy”,但是容易過擬合，用于擬合不足
								# 對于回歸決策數(shù)，默認“mse”，表示均方誤差選擇節(jié)點的最佳分割手段。
                                ,random_state=None
                                # 用于指定隨機數(shù)生成器的種子，默認None表示使用默認的隨機數(shù)生成器。
                                ,splitter="best"
                                # 用于指定節(jié)點中的分割點的選擇方法，默認best表示從所有的分割點中選出最佳分割點，
                                # 也可以是random，表示隨機選擇分割點
                                
                                #以下參數(shù)均為防止過擬合
                                ,max_depth=None
                                # 用于指定決策樹的最大深度，默認None，表示樹的生長過程中對于深度不做任何限制。
                                ,min_samples_leaf=1
                                # 用于指定葉節(jié)點的最小樣本量默認為1。
                                ,min_samples_split=2
                                # 用于指定根節(jié)點或中間節(jié)點能夠繼續(xù)分割的最小樣本量默認為2。
                                ,max_features=None
                                # 用于指定決策樹包含的最多分隔字段數(shù)，默認None表示分割時使用所有的字段。如果為具體的整數(shù)，則考慮使用對應的分割手段數(shù)，如果為0~1的浮點數(shù)，則考慮對于對應百分比的字段個數(shù)。
                                ,min_impurity_decrease=0
                                # 用于指定節(jié)點是否繼續(xù)分割的最小不純度值，默認為0
                                ,class_weight=None
                                # 用于指定因變量中類別之間的權重。默認None表示每個類別的權重都相同。
                                )

import pandas as pd
from sklearn import tree
from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_wine
import graphviz
# 實例化數(shù)據(jù)集，為字典格式
wine=load_wine()
datatarget=pd.concat([pd.DataFrame(wine.data),pd.DataFrame(wine.target)],axis=1)
# 通過數(shù)據(jù)集的數(shù)據(jù)和標簽進行訓練和測試集的分類。
xtrain,xtest,ytrain,ytest=train_test_split(wine.data # 數(shù)據(jù)集的數(shù)據(jù)。
											,wine.target# 數(shù)據(jù)集標簽。
											,test_size=0.3#表示訓練集為70%測試集為30%。
											)
								
# 創(chuàng)建一個樹的模型。			
clf=tree.DecisionTreeClassifier(criterion="gini") # 這里只使用了基尼系數(shù)作為參數(shù)，其他沒有暫時使用
# 將訓練集數(shù)據(jù)放在模型中進行訓練，clf就是我們訓練好的模型，可以用來進行測試劑的決策。
clf=clf.fit(xtrain,ytrain)

# 那么對于我們訓練好的模型來說，怎么樣才能夠說明他是一個比較好的模型，那么我們就要引入模型中的一個函數(shù)score進行模型打分
clf.score(xtest,ytest)#測試集打分
# 也可以使用交叉驗證的方式，對于數(shù)據(jù)進行評估更具有穩(wěn)定性。
cross_val_score(clf # 填入想要打分的模型。
				,wine.data# 打分的數(shù)據(jù)集
				,wine.target# 用于打分的標簽。
				,cv=10# 交叉驗證的次數(shù)
				#,scoring="neg_mean_squared_error"
		#只有在回歸中有該參數(shù)，表示以負均方誤差輸出分數(shù)
		).mean()

# 將決策樹以樹的形式展現(xiàn)出來
dot=tree.export_graphviz(clf
                         #,feature_names    #特征名
                         #,class_names  #結果名
                         ,filled=True#顏色自動填充
                         ,rounded=True)#弧線邊界
graph=graphviz.Source(dot)

# 模型特征重要性指標
clf.feature_importances_
#[*zip(wine.feature_name,clf.feature_importances_)]特征名和重要性結合

#apply返回每個測試樣本所在的葉子節(jié)點的索引
clf.apply(Xtest)
#predict返回每個測試樣本的分類/回歸結果
clf.predict(Xtest)

from sklearn import tree
from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_wine
import matplotlib.pyplot as plt、

wine=load_wine()
xtrain,xtest,ytrain,ytest=train_test_split(wine.data,wine.target,test_size=0.3)
trainscore=[]
testscore=[]
for i in range(10):
    clf=tree.DecisionTreeClassifier(criterion="gini"
                                    ,random_state=0
                                    ,max_depth=i+1
                                    ,min_samples_split=5
                                    ,max_features=5
                                    ).fit(xtrain,ytrain)

	# 下面這這兩句代碼本質上結果是一樣的。第2種比較穩(wěn)定，但是費時間
    once1=clf.score(xtrain,ytrain)
    once2=cross_val_score(clf,wine.data,wine.target,cv=10).mean()#也可用clf.score(xtest,ytest)

    trainscore.append(once1)
    testscore.append(once2)

#畫圖像
plt.plot(range(1,11),trainscore,color="red",label="train")
plt.plot(range(1,11),testscore,color="blue",label="test")
#顯示范圍
plt.xticks(range(1,11))
plt.legend()
plt.show()

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_wine
from sklearn.model_selection import GridSearchCV # 網(wǎng)格搜索的導入
wine = load_wine()
xtrain, xtest, ytrain, ytest = train_test_split(wine.data, wine.target, test_size=0.3)
clf = DecisionTreeClassifier(random_state=0)  # 確定random_state，就會在以后多次運行的情況下結果相同

# parameters為網(wǎng)格搜索的主要參數(shù)，它是以字典的形式存在。鍵為指定模型的參數(shù)名稱，值為參數(shù)列表
parameters = {"criterion": ["gini", "entropy"]
    , "splitter": ["best", "random"]
    , "max_depth": [*range(1, 10)]
              # ,"min_samples_leaf":[*range(5,10)]
              }
# 使用網(wǎng)絡搜索便利查詢,返回建立好的模型，網(wǎng)格搜索包括交叉驗證cv為交叉次數(shù)
GS = GridSearchCV(clf, cv=10, param_grid=parameters)
# 進行數(shù)據(jù)訓練
gs = GS.fit(xtrain, ytrain)

# best_params_接口可以查看最佳組合
# 最佳組合，（不一定最好，可能有些參數(shù)不涉及結果更好）
best_choice = gs.best_params_
print(best_choice)

# best_score_接口可以查看最佳組合的得分
best_score = gs.best_score_
print(best_score)

import numpy as np
from sklearn.tree import DecisionTreeRegressor
import matplotlib.pyplot as plt

#隨機數(shù)生成器的實例化
rng = np.random.RandomState(0)
# rng.rand(80, 1)在0到1之間生成80個數(shù)，axis=0，縱向排序作為自變量
X = np.sort(5 * rng.rand(80, 1), axis=0)
# 因變量的生成
y = np.sin(X).ravel()
# 添加噪聲
y[::5] += 3 * (0.5 - rng.rand(16))

#建立不同樹模型，回歸樹除了criterion其余和分類樹參數(shù)相同
regr_1 = DecisionTreeRegressor(max_depth=2)
regr_2 = DecisionTreeRegressor(max_depth=5)
# 訓練數(shù)據(jù)
regr_1.fit(X, y)
regr_2.fit(X, y)

# 生成測試數(shù)據(jù)
X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]
# 預測X_test數(shù)據(jù)在不同數(shù)上的表現(xiàn)
y_1 = regr_1.predict(X_test)
y_2 = regr_2.predict(X_test)

#畫圖
plt.figure()
plt.scatter(X, y, s=20, edgecolor="black",
            c="red", label="data")
plt.plot(X_test, y_1, color="blue",
         label="max_depth=2", linewidth=2)
plt.plot(X_test, y_2, color="green", label="max_depth=5", linewidth=2)
plt.xlabel("data")
plt.ylabel("target")
plt.title("Decision Tree Regression")
plt.legend()
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_moons, make_circles, make_classification
from sklearn.tree import DecisionTreeClassifier

######生成三種數(shù)據(jù)集######
# 二分類數(shù)據(jù)集
X, y = make_classification(n_samples=100, #生成100個樣本
 n_features=2,#有兩個特征
 n_redundant=0, #添加冗余特征0個
 n_informative=2, #包含信息的特征是2個
 random_state=1,#隨機模式1
n_clusters_per_class=1 #每個簇內(nèi)包含的標簽類別有1個
 )
rng = np.random.RandomState(2) #生成一種隨機模式
X += 2 * rng.uniform(size=X.shape) #加減0~1之間的隨機數(shù)
linearly_separable = (X, y) #生成了新的X，依然可以畫散點圖來觀察一下特征的分布
#plt.scatter(X[:,0],X[:,1])

#用make_moons創(chuàng)建月亮型數(shù)據(jù)，make_circles創(chuàng)建環(huán)形數(shù)據(jù)，并將三組數(shù)據(jù)打包起來放在列表datasets中
moons=make_moons(noise=0.3, random_state=0)
circles=make_circles(noise=0.2, factor=0.5, random_state=1)
datasets = [moons,circles,linearly_separable]


figure = plt.figure(figsize=(6, 9))
i=1
#設置用來安排圖像顯示位置的全局變量i i = 1
#開始迭代數(shù)據(jù)，對datasets中的數(shù)據(jù)進行for循環(huán)
for ds_index, ds in enumerate(datasets):
    X, y = ds
    # 對數(shù)據(jù)進行標準化處理
    X = StandardScaler().fit_transform(X)
    #劃分數(shù)據(jù)集
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4,
random_state=42)

    #定數(shù)據(jù)范圍，以便后續(xù)進行畫圖背景的確定
    #注意X[:,0]指橫坐標，X[：，1]指縱坐標
    x1_min, x1_max = X[:, 0].min() - .5, X[:, 0].max() + .5
    x2_min, x2_max = X[:, 1].min() - .5, X[:, 1].max() + .5

    #使畫板上每個點組成坐標的形式（沒間隔0.2取一個），array1表示橫坐標，array2表示縱坐標
    array1,array2 = np.meshgrid(np.arange(x1_min, x1_max, 0.2), np.arange(x2_min, x2_max, 0.2))
    # 顏色列表
    cm_bright = ListedColormap(['#FF0000', '#0000FF'])

########## 原始數(shù)據(jù)的現(xiàn)實  #########

    # 用畫板上六個圖片位置（3，2）的第i個
    ax = plt.subplot(len(datasets), 2, i)

    # 便簽添加
    if ds_index == 0:
        ax.set_title("Input data")

    #畫出訓練數(shù)據(jù)集散點圖
    ax.scatter(X_train[:, 0],#橫坐標
               X_train[:, 1],#縱坐標
               c=y_train,#意思是根據(jù)y_train標簽從cm_bright顏色列表中取出對應的顏色，也就是說相同的標簽有相同的顏色。
               cmap = cm_bright, #顏色列表
               edgecolors = 'k'#生成散點圖，每一個點邊緣的顏色
               )
    #畫出測試數(shù)據(jù)集的散點圖，其中比訓練集多出alpha = 0.4參數(shù)，以分辨訓練測試集
    ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test,cmap = cm_bright, alpha = 0.4, edgecolors = 'k')
    #顯示的坐標范圍
    ax.set_xlim(array1.min(), array1.max())
    ax.set_ylim(array2.min(), array2.max())
    #不顯示坐標值
    ax.set_xticks(())
    ax.set_yticks(())

    #i+1顯示在下一個子圖版上畫圖
    i += 1

####### 經(jīng)過決策的數(shù)據(jù)顯示 #######
    ax = plt.subplot(len(datasets), 2, i)
    #實例化訓練模型
    clf = DecisionTreeClassifier(max_depth=5).fit(X_train, y_train)
    score = clf.score(X_test, y_test)

    # np.c_是能夠將兩個數(shù)組組合起來的函數(shù)
    # ravel()能夠將一個多維數(shù)組轉換成一維數(shù)組
    #通過對畫板上每一個點的預測值確定分類結果范圍，并以此為依據(jù)通，通過不同的顏色展現(xiàn)出來范圍
    Z = clf.predict(np.c_[array1.ravel(), array2.ravel()])
    Z = Z.reshape(array1.shape)
    cm = plt.cm.RdBu # 自動選取顏色的實例化模型。
    ax.contourf(array1#畫板橫坐標。
                , array2#畫板縱坐標
                , Z# 畫板每個點對應的預測值m,并據(jù)此來確定底底板的顏色。
                , cmap=cm#顏顏色選取的模型，由于Z的值只有兩個，也可以寫出一個顏色列表，指定相應顏色，不讓其自動生成
                , alpha=0.8
                )
    #和原始數(shù)據(jù)集一樣，畫出每個訓練集和測試集的散點圖
    ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright, edgecolors = 'k')
    ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, edgecolors = 'k', alpha = 0.4)
    ax.set_xlim(array1.min(), array1.max())
    ax.set_ylim(array2.min(), array2.max())
    ax.set_xticks(())
    ax.set_yticks(())

    if ds_index == 0:
        ax.set_title("Decision Tree")

    #在右下角添加模型的分數(shù)
    ax.text(array1.max() - .3, array2.min() + .3, ('{:.1f}%'.format(score * 100)),
    size = 15, horizontalalignment = 'right')
    i += 1

#自動調(diào)整子畫板與子畫板之間的的距離
plt.tight_layout()
plt.show()

RandomForestClassifier(n_estimators=10 # 用于對于指定隨機森林所包含的決策樹個數(shù)
						,criterion="gini" # 用于每棵樹分類節(jié)點的分割字段的度量指標。和決策樹含義相同。
						,max_depth=None # 用于每顆決策樹的最大深度，默認不限制其生長深度。
						,min_samples_split=2 # 用于指定每顆決策數(shù)根節(jié)點或者中間節(jié)點能夠繼續(xù)分割的最小樣本量,默認2。
						,min_samples_leaf=1 # 用于指定每個決策樹葉子節(jié)點的最小樣本量，默認為1
						,max_features="auto" # 用于指定每個決策樹包含的最多分割字段數(shù)（特征數(shù)）默認None。表示分割時涉及使用所有特征
						,bootstrap=True # #是否開啟帶外模式（有放回取值，生成帶外數(shù)據(jù)）若不開啟，需要自己劃分train和test數(shù)據(jù)集，默認True
						,oob_score=False # #是否用帶外數(shù)據(jù)檢測 即是是否使用帶外樣本計算泛化，誤差默認為false，袋外樣本是指每一個bootstrap抽樣時沒有被抽中的樣本
						,random_state=None # 用于指定隨機數(shù)生成器的種子，默認None，表示默認隨機生成器
						,calss_weight # 用于因變量中類別的權重，默認每個類別權重相同
						)
注：一般n_estimators越大，模型的效果往往越好。但是相應的，任何模型都有決策邊界
n_estimators達到一定的程度之后，隨機森林的精確性往往不在上升或開始波動
并且n_estimators越大，需要的計算量和內(nèi)存也越大，訓練的時間也會越來越長

from sklearn.datasets import load_wine
from sklearn.ensemble import RandomForestClassifier
wine=load_wine()
xtrain,xtest,ytrain,ytest=train_test_split(wine.data ,wine.target,test_size=0.3)
rfc=RandomForestClassifier(random_state=0
                          ,n_estimators=10#生成樹的數(shù)量
                          ,bootstrap=True
                          ,oob_score=True#開啟袋外數(shù)據(jù)檢測
                           ).fit(xtrain,ytrain)
rfc.score(xtest,ytest)
rfc.oob_score_#帶外數(shù)據(jù)作為檢測數(shù)據(jù)集
rfc.predict_proba(wine.data)#輸出所有數(shù)據(jù)在target上的概率
rfc.estimators_#所有樹情況
rfc.estimators_[1].random_state#某個樹random——state值

from sklearn.model_selection import cross_val_score
import matplotlib.pyplot as plt
from sklearn.datasets import load_wine
from sklearn.ensemble import RandomForestClassifier
wine=load_wine()
score=[]
for i in range(100):
    rfc=RandomForestClassifier(random_state=0
                              ,n_estimators=i+1
                              ,bootstrap=True
                              ,oob_score=False
                               )
    once=cross_val_score(rfc,wine.data,wine.target,cv=10).mean()
    score.append(once)
    
plt.plot(range(1,101),score)
plt.xlabel("n_estimators")
plt.show()
print("best srore = ",max(score),"\nbest n_estimators = ",score.index(max(score))+1)

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score
import matplotlib.pyplot as plt
from sklearn.datasets import load_wine
from sklearn.ensemble import RandomForestClassifier
wine=load_wine()
score1=[]
score2=[]
for i in range(10):
    rfc=RandomForestClassifier(n_estimators=12)
    once1=cross_val_score(rfc,wine.data,wine.target,cv=10).mean()
    score1.append(once1)
    clf=DecisionTreeClassifier()
    once2=cross_val_score(clf,wine.data,wine.target,cv=10).mean()
    score2.append(once2)
plt.plot(range(1,11),score1,label="Forest")
plt.plot(range(1,11),score2,label="singe tree")
plt.legend()
plt.show()

from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
import matplotlib.pyplot as plt
cancer = load_breast_cancer()
scores=[]
for i in range(1,201,10):
    rfc = RandomForestClassifier(n_estimators=i, random_state=0).fit(cancer.data,cancer.target)
    score = cross_val_score(rfc,cancer.data,cancer.target,cv=10).mean()
    scores.append(score)
print(max(scores),(scores.index(max(scores))*10)+1)
plt.figure(figsize=[20,5])
plt.plot(range(1,201,10),scores)
plt.show()

from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
import matplotlib.pyplot as plt
cancer = load_breast_cancer()
scores=[]
for i in range(1,20,2):
    rfc = RandomForestClassifier(n_estimators=111,max_depth=i, random_state=0)
    score = cross_val_score(rfc,cancer.data,cancer.target,cv=10).mean()
    scores.append(score)
print(max(scores),(scores.index(max(scores))*2)+1)
plt.figure(figsize=[20,5])
plt.plot(range(1,20,2),scores)
plt.show()

from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
import matplotlib.pyplot as plt
cancer = load_breast_cancer()
scores=[]
for i in range(1,20,2):
    rfc = RandomForestClassifier(n_estimators=111,criterion="entropy",max_depth=i, random_state=0)
    score = cross_val_score(rfc,cancer.data,cancer.target,cv=10).mean()
    scores.append(score)
print(max(scores),(scores.index(max(scores))*2)+1)
plt.figure(figsize=[20,5])
plt.plot(range(1,20,2),scores)
plt.show()