【人工智能】深度学习框架基础操作实验（安装Anaconda、PyCharm、Tensorflow、PyTorch、PaddlePaddle及测试）（保姆级重磅52张教程图）

实验过程

1. Anaconda安装

根据我的本机系统（Windows 11）选择合适的版本的Anaconda进行安装并验证
安装Python开发IDE，我的是PyCharm
提交安装验证成功截图

2. TensorFlow（CPU版）安装与测试

在Anaconda中创建虚拟环境
通过`pip install tensorflow`安装CPU版TensorFlow
下载官网测试样例代码，完成环境基本测试
提交含注释的测试代码（说明各模块及代码功能）、实验过程及结果截图

PS：我研究了半天时间安装，发现从 TensorFlow 2.11 开始官方停止了对 Windows CUDA 的支持，只能用 WSL2（这是一个WIndows 11里面相对于虚拟机的app） 和 DirectML（而微软官方已经停止 DirectML 的更新）联动实现，我虽然装了 CUDA 12.4（我的驱动，也就是nvidia-smi中显示可以支持到 CUDA 13.0），PyTorch和paddlepaddle 完全可以正常调用，但 TensorFlow 在 Windows 上最多只能用到 2.10 + CUDA 11.2，再往后就不支持了，为了确保PyTorch和PaddlePaddle的正常使用，我放弃了TensorFlow的GPU版，使用CPU版验证安装。

3. PaddlePaddle（GPU版）安装与测试

在Anaconda中创建虚拟环境
安装适配本机NVIDIA显卡的驱动、CUDA及对应CUDNN并验证
参照官网指引，结合本机环境获取安装命令，安装GPU版PaddlePaddle
下载官网测试样例代码，完成环境基本测试
提交含注释的测试代码（说明各模块及代码功能）、实验过程及结果截图

4. PyTorch（GPU版）安装与测试

在Anaconda中创建虚拟环境
安装适配本机NVIDIA显卡的驱动、CUDA及对应CUDNN并验证
参照官网指引，结合本机环境获取安装命令，安装GPU版PyTorch
下载官网测试样例代码，完成环境基本测试
提交含注释的测试代码（说明各模块及代码功能）、实验过程及结果截图

5. PyTorch Tensor运算练习

根据提供资料练习PyTorch中tensor的基础运算与变换
提供含注释的实验代码（说明代码含义）
附上实验结果

实验详细操作步骤或程序清单

1. Anaconda安装

根据我的本机系统（Windows）选择合适的版本的Anaconda进行安装并验证

安装Python开发IDE，我的是PyCharm

注：不同版本的软件在安装和配置时可能存在不同，若存在不同请理解安装逻辑后再执行。

2. TensorFlow（CPU版）安装与测试

在Anaconda中创建虚拟环境

通过 pip install tensorflow 安装CPU版TensorFlow

下载官网测试样例代码，完成环境基本测试，我参考的代码是这个：https://www.tensorflow.org/tutorials/quickstart/beginner?hl=zh-cn

下面我又参照官方代码，写了一个训练LeNet模型的代码，batch_size=128, epochs=20。

import tensorflow as tf
from tensorflow.keras import datasets, layers, models
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

# 确认 TensorFlow 版本
print("TensorFlow version:", tf.__version__)

# 加载 MNIST 数据集
(x_train, y_train), (x_test, y_test) = datasets.mnist.load_data()

# LeNet 输入是 32x32，这里需要 padding
x_train = tf.expand_dims(x_train, -1)  # (60000, 28, 28, 1)
x_test = tf.expand_dims(x_test, -1)  # (10000, 28, 28, 1)

# 填充到 32x32
x_train = tf.image.resize_with_pad(x_train, 32, 32)
x_test = tf.image.resize_with_pad(x_test, 32, 32)

# 归一化到 [0,1]
x_train = x_train / 255.0
x_test = x_test / 255.0


# 定义 LeNet 模型
def build_lenet():
    model = models.Sequential([
        layers.Conv2D(6, kernel_size=5, activation='tanh', input_shape=(32, 32, 1), padding="same"),
        layers.AveragePooling2D(pool_size=2, strides=2),

        layers.Conv2D(16, kernel_size=5, activation='tanh'),
        layers.AveragePooling2D(pool_size=2, strides=2),

        layers.Flatten(),
        layers.Dense(120, activation='tanh'),
        layers.Dense(84, activation='tanh'),
        layers.Dense(10, activation='softmax')
    ])
    return model


