一篇文章了解机器学习

一、软件版本安装

版本要求：python3.9 + scikit-learn 库

conde create -n python==3.9
pip install  scikit-learn  -i https://pypi.tuna.tsinghua.edu.cn/simple

二、数据集的加载

Scikit-learn官网：https://scikit-learn.org/stable/#
Scikit-learn中文文档：https://scikitlearn.com.cn/
sk_learn 库中具有一定的学习研究数据以及fetch数据。

import sklearn.datasets import load_iris  # 在数据库中加载本地数据
data = load_iris(return_X_y = True)   # 返回的文件自动分为x，y两部分
import sklearn.datasets import fetch_20newsgroups  # 采用网络中的数据进行下载
data = fetch_20newsgroups(data_home = './data',subset = 'all') # 对文件下载后的位置进行保存。同时规定文件下载为所有数据

三、数据集的切分

from sklearn.model_selection import trian_test_split
x_trian,x_test,y_train,y_test = train_test_split(x,y,random_stata = 1,train_size = 0.8)
# 对数据集划分的比例进行定义   模型默认进行数据的shuffle

四、数据特征提取及标准化

1、字典数据的特征提取

# 主要将字典类型的数据/datafram数据/文本数据转换为可计算的向量数据
from sklearn.feature_extraction import DictVectorizer
transfer = DictVectorizer(sparse=False)   # 对转换后的数据进行转换为混淆矩阵
##  三元组数据转换为混淆矩阵
data.toarray()  # 将三元组数据转换为混淆矩阵
# data数据类型
[[(1,0),155],
[(0,1),255]]
====>
[[255,0],[155,0]]
# 将文本数据转换为字典数据
data.to_dict(orient="records")   # 将数据转换为字典数据后进行矩阵数据的转换

2、文本特征向量的提取

（1）词频的计算

# 文本特征向量提取  == 英文状态的数据 按空格 作为分词符
from sklearn.feature_extraction.text import CountVectorizer
model =  CountVectorizer(stop_word = ['ins'])  # ins不计算向量
# 同时，该向量在词频的计算过程中会将一些默认的单词进行频闭

（2）中文词频的计算 == 在库中导入jieba分词器

pip install jieba
import jieba 
# 采用jieba分词器对中文文本进行切分
data= ['山东黄金就感觉大手笔就按书到了']
data = jieba.cut(data)  # 最终输出为切分好的列表

（3）TF—IDF计算

from sklearn.feature_extraction.text import TfidfVectorizer
model = TfidfVectorizer()
# 手动实现tf-idf
# 手动计算TF_IDF
def cut_word(text):
    return " ".join(jieba.cut(text))

data=["教育学会会长期间，坚定支持民办教育事业！",  "扶持民办,学校发展事业","事业做出重大贡献！"]# 拆分好的数据
new_data = [cut_word(i) for i in data]    # 分词器只能进行单语句进行传输后进行分词

# 构造计数器对象
count = CountVectorizer()
# 对数据进行fit
data = count.fit_transform(new_data)
arr = data.toarray()   # 生成array数组 对数组整体进行计算
# print(arr)

# 1、计算每个词的词频
tf_arr_sum = arr / (np.sum(arr, axis=0))  # 公式中使用此方法进行词频计算
# tf_arr_sum = arr    # 直接词频的计数   # 在模块封装库中使用此方法进行词频计算
# print(tf_arr_sum)
# # 2、词频的逆文档数
idf_arr_word = np.log((arr.shape[0]+1)/((np.sum(arr,axis=0))+1))+1
# print(idf_arr_word.shape)
# 3、计算tf-idf
tf_idf_arr = tf_arr_sum * idf_arr_word
print('-------------------')
# print(tf_idf_arr)
print('-------------------')

# 模块中使用的l2正则表达式
# tf_idf_normalized = normalize(tf_idf_arr, norm='l2', axis=1, copy=True)
# print(tf_idf_normalized)
# 4、进行数据的l2标准化
l2 = np.sqrt(np.sum(tf_idf_arr**2,axis=1))   # 二阶范式 y = sqrt(sum(x**2))
l2 = l2[:, np.newaxis] 

norm_l2 = tf_idf_arr/ l2
df = pd.DataFrame(data=norm_l2,columns=count.get_feature_names_out())
print(df)
print("==========================================================================================================")

