---

如果你工作在推薦、搜索領域，我強烈你學習、掌握FM演算法。我不敢說它是最簡單的（FM的確很簡單），但是作為一個推薦演算法調參工程師，掌握FM一定是性價比最高的。我推崇FM演算法的原因，有以下三點。

功能齊全

眾所周知，推薦演算法有三個應用領域：召回、粗排、精排。推薦演算法千千萬，但是有的演算法只能用於召回，有的演算法只能用於排序。像FM這樣實現三個領域全覆蓋的多面手，目前為止，孤陋寡聞的我尚不知道有第二個。

但是需要強調的是，我們不能只訓練一個FM排序模型 ，然後直接拿這個排序模型用於召回。儘管都是基於FM演算法，但是FM召回與排序，有以下不同：

• 使用的特徵不同。
• FM召回，由於未來要依賴Faiss進行線上檢索，所以不能使用user與doc的交叉特徵。只有如此，我們才能獨立計算user embedding與doc embedding
• FM排序，則沒有這方面的限制，可以使用user與doc的交叉特徵。是的，你沒看錯。因為FM所實現自動二階交叉，僅能代表「共現」。但是user與doc之間還有其他形式的交叉，比如user tag與doc tag之間的重合度，喂入這樣的交叉，對於排序性能提升，仍然有很大幫助。

• 使用的樣本不同。
• 訓練FM做排序時，必須使用「曝光未點擊」這樣的「真負」樣本。
• 訓練FM做召回時，起碼不能只使用「曝光未點擊」做負樣本。大部分的負樣本必須通過隨機採樣得到。箇中原因見我的文章《負樣本為王：評Facebook的向量化召回演算法》。
• 使用的Loss不同
• FM排序時，由於負樣本是真實的，可以採用CTR預估那樣的point-wise loss
• FM召回時，由於負樣本是隨機採樣得到的，存在一定的雜訊，最好採用BPR, hinge這樣的pair-wise loss。

性能優異

推薦系統的兩大永恆主題，「記憶」與「擴展」，FM也能實現全覆蓋。

• FM存在一階項，實際就是LR，能夠「記憶」高頻、常見模式
• FM存在feature embedding。如我在《無中生有：論推薦演算法中的Embedding思想》據說，Embedding是提升推薦演算法「擴展性」的法寶。FM通過feature embedding，能夠自動挖掘低頻、長尾模式。在這一點上，基於embedding的二階交叉，並不比DNN的高階交叉，遜色多少。

便於上線

現在深度學習是推薦領域的寵兒，LR/FM/GBDT這樣的傳統機器學習演算法，不招人待見。

DNN雖然性能優異，但是它有一個致命缺點，就是上線困難。訓練的時候，各位調參俠，把各種酷炫的結構，什麼attention, transformer, capsule，能加上的都給它加上，看著離線指標一路上漲，心裡和臉上都樂開了花，卻全然無視旁邊的後端工程師恨得咬緊了牙根。模型越複雜，離線和線上指標未必就更好，但是線上的時間開銷肯定會增加，輕則影響演算法與後端的同事關係（打工人何苦為難打工人），重則你那離線指標完美的模型壓根沒有上線的機會。雖說，目前已經有TF Serving這樣的線上serving框架，但是它也不是開箱即用的，也需要一系列的性能調優，才能滿足線上的實時性要求。

所以，如果你身處一個小團隊，後端工程人員的技術能力不強，DNN的線上實時預測，就會成為一個難題，這個時候，FM這樣的傳統機器學習演算法，就凸顯出其優勢。

• FM排序，雖然理論上需要所有特徵進行二階交叉，但是通過公式化簡，可以在 O(n)的時間複雜度下完成。n是樣本中非零的特徵數目，由於推薦系統中的特徵非常稀疏，所以預測速度是非常快的。
• 召回，由於候選集巨大，對於實時性的要求更高。很多基於DNN的召回演算法，由於無法滿足線上實時生成user embedding的需求，只能退而離線生成user embedding ，對於用戶實時興趣的捕捉大打折扣。FM召回，這時就顯現其巨大的優勢。事先把doc embedding計算好，存入Faiss建立索引，user embedding只需要把一系列的feature embedding相加就可以得到，再去faiss中進行top-k近鄰搜索。FM召回，可以實現基於用戶最新的實時興趣，從千萬量級候選doc中完成實時召回。