model = build_lenet()
model.summary()

# 编译与训练
model.compile(optimizer=tf.keras.optimizers.Adam(1e-3),
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 训练
model.fit(x_train, y_train, batch_size=128, epochs=20, validation_split=0.1)

# 测试集评估
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print(f"Test accuracy: {test_acc:.4f}"\n)

3. PaddlePaddle（GPU版）安装与测试

在Anaconda中创建虚拟环境

安装适配本机NVIDIA显卡的驱动、CUDA及对应CUDNN并验证

参照官网指引，结合本机环境获取安装命令，安装GPU版PaddlePaddle

下载官网测试样例代码，完成环境基本测试

同样是LeNet进行测试

import paddle
import paddle.nn as nn
import paddle.nn.functional as F
from paddle.vision.datasets import MNIST
from paddle.vision.transforms import Compose, Resize, ToTensor
from paddle.io import DataLoader

# 版本与随机种子
print("PaddlePaddle version:", paddle.__version__)
paddle.seed(42)

# 准备数据
transform = Compose([
    Resize((32, 32)),   # LeNet 期望 32x32
    ToTensor()          # [0,1], CHW
])

train_dataset = MNIST(mode='train', transform=transform, download=True)
test_dataset = MNIST(mode='test', transform=transform, download=True)

train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=0)
test_loader = DataLoader(test_dataset, batch_size=128, shuffle=False, num_workers=0)

# 模型（LeNet-5，tanh + AvgPool）
class LeNet(nn.Layer):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2D(1, 6, kernel_size=5, padding=2)   # -> 6x32x32
        self.pool1 = nn.AvgPool2D(2, 2)                          # -> 6x16x16
        self.conv2 = nn.Conv2D(6, 16, kernel_size=5)             # -> 16x12x12
        self.pool2 = nn.AvgPool2D(2, 2)                          # -> 16x6x6
        self.fc1 = nn.Linear(16 * 6 * 6, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)
    
    # 前向传播
    def forward(self, x):
        x = F.tanh(self.conv1(x))
        x = self.pool1(x)
        x = F.tanh(self.conv2(x))
        x = self.pool2(x)
        x = paddle.flatten(x, start_axis=1)
        x = F.tanh(self.fc1(x))
        x = F.tanh(self.fc2(x))
        x = self.fc3(x)  # logits
        return x

# 创建模型对象
model = LeNet()

# 设置优化器与损失
optimizer = paddle.optimizer.Adam(learning_rate=1e-3, parameters=model.parameters())
criterion = nn.CrossEntropyLoss()

# 设置显卡设备
paddle.set_device("gpu")


# 训练与测试，20轮
epochs = 20
for epoch in range(epochs):
    model.train()
    for batch_id, (images, labels) in enumerate(train_loader):
        # labels 可能是 [B,1]，压到 [B]
        if labels.ndim == 2 and labels.shape[1] == 1:
            labels = labels.squeeze(1)

        logits = model(images)
        loss = criterion(logits, labels)
        loss.backward()
        optimizer.step()
        optimizer.clear_grad()

        if batch_id % 100 == 0:
            print(f"Epoch [{epoch+1}/{epochs}], Step [{batch_id}], Loss: {loss.numpy().item():.4f}")

    # 验证
    model.eval()
    correct, total = 0, 0
    with paddle.no_grad():
        for images, labels in test_loader:
            if labels.ndim == 2 and labels.shape[1] == 1:
                labels = labels.squeeze(1)
            logits = model(images)
            preds = logits.argmax(axis=1)
            correct += (preds == labels).astype('int32').sum().item()
            total += labels.shape[0]
    acc = correct / total
    print(f"Epoch [{epoch+1}/{epochs}] Test Accuracy: {acc:.4f}")

4. PyTorch（GPU版）安装与测试

在Anaconda中创建虚拟环境

安装适配本机NVIDIA显卡的驱动、CUDA及对应CUDNN并验证，这里就不再写了，参考上一小节PaddlePaddle的。

参照官网指引，结合本机环境获取安装命令，安装GPU版PyTorch

下载官网测试样例代码，完成环境基本测试

现在我在 PyTorch环境用的是AlexNet进行训练，数据集用的是自定义的水果数据集。

import torch.nn as nn
import torch

