import numpy as np  
import pandas as pd  
import matplotlib.pyplot as plt  
import seaborn as sns  

plt.rcParams['font.family'] = 'SimHei'  
plt.rcParams['axes.unicode_minus'] = False  

# 正态分布  
data1 = np.around(np.random.normal(10, 3, 600)).reshape(-1, 1)  

# 左偏  
t1 = np.random.randint(1, 21, size=100)  
t2 = np.random.randint(21, 31, size=500)  
left_data = np.concatenate([t1, t2]).reshape(-1, 1)  

# 右偏  
t3 = np.random.randint(1, 11, size=500)  
t4 = np.random.randint(11, 21, size=100)  
right_data = np.concatenate([t3, t4]).reshape(-1, 1)  

# 类别  
type_data = np.random.randint(0, 2, size=600).reshape(-1, 1)  

data = np.concatenate([data1, left_data, right_data, type_data], axis=1)  
data = pd.DataFrame(data,  
                   columns=['data1', 'left_data', 'right_data', 'type_data'])  
# 随机取 10 条数据  
data.sample(10)  

frequency = data['type_data'].value_counts()  
frequency 

percentage = frequency * 100 / len(data)  
percentage  

mean = data['data1'].mean()  
median = data['data1'].median()  
mode = data['data1'].mode()  
print(f'均值:{mean} 中位数:{median}\n众数:\n{mode}')  

x = np.arange(0, 9)  
n = len(x)  

index1 = (n - 1) * 0.25  
index2 = (n - 1) * 0.5    
index3 = (n - 1) * 0.75    

index = np.array([index1, index2, index3]).astype(np.int32)  
x[index]  

x = np.arange(0, 10)  
n = len(x)  

index1 = (n - 1) * 0.25  
index2 = (n - 1) * 0.5    
index3 = (n - 1) * 0.75    

index = np.array([index1, index2, index3])  
left = np.floor(index).astype(np.int32)  
right = np.ceil(index).astype(np.int32)  
weight, _ = np.modf(index) # 获取 index 整数和小数部分  

result = x[left] * (1 - weight) + x[right] * weight  
result  

np.quantile(x, q=[0.25, 0.5, 0.75]), np.percentile(x, q=[25, 50, 75])  

s = pd.Series(x)  
s.describe()  

s.describe().iloc[4:7]  

s.describe(percentiles=[0.15, 0.4, 0.8])  

sub = np.ptp(data['left_data'])  
var = data['left_data'].var()  
std = data['left_data'].std()  
sub, var, std  

plt.figure(figsize=(11, 1))  
plt.ylim(-0.5, 1.5)  
plt.plot(data['data1'], np.zeros(len(data)), ls='', marker='o', color='r', label='data1')  
plt.plot(data['left_data'], np.ones(len(data)), ls='', marker='o', color='g', label='left_data')  
plt.axvline(data['data1'].mean(), ls='--', color='r', label='data1均值')  
plt.axvline(data['left_data'].mean(), ls='--', color='g', label='left_data均值')  
plt.legend()  
plt.show()  

print('偏度:', data['data1'].skew(), data['left_data'].skew(), data['right_data'].skew())  
print('峰度:', data['data1'].kurt(), data['left_data'].kurt(), data['right_data'].kurt())  
print('标准差:', data['data1'].std(), data['left_data'].std(), data['right_data'].std())  

sns.kdeplot(data['data1'], shade=True, label='正态')  
sns.kdeplot(data['left_data'], shade=True, label='左偏')  
sns.kdeplot(data['right_data'], shade=True, label='右偏')  
plt.show()  

import numpy as np  
import pandas as pd  
import matplotlib.pyplot as plt  
import seaborn as sns  

plt.rcParams['font.family'] = 'SimHei'  
plt.rcParams['axes.unicode_minus'] = False  

# 定义非正态分布总体(也可以是正态分布)  
data = np.random.normal(20, 5, size=10000)  
data.sort()  
all_ = np.random.choice(data[0:8000], size=10000)  
# sns.displot(all_)  

# 将总体的均值和标准差设为已知条件  
print('总体均值:', all_.mean(), '总体标准差:', all_.std())  

# 创建存放每次抽样的平均值的数组(初始值为 0)  
mean_arr = np.zeros(1000)  

# 循环抽取 1000 个样本, 每次抽 100 个  
for i in range(len(mean_arr)):  
    mean_arr[i] = np.random.choice(all_, size=100, replace=False).mean()  

# 验证结果  
print('样本均值:', mean_arr[1], '样本均值的均值:', mean_arr.mean(),   
      '标准误差:', mean_arr.std(), '偏度:', pd.Series(mean_arr).skew(), sep='\n')  

sns.displot(mean_arr, kde=True)  
plt.show() 

# 定义标准差  
scale = 10  

# 定义数据  
x = np.random.normal(0, scale, size=100000)  

