一、准备数据

代码

  1. import torchvision
  2. import torchvision.transforms as transforms
  3. from torch.utils.data import DataLoader
  5. # ========================================准备数据========================================
  6. # 定义预处理函数
  7. transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
  8. """
  9. ①transfom.Compose可以把一些转换函数组合在一起。
  10. ②transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))对张量进行归一化：图像有三个通道，每个通道均值0.5，方差0.5。)
  11. """
  12. # 下载CIFAR10数据，并对数据进行预处理
  13. trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=False, transform=transform)
  14. testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=False, transform=transform)
  15. # 得到一个生成器
  16. trainloader = DataLoader(trainset, batch_size=4, shuffle=True)
  17. testloader = DataLoader(testset, batch_size=4, shuffle=False)  # 数据分批
  18. """
  19. ①dataloader是一个可迭代对象，可以使用迭代器一样使用。
  20. ②用DataLoader得到生成器，这可节省内存。
  21. """
  22. # 分类类别
  23. classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
  25. # ========================================可视化源数据========================================
  26. import matplotlib.pyplot as plt
  27. import numpy as np
  29. # 显示图像
  30. def imshow(img):
  31.     img = img / 2 + 0.5  # unnormalize反归一化：img = img * std + mu
  32.     npimg = img.numpy()  # 将图片转换为数组
  33.     plt.imshow(np.transpose(npimg, (1, 2, 0)))  # transpose对高维矩阵进行轴对换：把图片中表示颜色顺序的RGB改为GBR
  34.     # 显示图像
  35.     plt.xticks([])
  36.     plt.yticks([])
  37.     plt.show()
  39. # 随机获取部分训练数据
  40. dataiter = iter(trainloader)
  41. images, labels = dataiter.next()
  42. # 打印标签
  43. print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
  44. # 显示图像
  45. imshow(torchvision.utils.make_grid(images))

运行结果

  1. horse  ship truck plane

二、全连接层FC

