
#在 Jupyter Notebook 中，使用以下代码来打印当前工作目录：
import os
print(os.getcwd())


# import pandas as pd
# from sklearn.model_selection import train_test_split

# # 导入三个CSV文件
# file1 = r'd:\VS Code python program\machine_learing\wine_data.csv'
# file2 = r'd:\VS Code python program\machine_learing\breast_cancer.csv'
# file3 = r'd:\VS Code python program\machine_learing\prices.csv'

# data1 = pd.read_csv(file1)
# data2 = pd.read_csv(file2)
# data3 = pd.read_csv(file3)

# #划分训练集和测试集
# # 划分特征X和目标变量y
# # 最后一列是目标变量，其他列是特征
# X = data1.iloc[:,:-1]  # 所有行，除了最后一列
# y = data1.iloc[:,-1]   # 所有行，最后一列
# data.iloc[:, :-1]选择了所有行和除了最后一列以外的所有列(:-1表示从第一列到倒数第二列)。而data.iloc[:, -1]选择了所有行的最后一列。

# X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1)

# # 显示数据集的基本信息

# print(data1.info())

# print(data1.describe())

# # 打印出一部分数据
# print("\nData1 Head:")
# print(data1.head())


# 参考课程资料中的“03-机器学习库Scikit-learn.zip”，读取附件中的三个训练数据集，并参考教材P25-26页内容，
# 用一种方法划分出训练集S和测试集T，显示出数据集的基本信息，并打印出一部分数据。


import pandas as pd
from sklearn.model_selection import train_test_split


# 修复列名并读取文件
column_names = [
    'Alcohol', 'Malic_acid', 'Ash', 'Alcalinity', 'Magnesium',
    'Phenols', 'Flavanoids', 'Nonflavanoid_phenols', 'Proanthocyanins',
    'Color_intensity', 'Hue', 'OD280_OD315', 'Proline', 'Class'
]

# 读取CSV文件
file1 = r"d:\VS Code python program\machine_learing\wine_data.csv"
file2 = r'd:\VS Code python program\machine_learing\breast_cancer.csv'
file3 = r'd:\VS Code python program\machine_learing\prices.csv'
data = pd.read_csv(
    file1, 
    header=None,          # 忽略原文件标题行
    names=column_names,   # 使用自定义列名
    skiprows=1            # 跳过原文件第一行
)

# 划分训练集和测试集
# 特征列
X = data.drop('Class', axis=1)# 从data数据框中删除名为Class的列，axis=1表示操作是在列上进行的(axis=0表示在行上进行操作)
# 目标列
y = data['Class']             # 选取了名为Class的列

# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(
    X, y, 
    test_size=0.2,  # 80%训练集,20%测试集
    random_state=42,
    stratify=y  # 保持类别比例
)

# 显示数据集信息
print("="*50)
print("数据集基本信息：")
print(data.info()) # 显示数据类型和内存使用

print("\n" + "="*50)
print("数据集统计信息：") 
print(data.describe()) # 显示统计信息,均值、标准差等

print("\n" + "="*50)
print("数据集前5行: ")
print(data.head())

print("\n" + "="*50)
print("类别分布：")
print(y.value_counts()) # 显示类别分布

print("\n" + "="*50)
print("训练集大小：", X_train.shape)
print("测试集大小：", X_test.shape)

# 真实标签/目标标签
y_true = np.array([1, 0, 1, 1, 0, 1, 1, 0, 1, 0])

# 预测标签   
y_pred = np.array([1, 1, 1, 1, 0, 1, 1, 1, 1, 0])  
TP = sum((y_pred==1)==(y_pred==y_true))
FP = sum((y_pred==1)==(y_pred!=y_true))
FN = sum((y_pred==0)==(y_pred!=y_true))
TN = sum((y_pred==0)==(y_pred==y_true))
# 精度/准确率(accuracy)  
accuracy = sum(y_true==y_pred)/len(y_true)
# 查准率(precision)  
precision = TP / (TP + FP)
# 查全率/召回率(recall)  
recall = TP / (TP + FN)
# F1  
f1_score = 2 * precision * recall / (precision + recall)

