从零开始数据科学与机器学习算法-数据预处理与基准模型-01

其他 2021-03-01 11:40:33 阅读次数: 0

读取数据函数

在这里插入图片描述

from csv import reader # 导入库

def read_csv(the_name_of_file_to_be_read):  # 定义数据读取函数
    file = open(the_name_of_file_to_be_read,"r")#要读取的文件的名称
    every_line_of_the_data = reader(file) # 读取每一行数据
    the_dataseet = list(every_line_of_the_data) # 把每一行数据放到该列表中
    return the_dataseet # 返回处理后的数据

the_name_of_file_to_be_read = "diabetes-NAN.csv" # 数据文件
dataset = read_csv(the_name_of_file_to_be_read) # 读取数据
print(dataset) # 打印数据

在这里插入图片描述

数据缺失先判断在放入

在这里插入图片描述

在这里插入图片描述

from csv import reader# 导入库

def read_csv(the_name_of_file_to_be_read):  # 定义数据读取函数
    dataset = list()# 定义一个空列表
    with open(the_name_of_file_to_be_read,"r") as file: # 文件读取
        csv_reader = reader(file) # 读取
        for row in csv_reader: # 循环文件内容逐行判断
            if not row: # 如果不存在就跳过
                continue # continue的作用：用来结束本次循环，紧接着执行下一次的循环
            dataset.append(row) # 把读取的内容追加到上面定义的空列表中
    return dataset # 返回列表

the_name_of_file_to_be_read = "diabetes-NAN.csv" # 数据文件
dataset = read_csv(the_name_of_file_to_be_read) # 读取数据
print(dataset) # 打印数据

在这里插入图片描述

数据类型强调与转换

# 列子
dataset = [[1,2],[3,4]]

for i in dataset:# 循环列表
    print(i)
# [1, 2]
# [3, 4]
for i in dataset[0]: # 循环列表中第一行
    print(i)
# 1
# 2
for i in range(len(dataset[0])): # 循环列表中第一行的长度
    print(i)
# 0
# 1
dataset = [[1,2],
           [3,4],
           [5,6],
           [7,8]]
for i in range(len(dataset[0])):  # 安照列表中第一行的长度进行循环
    col_values = [row[i] for row in dataset]  # 对每列中的数据进行循环
    print(col_values) 
#[1, 3, 5, 7]
#[2, 4, 6, 8]
 

from csv import reader# 导入库

def read_csv(the_name_of_file_to_be_read):  # 定义数据读取函数
    dataset = list()# 定义一个空列表
    with open(the_name_of_file_to_be_read,"r") as file: # 文件读取
        csv_reader = reader(file) # 读取
        for row in csv_reader: # 循环文件内容逐行判断
            if not row: # 如果不存在就跳过
                continue # continue的作用：用来结束本次循环，紧接着执行下一次的循环
            dataset.append(row) # 把读取的内容追加到上面定义的空列表中
    return dataset # 返回列表

def conver_string_to_float(dataset,column): # 字符串转数字函数
    dataset = dataset[1:] # 列表切分 保留列表索引1至最后一行
    for row in dataset: # 循环数据集
        row[column]=float(row[column].strip()) # 对每一行中每一列进行变化为浮点类型，去掉空格

the_name_of_file_to_be_read = "diabetes-NAN.csv" # 数据文件
dataset = read_csv(the_name_of_file_to_be_read) # 读取数据

for i in range(len(dataset[0])):# 取出一行的长度进行循环
    conver_string_to_float(dataset,i)# 调用字符串转数字函数
print(dataset)# 打印

在这里插入图片描述

特征缩放

在这里插入图片描述
在这里插入图片描述

最大最小归一化，平均归一化有一个缺陷就是当有新数据加入时，可能导致max和min的变化，需要重新定义。
在这里插入图片描述
在这里插入图片描述

通过函数找出每列中最大最小值列子

dataset = [[1,2,3],
           [4,5,6]]

在这里插入图片描述

# 编写函数：在数据集中找到最大值和最小值
def find_the_max_and_min_in_the_dataset(dataset): 
    max_and_min=list() # 定义一个空列表
    for i in range(len(dataset[0])): # 安照列表中第一行的长度进行循环
        col_values = [row[i] for row in dataset] # 对每列中的数据进行循环
        value_max = max(col_values)# 取出每列中最大值
        value_min = min(col_values) #最小值
        max_and_min.append([value_max,value_min]) # 追加
    return max_and_min