代码

  1. from 准备数据 import trainloader,images,classes,testloader
  3. # ========================================构建网络========================================
  4. import torch
  5. import torch.nn as nn
  6. import torch.nn.functional as F
  7. # 检测是否有GPU，有则使用，否则使用CPU
  8. device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")  # cuda:0表示使用第一块GPU；若有显卡torch.cuda.is_available()返回True
  9. """
  10. #若有多块显卡可并行化训练：
  11. if torch.cuda.device_count() > 1:
  12.     print("Let's use", torch.cuda.device_count(), "GPUs")
  13.     dim = 0 [20, xxx] -> [10, ...], [10, ...] on 2GPUs
  14.     model = nn.DataParallel(model)
  15. """
  17. # --------------------构建卷积网络--------------------
  18. class CNNNet(nn.Module):
  19.     def __init__(self):
  20.         super(CNNNet, self).__init__()
  21.         self.conv1 = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=(5,5), stride=(1,1))         #卷积层1
  22.         self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)                                              #池化层1
  23.         self.conv2 = nn.Conv2d(in_channels=16, out_channels=36, kernel_size=(3,3), stride=(1,1))        #卷积层2
  24.         self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)                                              #池化层2
  26.         self.fc1 = nn.Linear(1296, 128)                                                                 #全连接层1
  27.         self.fc2 = nn.Linear(128, 10)                                                                   #全连接层2
  29.     def forward(self, x):
  30.         x = self.pool1(F.relu(self.conv1(x)))
  31.         x = self.pool2(F.relu(self.conv2(x)))
  32.         x = x.view(-1, 36 * 6 * 6)
  33.         x = F.relu(self.fc2(F.relu(self.fc1(x))))
  34.         return x
  36. # --------------------实例化网络--------------------
  37. net = CNNNet()           #实例化网络
  38. net = net.to(device)     #使用GPU训练
  40. # 定义损失函数和优化器
  41. import torch.optim as optim
  42. criterion = nn.CrossEntropyLoss()
  43. optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
  44. #optimizer = optim.Adam(net.parameters(), lr=0.001)
  45. """
  46. model.parameters()：传入模型参数；
  47. lr：学习率；
  48. momentum：动量，更新缩减和平移参数的频率和幅度，结合当前梯度与上一次更新信息用于当前更新
  49. """
  51. # ========================================训练模型========================================
  52. import time
  53. for epoch in range(10):
  54.     start = time.time()
  55.     running_loss = 0.0
  56.     for i, data in enumerate(trainloader, 0):
  57.         # 获取训练数据
  58.         inputs, labels = data   #解包元组
  59.         inputs, labels = inputs.to(device), labels.to(device)       #将数据放在GPU上
  60.         # 前向传播
  61.         outputs = net(inputs)
  62.         loss = criterion(outputs, labels)
  63.         # 反向传播
  64.         optimizer.zero_grad()   #清空上一步的残余更新参数值，将神经网络参数梯度降为0
  65.         loss.backward()         #误差反向传递，计算参数更新值
  66.         optimizer.step()        #优化梯度，将参数更新值施加到net的parameters上
  67.         # 记录误差
  68.         running_loss += loss.item()
  69.         # 每2000步打印损失
  70.         if i % 2000 == 1999:
  71.             print('[%d, %5d] loss: %.3f, time:%.2f' % (epoch + 1, i + 1, running_loss / 2000, time.time()-start))
  72.             running_loss = 0.0
  73. print('训练完成')
  75. # 预测结果
  76. images, labels = images.to(device), labels.to(device)
  77. outputs = net(images)
  78. _, predicted = torch.max(outputs, 1)    #输出值的最大值作为预测值
  79. print('预测结果: ', ' '.join('%5s' % classes[predicted[j]]for j in range(4)))
  81. # ========================================测试模型========================================
  82. # --------------------整体预测准确率--------------------
  83. correct = 0
  84. total = 0
  85. with torch.no_grad():
  86.     # 从测试数据中取出数据
  87.     for data in testloader:
  88.         images, labels = data
  89.         images, labels = images.to(device), labels.to(device)
  90.         outputs = net(images)
  91.         _, predicted = torch.max(outputs.data, 1)   #模型预测的最大值作为预测值
  93.         total += labels.size(0) #统计测试图片个数
  94.         correct += (predicted == labels).sum().item()   #统计正确预测的图片数
  95. print('10000张测试图片的准确率：%d%%' % (100 * correct / total))
  97. # --------------------每个类别预测准确率--------------------
  98. class_correct = list(0. for i in range(10)) #正确的类别个数
  99. class_total = list(0. for i in range(10))   #一共10个类别
  100. with torch.no_grad():
  101.     # 从测试数据中取出数据
  102.     for data in testloader:
  103.         images, labels = data
  104.         images, labels = images.to(device), labels.to(device)
  105.         outputs = net(images)
  106.         _, predicted = torch.max(outputs, 1)
  108.         c = (predicted == labels).squeeze()         #预测正确的返回True，预测错误的返回False；squeeze将数据转换为一维数据
  109.         for i in range(4):
  110.             label = labels[i]                       #提取标签
  111.             class_correct[label] += c[i].item()     #预测正确个数
  112.             class_total[label] += 1                 #总数
  113. for i in range(10):
  114.     print('%5s的准确率:%2d%%' % (classes[i], 100 * class_correct[i] / class_total[i]))

