澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

澳门新萄京官方网站:左邻右舍算法,机器学习

2019-07-07 作者:www.8455.com   |   浏览(90)

这两日翻了一晃机械学习实战那本书,算法是正确,只是代码远远不够本人,小编是个搞算法的,那点从代码上就能够看出来。可是多少地点使用numpy搞数组,搞矩阵,总是感觉蹊跷,一个是索要利用三方包numpy,尽管这几个包为主能够说必备了,但是对于部分菜鸟,连pip都用倒霉,装的numpy也是各样主题材料,所以说能不要依旧尽量不用,第二个就是毕竟是数码,代码样例里面写的唯有多少个case,然而实际应用起来,一定是要上数据库的,假使是array是不适合从数据库中读写多少的。因而综合上述两点,作者就把这段代码改成list情势了,当然,也恐怕有人会说笔者对numpy很纯熟啊,何况作为正式的数学包,矩阵的运算方面也很有益,我不否定,这小编这段代码恐怕对你不适合,你能够参照他事他说加以考察书上的代码,直接照打并知道就好了。

扬言:本篇博文是上学《机器学习实战》一书的点子路程,系原创,若转发请标记源于。

K近些日子邻(k-Nearest Neighbor,KNN)分类算法能够说是最简易的机器学习算法了。它利用衡量分化特征值之间的距离方法开始展览分类。它的思量很简短:假使多个样本在特色空间中的k个最相似(即特征空间中最邻近)的样本中的大比较多属于某四个种类,则该样本也属于这么些类型。

k-近邻算法

NumPy

knn,十分的少说了,网络书上讲那一个的一大堆,轻便说正是使用新样本new_case的各维度的数值与已有old_case各维度数值的欧式距离总计

  1. K-近邻算法的相似流程:

其算法描述如下:

k-近邻算法一般流程

  • 1访谈数据:能够选择任何方法。
  • 2备选数据:距离计算机手艺研讨所需求的数值,最佳是结构化的多少格式。
  • 3分析数据:能够动用其他方法。
  • 4演练算法:此步骤不适用于k-近邻算法。
  • 5测量检验算法:计算错误率。
  • 6行使算法:首先供给输入样本数量和结构化的输入结果,然后运维k-近邻算法推断输入数据分别属于极度分类,最终选择对计量出的分类实行后续的拍卖。

澳门新萄京官方网站 1

依照上海体育场地所示,有两类不一致的范本数量,分别用深蓝的小长方形和甲子革命的小三角形表示,而图正中间的丰富橙色的圆所标示的数量则是待分类的数目。也正是说,未来, 我们不明了中间那么些深绿的数码是从属于哪类(海螺红小圆锥形or茄皮紫小三角形),上面,大家就要化解这一个标题:给那些石黄的圆分类。

  • 即便K=3,浅米灰圆点的这段日子的3个街坊是2个革命小三角形和1个栗褐小星型,少数从属于诸多,基于计算的法子,判断银白的这些待分类点属于灰黄的三角形一类。
  • 假使K=5,鲜蓝圆点的近年的5个邻居是2个革命三角形和3个墨玫瑰紫红的长方形,依旧个别从属于大多,基于总括的情势,决断杏黄的那些待分类点属于雾灰的长方形一类。
    于此大家来看,当不可能推断当前待分类点是从属于已知分类中的哪类时,大家得以依附计算学的辩解看它所处的岗位特征,衡量它相近邻居的权重,而把它归为(或分配)到权重越来越大的那一类。那正是K近邻算法的核激情想。其主要性还在于K值的选项,所以应当严慎。

KNN算法中,所选用的邻里都以曾经不易分类的靶子。该方法在定类决策上只遵照最接近的叁个或然多少个样本的花色来决定待分样本所属的档案的次序。

KNN 算法自己轻松有效,它是一种 lazy-learning 算法,分类器没有需求采纳练习集进行练习,磨练时间复杂度为0。KNN 分类的计量复杂度和教练聚集的文档数目成正比,约等于说,假诺练习聚焦文档总的数量为 n,那么 KNN 的归类时间复杂度为O(n)。


欧式距离这里也不说了,有乐趣能够去翻自家那篇python_相距衡量,里面写的很详细,并用符号体现表达,你也足以改成棋盘距离或街区距离试试,速度恐怕会比欧式距离快,但依然安利欧式距离。

(1)搜罗数据:能够应用别的格局(如爬虫)。

1)总括已知体周密据汇总的点与眼下点时期的离开;

python代码落成认证

毫无疑问总括包:numpy
运算符模块:operator

目录

有点没搞驾驭的就是,对坐标进行精度化总括那块,实地衡量后分明使用直接计算无论是错误率仍旧精度,管理前都要比拍卖后更标准,恐怕原代码使用小数点的可能率越来越高些呢,可能那一个总计对于小数计算精度更有帮助

(2)准备数据:距离计算机技术琢磨所要求的数值,最棒是结构化的多少格式。

2)根据距离递增次序排序;

shape函数表明

shape函数是numpy.core.fromnumeric中的函数,它的遵循是翻开矩阵或然数组的维数

代码:

>>> a = array([[1,2,3],[5,6,9],[9,8,9]])
>>> a.shape
(3, 3)
>>> a.shape[0]
3
  1. 关于 numpy
  2. numpy 库
  3. numpy 基本操作
  4. numpy 复制操作
  5. numpy 计算
  6. numpy 常用函数

闲聊一些,十分的少也十分的多,上边上代码,代码中配有伪代码,方便阅读,如若还看不太知道能够留言,小编把详细注明加上

(3)剖析数据:能够接纳任何情势。

3)选用与当前点距离最小的k个点;

numpy.tile函数表明

函数方式:tile(A,rep)
功效:重复A的次第维度
参数类型:
A: Array类的都能够
rep:A沿着各类维度重复的次数

>>> a =array([[1,2,3],[5,6,9],[9,8,9]])
>>> tile(a,3)
array([[1, 2, 3, 1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9, 9, 8, 9]])
>>> tile(a,[3,2])
array([[1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9],
       [1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9],
       [1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9]])
>>> tile(a,[2,2,3])
array([[[1, 2, 3, 1, 2, 3, 1, 2, 3],
        [5, 6, 9, 5, 6, 9, 5, 6, 9],
        [9, 8, 9, 9, 8, 9, 9, 8, 9],
        [1, 2, 3, 1, 2, 3, 1, 2, 3],
        [5, 6, 9, 5, 6, 9, 5, 6, 9],
        [9, 8, 9, 9, 8, 9, 9, 8, 9]],

       [[1, 2, 3, 1, 2, 3, 1, 2, 3],
        [5, 6, 9, 5, 6, 9, 5, 6, 9],
        [9, 8, 9, 9, 8, 9, 9, 8, 9],
        [1, 2, 3, 1, 2, 3, 1, 2, 3],
        [5, 6, 9, 5, 6, 9, 5, 6, 9],
        [9, 8, 9, 9, 8, 9, 9, 8, 9]]])

reps的数字从后往前分别对应A的第N个维度的重新次数。

如:

  • tile(A,3)表示A的首先个维度重复3遍。
  • tile(A,(3,2))表示A的率先个维度重复2遍,然后第二个维度重复3遍。
  • tile(A,(2,2,3))表示A的首先个维度重复3遍,第一个维度重复2遍,第三维重复2遍。

 

 

(4)测量检验算法:总结舍入误差率。

4)分明前k个点所在类其余出现频率;

sum函数表明

函数情势:sum(axis = 0 or 1)
函数作用:未有axis参数表示全部相加,axis=0表示按列相加,axis=1表示根据行的样子相加(取‘厉害’谐音)

>>> b = tile(a,[3,2])
>>> b
array([[1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9],
       [1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9],
       [1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9]])
>>> c = b.sum(axis = 0)
>>> c
array([45, 48, 63, 45, 48, 63])
>>> d = b.sum(axis = 1)
>>> d
array([12, 40, 52, 12, 40, 52, 12, 40, 52])
>>> e = b.sum()
>>> e
312
>>>

1 关于numpy / About numpy

以下是代码中使用颜色,接纳html的16进制LX570GB颜色,在应用时将其改变为10进制数字总结,old_case选用灰褐圈,new_case选用碧绿圈

(5)使用算法:首先须求输入样本数量和结构化的出口结果,然后运转K-近邻算法判断输入数据分别属于哪个分类,最终动用对计量出的归类推行后续的管理。

5)重临前k个点出现频率最高的品类作为当下点的展望分类。

argsort函数表明

函数方式:argsort(x) or x.argsort()
参数功效:argsort函数再次来到的是数组值从小到大的索引值

>>> x = array([3,4,2,5,1,6])
#按升序排列
>>> x.argsort()
array([4, 2, 0, 1, 3, 5])
#按升序排列
>>> argsort(-x)
array([5, 3, 1, 0, 2, 4])
>>>

NumPy系统是Python的一种开源的数值总括扩张包。这种工具可用来存款和储蓄和管理特大型矩阵,比Python自个儿的嵌套列表(nested list structure)结构要飞速的多(该组织也能够用来表示矩阵(matrix))。听闻NumPy将Python相当于产生一种免费的越来越强大的MatLab系统。参照他事他说加以考察官网解释,

白色(落苏颜色)

  1. K-近邻算法的伪代码和Python代码

对于机器学习而已,Python必要非凡安装三件宝,分别是Numpy,scipy和Matplotlib。前双方用于数值计算,前者用于画图。安装很简单,直接到各自的官方网址下载回来安装就能够。安装程序会活动搜索大家的python版本和目录,然后安装到python援救的搜寻路径下。反正就python和那八个插件都默许安装就没难题了。