max_and_min = find_the_max_and_min_in_the_dataset(dataset) # 调用函数带入数据
print(max_and_min) # 打印每一列中最大值和最小值

在这里插入图片描述

最大最小值归一化

Min-Max Normalization
 公式：  x’ = (x - X_min) / (X_max - X_min)
列子

dataset = [[1,2],
           [3,4],
           [5,6],
           [7,8]]
(1-1)/(7-1),(2-2)/(8-2),(3-1)/(7-1),(4-2)/(8-2),(5-1)/(7-1),(6-2)/(8-2),(7-1)/(7-1),(8-2)/(8-2)

在这里插入图片描述
代码

dataset = [[1,2],
           [3,4],
           [5,6],
           [7,8]]

# 编写函数：在数据集中找到最大值和最小值
def find_the_max_and_min_in_the_dataset(dataset): 
    max_and_min=list() # 定义一个空列表
    for i in range(len(dataset[0])): # 安照列表中第一行的长度进行循环
        col_values = [row[i] for row in dataset] # 对每列中的数据进行循环
        value_max = max(col_values)# 取出每列中最大值
        value_min = min(col_values) #最小值
        max_and_min.append([value_max,value_min]) # 追加
    return max_and_min

max_and_min = find_the_max_and_min_in_the_dataset(dataset) # 调用函数带入数据
print(max_and_min) # 打印每一列中最大值和最小值

# 最大最小归一化
def max_min_normalization(dataset,max_and_min):
    for row in dataset:# 循环列表每行
        for i in range(len(row)): # 通过循环得到每行有多少个数据
            # 把列表中每个值代入到公式(x - X_min) / (X_max - X_min)
            row[i] = (row[i]-max_and_min[i][1])/(max_and_min[i][0]-max_and_min[i][1])

max_min_normalization(dataset,max_and_min)# 调用函数
print(dataset)

在这里插入图片描述

平均归一化

公式：  x’ = (x - μ) / (MaxValue - MinValue)
列子

dataset = [[1,2],
           [3,4],
           [5,6],
           [7,8]]

(1+3+5+7)/4,(2+4+6+8)/4

在这里插入图片描述

(1-4)/(7-1),(2-5)/(8-2),(3-4)/(7-1),(4-5)/(8-2),(5-4)/(7-1),(6-5)/(8-2),(7-4)/(7-1),(8-5)/(8-2)

在这里插入图片描述
代码

dataset = [[1,2],
           [3,4],
           [5,6],
           [7,8]]

在这里插入图片描述

# 编写函数：在数据集中找到最大值和最小值
def find_the_max_and_min_in_the_dataset(dataset): 
    max_and_min=list() # 定义一个空列表
    for i in range(len(dataset[0])): # 安照列表中第一行的长度进行循环
        col_values = [row[i] for row in dataset] # 对每列中的数据进行循环
        value_max = max(col_values)# 取出每列最大值
        value_min = min(col_values) #最小值
        max_and_min.append([value_max,value_min]) # 追加
    return max_and_min

max_and_min = find_the_max_and_min_in_the_dataset(dataset) # 调用函数带入数据
print(max_and_min) # 打印每一列中最大值和最小值

在这里插入图片描述

# 编写函数求出每列的平均值
def average_a(dataset):
    average=list()
    for i in range(len(dataset[0])):  # 安照列表中第一行的长度进行循环
        average_ = [row[i] for row in dataset]  # 对每列中的数据进行循环
        average.append(sum(average_)/len(dataset)) # 求每列数据的总和并除以个数求平均数
    return average

average = average_a(dataset) # 调用函数带入数据
print(average) # 打印每一列中的平均数

在这里插入图片描述

# 平均归一化
def mean_normalization(dataset,max_and_min):
    for row in dataset:# 循环列表每行
        for i in range(len(row)): # 通过循环得到每行有多少个数据
            row[i] = (row[i]-average[i])/(max_and_min[i][0]-max_and_min[i][1])

