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)