# 也可使用sklearn库计算精度、查准率、查全率与F1:
# 精度/准确率(accuracy)  
sklearn.metrics.accuracy_score(y_true, y_pred, *, normalize=True, sample_weight=None)
# 查准率(precision)  
sklearn.metrics.precision_score(y_true, y_pred, *, labels=None, pos_label=1, average='binary', sample_weight=None, zero_division='warn')
# 查全率/召回率(recall)  
sklearn.metrics.recall_score(y_true, y_pred, *, labels=None, pos_label=1, average='binary', sample_weight=None, zero_division='warn')
# F1  
sklearn.metrics.f1_score(y_true, y_pred, *, labels=None, pos_label=1, average='binary', sample_weight=None, zero_division='warn')
# 参数含义请参考：https://scikit-learn.org


import numpy as np


ndarray = np.ndarray


def task(y_true: ndarray, y_pred: ndarray):
    
    '''
    二分类任务,正标签为1,负标签为0
    y_true: 数组1*n, 真实标签
    y_pred: 数组1*n, 预测标签
    '''

    TP = sum((y_pred==1)==(y_pred==y_true))
    FP = sum((y_pred==1)==(y_pred!=y_true))
    FN = sum((y_pred==0)==(y_pred!=y_true))
    TN = sum((y_pred==0)==(y_pred==y_true))
    
    precision = TP / (TP + FP)
    
    '''
    任务描述：根据公式实现查全率(recall)和F1
    '''
    ########## Begin ##########
    recall = TP / (TP + FN)
    f1_score = 2 * precision * recall / (precision + recall)

    ########## End ##########
    
    return precision, recall, f1_score


import pandas as pd
from sklearn.linear_model import LinearRegression

# 获取已经划分好的训练数据和标签
train_data = pd.read_csv('./step3/train_data.csv')
train_label = pd.read_csv('./step3/train_label.csv')['target']

# 获取已经划分好的测试数据
test_data = pd.read_csv('./step3/test_data.csv')

# 初始化线性回归模型
lr = LinearRegression(fit_intercept=True, normalize=False)  

# 训练模型
lr.fit(train_data, train_label)

# 对测试集进行预测
predict = lr.predict(test_data)

# 将预测结果保存到 CSV 文件中
result = pd.DataFrame(predict, columns=['result'])
result.to_csv('./step3/result.csv', index=False)
# pd.DataFrame() 是Pandas库中用于创建DataFrame对象的函数。DataFrame是Pandas中的一种数据结构，它以表格形式存储数据，类似于Excel中的工作表或SQL数据库中的表。
# columns=['result'] 是一个参数，用于指定DataFrame中列的名称
# to_csv() 是DataFrame对象的一个方法，用于将DataFrame的内容保存到一个CSV文件中
# index=False 是一个参数，用于指定是否将DataFrame的索引（行标签）保存到CSV文件中。index=False，意味着不保存


import numpy as np
def sigmoid(t):
    '''
    完成sigmoid函数计算
    t: 负无穷到正无穷的实数
    return: 转换后的概率值
    可以考虑使用np.exp()函数
    '''
    #********** Begin **********#
    t=1/(1+np.exp(-t))
    return t
    #********** End **********#


from sklearn.linear_model import LogisticRegression

def digit_predict(train_image, train_label, test_image):
    '''
    实现功能：训练模型并输出预测结果
    :param train_sample: 包含多条训练样本的样本集,类型为ndarray,shape为[-1, 8, 8]
    :param train_label: 包含多条训练样本标签的标签集,类型为ndarray
    :param test_sample: 包含多条测试样本的测试集,类型为ndarry
    :return: test_sample对应的预测标签
    '''

    #************* Begin ************#
    #LogisticRegression 需要二维特征矩阵作为输入
    train_image_reshaped = train_image.reshape(-1, 64)
    test_image_reshaped = test_image.reshape(-1, 64)
    # 将训练集和测试集的图像数据从三维展平为二维
    # 形状从 [-1, 8, 8] 变为 [-1, 64]
    logreg = LogisticRegression(solver='lbfgs',max_iter =200,C=3)
    logreg.fit(train_image_reshaped, train_label)
    result = logreg.predict(test_image_reshaped)
    return result
    #************* End **************#


from sklearn.tree import DecisionTreeClassifier
from sklearn import datasets

#加载鸢尾花数据集
iris = datasets.load_iris()
#X表示特征,y表示标签
X = iris.data
y = iris.target

def iris_predict(train_sample, train_label, test_sample):
    '''
    实现功能:1.训练模型 2.预测
    :param train_sample: 包含多条训练样本的样本集,类型为ndarray
    :param train_label: 包含多条训练样本标签的标签集,类型为ndarray
    :param test_sample: 包含多条测试样本的测试集,类型为ndarry
    :return: test_sample对应的预测标签
    '''
    
    # ************* Begin ************#
    clf = DecisionTreeClassifier(criterion='entropy', max_depth=3)
    clf.fit(train_sample, train_label)
    result = clf.predict(test_sample)
    return result
    # ************* End **************#


import numpy as np
from sklearn import datasets
from collections import Counter


# 划分函数
def split(x,y,d,value):
    # x: 数据集的特征矩阵
    # y: 数据集的标签向量
    # d: 划分属性的索引，表示根据哪个特征进行划分。
    # 注意这里的索引是从0开始的，x[:,d]表示取所有样本的第d+1个特征
    index_a=(x[:,d]<=value)
    # 生成一个布尔向量，其中每个元素对应于x中的一行（一个样本），如果第d+1个特征的值小于等于value，则对应位置为True，否则为False
    index_b=(x[:,d]>value)
    # 生成另一个布尔向量，与index_a相反，如果第d+1个特征的值大于value，则对应位置为True，否则为False
    return x[index_a],x[index_b],y[index_a],y[index_b]
    # x[index_a]:根据index_a布尔向量，从x中选取满足条件(第d+1个特征的值小于等于value)的样本
    # x[index_b]:根据index_b布尔向量，从x中选取不满足条件（第d+1个特征的值大于value）的样本
    # y[index_a]:根据index_a布尔向量，从y中选取与子集A对应的标签
    # y[index_b]:根据index_b布尔向量，从y中选取与子集B对应的标签



# 信息熵的计算
def entropy(y):
    # 确保输入是numpy数组
    y = np.array(y)
    # 计算每个类别的频率
    unique_y, counts = np.unique(y, return_counts=True)
    #unique_y 包含了 y 数组中的唯一值（即类别标签），而 counts 数组则包含了与 unique_y 中每个标签相对应的计数，即该标签在 y 数组中出现的次数。
    pro = counts / len(y)
    # 计算信息熵
    res = np.sum(-pro * np.log(pro))
    return res



# 计算最优划分属性和值的函数
def try_spit(x,y):
    # x:一个NumPy数组
    # y:：一个一维数组，包含与 x 中每个样本对应的标签或目标值
    best_entropy=float("inf")
    # 初始化 best_entropy 为正无穷大，表示开始时还没有找到任何分割点
    best_d,best_v=-1,-1
    # 初始化 best_d 和 best_v 为 -1，表示还没有确定最佳分割特征和分割值
    for d in range(x.shape[1]):
        sorted_index=np.argsort(x[:,d])
        # 对该特征列的值进行排序，并获取排序后的索引
        for i in range(1,len(x)):
            if x[sorted_index[i-1],d] != x[sorted_index[i],d]:
                v=(x[sorted_index[i-1],d]+x[sorted_index[i],d])/2
                # 遍历排序后的索引，并通过索引访问特征值，尝试在每个不同的特征值之间找到最佳分割点。如果当前位置与前一个位置的特征值不同，则计算这两个值的中点作为候选分割值 v。
                x_l,x_r,y_l,y_r=split(x,y,d,v)
                e=entropy(y_l)+entropy(y_r)
                # 计算分割后的熵 e，即左半部分和右半部分标签的熵之和
                if e<best_entropy:
                    best_entropy,best_d,best_v=e,d,v
                    # 如果当前分割的熵小于 best_entropy，则更新 best_entropy、best_d 和 best_v 为当前分割的熵、特征和分割值。
    return best_entropy,best_d,best_v
    # best_entropy: 分割后的最小熵值。
    # best_d: 最佳分割特征的索引。
    # best_v: 最佳分割点的值



# 加载数据(鸢尾花)
d=datasets.load_iris()
x=d.data[:,2:] #只选择了数据集中的最后两个特征
y=d.target # 标签
# 计算出最优划分属性和最优值
best_entropy=try_spit(x,y)[0]
best_d=try_spit(x,y)[1]
best_v=try_spit(x,y)[2]
# 使用最优划分属性和值进行划分
x_l,x_r,y_l,y_r=split(x,y,best_d,best_v)
# 打印结果
print("叶子结点的熵值：")
print(entropy(y_l))
print("分支结点的熵值：")
print(entropy(y_r))


