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

读取数据函数

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-1return 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-1return 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正确记数就加1return 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)#### 字典存储与indexindexing_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=0for 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 randrangedef 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 # 前置条件

If we use the Random Prediction Algorithm: ((0.90.9)+(0.10.1))*100=82%
If we use ZeroR Algorithm , our prediction is 0 : 9/10=90%

from random import seed
from random import randrangedef 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)