[数据挖掘] 朴素贝叶斯 以及西瓜集特征工程
2024-06-06 09:22:46
朴素贝叶斯 以及西瓜数据集的特征工程
- 朴素贝叶斯的基本思想
- 朴素贝叶斯分类的过程
- 数据集:
- 版本1
- 记录一下代码有多烂:
- 评估
- 版本2
- 训练
- 预测:
- 结果即评估:
- 版本3
- 简介:
- 数据集特征工程
- OneHotEncoder 与LabelEncoder
- pandas 给我弄晕了的方法:
- 取值
- 集合
- 赋值
- 特殊索引 *** 我记得numpy 也是这样
- 代码
朴素贝叶斯的基本思想
- 先验概率: 通过已知事实, 推论出未知事务出现的概率
例如: 通过硬币有两面, 推论出抛一次硬币可能出现正面的概率 - 后验概率: 通过结果, 推论出导致该结果的原因的概率
例如: 通过硬币抛出来之后是正面, 需要你来判断该硬币被你做手法了的概率
关于先验概率 与 后验概率的理解: https://www.cnblogs.com/yemanxiaozu/p/7680761.html
- 贝叶斯公式:
- 其中, B 是 该事件最后的结果, A 是表示导致该结果的原因, 再结合我们之前对后验概率的理解, 可以知道, 贝叶斯公式的结果就是导致结果B出现的可能性
- 在机器学习中, 对于一个需要预测的数据, 我们知道的是它的各种已知信息相当于公式中的A, 而我们要求的是最后对他的各个分类的概率, 这个分类就相当于公式中的 B, 于是 我们的公式可以表示为:
- 机器学习—朴素贝叶斯: 对于上述的贝叶斯公式, 其中已知的 A 可以看作该数据的特征, 而我们假定该数据的各个特征是独立的, 所以对于p(特征|类别), 我们可以分解为 p(特征1|类别) * p(特征2|类别) * p(特征3|类别) … 这就是朴素的意思, 而对于需预测的数据来说, 我们p(特征), p(类别) 是很容易通过大量数据得到的已知值
- 引用西瓜书上说的:
其中ck表示第k 个分类, xj 表示第j个特征值, Y是该数据最终的分类结果
- 因此 我们需要训练的是什么呢:
每个特征属于每个分类的概率 - 通过被预测数据的特征, 从训练出来的分类器中查找每个特征在每个分类的概率相乘(朴素)
- 得到该数据最终属于每个分类的概率, 选出概率最大的为其最后的分类
- 引用西瓜书上说的:
- 本文算法代码只讨论二分类情况
朴素贝叶斯分类的过程
- 数据获取: 任意方式获取
- 数据分析: 得到其独立同分布的特征, 应用朴素这一条件
- 训练过程:
- 若是离散值: 获取每一个特征在每一个分类下的可能性
- 若是连续值: 假定其符合正态分布, 计算其一维正态分布值:
- 预测过程: 获取数据各个特征, 计算其属于每个分类的概率, 选出最大概率作为其分类结果
- 模型评估: 本章采用 留出法, k折交叉验证法(留一法), 自助法, 结果为
[真正例, 假正例, 真负例, 假负例]- 性能评估: 准确率
数据集:
1,青绿,蜷缩,浊响,清晰,凹陷,硬滑,0.697,0.46,是
2,乌黑,蜷缩,沉闷,清晰,凹陷,硬滑,0.774,0.376,是
3,乌黑,蜷缩,浊响,清晰,凹陷,硬滑,0.634,0.264,是
4,青绿,蜷缩,沉闷,清晰,凹陷,硬滑,0.608,0.318,是
5,浅白,蜷缩,浊响,清晰,凹陷,硬滑,0.556,0.215,是
6,青绿,稍蜷,浊响,清晰,稍凹,软粘,0.403,0.237,是
7,乌黑,稍蜷,浊响,稍糊,稍凹,软粘,0.481,0.149,是
8,乌黑,稍蜷,浊响,清晰,稍凹,硬滑,0.437,0.211,是
9,乌黑,稍蜷,沉闷,稍糊,稍凹,硬滑,0.666,0.091,否
10,青绿,硬挺,清脆,清晰,平坦,软粘,0.243,0.267,否
11,浅白,硬挺,清脆,模糊,平坦,硬滑,0.245,0.057,否
12,浅白,蜷缩,浊响,模糊,平坦,软粘,0.343,0.099,否
13,青绿,稍蜷,浊响,稍糊,凹陷,硬滑,0.639,0.161,否
14,浅白,稍蜷,沉闷,稍糊,凹陷,硬滑,0.657,0.198,否
15,乌黑,稍蜷,浊响,清晰,稍凹,软粘,0.36,0.37,否
16,浅白,蜷缩,浊响,模糊,平坦,硬滑,0.593,0.042,否
17,青绿,蜷缩,沉闷,稍糊,稍凹,硬滑,0.719,0.103,否
- 特征包含了离散值与连续值, 最后是数据标签
- 可看到连续值已经处于 (0,1)之间了, 因此不需要归一化处理
版本1
- 这个版本只完成了最基础的西瓜数据集的朴素贝叶斯分类
- 写的时候发现每次预测都要训练, 然后, 想到把训练与预测分类, 就可以多次使用分类器了, 然后有了版本2
记录一下代码有多烂:
import numpy as np
import mathdef label_count(dataset):"""计算每个分类结果的概率:param dataset:[ [feat], [feat], [feat], ... , [label], ]:return: p(label) : {label: prob, }"""label = {}for i in dataset:if i[-1] not in label.keys():label[i[-1]] = 0label[i[-1]] += 1return labeldef feat_count(dataset, item, label, labels):"""计算某个特征向量被分类为label的概率:param dataset::param labels 每种分类的概率:param item: 特征向量:return:"""feat_num = np.array([0 for _ in item], np.float32)for i in range(len(item)):if isinstance(item[i], (float, int)):set_i = np.array([j[i] for j in dataset])u = set_i.mean()std = set_i.std()feat_num[i] = (1/(math.sqrt(2*math.pi)*std)) * math.pow(math.e, -1*(feat_num[i] - u)**2 / (2*(std**2)))else:for j in dataset:if item[i] == j[i] and j[-1] == label:feat_num[i] += 1feat_num[i] /= labels[label]return feat_numdef classification(item, dataset):"""返回属于每一种分类的可能性:param item::param dataset::return:"""labels = label_count(dataset)data_num = len(dataset)ans = {}for label in labels:feat_num = feat_count(dataset, item, label, labels)ans[label] = 1for i in feat_num:ans[label] *= ians[label] *= float(labels[label]) / float(data_num)return sorted(ans.items(), key=lambda j: j[1], reverse=True)def fun(i):i = i.strip()try:i = float(i)except ValueError:passreturn idef read_data(path):dataset = []with open(path, 'r', encoding='utf8') as f:for line in f.readlines():split_ = line.strip().split(',')[1:]dataset.append([i for i in map(fun, split_)])return datasetif __name__ == '__main__':path = "xigua.txt"dataset = read_data(path)pre_data = '青绿,蜷缩,浊响,清晰,凹陷,硬滑,0.697, 0.460'item = [i for i in pre_data.strip().split(',')]item = [i for i in map(fun, item)]print(item)l = classification(item, dataset)print(l)
结果:
评估
把数据集放进去, 分出测试集与训练集, 进行评估即可
结果:
[真正例, 假正例, 真负例, 假负例]
版本2
- 这个版本把训练过程 与测试过程分开了
- 加入了拉普拉斯假设: 即把为0的特征进行+1, 避免了该分类可能性为0
- 最后给每个特征概率的结果相乘改成了: 最后求log后相加, 避免了特征很多的时候出现的大误差
- 写的时候想到了是不是可以用矩阵运算来避免遍历过程, 以及面向对象.于是出现了版本3
训练
- 训练返回结果的数据结构:
- 离散型, feat_pos_count, feat_neg_count, 表示分类结果为正例和负例的计数
{
特征1:{value1: count, value2: count},
特征2:{value1: count, value2: count},
…
} - 连续型, numer_feat
{
连续型特征: {‘u’: 平均数, ‘std’: 标准差},
…
} - pos_prob: 正例占总数的可能性, 负例直接 1-pos_prob
- 离散型, feat_pos_count, feat_neg_count, 表示分类结果为正例和负例的计数
- 训练过程就是计数而已, 很简单
def n_attribute(u, std, x):return (1/(sqrt(2*pi)*std)) * pow(e, -1*(x - u)**2 / (2*(std**2)))def train_bayesian_2_classify(dataset):"""2分类器, 1--正, 0--负训练贝叶斯分类器, 即得到每个特征值的条件概率:param dataset:最后一列是label 其他作为特征值:return:"""# 初始化每个特征有一个计数,避免最后概率为0. 拉普拉斯校准feat_num = len(dataset[0])-1feat_pos_count = [dict() for _ in range(feat_num)]feat_neg_count = [dict() for _ in range(feat_num)]# 获取正负例数pos_num = 0.0neg_num = 0.0data_num = len(dataset)numer_feat = []for i in range(feat_num):if isinstance(dataset[0][i], (float,)):numer_feat.append(i)for i in range(data_num):for j in range(feat_num):if j not in numer_feat:if dataset[i][j] not in feat_pos_count[j].keys():feat_pos_count[j][dataset[i][j]] = 0feat_neg_count[j][dataset[i][j]] = 0if dataset[i][-1] == 1: # 在正例条件下,对该特征计数feat_pos_count[j][dataset[i][j]] += 1else:feat_neg_count[j][dataset[i][j]] += 1if dataset[i][-1] == 1:pos_num += 1else:neg_num += 1pos_prob = pos_num / float(data_num)for i in range(feat_num):if i not in numer_feat:for k in feat_pos_count[i]:if feat_pos_count[i][k] == 0:feat_pos_count[i][k] = 1pos_num += 1if feat_neg_count[i][k] == 0:feat_neg_count[i][k] = 1neg_num += 1for i in range(feat_num):if i not in numer_feat:for k in feat_pos_count[i]:feat_pos_count[i][k] /= float(pos_num)feat_neg_count[i][k] /= float(neg_num)# 计算标称属性的均值与方差for i in numer_feat:set_i = np.array([j[i] for j in dataset])u = set_i.mean()std = set_i.std()feat_pos_count[i]['u'] = ufeat_pos_count[i]['std'] = stdfeat_neg_count[i]['u'] = ufeat_neg_count[i]['std'] = stdreturn pos_prob, feat_pos_count, feat_neg_count, numer_feat
预测:
- 预测对于离散特征, 直接从训练结果中查询,
对于连续型特征, 从训练结果中查询出u 与 std, 计算结果即可 - 代码
def prediction(pos_prob, feat_pos_count, feat_neg_count, numer_feat, item):feat_num = len(item)# log 化 去除精度问题res_p = 0res_n = 0for i in range(feat_num):if i not in numer_feat:res_p += log2(feat_pos_count[i][item[i]])res_n += log2(feat_neg_count[i][item[i]])else:res_p += log2(n_attribute(feat_pos_count[i]['u'], feat_pos_count[i]['std'], item[i]))res_n += log2(n_attribute(feat_neg_count[i]['u'], feat_neg_count[i]['std'], item[i]))res_p += log2(pos_prob)res_n += log2(1-pos_prob)l = [(1, res_p,), (0, res_n)]l.sort(key=lambda i:i[1], reverse=True)return l
结果即评估:
- 预测结果:
- 评估结果
版本3
简介:
- 面向对象,
- 分类器一个对象
- 特征工程一个对象
- 模型评估为一个对象
- 因为想到对离散特征每一个值都需要进行计数, 因此想到直接使用独热编码, 扩展维度: 把每个特征值当成一个新的维度
- pandas来存储数据以及数据处理, 减少了很多遍历, 直接矩阵方法运算\
- 哇, 写不下去了, 想到我在写这个代码的时候因为pandas用得不熟, 各种bug, 各种查资料, 大部分时间都在解决pandas的bug去了, 直接看代码吧, 这个代码的鲁棒性很大提高,应该可以用到很多数据集上了…但是, 数据集太小, 也不知道实际模型效果如何, 实在没时间弄了,
数据集特征工程
OneHotEncoder 与LabelEncoder
sklearn.preprocessing 里面包含了两种对离散数据的编码工具:
OneHotEncoder: 只能对数字进行处理, 所以在处理string数据的时候必须先转化成数字形式, 例:
from sklearn.preprocessing import LabelEncoder from sklearn.preprocessing import OneHotEncoder enc = OneHotEncoder() # 训练 传入二维数据集 enc.fit_transform([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2],[1,1,1]]) print(enc.n_values_) # 打印每个特征的值的个数 enc.transform([[0,1,3]]).toarray()结果:
[2 3 4]array([[1., 0., 0., 1., 0., 0., 0., 0., 1.]])- LabelEncoder: 对离散的文本或者数字进行编号, 可以对字符串的特征向量进行处理, 可以进行逆编码: 即把编码之后的编号还原成特征值描述 inverse_transform()
pandas 自带的编码方法::
独热编码: pd.get_dummies(), 可以对字符串进行处理, 而连续型的特征会自动忽略.
例:print(dataset.head(3)) new_dataset = pd.get_dummies(dataset) print(new_dataset.head(3))结果:
标签编码: pd.Categorical().codes
不知道这个方法与 sklearn的有什么不一样, 具体待查阅资料结论: 如果只需要对数据进行处理, 那么 pandas自带的方法更好用
如果需要获取训练出来的编码器, 那么 sklearn会保存这个编码器, 在你对新的数据进行处理的时候, 可以直接使用该编码器得到跟训练数据一样的编码
pandas 给我弄晕了的方法:
取值
- pd.loc[index] -->return Series
- pd.loc[[index]] / pd.reindex([]) -->return DataFrame , 一般用后一种方法 reindex
- pd.iloc[] 跟loc 一样, 获取某一行, 不过传入的是行的下标
- pd.iloc[[]]
- pd[col_name] --> , return Series 直接获取某一列, 的值
- pd[[col_name]] --> return DataFrame
- pd.at[index, col_name] --> 获取某一个数据点
集合
并集: append
差集: 比如 求 df1 与 df2 的差集
df1.append(df2).append(df2).drop_duplicates(keep=False)即: 对其中一个元素 append两次, 然后再在最后去重, 参数表示把重复的元素都删掉, 如果 keep=True, 会保留重复元素的第一个
赋值
- pd.at[r, c] = x
- pd.[col_name] = Series, 如果, 这一列不存在 则添加新的一列
- pd.loc[[index]] = Series, 给某一行赋值, 不存在这一行报错
- DataFrame.append --> 与下面一样
- series.append(series) --> 在series下面拼接, 不改变原元素, 返回新的Series
特殊索引 *** 我记得numpy 也是这样
- 在df[]的中括号里面传入与 df 的列数匹配的Series, 返回里面为 True 的值
- 看两个例子
>>> import pandas as pd >>> pd.DataFrame([[1,2,3], [2,3,4]])0 1 2 0 1 2 3 1 2 3 4 >>> pd <module 'pandas' from 'D:\\software\\Python3.6\\lib\\site->packages\\pandas\\__init__.py'> >>> df = pd.DataFrame([[1,2,3], [2,3,4]]) >>> s = pd.Series([True, True, False]) >>> s 0 True 1 True 2 False dtype: bool >>> df[s] __main__:1: UserWarning: Boolean Series key will be reindexed to match >DataFrame index.0 1 2 0 1 2 3 1 2 3 4 >>> s = pd.Series([True,False, False]) >>> df[s]0 1 2 0 1 2 3 >>>
代码
- 特征工程方法
def feat_handle(dataset, dis_cols, cont_cols, v_col):"""特征工程,:param dataset: DataFrame原始数据集 pd.DataFrame:param dis_cols: list 离散特征列 [clo1, col2, col3 ...]:param cont_cols: list 连续特征列 [col1, col2, col3]:param v_col: int/str 数据标签(类别) 所在的列名:return:"""values = dataset[v_col]discrete_data = dataset[dis_cols]# print('原始数据')# print(dataset.head())enc = OneHotEncoder()X = enc.fit_transform(discrete_data)discrete_data = pd.DataFrame(X.toarray())# discrete_data = pd.get_dummies(discrete_data)# print('\n编码后')# print(discrete_data.head())continuous_data = dataset[cont_cols]# print('连续特征')# print(continuous_data.head())# 给最终分类结果 标签编码 1, 0:# values = values.apply(lambda x: pd.Categorical(x).codes)[v_col]le = LabelEncoder()Y = le.fit_transform(values)values = pd.Series(Y)# print('数据标签 y向量:')# print(values.head())return continuous_data, discrete_data, values, enc, le- 二分类分类器:
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import OneHotEncoder
import numpy as np
import pandas as pdclass Bayes_2:def __init__(self, discrete_data, continuous_data, values):self.dis_data = discrete_dataself.con_data = continuous_data# 这个是series类型self.V = valuesself.feat_prob = pd.DataFrame(columns=discrete_data.keys(), index=[0, 1])self.con_charct_1 = pd.DataFrame(columns=continuous_data.keys(), index=['std', 'mean'])self.con_charct_0 = pd.DataFrame(columns=continuous_data.keys(), index=['std', 'mean'])self.prob_0 = 0.0self.prob_1 = 0.0def train(self):# 拉普拉斯校准的计数count1_off = 0count0_off = 0for key in self.feat_prob.keys():# print(self.dis_data.loc[self.dis_data[key] == 1].index)# print(self.V[self.V == 1].index)# print(self.V[self.V == 1].index & self.dis_data.loc[self.dis_data[key] == 1].index)self.feat_prob.at[1, key] = self.dis_data[key].reindex(self.V[self.V == 1].index & self.dis_data.loc[self.dis_data[key] == 1].index).count()if self.feat_prob.at[1, key] == 0:count1_off += 1self.feat_prob.at[0, key] = self.dis_data[key].reindex(self.V[self.V == 0].index & self.dis_data.loc[self.dis_data[key] == 1].index).count()if self.feat_prob.at[0, key] == 0:count0_off += 1# print(self.feat_prob)p1 = self.V[self.V == 1].count()count = self.V.count()p0 = count - p1self.prob_1 = p1 / float(count)self.prob_0 = p0 / float(count)self.feat_prob.loc[1] /= float(p1 + count1_off)self.feat_prob.loc[0] /= float(p0 + count0_off)# 计算连续型数据的标准差和平均值for key in self.con_data.keys():self.con_charct_1.at['std', key] = self.con_data[key].reindex(self.V[self.V == 1].index).std()self.con_charct_0.at['std', key] = self.con_data[key].reindex(self.V[self.V == 0].index).std()self.con_charct_1.at['mean', key] = self.con_data[key].reindex(self.V[self.V == 1].index).mean()self.con_charct_0.at['mean', key] = self.con_data[key].reindex(self.V[self.V == 0].index).mean()def predict(self, dis_feat, conti_feat):# 获取预测数据每个特征值取得的概率feat_1 = self.feat_prob.loc[1] * dis_featfeat_0 = self.feat_prob.loc[0] * dis_feat# log化feat_1 = feat_1.apply(lambda x: np.log2(np.float64(x.values)) if x.values > 0 else 0)feat_0 = feat_0.apply(lambda x: np.log2(np.float64(x.values)) if x.values > 0 else 0)# 获取预测数据离散特征值的正太分布函数值 并log化# print(self.con_charct_1)conti_feat_1 = conti_feat.apply(lambda x: self._norm_value(x, self.con_charct_1.at['std', x.name], self.con_charct_1.at['mean', x.name]))conti_feat_0 = conti_feat.apply(lambda x: self._norm_value(x, self.con_charct_0.at['std', x.name], self.con_charct_0.at['mean', x.name]))# print(conti_feat)# log结果 累加 相当于非log的累乘pre_1 = feat_1.sum() + conti_feat_1.values.sum() + np.log2(self.prob_1)pre_0 = feat_0.sum() + conti_feat_0.values.sum() + np.log2(self.prob_0)return sorted([(1, pre_1), (0, pre_0)],key=lambda x: x[1], reverse=True)def _norm_value(self, x, std, u):return (1/(np.sqrt(2*np.pi)*std)) * pow(np.e, -1*(x - u)**2 / (2*(std**2)))def evolut_hold_out(self, t=0.3):pass
- 评估, 这块的代码.鲁棒性不强, 不知道其他数据集上能不能用
class Evolutor:def __init__(self, learner, dataset, cont_cols, dis_cols, v_col):self.learner = learnerself.dataset = datasetself.dis_cols = dis_colsself.cont_cols = cont_colsself.v_col = v_coldef feat_handle(self):# 进行特征工程self.continuous_data, self.discrete_data, self.values, self.enc, self.le = feat_handle(self.dataset, self.dis_cols, self.cont_cols,self.v_col)def hold_out(self, t=0.3, times=1):self.feat_handle()# 真正例, 假正例, 真负例, 假付例assem = [0, 0, 0, 0]testset = list()trainset = list()for _ in range(times):test1num = int(len(self.values[self.values == 1]) * t)test0num = int(len(self.values[self.values == 0]) * t)testnum = test1num + test0num# 随机选择 testnum个数据test1_index = np.random.choice(self.discrete_data.iloc[self.values[self.values == 1].index].index, test1num)test0_index = np.random.choice(self.discrete_data.iloc[self.values[self.values == 0].index].index, test0num)testset.append(self.discrete_data.reindex(np.append(test1_index, test0_index)))testset.append(self.continuous_data.reindex(np.append(test1_index, test0_index)))testset.append(self.values[np.append(test1_index, test0_index)]) # 这里有 bug# 得到dataset与testset的差集tmp = self.discrete_data.append(testset[0]).append(testset[0])trainset.append(tmp.drop_duplicates(keep=False))tmp = self.continuous_data.append(testset[1]).append(testset[1])trainset.append(tmp.drop_duplicates(keep=False))trainset.append(self.values[list(filter(lambda x: x not in testset[2].index, self.values.index))])## 进行贝叶斯分类for i in range(testnum):self.learner = Bayes_2(trainset[0], trainset[1], trainset[2])self.learner.train()pre_dis_v = testset[0].iloc[[i]]pre_cont_v = testset[1].iloc[[i]]res = self.learner.predict(pre_dis_v, pre_cont_v)# print(testset[2].iloc[i])# print(res)if testset[2].iloc[i] == '是' or testset[2].iloc[i] == 1:if res[0][0] == '是' or res[0][0] == 1:assem[0] += 1else:assem[3] += 1elif testset[2].iloc[i] == '否' or testset[2].iloc[i] == 0:if res[0][0] == '否' or res[0][0] == 0:assem[2] += 1else:assem[1] += 1# assem = [0,0,0,0]# assem = [i / times for i in assem]print('留出法,测试集比例:t={0},结果:{1}'.format(t, assem))return assemdef cross_validate(self):"""留一法:return:"""# 真正例, 假正例, 真负例, 假负例assem = [0, 0, 0, 0]datanum = len(self.dataset)for i in range(datanum):item = self.dataset.iloc[[i]]trainset = self.dataset.iloc[:i]trainset = trainset.append(self.dataset.iloc[i + 1:])# 进行特征工程continuous_data, discrete_data, values, enc, le = feat_handle(self.dataset, self.dis_cols, self.cont_cols,self.v_col)self.learner = Bayes_2(discrete_data, continuous_data, values)self.learner.train()pre_dis_v = pd.DataFrame(enc.transform(item[self.dis_cols]).toarray())pre_cont_v = item[self.cont_cols]res = self.learner.predict(pre_dis_v, pre_cont_v)if item.iloc[0][self.v_col] == '是' or item.iloc[0][self.v_col] == 1:if res[0][0] == '是' or res[0][0] == 1:assem[0] += 1else:assem[3] += 1elif item.iloc[0][self.v_col] == '否' or item.iloc[0][self.v_col] == 0:if res[0][0] == '否' or res[0][0] == 0:assem[2] += 1else:assem[1] += 1print('留1法:{0}'.format(assem))return assemdef bootstrap(self):assem = [0, 0, 0, 0]data_num = len(self.dataset)test_index = np.random.randint(0, data_num-1, data_num)testset = self.dataset.iloc[test_index]trainset = self.dataset.copy()# 进行特征工程continuous_data, discrete_data, values, enc, le = feat_handle(self.dataset, self.dis_cols, self.cont_cols,self.v_col)self.learner = Bayes_2(discrete_data, continuous_data, values)self.learner.train()for i in range(len(testset)):item = testset.iloc[[i]]pre_dis_v = pd.DataFrame(enc.transform(item[self.dis_cols]).toarray())pre_cont_v = item[self.cont_cols]res = self.learner.predict(pre_dis_v, pre_cont_v)if item.iloc[0][self.v_col] == '是' or item.iloc[0][self.v_col] == 1:if res[0][0] == '是' or res[0][0] == 1:assem[0] += 1else:assem[3] += 1elif item.iloc[0][self.v_col] == '否' or item.iloc[0][self.v_col] == 0:if res[0][0] == '否' or res[0][0] == 0:assem[2] += 1else:assem[1] += 1print('自助法:{0}'.format(assem))return assem- 主函数
if __name__ == '__main__':path = r"D:\Workspace\Pyworkspase\DataMining\Bayesian\xigua.txt"# 数据获取dataset = pd.read_csv(path, ",", header=None, usecols=[i for i in range(1, 10)])dis_cols = [i for i in range(1, 7)]cont_cols = [7, 8]v_col = 9print('特征工程','-'*100)# 特征工程, 获取 one-hot编码器 与 label编码器, 还有数据里面的编码后的离散值与连续值向量 以及 最后每条数据的标签向量continuous_data, discrete_data, values, enc, le = feat_handle(dataset, dis_cols, cont_cols, v_col)print('-'*100)# 训练print('训练:', '-'*100)bayes = Bayes_2(discrete_data, continuous_data, values)bayes.train()print('-'*100)print('预测', '-'*100)# 1,青绿,蜷缩,浊响,清晰,凹陷,硬滑,0.697,0.46pre_data = pd.DataFrame([['1','青绿','蜷缩','浊响','清晰','凹陷','硬滑',0.697,0.46]])print('预测数据:', pre_data.values)# 给预测数据进行处理pre_dis_v = pd.DataFrame(enc.transform(pre_data[dis_cols]).toarray())pre_cont_v = pre_data[cont_cols]# 预测res = bayes.predict(pre_dis_v, pre_cont_v)print('预测结果:', res)print('-'*100)# 模型评估print('评估结果:')evolutor = Evolutor(None, dataset, cont_cols, dis_cols, v_col)evolutor.hold_out(times=1)evolutor.cross_validate()evolutor.bootstrap()
- 结果
特征工程 ----------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------
训练: ----------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------
预测 ----------------------------------------------------------------------------------------------------
预测数据: [['1' '青绿' '蜷缩' '浊响' '清晰' '凹陷' '硬滑' 0.697 0.46]]
预测结果: [(1, -5.644075586912031), (0, -8.912675295359993)]
----------------------------------------------------------------------------------------------------
评估结果:
留出法,测试集比例:t=0.3,结果:[2, 2, 0, 0]
留1法:[6, 3, 6, 2]
自助法:[8, 3, 5, 1][数据挖掘] 朴素贝叶斯 以及西瓜集特征工程相关推荐
- 朴素贝叶斯（西瓜数据集分类，社区恶意留言分类，垃圾邮件分类，新浪新闻分类），AODE分类器 代码实现
朴素贝叶斯(西瓜数据集分类,社区恶意留言分类,垃圾邮件分类,新浪新闻分类),AODE分类器 代码实现 以下代码为本人学习后,修改或补充后的代码实现,数据集和原代码请参考:https://github. ...
- 数据挖掘-朴素贝叶斯算法的R实现
本次为学生时期所写的实验报告,代码程序为课堂学习和自学,对网络程序有所参考,如有雷同,望指出出处,谢谢! 基础知识来自教材:李航的<统计学习方法> 本人小白,仍在不断学习中,有错误的地方恳 ...
- 数据挖掘-朴素贝叶斯算法
微信搜索:"二十同学" 公众号,欢迎关注一条不一样的成长之路 我个人认为,在数据挖掘领域,分类算法是最为重要.它根据以往的数据来对新的数据做预测.垃圾邮件判断,潜在用户挖掘等都会用 ...
- 朴素贝叶斯算法之鸢尾花特征分类【机器学习】【伯努利分布,多项式分布,高斯分布】
文章目录 一.前言 1.1 本文原理 1.2 本文目的 二.实验过程 2.1使用BernoulliNB(伯努利分布)给鸢尾花分类,写出代码,对运行结果截图并对分类结果进行分析: 2.2 使用Multi ...
- 基于.NET实现数据挖掘--朴素贝叶斯算法
本篇文章主要是继续上两篇Microsoft决策树分析算法和Microsoft聚类分析算法后,采用另外更为简单一种分析算法对目标顾客群体的挖掘,同样的利用微软案例数据进行简要总结.有兴趣的同学可以先参照 ...
- 【互联网大厂机试真题 - 科大讯飞】朴素贝叶斯挑西瓜
前言:本专栏将持续更新互联网大厂机试真题,并进行详细的分析与解答,包含完整的代码实现,希望可以帮助到正在努力的你.关于大厂机试流程.面经.面试指导等,如有任何疑问,欢迎联系我,wechat:steve ...
- 基于朴素贝叶斯分类器的西瓜数据集 2.0 预测分类_朴素贝叶斯为什么被称为“朴素”？...
一.基本理解 1.朴素贝叶斯分类器: 例:如果有一种水果具有红.椭圆形.直径约3英寸等特征,则该水果可以被判定为是苹果. 尽管这些特征相互依赖或者有些特征由其他特征决定,然而朴素贝叶斯分类器认为这些属 ...
- 机器学习(7): 朴素贝叶斯算法 小结及实验
文章目录 1 朴素贝叶斯简介 2 条件概率与全概率公式 3 贝叶斯推断 4 引例 5 朴素贝叶斯算法分类 (1) GaussianNB (2) MultinomialNB (3) BernoulliN ...
- Spark MLlib 源码学习---朴素贝叶斯模型(Naive Bayes)
朴素贝叶斯是机器学习中比较常用的一种模型,尤其在文本分类的问题上是比较常用的baseline.朴素贝叶斯本身训练速度快,具有可并行化程度高,可解释性好的优点,但由于其对特征之间的独立性假设不是很符合某 ...
最新文章
- mac python3.8怎样安装scrapy_Python爬虫与mac下Scrapy配置
- 图：DFS(深度优先搜索)图解分析代码实现
- 中国美丽乡村建设投融资及十四五发展规划分析报告2022-2028年版
- 机器学习06神经网络--学习
- 25年前，互联网大佬在最原始的论坛网上冲浪
- linux mint 18.3浏览器,在Ubuntu 18.04/Linux Mint 19中安装Chromium浏览器的方法
- IDEA配置JavaScript库
- 注册ActiveX控件 未在此计算机上注册ActiveX控件！！！
- 用照片进行三维模型重建
- 8 种流行的计算机视觉应用
- 守望先锋app（2）
- 利用pm2 启动node项目
- 软件架构之前后端分离与前端模块化发展史
- 洛谷P1757 通天之分组背包
- 单细胞拟时分析：基因及通路随拟时表达变化趋势
- Linux /dev/mapper/ubuntu--vg-ubuntu--lv 磁盘空间不足的问题
- 视频增强，去雾的实现 BU6521KV
- Qt之标签和单行文本编辑框(QLabel、QLineEdit)
- USACO 3.2 Sweet Butter 香甜的黄油
- 刘振飞BugFree管理系统的功能与使用（一）