• DDC代码阅读笔记

    论文：《Deep Domain Confusion: Maximizing for Domain Invariance》 

    https://arxiv.org/abs/1412.3474

    [DDC]Deep Domain Confusion: Maximizing for Domain Invariance_HHzdh的博客-CSDN博客

    源码：https://github.com/guoXuehong77/transferlearning/tree/master/code/deep/DDC_DeepCoral

    前言（摘自README.md）

            该源码主要是做了《Deep CORAL Correlation Alignment for Deep Domain Adaptation》的复现工作，但是只要把源码中的CORAL loss替换成MMD loss, 就可以复现DDC了。

    网络部分

            该架构使用了一个自适应层（adaptation layer）和一个基于最大平均偏差(MMD，maximum mean discrepancy)的domain confusion loss来自动学习一个联合训练的表示来优化分类和域不变性。论文是在AlexNet的fc7层后面加入fc_adapt层，源码中实际上实现了多种backbone，包括alexnet、resnet18-152。

    代码部分

    1、backbone.py

            该文件定义了几种经典的CNN网络，包括alexnet、resnet18、resnet34、resnet50、resnet101、resnet152。初始化时加载预训练模型。

    1. import numpy as np
    2. import torch
    3. import torch.nn as nn
    4. import torchvision
    5. from torchvision import models
    6. from torch.autograd import Variable
    7.  
    8.  
    9. # convnet without the last layer
    10. class AlexNetFc(nn.Module):
    11.     def __init__(self):
    12.         super(AlexNetFc, self).__init__()
    13.         model_alexnet = models.alexnet(pretrained=True)
    14.         self.features = model_alexnet.features
    15.         self.classifier = nn.Sequential()
    16.         for i in range(6):
    17.             self.classifier.add_module(
    18.                 "classifier"+str(i), model_alexnet.classifier[i])
    19.         self.__in_features = model_alexnet.classifier[6].in_features
    20.  
    21.     def forward(self, x):
    22.         x = self.features(x)
    23.         x = x.view(x.size(0), 256*6*6)
    24.         x = self.classifier(x)
    25.         return x
    26.  
    27.     def output_num(self):
    28.         return self.__in_features
    29.  
    30.  
    31. class ResNet18Fc(nn.Module):
    32.     def __init__(self):
    33.         super(ResNet18Fc, self).__init__()
    34.         model_resnet18 = models.resnet18(pretrained=True)
    35.         self.conv1 = model_resnet18.conv1
    36.         self.bn1 = model_resnet18.bn1
    37.         self.relu = model_resnet18.relu
    38.         self.maxpool = model_resnet18.maxpool
    39.         self.layer1 = model_resnet18.layer1
    40.         self.layer2 = model_resnet18.layer2
    41.         self.layer3 = model_resnet18.layer3
    42.         self.layer4 = model_resnet18.layer4
    43.         self.avgpool = model_resnet18.avgpool
    44.         self.__in_features = model_resnet18.fc.in_features
    45.  
    46.     def forward(self, x):
    47.         x = self.conv1(x)
    48.         x = self.bn1(x)
    49.         x = self.relu(x)
    50.         x = self.maxpool(x)
    51.         x = self.layer1(x)
    52.         x = self.layer2(x)
    53.         x = self.layer3(x)
    54.         x = self.layer4(x)
    55.         x = self.avgpool(x)
    56.         x = x.view(x.size(0), -1)
    57.         return x
    58.  
    59.     def output_num(self):
    60.         return self.__in_features
    61.  
    62.  
    63. class ResNet34Fc(nn.Module):
    64.     def __init__(self):
    65.         super(ResNet34Fc, self).__init__()
    66.         model_resnet34 = models.resnet34(pretrained=True)
    67.         self.conv1 = model_resnet34.conv1
    68.         self.bn1 = model_resnet34.bn1
    69.         self.relu = model_resnet34.relu
    70.         self.maxpool = model_resnet34.maxpool
    71.         self.layer1 = model_resnet34.layer1
    72.         self.layer2 = model_resnet34.layer2
    73.         self.layer3 = model_resnet34.layer3
    74.         self.layer4 = model_resnet34.layer4
    75.         self.avgpool = model_resnet34.avgpool
    76.         self.__in_features = model_resnet34.fc.in_features
    77.  
    78.     def forward(self, x):
    79.         x = self.conv1(x)
    80.         x = self.bn1(x)
    81.         x = self.relu(x)
    82.         x = self.maxpool(x)
    83.         x = self.layer1(x)
    84.         x = self.layer2(x)
    85.         x = self.layer3(x)
    86.         x = self.layer4(x)
    87.         x = self.avgpool(x)
    88.         x = x.view(x.size(0), -1)
    89.         return x
    90.  
    91.     def output_num(self):
    92.         return self.__in_features
    93.  
    94.  
    95. class ResNet50Fc(nn.Module):
    96.     def __init__(self):
    97.         super(ResNet50Fc, self).__init__()
    98.         model_resnet50 = models.resnet50(pretrained=True)
    99.         self.conv1 = model_resnet50.conv1
    100.         self.bn1 = model_resnet50.bn1
    101.         self.relu = model_resnet50.relu
    102.         self.maxpool = model_resnet50.maxpool
    103.         self.layer1 = model_resnet50.layer1
    104.         self.layer2 = model_resnet50.layer2
    105.         self.layer3 = model_resnet50.layer3
    106.         self.layer4 = model_resnet50.layer4
    107.         self.avgpool = model_resnet50.avgpool
    108.         self.__in_features = model_resnet50.fc.in_features
    109.  
    110.     def forward(self, x):
    111.         x = self.conv1(x)
    112.         x = self.bn1(x)
    113.         x = self.relu(x)
    114.         x = self.maxpool(x)
    115.         x = self.layer1(x)
    116.         x = self.layer2(x)
    117.         x = self.layer3(x)
    118.         x = self.layer4(x)
    119.         x = self.avgpool(x)
    120.         x = x.view(x.size(0), -1)
    121.         return x
    122.  
    123.     def output_num(self):
    124.         return self.__in_features
    125.  
    126.  
    127. class ResNet101Fc(nn.Module):
    128.     def __init__(self):
    129.         super(ResNet101Fc, self).__init__()
    130.         model_resnet101 = models.resnet101(pretrained=True)
    131.         self.conv1 = model_resnet101.conv1
    132.         self.bn1 = model_resnet101.bn1
    133.         self.relu = model_resnet101.relu
    134.         self.maxpool = model_resnet101.maxpool
    135.         self.layer1 = model_resnet101.layer1
    136.         self.layer2 = model_resnet101.layer2
    137.         self.layer3 = model_resnet101.layer3
    138.         self.layer4 = model_resnet101.layer4
    139.         self.avgpool = model_resnet101.avgpool
    140.         self.__in_features = model_resnet101.fc.in_features
    141.  
    142.     def forward(self, x):
    143.         x = self.conv1(x)
    144.         x = self.bn1(x)
    145.         x = self.relu(x)
    146.         x = self.maxpool(x)
    147.         x = self.layer1(x)
    148.         x = self.layer2(x)
    149.         x = self.layer3(x)
    150.         x = self.layer4(x)
    151.         x = self.avgpool(x)
    152.         x = x.view(x.size(0), -1)
    153.         return x
    154.  
    155.     def output_num(self):
    156.         return self.__in_features
    157.  
    158.  
    159. class ResNet152Fc(nn.Module):
    160.     def __init__(self):
    161.         super(ResNet152Fc, self).__init__()
    162.         model_resnet152 = models.resnet152(pretrained=True)
    163.         self.conv1 = model_resnet152.conv1
    164.         self.bn1 = model_resnet152.bn1
    165.         self.relu = model_resnet152.relu
    166.         self.maxpool = model_resnet152.maxpool
    167.         self.layer1 = model_resnet152.layer1
    168.         self.layer2 = model_resnet152.layer2
    169.         self.layer3 = model_resnet152.layer3
    170.         self.layer4 = model_resnet152.layer4
    171.         self.avgpool = model_resnet152.avgpool
    172.         self.__in_features = model_resnet152.fc.in_features
    173.  
    174.     def forward(self, x):
    175.         x = self.conv1(x)
    176.         x = self.bn1(x)
    177.         x = self.relu(x)
    178.         x = self.maxpool(x)
    179.         x = self.layer1(x)
    180.         x = self.layer2(x)
    181.         x = self.layer3(x)
    182.         x = self.layer4(x)
    183.         x = self.avgpool(x)
    184.         x = x.view(x.size(0), -1)
    185.         return x
    186.  
    187.     def output_num(self):
    188.         return self.__in_features
    189.  
    190.  
    191. network_dict = {"alexnet": AlexNetFc,
    192.                 "resnet18": ResNet18Fc,
    193.                 "resnet34": ResNet34Fc,
    194.                 "resnet50": ResNet50Fc,
    195.                 "resnet101": ResNet101Fc,
    196.                 "resnet152": ResNet152Fc}

    2、data_loader.py

            数据加载部分，对于训练集数据Resize成[256,256]大小再进行[224,224]的随机裁剪，后续操作以此为随机水平翻转、转为tensor、标准化；而对于测试集数据则直接Resize为[224,224]大小，后进行tensor化和标准化。

    1. from torchvision import datasets, transforms
    2. import torch
    3.  
    4. def load_data(data_folder, batch_size, train, kwargs):
    5.     transform = {
    6.         'train': transforms.Compose(
    7.             [transforms.Resize([256, 256]),
    8.                 transforms.RandomCrop(224),
    9.                 transforms.RandomHorizontalFlip(),
    10.                 transforms.ToTensor(),
    11.                 transforms.Normalize(mean=[0.485, 0.456, 0.406],
    12.                                   std=[0.229, 0.224, 0.225])]),
    13.         'test': transforms.Compose(
    14.             [transforms.Resize([224, 224]),
    15.                 transforms.ToTensor(),
    16.                 transforms.Normalize(mean=[0.485, 0.456, 0.406],
    17.                                   std=[0.229, 0.224, 0.225])])
    18.         }
    19.     data = datasets.ImageFolder(root = data_folder, transform=transform['train' if train else 'test'])
    20.     data_loader = torch.utils.data.DataLoader(data, batch_size=batch_size, shuffle=True, **kwargs, drop_last = True if train else False)
    21.     return data_loader
    22.

    3、mmd.py

            即论文提出的MMD loss，MMD（最大均值差异）是迁移学习，尤其是Domain adaptation （域适应）中使用最广泛（目前）的一种损失函数，主要用来度量两个不同但相关的分布的距离。两个分布的距离定义为：可以参考以下这篇博客。【代码阅读】最大均值差异（Maximum Mean Discrepancy, MMD）损失函数代码解读（Pytroch版）_Vincent_gc的博客-CSDN博客_mmd损失

    1. import torch
    2. import torch.nn as nn
    3.  
    4.  
    5. class MMD_loss(nn.Module):
    6.     def __init__(self, kernel_type='rbf', kernel_mul=2.0, kernel_num=5):
    7.         '''
    8.         source:源域数据（n * len(x))
    9. 	    target:目标域数据（m * len(y))
    10.         kernel_mul:核的倍数
    11.         kernel_num:多少个核
    12.         fix_sigma: 不同高斯核的sigma值
    13.         '''
    14.         super(MMD_loss, self).__init__()
    15.         self.kernel_num = kernel_num
    16.         self.kernel_mul = kernel_mul
    17.         self.fix_sigma = None
    18.         self.kernel_type = kernel_type
    19.  
    20.     def guassian_kernel(self, source, target, kernel_mul=2.0, kernel_num=5, fix_sigma=None):
    21.         n_samples = int(source.size()[0]) + int(target.size()[0]) # 求矩阵的行数，一般source和target的尺度是一样的，这样便于计算
    22.         total = torch.cat([source, target], dim=0) # 将source,target按列方向合并
    23.         # 将total复制（n+m）份
    24.         total0 = total.unsqueeze(0).expand(
    25.             int(total.size(0)), int(total.size(0)), int(total.size(1)))
    26.         # 将total的每一行都复制成（n+m）行，即每个数据都扩展成（n+m）份
    27.         total1 = total.unsqueeze(1).expand(
    28.             int(total.size(0)), int(total.size(0)), int(total.size(1)))
    29.         # 求任意两个数据之间的和，得到的矩阵中坐标（i,j）代表total中第i行数据和第j行数据之间的l2 distance(i==j时为0）
    30.         L2_distance = ((total0-total1)**2).sum(2)
    31.         # 调整高斯核函数的sigma值
    32.         if fix_sigma:
    33.             bandwidth = fix_sigma
    34.         else:
    35.             bandwidth = torch.sum(L2_distance.data) / (n_samples**2-n_samples)
    36.         # 以fix_sigma为中值，以kernel_mul为倍数取kernel_num个bandwidth值（比如fix_sigma为1时，得到[0.25,0.5,1,2,4]
    37.         bandwidth /= kernel_mul ** (kernel_num // 2)
    38.         bandwidth_list = [bandwidth * (kernel_mul**i)
    39.                           for i in range(kernel_num)]
    40.         # 高斯核函数的数学表达式
    41.         kernel_val = [torch.exp(-L2_distance / bandwidth_temp)
    42.                       for bandwidth_temp in bandwidth_list]
    43.         # 得到最终的核矩阵
    44.         return sum(kernel_val)
    45.  
    46.     def linear_mmd2(self, f_of_X, f_of_Y):
    47.         loss = 0.0
    48.         delta = f_of_X.float().mean(0) - f_of_Y.float().mean(0)
    49.         loss = delta.dot(delta.T)
    50.         return loss
    51.  
    52.     def forward(self, source, target):
    53.         if self.kernel_type == 'linear':
    54.             return self.linear_mmd2(source, target)
    55.         elif self.kernel_type == 'rbf':
    56.             batch_size = int(source.size()[0]) # 一般默认为源域和目标域的batchsize相同
    57.             kernels = self.guassian_kernel(
    58.                 source, target, kernel_mul=self.kernel_mul, kernel_num=self.kernel_num, fix_sigma=self.fix_sigma)
    59.             # 将核矩阵分成4部分
    60.             with torch.no_grad():
    61.                 XX = torch.mean(kernels[:batch_size, :batch_size])
    62.                 YY = torch.mean(kernels[batch_size:, batch_size:])
    63.                 XY = torch.mean(kernels[:batch_size, batch_size:])
    64.                 YX = torch.mean(kernels[batch_size:, :batch_size])
    65.                 loss = torch.mean(XX + YY - XY - YX) # 因为一般都是n==m，所以L矩阵一般不加入计算
    66.             torch.cuda.empty_cache()
    67.             return loss

     4、models.py

    1. import torch.nn as nn
    2. from Coral import CORAL
    3. import mmd
    4. import backbone
    5.  
    6.  
    7. class Transfer_Net(nn.Module):
    8.     def __init__(self, num_class, base_net='resnet50', transfer_loss='mmd', use_bottleneck=True, bottleneck_width=256, width=1024):
    9.         super(Transfer_Net, self).__init__()
    10.         self.base_network = backbone.network_dict[base_net]()
    11.         self.use_bottleneck = use_bottleneck
    12.         self.transfer_loss = transfer_loss
    13.         bottleneck_list = [nn.Linear(self.base_network.output_num(
    14.         ), bottleneck_width), nn.BatchNorm1d(bottleneck_width), nn.ReLU(), nn.Dropout(0.5)]
    15.         self.bottleneck_layer = nn.Sequential(*bottleneck_list)
    16.         classifier_layer_list = [nn.Linear(self.base_network.output_num(), width), nn.ReLU(), nn.Dropout(0.5),
    17.                                  nn.Linear(width, num_class)]
    18.         self.classifier_layer = nn.Sequential(*classifier_layer_list)
    19.  
    20.         self.bottleneck_layer[0].weight.data.normal_(0, 0.005)
    21.         self.bottleneck_layer[0].bias.data.fill_(0.1)
    22.         for i in range(2):
    23.             self.classifier_layer[i * 3].weight.data.normal_(0, 0.01)
    24.             self.classifier_layer[i * 3].bias.data.fill_(0.0)
    25.  
    26.     def forward(self, source, target):
    27.         source = self.base_network(source)
    28.         target = self.base_network(target)
    29.         source_clf = self.classifier_layer(source)
    30.         if self.use_bottleneck:
    31.             source = self.bottleneck_layer(source)
    32.             target = self.bottleneck_layer(target)
    33.         transfer_loss = self.adapt_loss(source, target, self.transfer_loss)
    34.         return source_clf, transfer_loss
    35.  
    36.     def predict(self, x):
    37.         features = self.base_network(x)
    38.         clf = self.classifier_layer(features)
    39.         return clf
    40.  
    41.     def adapt_loss(self, X, Y, adapt_loss):
    42.         """Compute adaptation loss, currently we support mmd and coral
    44.         Arguments:
    45.             X {tensor} -- source matrix
    46.             Y {tensor} -- target matrix
    47.             adapt_loss {string} -- loss type, 'mmd' or 'coral'. You can add your own loss
    49.         Returns:
    50.             [tensor] -- adaptation loss tensor
    51.         """
    52.         if adapt_loss == 'mmd':
    53.             mmd_loss = mmd.MMD_loss()
    54.             loss = mmd_loss(X, Y)
    55.         elif adapt_loss == 'coral':
    56.             loss = CORAL(X, Y)
    57.         else:
    58.             loss = 0
    59.         return loss

             以AlexNet为例，model.py中定义的base_network即直接调用backbone.py中的alexnet，根据网络结构图，下图即conv1-5以及fc6-7的结构，因为这部分源域和目标域均使用且参数共享，故作为base_network。

            而bottleneck_layer 即论文中提到的fc_adapt层，结构如下所示。

     5、main.py

    （1）参数设置

    1. # Command setting
    2. parser = argparse.ArgumentParser(description='DDC_DCORAL')
    3. parser.add_argument('--model', type=str, default='alexnet')
    4. parser.add_argument('--batchsize', type=int, default=2)
    5. parser.add_argument('--src', type=str, default='amazon')
    6. parser.add_argument('--tar', type=str, default='webcam')
    7. parser.add_argument('--n_class', type=int, default=31)
    8. parser.add_argument('--lr', type=float, default=1e-3)
    9. parser.add_argument('--n_epoch', type=int, default=100)
    10. parser.add_argument('--momentum', type=float, default=0.9)
    11. parser.add_argument('--decay', type=float, default=5e-4)
    12. parser.add_argument('--data', type=str, default='E:\Myself\Office31\Original_images')
    13. parser.add_argument('--early_stop', type=int, default=20)
    14. parser.add_argument('--lamb', type=float, default=10)
    15. parser.add_argument('--trans_loss', type=str, default='mmd')
    16. args = parser.parse_args()

     （2）test函数

    Pytorch：model.train()和model.eval()用法和区别，以及model.eval()和torch.no_grad()的区别_BEINTHEMEMENT的博客-CSDN博客_def train(model):

            model.eval()的作用是不启用 Batch Normalization 和 Dropout。如果模型中有BN层(Batch Normalization）和Dropout。在测试时添加model.eval()。model.eval()是保证BN层能够用全部训练数据的均值和方差，即测试过程中要保证BN层的均值和方差不变。对于Dropout，model.eval()是利用到了所有网络连接，即不进行随机舍弃神经元。

    1. def test(model, target_test_loader):
    2.     model.eval()
    3.     test_loss = utils.AverageMeter()
    4.     correct = 0
    5.     criterion = torch.nn.CrossEntropyLoss()
    6.     len_target_dataset = len(target_test_loader.dataset)
    7.     with torch.no_grad():
    8.         for data, target in target_test_loader:
    9.             data, target = data.to(DEVICE), target.to(DEVICE)
    10.             s_output = model.predict(data)
    11.             loss = criterion(s_output, target)
    12.             test_loss.update(loss.item())
    13.             pred = torch.max(s_output, 1)[1]
    14.             correct += torch.sum(pred == target)
    15.     acc = 100. * correct / len_target_dataset
    16.     return acc

    （3）train函数

            model.train()的作用是启用 Batch Normalization 和 Dropout。如果模型中有BN层(Batch Normalization）和Dropout，需要在训练时添加model.train()。model.train()是保证BN层能够用到每一批数据的均值和方差。对于Dropout，model.train()是随机取一部分网络连接来训练更新参数。

    1. def train(source_loader, target_train_loader, target_test_loader, model, optimizer):
    2.     len_source_loader = len(source_loader)
    3.     len_target_loader = len(target_train_loader)
    4.     best_acc = 0
    5.     stop = 0
    6.     for e in range(args.n_epoch):
    7.         stop += 1
    8.         train_loss_clf = utils.AverageMeter()
    9.         train_loss_transfer = utils.AverageMeter()
    10.         train_loss_total = utils.AverageMeter()
    11.         model.train()
    12.         iter_source, iter_target = iter(source_loader), iter(target_train_loader)
    13.         n_batch = min(len_source_loader, len_target_loader)
    14.         criterion = torch.nn.CrossEntropyLoss()
    15.         for _ in range(n_batch):
    16.             data_source, label_source = iter_source.next()
    17.             data_target, _ = iter_target.next()
    18.             data_source, label_source = data_source.to(
    19.                 DEVICE), label_source.to(DEVICE)
    20.             data_target = data_target.to(DEVICE)
    21.  
    22.             optimizer.zero_grad()
    23.             label_source_pred, transfer_loss = model(data_source, data_target)
    24.             clf_loss = criterion(label_source_pred, label_source)
    25.             loss = clf_loss + args.lamb * transfer_loss
    26.             loss.backward()
    27.             optimizer.step()
    28.             train_loss_clf.update(clf_loss.item())
    29.             train_loss_transfer.update(transfer_loss.item())
    30.             train_loss_total.update(loss.item())
    31.         # Test
    32.         acc = test(model, target_test_loader)
    33.         log.append([train_loss_clf.avg, train_loss_transfer.avg, train_loss_total.avg])
    34.         np_log = np.array(log, dtype=float)
    35.         np.savetxt('train_log.csv', np_log, delimiter=',', fmt='%.6f')
    36.         print('Epoch: [{:2d}/{}], cls_loss: {:.4f}, transfer_loss: {:.4f}, total_Loss: {:.4f}, acc: {:.4f}'.format(
    37.                     e, args.n_epoch, train_loss_clf.avg, train_loss_transfer.avg, train_loss_total.avg, acc))
    38.         if best_acc < acc:
    39.             best_acc = acc
    40.             stop = 0
    41.         if stop >= args.early_stop:
    42.             break
    43.     print('Transfer result: {:.4f}'.format(best_acc))

    （4）数据加载和main

    1.  
    2. # 方便自己电脑运行，num_workers更改为1，原代码为4
    3. def load_data(src, tar, root_dir):
    4.     folder_src = os.path.join(root_dir, src)
    5.     folder_tar = os.path.join(root_dir, tar)
    6.     source_loader = data_loader.load_data(
    7.         folder_src, args.batchsize, True, {'num_workers': 1})
    8.     target_train_loader = data_loader.load_data(
    9.         folder_tar, args.batchsize, True, {'num_workers': 1})
    10.     target_test_loader = data_loader.load_data(
    11.         folder_tar, args.batchsize, False, {'num_workers': 1})
    12.     return source_loader, target_train_loader, target_test_loader
    13.  
    14.  
    15. if __name__ == '__main__':
    16.     torch.manual_seed(0)
    17.  
    18.     source_name = "amazon"
    19.     target_name = "webcam"
    20.  
    21.     print('Src: %s, Tar: %s' % (source_name, target_name))
    22.     print('Backbone: %s,Loss: %s' % (args.model, args.trans_loss))
    23.  
    24.     source_loader, target_train_loader, target_test_loader = load_data(
    25.         source_name, target_name, args.data)
    26.  
    27.     model = models.Transfer_Net(
    28.         args.n_class, transfer_loss=args.trans_loss, base_net=args.model).to(DEVICE)
    29.     print(model)
    30.     optimizer = torch.optim.SGD([
    31.         {'params': model.base_network.parameters()},
    32.         {'params': model.bottleneck_layer.parameters(), 'lr': 10 * args.lr},
    33.         {'params': model.classifier_layer.parameters(), 'lr': 10 * args.lr},
    34.     ], lr=args.lr, momentum=args.momentum, weight_decay=args.decay)
    35.  
    36.     train(source_loader, target_train_loader,
    37.           target_test_loader, model, optimizer)

    实验部分

            debugging~虽然跑通了但是跟论文和github给出的结果相差有点大？？

  • 相关阅读:
    从谷歌CRE谈起，运维如何培养服务意识?
    虚数是什么
    一文浅入Springboot+mybatis-plus+actuator+Prometheus+Grafana+Swagger2.9.2开发运维一体化
    【WINDOWS / DOS 批处理】call命令的变量延迟展开特性
    【学习笔记】4、组合逻辑电路(下)
    CocosCreator 3.x热更新学习
    画一个 “月饼” 陪我过中秋，玩转炫彩 “月饼” 之 基本测试
    2022前端面试题上岸手册-Vue部分
    java中泛型（一）
    拓端tecdat|Python之LDA主题模型算法应用
  • 原文地址：https://blog.csdn.net/weixin_44855366/article/details/126704430