sort函数、sorted函数表达

函数格局:sorted(iterable,cmp,key,reverse)
函数成效:排序

  • sort对列表list进行排序,而sorted能够对list也许iterator实行排序

  • sort函数对列表list进行排序时会影响列表list本人,而sorted不会

参数类型:
iterable:是可迭代类型;
cmp:用于比较的函数,相比什么由key决定;
key:用列表成分的某部属性或函数进行作为首要字,有私下认可值,迭代集合中的一项;
reverse:排序法规. reverse = True 降序 或许 reverse = False 升序,有暗许值。
重临值:是三个因而排序的可迭代类型,与iterable一样。

>>> a = [7,3,9,4,1]
>>> sorted(a)
[1, 3, 4, 7, 9]
>>> a
[7, 3, 9, 4, 1]
>>> a.sort()
>>> a
[1, 3, 4, 7, 9]

NumPy is the fundamental package for scientific computing with Python. It contains among other things:

澳门新萄京官方网站 2

对未知种类属性的数额集中的每一个点依次实践以下操作:

诚如完成三个算法后,大家要求先用多个不大的数据库来测验它的不利,不然一下子给个大数目给它,它也很难消化,何况还不方便人民群众我们剖析代码的管事。

operator.itemgetter函数

>>> a = [1,2,3]
>>> b = operator.itemgetter(1)//定义函数b,获取对象的第1个域的值
>>> b(a)
2
>>> b = operator.itemgetter(0,1)//定义函数b,获取对象的第1个域和第0个的值
>>> b(a)
(1, 2)

源码

  • a powerful N-dimensional array object
  • sophisticated (broadcasting) functions
  • tools for integrating C/C and Fortran code
  • useful linear algebra, Fourier transform, and random number capabilities

栗色(胡瓜颜色)

(1)总括已知种类数据汇总的点与方今点之间的距离。

 

Besides its obvious scientific uses, NumPy can also be used as an efficient multi-dimensional container of generic data. Arbitrary data-types can be defined. This allows NumPy to seamlessly and speedily integrate with a wide variety of databases.

澳门新萄京官方网站 3

(2)依据距离递增次序排序。

补给用python完成的代码,要给python装numpy和matplotlib库,提出间接装anaconda,装好了anaconda暗中认可安装了spyder,里面集成了那多个库,比较便利。

NumPy is licensed under the BSD license, enabling reuse with few restrictions.

风骚(美蕉颜色)

(3)选拔与当下点离开最小的k个点。

先是,大家新建三个kNN.py脚本文件,文件之中含有多少个函数,三个用来生成小数据库,八个兑现kNN分类算法。代码如下:

三个用python达成的没有错总计包。包涵:

澳门新萄京官方网站 4

(4)鲜明前k个点所在类别的面世频率。

# -*- coding: utf-8 -*-
from numpy import *
def createDataSet():#创建一个很小的数据库
    group=array([[1.0,0.9],[1.0,1.0],[0.1,0.2],[0.0,0.1]])
    labels=['A','A','B','B']
    return group,labels
#[1.2,1.0]
def kNNClassify(newInput,dataset,labels,k):#knn算法核心
    #先求数据库中每个点到所求点之间的距离
    numSamples=dataset.shape[0] #获取数据库的行数
    diff=tile(newInput,(numSamples,1))-dataset#使用tile函数迭代创建一个numSample行1列的array与dataset做差
    squaredDiff=diff**2#diff中的每一个数都平方
    squaredDist=sum(squaredDiff,axis=1)#每一行两数求和
    distance=squaredDist**0.5#再开方
    #再对距离进行排序
    sortedDistIndices=argsort(distance)#argsort函数对distance中元素从小到大排序,返回序号
    classCount={}
    #统计距离小于等于k的每个点的类别
    for i in xrange(k):
       voteLabel=labels[sortedDistIndices[i]]
       classCount[voteLabel]=classCount.get(voteLabel,0) 1
    maxCount=0              
    #找出离所求点最近的k个点中最多的类别         
    for key,value in classCount.items():
        if maxCount<value:
            maxCount=value
            maxIndex=key
    #返回所求点的类型,算法到此结束
    return maxIndex
  1. 一个无敌的N维数组对象Array;
  2. 相比成熟的(广播)函数库;
  3. 用于整合C/C 和Fortran代码的工具包;
  4. 实用的线性代数、傅里叶调换和自便数生成函数。numpy和抛荒矩阵运算包scipy协作使用更为实惠。

梅红(小瓜颜色)

(5)重返前k个点出现频率最高的花色作为当下点的推断分类。

  然后大家在命令行中或在建贰个python文件那样测验就能够:

NumPy(Numeric Python)提供了众多高等的数值编制程序工具,如:矩阵数据类型、矢量管理,以及精细的运算库。专为实行严俊的数字管理而发出。多为广大巨型金融集团接纳,以及宗旨的科学总结协会如:LawrenceLivermore,NASA用其管理局地不移至理使用C ,Fortran或Matlab等所做的职责。

澳门新萄京官方网站 5

程序代码:

import kNN
from numpy import *

dataSet,labels=kNN.createDataSet()
testX=array([0,0.05])
k=3
maxIndex=kNN.kNNClassify(testX,dataSet,labels,3)
print maxIndex

广播准则(rule)

代码见下

def classify0(inX, dataSet, labels, k):
    dataSetSize = dataSet.shape[0]  
    diffMat = tile(inX, (dataSetSize,1)) - dataSet
    sqDiffMat = diffMat**2
    sqDistances = sqDiffMat.sum(axis=1)
    distances = sqDistances**0.5
    sortedDistIndicies = distances.argsort()     
    classCount={}          
    for i in range(k):
        voteIlabel = labels[sortedDistIndicies[i]]
        classCount[voteIlabel] = classCount.get(voteIlabel,0)   1
    sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True)
    return sortedClassCount[0][0]

  运维程序:此时点[0,0.05]最接近B类。

广播法则能使通用函数有含义地管理不抱有同等形状的输入。

#!/usr/bin//python
# coding: utf-8

'''
1、获取key和coord_values,样例使用的是list,但是如果真正用在训练上的话list就不适合了,建议改为使用数据库进行读取
2、对坐标进行精度化计算,这个其实我没理解是为什么,可能为了防止错误匹配吧,书上是这样写的
3、指定两个参数,参数一是新加入case的坐标,参数二是需要匹配距离最近的周边点的个数n,这里赢指定单数
4、距离计算,使用欧式距离
  新加入case的坐标与每一个已有坐标计算,这里还有优化空间,以后更新
  计算好的距离与key做成新的key-value
  依据距离排序
  取前n个case
5、取得key
  对前n个case的key进行统计
  取统计量结果最多的key即是新加入case所对应的分组
6、将新加入的values与分组写成key-value加入已有的key-value列队
输入新的case坐标,返回第一步......递归
'''

import operator

def create_case_list():
  # 1代表黄瓜,2代表香蕉,3代表茄子,4代表西葫芦
  case_list = [[25,3,73732],[27.5,8,127492],[13,6,127492],[16,13,50331049],[17,4,18874516],[22,8,13762774],[14,1,30473482],[18,3,38338108]]
  case_type = [1,1,2,2,3,3,4,4]
  return case_list,case_type

def knn_fun(user_coord,case_coord_list,case_type,take_num):
  case_len = len(case_coord_list)
  coord_len = len(user_coord)
  eu_distance = []
  for coord in case_coord_list:
    coord_range = [(user_coord[i] - coord[i]) ** 2 for i in range(coord_len)]
    coord_range = sum(coord_range) ** 0.5
    eu_distance.append(coord_range)
  merage_distance_and_type = zip(eu_distance,case_type)
  merage_distance_and_type.sort()
  type_list = [merage_distance_and_type[i][1] for i in range(take_num)]
  class_count = {}
  for type_case in type_list:
    type_temp = {type_case:1}
    if class_count.get(type_case) == None:
      class_count.update(type_temp)
    else: class_count[type_case]  = 1
  sorted_class_count = sorted(class_count.iteritems(), key = operator.itemgetter(1), reverse = True)
  return sorted_class_count[0][0]

def auto_norm(case_list):
  case_len = len(case_list[0])
  min_vals = [0] * case_len
  max_vals = [0] * case_len
  ranges = [0] * case_len
  for i in range(case_len):
    min_list = [case[i] for case in case_list]
    min_vals[i] = min(min_list)
    max_vals[i] = max([case[i] for case in case_list])
    ranges[i] = max_vals[i] - min_vals[i]
  norm_data_list = []
  for case in case_list:
    norm_data_list.append([(case[i] - min_vals[i])/ranges[i] for i in range(case_len)])
  return norm_data_list,ranges,min_vals

def main():
  result_list = ['黄瓜','香蕉','茄子','西葫芦']
  dimension1 = float(input('长度是: '))
  dimension2 = float(input('弯曲度是: '))
  dimension3 = float(input('颜色是: '))
  case_list,type_list = create_case_list()
  #norm_data_list,ranges,min_vals = auto_norm(case_list)
  in_coord = [dimension1,dimension2,dimension3]
  #in_coord_len = len(in_coord)
  #in_coord = [in_coord[i]/ranges[i] for i in range(in_coord_len)]
  #class_sel_result = knn_fun(in_coord,norm_data_list,type_list,3)
  class_sel_result = knn_fun(in_coord,case_list,type_list,3)
  class_sel_result = class_sel_result - 1
  return result_list[class_sel_result]

if __name__ == '__main__':
  a = main()
  print '这货是: %s' %a