總結與參考

由於以上優點，我心目中，將FM視為推薦、搜索領域的"瑞士軍刀"。風頭上雖然不及DNN那麼搶眼，但是論在推薦系統中發揮的作用，絲毫不比DNN遜色，有時還能更勝一籌。FM有如此眾多的優點，優秀的調參俠+打工人，還等什麼，還不趕快學起來。想迅速掌握FM，我推薦如下參考文獻：

• 掌握FM原理，推薦讀美團的博客《深入FFM原理與實踐》。FFM的部分可以忽略，在我看來，FFM更像是為了Kaggle專門訓練的比賽型選手，損失了FM的很多優點。這就好比，奧運會上的射擊冠軍，未必能夠勝任當狙擊手一樣。
• FM用於召回，推薦讀《推薦系統召回四模型之：全能的FM模型》。注意，如我所述，FM雖然萬能，但是FM排序與FM召回，在特徵、樣本、Loss都存在不同，不可能訓練一個FM排序就能直接拿來做召回。這一點，《全能FM》一文沒有提到，需要讀者特別注意。
• 如果想親手實踐，可以嘗試alphaFM。該項目只不過是作者八小時之外的課外作品，卻被很多公司拿來投入線上實際生產環境，足見該項目性能之優異和作者功力之深厚，令人佩服。強烈建議不滿足只當「調參俠」的同學，通讀一遍alphaFM的源代碼，一定收穫滿滿。

---

阿里工程師小姐姐分享9種常用的、較為簡單的機器學習演算法。

這裡給出解釋和實現，題主可以通過一些實際案例去進一步理解和熟悉演算法。ヾ(?°?°?)??

（點擊頭像關注我們，後續解鎖更多阿里工程師一線實戰分享）

————————————————————————————————————————————

一、簡介

根據機器學習的任務或應用情況的不同，我們通常把機器學習分為三大類：

（1）監督學習（Supervised Learning，SL）

這類演算法的工作原理是使用帶標籤的訓練數據來學習輸入變數X 轉化為輸出變數 Y 的映射函數，換句話說就是求解方程 Y=f(X) 中的 f 。

進一步地，監督學習又可細分為如下三類：

• 回歸（Regression）：預測一個值，如預測降雨量、房價等，較基礎的演算法有：Linear Regression
• 分類（Classification）：預測一個標籤，如預測「生病」或「健康」，圖片上是哪種動物等，較基礎的演算法有：Logistic Regression、Naive Bayes、K-Nearest Neighbors（KNN）

【另】：集成（Ensembling）也可以歸類為監督學習的一種，它將多個單獨較弱的機器學習模型的預測結合起來，以產生更準確的預測，較基礎的演算法有Bagging with Random Forests、Boosting with XGBoost

（2）非監督學習（Unsupervised Learning，UL）

這類演算法的工作原理是從無標籤的訓練數據中學習數據的底層結構。進一步地，非監督學習又可細分為如下三類：

• 關聯（Association）：發現集合中項目同時出現的概率，如通過分析超市購物籃，發現啤酒總是和尿片一起購買（啤酒與尿片的故事），較基礎的演算法有：Apriori
• 聚類（Clustering）：對數據進行分組，以便組內對象比組間對象更相似，較基礎的演算法有：K-Means
• 降維（Dimensionality Reduction）：減少數據集的變數數量，同時保證重要的信息不被丟失。降維可以通過特徵提取方法和特徵選擇方法來實現，特徵提取是執行從高維空間到低維空間的轉換，特徵選擇是選擇原始變數的子集，較基礎的演算法有：PCA

