【数据挖掘】技术点总结

第一天
一、 了解数据分析与数据挖掘
1、 数据挖掘的过程
1、定义目标
2、获取数据
3、数据探索:对数据初步的研究
4、数据预处理(数据清洗–数据集成–规范化数据–数据规约即数据标准化)
5、挖掘建模(分类、聚类、关联、预测)
6、模型评价与发布
二、 数据分析与数据挖掘中相关模块的简介与安装
1、 模块简介
Numpy:处理数据,提供数组的支持,很多模块的基础
Pandas:数据探索和数据分析
Matplotlib:作图和可视化
Scipy:数值计算、支持矩阵运算
Statsmodels:统计分析
Gensim:文本挖掘
Sklearn、keras:机器学习和深度学习
2、 模块安装与技巧
Numpy、mkl—下载安装
Pandas网络安装
Matplotlib—网络安装
Scipy—下载安装
Statsmodels—网络安装
Gensim—网络安装
3、 相关模块的基本使用
import numpy
#创建数组的格式
x=numpy.array([5,4,8,9,5,6,7,2])
#创建二维数组
y=numpy.array([[1,2,3],[4,5,6],[9,8,7]])
#数组取元素
a=x[2]
b=y[2][0]
#数组中的排序
x.sort()
y.sort()
#取最值
m=x.max()
n=y.min()

#切片操作:数组[起始下标:最终下标+1]
x[1:3] #最终的下标是1、2
x[:2] #表示从最开始开始取,一直到2的前一个元素
x[1:] #从1开始一直取到最后

#取别名
import pandas as pda
“”"
series:表示的是某一串数字,代表的是长或者列
DataFrame:代表的是长和列
“”"
a=pda.Series([8,9,2,1])
#我们把a的第一列称为它的索引index
#接下来我们指定索引
b=pda.Series([8,9,2,1],index=[“one”,“two”,“three”,“four”])
#可以使用dataframe来创建数据框
c=pda.DataFrame([[5,4,6],[8,9,7],[6,7,2]])
d=pda.DataFrame([[5,4,6],[8,9,7],[6,7,2]],columns=[“one”,“two”,“three”],index=[“one”,“two”,“three”])
#使用字典的方式创建数据框
f=pda.DataFrame({
“one”:4,
“two”:[6,5,2],
“three”:list(str(982))
})
s=d.head(2) #取数据的前2行
e=d.tail(1)#取数据的后1行
#统计数据的相关信息,分别代表元素的:个数、平均数、标准差、最小值、四等份差以及最大值
ms=d.describe()
#数据的转制
zz=f.T
三、python中数据导入的实战
#数据导入CSV格式的数据
import pandas as pda
i=pda.read_csv(“D:/python/bilibili/temp/1.csv”)
j=i.describe()
#i.sort_values(by=“1”) #按照某一列进行排序,这里的1表示该列的列名,程序会自动把csv文件的第一行作为列名
#导入excel数据
m=pda.read_excel(“D:/python/bilibili/temp/志愿填报.xls”)
n=m.describe()
#MYSQL数据库数据
import pymysql
conn=pymysql.connect(host=“localhost”,user=“root”,passwd=“gfb123”,db=“test”)
sql=“select * from user”
k=pda.read_sql(sql,conn)
#导入html数据:直接会对html中的表格进行读取,但在使用之前必须安装html5lib模块和beautifulsoup4模块
pda.read_html(“D:/python/bilibili/temp/1.html”)
pda.read_html(“https://movie.douban.com/review/best/1.html”)
#导入文本数据
pda.read_table(“https://movie.douban.com/review/best/abc.txt”)
注意:安装以下模块
Numpy、mkl
Pandas
Matplotlib
Scripy
Statsmodel
Gensim
第二天
一、 matplotlib基础
1、 折线图/散点图(plot)
#折线图和散点图
import matplotlib.pyplot as pyl
import numpy as nup
x=nup.array([1,2,3,4,5,6,7,8,9,10])
y=nup.array([1,1.5,2.5,6,7,8,9,6,5,1])
pyl.plot(x,y)

基本知识
Pyl.plot(x,y,[展现形式])
Pyl.show()
颜色:c-青色、r-红色、m-品红、g-绿色、b-蓝色、y-黄色、k-黑色、w-白色
线条:-:直线、–:虚线、“:”:虚线(细线)
点的样式:s-方形、h-六角形、H-六角形、*-星形、±“+”号形线、x-‘x’型、D和d-菱形、p-五角星
Title(“show”):标题
Xlabel(“ages”)
Ylabel(“temp”)
Xlim(0,20)
Ylim(5,18)
散点图
pyl.plot(x,y,’o’)
pyl.plot(x,y,’c’)

注意:可以使用多个ploy来在一张图上实现多条线。
2、 随机数的生产
Import numpy as npy
生成正常的随机数
Data=Npy.random.random_integers(1,20,100)//(最大值,最小值,个数)
Print(data)
生成正太分布的随机数
Npy.random.normal(5.0,2.0,10)//(均数,方差,个数)
3、 直方图(hist)
代表某一段数据出现的次数。
import matplotlib.pyplot as pyl
import numpy as nup
data3=nup.random.normal(10.0,1.0,1000)
pyl.hist(data3)
pyl.show()
data4=nup.random.random_integers(1,25,1000)
pyl.hist(data4)
pyl.show()
4、 子图
import matplotlib.pyplot as pyl
import numpy as nup
pyl.subplot(2,2,1)#(总行数,总列数,位置)
#第一个子图的代码区
pyl.subplot(2,2,2)
#第二个子图的代码区
pyl.subplot(2,1,2)
#第三个子图的代码区
二、 读取和讯博客的数据并且可视化分析
如何读取和讯博客的数据并且可视化分析?
import pandas as pda
import matplotlib.pylab as pyl
data=pda.read_csv(“D:/myhexun.csv”)
data.values#[第i行][第j列]
data1=data.T
x=data1.values[3]
y=data1.values[4]
pyl.plot(x,y)
pyl.show()
第三天
一、 数据探索和数据清洗
1、数据探索的核心
数据质量分析、数据特征分析
2、 数据清洗实战
缺失值处理:通过describe和len就可以对比处哪些是缺失的,通过零数据发现
异常值处理:通过散点图,
删除、
插补:(均值、中位数、众数、固定值、最近数据查补、回归查补、拉格朗日查补、牛顿差值法、分段差值)
不处理
二、数据集成实战

import pymysql
import pandas as pda
import matplotlib.pylab as pyl
conn=pymysql.connect(host=“127.0.0.1”,user=“root”,passwd=“gfb123”,db=“lingshi”)
sql=“select * from taob”
data=pda.read_sql(sql,conn)
print(data.describe())
#数据清洗
#发现缺失值
x=0
data[“price”][(data[“price”]==0)]None
for i in data.columns:
for j in range(len(data)):
if(data[i].isnull())[j]:
data[i][j]
“36”
x+=1
print(x)
#异常值处理
#画散点图(横轴为价格,纵轴为评论数据)
#得到价格
data1=data.T
price=data1.values[2]
comt=data1.values[3]
pyl.plot(price.comt,‘o’)
pyl.show()
line=len(data.values)
col=len(data.values[0])
da=data.values
for i in range(0,line):
for j in range(0,col):
if(da[i][2]>2300):
print(da[i][j])
da[i][j]=36
if(da[i][3]>200000):
print(da[i][j])
da[i][j]=58
da2=da.T
price=da2[2]
comt=da2[3]
pyl.plot(price,comt,‘o’)
pyl.show()

第四天
一、数据变换
1、简单变换
开方、平方、求均值等
2、数据规范化
离差标准化:可以消除单位的影响,消除变异大小因素的影响;
X=(x-min)/(max-min)
标准差标准化:消除单位的影响以及变量自身变异的影响,得到的数据平均数是0,标准差是1,该数据的特点是:大约一半的数据大于0一半的数据小于0;
X=(x-avg)/标准差
小数定标准化:消除单位的影响
X1=x/10k,k=log10(x的绝对值的最大值)
import pymysql
import pandas as pda
import numpy as npy
conn=pymysql.connect(host=“127.0.0.1”,user=“root”,passwd=“gfb123”,db=‘csdn’)
sql=“select price,comment from taobao”
data=pda.read_sql(conn,sql)
#离差标准化
data2=(data-data.min())/(data.max()-data.min())
#标准差标准化
data3=(data-data.min())/data.std()
#小数定标标准化
data4=data/10
(npy.ceil(npy.log10(data.abs().max())))
print(data4)
3、离散化
分类:等宽离散化、等频率离散化、一维聚类离散化;
#等宽离散化
data5=data[u"price"].copy()
data6=data5.T
data7=data6.values
k=3
c1=pda.cut(data7,k,labels=[“便宜”,“适中”,“贵了”])
print(c1)
c2=pda.cut(data7,[0,50,100,300,500,2000,data7.max()],labels=[“非常便宜”,“便宜”,“适中”,“贵了”,“太贵了”])
print(c2)

注意:cut函数的使用:
a=[1,2,3,5,9,4,8]
#这个是等宽离散化,3代表的是被分的类别数,labels表示的是每个类别的标签
pda.cut(a,3,labels=[“便宜”,“适中”,“天价”])
#指定宽度的离散化,
pda.cut(a,[2,5,8,10],labels=[“便宜”,“适中”,“天价”])
二、属性构造
就是为数据中构造新的属性,以此使得数据更具有可读性
#属性构造
import pymysql
import pandas as pda
conn=pymysql.connect(host=“127.0.0.1”,user=“root”,passwd=“gfb123”,db=‘csdn’)
sql=“select * from myhexun”
data=pda.read_sql(sql,conn)
print(data)
ch=data[u"comment"]/data[u"hits"]
data[u"评点比"]=ch
file="./hexun.xls"
data.to_excel(file,index=False)
三、数据规约
1、属性规约
就是对属性进行精简,对没用的属性取出即可
2、 数值规约
对数据进行精简,没用的去除或者对其范围进行扩展或者缩小是的数据可读性更高。
3、主成分分析(PCA)
保证数据本质的前提下,用于对数据降维。
from sklearn.decomposition import PCA
data=open(“d:/数据.txt”,‘ab’)
#主成分分析中
pca1=PCA()
pca1=fit(data)
#返回模型中各个特征量
Characteristic=pca1.components_
#print(Characteristic)
#各个成分中各自的方差百分比,贡献率
rate=pca1.explained_variance_ratio_
print(rate)

pca2=PCA(2)
pca2=fit(data)#加载数据
reduction=pca2.transform(data)#降维
print(reduction)
recovery=pca2.inverse_transform(reduction)
print(recovery)
第五天
一、 文本挖掘
1、 用于分词的模块
安装:pip install jieba
词库目录:c:/python/lib/site-packages/jieba/dict.txt
2、分词的三种模式
import jieba
sentence=“我喜欢上海东方明珠”
#默认是精准模式
w1=jieba.cut(sentence)
for item in w1:
print(item)
print("")
#全模式
w2=jieba.cut(sentence,cut_all=True)
for item in w2:
print(item)
print("")
#精准模式
w3=jieba.cut(sentence,cut_all=False)
for item in w3:
print(item)
print("")
#搜索引擎模式
w4=jieba.cut_for_search(sentence)
for item in w4:
print(item)
print("")
3、基本词性
a:形容词
c:连词
d:副词
e:叹词
f:方位词
i:成语
m:数词
n:名词
nr:人名
ns:地名
nt:机构团体
nz:其他专有名词
p:介词
r:代词
t:时间
u:助词
v:动词
vn:动名词
w:标点符号
un:未知词性
4、词性的标注
#词性标注
import jieba.posseg
w5=jieba.posseg.cut(sentence)
for item in w5:
print(item.word+"----"+item.flag)
print("")
5、加载自己的词典
jieba.load_userdict(“E:/softwarePackage/python/Anaconda3/Lib/site-packages/jieba/dict2.txt”)
sentence1=“天善智能是一个很好的机构”
w6=jieba.posseg.cut(sentence1)
for item in w6:
print(item.word+"—"+item.flag)

二、小说分析
#文章词频分析
data=open(“d:/1.txt”).read()
tag=jieba.analyse.extract_tags(data,15)
print(tag)
#盗墓笔记关键词提取
#编码问题解决方案
#data=open(“d:/dmbj.txt”,“r”,encoding=“utf-8”).read()
import urllib.request
data=urllib.request.urlopen(“http://127.0.0.1/dmbj.html”).read().decode(“utf-8”,“ignore”)
tag=jieba.analyse.extract_tags(data,30)
print(tag)
注意
1、如果加载到默认的dict中的话就会持久化存储,如果是自己建立的.txt那么必须在每次启动的时候必须首先导入自定义词库
2、什么是搜索引擎模式:有一定的规律可寻
2、 如何更改词频
第六天
一、文本相似度基本知识
1、使用到的算法
原理:
TFIDF的主要思想是:如果某个词或短语在一篇文章中出现的频率TF高,并且在其他文章中很少出现,则认为此词或者短语具有很好的类别区分能力,适合用来分类。TFIDF实际上是:TF * IDF,TF词频(Term Frequency),IDF逆向文件频率(Inverse Document Frequency)。TF表示词条在文档d中出现的频率。IDF的主要思想是:如果包含词条t的文档越少,也就是n越小,IDF越大,则说明词条t具有很好的类别区分能力。如果某一类文档C中包含词条t的文档数为m,而其它类包含t的文档总数为k,显然所有包含t的文档数n=m+k,当m大的时候,n也大,按照IDF公式得到的IDF的值会小,就说明该词条t类别区分能力不强。但是实际上,如果一个词条在一个类的文档中频繁出现,则说明该词条能够很好代表这个类的文本的特征,这样的词条应该给它们赋予较高的权重,并选来作为该类文本的特征词以区别与其它类文档。
公式:

TFIDF=TF*IDF

举例:
有很多不同的数学公式可以用来计算TF-IDF。这边的例子以上述的数学公式来计算。词频 (TF) 是一词语出现的次数除以该文件的总词语数。假如一篇文件的总词语数是100个,而词语“母牛”出现了3次,那么“母牛”一词在该文件中的词频就是3/100=0.03。一个计算文件频率 (IDF) 的方法是文件集里包含的文件总数除以测定有多少份文件出现过“母牛”一词。所以,如果“母牛”一词在1,000份文件出现过,而文件总数是10,000,000份的话,其逆向文件频率就是 lg(10,000,000 / 1,000)=4。最后的TF-IDF的分数为0.03 * 4=0.12。
2、稀疏向量
举例:
表示方式一:一个向量(1,0,1,3),它的密集向量为[1,0,1,3],而它的稀疏向量为(4,[0,2,3],[1,1,3])
表示方式二:以索引和值的形式处理
3、使用到的库
Collections
collections.Defaultdict(function_factory)属于内建函数dict的一个子类,调用工厂函数提供的缺失值,即使键不存在也能返回一个正常的值
Gensim:
是一种语料库,用于将文本信息转换成稀疏矩阵格式,以便后续的处理
4、步骤
 读取文档
 对要计算的一篇或者多篇文档进行分词
 将文档整理成指定格式,方便后续进行计算
 计算出词语的频率
 对频率低的词语进行过滤操作【可选】
 通过语料库建立词典
 加载要对比的文档
 将要对比的文档通过doc2bow转化成稀疏向量
 对稀疏向量进一步处理得到新语料库
 将新语料库通过tfidf的model进行处理,得到tfidf的值
 通过token2id得到特征数
 计算稀疏矩阵的相似度,从而建立索引
 得到最终相似度的结果
二、文本相似度实战
from gensim import corpora,models,similarities
import jieba
d1=open(“F:/temp/text_mining/ljm.txt”,encoding=“utf-8”).read()
d2=open(“F:/temp/text_mining/dmbj.txt”,encoding=“utf-8”).read()
data1=jieba.cut(d1)
data2=jieba.cut(d2)
data11=""
for item in data1:
data11+=item+" "
data21=""
for item in data2:
data21+=item+" "
documents=[data11,data21]
#从右往左读,将读取到的结果赋值给word,然后用中括号扩起来,意思是转化成列表的形式
texts=[[word for word in document.split()]for document in documents]
from collections import defaultdict#该方法是写过滤用的
#frequency频率
frequency=defaultdict(int)
for text in texts:
for token in text:
frequency[token]+=1

#统计出各个词的个数
#corpora语料库
dictionary=corpora.Dictionary(texts)
dictionary.save(“F:/temp/text_mining/deerwester.dict”)
data3=open(“F:/temp/text_mining/gcd.txt”,encoding=“utf-8”).read()
data31=""
for item in data3:
data31+=item+" "
new_doc=data31
new_vec=dictionary.doc2bow(new_doc.split())
corpus=[dictionary.doc2bow(text) for text in texts]
corpora.MmCorpus.serialize(“F:/temp/text_mining/deerwester.dict”,corpus)
tfidf=models.TfidfModel(corpus)
featureNum=len(dictionary.token2id.keys())
index=similarities.SparseMatrixSimilarity(tfidf[corpus],num_features=featureNum)
sims=index[tfidf[new_vec]]
print(sims)
第七天
一、python数据建模的概述
对现实世界中的数据进行处理建模处理:分类、聚类、关联、回归等
二、python数据分类的实现过程
明确需求对数据进行观察和预处理
确定算法
确定步骤
编程实现
三、 常见的分类算法
KNN算法
贝克斯算法
决策树算法
人工神经网络算法
支持向量机(SVN)
四、 KNN算法和手写体数据的识别
1、KNN算法的实现步骤
处理数据
数据向量机
计算欧几里得距离
根据距离进行分类
2、KNN算法的原理
是一种近邻算法
B.Shape[m][n]:表示b有m行n列

Tile()表示对已经存在的数据进行扩展:
Eg:
import numpy as npy

a=npy.array([1,5,4,6])
data1=tile(a,2)
print(data1)
data2=tile(a,(2,1))
print(data2)
Tile(a,2):表示在行上扩展2倍
Tile(a,(2,1)):表示从列方向扩展

import numpy as npy

a=npy.array([1,5,4,6])
data=tile(a,(2,1))
rowsum=data.sum(axis=0)
print(“每一行的各列之和:”+str(rowsum))
colsum=data.sum(axis=1)
print(“每一列的各行之和:”+str(colsum))

import numpy as npy

a=npy.array([1,5,4,6])
r=a.argsort()
print(“原始数据:”+str(a))
print(“排序后的数据:”+str®)
代码:
from numpy import *
import operator
def knn(k,testdata,traindata,labels):#取得个数、测试集、训练集、类别名
traindatasize=traindata.shape[0]
dif=tile(testdata,(traindatasize,1))-traindata
sqdif=dif2
sumsqdif=sqdif.sum(axis=1)
sumsqdif=sumsqdif
0.5
sortdistence=distance.argsort#表示排序后的序号,升序
count=[]
for i in range(0,k):
vote=labels[sortdistence[i]]
count[vote]=count.get(vote,0)+1
sorted(count.items(),operator.itemgetter(1),reverse=True)#(得到的结果参数,排序依据的参数,降序排列)
return sortcount[0][0]
3、手写体数据的识别案例
首先得到一个数字;对该数字进行标准化格式,就是长和宽标准化;将其转化成文本的,将其进行训练。
#图片处理,将所有图片转化成固定宽高,然后再转为文本
from PIL import Image
im=Image.open(“F:/temp/handwritten/1.png”)
fh=open(“F:/temp/handwritten/1.txt”,“a”)
width=im.size[0] #表示im这个文本文件的宽,也就是有多少列
height=im.size[1] #表示im这个文本文件的高,也就是有多少行
for i in range(0,width):
for j in range(0,height):
cl=im.getpixel((i,j)) #获取当前像素点的RGB值
clall=cl[0]+cl[1]+cl[2]
if(clall==0):
fh.write(“1”)
else:
fh.write(“0”)
fh.write("\n")
fh.close()

#加载数据
def datatoarray(fname):#文件的名字
arr=[]
fh=open(fname)
for i in range(0,32):
thisline=fh.readline()
for j in range(0,32):
arr.append(int(thisline[j]))
return arr

#取文件名的函数
def seplabel(fname):
filestr=fname.split(".")[0]
label=int(filestr.split("_")[0])
return label

#建立训练集数据
from os import listdir
import numpy as npy
def traindata():
labels=[]
trainfile=listdir(“F:/temp/handwritten”)#获取当前文件夹下所有的文件名
num=len(trainfile)
#长度1024(列),每一行存储一个文件
#用一个数组存储所有训练集数据,行:文件总数,列:1024
trainarr=npy.zeros((num,1024))
for i in range(0,num):
thisfname=trainfile[i]
thislabel=seplabel(thisfname)
labels.append(thislabel)
trainarr[i,:]=datatoarray("/train/"+thisfname)
return trainarr,labels

#knn算法
import operator
def knn(k,testdata,traindata,labels):#k表示取排序在前k个数、测试集、训练集、类别名
traindatasize=traindata.shape[0]
dif=npy.tile(testdata,(traindatasize,1))-traindata
sqdif=dif2
sumsqdif=sqdif.sum(axis=1)
sumsqdif=sumsqdif
0.5
sortdistence=npy.distance.argsort#表示排序后的序号,升序
count=[]
for i in range(0,k):
vote=labels[sortdistence[i]]
count[vote]=count.get(vote,0)+1
#(得到的结果参数,排序依据的参数,降序排列)
sorted(count.items(),operator.itemgetter(1),reverse=True)
return count[0][0]

#测试test中的数据
def datatest():
trainarr,labels=traindata()
testlist=listdir(“test”)
tnum=len(testlist)
for i in range(0,tnum):
thistestfile=testlist[i]
testarr=datatoarray(“test/”+thistestfile)
rknn=knn(3,testarr,trainarr,labels)
print(rknn)

#抽取某一个测试文件出来进行验证
trainarr,labels=traindata()
testlist=listdir(“test”)
thistestfile=“8_76.txt”
testarr=datatoarray(“testdata/”+thistestfile)
rknn=knn(3,testarr,trainarr,labels)
print(rknn)
第八天
一、贝叶斯算法
1、公式简介

表示A是B这个类别的概率是多少
举例:
一所学校,男女比例为3:2,男生都穿长裤,女生40%长裤,60%裙子,求学校女生穿长裤的概率。
2、代码实现
import numpy as npy
class Bayes:
def int(self): #类初始化
self.length=-1 #初始化长度
self.labelcount=dict() #存储标签
self.vectorcount=dict() #存储向量
def fit(self,dataSet:list,labels:list): #训练方法:训练集和类别集
if(len(dataSet)!=len(labels)): #判断特征值数量和类别数量是否一致
raise ValueError(“你输入的测试数组跟类别数组长度不一致”)
self.length=len(dataSet[0]) #取测试数据特征值长度
labelsnum=len(labels) #获取类别数量(有重复)
norlabels=set(labels) #不重复类别数量(去重)
for item in norlabels:
thislabel=item
self.labelcount[thislabel]=labels.count(thislabel)/labelsnum#求当前类别在类别中的比例
for vector,label in zip(dataSet,labels):#向量,类别
if(label not in self.vectorcount):
self.vectorcount[label]=[]
self.vectorcount[label].append(vector)
print(“训练结束”)
return self
def btest(self,TestData,labelsSet): #测试
if(self.length==-1):
raise ValueError(“你还没有训练呢,请先训练吧”)
#计算testdata分别为各个类别的概率
lbDict=dict()
for thislb in labelsSet:
p=1
alllabel=self.labelcount[thislb]
allvector=self.vectorcount[thislb]
vnum=len(allvector)
allvector=npy.array(allvector).T
for index in range(0,len(TestData)):
vector=list(allvector[index])
p*=vector.count(TestData[index])/vnum
lbDict[thislb]=p*alllabel
thislabel=sorted(lbDict,key=lambda x:lbDict[x],reverse=True)[0]
return thislabel
3、贝叶斯算法应用
bys=Bayes()
#训练数据
train_data,labels=traindata()
bys.fit(train_data,labels)
#测试
thisdata=datatoarray(“F:/8_90.txt”)
labelsall=[0,1,2,3,4.5,6,7.8,9,]
rst=bys.btset(thisdata,labelsall)
print(rst)
二、回归算法
1、回归算法简介
回归:线性回归和逻辑回归,线性回归只要是勾勒出一条线出来,例如这条线之上为三角形,线之下为圆形,有一个测试数据,通过计算,这条测试数据在这条线之上则为三角形,之下则为圆形;逻辑回归比较复杂,举个例子,如果记1的概率为p,则0的概率为1-p,那么我们记z=p/1-p为0和的概率比,取对数可得z=ln(p/1-p),可得到自变量为z因变量为p的函数,p=1-(1/e^z+1)
2、代码实现
import pandas as pda
fname=“F:/temp/regression/regression.xlsx”
dataf=pda.read_excel(fname)
x=dataf.iloc[:,1:4].as_matrix()#直接转为数据
y=dataf.iloc[:,0:1].as_matrix()#直接转为数据
from sklearn.linear_model import LogisticRegression as LR #逻辑回归模型
from sklearn.linear_model import RandomizedLogisticRegression as RLR #建立随机逻辑回归模型
r1=RLR()
r1.fit(x,y) #进行训练
r1.get_support() #筛选有效的特征
#print(dataf.columns[r1.get_support()])
t=dataf[dataf.columns[r1.get_support()]].as_matrix()
r2=LR()
r2.fit(t,y)
print(“训练结束”)
print(“模型正确率为:”+r2.score(x,y))
三、决策树
1、ID3算法
信息熵:I(a,b)=( -a/b) (log2(a/(a+b)))-b/(a+b)(log2(b/(a+b)))
代码实战:
import pandas as pda
fname=“F:/temp/decisiontree/test.xlsx”
dataf=pda.read_excel(fname,encoding=“gbk”)
#提取x和y,并将其转为数组
x=dataf.iloc[:,1:5].as_matrix()
y=dataf.iloc[:,5:6].as_matrix()
for i in range(0,len(x)):
for j in range(0,len(x[i])):
thisdata=x[i][j]
if(thisdata==“是” or thisdata==“多” or thisdata==“高”):
x[i][j]=int(1)
else:
x[i][j]=-1
for i in range(0,len(y)):
thisdata=y[i]
if(thisdata==“高”):
y[i]=1
else:
y[i]=0
#容易错的地方:直接使用,目前的x和y是object类型,我们需要转化成数字类型
#正确做法:转化好格式,将x,y转化为数据框,然后再转化为数组并指定格式
xf=pda.DataFrame(x) #将x转为数据框
yf=pda.DataFrame(y) #将y转为数据框
x2=xf.as_matrix().astype(int)
y2=yf.as_matrix().astype(int)

#建立决策树
from sklearn.tree import DecisionTreeClassifier as DTC
dtc=DTC(criterion=“entropy”)
dtc.fit(x2,y2)

#可视化决策树
from sklearn.tree import export_graphviz #
with open(“F:\temp\decisiontree\dtc.dot”,“w”) as file:
export_graphviz(dtc,feature_names=[“combat”,“num”,“promotion”,“datum”],out_file=file)

#直接预测销量高低
import numpy as npy
x3=npy.array([[1,-1,-1,1],[1,1,-1,-1],[-1,-1,1,-1]])
rst=dtc.predict(x3)
print(rst)
2、C4.5算法

3、CART算法

注意:
dot -Tpng dtc.dot -o lesson.png:该命令会将生成的决策树文件.dot文件通过软件graphziv转化为png格式的文件,使得其能够查看。
第九天
一、聚类的概述
在分类标准不明确的情况下进行自动分类,也就是在不指定类别的情况下进行分类。
二、 聚类常见算法
地址:https://blog.csdn.net/Katherine_hsr/article/details/79382249
 K-Means(K均值)聚类
 均值漂移聚类
 基于密度的聚类方法(DBSCAN)
 用高斯混合模型(GMM)的最大期望(EM)聚类
 凝聚层次聚类
 图团体检测(Graph Community Detection)
三、 聚类三法
1、划分法
首先划分计算中心点进行随机分类分类;计算再划分,直到整个模型收敛为止。eg:kmeans
2、层次分析法:
自顶向下;自底向上。
3、密度分析法
可以消除距离之间的影响,根据数据的密度判断聚类
其他方法:
网格分析法和模型分析法
四、kmeans算法概述
实现步骤:
1、有多个数据,从中随机选出k个点作为聚类中心,k就是类别数;
2、计算各个点到这k个点的距离;
3、将其对应的点聚到与它最近的这个聚类中心
4、重新计算聚类中心;
5、比较当前聚类中心与前一次聚类中心,如果是同一个点的话,得到聚类结果,如果不是同一个点的话,重复步骤2-5。
五、kmeans算法实战
1、通过程序实现录取学生的聚类
import pandas as pda
import numpy as npy
import matplotlib.pylab as pyl
fname=""
dataf=pda.read_csv(fname) #读取文件数据
x=dataf.iloc[:,1:4].as_matrix() #选择读入的数据
from sklearn.cluster import KMeans #算法
kms=KMeans(n_clusters=4,n_jobs=2,max_iter=500) #(聚为几类,线程数,最大循环次数)
y=kms.fit_predict(x) #fit_predict()进行聚类
print(y)
#x代表学生序号,y代表学生类别
s=npy.arange(0,len(y)) #生成数组代表学生序号
pyl.plot(s,y,“o”)
pyl.show()
2、通过程序实现商品的聚类(商品和评论)
import pandas as pda
import numpy as npy
import matplotlib.pylab as pyl
import pymysql
conn=pymysql.connect(host=“127.0.0.1”,user=“root”,passwd=“gfb123”,db=“goods”)
sql=“select price comment from goods limit 300”
dataf=pda.read_sql(sql,conn) #读取文件数据
x=dataf.iloc[:,:].as_matrix() #选择读入的数据
from sklearn.cluster import KMeans #算法
kms=KMeans(n_clusters=3) #(聚为几类,线程数,最大循环次数)
y=kms.fit_predict(x) #fit_predict()进行聚类
print(y)
for i in range(0,len(y)):
if(y[i]0):
pyl.plot(dataf.iloc[i:i+1,0:1].as_matrix(),dataf.iloc[i:i+1,1:2].as_matrix(),"*r")
elif(y[i]1):
pyl.plot(dataf.iloc[i:i+1,0:1].as_matrix(),dataf.iloc[i:i+1,1:2].as_matrix(),“sy”)
elif(y[i]2):
pyl.plot(dataf.iloc[i:i+1,0:1].as_matrix(),dataf.iloc[i:i+1,1:2].as_matrix(),“pk”)
pyl.show()
第十天
一、人工神经网络
1、人工神经网络的理论基础
激活函数(阀值):域值函数、relu函数、分段线性函数、非线性转移函数。
具体人工神经网络的模型:BP人工神经网络、RBF、FNN、LM(精度比较高)
2、使用人工神经网络预测课程销量
#使用人工神经网络预测课程销量
import pandas as pda
fname=“F:/temp/neuralnetwork/test.xlsx”
dataf=pda.read_excel(fname,encoding=“gbk”)
x=dataf.iloc[:,1:5].as_matrix()
y=dataf.iloc[:,5].as_matrix()
for i in range(0,len(x)):
for j in range(0,len(x[i])):
thisdata=x[i][j]
if(thisdata
"是" or thisdata
"多" or thisdata
"高"):
x[i][j]=int(1)
else:
x[i][j]=0
for i in range(0,len(y)):
thisdata=y[i]
if(thisdata==“高”):
y[i]=1
else:
y[i]=0
xf=pda.DataFrame(x)
yf=pda.DataFrame(y)
x2=xf.as_matrix().astype(int)
y2=yf.as_matrix().astype(int)

#使用人工神经网络模型
from keras.models import Sequential
from keras.layers.core import Dense ,Activation
model=Sequential() #建立模型
#使用dense建立输入层(输入层的层数,特征数或信号数)
model.add(Dense(10,input_dim=len(x2[0])))
#建立激活函数
model.add(Activation(“relu”))
#建立输出层(输出层的层数,特征数)
model.add(Dense(1,input_dim=1))
#建立激活函数
model.add(Activation(“sigmoid”))
#模型的编译(损失函数,求解方法,模式)
model.compile(loss=“binary_crossentropy”,optimizer=“adam”,class_mode=“binary”)
#训练(自变量,因变量,学习的次数,p大小根据具体的情况)
model.fit(x2,y2,nb_epoch=1000,batch_size=100)
#预测分类(reshape是为了改它的维度)
rst=model.predict_classes(x).reshape(len(x))
print(rst)
#准确率
x=0
for i in range(0,len(x2)):
if(rst[i]!=y[i]):
x+=1
print(1-x/len(x2))

你可能感兴趣的:(机器学习,数据挖掘,算法,神经网络,机器学习)