# 计算机计算TD-IDF
from sklearn.feature_extraction.text import TfidfTransformer
tfidf = TfidfTransformer()
tfidf_data = tfidf.fit_transform(data)
df = pd.DataFrame(data=tfidf_data.toarray(),columns=count.get_feature_names_out())

3、数据标准化处理

（1）数据最大最小化

from sklearn.preprossing import MinMaxScaler   # 最大最小化
from sklearn.preprossing import StandardScaler  # 数据标准化
from sklearn.preprossing import normalize # 正则化
# 最大最小化 == 可以将数据转化为固定区间内的数据
# 缺点：容易受到极大、极小噪声点的影响较为明显 == 模型的鲁棒性较差
# 有变异点后抵抗异常冲击的能力较弱

# 对数据进行手动最大最小值处理
df = pd.read_excel('./src/text.xls',dtype=np.float32)
# 创建一个新的矩阵进行计算后数据的存储
m,n = np.shape(df)
data = np.zeros((m,n),dtype=np.float32)
handle_data = pd.DataFrame(data= data ,
                    columns=df.columns)
for i in df.columns:
    for j in range(len(df[i])):
        min = df[i].min()
        max = df[i].max()
        handle_data[i][j] = ((df[i][j]-min)/(max-min))
print(handle_data)
# 采用最大最小计算器进行归一化处理
min_max = MinMaxScaler(feature_range=(0,1))
computer_data = min_max.fit_transform(df)
print(computer_data)

（2）数据标准化

from sklearn.preprossing import StandardScaler  # 数据标准化
# 缺点：特征之间的差异性降低，优点，将数据进行无量纲化处理，降低因量纲不一致导致的数据拟合偏执的现象。
# 手动实现数据标准化
df = pd.read_excel('./src/text.xls',dtype=np.float32)
# 创建一个新的矩阵进行计算后数据的存储
m,n = np.shape(df)
data = np.zeros((m,n),dtype=np.float32)
handle_data = pd.DataFrame(data= data ,
                    columns=df.columns)
# # 对矩阵进行按列进行标准差归一化
mean_ = df1.mean(axis=0)
s_ = df1.std(axis=0)
df2 = (df1 - mean_)/s_
print(df2)
# 采用最大最小计算器进行归一化处理
stadar = StandardScaler()
computer_data = stadar.fit_transform(df)
print(computer_data)

四、特征降维

（1）低方差过滤

# 低方差过滤
from sklearn.feature_selection import VarianceThreshold
model = VarianceThreshold(thresholt = 1.0)  # 将特征值的方差小于1.0的特征进行过滤剔除
# 手动进行数据方差计算，将低于阈值的数据进行删除
data_var = np.var(data,axis=0)
x = [ i for i in range(len(data_var)) if data_var[i]>2]
data = data[:,x]
print(data)

# 采用模型进行数据低方差过滤
data = var.fit_transform(df)
print(data)

（2）相关性分析

# 皮尔逊相关性分析
# 主要应用场景 == 数据特征维度较多时，将具有相关性的数据进行合并
# 手动计算两个变量之间的相关性系数
from scipy.stats import pearsonr
x = np.array([1,2,3,4,5])
y = np.array([1,2,3,4,5])
x_mean = x.mean()
y_mean = y.mean()
fenzi = sum((x-x_mean)*(y-y_mean))/len(x)
fenmu = (np.sqrt(sum((x-x_mean)**2)/(len(x))))*(np.sqrt(sum((y-y_mean)**2)/(len(x))))
print(fenzi/fenmu)

# computer_value 计算的相关性系数   # 计算机计算皮尔逊相关系数
r = pearsonr(x,y)
print(r)

（3）主成分分析
主要保留的特征为==信息波动大，方差大的数据进行保留

# 主成分分析
from sklearn.decomposition import PCA
pca = PCA(n_components=5)  # 最后保留5个特征

注：训练器的区别：：

fit_transform == 对训练器中中的数据进行计算 ，将初始化后的模型对原始数据进行转换
fit == 对训练器中的模型参数进行初始化 ， 将数据保存在transfer中。
transform == 将保存在训练器中的参数 进行调用，对数据进行 标准归一化操作

五、模型的训练与调优

1、常用的模型训练的距离计算方法

欧氏距离

曼哈顿距离

2、KNN算法

