Hsinyan写字的地方 - 基础
type: channel
link: https://www.hsinyan.cn/index.php/category/%E5%9F%BA%E7%A1%80/
items: D2L学习笔记03：从零实现一个线性回归
items: D2L学习笔记02：线性回归
items: D2L学习笔记01：线性代数
items: D2L学习笔记00：Pytorch操作
items: 测试集的分类准确率
items: 数据集的分割
items: Numpy入门笔记2
items: Numpy入门笔记1
items: Jupyter Notebook开荒笔记

D2L学习笔记03：从零实现一个线性回归
type: item
date: 2022-04-30T15:06:07+08:00
description: 接下来将从零开始实现线性回归整个方法，包括数据流水线、模型、损失函数和小批量随机梯度下降优化器。虽然现代的深度学习框架几乎可以自动化地进行所有这些工作，但从零开始实现可以确保你真正知道自己在做什么。同时，了解更细致的工作原理将方便我们自定义模型、自定义层或自定义损失函数。在这一节中，我们将只使用张量和自动求导。%matplotlib inline import random import torch from d2l import torch as d2l生成数据集为了简单起见，将根据带有噪声的线性模型构造一个人造数据集，我们的任务是使用这个有限样本的数据集来恢复这个模型的参数。我们将使用低维数据，这样可以很容易地将其可视化。在下面的代码中，我们生成一个包含1000个样本的数据集，每个样本包含从标准正态分布中采样的2个特征。我们的合成数据集是一个矩阵$\textbf{X}\in \textbf{R}^{1000 \times 2}$。使用线性模型参数$\textbf{w} = [2, -3.4]^\top$、$b = 4.2$和噪声项$\epsilon$生成数据集及其标签：$$ \textbf{y}= \textbf{X} \textbf{w} + b + \epsilon. $$可以将$\epsilon$视为模型预测和标签时的潜在观测误差，在这里我们认为标准假设成立，即$\epsilon$服从均值为0的正态分布。为了简化问题，将标准差设为0.01，下面的代码生成合成数据集。def synthetic_data(w, b, num_examples): #@save """生成y=Xw+b+噪声""" X = torch.normal(0, 1, (num_examples, len(w))) y = torch.matmul(X, w) + b y += torch.normal(0, 0.01, y.shape) return X, y.reshape((-1, 1))true_w = torch.tensor([2, -3.4]) true_b = 4.2 features, labels = synthetic_data(true_w, true_b, 1000) print('features:', features[0],'\nlabel:', labels[0]) #features: tensor([-0.0575, 0.6582]) #label: tensor([1.8422])画出散点图可以看出两者之间的线性关系d2l.set_figsize() d2l.plt.scatter(features[:, (1)].detach().numpy(), labels.detach().numpy(), 1);读取数据集训练模型时要对数据集进行遍历，每次抽取一小批量样本，并使用它们来更新我们的模型。 由于这个过程是训练机器学习算法的基础，所以有必要定义一个函数， 该函数能打乱数据集中的样本并以小批量方式获取数据。在下面的代码中，定义一个data_iter函数， 该函数接收批量大小、特征矩阵和标签向量作为输入，生成大小为batch_size的小批量。 每个小批量包含一组特征和标签。def data_iter(batch_size, features, labels): num_examples = len(features) indices = list(range(num_examples)) # 这些样本是随机读取的，没有特定的顺序 random.shuffle(indices) for i in range(0, num_examples, batch_size): batch_indices = torch.tensor( indices[i: min(i + batch_size, num_examples)]) yield features[batch_indices], labels[batch_indices]通常，利用GPU并行运算的优势，处理合理大小的“小批量”。 每个样本都可以并行地进行模型计算，且每个样本损失函数的梯度也可以被并行计算。 GPU可以在处理几百个样本时，所花费的时间不比处理一个样本时多太多。直观感受一下小批量运算：读取第一个小批量数据样本并打印。 每个批量的特征维度显示批量大小和输入特征数。 同样的，批量的标签形状与batch_size相等。batch_size = 10 for X, y in data_iter(batch_size, features, labels): print(X, '\n', y) break #tensor([[ 0.9458, -0.0361]…