代码解释:

 应用:这里大家用kNN来分类三个大点的数据库,满含数据维度一点都不小和样本数比相当多的数据库。这里大家用到贰个手写数字的数据库,能够到这里下载。这几个数据库包含数字0-9的手写体。每一种数字大约有200个样本。各种样本保持在多个txt文件中。手写体图像本人的分寸是32x32的二值图,转变来txt文件保留后,内容也是32x叁11个数字,0大概1.

广播第一法则是,假诺持有的输入数组维度不都一样,三个“1”将被重新鸿基土地资产增添在维度一点都不大的数组上直至全部的数组具有同样的维度。

测量检验结果,效果还不赖

(1)classify0()函数的三个输入参数:inX 用于分类的输入向量,dataSet是输入的教练样本集,labels是标签向量,最终k是用于选用近期邻的数据,当中标签向量的成分数目和矩阵dataSet的行数一样。

数据库解压后有三个目录:目录trainingDigits寄放的是轮廓3000个教练多少,testDigits贮存大概900个测验数据。

播音第二法规鲜明长度为1的数组沿着特殊的矛头表现地临近它有沿着那三个样子最大形状的尺寸。对数组来讲,沿着这些维度的数组成分的值理应同等。

澳门新萄京官方网站 6

(2)代码中度量四个对象距离的情势是欧几里得公式:

编写kNN2.py:

应用广播法规之后,全数数组的尺寸必须合营。

                                                                                         澳门新萄京官方网站 7

 

 

(3)shape函数是numpy.core.fromnumeric中的函数,它的效率是读取矩阵的长度,比方shape[0]即使读取矩阵第一维度的尺寸。它的输入参数能够使三个整数表示维度,也足以是一个矩阵。

# -*- coding: utf-8 -*-
from numpy import *
import os
def kNNClassify(newInput,dataset,labels,k):#knn算法核心
    #先求数据库中每个图像与所要分类图像像素值差的平方再开方,用这种计算方法表示距离(相似度)俗称欧氏距离
    numSamples=dataset.shape[0] #获取数据库的行数(即文件夹下的文件数)
    diff=tile(newInput,(numSamples,1))-dataset#使用tile函数迭代创建一个numSample行1列的array与dataset做差
    squaredDiff=diff**2#diff中的每一个数都平方
    squaredDist=sum(squaredDiff,axis=1)#每一行的数求和
    distance=squaredDist**0.5#再开方
    #再对距离进行排序
    sortedDistIndices=argsort(distance)
    classCount={}
    #统计距离为k的每个图像的类别(即统计相似度最小的k个图像所表示的数字)
    for i in xrange(k):  
        voteLabel = labels[sortedDistIndices[i]]  
        classCount[voteLabel] = classCount.get(voteLabel, 0)   1

    maxCount=0            
    #找出离所求图像类别最近的k个图像中最多的类别       
    for key,value in classCount.items():
        if maxCount<value:
            maxCount=value
            maxIndex=key
    #返回所求图像的类型(类型即数字)
    return maxIndex

#函数img2vector把一张32*32的图像转化成一行向量imgVector
def img2vector(filename):
    rows=32
    cols=32
    imgVector=zeros((1,rows*cols))
    fileIn=open(filename)
    for row in xrange(rows):
        lineStr=fileIn.readline()
        for col in xrange(cols):
            imgVector[0,row*32 col]=int(lineStr[col])
    return imgVector

#函数loadDataSet从文件夹中加载多个文件数据,python对文件数据流加载到内存的操作很方便,这里的代码可以仔细理解加记忆一下
def loadDataSet():
    dataSetDir='/home/chao/Desktop/python_work/knn/'
    trainingFileList=os.listdir(dataSetDir 'trainingDigits')
    numSamples=len(trainingFileList)
    train_x=zeros((numSamples,1024))#使用zeros函数为train_x分配numSamples行,每行1024列,每行为一个图像转化后的数据,总共numSamples行
    train_y=[]#用来存放每个图像的真实值
    for i in xrange(numSamples):
        filename=trainingFileList[i]
        train_x[i,:]=img2vector(dataSetDir 'trainingDigits/%s'%filename)
        label=int(filename.split('_')[0])
        train_y.append(label)
    testingFileList=os.listdir(dataSetDir 'testDigits')
    numSamples=len(testingFileList)
    test_x=zeros((numSamples,1024))#同train_x,但这里表示的是测试图像文件的
    test_y=[]
    for i in xrange(numSamples):
        filename=testingFileList[i]
        test_x[i,:]=img2vector(dataSetDir 'testDigits/%s'%filename)
        label=int(filename.split('_')[0])
        test_y.append(label)
    return train_x,train_y,test_x,test_y

#测试预测准确率
def testHandWritingClass():
    print "第一步:加载数据。。。"
    train_x,train_y,test_x,test_y=loadDataSet()

    numTestSamples=test_x.shape[0]#返回待测试图像的个数
    print "数据加载完成"
    matchCount=0#用来表示预测正确的图像的个数
    #每个待测图像都要调用一次knn预测其值
    for i in xrange(numTestSamples):
        print i
        predict=kNNClassify(test_x[i],train_x,train_y,3)#这里k=3准确率达98.63%,如果改成k=1的话会达到98.97%
        if predict==test_y[i]:
            matchCount =1
    accuracy=float(matchCount)/numTestSamples
    print matchCount#打印正确预测个数
    print "accuracy is:%.2f%%"%(accuracy*100)#打印正确预测准确率

2 numpy库 / numpy Library

(4)tile函数是模板numpy.lib.shape_base中的函数。函数的款型是tile(A,reps)

 

条件设置:

        A的类型差不离全体体系都得以:array, list, tuple, dict, matrix以及着力数据类型int, string, float以及bool类型。

测量试验极度简单,编写几个main.py:

pip install numpy  

        reps的类型也比很多,能够是tuple,list, dict, array, int,bool.但不可能是float, string, matrix类型。行列重复copy的次数。

# -*- coding: utf-8 -*-
import kNN2
kNN2.testHandWritingClass()

 

(5)sum函数中投入参数。sum(a,axis=0)或许是.sum(axis=1) ,axis=0 就是常常的相加 ;参与axis=1以后就是将叁个矩阵的每一行向量相加。

然后运维main.py观望准确率:

2.1 常量 / Constants

(6)argsort函数再次来到的是数组值从小到大的索引值。

933个预测正确
accuracy is:98.63%

2.1.1 pi常量

 (7)   get() 函数重回字典钦赐键的值,就算值不在字典中重临默认值。

 版权证明:原著地址

*常量名: pi***

(8)sorted进行排序,sorted(iterable, cmp=None, key=None, reverse=False)

*常量值:*** π 

         iterable:是可迭代类型;
         cmp:用于比较的函数,相比较什么由key决定;
         key:用列表成分的某部属性或函数进行作为最首要字,有暗中认可值,迭代集合中的一项;
         reverse:排序法规. reverse = True  降序 或许 reverse = False 升序,有暗中认可值。
         重临值:是一个由此排序的可迭代类型,与iterable同样。

 

3 示例-使用K-近邻算法立异约会网站的配对效果与利益

2.2 函数 / Function

3.1 企图数据:从文本文件中剖判数据

2.2.1 array()函数

将待管理数据的格式改换为分类器尚可的格式。

*函数调用: ndarray = np.array(matrix_list)***

代码达成:

*函数成效:***生成三个ndarray格式的多维矩阵

 1 def file2matrix(filename):
 2     fr = open(filename)
 3     numberOfLines = len(fr.readlines())         #get the number of lines in the file
 4     returnMat = zeros((numberOfLines,3))        #prepare matrix to return
 5     classLabelVector = []                       #prepare labels return   
 6     fr = open(filename)
 7     index = 0
 8     for line in fr.readlines():
 9         line = line.strip()
10         listFromLine = line.split('t')
11         returnMat[index,:] = listFromLine[0:3]
12         classLabelVector.append(int(listFromLine[-1]))
13         index  = 1
14     return returnMat,classLabelVector

*传入参数: matrix_list***

代码解释:

matrix_list: list类型,须求转变来矩阵的列表

(1)file2matrix ()函数的参数,filename接收文件名。

*再次来到参数: ndarray***

(2)open(路线 文件名,读写格局),读写形式:r只读,r 读写,w新建(会覆盖原有文件),a追加,b二进制文件。

ndarray: ndarray类型,numpy生成的矩阵

(3)readlines() 自动将文件内容剖判成贰个行的列表,该列表能够由 Python 的 for ... in ... 结构进行管理。

 

(4)len()得到列表中的成分个数。

2.2.2 arange()函数

(5)zeros(shape, dtype=float, order='C'),重临来五个给定形状和品种的用0填充的数组;

*函数调用: vector = np.arange(num)***

         参数:shape:形状

*函数效能:***生成贰个1行n列的ndarray矩阵(一维向量)

                   dtype:数据类型,可选参数,暗中认可numpy.float64

*传入参数: num***

                   dtype类型:t ,位域,如t4代表4位

num: int类型,生成向量的数额个数(从0计算)

                                     b,布尔值,true or false

*再次来到参数: vector***

                                     i,整数,如i8(64位)

vector: ndarray类型,numpy生成的矩阵(一维)

                                     u,无符号整数,u8(62个人)

 

                                    f,浮点数,f8(64位)

2.2.3 zeros()函数

                                   c,浮点负数,

*函数调用: matrix = np.zeros(shape, dtype=)***

                                   o,对象,

*函数作用:***生成贰个shape形状成分为0,数据类型为dtype的矩阵

                                   s,a,字符串,s24

*传入参数: shape, dtype***

                                   u,unicode,u24

shape: tuple类型,生成的0矩阵的形象

                order:可选参数,c代表与c语言类似,行优先;F代表列优先

