精华内容
下载资源
问答
  • python 科学计算 发行版 Anaconda安装使用教程

    万次阅读 多人点赞 2016-07-15 14:41:10
    现阶段python做科学计算的标配是numpy+scipy+matplotlib+sklearn+pandas。可惜的是,原生的python是不带这些包的。于是,每次遇到一个新机器,需要安装这些包。更可气的是,昨晚本博主为了在新机器上安装sklearn,...

    项目github地址:bitcarmanlee easy-algorithm-interview-and-practice
    欢迎大家star,留言,一起学习进步

    1.原生python的不方便

    作为一个数据与算法工作者,python的使用频率很高。现阶段python做科学计算的标配是numpy+scipy+matplotlib+sklearn+pandas。可惜的是,原生的python是不带这些包的。于是,每次遇到一个新机器,需要安装这些包。更可气的是,昨晚本博主为了在新机器上安装sklearn,足足花了两小时,中间踩了无数之前没遇到过的天坑加上天朝坑爹的网络。。。作为一个搭建了无数次科学计算环境的老司机还遇到这种情况,估计新手们就更无比郁闷了。于是老司机就想,有没有一个东西把所有常用的科学计算工具都集成好,这样就省了每次搭环境的天坑。。。google一把,发现了今天文章的主角:Anaconda。

    2.先看看Anaconda是个什么鬼

    Anaconda:蟒蛇,估计来源就是python logo里那条可爱的小蟒蛇吧。
    mac版下载地址:https://www.continuum.io/downloads#_macosx
    看看官网首页是怎么介绍的:
    Anaconda is the leading open data science platform powered by Python. The open source version of Anaconda is a high performance distribution of Python and R and includes over 100 of the most popular Python, R and Scala packages for data science. Additionally, you’ll have access to over 720 packages that can easily be installed with conda, our renowned package, dependency and environment manager, that is included in Anaconda. Anaconda is BSD licensed which gives you permission to use Anaconda commercially and for redistribution. See the packages included with Anaconda and the Anaconda changelog.

    通过上面这段牛逼闪闪的介绍,我们知道Anaconda是一个基于python的科学计算平台,这个平台里包含有python,r,scala等绝大部分主流的用于科学计算的包。

    接下来自然就是开始下载了。因为集成有很多牛逼科学计算包的缘故,所以安装包自然也小不了,比如我下载的mac版就有360M。那就慢慢下着吧。还好网络虽然不是很快,好歹还是稳定的,能到一两百k,一个小时左右能下完。这段时间就先干点别的吧。

    3.安装配置

    下载完成以后,跟mac里安装普通软件一样,双击安装即可。
    安装完以后,开始进行相应的配置。因为我平时使用eclipse开发,正好官网都贴心地给出了在IDE里怎么配置使用,里面就有eclipse,前提是eclipse已经安装了pydev插件。

    以下eclipse配置方法来自官网:
    After you have Eclipse, PyDev, and Anaconda installed, follow these steps to set Anaconda Python as your default by adding it as a new interpreter, and then selecting that new interpreter:

    Open the Eclipse Preferences window:
    这里写图片描述
    Go to PyDev -> Interpreters -> Python Interpreter.
    Click the New button:
    这里写图片描述
    In the “Interpreter Name” box, type “Anaconda Python”.
    Browse to ~/anaconda/bin/python or wherever your Anaconda Python is installed.
    Click the OK button.
    这里写图片描述
    In the next window, select all the folders and click the OK button again to select the folders to add to the SYSTEM python path.
    这里写图片描述
    The Python Interpreters window will now display Anaconda Python. Click OK.
    这里写图片描述
    You are now ready to use Anaconda Python with your Eclipse and PyDev installation.

    如果是其他IDE,可以上官网查看其他配置方法。具体地址:
    https://docs.continuum.io/anaconda/ide_integration#id8

    4.查看Anaconda的基本用法

    配置完成以后,查看一下此时系统的python:

    lei.wang ~ $ which python
    /Users/lei.wang/anaconda/bin/python
    lei.wang ~ $ python --version
    Python 2.7.12 :: Anaconda 4.1.1 (x86_64)
    

    此时,系统默认的python已经变成了Anaconda的版本!
    为什么会这样呢?原来是安装过程中,偷偷给我们在home目录下生成了一个.bashrc_profile文件,并在里面加入了PATH:

    # added by Anaconda2 4.1.1 installer
    export PATH="/Users/wanglei/anaconda/bin:$PATH"
    

    所以这个时候我们的bash里使用python的话,已经指向了anaconda里的python解释器。
    如果使用的不是mac的标准bash,而是zsh,不用着急,将上面一行配置复制粘贴到.zshrc文件中,然后source一下.zshrc文件即可!

    执行一下conda命令:

    lei.wang ~ $ conda
    usage: conda [-h] [-V] [--debug] command ...
    
    conda is a tool for managing and deploying applications, environments and packages.
    
    Options:
    
    positional arguments:
      command
        info         Display information about current conda install.
        help         Displays a list of available conda commands and their help
                     strings.
        list         List linked packages in a conda environment.
        search       Search for packages and display their information. The input
                     is a Python regular expression. To perform a search with a
                     search string that starts with a -, separate the search from
                     the options with --, like 'conda search -- -h'. A * in the
                     results means that package is installed in the current
                     environment. A . means that package is not installed but is
                     cached in the pkgs directory.
        create       Create a new conda environment from a list of specified
                     packages.
        install      Installs a list of packages into a specified conda
                     environment.
        update       Updates conda packages to the latest compatible version. This
                     command accepts a list of package names and updates them to
                     the latest versions that are compatible with all other
                     packages in the environment. Conda attempts to install the
                     newest versions of the requested packages. To accomplish
                     this, it may update some packages that are already installed,
                     or install additional packages. To prevent existing packages
                     from updating, use the --no-update-deps option. This may
                     force conda to install older versions of the requested
                     packages, and it does not prevent additional dependency
                     packages from being installed. If you wish to skip dependency
                     checking altogether, use the '--force' option. This may
                     result in an environment with incompatible packages, so this
                     option must be used with great caution.
        upgrade      Alias for conda update. See conda update --help.
        remove       Remove a list of packages from a specified conda environment.
        uninstall    Alias for conda remove. See conda remove --help.
        config       Modify configuration values in .condarc. This is modeled
                     after the git config command. Writes to the user .condarc
                     file (/Users/lei.wang/.condarc) by default.
        init         Initialize conda into a regular environment (when conda was
                     installed as a Python package, e.g. using pip). (DEPRECATED)
        clean        Remove unused packages and caches.
        package      Low-level conda package utility. (EXPERIMENTAL)
        bundle       Create or extract a "bundle package" (EXPERIMENTAL)
    ...
    

    信息太长了,后面的部分就不列举了。不过看到前面这部分选项,就已经足够让我们兴奋了:基本的list,search,install,upgrade,uninstall等功能都包含,说明我们可以向apt-get一样方便管理python的各种依赖了。。。

    先list一下,查看里面都带了哪些牛逼闪闪的科学计算包:

    ei.wang ~ $ conda list
    # packages in environment at /Users/lei.wang/anaconda:
    #
    _nb_ext_conf              0.2.0                    py27_0
    alabaster                 0.7.8                    py27_0
    anaconda                  4.1.1               np111py27_0
    anaconda-client           1.4.0                    py27_0
    anaconda-navigator        1.2.1                    py27_0
    appnope                   0.1.0                    py27_0
    appscript                 1.0.1                    py27_0
    argcomplete               1.0.0                    py27_1
    astropy                   1.2.1               np111py27_0
    babel                     2.3.3                    py27_0
    backports                 1.0                      py27_0
    backports_abc             0.4                      py27_0
    beautifulsoup4            4.4.1                    py27_0
    bitarray                  0.8.1                    py27_0
    blaze                     0.10.1                   py27_0
    bokeh                     0.12.0                   py27_0
    boto                      2.40.0                   py27_0
    bottleneck                1.1.0               np111py27_0
    cdecimal                  2.3                      py27_2
    cffi                      1.6.0                    py27_0
    chest                     0.2.3                    py27_0
    click                     6.6                      py27_0
    cloudpickle               0.2.1                    py27_0
    clyent                    1.2.2                    py27_0
    colorama                  0.3.7                    py27_0
    conda                     4.1.6                    py27_0
    conda-build               1.21.3                   py27_0
    conda-env                 2.5.1                    py27_0
    configobj                 5.0.6                    py27_0
    configparser              3.5.0b2                  py27_1
    contextlib2               0.5.3                    py27_0
    cryptography              1.4                      py27_0
    curl                      7.49.0                        0
    cycler                    0.10.0                   py27_0
    cython                    0.24                     py27_0
    cytoolz                   0.8.0                    py27_0
    dask                      0.10.0                   py27_0
    datashape                 0.5.2                    py27_0
    decorator                 4.0.10                   py27_0
    dill                      0.2.5                    py27_0
    docutils                  0.12                     py27_2
    dynd-python               0.7.2                    py27_0
    entrypoints               0.2.2                    py27_0
    enum34                    1.1.6                    py27_0
    et_xmlfile                1.0.1                    py27_0
    fastcache                 1.0.2                    py27_1
    flask                     0.11.1                   py27_0
    flask-cors                2.1.2                    py27_0
    freetype                  2.5.5                         1
    funcsigs                  1.0.2                    py27_0
    functools32               3.2.3.2                  py27_0
    futures                   3.0.5                    py27_0
    get_terminal_size         1.0.0                    py27_0
    gevent                    1.1.1                    py27_0
    greenlet                  0.4.10                   py27_0
    grin                      1.2.1                    py27_3
    h5py                      2.6.0               np111py27_1
    hdf5                      1.8.16                        0
    heapdict                  1.0.0                    py27_1
    idna                      2.1                      py27_0
    imagesize                 0.7.1                    py27_0
    ipaddress                 1.0.16                   py27_0
    ipykernel                 4.3.1                    py27_0
    ipython                   4.2.0                    py27_1
    ipython_genutils          0.1.0                    py27_0
    ipywidgets                4.1.1                    py27_0
    itsdangerous              0.24                     py27_0
    jbig                      2.1                           0
    jdcal                     1.2                      py27_1
    jedi                      0.9.0                    py27_1
    jinja2                    2.8                      py27_1
    jpeg                      8d                            1
    jsonschema                2.5.1                    py27_0
    jupyter                   1.0.0                    py27_3
    jupyter_client            4.3.0                    py27_0
    jupyter_console           4.1.1                    py27_0
    jupyter_core              4.1.0                    py27_0
    libdynd                   0.7.2                         0
    libpng                    1.6.22                        0
    libtiff                   4.0.6                         2
    libxml2                   2.9.2                         0
    libxslt                   1.1.28                        2
    llvmlite                  0.11.0                   py27_0
    locket                    0.2.0                    py27_1
    lxml                      3.6.0                    py27_0
    markupsafe                0.23                     py27_2
    matplotlib                1.5.1               np111py27_0
    mistune                   0.7.2                    py27_1
    mkl                       11.3.3                        0
    mkl-service               1.1.2                    py27_2
    mpmath                    0.19                     py27_1
    multipledispatch          0.4.8                    py27_0
    nb_anacondacloud          1.1.0                    py27_0
    nb_conda                  1.1.0                    py27_0
    nb_conda_kernels          1.0.3                    py27_0
    nbconvert                 4.2.0                    py27_0
    nbformat                  4.0.1                    py27_0
    nbpresent                 3.0.2                    py27_0
    networkx                  1.11                     py27_0
    nltk                      3.2.1                    py27_0
    nose                      1.3.7                    py27_1
    notebook                  4.2.1                    py27_0
    numba                     0.26.0              np111py27_0
    numexpr                   2.6.0               np111py27_0
    numpy                     1.11.1                   py27_0
    odo                       0.5.0                    py27_1
    openpyxl                  2.3.2                    py27_0
    openssl                   1.0.2h                        1
    pandas                    0.18.1              np111py27_0
    partd                     0.3.4                    py27_0
    path.py                   8.2.1                    py27_0
    pathlib2                  2.1.0                    py27_0
    patsy                     0.4.1                    py27_0
    pep8                      1.7.0                    py27_0
    pexpect                   4.0.1                    py27_0
    pickleshare               0.7.2                    py27_0
    pillow                    3.2.0                    py27_1
    pip                       8.1.2                    py27_0
    ply                       3.8                      py27_0
    psutil                    4.3.0                    py27_0
    ptyprocess                0.5.1                    py27_0
    py                        1.4.31                   py27_0
    pyasn1                    0.1.9                    py27_0
    pyaudio                   0.2.7                    py27_0
    pycosat                   0.6.1                    py27_1
    pycparser                 2.14                     py27_1
    pycrypto                  2.6.1                    py27_4
    pycurl                    7.43.0                   py27_0
    pyflakes                  1.2.3                    py27_0
    pygments                  2.1.3                    py27_0
    pyopenssl                 0.16.0                   py27_0
    pyparsing                 2.1.4                    py27_0
    pyqt                      4.11.4                   py27_3
    pytables                  3.2.2               np111py27_4
    pytest                    2.9.2                    py27_0
    python                    2.7.12                        1
    python-dateutil           2.5.3                    py27_0
    python.app                1.2                      py27_4
    pytz                      2016.4                   py27_0
    pyyaml                    3.11                     py27_4
    pyzmq                     15.2.0                   py27_1
    qt                        4.8.7                         3
    qtconsole                 4.2.1                    py27_0
    qtpy                      1.0.2                    py27_0
    readline                  6.2                           2
    redis                     3.2.0                         0
    redis-py                  2.10.5                   py27_0
    requests                  2.10.0                   py27_0
    rope                      0.9.4                    py27_1
    ruamel_yaml               0.11.7                   py27_0
    scikit-image              0.12.3              np111py27_1
    scikit-learn              0.17.1              np111py27_2
    scipy                     0.17.1              np111py27_1
    setuptools                23.0.0                   py27_0
    simplegeneric             0.8.1                    py27_1
    singledispatch            3.4.0.3                  py27_0
    sip                       4.16.9                   py27_0
    six                       1.10.0                   py27_0
    snowballstemmer           1.2.1                    py27_0
    sockjs-tornado            1.0.3                    py27_0
    sphinx                    1.4.1                    py27_0
    sphinx_rtd_theme          0.1.9                    py27_0
    spyder                    2.3.9                    py27_0
    sqlalchemy                1.0.13                   py27_0
    sqlite                    3.13.0                        0
    ssl_match_hostname        3.4.0.2                  py27_1
    statsmodels               0.6.1               np111py27_1
    sympy                     1.0                      py27_0
    terminado                 0.6                      py27_0
    tk                        8.5.18                        0
    toolz                     0.8.0                    py27_0
    tornado                   4.3                      py27_1
    traitlets                 4.2.1                    py27_0
    unicodecsv                0.14.1                   py27_0
    werkzeug                  0.11.10                  py27_0
    wheel                     0.29.0                   py27_0
    xlrd                      1.0.0                    py27_0
    xlsxwriter                0.9.2                    py27_0
    xlwings                   0.7.2                    py27_0
    xlwt                      1.1.2                    py27_0
    xz                        5.2.2                         0
    yaml                      0.1.6                         0
    zlib                      1.2.8                         3
    

    好吧,至少我常用的都已经在这了。太方便了。

    5.写个demo测试一下sklearn

    为了测试一下是不是真像传说中那么好用,从网络上现找了部分简单的测试代码:

    #!/usr/bin/env python
    #coding:utf-8
    
    '''
    Created on 2016年7月15日
    
    @author: lei.wang
    '''
    
    import numpy as np
    import urllib
    from sklearn import preprocessing
    from sklearn import metrics
    from sklearn.ensemble import ExtraTreesClassifier
    from sklearn.linear_model import LogisticRegression
    
    
    def t1():
        url = "http://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data"
        raw_data = urllib.urlopen(url)
        dataset = np.loadtxt(raw_data,delimiter=",")
        X = dataset[:,0:7]
        y = dataset[:,8]
        
        # normalize the data attributes
        normalized_X = preprocessing.normalize(X)
        # standardize the data attributes
        standardized_X = preprocessing.scale(X)
    
        model = ExtraTreesClassifier()
        model.fit(X, y)
        # display the relative importance of each attribute
        print model.feature_importances_
        
        model = LogisticRegression()
        model.fit(X, y)
        print(model)
        # make predictions
        expected = y
        predicted = model.predict(X)
        # summarize the fit of the model
        print(metrics.classification_report(expected, predicted))
        print(metrics.confusion_matrix(expected, predicted))
    
    t1()
    

    让代码run起来,得到如下结果:

    [ 0.13697671  0.26771573  0.11139943  0.08658428  0.079841    0.16862413
      0.1488587 ]
    LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
              intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,
              penalty='l2', random_state=None, solver='liblinear', tol=0.0001,
              verbose=0, warm_start=False)
                 precision    recall  f1-score   support
    
            0.0       0.79      0.89      0.84       500
            1.0       0.74      0.55      0.63       268
    
    avg / total       0.77      0.77      0.77       768
    
    [[447  53]
     [120 148]]
    
    

    好吧,sklearn表现正常,能正常输出预期结果。看来,Anaconda确实是为搞算法与数据的同志们提供了一个非常好的工具,省去了我们各种搭环境找依赖包的烦恼!向开发了这么好用工具的程序猿们致敬!

    展开全文
  • Python进阶-Numpy科学计算

    千人学习 2018-12-18 13:36:31
    Numpy是python最基本最常用的科学计算库,在数据分析,机器学习,深度学习等领域经常被使用,可以说是学习python必学的一个库。本课程会讲解到numpy中最核心的一些知识点,包括numpy的属性,创建array,numpy的运算...
  • Python 科学计算和绘图

    万次阅读 2018-05-23 11:50:37
    達聞西给深度学习入门者的Python快速教程基础篇numpy和Matplotlib篇本篇部分代码的下载地址:https://github.com/frombeijingwithlove/dlcv_for_beginners/tree/master/chap55.3 Python的科学计算包 – Numpynum...

    转自:http://python.jobbole.com/87471/

     

     

    原文出处: 達聞西   

    给深度学习入门者的Python快速教程

    本篇部分代码的下载地址:

    https://github.com/frombeijingwithlove/dlcv_for_beginners/tree/master/chap5

    5.3 Python的科学计算包 – Numpy

    numpy(Numerical Python extensions)是一个第三方的Python包,用于科学计算。这个库的前身是1995年就开始开发的一个用于数组运算的库。经过了长时间的发展,基本上成了绝大部分Python科学计算的基础包,当然也包括所有提供Python接口的深度学习框架。

    numpy在Linux下的安装已经在5.1.2中作为例子讲过,Windows下也可以通过pip,或者到下面网址下载:

    Obtaining NumPy & SciPy libraries

    5.3.1 基本类型(array)

    array,也就是数组,是numpy中最基础的数据结构,最关键的属性是维度和元素类型,在numpy中,可以非常方便地创建各种不同类型的多维数组,并且执行一些基本基本操作,来看例子:

     
     
     
     
     
     
    Python
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    import numpy as np
     
    a = [1, 2, 3, 4]     #
    b = np.array(a)         # array([1, 2, 3, 4])
    type(b)                   # <type 'numpy.ndarray'>
     
    b.shape                   # (4,)
    b.argmax()               # 3
    b.max()                   # 4
    b.mean()                   # 2.5
     
    c = [[1, 2], [3, 4]]   # 二维列表
    d = np.array(c)         # 二维numpy数组
    d.shape                   # (2, 2)
    d.size                   # 4
    d.max(axis=0)             # 找维度0,也就是最后一个维度上的最大值,array([3, 4])
    d.max(axis=1)             # 找维度1,也就是倒数第二个维度上的最大值,array([2, 4])
    d.mean(axis=0)           # 找维度0,也就是第一个维度上的均值,array([ 2.,  3.])
    d.flatten()               # 展开一个numpy数组为1维数组,array([1, 2, 3, 4])
    np.ravel(c)               # 展开一个可以解析的结构为1维数组,array([1, 2, 3, 4])
     
    # 3x3的浮点型2维数组,并且初始化所有元素值为1
    e = np.ones((3, 3), dtype=np.float)
     
    # 创建一个一维数组,元素值是把3重复4次,array([3, 3, 3, 3])
    f = np.repeat(3, 4)
     
    # 2x2x3的无符号8位整型3维数组,并且初始化所有元素值为0
    g = np.zeros((2, 2, 3), dtype=np.uint8)
    g.shape                    # (2, 2, 3)
    h = g.astype(np.float)  # 用另一种类型表示
     
    l = np.arange(10)       # 类似range,array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    m = np.linspace(0, 6, 5)# 等差数列,0到6之间5个取值,array([ 0., 1.5, 3., 4.5, 6.])
     
    p = np.array(
        [[1, 2, 3, 4],
         [5, 6, 7, 8]]
    )
     
    np.save('p.npy', p)     # 保存到文件
    q = np.load('p.npy')    # 从文件读取

    注意到在导入numpy的时候,我们将np作为numpy的别名。这是一种习惯性的用法,后面的章节中我们也默认这么使用。作为一种多维数组结构,array的数组相关操作是非常丰富的:

     
     
     
     
     
    Python
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    import numpy as np
     
    '''
    array([[[ 0,  1,  2,  3],
            [ 4,  5,  6,  7],
            [ 8,  9, 10, 11]],
     
           [[12, 13, 14, 15],
            [16, 17, 18, 19],
            [20, 21, 22, 23]]])
    '''
    a = np.arange(24).reshape((2, 3, 4))
    b = a[1][1][1]  # 17
     
    '''
    array([[ 8,  9, 10, 11],
           [20, 21, 22, 23]])
    '''
    c = a[:, 2, :]
     
    ''' 用:表示当前维度上所有下标
    array([[ 1,  5,  9],
           [13, 17, 21]])
    '''
    d = a[:, :, 1]
     
    ''' 用...表示没有明确指出的维度
    array([[ 1,  5,  9],
           [13, 17, 21]])
    '''
    e = a[..., 1]
     
    '''
    array([[[ 5,  6],
            [ 9, 10]],
     
           [[17, 18],
            [21, 22]]])
    '''
    f = a[:, 1:, 1:-1]
     
    '''
    平均分成3份
    [array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
    '''
    g = np.split(np.arange(9), 3)
     
    '''
    按照下标位置进行划分
    [array([0, 1]), array([2, 3, 4, 5]), array([6, 7, 8])]
    '''
    h = np.split(np.arange(9), [2, -3])
     
    l0 = np.arange(6).reshape((2, 3))
    l1 = np.arange(6, 12).reshape((2, 3))
     
    '''
    vstack是指沿着纵轴拼接两个array,vertical
    hstack是指沿着横轴拼接两个array,horizontal
    更广义的拼接用concatenate实现,horizontal后的两句依次等效于vstack和hstack
    stack不是拼接而是在输入array的基础上增加一个新的维度
    '''
    m = np.vstack((l0, l1))
    p = np.hstack((l0, l1))
    q = np.concatenate((l0, l1))
    r = np.concatenate((l0, l1), axis=-1)
    s = np.stack((l0, l1))
     
    '''
    按指定轴进行转置
    array([[[ 0,  3],
            [ 6,  9]],
     
           [[ 1,  4],
            [ 7, 10]],
     
           [[ 2,  5],
            [ 8, 11]]])
    '''
    t = s.transpose((2, 0, 1))
     
    '''
    默认转置将维度倒序,对于2维就是横纵轴互换
    array([[ 0,  4,  8],
           [ 1,  5,  9],
           [ 2,  6, 10],
           [ 3,  7, 11]])
    '''
    u = a[0].transpose() # 或者u=a[0].T也是获得转置
     
    '''
    逆时针旋转90度,第二个参数是旋转次数
    array([[ 3,  2,  1,  0],
           [ 7,  6,  5,  4],
           [11, 10,  9,  8]])
    '''
    v = np.rot90(u, 3)
     
    '''
    沿纵轴左右翻转
    array([[ 8,  4,  0],
           [ 9,  5,  1],
           [10,  6,  2],
           [11,  7,  3]])
    '''
    w = np.fliplr(u)
     
    '''
    沿水平轴上下翻转
    array([[ 3,  7, 11],
           [ 2,  6, 10],
           [ 1,  5,  9],
           [ 0,  4,  8]])
    '''
    x = np.flipud(u)
     
    '''
    按照一维顺序滚动位移
    array([[11,  0,  4],
           [ 8,  1,  5],
           [ 9,  2,  6],
           [10,  3,  7]])
    '''
    y = np.roll(u, 1)
     
    '''
    按照指定轴滚动位移
    array([[ 8,  0,  4],
           [ 9,  1,  5],
           [10,  2,  6],
           [11,  3,  7]])
    '''
    z = np.roll(u, 1, axis=1)

    对于一维的array所有Python列表支持的下标相关的方法array也都支持,所以在此没有特别列出。

    既然叫numerical python,基础数学运算也是强大的:

     
     
     
     
     
    Python
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    import numpy as np
     
    # 绝对值,1
    a = np.abs(-1)
     
    # sin函数,1.0
    b = np.sin(np.pi/2)
     
    # tanh逆函数,0.50000107157840523
    c = np.arctanh(0.462118)
     
    # e为底的指数函数,20.085536923187668
    d = np.exp(3)
     
    # 2的3次方,8
    f = np.power(2, 3)
     
    # 点积,1*3+2*4=11
    g = np.dot([1, 2], [3, 4])
     
    # 开方,5
    h = np.sqrt(25)
     
    # 求和,10
    l = np.sum([1, 2, 3, 4])
     
    # 平均值,5.5
    m = np.mean([4, 5, 6, 7])
     
    # 标准差,0.96824583655185426
    p = np.std([1, 2, 3, 2, 1, 3, 2, 0])

    对于array,默认执行对位运算。涉及到多个array的对位运算需要array的维度一致,如果一个array的维度和另一个array的子维度一致,则在没有对齐的维度上分别执行对位运算,这种机制叫做广播(broadcasting),言语解释比较难,还是看例子理解:

     
     
     
     
     
    Python
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    import numpy as np
     
    a = np.array([
        [1, 2, 3],
        [4, 5, 6]
    ])
     
    b = np.array([
        [1, 2, 3],
        [1, 2, 3]
    ])
     
    '''
    维度一样的array,对位计算
    array([[2, 4, 6],
           [5, 7, 9]])
    '''
    a + b
     
    '''
    array([[0, 0, 0],
           [3, 3, 3]])
    '''
    a - b
     
    '''
    array([[ 1,  4,  9],
           [ 4, 10, 18]])
    '''
    a * b
     
    '''
    array([[1, 1, 1],
           [4, 2, 2]])
    '''
    a / b
     
    '''
    array([[ 1,  4,  9],
           [16, 25, 36]])
    '''
    a ** 2
     
    '''
    array([[  1,   4,  27],
           [  4,  25, 216]])
    '''
    a ** b
     
    c = np.array([
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9],
        [10, 11, 12]
    ])
    d = np.array([2, 2, 2])
     
    '''
    广播机制让计算的表达式保持简洁
    d和c的每一行分别进行运算
    array([[ 3,  4,  5],
           [ 6,  7,  8],
           [ 9, 10, 11],
           [12, 13, 14]])
    '''
    c + d
     
    '''
    array([[ 2,  4,  6],
           [ 8, 10, 12],
           [14, 16, 18],
           [20, 22, 24]])
    '''
    c * d
     
    '''
    1和c的每个元素分别进行运算
    array([[ 0,  1,  2],
           [ 3,  4,  5],
           [ 6,  7,  8],
           [ 9, 10, 11]])
    '''
    c - 1

     

    5.3.2 线性代数模块(linalg)

    在深度学习相关的数据处理和运算中,线性代数模块(linalg)是最常用的之一。结合numpy提供的基本函数,可以对向量,矩阵,或是说多维张量进行一些基本的运算:

     
     
     
     
     
    Python
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    import numpy as np
     
    a = np.array([3, 4])
    np.linalg.norm(a)
     
    b = np.array([
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]
    ])
    c = np.array([1, 0, 1])
     
    # 矩阵和向量之间的乘法
    np.dot(b, c)             # array([ 4, 10, 16])
    np.dot(c, b.T)           # array([ 4, 10, 16])
     
    np.trace(b)             # 求矩阵的迹,15
    np.linalg.det(b)         # 求矩阵的行列式值,0
    np.linalg.matrix_rank(b) # 求矩阵的秩,2,不满秩,因为行与行之间等差
     
    d = np.array([
        [2, 1],
        [1, 2]
    ])
     
    '''
    对正定矩阵求本征值和本征向量
    本征值为u,array([ 3.,  1.])
    本征向量构成的二维array为v,
    array([[ 0.70710678, -0.70710678],
           [ 0.70710678,  0.70710678]])
    是沿着45°方向
    eig()是一般情况的本征值分解,对于更常见的对称实数矩阵,
    eigh()更快且更稳定,不过输出的值的顺序和eig()是相反的
    '''
    u, v = np.linalg.eig(d)
     
    # Cholesky分解并重建
    l = np.linalg.cholesky(d)
     
    '''
    array([[ 2.,  1.],
           [ 1.,  2.]])
    '''
    np.dot(l, l.T)
     
    e = np.array([
        [1, 2],
        [3, 4]
    ])
     
    # 对不镇定矩阵,进行SVD分解并重建
    U, s, V = np.linalg.svd(e)
     
    S = np.array([
        [s[0], 0],
        [0, s[1]]
    ])
     
    '''
    array([[ 1.,  2.],
           [ 3.,  4.]])
    '''
    np.dot(U, np.dot(S, V))

     

    5.3.3 随机模块(random)

    随机模块包含了随机数产生和统计分布相关的基本函数,Python本身也有随机模块random,不过功能更丰富,还是来看例子:

     
     
     
     
     
     
    Python
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    import numpy as np
    import numpy.random as random
     
    # 设置随机数种子
    random.seed(42)
     
    # 产生一个1x3,[0,1)之间的浮点型随机数
    # array([[ 0.37454012,  0.95071431,  0.73199394]])
    # 后面的例子就不在注释中给出具体结果了
    random.rand(1, 3)
     
    # 产生一个[0,1)之间的浮点型随机数
    random.random()
     
    # 下边4个没有区别,都是按照指定大小产生[0,1)之间的浮点型随机数array,不Pythonic…
    random.random((3, 3))
    random.sample((3, 3))
    random.random_sample((3, 3))
    random.ranf((3, 3))
     
    # 产生10个[1,6)之间的浮点型随机数
    5*random.random(10) + 1
    random.uniform(1, 6, 10)
     
    # 产生10个[1,6]之间的整型随机数
    random.randint(1, 6, 10)
     
    # 产生2x5的标准正态分布样本
    random.normal(size=(5, 2))
     
    # 产生5个,n=5,p=0.5的二项分布样本
    random.binomial(n=5, p=0.5, size=5)
     
    a = np.arange(10)
     
    # 从a中有回放的随机采样7个
    random.choice(a, 7)
     
    # 从a中无回放的随机采样7个
    random.choice(a, 7, replace=False)
     
    # 对a进行乱序并返回一个新的array
    b = random.permutation(a)
     
    # 对a进行in-place乱序
    random.shuffle(a)
     
    # 生成一个长度为9的随机bytes序列并作为str返回
    # '\x96\x9d\xd1?\xe6\x18\xbb\x9a\xec'
    random.bytes(9)

    随机模块可以很方便地让我们做一些快速模拟去验证一些结论。比如来考虑一个非常违反直觉的概率题例子:一个选手去参加一个TV秀,有三扇门,其中一扇门后有奖品,这扇门只有主持人知道。选手先随机选一扇门,但并不打开,主持人看到后,会打开其余两扇门中没有奖品的一扇门。然后,主持人问选手,是否要改变一开始的选择?

    这个问题的答案是应该改变一开始的选择。在第一次选择的时候,选错的概率是2/3,选对的概率是1/3。第一次选择之后,主持人相当于帮忙剔除了一个错误答案,所以如果一开始选的是错的,这时候换掉就选对了;而如果一开始就选对,则这时候换掉就错了。根据以上,一开始选错的概率就是换掉之后选对的概率(2/3),这个概率大于一开始就选对的概率(1/3),所以应该换。虽然道理上是这样,但是还是有些绕,要是通过推理就是搞不明白怎么办,没关系,用随机模拟就可以轻松得到答案:

     
     
     
     
     
     
    Python
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    import numpy.random as random
     
    random.seed(42)
     
    # 做10000次实验
    n_tests = 10000
     
    # 生成每次实验的奖品所在的门的编号
    # 0表示第一扇门,1表示第二扇门,2表示第三扇门
    winning_doors = random.randint(0, 3, n_tests)
     
    # 记录如果换门的中奖次数
    change_mind_wins = 0
     
    # 记录如果坚持的中奖次数
    insist_wins = 0
     
    # winning_door就是获胜门的编号
    for winning_door in winning_doors:
     
        # 随机挑了一扇门
        first_try = random.randint(0, 3)
        
        # 其他门的编号
        remaining_choices = [i for i in range(3) if i != first_try]
      
        # 没有奖品的门的编号,这个信息只有主持人知道
        wrong_choices = [i for i in range(3) if i != winning_door]
     
        # 一开始选择的门主持人没法打开,所以从主持人可以打开的门中剔除
        if first_try in wrong_choices:
            wrong_choices.remove(first_try)
        
        # 这时wrong_choices变量就是主持人可以打开的门的编号
        # 注意此时如果一开始选择正确,则可以打开的门是两扇,主持人随便开一扇门
        # 如果一开始选到了空门,则主持人只能打开剩下一扇空门
        screened_out = random.choice(wrong_choices)
        remaining_choices.remove(screened_out)
        
        # 所以虽然代码写了好些行,如果策略固定的话,
        # 改变主意的获胜概率就是一开始选错的概率,是2/3
        # 而坚持选择的获胜概率就是一开始就选对的概率,是1/3
        
        # 现在除了一开始选择的编号,和主持人帮助剔除的错误编号,只剩下一扇门
        # 如果要改变注意则这扇门就是最终的选择
        changed_mind_try = remaining_choices[0]
     
        # 结果揭晓,记录下来
        change_mind_wins += 1 if changed_mind_try == winning_door else 0
        insist_wins += 1 if first_try == winning_door else 0
     
    # 输出10000次测试的最终结果,和推导的结果差不多:
    # You win 6616 out of 10000 tests if you changed your mind
    # You win 3384 out of 10000 tests if you insist on the initial choice
    print(
        'You win {1} out of {0} tests if you changed your mind\n'
        'You win {2} out of {0} tests if you insist on the initial choice'.format(
            n_tests, change_mind_wins, insist_wins
            )
    )

     

    5.4 Python的可视化包 – Matplotlib

    Matplotlib是Python中最常用的可视化工具之一,可以非常方便地创建海量类型地2D图表和一些基本的3D图表。Matplotlib最早是为了可视化癫痫病人的脑皮层电图相关的信号而研发,因为在函数的设计上参考了MATLAB,所以叫做Matplotlib。Matplotlib首次发表于2007年,在开源和社区的推动下,现在在基于Python的各个科学计算领域都得到了广泛应用。Matplotlib的原作者John D. Hunter博士是一名神经生物学家,2012年不幸因癌症去世,感谢他创建了这样一个伟大的库。

    安装Matplotlib的方式和numpy很像,可以直接通过Unix/Linux的软件管理工具,比如Ubuntu 16.04 LTS下,输入:

    >> sudo apt install python-matplotlib

    或者通过pip安装:

    >> pip install matplotlib

    Windows下也可以通过pip,或是到官网下载:

    python plotting – Matplotlib 1.5.3 documentation

    Matplotlib非常强大,不过在深度学习中常用的其实只有很基础的一些功能,这节主要介绍2D图表,3D图表和图像显示。

    5.4.1 2D图表

    Matplotlib中最基础的模块是pyplot。先从最简单的点图和线图开始,比如我们有一组数据,还有一个拟合模型,通过下面的代码图来可视化:

     
     
     
     
     
    Python
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    import numpy as np
    import matplotlib as mpl
    import matplotlib.pyplot as plt
     
    # 通过rcParams设置全局横纵轴字体大小
    mpl.rcParams['xtick.labelsize'] = 24
    mpl.rcParams['ytick.labelsize'] = 24
     
    np.random.seed(42)
     
    # x轴的采样点
    x = np.linspace(0, 5, 100)
     
    # 通过下面曲线加上噪声生成数据,所以拟合模型就用y了……
    y = 2*np.sin(x) + 0.3*x**2
    y_data = y + np.random.normal(scale=0.3, size=100)
     
    # figure()指定图表名称
    plt.figure('data')
     
    # '.'标明画散点图,每个散点的形状是个圆
    plt.plot(x, y_data, '.')
     
    # 画模型的图,plot函数默认画连线图
    plt.figure('model')
    plt.plot(x, y)
     
    # 两个图画一起
    plt.figure('data & model')
     
    # 通过'k'指定线的颜色,lw指定线的宽度
    # 第三个参数除了颜色也可以指定线形,比如'r--'表示红色虚线
    # 更多属性可以参考官网:http://matplotlib.org/api/pyplot_api.html
    plt.plot(x, y, 'k', lw=3)
     
    # scatter可以更容易地生成散点图
    plt.scatter(x, y_data)
     
    # 将当前figure的图保存到文件result.png
    plt.savefig('result.png')
     
    # 一定要加上这句才能让画好的图显示在屏幕上
    plt.show()

    matplotlib和pyplot的惯用别名分别是mpl和plt,上面代码生成的图像如下:

    基本的画图方法就是这么简单,如果想了解更多pyplot的属性和方法来画出风格多样的图像,可以参考官网:

    pyplot – Matplotlib 1.5.3 documentation

    Customizing matplotlib

    点和线图表只是最基本的用法,有的时候我们获取了分组数据要做对比,柱状或饼状类型的图或许更合适:

     
     
     
     
     
     
    Python
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    import numpy as np
    import matplotlib as mpl
    import matplotlib.pyplot as plt
     
    mpl.rcParams['axes.titlesize'] = 20
    mpl.rcParams['xtick.labelsize'] = 16
    mpl.rcParams['ytick.labelsize'] = 16
    mpl.rcParams['axes.labelsize'] = 16
    mpl.rcParams['xtick.major.size'] = 0
    mpl.rcParams['ytick.major.size'] = 0
     
    # 包含了狗,猫和猎豹的最高奔跑速度,还有对应的可视化颜色
    speed_map = {
        'dog': (48, '#7199cf'),
        'cat': (45, '#4fc4aa'),
        'cheetah': (120, '#e1a7a2')
    }
     
    # 整体图的标题
    fig = plt.figure('Bar chart & Pie chart')
     
    # 在整张图上加入一个子图,121的意思是在一个1行2列的子图中的第一张
    ax = fig.add_subplot(121)
    ax.set_title('Running speed - bar chart')
     
    # 生成x轴每个元素的位置
    xticks = np.arange(3)
     
    # 定义柱状图每个柱的宽度
    bar_width = 0.5
     
    # 动物名称
    animals = speed_map.keys()
     
    # 奔跑速度
    speeds = [x[0] for x in speed_map.values()]
     
    # 对应颜色
    colors = [x[1] for x in speed_map.values()]
     
    # 画柱状图,横轴是动物标签的位置,纵轴是速度,定义柱的宽度,同时设置柱的边缘为透明
    bars = ax.bar(xticks, speeds, width=bar_width, edgecolor='none')
     
    # 设置y轴的标题
    ax.set_ylabel('Speed(km/h)')
     
    # x轴每个标签的具体位置,设置为每个柱的中央
    ax.set_xticks(xticks+bar_width/2)
     
    # 设置每个标签的名字
    ax.set_xticklabels(animals)
     
    # 设置x轴的范围
    ax.set_xlim([bar_width/2-0.5, 3-bar_width/2])
     
    # 设置y轴的范围
    ax.set_ylim([0, 125])
     
    # 给每个bar分配指定的颜色
    for bar, color in zip(bars, colors):
        bar.set_color(color)
     
    # 在122位置加入新的图
    ax = fig.add_subplot(122)
    ax.set_title('Running speed - pie chart')
     
    # 生成同时包含名称和速度的标签
    labels = ['{}\n{} km/h'.format(animal, speed) for animal, speed in zip(animals, speeds)]
     
    # 画饼状图,并指定标签和对应颜色
    ax.pie(speeds, labels=labels, colors=colors)
     
    plt.show()

    在这段代码中又出现了一个新的东西叫做,一个用ax命名的对象。在Matplotlib中,画图时有两个常用概念,一个是平时画图蹦出的一个窗口,这叫一个figure。Figure相当于一个大的画布,在每个figure中,又可以存在多个子图,这种子图叫做axes。顾名思义,有了横纵轴就是一幅简单的图表。在上面代码中,先把figure定义成了一个一行两列的大画布,然后通过fig.add_subplot()加入两个新的子图。subplot的定义格式很有趣,数字的前两位分别定义行数和列数,最后一位定义新加入子图的所处顺序,当然想写明确些也没问题,用逗号分开即可。。上面这段代码产生的图像如下:

    5.3.1 3D图表

    Matplotlib中也能支持一些基础的3D图表,比如曲面图,散点图和柱状图。这些3D图表需要使用mpl_toolkits模块,先来看一个简单的曲面图的例子:

     
     
     
     
     
     
    Python
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    import matplotlib.pyplot as plt
    import numpy as np
     
    # 3D图标必须的模块,project='3d'的定义
    from mpl_toolkits.mplot3d import Axes3D    
     
    np.random.seed(42)
     
    n_grids = 51         # x-y平面的格点数
    c = n_grids / 2     # 中心位置
    nf = 2               # 低频成分的个数
     
    # 生成格点
    x = np.linspace(0, 1, n_grids)
    y = np.linspace(0, 1, n_grids)
     
    # x和y是长度为n_grids的array
    # meshgrid会把x和y组合成n_grids*n_grids的array,X和Y对应位置就是所有格点的坐标
    X, Y = np.meshgrid(x, y)
     
    # 生成一个0值的傅里叶谱
    spectrum = np.zeros((n_grids, n_grids), dtype=np.complex)
     
    # 生成一段噪音,长度是(2*nf+1)**2/2
    noise = [np.complex(x, y) for x, y in np.random.uniform(-1,1,((2*nf+1)**2/2, 2))]
     
    # 傅里叶频谱的每一项和其共轭关于中心对称
    noisy_block = np.concatenate((noise, [0j], np.conjugate(noise[::-1])))
     
    # 将生成的频谱作为低频成分
    spectrum[c-nf:c+nf+1, c-nf:c+nf+1] = noisy_block.reshape((2*nf+1, 2*nf+1))
     
    # 进行反傅里叶变换
    Z = np.real(np.fft.ifft2(np.fft.ifftshift(spectrum)))
     
    # 创建图表
    fig = plt.figure('3D surface & wire')
     
    # 第一个子图,surface图
    ax = fig.add_subplot(1, 2, 1, projection='3d')
     
    # alpha定义透明度,cmap是color map
    # rstride和cstride是两个方向上的采样,越小越精细,lw是线宽
    ax.plot_surface(X, Y, Z, alpha=0.7, cmap='jet', rstride=1, cstride=1, lw=0)
     
    # 第二个子图,网线图
    ax = fig.add_subplot(1, 2, 2, projection='3d')
    ax.plot_wireframe(X, Y, Z, rstride=3, cstride=3, lw=0.5)
     
    plt.show()

    这个例子中先生成一个所有值均为0的复数array作为初始频谱,然后把频谱中央部分用随机生成,但同时共轭关于中心对称的子矩阵进行填充。这相当于只有低频成分的一个随机频谱。最后进行反傅里叶变换就得到一个随机波动的曲面,图像如下:

    3D的散点图也是常常用来查看空间样本分布的一种手段,并且画起来比表面图和网线图更加简单,来看例子:

     
     
     
     
     
    Python
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    import matplotlib.pyplot as plt
    import numpy as np
     
    from mpl_toolkits.mplot3d import Axes3D
     
    np.random.seed(42)
     
    # 采样个数500
    n_samples = 500
    dim = 3
     
    # 先生成一组3维正态分布数据,数据方向完全随机
    samples = np.random.multivariate_normal(
        np.zeros(dim),
        np.eye(dim),
        n_samples
    )
     
    # 通过把每个样本到原点距离和均匀分布吻合得到球体内均匀分布的样本
    for i in range(samples.shape[0]):
        r = np.power(np.random.random(), 1.0/3.0)
        samples[i] *= r / np.linalg.norm(samples[i])
     
    upper_samples = []
    lower_samples = []
     
    for x, y, z in samples:
        # 3x+2y-z=1作为判别平面
        if z > 3*x + 2*y - 1:
            upper_samples.append((x, y, z))
        else:
            lower_samples.append((x, y, z))
     
    fig = plt.figure('3D scatter plot')
    ax = fig.add_subplot(111, projection='3d')
     
    uppers = np.array(upper_samples)
    lowers = np.array(lower_samples)
     
    # 用不同颜色不同形状的图标表示平面上下的样本
    # 判别平面上半部分为红色圆点,下半部分为绿色三角
    ax.scatter(uppers[:, 0], uppers[:, 1], uppers[:, 2], c='r', marker='o')
    ax.scatter(lowers[:, 0], lowers[:, 1], lowers[:, 2], c='g', marker='^')
     
    plt.show()

    这个例子中,为了方便,直接先采样了一堆3维的正态分布样本,保证方向上的均匀性。然后归一化,让每个样本到原点的距离为1,相当于得到了一个均匀分布在球面上的样本。再接着把每个样本都乘上一个均匀分布随机数的开3次方,这样就得到了在球体内均匀分布的样本,最后根据判别平面3x+2y-z-1=0对平面两侧样本用不同的形状和颜色画出,图像如下:

    5.3.1 图像显示

    Matplotlib也支持图像的存取和显示,并且和OpenCV一类的接口比起来,对于一般的二维矩阵的可视化要方便很多,来看例子:

     
     
     
     
     
    Python
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    import matplotlib.pyplot as plt
     
    # 读取一张小白狗的照片并显示
    plt.figure('A Little White Dog')
    little_dog_img = plt.imread('little_white_dog.jpg')
    plt.imshow(little_dog_img)
     
    # Z是上小节生成的随机图案,img0就是Z,img1是Z做了个简单的变换
    img0 = Z
    img1 = 3*Z + 4
     
    # cmap指定为'gray'用来显示灰度图
    fig = plt.figure('Auto Normalized Visualization')
    ax0 = fig.add_subplot(121)
    ax0.imshow(img0, cmap='gray')
     
    ax1 = fig.add_subplot(122)
    ax1.imshow(img1, cmap='gray')
     
    plt.show()

    这段代码中第一个例子是读取一个本地图片并显示,第二个例子中直接把上小节中反傅里叶变换生成的矩阵作为图像拿过来,原图和经过乘以3再加4变换的图直接绘制了两个形状一样,但是值的范围不一样的图案。显示的时候imshow会自动进行归一化,把最亮的值显示为纯白,最暗的值显示为纯黑。这是一种非常方便的设定,尤其是查看深度学习中某个卷积层的响应图时。得到图像如下:

    只讲到了最基本和常用的图表及最简单的例子,更多有趣精美的例子可以在Matplotlib的官网找到:

    Thumbnail gallery – Matplotlib 1.5.3 documentation

     

    展开全文
  • 人工智能基础—Numpy科学计算

    千人学习 2019-09-17 15:04:11
    Numpy 是 Python 生态中最受欢迎的科学计算包,它所定义的数据组织结构,事实上已经成为所有数据处理模块、机器学习模块与2D/3D数据展示模块的标准数据结构了。本课程以 NumPy 为纲,穿插介绍了SciPy / Matplotlib /...
  • 科学计算应用随想

    2016-08-06 14:07:39
    科学计算及其应用

    如今科研活动的进行越来越依耐软件的科学计算功能,国内目前仍然是matlab汗牛充栋的阶段,其原因大概有以下两点:

    1、国内的大多数科研计算任务尚且比较小规模、简单,matlab的面向过程编程已经够用了;

    2、软件开发不是各行各业都能随便找人做的,软件工程的复杂性和专业性依然是让大多数行业从业人员望而生畏;


    但是依然有许多足够实力的科研团体(如中核集团)以及许多有志于开发开源应用的人自主开发;

    例一:运用python开源框架开发的集成计算绘图工具mathbox:


    例二:中核的metro风格的cosine系列套件:


    展开全文
  • Python科学计算PDF

    2018-12-19 14:17:00
    Python科学计算(高清版)PDF 百度网盘 链接:https://pan.baidu.com/s/1VYs9BamMhCnu4rfN6TG5bg 提取码:2zzk 复制这段内容后打开百度网盘手机App,操作更方便哦 内容简介 ······ 本书介绍如何用Python...

    Python科学计算(高清版)PDF

    百度网盘

    链接:https://pan.baidu.com/s/1VYs9BamMhCnu4rfN6TG5bg

    提取码:2zzk

    复制这段内容后打开百度网盘手机App,操作更方便哦

    内容简介  · · · · · ·

    本书介绍如何用Python开发科学计算的应用程序,除了介绍数值计算之外,还着重介绍如何制作交互式的2D、3D图像,如何设计精巧的程序界面,如何与C语言编写的高速计算程序结合,如何编写声音、图像处理算法等内容。书中涉及的Python扩展库包括NumPy、SciPy、SymPy、matplotlib、Traits、TraitsUI、Chaco、TVTK、Mayavi、VPython、OpenCV等,涉及的应用领域包括数值运算、符号运算、二维图表、三维数据可视化、三维动画演示、图像处理以及界面设计等。

    书中以大量实例引导读者逐步深入学习,每个实例程序都有详尽的解释,并都能在本书推荐的运行环境中正常运行。此外,本书附有大量的图表和插图,力求减少长篇的理论介绍和公式推导,以便读者通过实例和数据学习并掌握理论知识。

    作者简介  · · · · · ·

    张若愚,毕业于华中理工大学(现华中科技大学)通信工程专业,2004年获日本姬路工业大学(现兵库县立大学)硕士学位。毕业后于日本神户制钢综合研究所从事研究开发工作至今,研究方向为:嵌入式DSP信号处理系统开发,嵌入式MCU控制系统开发,工业控制软件开发,信号处理、数据处理以及生产系统的计算机模拟。在工作中他积极采用Python作为主要编程语言,在数据处理、信号分析、工业控制、算法模拟等领域取得了较好的研究成果。已完成的研究课题有:嵌入式声音分离系统、车载音响设备、超声波探伤系统、压缩机系统的数字模拟等。

     

    转载于:https://www.cnblogs.com/wori/p/10142945.html

    展开全文
  • python 科学计算

    千次阅读 2014-03-18 23:54:49
    分享一个介绍科学计算的pdf。
  • python科学计算

    千次阅读 2016-05-12 14:27:37
    1 软件包的安装和介绍 1.1 安装软件包 1.1.1 安装 和Matlab不同,Python的科学软件包由众多的社区维护和发布,因此要一一将其收集齐安装到你...这里介绍两个科学计算Python合集的下载和安装过程。 Python(x,y)
  • 科学计算可视化

    千次阅读 2017-12-06 14:10:05
    Python科学计算三维可视化奖学金 黄天羽、嵩天 科学计算可视化分类 ​信息可视化(信息、知识) 科学可视化(空间数据) 主要方法二维标量数据场 颜色映射法 等值线法 立体图法 层次分割法 三维标量数据场 面绘制...
  • Python科学计算pdf

    2017-08-25 17:55:00
    本书介绍如何用Python开发科学计算的应用程序,除了介绍数值计算之外,还着重介绍如何制作交互式的2D、3D图像,如何设计精巧的程序界面,如何与C语言编写的高速计算程序结合,如何编写声音、图像处理算法等内容。...
  • 科学计算即是数值计算,科学计算是指应用计算机处理科学研究和工程技术中所遇到的数学计算。在现代科学和工程技术中,经常会遇到大量复杂的数学计算问题,这些问题用一般的计算工具来解决非常困难,而用计算机来处理...
  • 科学计算 | Matlab 使用 GPU 并行计算

    千次阅读 2017-03-02 16:22:00
    科学计算 | Matlab 使用 GPU 并行计算 本文转载自: https://sanwen8.cn/p/14bJc10.html Matlab下直接使用GPU并行计算(预告)<--这预告也贴出来太久了,然而我的大论文还是没有写完,但是自己...
  • 分布式科学计算与docker

    千次阅读 2017-12-29 15:15:41
    Docker和科学计算的结合, 其主要优势在于快速部署和计算资源的统一管理. 相对比较轻. 且对环境要求不高. 老旧机器, 新机器, 都可以加入到计算集群. 以实现资源的最大化利用.
  • 《C#科学计算讲义》高清PDF版本

    热门讨论 2012-09-03 18:16:28
    《C#科学计算讲义》高清PDF版本,与《Fortran95/2003科学计算与工程》为平行版本
  • python科学计算代码详解

    千次阅读 2018-03-22 17:29:37
    python科学计算代码详解chtx 链接:https://pan.baidu.com/s/1eTspyGgJGirxsglhfmqd9g
  • scipy: 科学计算

    万次阅读 2014-04-09 19:13:22
    Scipy:高端科学计算 作者:Adrien Chauve, Andre Espaze, Emmanuelle Gouillart, Gaël Varoquaux, Ralf Gommers 翻译自:scipy lecture notes 译者表示最后部分没怎么看懂,此文档维护中…… Scipy ...
  • 收集的Java科学计算

    万次阅读 2017-01-05 18:28:56
    科学计算框架 Catalano http://www.oschina.NET/p/catalano Catalano Framework 是一个 Java 和 Android 的科学计算框架。 主要计算功能: 图像处理 模糊逻辑 数学计算 统计 机器学习
  • 用Python 做科学计算

    2016-04-16 14:45:52
    在学习Python科学计算的过程中,找到了一个非常好的网站 网站链接: 用Python做科学计算 里面的内容是以Python2.7为工作环境下实现的,具体内容有: 基础篇 手册篇 实战篇 附录 源程序集
  • numpy是python基本常用的科学计算库,在数据分析,机器学习,深度学习等领域经常被使用,可以说是学习python的一个库。本课程会讲解到numpy中核心的一些知识点,包括numpy的属性,创建array,numpy的运算,矩阵运算...
  • Python 科学计算基础 (整理)

    千次阅读 2016-07-29 09:35:04
    python 科学计算
  • Python学习_科学计算

    千次阅读 2016-11-07 20:03:14
    Python科学计算一、Numpy1、Numpy特征和导入 (1)用于多维数组的第三方Python包 (2)更接近于底层和硬件 (高效) (3)专注于科学计算 (方便) (4)导入包:import numpy as np 2、list转为数组 (1)a = np.array...
  • python科学计算之anaconda

    千次阅读 2017-01-11 14:46:09
    简介  利用python进行科学计算需要安装很多模块,如numpy、scipy、pandas、matplotlib等,而这些模块又依赖其他的软件包或库,因而安装使用起来相当麻烦。本文介绍的anaconda是将python科学计算所需要的模块都编译...
  • python科学计算

    千次阅读 2013-08-27 15:16:17
    Python是一门很强大的语言...有了它,很多科学计算都能方便地直接调用,如滤波,解线性方程(从某种角度看,基本上所有科学计算问题都可以归结为解线性方程组,斯坦福的大牛Boyd说的哈),求特征值,图像插值等。库的地
  • Python 初步了解科学计算和数据分析

    千次阅读 2020-01-12 18:00:19
    Python科学计算和数据分析库(例如NumPy、SciPy、Pandas、MatPlotlib、IPython等)简介;使用IPython Notebook进行科学计算;Python在线性代数中的应用
  • 前言 由于python极高的开源性,...如果你的项目中需要用到 pandas,numpy,sklearn等科学计算的库 推荐 使用 pycharm + anaconda 1、pycharm 下载地址 2、anaconda 下载地址 3、pycharm配置anaconda的工具包...
  • gsl是GNU的一个开源科学计算库,c语言的。不过感觉使用人群小了点,最近一次更新是在2011年。GNU的项目有好多是费了的,纯粹的开源不寻求商业途径很难撑下去。 下面是项目主页: 项目主页 这里可以下载到源码和...
  • 用python来玩科学计算

    千次阅读 2016-10-16 20:59:55
    用python来玩科学计算(准备工作)个人来说很喜欢python的语言,但其实python本身并不适合做科学计算:首先作为动态脚本语言,其运行效率本来就低;其次占用内存也太大,下一篇介绍的一个简单的.py程序运行起来就占用...
  • Python科学计算初探——余弦相似度

    万次阅读 2018-04-25 20:09:35
    SciPy是世界上著名的Python开源科学计算库,建立在Numpy之上。它增加的功能包括数值积分、最优化、统计和一些专用函数。例如线性代数、常微分方程数值求解、信号处理、图像处理、稀疏矩阵等等。 安装科学计算包...
  • 最近重装Python,看了一下Python科学计算发行版,打算多玩一下数据处理和数值计算。 Python用于科学计算的一些常用工具和库 IPython-增强的交互环境:支持变量自动补全,自动缩进,支持 bash shell命令,内置...
  • 科学计算的特点

    千次阅读 2011-01-13 11:07:00
    本人不敢从系统科学上讨论科学计算,本人只是想要讨论下对大部分工程计算都需要的科学计算科学计算几乎都是过程式的,即从输入到输出,中间几乎不需要交互。参数设置都是一步到位,中间计算过程一刻...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 63,294
精华内容 25,317
关键字:

科学计算