from sklearn import svm # 调用sklearn实现svm算法
from sklearn.datasets import load_iris #加载sklearn库中的数据集
from sklearn.model_selection import train_test_split #划分测试集训练集
# 加载数据集
dataset = load_iris()
data_x = dataset.data #定义数据
data_y = dataset.target #定义标签
# 划分训练集和测试集
x_train,x_test,y_train,y_test = train_test_split(data_x,data_y,test_size=0.3)
#调用svm函数中的SVC核心算法
clf = svm.SVC()
clf = clf.fit(x_train,y_train) #开始训练svm模型
a = clf.predict(x_test) #开始测试
# 准确率
cnt = 0
for i in range(len(y_test)):  
    if a[i] == y_test[i]:
        cnt +=1
print(cnt/len(a))
# 评估模型
print(clf.score(x_test, y_test)) #它提供了一个缺省的评估法则来评估模型,简要的说,它用你训练好的模型在测试集上进行评分（0~1）1分代表最好
print(clf.support_vectors_)  #输出当前的支持向量


from sklearn import svm # 加载sklearn库来调用svm算法

X = [[0, 0], [1, 1]] #输入的数据
y = [0, 1]  #输入数据对应的类别(标签)
# 调用svm函数中的SVC核心算法
clf = svm.SVC();    
# 开始训练
clf = clf.fit(X,y)
# 测试
test_X = [[0.5, 0.5], [1.5, 1.5]] #输入需要预测的数据
print(clf.predict(test_X))       # 调用预测函数进行分类

print(clf.score(X,y)) #它提供了一个缺省的评估法则来评估模型,简要的说,它用你训练好的模型在测试集上进行评分（0~1）1分代表最好
print(clf.support_vectors_)  #输出当前的支持向量


import numpy as np
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score
from sklearn.metrics import classification_report

data_path ='/data/bigfiles/5297379b-7cd5-4239-bcac-e2d361753393'
df = pd.read_csv(data_path, delimiter='\t',header=None)
######Begin ######

# 将label编码，替换为数值形式：ham -> 1, spam -> 0
df[0] = df[0].replace(to_replace=['spam', 'ham'], value=[0, 1])

# 完成数据划分及词向量的转化
X = df[1].values  # 邮件内容
y = df[0].values  # 标签
# 划分训练集和测试集 使用random_state=0确保结果可复现
X_train_raw,X_test_raw,y_train,y_test=train_test_split(X,y,random_state = 0)
# 初始化TfidfVectorizer，用于将文本数据转化为词向量
vectorizer = TfidfVectorizer()
# 对训练集进行fit和transform，学习词汇表并生成词向量
x_train = vectorizer.fit_transform(X_train_raw)
# 对测试集进行transform，仅使用训练集学到的词汇表生成词向量
x_test = vectorizer.transform(X_test_raw)


# 构建模型及训练
model = MultinomialNB()

#对于测试集x_test进行预测
model.fit(x_train,y_train)
# 对测试集进行预测，得到分类标签
x_pre_test=model.predict(x_test)
# 对测试集进行预测，得到每个类别的概率
x_pro_test=model.predict_proba(x_test)
#计算验证集的auc值,参数为预测值和概率估计
auc=roc_auc_score(y_test, x_pro_test[:, 1])

###### End ######

print("auc的值:{}".format(auc))


from sklearn.feature_extraction.text import CountVectorizer  
# 从sklearn.feature_extraction.text里导入文本特征向量化模块
from sklearn.naive_bayes import MultinomialNB


def news_predict(train_sample, train_label, test_sample):
    '''
    训练模型并进行预测,返回预测结果
    :param train_sample:原始训练集中的新闻文本,类型为ndarray
    :param train_label:训练集中新闻文本对应的主题标签,类型为ndarray
    :test_sample:原始测试集中的新闻文本,类型为ndarray
    '''

    #实例化向量化对象
    vec = CountVectorizer()
    #将训练集中的新闻向量化
    train_sample = vec.fit_transform(train_sample)
    #将测试集中的新闻向量化
    test_sample = vec.transform(test_sample)  

    clf = MultinomialNB()
    clf.fit(train_sample, train_label)
    result = clf.predict(test_sample)    
    return result


import numpy as np