D2L学习笔记02：线性回归
type: item
date: 2022-04-28T20:26:00+08:00
description: 回归（regression）是能为一个或多个自变量与因变量之间关系建模的一类方法。在自然科学和社会科学领域，回归经常用来表示输入和输出之间的关系。在机器学习领域中的大多数任务通常都与预测（prediction）有关。当我们想预测一个数值时，就会涉及到回归问题。常见的例子包括：预测价格（房屋、股票等）、预测住院时间（针对住院病人等）、预测需求（零售销量等）。线性回归的基本元素线性回归（linear regression）可以追溯到19世纪初，它在回归的各种标准工具中最简单而且最流行。线性回归基于几个简单的假设：首先，假设自变量$x$和因变量$y$之间的关系是线性的，即$y$可以表示为$x$中元素的加权和，这里通常允许包含观测值的一些噪声；其次，我们假设任何噪声都比较正常，如噪声遵循正态分布。为了解释线性回归，举一个实际的例子：我们希望根据房屋的面积（平方英尺）和房龄（年）来估算房屋价格（美元）。为了开发一个能预测房价的模型，我们需要收集一个真实的数据集。这个数据集包括了房屋的销售价格、面积和房龄。在机器学习的术语中，该数据集称为训练数据集（training data set）或训练集（training set）。每行数据（比如一次房屋交易相对应的数据）称为样本（sample），也可以称为数据点（data point）或数据样本（data instance）。我们把试图预测的目标（比如预测房屋价格）称为标签（label）或目标（target）。预测所依据的自变量（面积和房龄）称为特征（feature）或协变量（covariate）。通常，我们使用$n$来表示数据集中的样本数，对索引为$i$的样本，其输入表示为$\textbf{x}^{(i)} = [x_1^{(i)}, x_2^{(i)}]^\top$，其对应的标签是$y^{(i)}$。线性模型线性假设是指目标（房屋价格）可以表示为特征（面积和房龄）的加权和，如下面的式子：$$ \textbf{price} = w_{\textbf{area}} \cdot \textbf{area} + w_{\textbf{age}} \cdot \textbf{age} + b. $$其中中的$w_{area}$和$w_{age}$称为权重（weight），权重决定了每个特征对我们预测值的影响，$b$称为偏置（bias）、偏移量（offset）或截距（intercept）。偏置是指当所有特征都取值为0时，预测值应该为多少。即使现实中不会有任何房子的面积是0或房龄正好是0年，我们仍然需要偏置项。如果没有偏置项，我们模型的表达能力将受到限制。严格来说，是输入特征的一个仿射变换（affine transformation）。仿射变换的特点是通过加权和对特征进行线性变换（linear transformation），并通过偏置项来进行平移（translation）。给定一个数据集，我们的目标是寻找模型的权重$\textbf{w}$和偏置$b$，使得根据模型做出的预测大体符合数据里的真实价格。输出的预测值由输入特征通过线性模型的仿射变换决定，仿射变换由所选权重和偏置确定。而在机器学习领域，我们通常使用的是高维数据集，建模时采用线性代数表示法会比较方便。当我们的输入包含$d$个特征时，我们将预测结果$\hat{y}$（通常使用“尖角”符号表示$y$的估计值）表示为：$$ \hat{y} = w_1 x_1 + ... + w_d x_d + b. $$将所有特征放到向量$\textbf{x} \in \mathbb{R}^d$中，并将所有权重放到向量$\textbf{w} \in \mathbb{R}^d$中，我们可以用点积形式来简洁地表达模型：$$ \hat{y} = \textbf{w}^\top \textbf{x} + b. $$向量$\textbf{x}$对应于单个数据样本的特征。用符号表示的矩阵$\textbf{X} \in \mathbb{R}^{n \times d}$可以很方便地引用我们整个数据集的$n$个样本。其中，$\textbf{X}$的每一行是一个样本，每一列是一种特征。对于特征集合$\textbf{X}$，预测值$\hat{\textbf{y}} \in \mathbb{R}^n$可以通过矩阵-向量乘法表示为：${\hat{\textbf{y}}} = \textbf{X} \textbf{w} + b$这个过程中的求和将使用广播机制，给定训练数据特征$\textbf{X}$和对应的已知标签$\textbf{y}$，线性回归的目标是找到一组权重向量$\textbf{w}$和偏置$b$：当给定从$\textbf{X}$的同分布中取样的新样本特征时，这组权重向量和偏置能够使得新…