class AlexNet(nn.Module):
    def __init__(self, num_classes=1000, init_weights=False):
        super(AlexNet, self).__init__()
        self.features = nn.Sequential(  # Sequential将一系列层结构打包
            # 卷积核个数均采用原AlexNet的一半
            nn.Conv2d(3, 48, kernel_size=11, stride=4, padding=2),  # input[3, 224, 224]  output[48, 55, 55]
            nn.ReLU(inplace=True),  # inplace可理解为pytorch增加计算量、降低内存使用的一种方法
            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[48, 27, 27]
            nn.Conv2d(48, 128, kernel_size=5, padding=2),           # output[128, 27, 27]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[128, 13, 13]
            nn.Conv2d(128, 192, kernel_size=3, padding=1),          # output[192, 13, 13]
            nn.ReLU(inplace=True),
            nn.Conv2d(192, 192, kernel_size=3, padding=1),          # output[192, 13, 13]
            nn.ReLU(inplace=True),
            nn.Conv2d(192, 128, kernel_size=3, padding=1),          # output[128, 13, 13]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[128, 6, 6]
        )
        self.classifier = nn.Sequential(# 全连接层
            # Dropout加在两个全连接层之间
            nn.Dropout(p=0.5),# 神经元随机失活的比例=0.5

            # 展成一维的并且卷积核的个数为原AlexNet的一半
            # 因此不是256*6*6，而是128 * 6 * 6，且FC1的卷积核大小为2048
            nn.Linear(128 * 6 * 6, 2048),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5),

            # 第二个全连接层
            nn.Linear(2048, 2048),
            nn.ReLU(inplace=True),

            # 第三个全连接层，输出num_classes的数值是训练集类别的个数
            # 对于花的数据集num_classes=5
            nn.Linear(2048, num_classes),
        )

        # 在pytorch中其实并不需要此函数
        # pytorch自动使用kaiming_normal_对卷积层和全连接层进行初始化
        if init_weights:# 初始化权重函数，init_weights=True时，会执行此函数
            self._initialize_weights()

    # 正向传播
    def forward(self, x):
        x = self.features(x)

        # 展平处理 pytorch的tensor排列顺序为[batch,channel,height,width]
        # 0维的batch不用，故start_dim=1，也可以使用view函数展平
        x = torch.flatten(x, start_dim=1)

        # 输入到分类结构中，即后面的三个全连接层
        x = self.classifier(x)
        return x

    def _initialize_weights(self):
        for m in self.modules():# 遍历之前定义的每一个层结构
            if isinstance(m, nn.Conv2d):# 判断属于哪个层类别
                # 如果是卷积层，kaiming_normal_
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                if m.bias is not None:
                    # 对偏执进行赋值为0
                    nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                # 如果是全连接层，通过正态分布对权重进行赋值，正态分布的均值=0，方差=0.01
                nn.init.normal_(m.weight, 0, 0.01)
                nn.init.constant_(m.bias, 0)

import torch
import torch.nn as nn
from torchvision import transforms, datasets
import torch.optim as optim
from torch.utils.tensorboard import SummaryWriter
from model import AlexNet
import os
import json
import time
import numpy as np


def confusion_matrix_scores(confusion_matrix):
    # 将 confusion_matrix 转换为 NumPy 数组，方便进行矩阵操作
    confusion_matrix = np.array(confusion_matrix)
    # 获取类别数量
    num_classes = confusion_matrix.shape[0]
    # 计算样本总数
    total_samples = np.sum(confusion_matrix)

    # 存储每个类别的精确率，召回率和F1分数
    per_class_values = []
    for i in range(num_classes):
        # 计算类别 i 的真阳性数（TP）
        tp_i = confusion_matrix[i, i]

        # 计算类别 i 的精确率（Precision）
        col_i_sum = np.sum(confusion_matrix[:, i])  # 计算第 i 列的总和
        precision_i = tp_i / col_i_sum if col_i_sum != 0 else 0  # 添加除零检查

        # 计算类别 i 的召回率（Recall）
        row_i_sum = np.sum(confusion_matrix[i, :])  # 计算第 i 行的总和
        recall_i = tp_i / row_i_sum if row_i_sum != 0 else 0  # 添加除零检查

        # 计算类别 i 的F1分数
        if precision_i + recall_i != 0:
            f1_i = 2 * precision_i * recall_i / (precision_i + recall_i)
        else:
            f1_i = 0

        # 将计算结果存储到列表per_class_values中
        per_class_values.append((precision_i, recall_i, f1_i))
        # 打印类别 i 的各项指标
        print(f"类别{i}的精确率：{100*precision_i:.2f}%，召回率：{100*recall_i:.2f}%，F1分数：{100*f1_i:.2f}%")

    # 计算总的准确率（Accuracy）
    accuracy = np.trace(confusion_matrix) / total_samples  # np.trace(confusion_matrix) 返回对角线元素之和，即所有TP的总和
    # 将每个类别的精确率、召回率和F1分数解包
    precisions, recalls, f1s = zip(*per_class_values)

    # 计算微平均（micro-average）的精确率、召回率和F1分数
    micro_precision = np.mean(precisions)
    micro_recall = np.mean(recalls)
    micro_f1 = np.mean(f1s)

    print(f"总准确率：{100*accuracy:.2f}%", end=" ")
    print(f"总精确率：{100*micro_precision:.2f}%", end=" ")
    print(f"总召回率：{100*micro_recall:.2f}%", end=" ")
    print(f"总F1分数：{100*micro_f1:.2f}%")