dtype: obj类型,如np.float64/np.int32等,分明因素的数据类型

(6)strip() 方法用于移除字符串头尾钦赐的字符,默许删除空白符(包含'n', 'r',  't',  ' ')。

*重临参数: matrix***

 (7)split()正是将三个字符串不相同成多少个字符串组成的列表。

matrix: ndarray类型,numpy生成的零矩阵

3.2 谋算数据:归一化数值

 

差别的性质,其数值的取值范围不一,则计算距离时属性的权重就能不能够掌握控制。因此,平常选取的主意是将数值归一化,如将取值范围管理为0到1依然-1到1里头。其通用公式:

2.2.4 ones()函数

newValue = (oldValue-min) /(max-min)

*函数调用: matrix = np.ones(shape, dtype=)***

中间min和max分别是数据汇总的微小特征值和最大特征值。

*函数作用:***生成一个shape形榜眼素为1,数据类型为dtype的矩阵

代码实现:

*传入参数: shape, dtype***

1 def autoNorm(dataSet):
2     minVals = dataSet.min(0)
3     maxVals = dataSet.max(0)
4     ranges = maxVals - minVals
5     normDataSet = zeros(shape(dataSet))
6     m = dataSet.shape[0]
7     normDataSet = dataSet - tile(minVals, (m,1))
8     normDataSet = normDataSet/tile(ranges, (m,1))   #element wise divide
9     return normDataSet, ranges, minVals

shape: tuple类型,生成的1矩阵的造型

3.3 测量试验算法:作为完全程序验证分类器

dtype: obj类型,如np.float64/np.int32等,鲜明因素的数据类型

一般说来把已有些数据十分八用作战锻炼练样本分类器,其他百分之十数据去测量检验分类器,查证分类器的精确率。

*重返参数: matrix***

代码实现:

matrix: ndarray类型,numpy生成的一矩阵

 1 def datingClassTest():
 2     hoRatio = 0.10      #hold out 10%
 3     datingDataMat,datingLabels = file2matrix('datingTestSet2.txt')       #load data setfrom file
 4     normMat, ranges, minVals = autoNorm(datingDataMat)
 5     m = normMat.shape[0]
 6     numTestVecs = int(m*hoRatio)
 7     errorCount = 0.0
 8     for i in range(numTestVecs):
 9         classifierResult = classify0(normMat[i,:],normMat[numTestVecs:m,:],datingLabels[numTestVecs:m],3)
10         print "the classifier came back with: %d, the real answer is: %d" % (classifierResult, datingLabels[i])
11         if (classifierResult != datingLabels[i]): errorCount  = 1.0
12     print "the total error rate is: %f" % (errorCount/float(numTestVecs))
13     print errorCount

 

测量试验结果:

2.2.5 linspace()函数

澳门新萄京官方网站 8

*函数调用: matrix = np.linspace(start, stop, num=50, endpoint=True)***

基值误差在5%,基本得以兑现对结果的猜测。

*函数作用:***生成七个等差矩阵

4.选取算法:塑造一体化可用系统

*传入参数: start, stop, num, endpoint***

代码落成:

start: int类型,等差矩阵的初叶数

 1 def classifierPerson():
 2    resultList = [u'不喜欢',u'比较喜欢',u'很喜欢']
 3    percentTats = float(raw_input(u"玩视频游戏所耗时间百分百:"))
 4    ffmiles = float(raw_input(u"每年获得的飞行常客里程数:"))
 5    iceCream = float(raw_input(u"每周消耗的冰淇淋公升数:"))
 6    datingDataMat, datingLables = kNN.file2matrix('datingTestSet2.txt')
 7    normMat,ranges,minVals = kNN.autoNorm(datingDataMat )
 8    inArr = array([ffmiles ,percentTats ,iceCream ])
 9    classifierResult = kNN.classify0((inArr-minVals )/ranges,normMat ,datingLables ,3)
10    print u"你对这个人喜欢度: %s" % resultList [classifierResult -1]

stop: int类型,等差矩阵的告一段落数

运作结果:

num: int类型,生成的样书数量,默许50,必须非负

澳门新萄京官方网站 9

endpoint: bool类型,纵然为True,最后贰个数富含stop,False则不包蕴

5 附-对数码深入分析的数码可视化

*再次回到参数: matrix***

 代码完结:

matrix: ndarray类型,numpy生成的等差矩阵

1 def show_data():
2    dataSet,lables = kNN .file2matrix('datingTestSet2.txt')
3    jieguo = kNN .classify0([2674,8.54,8.0],dataSet ,lables ,10)
4    fig= plt.figure()
5    ax = fig.add_subplot(111)
6    ax.scatter(dataSet [:, 1], dataSet [:, 2],
7               15.0*array(lables ),15.0*array(lables))
8    fig.show()
9    raw_input()

 

运维结果:

2.2.6 view()函数

澳门新萄京官方网站 10

*函数调用: new_matrix = matrix.view()***

 

*函数作用:***创设八个新的矩阵,与原始矩阵共享原始数据(不共享别的音信,id差别)

*传入参数:无***

*再次来到参数: new_ matrix***

new_matrix: ndarray类型,view函数生成的新矩阵

 

2.2.7 copy()函数

*函数调用: new_matrix = matrix.copy()***

*函数功效:***创造二个新的矩阵,完全复制,且不分享任何能源,三个非亲非故矩阵

*传入参数:无***

*重回参数: new_ matrix***

new_matrix: ndarray类型,copy函数生成的新矩阵

 

2.2.8 sin/cos()函数

*函数调用: matrix = np.sin/cos(matrix)***

*函数成效:***对矩阵的种种成分举办sin/cos操作

*传入参数: matrix***

matrix: ndarray类型,须要管理的矩阵

*重临参数: matrix***

matrix: ndarray类型,sin/cos后变化的矩阵

 

2.2.9 exp()函数

*函数调用: new_matrix = np.exp(matrix)***

*函数功用:***对矩阵元素进行以e为底的乘方运算(e^x)

*传入参数: matrix***

matrix: ndarray类型,总计矩阵

*再次回到参数: new_matrix***

new_matrix: ndarray类型,乘方运算后的矩阵

 

2.2.10 sqrt()函数

*函数调用: new_matrix = np.sqrt(matrix)***

*函数成效:***对矩阵成分实行以开药方运算

*传入参数: matrix***

matrix: ndarray类型,总计矩阵

*再次回到参数: new_matrix***

new_matrix: ndarray类型,开方运算后的矩阵

 

2.2.11 dot()函数

*函数调用: matrix = np.dot(matrix_1, matrix_2) / matrix = matrix_1.dot(matrix_2)***

*函数作用:***将三个矩阵展开点乘运算

*传入参数: matrix_1, matrix_2***

matrix_1: ndarray类型,点乘矩阵1

matrix_2: ndarray类型,点乘矩阵2

*重临参数: matrix***

matrix: ndarray类型,点乘后变化的矩阵

 

2.2.12 floor/ceil()函数

*函数调用: new_matrix = np.floor/ceil(matrix)***

*函数成效:***对矩阵中的各种成分实行取整操作(floor向下,ceil向上)

*传入参数: matrix***

matrix: ndarray类型,总计矩阵

*再次回到参数: new_matrix***

new_matrix: ndarray类型,取整管理后的矩阵

 

2.2.13 argmax()函数

*函数调用: index = matrix.argmax(axis=None)***

*函数功效:***获取原矩阵的最大值/每行/列最大值所在索引

*传入参数: axis***

asix: bool/int类型,None则赶回最大值,0/1则赶回每列/行中最大值的目录

*重返参数: index***

index: int/ndarray类型,最大值或每行/列最大值索引矩阵

 

2.2.14 ravel()函数

*函数调用: new_matrix = matrix.ravel(order=‘C’)***

*函数功用:***对原矩阵张开采展(flatten)操作,变成三个单行矩阵

*传入参数: order***

order: str类型,分明取值方向

*再次回到参数: new_matrix***

new_matrix: ndarray类型,取整管理后的矩阵

 

2.2.15 hstack / vstack()函数

*函数调用: new_matrix = np.hstack/vstack(tup)***

*函数成效:***对原矩阵在等级次序/竖直方向拓展堆集(堆积地点维度必要一致)

*传入参数: tup***

tup: tuple类型,(a, b),包涵五个须要开展堆成堆的矩阵a和b

*重临参数: new_matrix***

new_matrix: ndarray类型,聚积管理后的矩阵

 

2.2.16 hsplit / vsplit()函数

*函数调用: new_matrix = np.hsplit/vsplit(matrix, indices_or_sections)***

*函数功用:***对原矩阵在档期的顺序/竖直方向实行拆分

*传入参数: matrix, indices_or_section***

matrix: ndarray类型,必要分割的原始矩阵

indices_or_section: int/tuple类型,int则象征供给切割的份数,tuple则象征须求切割的任务,如(3,4)表示切割地点在3h/v和4h/v之内

*再次回到参数: new_matrix***

new_matrix: list类型,切割管理后的矩阵列表,富含切割后的保有array

 

2.2.17 tile()函数

*函数调用: new_matrix = np.tile(matrix, reps)***

*函数功效:**对原矩阵展开铺展,原矩阵(c, d), reps=(a, b),则张开成(ac, b*d)结构

*传入参数: matrix, reps***

matrix: ndarray类型,须要举行铺展的原始矩阵

reps: tuple类型,铺展形状

*重临参数: new_matrix***

new_matrix: ndarray类型,铺展管理后的矩阵

 

2.2.18 sort()函数

*函数调用: new_matrix = np.sort(matrix, axis=-1, kind=’quicksort’, order=None)***

*函数成效:***对原矩阵按行/列进行排序