D2L学习笔记01：线性代数
type: item
date: 2022-04-24T21:51:00+08:00
description: 这里略去了课程中部分线性代数基础笔记，只记录了自己理解得不够深刻的部分张量算法的基本性质标量、向量、矩阵和任意数量轴的张量（本小节中的“张量”指代数对象）有一些实用的属性。例如，你可能已经从按元素操作的定义中注意到，任何按元素的一元运算都不会改变其操作数的形状。同样，给定具有相同形状的任意两个张量，任何按元素二元运算的结果都将是相同形状的张量。例如，将两个相同形状的矩阵相加，会在这两个矩阵上执行元素加法。A = torch.arange(20, dtype=torch.float32).reshape(5, 4) B = A.clone() # 通过分配新内存，将A的一个副本分配给B A, A + B #(tensor([[ 0., 1., 2., 3.], # [ 4., 5., 6., 7.], # [ 8., 9., 10., 11.], # [12., 13., 14., 15.], # [16., 17., 18., 19.]]), # tensor([[ 0., 2., 4., 6.], # [ 8., 10., 12., 14.], # [16., 18., 20., 22.], # [24., 26., 28., 30.], # [32., 34., 36., 38.]]))具体而言，两个矩阵的按元素乘法称为Hadamard积（Hadamard product）（数学符号$\odot$）。对于矩阵$\textbf{B} \in \textbf{R}^{m \times n}$，其中第$i$行和第$j$列的元素是$b_{ij}$。矩阵$\textbf{A}$和$\textbf{B}$的Hadamard积为：$$ \textbf{A} \odot \textbf{B} = \begin{bmatrix} a_{11} b_{11} & a_{12} b_{12} & \dots & a_{1n} b_{1n} \\ a_{21} b_{21} & a_{22} b_{22} & \dots & a_{2n} b_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m1} b_{m1} & a_{m2} b_{m2} & \dots & a_{mn} b_{mn} \end{bmatrix}. $$A * B # tensor([[ 0., 1., 4., 9.], # [ 16., 25., 36., 49.], # [ 64., 81., 100., 121.], # [144., 169., 196., 225.], # [256., 289., 324., 361.]])将张量乘以或加上一个标量不会改变张量的形状，其中张量的每个元素都将与标量相加或相乘。a = 2 X = torch.arange(24).reshape(2, 3, 4) a + X, (a * X).shape #(tensor([[[ 2, 3, 4, 5], # [ 6, 7, 8, 9], # [10, 11, 12, 13]], # # [[14, 15, 16, 17], # [18, 19, 20, 21], # [22, 23, 24, 25]]]), # torch.Size([2, 3, 4]))降维我们可以对任意张量进行的一个有用的操作是计算其元素的和。在数学表示法中，我们使用$\sum$符号表示求和。为了表示长度为$d$的向量中元素的总和，可以记为$\sum_{i=1}^dx_i$。在代码中，我们可以调用计算求和的函数：x = torch.arange(4, dtype=torch.float32) x, x.sum() # (tensor([0., 1., 2., 3.]), tensor(6.))我们可以表示任意形状张量的元素和。例如，矩阵$\textbf{A}$中元素的和可以记为$\sum_{i=1}^{m} \sum_{j=1}^{n} a_{ij}$。A.shape, A.sum() # (torch.Size([5, 4]), tensor(190.))默认情况下，调用求和函数会沿所有的轴降低张量的维度，使它变为一个标量。我们还可以指定张量沿哪一个轴来通过求和降低维度。以矩阵为例，为了通过求和所有行的元素来降维（轴0），我们可以在调用函数时指定axis=0。由于输入矩阵沿0轴降维以生成输出向量，因此输入轴0的维数在输出形状中消失。A # tensor([[ 0., 1., 2., 3.], # [ 4., 5., 6., 7.], # [ 8., 9., 10., 11.], # [12., 13., 14., 15.], # [16., 17., 18., 19…