# 计算  
for times in range(1, 4):  
    y = x[(x > -times * scale) & (x < times * scale)]  
    print(f'{times}倍的标准差:')  
    print(f'{len(y) * 100 / len(x)}%')  

# 随机生成总体均值, 其值未知  
mean = np.random.randint(0, 10000)  

# 总体的标准差已知为 50  
std = 50  

# 定义总体数据  
all_ = np.random.normal(mean, std, size=100000)  

# 从总体抽取 100 个元素构成样本  
sample = np.random.choice(all_, size=100, replace=False)  

# 计算样本均值  
sample_mean = sample.mean()  
print('样本均值:', sample_mean)  

# 计算样本的标准误差  
se = std / np.sqrt(n)  

# 计算置信区间 95%置信度  
min_ = sample_mean - 1.96 * se  
max_ = sample_mean + 1.96 * se  
print('置信区间(95%置信度):', (min_, max_))  

# 区间估计  
print(f'总体均值有 95% 的概率在{(min_, max_)}区间内')  
print('总体均值:', mean)  

# 绘图辅助  
plt.plot(mean, 0, marker='*', color='orange', ms=12, label='总体均值')  
plt.plot(sample_mean, 0, marker='o', color='r', label='样本均值')  
plt.hlines(0, xmin=min_, xmax=max_, color='b', label='置信区间')  
plt.axvline(min_, 0.4, 0.6, color='r', ls='--', label='左边界')  
plt.axvline(max_, 0.4, 0.6, color='g', ls='--', label='右边界')  
plt.legend()  
plt.show()  

import numpy as np  
from scipy import stats  

# 样本已知  
a = np.array([0.497, 0.506, 0.518, 0.524, 0.498, 0.511, 0.520, 0.515, 0.512])  

# 总体均值和标准差已知  
mean, std = 0.5, 0.015  

# 计算样本均值  
sample_mean = a.mean()  

# 计算样本标准误差  
se = std / np.sqrt(len(a))  

# 计算 Z统计量  
Z = (sample_mean - mean) / se  
print('Z统计量:', Z)  

# 计算 P值, 双边检验: Z值与其右边曲线围成的面积的 2 倍  
P = 2 * stats.norm.sf(abs(Z))  

print('P值:' , P)  

# 样本已知  
a = np.array([0.497, 0.506, 0.518, 0.524, 0.498, 0.511, 0.520, 0.515, 0.512])  

# 假设的总体均值已知  
mean = 0.5  

# 计算样本均值  
sample_mean = a.mean()  

# 计算样本标准差  
std = a.std()  

# 计算 t统计量  
t = (sample_mean - mean) / ( std / np.sqrt(len(a)))  
print('t统计量:', t)  

# 计算 P值, df 是自由度: 样本变量可自由取值的个数  
P = 2 * stats.t.sf(abs(t), df=len(a) - 1)  
print('P值:', P)  

from scipy import stats
stats.ttest_1samp(a, 0.5)  

# t统计量上述已经计算, 只需计算 P值: t统计量与其左边曲线围成的面积  
P = stats.t.cdf(t, df=len(a) - 1)  
print('P值:', P)  

# 计算 P值: t统计量与其右边曲线围成的面积  
P = stats.t.sf(t, df=len(a) - 1)  
print('P值:', P)  

import numpy as np  

# 导入用于线性回归的类  
from sklearn.linear_model import LinearRegression  

# 切分训练集与测试集的模块  
from sklearn.model_selection import train_test_split  

# 鸢尾花数据集  
from sklearn.datasets import load_iris  

# 设置输出数据的精度为 2 (默认是8)  
np.set_printoptions(precision=2)  

# 获取花瓣长度 x, 宽度 y  
iris = load_iris()  
x, y = iris.data[:, 2].reshape(-1, 1), iris.data[:, 3]  

# 将数据拆分为训练集和测试集, 指定测试集占比 test_size  
# 指定随机种子 random_state(可以任意值但必须确定), 锁定拆分行为  
x_train, x_test, y_train, y_test = train_test_split(  
    x, y, test_size=0.25, random_state=5)  

# 使用训练集训练模型  
lr = LinearRegression()  
lr.fit(x_train, y_train)  

# 求得模型参数  
print('权重 w:', lr.coef_, '截距 b:', lr.intercept_)  

# 调用模型进行预测  
y_hat = lr.predict(x_test)  

# 结果可视化  
import matplotlib.pyplot as plt  

plt.rcParams['font.family'] = 'SimHei'  
plt.rcParams['axes.unicode_minus'] = False  
plt.rcParams['font.size'] = 10  

plt.scatter(x_train, y_train, c='orange', label='训练集')  
plt.scatter(x_test, y_test, c='g', marker='D', label='测试集')  
plt.plot(x, lr.predict(x), 'r-')  
plt.legend()  
plt.xlabel('花瓣长度')  
plt.ylabel('花瓣宽度')  
plt.show()  

# 模型评估  
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score  

print('MSE:', mean_squared_error(y_test, y_hat))  
print('RMSE:', np.sqrt(mean_squared_error(y_test, y_hat)))  
print('MAE:', mean_absolute_error(y_test, y_hat))  
print('训练集R²:', r2_score(y_train, lr.predict(x_train))) # 可换成 lr.score(x_train, y_train)  
print('测试集R²:', r2_score(y_test, y_hat)) # 可换成 lr.score(x_test, y_test)  

import numpy as np  
from sklearn.linear_model import LinearRegression  
from sklearn.model_selection import train_test_split  
from sklearn.datasets import load_boston  
import pandas as pd  

boston = load_boston()  
x, y = boston.data, boston.target  
df = pd.DataFrame(np.concatenate([x, y.reshape(-1, 1)], axis=1),   
                 columns=boston.feature_names.tolist() + ['MEDV'])  
# 部分数据  
df.head(3)  

x_train, x_test, y_train, y_test = train_test_split(  
    x, y, test_size=0.25, random_state=5)  
lr = LinearRegression()  
lr.fit(x_train, y_train)  
print('权重:', lr.coef_)  
print('截距:', lr.intercept_)  
y_hat = lr.predict(x_test)  
print('训练集R²:', lr.score(x_train, y_train))  
print('测试集R²:', lr.score(x_test, y_test))   

# 假如获取了一间房屋的数据, 预测其房价  
room_data = np.array([0.00732, 17.0, 1.31, 1.0, 0.638, 7.575, 62.2, 5.0900,  
                      1.0, 296.0, 15.3, 396.90, 4.98]).reshape(1, -1)  
y_price = lr.predict(room_data)  
print('房屋价格:', y_price)  

from sklearn.linear_model import LogisticRegression  
from sklearn.model_selection import train_test_split  
from sklearn.datasets import load_iris  
import warnings  

warnings.filterwarnings('ignore')  

iris = load_iris()  
x, y = iris.data, iris.target  

# 鸢尾花数据集有 3 个类别, 4 个特性, 取两个类别, 两个特性  
x = x[y!=0, 2:]  
y = y[y!=0]  

# 拆分训练集与测试集  
x_train, x_test, y_train, y_test = train_test_split(x, y,  
        test_size=0.25, random_state=2)  

# 训练分类模型  
lr = LogisticRegression()  
lr.fit(x_train, y_train)  

# 测试  
y_hat = lr.predict(x_test)  
print('权重:', lr.coef_)  
print('偏置:', lr.intercept_)  
print('真实值:', y_test)  
print('预测值:', y_hat)  

# 样本的真实类别可视化  
import matplotlib.pyplot as plt  
plt.rcParams['font.family'] = 'SimHei'  

# 取出两种鸢尾花的特征  
c1 = x[y==1]  
c2 = x[y==2]  

# 绘制样本分布  
plt.scatter(x=c1[:, 0], y=c1[:, 1], c='g', label='类别1')  
plt.scatter(x=c2[:, 0], y=c2[:, 1], c='r', label='类别2')  
plt.xlabel('花瓣长度')  
plt.ylabel('花瓣宽度')  
plt.title('鸢尾花样本分布')  
plt.legend()  
plt.show()  

# 将预测类别和真实类别可视化对比  
plt.figure(figsize=(6, 2.2))  
plt.plot(y_test, marker='o', ls='', ms=10, c='r', label='真实类别')  
plt.plot(y_hat, marker='x', ls='', ms=10, c='g', label='预测类别')  
plt.xlabel('样本序号')  
plt.ylabel('类别')  
plt.title('预测结果')  
plt.legend()  
plt.show()  

# 因预测样本所属类别时, 通过比较概率得到结果,   
# 我们可将结果对应的概率可视化  
import numpy as np  

# 获取预测的概率值  
probability = lr.predict_proba(x_test)  
print('概率:', probability[:5], sep='\n')  

index = np.arange(len(x_test))  
pro_0 = probability[:, 0]  
pro_1 = probability[:, 1]  

# 设置预测结果标签, 对和错  
tick_label = np.where(y_test==y_hat, '对', '错')  

# 绘制堆叠图  
plt.figure(figsize=(8, 2))  
plt.bar(index, height=pro_0, color='g', label='类别1的概率')  
plt.bar(index, height=pro_1, color='r', bottom=pro_0,  
        label='类别2的概率', tick_label=tick_label)  
plt.xlabel('预测结果')  
plt.ylabel('各类别的概率')  
plt.title('分类概率')  
plt.legend()  
plt.show() 

# 绘制决策边界  
# 决策边界: 不同类别的分界线  
from matplotlib.colors import ListedColormap  