mean_normalization(dataset,max_and_min)# 调用函数
print(dataset)

在这里插入图片描述

标准化

列子：

dataset = [[1,2,3],
           [3,4,5],
           [5,6,7],
           [7,8,9],
           [81,96,100]]

# 每列平均值
for i in range(len(dataset[0])):  
    col_values = [row[i] for row in dataset]  
    print(sum(col_values)/len(dataset))

在这里插入图片描述

a = sqrt((((1-19.4)**2)+((3-19.4)**2)+((5-19.4)**2)+((7-19.4)**2)+((81-19.4)**2))/4)
a

在这里插入图片描述

(1-19.4)/a

在这里插入图片描述

(3-19.4)/a

在这里插入图片描述
代码:

dataset = [[1,2,3],
           [3,4,5],
           [5,6,7],
           [7,8,9],
           [81,96,100]]

# 计算数据集的平均值 函数
def calculate_the_mean_of_the_dataset(dataset):
    means = list()
    for i in range(len(dataset[0])):  # 安照列表中第一行的长度进行循环
        col_values = [row[i] for row in dataset]  # 对每列中的数据进行循环
        mean = sum(col_values)/float(len(dataset)) #每一列数据和除以数据个数得出平均值
        means.append(mean)
    return means

a = calculate_the_mean_of_the_dataset(dataset)
print(a)

在这里插入图片描述

# 计算数据集的平均值 函数
def calculate_the_mean_of_the_dataset_V2(dataset):
    means = ["占位符" for i in range(len(dataset[0]))] 
    for i in range(len(dataset[0])):  # 安照列表中第一行的长度进行循环
        col_values = [row[i] for row in dataset]  # 对每列中的数据进行循环
        means[i] = sum(col_values)/float(len(dataset)) #每一列数据和除以数据个数得出平均值
    return means

from math import sqrt

# 计算数据集的标准偏差
def calculate_the_stdevs_of_the_dataset(dataset,means):
    stdevs = ["占位符" for i in range(len(dataset[0]))]
    for i in range(len(dataset[0])):# 对列表进行迭代
        variance = [pow(row[i]-means[i],2) for row in dataset]
        stdevs[i] = sum(variance)
    stdevs=[sqrt(element/float(len(dataset)-1)) for element in stdevs] # 偏估计要除以n-1
    return stdevs   

means_list = calculate_the_mean_of_the_dataset_V2(dataset)
means_list

在这里插入图片描述

stdevs_list = calculate_the_stdevs_of_the_dataset(dataset,means_list)
stdevs_list

在这里插入图片描述

# 数据集的标准化
def the_standardization_of_our_dataset(dataset,means_list,stdevs_list):
    for row in dataset:
        for i in range(len(row)):
            row[i] = (row[i]-means_list[i])/stdevs_list[i]

the_standardization_of_our_dataset(dataset,means_list,stdevs_list)
print(dataset)

在这里插入图片描述

在kaggle数据集上使用特征缩放

from csv import reader# 导入库
from math import sqrt

数据读取预处理

def read_csv(the_name_of_file_to_be_read):  # 定义数据读取函数
    dataset = list()# 定义一个空列表
    with open(the_name_of_file_to_be_read,"r") as file: # 文件读取
        csv_reader = reader(file) # 读取
        for row in csv_reader: # 循环文件内容逐行判断
            if not row: # 如果不存在就跳过
                continue # continue的作用：用来结束本次循环，紧接着执行下一次的循环
            dataset.append(row) # 把读取的内容追加到上面定义的空列表中
    return dataset # 返回列表

def conver_string_to_float(dataset,column): # 字符串转数字函数
    dataset = dataset[1:] # 列表切分 保留列表索引1至最后一行
    for row in dataset: # 循环数据集
        row[column]=float(row[column].strip()) # 对每一行中每一列进行变化为浮点类型，去掉空格

the_name_of_file_to_be_read = "bbb.csv" # 数据文件
dataset = read_csv(the_name_of_file_to_be_read) # 读取数据

for i in range(len(dataset[0])):# 取出一行的长度进行循环
    conver_string_to_float(dataset,i)# 调用字符串转数字函数
print(dataset)# 打印

在这里插入图片描述