*传入参数: matrix, axis, kind, order***

matrix: ndarray类型,要求进行排序的原始矩阵

axis: int/bool类型,None则将矩阵展开后排列, 0则按shape的第一维度排序,1,则按第二维度,依次类推,-1则为按最后二个维度排列

kind: str类型,鲜明sort的排序算法,满含{‘quicksort’, ‘mergesort’, ‘heapsort’}

order: str/list of str类型,分明排序的优先级,钦点的优先排序,未内定的暗中同意排序

*再次来到参数: new_matrix***

new_matrix: ndarray类型,排序管理后的矩阵

Eg.:

 1 import numpy as np
 2 
 3 x = np.array([[range(16, 12, -1), range(12, 8, -1), range(8, 4, -1)], [range(12, 8, -1), range(8, 4, -1), range(4, 0, -1)]])
 4 print(x)
 5 print(x.shape)
 6 print('----------------')
 7 print(np.sort(x, axis=None))
 8 print('----------------')
 9 print(np.sort(x, axis=0))
10 print('----------------')
11 print(np.sort(x, axis=1))
12 print('----------------')
13 print(np.sort(x, axis=-1))

出口结果

澳门新萄京官方网站 11澳门新萄京官方网站 12

[[[16 15 14 13]
  [12 11 10  9]
  [ 8  7  6  5]]

 [[12 11 10  9]
  [ 8  7  6  5]
  [ 4  3  2  1]]]
(2, 3, 4)
----------------
[ 1  2  3  4  5  5  6  6  7  7  8  8  9  9 10 10 11 11 12 12 13 14 15 16]
----------------
[[[12 11 10  9]
  [ 8  7  6  5]
  [ 4  3  2  1]]

 [[16 15 14 13]
  [12 11 10  9]
  [ 8  7  6  5]]]
----------------
[[[ 8  7  6  5]
  [12 11 10  9]
  [16 15 14 13]]

 [[ 4  3  2  1]
  [ 8  7  6  5]
  [12 11 10  9]]]
----------------
[[[13 14 15 16]
  [ 9 10 11 12]
  [ 5  6  7  8]]

 [[ 9 10 11 12]
  [ 5  6  7  8]
  [ 1  2  3  4]]]

View Code

2.2.19 argsort()函数

*函数调用: index_matrix = np.argsort(matrix, axis=-1)***

*函数功用:***再次来到矩阵按行/列实行排序后的索引值列表

*传入参数: matrix, axis***

matrix: ndarray类型,必要展开排序的原始矩阵

axis: int/bool类型,None则将矩阵张开后排列, 0则按shape的率先维度排序,1,则按第二维度,依次类推,-1则为按最终一个维度排列

*重返参数: index_matrix***

index_matrix: ndarray类型,排序管理后的索引矩阵

 

2.2.20 T属性方法

*方法调用: T_matrix = matrix.T***

*方法效果:***对原矩阵张开转置操作

*传入参数:无***

*再次来到参数: T_matrix***

T_matrix: ndarray类型,转置管理后的矩阵

 

2.3 / Class

2.3.1 ndarray类

*类实例化:ndarray = np.array(matrix_list) / np.arange(num)***

*类的功用:***用于生成矩阵数组

*传入参数: matrix_list / num***

matrix_list: list类型,包括须要创设成ndarray矩阵的数量

num: int类型,生成ndarray的数码数量

*重返参数: ndarray***

ndarray: ndarray类型,生成的ndarray矩阵

 

2.3.1.1 dtype属性

*属性调用: fmt = ndarray.dtype澳门新萄京官方网站:左邻右舍算法,机器学习算法_knn。***

*属性作用:*** 再次回到矩阵内数据的格式类型

*属性参数: fmt***

fmt: obj类型,<class ‘numpy.dtype’>

 

2.3.1.2 shape属性

*属性调用: shp = ndarray.shape / ndarray.shape = shp***

*属性功效:*** 再次来到矩阵各维度长度参数 / 更动矩阵各维度长度参数

*属性参数: shp***

shp: tuple类型,eg. 3维矩阵再次来到 (x, y, z)

 

2.3.1.3 ndim属性

*属性调用: rank = ndarray.ndim***

*属性功效:*** 再次来到矩阵的秩

*属性参数: rank***

rank: int类型,矩阵的秩

 

2.3.1.4 size属性

*属性调用: size = ndarray.size***

*属性效率:*** 再次回到矩阵的因素总的数量

*属性参数: size***

siez: int类型,矩阵的要素总的数量,等于shape中的成分乘积

 

2.3.1.5 itemsize属性

*属性调用: iSize = ndarray.itemsize***

*属性功效:*** 再次来到矩阵的因素总量

*属性参数: size***

siez: int类型,数组中各类成分的字节大小。比如,叁个要素类型为float64的数组itemsize属性值为8(=64/8),又如,贰个因素类型为complex32的数组item属性为4(=32/8)

 

2.3.1.6 data属性

*属性调用: mem = ndarray.data***

*属性效能:*** 再次来到富含实际数组成分的缓冲区

*属性参数: mem***

siez: obj类型,type: <class ‘memoryview’>,value: <memory at 0x00000X00X>

 

2.3.1.7 reshape方法

*函数调用: new_matrix = matrix.reshape (shape)***

*函数功能:***再次来到贰个依据原始数据重排的矩阵

*传入参数: shape, order***

shape: tuple/int类型,用于明确新矩阵的维度参数,若一个元组有个别维度为-1,则该维度由其他维度总括得出

order: str类型,‘C’表示将原始数据依靠行顺序重排列,‘F’表示依据列顺序

*重返参数: new_matrix***

new_matrix: ndarray类型,重排后的矩阵

 

2.3.1.8 min/max()方法

*函数调用: value = matrix.min/max()***

*函数效能:***再次来到矩阵中的最小/最大值

*传入参数:无***

*再次来到参数澳门新萄京官方网站:左邻右舍算法,机器学习算法_knn。: value***

value: int/str类型,矩阵中的最小/最大值

 

2.3.1.9 sum()方法

*函数调用: value = matrix.sum(axis=None)***

*函数效用:***重回矩阵的求和值

*传入参数: axis***

axis: int/None类型,None时重返矩阵全部因素之和,axis=0重返第1个维度求和值,axis=1首个维度

*重临参数: value***

value: int/str类型,矩阵中的求和值

 

2.4 模块 / Module

2.4.1 random模块

2.4.1.1 常量

Pass

2.4.1.2 函数

2.4.1.2.1 random()函数

*函数调用: rdm = np.random.random(shape)***

*函数功能:***再次来到一个shape形状的即兴成分矩阵

*传入参数: shape***

shape: tuple类型,随机矩阵的维度形状

*重返参数: rdm***

rdm: ndarray类型,重临的随机值矩阵

 

2.4.1.2.2 ranint()函数

*函数调用: rdi = np.random.randint(start, stop, num)***

*函数效能:***再次来到贰个放肆整数列表

*传入参数: start, stop, num***

start: int类型,随机数起先值

stop: int类型,随机数终止值

num: int类型,随机数数据

*重回参数: rdi***

rdi: list类型,再次来到的随机值列表

 

3 numpy基本操作

下边包车型大巴代码提供了有的 numpy 基本函数的施用方法,

一体化代码

澳门新萄京官方网站 13澳门新萄京官方网站 14

 1 import numpy as np
 2 
 3 # Change type, all the elements in array should be in same type.
 4 matrix = np.array([1, 2, 3, 4])
 5 print(matrix, matrix.dtype)         # [1 2 3 4] int32
 6 matrix = np.array([1, 2, 3, 4.0])
 7 print(matrix, matrix.dtype)         # [ 1.  2.  3.  4.] float64
 8 matrix = np.array([1, 2, 3, '4'])
 9 print(matrix, matrix.dtype)         # ['1' '2' '3' '4'] <U11
10 
11 # Basic slice operation
12 matrix = np.array([[1, 2, 3, 4],
13              [5, 6, 7, 8],
14              [9, 10, 11, 12],
15              [13, 14, 15, 16]])
16 # Get number certain element(7), [row, column]
17 print(matrix[1,2])          # 7
18 # Get all row and column 3
19 print(matrix[:, 2])         # [3 7 11 15]
20 # Get certain row and column, not contains the max number
21 print(matrix[0:3, 0:2])     ''' [[ 1  2]
22                                  [ 5  6]
23                                  [ 9 10]] '''
24 
25 # Get the number by certain list
26 # (0,0),(1,1),(2,2),(3,3)
27 print(matrix[[0, 1, 2, 3], [0, 1, 2, 3]])   # [1 6 11 16]
28 # Use range method can make it too
29 print(matrix[range(4), range(4)])           # [1 6 11 16]
30 
31 # Operation to array will act to each element
32 equal_to_seven = (matrix == 7)
33 print(equal_to_seven)       ''' [[False False False False]
34                                  [False False  True False]
35                                  [False False False False]
36                                  [False False False False]] '''
37 
38 # equal_to_seven can be use as an index, True/False list also can do so
39 print(matrix[equal_to_seven])       # [7]
40 get_certain_row = [False, True, True, False]
41 print(matrix[get_certain_row])      ''' [[ 5  6  7  8]
42                                          [ 9 10 11 12]] '''
43 # Fetch row where the certain number in
44 matrix = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
45 print(matrix[matrix[:, 2] == 7])    # [[5 6 7 8]]
46 
47 vector = np.array([5, 10, 15, 20])
48 # Find the element equal to ten and five(impossible)
49 equal_to_ten_and_five = (vector == 5) & (vector == 10)
50 print(vector[equal_to_ten_and_five])                    # []
51 # Find the element equal to ten or five
52 equal_to_ten_or_five = (vector == 5) | (vector == 10)   
53 print(vector[equal_to_ten_or_five])                     # [5 10]
54 # Change equal one to other number
55 vector[equal_to_ten_or_five]=50
56 print(vector)                                           # [50 50 15 20]
57 
58 # Change the type of array
59 vector = np.array(['1', '2', '3'])
60 print(vector.dtype, vector)     # <U1 ['1' '2' '3']
61 new_vector = vector.astype(int)
62 print(new_vector.dtype, new_vector)     # int32 [1 2 3]
63 
64 # Get the min number
65 # Use print(help(np.array))
66 vector = np.array([5, 10, 15, 20])
67 print(vector.min())     # 5
68 
69 # Calculate the sum in certain dimension
70 # 1 for cal sum in row, 0 for cal sum in column
71 matrix = np.array([[1, 2, 3, 4],
72              [5, 6, 7, 8],
73              [9, 10, 11, 12],
74              [13, 14, 15, 16]])
75 print(matrix.sum(axis=1))   # [10 26 42 58]
76 print(matrix.sum(axis=0))   # [28 32 36 40]