# 定义绘制函数  
def plot_decision_boundary(model, x, y):  
    color = ['r', 'g', 'b']  
    marker = ['o', 'v', 'x']  
    class_label = np.unique(y)  
    cmap = ListedColormap(color[:len(class_label)])  
    x1_min, x2_min = np.min(x, axis=0)  
    x1_max, x2_max = np.max(x, axis=0)  
    x1 = np.arange(x1_min - 1, x1_max + 1, 0.02)  
    x2 = np.arange(x2_min - 1, x2_max + 1, 0.02)  
    x1, x2 = np.meshgrid(x1, x2)  
    z = model.predict(np.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape)  

    plt.contourf(x1, x2, z, cmap=cmap, alpha=0.5)  
    for i, class_ in enumerate(class_label):  
        plt.scatter(x=x[y==class_, 0], y=x[y==class_, 1],  
                c=cmap.colors[i], label=class_, marker=marker[i])  
    plt.legend()  
    plt.show()  

# 绘制模型在训练集上的决策边界  
plot_decision_boundary(lr, x_train, y_train)  

iris = load_iris()  
x, y = iris.data, iris.target  
x = x[:, 2:]  
x_train, x_test, y_train, y_test = train_test_split(x, y,   
        test_size=0.25, random_state=2)  
lr = LogisticRegression()  
lr.fit(x_train, y_train)  

# 测试分类  
y_hat = lr.predict(x_test)  

# 可视化结果  
plt.rcParams['axes.unicode_minus']=False  
plot_decision_boundary(lr, x_test, y_test)  

import numpy as np  
from sklearn.datasets import load_iris  
from sklearn.linear_model import LogisticRegression   
from sklearn.model_selection import train_test_split  
from sklearn.metrics import confusion_matrix  
import matplotlib.pyplot as plt  
import warnings  

plt.rcParams["font.family"] = "SimHei"  
plt.rcParams["axes.unicode_minus"] = False   
plt.rcParams["font.size"] = 12   
warnings.filterwarnings("ignore")  

iris = load_iris()  
x, y = iris.data, iris.target  
x = x[y!=0, 2:]  
y = y[y!=0]  
x_train, x_test, y_train, y_test = train_test_split(x, y,  
                        test_size=0.25, random_state=2)  
lr = LogisticRegression()  
lr.fit(x_train, y_train)  
y_hat = lr.predict(x_test)  

# 传入真实值与预测值, 创建混淆矩阵  
matrix = confusion_matrix(y_true=y_test, y_pred=y_hat)  
print(matrix)  
y_hat[y_hat==1].sum()  

# 将混淆矩阵可视化  
mat = plt.matshow(matrix, cmap=plt.cm.Blues, alpha=0.5)  
label = ["负例", "正例"]  

# 获取当前的绘图对象  
ax = plt.gca()  

# 设置属性, 设类别 1 为负例  
ax.set(  
    xticks=np.arange(matrix.shape[1]),   
    yticks=np.arange(matrix.shape[0]),  
    xticklabels=label,   
    yticklabels=label,   
    title="混淆矩阵可视化\n",   
    ylabel="真实值",   
    xlabel="预测值")  

# 设置统计值的位置  
for i in range(matrix.shape[0]):  
    for j in range(matrix.shape[1]):  
        plt.text(x=j, y=i, s=matrix[i, j], va="center", ha="center")   

plt.show()  

# 计算各个评估指标  
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score  

print("正确率：", accuracy_score(y_test, y_hat))  

# 默认以 1 为正例, 我们将 2 设为正例  
print("精准率：", precision_score(y_test, y_hat, pos_label=2))  
print("召回率：", recall_score(y_test, y_hat, pos_label=2))  
print("F1：", f1_score(y_test, y_hat, pos_label=2))  

# 也可以用逻辑回归模型对象的score方法计算正确率   
print("score方法计算正确率：", lr.score(x_test, y_test))  

# 还可以用 classification_report 方法直接计算各个指标  
from sklearn.metrics import classification_report  
print(classification_report(y_true=y_test, y_pred=y_hat))  

# 绘制 ROC曲线 和计算 AUC  
from sklearn.metrics import roc_curve, auc, roc_auc_score  

iris = load_iris()  
x, y = iris.data, iris.target  
x = x[y!=0, 2:]  
y = y[y!=0]  
x_train, x_test, y_train, y_test = train_test_split(x, y,  
                            test_size=0.25, random_state=2)  

# 设置模型参数(有默认值可以不设), 并进行训练  
# 不同的参数训练结果不一样, 需要注意参数之间关系  
lr = LogisticRegression(multi_class="ovr", solver="liblinear")  
# lr = LogisticRegression(multi_class="multinomial")  
lr.fit(x_train, y_train)  

# 获取样本的概率  
probo = lr.predict_proba(x_test)  
print('类别 2 的概率:', probo[:, 1][:5])  

# 将概率值传入 roc_curve 方法, 从概率中选择若干个值作为阈值  
# 同时根据阈值判定正负例, 返回 fpr, tpr 和 阈值 thresholds  
fpr, tpr, thresholds = roc_curve(y_true=y_test,  
                       y_score=probo[:, 1], pos_label=2)  

# 阈值中的第一个值是第二个值 +1 得到, 为了让让曲线过 0 点  
print('阈值:', thresholds)  

