Python数据分析与挖掘（二）

其他 2018-06-24 03:22:40 阅读次数: 2

1、KNN算法

#!/usr/bin/python
# -*-coding:utf-8-*-
# __author__ = 'ShenJun'

import numpy as np
import operator

def knn(k,testdata,traindata,labels):
    '''
    :param k:表示到最近的k个点，即以最近的k个点的距离来对测试数据所属类别进行判定，这k个点中哪个类别的点最多即为哪一类
    :param testdata:测试数据
    :param traindata: 训练数据
    :param labels: 标签
    :return:
    ＫＮＮ算法是通过计算测试点与ｋ个最近参照点（训练集）所有的距离，统计这ｋ个点的类别，将测试点判定为其中类别多数的一类
    '''
    # traindata.shape
    traindatasize=traindata.shape[0]#获取训练数据的行数
    dif=np.tile(testdata,(traindatasize,1))-traindata#计算测试数据到训练数据的距离
    sqdif=dif**2#计算距离的平方
    sumsqdif=sqdif.sum(axis=1)#计算所有距离的平方和
    distance=sumsqdif**0.5#平方和开根号
    sortdistance=distance.argsort()#对距离进行排序
    count={}
    for i in range(0,k):
        vote=labels[sortdistance[i]]#获取前k个训练集的每个标签
        #count.get(vote,0)：返回vote对应的value值，如果不存在则返回0
        count[vote]=count.get(vote,0)+1#统计标签的个数，是一个字典形式的，标签：票数
    #按降序对标签的票数进行排序返回一个列表
    #count.items()：以列表返回可遍历的(键, 值) 元组数组
    sortcount=sorted(count.items(),key=operator.itemgetter(1),reverse=True)
    #返回类别，即为最终的分类
    return sortcount[0][0]


'''
# a=np.array([1,5,6,4])
# dis=a.argsort()
# print(dis[1])
# count={"a":1,"b":3,"c":2,"d":0}
# print(count.get("b",0))#结果：3  获取"b"对应的value值即为3
'''
# sortcount=sorted(count.items(),key=operator.itemgetter(1))
# print(sortcount[0][0])
# print(type(sortcount))#列表
# print(type(count.items()))
# print(type(count))

'''
结果：
[0 3 1 2]
'''
# print(np.tile(a,2))

'''
将数据在行上重复指定的次数
结果：
[1 5 6 4 1 5 6 4]
'''
# print(np.tile(a,(2,1)))
'''
从列方向上进行扩展
结果：
[[1 5 6 4]
 [1 5 6 4]]
'''

将图片转为01文本

#!/usr/bin/python
# -*-coding:utf-8-*-
# __author__ = 'ShenJun'

from PIL import Image
#图片处理，图片处理之前先将图片转为固定宽高，比如32*32，然后再转为文本
im=Image.open("J:\\c.png")
#将图片存储为
# im.save("J:\\pic\\b.png")
#获取图片的宽和高
width=im.size[0]
height=im.size[1]
#获取坐标（1，9）的像素
# k=im.getpixel((1,9))
#将图片转成0,1表示的文本
for i in range(0,width):
    for j in range(0,height):
        cl=im.getpixel((i,j))
        clall=cl[0]+cl[1]+cl[2]#表示三个通道的像素相加
        if(clall==0):
            #图片中的黑色用1表示
            im.write("1")
        else:
            im.write("0")
    im.write("\n")
im.close()

使用KNN使用手写数字识别

#!/usr/bin/python
# -*-coding:utf-8-*-
# __author__ = 'ShenJun'

from os import listdir
import numpy as np
import operator

def knn(k,testdata,traindata,labels):
    '''
    :param k:表示到最近的k个点，即以最近的k个点的距离来对测试数据所属类别进行判定，这k个点中哪个类别的点最多即为哪一类
    :param testdata:测试数据
    :param traindata: 训练数据
    :param labels: 标签
    :return:
    ＫＮＮ算法是通过计算测试点与ｋ个最近参照点（训练集）所有的距离，统计这ｋ个点的类别，将测试点判定为其中类别多数的一类
    '''
    # traindata.shape
    traindatasize=traindata.shape[0]#获取训练数据的行数
    dif=np.tile(testdata,(traindatasize,1))-traindata#计算测试数据到训练数据的距离
    sqdif=dif**2#计算距离的平方
    sumsqdif=sqdif.sum(axis=1)#计算所有距离的平方和
    distance=sumsqdif**0.5#平方和开根号
    sortdistance=distance.argsort()#对距离进行排序
    count={}
    for i in range(0,k):
        vote=labels[sortdistance[i]]#获取前k个训练集的每个标签
        #count.get(vote,0)：返回vote对应的value值，如果不存在则返回0
        count[vote]=count.get(vote,0)+1#统计标签的个数，是一个字典形式的，标签：票数
    #按降序对标签的票数进行排序返回一个列表
    #count.items()：以列表返回可遍历的(键, 值) 元组数组
    sortcount=sorted(count.items(),key=operator.itemgetter(1),reverse=True)
    #返回类别，即为最终的分类
    return sortcount[0][0]