运行结果

  1. plane   car  deer horse
  1. [1,  2000] loss: 2.167, time:5.35
  2. [1,  4000] loss: 1.979, time:9.37
  3. [1,  6000] loss: 1.842, time:13.38
  4. [1,  8000] loss: 1.732, time:17.44
  5. [1, 10000] loss: 1.474, time:21.50
  6. [1, 12000] loss: 1.380, time:25.49
  7. [2,  2000] loss: 1.246, time:4.10
  8. [2,  4000] loss: 1.210, time:8.21
  9. [2,  6000] loss: 1.180, time:12.33
  10. [2,  8000] loss: 1.156, time:16.47
  11. [2, 10000] loss: 1.088, time:20.49
  12. [2, 12000] loss: 1.063, time:24.45
  13. [3,  2000] loss: 0.987, time:3.99
  14. [3,  4000] loss: 0.975, time:7.97
  15. [3,  6000] loss: 0.970, time:11.93
  16. [3,  8000] loss: 0.947, time:15.89
  17. [3, 10000] loss: 0.964, time:19.85
  18. [3, 12000] loss: 0.930, time:23.81
  19. [4,  2000] loss: 0.814, time:3.98
  20. [4,  4000] loss: 0.831, time:7.93
  21. [4,  6000] loss: 0.833, time:11.91
  22. [4,  8000] loss: 0.829, time:15.86
  23. [4, 10000] loss: 0.841, time:19.81
  24. [4, 12000] loss: 0.826, time:23.78
  25. [5,  2000] loss: 0.701, time:3.98
  26. [5,  4000] loss: 0.708, time:7.93
  27. [5,  6000] loss: 0.710, time:11.88
  28. [5,  8000] loss: 0.746, time:15.84
  29. [5, 10000] loss: 0.734, time:19.81
  30. [5, 12000] loss: 0.756, time:23.78
  31. [6,  2000] loss: 0.582, time:4.23
  32. [6,  4000] loss: 0.597, time:8.23
  33. [6,  6000] loss: 0.628, time:12.22
  34. [6,  8000] loss: 0.661, time:16.20
  35. [6, 10000] loss: 0.667, time:20.18
  36. [6, 12000] loss: 0.678, time:24.14
  37. [7,  2000] loss: 0.494, time:3.98
  38. [7,  4000] loss: 0.543, time:7.94
  39. [7,  6000] loss: 0.576, time:11.92
  40. [7,  8000] loss: 0.577, time:15.89
  41. [7, 10000] loss: 0.586, time:19.85
  42. [7, 12000] loss: 0.604, time:23.83
  43. [8,  2000] loss: 0.442, time:4.02
  44. [8,  4000] loss: 0.457, time:7.97
  45. [8,  6000] loss: 0.494, time:11.96
  46. [8,  8000] loss: 0.524, time:15.93
  47. [8, 10000] loss: 0.521, time:19.92
  48. [8, 12000] loss: 0.558, time:23.90
  49. [9,  2000] loss: 0.349, time:3.99
  50. [9,  4000] loss: 0.389, time:7.96
  51. [9,  6000] loss: 0.408, time:11.92
  52. [9,  8000] loss: 0.464, time:15.88
  53. [9, 10000] loss: 0.500, time:19.85
  54. [9, 12000] loss: 0.490, time:23.82
  55. [10,  2000] loss: 0.319, time:4.00
  56. [10,  4000] loss: 0.354, time:7.98
  57. [10,  6000] loss: 0.356, time:12.02
  58. [10,  8000] loss: 0.428, time:16.11
  59. [10, 10000] loss: 0.422, time:20.06
  60. [10, 12000] loss: 0.447, time:24.25
  61. 训练完成
  62. 预测结果:  plane   car   dog horse
  63. 10000张测试图片的准确率：66%
  64. plane的准确率:72%
  65.   car的准确率:74%
  66.  bird的准确率:60%
  67.   cat的准确率:50%
  68.  deer的准确率:54%
  69.   dog的准确率:60%
  70.  frog的准确率:72%
  71. horse的准确率:68%
  72.  ship的准确率:80%
  73. truck的准确率:73%

三、全局平均池化层GAP