# 完成fit与predict函数,分别实现模型的训练与预测。
# 在fit函数中需要将预测时需要的概率保存到self.label_prob和self.condition_prob这两个变量
class NaiveBayesClassifier(object):
    def __init__(self):
        '''
        self.label_prob表示每种类别在数据中出现的概率
        例如,{0:0.333, 1:0.667}表示数据中类别0出现的概率为0.333,类别1的概率为0.667
        '''
        self.label_prob = {}# 用于存储每个类别的先验概率，即每个类别在训练数据中出现的概率
        '''
        self.condition_prob表示每种类别确定的条件下各个特征出现的概率
        例如训练数据集中的特征为 [[2, 1, 1],
                              [1, 2, 2],
                              [2, 2, 2],
                              [2, 1, 2],
                              [1, 2, 3]]
        标签为[1, 0, 1, 0, 1]
        那么当标签为0时第0列的值为1的概率为0.5,值为2的概率为0.5;
        当标签为0时第1列的值为1的概率为0.5,值为2的概率为0.5;
        当标签为0时第2列的值为1的概率为0,值为2的概率为1,值为3的概率为0;
        当标签为1时第0列的值为1的概率为0.333,值为2的概率为0.666;
        当标签为1时第1列的值为1的概率为0.333,值为2的概率为0.666;
        当标签为1时第2列的值为1的概率为0.333,值为2的概率为0.333,值为3的概率为0.333;
        因此self.label_prob的值如下:     
        {
            0:{
                0:{
                    1:0.5
                    2:0.5
                }
                1:{
                    1:0.5
                    2:0.5
                }
                2:{
                    1:0
                    2:1
                    3:0
                }
            }
            1:
            {
                0:{
                    1:0.333
                    2:0.666
                }
                1:{
                    1:0.333
                    2:0.666
                }
                2:{
                    1:0.333
                    2:0.333
                    3:0.333
                }
            }
        }
        '''
        self.condition_prob = {}# 用于存储在给定类别的条件下，每个特征取不同值的条件概率
    def fit(self, feature, label):
        '''
        对模型进行训练,需要将各种概率分别保存在self.label_prob和self.condition_prob中
        :param feature: 训练数据集所有特征组成的ndarray
        :param label:训练数据集中所有标签组成的ndarray
        :return: 无返回
        '''
        #********* Begin *********#
        row_num = len(feature)
        col_num = len(feature[0])
        for c in label:
            if c in self.label_prob:
                self.label_prob[c] += 1
            else:
                self.label_prob[c] = 1
        for key in self.label_prob.keys():
            self.label_prob[key] /= row_num
            self.condition_prob[key] = {}
            for i in range(col_num):
                self.condition_prob[key][i] = {}
                for k in np.unique(feature[:,i], axis=0):
                    self.condition_prob[key][i][k] = 0
        for i in range(len(feature)):
            for j in range(len(feature[i])):
                if feature[i][j] in self.condition_prob[label[i]]:
                    self.condition_prob[label[i]][j][feature[i][j]] += 1
                else:
                    self.condition_prob[label[i]][j][feature[i][j]] = 1
        for label_key in self.condition_prob.keys():
            for k in self.condition_prob[label_key].keys():
                total = 0
                for v in self.condition_prob[label_key][k].values():
                    total += v
                for kk in self.condition_prob[label_key][k].keys():
                    self.condition_prob[label_key][k][kk] /= total
        #********* End *********#


    def predict(self, feature):
        '''
        对数据进行预测,返回预测结果
        :param feature:测试数据集所有特征组成的ndarray,有多条数据
        :return:预测结果,feature中有多少条数据,就需要返回长度为多少的list或者ndarry**
        '''
        # ********* Begin *********#
        result = []
        for i,f in enumerate(feature):
            prob=np.zeros(len(self.label_prob.keys()))
            i1 = 0
            for label,label_prob in self.label_prob.items():
                prob[i1] = label_prob
                for  j  in range(len(feature[0])):
                    prob[i1] *= self.condition_prob[label][j][f[j]]
                i1 += 1
            result.append(list(self.label_prob.keys())[np.argmax(prob)])
        return np.array(result)
        #********* End *********#


# 导入 numpy 科学计算库
import numpy as np

# 令 m=100
m = 100

# lambda_true 表示参考模型给出的簇标记
np.random.seed(0)
lambda_true = np.random.randint(0,5,m)

# lambda_pred 表示通过聚类得到的簇标记
np.random.seed(1)
lambda_pred = np.random.randint(0,5,m)