（3）強化學習（Reinforcement Learning，DL）

讓agent根據當前環境狀態，通過學習能夠獲得最大回報的行為來決定下一步的最佳行為。

二、實現

以上列出的演算法都是簡單常用的，基於scikit-learn可以僅用幾行代碼就完成模型訓練、預測、評估和可視化。

關於演算法的原理知乎上有很多精彩的回答，這裡不會贅述，僅給出代碼的實現與可視化。

（1）Linear Regression 它為變數 X 分配最佳權重，以創建一條直線或一個平面或更高維的超平面，使得預測值和真實值之間的誤差最小化。

具體原理參考：

化簡可得：用人話講明白線性回歸LinearRegression?

zhuanlan.zhihu.com

下面以一元線性回歸為例，給出代碼實現。

import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split

# Linear Regression 一元回歸
from sklearn import linear_model
from sklearn.metrics import mean_squared_error

# 1. 準備數據
lr_X_data, lr_y_data = datasets.make_regression(n_samples=500,n_features=1,n_targets=1,noise=2) # feature為1維度
# 2. 構造訓練與測試集
lr_X_train, lr_X_test, lr_y_train, lr_y_test = train_test_split(lr_X_data, lr_y_data, test_size=0.3)
# 3. 訓練模型
lr_model = linear_model.LinearRegression()
lr_model.fit(lr_X_train, lr_y_train)
# 4. 預測數據
lr_y_pred = lr_model.predict(lr_X_test)
# 5. 評估模型
lr_mse = mean_squared_error(lr_y_test, lr_y_pred)
print("mse:", lr_mse)
# 6. 可視化
plt.figure(Linear Regression)
plt.title(Linear Regression)
plt.scatter(lr_X_test, lr_y_test, color=lavender, marker=o)
plt.plot(lr_X_test, lr_y_pred, color=pink, linew=3)
plt.show()

# print info mse: 4.131366697554779

（2）Logistic Regression

雖然寫著回歸，但實際上是一種二分類演算法。它將數據擬合到logit函數中，所以稱為logit回歸。簡單來說就是基於一組給定的變數，用logistic function來預測這個事件的概率，給出一個介於0和1之間的輸出。

具體原理參考：

化簡可得：用人話講明白邏輯回歸Logistic regression?

zhuanlan.zhihu.com

下面給出代碼的實現。

import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split

# Logistic Regression 二分類
from sklearn import linear_model

# 1. 準備數據
np.random.seed(123)
logit_X_data = np.random.normal(size=1000)
logit_y_data = (logit_X_data&>0).astype(np.float)
logit_X_data[logit_X_data&>0]*=5
logit_X_data+=.4*np.random.normal(size=1000)
logit_X_data=logit_X_data[:,np.newaxis]
# 2. 構造訓練與測試集
logit_X_train, logit_X_test, logit_y_train, logit_y_test = train_test_split(logit_X_data, logit_y_data, test_size=0.3)
# 3. 訓練模型
logit_model=linear_model.LogisticRegression(C=1e4) #classifier
logit_model.fit(logit_X_train,logit_y_train)
# 4. 預測數據
logit_y_pred = logit_model.predict(logit_X_test)
# 5. 評估模型
logit_acc = logit_model.score(logit_X_test,logit_y_pred)
print("accuracy:", logit_acc)
# 5. 可視化
logit_X_view=np.linspace(-7,7,277)
logit_X_view = logit_X_view[:,np.newaxis]
def model(x):
return 1/(1+np.exp(-x))
loss=model(logit_X_view*logit_model.coef_+logit_model.intercept_).ravel()
plt.figure(Logistic Regression)
plt.title(Logistic Regression)
plt.scatter(logit_X_train.ravel(), logit_y_train, color=lavender,zorder=17)
plt.plot(logit_X_view, loss, color=pink,linew=3)

