精华内容
下载资源
问答
  • numpy 机器学习
    2022-07-17 18:04:34

    今天登录CSDN后发现我好像很长一段时间没更新了,正好放假在家闲着没啥事,分享一下最近看网课时做的笔记吧。以后有时间的话就多写些文章。

    import numpy# numpy是用于矩阵处理的一个python库
    # delimiter分隔符,dtype读取数据时默认的读取方式
    # 所有的numpy都是ndarray结构
    # help(numpy.action())可以打印帮助说明
    print(help(numpy.genfromtxt))

    会打印出关于genfromtxt()方法的所有参数取值 并且在最后会给出一个运行实例,感兴趣的小伙伴可以尝试一下运行看看

    import numpy
    
    vector = numpy.array([1, 2, 32, '20'])
    # array方法是核心,接收一个列表(只能是一个)用于生成行向量,列表中元素必须是相同的结构
    martrix = numpy.array([[2, 4, 6],
                           [1, 3, 5],
                           [7, 8, 9]])
    print(vector)
    print(martrix)
    print(martrix.shape)
    # 可以很清晰地看到所创造矩阵的行与列
    # vector.dtype可以看到数据的类型
    print(martrix[1, 2])
    # 矩阵中的元素通过索引进行读取,索引是从0开始的,用:可以表示某一列或某一行
    print(martrix[:, 0])
    print(martrix[1, :])

    运行结果:['1' '2' '32' '20']
                    [[2 4 6]
                     [1 3 5]
                     [7 8 9]]
                    (3, 3)
                    5
                    [2 1 7]
                    [1 3 5]

    import numpy
    
    vector = numpy.array([1, 2, 32, 20])
    martrix = numpy.array([[2, 4, 6],
                           [1, 3, 5],
                           [7, 8, 9]])
    vector == 2
    martrix == 3
    # 直接用等号进行判断,可以返回一系列bool值
    eqaul_to_two_and_three = (martrix == 2) | (martrix == 3)
    print(eqaul_to_two_and_three)
    # 等号判断之后的bool矩阵可以进行与或非逻辑运算
    martrix=martrix.astype(float)
    print(martrix.dtype)
    # astype 方法可以将矩阵的元素类型进行转换
    print(martrix.min())
    # min,max()方法可以求出最大和最小值
    print(martrix.sum(axis=1))
    # axis等于1代表对每一行求和
    print(martrix.sum(axis=0))
    # axis等于0代表对每一列求和

    运行结果:[[ True False False]
                     [False  True False]
                     [False False False]]
                    float64
                    1.0
                    [12.  9. 24.]
                    [10. 15. 20.]

    import numpy as np
    from numpy import pi
    print(np.arange(15))
    print(np.arange(15).reshap(3,5))
    # arange表示构建从0到14的自然数,reshape表示构造3×5的矩阵
    # shape打印行和列,ndim打印矩阵维度,size打印矩阵元素个数
    np.zeros((3,4),dtype=int)
    # 初始化一个零矩阵,传进的是元组格式,并且可以指定dtype
    np.random.random((3,4))
    # 表示调用random库中的random函数
    print(np.linspace(0,2*pi,100))
    # linspace()方法表示生成两个端点间间隔相同的n个数

    运行结果:

    [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
    [[ 0  1  2  3  4]
     [ 5  6  7  8  9]
     [10 11 12 13 14]]
    [0.         0.06346652 0.12693304 0.19039955 0.25386607 0.31733259
     0.38079911 0.44426563 0.50773215 0.57119866 0.63466518 0.6981317
     0.76159822 0.82506474 0.88853126 0.95199777 1.01546429 1.07893081
     1.14239733 1.20586385 1.26933037 1.33279688 1.3962634  1.45972992
     1.52319644 1.58666296 1.65012947 1.71359599 1.77706251 1.84052903
     1.90399555 1.96746207 2.03092858 2.0943951  2.15786162 2.22132814
     2.28479466 2.34826118 2.41172769 2.47519421 2.53866073 2.60212725
     2.66559377 2.72906028 2.7925268  2.85599332 2.91945984 2.98292636
     3.04639288 3.10985939 3.17332591 3.23679243 3.30025895 3.36372547
     3.42719199 3.4906585  3.55412502 3.61759154 3.68105806 3.74452458
     3.8079911  3.87145761 3.93492413 3.99839065 4.06185717 4.12532369
     4.1887902  4.25225672 4.31572324 4.37918976 4.44265628 4.5061228
     4.56958931 4.63305583 4.69652235 4.75998887 4.82345539 4.88692191
     4.95038842 5.01385494 5.07732146 5.14078798 5.2042545  5.26772102
     5.33118753 5.39465405 5.45812057 5.52158709 5.58505361 5.64852012
     5.71198664 5.77545316 5.83891968 5.9023862  5.96585272 6.02931923
     6.09278575 6.15625227 6.21971879 6.28318531]

    a=numpy.array([[1,2],
                  [2,0]])
    b=numpy.array([[2,3]
                  ,[0,2]])
    print(a*b)
    # *表示矩阵对应位置相乘
    print(a.dot(b))
    print(np.dot(a,b))
    # .dot表示实际的矩阵相乘
    c=a.ravel()
    c.shape=(4,1)
    print(c)
    # ravel表示把矩阵铺平,然后可以指定矩阵结构
    print(np.hstack((a,b)))
    # hstack表示矩阵的按行拼接,vstack表示矩阵的按列拼接
    # hsplit按照行进行切分,vsplit按照列进行切分

    运行结果:

    [[2 6]
     [0 0]]
    [[2 7]
     [4 6]]
    [[2 7]
     [4 6]]
    [[1]
     [2]
     [2]
     [0]]
    [[1 2 2 3]
     [2 0 0 2]]

    # 复制操作
    c=a
    c=a.view()
    c=a.copy()#建议用这个
    import numpy
    data=numpy.sin(numpy.arange(20).reshape(5,4))
    print(data)
    ind=data.argmax(axis=0)#找到每一列最大的索引值
    print(ind)
    data_max=data[ind,range(data.shape[1])]#根据索引找到最大值
    print(data_max)

    运行结果:

    [[ 0.          0.84147098  0.90929743  0.14112001]
     [-0.7568025  -0.95892427 -0.2794155   0.6569866 ]
     [ 0.98935825  0.41211849 -0.54402111 -0.99999021]
     [-0.53657292  0.42016704  0.99060736  0.65028784]
     [-0.28790332 -0.96139749 -0.75098725  0.14987721]]
    [2 0 3 1]
    [0.98935825 0.84147098 0.99060736 0.6569866 ]

    a=np.array(range(0,40,10))
    print(a)
    b=np.tile(a,(2,3))#将一个矩阵进行拓展
    print(b)
    c=np.argsort(a)#获取从小到大的索引,传入索引实现对矩阵排序
    print(a[c])
    

    运行结果:
    [ 0 10 20 30]
    [[ 0 10 20 30  0 10 20 30  0 10 20 30]
     [ 0 10 20 30  0 10 20 30  0 10 20 30]]
    [ 0 10 20 30]

    所有代码均在pycharm2022版本上运行通过,如有代码异常请评论区留言

    更多相关内容
  • Numpy机器学习基础库

    2019-03-31 08:59:51
    该文档着重介绍了Numpy库的使用,Numpy库是机器学习最常用最有用的库,熟练掌握Numpy库的使用是机器学习的基础。
  • A tiny lib with pocket-sized implementations of machine learning models in NumPy.
  • NumPy 实现所有机器学习模型
  • 机器学习 此仓库用于收集我在机器学习模型上的Python实现和笔记本。
  • 机器学习---初识python的numpy模块

    千次阅读 多人点赞 2022-05-18 13:54:14
    初识python的numpy库,更早走进机器学习的大门

     🔝🔝🔝🔝🔝🔝🔝🔝🔝🔝🔝🔝

    🥰 博客首页:knighthood2001

    😗 欢迎点赞👍评论🗨️

    ❤️ 热爱python,期待与大家一同进步成长!!❤️

            Numpy是Numerical Python extensions的缩写,字面意思是Python数值计算扩展。Numpy是python中众多机器学习库的依赖,这些库通过Numpy实现基本的矩阵计算。

            Numpy支持高阶、大量计算的矩阵、向量计算,与此同时还提供了较为丰富的函数。此外,Numpy基于更加现代化的编程语言--python,python凭借着开源、免费、灵活性、简单易学、工程特性好等特点风靡技术圈,已经成为机器学习、数据分析等领域的主流编程语言。

            本文主要带大家粗略的学习python的numpy模块!!

    目录

    一、array类型

    1.1array类型的基本使用

    1.2对更高维度数据的处理

    1.3Numpy创建特殊类型的array类型

    1.3.1生成全为0或全为1的array

    1.3.2np.arrange()和np.linspace()

    1.4Numpy基础计算演示

    二、线性代数相关 

    三、矩阵的高级函数-随机数矩阵

    四、总结


    一、array类型

            numpy的array类型是该库的一个基本数据类型,这个数据类型从字面上看是数组的意思,也就意味着它最关键的属性是元素与维度,我们可以用这个数据类型来实现多维数组。

            因此,通过这个数据类型,我们可以使用一维数组来表示向量,二维数组表示矩阵,并以此类推以用来表示更高维度的张量。

    1.1array类型的基本使用

    import numpy as np
    # 通过np.array()方法创建一个名为array的array类型,参数是一个list
    array = np.array([1, 2, 3, 4])
    print(array)
    # 结果为:[1 2 3 4]
    
    # 获取array中元素的最大值
    print(array.max())
    # 结果为:4
    
    # 获取array中元素的最小值
    print(array.min())
    # 结果为:1
    
    # 获取array中元素的平均值
    print(array.mean())
    # 结果为:2.5
    
    # 直接将array乘以2,python将每个元素都乘以2
    print(array*2)
    # 结果为:[2 4 6 8]
    
    print(array+1)
    # 结果为:[2 3 4 5]
    
    print(array/2)
    # 结果为:[0.5 1.  1.5 2. ]
    
    # 将每一个元素都除以2,得到浮点数表示的结果
    print(array % 2)
    # 结果为:[1 0 1 0]
    
    array_1 = np.array([1, 0, 2, 0])
    # 获取该组数据中元素值最大的那个数据的首个索引,下标从0开始
    print(array_1.argmax())
    # 结果为:2

    通过上面的代码,我们可以了解到Numpy中array类型的基本使用方法。

    我们可以看到,array其实是一个类,通过传入一个list参数来实例化为一个对象,从而实现了对数据的封装。


    1.2对更高维度数据的处理

    import numpy as np
    # 创建一个二维数组,用以表示一个3行2列的矩阵
    array = np.array([[1, 2], [3, 4], [5, 6]])
    print(array)
    
    # 查看数据的维度属性,下面输出结果(3,2)表示3行2列
    print(array.shape)
    # 结果为:(3, 2)
    
    # 查看元素个数
    print(array.size)
    # 结果为:6
    
    # 查看元素最大值的索引
    print(array.argmax())
    # 结果为:5
    
    # 将shape为(3,2)的array转换为一行表示
    print(array.flatten())
    # 结果为:[1 2 3 4 5 6]
    # 我们可以看到,flatten()方法是将多维数据“压平”为一维数组的过程
    
    #将array数据从shape为(3,2)的形式转为(2,3)的形式
    print(array.reshape(2, 3))
    '''结果为:
    [[1 2 3]
     [4 5 6]]'''
    
    #将array数据从shape为(3,2)的形式转为(1,6)的形式
    print(array.reshape(1, 6))
    # 结果为:[[1 2 3 4 5 6]]
    

    高级一点的就是flatten()和reshape()函数了,需要注意下reshape()返回的结果是array类型


    1.3Numpy创建特殊类型的array类型

    1.3.1生成全为0或全为1的array

    import numpy as np
    # 生成所有元素为
    array_zeros = np.zeros((2, 3, 3))
    print(array_zeros)
    '''结果为:
    [[[0. 0. 0.]
      [0. 0. 0.]
      [0. 0. 0.]]
    
     [[0. 0. 0.]
      [0. 0. 0.]
      [0. 0. 0.]]]
    '''
    array_ones = np.ones((2, 3, 3))
    print(array_ones)
    '''结果为:
    [[[1. 1. 1.]
      [1. 1. 1.]
      [1. 1. 1.]]
    
     [[1. 1. 1.]
      [1. 1. 1.]
      [1. 1. 1.]]]
    '''
    print(array_ones.shape)
    # 结果为:(2, 3, 3)

    注意:如果将(2,3,3)改为(3,3)

    array_zeros = np.zeros((3, 3))
    print(array_zeros)
    '''结果为:
    [[0. 0. 0.]
     [0. 0. 0.]
     [0. 0. 0.]]
    '''

    其生成的是3行3列的array 


    1.3.2np.arrange()和np.linspace()

    arange([start,] stop[, step,], dtype=None, , like=None)

    返回给定间隔内均匀分布的值。值在半开区间``[start, stop)``(换句话说,包括`start`但不包括`stop`的区间)内生成。对于整数参数,该函数等效于 Python 内置的 `range` 函数,但返回的是 ndarray 而不是列表。当使用非整数步长(例如 0.1)时,结果通常会不一致。对于这些情况,最好使用 `numpy.linspace`。

    linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

    在指定的时间间隔内返回均匀分布的数字。返回“num”个均匀分布的样本,在区间 [`start`, `stop`] 上计算。 

    start:序列的起始值。

    stop:序列的结束值,除非 `endpoint` 设置为 False。在这种情况下,序列由除最后一个“num + 1”个均匀分布的样本之外的所有样本组成,因此排除了“stop”。请注意,当 `endpoint` 为 False 时,步长会发生变化。

    num=50:要生成的样本数。默认值为 50。必须为非负数。

    endpoint=True:如果为真,`stop` 是最后一个样本。否则,不包括在内。默认为真。

    retstep=False:如果为 True,则返回 (`samples`, `step`),其中 `step` 是样本之间的间距。

    dtype=None:输出数组的类型。如果 `dtype` 没有给出,数据类型是从 `start` 和 `stop` 推断出来的。推断的 dtype 永远不会是整数;即使参数会产生一个整数数组,也会选择`float`。

    因此以下代码就很容易理解了

    # 生成一个array,从0递增到10,步长为1
    array_arange = np.arange(10)
    print(array_arange)
    # 结果为:[0 1 2 3 4 5 6 7 8 9]
    
    # 生成一个array,从0递增到10,步长为2
    array_arange_1 = np.arange(0, 10, 2)
    print(array_arange_1)
    # 结果为:[0 2 4 6 8]
    
    # 生成一个array,将0-10等分为5部分
    array_linspace = np.linspace(0, 10, 5)
    print(array_linspace)
    # 结果为:[ 0.   2.5  5.   7.5 10. ]
    

    1.4Numpy基础计算演示

    import numpy as np
    # 取绝对值
    print(np.abs([1, -2, 3, -4]))
    # [1 2 3 4]
    
    # 求正弦值
    print(np.sin(np.pi/2))
    # 1.0
    
    # 求反正切值
    print(np.arctan(1))
    # 0.7853981633974483
    
    # 求e的2次方
    print(np.exp(2))
    # 7.38905609893065
    
    # 求2的三次方
    print(np.power(2, 3))
    # 8
    
    # 求向量[1,2]与[3,4]的点积
    print(np.dot([1, 2], [3, 4]))
    # 11
    
    # 求开方
    print(np.sqrt(4))
    # 2.0
    
    # 求和
    print(np.sum([1, 2, 3, 4]))
    # 10
    
    # 求平均值
    print(np.mean([1, 2, 3, 4]))
    #2.5 
    
    # 求标准差
    print(np.std([1, 2, 3, 4]))
    # 1.118033988749895

    二、线性代数相关 

            前面我们已经了解到array类型及其基本操作方法,了解array类型可以表示向量、矩阵和多维张量。

            线性代数计算在科学计算领域中非常重要,因此接下来了解以下Numpy提供的线性代数操作

    import numpy as np
    
    vector_a = np.array([1, 2, 3])
    vector_b = np.array([2, 3, 4])
    # 定义两入向量vector_a与vector_b
    
    m = np.dot(vector_a, vector_b)
    # 将两个向量相乘,在这里也就是点乘,结果为20
    print(m)
    
    n = vector_a.dot(vector_b)
    print(n)
    # 将vector_a与vector_b相乘,结果为20
    o = np.dot(vector_a, vector_b.T)
    print(o)
    
    '''
    将一个行向量与一个列向量叉乘的结果相当于将两个行向量求点积,这里测试了dot()方法。其中array类型的T()方法表示转置。
    测试结果表明:
    dot()方法默认对两个向量求点积。对于符合叉乘格式的矩阵,自动进行又乘。'''
    
    # 我们看一下下面这个例子:
    
    matrix_a = np.array([[1, 2], [3, 4]])
    # 定义一个2行2列的方阵
    
    matrix_b = np.dot (matrix_a, matrix_a.T)
    # 这里将该方阵与其转置叉乘,将结果赋予matrix_b变量
    print(matrix_b)
    '''结果为:
    array([[5,11],
    [11,25]])'''
    
    p = np.linalg.norm([1, 2])
    print(p)
    # 求一个向量的范数的值,结果为2.2360679774997898
    # 如果norm()方法没有指定第2个参数,则默认为求2范数
    
    np.linalg.norm([1, -2], 1)
    # 指定第2个参数值为1,即求1范数。我们在前面介绍过,1范数的结果为向量中各元素绝对值之和,结果为3.0
    
    q = np.linalg.norm([1, 2, 3, 4], np. inf)
    print(q)
    # 求向量的无穷范数,其中np.inf表示正无穷,也就是向量中元素值最大的那个,其结果为4.0
    
    r = np.linalg .norm([1, 2, 3, 4], -np.inf)
    print(r)
    # 同理,求负无穷范数的结果为1, 也就是向量中元素的最小值
    
    # 求行列式
    s = np.linalg.det(matrix_a)
    print(s)
    # -2.0000000000000004
    
    t = np.trace(matrix_a)
    print(t)
    # 求矩阵matrix_a的迹,结果为5
    
    u = np.linalg.matrix_rank(matrix_a)
    # 求矩阵的秩,结果为2
    print(u)
    
    v = vector_a * vector_b
    # 使用*符号将两个向量相乘,是将两个向量中的元素分别相乘,也就是我们所讲到的哈达马乘积
    print(v)
    # [ 2  6 12]
    
    w = vector_a ** vector_b
    print(w)
    # 使用二元运算符**对两个向量进行操作,结果为array([1, 8, 81],dtype = int32)
    # 表示将向量vector. a中元素对应vector. b中的元素值求幂运算。例如最终结果[1,8,81]可以表示为[1*1,2*2*2,3*3*3*3]
    
    # 求逆矩阵
    z = np.linalg.inv(matrix_a)
    print(z)
    '''
    [[-2.   1. ]
     [ 1.5 -0.5]]'''
    
    

    三、矩阵的高级函数-随机数矩阵

            Numpy除了为我们提供常规的数学计算函数和矩阵相关操作之外,还提供很多功能丰富的模块,随机数模块就是其中一部分。

            利用随机数模块可以生成随机数矩阵,比python自带的随机数模块功能还要强大。

    import numpy as np
    # 设置随机数种子
    np.random.seed()
    
    # 从[1,3)中生成一个整型的随机数,连续生成10个
    a = np.random.randint(1, 3, 10)
    print(a)
    # [1 1 1 2 1 1 1 1 2 2]
    
    # 若要连续产生[1,3}之间的浮点数,可以使用以下方法:
    # ①
    b = 2*np.random.random(10)+1
    print(b)
    '''
    [2.88458839 2.07004167 2.80814156 1.83247535 2.33649809 2.62763357
     2.0549351  2.33464915 1.70562208 2.66257726]'''
    # ②
    c = np.random.uniform(1, 3, 10)
    print(c)
    '''
    [1.76967412 1.37703868 2.48838004 1.45986254 2.04487418 2.51107658
     1.25673115 1.31416097 2.56218317 2.90575438]'''
    
    # 生成一个满足正态分布(高斯分布)的矩阵,其维度是4*4
    d = np. random.normal(size=(4, 4))
    print(d)
    '''
    [[ 0.76164366  0.11588368  0.49221559 -0.28222691]
     [ 0.47638143 -0.21197541 -1.0776362   0.49241666]
     [ 0.26038756 -0.20406522  1.11210954 -1.191425  ]
     [ 0.58255677  1.84047863 -0.21366512 -0.85425828]]'''
    
    # 随机产生10个n=5、p=0.5的二项分布数据:
    e = np.random.binomial(n=5, p=0.5, size=10)
    print(e)
    # [1 1 5 2 1 2 1 2 1 2]
    
    # 产生一个0到9的序列
    data = np.arange(10)
    print(data)
    # [0 1 2 3 4 5 6 7 8 9]
    
    # 从data数据中随机采集5个样本,采集过程是有放回的
    f = np.random.choice(data, 5)
    print(f)
    # [1 7 3 3 4]
    
    # 从data数据中随机采集5个样本,采集过程是没有放回的
    g = np.random.choice(data, 5, replace=False)
    print(g)
    # [8 9 1 5 0]
    
    # 对data进行乱序
    h = np.random.permutation(data)
    print(h)
    # [8 5 3 9 2 0 4 6 1 7]
    
    # 对data进行乱序,并替换为新的data
    np.random.shuffle(data)
    print(data)
    # [9 7 0 3 8 5 2 1 4 6]
    

    四、总结

            目前机器学习领域非常火爆,因此如果想涉及该领域,学习numpy的相关知识是必不可少的,因此笔者写了这篇numpy基础型文章,供大家学习;

            ②以上代码笔者是纯手敲的,如果觉得不错的话,希望三连支持一下!! ❤️❤️

    展开全文
  • 1、机器学习sklearn框架知识点,pandas与numpy大全 3、了解机器的核心原理和算法理论 4、应用场景:数据挖掘,预测、分类、推荐算法 5、特点:简化框架及代码思想,言简意赅 6、适用人群:想学习机器学习的初学者 7、...
  • numpy作为python机器学习里面重要的数学库,里面放着很多我们机器学习算法中需要的方法,这里挑几个来讲讲 arr1 = np.random.randint(10, 40, [5,8]) 意思是生成一个5行,8列的,大小范围在10到40的整型随机矩阵...

    numpy作为python机器学习里面重要的数学库,里面放着很多我们机器学习算法中需要的方法,这里挑几个来讲讲

    arr1 = np.random.randint(10, 40, [5,8])

    意思是生成一个5行,8列的,大小范围在10到40的整型随机矩阵

     

    numpy.zeros([3,5], dtype=int)

     第一个值可以是数组,也可以是数字,如果是是数字就是生成n个0的一维矩阵,第二个参数dtype是矩阵里面的类型,如果不加,矩阵里面的数值默认是浮点型,如果加了int,就int类型

     

    arr = numpy.ones([4,3], dtype=int)

    和zeros差不多,不过这个是生成全是1 的矩阵,数学也称之为单元矩阵,向量也是1

     

    arr = numpy.full([3,7], 999)

    如果是想自己生成一个全是同一个数的矩阵,就用full

     

    numpy.random.seed(444)
    numpy.random.randint(20, 10000, [3,5])

    上面这种写法是说,随机种子固定是444,然后生成一个随机矩阵,这种主要是用来既想生成一个随机矩阵,又想这个随机矩阵只生成一次后面全部都用同一个的情况,当然也可以将生成的随机矩阵保存到另外一个变量中。随机种子一旦固定下来,生成的随机矩阵也是不会变化的

     

    上面所说的都是生成二维矩阵

    numpy.arange(10, 20, 3)

    arange是生成一个一维矩阵,但是如果想用这个一维矩阵转化成二维的呢

    用reshape来转化,里面的[2,-1]是说,生成一个2行,列数由计算机帮我算出来的矩阵,所以这里填了-1,这里其实就相当于[2,2],不过当一维矩阵数值很大的时候,我们就只需要知道我们需要一个多少行或者多少列的数字,另外一个数就由计算机帮我们算好即可

     

    numpy中还有两个属性可以查看矩阵的信息

    ndim 查看矩阵维度,size 查看整个矩阵有多少个元素

     

    最后讲下numpy里生成一个符合正态分布的随机矩阵

    np.random.normal(4, 100, 20)

    这是一个均值为4,方差为100的正态分布的随机矩阵,均值就是这个正态分布图形的对称轴,方差就是整个图形的宽度,方差越大,说明这一组数值越不稳定,越小就越稳定

     

    最后讲讲如果获取矩阵里面的值

    有两种

    arr[1][1] 和 arr[1,1]

    都是获取第2行的第2列,但是两者效率是有区别的

    从上图可以看出,arr6[3000, 10000]明显要比arr6[3000][10000]快的,时间差不多快了一倍,为什么呢

    意思应该就是arr6[3000][10000]这种会先为第一维创建一个索引数组,创建完之后再去创建第二维的索引数组,之后再检索

    而arr6[3000, 10000]这种针对整个矩阵创建一个索引数组,然后就直接检索了

     

     

    展开全文
  • numpy和pandas案例实例,基础教学
  • Python机器学习——numpy 文章目录Python机器学习——numpy前言一、numpy是什么?二、使用步骤1.引入库2.NumPy Ndarray 对象2.NumPy 矩阵对象2.1 矩阵转置(T)2.2 矩阵求逆(I)2.3 矩阵乘法(dot)2.4 访问矩阵...

    Python机器学习——numpy



    前言

    在机器学习中,我们要面临大量的数学公式,掌握好的工具可以使我们更好的将理论用于实战。接下来我们粗略的了解什么是Numpy。

    一、numpy是什么?

    NumPy(Numerical Python)是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵,比Python自身的嵌套列表(nested list structure)结构要高效的多(该结构也可以用来表示矩阵(matrix)),支持大量的维度数组与矩阵运算,此外也针对数组运算提供大量的数学函数库。菜鸟教程链接: link.

    二、使用步骤

    1.引入库

    代码如下:

    import numpy as np
    

    2.NumPy Ndarray 对象

    创建一个 ndarray 只需调用 NumPy 的 array 函数即可:

    numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

    名称描述
    object数组或嵌套的数列
    dtype数组元素的数据类型,可选
    copy对象是否需要复制,可选
    order创建数组的样式,C为行方向,F为列方向,A为任意方向(默认)
    subok默认返回一个与基类类型一致的数组
    ndmin指定生成数组的最小维度

    例如:

    import numpy as np
    a = np.array([1,2,3]) #一维array
    b = np.array([[1,2],[3,4]]) #二维array
    

    2.NumPy 矩阵对象

    创建一个 ndarray 只需调用 NumPy 的 mat 函数即可,例如:

    import numpy as np
    a = np.mat([[1,2],[3,4]])
    b = np.mat([[1,2,3,4]])
    c = np.mat([[1],[2],[3],[4]])
    

    对应于:

    a = [ 1 2 3 4 ] , b = [ 1 2 3 4 ] , c = [ 1 2 3 4 ] a = \begin{bmatrix} 1&2 \\ 3&4 \end{bmatrix} ,b=\begin{bmatrix} 1&2 &3 &4 \end{bmatrix} ,c = \begin{bmatrix} 1\\2 \\3 \\4 \end{bmatrix} a=[1324],b=[1234],c=1234
    numpy已经为我们实现了对矩阵的各种操作,常见的有:

    2.1 矩阵转置(T)

    import numpy as np
    a = np.mat([[1,2],[3,4]])
    a_t = a.T
    

    a _ t = [ 1 3 2 4 ] a\_t = \begin{bmatrix} 1&3 \\ 2&4 \end{bmatrix} a_t=[1234]

    2.2 矩阵求逆(I)

    import numpy as np
    a = np.mat([[1,2],[3,4]])
    a_i = a.I
    

    a _ i = [ − 2 1 1.5 − 0.5 ] a\_i = \begin{bmatrix} -2&1 \\ 1.5&-0.5 \end{bmatrix} a_i=[21.510.5]

    2.3 矩阵乘法(dot)

    import numpy as np
    a = np.mat([[1,2],[3,4]])
    b = np.mat([[2,3],[4,5]])
    c = a.dot(b)
    

    c = [ 10 13 22 29 ] c = \begin{bmatrix} 10&13 \\ 22&29 \end{bmatrix} c=[10221329]

    2.4 访问矩阵

    2.4.1 访问第i行第j列的值(i,j从0开始)

    import numpy as np
    a = np.mat([[1,2],[3,4]])
    print(a[0,1])
    print(type(a[0,1]))
    

    输出:

    2
    <class 'numpy.int32'>
    

    2.4.2 遍历第i行

    import numpy as np
    a = np.mat([[1,2],[3,4]])
    print(a[0,:])
    print(type(a[0,:]))
    

    输出:

    [[1 2]]
    <class 'numpy.matrix'>
    

    2.4.3 遍历第j列

    import numpy as np
    a = np.mat([[1,2],[3,4]])
    print(a[:,0])
    print(type(a[:,0]))
    

    输出:

    [[1]
     [3]]
    <class 'numpy.matrix'>
    

    总结

    Numpy是python中一个强大的数值计算库,熟悉Numpy的操作可以大大简化我们的代码,使其更加整洁高效。Numpy的常见用法可以参考菜鸟教程。菜鸟教程链接: [link](https://www.runoob.com/numpy/numpy-tutorial.html).
    展开全文
  • 机器学习:使用numpy从零开始的机器学习算法
  • numpy(Numerical Python extensions)是一个第三方的Python包,用于科学计算。这个库的前身是1995年就开始开发的一个用于数组运算的库。经过了长时间的发展,基本上成了绝大部分Python科学计算的基础包,当然也包括...
  • 在我们使用Python语言进行机器学习编程的时候,这是一个非常常用的基础库。本文针对Python 机器学习NumPy入门教程,感兴趣的朋友跟随脚本之家小编一起学习吧
  • 本博客介绍 numpy 模块的使用方法,并对机器学习中应用到的较多的一些方法进行重点讲解。 机器学习入门系列博客 文章目录一、创建numpy的数组(矩阵)1 np.array()2 np.asarray()3 生成某一个值的特定矩阵4 创建等...
  • 机器学习的必不可少的工具。本文是在学习了Numpy数值计算课程之后,所做的些许笔记。 文章目录导入Numpy第三方库生成Numpy数组几种方法数组的基本操作 导入Numpy第三方库 导入numpy库 import numpy as np 查看...
  • jax.numpy是CPU、GPU和TPU上的numpy,具有出色的自动差异化功能,可用于高性能机器学习研究。 我今天就来试一试到底多快。我在同一台bu带gpu的机器上进行试验 首先我们得安装jax pip install jax jaxlib 先试一下...
  • Python-建模分析师之硬技能 Python数据分析基础 机器学习numpy和pandas基础
  • 机器学习小白入门之自学numpy,学习之余自己整理了一下numpy基础部分的内容,主要是对矩阵、向量的一些基本操作函数和函数使用格式。
  • 目录numpy1、创建 numpy.array1.1、常规创建 numpy.array 的方法1.2、其他创建 numpy.array 的方法1.2、其他创建随机数 random2、numpy.array 基本操作2.1、numpy.array 的基本属性2.2、numpy.array 的数据访问2.3、...
  • 该资源为机器学习科学计算库(1)Matplotlib、Numpy、Pandas及拓展的详细讲解,包括理论和实践案例。环境安装配置等也详细说明了。
  • 是否曾经希望您有一个效率低下但清晰易读的机器学习算法集合,这些算法仅在NumPy中实现? 没有? 安装 快速实验 要将此代码用作ML原型设计/实验的起点,只需克隆存储库,创建一个新的 ,然后开始黑客攻击: $ git ...
  • numpy的使用
  • 机器学习的必不可少的工具。本文是在学习了Numpy数值计算课程之后,所做的些许笔记。 文章目录Numpy生成随机数Numpy数学函数Numpy数据修约Numpy数组的数学运算 Numpy生成随机数 生成随机数几种方法 rand(d0, d1, ...
  • 网易公开课程练手资源,机器学习,Python,自己手写的练习代码。^_^
  • 机器学习的必不可少的工具。本文是在学习了Numpy数值计算课程之后,做的些许笔记。 文章目录Numpy数组的索引与切片Numpy数组排序、搜索及计数 Numpy数组的索引与切片 数组索引 //一维数据索引 data[x] //索引一个...
  • 从零开始的ML和DL算法仅使用香草python和numpy库的机器学习和深度学习算法实现。K均值K均值聚类是一种无监督学习算法,可将未标记的数据集分为不同的聚类。 它使我们可以将数据分为不同的组,并且可以方便地自行发现...
  • 安装光盘./ml_utils 机器学习实用程序文件(API)
  • Python机器学习编程与实战教学教案02NumPy数值计算.pdfPython机器学习编程与实战教学教案02NumPy数值计算.pdfPython机器学习编程与实战教学教案02NumPy数值计算.pdfPython机器学习编程与实战教学教案02NumPy数值计算...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 154,227
精华内容 61,690
关键字:

numpy 机器学习