# 计算 AUC   
print('用auc计算:', auc(fpr, tpr))  
print('用roc_auc_score计算:', roc_auc_score(y_true=y_test,  
                                    y_score=probo[:, 1]))  

# 绘制 ROC 曲线  
plt.figure(figsize=(6, 2))  
plt.plot(fpr, tpr, marker="o", label="ROC曲线")  
plt.plot([0,1], [0,1], lw=2, ls="--", label="随机猜测")   
plt.plot([0, 0, 1], [0, 1, 1], lw=2, ls="-.", label="完美预测")   
plt.xlim(-0.01, 1.02)  
plt.ylim(-0.01, 1.02)  
plt.xticks(np.arange(0, 1.1, 0.2))  
plt.yticks(np.arange(0, 1.1, 0.2))  
plt.xlabel("FPR")  
plt.ylabel("TPR")  
plt.grid()  
plt.title(f"ROC曲线, AUC值为:{auc(fpr, tpr):.2f}")  
plt.legend()  
plt.show()  

from sklearn.model_selection import train_test_split  
from sklearn.neighbors import KNeighborsClassifier  
from sklearn.metrics import classification_report  
from sklearn.datasets import load_iris  
from sklearn.preprocessing import StandardScaler  
from sklearn.linear_model import LogisticRegression  
import matplotlib as mpl  
import matplotlib.pyplot as plt  
import warnings  
warnings.filterwarnings("ignore")  
import numpy as np  

mpl.rcParams["font.family"] = "SimHei"  
mpl.rcParams["axes.unicode_minus"] = False  

iris = load_iris()  
X = iris.data[:, :2]  
y = iris.target  
X_train, X_test, y_train, y_test = train_test_split(X, y,   
                        test_size=0.25, random_state=0)  

# 数据标准化: StandardScaler 均值标准差标准化, MinMaxScaler 最大最小值标准化  
ss = StandardScaler()  
X_train = ss.fit_transform(X_train)  
X_test = ss.transform(X_test)  

# 逻辑回归训练  
lr = LogisticRegression()  
lr.fit(X_train,y_train)  

# KNN 训练  
# n_neighbors: 邻居的数量  
# weights：权重计算方式, 可选值为 uniform 统一权重, 与 distance 加权权重  
knn = KNeighborsClassifier(n_neighbors=3, weights="uniform")  
knn.fit(X_train, y_train)  

# 比较 AUC  
from sklearn.metrics import roc_curve, auc,roc_auc_score  

lr_fpr, lr_tpr, lr_thresholds = roc_curve(y_test,  
                lr.predict_proba(X_test)[:,1], pos_label=1)  
lr_auc = auc(lr_fpr, lr_tpr)  
print('Logistic 算法: AUC = %.3f' % lr_auc)  

knn_fpr, knn_tpr, knn_thresholds = roc_curve(y_test,  
                knn.predict_proba(X_test)[:,1], pos_label=1)  
knn_auc = auc(knn_fpr, knn_tpr)  
print('KNN 算法: AUC = %.3f' % knn_auc) 

# 将 KNN 算法参数进行调优再来比较  
from sklearn.model_selection import GridSearchCV  

# K 值取 1~10, 并定义需要的参数组合  
knn = KNeighborsClassifier()  
grid = {'n_neighbors': range(1,11,1), 'weights': ['uniform','distance']}  

# 网格搜索交叉验证  
# param_grid：需要检验的超参数组合  
# scoring：模型评估标准, accuracy 正确率  
# n_jobs：并发数量  
# cv：交叉验证折数  
# verbose：输出冗余信息  
gs = GridSearchCV(estimator=knn, param_grid=grid, scoring='accuracy',  
                  n_jobs=-1, cv=5, verbose=0)  
gs.fit(X_train, y_train)  
gs_fpr, gs_tpr, gs_thresholds = roc_curve(y_test,  
                gs.predict_proba(X_test)[:,1], pos_label=1)  
gs_auc = auc(gs_fpr, gs_tpr)  
print('KNN 算法: AUC = %.3f' % gs_auc) 

from sklearn.datasets import load_boston  
from sklearn.neighbors import KNeighborsRegressor   
from sklearn.linear_model import LinearRegression  

X, y = load_boston(return_X_y=True)  
X_train, X_test, y_train, y_test = train_test_split(X, y,  
                        test_size=0.25, random_state=0)  
knn = KNeighborsRegressor(n_neighbors=3, weights="distance")   
knn.fit(X_train, y_train)  
print("KNN 算法 R²：", knn.score(X_test, y_test))  
lr = LinearRegression()  
lr.fit(X_train, y_train)  
print("线性回归算法 R²：", lr.score(X_test, y_test))  

# 对 KNN 数据标准化和参数调优之后再来比较  
knn = KNeighborsRegressor()  
grid = {'n_neighbors': range(1,11,1), 'weights': ['uniform','distance']}  
gs = GridSearchCV(estimator=knn, param_grid=grid, scoring='r2',  
                  n_jobs=-1, cv=5, verbose=0)   