D2L学习笔记00：Pytorch操作
type: item
date: 2022-04-24T21:50:30+08:00
description: 导入包import torch虽然被称为Pytorch，但是代码中使用torch张量张量表示由一个数值组成的数组，这个数组可能有多个维度。具有一个轴的张量对应数学上的向量（vector）；具有两个轴的张量对应数学上的矩阵（matrix）；具有两个轴以上的张量没有特殊的数学名称。可以使用 arange 创建一个行向量 x。这个行向量包含以0开始的前12个整数，它们默认创建为整数。也可指定创建类型为浮点数。张量中的每个值都称为张量的 元素（element）。例如，张量 x 中有 12 个元素。除非额外指定，新的张量将存储在内存中，并采用基于CPU的计算。x = torch.arange(12) x # tensor([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) # 可以通过张量的shape属性来访问张量（沿每个轴的长度）的形状 x.shape # torch.Size([12]) x.numel() # 12要想改变一个张量的形状而不改变元素数量和元素值，可以调用reshape函数。我们不需要通过手动指定每个维度来改变形状。 也就是说，如果我们的目标形状是（高度,宽度）， 那么在知道宽度后，高度会被自动计算得出，不必我们自己做除法。 在上面的例子中，为了获得一个3行的矩阵，我们手动指定了它有3行和4列。 幸运的是，我们可以通过-1来调用此自动计算出维度的功能。 即我们可以用x.reshape(-1,4)或x.reshape(3,-1)来取代x.reshape(3,4)。X = x.reshape(3, 4) X # tensor([[ 0, 1, 2, 3], # [ 4, 5, 6, 7], # [ 8, 9, 10, 11]]) X.reshape(2,-1) # tensor([[ 0, 1, 2, 3, 4, 5], # [ 6, 7, 8, 9, 10, 11]])有时，我们希望使用全0、全1、其他常量，或者从特定分布中随机采样的数字来初始化矩阵。# 创建一个形状为（2,3,4）的张量，其中所有元素都设置为0 torch.zeros((2, 3, 4)) # tensor([[[0., 0., 0., 0.], # [0., 0., 0., 0.], # [0., 0., 0., 0.]], # # [[0., 0., 0., 0.], # [0., 0., 0., 0.], # [0., 0., 0., 0.]]]) # 同理，所有元素设置为1 torch.ones((2, 3, 4)) # tensor([[[1., 1., 1., 1.], # [1., 1., 1., 1.], # [1., 1., 1., 1.]], # # [[1., 1., 1., 1.], # [1., 1., 1., 1.], # [1., 1., 1., 1.]]]) # 创建一个形状为（3,4）的张量。 其中的每个元素都从均值为0、标准差为1的标准高斯分布（正态分布）中随机采样。 torch.randn(3, 4) # tensor([[ 1.1704, -0.4649, -1.1481, -2.0655], # [-0.1964, 0.3888, 0.2516, -0.5367], # [-0.3829, -0.0578, 0.8739, -1.4293]])还可以用Python的嵌套数组来为所需张量中每个元素赋予确定值torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]]) # tensor([[2, 1, 4, 3], # [1, 2, 3, 4], # [4, 3, 2, 1]])运算符x = torch.tensor([1.0, 2, 4, 8]) y = torch.tensor([2, 2, 2, 2]) x + y, x - y, x * y, x / y, x ** y # **运算符是求幂运算 # (tensor([ 3., 4., 6., 10.]), # tensor([-1., 0., 2., 6.]), # tensor([ 2., 4., 8., 16.]), # tensor([0.5000, 1.0000, 2.0000, 4.0000]), # tensor([ 1., 4., 16., 64.])) torch.exp(x) # tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])也可以把多个张量连结（concatenate）在一起，把它们端对端地叠起来形成一个更大的张量。只需要提供张量列表，并给出沿哪个轴连结。下面的例子分别演示了当沿行（轴-0…

测试集的分类准确率
type: item
date: 2020-03-28T01:25:00+08:00
description: 导入测试数据集这里使用的是手写体数字识别的数据import numpy as np import matplotlib.pyplot as plt import matplotlib from sklearn import datasets digits = datasets.load_digits() digits.keys() # dict_keys(['data', 'target', 'target_names', 'images', 'DESCR']) X = digits.data X.shape # (1797, 64) y = digits.target y.shape # (1797,) digits.target_names # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) # 可以看到这个数据集是乱序的，所以可以不进行打乱操作 y[:100] # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, # 2, 3, 4, 5, 6, 7, 8, 9, 0, 9, 5, 5, 6, 5, 0, 9, 8, 9, 8, 4, 1, 7, # 7, 3, 5, 1, 0, 0, 2, 2, 7, 8, 2, 0, 1, 2, 6, 3, 3, 7, 3, 3, 4, 6, # 6, 6, 4, 9, 1, 5, 0, 9, 5, 2, 8, 2, 0, 0, 1, 7, 6, 3, 2, 1, 7, 4, # 6, 3, 1, 3, 9, 1, 7, 6, 8, 4, 3, 1]) # 查看一下第666个数据 some_digit = X[666] y[666] # 0 # 将这张图打印出来 some_digit_image = some_digit.reshape(8,8) plt.imshow(some_digit_image,cmap=matplotlib.cm.binary) plt.show()可以看到这是数字0，之后我们使用自己封装的函数对数据集进行测试使用kNN算法进行测试# 以下两个都是自己封装的函数 from model_selection import train_test_split from kNN import KNNClassifier X_train,X_test,y_train,y_test = train_test_split(X,y,test_ratio = 0.2) my_knn_clf = KNNClassifier(k=3) my_knn_clf.fit(X_train,y_train) y_predict= my_knn_clf.predict(X_test) # 计算准确率 sum(y_predict == y_test) / len(y_test) # 0.9916434540389972使用上述过程即可使用kNN算法(k取3)，且对测试集进行预测的准确率达到99.16%以上封装自己的准确率函数def accuracy_score(y_true, y_predict): """计算y_true和y_predict之间的准确率""" assert len(y_true) == len(y_predict), \ "the size of y_true must be equal to the size of y_predict" return np.sum(y_true == y_predict) / len(y_true)测试一下from metrics import accuracy_score accuracy_score(y_test,y_predict) # 0.9916434540389972使用scikit-learn封装的accuracy_scorescikit-learn中也为我们封装好了计算准确率的函数，可以直接调用from sklearn.model_selection import train_test_split from sklearn.neighbors import KNeighborsClassifier from sklearn.metrics import accuracy_score # 得到训练集和测试集 X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = 0.2, random_state = 666) # 得到knn分类器 knn_clf = KNeighborsClassifier(n_neighbors=3) knn_c…

