统计机器学习相关

什么是聚类算法

聚类的一般步骤

常用聚类算法有哪些、对应的度量函数分别是

聚类跟分类的本质区别

延伸考点

迭代过程

伪代码

input: 获取数据 n 个 m 维的数据
input: 随机生成 K 个 m 维的点
while(t)  // t 表示设置的终止条件，比如迭代次数
    for(int i=0;i < n;i++)  // 遍历每个元素
        for(int j=0;j < k;j++)  // 为每个元素计算其到 K 个聚类中心的距离
            计算点 i 到类 j 的距离
    for(int i=0;i < k;i++)  // 更新聚类中心点
        1. 找出所有属于自己这一类的所有数据点  // 通过选定的距离度量函数确定
        2. 把自己的坐标修改为这些数据点的中心点坐标
end

output: K 个 m 维的点（聚成了K类）

复杂度分析

k-means 迭代过程可视化

簇心随机不好，怎么才能更稳定

from sklearn.datasets import make_moons
X, y = make_moons(200, noise=.05, random_state=0)

labels = KMeans(2, random_state=0).fit_predict(X)
plt.scatter(X[:, 0], X[:, 1], c=labels,  s=50, cmap='viridis')

from sklearn.cluster import SpectralClustering
model = SpectralClustering(n_clusters=2, affinity='nearest_neighbors', assign_labels='kmeans')
labels = model.fit_predict(X)
plt.scatter(X[:, 0], X[:, 1], c=labels, s=50, cmap='viridis')

延伸考点

确定聚类初始点的个数

distortions = []
K = range(1,10)
# 遍历所有可能的聚类中心点数
for k in K:
    kmeanModel = KMeans(n_clusters=k)
    kmeanModel.fit(df)
    distortions.append(kmeanModel.inertia_)  # 统计在该点数下的 loss 大小

plt.figure(figsize=(16,8))
plt.plot(K, distortions, 'bx-')
plt.xlabel('k')
plt.ylabel('Distortion')
plt.title('The Elbow Method showing the optimal k')
plt.show()

确定聚类初始点的位置

延伸考点

K-Means是无监督学习的聚类算法，没有样本输出；而KNN是监督学习的分类算法，有对应的类别输出。

当然，两者也有一些相似点，两个算法都包含一个过程，即找出和某一个点最近的点。两者都利用了最近邻(nearest neighbors)的思想。

公式推导

代码示例

import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
import seaborn as sns
sns.set()

# 生成示例数据
from sklearn.datasets import make_blobs
X, y = make_blobs(n_samples=50, centers=2,
                  random_state=0, cluster_std=0.60)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
plt.show()

# 手动选择超平面
xfit = np.linspace(-1, 3.5)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')

for m, b, d in [(1, 0.65, 0.33), (0.5, 1.6, 0.55), (-0.2, 2.9, 0.2)]:
    yfit = m * xfit + b
    plt.plot(xfit, yfit, '-k')
    plt.fill_between(xfit, yfit - d, yfit + d, edgecolor='none',
                     color='#AAAAAA', alpha=0.4)

plt.xlim(-1, 3.5)
plt.show()

# 使用 svm 实现
from sklearn.svm import SVC # "Support vector classifier"
model = SVC(kernel='linear', C=1E10)
model.fit(X, y)

# 可视化
def plot_svc_decision_function(model, ax=None, plot_support=True):
    """绘制二维SVC的决策函数"""
    if ax is None:
        ax = plt.gca()
    xlim = ax.get_xlim()
    ylim = ax.get_ylim()

    x = np.linspace(xlim[0], xlim[1], 30)
    y = np.linspace(ylim[0], ylim[1], 30)
    Y, X = np.meshgrid(y, x)
    xy = np.vstack([X.ravel(), Y.ravel()]).T
    P = model.decision_function(xy).reshape(X.shape)

    # 绘制决策边界和边缘
    ax.contour(X, Y, P, colors='k',
               levels=[-1, 0, 1], alpha=0.5,
               linestyles=['--', '-', '--'])

    # 绘制支持向量
    if plot_support:
        ax.scatter(model.support_vectors_[:, 0],
                   model.support_vectors_[:, 1],
                   s=300, linewidth=1, facecolors='none');
    ax.set_xlim(xlim)
    ax.set_ylim(ylim)
    plt.show()


plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
plot_svc_decision_function(model)

延伸考点

决策树

随机森林

RF 代码示例

# 生成数据
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt
import numpy as np