def main():
    batch_size = 64
    epochs = 10
    lr = 0.0002
    writer = SummaryWriter("logs" + "/e" + str(epochs) + "_bs" + str(batch_size) + "_lr" + str(lr))
    # 指定训练的设备
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    print("using {} device.".format(device))

    # 数据预处理函数
    data_transform = {
        "train": transforms.Compose([transforms.RandomResizedCrop(224),  # 随机裁减到224
                                     transforms.RandomHorizontalFlip(),  # 水平方向翻转
                                     transforms.ToTensor(),
                                     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),  # 标准化处理
        "val": transforms.Compose([transforms.Resize((224, 224)),  # cannot 224, must (224, 224)
                                   transforms.ToTensor(),
                                   transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}

    # 获取数据集
    # data_root = os.path.abspath(os.path.join(os.getcwd(), "../.."))  # get data root path
    image_path = os.path.join("../dataset", "fruits_data")  # fruits data set path
    assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
    # 加载数据集
    train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
                                         transform=data_transform["train"])
    # 通过len函数获取训练集有多少张图片
    train_num = len(train_dataset)

    # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
    # 获取分类名称对应的索引
    flower_list = train_dataset.class_to_idx

    # 将key和val交换位置，变成{0:'daisy':,1: 'dandelion', 2:'roses', 3:'sunflower', 4:'tulips'}
    # 便于预测后根据索引打印类别
    cla_dict = dict((val, key) for key, val in flower_list.items())
    # write dict into json file
    # 将cla_dict字典编码成json格式
    json_str = json.dumps(cla_dict, indent=4)
    # 打开class_indices.json，便于预测时读取信息
    with open('class_indices.json', 'w') as json_file:
        json_file.write(json_str)

    nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])  # number of workers
    print('Using {} dataloader workers every process'.format(nw))

    # 通过DataLoader加载train_dataset
    # num_workers表示加载数据所需的线程个数，Windows下设置为0，表示使用主线程加载数据
    # linux下可设置成8,16等加快加载速度和训练速度
    train_loader = torch.utils.data.DataLoader(train_dataset,
                                               batch_size=batch_size, shuffle=True,
                                               num_workers=nw)

    # 载入测试集
    validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"),
                                            transform=data_transform["val"])
    val_num = len(validate_dataset)
    validate_loader = torch.utils.data.DataLoader(validate_dataset,
                                                  batch_size=batch_size, shuffle=False,
                                                  num_workers=nw)

    print("using {} images for training, {} images fot validation.".format(train_num,
                                                                           val_num))
    # # 随机查看测试集中的4张图片，注意将shuffle改成True
    # test_data_iter = iter(validate_loader)
    # test_image, test_label = test_data_iter.next()
    #
    # def imshow(img):
    #     img = img / 2 + 0.5  # unnormalize
    #     npimg = img.numpy()
    #     plt.imshow(np.transpose(npimg, (1, 2, 0)))
    #     plt.show()
    #
    # print(' '.join('%5s' % cla_dict[test_label[j].item()] for j in range(4)))
    # imshow(utils.make_grid(test_image))

    # num_classes
    net = AlexNet(num_classes=5, init_weights=True)

    net.to(device)
    # 损失交叉熵函数
    loss_function = nn.CrossEntropyLoss()
    # pata = list(net.parameters())# 查看模型的参数
    # 使用Adam优化器，优化net的所有参数，学习率=0.0002
    optimizer = optim.Adam(net.parameters(), lr=lr)

    # 保存权重的路径
    save_path = "./AlexNet_" + "e" + str(epochs) + "bs" + str(batch_size) + "lr" + str(lr) + ".pth"
    best_acc = 0.0  # 保存最佳准确率
    for epoch in range(epochs):  # 迭代10次
        # train
        # 使用net.train()和net.eval()管理dropout方法
        net.train() # 在训练过程中启用dropout方法
        running_loss = 0.0  # 统计训练过程中的平均损失
        t1 = time.perf_counter()    # 记录训练一个epoch开始的时间
        for step, data in enumerate(train_loader, start=0):
            images, labels = data  # 将数据分为images和labels
            optimizer.zero_grad()   # 清空之前的梯度信息
            outputs = net(images.to(device))    # 进行正向传播
            loss = loss_function(outputs, labels.to(device))    # 计算预测值和真实值的损失
            loss.backward()  # 将得到的损失反向传播到每个节点中
            optimizer.step()  # 通过optimizer更新每个节点的参数

            # print statistics
            running_loss += loss.item()
            # print train process
            # 打印训练进度
            rate = (step + 1) / len(train_loader)
            a = "*" * int(rate * 50)
            b = "." * int((1 - rate) * 50)
            print("\rtrain loss: {:^3.0f}%[{}->{}]{:.3f}".format(int(rate * 100), a, b, loss), end="")

        print()
        writer.add_scalar("train_loss", running_loss, epoch + 1)
        print("所需时间："+str(time.perf_counter()-t1))  # 输出训练一个epoch所需的时间

        # validate验证
        net.eval()  # 在测试过程中关闭dropout方法
        acc = 0.0  # accumulate accurate number / epoch
        confusion_matrix = [[0 for _ in range(5)] for _ in range(5)]
        with torch.no_grad():   # 防止对每个梯度进行跟踪
            for val_data in validate_loader:
                val_images, val_labels = val_data
                outputs = net(val_images.to(device))
                predict_y = torch.max(outputs, dim=1)[1]
                acc += (predict_y == val_labels.to(device)).sum().item()

                for pred, true in zip(predict_y, val_labels.to(device)):
                    confusion_matrix[true.item()][pred.item()] += 1

            val_accurate = acc / val_num
            if val_accurate > best_acc:
                best_acc = val_accurate
                torch.save(net.state_dict(), save_path)
            print('[epoch %d] test_loss: %.3f  test_accuracy: %.3f' %
                  (epoch + 1, running_loss / step, val_accurate))
            writer.add_scalar("test_loss", running_loss / step, epoch + 1)
            writer.add_scalar("test_accuracy", 100 * val_accurate, epoch + 1)
            for i in confusion_matrix:
                print(i)
            confusion_matrix_scores(confusion_matrix)
    print("e" + str(epochs) + "_bs" + str(batch_size) + "_lr" + str(lr))
    print('Finished Training')
    writer.close()


if __name__ == '__main__':
    main()

5. PyTorch Tensor运算练习

根据提供资料练习PyTorch中tensor的基础运算与变换

import torch
import numpy as np

# 1、创建一行向量 t，值为 [5., 10., 15.]，输出结果验证其 dtype ，然后将类型转化为int16，输出结果。
t = torch.tensor([5., 10., 15.])
print(t, t.dtype)
t = t.to(torch.int16)
print(t)

# 2、用 torch.rand 创建 (2, 3) 的 FP32 张量 a，
# 用 torch.randn 创建同形状张量 b；
# 计算 a 与 b 的逐元素乘积，再对结果做一次行求和，得到长度 2 的一维张量 s。
# 默认就是FP32
a = torch.rand(2, 3)
b = torch.randn(2, 3)
print(a, a.dtype, b, b.dtype)
# 计算a与b的逐元素乘积
c = a * b
print(c)
# dim=1表示按行求和
s = c.sum(dim=1)
print(s)

# 3、把 NumPy 数组 np.arange(6).reshape(2, 3) 转成 PyTorch 张量 t，
# 再把 t 转回 NumPy 并验证两次数据是否共享内存（修改其一，另一同步变化）。
# np数组
np_arr = np.arange(6).reshape(2, 3)
print(np_arr)

# 转换为PyTorch张量
t = torch.from_numpy(np_arr)
print(t)

# 转回np数组
np_arr2 = t.numpy()
print(np_arr2)

# 验证内存共享
print("\n验证内存共享:")
np_arr[0, 0] = 999  # 修改原始NumPy数组
print("修改后原始NumPy数组:\n", np_arr)
print("PyTorch张量:\n", t)
print("NumPy数组2:\n", np_arr2)