数据集的分割
type: item
date: 2020-03-28T00:59:00+08:00
description: 导入测试数据集这里使用scikit-learn自带的鸢尾花数据import numpy as np import matplotlib.pyplot as plt from sklearn import datasets iris = datasets.load_iris() X = iris.data y = iris.target X.shape # (150, 4) y.shape # (150,)实现查看y的时候发现，发现lable是按照从小到大进行排序的，所以取训练集不能直接取前n个为训练集，后n个为测试集，这样得到的模型肯定是不准确的。这个时候可以使用permutation方法，获取到随机打乱的一组索引，之后自定义训练集和测试集的比例，这里设置测试集的比例为0.2，使用numpy的fancy indexing就可以切割得到完全随机的训练集和测试集。# 获取随机打乱的索引 shuffle_indexes = np.random.permutation(len(X)) # array([106, 61, 127, 139, 128, 0, 108, 142, 92, 20, 113, 17, 11, # 88, 140, 116, 18, 89, 104, 57, 38, 135, 131, 99, 133, 66, # 40, 121, 86, 93, 134, 145, 39, 52, 98, 50, 90, 24, 51, # 2, 120, 55, 75, 107, 67, 59, 36, 80, 119, 82, 143, 69, # 137, 81, 14, 19, 64, 65, 28, 60, 77, 7, 105, 47, 83, # 138, 109, 3, 71, 63, 31, 44, 102, 43, 146, 122, 110, 21, # 79, 29, 12, 53, 136, 148, 58, 149, 42, 114, 41, 97, 4, # 118, 85, 26, 96, 94, 48, 45, 8, 103, 16, 101, 130, 54, # 91, 27, 9, 132, 129, 23, 95, 78, 124, 74, 46, 25, 62, # 30, 6, 117, 115, 33, 111, 15, 76, 112, 72, 68, 5, 56, # 49, 144, 125, 37, 32, 13, 70, 84, 10, 1, 123, 100, 22, # 34, 147, 35, 73, 141, 126, 87]) # 设置测试集比例 test_ratio = 0.2 # 注意这里可能取到浮点数，需要强制取整 test_size = int(len(X)*test_ratio) # 得到训练集和测试集的索引 test_indexes = shuffle_indexes[:test_size] train_indexes = shuffle_indexes[test_size:] # 使用fancy indexing 即可得到训练集和测试集数据 X_train = X[train_indexes] y_train = y[train_indexes] X_test = X[test_indexes] y_test = y[test_indexes] print(X_train.shape) # (120, 4) print(y_train.shape) # (120,)自定义train_test_splitimport numpy as np def train_test_split(X, y, test_ratio=0.2, seed=None): """将数据 X 和 y 按照test_ratio分割成X_train, X_test, y_train, y_test""" assert X.shape[0] == y.shape[0], \ "the size of X must be equal to the size of y" assert 0.0 <= test_ratio <= 1.0, \ "test_ration must be valid" if seed: np.random.seed(seed) shuffled_indexes = np.random.permutation(len(X)) test_size = int(len(X) * test_ratio) test_indexes = shuffled_indexes[:test_size] train_indexes = shuffled_indexes[test_…

Numpy入门笔记2
type: item
date: 2020-03-25T23:51:00+08:00
description: array数据基本属性x = np.arange(15) # array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]) # 维度 x.ndim # 1 # 总个数 x.size # 15 # 查看维数 x.shape # (15,)array数据访问x=np.arange(15).reshape(3,5) x[0] # array([0, 1, 2, 3, 4]) # 不建议用下面的方式访问 # x[0][-1] # x[0][1] #推荐使用这种方法 x[1,1] # 6切片操作x=np.arange(15) # array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]) #获取前5个元素 x[:5] # array([0, 1, 2, 3, 4]) #获取5后面的元素 x[5:] # array([ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]) #步长为2截取元素 x[::2] # array([ 0, 2, 4, 6, 8, 10, 12, 14]) #步长为-1截取元素（倒序） x[::-1] # array([14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0])universal functions需要注意的是，Numpy的universal functions计算都是针对每个元素的L = np.arange(20).reshape(4,5) #array([[ 0, 1, 2, 3, 4], # [ 5, 6, 7, 8, 9], # [10, 11, 12, 13, 14], # [15, 16, 17, 18, 19]]) L-1 #array([[-1, 0, 1, 2, 3], # [ 4, 5, 6, 7, 8], # [ 9, 10, 11, 12, 13], # [14, 15, 16, 17, 18]]) L*2 #array([[ 0, 2, 4, 6, 8], # [10, 12, 14, 16, 18], # [20, 22, 24, 26, 28], # [30, 32, 34, 36, 38]]) #绝对值 np.abs(-1) #三角函数 np.sin(1) np.cos(1) np.tan(1)矩阵之间的计算为了方便说明，首先定义两个矩阵A和BA=np.arange(4).reshape(2,2) B=np.arange(4).reshape(2,2) A #array([[0, 1], # [2, 3]]) B #array([[0, 1], # [2, 3]])以下进行加减乘除取余乘方等操作都是矩阵对应元素之间进行对应的计算A+B #array([[0, 2], # [4, 6]]) A*B #array([[0, 1], # [4, 9]])如果要进行矩阵乘法，需要使用dot方法# A和B矩阵乘法 A.dot(B) #array([[ 2, 3], # [ 6, 11]])求转置矩阵A.T #array([[0, 2], # [1, 3]])向量和矩阵计算v = np.array([1,2]) # array([1, 2]) A #array([[0, 1], # [2, 3]]) #和每一行做加法 v+A #array([[1, 3], # [3, 5]]) #和每一行做减法 v-A #array([[ 1, 1], # [-1, -1]]) #向量乘以矩阵 v.dot(A) array([4, 7]) A.dot(v) # numpy会自动切换行、列向量使得计算可以进行 # 此处将v转化成2x1矩阵求逆矩阵等相关操作# 求A的逆矩阵，linalg是numpy下的一个线性代数包 np.linalg.inv(A) #array([[-1.5, 0.5], # [ 1. , 0. ]]) invA = np.linalg.inv(A) A.dot(invA) #array([[1., 0.], # [0., 1.]]) # 矩阵乘以矩阵的逆等于单位矩阵，符合定义在某些情况下，大部分矩阵没有逆，需要求伪逆矩阵X = np.arange(16).reshape(2,8) # invX = np.linalg.inv(X) # 这个矩阵求不了逆矩阵,会报错 pinvX = np.linalg.pinv(X) pinvX #array([[-1.35416667e-01, 5.20833333e-02], # [-1.01190476e-01, 4.16666667e-02], # [-6.69642…