lr_model=linear_model.LinearRegression()
lr_model.fit(logit_X_train,logit_y_train)
plt.plot(logit_X_view, lr_model.predict(logit_X_view), color=blue, linew=3)
plt.legend((Logistic Regression,Linear Regression),loc=lower right,fontsize=small)

# print info accuracy: 1.0

（3）Naive Bayes

樸素貝葉斯是一種基於貝葉斯定理的分類方法，它會假設一個類中的某個特徵與其他特徵無關。這個模型不僅非常簡單，而且比許多高度複雜的分類方法表現得更好。

具體原理參考：

樸素貝葉斯演算法原理小結 - 劉建平Pinard - 博客園?

www.cnblogs.com

下面給出代碼的實現。

import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

# Naive Bayes 任務為分類, n_classes=4
import sklearn.naive_bayes as nb
# 1. 準備數據
nb_X_train, nb_y_train = make_classification(n_features=2, n_redundant=0, n_informative=2,
random_state=1, n_clusters_per_class=1, n_classes=4)
# 2. 構造訓練與測試集
l, r = nb_X_train[:, 0].min() - 1, nb_X_train[:, 0].max() + 1
b, t = nb_X_train[:, 1].min() - 1, nb_X_train[:, 1].max() + 1
n = 1000
grid_x, grid_y = np.meshgrid(np.linspace(l, r, n), np.linspace(b, t, n))
nb_X_test = np.column_stack((grid_x.ravel(), grid_y.ravel()))
# 3. 訓練模型
nb_model = nb.GaussianNB()
nb_model.fit(nb_X_train, nb_y_train)
# 4. 預測數據
nb_y_pred = nb_model.predict(nb_X_test)
# 5. 可視化
grid_z = nb_y_pred.reshape(grid_x.shape)
plt.figure(Naive Bayes)
plt.title(Naive Bayes)
plt.pcolormesh(grid_x, grid_y, grid_z, cmap=Blues)
plt.scatter(nb_X_train[:, 0], nb_X_train[:, 1], s=30, c=nb_y_train, cmap=pink)
plt.show()

（4）K-Nearest Neighbors

這是用於分類和回歸的機器學習演算法(主要用於分類)。它考慮了不同的質心，並使用歐幾里得函數來比較距離。接著分析結果並將每個點分類到組中，以優化它，使其與所有最接近的點一起放置。 它使用k個最近鄰的多數票對數據進行分類預測。

具體原來參考：

K近鄰法(KNN)原理小結 - 劉建平Pinard - 博客園?

www.cnblogs.com

下面給出代碼的實現。

import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

# K-Nearest Neighbors 任務為分類, n_classes=4
from sklearn.neighbors import KNeighborsClassifier
# 1. 準備數據
knn_X_train, knn_y_train = make_classification(n_features=2, n_redundant=0, n_informative=2,
random_state=1, n_clusters_per_class=1, n_classes=4)
# 2. 構造訓練與測試集
l, r = knn_X_train[:, 0].min() - 1, knn_X_train[:, 0].max() + 1
b, t = knn_X_train[:, 1].min() - 1, knn_X_train[:, 1].max() + 1
n = 1000
grid_x, grid_y = np.meshgrid(np.linspace(l, r, n), np.linspace(b, t, n))
knn_X_test = np.column_stack((grid_x.ravel(), grid_y.ravel()))
# 3. 訓練模型
knn_model = KNeighborsClassifier(n_neighbors=5)
knn_model.fit(knn_X_train, knn_y_train)
# 4. 預測數據
knn_y_pred = knn_model.predict(knn_X_test)
# 5. 可視化
grid_z = knn_y_pred.reshape(grid_x.shape)
plt.figure(K-Nearest Neighbors)
plt.title(K-Nearest Neighbors)
plt.pcolormesh(grid_x, grid_y, grid_z, cmap=Blues)
plt.scatter(knn_X_train[:, 0], knn_X_train[:, 1], s=30, c=knn_y_train, cmap=pink)
plt.show()

（5）Decision Tree

遍歷樹，並將重要特徵與確定的條件語句進行比較。它是降到左邊的子分支還是降到右邊的子分支取決於結果。

通常，更重要的特性更接近根，它可以處理離散變數和連續變數。

具體原理參考：

憶臻：深入淺出理解決策樹演算法（一）-核心思想?

zhuanlan.zhihu.com

下面給出代碼的實現。

import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

# Decision Tree
from sklearn.tree import DecisionTreeClassifier
# 1. 準備數據
dt_X_train, dt_y_train = make_classification(n_features=2, n_redundant=0, n_informative=2,
random_state=1, n_clusters_per_class=1, n_classes=4)
# 2. 構造訓練與測試集
l, r = dt_X_train[:, 0].min() - 1, dt_X_train[:, 0].max() + 1
b, t = dt_X_train[:, 1].min() - 1, dt_X_train[:, 1].max() + 1
n = 1000
grid_x, grid_y = np.meshgrid(np.linspace(l, r, n), np.linspace(b, t, n))
dt_X_test = np.column_stack((grid_x.ravel(), grid_y.ravel()))
# 3. 訓練模型
dt_model = DecisionTreeClassifier(max_depth=4)
dt_model.fit(dt_X_train, dt_y_train)
# 4. 預測數據
dt_y_pred = dt_model.predict(dt_X_test)
# 5. 可視化
grid_z = dt_y_pred.reshape(grid_x.shape)
plt.figure(Decision Tree)
plt.title(Decision Tree)
plt.pcolormesh(grid_x, grid_y, grid_z, cmap=Blues)
plt.scatter(dt_X_train[:, 0], dt_X_train[:, 1], s=30, c=dt_y_train, cmap=pink)
plt.show()

（6）Random Forest

隨機森林是決策樹的集合。隨機採樣數據點構造樹、隨機採樣特徵子集分割，每棵樹提供一個分類。得票最多的分類在森林中獲勝，為數據點的最終分類。

具體原來參考：

清華大學數據科學研究院：獨家 | 一文讀懂隨機森林的解釋和實現?

zhuanlan.zhihu.com

下面給出代碼的實現

import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

# Random Forest
from sklearn.ensemble import RandomForestClassifier
# 1. 準備數據
rf_X_train, rf_y_train = make_classification(n_features=2, n_redundant=0, n_informative=2,
random_state=1, n_clusters_per_class=1, n_classes=4)
# 2. 構造訓練與測試集
l, r = rf_X_train[:, 0].min() - 1, rf_X_train[:, 0].max() + 1
b, t = rf_X_train[:, 1].min() - 1, rf_X_train[:, 1].max() + 1
n = 1000
grid_x, grid_y = np.meshgrid(np.linspace(l, r, n), np.linspace(b, t, n))
rf_X_test = np.column_stack((grid_x.ravel(), grid_y.ravel()))
# 3. 訓練模型
rf_model = RandomForestClassifier(max_depth=4)
rf_model.fit(rf_X_train, rf_y_train)
# 4. 預測數據
rf_y_pred = rf_model.predict(rf_X_test)
# 5. 可視化
grid_z = rf_y_pred.reshape(grid_x.shape)
plt.figure(Random Forest)
plt.title(Random Forest)
plt.pcolormesh(grid_x, grid_y, grid_z, cmap=Blues)
plt.scatter(rf_X_train[:, 0], rf_X_train[:, 1], s=30, c=rf_y_train, cmap=pink)
plt.show()

（7）Support Vector Machines

它將數據映射為空間中的點，使得不同類別的點可以被儘可能寬的間隔分隔開，對於待預測類別的數據，先將其映射至同一空間，並根據它落在間隔的哪一側來得到對應的類別。

具體原來參考：

SMON：看了這篇文章你還不懂SVM你就來打我?

zhuanlan.zhihu.com

下面給出代碼實現。

import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

# SVM
from sklearn import svm
# 1. 準備數據
svm_X_train, svm_y_train = make_classification(n_features=2, n_redundant=0, n_informative=2,
random_state=1, n_clusters_per_class=1, n_classes=4)
# 2. 構造訓練與測試集
l, r = svm_X_train[:, 0].min() - 1, svm_X_train[:, 0].max() + 1
b, t = svm_X_train[:, 1].min() - 1,svm_X_train[:, 1].max() + 1
n = 1000
grid_x, grid_y = np.meshgrid(np.linspace(l, r, n), np.linspace(b, t, n))
svm_X_test = np.column_stack((grid_x.ravel(), grid_y.ravel()))
# 3. 訓練模型
# svm_model = RandomForestClassifier(max_depth=4)
svm_model = svm.SVC(kernel=rbf, gamma=1, C=0.0001).fit(svm_X_train, svm_y_train)
svm_model.fit(svm_X_train, svm_y_train)
# 4. 預測數據
svm_y_pred = svm_model.predict(svm_X_test)
# 5. 可視化
grid_z = svm_y_pred.reshape(grid_x.shape)
plt.figure(SVM)
plt.title(SVM)
plt.pcolormesh(grid_x, grid_y, grid_z, cmap=Blues)
plt.scatter(svm_X_train[:, 0], svm_X_train[:, 1], s=30, c=svm_y_train, cmap=pink)
plt.show()

（8）K-Means

將數據劃分到K個聚類簇中，使得每個數據點都屬於離它最近的均值（即聚類中心，centroid）對應的集聚類簇。

最終，具有較高相似度的數據對象劃分至同一類簇，將具有較高相異度的數據對象劃分至不同類簇。

具體原理參考：

化簡可得：用人話講明白快速聚類kmeans?

zhuanlan.zhihu.com

下面給出代碼的實現。

import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.datasets.samples_generator import make_blobs

# K-means 任務為聚類 n_classes=5
from sklearn.cluster import KMeans

# 1. 準備數據
kmeans_X_data, kmeans_y_data = make_blobs(n_samples=500, centers=5, cluster_std=0.60, random_state=0)
# 2. 訓練模型
kmeans_model = KMeans(n_clusters=5)
kmeans_model.fit(kmeans_X_data)
# 3. 預測模型
kmeans_y_pred = kmeans_model.predict(kmeans_X_data)
# 4. 可視化
plt.figure(K-Means)
plt.title(K-Means)
plt.scatter(kmeans_X_data[:,0], kmeans_X_data[:, 1], s=50)
plt.scatter(kmeans_X_data[:, 0], kmeans_X_data[:, 1], c=kmeans_y_pred, s=50, cmap=viridis)
centers = kmeans_model.cluster_centers_
plt.scatter(centers[:,0], centers[:, 1], c=red, s=80, marker=x)
plt.show()

（9）PCA

一種常用的降維技術，顧名思義，PCA幫助我們找出數據的主要成分，主成分基本上是線性不相關的向量，用選出的k個主成分來表示數據，來達到降維的目的。

具體原理參考：

如何通俗易懂地講解什麼是 PCA 主成分分析？?

www.zhihu.com

下面給出代碼實現

import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

# PCA
from sklearn.decomposition import PCA
from sklearn.datasets import load_iris

# 1. 準備數據
pca_data=load_iris()
pca_X_data=pca_data.data
pca_y_data=pca_data.target
# 2. 訓練模型, 維度為2
pca_model=PCA(n_components=2)
# 3. 降維
reduced_X=pca_model.fit_transform(pca_X_data)
# 4. 可視化
red_x,red_y=[],[]
blue_x,blue_y=[],[]
green_x,green_y=[],[]

for i in range(len(reduced_X)):
if pca_y_data[i] ==0:
red_x.append(reduced_X[i][0])
red_y.append(reduced_X[i][1])
elif pca_y_data[i]==1:
blue_x.append(reduced_X[i][0])
blue_y.append(reduced_X[i][1])
else:
green_x.append(reduced_X[i][0])
green_y.append(reduced_X[i][1])

plt.figure(PCA)
plt.title(PCA)
plt.scatter(red_x,red_y,c=r)
plt.scatter(blue_x,blue_y,c=b)
plt.scatter(green_x,green_y,c=g)
plt.show()

三、總結

至此，給出了常有的9種機器學習演算法的實現，題主可以通過一些實際案例去進一步理解和熟悉演算法。

另外，國外的Kaggle和阿里雲天池都是獲取項目經驗的好途徑。

個人學習建議，歡迎交流討論。關注我們賬號，持續分享機器學習相關的知識乾貨。

——————————————————————————————————————————

阿里巴巴集團淘系技術部官方賬號。淘系技術部是阿里巴巴新零售技術的王牌軍，支撐淘寶、天貓核心電商以及淘寶直播、閑魚、躺平、阿里汽車、阿里房產等創新業務，服務9億用戶，賦能各行業1000萬商家。我們打造了全球領先的線上新零售技術平台，並作為核心技術團隊保障了11次雙十一購物狂歡節的成功。

點擊下方主頁關注我們，你將收穫更多來自阿里一線工程師的技術實戰技巧成長經歷心得。另，不定期更新最新崗位招聘信息和簡歷內推通道，歡迎各位以最短路徑加入我們。

阿里巴巴淘系技術?

www.zhihu.com

---

邏輯回歸算是很簡單的了

而且解釋性很好

---

2007年論文《Top 10 Algorithms in Data Mining》給出數據挖掘10大演算法：

Top 10 Algorithms in Data Mining?

www.researchgate.net

• 1、C4.5
• 2、K-Means
• 3、SVM
• 4、Apriori
• 5、EM
• 6、PageRank
• 7、AdaBoost
• 8、kNN
• 9、Naive Bayes
• 10、CART

這些都是機器學習中較為簡單的演算法。

《機器學習實戰》這本書就是參考這篇論文寫的，該書基於Python手動實現了其中8個演算法（除了EM、PageRank），偏實戰，實效性差，建議有針對性參考。

機器學習實戰(圖靈出品)京東￥ 51.40去購買?

作者: Peter Harrington

原作名: Machine Learning in Action

這10大演算法雖然簡單，但是個人不推薦。因為：

（1）、這些演算法有點過時；

（2）、不夠實用，演算法工業級落地才有價值；

（3）、機器學習領域很大，演算法聚焦比較好。

所以個人認為機器學習中較為簡單的演算法：

• 推薦系統方向

LR、GBDT、FM

劉啟林：FM因子分解機的原理、公式推導、Python實現和應用?

zhuanlan.zhihu.com

• 自然語言處理方向：

HMM 、CRF

劉啟林：CRF條件隨機場的原理、例子、公式推導和應用?

zhuanlan.zhihu.com

• 數據挖掘方向：

K-Means、LSA、GBDT

劉啟林：GBDT的原理、公式推導、Python實現、可視化和應用?

zhuanlan.zhihu.com

結束語：

限於當前能力和水平，我的可能是錯的，或者不全面的。

一家之言，拋磚引玉，僅供參考。

---

在這裡列舉一些較為簡單的機器學習演算法。

1）k近鄰演算法

k近鄰演算法可能是最簡單的機器學習演算法。如下圖所示，尋找與測試樣本距離最接近的k個訓練樣本，例如k=5，大多數訓練樣本屬於哪個類別，就判定測試樣本屬於哪個類別。

2）多層感知機

多層感知機就是由一些層的神經元組成的，其思想來源於人類的神經系統。

3）卷積神經網路

當輸入數據是圖像這種高維數據的時候，卷積神經網路的參數量比較少，比較適合。

4）深度殘差網路

當卷積神經網路的層數過深時，就會難以訓練。這個時候，殘差網路通過加入跨層連接，降低了訓練難度。

5）殘差收縮網路

如果數據含有較強雜訊，殘差收縮網路（https://ieeexplore.ieee.org/abstract/document/8850096/）在殘差網路中加入了軟閾值化，能夠取得較好的效果。

---

推薦閱讀：