# 利用流水线处理  
from sklearn.pipeline import Pipeline  

# 定义流水线的步骤: 类型为一个列表, 列表中的每个元素是元组类型  
# 格式为：[(步骤名1，评估器1), (步骤名2， 评估器2), ……, (步骤名n, 评估器n)  
knn_steps = [("scaler", StandardScaler()), ("knn", gs)]  
knn_p = Pipeline(knn_steps)  

# 可以设置流水线的参数. 所有可用的参数可以通过 get_params 获取  
# 设置格式如下: (步骤名__参数)  
# p.set_params(knn__n_neighbors=3, knn__weights="uniform")  
knn_p.fit(X_train, y_train)  
print("KNN 算法 R²：", knn_p.score(X_test, y_test))  

# 线性回归数据标准化  
lr_steps = [("scaler", StandardScaler()), ("lr", LinearRegression())]  
lr_p = Pipeline(lr_steps)  
lr_p.fit(X_train, y_train)  
print("线性回归算法 R²：", lr_p.score(X_test, y_test))  

import numpy as np  
import pandas as pd  
from sklearn.naive_bayes import GaussianNB  

np.random.seed(0)  
x = np.random.randint(0, 10, size=(8, 3))  
y = np.array([0, 1, 0, 0, 0, 1, 1, 1])  
data = pd.DataFrame(np.concatenate([x, y.reshape(-1, 1)], axis=1),  
                   columns=['x1', 'x2', 'x3', 'y'])  
display(data[:3])  

gnb = GaussianNB()  
gnb.fit(x, y)  

print('类别标签:', gnb.classes_)  
print('每个类别的先验概率:', gnb.class_prior_)  
print('样本数量:', gnb.class_count_)  
print('每个类别下特征的均值:', gnb.theta_)  
print('每个类别下特征的方差:', gnb.sigma_)  

# 测试集  
x_test = np.array([[5, 7, 2]])  
print('预测结果:', gnb.predict(x_test))  
print('预测结果概率:', gnb.predict_proba(x_test))  

from sklearn.naive_bayes import BernoulliNB  

np.random.seed(0)  
x = np.random.randint(-5, 5, size=(8, 3))  
y = np.array([0, 1, 0, 0, 0, 1, 1, 1])  
data = pd.DataFrame(np.concatenate([x, y.reshape(-1, 1)], axis=1),  
                   columns=['x1', 'x2', 'x3', 'y'])  
display(data[:3])  

bnb = BernoulliNB()  
bnb.fit(x, y)  

# 统计每个类别下, 特征中二值化后, 每个特征下值 1 出现的次数  
print('值 1 出现的次数:', bnb.feature_count_)  

# 每个类别的先验概率, 算法得到的该概率值是取对数后的结果,  
# 需要取指数还原  
print('每个类别的先验概率:', np.exp(bnb.class_log_prior_))  

# 每个类别下, 每个特征的概率(也需要取指数还原)  
print('每个特征的概率:', np.exp(bnb.feature_log_prob_))  

# 测试集  
x_test = np.array([[-5, 0, 2]])  
print('预测结果:', bnb.predict(x_test))  
print('预测结果概率:', bnb.predict_proba(x_test))  

from sklearn.naive_bayes import MultinomialNB  

np.random.seed(0)  
x = np.random.randint(1, 5, size=(8, 3))  
y = np.array([0, 1, 0, 0, 0, 1, 1, 1])  
data = pd.DataFrame(np.concatenate([x, y.reshape(-1, 1)], axis=1),  
                   columns=['x1', 'x2', 'x3', 'y'])  
display(data[:3])  

mnb = MultinomialNB()  
mnb.fit(x, y)  

# 每个类别的样本数量  
print('每个类别的样本数:', mnb.class_count_)  

# 每个特征在每个类别下发生(出现)的次数  
print('每个特征发生(出现)次数:', mnb.feature_count_)  

# 每个类别下, 每个特征的概率(需要取指数还原)  
print('每个类别下特征的概率:', np.exp(mnb.feature_log_prob_))  

# 测试集  
x_test = np.array([[1, 1, 4]])  
print('预测结果:', mnb.predict(x_test))  
print('预测结果概率:', mnb.predict_proba(x_test))  

from sklearn.datasets import load_iris  
from sklearn.model_selection import train_test_split  

x, y = load_iris(return_X_y=True)  
x_train, x_test, y_train, y_test = train_test_split(x, y,  
                        test_size=0.25, random_state=0)  
models = [('高斯朴素贝叶斯分值:', GaussianNB()),  
          ('伯努利朴素贝叶斯分值:', BernoulliNB()),  
          ('多项式朴素贝叶斯分值:', MultinomialNB())]  
for name, m in models:  
    m.fit(x_train, y_train)  
    print(name, m.score(x_test, y_test))  