# 4、创建 (2, 4, 3) 张量 x，要求元素服从均值为 0、标准差为 0.1 的正态分布；
# 随后用两种不同的方法获取其形状 (4, 3) 的子张量（即第 0 个切片）。
x = 0.1 * torch.randn(2, 4, 3)
print(x.shape, x)

# 方法1: 使用索引获取第0个切片
s1 = x[0]
# 方法2: 使用narrow方法获取第0个切片
s2 = x.narrow(dim=1, start=0, length=1).squeeze(0)
print(s1)
print(s1.shape)
print(s2)
print(s2.shape)

# 5、对任意 (3, 4) 张量 t，分别用
# a) 索引切片
# b) narrow
# 提取第 2 列（dim=1 的 index=1）形成形状 (3, 1) 的输出。
t = torch.randn(3, 4)
print(t)

# a) 使用索引切片提取第2列(dim=1, index=1)，保持(3,1)形状
col_a = t[:, 1:2]  # 使用1:2而不是1可以保持维度

# b) 使用narrow方法提取
col_b = t.narrow(dim=1, start=1, length=1)

print("方法1：", col_a.shape)
print(col_a)
print("方法2：", col_b.shape)
print(col_b)

# 6、创建 (10, 10) 张量 T，元素服从 U(0, 1)；
# a) 提取值大于 0.5 的掩码索引（torch.where 或 nonzero）
# b) 用这些索引把原张量对应位置置为 ?1
# 服从均匀分布
t = torch.rand(10, 10)
print(t)
# a) 提取值大于0.5的掩码索引
# 方法1
index_where = torch.where(t > 0.5)
# 方法2
mask = t > 0.5
index_nonzero = mask.nonzero()

print("方法1的索引形状：", index_where[0].shape)
print("方法2的索引形状：", index_nonzero.shape)

# b) 用索引将对应位置置为-1
t[index_where] = -1
# 验证结果（查看部分元素）
print("修改后张量的部分元素:\n", t[:3, :3])


# 7、创建 requires_grad=True 的 (2, 2) 张量 t；在 torch.no_grad() 上下文内计算 s = t * 3，打印 s.requires_grad 并解释原因。
t = torch.randn(2, 2, requires_grad=True)
print(t.requires_grad)

# 禁用梯度计算
with torch.no_grad():
    s = t * 3
    print("s.requires_grad:", s.requires_grad)  # 输出False

# 原因：torch.no_grad()会禁用梯度计算，所以在with下面创建的张量默认requires_grad=False

# 8、对任意标量张量 loss（例如 .randn(()).requires_grad_()），手动调用 backward()；
# 然后使用 torch.autograd.grad 再计算一次同一 loss 对同一叶子节点的梯度，验证两次结果相等。

loss = torch.randn((), requires_grad=True)
print("原始loss值:", loss.item())

# 1. 手动调用backward()计算梯度
loss.backward(retain_graph=True)  # retain_graph=True保留计算图
grad_backward = loss.grad  # loss是叶子节点，其梯度存储在.grad中

# 2. 使用torch.autograd.grad计算梯度
grad_autograd = torch.autograd.grad(loss, loss)[0]  # 第一个返回值是梯度

# 验证结果是否相等
print("backward()得到的梯度:", grad_backward.item())
print("autograd.grad得到的梯度:", grad_autograd.item())

# 9、用 torch.tensor 创建 Python 列表 [3, 6, 9] 对应的 浮点型 张量，并打印其形状与 dtype。

l = [3, 6, 9]
tensor = torch.tensor(l, dtype=torch.float32)  # 显式指定浮点类型

print(tensor, tensor.shape, tensor.dtype)

# 10、用 torch.arange 生成 0~8（含 8）的整数序列，再把它 reshape 成 (3, 3)。
a = torch.arange(9)  # 0到8共9个元素
print(a)
b = a.reshape(3, 3)
print(b, b.shape)

# 11、对 (4,) 张量 [1., 2., 3., 4.] 做一次 .sum()，再把结果转成 Python 浮点数并打印。

# 创建(4,)浮点张量
tensor = torch.tensor([1., 2., 3., 4.])
print("原始张量:", tensor)
# 求和操作
sum_result = tensor.sum()
print(sum_result)
print(type(sum_result))
# 转换为Python浮点数
python_float = sum_result.item()
print(python_float)
print(type(python_float))