# 切片去掉字符保留数字
dataset=dataset[1:]
dataset

在这里插入图片描述

# 编写函数：在数据集中找到最大值和最小值
def find_the_max_and_min_in_the_dataset(dataset): 
    max_and_min=list() # 定义一个空列表
    for i in range(len(dataset[0])): # 安照列表中第一行的长度进行循环
        col_values = [row[i] for row in dataset] # 对每列中的数据进行循环
        value_max = max(col_values)# 取出每列中最大值
        value_min = min(col_values) #最小值
        max_and_min.append([value_max,value_min]) # 追加
    return max_and_min

max_and_min=find_the_max_and_min_in_the_dataset(dataset)
max_and_min # 打印每列中的最大最小值

在这里插入图片描述

# 计算数据集的平均值 函数
def calculate_the_mean_of_the_dataset(dataset):
    means = list()
    for i in range(len(dataset[0])):  # 安照列表中第一行的长度进行循环
        col_values = [row[i] for row in dataset]  # 对每列中的数据进行循环
        mean = sum(col_values)/float(len(dataset)) #每一列数据和除以数据个数得出平均值
        means.append(mean)
    return means

means_list = calculate_the_mean_of_the_dataset(dataset)
means_list # 打印每列的平均值

在这里插入图片描述

# 计算数据集的标准偏差
def calculate_the_stdevs_of_the_dataset(dataset,means):
    stdevs = ["占位符" for i in range(len(dataset[0]))]
    for i in range(len(dataset[0])):# 对列表进行迭代
        variance = [pow(row[i]-means[i],2) for row in dataset]
        stdevs[i] = sum(variance)
    stdevs=[sqrt(element/float(len(dataset)-1)) for element in stdevs] # 偏估计要除以n-1
    return stdevs   

stdevs_list = calculate_the_stdevs_of_the_dataset(dataset,means_list)
stdevs_list #打印每列的偏差

在这里插入图片描述

# 数据集的标准化
def the_standardization_of_our_dataset(dataset,means_list,stdevs_list):
    for row in dataset:
        for i in range(len(row)):
            row[i] = (row[i]-means_list[i])/stdevs_list[i]

the_standardization_of_our_dataset(dataset,means_list,stdevs_list)
print(dataset) # 标准化后的数据

在这里插入图片描述

数据划分

train_test_split

例子一：

from random import seed
from random import randrange

# 训练集，测试集划分函数
def train_test_split(dataset,train=0.6):# 需要传入的数据集，切分比例
    train_lanzi=list()# 创建一个空列表存放训练集
    train_size = train*len(dataset) # train的长度就是0.6*数据总长度
    dataset_copy = list(dataset) # 把原始数据存放在该函数里
    
    while len(train_lanzi)<train_size: # 循环 当train_lanzi小于train_size一直循环执行下面的语句
        random_choose_some_element = randrange(len(dataset_copy))# 生成指定递增序列的随机数长度是数据的长度
        train_lanzi.append(dataset_copy.pop(random_choose_some_element))# 使用pop函数在dataset_copy中取出random_choose_some_element中的数据追加到train_lanzi列表中
    return train_lanzi,dataset_copy

测试

dataset = [[1],[2],[3],[4],[5],[6],[7],[8],[9],[10]]

train,test = train_test_split(dataset)
train,test

在这里插入图片描述

#seed()被设置了之后，np,random.random()可以按顺序产生一组固定的数组，如果使用相同的seed()值，则每次生成的随机数都相同
#如果不设置这个值，那么每次生成的随机数不同。但是，只在调用的时候seed()一下并不能使生成的随机数相同，需要每次调用都seed()一下，表示种子相同，从而生成的随机数相同。
seed(20210221)

train,test = train_test_split(dataset)
train,test

在这里插入图片描述

k_fold交叉验证

在这里插入图片描述
常用的是对标注数据集做7:3划分训练集和验证集，只用了一部分数据，且结果很大程度上依赖于选取的数据。
LOOCV（Leave-one-out cross-validation）:每次用一个样本测试，其他数据训练。计算量太大。
k_fold cv (k-fold cross validation) ：把数据分K份，每次留一份进行验证，k=N时是loocv。得到k个模型取最优。
k的选取，过大投入训练数据太多，极端例子成为loocv，导致每次训练的数据相关性很大。
过小很难得到较优结果