View Code

支行解释

第一导入 numpy,

随即利用dtype属性查看成分数据类型,numpy中要素的类别必须一律,因而改造贰个因素的类型,则其它成分也会被退换。

1 import numpy as np
2 
3 # Change type, all the elements in array should be in same type.
4 matrix = np.array([1, 2, 3, 4])
5 print(matrix, matrix.dtype)         # [1 2 3 4] int32
6 matrix = np.array([1, 2, 3, 4.0])
7 print(matrix, matrix.dtype)         # [ 1.  2.  3.  4.] float64
8 matrix = np.array([1, 2, 3, '4'])
9 print(matrix, matrix.dtype)         # ['1' '2' '3' '4'] <U11

 获取成分能够依据索引值实行,也得以依附类似列表切成丝的不二秘籍得到

 1 # Basic slice operation
 2 matrix = np.array([[1, 2, 3, 4],
 3              [5, 6, 7, 8],
 4              [9, 10, 11, 12],
 5              [13, 14, 15, 16]])
 6 # Get number certain element(7), [row, column]
 7 print(matrix[1,2])          # 7
 8 # Get all row and column 3
 9 print(matrix[:, 2])         # [3 7 11 15]
10 # Get certain row and column, not contains the max number
11 print(matrix[0:3, 0:2])     ''' [[ 1  2]
12                                  [ 5  6]
13                                  [ 9 10]] '''

使用列表的法子赢得成分,多个列表分别为三个维度,两两结缘获取数据

1 # Get the number by certain list
2 # (0,0),(1,1),(2,2),(3,3)
3 print(matrix[[0, 1, 2, 3], [0, 1, 2, 3]])   # [1 6 11 16]
4 # Use range method can make it too
5 print(matrix[range(4), range(4)])           # [1 6 11 16]

对于矩阵的操作将会独家效用于每多个因素上

 1 # Operation to array will act to each element
 2 equal_to_seven = (matrix == 7)
 3 print(equal_to_seven)       ''' [[False False False False]
 4                                  [False False  True False]
 5                                  [False False False False]
 6                                  [False False False False]] '''
 7 
 8 # equal_to_seven can be use as an index, True/False list also can do so
 9 print(matrix[equal_to_seven])       # [7]
10 get_certain_row = [False, True, True, False]
11 print(matrix[get_certain_row])      ''' [[ 5  6  7  8]
12                                          [ 9 10 11 12]] '''
13 # Fetch row where the certain number in
14 matrix = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
15 print(matrix[matrix[:, 2] == 7])    # [[5 6 7 8]]
16 
17 vector = np.array([5, 10, 15, 20])
18 # Find the element equal to ten and five(impossible)
19 equal_to_ten_and_five = (vector == 5) & (vector == 10)
20 print(vector[equal_to_ten_and_five])                    # []
21 # Find the element equal to ten or five
22 equal_to_ten_or_five = (vector == 5) | (vector == 10)   
23 print(vector[equal_to_ten_or_five])                     # [5 10]
24 # Change equal one to other number
25 vector[equal_to_ten_or_five]=50
26 print(vector)                                           # [50 50 15 20]

选取astype或shape=或reshape进行列表形状修改

1 # Change the type of array
2 vector = np.array(['1', '2', '3'])
3 print(vector.dtype, vector)     # <U1 ['1' '2' '3']
4 new_vector = vector.astype(int)
5 print(new_vector.dtype, new_vector)     # int32 [1 2 3]

获得最大十分的小值,以及求和操作

 1 # Get the min number
 2 # Use print(help(np.array))
 3 vector = np.array([5, 10, 15, 20])
 4 print(vector.min())     # 5
 5 
 6 # Calculate the sum in certain dimension
 7 # 1 for cal sum in row, 0 for cal sum in column
 8 matrix = np.array([[1, 2, 3, 4],
 9              [5, 6, 7, 8],
10              [9, 10, 11, 12],
11              [13, 14, 15, 16]])
12 print(matrix.sum(axis=1))   # [10 26 42 58]
13 print(matrix.sum(axis=0))   # [28 32 36 40]

 

4 numpy复制操作

在numpy(或然说Python)中,复制的矩阵的操作首要有二种方法,

  1. 向来通过赋值操作复制,这种复制得到的多个矩阵具有相同的id,其本质是四个针对同一内部存款和储蓄器空间的不如变量名;
  2. 通过numpy的view函数拓展复制,这种复制能够博得两个id不同的矩阵,分别改变他们的形制等参数是互不影响的,不过两个共享同一本来数据,即修改当中二个的数码内容会对其它叁个发生耳濡目染;
  3. 使用numpy的copy函数进展复制,那是一种截然复制,能够取得多少个完全互不相干的矩阵。

代码如下

 1 import numpy as np
 2 
 3 # The simple assignments make no copy, a and b are two names for one same ndarray object
 4 a = np.arange(12)
 5 b = a 
 6 print(b is a) # True
 7 b.shape = (3, 4)
 8 print(a.shape) # (3, 4)
 9 # a and b with same id
10 print(id(a))
11 print(id(b))
12 
13 # The view method creates a new array obj that share with same source data
14 a = np.arange(12)
15 c = a.view()
16 print(c is a) # False
17 # Change the shape of c will not change the shape of a
18 c.shape = (2, 6)
19 print(a.shape) # (12, )
20 # But Change the data of c will change the data of a 
21 c[1, 2] = 1111
22 print(a)
23 # a and b with different id
24 print(id(a))
25 print(id(b))
26 
27 # The copy method makes a complete copy of array and its data
28 a = np.arange(12)
29 d = a.copy()
30 print(d is a) # False

 

5 numpy计算**

三个同维度矩阵的加减乘除、大小相比、开药方、次幂、取整等操作,都将独家效能在依次要素上,点乘计算能够通过numpy.dot函数进行总括

总体代码

澳门新萄京官方网站 15澳门新萄京官方网站 16

  1 import numpy as np
  2 
  3 a = np.array([20, 30, 40, 50])
  4 b = np.arange(4)
  5 # For (matrix - matrix) will operate for each corresponding elements
  6 # Different shape can not be subtracted unless only one element
  7 c = a - b
  8 print(c)    # [20 29 38 47]
  9 # For (matrix (-/'**'/'<') number) will operate for each elements 
 10 c -= 1
 11 print(c)    # [19 28 37 46]
 12 b = b**2 # (b*b)
 13 print(b) # [0, 1, 4, 9]
 14 print(a<35) # [True, True, False, False]
 15 
 16 # * will multiply each element in corresponding position
 17 # dot will act the dot multiply for matrix(by using matrix_1.dot(matrix_2) or np.dot(matrix_1, matrix_2))
 18 x = np.array([[1, 1],
 19               [0, 1]])
 20 y = np.array([[2, 0],
 21               [3, 4]])
 22 print(x*y)  '''[[2 0]
 23                 [0 4]] '''
 24 print('-------')
 25 print(x.dot(y))     '''[[5 4]
 26                         [3 4]] '''
 27 
 28 print('-------')
 29 print(np.dot(x, y)) '''[[5 4]
 30                         [3 4]]'''
 31 
 32 # exp function to cal e^x for x in matrix
 33 # sqrt function to cal sqrt(x) for x in matrix
 34 m = np.arange(3)
 35 print(m)    # [0 1 2]
 36 print(np.exp(m))    # [ 1.          2.71828183  7.3890561 ]
 37 print(np.sqrt(m))   # [ 0.          1.          1.41421356]
 38 
 39 # floor/ceil function to round(down/up) number of each matrix
 40 x = 10*np.random.random((3, 4))
 41 print(x)    '''[[ 6.69732597  1.18238851  4.10109987  6.40797969]
 42                 [ 6.50193132  2.58724942  5.25748965  2.58338795]
 43                 [ 0.2798712   7.89760089  6.03544519  1.5176369 ]] '''
 44 print('-------')
 45 y = np.floor(x)
 46 print(y)     '''[[ 6.  1.  4.  6.]
 47                  [ 6.  2.  5.  2.]
 48                  [ 0.  7.  6.  1.]] '''
 49 print('-------')
 50 z = np.ceil(x)
 51 print(z)    ''' [[ 7.  2.  5.  7.]
 52                  [ 7.  3.  6.  3.]
 53                  [ 1.  8.  7.  2.]] '''
 54 
 55 # ravel function can flatten a matrix into vector
 56 print(y.ravel())    # [ 6.  1.  4.  6.  6.  2.  5.  2.  0.  7.  6.  1.]
 57 # Shape value can change shape too
 58 y.shape = (6, 2)
 59 print(y)    ''' [[ 6.  1.]
 60                  [ 4.  6.]
 61                  [ 6.  2.]
 62                  [ 5.  2.]
 63                  [ 0.  7.]
 64                  [ 6.  1.]] '''
 65 print('-------')
 66 # T property function
 67 print(y.T)  ''' [[ 6.  4.  6.  5.  0.  6.]
 68                  [ 1.  6.  2.  2.  7.  1.]] '''
 69 print('-------')
 70 # If a dimension is given as -1, this dimension will be calculated automatically
 71 print(y.reshape(6, -1)) ''' [[ 6.  1.]
 72                              [ 4.  6.]
 73                              [ 6.  2.]
 74                              [ 5.  2.]
 75                              [ 0.  7.]
 76                              [ 6.  1.]] '''
 77 
 78 # hstack/vstack function can stack the matrix in h/v direction
 79 a = np.arange(6).reshape(2, 3)
 80 b = np.arange(6).reshape(2, 3)
 81 print(np.hstack((a, b))) '''[[0 1 2 0 1 2]
 82                              [3 4 5 3 4 5]] '''
 83 print(np.vstack((a, b))) '''[[0 1 2]
 84                              [3 4 5]
 85                              [0 1 2]
 86                              [3 4 5]] '''
 87 
 88 # hsplit/vsplit function can split the matrix in h/v direction
 89 x = np.arange(30).reshape(2, -1)
 90 print(x)    ''' [[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
 91                  [15 16 17 18 19 20 21 22 23 24 25 26 27 28 29]] '''
 92 # Split into 3 part (h direction, from one (2, 15) matrix to three (2, 5) matrixes)
 93 print(np.hsplit(x, 3))  '''[array([[ 0,  1,  2,  3,  4],
 94                                    [15, 16, 17, 18, 19]]),
 95                             array([[ 5,  6,  7,  8,  9],
 96                                    [20, 21, 22, 23, 24]]),
 97                             array([[10, 11, 12, 13, 14],
 98                                    [25, 26, 27, 28, 29]])] '''
 99 # Split in certain loction (split the matrix in location(after) column 3 and column 4)
