Datawhale 零基礎入門數據挖掘-Task5 模型融合

五、模型融合

Tip:此部分爲零基礎入門數據挖掘的 Task5 模型融合部分，帶你來了解各種模型結果的融合方式，在比賽的攻堅時刻衝刺Top，歡迎大家後續多多交流。

賽題：零基礎入門數據挖掘 - 二手車交易價格預測

地址：https://tianchi.aliyun.com/competition/entrance/231784/introduction?spm=5176.12281957.1004.1.38b02448ausjSX

5.1 模型融合目標

對於多種調參完成的模型進行模型融合。
完成對於多種模型的融合，提交融合結果並打卡。

5.2 內容介紹

模型融合是比賽後期一個重要的環節，大體來說有如下的類型方式。

簡單加權融合:
- 迴歸（分類概率）：算術平均融合（Arithmetic mean），幾何平均融合（Geometric mean）；
- 分類：投票（Voting)
- 綜合：排序融合(Rank averaging)，log融合

stacking/blending:
- 構建多層模型，並利用預測結果再擬合預測。

boosting/bagging（在xgboost，Adaboost,GBDT中已經用到）:
- 多樹的提升方法

5.3 Stacking相關理論介紹

1) 什麼是 stacking

簡單來說 stacking 就是當用初始訓練數據學習出若干個基學習器後，將這幾個學習器的預測結果作爲新的訓練集，來學習一個新的學習器。

將個體學習器結合在一起的時候使用的方法叫做結合策略。對於分類問題，我們可以使用投票法來選擇輸出最多的類。對於迴歸問題，我們可以將分類器輸出的結果求平均值。

上面說的投票法和平均法都是很有效的結合策略，還有一種結合策略是使用另外一個機器學習算法來將個體機器學習器的結果結合在一起，這個方法就是Stacking。

在stacking方法中，我們把個體學習器叫做初級學習器，用於結合的學習器叫做次級學習器或元學習器（meta-learner），次級學習器用於訓練的數據叫做次級訓練集。次級訓練集是在訓練集上用初級學習器得到的。

2) 如何進行 stacking

算法示意圖如下：

引用自西瓜書《機器學習》

過程1-3 是訓練出來個體學習器，也就是初級學習器。
過程5-9是使用訓練出來的個體學習器來得預測的結果，這個預測的結果當做次級學習器的訓練集。
過程11 是用初級學習器預測的結果訓練出次級學習器，得到我們最後訓練的模型。

3）Stacking的方法講解

首先，我們先從一種“不那麼正確”但是容易懂的Stacking方法講起。

Stacking模型本質上是一種分層的結構，這裏簡單起見，只分析二級Stacking.假設我們有2個基模型 Model1_1、Model1_2 和一個次級模型Model2

Step 1. 基模型 Model1_1，對訓練集train訓練，然後用於預測 train 和 test 的標籤列，分別是P1，T1

Model1_1 模型訓練:

⎛⎜ ⎜ ⎜⎝⋮Xtrain⋮⎞⎟ ⎟ ⎟⎠Model1_1 Train⟹⎛⎜ ⎜ ⎜⎝⋮YTrue⋮⎞⎟ ⎟ ⎟⎠(⋮Xtrain⋮)⟹⏞Model1_1 Train(⋮YTrue⋮)

訓練後的模型 Model1_1 分別在 train 和 test 上預測，得到預測標籤分別是P1，T1

⎛⎜ ⎜ ⎜⎝⋮Xtrain⋮⎞⎟ ⎟ ⎟⎠Model1_1 Predict⟹⎛⎜ ⎜ ⎜⎝⋮P1⋮⎞⎟ ⎟ ⎟⎠(⋮Xtrain⋮)⟹⏞Model1_1 Predict(⋮P1⋮)

⎛⎜ ⎜ ⎜⎝⋮Xtest⋮⎞⎟ ⎟ ⎟⎠Model1_1 Predict⟹⎛⎜ ⎜ ⎜⎝⋮T1⋮⎞⎟ ⎟ ⎟⎠(⋮Xtest⋮)⟹⏞Model1_1 Predict(⋮T1⋮)

Step 2. 基模型 Model1_2 ，對訓練集train訓練，然後用於預測train和test的標籤列，分別是P2，T2

Model1_2 模型訓練:

⎛⎜ ⎜ ⎜⎝⋮Xtrain⋮⎞⎟ ⎟ ⎟⎠Model1_2 Train⟹⎛⎜ ⎜ ⎜⎝⋮YTrue⋮⎞⎟ ⎟ ⎟⎠(⋮Xtrain⋮)⟹⏞Model1_2 Train(⋮YTrue⋮)

訓練後的模型 Model1_2 分別在 train 和 test 上預測，得到預測標籤分別是P2，T2

⎛⎜ ⎜ ⎜⎝⋮Xtrain⋮⎞⎟ ⎟ ⎟⎠Model1_2 Predict⟹⎛⎜ ⎜ ⎜⎝⋮P2⋮⎞⎟ ⎟ ⎟⎠(⋮Xtrain⋮)⟹⏞Model1_2 Predict(⋮P2⋮)

⎛⎜ ⎜ ⎜⎝⋮Xtest⋮⎞⎟ ⎟ ⎟⎠Model1_2 Predict⟹⎛⎜ ⎜ ⎜⎝⋮T2⋮⎞⎟ ⎟ ⎟⎠(⋮Xtest⋮)⟹⏞Model1_2 Predict(⋮T2⋮)

Step 3. 分別把P1,P2以及T1,T2合併，得到一個新的訓練集和測試集train2,test2.

Train_2 ⎛⎜ ⎜ ⎜⎝⋮P1⋮⋮P2⋮⎞⎟ ⎟ ⎟⎠andTest_2 ⎛⎜ ⎜ ⎜⎝⋮T1⋮⋮T2⋮⎞⎟ ⎟ ⎟⎠(⋮P1⋮⋮P2⋮)⏞Train_2 and(⋮T1⋮⋮T2⋮)⏞Test_2

再用次級模型 Model2 以真實訓練集標籤爲標籤訓練,以train2爲特徵進行訓練，預測test2,得到最終的測試集預測的標籤列 YPreYPre。

Train_2 ⎛⎜ ⎜ ⎜⎝⋮P1⋮⋮P2⋮⎞⎟ ⎟ ⎟⎠Model2 Train⟹⎛⎜ ⎜ ⎜⎝⋮YTrue⋮⎞⎟ ⎟ ⎟⎠(⋮P1⋮⋮P2⋮)⏞Train_2 ⟹⏞Model2 Train(⋮YTrue⋮)

Test_2 ⎛⎜ ⎜ ⎜⎝⋮T1⋮⋮T2⋮⎞⎟ ⎟ ⎟⎠Model1_2 Predict⟹⎛⎜ ⎜ ⎜⎝⋮YPre⋮⎞⎟ ⎟ ⎟⎠(⋮T1⋮⋮T2⋮)⏞Test_2 ⟹⏞Model1_2 Predict(⋮YPre⋮)

這就是我們兩層堆疊的一種基本的原始思路想法。在不同模型預測的結果基礎上再加一層模型，進行再訓練，從而得到模型最終的預測。

Stacking本質上就是這麼直接的思路，但是直接這樣有時對於如果訓練集和測試集分佈不那麼一致的情況下是有一點問題的，其問題在於用初始模型訓練的標籤再利用真實標籤進行再訓練，毫無疑問會導致一定的模型過擬合訓練集，這樣或許模型在測試集上的泛化能力或者說效果會有一定的下降，因此現在的問題變成了如何降低再訓練的過擬合性，這裏我們一般有兩種方法。

1. 次級模型儘量選擇簡單的線性模型
1. 利用K折交叉驗證

K-折交叉驗證：訓練：

預測：

5.4 代碼示例

5.4.1 迴歸\分類概率-融合：

1）簡單加權平均，結果直接融合

## 生成一些簡單的樣本數據，test_prei 代表第i個模型的預測值

test_pre1 = [1.2, 3.2, 2.1, 6.2]

test_pre2 = [0.9, 3.1, 2.0, 5.9]

test_pre3 = [1.1, 2.9, 2.2, 6.0]

# y_test_true 代表第模型的真實值

y_test_true = [1, 3, 2, 6]

import numpy as np

import pandas as pd

## 定義結果的加權平均函數