from random import seed
from random import randrange

# k-fold对训练集，测试集划分函数
def k_fold_cross_validation_split(dataset,folds=10):# 需要传入的数据集，折叠次数
    basket_for_splitted_data=list()# 创建一个空列表存放折叠好的数据
    fold_size = int(len(dataset)/folds) # 数据的长度除以折叠的次数 int整数   # 当数据总数除以折叠次数除不尽的时候丢失部分数据
    dataset_copy = list(dataset) # 把原始数据存放在该函数里
    
    for i in range(folds): # 循环折叠的次数
        basket_for_random_choosen_fold = list()# 存储空列表
        while len(basket_for_random_choosen_fold)<fold_size: # 如果上面存储列表中的个数小于折叠的次数那么就继续循环
            random_choose_some_element = randrange(len(dataset_copy))# 对数据进行打乱（生成指定递增序列的随机数长度是数据的长度）
            basket_for_random_choosen_fold.append(dataset_copy.pop(random_choose_some_element)) # 将打乱后的数据 弹出追加到basket_for_random_choosen_fold列表中
        basket_for_splitted_data.append(basket_for_random_choosen_fold)# 循环结束后讲数据追加回basket_for_splitted_data列表中
    return basket_for_splitted_data

测试

# 测试
dataset = [[1],[2],[3],[4],[5],[6],[7],[8],[9],[10]]

k_folds_split = k_fold_cross_validation_split(dataset,10)
k_folds_split

在这里插入图片描述

在这里插入图片描述

准确度计算代码实现

简单准确度

真实正确个数除以判断正确的个数得到准确率（存在逻辑漏洞）

# 例子
# 正确答案[1,1,1,1,1]
# 预测答案[1,1,1,0,0]
print("准确度:",3/5)

在这里插入图片描述

# 简易模型准确度函数
# calculate accuracy of precdiction 
def calculate_the_accuracy_of_precdiction(actual_data,predicted_data): # 传入实际数据，预测数据
    correct_num = 0 # 记正确的个数
    for i in range(len(actual_data)):# 按照数据的长度进行循环
        if actual_data[i]==predicted_data[i]: # 如果实际第i个数据等于预测数据的第i个
            correct_num+=1 # correct_num正确记数就加1
    return correct_num / float(len(actual_data))  # 预测的正确个数除真实数据个数得出准确值

# 测试
actual_data = [1,1,1,1,1,0,0,0,0,0]
predicted_data = [1,1,1,1,1,1,1,1,1,1]

accuracy = calculate_the_accuracy_of_precdiction(actual_data,predicted_data)
accuracy

在这里插入图片描述

混淆矩阵（误差矩阵）

混淆矩阵也称误差矩阵，是表示精度评价的一种标准格式，用n行n列的矩阵形式来表示。具体评价指标有总体精度、制图精度、用户精度等，这些精度指标从不同的侧面反映了图像分类的精度。 [1] 在人工智能中，混淆矩阵（confusion matrix）是可视化工具，特别用于监督学习，在无监督学习一般叫做匹配矩阵。在图像精度评价中，主要用于比较分类结果和实际测得值，可以把分类结果的精度显示在一个混淆矩阵里面。混淆矩阵是通过将每个实测像元的位置和分类与分类图像中的相应位置和分类相比较计算的。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

代码

# 混淆矩阵函数
def confusion_matrix(actual_data,predicted_data): # 混淆矩阵函数 传入真实值与预测值
    #### 占位+列表解决第一个特性
    unique_class_in_data = set(actual_data)# 使用set去掉重复数据
    matrix = [list() for x in range(len(unique_class_in_data))]# 查看去重后有多少个数据
    for i in range(len(unique_class_in_data)):
        matrix[i] = [0 for x in range(len(unique_class_in_data))] # 有多少个数据就是生成X行X列的表格使用0占位
#     print(unique_class_in_data)
#     print(matrix)
    #### 字典存储与index
    indexing_our_class = dict() # 创建一个空字典来存储数据
    for i,class_value in enumerate(unique_class_in_data):
        indexing_our_class[class_value]=i # 使用循环给去重后的数据增加索引