X, y = make_blobs(n_samples=300, centers=4,
                  random_state=0, cluster_std=1.0)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='rainbow')
plt.show()

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import BaggingClassifier


def visualize_classifier(model, X, y, ax=None, cmap='rainbow'):
    ax = ax or plt.gca()

    # 绘制训练数据
    ax.scatter(X[:, 0], X[:, 1], c=y, s=30, cmap=cmap,
               clim=(y.min(), y.max()), zorder=3)
    ax.axis('tight')
    ax.axis('off')
    xlim = ax.get_xlim()
    ylim = ax.get_ylim()


    model.fit(X, y)
    xx, yy = np.meshgrid(np.linspace(*xlim, num=200),
                         np.linspace(*ylim, num=200))
    Z = model.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)

    # 绘制结果
    n_classes = len(np.unique(y))
    contours = ax.contourf(xx, yy, Z, alpha=0.3,
                           levels=np.arange(n_classes + 1) - 0.5,
                           cmap=cmap, clim=(y.min(), y.max()),
                           zorder=1)

    ax.set(xlim=xlim, ylim=ylim)
    plt.show()


tree = DecisionTreeClassifier()
bag = BaggingClassifier(tree, n_estimators=100, max_samples=0.8,
                        random_state=1)

bag.fit(X, y)
visualize_classifier(bag, X, y)

简单介绍下线性回归模型（LR）

from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt
import numpy as np

rng = np.random.RandomState(1)
x = 10 * rng.rand(50)
y = 2 * x - 5 + rng.randn(50)  # 添加噪声，模拟真实场景
plt.scatter(x, y)

model = LinearRegression(fit_intercept=True)
model.fit(x[:, np.newaxis], y)

xfit = np.linspace(0, 10, 1000)
yfit = model.predict(xfit[:, np.newaxis])

plt.scatter(x, y)
plt.plot(xfit, yfit)
plt.show()

LR 与 SVM的对比

延伸考点

代码示例

# 线性不可分的例子

# 样本生成
from sklearn.datasets import make_circles
X, y = make_circles(100, factor=.1, noise=.1)

clf = SVC(kernel='linear').fit(X, y)

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
plot_svc_decision_function(clf, plot_support=False)

# SVM
clf = SVC(kernel='rbf', C=1E6)
clf.fit(X, y)

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
plot_svc_decision_function(clf)
plt.scatter(clf.support_vectors_[:, 0], clf.support_vectors_[:, 1],
            s=300, lw=1, facecolors='none')

延伸考点

公式

Hinge loss 可视化

def hinge_loss(x):
    return np.maximum(0, 1 - x)

def plot_hinge_loss():
    x = np.arange(-5, 5, 0.1)
    y = hinge_loss(x)
    plt.plot(x, y, label="hinge loss")

    y2 = np.where(x>0, 0, 1)
    plt.plot(x, y2, label="0-1 loss")
    plt.legend()
    plt.title("nowcoder: offer+1")
    plt.show()


plot_hinge_loss()

延伸考点

原理

三元组选取

代码实现（pytorch 版本）

from torch import nn

class TripletLoss(nn.Module):
    """Triplet loss with hard positive/negative mining.
    
    Args:
        margin (float, optional): margin for triplet. Default is 0.3.
    """
    
    def __init__(self, margin=0.3, global_feat, labels):
        super(TripletLoss, self).__init__()
        self.margin = margin
        self.ranking_loss = nn.MarginRankingLoss(margin=margin)
    def forward(self, inputs, targets):
        """
        Args:
            inputs (torch.Tensor): feature matrix with shape (batch_size, feat_dim).
            targets (torch.LongTensor): ground truth labels with shape (num_classes).
        """
        n = inputs.size(0)
        
        # 计算 embeddings 之间的距离
        dist = torch.pow(inputs, 2).sum(dim=1, keepdim=True).expand(n, n)
        dist = dist + dist.t()
        dist.addmm_(1, -2, inputs, inputs.t())
        dist = dist.clamp(min=1e-12).sqrt()  # for numerical stability
        
        # 关键，三元组的选取：为每个 sample找到hardest positive and negative
        mask = targets.expand(n, n).eq(targets.expand(n, n).t())
        dist_ap, dist_an = [], []
        for i in range(n):
            dist_ap.append(dist[i][mask[i]].max().unsqueeze(0))
            dist_an.append(dist[i][mask[i] == 0].min().unsqueeze(0))
        dist_ap = torch.cat(dist_ap)
        dist_an = torch.cat(dist_an)
        
        # 计算 loss
        y = torch.ones_like(dist_an)
        return self.ranking_loss(dist_an, dist_ap, y)

延伸考点

平方误差损失 L2 loss

绝对误差损失 L1 loss

Smooth L1 Loss（Huber）

合页损失 Hinge loss

Hinge Loss 不仅会惩罚错误的预测，还会惩罚不自信的正确预测。

Hinge Loss 简化了 SVM 的数***算，同时最大化了损失（与 Log-Loss 相比）。当我们想要做出实时决策而不过于关注准确性时使用它。

二分类交叉熵损失函数Binary Cross Entropy Loss

多分类交叉熵损失函数Categorical Cross Entropy Loss

代码实现

from math import log
import matplotlib.pyplot as plt

import numpy as np


def L1_loss(predicted, actual):
    geterror = np.absolute(actual - predicted)
    totalloss = np.sum(geterror)
    return totalloss


def L2_loss(predicted, actual):
    geterror = np.absolute(actual - predicted)
    geterror = geterror ** 2
    totalloss = np.sum(geterror)
    return totalloss


def Mean_Squared_Error(predicted, actual):
    sum_square_error = 0.0
    for i in range(len(actual)):
        sum_square_error += (actual[i] - predicted[i]) ** 2.0
    mean_square_error = 1.0 / len(actual) * sum_square_error
    return mean_square_error
    
    
def smooth_l1_loss(predicted, actual, sigma, reduce=True, normalizer=1.0):
    beta = 1. / (sigma ** 2)
    diff = np.absolute(predicted - actual)
    cond = diff < beta
    loss = np.where(cond, 0.5 * diff ** 2 / beta, diff - 0.5 * beta)
    if reduce:
        return np.sum(loss) / normalizer
    return np.sum(loss, axis=1) / normalizer
    
    
def hinge_loss(predicted, actual):
    loss = np.maximum(0, 1 - predicted * actual)
    return loss
    
    
def Binary_Cross_Entropy(actual, predicted):
    sum_score = 0.0
    for i in range(len(actual)):
        sum_score += actual[i] * log(1e-15 + predicted[i])
    mean_sum_score = 1.0 / len(actual) * sum_score
    return -mean_sum_score



def Categorical_Cross_Entropy(actual, predicted):
    sum_score = 0.0
    for i in range(len(actual)):
        for j in range(len(actual[i])):
            sum_score += actual[i][j] * log(1e-15 + predicted[i][j])
    mean_sum_score = 1.0 / len(actual) * sum_score
    return -mean_sum_score

延伸考点

延伸考点

过拟合的定义

引起过拟合的原因

解决办法（很多）

数据上

模型上

训练方式上

示例代码

optimizer = torch.optim.SGD(model.parameters(),lr=0.01,weight_decay=0.001)
# weight_decay参数即调节 L2 正则化的超参数

# L1 正则化
regularization_loss = 0
for param in model.parameters():
    regularization_loss += torch.sum(abs(param))

calssify_loss = criterion(pred,target)
loss = classify_loss + lamda * regularization_loss

optimizer.zero_grad()
loss.backward()
optimizer.step()

# dropout 函数
torch.nn.Dropout(p=0.5) 
# 以 0.5的概率随机关闭神经元

延伸考点

首先解释偏差和方差

然后解释随机森林和 GDBT

GBDT(Gradient Boosting Decison Tree)

Random Forest

延伸考点

延伸考点

XGBoost 使用示例

# XGBoost 使用示例
import xgboost as xgb
from sklearn import metrics
from sklearn.model_selection import GridSearchCV

def auc(m, train, test): 
    return (metrics.roc_auc_score(y_train,m.predict_proba(train)[:,1]),
           metrics.roc_auc_score(y_test,m.predict_proba(test)[:,1]))

# xgb 分类器
model = xgb.XGBClassifier()
param_dist = {"max_depth": [10,30,50],
              "min_child_weight" : [1,3,6],
              "n_estimators": [200],
              "learning_rate": [0.05, 0.1,0.16],}
# 网格法搜索超参
grid_search = GridSearchCV(model, param_grid=param_dist, cv = 3, 
                                   verbose=10, n_jobs=-1)
grid_search.fit(train, y_train)

grid_search.best_estimator_

model = xgb.XGBClassifier(max_depth=50, min_child_weight=1,  n_estimators=200,                    n_jobs=-1 , verbose=1,learning_rate=0.16)
model.fit(train,y_train)