def Weighted_method(test_pre1,test_pre2,test_pre3,w=[1/3,1/3,1/3]):

    Weighted_result = w[0]*pd.Series(test_pre1)+w[1]*pd.Series(test_pre2)+w[2]*pd.Series(test_pre3)

    return Weighted_result

from sklearn import metrics

# 各模型的預測結果計算MAE

print('Pred1 MAE:',metrics.mean_absolute_error(y_test_true, test_pre1))

print('Pred2 MAE:',metrics.mean_absolute_error(y_test_true, test_pre2))

print('Pred3 MAE:',metrics.mean_absolute_error(y_test_true, test_pre3))

Pred1 MAE: 0.175
Pred2 MAE: 0.075
Pred3 MAE: 0.1

## 根據加權計算MAE

w = [0.3,0.4,0.3] # 定義比重權值

Weighted_pre = Weighted_method(test_pre1,test_pre2,test_pre3,w)

print('Weighted_pre MAE:',metrics.mean_absolute_error(y_test_true, Weighted_pre))

Weighted_pre MAE: 0.0575

可以發現加權結果相對於之前的結果是有提升的，這種我們稱其爲簡單的加權平均。

還有一些特殊的形式，比如mean平均，median平均

## 定義結果的加權平均函數

def Mean_method(test_pre1,test_pre2,test_pre3):

    Mean_result = pd.concat([pd.Series(test_pre1),pd.Series(test_pre2),pd.Series(test_pre3)],axis=1).mean(axis=1)

    return Mean_result

Mean_pre = Mean_method(test_pre1,test_pre2,test_pre3)

print('Mean_pre MAE:',metrics.mean_absolute_error(y_test_true, Mean_pre))

Mean_pre MAE: 0.0666666666667

## 定義結果的加權平均函數

def Median_method(test_pre1,test_pre2,test_pre3):

    Median_result = pd.concat([pd.Series(test_pre1),pd.Series(test_pre2),pd.Series(test_pre3)],axis=1).median(axis=1)

    return Median_result

Median_pre = Median_method(test_pre1,test_pre2,test_pre3)

print('Median_pre MAE:',metrics.mean_absolute_error(y_test_true, Median_pre))

Median_pre MAE: 0.075

2） Stacking融合(迴歸)：

from sklearn import linear_model

def Stacking_method(train_reg1,train_reg2,train_reg3,y_train_true,test_pre1,test_pre2,test_pre3,model_L2= linear_model.LinearRegression()):

    model_L2.fit(pd.concat([pd.Series(train_reg1),pd.Series(train_reg2),pd.Series(train_reg3)],axis=1).values,y_train_true)

    Stacking_result = model_L2.predict(pd.concat([pd.Series(test_pre1),pd.Series(test_pre2),pd.Series(test_pre3)],axis=1).values)

    return Stacking_result

## 生成一些簡單的樣本數據，test_prei 代表第i個模型的預測值

train_reg1 = [3.2, 8.2, 9.1, 5.2]

train_reg2 = [2.9, 8.1, 9.0, 4.9]

train_reg3 = [3.1, 7.9, 9.2, 5.0]

# y_test_true 代表第模型的真實值

y_train_true = [3, 8, 9, 5]

test_pre1 = [1.2, 3.2, 2.1, 6.2]

test_pre2 = [0.9, 3.1, 2.0, 5.9]

test_pre3 = [1.1, 2.9, 2.2, 6.0]

# y_test_true 代表第模型的真實值

y_test_true = [1, 3, 2, 6]

model_L2= linear_model.LinearRegression()

Stacking_pre = Stacking_method(train_reg1,train_reg2,train_reg3,y_train_true,

                               test_pre1,test_pre2,test_pre3,model_L2)

print('Stacking_pre MAE:',metrics.mean_absolute_error(y_test_true, Stacking_pre))

Stacking_pre MAE: 0.0421348314607

可以發現模型結果相對於之前有進一步的提升，這是我們需要注意的一點是，對於第二層Stacking的模型不宜選取的過於複雜，這樣會導致模型在訓練集上過擬合，從而使得在測試集上並不能達到很好的效果。

5.4.2 分類模型融合：

對於分類，同樣的可以使用融合方法，比如簡單投票，Stacking...

from sklearn.datasets import make_blobs

from sklearn import datasets

from sklearn.tree import DecisionTreeClassifier

import numpy as np

from sklearn.ensemble import RandomForestClassifier

from sklearn.ensemble import VotingClassifier

from xgboost import XGBClassifier

from sklearn.linear_model import LogisticRegression

from sklearn.svm import SVC

from sklearn.model_selection import train_test_split

from sklearn.datasets import make_moons

from sklearn.metrics import accuracy_score,roc_auc_score

from sklearn.model_selection import cross_val_score

from sklearn.model_selection import StratifiedKFold

1）Voting投票機制：

Voting即投票機制，分爲軟投票和硬投票兩種，其原理採用少數服從多數的思想。

'''

硬投票：對多個模型直接進行投票，不區分模型結果的相對重要度，最終投票數最多的類爲最終被預測的類。

'''

iris = datasets.load_iris()

x=iris.data

y=iris.target

x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.3)

clf1 = XGBClassifier(learning_rate=0.1, n_estimators=150, max_depth=3, min_child_weight=2, subsample=0.7,

                     colsample_bytree=0.6, objective='binary:logistic')

clf2 = RandomForestClassifier(n_estimators=50, max_depth=1, min_samples_split=4,

                              min_samples_leaf=63,oob_score=True)

clf3 = SVC(C=0.1)

# 硬投票

eclf = VotingClassifier(estimators=[('xgb', clf1), ('rf', clf2), ('svc', clf3)], voting='hard')

for clf, label in zip([clf1, clf2, clf3, eclf], ['XGBBoosting', 'Random Forest', 'SVM', 'Ensemble']):

    scores = cross_val_score(clf, x, y, cv=5, scoring='accuracy')

    print("Accuracy: %0.2f (+/- %0.2f) [%s]" % (scores.mean(), scores.std(), label))

Accuracy: 0.97 (+/- 0.02) [XGBBoosting]
Accuracy: 0.33 (+/- 0.00) [Random Forest]
Accuracy: 0.95 (+/- 0.03) [SVM]
Accuracy: 0.94 (+/- 0.04) [Ensemble]

'''

軟投票：和硬投票原理相同，增加了設置權重的功能，可以爲不同模型設置不同權重，進而區別模型不同的重要度。

'''

x=iris.data

y=iris.target

x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.3)

clf1 = XGBClassifier(learning_rate=0.1, n_estimators=150, max_depth=3, min_child_weight=2, subsample=0.8,

                     colsample_bytree=0.8, objective='binary:logistic')

clf2 = RandomForestClassifier(n_estimators=50, max_depth=1, min_samples_split=4,

                              min_samples_leaf=63,oob_score=True)

clf3 = SVC(C=0.1, probability=True)

# 軟投票

eclf = VotingClassifier(estimators=[('xgb', clf1), ('rf', clf2), ('svc', clf3)], voting='soft', weights=[2, 1, 1])

clf1.fit(x_train, y_train)

for clf, label in zip([clf1, clf2, clf3, eclf], ['XGBBoosting', 'Random Forest', 'SVM', 'Ensemble']):

    scores = cross_val_score(clf, x, y, cv=5, scoring='accuracy')

    print("Accuracy: %0.2f (+/- %0.2f) [%s]" % (scores.mean(), scores.std(), label))

Accuracy: 0.96 (+/- 0.02) [XGBBoosting]
Accuracy: 0.33 (+/- 0.00) [Random Forest]
Accuracy: 0.95 (+/- 0.03) [SVM]
Accuracy: 0.96 (+/- 0.02) [Ensemble]

2）分類的Stacking\Blending融合：

stacking是一種分層模型集成框架。

以兩層爲例，第一層由多個基學習器組成，其輸入爲原始訓練集，第二層的模型則是以第一層基學習器的輸出作爲訓練集進行再訓練，從而得到完整的stacking模型, stacking兩層模型都使用了全部的訓練數據。

'''

5-Fold Stacking

'''

from sklearn.ensemble import RandomForestClassifier

from sklearn.ensemble import ExtraTreesClassifier,GradientBoostingClassifier

import pandas as pd

#創建訓練的數據集

data_0 = iris.data

data = data_0[:100,:]

target_0 = iris.target

target = target_0[:100]

#模型融合中使用到的各個單模型

clfs = [LogisticRegression(solver='lbfgs'),

        RandomForestClassifier(n_estimators=5, n_jobs=-1, criterion='gini'),

        ExtraTreesClassifier(n_estimators=5, n_jobs=-1, criterion='gini'),

        ExtraTreesClassifier(n_estimators=5, n_jobs=-1, criterion='entropy'),

        GradientBoostingClassifier(learning_rate=0.05, subsample=0.5, max_depth=6, n_estimators=5)]

#切分一部分數據作爲測試集

X, X_predict, y, y_predict = train_test_split(data, target, test_size=0.3, random_state=2020)

dataset_blend_train = np.zeros((X.shape[0], len(clfs)))

dataset_blend_test = np.zeros((X_predict.shape[0], len(clfs)))

#5折stacking

n_splits = 5

skf = StratifiedKFold(n_splits)

skf = skf.split(X, y)

for j, clf in enumerate(clfs):

    #依次訓練各個單模型

    dataset_blend_test_j = np.zeros((X_predict.shape[0], 5))

    for i, (train, test) in enumerate(skf):

        #5-Fold交叉訓練，使用第i個部分作爲預測，剩餘的部分來訓練模型，獲得其預測的輸出作爲第i部分的新特徵。

        X_train, y_train, X_test, y_test = X[train], y[train], X[test], y[test]

        clf.fit(X_train, y_train)

        y_submission = clf.predict_proba(X_test)[:, 1]

        dataset_blend_train[test, j] = y_submission

        dataset_blend_test_j[:, i] = clf.predict_proba(X_predict)[:, 1]

    #對於測試集，直接用這k個模型的預測值均值作爲新的特徵。

    dataset_blend_test[:, j] = dataset_blend_test_j.mean(1)

    print("val auc Score: %f" % roc_auc_score(y_predict, dataset_blend_test[:, j]))

clf = LogisticRegression(solver='lbfgs')

clf.fit(dataset_blend_train, y)

y_submission = clf.predict_proba(dataset_blend_test)[:, 1]

print("Val auc Score of Stacking: %f" % (roc_auc_score(y_predict, y_submission)))

val auc Score: 1.000000
val auc Score: 0.500000
val auc Score: 0.500000
val auc Score: 0.500000
val auc Score: 0.500000
Val auc Score of Stacking: 1.000000

Blending，其實和Stacking是一種類似的多層模型融合的形式

其主要思路是把原始的訓練集先分成兩部分，比如70%的數據作爲新的訓練集，剩下30%的數據作爲測試集。

在第一層，我們在這70%的數據上訓練多個模型，然後去預測那30%數據的label，同時也預測test集的label。

在第二層，我們就直接用這30%數據在第一層預測的結果做爲新特徵繼續訓練，然後用test集第一層預測的label做特徵，用第二層訓練的模型做進一步預測

其優點在於：

1.比stacking簡單（因爲不用進行k次的交叉驗證來獲得stacker feature）
2.避開了一個信息泄露問題：generlizers和stacker使用了不一樣的數據集

缺點在於：

1.使用了很少的數據（第二階段的blender只使用training set10%的量）
2.blender可能會過擬合
3.stacking使用多次的交叉驗證會比較穩健 '''

'''

Blending

'''

#創建訓練的數據集

#創建訓練的數據集

data_0 = iris.data

data = data_0[:100,:]

target_0 = iris.target

target = target_0[:100]

#模型融合中使用到的各個單模型

clfs = [LogisticRegression(solver='lbfgs'),

        RandomForestClassifier(n_estimators=5, n_jobs=-1, criterion='gini'),

        RandomForestClassifier(n_estimators=5, n_jobs=-1, criterion='entropy'),

        ExtraTreesClassifier(n_estimators=5, n_jobs=-1, criterion='gini'),

        #ExtraTreesClassifier(n_estimators=5, n_jobs=-1, criterion='entropy'),

        GradientBoostingClassifier(learning_rate=0.05, subsample=0.5, max_depth=6, n_estimators=5)]

#切分一部分數據作爲測試集

X, X_predict, y, y_predict = train_test_split(data, target, test_size=0.3, random_state=2020)

#切分訓練數據集爲d1,d2兩部分

X_d1, X_d2, y_d1, y_d2 = train_test_split(X, y, test_size=0.5, random_state=2020)

dataset_d1 = np.zeros((X_d2.shape[0], len(clfs)))

dataset_d2 = np.zeros((X_predict.shape[0], len(clfs)))

for j, clf in enumerate(clfs):

    #依次訓練各個單模型

    clf.fit(X_d1, y_d1)

    y_submission = clf.predict_proba(X_d2)[:, 1]

    dataset_d1[:, j] = y_submission

    #對於測試集，直接用這k個模型的預測值作爲新的特徵。

    dataset_d2[:, j] = clf.predict_proba(X_predict)[:, 1]

    print("val auc Score: %f" % roc_auc_score(y_predict, dataset_d2[:, j]))

#融合使用的模型

clf = GradientBoostingClassifier(learning_rate=0.02, subsample=0.5, max_depth=6, n_estimators=30)

clf.fit(dataset_d1, y_d2)

y_submission = clf.predict_proba(dataset_d2)[:, 1]

print("Val auc Score of Blending: %f" % (roc_auc_score(y_predict, y_submission)))

val auc Score: 1.000000
val auc Score: 1.000000
val auc Score: 1.000000
val auc Score: 1.000000
val auc Score: 1.000000
Val auc Score of Blending: 1.000000

參考博客：https://blog.csdn.net/Noob_daniel/article/details/76087829

3）分類的Stacking融合(利用mlxtend)：

!pip install mlxtend

import warnings

warnings.filterwarnings('ignore')

import itertools

import numpy as np

import seaborn as sns

import matplotlib.pyplot as plt

import matplotlib.gridspec as gridspec

from sklearn import datasets

from sklearn.linear_model import LogisticRegression

from sklearn.neighbors import KNeighborsClassifier

from sklearn.naive_bayes import GaussianNB

from sklearn.ensemble import RandomForestClassifier

from mlxtend.classifier import StackingClassifier

from sklearn.model_selection import cross_val_score

from mlxtend.plotting import plot_learning_curves

from mlxtend.plotting import plot_decision_regions

# 以python自帶的鳶尾花數據集爲例

iris = datasets.load_iris()

X, y = iris.data[:, 1:3], iris.target

clf1 = KNeighborsClassifier(n_neighbors=1)

clf2 = RandomForestClassifier(random_state=1)

clf3 = GaussianNB()

lr = LogisticRegression()

sclf = StackingClassifier(classifiers=[clf1, clf2, clf3],

                          meta_classifier=lr)

label = ['KNN', 'Random Forest', 'Naive Bayes', 'Stacking Classifier']

clf_list = [clf1, clf2, clf3, sclf]

fig = plt.figure(figsize=(10,8))

gs = gridspec.GridSpec(2, 2)

grid = itertools.product([0,1],repeat=2)

clf_cv_mean = []

clf_cv_std = []

for clf, label, grd in zip(clf_list, label, grid):

    scores = cross_val_score(clf, X, y, cv=3, scoring='accuracy')

    print("Accuracy: %.2f (+/- %.2f) [%s]" %(scores.mean(), scores.std(), label))

    clf_cv_mean.append(scores.mean())

    clf_cv_std.append(scores.std())

    clf.fit(X, y)

    ax = plt.subplot(gs[grd[0], grd[1]])

    fig = plot_decision_regions(X=X, y=y, clf=clf)

    plt.title(label)

plt.show()

可以發現基模型用 'KNN', 'Random Forest', 'Naive Bayes' 然後再這基礎上次級模型加一個 'LogisticRegression'，模型測試效果有着很好的提升。

零基礎入門數據挖掘 task5

Datawhale 零基礎入門數據挖掘-Task5 模型融合

五、模型融合

5.1 模型融合目標

5.2 內容介紹

5.3 Stacking相關理論介紹

5.4 代碼示例

5.4.1 迴歸\分類概率-融合：

5.4.2 分類模型融合：

vue項目獲取富文本編輯器wangEditor內容導出爲word（html轉word格式並下載）

dotnet C# 創建 X11 應用時設置窗口背景顏色

TDengine docker安裝方法

vue3組件通信與props

sapui5

Alpine Linux apk add DNS lookup error

部分JDK版本的發佈時間

工作中用到的腳本合集

合併代碼時Beyond Compare設置

go語言 defer延遲機制

PARL 強化學習框架學習

零基礎入門數據挖掘 task5

零基礎入門數據分析 task3

[Aha]鏢局運鏢

零基礎入門數據挖掘 task4

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結