#     print(indexing_our_class)
    for i in range(len(actual_data)):# 使用真实数据的长度进行循环查找数据
        col = indexing_our_class[actual_data[i]] # 列 真实数据
        row = indexing_our_class[predicted_data[i]] # 行 预测数据
        matrix[row][col] += 1 # 将每次查找到的数据放入matrix进程存储并记录次数
#         print(matrix)
    return unique_class_in_data,matrix

# 调整美化混淆矩阵函数
def pretty_confusion_matrix(unique_class_in_data,matrix): 
    print("(Actual)"+" ".join(str(x) for x in unique_class_in_data))
    print("(Predicted)----------------------")
    for i,x in enumerate(unique_class_in_data):
        print("{}|      {}".format(x," ".join(str(x)for x in matrix[i])))

# 测试
actual_data =    [0,2,0,0,0,1,1,5,2,1] 
predicted_data = [2,0,2,0,1,0,5,0,0,1]
unique_class_in_data,matrix = confusion_matrix(actual_data,predicted_data)
pretty_confusion_matrix(unique_class_in_data,matrix)

在这里插入图片描述

回归误差

Mean Absolute Error（平均绝对误差法）

对于回归问题，最简单的检测误差方法就是：Mean Absolute Error（平均绝对误差法），以下为公式：

$MAE = \frac{
    
    \sum \limits_{
    
    i=1}^n \left | predicted_i -actual_i \right|}{
    
    total \, prediction} $

在这里插入图片描述
例子：

abs(1+1),abs(5-10),abs(1-1)# abs() 函数返回数字的绝对值

在这里插入图片描述

actual_data   =[1,2,3,4,5,2,3,4]
predicted_data=[2,4,3,5,4,1,3,4]

(abs(2-1)+abs(4-2)+abs(3-3)+abs(5-4)+abs(4-5)+abs(1-2)+abs(3-3)+abs(4-4))/8

在这里插入图片描述
我们通过Python实现以上公式

# 平均绝对误差函数
def calculate_the_MAE(predicted_data,actual_data): # 传入预测数据，实际数据
    the_sum_of_error=0 # 最开始误差的和为0通过下面计算不停增加
    for i in range(len(actual_data)):# 依次对数据的长度进行遍历
        the_sum_of_error += abs(predicted_data[i]-actual_data[i]) # 每个预测值减去实际值的结果相加
    MAE=the_sum_of_error/float(len(actual_data)) # 结果除以数据个数
    return MAE

利用数据检测结果

actual_data   =[1,2,3,4,5,2,3,4]
predicted_data=[2,4,3,5,4,1,3,4]

Mean_Absolute_Error=calculate_the_MAE(predicted_data,actual_data)
print(Mean_Absolute_Error)

在这里插入图片描述
但是MAE的方法可能会有分类讨论的情况，我们一般不太用。我们可以用Root Mean Squared Error

Root Mean Squared Error（均方根误差）

# 公式
$RMSE=\sqrt\frac{
    
    \sum \limits_{
    
    i=1}^n(predicted_i - actual_i)^2}{
    
    total \, prediction}$

在这里插入图片描述
例子：

actual_data   =[1,2,3,4,5,2,3,4,10]
predicted_data=[2,4,3,5,4,1,3,4,2]

a = ((2-1)**2)+((4-2)**2)+((3-3)**2)+((5-4)**2)+((4-5)**2)+((1-2)**2)+((3-3)**2)+((4-4)**2+(2-10)**2)
sqrt(a/9.0)

在这里插入图片描述
函数代码：

# 均方根误差函数编写
from math import sqrt #  从math即数学库中导入用于开根运算的方法sqrt
def calculate_the_RMSE(predicted_data,actual_data):
    the_sum_of_error=0
    for i in range(len(actual_data)):
        prediction_error=predicted_data[i]-actual_data[i] # 循环遍历预测值和真实值相减的结果
        the_sum_of_error += (prediction_error**2) # 预测值和真实值相减的结果的平方
    RMSE=sqrt(the_sum_of_error/float(len(actual_data))) # 预测值和真实值相减的结果的平方除以数据个数的开根运算
    return RMSE