Numpy入门笔记1
type: item
date: 2020-03-25T22:56:00+08:00
description: 导入numpyimport numpy as numpy print(numpy.__vision__) #'1.16.2'numpy.arrayarray的创建和访问nparr = np.array([i for i in range(10)]) #创建numpy.array数组 #array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) nparr[5] #可以通过索引方法访问第6个元素array的数据类型dtype方法,dtype是datatype的缩写nparr.dtype # dtype('int32')生成特定需求的数组或矩阵np.zeros(10) #array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]) np.zeros(10).dtype #dtype('float64') np.zeros(10,dtype='int') #可以使用dtype属性为生成的数组设置属性 np.zeros(shape=(3,5),dtype='int') #array([[0, 0, 0, 0, 0], # [0, 0, 0, 0, 0], # [0, 0, 0, 0, 0]]) np.ones((3,5)) #同理可以生成全为1的矩阵 #array([[1., 1., 1., 1., 1.], # [1., 1., 1., 1., 1.], # [1., 1., 1., 1., 1.]]) np.full((3,5),666) #除了全为0和1，也可以生成全为特定数的矩阵，使用full方法 #array([[666, 666, 666, 666, 666], # [666, 666, 666, 666, 666], # [666, 666, 666, 666, 666]])arangePython内置的列表生成式生成0~20之间，左闭右开，步长为2的列表[i for i in range(0,20,2)] #0到20，不包括20，步长为2 #[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]np.arange()方法使用np.arange()方法生成如上列表np.arange(0,20,2) #array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18]) np.arange(0,10) # 步长默认值为1 #array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) np.arange(10) # 起点默认为0 #array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])linspace在Matlab中也有类似的方法，一般用于作图的时候np.linspace(0,20,10) # array([ 0. , 2.22222222, 4.44444444, 6.66666667, 8.88888889, # 11.11111111, 13.33333333, 15.55555556, 17.77777778, 20. ]) np.linspace(0,20,11) # linspace 终止点参数包含在生成的array里面 # 第三个参数不是步长，而是生成几个数/点 # array([ 0., 2., 4., 6., 8., 10., 12., 14., 16., 18., 20.])random# 生成0~9之间一个随机的整数，右边界不包括 np.random.randint(0,10) # 4 # 生成10个0~9之间的随机整数，不包括右边界10 np.random.randint(0,10,10) # array([5, 2, 5, 4, 4, 9, 0, 4, 1, 7]) # 也可以用这种方法生成随机矩阵 np.random.randint(4,8,size=(3,5)) #array([[4, 4, 5, 7, 4], # [5, 4, 5, 7, 5], # [5, 6, 5, 7, 6]]) # 生成0~1之间的随机数 np.random.random() # 0.2811684913927954 # 生成10个0~1之间的随机数,下面两种方法等价 np.random.random(10) np.random.random(size = 10) # array([0.76741234, 0.95323137, 0.29097383, 0.84778197, 0.3497619 , # 0.92389692, 0.29489453, 0.52438061, 0.94253896, 0.07473949]) #默认生成均值为0，方差为1的随机数 np.random.normal() #…

