-论文地址:A Survey of
-Quantization Methods for Efficient Neural Network Inference
+论文地址:BitNet: Scaling
+1-bit Transformers for Large Language Models
摘要
-这篇论文是关于模型量化方向的综述，介绍了量化相关领域的研究，同时也介绍了一些
+这篇论文展示了BitNet,一种为大型语言模型设计的可扩展和稳定的1-bit转换器架构。具体地说，
-论文地址:BitNet: Scaling
-1-bit Transformers for Large Language Models
+论文地址:A Survey of
+Quantization Methods for Efficient Neural Network Inference
摘要
-这篇论文展示了BitNet,一种为大型语言模型设计的可扩展和稳定的1-bit转换器架构。具体地说，
+这篇论文是关于模型量化方向的综述，介绍了量化相关领域的研究，同时也介绍了一些
@@ -904,9 +904,10 @@
var data_title = data.title.trim().toLowerCase();
var data_content = data.content.trim().replace(/<[^>]+>/g, "").toLowerCase();
var data_url = data.url;
+ var root = '/'; // 通过模板引擎动态获取 root
if (data_url.indexOf('http') !== 0) {
// 生成绝对路径，确保基于网站根目录
- data_url = window.location.protocol + '//' + window.location.host + data_url;
+ data_url = window.location.protocol + '//' + window.location.host + root + data_url;
}
var index_title = -1;
var index_content = -1;
diff --git a/archives/2023/11/index.html b/archives/2023/11/index.html
index 09689271..a31d4529 100644
--- a/archives/2023/11/index.html
+++ b/archives/2023/11/index.html
@@ -766,9 +766,10 @@
var data_title = data.title.trim().toLowerCase();
var data_content = data.content.trim().replace(/<[^>]+>/g, "").toLowerCase();
var data_url = data.url;
+ var root = '/'; // 通过模板引擎动态获取 root
if (data_url.indexOf('http') !== 0) {
// 生成绝对路径，确保基于网站根目录
- data_url = window.location.protocol + '//' + window.location.host + data_url;
+ data_url = window.location.protocol + '//' + window.location.host + root + data_url;
}
var index_title = -1;
var index_content = -1;
diff --git a/archives/2023/12/index.html b/archives/2023/12/index.html
index 1a7406c8..04af9769 100644
--- a/archives/2023/12/index.html
+++ b/archives/2023/12/index.html
@@ -777,10 +777,10 @@
深度学习
- 矩阵
-
数学
+ 矩阵
+
-论文地址:A Survey of
-Quantization Methods for Efficient Neural Network Inference
+论文地址:BitNet: Scaling
+1-bit Transformers for Large Language Models
摘要
-这篇论文是关于模型量化方向的综述，介绍了量化相关领域的研究，同时也介绍了一些
+这篇论文展示了BitNet,一种为大型语言模型设计的可扩展和稳定的1-bit转换器架构。具体地说，
@@ -1336,9 +1336,10 @@
var data_title = data.title.trim().toLowerCase();
var data_content = data.content.trim().replace(/<[^>]+>/g, "").toLowerCase();
var data_url = data.url;
+ var root = '/'; // 通过模板引擎动态获取 root
if (data_url.indexOf('http') !== 0) {
// 生成绝对路径，确保基于网站根目录
- data_url = window.location.protocol + '//' + window.location.host + data_url;
+ data_url = window.location.protocol + '//' + window.location.host + root + data_url;
}
var index_title = -1;
var index_content = -1;
diff --git a/archives/2023/page/2/index.html b/archives/2023/page/2/index.html
index fe58fef1..a7df9331 100644
--- a/archives/2023/page/2/index.html
+++ b/archives/2023/page/2/index.html
@@ -527,24 +527,24 @@
-论文地址:BitNet: Scaling
-1-bit Transformers for Large Language Models
+论文地址:A Survey of
+Quantization Methods for Efficient Neural Network Inference
摘要
-这篇论文展示了BitNet,一种为大型语言模型设计的可扩展和稳定的1-bit转换器架构。具体地说，
+这篇论文是关于模型量化方向的综述，介绍了量化相关领域的研究，同时也介绍了一些
-论文地址:A Survey of
-Quantization Methods for Efficient Neural Network Inference
+论文地址:BitNet: Scaling
+1-bit Transformers for Large Language Models
摘要
-这篇论文是关于模型量化方向的综述，介绍了量化相关领域的研究，同时也介绍了一些
+这篇论文展示了BitNet,一种为大型语言模型设计的可扩展和稳定的1-bit转换器架构。具体地说，
@@ -1337,9 +1337,10 @@
var data_title = data.title.trim().toLowerCase();
var data_content = data.content.trim().replace(/<[^>]+>/g, "").toLowerCase();
var data_url = data.url;
+ var root = '/'; // 通过模板引擎动态获取 root
if (data_url.indexOf('http') !== 0) {
// 生成绝对路径，确保基于网站根目录
- data_url = window.location.protocol + '//' + window.location.host + data_url;
+ data_url = window.location.protocol + '//' + window.location.host + root + data_url;
}
var index_title = -1;
var index_content = -1;
diff --git a/archives/page/3/index.html b/archives/page/3/index.html
index e5ded99c..60cbe1ca 100644
--- a/archives/page/3/index.html
+++ b/archives/page/3/index.html
@@ -527,24 +527,24 @@
-论文地址:BitNet: Scaling
-1-bit Transformers for Large Language Models
+论文地址:A Survey of
+Quantization Methods for Efficient Neural Network Inference
摘要
-这篇论文展示了BitNet,一种为大型语言模型设计的可扩展和稳定的1-bit转换器架构。具体地说，
+这篇论文是关于模型量化方向的综述，介绍了量化相关领域的研究，同时也介绍了一些
-论文地址:BitNet: Scaling
-1-bit Transformers for Large Language Models
+论文地址:A Survey of
+Quantization Methods for Efficient Neural Network Inference
摘要
-这篇论文展示了BitNet,一种为大型语言模型设计的可扩展和稳定的1-bit转换器架构。具体地说，
+这篇论文是关于模型量化方向的综述，介绍了量化相关领域的研究，同时也介绍了一些
-论文地址:A Survey of
-Quantization Methods for Efficient Neural Network Inference
+论文地址:BitNet: Scaling
+1-bit Transformers for Large Language Models
摘要
-这篇论文是关于模型量化方向的综述，介绍了量化相关领域的研究，同时也介绍了一些
+这篇论文展示了BitNet,一种为大型语言模型设计的可扩展和稳定的1-bit转换器架构。具体地说，
-论文地址:BitNet: Scaling
-1-bit Transformers for Large Language Models
+论文地址:A Survey of
+Quantization Methods for Efficient Neural Network Inference
摘要
-这篇论文展示了BitNet,一种为大型语言模型设计的可扩展和稳定的1-bit转换器架构。具体地说，
+这篇论文是关于模型量化方向的综述，介绍了量化相关领域的研究，同时也介绍了一些
-论文地址:A Survey of
-Quantization Methods for Efficient Neural Network Inference
+论文地址:BitNet: Scaling
+1-bit Transformers for Large Language Models
摘要
-这篇论文是关于模型量化方向的综述，介绍了量化相关领域的研究，同时也介绍了一些
+这篇论文展示了BitNet,一种为大型语言模型设计的可扩展和稳定的1-bit转换器架构。具体地说，
@@ -864,9 +864,10 @@
var data_title = data.title.trim().toLowerCase();
var data_content = data.content.trim().replace(/<[^>]+>/g, "").toLowerCase();
var data_url = data.url;
+ var root = '/'; // 通过模板引擎动态获取 root
if (data_url.indexOf('http') !== 0) {
// 生成绝对路径，确保基于网站根目录
- data_url = window.location.protocol + '//' + window.location.host + data_url;
+ data_url = window.location.protocol + '//' + window.location.host + root + data_url;
}
var index_title = -1;
var index_content = -1;
diff --git "a/categories/\350\207\252\347\204\266\350\257\255\350\250\200\345\244\204\347\220\206/index.html" "b/categories/\350\207\252\347\204\266\350\257\255\350\250\200\345\244\204\347\220\206/index.html"
index b8f5dd4e..87af85c1 100644
--- "a/categories/\350\207\252\347\204\266\350\257\255\350\250\200\345\244\204\347\220\206/index.html"
+++ "b/categories/\350\207\252\347\204\266\350\257\255\350\250\200\345\244\204\347\220\206/index.html"
@@ -424,38 +424,38 @@
-
+ 课程资源
- 1
+ style="background-color: #F9EBEA;">杂项
+ 3
-
+ 杂项
- 3
+ style="background-color: #F5EEF8;">课程资源
+ 1
-
+ 深度学习
- 8
+ style="background-color: #D5F5E3;">huggingface
+ 1
-
+ huggingface
- 1
+ style="background-color: #E8F8F5;">深度学习
+ 8
@@ -487,19 +487,10 @@
-
- 前置数学
- 2
-
-
-
-
SmallProjects
+ style="background-color: #D7BDE2;">SmallProjects
1
@@ -508,17 +499,17 @@
工程细节
+ style="background-color: #A3E4D7;">工程细节
1
-
+ 经典模块
- 1
+ style="background-color: #85C1E9;">前置数学
+ 2
@@ -526,12 +517,21 @@
自然语言处理
+ style="background-color: #F8C471;">自然语言处理
3
+
+ 经典模块
+ 1
+
+
+
+
]+>/g, "").toLowerCase();
var data_url = data.url;
+ var root = '/'; // 通过模板引擎动态获取 root
if (data_url.indexOf('http') !== 0) {
// 生成绝对路径，确保基于网站根目录
- data_url = window.location.protocol + '//' + window.location.host + data_url;
+ data_url = window.location.protocol + '//' + window.location.host + root + data_url;
}
var index_title = -1;
var index_content = -1;
diff --git "a/categories/\350\257\276\347\250\213\350\265\204\346\272\220/index.html" "b/categories/\350\257\276\347\250\213\350\265\204\346\272\220/index.html"
index 308b591c..70dc0198 100644
--- "a/categories/\350\257\276\347\250\213\350\265\204\346\272\220/index.html"
+++ "b/categories/\350\257\276\347\250\213\350\265\204\346\272\220/index.html"
@@ -424,38 +424,38 @@
-
+ 课程资源
- 1
+ chip-default "
+ style="background-color: #F9EBEA;">杂项
+ 3
-
+ 杂项
- 3
+ chip-active "
+ style="background-color: #F5EEF8;">课程资源
+ 1
-
+ 深度学习
- 8
+ style="background-color: #D5F5E3;">huggingface
+ 1
-
+ huggingface
- 1
+ style="background-color: #E8F8F5;">深度学习
+ 8
@@ -487,47 +487,47 @@
-
+ 前置数学
- 2
+ style="background-color: #D7BDE2;">SmallProjects
+ 1
-
+ SmallProjects
+ style="background-color: #A3E4D7;">工程细节
1
-
+ 工程细节
- 1
+ style="background-color: #85C1E9;">前置数学
+ 2
-
+ 经典模块
- 1
+ style="background-color: #F8C471;">自然语言处理
+ 3
-
+ 自然语言处理
- 3
+ style="background-color: #F9E79F;">经典模块
+ 1
@@ -793,9 +793,10 @@
var data_title = data.title.trim().toLowerCase();
var data_content = data.content.trim().replace(/<[^>]+>/g, "").toLowerCase();
var data_url = data.url;
+ var root = '/'; // 通过模板引擎动态获取 root
if (data_url.indexOf('http') !== 0) {
// 生成绝对路径，确保基于网站根目录
- data_url = window.location.protocol + '//' + window.location.host + data_url;
+ data_url = window.location.protocol + '//' + window.location.host + root + data_url;
}
var index_title = -1;
var index_content = -1;
diff --git a/contact/index.html b/contact/index.html
index c661e9ff..9dd29753 100644
--- a/contact/index.html
+++ b/contact/index.html
@@ -665,9 +665,10 @@
var data_title = data.title.trim().toLowerCase();
var data_content = data.content.trim().replace(/<[^>]+>/g, "").toLowerCase();
var data_url = data.url;
+ var root = '/'; // 通过模板引擎动态获取 root
if (data_url.indexOf('http') !== 0) {
// 生成绝对路径，确保基于网站根目录
- data_url = window.location.protocol + '//' + window.location.host + data_url;
+ data_url = window.location.protocol + '//' + window.location.host + root + data_url;
}
var index_title = -1;
var index_content = -1;
diff --git a/content.json b/content.json
index af17f20c..aa7e4411 100644
--- a/content.json
+++ b/content.json
@@ -1 +1 @@
-{"meta":{"title":"Blogs","subtitle":"Welcome to bg51717's Wiki and Blog","description":"","author":"bg51717","url":"https://bg51717.github.io","root":"/"},"pages":[{"title":"404","date":"2024-09-30T09:25:30.000Z","updated":"2024-09-24T11:40:26.452Z","comments":true,"path":"404.html","permalink":"https://bg51717.github.io/404","excerpt":"","text":""},{"title":"friends","date":"2018-12-12T13:25:30.000Z","updated":"2024-09-24T11:40:26.464Z","comments":true,"path":"friends/index.html","permalink":"https://bg51717.github.io/friends/","excerpt":"","text":""},{"title":"contact","date":"2024-09-30T09:25:30.000Z","updated":"2024-09-24T11:40:26.464Z","comments":true,"path":"contact/index.html","permalink":"https://bg51717.github.io/contact/","excerpt":"","text":""},{"title":"categories","date":"2024-09-30T09:25:30.000Z","updated":"2024-09-24T11:40:26.464Z","comments":true,"path":"categories/index.html","permalink":"https://bg51717.github.io/categories/","excerpt":"","text":""},{"title":"about","date":"2024-09-30T09:25:30.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"about/index.html","permalink":"https://bg51717.github.io/about/","excerpt":"","text":""},{"title":"tags","date":"2024-09-30T10:23:38.000Z","updated":"2024-09-24T11:40:26.464Z","comments":true,"path":"tags/index.html","permalink":"https://bg51717.github.io/tags/","excerpt":"","text":""}],"posts":[{"title":"Welcome to bg51717's Wiki and Blog","slug":"index","date":"2024-09-24T11:40:26.457Z","updated":"2024-09-24T11:40:26.457Z","comments":true,"path":"/14261/","link":"","permalink":"https://bg51717.github.io/14261/","excerpt":"","text":"这是bg51717的个人Wiki和Blog站点，主要是把知识系统的罗列出来以及存放一些特殊bug的处理，当然也会更一些游戏或者二次元相关东西，也希望在成长的过程中可以认识许多志同道合的人。 本人一直认为互联网的开源是社会发展的重要原因之一，因为开源使得技术知识和解决问题的经验可以被记录和传承下去，很多时候在需要的时候可以被人们所发掘。 也希望可以通过博客让自己的思维有条理。很多时候我喜欢观察别人的思路，发现其实人与人的很多思路差距可能没有那么多。除开经验上的差别，很多人能成功的做成一件事很多原因是思维非常有条理，时时刻刻明白自己的应该做什么，下一步思路是什么。不会让自己的思维局限在某个步骤或者门槛上。从而即使在逆境中，也能实现把烂牌打出最好的效果。 在偶尔反思自己的不足的时候，深刻的发现拖延症是致命的，很多事情只要按照条理有计划的进行，结果其实都可以完成。但是拖延容易导致事情出现计划外的变故，进而导致完成的质量。这对于个人的成长来说是极为不利的。很早以前就看到了知行合一这个词，但是一直没有理解其重要性。后来发现，缺少行动力也会导致很多计划的失败。很多事物是需要我们用心去做，而不是用敷衍的态度去进行。在实践中不断地提升自己，革新自己。 不知道此刻在阅读这个博客的你是在何时何地打开的，也不知道你是为了探究什么而点开了这个链接。但是祝你身体健康，万事如意。大家一起学习，互相交流，共同成长！ 最后，附上我喜欢的一句话： 世界靠现实主义者维系，靠理想主义者发展。","categories":[],"tags":[]},{"title":"安卓手机配置Google","slug":"工具/安卓手机配置Google","date":"2024-08-27T10:14:49.000Z","updated":"2024-09-24T11:40:26.457Z","comments":true,"path":"/61294/","link":"","permalink":"https://bg51717.github.io/61294/","excerpt":"","text":"介绍 这篇博客主要记录了如何在安卓手机上配置谷歌三件套的服务。 对于非华为荣耀手机，可能仅仅需要简单的使用一些第三方的安装软件即可完成，比如 go安装助手等，资源较大且获取难度较低。 而本篇博客主要介绍华为荣耀手机如何获取谷歌三件套的服务和配置支付信息等。 介绍两个并行的方法，当其中一个方法失效的时候，可以用另一个方法的部分替代。 方法是 华谷套件和to-alan/HarmonyOSInstallGMS: 华为安装GMS教程 。 博主前面的流程都使用的是华谷套件，该软件可以在每一步运行完后自动检测是否设置成功。在卸载MicroG后，转为使用方法二进行后续的处理。 目前手机谷歌三件套运行稳定，基本可以提供原生的谷歌三件套服务。 支付方式的添加todo。 参考资料 to-alan/HarmonyOSInstallGMS: 华为安装GMS教程","categories":[{"name":"工具","slug":"工具","permalink":"https://bg51717.github.io/categories/%E5%B7%A5%E5%85%B7/"}],"tags":[{"name":"安卓","slug":"安卓","permalink":"https://bg51717.github.io/tags/%E5%AE%89%E5%8D%93/"},{"name":"Google","slug":"Google","permalink":"https://bg51717.github.io/tags/Google/"}]},{"title":"PyTorch代码转HF","slug":"模板/PyTorch代码转HF","date":"2024-08-06T10:56:13.000Z","updated":"2024-09-24T11:40:26.457Z","comments":true,"path":"/61054/","link":"","permalink":"https://bg51717.github.io/61054/","excerpt":"","text":"介绍 这篇博客主要介绍了怎么把一个已有的Pytorch代码转变成HF支持的格式，然后可以方便的放入HF代码流程中，并且使用一些HF的函数。代码转换主要涉及到以下几个方面： Config Model Trainer Dataset 因为ckpt里面的代码使用的会是相对导入，所以在转换的过程中，建议把 configuration_xxx.py和 modeling_xxx.py文件放在同一个目录下，并且添加 __init__.py文件。 Config 参考：Building custom models (huggingface.co) 示例： from transformers import PretrainedConfig from typing import List class LtgBertConfig(PretrainedConfig): model_type = \"LtgBert\" \"\"\"Configuration class to store the configuration of a `LtgBertModel`. \"\"\" def __init__(self, vocab_size_or_config_json_file=16384, hidden_size=768, num_hidden_layers=12, num_attention_heads=12, intermediate_size=3072, hidden_act=\"gelu\", hidden_dropout_prob=0.1, attention_probs_dropout_prob=0.1, max_position_embeddings=512, type_vocab_size=2, initializer_range=0.02, output_all_encoded_layers=False, require_all_hidden_states=True, batch_first=True, **kwargs): self.hidden_size = hidden_size self.num_hidden_layers = num_hidden_layers self.num_attention_heads = num_attention_heads self.hidden_act = hidden_act self.intermediate_size = intermediate_size self.hidden_dropout_prob = hidden_dropout_prob self.attention_probs_dropout_prob = attention_probs_dropout_prob self.max_position_embeddings = max_position_embeddings self.type_vocab_size = type_vocab_size self.initializer_range = initializer_range self.output_all_encoded_layers = output_all_encoded_layers self.require_all_hidden_states = require_all_hidden_states self.batch_first=batch_first if isinstance(vocab_size_or_config_json_file, str) or (sys.version_info[0] == 2 and isinstance(vocab_size_or_config_json_file, unicode)): with open(vocab_size_or_config_json_file, \"r\", encoding='utf-8') as reader: json_config = json.loads(reader.read()) for key, value in json_config.items(): self.__dict__[key] = value elif isinstance(vocab_size_or_config_json_file, int): self.vocab_size = vocab_size_or_config_json_file else: raise ValueError(\"First argument must be either a vocabulary size (int)\" \"or the path to a pretrained model config file (str)\") super(LtgBertConfig, self).__init__(**kwargs) 必须满足： 继承自 PretrainedConfig __init__函数接受 kwargs，并且使用 super()).__init__传递这些参数 model_type的作用是把模型注册到 AutoClass中，建议设置。 Model 参考：Building custom models (huggingface.co) 示例： class LtgBertForMaskedLM(PreTrainedModel): config_class=LtgBertConfig def __init__(self,config,activation_checkpointing=False): super().__init__(config) # 这里可以把成员变成类的继承LtgBertForMaskedLM(Bert): self.model=Bert( config=config, activation_checkpointing=activation_checkpointing ) self.require_all_hidden_states=config.require_all_hidden_states self.batch_first=config.batch_first def forward(self, input_ids, attention_mask, masked_lm_labels=None): if self.batch_first: # 模型把batch放在第二个维度 input_ids=input_ids.transpose(0,1) if masked_lm_labels is not None: masked_lm_labels=masked_lm_labels.transpose(0,1) subword_prediction=self.model(input_ids, attention_mask, masked_lm_labels=masked_lm_labels) loss=None if masked_lm_labels is not None: target_ids = masked_lm_labels.flatten() target_ids = target_ids[target_ids != -100] loss = F.cross_entropy(subword_prediction, target_ids) all_hidden_states=None if self.require_all_hidden_states: all_hidden_states=self.model.get_contextualized(input_ids=input_ids,attention_mask=attention_mask) if self.batch_first: if len(subword_prediction.size())>2: subword_prediction=subword_prediction.transpose(0,1) if all_hidden_states is not None: all_hidden_states=[it.transpose(0,1) for it in all_hidden_states] return MaskedLMOutput( loss=loss, logits=subword_prediction, hidden_states=all_hidden_states, attentions=None ) 对于自定义模型，往往每个 AutoClass上都会注册一个模型，因此往往要写多个自定义模型。 config_type的作用是把模型注册到 AutoClass中，建议设置。 由于简约性原则，官方要求 self.model对应原来的模型，比如用Pytorch定义的模型。 forward函数需要注意结果格式，transformers.modeling_outputs里定义了每种模型forward的结果格式。 其中对于每个特定的子任务都有个类似的模型，对于部分函数比如forward建议参考已有的代码进行操作，因为hf框架在使用特定子任务的模型的时候，可能会添加特殊的参数。比如，对于序列分类任务SequenceClassification，其中相关模型的forward为： def forward( self, input_ids: Optional[torch.Tensor] = None, attention_mask: Optional[torch.Tensor] = None, output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool] = None, inputs_embeds: Optional[torch.Tensor] = None, return_dict: Optional[bool] = None, labels: Optional[torch.LongTensor] = None, ) -> Union[Tuple[torch.Tensor], SequenceClassifierOutput]: if self.batch_first: # 模型把batch放在第二个维度 input_ids=input_ids.transpose(0,1) contextualized_embeddings=self.model.get_contextualized(input_ids, attention_mask) if self.batch_first: contextualized_embeddings=contextualized_embeddings.transpose(0,1) logits = self.head(contextualized_embeddings[:, 0, :]) if labels is not None: if self.config.problem_type is None: if self.num_labels == 1: self.config.problem_type = \"regression\" elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int): self.config.problem_type = \"single_label_classification\" else: self.config.problem_type = \"multi_label_classification\" if self.config.problem_type == \"regression\": loss_fct = nn.MSELoss() if self.num_labels == 1: loss = loss_fct(logits.squeeze(), labels.squeeze()) else: loss = loss_fct(logits, labels) elif self.config.problem_type == \"single_label_classification\": loss_fct = nn.CrossEntropyLoss() loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1)) elif self.config.problem_type == \"multi_label_classification\": loss_fct = nn.BCEWithLogitsLoss() loss = loss_fct(logits, labels) assert output_attentions is None assert output_hidden_states is None return SequenceClassifierOutput( loss=loss, logits=logits, hidden_states=contextualized_embeddings if output_hidden_states else None, attentions=None ) 这里hf框架会在配置中添加problem_type等内容。 注册 如果在ckpt文件夹的 config.json里没有 auto_map指明 AutoClass的注册： \"auto_map\": { \"AutoConfig\": \"configuration_ltgbert.LtgBertConfig\", \"AutoModelForMaskedLM\": \"modeling_ltgbert.LtgBertForMaskedLM\" } 那么需要手动添加，在读取ckpt的代码里添加： AutoConfig.register(\"LtgBert\", LtgBertConfig) AutoModelForMaskedLM.register(LtgBertConfig, LtgBertForMaskedLM) 如果希望在保存模型的时候 config.json文件中自动包含 auto_map，可以添加以下代码（如果模型是从ckpt里加载的就不需要添加）： LtgBertConfig.register_for_auto_class() LtgBertForMaskedLM.register_for_auto_class(\"AutoModelForMaskedLM\") 后来发现只有注册可能会存在 config.json里 auto_map不完整的情况（原因暂时没有调查），可以考虑直接在 config.__init__里强制指定： def __init__(self,....): ... self.auto_map={ \"AutoConfig\": \"configuration_ltgbert.LtgBertConfig\", \"AutoModelForMaskedLM\": \"modeling_ltgbert.LtgBertForMaskedLM\" } Trainer 训练流程的转换主要设计HF的 Trainer类，可以参考Trainer (huggingface.co)和Trainer (huggingface.co)。 Trainer把训练的流程分为几个过程，通过继承以及重写相关函数即可完成流程的定制，通过参数即可实现超参数的设置，细节阅读参考资料。 Dataset dataset可以继承自 torch.utils.data.dataset，但是需要注意 __getitem__，默认情况该函数返回的需要满足 dict格式，从而实现参数的设置。 参考资料 Building custom models (huggingface.co) Trainer (huggingface.co) Trainer (huggingface.co)","categories":[{"name":"模板","slug":"模板","permalink":"https://bg51717.github.io/categories/%E6%A8%A1%E6%9D%BF/"}],"tags":[{"name":"模板","slug":"模板","permalink":"https://bg51717.github.io/tags/%E6%A8%A1%E6%9D%BF/"},{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"PyTorch","slug":"PyTorch","permalink":"https://bg51717.github.io/tags/PyTorch/"},{"name":"HuggingFace","slug":"HuggingFace","permalink":"https://bg51717.github.io/tags/HuggingFace/"},{"name":"Trainer","slug":"Trainer","permalink":"https://bg51717.github.io/tags/Trainer/"},{"name":"config","slug":"config","permalink":"https://bg51717.github.io/tags/config/"},{"name":"model","slug":"model","permalink":"https://bg51717.github.io/tags/model/"},{"name":"dataset","slug":"dataset","permalink":"https://bg51717.github.io/tags/dataset/"}]},{"title":"随机数种子","slug":"深度学习/工程细节/随机数种子","date":"2024-07-09T10:02:24.000Z","updated":"2024-09-29T06:07:20.929Z","comments":true,"path":"/7369/","link":"","permalink":"https://bg51717.github.io/7369/","excerpt":"","text":"介绍 在深度学习的实际项目中，为了减少随机性，增强项目的复现能力，设置固定随机数种子十分重要，因此这篇文章罗列了一些设置随机种子的方法和减少项目随机性的经验。 通用函数 def set_random_seed(seed): \"\"\"Set random seeds.\"\"\" os.environ['PYTHONHASHSEED'] = str(seed) random.seed(seed) # 设置 Python 内置随机库的种子 np.random.seed(seed) # 设置 NumPy 随机库的种子 torch.manual_seed(seed) # 设置 PyTorch 随机库的种子 torch.cuda.manual_seed(seed) # 为当前 CUDA 设备设置种子 torch.cuda.manual_seed_all(seed) # 为所有 CUDA 设备设置种子 Scikit-learn 在 Scikit-learn中，部分算法需要设置 random_state，比如聚类算法 kmeans。 KMeans(n_clusters=2,random_state=42) 工程经验 由于部分原因，一些python数组或者python集合等，可能顺序也会影响结果的随机性。如果在无法确保顺序是固定的或者顺序是有要求的情况下，尝试对这些中间结果进行排序减少随机性。 参考资料 【Python】深度学习中随机数种子seed的种类和设置方式_seed设置-CSDN博客","categories":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"工程细节","slug":"深度学习/工程细节","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E5%B7%A5%E7%A8%8B%E7%BB%86%E8%8A%82/"}],"tags":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"随机数","slug":"随机数","permalink":"https://bg51717.github.io/tags/%E9%9A%8F%E6%9C%BA%E6%95%B0/"}]},{"title":"vscode调试python","slug":"杂项/vscode调试python","date":"2024-04-19T14:47:51.000Z","updated":"2024-09-24T11:40:26.457Z","comments":true,"path":"/30403/","link":"","permalink":"https://bg51717.github.io/30403/","excerpt":"","text":"介绍 在学习项目的过程中，很多时候需要通过调试来高效率的了解代码的执行过程，因此这里介绍下怎么使用vscode对python程序进行调试。 方法一：简单图标点击 vscode对一些简单的程序提供了一些可视化的调试方式，对于一些不需要指定参数等简单的调试功能，可以直接点击vscode左上角的几个图标进行debug过程。由于过于简单，此处不做介绍。 1713538455137 方法二：编辑launch.json文件 在工作目录下的 ./vscode/launch.json文件里面，指定了各种debug和程序运行的参数、环境、解释器、目录等基本所有的环境配置。 可以在左下角的添加配置里面快速添加常见的选项。 比如下面所示： { // 使用 IntelliSense 了解相关属性。 // 悬停以查看现有属性的描述。 // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387 \"version\": \"0.2.0\", \"configurations\": [ { \"name\": \"(gdb) 启动\", \"type\": \"cppdbg\", \"request\": \"launch\", \"program\": \"${fileDirname}/${fileBasenameNoExtension}\", \"args\": [], \"stopAtEntry\": false, \"cwd\": \"${fileDirname}\", \"environment\": [], \"externalConsole\": false, \"MIMode\": \"gdb\", \"setupCommands\": [ { \"description\": \"为 gdb 启用整齐打印\", \"text\": \"-enable-pretty-printing\", \"ignoreFailures\": true }, { \"description\": \"将反汇编风格设置为 Intel\", \"text\": \"-gdb-set disassembly-flavor intel\", \"ignoreFailures\": true } ] }, { \"name\": \"py-dbg QLLM\", \"type\": \"debugpy\", \"request\": \"launch\", \"python\": \"/home/bg51717/.conda/envs/QLLM/bin/python\", // \"program\": \"/home/bg51717/project/QLLM/qllm/__main__.py\", \"module\": \"qllm\", \"console\": \"integratedTerminal\", \"args\":[ \"--model=/home/bg51717/project/models/facebook/opt-350m\", \"--method=gptq\", \"--nsamples=64\", \"--wbits=4\", \"--groupsize=128\", \"--save\", \"/home/bg51717/project/QLLM/facebook/opt-350m_gptq4b\", \"--export_onnx\", \"/home/bg51717/project/QLLM/onnx_model/facebook/opt-350m_gptq4b\" ], \"env\": {\"PYTHONPATH\": \"/home/bg51717/project/QLLM/qllm\"}, \"cwd\": \"/home/bg51717/project/QLLM\" } ] } 这里参数非常多（建议使用的时候查询 gpt、搜索引擎、文档等。 这里介绍几个常用的选项。此外，在编辑的时候可以类似 Linux那样使用 ${fileDirname}来引用 vscode程序的当前变量比如工作目录 参数 含义 类型 name 过程名字 str type 过程类型 str python 解释器（使用虚拟环境的时候需要注意指定 str program 程序文件，按照脚本方式运行过程 str module 模块名，按照模块方式运行过程 str args 运行过程的参数 list env 环境变量 dict cwd 工作目录 str 此外，在使用的过程中python里面绝对引入、相对引入等。建议参考python相对导入常见问题和解决方案 - 知乎 (zhihu.com) 。 此处发现那里也有些没有提及的东西。 解决方案错误一：ImportError: attempted relative import with no known parent package 里可以不修改代码，使用 python -m命令+调整工作目录成功运行。（笔者当时遇到一个坑，当时没有注意的调试的是工程目录里的qllm文件还是env里装的py包 方法三：使用debug.py文件引入要调试的文件 如题，建立一个 debug.py文件引入要调试的文件，类似于使用代理进行调试过程。 参考【Python 入门】新手必会 vscode Debug 调试技巧_哔哩哔哩_bilibili 参考资料 python相对导入常见问题和解决方案 - 知乎 (zhihu.com) 【Python 入门】新手必会 vscode Debug 调试技巧_哔哩哔哩_bilibili","categories":[{"name":"杂项","slug":"杂项","permalink":"https://bg51717.github.io/categories/%E6%9D%82%E9%A1%B9/"}],"tags":[{"name":"vscode","slug":"vscode","permalink":"https://bg51717.github.io/tags/vscode/"},{"name":"python","slug":"python","permalink":"https://bg51717.github.io/tags/python/"},{"name":"调试","slug":"调试","permalink":"https://bg51717.github.io/tags/%E8%B0%83%E8%AF%95/"},{"name":"debug","slug":"debug","permalink":"https://bg51717.github.io/tags/debug/"}]},{"title":"nlp常用排行榜","slug":"深度学习/自然语言处理/nlp常用排行榜","date":"2024-04-05T06:56:57.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/63314/","link":"","permalink":"https://bg51717.github.io/63314/","excerpt":"","text":"介绍 在工作和学习的时候发现，很多时候挑选合适的模型和数据集等也是一个重要且麻烦的过程。发现有很多相关的评测的排行榜，根据这些实时更新的排行榜，可以辅助我们进行选择模型等前期工作。 Spaces - Hugging Face 这里罗列了许多关于ai的最新新闻，也能搜索到各种排行榜leaderboard。 nlp任务 MTEB Leaderboard - a Hugging Face Space by mteb Massive Text Embedding Benchmark (MTEB) ，是关于文本嵌入的排行榜，同时关注排行榜的like人数（从某种意义上反应排行榜的效用）。 大模型评测 Open LLM Leaderboard - a Hugging Face Space by HuggingFaceH4 这里提供了各种关于大模型在多维度的数据集上的表现能力，并且支持根据大模型的类型、精度等过滤大模型排行榜。 Big Code Models Leaderboard - a Hugging Face Space by bigcode 这里提供了关于大模型code能力的排行榜。 LMSys Chatbot Arena Leaderboard - a Hugging Face Space by lmsys 这里提供了关于大模型对话能力的排行榜（但是由于不知名原因暂时无法打开）。 Chat with Open Large Language Models (lmsys.org) 这里是关于大模型对话能力的测评网站，也提供了参考用的排行榜。 LLM-Perf Leaderboard - a Hugging Face Space by optimum 这里提供了大模型在给定硬件条件的训练资源后微调的性能排行榜。 Open CoT Leaderboard - a Hugging Face Space by logikon 这里提供了关于大模型CoT（Chain of Thought）的排行榜。 数据集 参考资料","categories":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"自然语言处理","slug":"自然语言处理","permalink":"https://bg51717.github.io/categories/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"}],"tags":[]},{"title":"pytroch_tutorials杂项","slug":"杂项/huggingface/transformers_tutorials杂项","date":"2024-03-23T08:23:43.000Z","updated":"2024-09-24T11:40:26.457Z","comments":true,"path":"/20669/","link":"","permalink":"https://bg51717.github.io/20669/","excerpt":"","text":"介绍 当作快速过这个资料的笔记，一些关于别的库的介绍是不完全的，考虑在使用的时候从别的信息渠道就行信息的搜集。也可以作为后面待更博客列举？ 常用方式 可以参考huggingface transformers教程总结 - 知乎 (zhihu.com) （这篇教程很多是基于tf的，使用时候可以考虑换成pt）和 Hugging Face - Documentation 。 tutorials具体（中文版本） 使用AutoClass加载预训练实例 (huggingface.co) 这里有个注意的点是使用 AutoModelForSequenceClassification可能会在模型后面添加一层来适应下游任务（别的类似的类可能也会有类似的做法），如果想不添加任何层直接使用，考虑使用AutoModel类来加载模型。 预处理 (huggingface.co) 这里介绍了怎么预处理各种数据比如文本，多模态，图片等。 微调预训练模型 (huggingface.co) 这里介绍了怎么使用 transformers.Trainer类和pytorch原生代码来微调模型（pytorch lighting也提供了一个Trainer）。 也介绍了怎么使用huggingface的github上分享的脚本来微调模型huggingface/transformers: 🤗 Transformers: State-of-the-art Machine Learning for Pytorch, TensorFlow, and JAX. (github.com)， accelerate提供了accelerate config命令通过命令行交互帮助配置文件。 🤗 加速分布式训练 (huggingface.co) 这里介绍了怎么使用accelerate来进行分布式训练，流程非常简单，基本就是pytorch框架单卡训练的代码改个四五行。 使用 🤗 PEFT 加载adapters (huggingface.co) 这里大致介绍了怎么使用 perf库进行高效的参数微调，具体表现为通过 adapters实现少参数调整，还大致介绍了怎么量化加载、启用、禁止、训练等。 Transformers Agents (huggingface.co) 这里介绍了transformers新版本提供的一个api（测试版可能随时变化），通过自然语言来辅助进行功能实现，类似于通过自然语言编程。 使用LLMs进行生成 (huggingface.co) 这里大致介绍了怎么使用 model.generate()进行更好且多样化生成。 使用 🤗 Tokenizers 中的分词器 (huggingface.co) 大概介绍了怎么训练、保存和加载分词器tokenizer。 用于推理的多语言模型 (huggingface.co) 介绍了一些常用的多语言翻译模型。 创建自定义架构 (huggingface.co) 如题，使用一些配置文件自定义模型架构和各种处理器比如自然语言处理的分词器、语音识别的特征提取器等。 共享自定义模型 (huggingface.co) 这里介绍了怎么自定义模型，推送到hub上面以及怎么在AutoClass（比如AutoModel等）上面注册。 聊天模型的模板 (huggingface.co) 这里介绍了聊天的模板，怎么把多轮对话转变成一个字符串输入模型。并且支持用户自定义模板和使用内置模板等功能。自定义模板的办法使用的是Jinja。 导出为 ONNX (huggingface.co) 这里介绍了怎么通过Optimum库把模型导出为ONNX格式，ONNX模式下为公开具有标准化运算符和数据类型的图，可以进行各种优化和框架间的相互转移。 （这里还介绍了transformers.onnx，但这个库已经停止了维护并且回头会从教程里删去 导出为 TFLite (huggingface.co) TensorFlow Lite 是一个轻量级框架，用于资源受限的设备上，如手机、嵌入式系统和物联网（IoT）设备，部署机器学习模型，其文件扩展名为 .tflite，同样可以通过Optimum库导出。 导出为 TorchScript (huggingface.co) 这里关于torchscirpt的介绍可以参考pytorch的，这里还介绍了使用 Neuron SDK 将 Hugging Face TorchScript 模型部署到 AWS。 性能与可扩展性 (huggingface.co) 这是关于训练和推理的综述，里面有许多指向英语文档的链接。 完全分片数据并行 (huggingface.co) 介绍了怎么使用accelerate把模型参数切片在多个GPU运行以及部分优化。 训练用的定制硬件 (huggingface.co) 这里引入了怎么更好的使用和了解硬件，但只是引入，还是需要后期继续深入学习。 使用Trainer API进行超参数搜索 (huggingface.co) 如题，支持多种超参数搜索框架。 实例化大型模型 (huggingface.co) 这里介绍了怎么加载大模型，降低内存，具体表现为分片，把权重文件分成多个。 调试 (huggingface.co) 这里介绍了怎么使用脚本进行多GPU网络问题调试和上溢下溢检测（通过hook函数统计每个模块的输入和输出的绝对值的极值）。 使用 torch.compile() 优化推理 (huggingface.co) torch.compile() 优化推理过程，并且列出了许多实验结果。 如何创建自定义流水线？ (huggingface.co) 这里介绍了怎么自定义流水线pipeline并且注册和推送到云端。 分词器的摘要 (huggingface.co) 这里介绍了许多分词算法，如何构造tokenizer。 Agents和工具 (huggingface.co) 这里介绍了各种各样的agent和tools，agents相较于模型可以使用tools。 Callbacks (huggingface.co) Callbacks可以用来自定义PyTorch [Trainer]中训练循环行为的对象（此功能尚未在TensorFlow中实现），该对象可以检查训练循环状态（用于进度报告、在TensorBoard或其他ML平台上记录日志等），并做出决策（例如提前停止）。 这里介绍了一些常用的callbacks，怎么自定义callbacks，TrainerState代表当前训练状态，TrainerControl控制训练循环。 Configuration (huggingface.co) 介绍了Pretrainedconfig类。 Data Collator (huggingface.co) 这里介绍了各种Data collators来处理数据。 Logging (huggingface.co) 这里介绍了transformers的日志系统。 模型 (huggingface.co) 这里介绍了怎么使用PretrainedModel，由于一定原因，官方似乎推荐PretrainedModel是用于对model的一层包装，forward等函数在model里面实现。 还介绍了ModuleUtilsMixin，这个是py通过多继承扩展模型功能的一个类，可以参考一个例子走近 Python 的 Mixin 类：利用 Python 多继承的魔力_mixin类-CSDN博客学习Mixin类和调用顺序。 Generation (huggingface.co) 这里介绍了GenerationConfig和GenerationMixin来使得模型进行多样化的生成过程，扩展了模型的功能。 导出 🤗 Transformers 模型到 ONNX (huggingface.co) 这里介绍了一些配置类来帮助transformers模型导出到ONNX。 Optimization (huggingface.co) 这里只是列举了几个模型参数跟新过程会用到的优化器等，但不是很全，也不是很深入，连示例过程都没有。 模型输出 (huggingface.co) Transformers库所有模型的输出都是 ModelOutput 的子类的实例，这里介绍了许多输出类和基本的类。 Pipelines (huggingface.co) 这里介绍了许多Pipeline和自定义Pipeline。 Processors (huggingface.co) 这个库大概介绍了Processor类，用于编码或者解码多模型输入并且组合。 量化 🤗 Transformers 模型 (huggingface.co) 这个大致介绍了常见的量化方法并给了简答的示例。 Tokenizer (huggingface.co) 大致介绍了Tokenizer和常用的办法。 Trainer (huggingface.co) 这里介绍了Transformers的Trainer，同时说明了这个Trainer用于别的库的模型时要注意的问题，同时还介绍了一些常用的问题和通过accelerate使用Trainer。 DeepSpeed集成 (huggingface.co) 这里介绍了DeepSpeed的很多常用的配置选项（非常复杂，挖坑todo Feature Extractor (huggingface.co) 这里介绍了Feature负责为音频或视觉模型准备输入特征。这包括从序列中提取特征。 Image Processor (huggingface.co) 这里介绍了对于图像处理的Processor。 这里往后就是介绍一些功能类，可以用于扩展、调试控制等功能 自定义层和工具 (huggingface.co) 这里介绍了一些Transformers库的为模型提供的自定义层和帮助函数（底层还是调用的pytorch或者TensorFlow，但是组合了一些常用的层。 pipelines的工具 (huggingface.co) 这里介绍了一些为Pipeline使用的功能类。 Tokenizers的工具 (huggingface.co) Trainer的工具 (huggingface.co) 用于生成的工具 (huggingface.co) Image Processors的工具 (huggingface.co) FeatureExtractors 的工具 (huggingface.co) 通用工具 (huggingface.co) 时间序列工具 (huggingface.co)","categories":[{"name":"杂项","slug":"杂项","permalink":"https://bg51717.github.io/categories/%E6%9D%82%E9%A1%B9/"},{"name":"huggingface","slug":"huggingface","permalink":"https://bg51717.github.io/categories/huggingface/"}],"tags":[{"name":"transformers_tutorials","slug":"transformers-tutorials","permalink":"https://bg51717.github.io/tags/transformers-tutorials/"}]},{"title":"pytorch_model","slug":"模板/pytorch-model","date":"2024-02-24T09:54:19.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/42347/","link":"","permalink":"https://bg51717.github.io/42347/","excerpt":"","text":"介绍 作为深度学习的基本模板使用，方便使用的时候作为骨架 许多文件可以考虑添加argparse和sh来引入外部配置来抽象过程，增强代码重用性 dataset.py 这个文件提供了各种数据集的定义，自定义数据集需要实习三个主要函数 class MyDataset(torch.utils.data.Dataset): def __init__(self): super().__init__() #todo def __getitem__(self,idx): #todo def __len__(self): #todo models.py 这个文件负责提供各种模型的定义，可以是完全自定义的模型或者预训练模型 class MyModel(torch.nn.Module): def __init__(self) super().__init__() #todo def forward(self,input): #todo def get_model(config): #todo return model criterion.py 这个文件负责提供各种损失函数的定义，可以是完全自定义的损失函数或者框架提供的损失函数 class CustomLoss(nn.Module): def __init__(self): super(CustomLoss, self).__init__() # 在这里初始化你的参数，如果有的话 def forward(self, input, target): # 计算损失的逻辑 # 例如，这里我们使用简单的均方误差作为示例 loss = torch.mean((input - target) ** 2) return loss def get_criterion() #todo optimizer.py 这个文件负责提供各种优化器的定义，可以是完全自定义的优化器或者框架提供的优化器 class CustomOptimizer(torch.optim.Optimizer): def __init__(self, params, lr=0.01, momentum=0.5, weight_decay=0, learning_rate_decay=0.9): defaults = dict(lr=lr, momentum=momentum, weight_decay=weight_decay, learning_rate_decay=learning_rate_decay) super(CustomOptimizer, self).__init__(params, defaults) def step(self, closure=None): \"\"\"Performs a single optimization step.\"\"\" loss = None if closure is not None: loss = closure() for group in self.param_groups: for p in group['params']: if p.grad is None: continue d_p = p.grad.data if group['momentum'] > 0: param_state = self.state[p] if 'momentum_buffer' not in param_state: buf = param_state['momentum_buffer'] = torch.clone(d_p).detach() buf.mul_(group['momentum']) else: buf = param_state['momentum_buffer'] buf.mul_(group['momentum']).add_(d_p, alpha=1 - group['momentum']) d_p = buf if group['weight_decay'] != 0: d_p.add_(p.data, alpha=group['weight_decay']) p.data.add_(d_p, alpha=-lr) return loss def get_Optimizer(): #todo lr_scheduler.py 这个文件负责提供各种学习率调度器的定义，可以是完全自定义的学习率调度器或者框架提供的学习率调度器 class MyLRScheduler(torch.optim.lr_scheduler._LRScheduler): def __init__(self, optimizer, step_size=10, gamma=0.1): self.step_size = step_size self.gamma = gamma super(CustomLRScheduler, self).__init__(optimizer) def get_lr(self): \"\"\"Calculate the learning rate at a given step.\"\"\" return [base_lr * self.gamma ** (self.last_step // self.step_size) for base_lr in self.base_lrs] def step(self, epoch=None): \"\"\"Update the learning rate at the end of the given epoch.\"\"\" if epoch is None: self.last_step += 1 else: self.last_step = epoch + 1 self._last_lr = self.get_lr() for param_group, lr in zip(self.optimizer.param_groups, self._last_lr): param_group['lr'] = lr def get_lr_scheduler() #todo train.py 这个文件负责提供各种训练方法和过程 def train_model(model,criterion,optimizer,scheduler,num_epochs): since=time.time() best_model_wts=copy.deepcopy(model.state_dict()) best_acc=0.0 #每个epoch for epoch in range(num_epochs): print('Epoch {}/{}'.format(epoch,num_epochs-1)) print('-'*10) # 分为训练或者测试阶段 for phase in ['train','val']: if phase=='train': model.train() else: model.eval() running_loss=0.0 running_corrects=0 # 每个批次进行计算损失和反向梯度 for inputs,labels in dataloaders[phase]: inputs=inputs.to(device) labels=labels.to(device) optimizer.zero_grad() with torch.set_grad_enabled(phase=='train'): outputs=model(inputs) _,preds=torch.max(outputs,1) loss=criterion(outputs,labels) if phase=='train': loss.backward() optimizer.step() running_loss+=loss.item()*inputs.size(0) running_corrects+=torch.sum(preds==labels.data) epoch_loss=running_loss/dataset_sizes[phase] epoch_acc=running_corrects/dataset_sizes[phase] print('{} Loss :{:.4f} Acc:{:.4f}'.format(phase,epoch_loss,epoch_acc)) if phase=='val' and epoch_acc>best_acc: best_acc=epoch_acc best_model_wts=copy.deepcopy(model.state_dict()) scheduler.step() print() time_elapsed=time.time()-since print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed//60,time_elapsed%60)) model.load_state_dict(best_model_wts) return model main.py 主要负责对于各个文件部分的引用，整合代码，基本逻辑为 #数据集 dataset #数据迭代器 dataloader #模型 model #损失函数 criterion #优化器 optimizer #学习率优化器 lr_scheduler #训练 train #保存 save #预测 predict 可选优化 梯度裁剪 torch.nn.utils.clip_grad_norm_ 加载最优参数 ... 其他 可以去pytorch官网找找一些关于模型的优化。 参考资料","categories":[{"name":"模板","slug":"模板","permalink":"https://bg51717.github.io/categories/%E6%A8%A1%E6%9D%BF/"}],"tags":[{"name":"模板","slug":"模板","permalink":"https://bg51717.github.io/tags/%E6%A8%A1%E6%9D%BF/"},{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"}]},{"title":"信息熵","slug":"深度学习/前置数学/信息熵","date":"2024-01-31T11:19:50.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/5656/","link":"","permalink":"https://bg51717.github.io/5656/","excerpt":"","text":"信息熵的公式 计算信息熵的公式为: \\[ H(x)=-\\sum p(x_i)logp(x_i) \\] 其中\\(p(x_i)\\)表示事件结果为\\(x_i\\)的概率 理解 信息熵表示对事件不确定性的一个度量，计算思路为“编码一个事件的最短平均编码长度”（任意进制编码都行，彼此差一个常数，但常用的是二进制以及自然对数） 所以信息熵的计算也可以写作： \\[ H(x)=\\sum p(x_i)f(x_i) \\] 其中\\(p(x_i)\\)表示事件结果为\\(x_i\\)的概率，\\(f(x_i)\\)为编码\\(x_i\\)需要的位数（这也是为什么在比较概率分布的时候，会选择用拟合的概率来计算\\(f(x_i)\\)） Huffman编码树 类比哈夫曼树，根据贪心思想， 出现概率大的结果应该占据相对短的编码 编码结果的种类和编码位数是指数级关系 所以我们得到 \\[ f(x_i)=-logp(x_i) \\] 代入就得到了最终形式。 应用 KL散度 交叉熵损失 参考资料","categories":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"前置数学","slug":"深度学习/前置数学","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E5%89%8D%E7%BD%AE%E6%95%B0%E5%AD%A6/"}],"tags":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"数学","slug":"数学","permalink":"https://bg51717.github.io/tags/%E6%95%B0%E5%AD%A6/"},{"name":"信息学","slug":"信息学","permalink":"https://bg51717.github.io/tags/%E4%BF%A1%E6%81%AF%E5%AD%A6/"}]},{"title":"pytroch_tutorials杂项","slug":"杂项/pytroch_tutorials杂项","date":"2023-12-29T08:23:43.000Z","updated":"2024-09-24T11:40:26.457Z","comments":true,"path":"/20668/","link":"","permalink":"https://bg51717.github.io/20668/","excerpt":"","text":"介绍 当作快速过这个资料的笔记，一些关于别的库的介绍是不完全的，考虑在使用的时候从别的信息渠道就行信息的搜集。也可以作为后面待更博客列举？ 具体 torchscript Introduction to TorchScript — PyTorch Tutorials 2.2.1+cu121 documentation Loading a TorchScript Model in C++ — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了把pytorch模型转换成torchscript的两种方法torch.jit.trace和torch.jit.script，前者会失去控制流信息，后者会保留控制流信息（具体查阅文档）。 转化为torchscript有以下好处： 不需要Python解释器也可以运行，可以被pytorch自带的特殊解释器直接使用 转为torchscript可以进行各种优化，提高运行效率 方便被其他语言调用 ONNX (optional) Exporting a Model from PyTorch to ONNX and Running it using ONNX Runtime — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了在高效且跨平台ONNX运行环境部署的基本教程，通过torch.onnx把模型转化为onnx格式并保存，然后读取本地保存onnx格式模型并运行。 剖析pytorch model Profiling your PyTorch Module — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了torch.autograd.profiler,在代码里添加with profiler.record_function(\"MASK INDICES\"):可以记录代码运行的指标，比如时间，cpu和内存使用率等，名字可以自定义，支持可视化结果。 Introduction to Holistic Trace Analysis — PyTorch Tutorials 2.2.1+cu121 documentation Trace Diff using Holistic Trace Analysis — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了HolisticTraceAnalysis（HTA），一个用来剖析GPU运行情况的库。 把GPU运行时间分为了等待时间、计算时间和非计算时间，方便开发者评测模型运行的情况。还支持查看GPU内部的运行情况，也支持和之前的记录进行对比，也能可视化结果。 troch.fx 操作计算图 （测试版）在 FX 中构建卷积/批量范数热熔器 — PyTorch 教程 2.2.1+cu121 文档 torch.fx 是 PyTorch 提供的一个模块，它允许用户通过操作计算图来转换和优化 PyTorch 模型。这个模块提供了一种方式来表示和操作 PyTorch 模型的抽象，使得开发者可以更容易地对模型进行修改，例如重构模型结构、插入调试代码、优化性能等。 教程里介绍了一种融合相邻层的操作（只能用于eval模式）。比如融合卷积和归一化，融合之前，模型会把卷积结果写回显存，然后在调用归一化并且从显存读取之前结果；融合后变成一种操作，卷积结果不会写回显存，而是直接进行归一化后写会显存。 def _parent_name(target : str) -> Tuple[str, str]: \"\"\" Splits a ``qualname`` into parent path and last atom. For example, `foo.bar.baz` -> (`foo.bar`, `baz`) \"\"\" *parent, name = target.rsplit('.', 1) return parent[0] if parent else '', name def replace_node_module(node: fx.Node, modules: Dict[str, Any], new_module: torch.nn.Module): assert(isinstance(node.target, str)) parent_name, name = _parent_name(node.target) setattr(modules[parent_name], name, new_module) def fuse(model: torch.nn.Module) -> torch.nn.Module: model = copy.deepcopy(model) # The first step of most FX passes is to symbolically trace our model to # obtain a `GraphModule`. This is a representation of our original model # that is functionally identical to our original model, except that we now # also have a graph representation of our forward pass. #获取计算图 fx_model: fx.GraphModule = fx.symbolic_trace(model) modules = dict(fx_model.named_modules()) # The primary representation for working with FX are the `Graph` and the # `Node`. Each `GraphModule` has a `Graph` associated with it - this # `Graph` is also what generates `GraphModule.code`. # The `Graph` itself is represented as a list of `Node` objects. Thus, to # iterate through all of the operations in our graph, we iterate over each # `Node` in our `Graph`. #枚举所有计算图节点 for node in fx_model.graph.nodes: # The FX IR contains several types of nodes, which generally represent # call sites to modules, functions, or methods. The type of node is # determined by `Node.op`. #计算图节点还有别的属性,具体可以查阅相关资料 if node.op != 'call_module': # If our current node isn't calling a Module then we can ignore it. continue # For call sites, `Node.target` represents the module/function/method # that's being called. Here, we check `Node.target` to see if it's a # batch norm module, and then check `Node.args[0].target` to see if the # input `Node` is a convolution. #modules指的是模块,node.target指的是节点名字,node.args应该指的是输入这个节点的前置节点 if type(modules[node.target]) is nn.BatchNorm2d and type(modules[node.args[0].target]) is nn.Conv2d: if len(node.args[0].users) > 1: # Output of conv is used by other nodes continue conv = modules[node.args[0].target] bn = modules[node.target] fused_conv = fuse_conv_bn_eval(conv, bn) replace_node_module(node.args[0], modules, fused_conv) # As we've folded the batch nor into the conv, we need to replace all uses # of the batch norm with the conv. #把使用到node节点输出的地方变成node.args[0]节点输出 node.replace_all_uses_with(node.args[0]) # Now that all uses of the batch norm have been replaced, we can # safely remove the batch norm. fx_model.graph.erase_node(node) #检查计算图（Graph）的完整性和一致性,确定计算图的正确性 fx_model.graph.lint() # After we've modified our graph, we need to recompile our graph in order # to keep the generated code in sync. #recompile()方法的作用是将这些修改后的计算图转换回 Python 代码，这样你就可以创建一个新的 PyTorch 模型实例，它包含了你所做的所有修改 fx_model.recompile() return fx_model （测试版）使用 FX 构建简单的 CPU 性能分析器 — PyTorch 教程 2.2.1+cu121 文档 通过 print(traced_rn18.graph)我们可以查看计算图的信息，这里只选择一行查看，例子: %layer1_1_conv2 : [num_users=1] = call_module[target=layer1.1.conv2](args = (%layer1_1_relu,), kwargs = {}) %layer1_1_conv2:节点名字, [num_users=1]:被几个后续节点使用, call_module:表面这是一个调用模块, target=layer1.1.conv2:调用模块的名字, args = (%layer1_1_relu,):传递给模块的参数(输入模块的之前节点) kwargs = {}:额外关键词参数 可以参照教程写一个继承torch.fx.Interpreter的类,重写run和run_node实现对于计算图的捕获，在运行过程中添加自定义行为。 存储组织 (beta) Channels Last Memory Format in PyTorch — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了内存组织方式torch.channels_last，torch.contiguous_format等，同时介绍了一下torch.stride、torch.contiguous和torch.is_contiguous等函数。 有的操作符会保留内存组织格式。 可以通过model.to(memory_format=)把模型转化为适合的组织形式，同时输入也需要相应的转换（框架应该支持自动转换？）。 但由于不是所有的操作符都支持某种内存组织格式，可能需要进行检查，这里给了检查和设置的示例代码。 前向模式自动微分 正向模式自动微分 （Beta） — PyTorch 教程 2.2.1+cu121 文档 这里看的不是很明白。挖个坑（todo... 正向传播一次只能算出相对一个参数的梯度，如果有n个参数，需要计算n次，所以这里的tangent只有一个，而不是每个参数对应一个。 可以参考【自动微分原理】AD的正反向模式 - 知乎 (zhihu.com)。 （这么一看，正向自动微分被方向自动微分爆杀？目前应用少且pytorch也只是测试版本 微分矩阵计算 雅可比派、黑森派、hvp、vhp 等：编写函数转换 — PyTorch 教程 2.2.1+cu121 文档 这里提供了各种使用自动求导计算微分矩阵的方法。 模型组装 模型组装 — PyTorch 教程 2.2.1+cu121 文档 这里介绍了torch.func.stack_model_state、torch.vmap等函数用来组装一系列结构相同参数不同的模型的输出，类似于使用cat连接模型输出，但是增加了底层优化。 单样本梯度 Per-sample-gradients — PyTorch 教程 2.2.1+cu121 文档 在一些要求对每个样本单独计算梯度的特殊情况下，可以使用本篇介绍的方法优化速度。 这里介绍了torch.func.grad、torch.func.functional_call、torch.func.vmap来优化加速（注意不同库有不同的同名函数） 这里grad和vmap都是创建的可调用对象，与别的同名函数不同。 c++接口 Using the PyTorch C++ Frontend — PyTorch Tutorials 2.2.1+cu121 documentation 介绍了怎么使用c++调用 TorchScript 中的动态并行性 TorchScript 中的动态并行性 — PyTorch 教程 2.2.1+cu121 文档 这里介绍了torch.jit.fork和torch.jit.wait两个函数用来并行执行pytorch相关代码。同时也引入了相关的类torch.jit.Future。 c++接口中的自动求导 Autograd in C++ Frontend — PyTorch Tutorials 2.2.1+cu121 documentation 这里都是一些用c++扩展pytorch的内容，后面需要细致学习（挖坑todo 自定义函数求二阶导 Double Backward with Custom Functions — PyTorch Tutorials 2.2.1+cu121 documentation 这篇文章介绍了怎么使用继承自torch.autograd.Function的自定义函数（重新forward和backward），计算导数，并且用torch.autograd.gradcheck使用数值解验证求导以及使用torchviz 可视化图形。 同时，注意在运行过程中，保存求导所需要参数时候建议按照教程分保存输入、保存输出和保存中间结果考虑代码结构，避免bug。 forward函数返回结果似乎和backward参数对应，backward输入参数是每个forward函数返回结果的grad。 保存中间结果的时候需要把中间结果返回，这样可以让pytorch的自动微分系统追踪这些中间结果（个人理解为返回中间结果相当于注册了这些中间结果，在backward的时候设置grad模型就会追踪这些中间结果，理解可能有误，但是使用的时候参考教程应该问题不大）。 自定义函数实现卷积 Fusing Convolution and Batch Norm using Custom Function — PyTorch Tutorials 2.2.1+cu121 documentation 先介绍了自定义卷积函数的构造，这里的once_differentiable指的是正向传播的结果只会反向传播一次，作用为求二阶导的时候会报错，从而起到限制的作用。 然后介绍了自定义批量归一化层的构造，然后介绍了自定义函数混合卷积和批量归一化，从而实现了节省内存的作用。 自定义 C++ 和 CUDA 扩展 Custom C++ and CUDA Extensions — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了两个扩展c++组件的方法，“ahead of time ”和“just in time”。 ahead of time：构建setup.py文件用于构建c++扩展，然后在对应的cpp文件里面构建c++扩展代码。 just in time:通过torch.utils.cpp_extension.load直接加载cpp文件，会把编译的中间文件存在一个临时目录里。 这里还介绍了编写混合 C++/CUDA 扩展，由于还没有学过cuda，挖个坑todu... 使用自定义 C++ 运算符扩展 TorchScript Extending TorchScript with Custom C++ Operators — PyTorch Tutorials 2.2.1+cu121 documentation 如题，后面需要细致学习todo,,, 使用自定义 C++ 类扩展 TorchScript Extending TorchScript with Custom C++ Classes — PyTorch Tutorials 2.2.1+cu121 documentation 如题，后面需要细致学习todo,,, 在C++中注册一个分派操作符 Registering a Dispatched Operator in C++ — PyTorch Tutorials 2.2.1+cu121 documentation 由于一个操作在不同的设备上对应不同的底层代码，所以为了抽象化其操作，方便调用，需要在内核注册对应设备对应函数，然后在调用。 比如，第一个把 myadd_cpu注册到cpu上的 myadd函数，当在cpu上运行 myadd函数时候，会调用 myadd_cpu TORCH_LIBRARY_IMPL(myops, CPU, m) { m.impl(\"myadd\", myadd_cpu); } TORCH_LIBRARY_IMPL(myops, CUDA, m) { m.impl(\"myadd\", myadd_cuda); } 然后在使用的时候，通过torch的调度器自动根据设备在内核寻找合适函数调用。 Tensor myadd(const Tensor& self, const Tensor& other) { static auto op = torch::Dispatcher::singleton() .findSchemaOrThrow(\"myops::myadd\", \"\") .typed<decltype(myadd)>(); return op.call(self, other); } 这里还介绍了自动投影机制autocast，用于在运算之前把精度投影到合适的精度。 在 C++ 中扩展新后端的调度程序 Extending dispatcher for a new backend in C++ — PyTorch Tutorials 2.2.1+cu121 documentation 后端（backend）通常指的是支持PyTorch运行的底层系统或框架，这里介绍了如何添加自定义的框架。(大致是需要实现一些基本的运算，别的运算可以表示成这样运算的组合)。 Facilitating New Backend Integration by PrivateUse1 — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了使用privateuse1注册新后端的流程。 结合tensorboard的profiler PyTorch Profiler With TensorBoard — PyTorch Tutorials 2.2.1+cu121 documentation 这篇文章介绍了profiler结合tensorboard的使用。 使用Ray Tune进行超参数调优 Hyperparameter tuning with Ray Tune — PyTorch Tutorials 2.2.1+cu121 documentation 这篇文章介绍了怎么使用Ray Tune库进行超参数的搜索。 优化Vision Transformer模型 Optimizing Vision Transformer Model for Deployment — PyTorch Tutorials 2.2.1+cu121 documentation 这篇文章介绍了怎么去优化Vision Transformer模型，列举了一些常见的优化方式。 参数化教程 Parametrizations Tutorial — PyTorch Tutorials 2.2.1+cu121 documentation 这里的参数化指的是类似于对模型部分权重使用的一种限制，应该是在参数修改后调用（比如初始化，参数更新等）的一些nn.module，从而使得模型更加灵活，实现对不同参数的不同处理过程，具体使用过程也是看教程，进行类的注册，使用函数parametrize。 with parametrize.cached():可以开启参数的缓存模型。 可以对于一个参数注册多个参数化模块。 同时参数化模块内部有的函数可以只在特殊时期调用，比如初始化。 可以移除参数化模块。 剪枝教程 Pruning Tutorial — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了剪枝和机制，以及钩子函数的引入。 介绍了组合剪枝，通过移除重参数化来永久化剪枝，不同模块针对剪枝，全局剪枝，扩展自己的剪枝函数等。 动态量化 (beta) Dynamic Quantization on an LSTM Word Language Model — PyTorch Tutorials 2.2.1+cu121 documentation (beta) Dynamic Quantization on BERT — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了使用torch.quantization.quantize_dynamic动态量化一次常见模型的例子。 计算机视觉的量化迁移学习教程 (beta) Quantized Transfer Learning for Computer Vision Tutorial — PyTorch Tutorials 2.2.1+cu121 documentation 这篇文章介绍了在微调时候插入量化模拟层和反量化层，从而让模型适应量化的过程（QAT）。 PyTorch 中具有 Eager 模式的静态量化 (beta) Static Quantization with Eager Mode in PyTorch — PyTorch Tutorials 2.2.1+cu121 documentation 这个教程演示如何进行训练后静态量化，并说明两种更先进的技术，通道量化和量化感知训练。 从第一性原理挖掘 PyTorch Intel CPU 性能 Grokking PyTorch Intel CPU performance from first principles — PyTorch Tutorials 2.2.1+cu121 documentation Grokking PyTorch Intel CPU performance from first principles (Part 2) — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了优化CPU性能的方法和原理，目前来说太高深（挖矿todo 带 Ax 的多目标 NAS Multi-Objective NAS with Ax — PyTorch Tutorials 2.2.1+cu121 documentation 这篇文章介绍了怎么使用Ax平台进行神经网络架构的搜索。 torch.compile介绍 Introduction to torch.compile — PyTorch Tutorials 2.2.1+cu121 documentation 可以使用torch.compile当做装饰器或者函数使用。 同时也列举了几个模式以及和别的几个优化方法的对比。 Inductor CPU backend debugging and profiling Inductor CPU backend debugging and profiling — PyTorch Tutorials 2.2.1+cu121 documentation 这篇文章介绍了怎么对C++后端进行debug和profile的过程。有点复杂，，，（挖坑todo 实现高效缩放点积注意力Transformer (Beta) Implementing High-Performance Transformers with Scaled Dot Product Attention (SDPA) — PyTorch Tutorials 2.2.1+cu121 documentation 这篇文章介绍了怎么优化使用常用的缩放点积注意力。 torch.nested.nested_tensor支持融合不同长度的张量。 知识蒸馏 Knowledge Distillation Tutorial — PyTorch Tutorials 2.2.1+cu121 documentation 这篇教程介绍了知识蒸馏的几个方式，主要都是在损失函数里面添加教师模型和学生模型的各种量化差异来训练学生模型。 分布式（挖坑todo 参考资料 Welcome to PyTorch Tutorials — PyTorch Tutorials 2.2.1+cu121 documentation","categories":[{"name":"杂项","slug":"杂项","permalink":"https://bg51717.github.io/categories/%E6%9D%82%E9%A1%B9/"}],"tags":[{"name":"pytroch_tutorials","slug":"pytroch-tutorials","permalink":"https://bg51717.github.io/tags/pytroch-tutorials/"}]},{"title":"Adam Optimizer","slug":"深度学习/经典模块/Adam-Optimizer","date":"2023-12-29T08:23:43.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/12551/","link":"","permalink":"https://bg51717.github.io/12551/","excerpt":"","text":"背景 传统的随机梯度下降算法SGD(Stochastic Gradient Descent)的式子为: \\[ \\theta_{t+1} \\leftarrow \\theta_{t} -\\alpha \\nabla_{\\theta_{t}}J_{minibatcg}(\\theta_{t}) \\] 其中\\(J\\)为损失函数,\\(\\theta_{t}\\)为t时刻的参数,\\(\\alpha\\)为学习率,\\(\\nabla_{\\theta_{t}}J_{minibatcg}(\\theta_{t})\\)为t时刻梯度. Adam算法初步优化 考虑让梯度更加平滑,有以下式子: $$ m_{t+1} {1}m{t}+(1-{1}){{t}}J{minibatcg}(_{t}) \\ {t+1} {t} -m_{t+1} $$ 优点: 梯度更加平滑,减少了振荡 可以在初始设置更大的学习率 Adam算法最终优化 通过对应\"动量\"这一想法的进一步扩展,我们得到了新的学习算法式子: $$ m_{t+1} _1 m_t + (1 - 1) {t} J{}(t) \\ v{t+1} _2 v_t + (1 - 2)({t} J{}(t) {t} J{}(_t)) \\ _{t+1} _t - $$ 其中\\(\\beta_{1},\\beta_{2}\\)是大小在0和1之间的超参数,\\(\\odot\\)是平方的符号,\\(\\alpha\\)是学习率. 优点: 梯度更加平滑,减少了振荡 可以在初始设置更大的学习率 接收较小或很少更新的模型参数将得到较大的更新 参考资料 11.10. Adam算法 — 动手学深度学习 2.0.0 documentation (d2l.ai) Stanford CS 224N | Natural Language Processing with Deep Learning","categories":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"经典模块","slug":"深度学习/经典模块","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E7%BB%8F%E5%85%B8%E6%A8%A1%E5%9D%97/"}],"tags":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"优化算法","slug":"优化算法","permalink":"https://bg51717.github.io/tags/%E4%BC%98%E5%8C%96%E7%AE%97%E6%B3%95/"}]},{"title":"依赖分析Dependency Parsing","slug":"深度学习/自然语言处理/依赖分析Dependency-Parsing","date":"2023-12-27T14:21:54.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/26708/","link":"","permalink":"https://bg51717.github.io/26708/","excerpt":"","text":"介绍 这里介绍两种语义结构: Constituency Parsing：句法分析，Context-free grammars(CFGs)，上下文无关语法，赋予每个单词一个词性类别，单词组合成短语，短语递归形成更大的短语 Dependency Parsing：直接通过单词与其他单词的关系表示句子的结构，表示单词依赖于(修饰或是其参数)其他单词 Dependency Parsing缺陷 不同的自然语言有不同的组织结构,每种自然语言都有独特的二义问题(ambiguity),即同一个句子通过不同Dependency Parsing分析会得到不同语义树,进而得到不同的语句意思. 总的可能的语义数目极限情况下大概是随着字符串的提示可能是指数级增加,所以有一些方法来解决这些问题. Dependency Structure 通过一个单向边指明依赖关系(同时这个边也会指明依赖关系的种类),进而组成一个树状结构,通常会添加一个虚拟的\"ROOT\"节点作为根节点 1703687822509 1703687931983 Greedy transition-based parsing 1703688065130 初始状态:\\(\\sigma=[ROOT],\\beta=w_1,...,w_n,A=\\empty\\) 三种操作: Shift : 从缓存区\\(\\beta\\)里面移入一个词到栈\\(\\sigma\\)里面 Left-Arc : 将\\((w_j,r,w_i)\\)加入边集合\\(A\\) ,其中\\(w_i\\)是stack上的次顶层的词,\\(w_j\\)是stack上的最顶层的词,然后保留\\(w_j\\)在栈中（堆必须包含两个单词以及 \\(w_i\\)不是 ROOT ） Right-Arc : 将\\((w_i,r,w_j)\\)加入边集合\\(A\\) ,其中\\(w_i\\)是stack上的次顶层的词,\\(w_j\\)是stack上的最顶层的词,然后保留\\(w_i\\)在栈中（堆必须包含两个单词以及 \\(w_i\\)不是 ROOT ） 重复上述操作到指定目标. 实际应用的时候,如何判断选择哪一种操作可以通过机器学习的方式来判断,也可以加入集束搜索来寻找最优解. 评判标准: UAS:找准依赖项的词的比例 LAS:在UAS基础上,还要求边的属性得准确 示例: 1703689446845 参考资料 2021斯坦福CS224N课程笔记~2_context-free grammars and constituency parsing-CSDN博客","categories":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"自然语言处理","slug":"深度学习/自然语言处理","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"}],"tags":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"自然语言处理","slug":"自然语言处理","permalink":"https://bg51717.github.io/tags/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"}]},{"title":"矩阵偏分","slug":"深度学习/前置数学/矩阵偏分","date":"2023-12-24T07:18:43.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/45525/","link":"","permalink":"https://bg51717.github.io/45525/","excerpt":"","text":"在学习深度学习的过程中,很多次遇到了矩阵求导的问题,发现网上很多教程写的不是很好理解,记录自己的浅薄认知. （矩阵求导有分子转置和分母转置两种，本篇介绍的是分母转置。） Jacobian形式 矩阵论里的求导: 假设\\(A\\)矩阵维度列表为\\([a_1,a_2,...,a_n]\\) 假设\\(B\\)矩阵维度列表翻转为\\([b_m,b_{m-1},...,b_1]\\) \\(A\\)矩阵对\\(B\\)矩阵求偏导的结果\\(C\\),维度上相当于\\(A\\)矩阵维度列表和\\(B\\)矩阵维度列表翻转连起来 即\\(C\\)矩阵维度列表为\\([a_1,a_2,...,a_n,b_m,b_{m-1},...,b_1]\\) 根据维度信息也能很方便的推导各个元素的含义,即为\\(A\\)矩阵的每个元素对\\(B\\)矩阵的每个元素求一个偏导。 行向量偏导形式 此外，行向量偏导和Jacobian形式不同。把矩阵变成按列堆栈向量化\\(vec\\)， \\[ vec(X)=[x_{11},x_{21},..,x_{12},x_{22},...,x_{1n},x_{2n},...,x_{nm}]^T \\] 合适做法 合适的做法还是对于矩阵的每个元素单独看梯度和贡献，然后根据指标的变化来总结公式。 比如，计算\\(x_{ij}\\)是如何影响\\(y_{ik}\\)的，然后总结梯度公式。 示例1： \\[ X*A=Y,而X \\in R^{n \\times p}, A \\in R^{p \\times m},Y \\in R^{n \\times m},l为标量 \\\\ 已知\\frac{\\partial l}{\\partial Y},求\\frac{\\partial l}{\\partial X} \\\\ 计算x_{ik}的贡献,有 \\frac{\\partial z}{\\partial x_{ik}}=\\sum_{j}a_{kj}\\frac{\\partial z}{\\partial y_{ij}} \\\\ 根据维度信息(i在左侧,k在右侧)总结,得到\\frac{\\partial l}{\\partial X}=\\frac{\\partial l}{\\partial Y}A^T \\] tip:由于一维向量很多时候会被写为列向量,所以有的教程理解不是很方便,但如果接触过pytorch框架,会方便理解很多. 参考资料 矩阵求导的本质与分子布局、分母布局的本质（矩阵求导——本质篇） - 知乎 (zhihu.com) 【ML-0-3】矩阵求导-链式法则 - 忆凡人生 - 博客园 (cnblogs.com)","categories":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"前置数学","slug":"深度学习/前置数学","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E5%89%8D%E7%BD%AE%E6%95%B0%E5%AD%A6/"}],"tags":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"矩阵","slug":"矩阵","permalink":"https://bg51717.github.io/tags/%E7%9F%A9%E9%98%B5/"},{"name":"数学","slug":"数学","permalink":"https://bg51717.github.io/tags/%E6%95%B0%E5%AD%A6/"}]},{"title":"GloVe","slug":"深度学习/自然语言处理/GloVe","date":"2023-12-22T08:36:28.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/51558/","link":"","permalink":"https://bg51717.github.io/51558/","excerpt":"","text":"介绍 相比Word2Vec的局部训练,GloVe可以使用全局的语料统计信息来训练,可以预先计算全局语料库统计数据来提高训练数据. 带全局语料统计的跳元模型 用\\(q_{ij}\\)表示词\\(w_j\\)的条件概率\\(P(w_j|w_i)\\),在跳元模型中给定词\\(w_i\\),我们有 \\[ q_{ij}=\\frac{exp(\\bm u^T_j\\bm v_i)}{\\sum_{k \\in V}exp(\\bm u^T_k\\bm v_i)} \\] 记录\\(w_i\\)在所有出现地方的上下文构成一个可重集合\\(C_i\\),其中元素j的数目记为\\(x_{ij}\\),损失函数定义为 \\[ -\\sum_{i\\in V}\\sum_{j\\in V}x_{ij}log\\ q_{ij} \\] 用\\(x_i\\)表示\\(|C_i|\\),用\\(p_{ij}\\)表示概率\\(x_{ij}/x_i\\),则损失函数可以改写为 \\[ -\\sum_{i\\in V}x_i\\sum_{j\\in V}p_{ij}log\\ q_{ij} \\] 我们发现\\(-\\sum_{j\\in V}p_{ij}log\\ q_{ij}\\)就是计算全局语料统计的条件分布\\(p_{ij}\\)和模型预测的条件分布\\(q_{ij}\\)的交叉熵。 GloVe模型 考虑到计算成本的问题,以及大量罕见事件被损失建模,GloVe模型基于平方损失对模型进行了以下修改: 使用变量\\(p^{'}_{ij}=x_ij\\)和\\(q^{'}_{ij}=exp(\\bm u^T_{j}\\bm v_i)\\),并取两者对数,所以平方损失为\\((log\\ p^{'}_{ij}-log\\ q^{'}_{ij})^2=(\\bm u^T_{j}\\bm v_i-log\\ x_{ij})^2\\). 为每个词\\(w_i\\)添加中心词偏执\\(b_i\\)和上下文词偏置\\(c_i\\) 用权重函数\\(h(x)\\)替代损失项权重,其中\\(h(x)\\)在[0,1]的间隔内递增. 最后总的损失函数为: \\[ \\sum_{i\\in V}\\sum_{j\\in V}h(x_{ij})(\\bm u^T_{j}\\bm v_i+b_i+c_j-log\\ x_{ij})^2 \\] 由于对称性,有\\(x_{ij}=x_{ji}\\),而Word2Vec没有拟合对称性,GloVe拟合了对称性.因此,在GloVe模型中,词的上下文向量\\(u_i\\)和中心词向量\\(v_i\\)应该是相等的,但在实际应用中,由于训练过程的随机化导致两个向量有轻微不同,因此GloVe将两者相加作为输出向量. 参考资料1也提供了另一种理解GloVe模型的思路,和cs224n里面类似. 参考资料 14.5. 全局向量的词嵌入（GloVe） — 动手学深度学习 2.0.0 documentation (d2l.ai)","categories":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"自然语言处理","slug":"深度学习/自然语言处理","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"}],"tags":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"自然语言处理","slug":"自然语言处理","permalink":"https://bg51717.github.io/tags/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"}]},{"title":"Word2Vec","slug":"深度学习/自然语言处理/Word2Vec","date":"2023-12-21T08:53:05.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/5925/","link":"","permalink":"https://bg51717.github.io/5925/","excerpt":"","text":"介绍 传统的词向量是独热编码One-Hot,每个词语对应的向量只有一位为1,其余为0,通过这个1的位置区分向量 Word2Vec是一种Distributed Representation,相比独热编码有以下优点: 维度远小于独热编码 能更好的反馈向量间的关系 每个维度都被充分利用 Word2Vec的网络结构 Word2Vec是轻量级的神经网络，其模型仅仅包括输入层、隐藏层和输出层，模型框架根据输入输出的不同，主要包括CBOW和Skip-gram模型。 CBOW模型,在知道上下文的情况下预测中心词\\(w_t\\) Skip-gram模型,在知道中心词\\(w_t\\)的情况下预测 1703252876064 网络结构基础 下图是两种模型结构的基础,是输入一个词,预测一个词 1703253424041 中间的运算都会使用矩阵方便加速: 一个词语转换成对应的词向量,就会使用独热编码乘以这个\\(W_{V\\times N}\\),(其中V为词库大小,N为词向量维度数) 一个词向量和别的词的上下文向量点乘,也会乘以矩阵\\(W^{'}_{V\\times N}\\),得到\\(\\bm y\\),也就是\\(\\bm u^T\\cdot \\bm v\\) 之后词语k的概率就是softmax: \\[ P(w_k|w_c)=\\frac{\\exp(\\bm u^T_k\\cdot \\bm v_c)}{\\sum \\exp(\\bm u^T_i\\cdot \\bm v_c)}=\\frac{\\exp(\\bm y_k)}{\\sum \\exp(\\bm y_i)} \\] 之后就是追求句子概率最大化: \\[ \\prod P(w_k|w_c) \\] 对数化后取负数就得到了损失函数: \\[ Loss=\\sum_{o \\in context}( \\bm u^T_k\\cdot \\bm v_c-log(\\sum_{i \\in V}exp(\\bm u^T_i\\cdot \\bm v_c))) \\] 通过微分，我们可以获得其相对于中心词向量\\(\\bm v_c\\)的梯度为 1703256300356 其他向量的方法也是类似.这里就不给予推导. CBOW 词袋模型 用上下文预测中心词\\(w_t\\) 1703256961548 Skip-gram Model 跳元模型 用中心词\\(w_t\\)预测上下文 1703256988046 近似训练 由于softmax操作的性质，上下文词可以是词表V中的任意项，式子包含与整个词表大小一样多的项的求 和。因此，跳元模型的梯度计算和连续词袋模型的梯度计算都包含求和。不幸的是， 在一个词典上（通常有几十万或数百万个单词）求和的梯度的计算成本是巨大的！ 为了降低上述计算复杂度，引入两种近似训练方法：负采样和分层softmax。由于跳元模型和连续词袋 模型的相似性，将以跳元模型为例来描述这两种近似训练方法。 负采样Negative Sampling 负采样指的是加入一些负样本来进行模型的训练. 负采样修改了原目标函数来减少运算成本. 给定中心词\\(w_c\\)的上下文窗口，任意上下文词\\(w_o\\)来自该上下文窗口的被认为是由下式建模概率的事件： \\[ P(D=1|w_c,w_o)=\\sigma(\\bm u^T_o\\bm v_c) \\] 其中 \\[ \\sigma(x)=\\frac{1}{1+exp(-x)} \\] 考虑最大化联合概率 \\[ \\prod^T_{t=1}\\prod_{-m\\leqslant j \\leqslant m,j\\neq 0} P(D=1|w_t,w_{t+j}) \\] 然而这样只考虑了正样本,当且仅当所有词向量都等于无穷大的时候,这个式子会最大化为1,因此考虑加入一些噪声词作为负样本. \\[ \\prod^T_{t=1}\\prod_{-m\\leqslant j \\leqslant m,j\\neq 0} P(w_{t+j}|w_t) \\\\ 其中 P(w_{t+j}|w_t)=P(D=1|w_t,w_{t+j})\\prod^K_{k=1,w_k\\thicksim P(w)}P(D=0|w_t,w_k) \\] 关于条件概率的对数损失函数为: 1703258521309 分层softmax Hierarchical Softmax 1703258985364 这是一颗二叉树,从根节点开始,每次走左节点还是右节点都是概率时间,每个叶子节点都是词,所以根据中心词向量预测上下文可以看作是从根节点到叶子节点路径的概率乘积. 一种构造二叉树的方法是根据词语的出现频率构造哈夫曼树. 在非叶子节点\\(i\\)走右边的概率是 \\[ \\sigma(\\bm x^T_w \\bm \\theta)=\\frac{1}{1+eps(-\\bm x^T_w \\bm \\theta)} \\] 根据中心词\\(w_t\\)预测上下文\\(w_o\\)的概率也很就容易得到. 参考资料 第一篇写的最为详细全面,包括本文各种没有提到的细节,点赞! 参考资料里面第一篇和第三篇其实说的是一个东西,只不过一个是以矩阵的形式给出的. 可以通过奇异值分解减少词的特征维度. 深入浅出Word2Vec原理解析 - 知乎 (zhihu.com) 如何通俗理解Word2Vec (23年修订版)-CSDN博客 14.1. 词嵌入（word2vec） — 动手学深度学习 2.0.0 documentation (d2l.ai)","categories":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"自然语言处理","slug":"深度学习/自然语言处理","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"}],"tags":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"自然语言处理","slug":"自然语言处理","permalink":"https://bg51717.github.io/tags/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"}]},{"title":"readme","slug":"课程资源/readme","date":"2023-12-08T15:46:44.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/17140/","link":"","permalink":"https://bg51717.github.io/17140/","excerpt":"","text":"前言 当大四结束的时候,才意识到大学过的十分失败,很多计算机的核心知识其实都是处于一知半解的状态,动手能力也还是有很大的差距.即使在大一的时候,就已经在知乎上面刷到过不少计科混子的自我吐槽和悔恨,并且立志不要这么做,但大四上结束后,发现终究还是浪费了重要的四年和对重要知识的追求. 所以希望能通过一些大神的网上课程资源的推荐,弥补自己计算机教育的不足,希望亡羊补牢,为时未晚. 介绍 首先打算参考cswiki上面的课程和相关资源学习理论知识和提高动手能力. 而本目录大概包括各个课程的: 学习笔记 作业代码 工程代码 参考资料 cswiki","categories":[{"name":"课程资源","slug":"课程资源","permalink":"https://bg51717.github.io/categories/%E8%AF%BE%E7%A8%8B%E8%B5%84%E6%BA%90/"}],"tags":[]},{"title":"文献管理工具zotero","slug":"工具/文献管理工具zotero","date":"2023-11-22T02:12:21.000Z","updated":"2024-09-24T11:40:26.457Z","comments":true,"path":"/43151/","link":"","permalink":"https://bg51717.github.io/43151/","excerpt":"","text":"这里推荐一个文献管理工具,zotero,很好用的文献管理工具，也能很好的辅助写论文，获取文献，免费开源且支持插件,可以参考这个b站up的视频搭建和使用这个工具。 参考资料 Zotero零基础保姆级教程","categories":[{"name":"工具","slug":"工具","permalink":"https://bg51717.github.io/categories/%E5%B7%A5%E5%85%B7/"}],"tags":[{"name":"工具","slug":"工具","permalink":"https://bg51717.github.io/tags/%E5%B7%A5%E5%85%B7/"},{"name":"文献管理","slug":"文献管理","permalink":"https://bg51717.github.io/tags/%E6%96%87%E7%8C%AE%E7%AE%A1%E7%90%86/"}]},{"title":"论文阅读:A_Survey_of_Quantization_Methods_for_Efficient_Neural_Network_Inference","slug":"科研/论文阅读/论文阅读~A_Survey_of_Quantization_Methods_for_Efficient_Neural_Network_Inference","date":"2023-10-23T12:10:11.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/62023/","link":"","permalink":"https://bg51717.github.io/62023/","excerpt":"","text":"论文地址:A Survey of Quantization Methods for Efficient Neural Network Inference 摘要 这篇论文是关于模型量化方向的综述，介绍了量化相关领域的研究，同时也介绍了一些重要的论文。 提到了量化的好处： 加快模型的推理过程 减少模型的存储开销 可以部署到特定设备（比如有的设备只能进行整型运算） 介绍 过去模型的能力有了巨大的提升，其中一个原因就是模型参数的增加，但这也为模型的部署提升了难度。 过去几年关于这方面的尝试有如下几种： 设计高效的神经网络模型架构，包括微观结构和宏观结构 神经网络软件和硬件协同设计 剪枝，减去对模型影响小的参数，分为结构化剪枝（删去部分参数）和非结构化剪枝（删去部分结构，相当于参数按组删去），两个方法各有优劣 知识蒸馏，用“教师”模型训练“学生”模型，可与前面方法结合 量化：分为训练中量化和推理量化 量化和神经科学的发展 这里很多次提到了AutoML和NAS技术调整网络结构 量化历史 量化，作为一种从大的（通常是连续的）集合中的输入值映射到小的（通常是有限的）集合中的输出值的方法，具有很长的历史。早在1897年就有微积分相关工作从事量化研究，同时，量化在信号处理中也非常重要。 香农在信息学和信号处理的研究过程中也针对量化进行过研究。同时，量化在连续数学量的数值求解中研究过。一些问题的良好解法可能由于数字量化会导致巨大误差，从而引出了算法数值稳定性的概念。 神经网络的发展给量化带来了机遇。神经网络的计算是计算密集型任务且目前很多模型都过度参数化。很多问题的解决都是基于一个某种误差度量，因此量化可能会增大误差，但同时也会增加模型的鲁棒性。 量化的基本概念 问题设置和符号 在不失一般性的情况下，让我们关注监督学习问题，即最小化下面所示的损失函数。 \\[ L(\\theta)=\\frac{1}{N} \\sum^{N}_{i=1}l(x_i,y_i;\\theta) \\] (x,y)是输入数据和对应的标签,$ l(x_i,y_i;)$是损失函数,N是数据数目 同时让我们把第\\(i\\)层的输入隐藏激活表示为\\(h_i\\),输出隐藏激活表示为\\(a_i\\),我们假设浮点格式存储的模型参数为\\(\\theta\\). 均匀量化 均匀量化和非均匀量化 1699360183609 均匀量化的一个常用的函数是 \\[ Q(r)=Int(\\frac{r}{S})-Z \\] \\(Q\\)是压缩函数,\\(r\\)是实数类型的输入,\\(S\\)是实数类型的比例因子,\\(Z\\)是整数零点,\\(Int\\)函数通过舍入操作把实数映射到整数 去量化操作 \\[ Q(\\tilde{r})=S(Q(r)+Z) \\] 由于舍入操作\\(\\tilde{r}\\)和\\(r\\)不会严格相等 对称和非对称量化 对称和非对称量化（观察量化前后零点位置 1699360947746 确定放缩因子\\(S\\)的式子为 \\[ S=\\frac{\\beta-\\alpha}{2^{b}-1} \\] \\([\\alpha,\\beta]\\)代表剪切范围,\\(b\\)代表量化位宽. 确定\\([\\alpha,\\beta]\\)的两个方式: \\(\\alpha=r_{min},\\beta=r_{max}\\) \\(-\\alpha=\\beta=max(|r_{min}|,|r_{max}|)\\) 利用实数的最大最小位选定裁剪范围可能会容易被异常数据影响,从而增加不必要的范围.解决这个问题的一种方法是使用百分位数,另一种方法是选择\\(α\\)和\\(β\\)，以最小化真实值和量化值之间的KL散度（即信息损失）.也有学者对不同的量化范围选取范围方法进行了评估. 确定\\(S\\)的两个方式: \\(\\frac{2max(|r|)}{2^n-1}\\) \\(\\frac{max(|r|)}{2^{n-1}-1}\\) 对称量化使用广泛,因为可以把零点降为0,减少计算成本并且实现更加简单;非对称量化对于范围可能是倾斜的和不对称的情况表现会更加优秀. 非对称激活中的偏移而占据的交叉项是一个静态数据独立项并且可以被偏差吸收(或用于初始化累加器). 范围校准算法：静态与动态量化 动态量化：运行期间计算量化参数，高精度，高开销 静态量化：量化参数预先确定，推理期间为静态，低开销，低精度 量化粒度 分层量化：通过一整个层的数值来计算量化参数，实现简单，精度次优 分组量化：把每一层的多个通道进行分组量化，有助于解决单个通道、激活分布离散的情况，但是计算开销会增加 分通道量化：每一层的每个通道进行量化，更好的精度，更高的计算成本 分卷积核（滤波器）量化：输入通道为\\(n\\)，输出通道为\\(m\\)，那么应该会有\\(n*m\\)个卷积核，根据卷积核量化会有更高的精度 总结（量化粒度）。通道量化是目前用于量化卷积核的标准方法。它使从业者能够以可忽略不计的开销来调整每个单独的内核的剪切范围。相比之下，子信道量化可能会导致巨大的开销，而且目前还不是标准的选择。 非均匀量化 量化步骤和量化水平被允许是非均匀间隔的 \\[ Q(r)=X_i, \\quad if\\quad r \\in [r_i,r_{i+1}] \\] 非均匀量化对于固定的位宽，可以获得更高的精度 典型的有 钟型分布 对数分布 二进制码,把一个向量拆成多个基向量的和,每个基向量的每个维度的值的绝对值为1 很多把量化问题转化为优化问题,减少原始张量r和量化后张量Q(r)的差异 \\[ \\underset{Q}{min}||Q(r)-r|| \\] 此外,量化器本身也可以和模型参数一起学习,称之为可学习的量化器 还有一些工作使用聚类来减少量化损失 非均匀量化能更好的捕获信息,但是计算成本更高,因此目前主流的还是均匀量化 微调方法 量化可能需要对参数进行微调,有两种方式: 量化感知训练QAT 训练后量化PTQ 左边是QAT,右边是PTQ QAT QAT一种方法展示 反向传播方法有: STE 随机神经元 组合优化 目标传播 Gumbelsoftmax 正则化算子来强制执行要量化的权重(量化过程没有不可微分算符) 也可以考虑量化感知训练的过程种学习量化参数 PTQ 由于PTQ不需要训练，所以对数据集的依赖比较低，当然，精度也会下降 因此，PTQ的研究重点都在于减轻PTQ的精度下降： ACIQ 解析地计算了PTQ的最佳剪切范围和通道级位宽设置 OMSE方法在激活时去除信道级量化，并提出通过优化量化张量与相应的浮点张量之间的L2距离来进行PTQ 一种离群值信道分裂（OCS）方法，该方法将包含离群值的信道重复和减半，缓解离群值对PTQ的不利影响 AdaRound表明，简单的圆到最近的量化方法（round-to-nearest）可以反直觉地得到次优解，并且提出了一种自适应四舍五入的方法 AdaQuant提出了一种更通用的方法，允许量化权值根据需要进行变化。 在PTQ中，所有的权值和激活量化参数都是不需要再训练而确定的。因此，PTQ是一种非常快速的神经网络模型量化方法。然而，与QAT相比，这往往以较低的准确性为代价。 Zero-shot Quantization（ZSQ） PTQ的极端场景，量化过程中不使用数据 Level 1: 没有数据且没有微调 (ZSQ + PTQ). Level 2: 没有数据但需要微调 (ZSQ +QAT). ZSQ中一个流行的研究分支是生成与类似于真实数据的合成数据，从中训练目标预先训练的模型。 随机量化 在推理过程中，量化方案总是确定的，小的权重更新可能不会导致任何权重变化，因为舍入操作可能总是返回相同的权重。然而，启用一个随机舍入可能为神经网络提供一个随机的机会，从而更新其参数。 比如，在有的论文里面，INT操作定义为 \\[ INT(x)=\\begin{cases} \\lfloor x \\rfloor ,with \\quad probability \\quad \\lceil x \\rceil-x\\\\ \\lceil x \\rceil ,with \\quad probability \\quad x-\\lfloor x \\rfloor\\\\ \\end{cases} \\] 有的会选择在量化的适合选择随机从量化参数权重子集里选一个进行量化运算 ADVANCED CONCEPTS: QUANTIZATION BELOW 8 BITS 模拟和纯整数量化 部署量化神经网络模型有两种常见方法： 模拟量化（又名假量化）：模拟量化中，量化后的模型参数以低精度存储，但运算（例如矩阵乘法和卷积）是用浮点运算进行的，运算之前需要对量化参数进行反量化 纯整数量化（又名定点量化）：所有运算都是使用低精度整数算术执行 1712407532667 如下图所示，硬件对低精度的处理会更好，并且低精度能量和面积方面的效率明显更高。 1712407640141 （这里稍微介绍了对于各种激活函数的量化方法，可以留意一下？ 二进量化（Dyadic quantization）是一种特殊的量化方法，通过把权重量化为二元数（二元数是分子中具有整数值、分母中具有 2 的幂的有理数），从而把运算转化为加减与位移从而提高效率。 两种量化种纯整数量化应用较多，但是假量化在通信成本高于计算成本的时候也有一定的应用前景。 混合精度量化 使用较低精度的量化时，硬件性能会提高。然而，将模型统一量化为超低精度可能会导致精度显着下降，可以通过混合精度量化来解决这个问题。 每一层都以不同的位精度进行量化，如下图所示。这种方法的一个挑战是，用于选择此位设置的搜索空间与层数成指数关系。人们提出了不同的方法来解决这个巨大的搜索空间。 1712408451748 搜索方法有： 强化学习 转化为神经架构搜索NAS使用DNAS解决 另一类混合精度方法使用周期函数正则化来训练混合精度模型，方法是在学习各自的位宽时自动区分不同的层及其在准确性方面的不同重要性。 HAWQ引入了一种基于模型二阶灵敏度自动查找混合精度设置的方法。 硬件感知量化 量化带来的性能提升和硬件有着密切关系，比如带宽设置、缓存结构等。因此，通过硬件感知量化实现最佳效益十分重要。 蒸馏辅助量化 量化领域的一个有趣的工作是结合模型蒸馏来提高量化精度。在学生模型的训练过程中，模型蒸馏建议利用教师产生的软概率，而不是仅使用真实类别标签，其中可能包含更多的输入信息。 \\[ \\mathcal{L}=\\alpha\\mathcal{H}(y,\\sigma(\\mathcal{z}_{s}))+\\beta\\mathcal{H}(\\sigma(\\mathcal{z}_{t},T),\\sigma(\\mathcal{z}_{s},T)) \\] α 和 β 是调整学生模型损失量和蒸馏损失的加权系数，y 是真实类别标签， \\(\\mathcal{H}\\)是交叉熵损失函数，\\({\\mathcal{z}}_{s}/{\\mathcal{z}}_{t}\\)是学生/教师模型生成的概率，T是温度。 \\[ p_{i}=\\frac{\\exp\\frac{z_{i}}{T}}{\\sum_{j}\\exp\\frac{z_{j}}{T}} \\] 然后有许多关于蒸馏过程的尝试，比如使用软概率、中间层数据、多教师模型等。 极致量化 这里提到了一些极端的量化方法，比如二值化和三值化等，但是极致的量化也会带来巨大的精度损失。因此有许多工作是关于极值量化的。目前大致有三个分支： 量化误差最小化 改进损失函数 改进训练方法 矢量量化 量化的目标是保持精度，而不是单个值的差异。因此有相关工作是把权重聚类分组然后使用中心作为量化值。还可以扩展为矩阵的乘积量化，把矩阵按照子矩阵分组。 量化和硬件处理器 这里罗列了一些处理器，并且介绍了他们的特点。 量化的未来研究 介绍了未来可以研究的几个东西： 量化软件 硬件和神经网络架构协同设计 耦合压缩方法 量化训练 总结和结论 ... 参考资料 A Survey of Quantization Methods for Efficient Neural Network Inference","categories":[{"name":"科研","slug":"科研","permalink":"https://bg51717.github.io/categories/%E7%A7%91%E7%A0%94/"},{"name":"论文阅读","slug":"科研/论文阅读","permalink":"https://bg51717.github.io/categories/%E7%A7%91%E7%A0%94/%E8%AE%BA%E6%96%87%E9%98%85%E8%AF%BB/"}],"tags":[{"name":"量化","slug":"量化","permalink":"https://bg51717.github.io/tags/%E9%87%8F%E5%8C%96/"}]},{"title":"论文阅读:BitNet_Scaling_1-bit_Transformers_for_Large_Language_Models","slug":"科研/论文阅读/论文阅读~BitNet-Scaling-1-bit-Transformers-for-Large-Language-Models","date":"2023-10-23T12:10:11.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/8948/","link":"","permalink":"https://bg51717.github.io/8948/","excerpt":"","text":"论文地址:BitNet: Scaling 1-bit Transformers for Large Language Models 摘要 这篇论文展示了BitNet,一种为大型语言模型设计的可扩展和稳定的1-bit转换器架构。具体地说，引入了BitLinear作为nn.Linar的插入替代,以便从头开始训练1-bit的权重。在语言建模上的实验结果表明，与最先进的8-bit量化方法和FP16 Transformer相比，BitNet在显著降低内存占用和能量消耗的同时，实现了强力的性能。此外，BitNet还展示了一种类似于全精度Transformers的缩放律，这表明它可以在保持效率和性能效益的同时有效地扩展到更大的语言模型。 1698064373146 图1： BitNet从头开始训练1-bit Transformers，以一种高效的方式获得竞争结果。BitNet明显优于最先进的量化方法。随着模型规模的扩大，成本节约变得更加显著，同时实现与FP16训练的模型的竞争性能。 介绍 大多数现有的大型语言模型的量化方法都是训练后的。它们简单且易于应用，因为它不需要对训练管道进行任何更改或重新训练模型。然而，它将导致更显著的精度损失，特别是当精度较低时，因为模型在训练过程中没有对量化表示进行优化。 深度神经网络的另一条量化链是量化感知训练。与训练后相比，它通常会产生更好的准确性，因为该模型被训练是为了考虑到从一开始就降低的精度。此外，它允许模型继续训练或进行微调，这对于大型语言模型至关重要。量化感知训练的挑战主要在于优化，即随着精度的降低，模型越来越难以收敛。此外，量化感知训练是否遵循神经语言模型的标度规律尚不清楚。 参考资料 BitNet: Scaling 1-bit Transformers for Large Language Models","categories":[{"name":"科研","slug":"科研","permalink":"https://bg51717.github.io/categories/%E7%A7%91%E7%A0%94/"},{"name":"论文阅读","slug":"科研/论文阅读","permalink":"https://bg51717.github.io/categories/%E7%A7%91%E7%A0%94/%E8%AE%BA%E6%96%87%E9%98%85%E8%AF%BB/"}],"tags":[{"name":"量化","slug":"量化","permalink":"https://bg51717.github.io/tags/%E9%87%8F%E5%8C%96/"}]},{"title":"Hexo+Github搭建个人Wiki风格博客","slug":"SmallProjects/博客搭建/Hexo+Github搭建个人Wiki风格博客","date":"2023-10-18T08:12:44.000Z","updated":"2024-09-24T11:40:26.457Z","comments":true,"path":"/13640/","link":"","permalink":"https://bg51717.github.io/13640/","excerpt":"","text":"介绍 以前一直不理解更新博客的用处，后来发现记录一些学到的东西和处理问题的经验对个人还是互联网都是有促进作用的(希望不是在生产互联网垃圾)。 所以本文会介绍一下个人搭建这个博客的过程。 博客风格 简洁（本来想弄点二次元风格的，但是博客还是减少点无用东西吧） 多级分类：多级分类可以帮助来快速浏览学过的知识点 标签：标签还是比较重要的，可以实习对相关博客的快速定位 主题选择 基于上述的需求，最终选择了Wikitten作为自己的博客主题 顺便放一下这个大佬的相关链接： Wiki地址：http://wiki.zthxxx.me/ Wikitten主题地址：https://github.com/zthxxx/hexo-theme-Wikitten/ 环境搭建 参考地址:使用 Hexo+GitHub 搭建个人免费博客教程（小白向） - 知乎 (zhihu.com) Github创建项目并取名为 用户名.github.io 使用 npm 一键安装 Hexo 博客程序 npm install -g hexo-cli 使用npm安装package.json里面的依赖 npm install 安装用于部署的包hexo-deployer-git npm install hexo-deployer-git --save 修改_config.yml文件末尾的Deployment部分 deploy: type: git repository: git@github.com:用户名/用户名.github.io.git branch: master 公式 参考文章：Hexo显示Latex公式最新解决方案_hexo latex-CSDN博客 卸载部分插件 npm un hexo-math npm un hexo-renderer-marked 安装hexo-renderer-pandoc渲染器 npm i hexo-renderer-pandoc 配置主题配置下的mathjax设置(文件位置在 \\themes\\{主题名}\\ _config.yml # MathJax mathjax: enable: true per_page: true 安装Pandoc 去Pandoc官网下载最新版本pandoc：Pandoc - About pandoc （参考文章说 Anaconda自带的 pandoc可能会引起问题并且提供了解决方案，但是笔者使用的是 miniconda，没有遇到任何问题 图片 参考文章：Hexo 引用本地图片以及引用本地任意位置图片的一点思路 | 养恐龙 (leay.net) 对于图片显示，hexo的原生设置较为冷门，hexo-asset-image等插件也提供了一定的解决方法，在博客文件同目录下设置个同名文件夹存放图片。但是笔者习惯使用 vscode编辑 markdown文章，而vscode默认在同目录下的 /image/{文件名}下存放图片文件。 笔者最后没有找到已有的较好的解决方案，于是写了个脚本文件进行处理（仅供参考）。 首先安装 hexo-asset-image插件，然后在 _config.yml里设置： post_asset_folder: true # 注意这个不能简单设置为false，否则插件hexo-asset-image会直接跳过（可以看看源码 marked: prependRoot: true postAsset: true 然后构建一个脚本文件在每次更新完后进行预处理，其中重要函数为 import os import shutil import re from functools import partial def move_directory(src, dst): \"\"\"把src下所有内容复制到dst下，并删除src\"\"\" # 确保目标目录存在 if not os.path.exists(dst): os.makedirs(dst) # 遍历源目录中的所有文件和子目录 for item in os.listdir(src): s = os.path.join(src, item) d = os.path.join(dst, item) # 如果是目录，递归移动子目录 if os.path.isdir(s): move_directory(s, d) else: # 移动文件，如果目标文件已存在，则跳过 if not os.path.exists(d): shutil.copy(s, d) # 最后，删除空的源目录 os.rmdir(src) def img_url_replace(match, file_name): pattern = r\"!\\[(.*?)\\]\\((.*?)\\)\" name, old_link = re.findall(pattern, match.group(0))[0] if old_link.startswith(\"./{file_name}\"): # 如果格式正确 return match.group(0) if old_link.startswith(\"./\"): old_link = old_link[2:] if old_link.startswith(\"image/\"): old_link = old_link[6:] return f\"\" def remedy_image_path(md_file_path): \"\"\"修改md文件中的图片路径\"\"\" with open(md_file_path, \"r\", encoding=\"utf-8\") as f: text = f.read() img_patten = r\"!\\[.*?\\]\\((.*?)\\)\" file_name = os.path.basename(md_file_path).split(\".\")[0] # img_patten = r'!\\[.*?\\]\\((.*?)\\)|<img.*?src=[\\'\\\"](.*?)[\\'\\\"].*?>' updated_text, changed_num = re.subn( img_patten, partial(img_url_replace, file_name=file_name), text ) if changed_num>0: with open(md_file_path, 'w', encoding='utf-8') as f: f.write(updated_text) def process_md_file(file_path): \"\"\"处理md文件\"\"\" # 如果不是md文件,返回 if not file_path.endswith(\".md\"): return file_dir, file_name = os.path.split(file_path) # 如果没有需要处理的文件 if not os.path.exists(os.path.join(file_dir, \"image\", file_name.split(\".\")[0])): return # 移动图片文件 move_directory( src=os.path.join(file_dir,'image',file_name.split('.')[0]), dst=os.path.join(file_dir,file_name.split('.')[0]) ) # 修改连接 remedy_image_path(file_path) def dfs(dir): \"\"\"dfs处理所有文件\"\"\" for root, dirs, files in os.walk(dir): for file in files: file = os.path.join(root, file) process_md_file(file) for sub_dir in dirs: sub_dir = os.path.join(root, sub_dir) dfs(sub_dir) Hexo常用命令 hexo clean #清除生成的网页文件 hexo g #生成静态网页 hexo s #本地运行博客 hexo d #将网页文件推送至远程服务器 Hexo常用文件夹 文件夹 备注 node_modules 依赖文件 .deploy_git 推送到远程的文件 public 生成的网页文件 themes 主题文件夹 scaffolds 博客模板文件夹 source 博客源文件 主题安装 Wikitten主题地址：https://github.com/zthxxx/hexo-theme-Wikitten/ 里面提供了双语详细的安装步骤,笔者使用的版本是 5b0d493 注意:里面有个可选步骤 配置mathjax渲染，笔者发现进行这个步骤后会出现生成网页文件失败的情况，跳过即可，并且暂时没发现有什么问题 评论系统giscus 由于不知名的原因，Gitment和Gitalk无法使用，选择了giscus来替代,参考Hexo静态博客使用giscus评论系统教程 1.打开自己的GitHub，选择博客所在仓库或可新建一个仓库 确保仓库是公开的(新建的时候选择 private或者在仓库的 Settings - General，选择 change visibility - change to public) 确保仓库开启了 Discussions(在仓库的 Settings - General，勾选 Discussions) 确保安装了 giscus app 2.打开官方配置页面giscus，生成代码 语言 仓库：填写格式：你的用户名/你的仓库名 页面 与 discussion 映射关系：由于本博客会分级，所以选择路径pathname Discussion分类：General 特性:按个人喜好即可，本博客加载了：启用主贴上的反应,将评论框放在评论上方,懒加载评论 主题：选择与博客风格一致的主题 3.修改主题 _config.yml 在文件末尾添加 giscus: enable: true 方便以后直接从配置文件开关评论区 4.粘贴代码 网页会自动生成代码,复制粘贴到网页模板文件即可 不同主题的模板文件位置可能不同，wiki主题在 themes/Wikitten/layout/comment/giscus.ejs下添加代码 (然后检查同目录的引入giscus的文件：counter.ejs，index.ejs，scripts.ejs，仿照之前代码添加引入) <% if (theme.comment.giscus.enable) { %> <div id=\"giscus-container\"></div> <script src=\"https://giscus.app/client.js\" data-repo=\"<%= theme.comment.giscus.repo %>\" data-repo-id=\"<%= theme.comment.giscus.repo_id %>\" data-category=\"<%= theme.comment.giscus.category %>\" data-category-id=\"<%= theme.comment.giscus.category_id %>\" data-mapping=\"pathname\" data-strict=\"0\" data-reactions-enabled=\"1\" data-emit-metadata=\"0\" data-input-position=\"top\" data-theme=\"<%= theme.comment.giscus.theme || 'light' %>\" data-lang=\"<%= theme.comment.giscus.lang || 'zh-CN' %>\" data-loading=\"lazy\" crossorigin=\"anonymous\" async> </script> <noscript>请启用 JavaScript 以查看评论。</noscript> <% } %> 然后修改 themes/Wikitten/layout/common/article.ejs文件，把 <% if (!index) { %> <%- partial('comment/index') %> <% } %> 移动到 <footer class=\"article-footer\"> </footer> 前面，两个代码块在同一个 div内。 然后在 themes/Wikitten/_config.yml内修改： comment: disqus: # enter disqus shortname here duoshuo: # enter duoshuo shortname here youyan: # enter youyan uid here giscus: enable: true repo: '' # 添加 repo_id: '' # 添加 category: 'General' category_id: '' # 添加 theme: 'light' lang: 'zh-CN' 对于不同的主题添加的方式可能不同 常见QA 修改配置文件应该修改站点的 _config.yml 还是主题的 _config.yml? 具体使用哪个，要看主题的源代码，如果是 config.xxx那就是用的根目录配置文件，如果是 theme.xxx那就用的是主题目录的配置文件。 怎么让自己的博客可以被常用搜索引擎搜索到? 很多搜索引擎可以在搜索框里用 site:网址来判断是否被收录 Google 打开Google搜索，搜索“Google Search Console” 根据提示登录你的Google账号 选择资源类型 选择验证方式(本博客用的是HTML标记,把对应代码添加到主题文件里面,本主题是 themes/Wikitten/layout/common/head.ejs) 在Google Search Console后台添加站点地图 参考资料 使用 Hexo+GitHub 搭建个人免费博客教程（小白向） Hexo 的个人 Wiki 主题 - Wikitten 超详细Hexo+Github博客搭建小白教程 Hexo显示Latex公式最新解决方案_hexo latex-CSDN博客 Hexo 引用本地图片以及引用本地任意位置图片的一点思路 | 养恐龙 (leay.net) Hexo静态博客使用giscus评论系统教程 Hexo官方文档","categories":[{"name":"SmallProjects","slug":"SmallProjects","permalink":"https://bg51717.github.io/categories/SmallProjects/"},{"name":"博客搭建","slug":"SmallProjects/博客搭建","permalink":"https://bg51717.github.io/categories/SmallProjects/%E5%8D%9A%E5%AE%A2%E6%90%AD%E5%BB%BA/"}],"tags":[{"name":"博客","slug":"博客","permalink":"https://bg51717.github.io/tags/%E5%8D%9A%E5%AE%A2/"},{"name":"Hexo","slug":"Hexo","permalink":"https://bg51717.github.io/tags/Hexo/"},{"name":"Wiki","slug":"Wiki","permalink":"https://bg51717.github.io/tags/Wiki/"}]},{"title":"快速启动工具——utools","slug":"工具/utools","date":"2023-04-05T02:12:21.000Z","updated":"2024-09-24T11:40:26.457Z","comments":true,"path":"/44392/","link":"","permalink":"https://bg51717.github.io/44392/","excerpt":"","text":"介绍 这里接受一个快速启动的工具utools和常用的插件。 utools utools已经被很多人开始使用了，无论是 alt+space 还是鼠标中键等快速启动方式，都可以使用户不要来回在鼠标和键盘之间切换从而提升效率。内置的一些默认插件已经可以极大的提升效率了。 utools优势： 完善的生态市场：里面有很多人在开发各种插件，并且插件的体积都非常小，也支持插件数据迁移 ，基本你想到的功能都可以在插件市场找到 多平台：utools在多个平台都可以使用，也可以多平台进行数据迁移 插件推荐 音速启动 utools搜索框可以使用且快速启动的大概为系统安装的软件搜素、文件搜索、网络搜索、插件搜索等，但是假如你有复杂的命令以及一个别名使用多个命令等，这是原生的utools无法使用的，而下面这款插件就可以使用。 音速启动插件是utools官方开发的插件，可以让utools快速启动的能力再次得到提高。在音速启动的配置界面，你可以配置一些命令，并且给这些常用的命令起别名，这样在utools搜索框内就可以通过别名快速运行一些命令。","categories":[{"name":"工具","slug":"工具","permalink":"https://bg51717.github.io/categories/%E5%B7%A5%E5%85%B7/"}],"tags":[{"name":"工具","slug":"工具","permalink":"https://bg51717.github.io/tags/%E5%B7%A5%E5%85%B7/"},{"name":"效率","slug":"效率","permalink":"https://bg51717.github.io/tags/%E6%95%88%E7%8E%87/"}]}],"categories":[{"name":"工具","slug":"工具","permalink":"https://bg51717.github.io/categories/%E5%B7%A5%E5%85%B7/"},{"name":"模板","slug":"模板","permalink":"https://bg51717.github.io/categories/%E6%A8%A1%E6%9D%BF/"},{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"工程细节","slug":"深度学习/工程细节","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E5%B7%A5%E7%A8%8B%E7%BB%86%E8%8A%82/"},{"name":"杂项","slug":"杂项","permalink":"https://bg51717.github.io/categories/%E6%9D%82%E9%A1%B9/"},{"name":"自然语言处理","slug":"自然语言处理","permalink":"https://bg51717.github.io/categories/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"},{"name":"huggingface","slug":"huggingface","permalink":"https://bg51717.github.io/categories/huggingface/"},{"name":"前置数学","slug":"深度学习/前置数学","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E5%89%8D%E7%BD%AE%E6%95%B0%E5%AD%A6/"},{"name":"经典模块","slug":"深度学习/经典模块","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E7%BB%8F%E5%85%B8%E6%A8%A1%E5%9D%97/"},{"name":"自然语言处理","slug":"深度学习/自然语言处理","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"},{"name":"课程资源","slug":"课程资源","permalink":"https://bg51717.github.io/categories/%E8%AF%BE%E7%A8%8B%E8%B5%84%E6%BA%90/"},{"name":"科研","slug":"科研","permalink":"https://bg51717.github.io/categories/%E7%A7%91%E7%A0%94/"},{"name":"论文阅读","slug":"科研/论文阅读","permalink":"https://bg51717.github.io/categories/%E7%A7%91%E7%A0%94/%E8%AE%BA%E6%96%87%E9%98%85%E8%AF%BB/"},{"name":"SmallProjects","slug":"SmallProjects","permalink":"https://bg51717.github.io/categories/SmallProjects/"},{"name":"博客搭建","slug":"SmallProjects/博客搭建","permalink":"https://bg51717.github.io/categories/SmallProjects/%E5%8D%9A%E5%AE%A2%E6%90%AD%E5%BB%BA/"}],"tags":[{"name":"安卓","slug":"安卓","permalink":"https://bg51717.github.io/tags/%E5%AE%89%E5%8D%93/"},{"name":"Google","slug":"Google","permalink":"https://bg51717.github.io/tags/Google/"},{"name":"模板","slug":"模板","permalink":"https://bg51717.github.io/tags/%E6%A8%A1%E6%9D%BF/"},{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"PyTorch","slug":"PyTorch","permalink":"https://bg51717.github.io/tags/PyTorch/"},{"name":"HuggingFace","slug":"HuggingFace","permalink":"https://bg51717.github.io/tags/HuggingFace/"},{"name":"Trainer","slug":"Trainer","permalink":"https://bg51717.github.io/tags/Trainer/"},{"name":"config","slug":"config","permalink":"https://bg51717.github.io/tags/config/"},{"name":"model","slug":"model","permalink":"https://bg51717.github.io/tags/model/"},{"name":"dataset","slug":"dataset","permalink":"https://bg51717.github.io/tags/dataset/"},{"name":"随机数","slug":"随机数","permalink":"https://bg51717.github.io/tags/%E9%9A%8F%E6%9C%BA%E6%95%B0/"},{"name":"vscode","slug":"vscode","permalink":"https://bg51717.github.io/tags/vscode/"},{"name":"python","slug":"python","permalink":"https://bg51717.github.io/tags/python/"},{"name":"调试","slug":"调试","permalink":"https://bg51717.github.io/tags/%E8%B0%83%E8%AF%95/"},{"name":"debug","slug":"debug","permalink":"https://bg51717.github.io/tags/debug/"},{"name":"transformers_tutorials","slug":"transformers-tutorials","permalink":"https://bg51717.github.io/tags/transformers-tutorials/"},{"name":"数学","slug":"数学","permalink":"https://bg51717.github.io/tags/%E6%95%B0%E5%AD%A6/"},{"name":"信息学","slug":"信息学","permalink":"https://bg51717.github.io/tags/%E4%BF%A1%E6%81%AF%E5%AD%A6/"},{"name":"pytroch_tutorials","slug":"pytroch-tutorials","permalink":"https://bg51717.github.io/tags/pytroch-tutorials/"},{"name":"优化算法","slug":"优化算法","permalink":"https://bg51717.github.io/tags/%E4%BC%98%E5%8C%96%E7%AE%97%E6%B3%95/"},{"name":"自然语言处理","slug":"自然语言处理","permalink":"https://bg51717.github.io/tags/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"},{"name":"矩阵","slug":"矩阵","permalink":"https://bg51717.github.io/tags/%E7%9F%A9%E9%98%B5/"},{"name":"工具","slug":"工具","permalink":"https://bg51717.github.io/tags/%E5%B7%A5%E5%85%B7/"},{"name":"文献管理","slug":"文献管理","permalink":"https://bg51717.github.io/tags/%E6%96%87%E7%8C%AE%E7%AE%A1%E7%90%86/"},{"name":"量化","slug":"量化","permalink":"https://bg51717.github.io/tags/%E9%87%8F%E5%8C%96/"},{"name":"博客","slug":"博客","permalink":"https://bg51717.github.io/tags/%E5%8D%9A%E5%AE%A2/"},{"name":"Hexo","slug":"Hexo","permalink":"https://bg51717.github.io/tags/Hexo/"},{"name":"Wiki","slug":"Wiki","permalink":"https://bg51717.github.io/tags/Wiki/"},{"name":"效率","slug":"效率","permalink":"https://bg51717.github.io/tags/%E6%95%88%E7%8E%87/"}]}
\ No newline at end of file
+{"meta":{"title":"Blogs","subtitle":"Welcome to bg51717's Wiki and Blog","description":"","author":"bg51717","url":"https://bg51717.github.io","root":"/"},"pages":[{"title":"404","date":"2024-09-30T09:25:30.000Z","updated":"2024-09-24T11:40:26.452Z","comments":true,"path":"404.html","permalink":"https://bg51717.github.io/404","excerpt":"","text":""},{"title":"contact","date":"2024-09-30T09:25:30.000Z","updated":"2024-09-24T11:40:26.464Z","comments":true,"path":"contact/index.html","permalink":"https://bg51717.github.io/contact/","excerpt":"","text":""},{"title":"about","date":"2024-09-30T09:25:30.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"about/index.html","permalink":"https://bg51717.github.io/about/","excerpt":"","text":""},{"title":"tags","date":"2024-09-30T10:23:38.000Z","updated":"2024-09-24T11:40:26.464Z","comments":true,"path":"tags/index.html","permalink":"https://bg51717.github.io/tags/","excerpt":"","text":""},{"title":"categories","date":"2024-09-30T09:25:30.000Z","updated":"2024-09-24T11:40:26.464Z","comments":true,"path":"categories/index.html","permalink":"https://bg51717.github.io/categories/","excerpt":"","text":""},{"title":"friends","date":"2018-12-12T13:25:30.000Z","updated":"2024-09-24T11:40:26.464Z","comments":true,"path":"friends/index.html","permalink":"https://bg51717.github.io/friends/","excerpt":"","text":""}],"posts":[{"title":"Welcome to bg51717's Wiki and Blog","slug":"index","date":"2024-09-24T11:40:26.457Z","updated":"2024-09-24T11:40:26.457Z","comments":true,"path":"/14261/","link":"","permalink":"https://bg51717.github.io/14261/","excerpt":"","text":"这是bg51717的个人Wiki和Blog站点，主要是把知识系统的罗列出来以及存放一些特殊bug的处理，当然也会更一些游戏或者二次元相关东西，也希望在成长的过程中可以认识许多志同道合的人。 本人一直认为互联网的开源是社会发展的重要原因之一，因为开源使得技术知识和解决问题的经验可以被记录和传承下去，很多时候在需要的时候可以被人们所发掘。 也希望可以通过博客让自己的思维有条理。很多时候我喜欢观察别人的思路，发现其实人与人的很多思路差距可能没有那么多。除开经验上的差别，很多人能成功的做成一件事很多原因是思维非常有条理，时时刻刻明白自己的应该做什么，下一步思路是什么。不会让自己的思维局限在某个步骤或者门槛上。从而即使在逆境中，也能实现把烂牌打出最好的效果。 在偶尔反思自己的不足的时候，深刻的发现拖延症是致命的，很多事情只要按照条理有计划的进行，结果其实都可以完成。但是拖延容易导致事情出现计划外的变故，进而导致完成的质量。这对于个人的成长来说是极为不利的。很早以前就看到了知行合一这个词，但是一直没有理解其重要性。后来发现，缺少行动力也会导致很多计划的失败。很多事物是需要我们用心去做，而不是用敷衍的态度去进行。在实践中不断地提升自己，革新自己。 不知道此刻在阅读这个博客的你是在何时何地打开的，也不知道你是为了探究什么而点开了这个链接。但是祝你身体健康，万事如意。大家一起学习，互相交流，共同成长！ 最后，附上我喜欢的一句话： 世界靠现实主义者维系，靠理想主义者发展。","categories":[],"tags":[]},{"title":"安卓手机配置Google","slug":"工具/安卓手机配置Google","date":"2024-08-27T10:14:49.000Z","updated":"2024-09-24T11:40:26.457Z","comments":true,"path":"/61294/","link":"","permalink":"https://bg51717.github.io/61294/","excerpt":"","text":"介绍 这篇博客主要记录了如何在安卓手机上配置谷歌三件套的服务。 对于非华为荣耀手机，可能仅仅需要简单的使用一些第三方的安装软件即可完成，比如 go安装助手等，资源较大且获取难度较低。 而本篇博客主要介绍华为荣耀手机如何获取谷歌三件套的服务和配置支付信息等。 介绍两个并行的方法，当其中一个方法失效的时候，可以用另一个方法的部分替代。 方法是 华谷套件和to-alan/HarmonyOSInstallGMS: 华为安装GMS教程 。 博主前面的流程都使用的是华谷套件，该软件可以在每一步运行完后自动检测是否设置成功。在卸载MicroG后，转为使用方法二进行后续的处理。 目前手机谷歌三件套运行稳定，基本可以提供原生的谷歌三件套服务。 支付方式的添加todo。 参考资料 to-alan/HarmonyOSInstallGMS: 华为安装GMS教程","categories":[{"name":"工具","slug":"工具","permalink":"https://bg51717.github.io/categories/%E5%B7%A5%E5%85%B7/"}],"tags":[{"name":"安卓","slug":"安卓","permalink":"https://bg51717.github.io/tags/%E5%AE%89%E5%8D%93/"},{"name":"Google","slug":"Google","permalink":"https://bg51717.github.io/tags/Google/"}]},{"title":"PyTorch代码转HF","slug":"模板/PyTorch代码转HF","date":"2024-08-06T10:56:13.000Z","updated":"2024-09-24T11:40:26.457Z","comments":true,"path":"/61054/","link":"","permalink":"https://bg51717.github.io/61054/","excerpt":"","text":"介绍 这篇博客主要介绍了怎么把一个已有的Pytorch代码转变成HF支持的格式，然后可以方便的放入HF代码流程中，并且使用一些HF的函数。代码转换主要涉及到以下几个方面： Config Model Trainer Dataset 因为ckpt里面的代码使用的会是相对导入，所以在转换的过程中，建议把 configuration_xxx.py和 modeling_xxx.py文件放在同一个目录下，并且添加 __init__.py文件。 Config 参考：Building custom models (huggingface.co) 示例： from transformers import PretrainedConfig from typing import List class LtgBertConfig(PretrainedConfig): model_type = \"LtgBert\" \"\"\"Configuration class to store the configuration of a `LtgBertModel`. \"\"\" def __init__(self, vocab_size_or_config_json_file=16384, hidden_size=768, num_hidden_layers=12, num_attention_heads=12, intermediate_size=3072, hidden_act=\"gelu\", hidden_dropout_prob=0.1, attention_probs_dropout_prob=0.1, max_position_embeddings=512, type_vocab_size=2, initializer_range=0.02, output_all_encoded_layers=False, require_all_hidden_states=True, batch_first=True, **kwargs): self.hidden_size = hidden_size self.num_hidden_layers = num_hidden_layers self.num_attention_heads = num_attention_heads self.hidden_act = hidden_act self.intermediate_size = intermediate_size self.hidden_dropout_prob = hidden_dropout_prob self.attention_probs_dropout_prob = attention_probs_dropout_prob self.max_position_embeddings = max_position_embeddings self.type_vocab_size = type_vocab_size self.initializer_range = initializer_range self.output_all_encoded_layers = output_all_encoded_layers self.require_all_hidden_states = require_all_hidden_states self.batch_first=batch_first if isinstance(vocab_size_or_config_json_file, str) or (sys.version_info[0] == 2 and isinstance(vocab_size_or_config_json_file, unicode)): with open(vocab_size_or_config_json_file, \"r\", encoding='utf-8') as reader: json_config = json.loads(reader.read()) for key, value in json_config.items(): self.__dict__[key] = value elif isinstance(vocab_size_or_config_json_file, int): self.vocab_size = vocab_size_or_config_json_file else: raise ValueError(\"First argument must be either a vocabulary size (int)\" \"or the path to a pretrained model config file (str)\") super(LtgBertConfig, self).__init__(**kwargs) 必须满足： 继承自 PretrainedConfig __init__函数接受 kwargs，并且使用 super()).__init__传递这些参数 model_type的作用是把模型注册到 AutoClass中，建议设置。 Model 参考：Building custom models (huggingface.co) 示例： class LtgBertForMaskedLM(PreTrainedModel): config_class=LtgBertConfig def __init__(self,config,activation_checkpointing=False): super().__init__(config) # 这里可以把成员变成类的继承LtgBertForMaskedLM(Bert): self.model=Bert( config=config, activation_checkpointing=activation_checkpointing ) self.require_all_hidden_states=config.require_all_hidden_states self.batch_first=config.batch_first def forward(self, input_ids, attention_mask, masked_lm_labels=None): if self.batch_first: # 模型把batch放在第二个维度 input_ids=input_ids.transpose(0,1) if masked_lm_labels is not None: masked_lm_labels=masked_lm_labels.transpose(0,1) subword_prediction=self.model(input_ids, attention_mask, masked_lm_labels=masked_lm_labels) loss=None if masked_lm_labels is not None: target_ids = masked_lm_labels.flatten() target_ids = target_ids[target_ids != -100] loss = F.cross_entropy(subword_prediction, target_ids) all_hidden_states=None if self.require_all_hidden_states: all_hidden_states=self.model.get_contextualized(input_ids=input_ids,attention_mask=attention_mask) if self.batch_first: if len(subword_prediction.size())>2: subword_prediction=subword_prediction.transpose(0,1) if all_hidden_states is not None: all_hidden_states=[it.transpose(0,1) for it in all_hidden_states] return MaskedLMOutput( loss=loss, logits=subword_prediction, hidden_states=all_hidden_states, attentions=None ) 对于自定义模型，往往每个 AutoClass上都会注册一个模型，因此往往要写多个自定义模型。 config_type的作用是把模型注册到 AutoClass中，建议设置。 由于简约性原则，官方要求 self.model对应原来的模型，比如用Pytorch定义的模型。 forward函数需要注意结果格式，transformers.modeling_outputs里定义了每种模型forward的结果格式。 其中对于每个特定的子任务都有个类似的模型，对于部分函数比如forward建议参考已有的代码进行操作，因为hf框架在使用特定子任务的模型的时候，可能会添加特殊的参数。比如，对于序列分类任务SequenceClassification，其中相关模型的forward为： def forward( self, input_ids: Optional[torch.Tensor] = None, attention_mask: Optional[torch.Tensor] = None, output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool] = None, inputs_embeds: Optional[torch.Tensor] = None, return_dict: Optional[bool] = None, labels: Optional[torch.LongTensor] = None, ) -> Union[Tuple[torch.Tensor], SequenceClassifierOutput]: if self.batch_first: # 模型把batch放在第二个维度 input_ids=input_ids.transpose(0,1) contextualized_embeddings=self.model.get_contextualized(input_ids, attention_mask) if self.batch_first: contextualized_embeddings=contextualized_embeddings.transpose(0,1) logits = self.head(contextualized_embeddings[:, 0, :]) if labels is not None: if self.config.problem_type is None: if self.num_labels == 1: self.config.problem_type = \"regression\" elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int): self.config.problem_type = \"single_label_classification\" else: self.config.problem_type = \"multi_label_classification\" if self.config.problem_type == \"regression\": loss_fct = nn.MSELoss() if self.num_labels == 1: loss = loss_fct(logits.squeeze(), labels.squeeze()) else: loss = loss_fct(logits, labels) elif self.config.problem_type == \"single_label_classification\": loss_fct = nn.CrossEntropyLoss() loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1)) elif self.config.problem_type == \"multi_label_classification\": loss_fct = nn.BCEWithLogitsLoss() loss = loss_fct(logits, labels) assert output_attentions is None assert output_hidden_states is None return SequenceClassifierOutput( loss=loss, logits=logits, hidden_states=contextualized_embeddings if output_hidden_states else None, attentions=None ) 这里hf框架会在配置中添加problem_type等内容。 注册 如果在ckpt文件夹的 config.json里没有 auto_map指明 AutoClass的注册： \"auto_map\": { \"AutoConfig\": \"configuration_ltgbert.LtgBertConfig\", \"AutoModelForMaskedLM\": \"modeling_ltgbert.LtgBertForMaskedLM\" } 那么需要手动添加，在读取ckpt的代码里添加： AutoConfig.register(\"LtgBert\", LtgBertConfig) AutoModelForMaskedLM.register(LtgBertConfig, LtgBertForMaskedLM) 如果希望在保存模型的时候 config.json文件中自动包含 auto_map，可以添加以下代码（如果模型是从ckpt里加载的就不需要添加）： LtgBertConfig.register_for_auto_class() LtgBertForMaskedLM.register_for_auto_class(\"AutoModelForMaskedLM\") 后来发现只有注册可能会存在 config.json里 auto_map不完整的情况（原因暂时没有调查），可以考虑直接在 config.__init__里强制指定： def __init__(self,....): ... self.auto_map={ \"AutoConfig\": \"configuration_ltgbert.LtgBertConfig\", \"AutoModelForMaskedLM\": \"modeling_ltgbert.LtgBertForMaskedLM\" } Trainer 训练流程的转换主要设计HF的 Trainer类，可以参考Trainer (huggingface.co)和Trainer (huggingface.co)。 Trainer把训练的流程分为几个过程，通过继承以及重写相关函数即可完成流程的定制，通过参数即可实现超参数的设置，细节阅读参考资料。 Dataset dataset可以继承自 torch.utils.data.dataset，但是需要注意 __getitem__，默认情况该函数返回的需要满足 dict格式，从而实现参数的设置。 参考资料 Building custom models (huggingface.co) Trainer (huggingface.co) Trainer (huggingface.co)","categories":[{"name":"模板","slug":"模板","permalink":"https://bg51717.github.io/categories/%E6%A8%A1%E6%9D%BF/"}],"tags":[{"name":"模板","slug":"模板","permalink":"https://bg51717.github.io/tags/%E6%A8%A1%E6%9D%BF/"},{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"PyTorch","slug":"PyTorch","permalink":"https://bg51717.github.io/tags/PyTorch/"},{"name":"HuggingFace","slug":"HuggingFace","permalink":"https://bg51717.github.io/tags/HuggingFace/"},{"name":"Trainer","slug":"Trainer","permalink":"https://bg51717.github.io/tags/Trainer/"},{"name":"config","slug":"config","permalink":"https://bg51717.github.io/tags/config/"},{"name":"model","slug":"model","permalink":"https://bg51717.github.io/tags/model/"},{"name":"dataset","slug":"dataset","permalink":"https://bg51717.github.io/tags/dataset/"}]},{"title":"随机数种子","slug":"深度学习/工程细节/随机数种子","date":"2024-07-09T10:02:24.000Z","updated":"2024-09-29T06:07:20.929Z","comments":true,"path":"/7369/","link":"","permalink":"https://bg51717.github.io/7369/","excerpt":"","text":"介绍 在深度学习的实际项目中，为了减少随机性，增强项目的复现能力，设置固定随机数种子十分重要，因此这篇文章罗列了一些设置随机种子的方法和减少项目随机性的经验。 通用函数 def set_random_seed(seed): \"\"\"Set random seeds.\"\"\" os.environ['PYTHONHASHSEED'] = str(seed) random.seed(seed) # 设置 Python 内置随机库的种子 np.random.seed(seed) # 设置 NumPy 随机库的种子 torch.manual_seed(seed) # 设置 PyTorch 随机库的种子 torch.cuda.manual_seed(seed) # 为当前 CUDA 设备设置种子 torch.cuda.manual_seed_all(seed) # 为所有 CUDA 设备设置种子 Scikit-learn 在 Scikit-learn中，部分算法需要设置 random_state，比如聚类算法 kmeans。 KMeans(n_clusters=2,random_state=42) 工程经验 由于部分原因，一些python数组或者python集合等，可能顺序也会影响结果的随机性。如果在无法确保顺序是固定的或者顺序是有要求的情况下，尝试对这些中间结果进行排序减少随机性。 参考资料 【Python】深度学习中随机数种子seed的种类和设置方式_seed设置-CSDN博客","categories":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"工程细节","slug":"深度学习/工程细节","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E5%B7%A5%E7%A8%8B%E7%BB%86%E8%8A%82/"}],"tags":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"随机数","slug":"随机数","permalink":"https://bg51717.github.io/tags/%E9%9A%8F%E6%9C%BA%E6%95%B0/"}]},{"title":"vscode调试python","slug":"杂项/vscode调试python","date":"2024-04-19T14:47:51.000Z","updated":"2024-09-24T11:40:26.457Z","comments":true,"path":"/30403/","link":"","permalink":"https://bg51717.github.io/30403/","excerpt":"","text":"介绍 在学习项目的过程中，很多时候需要通过调试来高效率的了解代码的执行过程，因此这里介绍下怎么使用vscode对python程序进行调试。 方法一：简单图标点击 vscode对一些简单的程序提供了一些可视化的调试方式，对于一些不需要指定参数等简单的调试功能，可以直接点击vscode左上角的几个图标进行debug过程。由于过于简单，此处不做介绍。 1713538455137 方法二：编辑launch.json文件 在工作目录下的 ./vscode/launch.json文件里面，指定了各种debug和程序运行的参数、环境、解释器、目录等基本所有的环境配置。 可以在左下角的添加配置里面快速添加常见的选项。 比如下面所示： { // 使用 IntelliSense 了解相关属性。 // 悬停以查看现有属性的描述。 // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387 \"version\": \"0.2.0\", \"configurations\": [ { \"name\": \"(gdb) 启动\", \"type\": \"cppdbg\", \"request\": \"launch\", \"program\": \"${fileDirname}/${fileBasenameNoExtension}\", \"args\": [], \"stopAtEntry\": false, \"cwd\": \"${fileDirname}\", \"environment\": [], \"externalConsole\": false, \"MIMode\": \"gdb\", \"setupCommands\": [ { \"description\": \"为 gdb 启用整齐打印\", \"text\": \"-enable-pretty-printing\", \"ignoreFailures\": true }, { \"description\": \"将反汇编风格设置为 Intel\", \"text\": \"-gdb-set disassembly-flavor intel\", \"ignoreFailures\": true } ] }, { \"name\": \"py-dbg QLLM\", \"type\": \"debugpy\", \"request\": \"launch\", \"python\": \"/home/bg51717/.conda/envs/QLLM/bin/python\", // \"program\": \"/home/bg51717/project/QLLM/qllm/__main__.py\", \"module\": \"qllm\", \"console\": \"integratedTerminal\", \"args\":[ \"--model=/home/bg51717/project/models/facebook/opt-350m\", \"--method=gptq\", \"--nsamples=64\", \"--wbits=4\", \"--groupsize=128\", \"--save\", \"/home/bg51717/project/QLLM/facebook/opt-350m_gptq4b\", \"--export_onnx\", \"/home/bg51717/project/QLLM/onnx_model/facebook/opt-350m_gptq4b\" ], \"env\": {\"PYTHONPATH\": \"/home/bg51717/project/QLLM/qllm\"}, \"cwd\": \"/home/bg51717/project/QLLM\" } ] } 这里参数非常多（建议使用的时候查询 gpt、搜索引擎、文档等。 这里介绍几个常用的选项。此外，在编辑的时候可以类似 Linux那样使用 ${fileDirname}来引用 vscode程序的当前变量比如工作目录 参数 含义 类型 name 过程名字 str type 过程类型 str python 解释器（使用虚拟环境的时候需要注意指定 str program 程序文件，按照脚本方式运行过程 str module 模块名，按照模块方式运行过程 str args 运行过程的参数 list env 环境变量 dict cwd 工作目录 str 此外，在使用的过程中python里面绝对引入、相对引入等。建议参考python相对导入常见问题和解决方案 - 知乎 (zhihu.com) 。 此处发现那里也有些没有提及的东西。 解决方案错误一：ImportError: attempted relative import with no known parent package 里可以不修改代码，使用 python -m命令+调整工作目录成功运行。（笔者当时遇到一个坑，当时没有注意的调试的是工程目录里的qllm文件还是env里装的py包 方法三：使用debug.py文件引入要调试的文件 如题，建立一个 debug.py文件引入要调试的文件，类似于使用代理进行调试过程。 参考【Python 入门】新手必会 vscode Debug 调试技巧_哔哩哔哩_bilibili 参考资料 python相对导入常见问题和解决方案 - 知乎 (zhihu.com) 【Python 入门】新手必会 vscode Debug 调试技巧_哔哩哔哩_bilibili","categories":[{"name":"杂项","slug":"杂项","permalink":"https://bg51717.github.io/categories/%E6%9D%82%E9%A1%B9/"}],"tags":[{"name":"vscode","slug":"vscode","permalink":"https://bg51717.github.io/tags/vscode/"},{"name":"python","slug":"python","permalink":"https://bg51717.github.io/tags/python/"},{"name":"调试","slug":"调试","permalink":"https://bg51717.github.io/tags/%E8%B0%83%E8%AF%95/"},{"name":"debug","slug":"debug","permalink":"https://bg51717.github.io/tags/debug/"}]},{"title":"nlp常用排行榜","slug":"深度学习/自然语言处理/nlp常用排行榜","date":"2024-04-05T06:56:57.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/63314/","link":"","permalink":"https://bg51717.github.io/63314/","excerpt":"","text":"介绍 在工作和学习的时候发现，很多时候挑选合适的模型和数据集等也是一个重要且麻烦的过程。发现有很多相关的评测的排行榜，根据这些实时更新的排行榜，可以辅助我们进行选择模型等前期工作。 Spaces - Hugging Face 这里罗列了许多关于ai的最新新闻，也能搜索到各种排行榜leaderboard。 nlp任务 MTEB Leaderboard - a Hugging Face Space by mteb Massive Text Embedding Benchmark (MTEB) ，是关于文本嵌入的排行榜，同时关注排行榜的like人数（从某种意义上反应排行榜的效用）。 大模型评测 Open LLM Leaderboard - a Hugging Face Space by HuggingFaceH4 这里提供了各种关于大模型在多维度的数据集上的表现能力，并且支持根据大模型的类型、精度等过滤大模型排行榜。 Big Code Models Leaderboard - a Hugging Face Space by bigcode 这里提供了关于大模型code能力的排行榜。 LMSys Chatbot Arena Leaderboard - a Hugging Face Space by lmsys 这里提供了关于大模型对话能力的排行榜（但是由于不知名原因暂时无法打开）。 Chat with Open Large Language Models (lmsys.org) 这里是关于大模型对话能力的测评网站，也提供了参考用的排行榜。 LLM-Perf Leaderboard - a Hugging Face Space by optimum 这里提供了大模型在给定硬件条件的训练资源后微调的性能排行榜。 Open CoT Leaderboard - a Hugging Face Space by logikon 这里提供了关于大模型CoT（Chain of Thought）的排行榜。 数据集 参考资料","categories":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"自然语言处理","slug":"自然语言处理","permalink":"https://bg51717.github.io/categories/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"}],"tags":[]},{"title":"pytroch_tutorials杂项","slug":"杂项/huggingface/transformers_tutorials杂项","date":"2024-03-23T08:23:43.000Z","updated":"2024-09-24T11:40:26.457Z","comments":true,"path":"/20669/","link":"","permalink":"https://bg51717.github.io/20669/","excerpt":"","text":"介绍 当作快速过这个资料的笔记，一些关于别的库的介绍是不完全的，考虑在使用的时候从别的信息渠道就行信息的搜集。也可以作为后面待更博客列举？ 常用方式 可以参考huggingface transformers教程总结 - 知乎 (zhihu.com) （这篇教程很多是基于tf的，使用时候可以考虑换成pt）和 Hugging Face - Documentation 。 tutorials具体（中文版本） 使用AutoClass加载预训练实例 (huggingface.co) 这里有个注意的点是使用 AutoModelForSequenceClassification可能会在模型后面添加一层来适应下游任务（别的类似的类可能也会有类似的做法），如果想不添加任何层直接使用，考虑使用AutoModel类来加载模型。 预处理 (huggingface.co) 这里介绍了怎么预处理各种数据比如文本，多模态，图片等。 微调预训练模型 (huggingface.co) 这里介绍了怎么使用 transformers.Trainer类和pytorch原生代码来微调模型（pytorch lighting也提供了一个Trainer）。 也介绍了怎么使用huggingface的github上分享的脚本来微调模型huggingface/transformers: 🤗 Transformers: State-of-the-art Machine Learning for Pytorch, TensorFlow, and JAX. (github.com)， accelerate提供了accelerate config命令通过命令行交互帮助配置文件。 🤗 加速分布式训练 (huggingface.co) 这里介绍了怎么使用accelerate来进行分布式训练，流程非常简单，基本就是pytorch框架单卡训练的代码改个四五行。 使用 🤗 PEFT 加载adapters (huggingface.co) 这里大致介绍了怎么使用 perf库进行高效的参数微调，具体表现为通过 adapters实现少参数调整，还大致介绍了怎么量化加载、启用、禁止、训练等。 Transformers Agents (huggingface.co) 这里介绍了transformers新版本提供的一个api（测试版可能随时变化），通过自然语言来辅助进行功能实现，类似于通过自然语言编程。 使用LLMs进行生成 (huggingface.co) 这里大致介绍了怎么使用 model.generate()进行更好且多样化生成。 使用 🤗 Tokenizers 中的分词器 (huggingface.co) 大概介绍了怎么训练、保存和加载分词器tokenizer。 用于推理的多语言模型 (huggingface.co) 介绍了一些常用的多语言翻译模型。 创建自定义架构 (huggingface.co) 如题，使用一些配置文件自定义模型架构和各种处理器比如自然语言处理的分词器、语音识别的特征提取器等。 共享自定义模型 (huggingface.co) 这里介绍了怎么自定义模型，推送到hub上面以及怎么在AutoClass（比如AutoModel等）上面注册。 聊天模型的模板 (huggingface.co) 这里介绍了聊天的模板，怎么把多轮对话转变成一个字符串输入模型。并且支持用户自定义模板和使用内置模板等功能。自定义模板的办法使用的是Jinja。 导出为 ONNX (huggingface.co) 这里介绍了怎么通过Optimum库把模型导出为ONNX格式，ONNX模式下为公开具有标准化运算符和数据类型的图，可以进行各种优化和框架间的相互转移。 （这里还介绍了transformers.onnx，但这个库已经停止了维护并且回头会从教程里删去 导出为 TFLite (huggingface.co) TensorFlow Lite 是一个轻量级框架，用于资源受限的设备上，如手机、嵌入式系统和物联网（IoT）设备，部署机器学习模型，其文件扩展名为 .tflite，同样可以通过Optimum库导出。 导出为 TorchScript (huggingface.co) 这里关于torchscirpt的介绍可以参考pytorch的，这里还介绍了使用 Neuron SDK 将 Hugging Face TorchScript 模型部署到 AWS。 性能与可扩展性 (huggingface.co) 这是关于训练和推理的综述，里面有许多指向英语文档的链接。 完全分片数据并行 (huggingface.co) 介绍了怎么使用accelerate把模型参数切片在多个GPU运行以及部分优化。 训练用的定制硬件 (huggingface.co) 这里引入了怎么更好的使用和了解硬件，但只是引入，还是需要后期继续深入学习。 使用Trainer API进行超参数搜索 (huggingface.co) 如题，支持多种超参数搜索框架。 实例化大型模型 (huggingface.co) 这里介绍了怎么加载大模型，降低内存，具体表现为分片，把权重文件分成多个。 调试 (huggingface.co) 这里介绍了怎么使用脚本进行多GPU网络问题调试和上溢下溢检测（通过hook函数统计每个模块的输入和输出的绝对值的极值）。 使用 torch.compile() 优化推理 (huggingface.co) torch.compile() 优化推理过程，并且列出了许多实验结果。 如何创建自定义流水线？ (huggingface.co) 这里介绍了怎么自定义流水线pipeline并且注册和推送到云端。 分词器的摘要 (huggingface.co) 这里介绍了许多分词算法，如何构造tokenizer。 Agents和工具 (huggingface.co) 这里介绍了各种各样的agent和tools，agents相较于模型可以使用tools。 Callbacks (huggingface.co) Callbacks可以用来自定义PyTorch [Trainer]中训练循环行为的对象（此功能尚未在TensorFlow中实现），该对象可以检查训练循环状态（用于进度报告、在TensorBoard或其他ML平台上记录日志等），并做出决策（例如提前停止）。 这里介绍了一些常用的callbacks，怎么自定义callbacks，TrainerState代表当前训练状态，TrainerControl控制训练循环。 Configuration (huggingface.co) 介绍了Pretrainedconfig类。 Data Collator (huggingface.co) 这里介绍了各种Data collators来处理数据。 Logging (huggingface.co) 这里介绍了transformers的日志系统。 模型 (huggingface.co) 这里介绍了怎么使用PretrainedModel，由于一定原因，官方似乎推荐PretrainedModel是用于对model的一层包装，forward等函数在model里面实现。 还介绍了ModuleUtilsMixin，这个是py通过多继承扩展模型功能的一个类，可以参考一个例子走近 Python 的 Mixin 类：利用 Python 多继承的魔力_mixin类-CSDN博客学习Mixin类和调用顺序。 Generation (huggingface.co) 这里介绍了GenerationConfig和GenerationMixin来使得模型进行多样化的生成过程，扩展了模型的功能。 导出 🤗 Transformers 模型到 ONNX (huggingface.co) 这里介绍了一些配置类来帮助transformers模型导出到ONNX。 Optimization (huggingface.co) 这里只是列举了几个模型参数跟新过程会用到的优化器等，但不是很全，也不是很深入，连示例过程都没有。 模型输出 (huggingface.co) Transformers库所有模型的输出都是 ModelOutput 的子类的实例，这里介绍了许多输出类和基本的类。 Pipelines (huggingface.co) 这里介绍了许多Pipeline和自定义Pipeline。 Processors (huggingface.co) 这个库大概介绍了Processor类，用于编码或者解码多模型输入并且组合。 量化 🤗 Transformers 模型 (huggingface.co) 这个大致介绍了常见的量化方法并给了简答的示例。 Tokenizer (huggingface.co) 大致介绍了Tokenizer和常用的办法。 Trainer (huggingface.co) 这里介绍了Transformers的Trainer，同时说明了这个Trainer用于别的库的模型时要注意的问题，同时还介绍了一些常用的问题和通过accelerate使用Trainer。 DeepSpeed集成 (huggingface.co) 这里介绍了DeepSpeed的很多常用的配置选项（非常复杂，挖坑todo Feature Extractor (huggingface.co) 这里介绍了Feature负责为音频或视觉模型准备输入特征。这包括从序列中提取特征。 Image Processor (huggingface.co) 这里介绍了对于图像处理的Processor。 这里往后就是介绍一些功能类，可以用于扩展、调试控制等功能 自定义层和工具 (huggingface.co) 这里介绍了一些Transformers库的为模型提供的自定义层和帮助函数（底层还是调用的pytorch或者TensorFlow，但是组合了一些常用的层。 pipelines的工具 (huggingface.co) 这里介绍了一些为Pipeline使用的功能类。 Tokenizers的工具 (huggingface.co) Trainer的工具 (huggingface.co) 用于生成的工具 (huggingface.co) Image Processors的工具 (huggingface.co) FeatureExtractors 的工具 (huggingface.co) 通用工具 (huggingface.co) 时间序列工具 (huggingface.co)","categories":[{"name":"杂项","slug":"杂项","permalink":"https://bg51717.github.io/categories/%E6%9D%82%E9%A1%B9/"},{"name":"huggingface","slug":"huggingface","permalink":"https://bg51717.github.io/categories/huggingface/"}],"tags":[{"name":"transformers_tutorials","slug":"transformers-tutorials","permalink":"https://bg51717.github.io/tags/transformers-tutorials/"}]},{"title":"pytorch_model","slug":"模板/pytorch-model","date":"2024-02-24T09:54:19.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/42347/","link":"","permalink":"https://bg51717.github.io/42347/","excerpt":"","text":"介绍 作为深度学习的基本模板使用，方便使用的时候作为骨架 许多文件可以考虑添加argparse和sh来引入外部配置来抽象过程，增强代码重用性 dataset.py 这个文件提供了各种数据集的定义，自定义数据集需要实习三个主要函数 class MyDataset(torch.utils.data.Dataset): def __init__(self): super().__init__() #todo def __getitem__(self,idx): #todo def __len__(self): #todo models.py 这个文件负责提供各种模型的定义，可以是完全自定义的模型或者预训练模型 class MyModel(torch.nn.Module): def __init__(self) super().__init__() #todo def forward(self,input): #todo def get_model(config): #todo return model criterion.py 这个文件负责提供各种损失函数的定义，可以是完全自定义的损失函数或者框架提供的损失函数 class CustomLoss(nn.Module): def __init__(self): super(CustomLoss, self).__init__() # 在这里初始化你的参数，如果有的话 def forward(self, input, target): # 计算损失的逻辑 # 例如，这里我们使用简单的均方误差作为示例 loss = torch.mean((input - target) ** 2) return loss def get_criterion() #todo optimizer.py 这个文件负责提供各种优化器的定义，可以是完全自定义的优化器或者框架提供的优化器 class CustomOptimizer(torch.optim.Optimizer): def __init__(self, params, lr=0.01, momentum=0.5, weight_decay=0, learning_rate_decay=0.9): defaults = dict(lr=lr, momentum=momentum, weight_decay=weight_decay, learning_rate_decay=learning_rate_decay) super(CustomOptimizer, self).__init__(params, defaults) def step(self, closure=None): \"\"\"Performs a single optimization step.\"\"\" loss = None if closure is not None: loss = closure() for group in self.param_groups: for p in group['params']: if p.grad is None: continue d_p = p.grad.data if group['momentum'] > 0: param_state = self.state[p] if 'momentum_buffer' not in param_state: buf = param_state['momentum_buffer'] = torch.clone(d_p).detach() buf.mul_(group['momentum']) else: buf = param_state['momentum_buffer'] buf.mul_(group['momentum']).add_(d_p, alpha=1 - group['momentum']) d_p = buf if group['weight_decay'] != 0: d_p.add_(p.data, alpha=group['weight_decay']) p.data.add_(d_p, alpha=-lr) return loss def get_Optimizer(): #todo lr_scheduler.py 这个文件负责提供各种学习率调度器的定义，可以是完全自定义的学习率调度器或者框架提供的学习率调度器 class MyLRScheduler(torch.optim.lr_scheduler._LRScheduler): def __init__(self, optimizer, step_size=10, gamma=0.1): self.step_size = step_size self.gamma = gamma super(CustomLRScheduler, self).__init__(optimizer) def get_lr(self): \"\"\"Calculate the learning rate at a given step.\"\"\" return [base_lr * self.gamma ** (self.last_step // self.step_size) for base_lr in self.base_lrs] def step(self, epoch=None): \"\"\"Update the learning rate at the end of the given epoch.\"\"\" if epoch is None: self.last_step += 1 else: self.last_step = epoch + 1 self._last_lr = self.get_lr() for param_group, lr in zip(self.optimizer.param_groups, self._last_lr): param_group['lr'] = lr def get_lr_scheduler() #todo train.py 这个文件负责提供各种训练方法和过程 def train_model(model,criterion,optimizer,scheduler,num_epochs): since=time.time() best_model_wts=copy.deepcopy(model.state_dict()) best_acc=0.0 #每个epoch for epoch in range(num_epochs): print('Epoch {}/{}'.format(epoch,num_epochs-1)) print('-'*10) # 分为训练或者测试阶段 for phase in ['train','val']: if phase=='train': model.train() else: model.eval() running_loss=0.0 running_corrects=0 # 每个批次进行计算损失和反向梯度 for inputs,labels in dataloaders[phase]: inputs=inputs.to(device) labels=labels.to(device) optimizer.zero_grad() with torch.set_grad_enabled(phase=='train'): outputs=model(inputs) _,preds=torch.max(outputs,1) loss=criterion(outputs,labels) if phase=='train': loss.backward() optimizer.step() running_loss+=loss.item()*inputs.size(0) running_corrects+=torch.sum(preds==labels.data) epoch_loss=running_loss/dataset_sizes[phase] epoch_acc=running_corrects/dataset_sizes[phase] print('{} Loss :{:.4f} Acc:{:.4f}'.format(phase,epoch_loss,epoch_acc)) if phase=='val' and epoch_acc>best_acc: best_acc=epoch_acc best_model_wts=copy.deepcopy(model.state_dict()) scheduler.step() print() time_elapsed=time.time()-since print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed//60,time_elapsed%60)) model.load_state_dict(best_model_wts) return model main.py 主要负责对于各个文件部分的引用，整合代码，基本逻辑为 #数据集 dataset #数据迭代器 dataloader #模型 model #损失函数 criterion #优化器 optimizer #学习率优化器 lr_scheduler #训练 train #保存 save #预测 predict 可选优化 梯度裁剪 torch.nn.utils.clip_grad_norm_ 加载最优参数 ... 其他 可以去pytorch官网找找一些关于模型的优化。 参考资料","categories":[{"name":"模板","slug":"模板","permalink":"https://bg51717.github.io/categories/%E6%A8%A1%E6%9D%BF/"}],"tags":[{"name":"模板","slug":"模板","permalink":"https://bg51717.github.io/tags/%E6%A8%A1%E6%9D%BF/"},{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"}]},{"title":"信息熵","slug":"深度学习/前置数学/信息熵","date":"2024-01-31T11:19:50.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/5656/","link":"","permalink":"https://bg51717.github.io/5656/","excerpt":"","text":"信息熵的公式 计算信息熵的公式为: \\[ H(x)=-\\sum p(x_i)logp(x_i) \\] 其中\\(p(x_i)\\)表示事件结果为\\(x_i\\)的概率 理解 信息熵表示对事件不确定性的一个度量，计算思路为“编码一个事件的最短平均编码长度”（任意进制编码都行，彼此差一个常数，但常用的是二进制以及自然对数） 所以信息熵的计算也可以写作： \\[ H(x)=\\sum p(x_i)f(x_i) \\] 其中\\(p(x_i)\\)表示事件结果为\\(x_i\\)的概率，\\(f(x_i)\\)为编码\\(x_i\\)需要的位数（这也是为什么在比较概率分布的时候，会选择用拟合的概率来计算\\(f(x_i)\\)） Huffman编码树 类比哈夫曼树，根据贪心思想， 出现概率大的结果应该占据相对短的编码 编码结果的种类和编码位数是指数级关系 所以我们得到 \\[ f(x_i)=-logp(x_i) \\] 代入就得到了最终形式。 应用 KL散度 交叉熵损失 参考资料","categories":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"前置数学","slug":"深度学习/前置数学","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E5%89%8D%E7%BD%AE%E6%95%B0%E5%AD%A6/"}],"tags":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"信息学","slug":"信息学","permalink":"https://bg51717.github.io/tags/%E4%BF%A1%E6%81%AF%E5%AD%A6/"},{"name":"数学","slug":"数学","permalink":"https://bg51717.github.io/tags/%E6%95%B0%E5%AD%A6/"}]},{"title":"pytroch_tutorials杂项","slug":"杂项/pytroch_tutorials杂项","date":"2023-12-29T08:23:43.000Z","updated":"2024-09-24T11:40:26.457Z","comments":true,"path":"/20668/","link":"","permalink":"https://bg51717.github.io/20668/","excerpt":"","text":"介绍 当作快速过这个资料的笔记，一些关于别的库的介绍是不完全的，考虑在使用的时候从别的信息渠道就行信息的搜集。也可以作为后面待更博客列举？ 具体 torchscript Introduction to TorchScript — PyTorch Tutorials 2.2.1+cu121 documentation Loading a TorchScript Model in C++ — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了把pytorch模型转换成torchscript的两种方法torch.jit.trace和torch.jit.script，前者会失去控制流信息，后者会保留控制流信息（具体查阅文档）。 转化为torchscript有以下好处： 不需要Python解释器也可以运行，可以被pytorch自带的特殊解释器直接使用 转为torchscript可以进行各种优化，提高运行效率 方便被其他语言调用 ONNX (optional) Exporting a Model from PyTorch to ONNX and Running it using ONNX Runtime — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了在高效且跨平台ONNX运行环境部署的基本教程，通过torch.onnx把模型转化为onnx格式并保存，然后读取本地保存onnx格式模型并运行。 剖析pytorch model Profiling your PyTorch Module — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了torch.autograd.profiler,在代码里添加with profiler.record_function(\"MASK INDICES\"):可以记录代码运行的指标，比如时间，cpu和内存使用率等，名字可以自定义，支持可视化结果。 Introduction to Holistic Trace Analysis — PyTorch Tutorials 2.2.1+cu121 documentation Trace Diff using Holistic Trace Analysis — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了HolisticTraceAnalysis（HTA），一个用来剖析GPU运行情况的库。 把GPU运行时间分为了等待时间、计算时间和非计算时间，方便开发者评测模型运行的情况。还支持查看GPU内部的运行情况，也支持和之前的记录进行对比，也能可视化结果。 troch.fx 操作计算图 （测试版）在 FX 中构建卷积/批量范数热熔器 — PyTorch 教程 2.2.1+cu121 文档 torch.fx 是 PyTorch 提供的一个模块，它允许用户通过操作计算图来转换和优化 PyTorch 模型。这个模块提供了一种方式来表示和操作 PyTorch 模型的抽象，使得开发者可以更容易地对模型进行修改，例如重构模型结构、插入调试代码、优化性能等。 教程里介绍了一种融合相邻层的操作（只能用于eval模式）。比如融合卷积和归一化，融合之前，模型会把卷积结果写回显存，然后在调用归一化并且从显存读取之前结果；融合后变成一种操作，卷积结果不会写回显存，而是直接进行归一化后写会显存。 def _parent_name(target : str) -> Tuple[str, str]: \"\"\" Splits a ``qualname`` into parent path and last atom. For example, `foo.bar.baz` -> (`foo.bar`, `baz`) \"\"\" *parent, name = target.rsplit('.', 1) return parent[0] if parent else '', name def replace_node_module(node: fx.Node, modules: Dict[str, Any], new_module: torch.nn.Module): assert(isinstance(node.target, str)) parent_name, name = _parent_name(node.target) setattr(modules[parent_name], name, new_module) def fuse(model: torch.nn.Module) -> torch.nn.Module: model = copy.deepcopy(model) # The first step of most FX passes is to symbolically trace our model to # obtain a `GraphModule`. This is a representation of our original model # that is functionally identical to our original model, except that we now # also have a graph representation of our forward pass. #获取计算图 fx_model: fx.GraphModule = fx.symbolic_trace(model) modules = dict(fx_model.named_modules()) # The primary representation for working with FX are the `Graph` and the # `Node`. Each `GraphModule` has a `Graph` associated with it - this # `Graph` is also what generates `GraphModule.code`. # The `Graph` itself is represented as a list of `Node` objects. Thus, to # iterate through all of the operations in our graph, we iterate over each # `Node` in our `Graph`. #枚举所有计算图节点 for node in fx_model.graph.nodes: # The FX IR contains several types of nodes, which generally represent # call sites to modules, functions, or methods. The type of node is # determined by `Node.op`. #计算图节点还有别的属性,具体可以查阅相关资料 if node.op != 'call_module': # If our current node isn't calling a Module then we can ignore it. continue # For call sites, `Node.target` represents the module/function/method # that's being called. Here, we check `Node.target` to see if it's a # batch norm module, and then check `Node.args[0].target` to see if the # input `Node` is a convolution. #modules指的是模块,node.target指的是节点名字,node.args应该指的是输入这个节点的前置节点 if type(modules[node.target]) is nn.BatchNorm2d and type(modules[node.args[0].target]) is nn.Conv2d: if len(node.args[0].users) > 1: # Output of conv is used by other nodes continue conv = modules[node.args[0].target] bn = modules[node.target] fused_conv = fuse_conv_bn_eval(conv, bn) replace_node_module(node.args[0], modules, fused_conv) # As we've folded the batch nor into the conv, we need to replace all uses # of the batch norm with the conv. #把使用到node节点输出的地方变成node.args[0]节点输出 node.replace_all_uses_with(node.args[0]) # Now that all uses of the batch norm have been replaced, we can # safely remove the batch norm. fx_model.graph.erase_node(node) #检查计算图（Graph）的完整性和一致性,确定计算图的正确性 fx_model.graph.lint() # After we've modified our graph, we need to recompile our graph in order # to keep the generated code in sync. #recompile()方法的作用是将这些修改后的计算图转换回 Python 代码，这样你就可以创建一个新的 PyTorch 模型实例，它包含了你所做的所有修改 fx_model.recompile() return fx_model （测试版）使用 FX 构建简单的 CPU 性能分析器 — PyTorch 教程 2.2.1+cu121 文档 通过 print(traced_rn18.graph)我们可以查看计算图的信息，这里只选择一行查看，例子: %layer1_1_conv2 : [num_users=1] = call_module[target=layer1.1.conv2](args = (%layer1_1_relu,), kwargs = {}) %layer1_1_conv2:节点名字, [num_users=1]:被几个后续节点使用, call_module:表面这是一个调用模块, target=layer1.1.conv2:调用模块的名字, args = (%layer1_1_relu,):传递给模块的参数(输入模块的之前节点) kwargs = {}:额外关键词参数 可以参照教程写一个继承torch.fx.Interpreter的类,重写run和run_node实现对于计算图的捕获，在运行过程中添加自定义行为。 存储组织 (beta) Channels Last Memory Format in PyTorch — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了内存组织方式torch.channels_last，torch.contiguous_format等，同时介绍了一下torch.stride、torch.contiguous和torch.is_contiguous等函数。 有的操作符会保留内存组织格式。 可以通过model.to(memory_format=)把模型转化为适合的组织形式，同时输入也需要相应的转换（框架应该支持自动转换？）。 但由于不是所有的操作符都支持某种内存组织格式，可能需要进行检查，这里给了检查和设置的示例代码。 前向模式自动微分 正向模式自动微分 （Beta） — PyTorch 教程 2.2.1+cu121 文档 这里看的不是很明白。挖个坑（todo... 正向传播一次只能算出相对一个参数的梯度，如果有n个参数，需要计算n次，所以这里的tangent只有一个，而不是每个参数对应一个。 可以参考【自动微分原理】AD的正反向模式 - 知乎 (zhihu.com)。 （这么一看，正向自动微分被方向自动微分爆杀？目前应用少且pytorch也只是测试版本 微分矩阵计算 雅可比派、黑森派、hvp、vhp 等：编写函数转换 — PyTorch 教程 2.2.1+cu121 文档 这里提供了各种使用自动求导计算微分矩阵的方法。 模型组装 模型组装 — PyTorch 教程 2.2.1+cu121 文档 这里介绍了torch.func.stack_model_state、torch.vmap等函数用来组装一系列结构相同参数不同的模型的输出，类似于使用cat连接模型输出，但是增加了底层优化。 单样本梯度 Per-sample-gradients — PyTorch 教程 2.2.1+cu121 文档 在一些要求对每个样本单独计算梯度的特殊情况下，可以使用本篇介绍的方法优化速度。 这里介绍了torch.func.grad、torch.func.functional_call、torch.func.vmap来优化加速（注意不同库有不同的同名函数） 这里grad和vmap都是创建的可调用对象，与别的同名函数不同。 c++接口 Using the PyTorch C++ Frontend — PyTorch Tutorials 2.2.1+cu121 documentation 介绍了怎么使用c++调用 TorchScript 中的动态并行性 TorchScript 中的动态并行性 — PyTorch 教程 2.2.1+cu121 文档 这里介绍了torch.jit.fork和torch.jit.wait两个函数用来并行执行pytorch相关代码。同时也引入了相关的类torch.jit.Future。 c++接口中的自动求导 Autograd in C++ Frontend — PyTorch Tutorials 2.2.1+cu121 documentation 这里都是一些用c++扩展pytorch的内容，后面需要细致学习（挖坑todo 自定义函数求二阶导 Double Backward with Custom Functions — PyTorch Tutorials 2.2.1+cu121 documentation 这篇文章介绍了怎么使用继承自torch.autograd.Function的自定义函数（重新forward和backward），计算导数，并且用torch.autograd.gradcheck使用数值解验证求导以及使用torchviz 可视化图形。 同时，注意在运行过程中，保存求导所需要参数时候建议按照教程分保存输入、保存输出和保存中间结果考虑代码结构，避免bug。 forward函数返回结果似乎和backward参数对应，backward输入参数是每个forward函数返回结果的grad。 保存中间结果的时候需要把中间结果返回，这样可以让pytorch的自动微分系统追踪这些中间结果（个人理解为返回中间结果相当于注册了这些中间结果，在backward的时候设置grad模型就会追踪这些中间结果，理解可能有误，但是使用的时候参考教程应该问题不大）。 自定义函数实现卷积 Fusing Convolution and Batch Norm using Custom Function — PyTorch Tutorials 2.2.1+cu121 documentation 先介绍了自定义卷积函数的构造，这里的once_differentiable指的是正向传播的结果只会反向传播一次，作用为求二阶导的时候会报错，从而起到限制的作用。 然后介绍了自定义批量归一化层的构造，然后介绍了自定义函数混合卷积和批量归一化，从而实现了节省内存的作用。 自定义 C++ 和 CUDA 扩展 Custom C++ and CUDA Extensions — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了两个扩展c++组件的方法，“ahead of time ”和“just in time”。 ahead of time：构建setup.py文件用于构建c++扩展，然后在对应的cpp文件里面构建c++扩展代码。 just in time:通过torch.utils.cpp_extension.load直接加载cpp文件，会把编译的中间文件存在一个临时目录里。 这里还介绍了编写混合 C++/CUDA 扩展，由于还没有学过cuda，挖个坑todu... 使用自定义 C++ 运算符扩展 TorchScript Extending TorchScript with Custom C++ Operators — PyTorch Tutorials 2.2.1+cu121 documentation 如题，后面需要细致学习todo,,, 使用自定义 C++ 类扩展 TorchScript Extending TorchScript with Custom C++ Classes — PyTorch Tutorials 2.2.1+cu121 documentation 如题，后面需要细致学习todo,,, 在C++中注册一个分派操作符 Registering a Dispatched Operator in C++ — PyTorch Tutorials 2.2.1+cu121 documentation 由于一个操作在不同的设备上对应不同的底层代码，所以为了抽象化其操作，方便调用，需要在内核注册对应设备对应函数，然后在调用。 比如，第一个把 myadd_cpu注册到cpu上的 myadd函数，当在cpu上运行 myadd函数时候，会调用 myadd_cpu TORCH_LIBRARY_IMPL(myops, CPU, m) { m.impl(\"myadd\", myadd_cpu); } TORCH_LIBRARY_IMPL(myops, CUDA, m) { m.impl(\"myadd\", myadd_cuda); } 然后在使用的时候，通过torch的调度器自动根据设备在内核寻找合适函数调用。 Tensor myadd(const Tensor& self, const Tensor& other) { static auto op = torch::Dispatcher::singleton() .findSchemaOrThrow(\"myops::myadd\", \"\") .typed<decltype(myadd)>(); return op.call(self, other); } 这里还介绍了自动投影机制autocast，用于在运算之前把精度投影到合适的精度。 在 C++ 中扩展新后端的调度程序 Extending dispatcher for a new backend in C++ — PyTorch Tutorials 2.2.1+cu121 documentation 后端（backend）通常指的是支持PyTorch运行的底层系统或框架，这里介绍了如何添加自定义的框架。(大致是需要实现一些基本的运算，别的运算可以表示成这样运算的组合)。 Facilitating New Backend Integration by PrivateUse1 — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了使用privateuse1注册新后端的流程。 结合tensorboard的profiler PyTorch Profiler With TensorBoard — PyTorch Tutorials 2.2.1+cu121 documentation 这篇文章介绍了profiler结合tensorboard的使用。 使用Ray Tune进行超参数调优 Hyperparameter tuning with Ray Tune — PyTorch Tutorials 2.2.1+cu121 documentation 这篇文章介绍了怎么使用Ray Tune库进行超参数的搜索。 优化Vision Transformer模型 Optimizing Vision Transformer Model for Deployment — PyTorch Tutorials 2.2.1+cu121 documentation 这篇文章介绍了怎么去优化Vision Transformer模型，列举了一些常见的优化方式。 参数化教程 Parametrizations Tutorial — PyTorch Tutorials 2.2.1+cu121 documentation 这里的参数化指的是类似于对模型部分权重使用的一种限制，应该是在参数修改后调用（比如初始化，参数更新等）的一些nn.module，从而使得模型更加灵活，实现对不同参数的不同处理过程，具体使用过程也是看教程，进行类的注册，使用函数parametrize。 with parametrize.cached():可以开启参数的缓存模型。 可以对于一个参数注册多个参数化模块。 同时参数化模块内部有的函数可以只在特殊时期调用，比如初始化。 可以移除参数化模块。 剪枝教程 Pruning Tutorial — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了剪枝和机制，以及钩子函数的引入。 介绍了组合剪枝，通过移除重参数化来永久化剪枝，不同模块针对剪枝，全局剪枝，扩展自己的剪枝函数等。 动态量化 (beta) Dynamic Quantization on an LSTM Word Language Model — PyTorch Tutorials 2.2.1+cu121 documentation (beta) Dynamic Quantization on BERT — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了使用torch.quantization.quantize_dynamic动态量化一次常见模型的例子。 计算机视觉的量化迁移学习教程 (beta) Quantized Transfer Learning for Computer Vision Tutorial — PyTorch Tutorials 2.2.1+cu121 documentation 这篇文章介绍了在微调时候插入量化模拟层和反量化层，从而让模型适应量化的过程（QAT）。 PyTorch 中具有 Eager 模式的静态量化 (beta) Static Quantization with Eager Mode in PyTorch — PyTorch Tutorials 2.2.1+cu121 documentation 这个教程演示如何进行训练后静态量化，并说明两种更先进的技术，通道量化和量化感知训练。 从第一性原理挖掘 PyTorch Intel CPU 性能 Grokking PyTorch Intel CPU performance from first principles — PyTorch Tutorials 2.2.1+cu121 documentation Grokking PyTorch Intel CPU performance from first principles (Part 2) — PyTorch Tutorials 2.2.1+cu121 documentation 这里介绍了优化CPU性能的方法和原理，目前来说太高深（挖矿todo 带 Ax 的多目标 NAS Multi-Objective NAS with Ax — PyTorch Tutorials 2.2.1+cu121 documentation 这篇文章介绍了怎么使用Ax平台进行神经网络架构的搜索。 torch.compile介绍 Introduction to torch.compile — PyTorch Tutorials 2.2.1+cu121 documentation 可以使用torch.compile当做装饰器或者函数使用。 同时也列举了几个模式以及和别的几个优化方法的对比。 Inductor CPU backend debugging and profiling Inductor CPU backend debugging and profiling — PyTorch Tutorials 2.2.1+cu121 documentation 这篇文章介绍了怎么对C++后端进行debug和profile的过程。有点复杂，，，（挖坑todo 实现高效缩放点积注意力Transformer (Beta) Implementing High-Performance Transformers with Scaled Dot Product Attention (SDPA) — PyTorch Tutorials 2.2.1+cu121 documentation 这篇文章介绍了怎么优化使用常用的缩放点积注意力。 torch.nested.nested_tensor支持融合不同长度的张量。 知识蒸馏 Knowledge Distillation Tutorial — PyTorch Tutorials 2.2.1+cu121 documentation 这篇教程介绍了知识蒸馏的几个方式，主要都是在损失函数里面添加教师模型和学生模型的各种量化差异来训练学生模型。 分布式（挖坑todo 参考资料 Welcome to PyTorch Tutorials — PyTorch Tutorials 2.2.1+cu121 documentation","categories":[{"name":"杂项","slug":"杂项","permalink":"https://bg51717.github.io/categories/%E6%9D%82%E9%A1%B9/"}],"tags":[{"name":"pytroch_tutorials","slug":"pytroch-tutorials","permalink":"https://bg51717.github.io/tags/pytroch-tutorials/"}]},{"title":"Adam Optimizer","slug":"深度学习/经典模块/Adam-Optimizer","date":"2023-12-29T08:23:43.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/12551/","link":"","permalink":"https://bg51717.github.io/12551/","excerpt":"","text":"背景 传统的随机梯度下降算法SGD(Stochastic Gradient Descent)的式子为: \\[ \\theta_{t+1} \\leftarrow \\theta_{t} -\\alpha \\nabla_{\\theta_{t}}J_{minibatcg}(\\theta_{t}) \\] 其中\\(J\\)为损失函数,\\(\\theta_{t}\\)为t时刻的参数,\\(\\alpha\\)为学习率,\\(\\nabla_{\\theta_{t}}J_{minibatcg}(\\theta_{t})\\)为t时刻梯度. Adam算法初步优化 考虑让梯度更加平滑,有以下式子: $$ m_{t+1} {1}m{t}+(1-{1}){{t}}J{minibatcg}(_{t}) \\ {t+1} {t} -m_{t+1} $$ 优点: 梯度更加平滑,减少了振荡 可以在初始设置更大的学习率 Adam算法最终优化 通过对应\"动量\"这一想法的进一步扩展,我们得到了新的学习算法式子: $$ m_{t+1} _1 m_t + (1 - 1) {t} J{}(t) \\ v{t+1} _2 v_t + (1 - 2)({t} J{}(t) {t} J{}(_t)) \\ _{t+1} _t - $$ 其中\\(\\beta_{1},\\beta_{2}\\)是大小在0和1之间的超参数,\\(\\odot\\)是平方的符号,\\(\\alpha\\)是学习率. 优点: 梯度更加平滑,减少了振荡 可以在初始设置更大的学习率 接收较小或很少更新的模型参数将得到较大的更新 参考资料 11.10. Adam算法 — 动手学深度学习 2.0.0 documentation (d2l.ai) Stanford CS 224N | Natural Language Processing with Deep Learning","categories":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"经典模块","slug":"深度学习/经典模块","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E7%BB%8F%E5%85%B8%E6%A8%A1%E5%9D%97/"}],"tags":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"优化算法","slug":"优化算法","permalink":"https://bg51717.github.io/tags/%E4%BC%98%E5%8C%96%E7%AE%97%E6%B3%95/"}]},{"title":"依赖分析Dependency Parsing","slug":"深度学习/自然语言处理/依赖分析Dependency-Parsing","date":"2023-12-27T14:21:54.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/26708/","link":"","permalink":"https://bg51717.github.io/26708/","excerpt":"","text":"介绍 这里介绍两种语义结构: Constituency Parsing：句法分析，Context-free grammars(CFGs)，上下文无关语法，赋予每个单词一个词性类别，单词组合成短语，短语递归形成更大的短语 Dependency Parsing：直接通过单词与其他单词的关系表示句子的结构，表示单词依赖于(修饰或是其参数)其他单词 Dependency Parsing缺陷 不同的自然语言有不同的组织结构,每种自然语言都有独特的二义问题(ambiguity),即同一个句子通过不同Dependency Parsing分析会得到不同语义树,进而得到不同的语句意思. 总的可能的语义数目极限情况下大概是随着字符串的提示可能是指数级增加,所以有一些方法来解决这些问题. Dependency Structure 通过一个单向边指明依赖关系(同时这个边也会指明依赖关系的种类),进而组成一个树状结构,通常会添加一个虚拟的\"ROOT\"节点作为根节点 1703687822509 1703687931983 Greedy transition-based parsing 1703688065130 初始状态:\\(\\sigma=[ROOT],\\beta=w_1,...,w_n,A=\\empty\\) 三种操作: Shift : 从缓存区\\(\\beta\\)里面移入一个词到栈\\(\\sigma\\)里面 Left-Arc : 将\\((w_j,r,w_i)\\)加入边集合\\(A\\) ,其中\\(w_i\\)是stack上的次顶层的词,\\(w_j\\)是stack上的最顶层的词,然后保留\\(w_j\\)在栈中（堆必须包含两个单词以及 \\(w_i\\)不是 ROOT ） Right-Arc : 将\\((w_i,r,w_j)\\)加入边集合\\(A\\) ,其中\\(w_i\\)是stack上的次顶层的词,\\(w_j\\)是stack上的最顶层的词,然后保留\\(w_i\\)在栈中（堆必须包含两个单词以及 \\(w_i\\)不是 ROOT ） 重复上述操作到指定目标. 实际应用的时候,如何判断选择哪一种操作可以通过机器学习的方式来判断,也可以加入集束搜索来寻找最优解. 评判标准: UAS:找准依赖项的词的比例 LAS:在UAS基础上,还要求边的属性得准确 示例: 1703689446845 参考资料 2021斯坦福CS224N课程笔记~2_context-free grammars and constituency parsing-CSDN博客","categories":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"自然语言处理","slug":"深度学习/自然语言处理","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"}],"tags":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"自然语言处理","slug":"自然语言处理","permalink":"https://bg51717.github.io/tags/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"}]},{"title":"矩阵偏分","slug":"深度学习/前置数学/矩阵偏分","date":"2023-12-24T07:18:43.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/45525/","link":"","permalink":"https://bg51717.github.io/45525/","excerpt":"","text":"在学习深度学习的过程中,很多次遇到了矩阵求导的问题,发现网上很多教程写的不是很好理解,记录自己的浅薄认知. （矩阵求导有分子转置和分母转置两种，本篇介绍的是分母转置。） Jacobian形式 矩阵论里的求导: 假设\\(A\\)矩阵维度列表为\\([a_1,a_2,...,a_n]\\) 假设\\(B\\)矩阵维度列表翻转为\\([b_m,b_{m-1},...,b_1]\\) \\(A\\)矩阵对\\(B\\)矩阵求偏导的结果\\(C\\),维度上相当于\\(A\\)矩阵维度列表和\\(B\\)矩阵维度列表翻转连起来 即\\(C\\)矩阵维度列表为\\([a_1,a_2,...,a_n,b_m,b_{m-1},...,b_1]\\) 根据维度信息也能很方便的推导各个元素的含义,即为\\(A\\)矩阵的每个元素对\\(B\\)矩阵的每个元素求一个偏导。 行向量偏导形式 此外，行向量偏导和Jacobian形式不同。把矩阵变成按列堆栈向量化\\(vec\\)， \\[ vec(X)=[x_{11},x_{21},..,x_{12},x_{22},...,x_{1n},x_{2n},...,x_{nm}]^T \\] 合适做法 合适的做法还是对于矩阵的每个元素单独看梯度和贡献，然后根据指标的变化来总结公式。 比如，计算\\(x_{ij}\\)是如何影响\\(y_{ik}\\)的，然后总结梯度公式。 示例1： \\[ X*A=Y,而X \\in R^{n \\times p}, A \\in R^{p \\times m},Y \\in R^{n \\times m},l为标量 \\\\ 已知\\frac{\\partial l}{\\partial Y},求\\frac{\\partial l}{\\partial X} \\\\ 计算x_{ik}的贡献,有 \\frac{\\partial z}{\\partial x_{ik}}=\\sum_{j}a_{kj}\\frac{\\partial z}{\\partial y_{ij}} \\\\ 根据维度信息(i在左侧,k在右侧)总结,得到\\frac{\\partial l}{\\partial X}=\\frac{\\partial l}{\\partial Y}A^T \\] tip:由于一维向量很多时候会被写为列向量,所以有的教程理解不是很方便,但如果接触过pytorch框架,会方便理解很多. 参考资料 矩阵求导的本质与分子布局、分母布局的本质（矩阵求导——本质篇） - 知乎 (zhihu.com) 【ML-0-3】矩阵求导-链式法则 - 忆凡人生 - 博客园 (cnblogs.com)","categories":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"前置数学","slug":"深度学习/前置数学","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E5%89%8D%E7%BD%AE%E6%95%B0%E5%AD%A6/"}],"tags":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"数学","slug":"数学","permalink":"https://bg51717.github.io/tags/%E6%95%B0%E5%AD%A6/"},{"name":"矩阵","slug":"矩阵","permalink":"https://bg51717.github.io/tags/%E7%9F%A9%E9%98%B5/"}]},{"title":"GloVe","slug":"深度学习/自然语言处理/GloVe","date":"2023-12-22T08:36:28.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/51558/","link":"","permalink":"https://bg51717.github.io/51558/","excerpt":"","text":"介绍 相比Word2Vec的局部训练,GloVe可以使用全局的语料统计信息来训练,可以预先计算全局语料库统计数据来提高训练数据. 带全局语料统计的跳元模型 用\\(q_{ij}\\)表示词\\(w_j\\)的条件概率\\(P(w_j|w_i)\\),在跳元模型中给定词\\(w_i\\),我们有 \\[ q_{ij}=\\frac{exp(\\bm u^T_j\\bm v_i)}{\\sum_{k \\in V}exp(\\bm u^T_k\\bm v_i)} \\] 记录\\(w_i\\)在所有出现地方的上下文构成一个可重集合\\(C_i\\),其中元素j的数目记为\\(x_{ij}\\),损失函数定义为 \\[ -\\sum_{i\\in V}\\sum_{j\\in V}x_{ij}log\\ q_{ij} \\] 用\\(x_i\\)表示\\(|C_i|\\),用\\(p_{ij}\\)表示概率\\(x_{ij}/x_i\\),则损失函数可以改写为 \\[ -\\sum_{i\\in V}x_i\\sum_{j\\in V}p_{ij}log\\ q_{ij} \\] 我们发现\\(-\\sum_{j\\in V}p_{ij}log\\ q_{ij}\\)就是计算全局语料统计的条件分布\\(p_{ij}\\)和模型预测的条件分布\\(q_{ij}\\)的交叉熵。 GloVe模型 考虑到计算成本的问题,以及大量罕见事件被损失建模,GloVe模型基于平方损失对模型进行了以下修改: 使用变量\\(p^{'}_{ij}=x_ij\\)和\\(q^{'}_{ij}=exp(\\bm u^T_{j}\\bm v_i)\\),并取两者对数,所以平方损失为\\((log\\ p^{'}_{ij}-log\\ q^{'}_{ij})^2=(\\bm u^T_{j}\\bm v_i-log\\ x_{ij})^2\\). 为每个词\\(w_i\\)添加中心词偏执\\(b_i\\)和上下文词偏置\\(c_i\\) 用权重函数\\(h(x)\\)替代损失项权重,其中\\(h(x)\\)在[0,1]的间隔内递增. 最后总的损失函数为: \\[ \\sum_{i\\in V}\\sum_{j\\in V}h(x_{ij})(\\bm u^T_{j}\\bm v_i+b_i+c_j-log\\ x_{ij})^2 \\] 由于对称性,有\\(x_{ij}=x_{ji}\\),而Word2Vec没有拟合对称性,GloVe拟合了对称性.因此,在GloVe模型中,词的上下文向量\\(u_i\\)和中心词向量\\(v_i\\)应该是相等的,但在实际应用中,由于训练过程的随机化导致两个向量有轻微不同,因此GloVe将两者相加作为输出向量. 参考资料1也提供了另一种理解GloVe模型的思路,和cs224n里面类似. 参考资料 14.5. 全局向量的词嵌入（GloVe） — 动手学深度学习 2.0.0 documentation (d2l.ai)","categories":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"自然语言处理","slug":"深度学习/自然语言处理","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"}],"tags":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"自然语言处理","slug":"自然语言处理","permalink":"https://bg51717.github.io/tags/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"}]},{"title":"Word2Vec","slug":"深度学习/自然语言处理/Word2Vec","date":"2023-12-21T08:53:05.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/5925/","link":"","permalink":"https://bg51717.github.io/5925/","excerpt":"","text":"介绍 传统的词向量是独热编码One-Hot,每个词语对应的向量只有一位为1,其余为0,通过这个1的位置区分向量 Word2Vec是一种Distributed Representation,相比独热编码有以下优点: 维度远小于独热编码 能更好的反馈向量间的关系 每个维度都被充分利用 Word2Vec的网络结构 Word2Vec是轻量级的神经网络，其模型仅仅包括输入层、隐藏层和输出层，模型框架根据输入输出的不同，主要包括CBOW和Skip-gram模型。 CBOW模型,在知道上下文的情况下预测中心词\\(w_t\\) Skip-gram模型,在知道中心词\\(w_t\\)的情况下预测 1703252876064 网络结构基础 下图是两种模型结构的基础,是输入一个词,预测一个词 1703253424041 中间的运算都会使用矩阵方便加速: 一个词语转换成对应的词向量,就会使用独热编码乘以这个\\(W_{V\\times N}\\),(其中V为词库大小,N为词向量维度数) 一个词向量和别的词的上下文向量点乘,也会乘以矩阵\\(W^{'}_{V\\times N}\\),得到\\(\\bm y\\),也就是\\(\\bm u^T\\cdot \\bm v\\) 之后词语k的概率就是softmax: \\[ P(w_k|w_c)=\\frac{\\exp(\\bm u^T_k\\cdot \\bm v_c)}{\\sum \\exp(\\bm u^T_i\\cdot \\bm v_c)}=\\frac{\\exp(\\bm y_k)}{\\sum \\exp(\\bm y_i)} \\] 之后就是追求句子概率最大化: \\[ \\prod P(w_k|w_c) \\] 对数化后取负数就得到了损失函数: \\[ Loss=\\sum_{o \\in context}( \\bm u^T_k\\cdot \\bm v_c-log(\\sum_{i \\in V}exp(\\bm u^T_i\\cdot \\bm v_c))) \\] 通过微分，我们可以获得其相对于中心词向量\\(\\bm v_c\\)的梯度为 1703256300356 其他向量的方法也是类似.这里就不给予推导. CBOW 词袋模型 用上下文预测中心词\\(w_t\\) 1703256961548 Skip-gram Model 跳元模型 用中心词\\(w_t\\)预测上下文 1703256988046 近似训练 由于softmax操作的性质，上下文词可以是词表V中的任意项，式子包含与整个词表大小一样多的项的求 和。因此，跳元模型的梯度计算和连续词袋模型的梯度计算都包含求和。不幸的是， 在一个词典上（通常有几十万或数百万个单词）求和的梯度的计算成本是巨大的！ 为了降低上述计算复杂度，引入两种近似训练方法：负采样和分层softmax。由于跳元模型和连续词袋 模型的相似性，将以跳元模型为例来描述这两种近似训练方法。 负采样Negative Sampling 负采样指的是加入一些负样本来进行模型的训练. 负采样修改了原目标函数来减少运算成本. 给定中心词\\(w_c\\)的上下文窗口，任意上下文词\\(w_o\\)来自该上下文窗口的被认为是由下式建模概率的事件： \\[ P(D=1|w_c,w_o)=\\sigma(\\bm u^T_o\\bm v_c) \\] 其中 \\[ \\sigma(x)=\\frac{1}{1+exp(-x)} \\] 考虑最大化联合概率 \\[ \\prod^T_{t=1}\\prod_{-m\\leqslant j \\leqslant m,j\\neq 0} P(D=1|w_t,w_{t+j}) \\] 然而这样只考虑了正样本,当且仅当所有词向量都等于无穷大的时候,这个式子会最大化为1,因此考虑加入一些噪声词作为负样本. \\[ \\prod^T_{t=1}\\prod_{-m\\leqslant j \\leqslant m,j\\neq 0} P(w_{t+j}|w_t) \\\\ 其中 P(w_{t+j}|w_t)=P(D=1|w_t,w_{t+j})\\prod^K_{k=1,w_k\\thicksim P(w)}P(D=0|w_t,w_k) \\] 关于条件概率的对数损失函数为: 1703258521309 分层softmax Hierarchical Softmax 1703258985364 这是一颗二叉树,从根节点开始,每次走左节点还是右节点都是概率时间,每个叶子节点都是词,所以根据中心词向量预测上下文可以看作是从根节点到叶子节点路径的概率乘积. 一种构造二叉树的方法是根据词语的出现频率构造哈夫曼树. 在非叶子节点\\(i\\)走右边的概率是 \\[ \\sigma(\\bm x^T_w \\bm \\theta)=\\frac{1}{1+eps(-\\bm x^T_w \\bm \\theta)} \\] 根据中心词\\(w_t\\)预测上下文\\(w_o\\)的概率也很就容易得到. 参考资料 第一篇写的最为详细全面,包括本文各种没有提到的细节,点赞! 参考资料里面第一篇和第三篇其实说的是一个东西,只不过一个是以矩阵的形式给出的. 可以通过奇异值分解减少词的特征维度. 深入浅出Word2Vec原理解析 - 知乎 (zhihu.com) 如何通俗理解Word2Vec (23年修订版)-CSDN博客 14.1. 词嵌入（word2vec） — 动手学深度学习 2.0.0 documentation (d2l.ai)","categories":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"自然语言处理","slug":"深度学习/自然语言处理","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"}],"tags":[{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"自然语言处理","slug":"自然语言处理","permalink":"https://bg51717.github.io/tags/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"}]},{"title":"readme","slug":"课程资源/readme","date":"2023-12-08T15:46:44.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/17140/","link":"","permalink":"https://bg51717.github.io/17140/","excerpt":"","text":"前言 当大四结束的时候,才意识到大学过的十分失败,很多计算机的核心知识其实都是处于一知半解的状态,动手能力也还是有很大的差距.即使在大一的时候,就已经在知乎上面刷到过不少计科混子的自我吐槽和悔恨,并且立志不要这么做,但大四上结束后,发现终究还是浪费了重要的四年和对重要知识的追求. 所以希望能通过一些大神的网上课程资源的推荐,弥补自己计算机教育的不足,希望亡羊补牢,为时未晚. 介绍 首先打算参考cswiki上面的课程和相关资源学习理论知识和提高动手能力. 而本目录大概包括各个课程的: 学习笔记 作业代码 工程代码 参考资料 cswiki","categories":[{"name":"课程资源","slug":"课程资源","permalink":"https://bg51717.github.io/categories/%E8%AF%BE%E7%A8%8B%E8%B5%84%E6%BA%90/"}],"tags":[]},{"title":"文献管理工具zotero","slug":"工具/文献管理工具zotero","date":"2023-11-22T02:12:21.000Z","updated":"2024-09-24T11:40:26.457Z","comments":true,"path":"/43151/","link":"","permalink":"https://bg51717.github.io/43151/","excerpt":"","text":"这里推荐一个文献管理工具,zotero,很好用的文献管理工具，也能很好的辅助写论文，获取文献，免费开源且支持插件,可以参考这个b站up的视频搭建和使用这个工具。 参考资料 Zotero零基础保姆级教程","categories":[{"name":"工具","slug":"工具","permalink":"https://bg51717.github.io/categories/%E5%B7%A5%E5%85%B7/"}],"tags":[{"name":"工具","slug":"工具","permalink":"https://bg51717.github.io/tags/%E5%B7%A5%E5%85%B7/"},{"name":"文献管理","slug":"文献管理","permalink":"https://bg51717.github.io/tags/%E6%96%87%E7%8C%AE%E7%AE%A1%E7%90%86/"}]},{"title":"论文阅读:BitNet_Scaling_1-bit_Transformers_for_Large_Language_Models","slug":"科研/论文阅读/论文阅读~BitNet-Scaling-1-bit-Transformers-for-Large-Language-Models","date":"2023-10-23T12:10:11.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/8948/","link":"","permalink":"https://bg51717.github.io/8948/","excerpt":"","text":"论文地址:BitNet: Scaling 1-bit Transformers for Large Language Models 摘要 这篇论文展示了BitNet,一种为大型语言模型设计的可扩展和稳定的1-bit转换器架构。具体地说，引入了BitLinear作为nn.Linar的插入替代,以便从头开始训练1-bit的权重。在语言建模上的实验结果表明，与最先进的8-bit量化方法和FP16 Transformer相比，BitNet在显著降低内存占用和能量消耗的同时，实现了强力的性能。此外，BitNet还展示了一种类似于全精度Transformers的缩放律，这表明它可以在保持效率和性能效益的同时有效地扩展到更大的语言模型。 1698064373146 图1： BitNet从头开始训练1-bit Transformers，以一种高效的方式获得竞争结果。BitNet明显优于最先进的量化方法。随着模型规模的扩大，成本节约变得更加显著，同时实现与FP16训练的模型的竞争性能。 介绍 大多数现有的大型语言模型的量化方法都是训练后的。它们简单且易于应用，因为它不需要对训练管道进行任何更改或重新训练模型。然而，它将导致更显著的精度损失，特别是当精度较低时，因为模型在训练过程中没有对量化表示进行优化。 深度神经网络的另一条量化链是量化感知训练。与训练后相比，它通常会产生更好的准确性，因为该模型被训练是为了考虑到从一开始就降低的精度。此外，它允许模型继续训练或进行微调，这对于大型语言模型至关重要。量化感知训练的挑战主要在于优化，即随着精度的降低，模型越来越难以收敛。此外，量化感知训练是否遵循神经语言模型的标度规律尚不清楚。 参考资料 BitNet: Scaling 1-bit Transformers for Large Language Models","categories":[{"name":"科研","slug":"科研","permalink":"https://bg51717.github.io/categories/%E7%A7%91%E7%A0%94/"},{"name":"论文阅读","slug":"科研/论文阅读","permalink":"https://bg51717.github.io/categories/%E7%A7%91%E7%A0%94/%E8%AE%BA%E6%96%87%E9%98%85%E8%AF%BB/"}],"tags":[{"name":"量化","slug":"量化","permalink":"https://bg51717.github.io/tags/%E9%87%8F%E5%8C%96/"}]},{"title":"论文阅读:A_Survey_of_Quantization_Methods_for_Efficient_Neural_Network_Inference","slug":"科研/论文阅读/论文阅读~A_Survey_of_Quantization_Methods_for_Efficient_Neural_Network_Inference","date":"2023-10-23T12:10:11.000Z","updated":"2024-09-24T11:40:26.460Z","comments":true,"path":"/62023/","link":"","permalink":"https://bg51717.github.io/62023/","excerpt":"","text":"论文地址:A Survey of Quantization Methods for Efficient Neural Network Inference 摘要 这篇论文是关于模型量化方向的综述，介绍了量化相关领域的研究，同时也介绍了一些重要的论文。 提到了量化的好处： 加快模型的推理过程 减少模型的存储开销 可以部署到特定设备（比如有的设备只能进行整型运算） 介绍 过去模型的能力有了巨大的提升，其中一个原因就是模型参数的增加，但这也为模型的部署提升了难度。 过去几年关于这方面的尝试有如下几种： 设计高效的神经网络模型架构，包括微观结构和宏观结构 神经网络软件和硬件协同设计 剪枝，减去对模型影响小的参数，分为结构化剪枝（删去部分参数）和非结构化剪枝（删去部分结构，相当于参数按组删去），两个方法各有优劣 知识蒸馏，用“教师”模型训练“学生”模型，可与前面方法结合 量化：分为训练中量化和推理量化 量化和神经科学的发展 这里很多次提到了AutoML和NAS技术调整网络结构 量化历史 量化，作为一种从大的（通常是连续的）集合中的输入值映射到小的（通常是有限的）集合中的输出值的方法，具有很长的历史。早在1897年就有微积分相关工作从事量化研究，同时，量化在信号处理中也非常重要。 香农在信息学和信号处理的研究过程中也针对量化进行过研究。同时，量化在连续数学量的数值求解中研究过。一些问题的良好解法可能由于数字量化会导致巨大误差，从而引出了算法数值稳定性的概念。 神经网络的发展给量化带来了机遇。神经网络的计算是计算密集型任务且目前很多模型都过度参数化。很多问题的解决都是基于一个某种误差度量，因此量化可能会增大误差，但同时也会增加模型的鲁棒性。 量化的基本概念 问题设置和符号 在不失一般性的情况下，让我们关注监督学习问题，即最小化下面所示的损失函数。 \\[ L(\\theta)=\\frac{1}{N} \\sum^{N}_{i=1}l(x_i,y_i;\\theta) \\] (x,y)是输入数据和对应的标签,$ l(x_i,y_i;)$是损失函数,N是数据数目 同时让我们把第\\(i\\)层的输入隐藏激活表示为\\(h_i\\),输出隐藏激活表示为\\(a_i\\),我们假设浮点格式存储的模型参数为\\(\\theta\\). 均匀量化 均匀量化和非均匀量化 1699360183609 均匀量化的一个常用的函数是 \\[ Q(r)=Int(\\frac{r}{S})-Z \\] \\(Q\\)是压缩函数,\\(r\\)是实数类型的输入,\\(S\\)是实数类型的比例因子,\\(Z\\)是整数零点,\\(Int\\)函数通过舍入操作把实数映射到整数 去量化操作 \\[ Q(\\tilde{r})=S(Q(r)+Z) \\] 由于舍入操作\\(\\tilde{r}\\)和\\(r\\)不会严格相等 对称和非对称量化 对称和非对称量化（观察量化前后零点位置 1699360947746 确定放缩因子\\(S\\)的式子为 \\[ S=\\frac{\\beta-\\alpha}{2^{b}-1} \\] \\([\\alpha,\\beta]\\)代表剪切范围,\\(b\\)代表量化位宽. 确定\\([\\alpha,\\beta]\\)的两个方式: \\(\\alpha=r_{min},\\beta=r_{max}\\) \\(-\\alpha=\\beta=max(|r_{min}|,|r_{max}|)\\) 利用实数的最大最小位选定裁剪范围可能会容易被异常数据影响,从而增加不必要的范围.解决这个问题的一种方法是使用百分位数,另一种方法是选择\\(α\\)和\\(β\\)，以最小化真实值和量化值之间的KL散度（即信息损失）.也有学者对不同的量化范围选取范围方法进行了评估. 确定\\(S\\)的两个方式: \\(\\frac{2max(|r|)}{2^n-1}\\) \\(\\frac{max(|r|)}{2^{n-1}-1}\\) 对称量化使用广泛,因为可以把零点降为0,减少计算成本并且实现更加简单;非对称量化对于范围可能是倾斜的和不对称的情况表现会更加优秀. 非对称激活中的偏移而占据的交叉项是一个静态数据独立项并且可以被偏差吸收(或用于初始化累加器). 范围校准算法：静态与动态量化 动态量化：运行期间计算量化参数，高精度，高开销 静态量化：量化参数预先确定，推理期间为静态，低开销，低精度 量化粒度 分层量化：通过一整个层的数值来计算量化参数，实现简单，精度次优 分组量化：把每一层的多个通道进行分组量化，有助于解决单个通道、激活分布离散的情况，但是计算开销会增加 分通道量化：每一层的每个通道进行量化，更好的精度，更高的计算成本 分卷积核（滤波器）量化：输入通道为\\(n\\)，输出通道为\\(m\\)，那么应该会有\\(n*m\\)个卷积核，根据卷积核量化会有更高的精度 总结（量化粒度）。通道量化是目前用于量化卷积核的标准方法。它使从业者能够以可忽略不计的开销来调整每个单独的内核的剪切范围。相比之下，子信道量化可能会导致巨大的开销，而且目前还不是标准的选择。 非均匀量化 量化步骤和量化水平被允许是非均匀间隔的 \\[ Q(r)=X_i, \\quad if\\quad r \\in [r_i,r_{i+1}] \\] 非均匀量化对于固定的位宽，可以获得更高的精度 典型的有 钟型分布 对数分布 二进制码,把一个向量拆成多个基向量的和,每个基向量的每个维度的值的绝对值为1 很多把量化问题转化为优化问题,减少原始张量r和量化后张量Q(r)的差异 \\[ \\underset{Q}{min}||Q(r)-r|| \\] 此外,量化器本身也可以和模型参数一起学习,称之为可学习的量化器 还有一些工作使用聚类来减少量化损失 非均匀量化能更好的捕获信息,但是计算成本更高,因此目前主流的还是均匀量化 微调方法 量化可能需要对参数进行微调,有两种方式: 量化感知训练QAT 训练后量化PTQ 左边是QAT,右边是PTQ QAT QAT一种方法展示 反向传播方法有: STE 随机神经元 组合优化 目标传播 Gumbelsoftmax 正则化算子来强制执行要量化的权重(量化过程没有不可微分算符) 也可以考虑量化感知训练的过程种学习量化参数 PTQ 由于PTQ不需要训练，所以对数据集的依赖比较低，当然，精度也会下降 因此，PTQ的研究重点都在于减轻PTQ的精度下降： ACIQ 解析地计算了PTQ的最佳剪切范围和通道级位宽设置 OMSE方法在激活时去除信道级量化，并提出通过优化量化张量与相应的浮点张量之间的L2距离来进行PTQ 一种离群值信道分裂（OCS）方法，该方法将包含离群值的信道重复和减半，缓解离群值对PTQ的不利影响 AdaRound表明，简单的圆到最近的量化方法（round-to-nearest）可以反直觉地得到次优解，并且提出了一种自适应四舍五入的方法 AdaQuant提出了一种更通用的方法，允许量化权值根据需要进行变化。 在PTQ中，所有的权值和激活量化参数都是不需要再训练而确定的。因此，PTQ是一种非常快速的神经网络模型量化方法。然而，与QAT相比，这往往以较低的准确性为代价。 Zero-shot Quantization（ZSQ） PTQ的极端场景，量化过程中不使用数据 Level 1: 没有数据且没有微调 (ZSQ + PTQ). Level 2: 没有数据但需要微调 (ZSQ +QAT). ZSQ中一个流行的研究分支是生成与类似于真实数据的合成数据，从中训练目标预先训练的模型。 随机量化 在推理过程中，量化方案总是确定的，小的权重更新可能不会导致任何权重变化，因为舍入操作可能总是返回相同的权重。然而，启用一个随机舍入可能为神经网络提供一个随机的机会，从而更新其参数。 比如，在有的论文里面，INT操作定义为 \\[ INT(x)=\\begin{cases} \\lfloor x \\rfloor ,with \\quad probability \\quad \\lceil x \\rceil-x\\\\ \\lceil x \\rceil ,with \\quad probability \\quad x-\\lfloor x \\rfloor\\\\ \\end{cases} \\] 有的会选择在量化的适合选择随机从量化参数权重子集里选一个进行量化运算 ADVANCED CONCEPTS: QUANTIZATION BELOW 8 BITS 模拟和纯整数量化 部署量化神经网络模型有两种常见方法： 模拟量化（又名假量化）：模拟量化中，量化后的模型参数以低精度存储，但运算（例如矩阵乘法和卷积）是用浮点运算进行的，运算之前需要对量化参数进行反量化 纯整数量化（又名定点量化）：所有运算都是使用低精度整数算术执行 1712407532667 如下图所示，硬件对低精度的处理会更好，并且低精度能量和面积方面的效率明显更高。 1712407640141 （这里稍微介绍了对于各种激活函数的量化方法，可以留意一下？ 二进量化（Dyadic quantization）是一种特殊的量化方法，通过把权重量化为二元数（二元数是分子中具有整数值、分母中具有 2 的幂的有理数），从而把运算转化为加减与位移从而提高效率。 两种量化种纯整数量化应用较多，但是假量化在通信成本高于计算成本的时候也有一定的应用前景。 混合精度量化 使用较低精度的量化时，硬件性能会提高。然而，将模型统一量化为超低精度可能会导致精度显着下降，可以通过混合精度量化来解决这个问题。 每一层都以不同的位精度进行量化，如下图所示。这种方法的一个挑战是，用于选择此位设置的搜索空间与层数成指数关系。人们提出了不同的方法来解决这个巨大的搜索空间。 1712408451748 搜索方法有： 强化学习 转化为神经架构搜索NAS使用DNAS解决 另一类混合精度方法使用周期函数正则化来训练混合精度模型，方法是在学习各自的位宽时自动区分不同的层及其在准确性方面的不同重要性。 HAWQ引入了一种基于模型二阶灵敏度自动查找混合精度设置的方法。 硬件感知量化 量化带来的性能提升和硬件有着密切关系，比如带宽设置、缓存结构等。因此，通过硬件感知量化实现最佳效益十分重要。 蒸馏辅助量化 量化领域的一个有趣的工作是结合模型蒸馏来提高量化精度。在学生模型的训练过程中，模型蒸馏建议利用教师产生的软概率，而不是仅使用真实类别标签，其中可能包含更多的输入信息。 \\[ \\mathcal{L}=\\alpha\\mathcal{H}(y,\\sigma(\\mathcal{z}_{s}))+\\beta\\mathcal{H}(\\sigma(\\mathcal{z}_{t},T),\\sigma(\\mathcal{z}_{s},T)) \\] α 和 β 是调整学生模型损失量和蒸馏损失的加权系数，y 是真实类别标签， \\(\\mathcal{H}\\)是交叉熵损失函数，\\({\\mathcal{z}}_{s}/{\\mathcal{z}}_{t}\\)是学生/教师模型生成的概率，T是温度。 \\[ p_{i}=\\frac{\\exp\\frac{z_{i}}{T}}{\\sum_{j}\\exp\\frac{z_{j}}{T}} \\] 然后有许多关于蒸馏过程的尝试，比如使用软概率、中间层数据、多教师模型等。 极致量化 这里提到了一些极端的量化方法，比如二值化和三值化等，但是极致的量化也会带来巨大的精度损失。因此有许多工作是关于极值量化的。目前大致有三个分支： 量化误差最小化 改进损失函数 改进训练方法 矢量量化 量化的目标是保持精度，而不是单个值的差异。因此有相关工作是把权重聚类分组然后使用中心作为量化值。还可以扩展为矩阵的乘积量化，把矩阵按照子矩阵分组。 量化和硬件处理器 这里罗列了一些处理器，并且介绍了他们的特点。 量化的未来研究 介绍了未来可以研究的几个东西： 量化软件 硬件和神经网络架构协同设计 耦合压缩方法 量化训练 总结和结论 ... 参考资料 A Survey of Quantization Methods for Efficient Neural Network Inference","categories":[{"name":"科研","slug":"科研","permalink":"https://bg51717.github.io/categories/%E7%A7%91%E7%A0%94/"},{"name":"论文阅读","slug":"科研/论文阅读","permalink":"https://bg51717.github.io/categories/%E7%A7%91%E7%A0%94/%E8%AE%BA%E6%96%87%E9%98%85%E8%AF%BB/"}],"tags":[{"name":"量化","slug":"量化","permalink":"https://bg51717.github.io/tags/%E9%87%8F%E5%8C%96/"}]},{"title":"Hexo+Github搭建个人Wiki风格博客","slug":"SmallProjects/博客搭建/Hexo+Github搭建个人Wiki风格博客","date":"2023-10-18T08:12:44.000Z","updated":"2024-09-24T11:40:26.457Z","comments":true,"path":"/13640/","link":"","permalink":"https://bg51717.github.io/13640/","excerpt":"","text":"介绍 以前一直不理解更新博客的用处，后来发现记录一些学到的东西和处理问题的经验对个人还是互联网都是有促进作用的(希望不是在生产互联网垃圾)。 所以本文会介绍一下个人搭建这个博客的过程。 博客风格 简洁（本来想弄点二次元风格的，但是博客还是减少点无用东西吧） 多级分类：多级分类可以帮助来快速浏览学过的知识点 标签：标签还是比较重要的，可以实习对相关博客的快速定位 主题选择 基于上述的需求，最终选择了Wikitten作为自己的博客主题 顺便放一下这个大佬的相关链接： Wiki地址：http://wiki.zthxxx.me/ Wikitten主题地址：https://github.com/zthxxx/hexo-theme-Wikitten/ 环境搭建 参考地址:使用 Hexo+GitHub 搭建个人免费博客教程（小白向） - 知乎 (zhihu.com) Github创建项目并取名为 用户名.github.io 使用 npm 一键安装 Hexo 博客程序 npm install -g hexo-cli 使用npm安装package.json里面的依赖 npm install 安装用于部署的包hexo-deployer-git npm install hexo-deployer-git --save 修改_config.yml文件末尾的Deployment部分 deploy: type: git repository: git@github.com:用户名/用户名.github.io.git branch: master 公式 参考文章：Hexo显示Latex公式最新解决方案_hexo latex-CSDN博客 卸载部分插件 npm un hexo-math npm un hexo-renderer-marked 安装hexo-renderer-pandoc渲染器 npm i hexo-renderer-pandoc 配置主题配置下的mathjax设置(文件位置在 \\themes\\{主题名}\\ _config.yml # MathJax mathjax: enable: true per_page: true 安装Pandoc 去Pandoc官网下载最新版本pandoc：Pandoc - About pandoc （参考文章说 Anaconda自带的 pandoc可能会引起问题并且提供了解决方案，但是笔者使用的是 miniconda，没有遇到任何问题 图片 参考文章：Hexo 引用本地图片以及引用本地任意位置图片的一点思路 | 养恐龙 (leay.net) 对于图片显示，hexo的原生设置较为冷门，hexo-asset-image等插件也提供了一定的解决方法，在博客文件同目录下设置个同名文件夹存放图片。但是笔者习惯使用 vscode编辑 markdown文章，而vscode默认在同目录下的 /image/{文件名}下存放图片文件。 笔者最后没有找到已有的较好的解决方案，于是写了个脚本文件进行处理（仅供参考）。 首先安装 hexo-asset-image插件，然后在 _config.yml里设置： post_asset_folder: true # 注意这个不能简单设置为false，否则插件hexo-asset-image会直接跳过（可以看看源码 marked: prependRoot: true postAsset: true 然后构建一个脚本文件在每次更新完后进行预处理，其中重要函数为 import os import shutil import re from functools import partial def move_directory(src, dst): \"\"\"把src下所有内容复制到dst下，并删除src\"\"\" # 确保目标目录存在 if not os.path.exists(dst): os.makedirs(dst) # 遍历源目录中的所有文件和子目录 for item in os.listdir(src): s = os.path.join(src, item) d = os.path.join(dst, item) # 如果是目录，递归移动子目录 if os.path.isdir(s): move_directory(s, d) else: # 移动文件，如果目标文件已存在，则跳过 if not os.path.exists(d): shutil.copy(s, d) # 最后，删除空的源目录 os.rmdir(src) def img_url_replace(match, file_name): pattern = r\"!\\[(.*?)\\]\\((.*?)\\)\" name, old_link = re.findall(pattern, match.group(0))[0] if old_link.startswith(\"./{file_name}\"): # 如果格式正确 return match.group(0) if old_link.startswith(\"./\"): old_link = old_link[2:] if old_link.startswith(\"image/\"): old_link = old_link[6:] return f\"\" def remedy_image_path(md_file_path): \"\"\"修改md文件中的图片路径\"\"\" with open(md_file_path, \"r\", encoding=\"utf-8\") as f: text = f.read() img_patten = r\"!\\[.*?\\]\\((.*?)\\)\" file_name = os.path.basename(md_file_path).split(\".\")[0] # img_patten = r'!\\[.*?\\]\\((.*?)\\)|<img.*?src=[\\'\\\"](.*?)[\\'\\\"].*?>' updated_text, changed_num = re.subn( img_patten, partial(img_url_replace, file_name=file_name), text ) if changed_num>0: with open(md_file_path, 'w', encoding='utf-8') as f: f.write(updated_text) def process_md_file(file_path): \"\"\"处理md文件\"\"\" # 如果不是md文件,返回 if not file_path.endswith(\".md\"): return file_dir, file_name = os.path.split(file_path) # 如果没有需要处理的文件 if not os.path.exists(os.path.join(file_dir, \"image\", file_name.split(\".\")[0])): return # 移动图片文件 move_directory( src=os.path.join(file_dir,'image',file_name.split('.')[0]), dst=os.path.join(file_dir,file_name.split('.')[0]) ) # 修改连接 remedy_image_path(file_path) def dfs(dir): \"\"\"dfs处理所有文件\"\"\" for root, dirs, files in os.walk(dir): for file in files: file = os.path.join(root, file) process_md_file(file) for sub_dir in dirs: sub_dir = os.path.join(root, sub_dir) dfs(sub_dir) Hexo常用命令 hexo clean #清除生成的网页文件 hexo g #生成静态网页 hexo s #本地运行博客 hexo d #将网页文件推送至远程服务器 Hexo常用文件夹 文件夹 备注 node_modules 依赖文件 .deploy_git 推送到远程的文件 public 生成的网页文件 themes 主题文件夹 scaffolds 博客模板文件夹 source 博客源文件 主题安装 Wikitten主题地址：https://github.com/zthxxx/hexo-theme-Wikitten/ 里面提供了双语详细的安装步骤,笔者使用的版本是 5b0d493 注意:里面有个可选步骤 配置mathjax渲染，笔者发现进行这个步骤后会出现生成网页文件失败的情况，跳过即可，并且暂时没发现有什么问题 评论系统giscus 由于不知名的原因，Gitment和Gitalk无法使用，选择了giscus来替代,参考Hexo静态博客使用giscus评论系统教程 1.打开自己的GitHub，选择博客所在仓库或可新建一个仓库 确保仓库是公开的(新建的时候选择 private或者在仓库的 Settings - General，选择 change visibility - change to public) 确保仓库开启了 Discussions(在仓库的 Settings - General，勾选 Discussions) 确保安装了 giscus app 2.打开官方配置页面giscus，生成代码 语言 仓库：填写格式：你的用户名/你的仓库名 页面 与 discussion 映射关系：由于本博客会分级，所以选择路径pathname Discussion分类：General 特性:按个人喜好即可，本博客加载了：启用主贴上的反应,将评论框放在评论上方,懒加载评论 主题：选择与博客风格一致的主题 3.修改主题 _config.yml 在文件末尾添加 giscus: enable: true 方便以后直接从配置文件开关评论区 4.粘贴代码 网页会自动生成代码,复制粘贴到网页模板文件即可 不同主题的模板文件位置可能不同，wiki主题在 themes/Wikitten/layout/comment/giscus.ejs下添加代码 (然后检查同目录的引入giscus的文件：counter.ejs，index.ejs，scripts.ejs，仿照之前代码添加引入) <% if (theme.comment.giscus.enable) { %> <div id=\"giscus-container\"></div> <script src=\"https://giscus.app/client.js\" data-repo=\"<%= theme.comment.giscus.repo %>\" data-repo-id=\"<%= theme.comment.giscus.repo_id %>\" data-category=\"<%= theme.comment.giscus.category %>\" data-category-id=\"<%= theme.comment.giscus.category_id %>\" data-mapping=\"pathname\" data-strict=\"0\" data-reactions-enabled=\"1\" data-emit-metadata=\"0\" data-input-position=\"top\" data-theme=\"<%= theme.comment.giscus.theme || 'light' %>\" data-lang=\"<%= theme.comment.giscus.lang || 'zh-CN' %>\" data-loading=\"lazy\" crossorigin=\"anonymous\" async> </script> <noscript>请启用 JavaScript 以查看评论。</noscript> <% } %> 然后修改 themes/Wikitten/layout/common/article.ejs文件，把 <% if (!index) { %> <%- partial('comment/index') %> <% } %> 移动到 <footer class=\"article-footer\"> </footer> 前面，两个代码块在同一个 div内。 然后在 themes/Wikitten/_config.yml内修改： comment: disqus: # enter disqus shortname here duoshuo: # enter duoshuo shortname here youyan: # enter youyan uid here giscus: enable: true repo: '' # 添加 repo_id: '' # 添加 category: 'General' category_id: '' # 添加 theme: 'light' lang: 'zh-CN' 对于不同的主题添加的方式可能不同 常见QA 修改配置文件应该修改站点的 _config.yml 还是主题的 _config.yml? 具体使用哪个，要看主题的源代码，如果是 config.xxx那就是用的根目录配置文件，如果是 theme.xxx那就用的是主题目录的配置文件。 怎么让自己的博客可以被常用搜索引擎搜索到? 很多搜索引擎可以在搜索框里用 site:网址来判断是否被收录 Google 打开Google搜索，搜索“Google Search Console” 根据提示登录你的Google账号 选择资源类型 选择验证方式(本博客用的是HTML标记,把对应代码添加到主题文件里面,本主题是 themes/Wikitten/layout/common/head.ejs) 在Google Search Console后台添加站点地图 参考资料 使用 Hexo+GitHub 搭建个人免费博客教程（小白向） Hexo 的个人 Wiki 主题 - Wikitten 超详细Hexo+Github博客搭建小白教程 Hexo显示Latex公式最新解决方案_hexo latex-CSDN博客 Hexo 引用本地图片以及引用本地任意位置图片的一点思路 | 养恐龙 (leay.net) Hexo静态博客使用giscus评论系统教程 Hexo官方文档","categories":[{"name":"SmallProjects","slug":"SmallProjects","permalink":"https://bg51717.github.io/categories/SmallProjects/"},{"name":"博客搭建","slug":"SmallProjects/博客搭建","permalink":"https://bg51717.github.io/categories/SmallProjects/%E5%8D%9A%E5%AE%A2%E6%90%AD%E5%BB%BA/"}],"tags":[{"name":"博客","slug":"博客","permalink":"https://bg51717.github.io/tags/%E5%8D%9A%E5%AE%A2/"},{"name":"Hexo","slug":"Hexo","permalink":"https://bg51717.github.io/tags/Hexo/"},{"name":"Wiki","slug":"Wiki","permalink":"https://bg51717.github.io/tags/Wiki/"}]},{"title":"快速启动工具——utools","slug":"工具/utools","date":"2023-04-05T02:12:21.000Z","updated":"2024-09-24T11:40:26.457Z","comments":true,"path":"/44392/","link":"","permalink":"https://bg51717.github.io/44392/","excerpt":"","text":"介绍 这里接受一个快速启动的工具utools和常用的插件。 utools utools已经被很多人开始使用了，无论是 alt+space 还是鼠标中键等快速启动方式，都可以使用户不要来回在鼠标和键盘之间切换从而提升效率。内置的一些默认插件已经可以极大的提升效率了。 utools优势： 完善的生态市场：里面有很多人在开发各种插件，并且插件的体积都非常小，也支持插件数据迁移 ，基本你想到的功能都可以在插件市场找到 多平台：utools在多个平台都可以使用，也可以多平台进行数据迁移 插件推荐 音速启动 utools搜索框可以使用且快速启动的大概为系统安装的软件搜素、文件搜索、网络搜索、插件搜索等，但是假如你有复杂的命令以及一个别名使用多个命令等，这是原生的utools无法使用的，而下面这款插件就可以使用。 音速启动插件是utools官方开发的插件，可以让utools快速启动的能力再次得到提高。在音速启动的配置界面，你可以配置一些命令，并且给这些常用的命令起别名，这样在utools搜索框内就可以通过别名快速运行一些命令。","categories":[{"name":"工具","slug":"工具","permalink":"https://bg51717.github.io/categories/%E5%B7%A5%E5%85%B7/"}],"tags":[{"name":"工具","slug":"工具","permalink":"https://bg51717.github.io/tags/%E5%B7%A5%E5%85%B7/"},{"name":"效率","slug":"效率","permalink":"https://bg51717.github.io/tags/%E6%95%88%E7%8E%87/"}]}],"categories":[{"name":"工具","slug":"工具","permalink":"https://bg51717.github.io/categories/%E5%B7%A5%E5%85%B7/"},{"name":"模板","slug":"模板","permalink":"https://bg51717.github.io/categories/%E6%A8%A1%E6%9D%BF/"},{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"工程细节","slug":"深度学习/工程细节","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E5%B7%A5%E7%A8%8B%E7%BB%86%E8%8A%82/"},{"name":"杂项","slug":"杂项","permalink":"https://bg51717.github.io/categories/%E6%9D%82%E9%A1%B9/"},{"name":"自然语言处理","slug":"自然语言处理","permalink":"https://bg51717.github.io/categories/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"},{"name":"huggingface","slug":"huggingface","permalink":"https://bg51717.github.io/categories/huggingface/"},{"name":"前置数学","slug":"深度学习/前置数学","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E5%89%8D%E7%BD%AE%E6%95%B0%E5%AD%A6/"},{"name":"经典模块","slug":"深度学习/经典模块","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E7%BB%8F%E5%85%B8%E6%A8%A1%E5%9D%97/"},{"name":"自然语言处理","slug":"深度学习/自然语言处理","permalink":"https://bg51717.github.io/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"},{"name":"课程资源","slug":"课程资源","permalink":"https://bg51717.github.io/categories/%E8%AF%BE%E7%A8%8B%E8%B5%84%E6%BA%90/"},{"name":"科研","slug":"科研","permalink":"https://bg51717.github.io/categories/%E7%A7%91%E7%A0%94/"},{"name":"论文阅读","slug":"科研/论文阅读","permalink":"https://bg51717.github.io/categories/%E7%A7%91%E7%A0%94/%E8%AE%BA%E6%96%87%E9%98%85%E8%AF%BB/"},{"name":"SmallProjects","slug":"SmallProjects","permalink":"https://bg51717.github.io/categories/SmallProjects/"},{"name":"博客搭建","slug":"SmallProjects/博客搭建","permalink":"https://bg51717.github.io/categories/SmallProjects/%E5%8D%9A%E5%AE%A2%E6%90%AD%E5%BB%BA/"}],"tags":[{"name":"安卓","slug":"安卓","permalink":"https://bg51717.github.io/tags/%E5%AE%89%E5%8D%93/"},{"name":"Google","slug":"Google","permalink":"https://bg51717.github.io/tags/Google/"},{"name":"模板","slug":"模板","permalink":"https://bg51717.github.io/tags/%E6%A8%A1%E6%9D%BF/"},{"name":"深度学习","slug":"深度学习","permalink":"https://bg51717.github.io/tags/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/"},{"name":"PyTorch","slug":"PyTorch","permalink":"https://bg51717.github.io/tags/PyTorch/"},{"name":"HuggingFace","slug":"HuggingFace","permalink":"https://bg51717.github.io/tags/HuggingFace/"},{"name":"Trainer","slug":"Trainer","permalink":"https://bg51717.github.io/tags/Trainer/"},{"name":"config","slug":"config","permalink":"https://bg51717.github.io/tags/config/"},{"name":"model","slug":"model","permalink":"https://bg51717.github.io/tags/model/"},{"name":"dataset","slug":"dataset","permalink":"https://bg51717.github.io/tags/dataset/"},{"name":"随机数","slug":"随机数","permalink":"https://bg51717.github.io/tags/%E9%9A%8F%E6%9C%BA%E6%95%B0/"},{"name":"vscode","slug":"vscode","permalink":"https://bg51717.github.io/tags/vscode/"},{"name":"python","slug":"python","permalink":"https://bg51717.github.io/tags/python/"},{"name":"调试","slug":"调试","permalink":"https://bg51717.github.io/tags/%E8%B0%83%E8%AF%95/"},{"name":"debug","slug":"debug","permalink":"https://bg51717.github.io/tags/debug/"},{"name":"transformers_tutorials","slug":"transformers-tutorials","permalink":"https://bg51717.github.io/tags/transformers-tutorials/"},{"name":"信息学","slug":"信息学","permalink":"https://bg51717.github.io/tags/%E4%BF%A1%E6%81%AF%E5%AD%A6/"},{"name":"数学","slug":"数学","permalink":"https://bg51717.github.io/tags/%E6%95%B0%E5%AD%A6/"},{"name":"pytroch_tutorials","slug":"pytroch-tutorials","permalink":"https://bg51717.github.io/tags/pytroch-tutorials/"},{"name":"优化算法","slug":"优化算法","permalink":"https://bg51717.github.io/tags/%E4%BC%98%E5%8C%96%E7%AE%97%E6%B3%95/"},{"name":"自然语言处理","slug":"自然语言处理","permalink":"https://bg51717.github.io/tags/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/"},{"name":"矩阵","slug":"矩阵","permalink":"https://bg51717.github.io/tags/%E7%9F%A9%E9%98%B5/"},{"name":"工具","slug":"工具","permalink":"https://bg51717.github.io/tags/%E5%B7%A5%E5%85%B7/"},{"name":"文献管理","slug":"文献管理","permalink":"https://bg51717.github.io/tags/%E6%96%87%E7%8C%AE%E7%AE%A1%E7%90%86/"},{"name":"量化","slug":"量化","permalink":"https://bg51717.github.io/tags/%E9%87%8F%E5%8C%96/"},{"name":"博客","slug":"博客","permalink":"https://bg51717.github.io/tags/%E5%8D%9A%E5%AE%A2/"},{"name":"Hexo","slug":"Hexo","permalink":"https://bg51717.github.io/tags/Hexo/"},{"name":"Wiki","slug":"Wiki","permalink":"https://bg51717.github.io/tags/Wiki/"},{"name":"效率","slug":"效率","permalink":"https://bg51717.github.io/tags/%E6%95%88%E7%8E%87/"}]}
\ No newline at end of file
diff --git a/friends/index.html b/friends/index.html
index b55b2263..b9147fc4 100644
--- a/friends/index.html
+++ b/friends/index.html
@@ -910,9 +910,10 @@
-论文地址:A Survey of
-Quantization Methods for Efficient Neural Network Inference
+论文地址:BitNet: Scaling
+1-bit Transformers for Large Language Models
摘要
-这篇论文是关于模型量化方向的综述，介绍了量化相关领域的研究，同时也介绍了一些
+这篇论文展示了BitNet,一种为大型语言模型设计的可扩展和稳定的1-bit转换器架构。具体地说，
@@ -1156,9 +1156,10 @@
var data_title = data.title.trim().toLowerCase();
var data_content = data.content.trim().replace(/<[^>]+>/g, "").toLowerCase();
var data_url = data.url;
+ var root = '/'; // 通过模板引擎动态获取 root
if (data_url.indexOf('http') !== 0) {
// 生成绝对路径，确保基于网站根目录
- data_url = window.location.protocol + '//' + window.location.host + data_url;
+ data_url = window.location.protocol + '//' + window.location.host + root + data_url;
}
var index_title = -1;
var index_content = -1;
diff --git a/page/3/index.html b/page/3/index.html
index b6bf8a85..19088898 100644
--- a/page/3/index.html
+++ b/page/3/index.html
@@ -421,13 +421,13 @@
-论文地址:BitNet: Scaling
-1-bit Transformers for Large Language Models
+论文地址:A Survey of
+Quantization Methods for Efficient Neural Network Inference
摘要
-这篇论文展示了BitNet,一种为大型语言模型设计的可扩展和稳定的1-bit转换器架构。具体地说，
+这篇论文是关于模型量化方向的综述，介绍了量化相关领域的研究，同时也介绍了一些
\[INT(x)=\begin{cases}\lfloor x \rfloor ,with \quad probability \quad \lceil x \rceil-x\\\lceil x \rceil ,with \quad probability \quad x-\lfloor x \rfloor\\\end{cases}\]
\[INT(x)=\begin{cases}\lfloor x \rfloor ,with \quad probability \quad \lceil x \rceil-x\\\lceil x \rceil ,with \quad probability \quad x-\lfloor x \rfloor\\\end{cases}\]
+ 
- 
+ 
- 论文阅读:A_Survey_of_Quantization_Methods_for_Efficient_Neural_Network_Inference
+ 论文阅读:BitNet_Scaling_1-bit_Transformers_for_Large_Language_Models
反向传播方法有: