【数据挖掘】技术点总结

第一天
一、 了解数据分析与数据挖掘
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=sumsqdif0.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=sumsqdif0.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))