#加载数据
def datatoarray(fname):
    arr=[]
    fh=open(fname)
    #因为图片文本是32乘32的，将每一个像素点的值都放入一个长度为1024的列表中
    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

#建立训练数据
def traindata():
    labels=[]
    trainfile=listdir("F:\\网络爬虫\\视频课程\\源码\\源码\\第7周\\testandtraindata\\traindata")
    num=len(trainfile)
    #长度为1024列  每一行存储一个文件
    #用一个数组存储所有训练数据，行是文件总数，列是1024
    trainarr=np.zeros((num,1024))
    for i in range(0,num):
        thisfname=trainfile[i]
        thislabel=seplabel(thisfname)
        labels.append(thislabel)
        trainarr[i,:]=datatoarray("F:\\网络爬虫\\视频课程\\源码\\源码\\第7周\\testandtraindata\\traindata\\"+thisfname)
    return trainarr,labels
#用测试数据调用kNN算法测试
def datatest():
    trainarr,labels=traindata()
    testlist=listdir("F:\\网络爬虫\\视频课程\\源码\\源码\\第7周\\testandtraindata\\testdata")
    tnum=len(testlist)
    for i in range(0,tnum):
        thistestfile=testlist[i]
        testarr=datatoarray("F:\\网络爬虫\\视频课程\\源码\\源码\\第7周\\testandtraindata\\testdata\\"+thistestfile)
        rknn=knn(3,testarr,trainarr,labels)
        print(rknn)
print(datatest())

2、贝叶斯算法
这里写图片描述
这里写图片描述
这里写图片描述

#!/usr/bin/python
# -*-coding:utf-8-*-
# __author__ = 'ShenJun'
import numpy as np
from os import listdir
class Bayes:
    def __init__(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 vevtor,label in zip(dataSet,labels):
            if(label not in self.vectorcount):
                self.vectorcount[label]=[]
            self.vectorcount[label].append(vevtor)
        print("训练结束")
        return self
    def btest(self,TestData,labelSet):
        #testData为一维数组
        if(self.length==-1):
            raise ValueError("您还没有进行训练，请先训练")
        #计算testdata分别为各个类别的概率
        lbDict=dict()
        for thislb in labelSet:
            p=1
            alllabel=self.labelcount[thislb]#得到当前标签占所有类别的概率
            allvector=self.vectorcount[thislb]
            vnum=len(allvector)#得到属于同一类别的个数，也就是训练集中同一类别的同一个特征能有多少种表示法（因为属于同一类别并不代表每一个特征表示的都一样，它只是从整体上而言是一样的）
            allvector=np.array(allvector).T
            for index in range(0,len(TestData)):
                vector=list(allvector[index])#将训练集的表示同一个特征的点列成一个列表（每个点并不完全一样）
                #vector.count(TestData[index]统计出训练集中该特征的表示有多少个与测试集的表示一样
                p=p*(vector.count(TestData[index])/vnum)#一个一个特征的计算概率
            lbDict[thislb]=p*alllabel
        thislabel=sorted(lbDict,key=lambda x:lbDict[x],reverse=True)[0]
        return thislabel
'''
贝叶斯公式因为分母都一样，所以只要分子最大则表明属于该类的可能性最大
'''

'''
贝叶斯算法实现手写体识别
'''
#加载数据
def datatoarray(fname):
    arr=[]
    fh=open(fname)
    #因为图片文本是32乘32的，将每一个像素点的值都放入一个长度为1024的列表中
    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

#建立训练数据
def traindata():
    labels=[]
    trainfile=listdir("F:\\网络爬虫\\视频课程\\源码\\源码\\第7周\\testandtraindata\\traindata")
    num=len(trainfile)
    #长度为1024列  每一行存储一个文件
    #用一个数组存储所有训练数据，行是文件总数，列是1024
    trainarr=np.zeros((num,1024))
    for i in range(0,num):
        thisfname=trainfile[i]
        thislabel=seplabel(thisfname)
        labels.append(thislabel)
        trainarr[i,:]=datatoarray("F:\\网络爬虫\\视频课程\\源码\\源码\\第7周\\testandtraindata\\traindata\\"+thisfname)
    return trainarr,labels
bys=Bayes()
#训练数据
train_data,labels=traindata()
bys.fit(train_data,labels)
#测试
thisdata=datatoarray("F:\\网络爬虫\\视频课程\\源码\\源码\\第7周\\testandtraindata\\testdata\\8_90.txt")
labelsall=[0,1,2,3,4,5,6,7,8,9]
'''
#识别单个手写体数字
# rst=bys.btest(thisdata,labelsall)
# print(rst)
'''
#识别多个手写体数字
testfileall=listdir("F:\\网络爬虫\\视频课程\\源码\\源码\\第7周\\testandtraindata\\testdata")
num=len(testfileall)
for i in range(0,num):
    thisfilename=testfileall[i]
    thislable=seplabel(thisfilename)
    thisdataarray=datatoarray("F:\\网络爬虫\\视频课程\\源码\\源码\\第7周\\testandtraindata\\testdata\\"+thisfilename)
    label=bys.btest(thisdataarray,labelsall)
    x=0
    if(label!=thislable):
        x+=1
        print("此次出错")
print(x)
print("错误率是："+str(float(x)/float(num)))

3、逻辑回归算法

#!/usr/bin/python
# -*-coding:utf-8-*-
# __author__ = 'ShenJun'

import pandas
from sklearn.linear_model import LogisticRegression as LR
from sklearn.linear_model import RandomizedLogisticRegression as RLR
path="F:\\网络爬虫\\视频课程\\源码\\源码\\luqu.csv"
file=open(path,encoding="utf-8")
data=pandas.read_csv(file)
x=data.values[:,1:4]
y=data.values[:,0:1]
# x=data.iloc[:,1:4].as_matrix()
# y=data.iloc[:,0:1].as_matrix()
# print(type(x))
# print(y)
r1=RLR()#随机逻辑回归模型
r1.fit(x,y)
# print(r1.get_support())#得到特征，通过模型拟合对特征进行了筛选
# print(data.columns[r1.get_support()])
t=data[data.columns[r1.get_support()]].as_matrix()
r2=LR()
r2.fit(x,y)
print("训练结束")
print("模型正确率为："+str(r2.score(x,y)))

4、决策树算法

#!/usr/bin/python
# -*-coding:utf-8-*-
# __author__ = 'ShenJun'

import pandas as pda
from sklearn.tree import DecisionTreeClassifier as DTC
from sklearn.tree import export_graphviz
from sklearn.externals.six import StringIO
import numpy as np
path="F:\\网络爬虫\\视频课程\\源码\源码\\lesson.csv"
fname=open(path,encoding="utf-8")
data=pda.read_csv(fname)
x=data.iloc[:,1:5].as_matrix()
y=data.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]=int(-1)
for i in range(0,len(y)):
    thisdata=y[i]
    if(thisdata=="高"):
        y[i]=1
    else:
        y[i]=-1
#转化格式，将x,y转化为数据框，然后再转化为数组并指定格式
x1=pda.DataFrame(x)
y1=pda.DataFrame(y)
x2=x1.as_matrix().astype(int)
y2=y1.as_matrix().astype(int)

#建立决策树
# print(type(y2))
# print(type(x2))
dtc=DTC(criterion="entropy")
dtc.fit(x2,y2)
#直接预测销量高低
x3=np.array([1,-1,-1,1],[1,1,1,1],[-1,1,-1,1])
rst=dtc.predict(x3)
print(rst)

#可视化决策树,要通过安装export_graphviz软件进行打开
with open("J:\\Program\\Python\\Python爬虫\\数据分析与数据挖掘\\dtc.dot","w") as file:
    export_graphviz(dtc,feature_names=["combat","num","promotion","datum"],out_file=file)

这里写图片描述
5、Kmeans聚类算法

#!/usr/bin/python
# -*-coding:utf-8-*-
# __author__ = 'ShenJun'

