读取数据函数
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 # 前置条件
- 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 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)