auc(model, train, test)

Light GBM 使用示例

# Light GBM 使用示例
import lightgbm as lgb
from sklearn import metrics
from sklearn.model_selection import GridSearchCV

def auc2(m, train, test): 
    return (metrics.roc_auc_score(y_train,m.predict(train)),
                            metrics.roc_auc_score(y_test,m.predict(test)))

# 定义 lgb 分类器
lg = lgb.LGBMClassifier(silent=False)
param_dist = {"max_depth": [25,50, 75],
              "learning_rate" : [0.01,0.05,0.1],
              "num_leaves": [300,900,1200],
              "n_estimators": [200]
             }
             
# 网格法搜索超参
grid_search = GridSearchCV(lg, n_jobs=-1, param_grid=param_dist, cv = 3, scoring="roc_auc", verbose=5)
grid_search.fit(train,y_train)
grid_search.best_estimator_

d_train = lgb.Dataset(train, label=y_train)
params = {"max_depth": 50, "learning_rate" : 0.1, "num_leaves": 900,  "n_estimators": 300}

model2 = lgb.train(params, d_train)
auc2(model2, train, test) 

延伸考点

代码实现

# 词频
def computeTF(wordDict, bagOfWords):
    tfDict = {}
    bagOfWordsCount = len(bagOfWords)
    for word, count in wordDict.items():
        tfDict[word] = count / float(bagOfWordsCount)
    return tfDict

# 逆文本频率
def computeIDF(documents):
    import math
    N = len(documents)
    
    idfDict = dict.fromkeys(documents[0].keys(), 0)
    for document in documents:
        for word, val in document.items():
            if val > 0:
                idfDict[word] += 1
    
    for word, val in idfDict.items():
        idfDict[word] = math.log(N / float(val))
    return idfDict
   
# TF-IDF
def computeTFIDF(tfBagOfWords, idfs):
    tfidf = {}
    for word, val in tfBagOfWords.items():
        tfidf[word] = val * idfs[word]
    return tfidf 

tfi-df 的理论

tf-idf 的不足

延伸考点

概念

特征选择

ID3 算法

C4.5 算法

CART（Classification and Regression Tree）

优缺点

代码实现

# sklearn 提供了各种经典决策树的接口
>>> from sklearn import tree
>>> X = [[0, 0], [1, 1]]
>>> Y = [0, 1]
>>> clf = tree.DecisionTreeClassifier()
>>> clf = clf.fit(X, Y)1

# 模型可以用来预测样本的类别:
>>> clf.predict([[2., 2.]])
array([1])
# 预测每个类的概率，在叶片上同一类的训练样本的分数
>>> clf.predict_proba([[2., 2.]])
array([[ 0.,  1.]])

延伸考点

决策树的实现逻辑

信息增益的公式

信息增益率的公式

logistics函数可视化代码

def sigmoid(x):
    return 1. / (1. + np.exp(-x))
def plot_sigmoid():
    x = np.arange(-10, 10, 0.1)
    y = sigmoid(x)
    plt.plot(x, y, label="sigmoid")
    plt.legend()
    plt.title("nowcoder: offer+1")
    plt.show()

plot_sigmoid()

优缺点

代码示例

from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
import numpy as np

def logisticRegression():
    data = ...
    X = data[:,0:-1]
    y = data[:,-1]

    # 划分为训练集和测试集
    x_train,x_test,y_train,y_test = train_test_split(X,y,test_size=0.2)

    # 归一化
    scaler = StandardScaler()
    # scaler.fit(x_train)
    x_train = scaler.fit_transform(x_train)
    x_test = scaler.fit_transform(x_test)

    # 逻辑回归
    model = LogisticRegression()
    model.fit(x_train,y_train)

    # 预测
    predict = model.predict(x_test)
    right = sum(predict == y_test)
    
    # 将预测值和真实值放在一块，好观察
    predict = np.hstack((predict.reshape(-1,1),y_test.reshape(-1,1)))   
    print(predict)

延伸考点

代码示例

# 使用方法与与分类一样
# fit方法将把向量X，y作为参数向量，
# 只是在这种情况下，只在 y 是浮点数而不是整数型
>>> from sklearn import svm
>>> X = [[0, 0], [2, 2]]
>>> y = [0.5, 2.5]
>>> regr = svm.SVR()
>>> regr.fit(X, y)
SVR()
>>> regr.predict([[1, 1]])
array([1.5])