1、判断题：
ndarray.shape返回一个元祖，表示数组在各个方向上的长度
选项：
A:错
B:对
答案:【对】

2、判断题：
empty（）函数生成的数组完全是随机的
选项：
A:错
B:对
答案:【对】

3、判断题：
b[1][1]是指数组中第一行第一列的元素值
选项：
A:错
B:对
答案:【错】

4、单选题：
numpy提供了rand()函数用于生成元素（）区间上均匀分布的数组
选项：
A:以上都不是
B:(0，1)
C:[0，1]
D:[0，1)
答案:【[0，1)】

5、多选题：
Python中的数据类型包括
选项：
A:浮点型
B:整型
C:字符型
D:布尔型
答案:【浮点型;
整型;
字符型;
布尔型】

6、判断题：
列表用（）标识。
选项：
A:对
B:错
答案:【错】

7、判断题：
python2、python3都默认支持默认支持中文。
选项：
A:错
B:对
答案:【错】

8、判断题：
b=np.arange(0,20,2)查找索引号为2的数据，取出数组中元素4。
选项：
A:错
B:对
答案:【对】

9、判断题：
b[1:8:2]=1，数组输出0，1，4，1，8，1，12，1，16，18
选项：
A:对
B:错
答案:【对】

10、判断题：
flatten()方法就把X转换成一维数组返回一个一维的数组，作用的对象可以是列表。
选项：
A:错
B:对
答案:【对】

智慧树深度学习之瑞士军刀-pytorch入门

近年来，随着深度学习技术的发展，越来越多的人开始关注深度学习。而深度学习的底层框架就是神经网络，它已经成为许多人学习深度学习的必备技能。在众多的深度学习框架中，Pytorch可以说是最热门的之一。Pytorch是一个开源的机器学习库，它基于Python语言，专门针对深度学习的开发。它的设计思想主要是简单、快速和具有延展性。

Pytorch的优点

Pytorch最大的优点是易于使用。它的文档简明扼要，代码精简，易于上手，并且支持动态计算图，让开发者更加高效和灵活地使用。此外，Pytorch的GPU加速也非常快，还支持分布式处理，可以充分利用硬件设施提高深度学习的速度。

另外，Pytorch还可以和Numpy相互转换，这让开发者在使用Pytorch时可以轻松地进行数学运算，并且在数据预处理时可以利用Numpy的优势。此外，Pytorch的API设计非常简单、方便，让开发者可以更加便捷地使用。最后，Pytorch的社区非常活跃，有大量的开发者在为Pytorch做贡献，使其变得更加完善和强大。

Pytorch的安装

在开始使用Pytorch之前，我们需要先进行安装。Pytorch的安装非常简单，可以通过以下方式安装：

1. 安装Anaconda或者Miniconda，这是一款Python的科学计算和数据分析工具。
2. 打开Anaconda Prompt或者命令行终端，输入以下命令：

   conda install pytorch torchvision torchaudio cpuonly -c pytorch

   如果你已经安装了NVIDIA GPU驱动，可以使用以下命令安装Pytorch：

   conda install pytorch torchvision torchaudio cudatoolkit=-c pytorch

   其中，代表你的CUDA版本号，例如10.2。如果你不知道你的CUDA版本号，可以使用以下命令查看：

   nvidia-smi

Pytorch的基本概念

在使用Pytorch之前，我们需要了解一些基本概念。

张量（Tensor）

张量是Pytorch中的基本数据结构，它可以理解为一个多维数组。Pytorch中的张量和Numpy中的数组类似，可以支持各种数学运算。

我们可以通过以下代码创建一个2x3的张量：

import torchx = torch.tensor([[1, 2, 3], [4, 5, 6]])print(x)

输出结果为：

tensor([[1, 2, 3],        [4, 5, 6]])

自动求导（Autograd）

Pytorch中的自动求导是其最大的特点之一。自动求导可以让我们在使用Pytorch进行深度学习时不需要手动计算导数，Pytorch会自动帮我们计算。

我们可以通过以下代码创建一个张量，并对其进行自动求导：