代码

  1. from 准备数据 import trainloader, testloader, classes, images
  3. # ========================================构建网络========================================
  4. import torch
  5. import torch.nn as nn
  6. import torch.nn.functional as F
  7. device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
  9. # --------------------构建卷积网络--------------------
  10. class Net(nn.Module):
  11.     def __init__(self):
  12.         super(Net, self).__init__()
  13.         self.conv1 = nn.Conv2d(3, 16, 5)    #卷积层1
  14.         self.pool1 = nn.MaxPool2d(2, 2)     #池化层1
  15.         self.conv2 = nn.Conv2d(16, 36, 5)   #卷积层2
  16.         self.pool2 = nn.MaxPool2d(2, 2)     #池化层2
  18.         self.aap=nn.AdaptiveAvgPool2d(1)    #全局平均池化层
  19.         self.fc3 = nn.Linear(36, 10)        #全连接层
  21.     def forward(self, x):
  22.         x = self.pool1(F.relu(self.conv1(x)))   #卷积层1->激励函数层->池化层1
  23.         x = self.pool2(F.relu(self.conv2(x)))   #卷积层2->激励函数层->池化层2
  24.         x = self.aap(x)
  25.         x = x.view(x.shape[0], -1)
  26.         x = self.fc3(x)
  27.         return x
  28. # --------------------实例化网络--------------------
  29. net = Net()
  30. net=net.to(device)
  32. # 定义损失函数和优化器
  33. import torch.optim as optim
  34. criterion = nn.CrossEntropyLoss()
  35. optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
  37. # ========================================训练模型========================================
  38. import time
  39. for epoch in range(10):
  40.     start=time.time()
  41.     running_loss = 0.0
  42.     for i, data in enumerate(trainloader, 0):
  43.         # 获取训练数据
  44.         inputs, labels = data   #解包元组
  45.         inputs, labels = inputs.to(device), labels.to(device)   #将数据放在GPU上
  46.         # 前向传播
  47.         outputs = net(inputs)
  48.         loss = criterion(outputs, labels)
  49.         # 反向传播
  50.         optimizer.zero_grad()  # 清空上一步的残余更新参数值，将神经网络参数梯度降为0
  51.         loss.backward()  # 误差反向传递，计算参数更新值
  52.         optimizer.step()  # 优化梯度，将参数更新值施加到net的parameters上
  53.         # 记录误差
  54.         running_loss += loss.item()
  55.         # 每2000步打印损失
  56.         if i % 2000 == 1999:
  57.             print('[%d, %5d] loss: %.3f, time:%.2f' % (epoch + 1, i + 1, running_loss / 2000, time.time()-start))
  58.             running_loss = 0.0
  59. print('训练完成')
  61. # 预测结果
  62. images, labels = images.to(device), labels.to(device)
  63. outputs = net(images)
  64. _, predicted = torch.max(outputs, 1)    #输出值的最大值作为预测值
  65. print('预测结果: ', ' '.join('%5s' % classes[predicted[j]]for j in range(4)))
  67. # ========================================测试模型========================================
  68. # --------------------整体预测准确率--------------------
  69. correct = 0
  70. total = 0
  71. with torch.no_grad():
  72.     # 从测试数据中取出数据
  73.     for data in testloader:
  74.         images, labels = data
  75.         images, labels = images.to(device), labels.to(device)
  76.         outputs = net(images)
  77.         _, predicted = torch.max(outputs.data, 1)   #模型预测的最大值作为预测值
  79.         total += labels.size(0) #统计测试图片个数
  80.         correct += (predicted == labels).sum().item()   #统计正确预测的图片数
  81. print('10000张测试图片的准确率：%d%%' % (100 * correct / total))
  83. # --------------------每个类别预测准确率--------------------
  84. class_correct = list(0. for i in range(10)) #正确的类别个数
  85. class_total = list(0. for i in range(10))   #一共10个类别
  86. with torch.no_grad():
  87.     # 从测试数据中取出数据
  88.     for data in testloader:
  89.         images, labels = data
  90.         images, labels = images.to(device), labels.to(device)
  91.         outputs = net(images)
  92.         _, predicted = torch.max(outputs, 1)
  94.         c = (predicted == labels).squeeze()         #预测正确的返回True，预测错误的返回False；squeeze将数据转换为一维数据
  95.         for i in range(4):
  96.             label = labels[i]                       #提取标签
  97.             class_correct[label] += c[i].item()     #预测正确个数
  98.             class_total[label] += 1                 #总数
  99. for i in range(10):
  100.     print('%5s的准确率:%2d%%' % (classes[i], 100 * class_correct[i] / class_total[i]))

运行结果

  1. deer  ship horse plane
  1. [1,  2000] loss: 2.129, time:5.14
  2. [1,  4000] loss: 1.875, time:8.86
  3. [1,  6000] loss: 1.741, time:12.61
  4. [1,  8000] loss: 1.693, time:16.29
  5. [1, 10000] loss: 1.638, time:20.04
  6. [1, 12000] loss: 1.598, time:23.71
  7. [2,  2000] loss: 1.549, time:3.71
  8. [2,  4000] loss: 1.504, time:7.43
  9. [2,  6000] loss: 1.484, time:11.13
  10. [2,  8000] loss: 1.461, time:14.89
  11. [2, 10000] loss: 1.431, time:18.68
  12. [2, 12000] loss: 1.407, time:22.37
  13. [3,  2000] loss: 1.376, time:3.69
  14. [3,  4000] loss: 1.343, time:7.37
  15. [3,  6000] loss: 1.349, time:11.18
  16. [3,  8000] loss: 1.324, time:14.89
  17. [3, 10000] loss: 1.303, time:18.60
  18. [3, 12000] loss: 1.297, time:22.36
  19. [4,  2000] loss: 1.262, time:3.69
  20. [4,  4000] loss: 1.250, time:7.36
  21. [4,  6000] loss: 1.246, time:11.01
  22. [4,  8000] loss: 1.240, time:14.68
  23. [4, 10000] loss: 1.239, time:18.35
  24. [4, 12000] loss: 1.232, time:22.00
  25. [5,  2000] loss: 1.185, time:3.69
  26. [5,  4000] loss: 1.214, time:7.34
  27. [5,  6000] loss: 1.194, time:11.01
  28. [5,  8000] loss: 1.175, time:14.67
  29. [5, 10000] loss: 1.148, time:18.36
  30. [5, 12000] loss: 1.174, time:22.03
  31. [6,  2000] loss: 1.113, time:3.70
  32. [6,  4000] loss: 1.160, time:7.36
  33. [6,  6000] loss: 1.129, time:11.03
  34. [6,  8000] loss: 1.144, time:14.70
  35. [6, 10000] loss: 1.125, time:18.35
  36. [6, 12000] loss: 1.110, time:22.01
  37. [7,  2000] loss: 1.103, time:3.70
  38. [7,  4000] loss: 1.100, time:7.34
  39. [7,  6000] loss: 1.098, time:11.02
  40. [7,  8000] loss: 1.091, time:14.67
  41. [7, 10000] loss: 1.077, time:18.32
  42. [7, 12000] loss: 1.076, time:21.97
  43. [8,  2000] loss: 1.065, time:3.68
  44. [8,  4000] loss: 1.066, time:7.33
  45. [8,  6000] loss: 1.037, time:10.99
  46. [8,  8000] loss: 1.058, time:14.65
  47. [8, 10000] loss: 1.054, time:18.31
  48. [8, 12000] loss: 1.064, time:21.96
  49. [9,  2000] loss: 1.060, time:3.68
  50. [9,  4000] loss: 1.024, time:7.33
  51. [9,  6000] loss: 1.032, time:10.99
  52. [9,  8000] loss: 1.029, time:14.66
  53. [9, 10000] loss: 1.029, time:18.30
  54. [9, 12000] loss: 1.011, time:21.96
  55. [10,  2000] loss: 0.995, time:3.67
  56. [10,  4000] loss: 1.023, time:7.33
  57. [10,  6000] loss: 1.007, time:11.00
  58. [10,  8000] loss: 1.020, time:14.64
  59. [10, 10000] loss: 0.996, time:18.29
  60. [10, 12000] loss: 1.014, time:21.96
  61. 训练完成
  62. 预测结果:   frog   car horse plane
  63. 10000张测试图片的准确率：63%
  64. plane的准确率:66%
  65.   car的准确率:73%
  66.  bird的准确率:51%
  67.   cat的准确率:57%
  68.  deer的准确率:43%
  69.   dog的准确率:32%
  70.  frog的准确率:76%
  71. horse的准确率:74%
  72.  ship的准确率:81%
  73. truck的准确率:79%

四、程序分析

本程序用了两种方法构建卷积神经网络，即全局平均池化和不采用全局平均池化。通过程序的运行结果可以看出，不采用全局平均池化相较采用全局平均池化准确率更高，但训练时间更长。


        两种方法构建卷积神经网络时，同样采用两个卷积层和两个池化层（MaxPool2d），但不采用全局平均池化的神经网络使用了两个全连接层，采用全局平均池化的神经网络只使用了一个全连接测。
        相较之下，使用全局平均池化层能减少很多参数，可以减轻过拟合的发生，而且在减少参数的同时，其泛化能力也比较好。

PyTorch程序练习（一）：PyTorch实现CIFAR-10多分类的更多相关文章

  1. 【翻译】TensorFlow卷积神经网络识别CIFAR 10Convolutional Neural Network (CNN)| CIFAR 10 TensorFlow

    原网址:https://data-flair.training/blogs/cnn-tensorflow-cifar-10/ by DataFlair Team · Published May 21, ...

  2. 解决运行pytorch程序多线程问题

    当我使用pycharm运行  (https://github.com/Joyce94/cnn-text-classification-pytorch )  pytorch程序的时候,在Linux服务器 ...

  3. 转：程序员最值得关注的10个C开源项目

    程序员最值得关注的10个C开源项目 1. Webbench Webbench 是一个在 linux 下使用的非常简单的网站压测工具.它使用 fork ()模拟多个客户端同时访问我们设定的 URL,测试 ...

  4. 程序员从初级到中级10个秘诀——摘自CSDN

    程序员从初级到中级10个秘诀 1.学习先进的搜索技术.手段和及策略 2.帮助别人 教别人始终是学习一切东西的最好方法之一.相对而言,由于你在开发领域还是个新手,认为自己没什么可教给人家的,这可以理解. ...

  5. 【转载】PyTorch系列 (二)：pytorch数据读取

    原文:https://likewind.top/2019/02/01/Pytorch-dataprocess/ Pytorch系列: PyTorch系列(一) - PyTorch使用总览 PyTorc ...

  6. DL Practice：Cifar 10分类

    Step 1:数据加载和处理 一般使用深度学习框架会经过下面几个流程: 模型定义(包括损失函数的选择)——>数据处理和加载——>训练(可能包括训练过程可视化)——>测试 所以自己写代 ...

  7. Pytorch学习--编程实战：猫和狗二分类

    Pytorch学习系列(一)至(四)均摘自<深度学习框架PyTorch入门与实践>陈云 目录: 1.程序的主要功能 2.文件组织架构 3. 关于`__init__.py` 4.数据处理 5 ...

  8. PyTorch迁移学习-私人数据集上的蚂蚁蜜蜂分类

    迁移学习的两个主要场景 微调CNN:使用预训练的网络来初始化自己的网络,而不是随机初始化,然后训练即可 将CNN看成固定的特征提取器:固定前面的层,重写最后的全连接层,只有这个新的层会被训练 下面修改 ...

  9. 【小白学PyTorch】15 TF2实现一个简单的服装分类任务

    [新闻]:机器学习炼丹术的粉丝的人工智能交流群已经建立,目前有目标检测.医学图像.时间序列等多个目标为技术学习的分群和水群唠嗑的总群,欢迎大家加炼丹兄为好友,加入炼丹协会.微信:cyx64501661 ...

  10. 了解Pytorch|Get Started with PyTorch

    一个开源的机器学习框架,加速了从研究原型到生产部署的路径. !pip install torch -i https://pypi.tuna.tsinghua.edu.cn/simple import ...

随机推荐

  1. 您可知道如何通过`HTTP2`实现TCP的内网穿透？？？

    可能有人很疑惑应用层 转发传输层?,为什么会有这样的需求啊???哈哈技术无所不用其极,由于一些场景下,对于一个服务器存在某一个内部网站中,但是对于这个服务器它没有访问外网的权限,虽然也可以申请端口访问 ...

  2. 用Vue仿了一个类似抖音的App

    大家好,我是 Java陈序员. 今天,给大家介绍一个基于 Vue3 实现的高仿抖音开源项目. 关注微信公众号:[Java陈序员],获取开源项目分享.AI副业分享.超200本经典计算机电子书籍等. 项目 ...

  3. 11K+ Star！图解计算机网络、操作系统、计算机组成、数据库！

    大家好,我是 Java陈序员. 俗话说得好,面试造火箭,入职拧螺丝.我们在工作中,其实很少用到一些计算机底层知识,往往只要编码完事.但是,知其然还要知其所以然,我们不仅要做一个合格的"CV ...

  4. 免费的visual studio智能代码插件——CodeGeeX

    CodeGeeX是什么?什么是CodeGeeX? CodeGeeX是一款基于大模型的智能编程助手,它可以实现代码的生成与补全,自动为代码添加注释,不同编程语言的代码间实现互译,针对技术和代码问题的智能 ...

  5. 02 go-zero入门--微服务demo

    参考文档: https://go-zero.dev/cn/docs/advance/rpc-call 视频地址: https://space.bilibili.com/387126464/channe ...

  6. fastposter v2.9.3 简单易用的海报生成器

    fastposter海报生成器是一款快速开发海报的工具.只需上传一张背景图,在对应的位置放上组件(文字.图片.二维.头像)即可生成海报. 点击代码直接生成各种语言的调用代码,方便快速开发. 现已服务众 ...

  7. 机器学习策略篇：详解为什么是人的表现？（Why human-level performance?）

    为什么是人的表现? 在过去的几年里,更多的机器学习团队一直在讨论如何比较机器学习系统和人类的表现,为什么呢? 认为有两个主要原因,首先是因为深度学习系统的进步,机器学习算法突然变得更好了.在许多机器学 ...

  8. 部署springboot+vue项目文档（若依ruoyi项目部署步骤）

    摘自:https://blog.csdn.net/Dreamboy_w/article/details/104389797 部署springboot+vue项目文档(若依ruoyi项目部署步骤)一:部 ...

  9. mysql in不走索引可能的情况

    在MySQL 5.7.3以及之前的版本中,eq_range_index_dive_limit的默认值为10,之 后的版本默认值为200.所以如果大家采用的是5.7.3以及之前的版本的话,很容易采用索引 ...

  10. Windows中实现将bat或exe文件作为服务_且实现命令行安装、配置、启动、删除服务

    一.背景描述 在Windows环境下进行日常的项目开发过程中,有时候需要将bat文件或exe文件程序注册为Windows的服务实现开机自己运行(没有用户登陆,服务在开机后也可以照常运行).且对于那些没 ...