Python中Numpy及Matplotlib使用

1. Jupyter Notebooks

作为小白，我现在使用的python编辑器是 Jupyter Notebook,非常的好用，推荐！！！
你可以按 [Ctrl] + [Enter]快捷键或按菜单中的 运行按钮来运行单元格。

在 function(后面按 [shift] + [tab]，可以获得函数或对象的帮助。

你还可以通过执行 function?获得帮助。

2. NumPy 数组

操作 numpy数组是 Python 机器学习（或者，实际上是任何类型的科学计算）的重要部分。 在这里我主要快速介绍一下重要基本的功能。

import numpy as np

# 设置随机种子来获得可重复性
rnd = np.random.RandomState(seed=520)

# 生成随机数组
# Array: shape(3, 5);
#        value: [0, 1]
X = rnd.uniform(low=0.0, high=1.0, size=(3, 5))

print(X)

（请注意，NumPy 数组也是从 0 开始的索引）

# 元素访问

# 获取单个元素
# （这里是第一行第一列的元素）
print(X[0, 0])

# 获取一行
# （这里是第二行）
print(X[1])

# 获取一列
# （这里是第二列）
print(X[:, 1])

# 数组转置
print(X.T)

# 创建均匀间隔的数字的行向量。
y = np.linspace(0, 12, 5) # 从0开始，到12结束，数量为5
print(y)

# 将行向量转换为列向量
print(y[:, np.newaxis])

# 获得形状或改变数组形状

# 生成随机数组
rnd = np.random.RandomState(seed=520)
X = rnd.uniform(low=0.0, high=1.0, size=(3, 5))

# X的大小（3，5）
print(X.shape)

# 将 X 大小变为 (5,3)
X_reshaped = X.reshape(5, 3)
print(X_reshaped)

# 使用整数数组的索引（花式索引）
indices = np.array([3, 1, 0])
print(indices)
# 取X的第4，2，1列作为新数组
X[:, indices]

3. SciPy 稀疏数组

虽然我们平时不会大量使用它们，但稀疏矩阵在某些情况下非常好用。 在一些机器学习任务中，尤其是与文本分析相关的任务，数据可能大多为零。 存储所有这些零是非常低效的，并且以仅包含"非零"值的方式表示可以更有效。 我们可以创建和操作稀疏矩阵，如下所示：

# 创建一个包含大量零的随机数组
rnd = np.random.RandomState(seed=123)

X = rnd.uniform(low=0.0, high=1.0, size=(10, 5))
print(X)

# 将大多数元素设置为零
X[X < 0.7] = 0
print(X)

from scipy import sparse
# 将 X 转换为 CSR（压缩稀疏行）矩阵
X_csr = sparse.csr_matrix(X)
print(X_csr)

# 将稀疏矩阵转换为密集数组
print(X_csr.toarray())

（你可能偶然发现了一种将稀疏表示转换为密集表示的替代方法： numpy.todense； toarray返回一个 NumPy 数组，而 todense返回一个 NumPy 矩阵。在本教程中，我们将使用 NumPy 数组，而不是矩阵；scikit-learn 不支持后者。）

CSR 表示对于计算非常有效，但它不适合添加元素。 为此，LIL（List-In-List）表示更好：

# 创建一个空的 LIL 矩阵并添加一些项目
X_lil = sparse.lil_matrix((5, 5))

for i, j in np.random.randint(0, 5, (15, 2)):
    X_lil[i, j] = i + j

print(X_lil)
print(type(X_lil))

X_dense = X_lil.toarray()
print(X_dense)
print(type(X_dense))

通常，一旦创建了 LIL 矩阵，将其转换为 CSR 格式很有用（许多 scikit-learn 算法需要 CSR 或 CSC 格式）

X_csr = X_lil.tocsr()
print(X_csr)
print(type(X_csr))

可用于各种问题的可用稀疏格式包括：

• CSR（压缩稀疏行）
• CSC（压缩稀疏列）
• BSR（块稀疏行）
• COO（坐标）
• DIA（对角线）
• DOK（键的字典）
• LIL（列表中的列表）

scipy.sparse子模块还有很多稀疏矩阵的函数，包括线性代数，稀疏求解器，图算法等等。

4. Matplotlib

机器学习的另一个重要部分是数据可视化。 Python 中最常用的工具是matplotlib。 这是一个非常灵活的包，我们将在这里介绍一些基础知识。

由于使用的是 Jupyter，所以使用 IPython 方便的内置"魔术函数"，即" matoplotlib内联"模式，它将直接在笔记本内部绘制图形。

%matplotlib inline

import matplotlib.pyplot as plt

# 绘制直线
x = np.linspace(0, 10, 100)
plt.plot(x, np.sin(x));

# 散点图
x = np.random.normal(size=500)
y = np.random.normal(size=500)
plt.scatter(x, y);

# 使用 imshow 展示绘图
# - note that origin is at the top-left by default!

x = np.linspace(1, 12, 100)
y = x[:, np.newaxis]

im = y * np.sin(x) * np.cos(y)
print(im.shape)

plt.imshow(im);

# 轮廓图
# - 请注意，此处的原点默认位于左下角！
plt.contour(im);

# 3D 绘图
from mpl_toolkits.mplot3d import Axes3D
ax = plt.axes(projection='3d')
xgrid, ygrid = np.meshgrid(x, y.ravel())
ax.plot_surface(xgrid, ygrid, im, cmap=plt.cm.viridis, cstride=2, rstride=2, linewidth=0);

有许多可用的绘图类型。 查看matplotlib库是一个很快的学习方法。

Original: https://www.cnblogs.com/HandsomeToDeath/p/15493693.html
Author: HandsomeToDeath
Title: Python中Numpy及Matplotlib使用

相关阅读

Title: 如何固定你的代码，只使用命令行来调参实验——argparse使用方法

argparse是深度学习项目调参时常用的python标准库，使用argparse后，我们在命令行输入的参数就可以以这种形式 python filename.py --lr 1e-4 --batch_size 32来完成对常见超参数的设置。，一般使用时可以归纳为以下三个步骤

使用步骤：

• 创建 ArgumentParser()对象
• 调用 add_argument()方法添加参数
• 使用 parse_args()解析参数 在接下来的内容中，我们将以实际操作来学习argparse的使用方法

import argparse

parser = argparse.ArgumentParser() # 创建一个解析对象

parser.add_argument() # 向该对象中添加你要关注的命令行参数和选项

args = parser.parse_args() # 调用parse_args()方法进行解析

常见规则

• 在命令行中输入 python demo.py -h或者 python demo.py --help可以查看该python文件参数说明
• arg字典类似python字典，比如arg字典 Namespace(integers='5')可使用 arg.参数名来提取这个参数
• parser.add_argument('integers', type=str, nargs='+',help='传入的数字') nargs是用来说明传入的参数个数， '+' 表示传入至少一个参数，'*' 表示参数可设置零个或多个，'?' 表示参数可设置零个或一个
• parser.add_argument('-n', '--name', type=str, required=True, default='', help='名') required=True表示必须参数, -n表示可以使用短选项使用该参数
• parser.add_argument("--test_action", default='False', action='store_true')store_true 触发时为真，不触发则为假（ test.py，输出为 False ， test.py --test_action，输出为 True）

使用config文件传入超参数

为了使代码更加简洁和模块化，可以将有关超参数的操作写在 config.py，然后在 train.py或者其他文件导入就可以。具体的 config.py可以参考如下内容。

import argparse

def get_options(parser=argparse.ArgumentParser()):

    parser.add_argument('--workers', type=int, default=0,
                        help='number of data loading workers, you had better put it '
                              '4 times of your gpu')

    parser.add_argument('--batch_size', type=int, default=4, help='input batch size, default=64')

    parser.add_argument('--niter', type=int, default=10, help='number of epochs to train for, default=10')

    parser.add_argument('--lr', type=float, default=3e-5, help='select the learning rate, default=1e-3')

    parser.add_argument('--seed', type=int, default=118, help="random seed")

    parser.add_argument('--cuda', action='store_true', default=True, help='enables cuda')
    parser.add_argument('--checkpoint_path',type=str,default='',
                        help='Path to load a previous trained model if not empty (default empty)')
    parser.add_argument('--output',action='store_true',default=True,help="shows output")

    opt = parser.parse_args()

    if opt.output:
        print(f'num_workers: {opt.workers}')
        print(f'batch_size: {opt.batch_size}')
        print(f'epochs (niters) : {opt.niter}')
        print(f'learning rate : {opt.lr}')
        print(f'manual_seed: {opt.seed}')
        print(f'cuda enable: {opt.cuda}')
        print(f'checkpoint_path: {opt.checkpoint_path}')

    return opt

if __name__ == '__main__':
    opt = get_options()

$ python config.py

num_workers: 0
batch_size: 4
epochs (niters) : 10
learning rate : 3e-05
manual_seed: 118
cuda enable: True
checkpoint_path:

随后在 train.py等其他文件，我们就可以使用下面的这样的结构来调用参数。

# 导入必要库
...

import config

opt = config.get_options()

manual_seed = opt.seed
num_workers = opt.workers
batch_size = opt.batch_size
lr = opt.lr
niters = opt.niters
checkpoint_path = opt.checkpoint_path

# 随机数的设置，保证复现结果
def set_seed(seed):
    torch.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
    random.seed(seed)
    np.random.seed(seed)
    torch.backends.cudnn.benchmark = False
    torch.backends.cudnn.deterministic = True

...

if __name__ == '__main__':
  set_seed(manual_seed)
  for epoch in range(niters):
    train(model,lr,batch_size,num_workers,checkpoint_path)
    val(model,lr,batch_size,num_workers,checkpoint_path)

参考：

Original: https://www.cnblogs.com/qftie/p/16319150.html
Author: MapleTx
Title: 如何固定你的代码，只使用命令行来调参实验——argparse使用方法