import pandas as pda
import matplotlib.pylab as pyl
import numpy as np
from sklearn.cluster import Birch
from sklearn.cluster import KMeans
import pymysql
'''
path="F:\\网络爬虫\\视频课程\\源码\源码\\luqu.csv"
fname=open(path,encoding="utf-8")
data=pda.read_csv(fname)
x=data.iloc[:,1:4].as_matrix()
#n_clusters聚类数  n_jobs：指定线程数   max_iter:最大迭代数
kms=KMeans(n_clusters=4,max_iter=500)
y=kms.fit_predict(x)
# print(y)
# print(data)
#可视化,x代表学生序号，y代表学生类别
s=np.arange(0,len(y))
pyl.plot(s,y,"o")
pyl.show()

'''
'''
聚类算法实现商品的聚类
'''
conn=pymysql.connect(host="127.0.0.1",user="root",passwd="123456",db="taobao")
sql="select price,comment from taob limit 1000"
data=pda.read_sql(sql,conn)
# print(data)
x=data.iloc[:,:].as_matrix()
kms=KMeans(n_clusters=3)
y=kms.fit_predict(x)
# print(y)
for i in range(0,len(y)):
    if(y[i]==0):
        pyl.plot(data.iloc[i:i+1,0:1].as_matrix(),data.iloc[i:i+1,1:2].as_matrix(),"*r")
    if(y[i]==1):
        pyl.plot(data.iloc[i:i+1,0:1].as_matrix(),data.iloc[i:i+1,1:2].as_matrix(),"sy")
    if(y[i]==2):
        pyl.plot(data.iloc[i:i+1,0:1].as_matrix(),data.iloc[i:i+1,1:2].as_matrix(),"pk")
pyl.show()

6、人工神经网络算法

#!/usr/bin/python
# -*-coding:utf-8-*-
# __author__ = 'ShenJun'
'''
1、读取数据
2、keras.models Sequential   /keras.layers.core Dense Activation
3、Sequential建立模型
4、Dense建立层
5、Activation激活函数
6、compile模型编译
7、fit训练（学习）
8、验证（测试、分类预测）
'''
import pandas as pda
from sklearn.tree import DecisionTreeClassifier as DTC
from sklearn.tree import export_graphviz
from sklearn.externals.six import StringIO
import numpy as np
from keras.models import Sequential
from keras.layers.core import Dense,Activation
path="F:\\网络爬虫\\视频课程\\源码\源码\\lesson.csv"
fname=open(path,encoding="utf-8")
data=pda.read_csv(fname)
x=data.iloc[:,1:5].as_matrix()
y=data.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]=int(-1)
for i in range(0,len(y)):
    thisdata=y[i]
    if(thisdata=="高"):
        y[i]=1
    else:
        y[i]=-1
#转化格式，将x,y转化为数据框，然后再转化为数组并指定格式
x1=pda.DataFrame(x)
y1=pda.DataFrame(y)
x2=x1.as_matrix().astype(int)
y2=y1.as_matrix().astype(int)
#使用人工神经网络模型实现课程销量的预测
#建立模型
model=Sequential()
#建立输入层
#10：输入层的个数   input_dim：代表特征数
model.add(Dense(10,input_dim=len(x2[0])))
#建立激活函数
model.add(Activation("relu"))
#建立输出层
#1:表示输出层
model.add(Dense(1,input_dim=1))
#输出层激活函数
model.add(Activation("sigmoid"))
#模型编译
#损失函数binary_crossentropy   optimizer:求解模式
model.compile(loss="binary_crossentropy",optimizer="adam")
#训练   nb_epoch：学习次数  batch_size批大小
model.fit(x2,y2,nb_epoch=1000,batch_size=100)
#预测分类
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))
import numpy as npy
x3=npy.array([[1,-1,-1,1],[1,1,1,1],[-1,1,-1,1]])
rst=model.predict_classes(x3).reshape(len(x3))
print("其中第一门课的预测结果为:"+str(rst[0]))

7、关联算法——Apriori
这里写图片描述

#!/usr/bin/python
# -*-coding:utf-8-*-
# __author__ = 'ShenJun'

'''
计算学员购买课程的关联性
'''
from apriori import *
import pandas as pda
filename="F:\\网络爬虫\\视频课程\\源码\\源码\\lesson_buy.xls"
dataframe=pda.read_excel(filename,header=None)
#转化数据，将买了的记为1
change=lambda x:pda.Series(1,index=x[pda.notnull(x)])
#map函数是一个映射关系，即采用change对dataframe.as_matrix()中的每个数进行处理，即将买了的记为1
mapok=map(change,dataframe.as_matrix())
# print(type(mapok))
# print(list(mapok))
# print(pda.DataFrame(list(mapok)))
#没有的设置为0
data=pda.DataFrame(list(mapok)).fillna(0)
# print(data)
#临界支持度（两个同时发生的概率）、置信度（一个发生，另一个发生的概率）设置
spt=0.1
cfd=0.3
#使用apriori计算关联结果
result=(find_rule(data,spt,cfd,"-->"))
print(result)

猜你喜欢

转载自blog.csdn.net/jorocco/article/details/80391402
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022