from sklearn.neighbors import KNeighborsClassifier
# 导入K分类模块库
model = KNeighborsClassifier(n = 4)
# K折交叉验证
from sklearn.model_selection import StratifiedKFold
model =StratifiedKFold(n_splits=5,shuffle = True,random_state=66)
for train_index,test_index in model.split(x,y):
	…………  进行模型的KNN 模型预测…………

3、模型的保存与加载

# 模型的保存与加载
import joblib
joblib.dump(model,'./data/model.pxt')
# 模型的加载
model = joblib.load('./data/model.pxt')

六、贝叶斯算法

# 手动实现朴素贝叶斯
import pandas as pd 
import numpy as np

data = pd.read_excel('byeas.xls')
data = np.array(data)
x,y = data[:,[0,1,2]],data[:,3]

# 计数
"""
p(a|X) = p(X|a)* p(a)/p(X)
p(X|a) = p(x1,x2,x3...xn|a) = p(x1|a)*p(x2|a)*p(x3|a)...p(xn|a)
p(X) = p(x1,x2,x3...xn) = p(x1)*p(x2)*p(x3)...p(xn)
p(a|X) = p(x1|a)*p(x2|a)*p(x3|a)...p(xn|a) * p(a) / p(x1)*p(x2)*p(x3)...p(xn)
"""
p_0 = np.unique(y,return_counts=True)[1][0] 
p_1 = np.unique(y,return_counts=True)[1][1] 
all_count_bad = np.zeros((1,7),dtype=np.int32)
all_count_good = np.zeros((1,7),dtype=np.int32)

n = len(y)
for i in range(n):
    if y[i] == 0 :
        # 坏瓜
        if x[i,0] == 0:
            all_count_bad[0,0] +=1
        if x[i,0] == 1:
            all_count_bad[0,1] +=1
        if x[i,1] == 0:
            all_count_bad[0,2] +=1
        if x[i,1] == 1:
            all_count_bad[0,3] +=1
        if x[i,2] == 1:
            all_count_bad[0,4] +=1
        if x[i,2] == 2:
            all_count_bad[0,5] +=1 
        if x[i,2] == 3:
            all_count_bad[0,6] +=1 
    else:
        # 坏瓜
        if x[i,0] == 0:
            all_count_good[0,0] +=1
        if x[i,0] == 1:
            all_count_good[0,1] +=1
        if x[i,1] == 0:
            all_count_good[0,2] +=1
        if x[i,1] == 1:
            all_count_good[0,3] +=1
        if x[i,2] == 1:
            all_count_good[0,4] +=1
        if x[i,2] == 2:
            all_count_good[0,5] +=1 
        if x[i,2] == 3:
            all_count_good[0,6] +=1  

"""
预测瓜的好坏 [1 1 3 ]
"""
# 预测是好瓜的概率
p_good =( p_1 / len(y) ) *  (all_count_good[0,1]/p_1 ) * (all_count_good[0,3]/p_1) * (all_count_good[0,6]/p_1)
# 预测是坏瓜的概率
p_bad =( p_0 / len(y) ) *  (all_count_bad[0,1]/p_0 ) * (all_count_bad[0,3]/p_0) * (all_count_bad[0,6]/p_0)

print("最终预测的结果为：",[1 if p_good > p_bad else 0])

"""
预测瓜的好坏 [0 0 2 ]
"""
# 预测是好瓜的概率
p_good =( p_1 / len(y) ) *  (all_count_good[0,0]/p_1 ) * (all_count_good[0,2]/p_1) * (all_count_good[0,5]/p_1)
# 预测是坏瓜的概率
p_bad =( p_0 / len(y) ) *  (all_count_bad[0,0]/p_0 ) * (all_count_bad[0,2]/p_0) * (all_count_bad[0,5]/p_0)

print("最终预测的结果为：",[1 if p_good > p_bad else 0])

# 计算机实现朴素贝叶斯
# 计算机预测代码实现
from sklearn.naive_bayes import MultinomialNB
import pandas as pd
import numpy as np
bytes = MultinomialNB()
data = pd.read_excel('byeas.xls')
data = np.array(data)
x_train,y_train = data[:,0:3],data[:,-1]
model = bytes.fit(x_train,y_train)
print(model.predict(np.array([[1,1,3]])))
print(model.predict(np.array([[0,0,2]])))