import torchx = torch.tensor(3.0, requires_grad=True)y1 = x + 1y2 = 2 * xloss = (y1 - y2) ** 2print(loss)loss.backward()print(x.grad)

输出结果为：

tensor(1., grad_fn=)tensor(5.)

在上面的代码中，我们首先创建了一个张量x，并设置了requires_grad=True，这表示我们需要对x进行自动求导。然后我们定义了两个新的张量y1和y2，然后计算了一个loss函数。最后我们调用了loss.backward()，Pytorch会自动帮我们计算loss对x的导数，并将结果保存在x.grad中。

模型（Model）

在Pytorch中，我们可以使用模型来构建我们的神经网络。模型是由多个层（Layer）组成的，每个层可以看作是对数据的一次变换。我们可以通过继承nn.Module来创建我们的模型。

以下是一个简单的线性模型的例子：

import torch.nn as nnclass LinearModel(nn.Module):    def __init__(self, in_features, out_features):        super(LinearModel, self).__init__()        self.linear = nn.Linear(in_features, out_features)    def forward(self, x):        out = self.linear(x)        return out

在上面的代码中，我们创建了一个名为LinearModel的类，并继承了nn.Module。我们在构造函数中定义了一个线性层（nn.Linear），并将其保存在self.linear中。在forward方法中，我们对输入进行一次线性变换，并返回结果。

Pytorch的示例

以下是一个使用Pytorch进行MNIST手写数字识别的示例：

import torchimport torch.nn as nnimport torch.optim as optimfrom torchvision import datasets, transforms# 定义超参数batch_size = 64learning_rate = 0.01num_epoches = 20# 定义数据预处理transform = transforms.Compose([    transforms.ToTensor(), # 转换成Tensor格式    transforms.Normalize((0.1307, ), (0.3081, )) # 归一化])# 加载数据集train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=True)# 定义模型class Net(nn.Module):    def __init__(self):        super(Net, self).__init__()        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)        self.pooling = nn.MaxPool2d(2)        self.fc = nn.Linear(320, 10)    def forward(self, x):        x = self.conv1(x)        x = nn.functional.relu(x)        x = self.pooling(x)        x = self.conv2(x)        x = nn.functional.relu(x)        x = self.pooling(x)        x = x.view(-1, 320)        x = self.fc(x)        x = nn.functional.softmax(x, dim=1)        return x# 创建模型model = Net()# 定义损失函数和优化器criterion = nn.CrossEntropyLoss()optimizer = optim.SGD(model.parameters(), lr=learning_rate)# 开始训练for epoch in range(num_epoches):    for i, (images, labels) in enumerate(train_loader):        # 将数据拷贝到GPU        images = images.cuda()        labels = labels.cuda()        # 前向传播        outputs = model(images)        loss = criterion(outputs, labels)        # 反向传播        optimizer.zero_grad()        loss.backward()        optimizer.step()        if (i+1) % 100 == 0:            print(\Epoch [{ }/{ }], Step [{ }/{ }], Loss: { :.4f}\                  .format(epoch+1, num_epoches, i+1, len(train_loader), loss.item()))# 评估模型model.eval()with torch.no_grad():    correct = 0    total = 0    for images, labels in test_loader:        # 将数据拷贝到GPU        images = images.cuda()        labels = labels.cuda()        # 前向传播        outputs = model(images)        _, predicted = torch.max(outputs.data, 1)        total += labels.size(0)        correct += (predicted == labels).sum().item()    print('Accuracy of the network on the test images: { } %'.format(100 * correct / total))

在上面的代码中，我们首先定义了超参数，然后对数据进行了预处理。接着我们创建了一个卷积神经网络模型，并定义了损失函数和优化器。最后我们开始训练模型，使用GPU对数据进行处理，进行前向传播和反向传播，并在每个epoch结束后计算损失。最后我们评估模型的性能，计算模型在测试集上的准确率。

结语

本文介绍了Pytorch的基本概念和优点，并通过一个MNIST手写数字识别的示例演示了如何使用Pytorch进行深度学习。Pytorch非常强大和易于使用，建议深度学习爱好者们学习使用Pytorch，它将成为您深度学习的绝佳工具。