Jupyter Notebook开荒笔记
type: item
date: 2020-03-22T04:29:00+08:00
description: 进入Jupyter Notebook命令行窗口运行jupyter notebook命令，浏览器访问'http://localhost:8888/tree'即可键盘快捷键快捷键是 Jupyter Notebooks 最好用的功能之一。当你想运行任何代码块时，你只需要按下Ctrl + Enter 即可。Jupyter Notebooks 提供的键盘快捷键非常多，为我们节省了大量时间。Jupyter Notebook 提供了两种不同的键盘输入模式 - 命令和编辑。命令模式将键盘与 Notebook 命令绑定，并由具有蓝色左边距的带有灰色单元格边框来表示。编辑模式允许你将文本（或代码）输入活动单元格，并以绿色单元格边框表示。使用 Esc 和 Enter 可以在命令和编辑模式之间跳转。常用快捷键已加粗，如果快捷键被系统中的其它应用占用，则可能会失效。命令模式快捷键（按 Esc 键开启）:快捷键作用说明Enter转入编辑模式 Shift-Enter运行本单元，选中下个单元新单元默认为命令模式Ctrl-Enter运行本单元 Alt-Enter运行本单元，在其下插入新单元新单元默认为编辑模式Y单元转入代码状态 M单元转入 markdown 状态 R单元转入 raw 状态 1设定 1 级标题仅在 markdown 状态下时建议使用标题相关快捷键，如果单元处于其他状态，则会强制切换到 markdown 状态2设定 2 级标题 3设定 3 级标题 4设定 4 级标题 5设定 5 级标题 6设定 6 级标题 Up选中上方单元 K选中上方单元 Down选中下方单元 J选中下方单元 Shift-K连续选择上方单元 Shift-J连续选择下方单元 A在上方插入新单元 B在下方插入新单元 X剪切选中的单元 C复制选中的单元 Shift-V粘贴到上方单元 V粘贴到下方单元 Z恢复删除的最后一个单元 D,D删除选中的单元连续按两个 D 键Shift-M合并选中的单元 Ctrl-S保存当前 NoteBook S保存当前 NoteBook L开关行号编辑框的行号是可以开启和关闭的O转换输出 Shift-O转换输出滚动 Esc关闭页面 Q关闭页面 H显示快捷键帮助 I,I中断 NoteBook 内核 0,0重启 NoteBook 内核 Shift忽略 Shift-Space向上滚动 Space向下滚动 编辑模式快捷键（ 按 Enter 键启动）:快捷键作用说明Tab代码补全或缩进 Shift-Tab提示输出帮助信息，部分函数、类、方法等会显示其定义原型，如果在其后加 ? 再运行会显示更加详细的帮助Ctrl-]缩进向右缩进Ctrl-[解除缩进向左缩进Ctrl-A全选 Ctrl-Z撤销 Ctrl-Shift-Z重做 Ctrl-Y重做 Ctrl-Home跳到单元开头 Ctrl-Up跳到单元开头 Ctrl-End跳到单元末尾 Ctrl-Down跳到单元末尾 Ctrl-Left跳到左边一个字首 Ctrl-Right跳到右边一个字首 Ctrl-Backspace删除前面一个字 Ctrl-Delete删除后面一个字 Esc切换到命令模式 Ctrl-M切换到命令模式 Shift-Enter运行本单元，选中下一单元新单元默认为命令模式Ctrl-Enter运行本单元 Alt-Enter运行本单元，在下面插入一单元新单元默认为编辑模式Ctrl-Shift--分割单元按光标所在行进行分割Ctrl-Shift-Subtract分割单元 Ctrl-S保存当前 NoteBook Shift忽略 Up光标上移或转入上一单元 Down光标下移或转入下一单元 Ctrl-/注释整行/撤销注释仅代码状态有效魔法命令%lsmagic打印当前可以用的魔法命令，当我们想使用一个魔法命令，而不知怎么拼写函数名时，可以使用%lsmagic来查询%run%run后面接着一个相对地址的py文件，表示运行这个py文件%timeit代码执行计时import numpy as np %timeit np.sin(24) #708 ns ± 17.1 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)