import numpy as np  
import matplotlib.pyplot as plt  

plt.rcParams['font.family'] = 'SimHei'  
plt.rcParams['font.size'] = 14  

# 下雨的概率  
p = np.linspace(0.01, 0.99, 100)  

# 信息熵  
h = -p * np.log2(p) - (1-p) * np.log2(1-p)  

# 绘制关系图  
plt.plot(p, h)  
plt.xlabel('概率分布')  
plt.ylabel('信息熵')  
plt.title('概率分布和信息熵关系图')  
plt.show()  

from sklearn.datasets import load_iris  
from sklearn.model_selection import train_test_split  
from sklearn.tree import DecisionTreeClassifier  

x, y = load_iris(return_X_y=True)  
x = x[:, :2]  
x_train, x_test, y_train, y_test = train_test_split(  
    x, y, test_size=0.25, random_state=0)  
'''  
参数介绍:  
criterion: 不纯度度量标准, 默认基尼系数 gini, 信息熵为 entropy  
splitter: 选择划分节点的方式, 默认最好 best, 随机 random  
max_depth: 划分深度, 默认 None 不设限  
min_samples_split: 划分节点的最小样本数, 默认 2  
min_samples_leaf: 划分节点后, 叶子节点的最少样本数, 默认 1  
max_features: 划分节点时, 考虑的最大特征数, 默认 None 考虑所有, 设置数量后会随机选择  
random_state: 随机种子, 控制模型的随机行为  
'''  
tree = DecisionTreeClassifier()  

# 定义列表, 用来储存不同深度下, 模型的分值  
train_score = []  
test_score = []  

# 设置深度 1~12 开始训练  
for depth in range(1, 13):  
    tree = DecisionTreeClassifier(criterion='entropy',  
                    max_depth=depth, random_state=0)  
    tree.fit(x_train, y_train) 

 

    train_score.append(tree.score(x_train, y_train))  
    test_score.append(tree.score(x_test, y_test))  

plt.plot(train_score, label='训练集分值')  
plt.plot(test_score, label='测试集分值')  
plt.xlabel('划分深度')  
plt.ylabel('分值')  
plt.legend()  
plt.show() 

def entropy(p):  
    return -p * np.log2(p) - (1-p) * np.log2(1-p)  

def gini(p):  
    return 1 - p**2 - (1-p)**2  

def error(p):  
    return 1 - np.max([p, 1-p], axis=0)  

p = np.linspace(0.0001, 0.9999, 200)  

en = entropy(p)  
er = error(p)  
g = gini(p)  

for i, lab, ls in zip([en, g, er],  
                      ['信息熵', '基尼系数', '错误率'],  
                      ['-', ':', '--']):  
    plt.plot(p, i, label=lab, linestyle=ls, lw=2)  

plt.legend()  
plt.xlabel('概率分布')  
plt.ylabel('不纯度')  
plt.show()  

en = lambda p: np.sum(-p * np.log2(p))  

a1 = np.array([0.3, 0.7])  
a2 = np.array([0.3, 0.3, 0.4])  
a3 = np.array([0.25] * 4)  
a4 = np.array([0.1] * 10)  

print(en(a1), en(a2), en(a3), en(a4), sep='\n')  

from sklearn.datasets import load_boston  
from sklearn.tree import DecisionTreeRegressor  
from sklearn.model_selection import train_test_split  

x, y = load_boston(return_X_y=True)  
x_train, x_test, y_train, y_test = train_test_split(  
            x, y, test_size=0.25, random_state=1)  

tree = DecisionTreeRegressor(max_depth=5, random_state=0)  
tree.fit(x_train, y_train)  
print(tree.score(x_train, y_train))  
print(tree.score(x_test, y_test))  

import numpy as np  
from sklearn.cluster import KMeans  
from sklearn.datasets import make_blobs  
import matplotlib.pyplot as plt  

plt.rcParams['font.family'] = 'Microsoft YaHei'   
plt.rcParams['font.size'] = 12   
plt.rcParams['axes.unicode_minus'] = False   

'''  
生成数据:  
n_samples: 样本数量  
n_features: 特征数  
centers: 聚类中心  
cluster_std: 簇的标准差, 可以统一指定, 也分别指定  
'''  
centers = [[1, 1], [5, 2], [2, 5]]  
x, y = make_blobs(n_samples=90,  
                  n_features=2,  
                  centers=centers,  
                  cluster_std=[2.2, 2.5, 2],  
                  random_state=0)  
# x 是特征, y 是类别标签  

# 绘制原始数据  
plt.figure(figsize=(12,8))  
plt.subplot(221)  
colors = np.array(['Coral', 'SeaGreen', 'RoyalBlue'])  
plt.scatter(x[:, 0], x[:, 1], c=colors[y], marker='.', label='原始数据')  
plt.title('原始数据')  

