प्रौद्योगिकी साझेदारी

आदर्श छंटनीयाः परिचयः

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

सन्दर्भः २.https://www.cnblogs.com/the-art-of-ai/p/17500399.html

1. पृष्ठभूमिपरिचयः

गहनशिक्षणप्रतिमानैः चित्रपरिचयः, प्राकृतिकभाषाप्रक्रियाकरणं, वाक्परिचयः इत्यादिषु क्षेत्रेषु उल्लेखनीयपरिणामाः प्राप्ताः, परन्तु एतेषु प्रतिरूपेषु प्रायः गणनासंसाधनानाम्, भण्डारणस्थानस्य च महती मात्रा आवश्यकी भवति विशेषतः संसाधन-संकुचित-वातावरणेषु यथा चलयन्त्राणि, एम्बेडेड्-प्रणाली च, एतेषां प्रतिरूपानाम् आकारः, गणनाजटिलता च प्रायः अटङ्काः भवन्ति ये तेषां अनुप्रयोगं सीमितं कुर्वन्ति अतः प्रतिरूपस्य सटीकताम् अवलम्ब्य यथासम्भवं प्रतिरूपस्य आकारं गणनाजटिलतां च कथं न्यूनीकर्तुं शक्यते इति महत्त्वपूर्णा शोधदिशा अभवत्

अस्याः समस्यायाः समाधानार्थं आदर्श-छंटाई-प्रौद्योगिकी एकः प्रभावी पद्धतिः अस्ति ।गहनशिक्षणप्रतिरूपस्य संरचनायाः अनुकूलनं कृत्वा मापदण्डान् न्यूनीकृत्य च, प्रतिरूपस्य आकारः लघुः भवति तथा च सटीकतां निर्वाहयन् द्रुततरं चालनवेगं भवति, तस्मात् भिन्नकार्यस्य वातावरणस्य च अनुकूलतां प्राप्नोति

2. मूलभूतसिद्धान्ताः

        आदर्श छंटाई प्रौद्योगिकी गहनशिक्षणप्रतिरूपस्य संरचनात्मकअनुकूलनस्य पैरामीटर् न्यूनीकरणस्य च प्रौद्योगिकीम् निर्दिशति । .छंटनीप्रौद्योगिक्याः विभक्तुं शक्यतेसंरचनात्मक छंटनीतथापैरामीटर छंटाईरूपद्वयम् ।

संरचनात्मकं छंटाई केषाञ्चन निष्कासनं निर्दिशतिअनावश्यक संरचनात्मक इकाई , यथा न्यूरॉन्स, कन्वोल्यूशन कर्नेल्, लेयर इत्यादयः, मॉडलस्य गणनाजटिलतां भण्डारणस्थानं च न्यूनीकर्तुं । सामान्य संरचनात्मक छंटाई पद्धतयः सन्ति : चैनल छंटाई, स्तर छंटाई, नोड छंटाई, फ़िल्टर छंटाई इत्यादयः ।

पैरामीटर् प्रूनिंग् इति गहनशिक्षणप्रतिमानात् आँकडानां निष्कासनं निर्दिशतिकेचन अनावश्यकभारमापदण्डाः निष्कासयन्तु , प्रतिरूपस्य सटीकताम् अवलम्ब्य प्रतिरूपस्य भण्डारणस्थानं गणनाजटिलतां च न्यूनीकर्तुं । सामान्यपैरामीटर् छंटाईविधयः सन्ति: L1 नियमितीकरणं, L2 नियमितीकरणं, छंटाई छंटाई, स्थानीयता-संवेदनशीलं हैश छंटाई इत्यादयः ।

3. तकनीकी सिद्धान्त

        मॉडल-प्रूनिंग-प्रौद्योगिक्याः मूलविचारः अस्ति यत् मॉडलस्य सटीकताम् अवलम्ब्य यथासम्भवं मॉडलस्य भण्डारणस्थानं, गणनाजटिलतां च न्यूनीकर्तुं शक्यतेयतो हि गहनशिक्षणप्रतिरूपेषु न्यूरॉन्स, कन्वोल्यूशन कर्नेल्, भारमापदण्डाः इत्यादीनां संरचनात्मक-एककानां मापदण्डानां च प्रायः अनावश्यकं अनावश्यकं च भागं भवति, अतः एतेषां अनावश्यकभागानाम् न्यूनीकरणाय छंटाई-प्रौद्योगिक्याः उपयोगः कर्तुं शक्यते, येन मॉडलस्य आयतनं न्यूनीकरोति तथा च The effect of computational complexity

विशेषतः, आदर्श छंटाई प्रौद्योगिक्याः कार्यान्वयनम् निम्नलिखितपदार्थेषु विभक्तुं शक्यते ।

(1) प्रथमं गहनशिक्षणप्रतिरूपस्य आरम्भं कृत्वा आधाररेखाप्रतिरूपं प्राप्तुं प्रशिक्षितुं;

(2) विशिष्टानुप्रयोगपरिदृश्यानां आवश्यकतानां च आधारेण छंटाई परिमाणीकरणपद्धतीनां रणनीतीनां च चयनं कुर्वन्तु;संरचनात्मक छंटाई तथा पैरामीटर छंटनी;सामान्यरणनीतयः सन्ति: वैश्विकछंटाई तथा पुनरावर्तनीय छंटाई;

(3) चयनित-छंटाई-विधि-रणनीत्याः आधारेण, गहन-शिक्षण-प्रतिरूपे छंटाई-क्रियाः कुर्वन्ति, केचन अनावश्यक-संरचनात्मक-एककाः भार-मापदण्डाः च विलोपयन्तु, अथवा तान् 0 अथवा अत्यन्तं लघु-मूल्यानि सेट् कुर्वन्तु

(4) प्रतिरूपस्य पुनः प्रशिक्षणं कृत्वा प्रतिरूपस्य सटीकता न्यूनीभवति अतः, प्रतिरूपस्य सटीकता पुनः स्थापयितुं छंटाईकृतस्य प्रतिरूपस्य पुनः प्रशिक्षणस्य आवश्यकता वर्तते;

(5) पुनः प्रशिक्षणस्य अनन्तरं मॉडलस्य सूक्ष्म-समायोजनं कुर्वन्तु;

संहिता : १.

  1. import torch
  2. import torch.nn as nn
  3. import torch.optim as optim
  4. import torch.nn.functional as F
  5. from torchvision import datasets, transforms
  6. # 定义一个简单的卷积神经网络
  7. class SimpleCNN(nn.Module):
  8. def __init__(self):
  9. super(SimpleCNN, self).__init__()
  10. self.conv1 = nn.Conv2d(1, 4, kernel_size=3, padding=1) # 4个输出通道
  11. self.conv2 = nn.Conv2d(4, 8, kernel_size=3, padding=1) # 8个输出通道
  12. self.fc1 = nn.Linear(8 * 7 * 7, 64)
  13. self.fc2 = nn.Linear(64, 10)
  14. def forward(self, x):
  15. x = F.relu(self.conv1(x)) # 卷积层1 + ReLU激活函数
  16. x = F.max_pool2d(x, 2) # 最大池化层,池化核大小为2x2
  17. x = F.relu(self.conv2(x)) # 卷积层2 + ReLU激活函数
  18. x = F.max_pool2d(x, 2) # 最大池化层,池化核大小为2x2
  19. x = x.view(x.size(0), -1) # 展平操作,将多维张量展平成一维
  20. x = F.relu(self.fc1(x)) # 全连接层1 + ReLU激活函数
  21. x = self.fc2(x) # 全连接层2,输出10个类别
  22. return x
  23. # 实例化模型
  24. model = SimpleCNN()
  25. # 打印剪枝前的模型结构
  26. print("Model before pruning:")
  27. print(model)
  28. # 加载数据
  29. transform = transforms.Compose([
  30. transforms.ToTensor(), # 转换为张量
  31. transforms.Normalize((0.1307,), (0.3081,)) # 归一化
  32. ])
  33. train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform) # 加载训练数据集
  34. train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True) # 创建数据加载器
  35. # 定义损失函数和优化器
  36. criterion = nn.CrossEntropyLoss() # 交叉熵损失函数
  37. optimizer = optim.Adam(model.parameters(), lr=0.001) # Adam优化器
  38. # 训练模型
  39. model.train() # 将模型设置为训练模式
  40. for epoch in range(1): # 训练一个epoch
  41. running_loss = 0.0
  42. for data, target in train_loader:
  43. optimizer.zero_grad() # 清零梯度
  44. outputs = model(data) # 前向传播
  45. loss = criterion(outputs, target) # 计算损失
  46. loss.backward() # 反向传播
  47. optimizer.step() # 更新参数
  48. running_loss += loss.item() * data.size(0) # 累加损失
  49. epoch_loss = running_loss / len(train_loader.dataset) # 计算平均损失
  50. print(f'Epoch {epoch + 1}, Loss: {epoch_loss:.4f}')
  51. # 通道剪枝
  52. # 获取卷积层的权重
  53. conv1_weights = model.conv1.weight.data.abs().sum(dim=[1, 2, 3]) # 计算每个通道的L1范数
  54. # 按照L1范数对通道进行排序
  55. sorted_channels = torch.argsort(conv1_weights)
  56. # 选择需要删除的通道
  57. num_prune = 2 # 假设我们要删除2个通道
  58. channels_to_prune = sorted_channels[:num_prune]
  59. print("Channels to prune:", channels_to_prune)
  60. # 删除指定通道的权重和偏置
  61. pruned_weights = torch.index_select(model.conv1.weight.data, 0, sorted_channels[num_prune:]) # 获取保留的权重
  62. pruned_bias = torch.index_select(model.conv1.bias.data, 0, sorted_channels[num_prune:]) # 获取保留的偏置
  63. # 创建一个新的卷积层,并将剪枝后的权重和偏置赋值给它
  64. model.conv1 = nn.Conv2d(in_channels=1, out_channels=4 - num_prune, kernel_size=3, padding=1)
  65. model.conv1.weight.data = pruned_weights
  66. model.conv1.bias.data = pruned_bias
  67. # 同时我们还需要调整conv2层的输入通道
  68. # 获取conv2层的权重并调整其输入通道
  69. conv2_weights = model.conv2.weight.data[:, sorted_channels[num_prune:], :, :] # 调整输入通道的权重
  70. # 创建一个新的卷积层,并将剪枝后的权重赋值给它
  71. model.conv2 = nn.Conv2d(in_channels=4 - num_prune, out_channels=8, kernel_size=3, padding=1)
  72. model.conv2.weight.data = conv2_weights
  73. # 打印剪枝后的模型结构
  74. print("Model after pruning:")
  75. print(model)
  76. # 定义新的优化器
  77. optimizer = optim.Adam(model.parameters(), lr=0.001)
  78. # 重新训练模型
  79. model.train() # 将模型设置为训练模式
  80. for epoch in range(1): # 训练一个epoch
  81. running_loss = 0.0
  82. for data, target in train_loader:
  83. optimizer.zero_grad() # 清零梯度
  84. outputs = model(data) # 前向传播
  85. loss = criterion(outputs, target) # 计算损失
  86. loss.backward() # 反向传播
  87. optimizer.step() # 更新参数
  88. running_loss += loss.item() * data.size(0) # 累加损失
  89. epoch_loss = running_loss / len(train_loader.dataset) # 计算平均损失
  90. print(f'Epoch {epoch + 1}, Loss: {epoch_loss:.4f}')
  91. # 加载测试数据
  92. test_dataset = datasets.MNIST('./data', train=False, transform=transform) # 加载测试数据集
  93. test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=1000, shuffle=False) # 创建数据加载器
  94. # 评估模型
  95. model.eval() # 将模型设置为评估模式
  96. correct = 0
  97. total = 0
  98. with torch.no_grad(): # 关闭梯度计算
  99. for data, target in test_loader:
  100. outputs = model(data) # 前向传播
  101. _, predicted = torch.max(outputs.data, 1) # 获取预测结果
  102. total += target.size(0) # 总样本数
  103. correct += (predicted == target).sum().item() # 正确预测的样本数
  104. print(f'Accuracy: {100 * correct / total}%') # 打印准确率

छंटाईप्रौद्योगिक्याः कार्यक्षमतां कार्यक्षमतां च सुधारयितुम् निम्नलिखित अनुकूलनपक्षेषु विचारः कर्तुं शक्यते ।

  • छंटाई प्रभावं सटीकता च सुधारयितुम् उचितं छंटाई रणनीतयः छंटाई एल्गोरिदम् च चयनं कुर्वन्तु ।

  • मॉडलस्य सटीकतायां कार्यप्रदर्शने च अधिकं सुधारं कर्तुं छंटनीकृतं प्रतिरूपं सूक्ष्मरूपेण ट्यून कुर्वन्तु अथवा वृद्धिशीलरूपेण शिक्षन्तु।

  • छंटाई-प्रशिक्षण-प्रक्रियायाः त्वरिततायै समानान्तर-गणना-वितरित-गणना-प्रौद्योगिक्याः उपयोगं कुर्वन्तु ।