100 print(np.hsplit(x, (3, 4))) '''[array([[ 0,  1,  2],
101                                        [15, 16, 17]]),
102                                 array([[ 3],
103                                        [18]]),
104                                 array([[ 4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14],
105                                        [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]])] '''
106 # Split into 3 part (v direction, from one (2, 15) matrix to two (1, 15) matrixes)
107 print(np.vsplit(x, 2))  ''' [array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14]]),
108                              array([[15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]])] '''
109 
110 # Fetch the max value position by row/column
111 data = np.random.random((5, 4))
112 print(data) ''' [[ 0.65419205  0.75953852  0.89856871  0.96162281]
113                  [ 0.76341568  0.10488636  0.06186101  0.27698986]
114                  [ 0.73737843  0.75305691  0.28705743  0.45542513]
115                  [ 0.5534984   0.54420756  0.86250921  0.596653  ]
116                  [ 0.24295898  0.28894731  0.58726507  0.39418991]] '''
117 # argmax/argmin function can get the max/min value index by row/column
118 index = data.argmax(axis=0)
119 print(index)    # [1 0 0 0]
120 # Get the max value by position
121 # data.shape[1] to get the number of column
122 print(data[index, range(data.shape[1])])    # [ 0.76341568  0.75953852  0.89856871  0.96162281]
123 
124 # Extend the matrix(like tile does)
125 x = np.arange(0, 40, 10)
126 print(x)    # [ 0 10 20 30]
127 # tile(x, (a, b)) can change origin shape(c, d) --> (a*c, b*d)
128 y = np.tile(x, (3, 5))
129 print(y)    ''' [[ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]
130                  [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]
131                  [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]] '''
132 print(y.shape) # (3, 20)
133 
134 # Sort the array
135 x = np.array([[4, 3, 5], [1, 2, 1]])
136 print(x)    '''[[4 3 5]
137                 [1 2 1]] '''
138 print('--------')
139 # Sort the number by row/column
140 y = np.sort(x, axis=1)
141 print(y)    '''[[3 4 5]
142                 [1 1 2]] '''
143 print('--------')
144 x.sort(axis=1)
145 print(x)    '''[[3 4 5]
146                 [1 1 2]] '''
147 print('--------')
148 # argsort can return the sorted index list
149 x = np.array([4, 3, 1, 2])
150 y = np.argsort(x)
151 print(y) # [2, 3, 1, 0] min is 1, index=2, then num 2, index is 3, num 3,index is 1, max is 4, index=0
152 # Use the sorted index list to fetch value
153 print('--------')
154 print(x[y]) # [1, 2, 3, 4]

View Code

支行解释

多个同维度矩阵的加减乘除、大小相比较、开药方、次幂、取整等操作,都将各自效用在各个要素上,点乘总结能够因而numpy.dot函数举行总计

 1 import numpy as np
 2 
 3 a = np.array([20, 30, 40, 50])
 4 b = np.arange(4)
 5 # For (matrix - matrix) will operate for each corresponding elements
 6 # Different shape can not be subtracted unless only one element
 7 c = a - b
 8 print(c)    # [20 29 38 47]
 9 # For (matrix (-/'**'/'<') number) will operate for each elements 
10 c -= 1
11 print(c)    # [19 28 37 46]
12 b = b**2 # (b*b)
13 print(b) # [0, 1, 4, 9]
14 print(a<35) # [True, True, False, False]
15 
16 # * will multiply each element in corresponding position
17 # dot will act the dot multiply for matrix(by using matrix_1.dot(matrix_2) or np.dot(matrix_1, matrix_2))
18 x = np.array([[1, 1],
19               [0, 1]])
20 y = np.array([[2, 0],
21               [3, 4]])
22 print(x*y)  '''[[2 0]
23                 [0 4]] '''
24 print('-------')
25 print(x.dot(y))     '''[[5 4]
26                         [3 4]] '''
27 
28 print('-------')
29 print(np.dot(x, y)) '''[[5 4]
30                         [3 4]]'''
31 
32 # exp function to cal e^x for x in matrix
33 # sqrt function to cal sqrt(x) for x in matrix
34 m = np.arange(3)
35 print(m)    # [0 1 2]
36 print(np.exp(m))    # [ 1.          2.71828183  7.3890561 ]
37 print(np.sqrt(m))   # [ 0.          1.          1.41421356]

random模块能够变动随机成分的矩阵

 1 # floor/ceil function to round(down/up) number of each matrix
 2 x = 10*np.random.random((3, 4))
 3 print(x)    '''[[ 6.69732597  1.18238851  4.10109987  6.40797969]
 4                 [ 6.50193132  2.58724942  5.25748965  2.58338795]
 5                 [ 0.2798712   7.89760089  6.03544519  1.5176369 ]] '''
 6 print('-------')
 7 y = np.floor(x)
 8 print(y)     '''[[ 6.  1.  4.  6.]
 9                  [ 6.  2.  5.  2.]
10                  [ 0.  7.  6.  1.]] '''
11 print('-------')
12 z = np.ceil(x)
13 print(z)    ''' [[ 7.  2.  5.  7.]
14                  [ 7.  3.  6.  3.]
15                  [ 1.  8.  7.  2.]] '''

ravel函数能够将矩阵展开成一维,T属性方法能够获得转置矩阵

 1 # ravel function can flatten a matrix into vector
 2 print(y.ravel())    # [ 6.  1.  4.  6.  6.  2.  5.  2.  0.  7.  6.  1.]
 3 # Shape value can change shape too
 4 y.shape = (6, 2)
 5 print(y)    ''' [[ 6.  1.]
 6                  [ 4.  6.]
 7                  [ 6.  2.]
 8                  [ 5.  2.]
 9                  [ 0.  7.]
10                  [ 6.  1.]] '''
11 print('-------')
12 # T property function
13 print(y.T)  ''' [[ 6.  4.  6.  5.  0.  6.]
14                  [ 1.  6.  2.  2.  7.  1.]] '''
15 print('-------')

reshape函数若里面多少个参数为-1则该维度由别的维度总计获得

1 # If a dimension is given as -1, this dimension will be calculated automatically
2 print(y.reshape(6, -1)) ''' [[ 6.  1.]
3                              [ 4.  6.]
4                              [ 6.  2.]
5                              [ 5.  2.]
6                              [ 0.  7.]
7                              [ 6.  1.]] '''

random模块能够转移随机成分的矩阵。

1 # hstack/vstack function can stack the matrix in h/v direction
2 a = np.arange(6).reshape(2, 3)
3 b = np.arange(6).reshape(2, 3)
4 print(np.hstack((a, b))) '''[[0 1 2 0 1 2]
5                              [3 4 5 3 4 5]] '''
6 print(np.vstack((a, b))) '''[[0 1 2]
7                              [3 4 5]
8                              [0 1 2]
9                              [3 4 5]] '''

聚成堆以及切割操作

 1 # hsplit/vsplit function can split the matrix in h/v direction
 2 x = np.arange(30).reshape(2, -1)
 3 print(x)    ''' [[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
 4                  [15 16 17 18 19 20 21 22 23 24 25 26 27 28 29]] '''
 5 # Split into 3 part (h direction, from one (2, 15) matrix to three (2, 5) matrixes)
 6 print(np.hsplit(x, 3))  '''[array([[ 0,  1,  2,  3,  4],
 7                                    [15, 16, 17, 18, 19]]),
 8                             array([[ 5,  6,  7,  8,  9],
 9                                    [20, 21, 22, 23, 24]]),
10                             array([[10, 11, 12, 13, 14],
11                                    [25, 26, 27, 28, 29]])] '''
12 # Split in certain loction (split the matrix in location(after) column 3 and column 4)
13 print(np.hsplit(x, (3, 4))) '''[array([[ 0,  1,  2],
14                                        [15, 16, 17]]),
15                                 array([[ 3],
16                                        [18]]),
17                                 array([[ 4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14],
18                                        [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]])] '''
19 # Split into 3 part (v direction, from one (2, 15) matrix to two (1, 15) matrixes)
20 print(np.vsplit(x, 2))  ''' [array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14]]),
21                              array([[15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]])] '''