# 定义绘制聚类结果的函数  
def plot_cluster(model, train, test=None):  
    global colors  # 使用上面的颜色  
    cc = model.cluster_centers_ # 获取质心  
    label = model.labels_ # 获取聚类结果的标签  
    # 绘制质心  
    plt.scatter(cc[:, 0], # 质心的 x 坐标  
                cc[:, 1], # 质心的 y 坐标  
                marker='*',  
                s=150,  
                c=colors)  
    # 绘制训练集  
    plt.scatter(train[:, 0], train[:, 1], marker='.', c=colors[label])  
    # 绘制测试集  
    if test is not None:  
        y_hat = model.predict(test)  
        plt.scatter(test[:, 0], test[:, 1], marker='+',  
                    s=150, c=colors[y_hat])          
    # 标题  
    plt.title(f'SSE:{model.inertia_:.1f} 迭代次数:{model.n_iter_}')  

# 测试集  
test = np.array([[6, 5]])      
# 绘制不同初始质心的聚类结果  
seed = [1, 10, 100]  
for i in range(2, 5):  
    plt.subplot(2, 2, i)  
    kmeans = KMeans(n_clusters=3, # 簇数  
                    init='random', # 初始化方式  
                    n_init=1, # 初始化质心组数  
                    random_state=seed[i-2])  
    kmeans.fit(x)  
    plot_cluster(kmeans, x)  
    # 测试结果  
    plot_cluster(kmeans, x, test)  

kmeans = KMeans(n_clusters=3, init='k-means++', n_init=1)  
kmeans.fit(x)  
plot_cluster(kmeans, x)  

# 设置列表储存 SSE  
sse = []  
# K 值从 1~9 变化  
scope = range(1, 10)  
for k in scope:  
    kmeans = KMeans(n_clusters=k)  
    kmeans.fit(x)  
    sse.append(kmeans.inertia_)  

plt.xticks(scope)  
plt.plot(scope, sse, marker='o')  
plt.show()  

import time  
import pandas as pd  
from sklearn.cluster import MiniBatchKMeans  
from sklearn.metrics.pairwise import pairwise_distances_argmin  

import warnings
warnings.filterwarnings('ignore')

# 生成数据  
centers = [[1, 1], [400, 100], [100, 400]]  
x, y = make_blobs(n_samples=8000, n_features=2, centers=centers,  
                  cluster_std=120, random_state=0)  

# 定义函数, 用于计算模型训练时间  
def elapsed_time(model, data):  
    start = time.time()  
    model.fit(data)  
    end = time.time()  
    return end - start  

n_clusters = len(centers)  
kmeans = KMeans(n_clusters=n_clusters)  
mbk = MiniBatchKMeans(n_clusters=n_clusters,  
                      batch_size=200, # 小批量的大小  
                     n_init=10 # 和 KMeans 统一为 10  
                     )  
kmeans_time = elapsed_time(kmeans, x)  
mbk_time = elapsed_time(mbk, x)  

print('K-Means耗时:', kmeans_time)  
print('Mini Batch K-Means耗时:', mbk_time)  

# 绘制聚类效果  
plt.figure(figsize=(12, 5))  
model = [kmeans, mbk]  
for i, m in enumerate(model, start=1):  
    plt.subplot(1, 2, i)  
    plot_cluster(m, x)  

plt.figure(figsize=(12, 5))  
# 定义列表, 用来保存两个模型预测结果  
y_hat_list = []  
for i, m in enumerate(model, start=1):  
    plt.subplot(1, 2, i)  
    y_hat = m.predict(x)  
    if m == mbk:  
        '''  
        因为输出的质心顺序就是训练结果标签的顺序  
        故可以按 mbk 训练的质心, 去找 kmeans 训练的相同簇的质心  

        pairwise_distances_argmin(x, y) 解释:  
        依次取出数组 X 中的元素 x,   
        计算找到数组 Y 中与 x 距离最近的元素 y 的索引,   
        返回索引构成的数组  
        '''  
        # 将两者相同簇的质心一一对应并按 mbk 质心的顺序封装成字典  
        ar = pairwise_distances_argmin(  
        mbk.cluster_centers_, kmeans.cluster_centers_)  
        dict_ = dict(enumerate(ar))  
        # 用 mbk 的训练结果标签 y_hat 就可以寻找到对应的 kmeans 的质心  
        y_hat = pd.Series(y_hat).map(dict_).values  
    # 将预测结果加入到列表中  
    y_hat_list.append(y_hat)  

    plt.scatter(x[:, 0], x[:, 1], c=colors[y_hat], marker='.')  

same = y_hat_list[0] == y_hat_list[1]  
diff = y_hat_list[0] != y_hat_list[1]  
plt.scatter(x[same, 0], x[same, 1], c='g', marker='.', label='预测相同')  
plt.scatter(x[diff, 0], x[diff, 1], c='r', marker='.', label='预测不同')  
plt.legend()  
print('相同数量:', x[same].shape[0])  
print('不同数量:', x[diff].shape[0])