# 计算 a,b,c,d
a = b = c = d = 0
for j in range(m):
    for i in range(j):
        if lambda_true[i]==lambda_true[j] and lambda_pred[i]==lambda_pred[j]:
            a = a + 1
        elif lambda_true[i]==lambda_true[j] and lambda_pred[i]!=lambda_pred[j]:
            b = b + 1
        elif lambda_true[i]!=lambda_true[j] and lambda_pred[i]==lambda_pred[j]:
            c = c + 1
        else:
            d = d + 1
        

# 计算 Jaccard 系数
JC = a / ( a + b + c)

# 计算 FM 指数

FM = np.sqrt( (a**2) / ( (a+b) * (a+c) ) )

# 计算 Rand 指数

RI = ( 2 * (a+b) ) / ( m * (m-1) )

# 打印结果
print("Jaccard 系数为{},FM 指数为{},Rand 指数为{}".format(JC, FM, RI))


# 从 sklearn.cluster 导入 KMeans
from sklearn.cluster import KMeans
import numpy as np

# 加载数据集
X = np.array([[1, 2], [2, 2.2], [3, 1.5], [2, 1.8], [1, 1.4], [1, 2.5], [1, 1], [10, 2], [10, 2.5], [9, 2.3], [10, 2.4], [9.5, 2.1]])

# 1：创建 KMeans 对象，令 n_clusters=2
kmeans = KMeans(n_clusters=2)

# 2：调用 fit 函数执行训练过程
kmeans.fit(X)

# 3：调用 predict 函数进行预测，预测的数据为 [0,0], [8,2], [10,3]
y=np.array(([0,0], [8,2], [10,3]))
y_pred = kmeans.predict(y)

# 打印结果
print(y_pred)
# [0 1 1]


from sklearn.datasets import load_iris
from sklearn.cluster import KMeans
from sklearn.model_selection import train_test_split
import numpy as np

# 加载鸢尾花数据集
iris = load_iris()
x = iris['data']
y = iris['target']

# 将数据集分为训练集和测试集
np.random.seed(0)
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1)

# 1：创建 KMeans 对象,令 n_clusters=4
kmeans = KMeans(n_clusters=4)

# 2：调用 fit 函数执行训练过程
kmeans.fit(x_train)

# 3：调用 predict 函数进行预测 
y_pred = kmeans.predict(x_test) 

# 打印结果
print("真实结果：\n", y_test)
print("预测结果：\n", y_pred)

# 计算 a,b,c,d
a = b = c = d = 0
m = 15
for j in range(m):
    for i in range(j):
        if y_test[i]==y_test[j] and y_pred[i]==y_pred[j]:
            a = a + 1
        elif y_test[i]==y_test[j] and y_pred[i]!=y_pred[j]:
            b = b + 1
        elif y_test[i]!=y_test[j] and y_pred[i]==y_pred[j]:
            c = c + 1
        else:
            d = d + 1
        
# 根据公式计算 Jaccard 系数
JC = a / (a + b + c)

# 根据公式计算 FM 指数
FM = np.sqrt(a ** 2 / ((a + b) * (a + c)))

# 根据公式计算 Rand 指数
RI = 2 * (a + b) / (m * (m - 1))

# 打印结果
print("Jaccard 系数为{},FM 指数为{},Rand 指数为{}".format(JC, FM, RI))

编号	颜色	声音	纹理	是否为好瓜
1	绿	清脆	清晰	是
2	黄	浑厚	模糊	否
3	绿	浑厚	模糊	是
4	绿	清脆	清晰	是
5	黄	浑厚	模糊	是
6	绿	清脆	清晰	否

基本函数¶

数据集划分与基本信息¶

留出法¶

sklearn.model_selection.train_test_split¶

stratify参数¶

错误率与精度&查准率、查全率与F1¶

线性回归¶

LinearRegression()¶

逻辑回归¶

LogisticRegression()¶

参数选择¶

手写图像识别¶

决策树¶

DecisionTreeClassifier()¶

计算原理¶

Autograd¶

Pytorch 中的 Autograd¶

requires_grad属性¶

backward函数¶

示例¶

静态图动态图设计¶

正向反向传播¶

示例¶

损失函数¶

常见的损失函数¶

示例¶

支持向量机¶

朴素贝叶斯¶

算法流程¶

聚类¶

外部指标¶

内部指标¶

K-Means算法¶

应用示例¶