actual_data   =[1,2,3,4,5,2,3,4,10]
predicted_data=[2,4,3,5,4,1,3,4,2]
RMSE=calculate_the_RMSE(predicted_data,actual_data)
print(RMSE)

在这里插入图片描述

简易随机预测基准模型建立

Whether the prediction for a given algorithm are good or not? 给定算法的预测是否良好？

分类问题

Baseline Models: 基准模型

Random Prediction Algorithm:随机预测算法：
1.Find unique output values from training data 1.从训练数据中找出唯一的输出值
2.Randomly select output from the unique output set 2.从唯一输出集中随机选择输出

from random import seed
from random import randrange

def Random_Prediction_Algorithm(traning_data,testing_data):
    values=[row[-1] for row in traning_data] # 将训练数据循环放入values中从最后一个开始选
    unique_values=list(set(values)) # 使用set对values中的结果去重
    
    Randomly_predicted_data=list() # 随机预测数据
    for row in testing_data: #对测试数据进行循环
        index=randrange(len(unique_values)) # index的长度为去重后的unique_values长度
        Randomly_predicted_data.append(unique_values[index])# 在去重后的unique_values中通过index方法随机选取并追加到Randomly_predicted_data中
    return Randomly_predicted_data # 返回最终结果
# 测试
seed(8888888888) # 使用seed控制随机
traning_data=[[0],[0],[0],[0],[0],[0],[0],[0],[0],[1]]# 训练数据中只有0和1两类
testing_data=[[None],[None],[None],[None],[None]] # 通过函数随机生成0 or 1的数据

predictions=Random_Prediction_Algorithm(traning_data,testing_data)
print(predictions)

在该模型中我们0有90%1只有1% 最后得到的记过1却比0多
在这里插入图片描述

ZeroR(Zero Rule) Algorithm

ZeroR(Zero Rule) Algorithm
9 [0] and 1[1]: #数据中有 90%是0和1%是1 # 前置条件

  1. If we use the Random Prediction Algorithm: ((0.90.9)+(0.10.1))*100=82%
  2. If we use ZeroR Algorithm , our prediction is 0 : 9/10=90%
from random import seed
from random import randrange

def ZeroR_Algorithm_classification(traning_data,testing_data):
    values=[row[-1] for row in traning_data]
    highest_count=max(set(values),key=values.count)# 选取出values中最多的数字
    ZeroR_prediction=[highest_count for i in range(len(testing_data))] # 将highest_count填充进test数据中长度为testing_data的长度
    return ZeroR_prediction # 返回填充结果
# 测试
seed(888)
traning_data=[[0],[0],[0],[0],[0],[0],[0],[0],[0],[1]]
testing_data=[[None],[None],[None],[None],[None]]
predictions=ZeroR_Algorithm_classification(traning_data,testing_data)
print(predictions)

在这里插入图片描述

线性回归问题

Regression: mean

from random import seed 
from random import randrange
# 建立回归函数
def ZeroR_Algorithm_regression(traning_data,testing_data):
    values=[row[-1] for row in traning_data] # 对测试数据进行迭代
    prediction=sum(values)/float(len(values)) # 使用测试数据总和除以数据个数
    ZeroR_prediction=[prediction for i in range(len(testing_data))] # 把均值按照测试数据的长度填充
    return ZeroR_prediction
# 测试
seed(888)
traning_data=[[1],[2],[3],[4],[5],[6],[7],[8],[9],[10]]
testing_data=[[None],[None],[None],[None],[None],[None],[None],[None],[None],[None]]

prediciton=ZeroR_Algorithm_regression(traning_data,testing_data)
print(prediciton)

在这里插入图片描述

猜你喜欢

转载自blog.csdn.net/qq_37978800/article/details/113886261
今日推荐
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
周排行
NEFU 117 素数个数的位数
Closest Common Ancestors (Lca,tarjan)
ELK部署
【转载】Hive笔记整理（三）
SQL语句（一）基本表的定义
关于Java web开发中的MySQL的事务语句
MFC创建自定义窗体
如何用一句话激怒程序员？
《逆袭大学》文摘——9.4 基础和应用的平衡中找到大学的节奏
【spring源码分析】@Value注解原理
每日归档
更多
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022