获得最大值索引

 1 # Fetch the max value position by row/column
 2 data = np.random.random((5, 4))
 3 print(data) ''' [[ 0.65419205  0.75953852  0.89856871  0.96162281]
 4                  [ 0.76341568  0.10488636  0.06186101  0.27698986]
 5                  [ 0.73737843  0.75305691  0.28705743  0.45542513]
 6                  [ 0.5534984   0.54420756  0.86250921  0.596653  ]
 7                  [ 0.24295898  0.28894731  0.58726507  0.39418991]] '''
 8 # argmax/argmin function can get the max/min value index by row/column
 9 index = data.argmax(axis=0)
10 print(index)    # [1 0 0 0]
11 # Get the max value by position
12 # data.shape[1] to get the number of column
13 print(data[index, range(data.shape[1])])    # [ 0.76341568  0.75953852  0.89856871  0.96162281]

将矩阵打开铺展操作

1 # Extend the matrix(like tile does)
2 x = np.arange(0, 40, 10)
3 print(x)    # [ 0 10 20 30]
4 # tile(x, (a, b)) can change origin shape(c, d) --> (a*c, b*d)
5 y = np.tile(x, (3, 5))
6 print(y)    ''' [[ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]
7                  [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]
8                  [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]] '''
9 print(y.shape) # (3, 20)

矩阵的排序及排序索引

 1 # Sort the array
 2 x = np.array([[4, 3, 5], [1, 2, 1]])
 3 print(x)    '''[[4 3 5]
 4                 [1 2 1]] '''
 5 print('--------')
 6 # Sort the number by row/column
 7 y = np.sort(x, axis=1)
 8 print(y)    '''[[3 4 5]
 9                 [1 1 2]] '''
10 print('--------')
11 x.sort(axis=1)
12 print(x)    '''[[3 4 5]
13                 [1 1 2]] '''
14 print('--------')
15 # argsort can return the sorted index list
16 x = np.array([4, 3, 1, 2])
17 y = np.argsort(x)
18 print(y) # [2, 3, 1, 0] min is 1, index=2, then num 2, index is 3, num 3,index is 1, max is 4, index=0
19 # Use the sorted index list to fetch value
20 print('--------')
21 print(x[y]) # [1, 2, 3, 4]

 

6 numpy常用函数

完整代码

澳门新萄京官方网站 17澳门新萄京官方网站 18

 1 import numpy as np
 2 
 3 # Build a matrix, shape is (2, 4, 2)
 4 matrix = np.array([[[1,2], [2,3], [3,4], [4,5]], 
 5                     [[1,2], [2,3], [3,4], [4,5]]])
 6 
 7 # arange function to quickly create an array(vector)
 8 # Note: the shape is (x, ), one dimension array
 9 vector = np.arange(15)
10 print(vector)   # [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
11 # reshape function to reshape an array
12 matrix = vector.reshape(3, 5)
13 print(matrix)   ''' [[ 0  1  2  3  4]
14                      [ 5  6  7  8  9]
15                      [10 11 12 13 14]] '''
16 # shape is the row&column of matrix(array) - (3, 5)
17 # ndim is the number of dimensions(axes) of matrix - 2
18 # dtype is a numpy class, dtype.name is the type name of matrix - int32
19 # size is the total number of elements of matrix - 15
20 print(matrix.shape, matrix.ndim, matrix.dtype.name, matrix.size) # (3, 5) 2 int32 15
21 # arrange(from, to, step)
22 vector = np.arange(10, 30, 5)
23 print(vector)   # [10 15 20 25]
24 vector = np.arange(1, 3, 0.5)
25 print(vector)   # [ 1.   1.5  2.   2.5]
26 
27 # Init a matrix with all elements 0, default type is float64
28 matrix = np.zeros((3, 4), dtype=np.float64)
29 print(matrix)   ''' [[ 0.  0.  0.  0.]
30                      [ 0.  0.  0.  0.]
31                      [ 0.  0.  0.  0.]] '''
32 # Init a matrix with all elements 1
33 matrix = np.ones((2, 3, 4), dtype=np.int32)
34 print(matrix)   ''' [[[1 1 1 1]
35                       [1 1 1 1]
36                       [1 1 1 1]]
37                       
38                      [[1 1 1 1]
39                       [1 1 1 1]
40                       [1 1 1 1]]]'''
41 
42 # random function will return a matrix with random number(between 0 to 1)
43 # random((row, column))
44 rd = np.random.random((2, 3))
45 print(rd)   ''' [[ 0.45595053  0.69816822  0.30391984]
46                  [ 0.22757757  0.725762    0.84856338]] '''
47 
48 # Get the matrix with some same step numbers,
49 # 得到相应数量的等差数列
50 # linspace(from, to, number)
51 # Notice whether the num should be plus one
52 matrix = np.linspace(0, 2, 11)
53 print(matrix)   # [ 0.   0.2  0.4  0.6  0.8  1.   1.2  1.4  1.6  1.8  2. ]
54 
55 # sin/cos function can calculate the sin/cos of each elements
56 from numpy import pi
57 matrix = np.linspace(0, 2*pi, 9)
58 print(matrix)   # [ 0.          0.78539816  1.57079633  2.35619449  3.14159265  3.92699082  4.71238898  5.49778714  6.28318531]
59 matrix = np.sin(matrix)
60 print(matrix)   # [  0.00000000e 00   7.07106781e-01   1.00000000e 00   7.07106781e-01   1.22464680e-16  -7.07106781e-01  -1.00000000e 00  -7.07106781e-01  -2.44929360e-16]

View Code

分层解释

确立二个矩阵,能够因而array或arange函数生成,对于一位矩阵,其shape值为(x, )

 

 1 import numpy as np
 2 
 3 # Build a matrix, shape is (2, 4, 2)
 4 matrix = np.array([[[1,2], [2,3], [3,4], [4,5]], 
 5                     [[1,2], [2,3], [3,4], [4,5]]])
 6 
 7 # arange function to quickly create an array(vector)
 8 # Note: the shape is (x, ), one dimension array
 9 vector = np.arange(15)
10 print(vector)   # [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
11 # reshape function to reshape an array
12 matrix = vector.reshape(3, 5)
13 print(matrix)   ''' [[ 0  1  2  3  4]
14                      [ 5  6  7  8  9]
15                      [10 11 12 13 14]] '''
16 # shape is the row&column of matrix(array) - (3, 5)
17 # ndim is the number of dimensions(axes) of matrix - 2
18 # dtype is a numpy class, dtype.name is the type name of matrix - int32
19 # size is the total number of elements of matrix - 15
20 print(matrix.shape, matrix.ndim, matrix.dtype.name, matrix.size) # (3, 5) 2 int32 15
21 # arrange(from, to, step)
22 vector = np.arange(10, 30, 5)
23 print(vector)   # [10 15 20 25]
24 vector = np.arange(1, 3, 0.5)
25 print(vector)   # [ 1.   1.5  2.   2.5]

浮动多少个全零/一矩阵

 1 # Init a matrix with all elements 0, default type is float64
 2 matrix = np.zeros((3, 4), dtype=np.float64)
 3 print(matrix)   ''' [[ 0.  0.  0.  0.]
 4                      [ 0.  0.  0.  0.]
 5                      [ 0.  0.  0.  0.]] '''
 6 # Init a matrix with all elements 1
 7 matrix = np.ones((2, 3, 4), dtype=np.int32)
 8 print(matrix)   ''' [[[1 1 1 1]
 9                       [1 1 1 1]
10                       [1 1 1 1]]
11                       
12                      [[1 1 1 1]
13                       [1 1 1 1]
14                       [1 1 1 1]]]'''

随意矩阵及等差矩阵等

 1 # random function will return a matrix with random number(between 0 to 1)
 2 # random((row, column))
 3 rd = np.random.random((2, 3))
 4 print(rd)   ''' [[ 0.45595053  0.69816822  0.30391984]
 5                  [ 0.22757757  0.725762    0.84856338]] '''
 6 
 7 # Get the matrix with some same step numbers,
 8 # 得到相应数量的等差数列
 9 # linspace(from, to, number)
10 # Notice whether the num should be plus one
11 matrix = np.linspace(0, 2, 11)
12 print(matrix)   # [ 0.   0.2  0.4  0.6  0.8  1.   1.2  1.4  1.6  1.8  2. ]
13 
14 # sin/cos function can calculate the sin/cos of each elements
15 from numpy import pi
16 matrix = np.linspace(0, 2*pi, 9)
17 print(matrix)   # [ 0.          0.78539816  1.57079633  2.35619449  3.14159265  3.92699082  4.71238898  5.49778714  6.28318531]
18 matrix = np.sin(matrix)
19 print(matrix)   # [  0.00000000e 00   7.07106781e-01   1.00000000e 00   7.07106781e-01   1.22464680e-16  -7.07106781e-01  -1.00000000e 00  -7.07106781e-01  -2.44929360e-16]

 

参照链接


本文由澳门新萄京官方网站发布于www.8455.com,转载请注明出处:澳门新萄京官方网站:左邻右舍算法,机器学习

关键词: