-
Notifications
You must be signed in to change notification settings - Fork 0
/
search.xml
980 lines (472 loc) · 324 KB
/
search.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
<?xml version="1.0" encoding="utf-8"?>
<search>
<entry>
<title>数学计算库:SymPy</title>
<link href="//16846/"/>
<url>//16846/</url>
<content type="html"><![CDATA[<h2 id="介绍">介绍</h2><p><strong>SymPy</strong>是一个功能强大、开源的符号计算库（数值计算也同样支持），涵盖了代数、微积分、线性代数、数论、组合数学、物理学等领域的广泛功能。</p><p>这个库可以提供你想象到的所有数学操作，包括但不限于：</p><ul><li>符号计算：可以定义符号，然后求解方程或者优化问题的解析解。比如合并同类项，简化，展开，因式分解，求导，微分，解方程，极限，泰勒展开，数论，离散数学，统计，几何学等。</li><li>数值计算：作为数学库的必备功能，计算数值答案也是稳定支持的。</li><li>公式转 <code>latex</code>：对于部分符号，支持转化为<code>latex</code>代码。</li><li>可视化：提供了基本的可视化功能，包括绘制函数图像，几何图像，向量场，符号计算结果等。</li></ul><p>和别的科学计算库相比，<code>SymPy</code>的优势有：</p><ul><li>基于 <code>BSD</code>协议，开源免费</li><li>基于Python，方便使用，可以在交互窗口使用也可以在代码中作为库引入</li><li>轻量化，相比别的计算系统，<code>SymPy</code>需要的依赖少且体积小很多</li></ul><p>总之，个人感觉这个开源库提供了你所能想象到的所有数学相关的操作，也是许多常用的框架的前置库之一。当你遇到一些数学问题的时候，不妨先查询<code>SymPy</code>库能否解决。</p><h2 id="教程">教程</h2><p>由于这个库包罗万象，支持的功能过多，因此通过短短一篇博客了解或者快速查询到需要的功能是不太现实的。</p><p>因此建议使用的时候可以直接查看参考资料里的相关文档和伟大的<code>GPT</code>。</p><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href="https://docs.sympy.org/latest/tutorials/index.html">Tutorials -SymPy 1.13.3 documentation</a></li><li><a href="https://chatgpt.com/">Chatgpt</a></li></ul></blockquote>]]></content>
<categories>
<category> 数学 </category>
<category> 代码 </category>
</categories>
<tags>
<tag> 数学 </tag>
<tag> SymPy </tag>
</tags>
</entry>
<entry>
<title>论文阅读习惯</title>
<link href="//22407/"/>
<url>//22407/</url>
<content type="html"><![CDATA[<h2 id="介绍">介绍</h2><p>发现<strong>论文阅读习惯</strong>是一个十分重要的事情。</p><p>在和师兄的交流当中发现，读完一篇文献总是会遗漏一部分内容，这是因为没有良好的论文阅读习惯导致无法从一个文献中获得足够的信息从而变成自己的东西。</p><p>因此考虑使用这篇博客记录、分享和培养自己的阅读习惯，进而形成一种规范。</p><p>当然，如果你作为有缘人看到这篇博客，希望我的阅读习惯可以为你带来一些帮助，我也十分欢迎有缘人一起在评论区分享自己的阅读习惯。</p><h2 id="关注重点">关注重点</h2><p>一篇论文，是为解决一个问题或者公布一个发现而存在的，因此关注的重点应该有。</p><ul><li>background：这个论文的背景包括，这个论文是关于什么问题或者现象而存在的，关于目前问题的解决办法或者现象的发现方法。</li><li>motivation：这个方法的发现动机是什么？是怎么发现或者提出这个方法的？</li><li>method：这个方法的过程具体是什么样的？具体是怎么解决问题和发现现象的？</li><li>contribution（advantages）：本文的主要贡献是什么？这个方法的优势，和别的方法的对比是什么？</li><li>experiment<ul><li>settings：验证方法的实验的设置具体是什么？通过设置可以复现实验。</li><li>comparisonresults：对比结果代表了这个方法的改进以及与过去方法的不同体现在哪里，包括不使用这个方法的效果会怎么样。结果可能会以图标或者文字的方式呈现。</li><li>ablationresults：消融实验代表了方法的内部组件或者不同设置的对比，可以体现不同组件的作用。呈现方式和对比实验一样。</li></ul></li><li>limitation：局限代表了作者认为方法的局限体现在哪里，可以作为日后改进的参考。</li></ul><h2 id="流程">流程</h2><blockquote><p>我目前是使用 <code>Zotero7</code>来进行论文的阅读。</p></blockquote><h3 id="大致了解">大致了解</h3><p>通过 <code>ChatGPT</code>或<code>博客文章分享</code>来首先对文章有个大致的了解。</p><h3 id="细致阅读笔记">细致阅读+笔记</h3><p>有了大致的了解后，对文章进行细致的阅读。</p><p>使用 <code>Zotero</code>阅读论文的时候，可以在右侧记笔记。</p><p><img src="/22407/1731333627028.png"></p><p>文章不同需要关注的点也可以画出来。</p><figure><img src="/22407/1731333678362.png" alt="img"><figcaption aria-hidden="true">img</figcaption></figure><table><colgroup><col style="width: 64%"><col style="width: 35%"></colgroup><thead><tr><th style="text-align: center;">颜色</th><th style="text-align: center;">论文重点</th></tr></thead><tbody><tr><td style="text-align: center;"><img src="/22407/1731336154271.png"></td><td style="text-align: center;">method</td></tr><tr><td style="text-align: center;"><img src="/22407/1731336257655.png"></td><td style="text-align: center;">motivation</td></tr><tr><td style="text-align: center;"><img src="/22407/1731336286381.png"></td><td style="text-align: center;">background</td></tr><tr><td style="text-align: center;"><img src="/22407/1731336410193.png"></td><td style="text-align: center;">experiment settings</td></tr><tr><td style="text-align: center;"><img src="/22407/1731336620113.png"></td><td style="text-align: center;">experiment comparison results</td></tr><tr><td style="text-align: center;"><img src="/22407/1731336562418.png"></td><td style="text-align: center;">experiment ablation results</td></tr><tr><td style="text-align: center;"><img src="/22407/1732150648533.png"></td><td style="text-align: center;">contribution(advantages)</td></tr><tr><td style="text-align: center;"><img src="/22407/1731336812112.png"></td><td style="text-align: center;">limitation</td></tr></tbody></table><p>其中背景色代表重要的，下划线代表重要性次一点的。</p><h3 id="代码">代码</h3><p>如果可以的话，尽量去尝试阅读代码，观察具体是如何实现的，同时也可以作为学习的过程，解答论文里不理解的点。</p><h3 id="博客">博客</h3><p>如果有足够时间，可以尝试去试着输出，通过输出可能会更好的把握内容。</p>]]></content>
<categories>
<category> 科研 </category>
<category> 论文阅读 </category>
</categories>
</entry>
<entry>
<title>OmniQuant: Omnidirectionally Calibrated Quantization for Large Language Models</title>
<link href="//58958/"/>
<url>//58958/</url>
<content type="html"><![CDATA[<h2 id="介绍">介绍</h2><p>很多针对LLM的PTQ量化算法在设计参数的时候都添加了太多的先验知识，导致性能不佳，尤其在低比特量化中。为了解决这个问题，本文提出了全向校准量化（OmniQuant）技术。</p><p>OmniQuant包含两个组件，可学习权重裁剪 (LWC) 和可学习等效变换 (LET)。LWC通过优化限幅阈值来调节权重的极值。同时，LET通过将量化的挑战从激活转移到权重来解决激活异常值。OmniQuant在使用逐块误差最小化的可微框架内运行。在校准的时候，OmniQuant冻结了模型原始的全精度权重，仅包含LWC和LET可学习的量化参数。</p><p>本文也利用了 <code>LLM.int8()</code>和<code>AWQ</code>中的几个结论：</p><ul><li>相比模型的权重，大模型的激活的异常值（绝对值远超别的参数）的绝对值更大。并且无论是哪个<code>token</code>或者哪个<code>Layer</code>，异常值都集中在固定的少数维度。</li><li>由于与激活相对应的权重的重要性，权重的量化误差在最终性能中也起着关键作用。</li></ul><h2 id="方法">方法</h2><h3 id="分块量化">分块量化</h3><p>和别的针对LLm的PTQ量化方法一样，为了降低LLM量化的复杂度，OmniQuant也是逐个block进行量化的。针对每个block，优化的目标函数为：</p><p><span class="math display">\[\arg \min_{\Theta_1, \Theta_2} \left\| \mathcal{F}(\mathbf{W},\mathbf{X}) - \mathcal{F} \left( Q_w(\mathbf{W}; \Theta_1, \Theta_2),Q_a(\mathbf{X}, \Theta_2) \right) \right\|\]</span></p><p>其中，<span class="math inline">\(\mathcal{F}\)</span> 表示 LLM中一个 Transformer 块的映射函数，<span class="math inline">\(\mathbf{W}\)</span> 和 <span class="math inline">\(\mathbf{X}\)</span>分别是全精度的权重和激活，<span class="math inline">\(Q_w(\cdot)\)</span> 和 <span class="math inline">\(Q_a(\cdot)\)</span>分别表示权重和激活的量化器，<span class="math inline">\(\Theta_1\)</span> 和 <span class="math inline">\(\Theta_2\)</span>分别是可学习权重裁剪（LWC）和可学习等效变换（LET）的量化参数。公式中的逐块量化在移动到下一个块之前，依次量化一个Transformer 块的参数。</p><p>以block作为量化优化的最小单位有两个好处：</p><ul><li>可以对LWC和LET的参数同时进行训练</li><li>可以显著减少资源需求</li></ul><h3 id="lwc-learnable-weight-clipping">LWC (Learnable WeightClipping)</h3><p>LWC考虑在量化函数里面加入可学习的参数，具体来说，LWC优化了一个Clip过程，其公式如下：</p><p><span class="math display">\[\mathbf{W}_q = \text{clamp}\left(\left\lfloor \frac{\mathbf{W}}{h}\right\rceil + z, 0, 2^N - 1\right), \quad \text{其中 } h = \frac{\gamma\max(\mathbf{W}) - \beta \min(\mathbf{W})}{2^N - 1}, \quad z =-\left\lfloor \frac{\beta \min(\mathbf{W})}{h} \right\rceil\]</span></p><p>公式里面的<span class="math inline">\(\left\lfloor \cdot\right\rceil\)</span>代表取整操作，<span class="math inline">\(N\)</span>是量化的比特数，<span class="math inline">\(\mathbf{W}_q\)</span> 和 <span class="math inline">\(\mathbf{W}\)</span>分别表示量化后的权重和全精度权重。<span class="math inline">\(h\)</span>是权重的归一化因子，<span class="math inline">\(z\)</span>是零点值。clamp 操作将值限制在 <span class="math inline">\(N\)</span>位整数范围内，具体为 <span class="math inline">\([0, 2^N -1]\)</span>。在公式中，<span class="math inline">\(\gamma \in [0,1]\)</span> 和 <span class="math inline">\(\beta \in [0, 1]\)</span>是分别针对权重上界和下界的可学习剪辑强度。我们通过 sigmoid 函数对 <span class="math inline">\(\gamma\)</span> 和 <span class="math inline">\(\beta\)</span> 进行初始化。因此，在公式 (1)中，<span class="math inline">\(\Theta_1 = \{\gamma,\beta\}\)</span>。</p><p>其中<span class="math inline">\(h,z\)</span>是个整型，如果直接学习可能难度较大。</p><h3 id="let-learnable-equivalent-transformation">LET (LearnableEquivalent Transformation)</h3><p>考虑到激活中的异常值是系统性的并且对于特定通道是固定的，follow之前的工作，使用通道级缩放和通道级移位来操纵激活分布。参数方面作者认为之前的工作是手动设计的参数，导致结果可能不是很理想。</p><p>OmniQuant 没有引入额外的计算或参数，因为和AWQ量化算法一样，LWC中的限幅阈值和 LET 中的等效因子可以融合为量化权重。</p><h4 id="linear">Linear</h4><p>线性层接受一个输入标记序列 <span class="math inline">\(\mathbf{X} \in\mathbb{R}^{T \times C_\text{in}}\)</span>，其中 <span class="math inline">\(T\)</span> 是标记长度，其操作是权重矩阵 <span class="math inline">\(\mathbf{W} \in \mathbb{R}^{C_\text{in} \timesC_\text{out}}\)</span> 与偏置向量 <span class="math inline">\(\mathbf{B}\in \mathbb{R}^{1 \times C_\text{out}}\)</span>的乘积。一个数学等价的线性层表示为：</p><p><span class="math display">\[\mathbf{Y} = \mathbf{X} \mathbf{W} + \mathbf{B} =\underbrace{\left(\mathbf{X} - \delta\right) \odots}_{\tilde{\mathbf{X}}} \cdot \underbrace{\left(s \odot\mathbf{W}\right)}_{\tilde{\mathbf{W}}} + \underbrace{\left(\mathbf{B} +\delta \mathbf{W}\right)}_{\tilde{\mathbf{B}}}\]</span></p><p>其中，<span class="math inline">\(\mathbf{Y}\)</span> 表示输出，<span class="math inline">\(s \in \mathbb{R}^{1 \times C_\text{in}}\)</span>和 <span class="math inline">\(\delta \in \mathbb{R}^{1 \timesC_\text{in}}\)</span> 分别是通道级的缩放和偏移参数。<span class="math inline">\(\tilde{\mathbf{X}}\)</span>，<span class="math inline">\(\tilde{\mathbf{W}}\)</span> 和 <span class="math inline">\(\tilde{\mathbf{B}}\)</span>分别是等效的激活、权重和偏置，符号“<span class="math inline">\(\odot\)</span>”表示元素级的除法和乘法。</p><p>通过公式，激活被转化为量化友好的形式，但代价是增加了权重量化的难度。在此意义上，LWC可以改善通过LET实现的权重-激活量化的性能，因为它使权重更加量化友好。最终，我们对转换后的激活和权重进行量化，公式如下：</p><p><span class="math display">\[\mathbf{Y} = Q_a(\tilde{\mathbf{X}}) Q_w(\tilde{\mathbf{W}}) +\tilde{\mathbf{B}}\]</span></p><p>其中，<span class="math inline">\(Q_a\)</span> 是普通的 MinMax量化器，<span class="math inline">\(Q_w\)</span>是带有可学习权重剪辑（即 LWC）的 MinMax 量化器。</p><p>请注意，<span class="math inline">\(\tilde{\mathbf{X}}\)</span>中的缩放和偏移参数可以吸收进前面的归一化或线性层，而 <span class="math inline">\(\tilde{\mathbf{W}}\)</span>中的缩放因子可以融合进原始线性权重 <span class="math inline">\(\mathbf{W}\)</span>中。因此，公式中的等效变换可以在不引入额外参数或成本的情况下有效减少量化误差。</p><p>OmniQuant在 LLM 的线性层（除了 FFN的第二个线性层）中使用此等效变换。这可能是因为在应用可学习的等效变换时，非线性层后的特征高度稀疏，导致梯度不稳定。</p><h4 id="attention-operation">Attention operation</h4><p>除了线性层外，注意力操作也占据了计算的一个重要部分。此外，LLM的自回归模式需要存储每个标记的键值（KV）缓存，这对于长序列带来了大量的内存需求。因此，考虑把<span class="math inline">\(Q,K,V\)</span>矩阵在权重-激活量化设置中量化为低比特值。具体而言，自注意力相似度矩阵的可学习等效变换可写为：</p><p><span class="math display">\[\mathbf{P} = \text{Softmax}(\mathbf{Q} \mathbf{K}^T) = \text{Softmax}\left( \underbrace{\mathbf{Q} \odot s_a}_{\tilde{\mathbf{Q}}} \,\underbrace{(s_a \odot \mathbf{K}^T)}_{\tilde{\mathbf{K}}^T} \right).\]</span></p><p>其中，<span class="math inline">\(s_a \in \mathbb{R}^{1 \timesC_\text{out}}\)</span>是相似度矩阵中的缩放因子。量化的相似度矩阵计算表示为 <span class="math inline">\(\mathbf{P} =\text{Softmax}(Q_a(\tilde{\mathbf{Q}})Q_a(\tilde{\mathbf{K}}^T))\)</span>。这里我们同样使用 MinMax 量化方案<span class="math inline">\(Q_a\)</span> 对 <span class="math inline">\(\tilde{\mathbf{Q}}/\tilde{\mathbf{K}}\)</span>矩阵进行量化。我们可以得出 <span class="math inline">\(\Theta_2 = \{\delta, s, s_a \}\)</span> 。</p><p><span class="math inline">\(\tilde{\mathbf{Q}}\)</span> 和 <span class="math inline">\(\tilde{\mathbf{K}}\)</span>中的通道级缩放因子，可以分别吸收到查询和键投影的线性权重中。值得一提的是，由于逆变换操作的存在，输出投影线性层中的显式变换在其分布上已按通道维度进行了更改，因此省略了<span class="math inline">\(\mathbf{V}\)</span> 的变换。</p><h2 id="实验">实验</h2><p>首先测试了只量化模型权重的结果，和GPTQ和AWQ进行了对比，取得了在WikiText2上最低的困惑度。</p><p><img src="/58958/1731158459757.png"></p><p>也测试了权重和激活都进行量化的表现，对比的baseline是SmoothQuant和LLM-QAT，可以看到甚至比LLM-QAT这种QAT量化方法还要好。</p><p><img src="/58958/1731158796713.png"></p><p>然后还参考AWQ的论文，测试了模型回答问题的准确率。把两个模型的回答连接在一起，让GPT-4判断哪个回答更好，为了去除顺序的影响，会交换顺序让GPT-4再回答一次，结果如下图所示：</p><p><img src="/58958/1731158884137.png"></p><p>最后测试了模型的效率情况，统计了算法在不同规模的Llama上的存储需求和推理速度。</p><p><img src="/58958/1731159099167.png"></p><p>这篇论文的附录罗列了很多细节，需要的可以去看原文。</p><h2 id="代码">代码</h2><p>论文源码：<a href="https://github.com/OpenGVLab/OmniQuant/tree/main">OpenGVLab/OmniQuant:[ICLR2024 spotlight] OmniQuant is a simple and powerful quantizationtechnique for LLMs.</a></p><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href="https://arxiv.org/abs/2308.13137">[2308.13137] OmniQuant:Omnidirectionally Calibrated Quantization for Large LanguageModels</a></li><li><a href="https://github.com/OpenGVLab/OmniQuant/tree/main">OpenGVLab/OmniQuant:[ICLR2024 spotlight] OmniQuant is a simple and powerful quantizationtechnique for LLMs.</a></li></ul></blockquote>]]></content>
<categories>
<category> 科研 </category>
<category> 论文阅读 </category>
</categories>
</entry>
<entry>
<title>OneBit: Towards Extremely Low-bit Large Language Models</title>
<link href="//341/"/>
<url>//341/</url>
<content type="html"><![CDATA[<h2 id="介绍">介绍</h2><p>OneBit属于量化方法中的量化感知训练QAT。基于BitNet的OneBit将LLM的权重矩阵量化为1位，用一种新颖的1 位参数表示方法以更好地量化LLM，以及一种基于矩阵分解的有效参数初始化方法以提高量化框架的收敛速度。</p><h2 id="方法">方法</h2><h3 id="bitlinear">BitLinear</h3><p>OneBitfollow的工作是BitNet，BitNet提出BitLinear，BitLinear的forward函数为：</p><p><span class="math display">\[\begin{align*}& \mathbf{W}_{\pm 1} = \operatorname{Sign}\left( \mathbf{W} -\operatorname{Mean}(\mathbf{W}) \right), \\& \eta = \operatorname{Mean} \left( \operatorname{Abs} \left(\mathbf{W} - \operatorname{Mean}(\mathbf{W}) \right) \right), \\& \mathbf{Y} = \eta \cdot \operatorname{LayerNorm}(\mathbf{X})\mathbf{W}_{\pm 1}^{\top},\end{align*}\]</span></p><p>其中，<span class="math inline">\(W\)</span>表示量化后的权重矩阵，形状为 <span class="math inline">\(m \times n\)</span>，<span class="math inline">\(W_{±1}\)</span>表示 1 位量化矩阵。<span class="math inline">\(X\)</span>是线性层的输入，<span class="math inline">\(Y\)</span> 是输出。函数 <span class="math inline">\(Sign()\)</span>、<span class="math inline">\(Mean()\)</span> 和 <span class="math inline">\(Abs()\)</span>分别返回符号矩阵、平均值和绝对值矩阵。</p><p>作者认为，缺失的浮点精度仍然破坏了模型性能，因此额外引入了两个始终保持fp16精度的向量：</p><p><span class="math display">\[\begin{align*}& \mathbf{W}_{\pm 1} = \operatorname{Sign}(\mathbf{W}), \\& \mathbf{Y} = \left[ (\mathbf{X} \odot \mathbf{g}) \mathbf{W}_{\pm1}^{\top} \right] \odot \mathbf{h}, \\& \mathbf{Z} = \operatorname{LayerNorm}(\mathbf{Y}),\end{align*}\]</span></p><p>其中的<span class="math inline">\(g\)</span>和<span class="math inline">\(h\)</span>是fp16精度的向量，<span class="math inline">\(Z\)</span>是最终的输出。同时括号严格要求了计算顺序从而减小计算成本。其余的和BitNet保持一致。</p><p>训练的时候，不需要保存一个高精度的参数矩阵，只需要保存两个高精度的向量即可。</p><h3 id="svid">SVID</h3><p>为了可以使用训练好的模型的ckpt来初始化量化模型的权重，这篇论文还引入了Sign-Value-IndependentDecomposition (SVID)，所以近似初始化方法为，</p><p><span class="math display">\[\mathbf{W} \approx \mathbf{W}_{\text{sign}} \odot (\mathbf{a}\mathbf{b}^{\top})\]</span></p><p>就是用训练好模型的权重矩阵<span class="math inline">\(W\)</span>，分解为量化模型的三部分<span class="math inline">\(\mathbf{W}_{\text{sign}} , \mathbf{a} ,\mathbf{b}\)</span>。</p><p>这里提出两个命题来说明合理性：</p><p><strong>命题一</strong>：使用上面的近似，我们可以得到，</p><p><span class="math display">\[\mathbf{X} \mathbf{W}^{\top} \approx \left[ (\mathbf{X} \odot\mathbf{b}^{\top}) \mathbf{W}_{\text{sign}}^{\top} \right] \odot\mathbf{a}^{\top}\]</span></p><p>根据这个命题，可以从近似初始化得到BitLinear的forward公式。</p><blockquote><p>证明过程：</p><p>令<span class="math inline">\(s_{ij}\)</span>为1Bit矩阵<span class="math inline">\(W_{sign}\)</span>的一个元素，我们很容易得到：<span class="math inline">\(w_{i,j} \approx s_{i,j} \cdot a_i b_j\)</span>。</p><p>因此，我们有，</p><p><span class="math display">\[\begin{align*}\left( \mathbf{X} \mathbf{W}^{\top} \right)_{ij} & = \sum_k x_{ik}w_{kj} \\& = \sum_k x_{ik} w_{jk} \\& \approx \sum_k x_{ik} s_{jk} a_j b_k \\& = \sum_k x_{ik} b_k s_{jk} a_j \\& = \sum_k \left( \mathbf{X} \odot \mathbf{b}^{\top} \right)_{ik}s_{kj}^{\top} a_j \\& = \left[ \left( \mathbf{X} \odot \mathbf{b}^{\top} \right)\mathbf{W}_{\text{sign}}^{\top} \right]_{ij} a_j \\& = \left\{ \left[ \left( \mathbf{X} \odot \mathbf{b}^{\top} \right)\mathbf{W}_{\text{sign}}^{\top} \right] \odot \mathbf{a}^{\top}\right\}_{ij}\end{align*}\]</span></p></blockquote><p><strong>命题二</strong>：给定矩阵 $W $和 <span class="math inline">\(|W|\)</span>，其中 <span class="math inline">\(W =W_{\text{sign}} \odot |W|\)</span>。以如下方式对这些矩阵进行分解：<span class="math inline">\(W = \mathbf{a} \mathbf{b}^{\top} +\mathbf{E}_1\)</span>和<span class="math inline">\(|W| =\tilde{\mathbf{a}} \tilde{\mathbf{b}}^{\top} +\mathbf{E}_2\)</span>，其中<span class="math inline">\(E_i\)</span>表示误差矩阵。就 Frobenius范数而言，SVD 分解比原始矩阵 $W $更接近：</p><p><span class="math display">\[\left\| W - W_{\text{sign}} \odot \tilde{\mathbf{a}}\tilde{\mathbf{b}}^{\top} \right\|_F^2 \leq \left\| W - \mathbf{a}\mathbf{b}^{\top} \right\|_F^2.\]</span></p><p>根据这个命题，可以说明提出符号位可以更好地减小误差。</p><blockquote><p><strong>引理 1</strong> 令 <span class="math inline">\(\sigma_i(\mathbf{W})\)</span> 表示矩阵 <span class="math inline">\(\mathbf{W}\)</span> 的第 <span class="math inline">\(i\)</span> 大奇异值。则以下不等式成立：</p><p><span class="math display">\[\sigma_1(|\mathbf{W}|) \geq \sigma_1(\mathbf{W}).\]</span></p><p><strong>引理证明</strong> 根据诱导范数的定义，有</p><p><span class="math display">\[\sigma_1(\mathbf{W}) = \|\mathbf{W}\|_2 = \max_{\mathbf{x},\|\mathbf{x}\|_2=1} \|\mathbf{W} \mathbf{x}\|_2,\]</span></p><p><span class="math display">\[\sigma_1(|\mathbf{W}|) = \||\mathbf{W}|\|_2 = \max_{\mathbf{y},\|\mathbf{y}\|_2=1} \||\mathbf{W}| \mathbf{y}\|_2.\]</span></p><p>注意对于任意 <span class="math inline">\(\mathbf{x}\)</span>，<span class="math inline">\(\|\mathbf{x}\|_2 = 1\)</span>，我们有</p><p><span class="math display">\[\||\mathbf{W}| \mathbf{x}\|_2^2 = \sum_i \left( \sum_j |w_{ij}||x_j|\right)^2 \geq \sum_i \left( \sum_j w_{ij} x_j \right)^2 = \|\mathbf{W}\mathbf{x}\|_2^2.\]</span></p><p>因此</p><p><span class="math display">\[\max_{\mathbf{y}, \|\mathbf{y}\|_2=1} \||\mathbf{W}| \mathbf{y}\|_2 \geq\max_{\mathbf{x}, \|\mathbf{x}\|_2=1} \|\mathbf{W} \mathbf{x}\|_2.\]</span></p><p>该引理得证。</p><hr><p><strong>命题证明</strong> 考虑通过 SVD 来证明。对于 SVD分解，因为使用两个向量近似，等同于只保留最大的奇异值和对应的特征向量，rank-1近似中的误差矩阵 <span class="math inline">\(\mathbf{E}\)</span>的范数等于所有奇异值平方和中除去最大奇异值后的总和。我们有</p><p><span class="math display">\[\|\mathbf{E}_1\|_F^2 = \sum_{i=2}^n \sigma_i^2(\mathbf{W}),\]</span></p><p><span class="math display">\[\|\mathbf{E}_2\|_F^2 = \sum_{i=2}^n \sigma_i^2(|\mathbf{W}|).\]</span></p><p>根据 <span class="math inline">\(\|\mathbf{W}\|_F^2 =\||\mathbf{W}|\|_F^2\)</span>，我们有</p><p><span class="math display">\[\sum_{i=1}^n \sigma_i^2(\mathbf{W}) = \sum_{i=1}^n\sigma_i^2(|\mathbf{W}|).\]</span></p><p>根据引理 1，我们可以得出</p><p><span class="math display">\[\|\mathbf{E}_1\|_F^2 \geq \|\mathbf{E}_2\|_F^2.\]</span></p><p>根据该命题中的方程，我们可以表示</p><p><span class="math display">\[\mathbf{W}_{\text{sign}} \odot |\mathbf{W}| = \mathbf{W}_{\text{sign}}\odot (\tilde{\mathbf{a}} \tilde{\mathbf{b}}^{\top} + \mathbf{E}_2).\]</span></p><p>因此我们有</p><p><span class="math display">\[\mathbf{W} - \mathbf{W}_{\text{sign}} \odot \tilde{\mathbf{a}}\tilde{\mathbf{b}}^{\top} = \mathbf{W}_{\text{sign}} \odot \mathbf{E}_2.\]</span></p><p>因此</p><p><span class="math display">\[\|\mathbf{W}_{\text{sign}} \odot \mathbf{E}_2\|_F^2 = \sum_{i,j}s_{ij}^2 e_{ij}^2 = \sum_{i,j} e_{ij}^2 = \|\mathbf{E}_2\|_F^2 \leq\|\mathbf{E}_1\|_F^2,\]</span></p><p>其中 <span class="math inline">\(s_{ij} = \pm 1\)</span> 是 <span class="math inline">\(\mathbf{W}_{\text{sign}}\)</span>的元素。由此，该命题中的不等式得证。</p></blockquote><h3 id="知识蒸馏">知识蒸馏</h3><p>考虑在量化模型训练的时候加入知识蒸馏，大的教师模型代表量化前的模型，小的学生模型代表量化后的模型。损失由两部分组成，首先是交叉熵损失，</p><p><span class="math display">\[\mathcal{L}_{\text{CE}} = -\frac{1}{n_s} \sum_{i=1}^{n_s} \sum_{c}P_c^{T}(o_i) \log P_c^{S}(o_i)\]</span></p><p>第二个是所以hidden states归一化后的差值的L2范数，</p><p><span class="math display">\[\mathcal{L}_{\text{MSE}} = \sum_{i=1}^{n_s} \sum_{j=1}^{n_l} \left\|\frac{q_{i,j}^{T}}{\|q_{i,j}^{T}\|_2} -\frac{q_{i,j}^{S}}{\|q_{i,j}^{S}\|_2} \right\|_2^2\]</span></p><p>总的损失为：</p><p><span class="math display">\[\mathcal{L}_{\text{KD}} = \mathcal{L}_{\text{CE}} + \alpha\mathcal{L}_{\text{MSE}}\]</span></p><blockquote><p>由于符号十分常用，因此这里省去对于其中的符号的解释说明。</p></blockquote><p>训练的时候，使用是模拟量化进行训练，即原来的权重也会进行训练，部署的时候再压缩：</p><p><img src="/341/1731079859743.png"></p><h2 id="实验">实验</h2><p>首先测试了该量化方法和一些PTQ方法和QAT方法的困惑度比较，其中的baseline为W2A16量化，本文方法为W1A16，可以看到取得了较大领先，</p><p><img src="/341/1731079794197.png"></p><p>为了评估实际解决问题的能力，还测试了和一些小模型能力的差异和资源的需求，其中的OneBit是本文方法训练的模型，LowRankLLaMA是通过低秩分解压缩的Llama模型：</p><p><img src="/341/1731080140597.png"></p><h2 id="代码">代码</h2><p>论文源码：<a href="https://github.com/xuyuzhuang11/OneBit">xuyuzhuang11/OneBit: Thehomepage of OneBit model quantization framework.</a></p><p>个人认为其中比较重要的部分：</p><ul><li><a href="https://github.com/xuyuzhuang11/OneBit/blob/main/transformers/src/transformers/models/bitnet.py">OneBit/transformers/src/transformers/models/bitnet.pyat main · xuyuzhuang11/OneBit</a></li><li><a href="https://github.com/xuyuzhuang11/OneBit/blob/main/scripts/build_start_ckpt.py">OneBit/scripts/build_start_ckpt.pyat main · xuyuzhuang11/OneBit</a></li></ul><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href="https://arxiv.org/abs/2402.11295">[2402.11295] OneBit:Towards Extremely Low-bit Large Language Models</a></li><li><a href="https://github.com/xuyuzhuang11/OneBit">xuyuzhuang11/OneBit: Thehomepage of OneBit model quantization framework.</a></li></ul></blockquote>]]></content>
<categories>
<category> 科研 </category>
<category> 论文阅读 </category>
</categories>
<tags>
<tag> 深度学习 </tag>
<tag> 量化 </tag>
</tags>
</entry>
<entry>
<title>矩阵奇异值分解SVD</title>
<link href="//33996/"/>
<url>//33996/</url>
<content type="html"><![CDATA[<h2 id="定理陈述">定理陈述</h2><p>对于任意 <span class="math inline">\(m \times n\)</span> 的矩阵 <span class="math inline">\(A\)</span>，存在一个分解：</p><p><span class="math display">\[A = U \Sigma V^T\]</span></p><p>其中：</p><ul><li>r=rank(A)是矩阵A的秩</li><li><span class="math inline">\(U\)</span> 是一个 <span class="math inline">\(m \times m\)</span> 的正交矩阵（即 <span class="math inline">\(U^T U = I\)</span>），前r列是矩阵<span class="math inline">\(A A^\top\)</span>的非零特征值的特征向量。</li><li><span class="math inline">\(V\)</span> 是一个 <span class="math inline">\(n \times n\)</span> 的正交矩阵（即 <span class="math inline">\(V^T V = I\)</span>），前r列是矩阵$ A^A$的非零特征值的特征向量。</li><li><span class="math inline">\(\Sigma\)</span> 是一个 <span class="math inline">\(m \times n\)</span>的对角矩阵，其对角线元素是非负实数，前r个非负实数称为A的奇异值。</li></ul><p>分解结果不是唯一的，不同分解的区别主要在于特征向量和奇异值的顺序。</p><h2 id="证明">证明</h2><blockquote><p>参考自：<a href="https://blog.csdn.net/THUChina/article/details/102576718">奇异值分解（SVD）推导证明与应用_简述奇异值分解定理,并进行推导与证明(公式以及矩阵可以写在纸上照下来)-CSDN博客</a></p></blockquote><p>因为<span class="math inline">\(AA^\top\)</span>是半正定矩阵，所以存在正交矩阵<span class="math inline">\(V_{n\times n}\)</span>，</p><p><span class="math display">\[V^T (A^T A) V = \operatorname{diag}(\lambda_1, \lambda_2, \dots,\lambda_n)\]</span></p><p>其中<span class="math inline">\(\lambda_1 > \lambda_2 > \cdots> \lambda_r > 0 = \lambda_{r+1} = \cdots =\lambda_n\)</span>为<span class="math inline">\(AA^\top\)</span>的n个非负特征根。</p><p>令<span class="math inline">\(\Sigma_1 =\operatorname{diag}(\sigma_1, \sigma_2, \dots, \sigma_r) =\operatorname{diag}(\sqrt{\lambda_1}, \sqrt{\lambda_2}, \dots,\sqrt{\lambda_r}), \quad V_1 = [\mathbf{v}_1, \mathbf{v}_2, \dots,\mathbf{v}_r], \quad V_2 = [\mathbf{v}_{r+1}, \mathbf{v}_{r+2}, \dots,\mathbf{v}_n],V=[V_1,V_2]\)</span>，所以根据<span class="math inline">\(V\)</span>定义，两个式子左边乘以<span class="math inline">\(V\)</span>，得到</p><p><span class="math display">\[A^\top A V=V\Sigma_1\]</span></p><p>取其中的r个列向量，有</p><p><span class="math display">\[A^\top A V_1=V_1\Sigma_1\]</span></p><p>进一步，我们可以得到</p><p><span class="math display">\[\Sigma_1^{-1} V_1^\top A^\top A V_1 \Sigma_1^{-1} = I\]</span></p><p>令 <span class="math inline">\(U_1 = A V_1\Sigma_1^{-1}\)</span>，则有 <span class="math inline">\(U_1^\top U_1 =I\)</span>。此时，我们可以选择 <span class="math inline">\(m -r\)</span> 组标准正交向量与 <span class="math inline">\(U_1\)</span>的列向量组成一组标准正交基，也即 <span class="math inline">\([U_1,U_2]\)</span> 是一个 <span class="math inline">\(m \times m\)</span>阶正交矩阵，且 <span class="math inline">\(U_1^\top U_2 =0\)</span>。</p><p>另一方面，容易得到：</p><p><span class="math display">\[A^\top A V_2 = V_2 0 \Rightarrow V_2^\top A^\top A V_2 = 0\]</span></p><p>根据矩阵性质<span class="math inline">\(A = 0 \Leftrightarrow A^\topA = 0\)</span>，我们可以得到<span class="math inline">\(AV_2=0\)</span>。</p><p><span class="math display">\[U^\top A V = \begin{bmatrix} U_1^\top A V_1 & U_1^\top A V_2 \\U_2^\top A V_1 & U_2^\top A V_2 \end{bmatrix}= \begin{bmatrix} \Sigma_1 & 0 \\ U_2^T U_1 \Sigma_1 & 0\end{bmatrix}= \begin{bmatrix} \Sigma_1 & 0 \\ 0 & 0 \end{bmatrix}= \Sigma\]</span></p><p>即，</p><p><span class="math display">\[U A V^\top=\Sigma\]</span></p><h2 id="几何理解">几何理解</h2><p>如果几何变换的方法为<span class="math inline">\(XA\)</span>，那么SVD将矩阵的线性变换拆解为三步：旋转（或方向调整）<span class="math inline">\(U\)</span>- 缩放 <span class="math inline">\(\Sigma\)</span> - 再旋转 <span class="math inline">\(V\)</span>，其中的缩放操作可以理解为，首先奇异值会对向量进行缩放：</p><ul><li>如果m<n，会额外增加一些为0的维度</li><li>如果m>n，会删去一些维度</li></ul><h2 id="应用">应用</h2><p>在机器学习的PCA中使用较多，作为特征工程降低数据维度的一个重要方法。</p><p>在一些信号领域也可以用于去噪或者图像领域的数据压缩。</p><h2 id="代码">代码</h2><p>Pytorch:</p><pre class="line-numbers language-python" data-language="python"><code class="language-python"><span class="token keyword">import</span> torch<span class="token comment"># 示例矩阵</span>A <span class="token operator">=</span> torch<span class="token punctuation">.</span>tensor<span class="token punctuation">(</span><span class="token punctuation">[</span><span class="token punctuation">[</span><span class="token number">1.0</span><span class="token punctuation">,</span> <span class="token number">2.0</span><span class="token punctuation">,</span> <span class="token number">3.0</span><span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token punctuation">[</span><span class="token number">4.0</span><span class="token punctuation">,</span> <span class="token number">5.0</span><span class="token punctuation">,</span> <span class="token number">6.0</span><span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token punctuation">[</span><span class="token number">7.0</span><span class="token punctuation">,</span> <span class="token number">8.0</span><span class="token punctuation">,</span> <span class="token number">9.0</span><span class="token punctuation">]</span><span class="token punctuation">]</span><span class="token punctuation">)</span><span class="token comment"># 计算 SVD</span>U<span class="token punctuation">,</span> S<span class="token punctuation">,</span> V <span class="token operator">=</span> torch<span class="token punctuation">.</span>svd<span class="token punctuation">(</span>A<span class="token punctuation">)</span><span class="token keyword">print</span><span class="token punctuation">(</span><span class="token string">"U:"</span><span class="token punctuation">,</span> U<span class="token punctuation">)</span><span class="token keyword">print</span><span class="token punctuation">(</span><span class="token string">"S:"</span><span class="token punctuation">,</span> S<span class="token punctuation">)</span> <span class="token comment"># 奇异值向量</span><span class="token keyword">print</span><span class="token punctuation">(</span><span class="token string">"V:"</span><span class="token punctuation">,</span> V<span class="token punctuation">)</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><p>numpy：</p><pre class="line-numbers language-python" data-language="python"><code class="language-python"><span class="token keyword">import</span> numpy <span class="token keyword">as</span> np<span class="token comment"># 示例矩阵</span>A <span class="token operator">=</span> np<span class="token punctuation">.</span>array<span class="token punctuation">(</span><span class="token punctuation">[</span><span class="token punctuation">[</span><span class="token number">1</span><span class="token punctuation">,</span> <span class="token number">2</span><span class="token punctuation">,</span> <span class="token number">3</span><span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token punctuation">[</span><span class="token number">4</span><span class="token punctuation">,</span> <span class="token number">5</span><span class="token punctuation">,</span> <span class="token number">6</span><span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token punctuation">[</span><span class="token number">7</span><span class="token punctuation">,</span> <span class="token number">8</span><span class="token punctuation">,</span> <span class="token number">9</span><span class="token punctuation">]</span><span class="token punctuation">]</span><span class="token punctuation">)</span><span class="token comment"># 计算 SVD</span>U<span class="token punctuation">,</span> sigma<span class="token punctuation">,</span> VT <span class="token operator">=</span> np<span class="token punctuation">.</span>linalg<span class="token punctuation">.</span>svd<span class="token punctuation">(</span>A<span class="token punctuation">)</span><span class="token keyword">print</span><span class="token punctuation">(</span><span class="token string">"U:"</span><span class="token punctuation">,</span> U<span class="token punctuation">)</span><span class="token keyword">print</span><span class="token punctuation">(</span><span class="token string">"Sigma:"</span><span class="token punctuation">,</span> sigma<span class="token punctuation">)</span><span class="token keyword">print</span><span class="token punctuation">(</span><span class="token string">"V^T:"</span><span class="token punctuation">,</span> VT<span class="token punctuation">)</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><p>scikit-learn:</p><pre class="line-numbers language-python" data-language="python"><code class="language-python"><span class="token keyword">from</span> sklearn<span class="token punctuation">.</span>decomposition <span class="token keyword">import</span> TruncatedSVD<span class="token keyword">import</span> numpy <span class="token keyword">as</span> np<span class="token comment"># 示例矩阵</span>A <span class="token operator">=</span> np<span class="token punctuation">.</span>array<span class="token punctuation">(</span><span class="token punctuation">[</span><span class="token punctuation">[</span><span class="token number">1</span><span class="token punctuation">,</span> <span class="token number">2</span><span class="token punctuation">,</span> <span class="token number">3</span><span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token punctuation">[</span><span class="token number">4</span><span class="token punctuation">,</span> <span class="token number">5</span><span class="token punctuation">,</span> <span class="token number">6</span><span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token punctuation">[</span><span class="token number">7</span><span class="token punctuation">,</span> <span class="token number">8</span><span class="token punctuation">,</span> <span class="token number">9</span><span class="token punctuation">]</span><span class="token punctuation">]</span><span class="token punctuation">)</span><span class="token comment"># 实例化 TruncatedSVD，指定保留的奇异值数量</span>svd <span class="token operator">=</span> TruncatedSVD<span class="token punctuation">(</span>n_components<span class="token operator">=</span><span class="token number">2</span><span class="token punctuation">)</span>A_reduced <span class="token operator">=</span> svd<span class="token punctuation">.</span>fit_transform<span class="token punctuation">(</span>A<span class="token punctuation">)</span><span class="token keyword">print</span><span class="token punctuation">(</span><span class="token string">"Reduced Matrix (A_reduced):"</span><span class="token punctuation">)</span><span class="token keyword">print</span><span class="token punctuation">(</span>A_reduced<span class="token punctuation">)</span><span class="token keyword">print</span><span class="token punctuation">(</span><span class="token string">"Explained Variance Ratio:"</span><span class="token punctuation">,</span> svd<span class="token punctuation">.</span>explained_variance_ratio_<span class="token punctuation">)</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href="https://blog.csdn.net/THUChina/article/details/102576718">奇异值分解（SVD）推导证明与应用_简述奇异值分解定理,并进行推导与证明(公式以及矩阵可以写在纸上照下来)-CSDN博客</a></li></ul></blockquote>]]></content>
<categories>
<category> 数学 </category>
<category> 线性代数 </category>
</categories>
<tags>
<tag> 矩阵 </tag>
<tag> SVD </tag>
</tags>
</entry>
<entry>
<title>梯度估计STE</title>
<link href="//13277/"/>
<url>//13277/</url>
<content type="html"><![CDATA[<h2 id="背景">背景</h2><p>反向传播是现在训练模型的重要方法，但是在部分场景下，会遇到不可微分的函数，从而导致梯度传播失败。比如量化里的取整函数。因此，需要对梯度进行估计然后反向传播。</p><p><strong>STE(Straight-Through Estimator)</strong>是2013年YoshuaBengio等人针对梯度估计进行了研究，那篇论文提出了几种梯度估计的方法，并推导出了一些理论性质，然后通过实验证明，STE是效果最好的方法。</p><blockquote><p>由于那篇论文很多篇幅在介绍较为复杂的估计方法，且理论推导也极为复杂，效果没有简洁的STE好，因此不对其进行详细介绍。</p></blockquote><h2 id="应用">应用</h2><h3 id="恒等函数">恒等函数</h3><p>STE在反向传播理论推导的时候，把不可微的原子函数（比如量化函数里有放缩和取整两部分，其中取整是不可微的原子函数）替换为恒等函数。</p><p>这种应用可以大大减少理论推导的难度，但是在代码里应用反向传播的时候不太方便，以pytorch框架为例，可能需要自己手写函数类<code>torch.autograd.Function</code>，具体文档可以查看：<a href="https://pytorch.org/tutorials/beginner/examples_autograd/two_layer_net_custom_function.html">PyTorch:Defining New autograd Functions — PyTorch Tutorials 2.5.0+cu124documentation</a> 。</p><h3 id="sg函数">SG函数</h3><p>苏神在他的博客（<a href="https://spaces.ac.cn/archives/6760">VQ-VAE的简明介绍：量子化自编码器- 科学空间|Scientific Spaces</a>）中提出了一个函数<code>sg(stop gradient)</code>，代表梯度反向传播终止的恒等函数。</p><p>所以原来的不可微的原子函数可以写为<span class="math inline">\(f(x)=x+sg(x'-x)\)</span>，在前向传播的时候和x'相同，在反向传播的时候梯度等于直接对<code>x</code>反向传播梯度。</p><p>这个式子也能用于理论推导，但是不如视为恒等函数麻烦，但是在代码方面容易完成，可以使用pytorch的默认反向传播函数，不需要自定义<code>torch.autograd.Function</code>（当然自定义也可以完成任务）。</p><p><a href="https://github.com/kyegomez/BitNet/blob/main/bitnet/bitlinear.py">BitNet/bitnet/bitlinear.pyat main · kyegomez/BitNet</a> 代码示例：</p><pre class="line-numbers language-python" data-language="python"><code class="language-python"><span class="token comment"># w_quant 是 w 量化（不可微）后的值</span><span class="token comment"># STE using detach</span>w_quant <span class="token operator">=</span> w <span class="token operator">+</span> <span class="token punctuation">(</span>weight_quant<span class="token punctuation">(</span>w<span class="token punctuation">)</span> <span class="token operator">-</span> w<span class="token punctuation">)</span><span class="token punctuation">.</span>detach<span class="token punctuation">(</span><span class="token punctuation">)</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span></span></code></pre><p>这里也给出 <code>torch.autograd.Function</code>的一个示例(<a href="https://github.com/xuyuzhuang11/OneBit/blob/main/transformers/src/transformers/models/bitnet.py">OneBit/transformers/src/transformers/models/bitnet.pyat main · xuyuzhuang11/OneBit</a>)：</p><pre class="line-numbers language-python" data-language="python"><code class="language-python"><span class="token keyword">class</span> <span class="token class-name">SignSTEFunc</span><span class="token punctuation">(</span>torch<span class="token punctuation">.</span>autograd<span class="token punctuation">.</span>Function<span class="token punctuation">)</span><span class="token punctuation">:</span> <span class="token decorator annotation punctuation">@staticmethod</span> <span class="token keyword">def</span> <span class="token function">forward</span><span class="token punctuation">(</span>ctx<span class="token punctuation">,</span> <span class="token builtin">input</span><span class="token punctuation">)</span><span class="token punctuation">:</span> ctx<span class="token punctuation">.</span>save_for_backward<span class="token punctuation">(</span><span class="token builtin">input</span><span class="token punctuation">)</span> <span class="token keyword">return</span> torch<span class="token punctuation">.</span>sign<span class="token punctuation">(</span><span class="token builtin">input</span><span class="token punctuation">)</span> <span class="token decorator annotation punctuation">@staticmethod</span> <span class="token keyword">def</span> <span class="token function">backward</span><span class="token punctuation">(</span>ctx<span class="token punctuation">,</span> grad_output<span class="token punctuation">)</span><span class="token punctuation">:</span> <span class="token builtin">input</span><span class="token punctuation">,</span> <span class="token operator">=</span> ctx<span class="token punctuation">.</span>saved_tensors <span class="token keyword">return</span> grad_output <span class="token operator">*</span> <span class="token punctuation">(</span><span class="token number">1.001</span> <span class="token operator">-</span> torch<span class="token punctuation">.</span>tanh<span class="token punctuation">(</span><span class="token builtin">input</span><span class="token punctuation">)</span> <span class="token operator">**</span> <span class="token number">2</span><span class="token punctuation">)</span> <span class="token comment"># return grad_output * (1.01 - torch.tanh(input) ** 2)</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href="https://arxiv.org/abs/1308.3432">[1308.3432] Estimating orPropagating Gradients Through Stochastic Neurons for ConditionalComputation</a></li><li><a href="https://pytorch.org/tutorials/beginner/examples_autograd/two_layer_net_custom_function.html">PyTorch:Defining New autograd Functions — PyTorch Tutorials 2.5.0+cu124documentation</a></li><li><a href="https://spaces.ac.cn/archives/6760">VQ-VAE的简明介绍：量子化自编码器- 科学空间|Scientific Spaces</a></li><li><a href="https://github.com/kyegomez/BitNet">kyegomez/BitNet:Implementation of "BitNet: Scaling 1-bit Transformers for Large LanguageModels" in pytorch</a></li><li><a href="https://github.com/xuyuzhuang11/OneBit/blob/main/transformers/src/transformers/models/bitnet.py">OneBit/transformers/src/transformers/models/bitnet.pyat main · xuyuzhuang11/OneBit</a></li></ul></blockquote>]]></content>
<categories>
<category> 深度学习 </category>
<category> 经典模块 </category>
</categories>
<tags>
<tag> 深度学习 </tag>
<tag> 梯度估计 </tag>
</tags>
</entry>
<entry>
<title>Welcome to bg51717's Wiki and Blog</title>
<link href="//14261/"/>
<url>//14261/</url>
<content type="html"><![CDATA[<p>这是bg51717的个人Wiki和Blog站点，主要是把知识系统的罗列出来以及存放一些特殊bug的处理，当然也会更一些游戏或者二次元相关东西，也希望在成长的过程中可以认识许多志同道合的人。</p><p>本人一直认为互联网的开源是社会发展的重要原因之一，因为开源使得技术知识和解决问题的经验可以被记录和传承下去，很多时候在需要的时候可以被人们所发掘。</p><p>也希望可以通过博客让自己的<strong>思维有条理</strong>。很多时候我喜欢观察别人的思路，发现其实人与人的很多思路差距可能没有那么多。除开经验上的差别，很多人能成功的做成一件事很多原因是思维非常有条理，时时刻刻明白自己的应该做什么，下一步思路是什么。不会让自己的思维局限在某个步骤或者门槛上。从而即使在逆境中，也能实现把烂牌打出最好的效果。</p><p>在偶尔反思自己的不足的时候，深刻的发现<strong>拖延症是致命的</strong>，很多事情只要按照条理有计划的进行，结果其实都可以完成。但是拖延容易导致事情出现计划外的变故，进而导致完成的质量。这对于个人的成长来说是极为不利的。很早以前就看到了<strong>知行合一</strong>这个词，但是一直没有理解其重要性。后来发现，缺少行动力也会导致很多计划的失败。很多事物是需要我们用心去做，而不是用敷衍的态度去进行。在实践中不断地提升自己，革新自己。</p><p>不知道此刻在阅读这个博客的你是在何时何地打开的，也不知道你是为了探究什么而点开了这个链接。但是祝你身体健康，万事如意。大家一起学习，互相交流，共同成长！</p><p>最后，附上我喜欢的一句话：</p><blockquote><p>世界靠现实主义者维系，靠理想主义者发展。</p></blockquote>]]></content>
</entry>
<entry>
<title>AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration</title>
<link href="//14592/"/>
<url>//14592/</url>
<content type="html"><![CDATA[<h2 id="介绍">介绍</h2><p>本篇博客介绍论文<a href="https://arxiv.org/abs/2306.00978">[2306.00978] AWQ:Activation-aware Weight Quantization for LLM Compression andAcceleration</a>提出的一种针对权重的训练后量化方法。该方法基于一个发现：<strong>模型的权重不是同等重要的，只保护1%的突出权重可以大大减少量化误差</strong>。但是混合精度会导致算法对硬件不友好，具体保护的方法是对模型的权重进行扩大，输入也进行对应的缩小。具体的比例根据激活通过网格搜索获得。由于没有进行反向传播，因此量化模型在与校准数据集不同分布的数据上也能表现良好。并最终实现了推理加速效果。</p><p>下图是PTQ大致流程图，和GPTQ算法一样，AWQ算法针对的主要是量化步骤中的参数调整部分：</p><p><img src="/14592/1730525025940.png"></p><h2 id="发现">发现</h2><p>首先介绍作者根据经验提出的假设：<strong>模型的权重不是同等重要的，只保护1%的突出权重可以大大减少量化误差</strong>。下图是示例：</p><p><img src="/14592/1730009795566.png"></p><p>从图里可以看出，在某一层layer的输入中，不同token的异常维度应该是集中在某几个维度中的。在LLM.int8中也有类似的结论，并且因此设计了llm.int8算法：</p><p><img src="/14592/1730258455859.png"></p><p>为了验证这个假设，作者进行了实验，尝试对少部分显著的权重保持原来精度，别的权重量化为int3，然后进行了多组测试。RTN是直接量化，不做调整，作为对比实验。作者分别尝试了使用权重的大小，激活的大小以及随机选择来确定哪些权重的显著的，结果发现根据激活选择的效果最好。</p><p><img src="/14592/1730010346827.png"></p><h2 id="方法">方法</h2><p>根据发现，只需要根据激活选择少部分权重保持为高精度即可实现优秀的量化算法，但是混合精度是硬件不友好的操作。因此，作者选择别的方法来保护这些权重：<strong>通过激活感知缩放来保护显着权重</strong>。</p><p>考虑权重 <span class="math inline">\(\mathbf{w}\)</span>，线性层操作可以记为<span class="math inline">\(y = \mathbf{w} \mathbf{x}\)</span>,对应的量化操作（包含反量化）为<span class="math inline">\(y =Q(\mathbf{w}) \mathbf{x}\)</span>，<span class="math inline">\(N\)</span>是量化的比特数，<span class="math inline">\(\Delta\)</span>是缩放因子，量化函数为:</p><p><span class="math display">\[Q(\mathbf{w}) = \Delta \cdot\text{Round}\left(\frac{\mathbf{w}}{\Delta}\right), \quad \Delta =\frac{\max(|\mathbf{w}|)}{2^{N-1}}\]</span></p><p>考虑针对权重中的一个向量 $w $ 乘以 $s > 1 $ ，然后按同等比例缩小$x $, 我们有 $Q(w s)(x / s) $， 具体为:</p><p><span class="math display">\[Q(w \cdot s) \cdot \frac{x}{s} = \Delta' \cdot\text{Round}\left(\frac{w s}{\Delta}\right) \cdot x \cdot \frac{1}{s}\]</span></p><p><span class="math inline">\(\Delta'\)</span>是新的缩放因子。</p><p>这里解释一下为什么放缩针对是一行（这里假设乘号左边是X，右边是W）：</p><p><img src="/14592/1731230615706.png"></p><p>然后量化的时候，以列或者行作为量化函数的基本单位：</p><p><img src="/14592/1730272140732.png"></p><p>作者根据经验判断：</p><ul><li>量化为整数（Round函数）的时候，误差在0~0.5之间均匀分布，因此，平均误差为0.25。因此在对权重放大后，相对误差会减小，比如之前值是1，相对误差为0.25，1放大2倍后，相对误差只有0.125。</li><li>对部分<span class="math inline">\(w\)</span>进行放缩对量化时分组里的极值改变较少，因此<span class="math inline">\(\Delta' \approx \Delta\)</span></li><li>第二点的误差可以表示为<span class="math inline">\(\text{Err}' =\Delta' \cdot \text{RoundErr} \cdot\frac{1}{s}\)</span>，与原始误差的比例为<span class="math inline">\(\frac{\Delta'}{\Delta} \cdot\frac{1}{s}\)</span>。如果<span class="math inline">\(\Delta'\approx \Delta,s>1\)</span>，那么就会降低误差</li></ul><p>然后作者选择了一部分参数进行了验证：</p><p><img src="/14592/1730011375988.png"></p><p>根据结果发现，在s=2的时候PPL达到了最小。在s不超过2的时候，基本符合根据经验得到的结论。</p><p>对于AWQ算法中的<span class="math inline">\(s\)</span>，作者认为这是一个最优化问题：</p><p><span class="math display">\[\mathbf{s}^* = \arg \min_{\mathbf{s}} \, \mathcal{L}(\mathbf{s}), \quad\mathcal{L}(\mathbf{s}) = \left\| Q(\mathbf{W} \cdot \mathbf{s})\left(\mathbf{s}^{-1} \cdot \mathbf{X}\right) - \mathbf{W} \mathbf{X}\right\|\]</span></p><p>由于量化函数不可微分，别的近似方法存在收敛不稳定的情况，作者最终根据激活使用网格搜索获得：</p><p><span class="math display">\[\mathbf{s} = \mathbf{s}_{\mathbf{X}}^{\alpha}, \quad \alpha^* = \arg\min_{\alpha} \mathcal{L}(\mathbf{s}_{\mathbf{X}}^{\alpha})\]</span></p><p><span class="math inline">\(\mathbf{s}_{\mathbf{X}}\)</span>和输入<span class="math inline">\(\mathbf{X}\)</span>有关，<span class="math inline">\(\alpha\)</span>搜索的范围在[0,1]之间。</p><p>作者通过实验验证了搜索的有效性：</p><p>此外，作者还进行了以下优化：</p><ul><li>对扩大化的权重进行裁剪</li><li>把对输入的缩小和前一个算子融合（比如，以前一个算子是矩阵乘法作为例子：前一个矩阵权重权重缩小<span class="math inline">\(s\)</span>，对前一个算子来说，扩大比例和缩小的比例大小不一样，并且可能方向也不一样，比如一个是列方向，另一个是行方向，因此不会完全抵消</li></ul><h2 id="实验">实验</h2><p>作者首先在LlaMa家族模型中进行了实验，比较在WikiText-2上的困惑度，发现AWQ的效果比GPTQ要好一点。</p><p><img src="/14592/1730012063950.png"></p><p>然后作者选取了80个样本问题，把量化前后模型的回答连接起来，让GPT-4打分判断哪个更好（交换次序后再重复一次）。结果也比之前的方法好。</p><p><img src="/14592/1730012673547.png"></p><p>作者还测试了在多模态大模型上表现：</p><p><img src="/14592/1730012744431.png"></p><p>还测试了在2比特量化下的表现，作者还提出AWQ和GPTQ是可以一起使用的：</p><p><img src="/14592/1730013136175.png"></p><p>然后作者罗列了一下推理加速的效果，可以看到每秒生成的token数目增长了很多：</p><p><img src="/14592/1730013299656.png"></p><p>作者认为，由于AWQ在使用校准数据进行量化的时候没有进行反向传播，因此可以过拟合校准集合：</p><p><img src="/14592/1730013388948.png"></p><h2 id="代码">代码</h2><p>论文源码：<a href="https://github.com/mit-han-lab/llm-awq">mit-han-lab/llm-awq:[MLSys 2024 Best Paper Award] AWQ: Activation-aware Weight Quantizationfor LLM Compression and Acceleration</a></p><p>算法工具包：<a href="https://github.com/AutoGPTQ/AutoGPTQ">AutoGPTQ/AutoGPTQ: Aneasy-to-use LLMs quantization package with user-friendly apis, based onGPTQ algorithm.</a></p><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href="https://arxiv.org/abs/2306.00978">[2306.00978] AWQ:Activation-aware Weight Quantization for LLM Compression andAcceleration</a></li><li><a href="https://github.com/mit-han-lab/llm-awq">mit-han-lab/llm-awq:[MLSys 2024 Best Paper Award] AWQ: Activation-aware Weight Quantizationfor LLM Compression and Acceleration</a></li></ul></blockquote>]]></content>
<categories>
<category> 科研 </category>
<category> 论文阅读 </category>
</categories>
<tags>
<tag> 深度学习 </tag>
<tag> 量化 </tag>
</tags>
</entry>
<entry>
<title>拉格朗日乘数法解条件极值</title>
<link href="//49444/"/>
<url>//49444/</url>
<content type="html"><![CDATA[<h2 id="介绍">介绍</h2><p>求解最优化是一类十分常见且难以求解的问题，因此，考虑开一个博客系统性的介绍一下重要解法：拉格朗日乘数法（LagrangeMultiplier Method）。之后再扩展到广义的拉格朗日乘数法。</p><p>拉格朗日乘数法的重点是<strong>在一些列约束条件下，构造包含隐藏条件的拉格朗日函数等同于优化的目标函数。</strong></p><blockquote><p>隐藏条件指的是在限制条件和拉格朗日函数共同作用下实际暗含的一些条件或方程。</p></blockquote><p>最优化问题通常是指对于给定的某一函数，<strong>求其在指定作用域上的全局最小值(因为最小值与最大值可以很容易转化，即最大值问题可以转化成最小值问题)</strong>。</p><h2 id="无约束条件">无约束条件</h2><p>对所有变量求偏导计算极值点后，把极值点代回原函数验证即可。</p><h2 id="等式约束条件">等式约束条件</h2><p>求一个函数在等式约束下的最值，即</p><p><span class="math display">\[\begin{aligned} \min & \quad f(\mathbf{x}) \\ \text{s.t.} & \quad h_j(\mathbf{x}) = 0, \quad j = 1, 2, \dots,l\end{aligned}\]</span></p><p>定义拉格朗日函数<span class="math inline">\(F(x)\)</span>，其中<span class="math inline">\(\lambda_k\)</span>为引入的变量：</p><p><span class="math display">\[F(\mathbf{x}, \lambda) = f(\mathbf{x}) + \sum_{j=1}^{l} \lambda_jh_j(\mathbf{x})\]</span></p><p>求解极值点只需求解方程组：</p><p><span class="math display">\[\frac{\partial F}{\partial x_i} = 0 \\\frac{\partial F}{\partial \lambda_j} = 0\]</span></p><p>下面关于不等式约束下的最优值求解给了通用的证明过程，不过，维基百科列出了一个形象的解释：</p><p>考虑有个优化问题：</p><p><span class="math display">\[\begin{aligned} \min & \quad f(x, y) \\ \text{s.t.} & \quad g(x, y) = c\end{aligned}\]</span></p><p><img src="/49444/1729772448154.png"></p><p>图上画的是两个函数的等高线，箭头表示梯度方向（暂时不考虑梯度正负）。绿色的线是约束条件，代表需要在绿色的线上寻找最优点。最优点显然在两个函数相切的地方，即两个函数梯度共线，<span class="math inline">\(\nabla f(x, y) = \lambda \left( \nabla g(x, y) - C\right)\)</span>（<span class="math inline">\(\nabla\)</span>代表梯度算子，<span class="math inline">\(\lambda\)</span>是非0实数），这就是等式约束下拉格朗日乘数法的<strong>隐藏条件</strong>。</p><p>从反证法考虑，假如两个梯度不共线，那么沿着约束函数的切向，即与约束函数梯度垂直的方向，一定可以找到一个向量，与约束函数梯度垂直且在目标函数梯度上有分量。那么沿着该向量方向修改变量，可以在约束函数值不变的条件下继续优化目标函数。</p><h2 id="不等式条件约束">不等式条件约束</h2><p>添加上不等式约束条件，就得到了广义拉格朗日问题，此时的最优化问题为，</p><p><span class="math display">\[\begin{aligned} \min & \quad f(\mathbf{\mathbf{x}}) \\ \text{s.t.} & \quad h_j(\mathbf{\mathbf{x}}) = 0, \quad j = 1,2, \dots, p \\ & \quad g_k(\mathbf{\mathbf{x}}) \leq 0, \quad k =1, 2, \dots, q\end{aligned}\]</span></p><p>对应的拉格朗日函数L为，</p><p><span class="math display">\[L(\mathbf{x}, \lambda, \mu) = f(\mathbf{x}) + \sum_{j=1}^{p} \lambda_jh_j(\mathbf{x}) + \sum_{k=1}^{q} \mu_k g_k(\mathbf{x})\]</span></p><p>常用的方法是KKT条件，即最优值必须满足：</p><p><span class="math display">\[\begin{aligned} \frac{\partial F}{\partial x_i} = 0 \quad &(1)\\ \frac{\partial F}{\partial \lambda_j} = 0 \quad &(2)\\ \lambda_j \neq 0 \quad &(3)\\ \mu_k g_k(\mathbf{x}) = 0 \quad &(4)\\ g_k(\mathbf{x}) \leq 0 \quad &(5)\\ \mu_k \geq 0 \quad &(6)\end{aligned}\]</span></p><p>其中前三个式子是等式条件约束里的，后三个式子是不等式条件引入的。</p><h2 id="kkt推导">KKT推导</h2><blockquote><p><span class="math inline">\(\max_\mu L(x,\mu)\)</span>代表调整<span class="math inline">\(\mu\)</span>最大化目标函数<span class="math inline">\(L(x,\mu)\)</span>。</p></blockquote><p>首先，令（这里的几个变量都是多元变量，即向量，为了书写方便，没有引入<code>\mathbf</code>）</p><p><span class="math display">\[\ L(x, \lambda, \mu) = f(x) + \sum_{k=1}^{q} \mu_k g_k(x)\]</span></p><p>引入约束条件，</p><p><span class="math display">\[\because\begin{cases} \mu_k \geq 0 \\ g_k(x) \leq 0\end{cases} \\\\\therefore \mu_k g_k(x) \leq 0 \\\therefore 根据非负得\ \max_\mu L(x,\mu)=f(x) \\\therefore \min_ x f(x) = \min_x \max_ \mu L(x,\mu)\]</span></p><p>所以我们发现调整<span class="math inline">\(\mu\)</span>最大化<span class="math inline">\(L\)</span>就等于<span class="math inline">\(f(x)\)</span>，所以</p><p><span class="math display">\[\min_ x f(x) = \min_x \max_ \mu L(x,\mu)\]</span></p><p>另一方面，</p><p><span class="math display">\[\max_\mu \min_x L(x, \mu) = \max_\mu \left[ \min_x f(x) + \min_x \mug(x) \right]= \max_\mu \min_x f(x) + \max_\mu \min_x \mu g(x)= \min_x f(x) + \max_\mu \min_x \mu g(x) \\又\because \begin{aligned} \mu_k \geq 0, \quad g_k(x) \leq 0 \quad &\Rightarrow \quad\min_x \mu g(x) = \begin{cases} 0, & \text{if } \mu = 0 \text{ or } g(x) = 0 \\ -\infty, & \text{if } \mu > 0 \text{ and } g(x) < 0 \end{cases}\end{aligned}\]</span></p><p>所以，引入约束条件<span class="math inline">\(\mug(X)=0\)</span>，我们得到，</p><p><span class="math display">\[\max_\mu \min_x \mu g(x) = 0 \\\therefore \max_\mu \min_x L(x, \mu) = \min_x f(x) + \max_\mu \min_x \mug(x) = \min_x f(x)\]</span></p><p>综上所述，</p><p><span class="math display">\[\begin{aligned}\begin{rcases}L(x, \lambda, \mu) &= f(x) + \sum_{k=1}^{q} \mu_k g_k(x) \\\mu_k &\geq 0 \\g_k(x) &\leq 0 \\\mu g(X)&=0\end{rcases} \end{aligned}\Rightarrow\max_\mu \min_x L(x, \mu)= \min_x \max_ \mu L(x,\mu)=\min_ x f(x)\]</span></p><p>引入等式约束的条件，我们得到了，</p><p><span class="math display">\[\begin{aligned}\begin{rcases} \frac{\partial F}{\partial x_i} = 0\\ \frac{\partial F}{\partial \lambda_j} = 0\\ \lambda_j \neq 0\\ \mu_k g_k(\mathbf{x}) = 0\\ g_k(\mathbf{x}) \leq 0\\ \mu_k \geq 0\end{rcases} \end{aligned}\Rightarrow\max_\mu \min_x L(x, \mu)= \min_x \max_ \mu L(x,\mu)=\min_ x f(x)\]</span></p><p>所以我们完成了我们需要证明的：<strong>在一些列约束条件下，拉格朗日函数等同于优化的目标函数。</strong></p><p>补充KTT下的隐藏条件：</p><p><span class="math display">\[\frac{\partial L(x, \lambda, \mu)}{\partial x} \Bigg|_{x = x^*} = 0\quad \text{表明} \quad f(x) \text{在极值点} x^* \text{处的梯度是含有}h_j(x^*) \text{和} g_k(x^*) \text{梯度的线性组合。}\]</span></p><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href="https://zh.wikipedia.org/zh-cn/%E6%8B%89%E6%A0%BC%E6%9C%97%E6%97%A5%E4%B9%98%E6%95%B0">拉格朗日乘数- 维基百科，自由的百科全书</a></li><li><a href="https://www.cnblogs.com/mo-wang/p/4775548.html">【整理】深入理解拉格朗日乘子法（LagrangeMultiplier) 和KKT条件 - mo_wang - 博客园</a></li><li><a href="https://blog.csdn.net/johnnyconstantine/article/details/46335763">KKT条件介绍-CSDN博客</a></li></ul></blockquote>]]></content>
<categories>
<category> 数学 </category>
<category> 微积分 </category>
</categories>
<tags>
<tag> 数学 </tag>
</tags>
</entry>
<entry>
<title>大模型量化~GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers</title>
<link href="//31769/"/>
<url>//31769/</url>
<content type="html"><![CDATA[<h2 id="介绍">介绍</h2><p>GPTQ算法的原理从数学公式出发，推导出权重的量化顺序和其余参数的调整值，然后根据这些值对block里的所有参数以列为单位进行量化，每次量化可以量化多个列，同时调整其余未量化的列的参数减小量化误差。</p><p>GPTQ算法是只针对权重的量化方式。在计算的时候，对应的内核会把需要计算的权重还原回原来的数据类型（比如int4->fp16）从而保证计算的稳定。</p><p>下图是PTQ大致流程图，GPTQ算法针对的主要是量化步骤中的参数调整部分：、</p><p><img src="/31769/1730268555276.png"></p><p>GPTQ量化算法最早来自1990年YannLeCun的OBD算法，然后按照OBS，OBC（OBQ）的顺序进行演化，最终到GPTQ算法。当然，这里的演化算法不都是量化算法，由于量化和剪枝是很像的两个技术，量化调整参数为距离最近的整数，剪枝调整参数为0，所以量化算法和剪枝算法有很多共同点。</p><h2 id="obdoptimal-brain-damage">OBD：Optimal Brain Damage</h2><p>OBD是一种剪枝方法，考虑目标函数为<span class="math inline">\(E\)</span>，模型参数为<span class="math inline">\(w_i\)</span>，对目标函数进行泰勒展开，有</p><p><span class="math display">\[\Delta E = \sum_i g_i \Delta w_i + \frac{1}{2} \sum_i h_{ii} \Deltaw_i^2 + \frac{1}{2} \sum_{i \neq j} h_{ij} \Delta w_i \Delta w_j +O(\Delta w^3)\]</span></p><p>其中<span class="math inline">\(g_i = \frac{\partial E}{\partialw_i}\)</span>是一阶偏导，<span class="math inline">\(h_{ij} =\frac{\partial^2 E}{\partial w_i \partialw_j}\)</span>是海森矩阵元素。</p><p>OBD假设：</p><ul><li>目标函数为二阶，不考虑高阶项<span class="math inline">\(O(\Deltaw^3)\)</span></li><li>模型训练充分收敛，一阶偏导为0，<span class="math inline">\(g_i=0,\forall i\)</span></li><li>每个参数对目标函数影响是独立的，海森矩阵中的交叉项为0，即<span class="math inline">\(h_{ij} = 0, \forall i, j, i \neq j\)</span></li></ul><p>于是，上式可以优化为，</p><p><span class="math display">\[\Delta E = \frac{1}{2} \sum_i h_{ii} \Delta w_i^2\]</span></p><p>因此，OBD算法只需要根据每个参数对目标的影响从小到大进行排序，然后进行剪枝即可。</p><h2 id="obsoptimal-brain-surgeon">OBS：Optimal Brain Surgeon</h2><p><img src="/31769/1729833758876.png"></p><p>OBS算法认为参数之间的独立性不成立，因此交叉项需要考虑，因此上式变为，</p><p><span class="math display">\[\Delta E = \frac{1}{2} \sum_i h_{ii} \Delta w_i^2 + \frac{1}{2} \sum_{i\neq j} h_{ij} \Delta w_i \Delta w_j\]</span></p><p>向量，矩阵形式为，</p><p><span class="math display">\[\Delta E = \frac{1}{2} \Delta \mathbf{w}^\mathrm{T} \mathbf{H} \Delta\mathbf{w}\]</span></p><p>剪枝删除一个权重，那么<span class="math inline">\(\Delta\mathbf{w}\)</span>的第 q 维固定为 <span class="math inline">\(-w_q\)</span>，但其他维度的值不固定，可以用于减少删除该权重带来的目标偏离。即约束条件为，</p><p><span class="math display">\[\mathbf{e}_q^\mathrm{T} \cdot \Delta \mathbf{w} + w_q = 0\]</span></p><p>其中，<span class="math inline">\(\mathbf{e}_q\)</span>是one-hot向量，第q个位置是1，其余位置为0。</p><p>所以剪枝转化为最优化问题，</p><p><span class="math display">\[\min_{\Delta \mathbf{w}, q} \frac{1}{2} \Delta \mathbf{w}^\mathrm{T}\mathbf{H} \Delta \mathbf{w} \quad \text{s.t.} \quad\mathbf{e}_q^\mathrm{T} \cdot \Delta \mathbf{w} + w_q = 0\]</span></p><p>构造拉格朗日函数，</p><p><span class="math display">\[L = \frac{1}{2} \Delta \mathbf{w}^\mathrm{T} \mathbf{H} \Delta\mathbf{w} + \lambda (\mathbf{e}_q^\mathrm{T} \cdot \Delta \mathbf{w} +w_q)\]</span></p><p>求解，得</p><p><span class="math display">\[\Delta \mathbf{w} = -\frac{w_q}{[\mathbf{H}^{-1}]_{qq}} \mathbf{H}^{-1}\cdot \mathbf{e}_q \quad \text{and} \quad L = \frac{1}{2}\frac{w_q^2}{[\mathbf{H}^{-1}]_{qq}}\]</span></p><p>因此，我们可以根据海森矩阵求得下一个剪枝的参数和其他参数调整的值。</p><blockquote><p>每次更新参数都需要重新求解海森矩阵，原论文中提到了数学上的优化方法，但是较为复杂且在后续算法没有使用，此处不予列出。</p></blockquote><h2 id="obc">OBC</h2><p>由于需要求解全参数的海森矩阵甚至逆矩阵，复杂度极高，在参数规模上去后求解是不现实的。</p><p>因此假设：</p><ul><li>在一个矩阵中只有同一行的参数是相关的</li></ul><p>同时，为了更好的求解，对于一个维度为<span class="math inline">\((d_{row},d_{col})\)</span>参数矩阵设置一个优化的目标函数，<span class="math inline">\(\mathbf{W}_{i,\cdot},\hat{\mathbf{W_{i,\cdot}}}\)</span>分别是参数调整前后的权重向量</p><p><span class="math display">\[E = \sum_{i=1}^{d_{\text{row}}} \| \mathbf{W}_{i,\cdot} \mathbf{X} -\hat{\mathbf{W}}_{i,\cdot} \mathbf{X} \|_2^2\]</span></p><p>求每行的海森矩阵，</p><p><span class="math display">\[\frac{\partial E}{\partial \hat{\mathbf{W}}_{i,\cdot}^2} = \mathbf{H}_i= 2 \mathbf{X} \mathbf{X}^\mathrm{T}, \quad \forall i = 1, 2, \dots,d_{\text{row}}\]</span></p><p>之后就可以求得矩阵每一行的剪枝顺序。</p><p>算法伪代码：</p><p><img src="/31769/1729836598356.png"></p><p>首先遍历每一行，然后重复k次，每次找到对目标函数影响最小的参数p，对p进行剪枝同时更新其他参数，删除海森矩阵的p行p列（不包括<span class="math inline">\(H_{pp}\)</span>），再求逆。（这里罗列的好像是降低复杂度后的数学等效。）</p><blockquote><p>OBC论文也罗列了一些别的性能上的优化，在后续算法没有使用，此处不予列出。</p><p>此处数学等效的方法是高斯消元，海森矩阵移除k行k列但包括<span class="math inline">\(H_{kk}\)</span>，因为左乘矩阵代表对行向量线性组合对，右乘矩阵代表对列向量线性组合，因此通过高斯消元即可实现对0的操作。证明可以从GPTQ的Cholesky证明中基本无条件的迁移。</p></blockquote><h2 id="obq">OBQ</h2><p>OBQ（和OBC是同一篇文章）指出，剪枝是一种特殊的量化（即剪枝的参数等价于量化到0 点），因此只需要修改一下 OBC 的约束条件即可：</p><p><span class="math display">\[\mathbf{e}_p^\mathrm{T} \cdot \Delta \mathbf{w} + w_p =\text{quant}(w_p)\]</span></p><p>相应的，权重的调整更新为，</p><p><span class="math display">\[\Delta \mathbf{w} = -\frac{w_p -\text{quant}(w_p)}{[\mathbf{H}^{-1}]_{pp}} \mathbf{H}^{-1} \cdot\mathbf{e}_p\quad \text{and} \quadL = \frac{1}{2} \frac{(w_p -\text{quant}(w_p))^2}{[\mathbf{H}^{-1}]_{pp}}\]</span></p><p>OBQ的算法伪代码，同OBC的很相似：</p><p><img src="/31769/1729837217525.png"></p><h2 id="gptq">GPTQ</h2><p>OBQ的算法复杂度还是太高了，GPTQ继续进行优化。</p><p>GPTQ是逐层量化的，同时做出以下假设：</p><ul><li>参数调整前量化网络（量化函数）是确定的，比如量化的缩放因子和零点等</li><li>权重参数可以在量化网格内进行调整</li></ul><h3 id="按索引顺序量化">按索引顺序量化</h3><p>将每一行的量化权重选择方式从贪心策略改成按索引顺序选择。</p><p>修改索引顺序的好处有两个，首先多个行的量化顺序是一样的，因此可以多行并行处理；第二个是<span class="math inline">\(\mathbf{H} = 2 \mathbf{X}\mathbf{X}^\mathrm{T}\)</span>说明，海森矩阵只与输入相关，因此不同行可以共用一个海森矩阵。<img src="/31769/1729841730501.png"></p><p>行里第p个权重调整公式可以为改为，</p><p><span class="math display">\[\Delta \mathbf{w} = -\frac{w_p -\text{quant}(w_p)}{[\mathbf{H}_{p:,p:}^{-1}]_{0,0}} \left([\mathbf{H}_{p:,p:}^{-1}]_{:,0} \right)^\top\]</span></p><p>加入多行并行后变为，</p><p><span class="math display">\[\Delta W_{:,p:} = -\frac{W_{:,p:} -\text{quant}(W_{:,p:})}{[\mathbf{H}_{p:,p:}^{-1}]_{0,0}} \left([\mathbf{H}_{p:,p:}^{-1}]_{:,0} \right)^\top=-\frac{\left( [\mathbf{H}_{p:,p:}^{-1}]_{:,0}\right)^\top}{[\mathbf{H}_{p:,p:}^{-1}]_{0,0}} ( W_{:,p:} -\text{quant}(W_{:,p:}))\]</span></p><p>逆矩阵的更新公式变为，</p><p><span class="math display">\[[H_{p:,p:}]^{-1} = \left( [H_{p-1:,p-1:}]^{-1} -\frac{1}{[H_{p-1:,p-1:}]^{-1}_{0,0}} [H_{p-1:,p-1:}]^{-1}_{:,0}[H_{p-1:,p-1:}]^{-1}_{0,:}\right)_{1:,1:}\]</span></p><h3 id="cholesky-分解">Cholesky 分解</h3><blockquote><p>关于Cholesky分解的数学介绍可以看：<a href="https://blog.csdn.net/xbinworld/article/details/104663481">三十分钟理解：矩阵Cholesky分解，及其在求解线性方程组、矩阵逆的应用_cholesky分解法求解线性方程组-CSDN博客</a></p></blockquote><p>实验过程中发现：在大规模参数矩阵上重复使用海森矩阵逆矩阵的更新公式会产生非正定的海森矩阵逆矩阵，原因可能是数值误差的积累。</p><p>作者对初始的<span class="math inline">\(H^{-1}\)</span>进行Cholesky分解，得到一个上三角矩阵<span class="math inline">\(T\)</span>，它的每一行刚好就等于使用更新公式得到的逆矩阵序列的第一行乘以一个常数，即，</p><p><span class="math display">\[C_p T_{p,p:} = \left[ H_{p:,p:} \right]^{-1}_{0,:}\]</span></p><p>图示，</p><p><img src="/31769/1729847766438.png"></p><p>所以，权重的调整更新为，</p><p><span class="math display">\[\Delta W_{:,p:} = - \frac{W_{:,p} - \text{quant}(W_{:,p})}{C_p T_{pp}}C_p T_{p,p:} = - \frac{W_{:,p} - \text{quant}(W_{:,p})}{T_{pp}} T_{p,p:}\]</span></p><p>发现很多资料都没有系统的罗列大致的推导过程，甚至论文基本也是一笔带过，因此考虑在此给出一些浅薄的证明（笔者不是数学系的。</p><p>首先介绍一下教程中的Cholesky分解：给定一个<span class="math inline">\(n\times n\)</span>的实数对称正定矩阵<span class="math inline">\(A\)</span>，存在一个对角元全为正数的下三角矩阵，是的<span class="math inline">\(A=LL^\top\)</span>成立。</p><p><span class="math display">\[\begin{align*}\mathbf{A} &= \begin{bmatrix} a_{11} & \mathbf{A}_{21}^T \\\mathbf{A}_{21} & \mathbf{A}_{22} \end{bmatrix}, \quad\mathbf{L} = \begin{bmatrix} l_{11} & 0 \\ L_{21} & L_{22}\end{bmatrix}, \quad\mathbf{L}^T = \begin{bmatrix} l_{11} & L_{21}^T \\ 0 & L_{22}^T\end{bmatrix}\end{align*}\]</span></p><p>其中 $a_{11} $ 和 $ l_{11} $是一个标量， <span class="math inline">\(\mathbf{A}_{21}\)</span> 和 <span class="math inline">\(L_{21}\)</span> 是一个列向量，$<em>{22} $是一个 (n-1 ) 阶的方阵，而 $ L</em>{22} $ 是一个 ( n-1 )阶的下三角矩阵。我们有，</p><p><span class="math display">\[\begin{align*}\begin{bmatrix} a_{11} & \mathbf{A}_{21}^T \\ \mathbf{A}_{21} &\mathbf{A}_{22} \end{bmatrix}&= \begin{bmatrix} l_{11} & 0 \\ L_{21} & L_{22}\end{bmatrix}\begin{bmatrix} l_{11} & L_{21}^T \\ 0 & L_{22}^T \end{bmatrix}&= \begin{bmatrix} l_{11}^2 & l_{11} L_{21}^T \\l_{11}L_{21} & L_{21} L_{21}^T + L_{22} L_{22}^T \end{bmatrix}\end{align*}\]</span></p><p>我们易得，</p><p><span class="math display">\[\begin{align*}l_{11} &= \sqrt{a_{11}} \\[10pt]L_{21} &= \frac{1}{l_{11}} \mathbf{A}_{21} \\[10pt]L_{22} L_{22}^T &= \mathbf{A}_{22} - L_{21} L_{21}^T\end{align*}\]</span></p><p>其中<span class="math inline">\(l_{11}\)</span>和<span class="math inline">\(L_{21}\)</span>我们直接得到，对于<span class="math inline">\(L_{22}\)</span>，我们发现又是一个Cholesky分解的过程，递归求解即可。</p><p>我们根据公式可以发现，</p><p><span class="math display">\[(\mathbf{L}^\top)_{1,:}=\begin{bmatrix} l_{11} & L^{\top}_{21} \end{bmatrix}= \frac{1}{\sqrt{a}} \begin{bmatrix} a_{11} & \mathbf{A}^{\top}_{21}\end{bmatrix}= \frac{1}{\sqrt{a}}\mathbf{A}_{1,:}\]</span></p><p>所以我们证明了两个矩阵第一列的比例关系，根据分解的递推性和矩阵的对称性，我们就完整证明了这个结论。</p><h2 id="海森逆矩阵更新公式证明">海森逆矩阵更新公式证明</h2><p>首先我们需要证明<strong>在海森矩阵删除p行p列参数（不包括<span class="math inline">\(H_{pp}\)</span>）的时候，在海森矩阵上会发生类似的操作。</strong></p><p>首先，我们需要知道<span class="math inline">\((H^{-1})^\top=(H^T)^{-1}=H^{-1}\)</span>，即海森矩阵的逆矩阵是对称矩阵。</p><p><span class="math display">\[\begin{align*}\mathbf{H}= \begin{bmatrix} a & \mathbf{z}^\top \\ \mathbf{z} &\mathbf{A} \end{bmatrix}, \quad构造矩阵\mathbf{B}=\begin{bmatrix} \frac{1}{a} & \mathbf{z}^\top \\\mathbf{z} & \mathbf{A}^{-1} \end{bmatrix}\end{align*}\]</span></p><p>其中，<span class="math inline">\(\mathbf{H}\)</span>和<span class="math inline">\(\mathbf{B}\)</span>是n维的对称正定方阵，a<span class="math inline">\(是标量，\)</span><span class="math inline">\(z\)</span>为n-1维的零向量，那么</p><p><span class="math display">\[\mathbf{H} \times \mathbf{B}=\begin{bmatrix} a & \mathbf{z}^\top \\ \mathbf{z} & \mathbf{A}\end{bmatrix} \times\begin{bmatrix} \frac{1}{a} & \mathbf{z}^\top \\ \mathbf{z} &\mathbf{A}^{-1} \end{bmatrix}=\begin{bmatrix} 1 & a\mathbf{z}^\top+\mathbf{z}^\top\mathbf{A}^{-1}\\ \frac{1}{a}\mathbf{z}+\mathbf{A}\mathbf{z} &\mathbf{z}\mathbf{z}^\top+\mathbf{A}\mathbf{A}^{-1} \end{bmatrix}=\begin{bmatrix} 1 & \mathbf{z}^\top \\ \mathbf{z} &I_{n-1\times n-1} \end{bmatrix}=I_{n\times n}\]</span></p><p>说明，说明<span class="math inline">\(\mathbf{B}\)</span>就是<span class="math inline">\(\mathbf{H}\)</span>的逆矩阵，因此，得证。我们就可以直接对海森矩阵的逆矩阵进行删除参数即可。</p><p>接下来，我们需要证明删除行参数和列参数的公式。为了方便，假设我们有个n维的对称正定方阵<span class="math inline">\(\mathbf{A}\)</span>，令</p><p><span class="math display">\[\mathbf{B}=\mathbf{A}-\frac{1}{\mathbf{A}_{11}}\mathbf{A}_{:,1}\mathbf{A}_{1,:}\]</span></p><p>那么，</p><p><span class="math display">\[\mathbf{B}_{i,1}=\mathbf{A}_{i,1}-\frac{1}{\mathbf{A}_{11}}\mathbf{A}_{i1}\mathbf{A}_{11}=0,i\neq 1\]</span></p><p>所以<span class="math inline">\(\mathbf{B}\)</span>的第一列除了第一个元素全部为0，根据对称性，第一行也全部为0，即实现了对第一行第一列元素的删除。</p><blockquote><p>尽管这里推导的时候是针对第一行或者第一列的，但是很容易外推到任意位置。</p></blockquote><p>到此，我们证明了海森逆矩阵更新公式的正确性，分为两步：首先证明删除参数后海森逆矩阵的格式，然后根据格式证明了更新公式的正确性。</p><h3 id="lazy-batch-updates">Lazy Batch-Updates</h3><p>在量化某个参数矩阵的情况下，每次量化一个参数，其他所有未量化的参数都要按公式全都要更新一遍。如果每行的量化并行计算，那么每次更新过程就需要read + write 一次参数矩阵。如果参数矩阵的维度为<span class="math inline">\(k \timesk\)</span>，那么量化这个参数矩阵就需要读写 k 次参数，总共的 IO 量为<span class="math inline">\(k^3\)</span>个元素。当 k 比较大时（>=4096），需要读写的元素就非常多了，运行时间大都被 IO 占据。</p><p><img src="/31769/1729848176700.png"></p><p><span class="math display">\[\Delta W_{:,p:} = -\frac{W_{:,p:} -\text{quant}(W_{:,p:})}{[\mathbf{H}_{p:,p:}^{-1}]_{0,0}} \left([\mathbf{H}_{p:,p:}^{-1}]_{:,0} \right)^\top=-\frac{\left( [\mathbf{H}_{p:,p:}^{-1}]_{:,0}\right)^\top}{[\mathbf{H}_{p:,p:}^{-1}]_{0,0}} ( W_{:,p:} -\text{quant}(W_{:,p:}))\]</span></p><p>将参数矩阵按每若干列划分为一个个 group，量化某一列时，group内的参数立即更新，而 group 后面的列只记录更新量，延迟更新。当一个 group的参数全部量化完成，再统一对后面的所有参数做一次更新。这就是 LazyBatch-Updates。根据更新公式我们可以发现，这个更新可以是可以合并同类项的，把一个group的第一项提出来求和，可以一次读写后面的所有group。</p><p><img src="/31769/1729848182654.png"></p><p>对应的算法伪代码为</p><p><img src="/31769/1729922822263.png"></p><h2 id="实验">实验</h2><p>1.小模型测试</p><p>首先在ResNet上面进行了测试。选择AdaQuant、基于贪心策略的OBQ在精度上保持持平。相比量化前的模型来说，性能也没有下降太多。</p><p><img src="/31769/1729943142457.png"></p><p>然后在小型语言模型上（这是OBQ能使用的最大的模型之一）进行了测试。在4bit得分比之前的方法稍微差一点，在3bit要低的多一点。</p><p><img src="/31769/1729943292624.png"></p><p>但是量化需要时间从1h降到1min。</p><p>2.测试了量化时间</p><p>提供了一个参考的标准：</p><p>"For reference, the straight-through based method ZeroQuant-LKD (Yaoet al., 2022) reports a 3 hour runtime (on the same hardware) for a 1.3Bmodel, which would linearly extrapolate to several hundred hours (a fewweeks) for 175B models."</p><p><img src="/31769/1729943743510.png"></p><p>3.测试了量化模型在文本生成任务的表现</p><p>和不进行优化的直接量化（RTN）进行了对比。</p><p><img src="/31769/1729944238282.png"></p><p>4.测试了OPT-175B文本生成的效率</p><p>开发了相关kernel（推理时权重会反量化），量化只针对权重，激活不量化。</p><p><img src="/31769/1729944960522.png"></p><p>5.零样本任务评测</p><p>测试了和基线相比，在零样本任务上的准确率。</p><p><img src="/31769/1729945727934.png"></p><p>该方法很容易和别的量化网络相结合。量化网络指的是量化的操作，是权重调整后的具体量化步骤，需要确定比如缩放因子，零点，量化的粒度等。</p><h2 id="代码解析">代码解析</h2><p>论文对应的代码仓库为：<a href="https://github.com/IST-DASLab/gptq">IST-DASLab/gptq: Code for theICLR 2023 paper "GPTQ: Accurate Post-training Quantization of GenerativePretrained Transformers".</a></p><p>基于改算法开发的工具包：<a href="https://github.com/AutoGPTQ/AutoGPTQ">AutoGPTQ/AutoGPTQ: Aneasy-to-use LLMs quantization package with user-friendly apis, based onGPTQ algorithm.</a></p><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href="https://zhuanlan.zhihu.com/p/646210009">QLoRA、GPTQ：模型量化概述- 知乎</a></li><li><a href="https://zhuanlan.zhihu.com/p/690834228">LLM 推理加速技术 ——GPTQ 量化技术演进 - 知乎</a></li><li><a href="https://arxiv.org/abs/2210.17323">[2210.17323] GPTQ:Accurate Post-Training Quantization for Generative Pre-trainedTransformers</a></li><li><a href="https://github.com/AutoGPTQ/AutoGPTQ">AutoGPTQ/AutoGPTQ: Aneasy-to-use LLMs quantization package with user-friendly apis, based onGPTQ algorithm.</a></li><li><a href="https://github.com/IST-DASLab/gptq">IST-DASLab/gptq: Codefor the ICLR 2023 paper "GPTQ: Accurate Post-training Quantization ofGenerative Pretrained Transformers".</a></li><li><a href="https://citeseerx.ist.psu.edu/document?repid=rep1&type=pdf&doi=17c0a7de3c17d31f79589d245852b57d083d386e">OptimalBrain Damage</a></li><li><a href="https://blog.csdn.net/xbinworld/article/details/104663481">三十分钟理解：矩阵Cholesky分解，及其在求解线性方程组、矩阵逆的应用_cholesky分解法求解线性方程组-CSDN博客</a></li></ul></blockquote>]]></content>
<categories>
<category> 科研 </category>
<category> 论文阅读 </category>
</categories>
<tags>
<tag> 深度学习 </tag>
<tag> 量化 </tag>
</tags>
</entry>
<entry>
<title>llm.int8</title>
<link href="//21264/"/>
<url>//21264/</url>
<content type="html"><![CDATA[<blockquote><p>todo：本文还在施工中.......</p></blockquote><h2 id="介绍">介绍</h2><p><code>llm.int8</code>是第一批针对大模型进行量化的算法，并且其算法也被集成在<code>bitsandbytes</code>库中，该库也已经被<code>huggingface</code>集成到代码库当中作为最基本的量化算法之一。</p><p>论文地址为：<a href="https://arxiv.org/abs/2208.07339">[2208.07339]LLM.int8(): 8-bit Matrix Multiplication for Transformers atScale</a></p><p>对应的源码为：<a href="https://github.com/bitsandbytes-foundation/bitsandbytes">bitsandbytes-foundation/bitsandbytes:Accessible large language models via k-bit quantization forPyTorch.</a></p><h2 id="摘要">摘要</h2><p>LLM.in8()量化针对的是transformer的FNN模块和Attn模块的矩阵乘法。</p><p>该量化方法把矩阵中的异常值抽出来保持16位精度，对于其余值量化为8位精度，计算的时候恢复16精度。量化常数的选择是在向量维度进行的（矩阵最后维度）。</p><h2 id="介绍-1">介绍</h2><p>FFN和Attn的矩阵参数在模型总参数占比较高，且矩阵乘法占据了较多的计算资源。以往的量化方法降低了模型的表现并且需要量化后训练。同时没有对超过350M参数进行量化研究。这篇论文第一次提出针对百万级参数量的模型的量化方法且模型性能下降有限。应该也是第一篇把大模型量化到8比特的论文。</p><h2 id="量化前置知识">量化前置知识</h2><p>论文这里简单说明了非对称量化理论上能提供更高的精度，但是由于实际限制，用的最多的还是对称量化。</p><h3 id="对称量化">对称量化</h3><p>对于fp16格式的输入<span class="math inline">\(\mathbf{X}_{f16} \in\mathbb{R}^{s \times h}\)</span>，8比特的量化为：</p><p><span class="math display">\[\mathbf{X}_{i8} = \left\lfloor \frac{127 \cdot\mathbf{X}_{f16}}{\max_{ij} \left( |\mathbf{X}_{f16_{ij}}| \right)}\right\rceil= \left\lfloor \frac{127}{\|\mathbf{X}_{f16}\|_{\infty}}\mathbf{X}_{f16} \right\rceil= \left\lfloor s_{x_{f16}} \mathbf{X}_{f16} \right\rceil\]</span></p><p>其中<span class="math inline">\(\left\lfloor \right\rceil\)</span>，代表四舍五入取整，即距离最近的整数。</p><h2 id="原理介绍">原理介绍</h2><p>这个量化的方法原理很简单，该方案先做了一个矩阵分解，对绝大部分权重和激活用8bit量化（<strong>vector</strong>-wise）。对离群特征的几个维度保留16bit，对其做高精度的矩阵乘法。</p><p><img src="/21264/1729756835272.png"></p><p>LLM.int8() 通过三个步骤完成矩阵乘法计算:</p><ol type="1"><li>从输入的隐含状态中，按列提取异常维度(离群特征，即大于某个阈值的值)。</li><li>对离群特征进行 FP16 矩阵运算，对非离群特征进行量化，做 INT8矩阵运算；</li><li>反量化非离群值的矩阵乘结果，并与离群值矩阵乘结果相加，获得最终的FP16 结果。</li></ol><h2 id="原理分析">原理分析</h2><p>这个方法能成功的一个重要原因是作者发现<strong>同一个序列的不同token异常维度集中在部分维度且异常维度数目较少</strong>。</p><p>首先，论文定义异常值的标准为：</p><ul><li>值需要大于等于6</li><li>影响25%的层</li><li>至少出现一个序列在6%的token中</li></ul><p>作者对此进行了解释：</p><ul><li>实验发现把大于等于6的值设置为异常值，困惑度退化就会停止</li><li>异常值特征是在大模型中系统出现的，要么出现在大多数层中，要么不出现；在小模型中概率出现。设置该阈值保证125M的最小模型中异常值只有一个（小模型中第二个出现最多的异常值仅仅出现2%的层）</li><li>使用和第二点相同的过程来选择异常值在序列维度的最小出现比例</li></ul><p>作者进行了实验，将满足条件的维度设置为0，比较最高可能性输出类别所分配的Softmax概率值。对比是随机选择相同数目的维度进行对比。</p><p><img src="/21264/1729962190147.png"></p><h2 id="实验">实验</h2><p>todo：量化效果</p><p><img src="/21264/1729961938672.png"></p><p>todo：加速效果</p><p>由于多余的反量化操作，在小模型上推理速度有所下降。</p><p><img src="/21264/1729962553598.png"></p><h2 id="bitsandbytes介绍">bitsandbytes介绍</h2><p>todo：介绍库的大致使用方法和部分疑点。</p><p><code>bitsandbytes</code>库在量化模型的时候，不需要数据首先直接把权重量化为8bit。在推理的时候，根据输入确定异常维度。输入的异常维度保持fp16，别的维度量化为int8。而量化后的权重，会把异常维度进行反量化为fp16（可能会有轻微损失），别的保持int8。之后的计算就和原理图保持一致。</p><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href="https://arxiv.org/abs/2208.07339">[2208.07339] LLM.int8():8-bit Matrix Multiplication for Transformers at Scale</a></li><li><a href="https://blog.csdn.net/scgaliguodong123_/article/details/136176382">大模型量化技术原理-LLM.int8()、GPTQ-CSDN博客</a></li><li><a href="https://github.com/bitsandbytes-foundation/bitsandbytes">bitsandbytes-foundation/bitsandbytes:Accessible large language models via k-bit quantization forPyTorch.</a></li></ul></blockquote>]]></content>
<categories>
<category> 科研 </category>
<category> 论文阅读 </category>
</categories>
<tags>
<tag> 深度学习 </tag>
<tag> 量化 </tag>
</tags>
</entry>
<entry>
<title>pytorch分布式-ddp</title>
<link href="//45014/"/>
<url>//45014/</url>
<content type="html"><![CDATA[<h1 id="介绍">介绍</h1><p>这篇博客主要是关于pytorch分布式ddp（DistributedDataParallel）的介绍和大概的食用（<del>这不是错别字</del>）教程。</p><p>数据并行DistributedDataParallel指的是在数据集层面进行多进程的切分，对于模型参数和训练状态等其他部分切分。</p><p>首先会介绍一下通信。在pytorch分布式ddp中，各个进程的代码是单独运行的。彼此之间在没有显式通信的时候，是不知道对方的的信息的。因此分布式的重点，所以了解通信的情况，也就了解了分布式的原理和使用的方法。</p><p>主要通信的方式有：</p><ul><li>环境变量</li><li>同步</li><li>tensor操作</li></ul><p>然后会介绍一下在数据并行下数据如何进行切分。</p><p>最后介绍整体pytorch分布式大概的流程和使用方法。</p><h1 id="通信">通信</h1><h2 id="环境变量">环境变量</h2><p>常用的环境变量有：</p><ul><li>WORLD_SIZE 全局进程数</li><li>RANK 当前进程全局标识符</li><li>LOCAL_RANK 在单个节点中的进程标识符</li><li>MASTER_ADDR 主节点IP地址</li><li>MASTER_PORT 主节点端口</li></ul><p>常用的为前三个，还有一些使用更加少的暂时没有罗列。</p><p>环境变量的获取可以：</p><pre class="line-numbers language-python" data-language="python"><code class="language-python"><span class="token keyword">import</span> osos<span class="token punctuation">.</span>environ<span class="token punctuation">[</span><span class="token string">"path"</span><span class="token punctuation">]</span>os<span class="token punctuation">.</span>environ<span class="token punctuation">.</span>get<span class="token punctuation">(</span><span class="token string">'KEY_THAT_MIGHT_EXIST'</span><span class="token punctuation">)</span>os<span class="token punctuation">.</span>getenv<span class="token punctuation">(</span><span class="token string">'KEY_THAT_MIGHT_EXIST'</span><span class="token punctuation">,</span> default_value<span class="token punctuation">)</span> <span class="token comment"># 推荐</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span></span></code></pre><h2 id="同步">同步</h2><p>引入pytorch分布式包</p><pre class="line-numbers language-python" data-language="python"><code class="language-python"><span class="token keyword">import</span> torch<span class="token punctuation">.</span>distributed <span class="token keyword">as</span> dist<span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre><p>同步所有进程进度</p><pre class="line-numbers language-python" data-language="python"><code class="language-python">dist<span class="token punctuation">.</span>barrier<span class="token punctuation">(</span><span class="token punctuation">)</span><span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre><p>在tensor通信的时候，也会起到同步进程的作用。很容易理解，不同步的话tensor的值都没有求得。</p><h2 id="tensor通信">tensor通信</h2><p>广播broadcast，收集gather，分发scatter，全收集all-gather，规约reduce，全规约all-reduce，全对称all-to-all，批量广播broadcast_object_list</p><h1 id="数据">数据</h1><p>在ddp中，只考虑的数据的剪切。那么对于某个进程，只需要计算部分数据即可。某个进程根据<strong>LOCAL_RANK</strong>获取自己所需的数据的方法有两种：</p><ol type="1"><li>数据集定义中加入offset，根据offset获取自己只需要的数据，那么进程只能看到自己的数据，比如<pre class="line-numbers language-python" data-language="python"><code class="language-python"><span class="token keyword">for</span> i<span class="token punctuation">,</span> segment <span class="token keyword">in</span> <span class="token builtin">enumerate</span><span class="token punctuation">(</span><span class="token builtin">open</span><span class="token punctuation">(</span><span class="token builtin">file</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">:</span> <span class="token keyword">if</span> i <span class="token operator">%</span> n_gpus <span class="token operator">!=</span> offset<span class="token punctuation">:</span> <span class="token keyword">continue</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span></span></code></pre></li><li>通过设置DataLoader中的sampler控制数据集采样实现数据切分，比如：<pre class="line-numbers language-python" data-language="python"><code class="language-python"><span class="token keyword">from</span> torch<span class="token punctuation">.</span>utils<span class="token punctuation">.</span>data <span class="token keyword">import</span> DataLoader<span class="token punctuation">,</span> DistributedSamplersampler <span class="token operator">=</span> DistributedSampler<span class="token punctuation">(</span>dataset<span class="token punctuation">,</span> num_replicas<span class="token operator">=</span>world_size<span class="token punctuation">,</span> rank<span class="token operator">=</span>rank<span class="token punctuation">)</span>dataloader <span class="token operator">=</span> DataLoader<span class="token punctuation">(</span>dataset<span class="token punctuation">,</span> batch_size<span class="token operator">=</span><span class="token number">64</span><span class="token punctuation">,</span> sampler<span class="token operator">=</span>sampler<span class="token punctuation">)</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span></span></code></pre></li></ol><h1 id="使用方法">使用方法</h1><p>在通信前，需要进行初始化操作（如果init_process_group不指定部分参数，也会自动从环境变量中获取）：</p><pre class="line-numbers language-python" data-language="python"><code class="language-python"><span class="token comment"># 初始化分布式进程</span><span class="token keyword">def</span> <span class="token function">setup</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">:</span> rank <span class="token operator">=</span> <span class="token builtin">int</span><span class="token punctuation">(</span>os<span class="token punctuation">.</span>environ<span class="token punctuation">[</span><span class="token string">"RANK"</span><span class="token punctuation">]</span><span class="token punctuation">)</span> world_size <span class="token operator">=</span> <span class="token builtin">int</span><span class="token punctuation">(</span>os<span class="token punctuation">.</span>environ<span class="token punctuation">[</span><span class="token string">"WORLD_SIZE"</span><span class="token punctuation">]</span><span class="token punctuation">)</span> dist<span class="token punctuation">.</span>init_process_group<span class="token punctuation">(</span><span class="token string">"nccl"</span><span class="token punctuation">,</span> rank<span class="token operator">=</span>rank<span class="token punctuation">,</span> world_size<span class="token operator">=</span>world_size<span class="token punctuation">)</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span></span></code></pre><p>设置使用的GPU（可以灵活设置，比如每若干个进程共享GPU）:</p><pre class="line-numbers language-python" data-language="python"><code class="language-python">rank <span class="token operator">=</span> <span class="token builtin">int</span><span class="token punctuation">(</span>os<span class="token punctuation">.</span>environ<span class="token punctuation">[</span><span class="token string">"RANK"</span><span class="token punctuation">]</span><span class="token punctuation">)</span>torch<span class="token punctuation">.</span>cuda<span class="token punctuation">.</span>set_device<span class="token punctuation">(</span>rank<span class="token punctuation">)</span> <span class="token comment"># 设置默认GPU</span>device <span class="token operator">=</span> torch<span class="token punctuation">.</span>device<span class="token punctuation">(</span><span class="token string-interpolation"><span class="token string">f"cuda:</span><span class="token interpolation"><span class="token punctuation">{</span>rank<span class="token punctuation">}</span></span><span class="token string">"</span></span><span class="token punctuation">)</span> <span class="token comment"># 显式指定设备</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span></span></code></pre><blockquote><p>使用的GPU还会收到环境变量CUDA_VISIBLE_DEVICES的限制</p><p>设置默认GPU可以让部分CUDA操作默认在该设备执行</p></blockquote><p>然后包装模型，隐式的进行<code>tensor</code>的同步和通信（在模型之外计算某些量（如精度、损失值等），可能需要同步）：</p><pre class="line-numbers language-python" data-language="python"><code class="language-python"><span class="token keyword">from</span> torch<span class="token punctuation">.</span>nn<span class="token punctuation">.</span>parallel <span class="token keyword">import</span> DistributedDataParallel <span class="token keyword">as</span> DDPmodel <span class="token operator">=</span> SimpleCNN<span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">.</span>to<span class="token punctuation">(</span>device<span class="token punctuation">)</span>model <span class="token operator">=</span> DDP<span class="token punctuation">(</span>model<span class="token punctuation">,</span> device_ids<span class="token operator">=</span><span class="token punctuation">[</span>rank<span class="token punctuation">]</span><span class="token punctuation">)</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span></span></code></pre><blockquote><p>当然，这里也可以切换成别的过程，比如如果不是模型的训练和推理，也可以进行tensor别的计算方法，但是需要手动的进行通信等。</p></blockquote><p>对于一些多个进程只需要完成一次的操作，比如保存模型或者日志记录等，只需要一个进程一般是主进程完成即可：</p><pre class="line-numbers language-python" data-language="python"><code class="language-python"><span class="token keyword">if</span> dist<span class="token punctuation">.</span>get_rank<span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token operator">==</span> <span class="token number">0</span><span class="token punctuation">:</span> torch<span class="token punctuation">.</span>save<span class="token punctuation">(</span>model<span class="token punctuation">.</span>state_dict<span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token string">"model_checkpoint.pth"</span><span class="token punctuation">)</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span></span></code></pre><p>代码执行完需要进程组的销毁：</p><pre class="line-numbers language-python" data-language="python"><code class="language-python"><span class="token keyword">def</span> <span class="token function">cleanup</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">:</span> dist<span class="token punctuation">.</span>destroy_process_group<span class="token punctuation">(</span><span class="token punctuation">)</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span></span></code></pre><h1 id="代码执行">代码执行</h1><p>如果执行代码直接使用python，那么需要使用pytorch的包启动多进程：</p><pre class="line-numbers language-python" data-language="python"><code class="language-python"><span class="token keyword">import</span> torch<span class="token punctuation">.</span>multiprocessing <span class="token keyword">as</span> mpmp<span class="token punctuation">.</span>spawn<span class="token punctuation">(</span>train<span class="token punctuation">,</span> nprocs<span class="token operator">=</span>world_size<span class="token punctuation">,</span> join<span class="token operator">=</span><span class="token boolean">True</span><span class="token punctuation">)</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span></span></code></pre><p>如果直接使用 <code>torchrun</code>命令执行代码，则不需要使用<code>torch.multiprocessing</code>，但需要在命令里添加部分参数，等于调用<code>torch.multiprocessing</code>的任务交给<code>torchrun</code>完成：</p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash">torchrun <span class="token parameter variable">--nproc_per_node</span><span class="token operator">=</span><span class="token number">4</span> your_script.py<span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre><h1 id="参考资料">参考资料</h1><blockquote><ul><li><a href="https://pytorch.org/tutorials/distributed/home.html">Distributedand Parallel Training Tutorials — PyTorch Tutorials 2.4.0+cu121documentation</a></li><li><a href="https://blog.csdn.net/qq_39131062/article/details/109206804">“最全“PyTorch分布式训练教程来了！_pytorch训练-CSDN博客</a></li><li><a href="https://blog.csdn.net/qq_40185847/article/details/115074443">Pytorch中基于NCCL多GPU训练_pytorchnccl-CSDN博客</a></li></ul></blockquote>]]></content>
<categories>
<category> 模板 </category>
</categories>
<tags>
<tag> 模板 </tag>
<tag> 深度学习 </tag>
<tag> PyTorch </tag>
<tag> 分布式 </tag>
<tag> ddq </tag>
<tag> 数据并行 </tag>
<tag> Data Parallel </tag>
</tags>
</entry>
<entry>
<title>hexo博客2:双主题</title>
<link href="//31680/"/>
<url>//31680/</url>
<content type="html"><![CDATA[<h1 id="介绍">介绍</h1><p>后来发现单纯的wiki风格博客可能确实有些单调了（<del>绝对不是因为我想弄二次元风格的</del>），因此在考虑以后，决定搭建一个双主题的博客，外层是个华丽一点的主题<a href="https://github.com/blinkfox/hexo-theme-matery">matery</a>，内层是个wiki风格主题<a href="https://github.com/zthxxx/hexo-theme-Wikitten">Wikitten</a>。</p><p><img src="/31680/1727953154709.png"></p><p>同时可以通过外层的wiki标志点击进入内层的wiki主题。</p><p><img src="/31680/1727953220606.png"></p><p><img src="/31680/1727953171329.png"></p><h1 id="双主题安装">双主题安装</h1><p>参考文章：<a href="https://masantu.com/blog/2020-05-23/hello-hexo-wiki/">Hexo同时使用两种主题（博客与 wiki 页面实现统一管理） | 别院牧志(masantu.com)</a></p><ol type="1"><li><p>把原来wiki主题的 <code>_config.yml</code>复制并重命名为<code>_config_wiki.yml</code>（wiki主题下的站点文件</p></li><li><p>安装 <code>hexo-theme-matery</code>主题</p><pre class="line-numbers language-powershell" data-language="powershell"><code class="language-powershell">cd your-hexo-directory/themesgit clone https:<span class="token operator">/</span><span class="token operator">/</span>github<span class="token punctuation">.</span>com/blinkfox/hexo-theme-matery<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span></span></code></pre></li><li><p>按照 <code>matery</code>教程配置新的<code>_config_wiki.yml</code>文件</p></li><li><p>修改 <code>_config_wiki.yml</code>文件：</p><pre class="line-numbers language-yaml" data-language="yaml"><code class="language-yaml"><span class="token comment"># URL</span><span class="token comment">## Set your site url here. For example, if you use GitHub Page, set url as 'https://username.github.io/project'</span><span class="token key atrule">url</span><span class="token punctuation">:</span> https<span class="token punctuation">:</span>//bg51717.github.io/wiki/<span class="token key atrule">root</span><span class="token punctuation">:</span> /wiki/<span class="token comment"># permalink: :year/:month/:day/:title/</span><span class="token comment"># permalink_defaults:</span><span class="token key atrule">permalink</span><span class="token punctuation">:</span> /<span class="token punctuation">:</span>abbrlink/<span class="token key atrule">abbrlink</span><span class="token punctuation">:</span> <span class="token key atrule">alg</span><span class="token punctuation">:</span> crc16 <span class="token comment">#算法： crc16(default) and crc32</span> <span class="token key atrule">rep</span><span class="token punctuation">:</span> dec <span class="token comment">#进制： dec(default) and hex</span><span class="token key atrule">permalink_defaults</span><span class="token punctuation">:</span> <span class="token comment"># Directory</span><span class="token key atrule">source_dir</span><span class="token punctuation">:</span> source<span class="token key atrule">public_dir</span><span class="token punctuation">:</span> public/wiki/<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre></li></ol><h1 id="代码块行高问题">代码块行高问题</h1><p>在使用<code>prismjs</code>渲染代码块的时候，可能会遇到图示问题，行高不匹配，其实主要是位置没有对准：<img src="/31680/1730525332224.png"></p><p>可以参考：<a href="https://github.com/blinkfox/hexo-theme-matery/issues/928">hexo 7.3代码块显示问题 · Issue #928 · blinkfox/hexo-theme-matery</a></p><p>解决办法是把<code>themes\hexo-theme-matery\source\libs\prism\prism.min.css</code>文件里的：</p><pre class="line-numbers language-css" data-language="css"><code class="language-css"><span class="token selector">[class*=language-].line-numbers>code</span><span class="token punctuation">{</span><span class="token property">position</span><span class="token punctuation">:</span>relative<span class="token punctuation">;</span><span class="token property">white-space</span><span class="token punctuation">:</span>inherit<span class="token punctuation">}</span><span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre><p>修改为：</p><pre class="line-numbers language-css" data-language="css"><code class="language-css"><span class="token selector">[class*=language-].line-numbers>code</span><span class="token punctuation">{</span><span class="token property">position</span><span class="token punctuation">:</span>sticky<span class="token punctuation">;</span><span class="token property">white-space</span><span class="token punctuation">:</span>inherit<span class="token punctuation">}</span><span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre><h1 id="wiki图片链接问题">wiki图片链接问题</h1><p>由于渲染的站点 <code>url</code>和 <code>root</code>里都有<code>wiki</code>，因此会导致渲染出来的图片出现两次<code>/wiki</code>，因此需要代码进行处理，核心函数如下所示：</p><pre class="line-numbers language-python" data-language="python"><code class="language-python"><span class="token keyword">def</span> <span class="token function">post_html_file</span><span class="token punctuation">(</span>file_path<span class="token punctuation">)</span><span class="token punctuation">:</span> <span class="token triple-quoted-string string">"""处理html文件，只修改图片链接中的重复/wiki/"""</span> <span class="token comment"># 如果不是html文件, 返回</span> <span class="token keyword">if</span> <span class="token keyword">not</span> file_path<span class="token punctuation">.</span>endswith<span class="token punctuation">(</span><span class="token string">".html"</span><span class="token punctuation">)</span><span class="token punctuation">:</span> <span class="token keyword">return</span> <span class="token comment"># 读取文件内容</span> <span class="token keyword">with</span> <span class="token builtin">open</span><span class="token punctuation">(</span>file_path<span class="token punctuation">,</span> <span class="token string">"r"</span><span class="token punctuation">,</span> encoding<span class="token operator">=</span><span class="token string">"utf-8"</span><span class="token punctuation">)</span> <span class="token keyword">as</span> <span class="token builtin">file</span><span class="token punctuation">:</span> content <span class="token operator">=</span> <span class="token builtin">file</span><span class="token punctuation">.</span>read<span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token comment"># 定义正则表达式来匹配图片链接，处理 <img> 标签中的 src 属性</span> img_pattern <span class="token operator">=</span> <span class="token string">r'<img[^>]+src="([^"]+)"'</span> <span class="token comment"># 查找所有匹配的图片链接</span> matches <span class="token operator">=</span> re<span class="token punctuation">.</span>findall<span class="token punctuation">(</span>img_pattern<span class="token punctuation">,</span> content<span class="token punctuation">)</span> <span class="token comment"># 遍历所有匹配的图片链接，替换掉重复的 /wiki/</span> modified_content <span class="token operator">=</span> content <span class="token keyword">for</span> <span class="token keyword">match</span> <span class="token keyword">in</span> matches<span class="token punctuation">:</span> <span class="token comment"># 如果链接中有重复的 /wiki/，替换为单一的 /wiki/</span> <span class="token keyword">if</span> <span class="token string">"/wiki/wiki/"</span> <span class="token keyword">in</span> <span class="token keyword">match</span><span class="token punctuation">:</span> corrected_url <span class="token operator">=</span> <span class="token keyword">match</span><span class="token punctuation">.</span>replace<span class="token punctuation">(</span><span class="token string">"/wiki/wiki/"</span><span class="token punctuation">,</span> <span class="token string">"/wiki/"</span><span class="token punctuation">)</span> <span class="token comment"># 替换内容中的旧链接为新的链接</span> modified_content <span class="token operator">=</span> modified_content<span class="token punctuation">.</span>replace<span class="token punctuation">(</span><span class="token keyword">match</span><span class="token punctuation">,</span> corrected_url<span class="token punctuation">)</span> <span class="token comment"># 将修改后的内容写回文件</span> <span class="token keyword">with</span> <span class="token builtin">open</span><span class="token punctuation">(</span>file_path<span class="token punctuation">,</span> <span class="token string">"w"</span><span class="token punctuation">,</span> encoding<span class="token operator">=</span><span class="token string">"utf-8"</span><span class="token punctuation">)</span> <span class="token keyword">as</span> <span class="token builtin">file</span><span class="token punctuation">:</span> <span class="token builtin">file</span><span class="token punctuation">.</span>write<span class="token punctuation">(</span>modified_content<span class="token punctuation">)</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><h1 id="图库api设置">图库APi设置</h1><p>对于外层主题，需要自己设置相关的图片，笔者从<a href="https://t.alcy.cc/">栗次元API-举个栗子图库API</a>爬取部分图片作为图片。也有别的食用方法可以参考该网站具体的教程。</p><h1 id="搜索链接跳转错误">搜索链接跳转错误</h1><p>由于把每篇博客链接到了一个数字，从而起到了缩短博客网址长度和增加搜索引擎爬取的概率，但是可能会导致原有的搜索跳转到随机IP。原因是：网址返回的是纯数字相对链接，比如<code>/7369</code>，完整的链接为<code>https://bg51717.github.io/7369/</code>，但是浏览器可能会把链接解析为ip地址，变成<code>0.0.28.201</code>，等同于256进制下的<code>7369</code>，从而导致跳转错误。因此需要调整搜索代码，每次返回完整链接，具体如下：</p><pre class="line-numbers language-ejs" data-language="ejs"><code class="language-ejs">if (data_url.indexOf('http') !== 0) { // 生成绝对路径，确保基于网站根目录 data_url = window.location.host +'/'+root+'/'+ data_url; data_url = data_url.replace(/\/+/g, '/'); // 去掉连续的斜杠 data_url = data_url.replace(/^\//, ''); // 去掉开头的斜杠 data_url = window.location.protocol + '//' + data_url;}<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><h1 id="渲染页面">渲染页面</h1><p>渲染部分的参考主要来自：<a href="https://masantu.com/blog/2020-05-23/hello-hexo-wiki/">Hexo同时使用两种主题（博客与 wiki 页面实现统一管理） | 别院牧志</a></p><ol type="1"><li><p>渲染主页面，生成到/public/</p><pre class="line-numbers language-none"><code class="language-none">hexo g<span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre></li><li><p>删除 db.json 及旧的 public/wiki</p><pre class="line-numbers language-none"><code class="language-none">hexo --config _config_wiki.yml clean<span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre></li><li><p>渲染wiki页面</p><pre class="line-numbers language-none"><code class="language-none">hexo --config _config_wiki.yml g<span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre></li><li><p>删除db.json</p><pre class="line-numbers language-none"><code class="language-none">rm db.json<span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre></li></ol><p>如果每次执行上述步骤都会稍显复杂，因此考虑整理脚本文件<code>run.py</code>，执行渲染时 <code>python run.py</code>即可：</p><pre class="line-numbers language-python" data-language="python"><code class="language-python"><span class="token keyword">import</span> os<span class="token keyword">import</span> platform<span class="token keyword">import</span> subprocess<span class="token keyword">def</span> <span class="token function">run_command</span><span class="token punctuation">(</span>command<span class="token punctuation">)</span><span class="token punctuation">:</span> <span class="token triple-quoted-string string">"""实时执行命令并将输出打印到控制台"""</span> <span class="token keyword">try</span><span class="token punctuation">:</span> <span class="token comment"># 使用 Popen 来执行命令并实时读取输出</span> process <span class="token operator">=</span> subprocess<span class="token punctuation">.</span>Popen<span class="token punctuation">(</span>command<span class="token punctuation">,</span> shell<span class="token operator">=</span><span class="token boolean">True</span><span class="token punctuation">,</span> stdout<span class="token operator">=</span>subprocess<span class="token punctuation">.</span>PIPE<span class="token punctuation">,</span> stderr<span class="token operator">=</span>subprocess<span class="token punctuation">.</span>PIPE<span class="token punctuation">,</span> text<span class="token operator">=</span><span class="token boolean">True</span><span class="token punctuation">,</span> encoding<span class="token operator">=</span><span class="token string">'utf-8'</span><span class="token punctuation">)</span> <span class="token comment"># 实时读取 stdout 和 stderr</span> <span class="token keyword">for</span> stdout_line <span class="token keyword">in</span> <span class="token builtin">iter</span><span class="token punctuation">(</span>process<span class="token punctuation">.</span>stdout<span class="token punctuation">.</span>readline<span class="token punctuation">,</span> <span class="token string">""</span><span class="token punctuation">)</span><span class="token punctuation">:</span> <span class="token keyword">print</span><span class="token punctuation">(</span>stdout_line<span class="token punctuation">,</span> end<span class="token operator">=</span><span class="token string">''</span><span class="token punctuation">)</span> <span class="token comment"># 实时输出 stdout</span> process<span class="token punctuation">.</span>stdout<span class="token punctuation">.</span>close<span class="token punctuation">(</span><span class="token punctuation">)</span> return_code <span class="token operator">=</span> process<span class="token punctuation">.</span>wait<span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token comment"># 等待命令执行结束</span> <span class="token comment"># 输出 stderr（如果有）</span> <span class="token keyword">if</span> return_code <span class="token operator">!=</span> <span class="token number">0</span><span class="token punctuation">:</span> <span class="token keyword">for</span> stderr_line <span class="token keyword">in</span> <span class="token builtin">iter</span><span class="token punctuation">(</span>process<span class="token punctuation">.</span>stderr<span class="token punctuation">.</span>readline<span class="token punctuation">,</span> <span class="token string">""</span><span class="token punctuation">)</span><span class="token punctuation">:</span> <span class="token keyword">print</span><span class="token punctuation">(</span>stderr_line<span class="token punctuation">,</span> end<span class="token operator">=</span><span class="token string">''</span><span class="token punctuation">)</span> <span class="token comment"># 实时输出 stderr</span> process<span class="token punctuation">.</span>stderr<span class="token punctuation">.</span>close<span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">except</span> subprocess<span class="token punctuation">.</span>CalledProcessError <span class="token keyword">as</span> e<span class="token punctuation">:</span> <span class="token keyword">print</span><span class="token punctuation">(</span><span class="token string-interpolation"><span class="token string">f"命令 '</span><span class="token interpolation"><span class="token punctuation">{</span>command<span class="token punctuation">}</span></span><span class="token string">' 执行失败，错误信息: </span><span class="token interpolation"><span class="token punctuation">{</span>e<span class="token punctuation">.</span>stderr<span class="token punctuation">}</span></span><span class="token string">"</span></span><span class="token punctuation">)</span><span class="token keyword">def</span> <span class="token function">clean_generate_hexo</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">:</span> <span class="token triple-quoted-string string">"""执行 hexo clean 和 hexo g 命令，以及相关的配置命令"""</span> os_type <span class="token operator">=</span> platform<span class="token punctuation">.</span>system<span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token comment"># 根据操作系统选择 rm 或 del</span> remove_command <span class="token operator">=</span> <span class="token string">"rm db.json"</span> <span class="token keyword">if</span> os_type <span class="token operator">!=</span> <span class="token string">"Windows"</span> <span class="token keyword">else</span> <span class="token string">"del db.json"</span> <span class="token comment"># 定义需要执行的命令列表</span> commands <span class="token operator">=</span> <span class="token punctuation">[</span> <span class="token string">"python -m process.run_before"</span><span class="token punctuation">,</span> <span class="token string">"hexo clean"</span><span class="token punctuation">,</span> <span class="token string">"hexo g"</span><span class="token punctuation">,</span> <span class="token string">"hexo --config _config_wiki.yml clean"</span><span class="token punctuation">,</span> <span class="token string">"hexo --config _config_wiki.yml g"</span><span class="token punctuation">,</span> remove_command<span class="token punctuation">,</span> <span class="token string">"python -m process.run_post"</span><span class="token punctuation">,</span> <span class="token punctuation">]</span> <span class="token comment"># 逐一执行命令</span> <span class="token keyword">for</span> command <span class="token keyword">in</span> commands<span class="token punctuation">:</span> <span class="token keyword">print</span><span class="token punctuation">(</span><span class="token string-interpolation"><span class="token string">f"\n正在执行命令: </span><span class="token interpolation"><span class="token punctuation">{</span>command<span class="token punctuation">}</span></span><span class="token string">"</span></span><span class="token punctuation">)</span> run_command<span class="token punctuation">(</span>command<span class="token punctuation">)</span><span class="token keyword">if</span> __name__ <span class="token operator">==</span> <span class="token string">"__main__"</span><span class="token punctuation">:</span> clean_generate_hexo<span class="token punctuation">(</span><span class="token punctuation">)</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><h1 id="参考资料">参考资料</h1><blockquote><ul><li><a href="https://github.com/blinkfox/hexo-theme-matery">blinkfox/hexo-theme-matery:A beautiful hexo blog theme with material design and responsivedesign.一个基于材料设计和响应式设计而成的全面、美观的Hexo主题。国内访问：http://blinkfox.com(github.com)</a></li><li><a href="https://github.com/zthxxx/hexo-theme-Wikitten">zthxxx/hexo-theme-Wikitten:A theme of Hexo for personal wiki which seems like Wikitten style.(github.com)</a></li><li><a href="https://masantu.com/blog/2020-05-23/hello-hexo-wiki/">Hexo同时使用两种主题（博客与 wiki 页面实现统一管理） | 别院牧志(masantu.com)</a></li></ul></blockquote>]]></content>
<categories>
<category> SmallProjects </category>
<category> 博客搭建 </category>
</categories>
<tags>
<tag> 博客 </tag>
<tag> Hexo </tag>
<tag> Wiki </tag>
</tags>
</entry>
<entry>
<title>使用dotbot快速同步Linux配置</title>
<link href="//13162/"/>
<url>//13162/</url>
<content type="html"><![CDATA[<h1 id="介绍">介绍</h1><p><strong>dotfiles</strong>指的是<code>.</code>开头的隐藏文件夹，一般是用户的配置或者软件信息。使用服务器或者Linux的时候，安装一些软件配置自己的使用环境是十分常见的场景。一个优秀的配置和各种软件不仅可以大幅提升工作效率，还可以美化工作环境，加强工作的动力。但是很多时候一个完整的配置是十分复杂且繁琐的，也难以去记忆每次配置时的信息。</p><p>因此很多人尝试收集配置文件，创建软连接，然后整理安装脚本，上传到github。实现难度较低。</p><p>这篇博客推荐使用基于Git的<a href="https://github.com/anishathalye/dotbot">dotbot</a>来管理dotfiles。自己编写管理脚本可能会导致脚本经常需要修改来使用不同的场合。框架在设计的时候会考虑到大部分场景，因此需要的修改和可能导致的错误较少。</p><h1 id="git子模块">Git子模块</h1><p>在介绍 <code>dotbot</code>之前需要了解一下<code>Git子模块(submodule)</code>的观念。当你的仓库依赖于别的仓库的时候，你可以添加一个链接指向被依赖的仓库的某个版本，而不需要去额外复制这些文件。</p><h2 id="基本操作">基本操作</h2><p>添加子模块：</p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token function">git</span> submodule <span class="token function">add</span> <span class="token operator"><</span>仓库地址<span class="token operator">></span> <span class="token operator"><</span>子模块路径<span class="token operator">></span><span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre><blockquote><p><仓库地址>是仓库的网络地址，<子模块路径>指的是相当于这个仓库的路径</p><p>示例：git submodule add https://github.com/example/library.gitlibs/library</p></blockquote><p>初始化子模块，当你克隆具有子模块的仓库的时候，需要手动初始化并更新子模块：</p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token function">git</span> submodule init<span class="token function">git</span> submodule update<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span></span></code></pre><blockquote><p>也可以一次更新</p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token function">git</span> clone --recurse-submodules <span class="token operator"><</span>仓库地址<span class="token operator">></span><span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre></blockquote><p>子模块管理，子模块可以像正常的仓库一样进行管理：</p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token builtin class-name">cd</span> <span class="token operator"><</span>子模块路径<span class="token operator">></span><span class="token function">git</span> pull<span class="token function">git</span> <span class="token function">add</span> <span class="token builtin class-name">.</span><span class="token function">git</span> commit <span class="token parameter variable">-m</span> <span class="token string">"Update submodule"</span><span class="token function">git</span> push<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span></span></code></pre><blockquote><p>如果需要对子模块更新且不是子模块的作者的话，建议fork仓库作为子模块，fork仓库的管理此处不再阐述。</p></blockquote><p>删除子模块，删除子模块需要调整 <code>.gitmodules</code>和<code>.git/config</code>配置：</p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token function">git</span> submodule deinit <span class="token operator"><</span>子模块路径<span class="token operator">></span><span class="token function">git</span> <span class="token function">rm</span> <span class="token parameter variable">--cached</span> <span class="token operator"><</span>子模块路径<span class="token operator">></span><span class="token function">rm</span> <span class="token parameter variable">-rf</span> <span class="token operator"><</span>子模块路径<span class="token operator">></span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span></span></code></pre><p>修改子模块url：</p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token function">git</span> submodule set-url <span class="token operator"><</span>子模块路径<span class="token operator">></span> <span class="token operator"><</span>新的URL<span class="token operator">></span><span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre><p>修改子模块路径：</p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token function">git</span> <span class="token function">mv</span> <span class="token operator"><</span>旧路径<span class="token operator">></span> <span class="token operator"><</span>新路径<span class="token operator">></span><span class="token function">git</span> submodule <span class="token function">sync</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span></span></code></pre><h1 id="安装">安装</h1><p>首先你需要一个<code>dotfiles</code>文件夹（名字可以自定义），里面是你所有的配置文件。</p><p>之后进入这个文件夹，添加 <code>dotbot</code>作为子模块：</p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token comment"># Initialize Repository</span><span class="token function">git</span> init<span class="token function">git</span> submodule <span class="token function">add</span> https://github.com/anishathalye/dotbot<span class="token function">cp</span> dotbot/tools/git-submodule/install <span class="token builtin class-name">.</span><span class="token function">touch</span> install.config.yaml<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span></span></code></pre><blockquote><p>也推荐把需要安装的软件作为子模块使用</p></blockquote><h1 id="配置">配置</h1><p>通过修改 <code>install.config.yaml</code>可以调整安装命令<code>./install</code>的工作。</p><p>默认的配置为：</p><pre class="line-numbers language-yaml" data-language="yaml"><code class="language-yaml"><span class="token punctuation">-</span> <span class="token key atrule">defaults</span><span class="token punctuation">:</span> <span class="token key atrule">link</span><span class="token punctuation">:</span> <span class="token key atrule">relink</span><span class="token punctuation">:</span> <span class="token boolean important">true</span><span class="token punctuation">-</span> <span class="token key atrule">clean</span><span class="token punctuation">:</span> <span class="token punctuation">[</span><span class="token string">'~'</span><span class="token punctuation">]</span><span class="token punctuation">-</span> <span class="token key atrule">link</span><span class="token punctuation">:</span> <span class="token key atrule">~/.bashrc</span><span class="token punctuation">:</span> bashrc <span class="token key atrule">~/.zshrc</span><span class="token punctuation">:</span> zshrc <span class="token key atrule">~/.vimrc</span><span class="token punctuation">:</span> vimrc<span class="token punctuation">-</span> <span class="token key atrule">shell</span><span class="token punctuation">:</span> <span class="token punctuation">-</span> <span class="token punctuation">[</span>git submodule update <span class="token punctuation">-</span><span class="token punctuation">-</span>init <span class="token punctuation">-</span><span class="token punctuation">-</span>recursive<span class="token punctuation">,</span> Installing submodules<span class="token punctuation">]</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><blockquote><p>几个类别的顺序会影响命令执行时的顺序</p></blockquote><p>主要类别有：</p><ul><li>defaults：会对所有操作进行的设置</li><li>clean：哪些links会被检查是否dead，如果是dead links会被删除</li><li>link：创建软链接的源目录和目标目录</li><li>shell：希望运行的指令</li></ul><p>之后就可以简单的使用git来管理dotfile，并且使用<code>./install</code>安装即可。</p><h1 id="参考资料">参考资料</h1><blockquote><ul><li><a href="https://github.com/anishathalye/dotbot">anishathalye/dotbot: Atool that bootstraps your dotfiles ⚡️ (github.com)</a></li><li><a href="https://anishathalye.com/managing-your-dotfiles/">管理您的点文件(anishathalye.com)</a></li><li><a href="https://dotfiles.github.io/">GitHub does dotfiles -dotfiles.github.io</a></li><li>杰哥</li></ul></blockquote>]]></content>
<categories>
<category> 工具 </category>
</categories>
<tags>
<tag> dotfiles </tag>
<tag> dotbot </tag>
<tag> Linux </tag>
</tags>
</entry>
<entry>
<title>zsh+powerlevel10K优化终端使用体验</title>
<link href="//13107/"/>
<url>//13107/</url>
<content type="html"><![CDATA[<h1 id="介绍">介绍</h1><p><strong>ZSH</strong>（Zshell）类似Bash，是被广泛用于类Unix系统的命令行解释器。在具备Bash的基本功能的同时，还扩展了很多功能，同时对插件的支持和高度定制化使其成为了很多Linux用户的最佳选择。经常使用的功能有：自动补全，历史命令，语法高亮等。</p><p><strong>powerlevel10K</strong>是ZSH的主题之一，但是扩展了一些额外的功能，比如更多信息的显示，运行时间和当前时间的查看等。</p><p>通过灵活使用这两个工具，可以在美化你的终端页面的同时提升你的效率。</p><blockquote><p>以下操作默认使用的<strong>Ubuntu</strong>系统。</p></blockquote><h1 id="zsh">ZSH</h1><h2 id="安装">安装</h2><p>Ubuntu：</p><ul><li><p>安装zsh</p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token function">sudo</span> <span class="token function">apt</span> <span class="token function">install</span> <span class="token function">zsh</span><span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre></li><li><p>设置为默认shell</p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token function">sudo</span> chsh <span class="token parameter variable">-s</span> /bin/zsh<span class="token comment"># 为其他用户设置：sudo chsh -s /bin/zsh <username></span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span></span></code></pre></li><li><p>安装git</p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token function">sudo</span> <span class="token function">apt</span> <span class="token function">install</span> <span class="token function">git</span><span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre></li><li><p>安装oh-my-zsh 手动安装:</p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token function">git</span> clone <span class="token parameter variable">--depth</span><span class="token operator">=</span><span class="token number">1</span> https://github.com/ohmyzsh/ohmyzsh.git ~/.oh-my-zsh<span class="token function">cp</span> ~/.oh-my-zsh/templates/zshrc.zsh-template ~/.zshrc<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span></span></code></pre><p>或 自动安装:</p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token function">sh</span> <span class="token parameter variable">-c</span> <span class="token string">"<span class="token variable"><span class="token variable">$(</span><span class="token function">curl</span> <span class="token parameter variable">-fsSL</span> https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh<span class="token variable">)</span></span>"</span><span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre></li></ul><h2 id="zsh设置">ZSH设置</h2><p>通过修改配置文件 <code>~/.zshrc</code>可以修改终端设置。经常使用的设置应该有：</p><ul><li>ZSH_THEME：ZSH主题。</li><li>plugins：ZSH插件。</li></ul><p>同时一些希望终端启动时运行的命令也可以放在该文件里，比如conda的启动。</p><blockquote><p>也就是终端加载的时候会运行的命令，也可以<code>source ~/.zshrc</code>更新配置文件对终端的设置</p></blockquote><h2 id="插件推荐">插件推荐</h2><h3 id="sh-completions"><a href="https://github.com/zsh-users/zsh-completions">sh-completions</a></h3><p>这个插件提供了基础的补全功能。目前似乎已经被集成到ZSH项目中。</p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token function">git</span> clone <span class="token parameter variable">--depth</span><span class="token operator">=</span><span class="token number">1</span> https://github.com/zsh-users/zsh-completions <span class="token variable">${ZSH_CUSTOM<span class="token operator">:-</span>${ZSH<span class="token operator">:-</span>~<span class="token operator">/</span>.oh-my-zsh}</span>/custom<span class="token punctuation">}</span>/plugins/zsh-completions<span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre><h3 id="zsh-autosuggestions"><a href="https://github.com/zsh-users/zsh-autosuggestions">zsh-autosuggestions</a></h3><p>这个插件可以提供自动补全的功能，比如输入 <code>git</code>，自动补全为<code>git status</code>。</p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token function">git</span> clone <span class="token parameter variable">--depth</span><span class="token operator">=</span><span class="token number">1</span> https://github.com/zsh-users/zsh-autosuggestions.git <span class="token variable">${ZSH_CUSTOM<span class="token operator">:-</span>${ZSH<span class="token operator">:-</span>~<span class="token operator">/</span>.oh-my-zsh}</span>/custom<span class="token punctuation">}</span>/plugins/zsh-autosuggestions<span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre><h3 id="incremental-completion-on-zsh"><a href="https://mimosa-pudica.net/zsh-incremental.html">Incrementalcompletion on zsh</a></h3><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token function">mkdir</span> <span class="token variable">$ZSH_CUSTOM</span>/plugins/incr<span class="token function">curl</span> <span class="token parameter variable">-fsSL</span> https://mimosa-pudica.net/src/incr-0.2.zsh <span class="token parameter variable">-o</span> <span class="token variable">$ZSH_CUSTOM</span>/plugins/incr/incr.zsh<span class="token builtin class-name">echo</span> <span class="token string">'source $ZSH_CUSTOM/plugins/incr/incr.zsh'</span> <span class="token operator">>></span> ~/.zshrc<span class="token builtin class-name">source</span> ~/.zshrc<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span></span></code></pre><h3 id="zsh-syntax-highlighting"><a href="https://github.com/zsh-users/zsh-syntax-highlighting">zsh-syntax-highlighting</a></h3><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token function">git</span> clone <span class="token parameter variable">--depth</span><span class="token operator">=</span><span class="token number">1</span> https://github.com/zsh-users/zsh-syntax-highlighting.git <span class="token variable">${ZSH_CUSTOM<span class="token operator">:-</span>~<span class="token operator">/</span>.oh-my-zsh<span class="token operator">/</span>custom}</span>/plugins/zsh-syntax-highlighting<span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre><h1 id="powerlevel10k">powerlevel10K</h1><p>目前配置的终端可以显示当前的虚拟环境、路径、git情况，以及上个命令的执行时间等。基本需要都被涵盖。这写额外的功能和美化得归功于ZSH主题——<strong>powerlevel10K</strong>。具体效果图如下所示：<img src="/13107/1727664718688.png"></p><h2 id="安装-1">安装</h2><h3 id="字体">字体</h3><p>由于会显示一些额外的符号，所以需要安装新的字体。</p><blockquote><p>字体需要在显示终端的设备上安装。比如如果系统在本地，那么在本地安装。如果连接的远程，那么需要在远程上安装ZSH和主题，在本地安装字体。原理不难理解。</p></blockquote><p>字体链接：<a href="https://github.com/ryanoasis/nerd-fonts#font-installation">NerFont</a>字体链接里有完整的安装教程，可以根据自己的平台进行安装。如果是克隆源码安装的时候注意设置depth，建议从该仓库的releases里选择字体进行安装。根据平台情况安装然后后设置字体显示即可，一般需要在终端或者编辑器里设置字体选项。考虑到种类较多且教程丰富简单，此处不罗列详细步骤。</p><blockquote><p>Tips：如果设置的是Vscode平台，需要设置整体的字体： Editor:FontFamily，单独设置终端字体好像无法正常工作。 <img src="/13107/1727665397412.png"></p></blockquote><h3 id="主题">主题</h3><p>使用命令安装到 <code>~/.oh-my-zsh</code>目录下：</p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token function">git</span> clone <span class="token parameter variable">--depth</span><span class="token operator">=</span><span class="token number">1</span> https://github.com/romkatv/powerlevel10k.git <span class="token variable">${ZSH_CUSTOM<span class="token operator">:-</span>$HOME<span class="token operator">/</span>.oh-my-zsh<span class="token operator">/</span>custom}</span>/themes/powerlevel10k<span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre><p>在 <code>~/.zshrc</code>下启动主题：</p><pre class="line-numbers language-none"><code class="language-none">ZSH_THEME="powerlevel10k/powerlevel10k"<span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre><h2 id="配置">配置</h2><p>重启终端或者<code>source ~/.zshrc</code>切换主题，之后会进入配置界面。（配置完成后也可以使用<code>p10k configure</code>重新进入配置向导）配置向导就是一些问题来判断你的字体情况和个人偏好，然后写入配置文件<code>~/.p10k.sh</code>中，大约有十几个问题。配置向导的详细介绍可以参考：<a href="https://juejin.cn/post/7293342627814244367">我的终端环境：与众不同的zsh 主题 - powerlevel10k本文介绍 zsh 主题 powerlevel10k - 掘金</a>在配置向导完成后，如果需要一些额外的配置。可以修改配置文件<code>~/.p10k.sh</code>。 比如，通过修改<code>POWERLEVEL9K_LEFT_PROMPT_ELEMENTS</code>和<code>POWERLEVEL9K_RIGHT_PROMPT_ELEMENTS</code>可以修改两侧显示的元素以及顺序等。</p><h1 id="参考资料">参考资料</h1><blockquote><ul><li><a href="https://sysin.org/blog/linux-zsh/">Linux Zsh 使用 oh-my-zsh打造高效便捷的 shell 环境 - sysin | SYStem INside |软件与技术分享</a></li><li><a href="https://juejin.cn/post/7293342627814244367">我的终端环境：与众不同的zsh 主题 - powerlevel10k本文介绍 zsh 主题 powerlevel10k - 掘金</a></li><li>杰哥</li></ul></blockquote>]]></content>
<categories>
<category> 工具 </category>
</categories>
<tags>
<tag> 终端 </tag>
<tag> oh-my-zsh </tag>
<tag> powerlevel10k </tag>
</tags>
</entry>
<entry>
<title>安卓手机配置Google</title>
<link href="//61294/"/>
<url>//61294/</url>
<content type="html"><![CDATA[<h2 id="介绍">介绍</h2><p>这篇博客主要记录了如何在安卓手机上配置谷歌三件套的服务。</p><p>对于非华为荣耀手机，可能仅仅需要简单的使用一些第三方的安装软件即可完成，比如<code>go安装助手</code>等，资源较大且获取难度较低。</p><p>而本篇博客主要介绍华为荣耀手机如何获取谷歌三件套的服务和配置支付信息等。</p><p>介绍两个并行的方法，当其中一个方法失效的时候，可以用另一个方法的部分替代。</p><p>方法是 <code>华谷套件</code>和<a href="https://github.com/to-alan/HarmonyOSInstallGMS?tab=readme-ov-file">to-alan/HarmonyOSInstallGMS:华为安装GMS教程</a> 。</p><p>博主前面的流程都使用的是华谷套件，该软件可以在每一步运行完后自动检测是否设置成功。在卸载MicroG后，转为使用方法二进行后续的处理。</p><p>目前手机谷歌三件套运行稳定，基本可以提供原生的谷歌三件套服务。</p><blockquote><p>支付方式的添加todo。</p></blockquote><p>参考资料</p><blockquote><ul><li><a href="https://github.com/to-alan/HarmonyOSInstallGMS?tab=readme-ov-file">to-alan/HarmonyOSInstallGMS:华为安装GMS教程</a></li></ul></blockquote>]]></content>
<categories>
<category> 工具 </category>
</categories>
<tags>
<tag> 安卓 </tag>
<tag> Google </tag>
</tags>
</entry>
<entry>
<title>PyTorch代码转HF</title>
<link href="//61054/"/>
<url>//61054/</url>
<content type="html"><![CDATA[<h2 id="介绍">介绍</h2><p>这篇博客主要介绍了怎么把一个已有的Pytorch代码转变成HF支持的格式，然后可以方便的放入HF代码流程中，并且使用一些HF的函数。代码转换主要涉及到以下几个方面：</p><ul><li>Config</li><li>Model</li><li>Trainer</li><li>Dataset</li></ul><p>因为ckpt里面的代码使用的会是相对导入，所以在转换的过程中，建议把<code>configuration_xxx.py</code>和<code>modeling_xxx.py</code>文件放在同一个目录下，并且添加<code>__init__.py</code>文件。</p><p>在hf框架下模型的ckpt文件夹里面，我们一般可以看到以下几个文件（假如模型是ltgbert）：</p><ul><li><code>config.json</code>：存放模型的具体设置，比如num_heads，act_fn等。</li><li><code>configuration_ltgbert.py</code>：存放关于模型<code>config</code>类的代码。</li><li><code>modeling_ltgbert.py</code>：模型类以及各种组件模块的代码，也会包含一些功能函数。</li><li><code>pytorch_model.bin</code>：模型的权重，存放模型参数具体的值。</li><li><code>special_token_map.json</code>：模型的<code>tokenizer</code>的特殊token。</li><li><code>tokenizer_config.json</code>：模型的<code>tokenizer</code>的设置，参考 <code>config.json</code>。</li><li><code>tokenizer.json</code>：模型的<code>token</code>以及序号，等同于 <code>tokenizer</code>的权重。</li></ul><p>部分 <code>ckpt</code>里如果有自定义的<code>tokenizer</code>，可能还会有相关的代码定义，此处暂不列出。<del>（挖坑</del></p><p>部分<code>ckpt</code>里模型的权重可能会使用多个文件拆分存放或者多种格式的，此处暂不列出。</p><p>模型的设置和类的代码可能不会在文件中出现，因为hf官方会把一些常用的模型的相关代码放在官方库里，该文件夹在github上的网址为：<a href="https://github.com/huggingface/transformers/tree/main/src/transformers/models">transformers/src/transformers/modelsat main · huggingface/transformers</a>。</p><p>尽管文件的<code>ckpt</code>里文件较多，但是框架可以帮你自动保存相关文件，当然也可以通过重载函数实现自定义的保存过程。<del>（挖坑</del></p><h2 id="config">Config</h2><p>参考：<a href="https://huggingface.co/docs/transformers/custom_models#building-custom-models">Buildingcustom models (huggingface.co)</a></p><p>代码主要在 <code>configuration_xxx.py</code>。</p><p><code>config</code>主要是在模型基本架构不变的情况下，怎么通过超参设置模型的具体结构，在模型初始化或者加载权重的时候会传入的config进行模型设置。</p><p>示例：</p><pre class="line-numbers language-python" data-language="python"><code class="language-python"><span class="token keyword">from</span> transformers <span class="token keyword">import</span> PretrainedConfig<span class="token keyword">from</span> typing <span class="token keyword">import</span> List<span class="token keyword">class</span> <span class="token class-name">LtgBertConfig</span><span class="token punctuation">(</span>PretrainedConfig<span class="token punctuation">)</span><span class="token punctuation">:</span> model_type <span class="token operator">=</span> <span class="token string">"LtgBert"</span> <span class="token triple-quoted-string string">"""Configuration class to store the configuration of a `LtgBertModel`. """</span> <span class="token keyword">def</span> <span class="token function">__init__</span><span class="token punctuation">(</span>self<span class="token punctuation">,</span> vocab_size_or_config_json_file<span class="token operator">=</span><span class="token number">16384</span><span class="token punctuation">,</span> hidden_size<span class="token operator">=</span><span class="token number">768</span><span class="token punctuation">,</span> num_hidden_layers<span class="token operator">=</span><span class="token number">12</span><span class="token punctuation">,</span> num_attention_heads<span class="token operator">=</span><span class="token number">12</span><span class="token punctuation">,</span> intermediate_size<span class="token operator">=</span><span class="token number">3072</span><span class="token punctuation">,</span> hidden_act<span class="token operator">=</span><span class="token string">"gelu"</span><span class="token punctuation">,</span> hidden_dropout_prob<span class="token operator">=</span><span class="token number">0.1</span><span class="token punctuation">,</span> attention_probs_dropout_prob<span class="token operator">=</span><span class="token number">0.1</span><span class="token punctuation">,</span> max_position_embeddings<span class="token operator">=</span><span class="token number">512</span><span class="token punctuation">,</span> type_vocab_size<span class="token operator">=</span><span class="token number">2</span><span class="token punctuation">,</span> initializer_range<span class="token operator">=</span><span class="token number">0.02</span><span class="token punctuation">,</span> output_all_encoded_layers<span class="token operator">=</span><span class="token boolean">False</span><span class="token punctuation">,</span> require_all_hidden_states<span class="token operator">=</span><span class="token boolean">True</span><span class="token punctuation">,</span> batch_first<span class="token operator">=</span><span class="token boolean">True</span><span class="token punctuation">,</span> <span class="token operator">**</span>kwargs<span class="token punctuation">)</span><span class="token punctuation">:</span> self<span class="token punctuation">.</span>hidden_size <span class="token operator">=</span> hidden_size self<span class="token punctuation">.</span>num_hidden_layers <span class="token operator">=</span> num_hidden_layers self<span class="token punctuation">.</span>num_attention_heads <span class="token operator">=</span> num_attention_heads self<span class="token punctuation">.</span>hidden_act <span class="token operator">=</span> hidden_act self<span class="token punctuation">.</span>intermediate_size <span class="token operator">=</span> intermediate_size self<span class="token punctuation">.</span>hidden_dropout_prob <span class="token operator">=</span> hidden_dropout_prob self<span class="token punctuation">.</span>attention_probs_dropout_prob <span class="token operator">=</span> attention_probs_dropout_prob self<span class="token punctuation">.</span>max_position_embeddings <span class="token operator">=</span> max_position_embeddings self<span class="token punctuation">.</span>type_vocab_size <span class="token operator">=</span> type_vocab_size self<span class="token punctuation">.</span>initializer_range <span class="token operator">=</span> initializer_range self<span class="token punctuation">.</span>output_all_encoded_layers <span class="token operator">=</span> output_all_encoded_layers self<span class="token punctuation">.</span>require_all_hidden_states <span class="token operator">=</span> require_all_hidden_states self<span class="token punctuation">.</span>batch_first<span class="token operator">=</span>batch_first <span class="token keyword">if</span> <span class="token builtin">isinstance</span><span class="token punctuation">(</span>vocab_size_or_config_json_file<span class="token punctuation">,</span> <span class="token builtin">str</span><span class="token punctuation">)</span> <span class="token keyword">or</span> <span class="token punctuation">(</span>sys<span class="token punctuation">.</span>version_info<span class="token punctuation">[</span><span class="token number">0</span><span class="token punctuation">]</span> <span class="token operator">==</span> <span class="token number">2</span> <span class="token keyword">and</span> <span class="token builtin">isinstance</span><span class="token punctuation">(</span>vocab_size_or_config_json_file<span class="token punctuation">,</span> <span class="token builtin">unicode</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">:</span> <span class="token keyword">with</span> <span class="token builtin">open</span><span class="token punctuation">(</span>vocab_size_or_config_json_file<span class="token punctuation">,</span> <span class="token string">"r"</span><span class="token punctuation">,</span> encoding<span class="token operator">=</span><span class="token string">'utf-8'</span><span class="token punctuation">)</span> <span class="token keyword">as</span> reader<span class="token punctuation">:</span> json_config <span class="token operator">=</span> json<span class="token punctuation">.</span>loads<span class="token punctuation">(</span>reader<span class="token punctuation">.</span>read<span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span> <span class="token keyword">for</span> key<span class="token punctuation">,</span> value <span class="token keyword">in</span> json_config<span class="token punctuation">.</span>items<span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">:</span> self<span class="token punctuation">.</span>__dict__<span class="token punctuation">[</span>key<span class="token punctuation">]</span> <span class="token operator">=</span> value <span class="token keyword">elif</span> <span class="token builtin">isinstance</span><span class="token punctuation">(</span>vocab_size_or_config_json_file<span class="token punctuation">,</span> <span class="token builtin">int</span><span class="token punctuation">)</span><span class="token punctuation">:</span> self<span class="token punctuation">.</span>vocab_size <span class="token operator">=</span> vocab_size_or_config_json_file <span class="token keyword">else</span><span class="token punctuation">:</span> <span class="token keyword">raise</span> ValueError<span class="token punctuation">(</span><span class="token string">"First argument must be either a vocabulary size (int)"</span> <span class="token string">"or the path to a pretrained model config file (str)"</span><span class="token punctuation">)</span> <span class="token builtin">super</span><span class="token punctuation">(</span>LtgBertConfig<span class="token punctuation">,</span> self<span class="token punctuation">)</span><span class="token punctuation">.</span>__init__<span class="token punctuation">(</span><span class="token operator">**</span>kwargs<span class="token punctuation">)</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><p>必须满足：</p><ul><li>继承自 <code>PretrainedConfig</code></li><li><code>__init__</code>函数接受 <code>kwargs</code>，并且使用<code>super()).__init__</code>传递这些参数</li></ul><p><code>model_type</code>的作用是把模型注册到<code>AutoClass</code>中，建议设置。</p><h2 id="model">Model</h2><p>参考：<a href="https://huggingface.co/docs/transformers/custom_models#building-custom-models">Buildingcustom models (huggingface.co)</a></p><p><code>modeling_xxx.py</code>会存放模型的函数，模块，主要类的代码。</p><p>函数按照正常定义即可，除了函数以外也可以存放一些常量。</p><p>模块基本是需要继承自 <code>nn.Module</code>，关于模块的各种知识参考<code>pytorch</code>教程。</p><p>首先模型需要一个基类，需要是<code>transformers.PreTrainedModel</code>的子类，然后其<code>self.model</code>需要是具体的模型主体，需要实现<code>__init__</code>和<code>forward</code>函数，并且部分参数需要固定，可以参考官方库里的模型源码。</p><p>然后针对每一个下游任务，都需要有对应的类，比如自回归任务需要<code>LlamaForCausalLM</code>。具体要求基本和模型的基类差不多。但是一般会针对下游任务额外多一个分类头等小组件，然后<code>forward</code>函数的部分固定参数可能会变化，基本也是根据已有的源码模仿即可。</p><p>此外，每个模型的类可能会有一些特殊的成员属性，比如<code>_tp_plan = {"lm_head": "colwise_rep"}</code>，是用于配合框架进行模型判断的，一般不设置也没有关系，代码执行时如果遇到缺少该属性的时候框架也会提示。</p><p>我们可以以<code>llama</code>模型举例，查看其模型定义文件里所有类：</p><ul><li>模块类：<ul><li>class LlamaRMSNorm(nn.Module)</li><li>class LlamaRotaryEmbedding(nn.Module)</li><li>class LlamaLinearScalingRotaryEmbedding(LlamaRotaryEmbedding)</li><li>classLlamaDynamicNTKScalingRotaryEmbedding(LlamaRotaryEmbedding)</li><li>class LlamaMLP(nn.Module)</li><li>class LlamaAttention(nn.Module)</li><li>class LlamaFlashAttention2(LlamaAttention)</li><li>class LlamaSdpaAttention(LlamaAttention)</li><li>class LlamaDecoderLayer(nn.Module)</li></ul></li><li>模型类：<ul><li>class LlamaPreTrainedModel(PreTrainedModel)</li><li>class LlamaModel(LlamaPreTrainedModel)</li><li>class LlamaForCausalLM(LlamaPreTrainedModel, GenerationMixin)</li><li>class LlamaForSequenceClassification(LlamaPreTrainedModel)</li><li>class LlamaForQuestionAnswering(LlamaPreTrainedModel)</li><li>class LlamaForTokenClassification(LlamaPreTrainedModel)</li></ul></li><li>函数：<ul><li>对于其中的函数不予列出，因为这没有什么理解难度。</li></ul></li></ul><p>示例：</p><pre class="line-numbers language-python" data-language="python"><code class="language-python"><span class="token keyword">class</span> <span class="token class-name">LtgBertForMaskedLM</span><span class="token punctuation">(</span>PreTrainedModel<span class="token punctuation">)</span><span class="token punctuation">:</span> config_class<span class="token operator">=</span>LtgBertConfig <span class="token keyword">def</span> <span class="token function">__init__</span><span class="token punctuation">(</span>self<span class="token punctuation">,</span>config<span class="token punctuation">,</span>activation_checkpointing<span class="token operator">=</span><span class="token boolean">False</span><span class="token punctuation">)</span><span class="token punctuation">:</span> <span class="token builtin">super</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">.</span>__init__<span class="token punctuation">(</span>config<span class="token punctuation">)</span><span class="token comment"># 这里可以把成员变成类的继承LtgBertForMaskedLM(Bert):</span> self<span class="token punctuation">.</span>model<span class="token operator">=</span>Bert<span class="token punctuation">(</span> config<span class="token operator">=</span>config<span class="token punctuation">,</span> activation_checkpointing<span class="token operator">=</span>activation_checkpointing <span class="token punctuation">)</span> self<span class="token punctuation">.</span>require_all_hidden_states<span class="token operator">=</span>config<span class="token punctuation">.</span>require_all_hidden_states self<span class="token punctuation">.</span>batch_first<span class="token operator">=</span>config<span class="token punctuation">.</span>batch_first <span class="token keyword">def</span> <span class="token function">forward</span><span class="token punctuation">(</span>self<span class="token punctuation">,</span> input_ids<span class="token punctuation">,</span> attention_mask<span class="token punctuation">,</span> masked_lm_labels<span class="token operator">=</span><span class="token boolean">None</span><span class="token punctuation">)</span><span class="token punctuation">:</span> <span class="token keyword">if</span> self<span class="token punctuation">.</span>batch_first<span class="token punctuation">:</span> <span class="token comment"># 模型把batch放在第二个维度</span> input_ids<span class="token operator">=</span>input_ids<span class="token punctuation">.</span>transpose<span class="token punctuation">(</span><span class="token number">0</span><span class="token punctuation">,</span><span class="token number">1</span><span class="token punctuation">)</span> <span class="token keyword">if</span> masked_lm_labels <span class="token keyword">is</span> <span class="token keyword">not</span> <span class="token boolean">None</span><span class="token punctuation">:</span> masked_lm_labels<span class="token operator">=</span>masked_lm_labels<span class="token punctuation">.</span>transpose<span class="token punctuation">(</span><span class="token number">0</span><span class="token punctuation">,</span><span class="token number">1</span><span class="token punctuation">)</span> subword_prediction<span class="token operator">=</span>self<span class="token punctuation">.</span>model<span class="token punctuation">(</span>input_ids<span class="token punctuation">,</span> attention_mask<span class="token punctuation">,</span> masked_lm_labels<span class="token operator">=</span>masked_lm_labels<span class="token punctuation">)</span> loss<span class="token operator">=</span><span class="token boolean">None</span> <span class="token keyword">if</span> masked_lm_labels <span class="token keyword">is</span> <span class="token keyword">not</span> <span class="token boolean">None</span><span class="token punctuation">:</span> target_ids <span class="token operator">=</span> masked_lm_labels<span class="token punctuation">.</span>flatten<span class="token punctuation">(</span><span class="token punctuation">)</span> target_ids <span class="token operator">=</span> target_ids<span class="token punctuation">[</span>target_ids <span class="token operator">!=</span> <span class="token operator">-</span><span class="token number">100</span><span class="token punctuation">]</span> loss <span class="token operator">=</span> F<span class="token punctuation">.</span>cross_entropy<span class="token punctuation">(</span>subword_prediction<span class="token punctuation">,</span> target_ids<span class="token punctuation">)</span> all_hidden_states<span class="token operator">=</span><span class="token boolean">None</span> <span class="token keyword">if</span> self<span class="token punctuation">.</span>require_all_hidden_states<span class="token punctuation">:</span> all_hidden_states<span class="token operator">=</span>self<span class="token punctuation">.</span>model<span class="token punctuation">.</span>get_contextualized<span class="token punctuation">(</span>input_ids<span class="token operator">=</span>input_ids<span class="token punctuation">,</span>attention_mask<span class="token operator">=</span>attention_mask<span class="token punctuation">)</span> <span class="token keyword">if</span> self<span class="token punctuation">.</span>batch_first<span class="token punctuation">:</span> <span class="token keyword">if</span> <span class="token builtin">len</span><span class="token punctuation">(</span>subword_prediction<span class="token punctuation">.</span>size<span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token operator">></span><span class="token number">2</span><span class="token punctuation">:</span> subword_prediction<span class="token operator">=</span>subword_prediction<span class="token punctuation">.</span>transpose<span class="token punctuation">(</span><span class="token number">0</span><span class="token punctuation">,</span><span class="token number">1</span><span class="token punctuation">)</span> <span class="token keyword">if</span> all_hidden_states <span class="token keyword">is</span> <span class="token keyword">not</span> <span class="token boolean">None</span><span class="token punctuation">:</span> all_hidden_states<span class="token operator">=</span><span class="token punctuation">[</span>it<span class="token punctuation">.</span>transpose<span class="token punctuation">(</span><span class="token number">0</span><span class="token punctuation">,</span><span class="token number">1</span><span class="token punctuation">)</span> <span class="token keyword">for</span> it <span class="token keyword">in</span> all_hidden_states<span class="token punctuation">]</span> <span class="token keyword">return</span> MaskedLMOutput<span class="token punctuation">(</span> loss<span class="token operator">=</span>loss<span class="token punctuation">,</span> logits<span class="token operator">=</span>subword_prediction<span class="token punctuation">,</span> hidden_states<span class="token operator">=</span>all_hidden_states<span class="token punctuation">,</span> attentions<span class="token operator">=</span><span class="token boolean">None</span> <span class="token punctuation">)</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><p>对于自定义模型，往往每个<code>AutoClass</code>上都会注册一个模型，因此往往要写多个自定义模型。</p><p><code>config_type</code>的作用是把模型注册到<code>AutoClass</code>中，建议设置。</p><p>由于简约性原则，官方要求<code>self.model</code>对应原来的模型，比如用Pytorch定义的模型。</p><p><code>forward</code>函数需要注意结果格式，<code>transformers.modeling_outputs</code>里定义了每种模型forward的结果格式。</p><p>其中对于每个特定的子任务都有个类似的模型，对于部分函数比如forward建议参考已有的代码进行操作，因为hf框架在使用特定子任务的模型的时候，可能会添加特殊的参数。比如，对于序列分类任务SequenceClassification，其中相关模型的forward为：</p><pre class="line-numbers language-none"><code class="language-none">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 )<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><p>这里hf框架会在配置中添加problem_type等内容。</p><h2 id="注册">注册</h2><p>如果在ckpt文件夹的 <code>config.json</code>里没有<code>auto_map</code>指明 <code>AutoClass</code>的注册：</p><pre class="line-numbers language-json" data-language="json"><code class="language-json"><span class="token property">"auto_map"</span><span class="token operator">:</span> <span class="token punctuation">{</span> <span class="token property">"AutoConfig"</span><span class="token operator">:</span> <span class="token string">"configuration_ltgbert.LtgBertConfig"</span><span class="token punctuation">,</span> <span class="token property">"AutoModelForMaskedLM"</span><span class="token operator">:</span> <span class="token string">"modeling_ltgbert.LtgBertForMaskedLM"</span><span class="token punctuation">,</span> <span class="token property">"AutoModelForSequenceClassification"</span><span class="token operator">:</span> <span class="token string">"modeling_ltgbert.LtgBertForSequenceClassification"</span><span class="token punctuation">,</span> <span class="token property">"AutoModelForCausalLM"</span><span class="token operator">:</span> <span class="token string">"modeling_ltgbert.LtgBertForCausalLM"</span><span class="token punctuation">}</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><p>那么需要手动添加，在读取ckpt的代码里添加：</p><pre class="line-numbers language-python-repl" data-language="python-repl"><code class="language-python-repl">AutoConfig.register("LtgBert", LtgBertConfig)AutoModelForMaskedLM.register(LtgBertConfig, LtgBertForMaskedLM)AutoModelForSequenceClassification.register(LtgBertConfig, LtgBertForSequenceClassification)AutoModelForCausalLM.register(LtgBertConfig, AutoModelForCausalLM)<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span></span></code></pre><p>如果希望在保存模型的时候 <code>config.json</code>文件中自动包含<code>auto_map</code>，可以在模型代码文件里添加以下代码（如果模型是从ckpt里加载的就不需要添加）：</p><pre class="line-numbers language-python" data-language="python"><code class="language-python">LtgBertConfig<span class="token punctuation">.</span>register_for_auto_class<span class="token punctuation">(</span><span class="token punctuation">)</span>LtgBertForMaskedLM<span class="token punctuation">.</span>register_for_auto_class<span class="token punctuation">(</span><span class="token string">"AutoModelForMaskedLM"</span><span class="token punctuation">)</span>LtgBertForSequenceClassification<span class="token punctuation">.</span>register_for_auto_class<span class="token punctuation">(</span><span class="token string">"AutoModelForSequenceClassification"</span><span class="token punctuation">)</span>LtgBertForCausalLM<span class="token punctuation">.</span>register_for_auto_class<span class="token punctuation">(</span><span class="token string">"AutoModelForCausalLM"</span><span class="token punctuation">)</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span></span></code></pre><p>后来发现只有注册可能会存在 <code>config.json</code>里<code>auto_map</code>不完整的情况（原因暂时没有调查），可以考虑直接在<code>config.__init__</code>里强制指定：</p><pre class="line-numbers language-none"><code class="language-none">def __init__(self,....): ... self.auto_map={ "AutoConfig": "configuration_ltgbert.LtgBertConfig", "AutoModelForMaskedLM": "modeling_ltgbert.LtgBertForMaskedLM", "AutoModelForSequenceClassification": "modeling_ltgbert.LtgBertForSequenceClassification", "AutoModelForCausalLM": "modeling_ltgbert.LtgBertForCausalLM" }<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><h2 id="trainer">Trainer</h2><p>训练流程的转换主要设计HF的 <code>Trainer</code>类，可以参考<a href="https://huggingface.co/docs/transformers/main/zh/main_classes/trainer">Trainer(huggingface.co)</a>和<a href="https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.TrainingArguments">Trainer(huggingface.co)</a>。</p><p><code>Trainer</code>把训练的流程分为几个过程，通过继承以及重写相关函数即可完成流程的定制，通过参数即可实现超参数的设置，细节阅读参考资料。</p><h2 id="dataset">Dataset</h2><p><code>dataset</code>可以继承自<code>torch.utils.data.dataset</code>，但是需要注意<code>__getitem__</code>，默认情况该函数返回的需要满足<code>dict</code>格式，从而实现参数的设置。</p><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href="https://huggingface.co/docs/transformers/custom_models#building-custom-models">Buildingcustom models (huggingface.co)</a></li><li><a href="https://huggingface.co/docs/transformers/main/zh/main_classes/trainer">Trainer(huggingface.co)</a></li><li><a href="https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.TrainingArguments">Trainer(huggingface.co)</a></li></ul></blockquote>]]></content>
<categories>
<category> 模板 </category>
</categories>
<tags>
<tag> 模板 </tag>
<tag> 深度学习 </tag>
<tag> PyTorch </tag>
<tag> HuggingFace </tag>
<tag> Trainer </tag>
<tag> config </tag>
<tag> model </tag>
<tag> dataset </tag>
</tags>
</entry>
<entry>
<title>随机数种子</title>
<link href="//7369/"/>
<url>//7369/</url>
<content type="html"><![CDATA[<h1 id="介绍">介绍</h1><p>在深度学习的实际项目中，为了减少随机性，增强项目的复现能力，设置固定随机数种子十分重要，因此这篇文章罗列了一些设置随机种子的方法和减少项目随机性的经验。</p><h1 id="通用函数">通用函数</h1><pre class="line-numbers language-python" data-language="python"><code class="language-python"><span class="token keyword">def</span> <span class="token function">set_random_seed</span><span class="token punctuation">(</span>seed<span class="token punctuation">)</span><span class="token punctuation">:</span> <span class="token triple-quoted-string string">"""Set random seeds."""</span> os<span class="token punctuation">.</span>environ<span class="token punctuation">[</span><span class="token string">'PYTHONHASHSEED'</span><span class="token punctuation">]</span> <span class="token operator">=</span> <span class="token builtin">str</span><span class="token punctuation">(</span>seed<span class="token punctuation">)</span> random<span class="token punctuation">.</span>seed<span class="token punctuation">(</span>seed<span class="token punctuation">)</span> <span class="token comment"># 设置 Python 内置随机库的种子</span> np<span class="token punctuation">.</span>random<span class="token punctuation">.</span>seed<span class="token punctuation">(</span>seed<span class="token punctuation">)</span> <span class="token comment"># 设置 NumPy 随机库的种子</span> torch<span class="token punctuation">.</span>manual_seed<span class="token punctuation">(</span>seed<span class="token punctuation">)</span> <span class="token comment"># 设置 PyTorch 随机库的种子</span> torch<span class="token punctuation">.</span>cuda<span class="token punctuation">.</span>manual_seed<span class="token punctuation">(</span>seed<span class="token punctuation">)</span> <span class="token comment"># 为当前 CUDA 设备设置种子</span> torch<span class="token punctuation">.</span>cuda<span class="token punctuation">.</span>manual_seed_all<span class="token punctuation">(</span>seed<span class="token punctuation">)</span> <span class="token comment"># 为所有 CUDA 设备设置种子</span><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><h2 id="scikit-learn">Scikit-learn</h2><p>在 <code>Scikit-learn</code>中，部分算法需要设置<code>random_state</code>，比如聚类算法 <code>kmeans</code>。</p><pre class="line-numbers language-python" data-language="python"><code class="language-python">KMeans<span class="token punctuation">(</span>n_clusters<span class="token operator">=</span><span class="token number">2</span><span class="token punctuation">,</span>random_state<span class="token operator">=</span><span class="token number">42</span><span class="token punctuation">)</span><span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre><h1 id="工程经验">工程经验</h1><ol type="1"><li>由于部分原因，一些python数组或者python集合等，可能顺序也会影响结果的随机性。如果在无法确保顺序是固定的或者顺序是有要求的情况下，尝试对这些中间结果进行排序减少随机性。</li></ol><h1 id="参考资料">参考资料</h1><blockquote><ul><li><a href="https://blog.csdn.net/yangweipeng708/article/details/138793949">【Python】深度学习中随机数种子seed的种类和设置方式_seed设置-CSDN博客</a></li></ul></blockquote>]]></content>
<categories>
<category> 深度学习 </category>
<category> 工程细节 </category>
</categories>
<tags>
<tag> 深度学习 </tag>
<tag> 随机数 </tag>
</tags>
</entry>
<entry>
<title>vscode调试python</title>
<link href="//30403/"/>
<url>//30403/</url>
<content type="html"><![CDATA[<h2 id="介绍">介绍</h2><p>在学习项目的过程中，很多时候需要通过调试来高效率的了解代码的执行过程，因此这里介绍下怎么使用vscode对python程序进行调试。</p><h2 id="方法一简单图标点击">方法一：简单图标点击</h2><p>vscode对一些简单的程序提供了一些可视化的调试方式，对于一些不需要指定参数等简单的调试功能，可以直接点击vscode左上角的几个图标进行debug过程。由于过于简单，此处不做介绍。</p><p><img src="/30403/1713538455137.png"></p><h2 id="方法二编辑launch.json文件">方法二：编辑launch.json文件</h2><p>在工作目录下的<code>./vscode/launch.json</code>文件里面，指定了各种debug和程序运行的参数、环境、解释器、目录等基本所有的环境配置。</p><p>可以在左下角的添加配置里面快速添加常见的选项。</p><p>比如下面所示：</p><pre class="line-numbers language-none"><code class="language-none">{ // 使用 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" } ]}<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><p>这里参数非常多（建议使用的时候查询<code>gpt</code>、<code>搜索引擎</code>、<code>文档</code>等。</p><p>这里介绍几个常用的选项。此外，在编辑的时候可以类似<code>Linux</code>那样使用 <code>${fileDirname}</code>来引用<code>vscode</code>程序的当前变量比如工作目录</p><table><thead><tr><th>参数</th><th>含义</th><th>类型</th></tr></thead><tbody><tr><td>name</td><td>过程名字</td><td>str</td></tr><tr><td>type</td><td>过程类型</td><td>str</td></tr><tr><td>python</td><td>解释器（使用虚拟环境的时候需要注意指定</td><td>str</td></tr><tr><td>program</td><td>程序文件，按照脚本方式运行过程</td><td>str</td></tr><tr><td>module</td><td>模块名，按照模块方式运行过程</td><td>str</td></tr><tr><td>args</td><td>运行过程的参数</td><td>list</td></tr><tr><td>env</td><td>环境变量</td><td>dict</td></tr><tr><td>cwd</td><td>工作目录</td><td>str</td></tr></tbody></table><blockquote><p>此外，在使用的过程中python里面绝对引入、相对引入等。建议参考<a href="https://zhuanlan.zhihu.com/p/416867942">python相对导入常见问题和解决方案- 知乎 (zhihu.com)</a> 。</p><p>此处发现那里也有些没有提及的东西。</p><ul><li>解决方案错误一：ImportError: attempted <strong>relativeimport</strong> with no known parent package 里可以不修改代码，使用<code>python -m</code>命令+调整工作目录成功运行。（笔者当时遇到一个坑，当时没有注意的调试的是工程目录里的qllm文件还是env里装的py包</li></ul></blockquote><h2 id="方法三使用debug.py文件引入要调试的文件">方法三：使用debug.py文件引入要调试的文件</h2><p>如题，建立一个<code>debug.py</code>文件引入要调试的文件，类似于使用代理进行调试过程。</p><iframe src="https://player.bilibili.com/player.html?isOutside=true&aid=656228835&bvid=BV1ta4y1u78v&cid=1129808210&p=1" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true" style="width:100%;aspect-ratio:16/9;"></iframe><p>参考<a href="https://www.bilibili.com/video/BV1ta4y1u78v/?spm_id_from=333.337.search-card.all.click&vd_source=6ca4c818110b061ac41dc3fcd0178f77">【Python入门】新手必会 vscode Debug 调试技巧_哔哩哔哩_bilibili</a></p><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href="https://zhuanlan.zhihu.com/p/416867942">python相对导入常见问题和解决方案- 知乎 (zhihu.com)</a></li><li><a href="https://www.bilibili.com/video/BV1ta4y1u78v/?spm_id_from=333.337.search-card.all.click&vd_source=6ca4c818110b061ac41dc3fcd0178f77">【Python入门】新手必会 vscode Debug 调试技巧_哔哩哔哩_bilibili</a></li></ul></blockquote>]]></content>
<categories>
<category> 杂项 </category>
</categories>
<tags>
<tag> vscode </tag>
<tag> python </tag>
<tag> 调试 </tag>
<tag> debug </tag>
</tags>
</entry>
<entry>
<title>nlp常用排行榜</title>
<link href="//63314/"/>
<url>//63314/</url>
<content type="html"><![CDATA[<h2 id="介绍">介绍</h2><p>在工作和学习的时候发现，很多时候挑选合适的模型和数据集等也是一个重要且麻烦的过程。发现有很多相关的评测的排行榜，根据这些实时更新的排行榜，可以辅助我们进行选择模型等前期工作。</p><p><a href="https://huggingface.co/spaces">Spaces - Hugging Face</a></p><p>这里罗列了许多关于ai的最新新闻，也能搜索到各种排行榜leaderboard。</p><h3 id="nlp任务">nlp任务</h3><p><a href="https://huggingface.co/spaces/mteb/leaderboard">MTEBLeaderboard - a Hugging Face Space by mteb</a></p><p>Massive Text Embedding Benchmark (MTEB)，是关于文本嵌入的排行榜，同时关注排行榜的like人数（从某种意义上反应排行榜的效用）。</p><h3 id="大模型评测">大模型评测</h3><p><a href="https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard">OpenLLM Leaderboard - a Hugging Face Space by HuggingFaceH4</a></p><p>这里提供了各种关于大模型在多维度的数据集上的表现能力，并且支持根据大模型的类型、精度等过滤大模型排行榜。</p><p><a href="https://huggingface.co/spaces/bigcode/bigcode-models-leaderboard">BigCode Models Leaderboard - a Hugging Face Space by bigcode</a></p><p>这里提供了关于大模型code能力的排行榜。</p><p><a href="https://huggingface.co/spaces/lmsys/chatbot-arena-leaderboard">LMSysChatbot Arena Leaderboard - a Hugging Face Space by lmsys</a></p><p>这里提供了关于大模型对话能力的排行榜（但是由于不知名原因暂时无法打开）。</p><p><a href="https://chat.lmsys.org/">Chat with Open Large LanguageModels (lmsys.org)</a></p><p>这里是关于大模型对话能力的测评网站，也提供了参考用的排行榜。</p><p><a href="https://huggingface.co/spaces/optimum/llm-perf-leaderboard">LLM-PerfLeaderboard - a Hugging Face Space by optimum</a></p><p>这里提供了大模型在给定硬件条件的训练资源后微调的性能排行榜。</p><p><a href="https://huggingface.co/spaces/logikon/open_cot_leaderboard">OpenCoT Leaderboard - a Hugging Face Space by logikon</a></p><p>这里提供了关于大模型CoT（Chain of Thought）的排行榜。</p><h3 id="数据集">数据集</h3><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href></a></li><li><a href></a></li></ul></blockquote>]]></content>
<categories>
<category> 深度学习 </category>
<category> 自然语言处理 </category>
</categories>
</entry>
<entry>
<title>pytroch_tutorials杂项</title>
<link href="//20669/"/>
<url>//20669/</url>
<content type="html"><![CDATA[<h2 id="介绍">介绍</h2><p>当作快速过这个资料的笔记，一些关于别的库的介绍是不完全的，考虑在使用的时候从别的信息渠道就行信息的搜集。也可以作为后面待更博客列举？</p><h2 id="常用方式">常用方式</h2><p>可以参考<a href="https://zhuanlan.zhihu.com/p/576691638">huggingfacetransformers教程总结 - 知乎 (zhihu.com)</a>（这篇教程很多是基于tf的，使用时候可以考虑换成pt）和 <a href="https://huggingface.co/docs">Hugging Face - Documentation</a>。</p><h2 id="tutorials具体中文版本">tutorials具体（中文版本）</h2><p><a href="https://huggingface.co/docs/transformers/main/zh/autoclass_tutorial">使用AutoClass加载预训练实例(huggingface.co)</a></p><p>这里有个注意的点是使用AutoModelForSequenceClassification可能会在模型后面添加一层来适应下游任务（别的类似的类可能也会有类似的做法），如果想不添加任何层直接使用，考虑使用AutoModel类来加载模型。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/preprocessing">预处理(huggingface.co)</a></p><p>这里介绍了怎么预处理各种数据比如文本，多模态，图片等。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/training">微调预训练模型(huggingface.co)</a></p><p>这里介绍了怎么使用<code>transformers.Trainer</code>类和pytorch原生代码来微调模型（pytorchlighting也提供了一个Trainer）。</p><p>也介绍了怎么使用huggingface的github上分享的脚本来微调模型<a href="https://github.com/huggingface/transformers">huggingface/transformers:🤗 Transformers: State-of-the-art Machine Learning for Pytorch,TensorFlow, and JAX. (github.com)</a>，</p><p>accelerate提供了accelerate config命令通过命令行交互帮助配置文件。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/accelerate#%E8%AE%BE%E7%BD%AE">🤗加速分布式训练 (huggingface.co)</a></p><p>这里介绍了怎么使用accelerate来进行分布式训练，流程非常简单，基本就是pytorch框架单卡训练的代码改个四五行。</p><p><a href="https://huggingface.co/docs/transformers/v4.39.1/zh/peft">使用 🤗PEFT 加载adapters (huggingface.co)</a></p><p>这里大致介绍了怎么使用<code>perf</code>库进行高效的参数微调，具体表现为通过<code>adapters</code>实现少参数调整，还大致介绍了怎么量化加载、启用、禁止、训练等。</p><p><a href="https://huggingface.co/docs/transformers/v4.39.1/zh/transformers_agents">TransformersAgents (huggingface.co)</a></p><p>这里介绍了transformers新版本提供的一个api（测试版可能随时变化），通过自然语言来辅助进行功能实现，类似于通过自然语言编程。</p><p><a href="https://huggingface.co/docs/transformers/v4.39.1/zh/llm_tutorial">使用LLMs进行生成(huggingface.co)</a></p><p>这里大致介绍了怎么使用<code>model.generate()</code>进行更好且多样化生成。</p><p><a href="https://huggingface.co/docs/transformers/v4.39.1/zh/fast_tokenizers">使用🤗 Tokenizers 中的分词器 (huggingface.co)</a></p><p>大概介绍了怎么训练、保存和加载分词器tokenizer。</p><p><a href="https://huggingface.co/docs/transformers/v4.39.1/zh/multilingual">用于推理的多语言模型(huggingface.co)</a></p><p>介绍了一些常用的多语言翻译模型。</p><p><a href="https://huggingface.co/docs/transformers/v4.39.1/zh/create_a_model">创建自定义架构(huggingface.co)</a></p><p>如题，使用一些配置文件自定义模型架构和各种处理器比如自然语言处理的分词器、语音识别的特征提取器等。</p><p><a href="https://huggingface.co/docs/transformers/v4.39.1/zh/custom_models#%E7%BC%96%E5%86%99%E8%87%AA%E5%AE%9A%E4%B9%89%E6%A8%A1%E5%9E%8B">共享自定义模型(huggingface.co)</a></p><p>这里介绍了怎么自定义模型，推送到hub上面以及怎么在AutoClass（比如AutoModel等）上面注册。</p><p><a href="https://huggingface.co/docs/transformers/v4.39.1/zh/chat_templating#%E6%88%91%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8%E8%81%8A%E5%A4%A9%E6%A8%A1%E6%9D%BF">聊天模型的模板(huggingface.co)</a></p><p>这里介绍了聊天的模板，怎么把多轮对话转变成一个字符串输入模型。并且支持用户自定义模板和使用内置模板等功能。自定义模板的办法使用的是Jinja。</p><p><a href="https://huggingface.co/docs/transformers/v4.39.1/zh/serialization">导出为ONNX (huggingface.co)</a></p><p>这里介绍了怎么通过Optimum库把模型导出为ONNX格式，ONNX模式下为公开具有标准化运算符和数据类型的图，可以进行各种优化和框架间的相互转移。</p><p>（这里还介绍了transformers.onnx，但这个库已经停止了维护并且回头会从教程里删去</p><p><a href="https://huggingface.co/docs/transformers/v4.39.1/zh/tflite">导出为TFLite (huggingface.co)</a></p><p><a href="https://www.tensorflow.org/lite/guide">TensorFlow Lite</a>是一个轻量级框架，用于资源受限的设备上，如手机、嵌入式系统和物联网（IoT）设备，部署机器学习模型，其文件扩展名为<code>.tflite</code>，同样可以通过Optimum库导出。</p><p><a href="https://huggingface.co/docs/transformers/v4.39.1/zh/torchscript">导出为TorchScript (huggingface.co)</a></p><p>这里关于torchscirpt的介绍可以参考pytorch的，这里还介绍了使用 NeuronSDK 将 Hugging Face TorchScript 模型部署到 AWS。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/performance">性能与可扩展性(huggingface.co)</a></p><p>这是关于训练和推理的综述，里面有许多指向英语文档的链接。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/fsdp">完全分片数据并行(huggingface.co)</a></p><p>介绍了怎么使用accelerate把模型参数切片在多个GPU运行以及部分优化。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/perf_hardware">训练用的定制硬件(huggingface.co)</a></p><p>这里引入了怎么更好的使用和了解硬件，但只是引入，还是需要后期继续深入学习。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/hpo_train">使用TrainerAPI进行超参数搜索 (huggingface.co)</a></p><p>如题，支持多种超参数搜索框架。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/big_models">实例化大型模型(huggingface.co)</a></p><p>这里介绍了怎么加载大模型，降低内存，具体表现为分片，把权重文件分成多个。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/debugging">调试(huggingface.co)</a></p><p>这里介绍了怎么使用脚本进行多GPU网络问题调试和上溢下溢检测（通过hook函数统计每个模块的输入和输出的绝对值的极值）。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/perf_torch_compile">使用torch.compile() 优化推理 (huggingface.co)</a></p><p>torch.compile() 优化推理过程，并且列出了许多实验结果。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/add_new_pipeline">如何创建自定义流水线？(huggingface.co)</a></p><p>这里介绍了怎么自定义流水线pipeline并且注册和推送到云端。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/tokenizer_summary#%E5%AD%90%E8%AF%8D%E5%88%86%E8%AF%8D">分词器的摘要(huggingface.co)</a></p><p>这里介绍了许多分词算法，如何构造tokenizer。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/main_classes/agent#transformers.Tool.setup">Agents和工具(huggingface.co)</a></p><p>这里介绍了各种各样的agent和tools，agents相较于模型可以使用tools。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/main_classes/callback">Callbacks(huggingface.co)</a></p><p>Callbacks可以用来自定义PyTorch[Trainer]中训练循环行为的对象（此功能尚未在TensorFlow中实现），该对象可以检查训练循环状态（用于进度报告、在TensorBoard或其他ML平台上记录日志等），并做出决策（例如提前停止）。</p><p>这里介绍了一些常用的callbacks，怎么自定义callbacks，TrainerState代表当前训练状态，TrainerControl控制训练循环。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/main_classes/configuration">Configuration(huggingface.co)</a></p><p>介绍了Pretrainedconfig类。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/main_classes/data_collator">DataCollator (huggingface.co)</a></p><p>这里介绍了各种Data collators来处理数据。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/main_classes/logging">Logging(huggingface.co)</a></p><p>这里介绍了transformers的日志系统。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel">模型(huggingface.co)</a></p><p>这里介绍了怎么使用PretrainedModel，由于一定原因，官方似乎推荐PretrainedModel是用于对model的一层包装，forward等函数在model里面实现。</p><p>还介绍了ModuleUtilsMixin，这个是py通过多继承扩展模型功能的一个类，可以参考<a href="https://blog.csdn.net/u012814856/article/details/81355935">一个例子走近Python 的 Mixin 类：利用 Python多继承的魔力_mixin类-CSDN博客</a>学习Mixin类和调用顺序。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/main_classes/text_generation">Generation(huggingface.co)</a></p><p>这里介绍了GenerationConfig和GenerationMixin来使得模型进行多样化的生成过程，扩展了模型的功能。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/main_classes/onnx#%E5%AF%BC%E5%87%BA--transformers-%E6%A8%A1%E5%9E%8B%E5%88%B0-onnx">导出🤗 Transformers 模型到 ONNX (huggingface.co)</a></p><p>这里介绍了一些配置类来帮助transformers模型导出到ONNX。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/main_classes/optimizer_schedules">Optimization(huggingface.co)</a></p><p>这里只是列举了几个模型参数跟新过程会用到的优化器等，但不是很全，也不是很深入，连示例过程都没有。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/main_classes/output">模型输出(huggingface.co)</a></p><p>Transformers库所有模型的输出都是 <a href="https://huggingface.co/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a>的子类的实例，这里介绍了许多输出类和基本的类。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/main_classes/pipelines">Pipelines(huggingface.co)</a></p><p>这里介绍了许多Pipeline和自定义Pipeline。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/main_classes/processors">Processors(huggingface.co)</a></p><p>这个库大概介绍了Processor类，用于编码或者解码多模型输入并且组合。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/main_classes/quantization#autogptq-%E9%9B%86%E6%88%90">量化🤗 Transformers 模型 (huggingface.co)</a></p><p>这个大致介绍了常见的量化方法并给了简答的示例。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/main_classes/tokenizer#transformers.BatchEncoding">Tokenizer(huggingface.co)</a></p><p>大致介绍了Tokenizer和常用的办法。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/main_classes/trainer#pytorch%E5%AE%8C%E5%85%A8%E5%88%86%E7%89%87%E6%95%B0%E6%8D%AE%E5%B9%B6%E8%A1%8Cfsdp">Trainer(huggingface.co)</a></p><p>这里介绍了Transformers的Trainer，同时说明了这个Trainer用于别的库的模型时要注意的问题，同时还介绍了一些常用的问题和通过accelerate使用Trainer。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/main_classes/deepspeed">DeepSpeed集成(huggingface.co)</a></p><p>这里介绍了DeepSpeed的很多常用的配置选项（非常复杂，挖坑todo</p><p><a href="https://huggingface.co/docs/transformers/main/zh/main_classes/feature_extractor#transformers.ImageFeatureExtractionMixin">FeatureExtractor (huggingface.co)</a></p><p>这里介绍了Feature负责为音频或视觉模型准备输入特征。这包括从序列中提取特征。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/main_classes/image_processor">ImageProcessor (huggingface.co)</a></p><p>这里介绍了对于图像处理的Processor。</p><h3 id="这里往后就是介绍一些功能类可以用于扩展调试控制等功能">这里往后就是介绍一些功能类，可以用于扩展、调试控制等功能</h3><p><a href="https://huggingface.co/docs/transformers/main/zh/internal/modeling_utils#transformers.modeling_tf_utils.TFConv1D">自定义层和工具(huggingface.co)</a></p><p>这里介绍了一些Transformers库的为模型提供的自定义层和帮助函数（底层还是调用的pytorch或者TensorFlow，但是组合了一些常用的层。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/internal/pipelines_utils">pipelines的工具(huggingface.co)</a></p><p>这里介绍了一些为Pipeline使用的功能类。</p><p><a href="https://huggingface.co/docs/transformers/main/zh/internal/tokenization_utils">Tokenizers的工具(huggingface.co)</a></p><p><a href="https://huggingface.co/docs/transformers/main/zh/internal/trainer_utils">Trainer的工具(huggingface.co)</a></p><p><a href="https://huggingface.co/docs/transformers/main/zh/internal/trainer_utils">用于生成的工具(huggingface.co)</a></p><p><a href="https://huggingface.co/docs/transformers/main/zh/internal/image_processing_utils">ImageProcessors的工具 (huggingface.co)</a></p><p><a href="https://huggingface.co/docs/transformers/main/zh/internal/audio_utils">FeatureExtractors的工具 (huggingface.co)</a></p><p><a href="https://huggingface.co/docs/transformers/main/zh/internal/file_utils">通用工具(huggingface.co)</a></p><p><a href="https://huggingface.co/docs/transformers/main/zh/internal/time_series_utils">时间序列工具(huggingface.co)</a></p>]]></content>
<categories>
<category> 杂项 </category>
<category> huggingface </category>
</categories>
<tags>
<tag> transformers_tutorials </tag>
</tags>
</entry>
<entry>
<title>pytorch_model</title>
<link href="//42347/"/>
<url>//42347/</url>
<content type="html"><![CDATA[<h2 id="介绍">介绍</h2><p>作为深度学习的基本模板使用，方便使用的时候作为骨架</p><p>许多文件可以考虑添加<strong>argparse</strong>和<strong><em>sh</em></strong>来引入外部配置来抽象过程，增强代码重用性</p><h2 id="dataset.py">dataset.py</h2><p>这个文件提供了各种数据集的定义，自定义数据集需要实习三个主要函数</p><pre class="line-numbers language-none"><code class="language-none">class MyDataset(torch.utils.data.Dataset): def __init__(self):super().__init__()#todo def __getitem__(self,idx):#todo def __len__(self):#todo<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><h2 id="models.py">models.py</h2><p>这个文件负责提供各种模型的定义，可以是完全自定义的模型或者预训练模型</p><pre class="line-numbers language-none"><code class="language-none">class MyModel(torch.nn.Module): def __init__(self)super().__init__()#todo def forward(self,input):#tododef get_model(config): #todo return model<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><h2 id="criterion.py">criterion.py</h2><p>这个文件负责提供各种损失函数的定义，可以是完全自定义的损失函数或者框架提供的损失函数</p><pre class="line-numbers language-none"><code class="language-none">class CustomLoss(nn.Module): def __init__(self): super(CustomLoss, self).__init__() # 在这里初始化你的参数，如果有的话 def forward(self, input, target): # 计算损失的逻辑 # 例如，这里我们使用简单的均方误差作为示例 loss = torch.mean((input - target) ** 2) return lossdef get_criterion() #todo<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><h2 id="optimizer.py">optimizer.py</h2><p>这个文件负责提供各种优化器的定义，可以是完全自定义的优化器或者框架提供的优化器</p><pre class="line-numbers language-none"><code class="language-none">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 lossdef get_Optimizer(): #todo<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><h2 id="lr_scheduler.py">lr_scheduler.py</h2><p>这个文件负责提供各种学习率调度器的定义，可以是完全自定义的学习率调度器或者框架提供的学习率调度器</p><pre class="line-numbers language-none"><code class="language-none">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'] = lrdef get_lr_scheduler() #todo<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><h2 id="train.py">train.py</h2><p>这个文件负责提供各种训练方法和过程</p><pre class="line-numbers language-none"><code class="language-none">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 <span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><h2 id="main.py">main.py</h2><p>主要负责对于各个文件部分的引用，整合代码，基本逻辑为</p><pre class="line-numbers language-none"><code class="language-none">#数据集dataset#数据迭代器dataloader#模型model#损失函数criterion#优化器optimizer#学习率优化器lr_scheduler#训练train#保存save#预测predict<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><h2 id="可选优化">可选优化</h2><ul><li>梯度裁剪 torch.nn.utils.clip_grad_norm_</li><li>加载最优参数</li><li>...</li></ul><h2 id="其他">其他</h2><p>可以去<a href="https://pytorch.org/tutorials/">pytorch官网</a>找找一些关于模型的优化。</p><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href></a></li><li><a href></a></li></ul></blockquote>]]></content>
<categories>
<category> 模板 </category>
</categories>
<tags>
<tag> 模板 </tag>
<tag> 深度学习 </tag>
</tags>
</entry>
<entry>
<title>信息熵</title>
<link href="//5656/"/>
<url>//5656/</url>
<content type="html"><![CDATA[<h2 id="信息熵的公式"><strong>信息熵的公式</strong></h2><p>计算信息熵的公式为:</p><p><span class="math display">\[H(x)=-\sum p(x_i)logp(x_i)\]</span></p><p>其中<span class="math inline">\(p(x_i)\)</span>表示事件结果为<span class="math inline">\(x_i\)</span>的概率</p><h2 id="理解">理解</h2><p>信息熵表示对事件不确定性的一个度量，计算思路为“编码一个事件的最短平均编码长度”（任意进制编码都行，彼此差一个常数，但常用的是二进制以及自然对数）</p><p>所以信息熵的计算也可以写作：</p><p><span class="math display">\[H(x)=\sum p(x_i)f(x_i)\]</span></p><p>其中<span class="math inline">\(p(x_i)\)</span>表示事件结果为<span class="math inline">\(x_i\)</span>的概率，<span class="math inline">\(f(x_i)\)</span>为编码<span class="math inline">\(x_i\)</span>需要的位数（这也是为什么在比较概率分布的时候，会选择用拟合的概率来计算<span class="math inline">\(f(x_i)\)</span>）</p><h1 id="huffman编码树">Huffman编码树</h1><p>类比哈夫曼树，根据贪心思想，</p><ul><li>出现概率大的结果应该占据相对短的编码</li><li>编码结果的种类和编码位数是指数级关系</li></ul><p>所以我们得到</p><p><span class="math display">\[f(x_i)=-logp(x_i)\]</span></p><p>代入就得到了最终形式。</p><h2 id="应用">应用</h2><ul><li>KL散度</li><li>交叉熵损失</li></ul><h2 id="参考资料">参考资料</h2>]]></content>
<categories>
<category> 数学 </category>
<category> 概率论 </category>
</categories>
<tags>
<tag> 数学 </tag>
<tag> 信息学 </tag>
</tags>
</entry>
<entry>
<title>pytroch_tutorials杂项</title>
<link href="//20668/"/>
<url>//20668/</url>
<content type="html"><![CDATA[<h2 id="介绍">介绍</h2><p>当作快速过这个资料的笔记，一些关于别的库的介绍是不完全的，考虑在使用的时候从别的信息渠道就行信息的搜集。也可以作为后面待更博客列举？</p><h2 id="具体">具体</h2><h3 id="torchscript">torchscript</h3><p><a href="https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html">Introductionto TorchScript — PyTorch Tutorials 2.2.1+cu121 documentation</a></p><p><a href="https://pytorch.org/tutorials/advanced/cpp_export.html">Loading aTorchScript Model in C++ — PyTorch Tutorials 2.2.1+cu121documentation</a></p><p>这里介绍了把pytorch模型转换成torchscript的两种方法torch.jit.trace和torch.jit.script，前者会失去控制流信息，后者会保留控制流信息（具体查阅文档）。</p><p>转化为torchscript有以下好处：</p><ul><li>不需要Python解释器也可以运行，可以被pytorch自带的特殊解释器直接使用</li><li>转为torchscript可以进行各种优化，提高运行效率</li><li>方便被其他语言调用</li></ul><h3 id="onnx">ONNX</h3><p><a href="https://pytorch.org/tutorials/advanced/super_resolution_with_onnxruntime.html">(optional)Exporting a Model from PyTorch to ONNX and Running it using ONNX Runtime— PyTorch Tutorials 2.2.1+cu121 documentation</a></p><p>这里介绍了在高效且跨平台ONNX运行环境部署的基本教程，通过torch.onnx把模型转化为onnx格式并保存，然后读取本地保存onnx格式模型并运行。</p><h3 id="剖析pytorch-model">剖析pytorch model</h3><p><a href="https://pytorch.org/tutorials/beginner/profiler.html">Profilingyour PyTorch Module — PyTorch Tutorials 2.2.1+cu121documentation</a></p><p>这里介绍了torch.autograd.profiler,在代码里添加withprofiler.record_function("MASKINDICES"):可以记录代码运行的指标，比如时间，cpu和内存使用率等，名字可以自定义，支持可视化结果。</p><p><a href="https://pytorch.org/tutorials/beginner/hta_intro_tutorial.html">Introductionto Holistic Trace Analysis — PyTorch Tutorials 2.2.1+cu121documentation</a></p><p><a href="https://pytorch.org/tutorials/beginner/hta_trace_diff_tutorial.html">TraceDiff using Holistic Trace Analysis — PyTorch Tutorials 2.2.1+cu121documentation</a></p><p>这里介绍了HolisticTraceAnalysis（HTA），一个用来剖析GPU运行情况的库。</p><p>把GPU运行时间分为了等待时间、计算时间和非计算时间，方便开发者评测模型运行的情况。还支持查看GPU内部的运行情况，也支持和之前的记录进行对比，也能可视化结果。</p><h3 id="troch.fx-操作计算图">troch.fx 操作计算图</h3><p><a href="https://pytorch.org/tutorials/intermediate/fx_conv_bn_fuser.html">（测试版）在FX 中构建卷积/批量范数热熔器 — PyTorch 教程 2.2.1+cu121 文档</a></p><p><code>torch.fx</code> 是 PyTorch提供的一个模块，它允许用户通过操作计算图来转换和优化 PyTorch模型。这个模块提供了一种方式来表示和操作 PyTorch模型的抽象，使得开发者可以更容易地对模型进行修改，例如重构模型结构、插入调试代码、优化性能等。</p><p>教程里介绍了一种融合相邻层的操作（只能用于eval模式）。比如融合卷积和归一化，融合之前，模型会把卷积结果写回显存，然后在调用归一化并且从显存读取之前结果；融合后变成一种操作，卷积结果不会写回显存，而是直接进行归一化后写会显存。</p><pre class="line-numbers language-python-repl" data-language="python-repl"><code class="language-python-repl">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 '', namedef 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<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><p><a href="https://pytorch.org/tutorials/intermediate/fx_profiling_tutorial.html">（测试版）使用FX 构建简单的 CPU 性能分析器 — PyTorch 教程 2.2.1+cu121 文档</a></p><p>通过<code>print(traced_rn18.graph)</code>我们可以查看计算图的信息，这里只选择一行查看，例子:</p><pre class="line-numbers language-none"><code class="language-none">%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 = {}:额外关键词参数<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><p>可以参照教程写一个继承torch.fx.Interpreter的类,重写run和run_node实现对于计算图的捕获，在运行过程中添加自定义行为。</p><h3 id="存储组织">存储组织</h3><p><a href="https://pytorch.org/tutorials/intermediate/memory_format_tutorial.html">(beta)Channels Last Memory Format in PyTorch — PyTorch Tutorials 2.2.1+cu121documentation</a></p><p>这里介绍了内存组织方式torch.channels_last，torch.contiguous_format等，同时介绍了一下torch.stride、torch.contiguous和torch.is_contiguous等函数。</p><p>有的操作符会保留内存组织格式。</p><p>可以通过model.to(memory_format=)把模型转化为适合的组织形式，同时输入也需要相应的转换（框架应该支持自动转换？）。</p><p>但由于不是所有的操作符都支持某种内存组织格式，可能需要进行检查，这里给了检查和设置的示例代码。</p><h3 id="前向模式自动微分">前向模式自动微分</h3><p><a href="https://pytorch.org/tutorials/intermediate/forward_ad_usage.html">正向模式自动微分（Beta） — PyTorch 教程 2.2.1+cu121 文档</a></p><p>这里看的不是很明白。挖个坑（todo...</p><p>正向传播一次只能算出相对一个参数的梯度，如果有n个参数，需要计算n次，所以这里的tangent只有一个，而不是每个参数对应一个。</p><p>可以参考<a href="https://zhuanlan.zhihu.com/p/518296942">【自动微分原理】AD的正反向模式- 知乎 (zhihu.com)</a>。</p><p>（这么一看，正向自动微分被方向自动微分爆杀？目前应用少且pytorch也只是测试版本</p><h3 id="微分矩阵计算">微分矩阵计算</h3><p><a href="https://pytorch.org/tutorials/intermediate/jacobians_hessians.html">雅可比派、黑森派、hvp、vhp等：编写函数转换 — PyTorch 教程 2.2.1+cu121 文档</a></p><p>这里提供了各种使用自动求导计算微分矩阵的方法。</p><h3 id="模型组装">模型组装</h3><p><a href="https://pytorch.org/tutorials/intermediate/ensembling.html">模型组装— PyTorch 教程 2.2.1+cu121 文档</a></p><p>这里介绍了torch.func.stack_model_state、torch.vmap等函数用来组装一系列结构相同参数不同的模型的输出，类似于使用cat连接模型输出，但是增加了底层优化。</p><h3 id="单样本梯度">单样本梯度</h3><p><a href="https://pytorch.org/tutorials/intermediate/per_sample_grads.html">Per-sample-gradients— PyTorch 教程 2.2.1+cu121 文档</a></p><p>在一些要求对每个样本单独计算梯度的特殊情况下，可以使用本篇介绍的方法优化速度。</p><p>这里介绍了torch.func.grad、torch.func.functional_call、torch.func.vmap来优化加速（注意不同库有不同的同名函数）</p><p>这里grad和vmap都是创建的可调用对象，与别的同名函数不同。</p><h3 id="c接口">c++接口</h3><p><a href="https://pytorch.org/tutorials/advanced/cpp_frontend.html">Usingthe PyTorch C++ Frontend — PyTorch Tutorials 2.2.1+cu121documentation</a></p><p>介绍了怎么使用c++调用</p><h3 id="torchscript-中的动态并行性">TorchScript 中的动态并行性</h3><p><a href="https://pytorch.org/tutorials/advanced/torch-script-parallelism.html">TorchScript中的动态并行性 — PyTorch 教程 2.2.1+cu121 文档</a></p><p>这里介绍了torch.jit.fork和torch.jit.wait两个函数用来并行执行pytorch相关代码。同时也引入了相关的类torch.jit.Future。</p><h3 id="c接口中的自动求导">c++接口中的自动求导</h3><p><a href="https://pytorch.org/tutorials/advanced/cpp_autograd.html">Autogradin C++ Frontend — PyTorch Tutorials 2.2.1+cu121 documentation</a></p><h3 id="这里都是一些用c扩展pytorch的内容后面需要细致学习挖坑todo">这里都是一些用c++扩展pytorch的内容，后面需要细致学习（挖坑todo</h3><h3 id="自定义函数求二阶导">自定义函数求二阶导</h3><p><a href="https://pytorch.org/tutorials/intermediate/custom_function_double_backward_tutorial.html">DoubleBackward with Custom Functions — PyTorch Tutorials 2.2.1+cu121documentation</a></p><p>这篇文章介绍了怎么使用继承自torch.autograd.Function的自定义函数（重新forward和backward），计算导数，并且用torch.autograd.gradcheck使用数值解验证求导以及使用torchviz可视化图形。</p><p>同时，注意在运行过程中，保存求导所需要参数时候建议按照教程分保存输入、保存输出和保存中间结果考虑代码结构，避免bug。</p><p>forward函数返回结果似乎和backward参数对应，backward输入参数是每个forward函数返回结果的grad。</p><p>保存中间结果的时候需要把中间结果返回，这样可以让pytorch的自动微分系统追踪这些中间结果（个人理解为返回中间结果相当于注册了这些中间结果，在backward的时候设置grad模型就会追踪这些中间结果，理解可能有误，但是使用的时候参考教程应该问题不大）。</p><h3 id="自定义函数实现卷积">自定义函数实现卷积</h3><p><a href="https://pytorch.org/tutorials/intermediate/custom_function_conv_bn_tutorial.html">FusingConvolution and Batch Norm using Custom Function — PyTorch Tutorials2.2.1+cu121 documentation</a></p><p>先介绍了自定义卷积函数的构造，这里的once_differentiable指的是正向传播的结果只会反向传播一次，作用为求二阶导的时候会报错，从而起到限制的作用。</p><p>然后介绍了自定义批量归一化层的构造，然后介绍了自定义函数混合卷积和批量归一化，从而实现了节省内存的作用。</p><h3 id="自定义-c-和-cuda-扩展">自定义 C++ 和 CUDA 扩展</h3><p><a href="https://pytorch.org/tutorials/advanced/cpp_extension.html">CustomC++ and CUDA Extensions — PyTorch Tutorials 2.2.1+cu121documentation</a></p><p>这里介绍了两个扩展c++组件的方法，“ahead of time ”和“just intime”。</p><p>ahead oftime：构建setup.py文件用于构建c++扩展，然后在对应的cpp文件里面构建c++扩展代码。</p><p>just intime:通过torch.utils.cpp_extension.load直接加载cpp文件，会把编译的中间文件存在一个临时目录里。</p><p>这里还介绍了编写混合 C++/CUDA扩展，由于还没有学过cuda，挖个坑todu...</p><h3 id="使用自定义-c-运算符扩展-torchscript">使用自定义 C++ 运算符扩展TorchScript</h3><p><a href="https://pytorch.org/tutorials/advanced/torch_script_custom_ops.html">ExtendingTorchScript with Custom C++ Operators — PyTorch Tutorials 2.2.1+cu121documentation</a></p><p>如题，后面需要细致学习todo,,,</p><h3 id="使用自定义-c-类扩展-torchscript">使用自定义 C++ 类扩展TorchScript</h3><p><a href="https://pytorch.org/tutorials/advanced/torch_script_custom_classes.html">ExtendingTorchScript with Custom C++ Classes — PyTorch Tutorials 2.2.1+cu121documentation</a></p><p>如题，后面需要细致学习todo,,,</p><h3 id="在c中注册一个分派操作符">在C++中注册一个分派操作符</h3><p><a href="https://pytorch.org/tutorials/advanced/dispatcher.html">Registeringa Dispatched Operator in C++ — PyTorch Tutorials 2.2.1+cu121documentation</a></p><p>由于一个操作在不同的设备上对应不同的底层代码，所以为了抽象化其操作，方便调用，需要在内核注册对应设备对应函数，然后在调用。</p><p>比如，第一个把 <code>myadd_cpu</code>注册到cpu上的<code>myadd</code>函数，当在cpu上运行 <code>myadd</code>函数时候，会调用<code>myadd_cpu</code></p><pre class="line-numbers language-none"><code class="language-none">TORCH_LIBRARY_IMPL(myops, CPU, m) { m.impl("myadd", myadd_cpu);}TORCH_LIBRARY_IMPL(myops, CUDA, m) { m.impl("myadd", myadd_cuda);}<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><p>然后在使用的时候，通过torch的调度器自动根据设备在内核寻找合适函数调用。</p><pre class="line-numbers language-none"><code class="language-none">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);}<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><p>这里还介绍了自动投影机制autocast，用于在运算之前把精度投影到合适的精度。</p><h3 id="在-c-中扩展新后端的调度程序">在 C++ 中扩展新后端的调度程序</h3><p><a href="https://pytorch.org/tutorials/advanced/extend_dispatcher.html">Extendingdispatcher for a new backend in C++ — PyTorch Tutorials 2.2.1+cu121documentation</a></p><p>后端（backend）通常指的是支持PyTorch运行的底层系统或框架，这里介绍了如何添加自定义的框架。(大致是需要实现一些基本的运算，别的运算可以表示成这样运算的组合)。</p><p><a href="https://pytorch.org/tutorials/advanced/privateuseone.html">FacilitatingNew Backend Integration by PrivateUse1 — PyTorch Tutorials 2.2.1+cu121documentation</a></p><p>这里介绍了使用privateuse1注册新后端的流程。</p><h3 id="结合tensorboard的profiler">结合tensorboard的profiler</h3><p><a href="https://pytorch.org/tutorials/intermediate/tensorboard_profiler_tutorial.html">PyTorchProfiler With TensorBoard — PyTorch Tutorials 2.2.1+cu121documentation</a></p><p>这篇文章介绍了profiler结合tensorboard的使用。</p><h3 id="使用ray-tune进行超参数调优">使用Ray Tune进行超参数调优</h3><p><a href="https://pytorch.org/tutorials/beginner/hyperparameter_tuning_tutorial.html">Hyperparametertuning with Ray Tune — PyTorch Tutorials 2.2.1+cu121documentation</a></p><p>这篇文章介绍了怎么使用Ray Tune库进行超参数的搜索。</p><h3 id="优化vision-transformer模型">优化Vision Transformer模型</h3><p><a href="https://pytorch.org/tutorials/beginner/vt_tutorial.html">OptimizingVision Transformer Model for Deployment — PyTorch Tutorials 2.2.1+cu121documentation</a></p><p>这篇文章介绍了怎么去优化VisionTransformer模型，列举了一些常见的优化方式。</p><h3 id="参数化教程">参数化教程</h3><p><a href="https://pytorch.org/tutorials/intermediate/parametrizations.html">ParametrizationsTutorial — PyTorch Tutorials 2.2.1+cu121 documentation</a></p><p>这里的参数化指的是类似于对模型部分权重使用的一种限制，应该是在参数修改后调用（比如初始化，参数更新等）的一些nn.module，从而使得模型更加灵活，实现对不同参数的不同处理过程，具体使用过程也是看教程，进行类的注册，使用函数parametrize。</p><p>with parametrize.cached():可以开启参数的缓存模型。</p><p>可以对于一个参数注册多个参数化模块。</p><p>同时参数化模块内部有的函数可以只在特殊时期调用，比如初始化。</p><p>可以移除参数化模块。</p><h3 id="剪枝教程">剪枝教程</h3><p><a href="https://pytorch.org/tutorials/intermediate/pruning_tutorial.html">PruningTutorial — PyTorch Tutorials 2.2.1+cu121 documentation</a></p><p>这里介绍了剪枝和机制，以及钩子函数的引入。</p><p>介绍了组合剪枝，通过移除重参数化来永久化剪枝，不同模块针对剪枝，全局剪枝，扩展自己的剪枝函数等。</p><h3 id="动态量化">动态量化</h3><p><a href="https://pytorch.org/tutorials/advanced/dynamic_quantization_tutorial.html">(beta)Dynamic Quantization on an LSTM Word Language Model — PyTorch Tutorials2.2.1+cu121 documentation</a></p><p><a href="https://pytorch.org/tutorials/intermediate/dynamic_quantization_bert_tutorial.html">(beta)Dynamic Quantization on BERT — PyTorch Tutorials 2.2.1+cu121documentation</a></p><p>这里介绍了使用torch.quantization.quantize_dynamic动态量化一次常见模型的例子。</p><h3 id="计算机视觉的量化迁移学习教程">计算机视觉的量化迁移学习教程</h3><p><a href="https://pytorch.org/tutorials/intermediate/quantized_transfer_learning_tutorial.html">(beta)Quantized Transfer Learning for Computer Vision Tutorial — PyTorchTutorials 2.2.1+cu121 documentation</a></p><p>这篇文章介绍了在微调时候插入量化模拟层和反量化层，从而让模型适应量化的过程（QAT）。</p><h3 id="pytorch-中具有-eager-模式的静态量化">PyTorch 中具有 Eager模式的静态量化</h3><p><a href="https://pytorch.org/tutorials/advanced/static_quantization_tutorial.html">(beta)Static Quantization with Eager Mode in PyTorch — PyTorch Tutorials2.2.1+cu121 documentation</a></p><p>这个教程演示如何进行训练后静态量化，并说明两种更先进的技术，通道量化和量化感知训练。</p><h3 id="从第一性原理挖掘-pytorch-intel-cpu-性能">从第一性原理挖掘PyTorch Intel CPU 性能</h3><p><a href="https://pytorch.org/tutorials/intermediate/torchserve_with_ipex.html">GrokkingPyTorch Intel CPU performance from first principles — PyTorch Tutorials2.2.1+cu121 documentation</a></p><p><a href="https://pytorch.org/tutorials/intermediate/torchserve_with_ipex_2.html">GrokkingPyTorch Intel CPU performance from first principles (Part 2) — PyTorchTutorials 2.2.1+cu121 documentation</a></p><p>这里介绍了优化CPU性能的方法和原理，目前来说太高深（挖矿todo</p><h3 id="带-ax-的多目标-nas">带 Ax 的多目标 NAS</h3><p><a href="https://pytorch.org/tutorials/intermediate/ax_multiobjective_nas_tutorial.html">Multi-ObjectiveNAS with Ax — PyTorch Tutorials 2.2.1+cu121 documentation</a></p><p>这篇文章介绍了怎么使用Ax平台进行神经网络架构的搜索。</p><h3 id="torch.compile介绍">torch.compile介绍</h3><p><a href="https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html">Introductionto torch.compile — PyTorch Tutorials 2.2.1+cu121 documentation</a></p><p>可以使用torch.compile当做装饰器或者函数使用。</p><p>同时也列举了几个模式以及和别的几个优化方法的对比。</p><h3 id="inductor-cpu-backend-debugging-and-profiling">Inductor CPUbackend debugging and profiling</h3><p><a href="https://pytorch.org/tutorials/intermediate/inductor_debug_cpu.html">InductorCPU backend debugging and profiling — PyTorch Tutorials 2.2.1+cu121documentation</a></p><p>这篇文章介绍了怎么对C++后端进行debug和profile的过程。有点复杂，，，（挖坑todo</p><h3 id="实现高效缩放点积注意力transformer">实现高效缩放点积注意力Transformer</h3><p><a href="https://pytorch.org/tutorials/intermediate/scaled_dot_product_attention_tutorial.html">(Beta)Implementing High-Performance Transformers with Scaled Dot ProductAttention (SDPA) — PyTorch Tutorials 2.2.1+cu121 documentation</a></p><p>这篇文章介绍了怎么优化使用常用的缩放点积注意力。</p><p>torch.nested.nested_tensor支持融合不同长度的张量。</p><h3 id="知识蒸馏">知识蒸馏</h3><p><a href="https://pytorch.org/tutorials/beginner/knowledge_distillation_tutorial.html">KnowledgeDistillation Tutorial — PyTorch Tutorials 2.2.1+cu121documentation</a></p><p>这篇教程介绍了知识蒸馏的几个方式，主要都是在损失函数里面添加教师模型和学生模型的各种量化差异来训练学生模型。</p><h3 id="分布式挖坑todo">分布式（挖坑todo</h3><h3 id="参考资料">参考资料</h3><blockquote><ul><li><a href="https://pytorch.org/tutorials/">Welcome to PyTorchTutorials — PyTorch Tutorials 2.2.1+cu121 documentation</a></li></ul></blockquote>]]></content>
<categories>
<category> 杂项 </category>
</categories>
<tags>
<tag> pytroch_tutorials </tag>
</tags>
</entry>
<entry>
<title>Adam Optimizer</title>
<link href="//12551/"/>
<url>//12551/</url>
<content type="html"><![CDATA[<h2 id="背景">背景</h2><p>传统的随机梯度下降算法SGD(Stochastic Gradient Descent)的式子为:</p><p><span class="math display">\[\theta_{t+1} \leftarrow \theta_{t} -\alpha\nabla_{\theta_{t}}J_{minibatcg}(\theta_{t})\]</span></p><p>其中<span class="math inline">\(J\)</span>为损失函数,<span class="math inline">\(\theta_{t}\)</span>为t时刻的参数,<span class="math inline">\(\alpha\)</span>为学习率,<span class="math inline">\(\nabla_{\theta_{t}}J_{minibatcg}(\theta_{t})\)</span>为t时刻梯度.</p><h2 id="adam算法初步优化">Adam算法初步优化</h2><p>考虑让梯度更加平滑,有以下式子:</p><p>$$ m_{t+1}<em>{1}m</em>{t}+(1-<em>{1})</em>{<em>{t}}J</em>{minibatcg}(_{t}) \</p><p><em>{t+1} </em>{t} -m_{t+1} $$</p><p>优点:</p><ul><li>梯度更加平滑,减少了振荡</li><li>可以在初始设置更大的学习率</li></ul><h2 id="adam算法最终优化">Adam算法最终优化</h2><p>通过对应"动量"这一想法的进一步扩展,我们得到了新的学习算法式子:</p><p>$$ m_{t+1} _1 m_t + (1 - <em>1) </em>{<em>t} J</em>{}(<em>t) \v</em>{t+1} _2 v_t + (1 - <em>2)(</em>{<em>t} J</em>{}(<em>t)</em>{<em>t} J</em>{}(_t)) \</p><p>_{t+1} _t - $$</p><p>其中<span class="math inline">\(\beta_{1},\beta_{2}\)</span>是大小在0和1之间的超参数,<span class="math inline">\(\odot\)</span>是平方的符号,<span class="math inline">\(\alpha\)</span>是学习率.</p><p>优点:</p><ul><li>梯度更加平滑,减少了振荡</li><li>可以在初始设置更大的学习率</li><li>接收较小或很少更新的模型参数将得到较大的更新</li></ul><h2 id="参考资料">参考资料</h2><blockquote><p><a href="https://zh.d2l.ai/chapter_optimization/adam.html">11.10.Adam算法 — 动手学深度学习 2.0.0 documentation (d2l.ai)</a></p><p><a href="https://web.stanford.edu/class/cs224n/">Stanford CS 224N |Natural Language Processing with Deep Learning</a></p></blockquote>]]></content>
<categories>
<category> 深度学习 </category>
<category> 经典模块 </category>
</categories>
<tags>
<tag> 深度学习 </tag>
<tag> 优化算法 </tag>
</tags>
</entry>
<entry>
<title>依赖分析Dependency Parsing</title>
<link href="//26708/"/>
<url>//26708/</url>
<content type="html"><![CDATA[<h2 id="介绍">介绍</h2><p>这里介绍两种语义结构:</p><ul><li>Constituency Parsing：句法分析，Context-freegrammars(CFGs)，上下文无关语法，赋予每个单词一个词性类别，单词组合成短语，短语递归形成更大的短语</li><li>DependencyParsing：直接通过单词与其他单词的关系表示句子的结构，表示单词依赖于(修饰或是其参数)其他单词</li></ul><h2 id="dependency-parsing缺陷">Dependency Parsing缺陷</h2><p>不同的自然语言有不同的组织结构,每种自然语言都有独特的二义问题(ambiguity),即同一个句子通过不同DependencyParsing分析会得到不同语义树,进而得到不同的语句意思.</p><p>总的可能的语义数目极限情况下大概是随着字符串的提示可能是指数级增加,所以有一些方法来解决这些问题.</p><h2 id="dependency-structure">Dependency Structure</h2><p>通过一个单向边指明依赖关系(同时这个边也会指明依赖关系的种类),进而组成一个树状结构,通常会添加一个虚拟的"ROOT"节点作为根节点</p><p><img src="/26708/1703687822509.png"></p><p><img src="/26708/1703687931983.png"></p><h2 id="greedy-transition-based-parsing">Greedy transition-basedparsing</h2><p><img src="/26708/1703688065130.png"></p><p>初始状态:<span class="math inline">\(\sigma=[ROOT],\beta=w_1,...,w_n,A=\empty\)</span></p><p>三种操作:</p><ul><li>Shift : 从缓存区<span class="math inline">\(\beta\)</span>里面移入一个词到栈<span class="math inline">\(\sigma\)</span>里面</li><li>Left-Arc : 将<span class="math inline">\((w_j,r,w_i)\)</span>加入边集合<span class="math inline">\(A\)</span> ,其中<span class="math inline">\(w_i\)</span><sub>是</sub>stack上的次顶层的词,<span class="math inline">\(w_j\)</span>是stack上的最顶层的词,然后保留<span class="math inline">\(w_j\)</span>在栈中（堆必须包含两个单词以及 <span class="math inline">\(w_i\)</span>不是 ROOT ）</li><li>Right-Arc : 将<span class="math inline">\((w_i,r,w_j)\)</span>加入边集合<span class="math inline">\(A\)</span> ,其中<span class="math inline">\(w_i\)</span><sub>是</sub>stack上的次顶层的词,<span class="math inline">\(w_j\)</span>是stack上的最顶层的词,然后保留<span class="math inline">\(w_i\)</span>在栈中（堆必须包含两个单词以及 <span class="math inline">\(w_i\)</span>不是 ROOT ）</li></ul><p>重复上述操作到指定目标.</p><p>实际应用的时候,如何判断选择哪一种操作可以通过机器学习的方式来判断,也可以加入集束搜索来寻找最优解.</p><p>评判标准:</p><ul><li>UAS:找准依赖项的词的比例</li><li>LAS:在UAS基础上,还要求边的属性得准确</li></ul><p>示例:</p><p><img src="/26708/1703689446845.png"></p><p>参考资料</p><blockquote><ul><li><a href="https://blog.csdn.net/qq_29216461/article/details/126096245#leture_3Backprop_and_Neural_Networks_1">2021斯坦福CS224N课程笔记~2_context-freegrammars and constituency parsing-CSDN博客</a></li></ul></blockquote>]]></content>
<categories>
<category> 深度学习 </category>
<category> 自然语言处理 </category>
</categories>
<tags>
<tag> 深度学习 </tag>
<tag> 自然语言处理 </tag>
</tags>
</entry>
<entry>
<title>矩阵偏分</title>
<link href="//45525/"/>
<url>//45525/</url>
<content type="html"><![CDATA[<p>在学习深度学习的过程中,很多次遇到了矩阵求导的问题,发现网上很多教程写的不是很好理解,记录自己的浅薄认知.</p><blockquote><p>（矩阵求导有分子转置（和分子行数一样）和分母转置（和分母行数一样）两种，两种结果互为转置。本篇介绍的不太一样，因为很多教程也是混杂的（太难蚌了）。</p></blockquote><h2 id="符号">符号</h2><p>标量：<span class="math inline">\(x\)</span></p><p>向量：<span class="math inline">\(\mathbf{x}\)</span> （）</p><p>矩阵：<span class="math inline">\(X\)</span></p><p>逐点乘积：<span class="math inline">\(\odot\)</span>（）</p><p>矩阵的迹：<span class="math inline">\(tr(X)\)</span></p><p>加入有两个矩阵<span class="math inline">\(A_{m\times n},B_{m\timesn}\)</span>，其中一个转置乘以另一个得到矩阵<span class="math inline">\(C\)</span>，该矩阵的迹为两个矩阵<strong>对应位置的元素相乘并相加</strong>，可以理解为<strong>向量的点积</strong>在矩阵上的推广，即：</p><p><span class="math display">\[\begin{align*}\text{tr}\left( AB^T \right) &= a_{11}b_{11} + a_{12}b_{12} + \cdots+ a_{1n}b_{1n} \\&+ a_{21}b_{21} + a_{22}b_{22} + \cdots + a_{2n}b_{2n} \\&+ \cdots \\&+ a_{m1}b_{m1} + a_{m2}b_{m2} + \cdots + a_{mn}b_{mn} \\\end{align*}\]</span></p><h2 id="矩阵微分规律">矩阵微分规律</h2><p>梯度矩阵里的微分：</p><p>假设<span class="math inline">\(A\)</span>矩阵维度列表为<span class="math inline">\([a_1,a_2,...,a_n]\)</span></p><p>假设<span class="math inline">\(B\)</span>矩阵维度列表为<span class="math inline">\([b_1,b_2,...,b_{m}]\)</span></p><p><span class="math inline">\(A\)</span>矩阵对<span class="math inline">\(B\)</span>矩阵求偏导的结果<span class="math inline">\(C\)</span>,维度上相当于<span class="math inline">\(A\)</span>矩阵维度列表和<span class="math inline">\(B\)</span>矩阵维度列表连接起来</p><p>即<span class="math inline">\(C\)</span>矩阵维度列表为<span class="math inline">\([a_1,a_2,...,a_n,b_1,b_2,...,b_{m}]\)</span></p><p>根据维度信息也能很方便的推导各个元素的含义,即为<span class="math inline">\(A\)</span>矩阵的每个元素对<span class="math inline">\(B\)</span>矩阵的每个元素求一个偏导。</p><blockquote><p>当然，高维的矩阵微分应用场景有限，我们很少需要求一个矩阵关于另一个矩阵的偏导。因此这个规律可能因为博主实践较少有误。</p></blockquote><p>在深度学习的场景中，一般是标量对矩阵求导，因此主要介绍标量对矩阵微分的情况。</p><p>一般对于向量，默认为列向量，<span class="math inline">\(\mathbf{x}=[x_1,x_2,...,x_n]^{T}\)</span>，我们有标量函数<span class="math inline">\(f(\mathbf{x})\)</span>，那么对应的梯度为</p><p><span class="math display">\[\frac{\partial f}{\partial \mathbf{x}}=[\frac{\partial f}{\partialx_1},\frac{\partial f}{\partial x_2},..\frac{\partial f}{\partialx_n}]^\top\]</span></p><p>根据这个公式我们可以发现，这个梯度向量的每个元素都是函数对该元素的偏导。</p><p>因此，我们有，</p><p><span class="math display">\[\partial f = (\frac{\partial f}{\partial \mathbf{x}})^\top \partial\mathbf{x}\]</span></p><p><strong>对于标量对向量到梯度来说，在左边乘以其梯度的转置就可以对应得到目标的微分。</strong></p><p><strong>对于矩阵来说，逐点乘积<span class="math inline">\(\odot\)</span>然后对应位置求和应该是更广泛的规律。但向量是特殊的，逐点乘积求和和转置相乘的结果是一样的。</strong></p><blockquote><p>对于函数值为标量，变量为二维矩阵的情况，函数值的微分是梯度矩阵和变量矩阵的转置乘积的迹。</p><p><span class="math display">\[df(X)=tr((\frac{df(X)}{dX})^\top \cdot X)\]</span></p></blockquote><h2 id="雅可比矩阵">雅可比矩阵</h2><p>雅可比矩阵指的是向量对于向量的微分，假如我们有：</p><p><span class="math display">\[F:R^{N}\to R^{M} ,\mathbf{y}=F(\mathbf{x})\]</span></p><p>那么雅克比矩阵为，</p><p><span class="math display">\[J_{F:\mathrm{x\to y}}=\left[\begin{array}{c c c}\frac{\partial y_1}{\partialx_1}&&\frac{\partial y_1}{\partial x_N}\\&&\\\frac{\partial y_M}{\partialx_1}&&\frac{\partial y_M}{\partial x_N}\\\end{array}\right]\]</span></p><p>其中第<span class="math inline">\(i\)</span>行是<span class="math inline">\(y_i\)</span>关于<span class="math inline">\(\mathbf{x}\)</span>的微分的转置。</p><p>我们有一阶泰勒展开式：</p><p><span class="math display">\[F({\bf{x}}+d{\bf{x}})=F({\bf{x}})+J_{F:x \toy}d{\bf{x}}+o(\|d{\bf{x}}\,\|).\]</span></p><h2 id="hessian">Hessian</h2><p>在向量微积分中，Hessian 矩阵用于表示标量关于向量的二阶偏导数。</p><p>假如我们有</p><p><span class="math display">\[f(\mathbf{x}) : \mathbb{R}^N \to \mathbb{R}\]</span></p><p>那么我们有，</p><p><span class="math display">\[H_{x \to f} = \frac{d^2 f}{dx \, dx^\top} = \left[ \frac{\partialf}{\partial x_i \partial x_j} \right]\]</span></p><p>通过定义也可以看出，Hessian矩阵可以写成一阶导数构成的向量关于自变量的雅可比矩阵。</p><p>令<span class="math inline">\(f\)</span>关于变量的一阶梯度为，</p><p><span class="math display">\[\mathbf{a}(\mathbf{x}) = \left[ \frac{\partial f}{\partial x_i} \right]\]</span></p><p>那么hessian矩阵还可以写为，</p><p><span class="math display">\[H_{x \to f} = \frac{d\mathbf{a}}{d\mathbf{x}} = \left[ \frac{d a_i}{dx_j} \right] = \left[ \frac{\partial f}{\partial x_i \partial x_j}\right]\]</span></p><p>对应的，我们也能得到二阶泰勒展开式，</p><p><span class="math display">\[f(\mathbf{x} + d\mathbf{x}) = f(\mathbf{x}) + \mathbf{a}^\topd\mathbf{x} + \frac{1}{2} d\mathbf{x}^\top H_{x \to f} \, d\mathbf{x} +o(\|d\mathbf{x}\|^2)\]</span></p><blockquote><p>这里的二次项的推导方式为：</p><p><span class="math display">\[\begin{align*}&\frac{1}{2}(\partial \mathbf{a})^\top\partial \mathbf{x} \\=&\frac{1}{2}((\frac{\partial \mathbf{a}}{\partial \mathbf{x}})^\top\partial \mathbf{x})^\top\partial \mathbf{x} \\=&\frac{1}{2} d\mathbf{x}^\top \frac{\partial \mathbf{a}}{\partial\mathbf{x}} \ d\mathbf{x} \\=&\frac{1}{2} d\mathbf{x}^\top H_{x \to f} d\mathbf{x} \\\end{align*}\]</span></p><p>根据这个例子我们也能很容易总结规律并且推广到更多公式。（从定义出发推导式子，向量乘以自己的梯度转置获得目标的微分）</p></blockquote><h2 id="链式表达式">链式表达式</h2><p>假设我们有，</p><p><span class="math display">\[\begin{align*}y &= f(g(h(x))) \\q &= h(x) \\k &= g(q) \\y &= f(k)\end{align*}\]</span></p><p>我们希望得到</p><p><span class="math display">\[\begin{align*}&\partial y \\=& (\frac{\partial y}{\partial k})^\top \partial k \\=& (\frac{\partial y}{\partial k})^\top (\frac{\partial k}{\partialq})^\top \partial q \\=& (\frac{\partial y}{\partial k})^\top (\frac{\partial k}{\partialq})^\top (\frac{\partial q}{\partial x})^\top \partial x \\=& (\frac{\partial q}{\partial x} \frac{\partial k}{\partial q}\frac{\partial y}{\partial k})^\top \partial x \\\end{align*}\]</span></p><p>所以我们有</p><p><span class="math display">\[\frac{\partial y}{\partial x} = \frac{\partial q}{\partial x}\frac{\partial k}{\partial q} \frac{\partial y}{\partial k}\]</span></p><blockquote><p>这个推导前置条件只有：<strong>向量左乘其梯度的转置就可以对应得到目标的微分。</strong></p><p>别的布局的推导方式也类似。</p></blockquote><p>在数学公式的推导中，链式法则的记忆要点为：能乘维数对就对（可能维度信息其实就包含了部分信息）。</p><p><img src="/45525/1729755284537.png"></p><h2 id="行向量偏导形式">行向量偏导形式</h2><p>有一种操作把矩阵变成按列堆栈向量化<span class="math inline">\(vec\)</span>，然后进行处理，就可以利用部分在低维中的规律进行计算：</p><p><span class="math display">\[vec(X)=[x_{11},x_{21},..,x_{12},x_{22},...,x_{1n},x_{2n},...,x_{nm}]^T\]</span></p><blockquote><p>更多介绍阅读矩阵论、弗罗贝尼乌斯内积、克罗内克积等相关资料。</p><p><del>因为博主也不会，只是计算机系的，在深度学习里不会用到所有的数学知识。</del></p></blockquote><h2 id="合适做法">合适做法</h2><p>合适的做法还是对于矩阵的每个元素单独看梯度和贡献，然后根据指标的变化来总结公式。</p><p>比如，计算<span class="math inline">\(x_{ij}\)</span>是如何影响<span class="math inline">\(y_{ik}\)</span>的，然后总结梯度公式。</p><p>示例1：</p><p><span class="math display">\[Y=X*A,而X \in R^{n \times p}, A \in R^{p \times m},Y \in R^{n \timesm},l为标量 \\已知\frac{\partial l}{\partial Y},求\frac{\partial l}{\partial X} \\计算x_{ik}的贡献,有 \frac{\partial l}{\partialx_{ik}}=\sum_{j}a_{kj}\frac{\partial l}{\partial y_{ij}} \\根据维度信息(i在左侧,k在右侧)总结,得到\frac{\partial l}{\partialX}=\frac{\partial l}{\partial Y}A^T\]</span></p><blockquote><p>tip:由于一维向量很多时候会被写为列向量,所以有的教程理解不是很方便,但如果接触过pytorch框架,会方便理解很多.</p></blockquote><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href="https://zhuanlan.zhihu.com/p/263777564">矩阵求导的本质与分子布局、分母布局的本质（矩阵求导——本质篇）- 知乎 (zhihu.com)</a></li><li><a href="https://zhuanlan.zhihu.com/p/273729929">矩阵求导公式的数学推导（矩阵求导——基础篇）- 知乎 (zhihu.com)</a></li><li><a href="https://zhuanlan.zhihu.com/p/288541909">矩阵求导公式的数学推导（矩阵求导——进阶篇）- 知乎 (zhihu.com)</a></li><li><a href="https://www.cnblogs.com/yifanrensheng/p/12639539.html#_label0">【ML-0-3】矩阵求导-链式法则- 忆凡人生 - 博客园 (cnblogs.com)</a></li><li><a href="https://blog.csdn.net/keeppractice/article/details/107231685">[机器学习-数学]矩阵求导(分母布局与分子布局)，以及常用的矩阵求导公式</a></li><li><a href="https://blog.csdn.net/nyist_yangguang/article/details/110917076">矩阵论——导数与梯度_矩阵的梯度-CSDN博客</a></li></ul></blockquote>]]></content>
<categories>
<category> 数学 </category>
<category> 线性代数 </category>
</categories>
<tags>
<tag> 深度学习 </tag>
<tag> 数学 </tag>
<tag> 矩阵 </tag>
<tag> 向量 </tag>
</tags>
</entry>
<entry>
<title>GloVe</title>
<link href="//51558/"/>
<url>//51558/</url>
<content type="html"><![CDATA[<h2 id="介绍">介绍</h2><p>相比Word2Vec的局部训练,GloVe可以使用全局的语料统计信息来训练,可以预先计算全局语料库统计数据来提高训练数据.</p><h2 id="带全局语料统计的跳元模型">带全局语料统计的跳元模型</h2><p>用<span class="math inline">\(q_{ij}\)</span>表示词<span class="math inline">\(w_j\)</span>的条件概率<span class="math inline">\(P(w_j|w_i)\)</span>,在跳元模型中给定词<span class="math inline">\(w_i\)</span>,我们有</p><p><span class="math display">\[q_{ij}=\frac{exp(\bm u^T_j\bm v_i)}{\sum_{k \in V}exp(\bm u^T_k\bm v_i)}\]</span></p><p>记录<span class="math inline">\(w_i\)</span>在所有出现地方的上下文构成一个可重集合<span class="math inline">\(C_i\)</span>,其中元素j的数目记为<span class="math inline">\(x_{ij}\)</span>,损失函数定义为</p><p><span class="math display">\[-\sum_{i\in V}\sum_{j\in V}x_{ij}log\ q_{ij}\]</span></p><p>用<span class="math inline">\(x_i\)</span>表示<span class="math inline">\(|C_i|\)</span>,用<span class="math inline">\(p_{ij}\)</span>表示概率<span class="math inline">\(x_{ij}/x_i\)</span>,则损失函数可以改写为</p><p><span class="math display">\[-\sum_{i\in V}x_i\sum_{j\in V}p_{ij}log\ q_{ij}\]</span></p><p>我们发现<span class="math inline">\(-\sum_{j\in V}p_{ij}log\q_{ij}\)</span>就是计算全局语料统计的条件分布<span class="math inline">\(p_{ij}\)</span>和模型预测的条件分布<span class="math inline">\(q_{ij}\)</span>的交叉熵。</p><h2 id="glove模型">GloVe模型</h2><p>考虑到计算成本的问题,以及大量罕见事件被损失建模,GloVe模型基于平方损失对模型进行了以下修改:</p><ul><li>使用变量<span class="math inline">\(p^{'}_{ij}=x_ij\)</span>和<span class="math inline">\(q^{'}_{ij}=exp(\bm u^T_{j}\bmv_i)\)</span>,并取两者对数,所以平方损失为<span class="math inline">\((log\ p^{'}_{ij}-log\ q^{'}_{ij})^2=(\bmu^T_{j}\bm v_i-log\ x_{ij})^2\)</span>.</li><li>为每个词<span class="math inline">\(w_i\)</span>添加中心词偏执<span class="math inline">\(b_i\)</span>和上下文词偏置<span class="math inline">\(c_i\)</span></li><li>用权重函数<span class="math inline">\(h(x)\)</span>替代损失项权重,其中<span class="math inline">\(h(x)\)</span>在[0,1]的间隔内递增.</li></ul><p>最后总的损失函数为:</p><p><span class="math display">\[\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\]</span></p><p>由于对称性,有<span class="math inline">\(x_{ij}=x_{ji}\)</span>,而Word2Vec没有拟合对称性,GloVe拟合了对称性.因此,在GloVe模型中,词的上下文向量<span class="math inline">\(u_i\)</span>和中心词向量<span class="math inline">\(v_i\)</span>应该是相等的,但在实际应用中,由于训练过程的随机化导致两个向量有轻微不同,因此GloVe将两者相加作为输出向量.</p><blockquote><p>参考资料1也提供了另一种理解GloVe模型的思路,和cs224n里面类似.</p></blockquote><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href="https://zh.d2l.ai/chapter_natural-language-processing-pretraining/glove.html">14.5.全局向量的词嵌入（GloVe） — 动手学深度学习 2.0.0 documentation(d2l.ai)</a></li></ul></blockquote>]]></content>
<categories>
<category> 深度学习 </category>
<category> 自然语言处理 </category>
</categories>
<tags>
<tag> 深度学习 </tag>
<tag> 自然语言处理 </tag>
</tags>
</entry>
<entry>
<title>Word2Vec</title>
<link href="//5925/"/>
<url>//5925/</url>
<content type="html"><![CDATA[<h2 id="介绍">介绍</h2><p>传统的词向量是独热编码One-Hot,每个词语对应的向量只有一位为1,其余为0,通过这个1的位置区分向量</p><p>Word2Vec是一种Distributed Representation,相比独热编码有以下优点:</p><ul><li>维度远小于独热编码</li><li>能更好的反馈向量间的关系</li><li>每个维度都被充分利用</li></ul><h2 id="word2vec的网络结构"><strong>Word2Vec的网络结构</strong></h2><p>Word2Vec是轻量级的神经网络，其模型仅仅包括输入层、隐藏层和输出层，模型框架根据输入输出的不同，主要包括CBOW和Skip-gram模型。</p><p>CBOW模型,在知道上下文的情况下预测中心词<span class="math inline">\(w_t\)</span></p><p>Skip-gram模型,在知道中心词<span class="math inline">\(w_t\)</span>的情况下预测</p><p><img src="/5925/1703252876064.png"></p><h2 id="网络结构基础">网络结构基础</h2><p>下图是两种模型结构的基础,是输入一个词,预测一个词</p><p><img src="/5925/1703253424041.png"></p><p>中间的运算都会使用矩阵方便加速:</p><ul><li>一个词语转换成对应的词向量,就会使用独热编码乘以这个<span class="math inline">\(W_{V\timesN}\)</span>,(其中V为词库大小,N为词向量维度数)</li><li>一个词向量和别的词的上下文向量点乘,也会乘以矩阵<span class="math inline">\(W^{'}_{V\times N}\)</span>,得到<span class="math inline">\(\bm y\)</span>,也就是<span class="math inline">\(\bm u^T\cdot \bm v\)</span></li></ul><p>之后词语k的概率就是softmax:</p><p><span class="math display">\[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)}\]</span></p><p>之后就是追求句子概率最大化:</p><p><span class="math display">\[\prod P(w_k|w_c)\]</span></p><p>对数化后取负数就得到了损失函数:</p><p><span class="math display">\[Loss=\sum_{o \in context}( \bm u^T_k\cdot \bm v_c-log(\sum_{i \inV}exp(\bm u^T_i\cdot \bm v_c)))\]</span></p><p>通过微分，我们可以获得其相对于中心词向量<span class="math inline">\(\bm v_c\)</span>的梯度为</p><p><img src="/5925/1703256300356.png#pic_center"></p><p>其他向量的方法也是类似.这里就不给予推导.</p><h2 id="cbow-词袋模型">CBOW 词袋模型</h2><p>用上下文预测中心词<span class="math inline">\(w_t\)</span></p><p><img src="/5925/1703256961548.png#pic_center"></p><h2 id="skip-gram-model-跳元模型">Skip-gram Model 跳元模型</h2><p>用中心词<span class="math inline">\(w_t\)</span>预测上下文</p><p><img src="/5925/1703256988046.png#pic_center"></p><h2 id="近似训练">近似训练</h2><p>由于softmax操作的性质，上下文词可以是词表V中的任意项，式子包含与整个词表大小一样多的项的求和。因此，跳元模型的梯度计算和连续词袋模型的梯度计算都包含求和。不幸的是，在一个词典上（通常有几十万或数百万个单词）求和的梯度的计算成本是巨大的！</p><p>为了降低上述计算复杂度，引入两种近似训练方法：负采样和分层softmax。由于跳元模型和连续词袋模型的相似性，将以跳元模型为例来描述这两种近似训练方法。</p><h3 id="负采样negative-sampling">负采样<strong>NegativeSampling</strong></h3><blockquote><p>负采样指的是加入一些负样本来进行模型的训练.</p></blockquote><p>负采样修改了原目标函数来减少运算成本.</p><p>给定中心词<span class="math inline">\(w_c\)</span>的上下文窗口，任意上下文词<span class="math inline">\(w_o\)</span>来自该上下文窗口的被认为是由下式建模概率的事件：</p><p><span class="math display">\[P(D=1|w_c,w_o)=\sigma(\bm u^T_o\bm v_c)\]</span></p><p>其中</p><p><span class="math display">\[\sigma(x)=\frac{1}{1+exp(-x)}\]</span></p><p>考虑最大化联合概率</p><p><span class="math display">\[\prod^T_{t=1}\prod_{-m\leqslant j \leqslant m,j\neq 0}P(D=1|w_t,w_{t+j})\]</span></p><p>然而这样只考虑了正样本,当且仅当所有词向量都等于无穷大的时候,这个式子会最大化为1,因此考虑加入一些噪声词作为负样本.</p><p><span class="math display">\[\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\thicksimP(w)}P(D=0|w_t,w_k)\]</span></p><p>关于条件概率的对数损失函数为:</p><p><img src="/5925/1703258521309.png#pic_center"></p><h3 id="分层softmax-hierarchical-softmax">分层softmax HierarchicalSoftmax</h3><p><img src="/5925/1703258985364.png"></p><p>这是一颗二叉树,从根节点开始,每次走左节点还是右节点都是概率时间,每个叶子节点都是词,所以根据中心词向量预测上下文可以看作是从根节点到叶子节点路径的概率乘积.</p><p>一种构造二叉树的方法是根据词语的出现频率构造哈夫曼树.</p><p>在非叶子节点<span class="math inline">\(i\)</span>走右边的概率是</p><p><span class="math display">\[\sigma(\bm x^T_w \bm \theta)=\frac{1}{1+eps(-\bm x^T_w \bm \theta)}\]</span></p><p>根据中心词<span class="math inline">\(w_t\)</span>预测上下文<span class="math inline">\(w_o\)</span>的概率也很就容易得到.</p><h2 id="参考资料">参考资料</h2><blockquote><p>第一篇写的最为详细全面,包括本文各种没有提到的细节,点赞!</p><p>参考资料里面第一篇和第三篇其实说的是一个东西,只不过一个是以矩阵的形式给出的.</p><p>可以通过奇异值分解减少词的特征维度.</p></blockquote><blockquote><ul><li><a href="https://zhuanlan.zhihu.com/p/114538417">深入浅出Word2Vec原理解析 -知乎 (zhihu.com)</a></li><li><a href="https://blog.csdn.net/v_JULY_v/article/details/102708459">如何通俗理解Word2Vec(23年修订版)-CSDN博客</a></li><li><a href="https://zh.d2l.ai/chapter_natural-language-processing-pretraining/word2vec.html">14.1.词嵌入（word2vec） — 动手学深度学习 2.0.0 documentation(d2l.ai)</a></li></ul></blockquote>]]></content>
<categories>
<category> 深度学习 </category>
<category> 自然语言处理 </category>
</categories>
<tags>
<tag> 深度学习 </tag>
<tag> 自然语言处理 </tag>
</tags>
</entry>
<entry>
<title>readme</title>
<link href="//17140/"/>
<url>//17140/</url>
<content type="html"><![CDATA[<h2 id="前言">前言</h2><p>当大四结束的时候,才意识到大学过的十分失败,很多计算机的核心知识其实都是处于一知半解的状态,动手能力也还是有很大的差距.即使在大一的时候,就已经在知乎上面刷到过不少计科混子的自我吐槽和悔恨,并且立志不要这么做,但大四上结束后,发现终究还是浪费了重要的四年和对重要知识的追求.</p><p>所以希望能通过一些大神的网上课程资源的推荐,弥补自己计算机教育的不足,希望亡羊补牢,为时未晚.</p><h2 id="介绍">介绍</h2><p>首先打算参考<a href="https://csdiy.wiki/">cswiki</a>上面的课程和相关资源学习理论知识和提高动手能力.</p><p>而本目录大概包括各个课程的:</p><ul><li>学习笔记</li><li>作业代码</li><li>工程代码</li></ul><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href="https://csdiy.wiki/">cswiki</a></li></ul></blockquote>]]></content>
<categories>
<category> 课程资源 </category>
</categories>
</entry>
<entry>
<title>文献管理工具zotero</title>
<link href="//43151/"/>
<url>//43151/</url>
<content type="html"><![CDATA[<p>这里推荐一个文献管理工具,<strong>zotero</strong>,很好用的文献管理工具，也能很好的辅助写论文，获取文献，免费开源且支持插件,可以参考这个b站up的视频搭建和使用这个工具。</p><iframe src="https://player.bilibili.com/player.html?aid=434272103&bvid=BV1o3411Q7JQ&cid=939317207&p=1" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true" style="width:100%;aspect-ratio:16/9;"></iframe><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href="【Zotero零基础保姆级教程】%20https://www.bilibili.com/video/BV1o3411Q7JQ/?share_source=copy_web&vd_source=27d2d5ef19f3ac0063f3e8c909037848">Zotero零基础保姆级教程</a></li></ul></blockquote>]]></content>
<categories>
<category> 工具 </category>
</categories>
<tags>
<tag> 工具 </tag>
<tag> 文献管理 </tag>
</tags>
</entry>
<entry>
<title>论文阅读:A_Survey_of_Quantization_Methods_for_Efficient_Neural_Network_Inference</title>
<link href="//62023/"/>
<url>//62023/</url>
<content type="html"><![CDATA[<blockquote><p>论文地址:<a href="https://arxiv.org/abs/2103.13630">A Survey ofQuantization Methods for Efficient Neural Network Inference</a></p></blockquote><h2 id="摘要">摘要</h2><p>这篇论文是关于模型量化方向的综述，介绍了量化相关领域的研究，同时也介绍了一些重要的论文。</p><p>提到了量化的好处：</p><ul><li>加快模型的推理过程</li><li>减少模型的存储开销</li><li>可以部署到特定设备（比如有的设备只能进行整型运算）</li></ul><h2 id="介绍">介绍</h2><p>过去模型的能力有了巨大的提升，其中一个原因就是模型参数的增加，但这也为模型的部署提升了难度。</p><p>过去几年关于这方面的尝试有如下几种：</p><ul><li>设计高效的神经网络模型架构，包括微观结构和宏观结构</li><li>神经网络软件和硬件协同设计</li><li>剪枝，减去对模型影响小的参数，分为结构化剪枝（删去部分参数）和非结构化剪枝（删去部分结构，相当于参数按组删去），两个方法各有优劣</li><li>知识蒸馏，用“教师”模型训练“学生”模型，可与前面方法结合</li><li>量化：分为训练中量化和推理量化</li><li>量化和神经科学的发展</li></ul><blockquote><p>这里很多次提到了AutoML和NAS技术调整网络结构</p></blockquote><h2 id="量化历史">量化历史</h2><p>量化，作为一种从大的（通常是连续的）集合中的输入值映射到小的（通常是有限的）集合中的输出值的方法，具有很长的历史。早在1897年就有微积分相关工作从事量化研究，同时，量化在信号处理中也非常重要。</p><p>香农在信息学和信号处理的研究过程中也针对量化进行过研究。同时，量化在连续数学量的数值求解中研究过。一些问题的良好解法可能由于数字量化会导致巨大误差，从而引出了算法数值稳定性的概念。</p><p>神经网络的发展给量化带来了机遇。神经网络的计算是计算密集型任务且目前很多模型都过度参数化。很多问题的解决都是基于一个某种误差度量，因此量化可能会增大误差，但同时也会增加模型的鲁棒性。</p><h2 id="量化的基本概念">量化的基本概念</h2><h3 id="问题设置和符号">问题设置和符号</h3><p>在不失一般性的情况下，让我们关注监督学习问题，即最小化下面所示的损失函数。</p><p><span class="math display">\[L(\theta)=\frac{1}{N} \sum^{N}_{i=1}l(x_i,y_i;\theta)\]</span></p><p>(x,y)是输入数据和对应的标签,$ l(x_i,y_i;)$是损失函数,N是数据数目</p><p>同时让我们把第<span class="math inline">\(i\)</span>层的输入隐藏激活表示为<span class="math inline">\(h_i\)</span>,输出隐藏激活表示为<span class="math inline">\(a_i\)</span>,我们假设浮点格式存储的模型参数为<span class="math inline">\(\theta\)</span>.</p><h3 id="均匀量化">均匀量化</h3><blockquote><p>均匀量化和非均匀量化</p><p><img src="/62023/1699360183609.png" title="均匀量化和非均匀量化"></p></blockquote><p>均匀量化的一个常用的函数是</p><p><span class="math display">\[Q(r)=Int(\frac{r}{S})-Z\]</span></p><p><span class="math inline">\(Q\)</span>是压缩函数,<span class="math inline">\(r\)</span>是实数类型的输入,<span class="math inline">\(S\)</span>是实数类型的比例因子,<span class="math inline">\(Z\)</span>是整数零点,<span class="math inline">\(Int\)</span>函数通过舍入操作把实数映射到整数</p><p>去量化操作</p><p><span class="math display">\[Q(\tilde{r})=S(Q(r)+Z)\]</span></p><p>由于舍入操作<span class="math inline">\(\tilde{r}\)</span>和<span class="math inline">\(r\)</span>不会严格相等</p><h3 id="对称和非对称量化">对称和非对称量化</h3><blockquote><p>对称和非对称量化（观察量化前后零点位置</p><p><img src="/62023/1699360947746.png"></p></blockquote><p>确定放缩因子<span class="math inline">\(S\)</span>的式子为</p><p><span class="math display">\[S=\frac{\beta-\alpha}{2^{b}-1}\]</span></p><p><span class="math inline">\([\alpha,\beta]\)</span>代表剪切范围,<span class="math inline">\(b\)</span>代表量化位宽.</p><p>确定<span class="math inline">\([\alpha,\beta]\)</span>的两个方式:</p><ul><li><span class="math inline">\(\alpha=r_{min},\beta=r_{max}\)</span></li><li><span class="math inline">\(-\alpha=\beta=max(|r_{min}|,|r_{max}|)\)</span></li></ul><p>利用实数的最大最小位选定裁剪范围可能会容易被异常数据影响,从而增加不必要的范围.解决这个问题的一种方法是使用百分位数,另一种方法是选择<span class="math inline">\(α\)</span>和<span class="math inline">\(β\)</span>，以最小化真实值和量化值之间的KL散度（即信息损失）.也有学者对不同的量化范围选取范围方法进行了评估.</p><p>确定<span class="math inline">\(S\)</span>的两个方式:</p><ul><li><span class="math inline">\(\frac{2max(|r|)}{2^n-1}\)</span></li><li><span class="math inline">\(\frac{max(|r|)}{2^{n-1}-1}\)</span></li></ul><p>对称量化使用广泛,因为可以把零点降为0,减少计算成本并且实现更加简单;非对称量化对于范围可能是倾斜的和不对称的情况表现会更加优秀.</p><p>非对称激活中的偏移而占据的交叉项是一个静态数据独立项并且可以被偏差吸收(或用于初始化累加器).</p><h3 id="范围校准算法静态与动态量化">范围校准算法：静态与动态量化</h3><ul><li>动态量化：运行期间计算量化参数，高精度，高开销</li><li>静态量化：量化参数预先确定，推理期间为静态，低开销，低精度</li></ul><h3 id="量化粒度">量化粒度</h3><ul><li>分层量化：通过一整个层的数值来计算量化参数，实现简单，精度次优</li><li>分组量化：把每一层的多个通道进行分组量化，有助于解决单个通道、激活分布离散的情况，但是计算开销会增加</li><li>分通道量化：每一层的每个通道进行量化，更好的精度，更高的计算成本</li><li>分卷积核（滤波器）量化：输入通道为<span class="math inline">\(n\)</span>，输出通道为<span class="math inline">\(m\)</span>，那么应该会有<span class="math inline">\(n*m\)</span>个卷积核，根据卷积核量化会有更高的精度</li></ul><p>总结（量化粒度）。通道量化是目前用于量化卷积核的标准方法。它使从业者能够以可忽略不计的开销来调整每个单独的内核的剪切范围。相比之下，子信道量化可能会导致巨大的开销，而且目前还不是标准的选择。</p><h3 id="非均匀量化">非均匀量化</h3><p>量化步骤和量化水平被允许是非均匀间隔的</p><p><span class="math display">\[Q(r)=X_i, \quad if\quad r \in [r_i,r_{i+1}]\]</span></p><p>非均匀量化对于固定的位宽，可以获得更高的精度 典型的有</p><ul><li>钟型分布</li><li>对数分布</li><li>二进制码,把一个向量拆成多个基向量的和,每个基向量的每个维度的值的绝对值为1</li></ul><p>很多把量化问题转化为优化问题,减少原始张量r和量化后张量Q(r)的差异</p><p><span class="math display">\[\underset{Q}{min}||Q(r)-r||\]</span></p><p>此外,量化器本身也可以和模型参数一起学习,称之为可学习的量化器还有一些工作使用<strong>聚类</strong>来减少量化损失</p><p>非均匀量化能更好的捕获信息,但是计算成本更高,因此目前主流的还是均匀量化</p><h3 id="微调方法">微调方法</h3><p>量化可能需要对参数进行微调,有两种方式:</p><ul><li>量化感知训练QAT</li><li>训练后量化PTQ</li></ul><p>左边是QAT,右边是PTQ <img src="/62023/1700397462765.png"></p><h4 id="qat">QAT</h4><p>QAT一种方法展示 <img src="/62023/1700397965758.png">反向传播方法有:</p><ul><li>STE</li><li>随机神经元</li><li>组合优化</li><li>目标传播</li><li>Gumbelsoftmax</li><li>正则化算子来强制执行要量化的权重(量化过程没有不可微分算符)</li></ul><p>也可以考虑量化感知训练的过程种学习量化参数</p><h4 id="ptq">PTQ</h4><p>PTQ的流程：</p><p><img src="/62023/1730970627502.png"></p><p>由于PTQ不需要训练，所以对数据集的依赖比较低，当然，精度也会下降</p><p>因此，PTQ的研究重点都在于减轻PTQ的精度下降：</p><ul><li>ACIQ 解析地计算了PTQ的最佳剪切范围和通道级位宽设置</li><li>OMSE方法在激活时去除信道级量化，并提出通过优化量化张量与相应的浮点张量之间的L2距离来进行PTQ</li><li>一种离群值信道分裂（OCS）方法，该方法将包含离群值的信道重复和减半，缓解离群值对PTQ的不利影响</li><li>AdaRound表明，简单的圆到最近的量化方法（round-to-nearest）可以反直觉地得到次优解，并且提出了一种自适应四舍五入的方法</li><li>AdaQuant提出了一种更通用的方法，允许量化权值根据需要进行变化。</li></ul><p>在PTQ中，所有的权值和激活量化参数都是不需要再训练而确定的。因此，PTQ是一种非常快速的神经网络模型量化方法。然而，与QAT相比，这往往以较低的准确性为代价。</p><h4 id="zero-shot-quantizationzsq">Zero-shot Quantization（ZSQ）</h4><p>PTQ的极端场景，量化过程中不使用数据</p><ul><li>Level 1: 没有数据且没有微调 (ZSQ + PTQ).</li><li>Level 2: 没有数据但需要微调 (ZSQ +QAT).</li></ul><p>ZSQ中一个流行的研究分支是生成与类似于真实数据的合成数据，从中训练目标预先训练的模型。</p><h3 id="随机量化">随机量化</h3><p>在推理过程中，量化方案总是确定的，小的权重更新可能不会导致任何权重变化，因为舍入操作可能总是返回相同的权重。然而，启用一个随机舍入可能为神经网络提供一个随机的机会，从而更新其参数。</p><p>比如，在有的论文里面，INT操作定义为</p><p><span class="math display">\[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}\]</span></p><p>有的会选择在量化的适合选择随机从量化参数权重子集里选一个进行量化运算</p><h2 id="advanced-concepts-quantization-below-8-bits">ADVANCED CONCEPTS:QUANTIZATION BELOW 8 BITS</h2><h3 id="模拟和纯整数量化">模拟和纯整数量化</h3><p>部署量化神经网络模型有两种常见方法：</p><ul><li>模拟量化（又名假量化）：模拟量化中，量化后的模型参数以低精度存储，但运算（例如矩阵乘法和卷积）是用浮点运算进行的，运算之前需要对量化参数进行反量化</li><li>纯整数量化（又名定点量化）：所有运算都是使用低精度整数算术执行</li></ul><p><img src="/62023/1712407532667.png"></p><p>如下图所示，硬件对低精度的处理会更好，并且低精度能量和面积方面的效率明显更高。</p><p><img src="/62023/1712407640141.png"></p><p>（这里稍微介绍了对于各种激活函数的量化方法，可以留意一下？</p><p>二进量化（Dyadicquantization）是一种特殊的量化方法，通过把权重量化为二元数（二元数是分子中具有整数值、分母中具有2 的幂的有理数），从而把运算转化为加减与位移从而提高效率。</p><p>两种量化种纯整数量化应用较多，但是假量化在通信成本高于计算成本的时候也有一定的应用前景。</p><h3 id="混合精度量化">混合精度量化</h3><p>使用较低精度的量化时，硬件性能会提高。然而，将模型统一量化为超低精度可能会导致精度显着下降，可以通过混合精度量化来解决这个问题。</p><p>每一层都以不同的位精度进行量化，如下图所示。这种方法的一个挑战是，用于选择此位设置的搜索空间与层数成指数关系。人们提出了不同的方法来解决这个巨大的搜索空间。</p><p><img src="/62023/1712408451748.png"></p><p>搜索方法有：</p><ul><li>强化学习</li><li>转化为神经架构搜索NAS使用DNAS解决</li></ul><p>另一类混合精度方法使用周期函数正则化来训练混合精度模型，方法是在学习各自的位宽时自动区分不同的层及其在准确性方面的不同重要性。</p><p>HAWQ引入了一种基于模型二阶灵敏度自动查找混合精度设置的方法。</p><h3 id="硬件感知量化">硬件感知量化</h3><p>量化带来的性能提升和硬件有着密切关系，比如带宽设置、缓存结构等。因此，通过硬件感知量化实现最佳效益十分重要。</p><h3 id="蒸馏辅助量化">蒸馏辅助量化</h3><p>量化领域的一个有趣的工作是结合模型蒸馏来提高量化精度。在学生模型的训练过程中，模型蒸馏建议利用教师产生的软概率，而不是仅使用真实类别标签，其中可能包含更多的输入信息。</p><p><span class="math display">\[\mathcal{L}=\alpha\mathcal{H}(y,\sigma(\mathcal{z}_{s}))+\beta\mathcal{H}(\sigma(\mathcal{z}_{t},T),\sigma(\mathcal{z}_{s},T))\]</span></p><p>α 和 β 是调整学生模型损失量和蒸馏损失的加权系数，y 是真实类别标签，<span class="math inline">\(\mathcal{H}\)</span>是交叉熵损失函数，<span class="math inline">\({\mathcal{z}}_{s}/{\mathcal{z}}_{t}\)</span>是学生/教师模型生成的概率，T是温度。</p><p><span class="math display">\[p_{i}=\frac{\exp\frac{z_{i}}{T}}{\sum_{j}\exp\frac{z_{j}}{T}}\]</span></p><p>然后有许多关于蒸馏过程的尝试，比如使用软概率、中间层数据、多教师模型等。</p><h3 id="极致量化">极致量化</h3><p>这里提到了一些极端的量化方法，比如二值化和三值化等，但是极致的量化也会带来巨大的精度损失。因此有许多工作是关于极值量化的。目前大致有三个分支：</p><ul><li>量化误差最小化</li><li>改进损失函数</li><li>改进训练方法</li></ul><h3 id="矢量量化">矢量量化</h3><p>量化的目标是保持精度，而不是单个值的差异。因此有相关工作是把权重聚类分组然后使用中心作为量化值。还可以扩展为矩阵的乘积量化，把矩阵按照子矩阵分组。</p><h2 id="量化和硬件处理器">量化和硬件处理器</h2><p>这里罗列了一些处理器，并且介绍了他们的特点。</p><h2 id="量化的未来研究">量化的未来研究</h2><p>介绍了未来可以研究的几个东西：</p><ul><li>量化软件</li><li>硬件和神经网络架构协同设计</li><li>耦合压缩方法</li><li>量化训练</li></ul><h2 id="总结和结论">总结和结论</h2><p>...</p><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href="https://arxiv.org/abs/2103.13630">A Survey of QuantizationMethods for Efficient Neural Network Inference</a></li></ul></blockquote>]]></content>
<categories>
<category> 科研 </category>
<category> 论文阅读 </category>
</categories>
<tags>
<tag> 量化 </tag>
</tags>
</entry>
<entry>
<title>论文阅读:BitNet_Scaling_1-bit_Transformers_for_Large_Language_Models</title>
<link href="//8948/"/>
<url>//8948/</url>
<content type="html"><![CDATA[<h2 id="摘要">摘要</h2><p>这篇论文展示了BitNet,一种为大型语言模型设计的可扩展和稳定的1-bit转换器架构。具体地说，引入了BitLinear作为nn.Linar的插入替代,以便从头开始训练1-bit的权重。在语言建模上的实验结果表明，与最先进的8-bit量化方法和FP16Transformer相比，BitNet在显著降低内存占用和能量消耗的同时，实现了强力的性能。此外，BitNet还展示了一种类似于全精度Transformers的scalinglow，这表明它可以在保持效率和性能效益的同时有效地扩展到更大的语言模型。</p><p><img src="/8948/1698064373146.png"></p><p>图1： BitNet从头开始训练1-bitTransformers，以一种高效的方式获得竞争结果。BitNet明显优于最先进的量化方法。随着模型规模的扩大，成本节约变得更加显著，同时实现与FP16训练的模型的竞争性能。</p><h2 id="介绍">介绍</h2><p>大模型的推理陈本较高，一个降低成本的重要办法就是量化。</p><p>目前LLM的量化方法大多数都是训练后量化PTQ，成本比QAT低但在极低精度表现不好。</p><p>LLM量化的另一类方法是量化感知训练QAT，效果更好，但是在低精度下难以收敛。此外，不确定QAT是否遵循scalinglow。</p><p>本文首次提出1-bit大模型QAT，提出BitNet，LLM的1-bittransformer。采用低精度二进制权重和量化激活，同时在训练期间保持优化器状态和梯度的高精度。BitNet架构的实现非常简单，只需要替换Transformer 中的线性投影（即 PyTorch 中的nn.Linear）。</p><p>在一系列语言建模基准上评测了BitNet。与最先进的量化方法和fp16的baseline相比有竞争力。有效减少了内存占用和能耗。同时遵循类似的scalinglow。</p><h2 id="bitnet">BitNet</h2><p>模型整体架构图如图所示：</p><p><img src="/8948/1730709381779.png"></p><p>相比transformer，使用BitLinear替代原有的Linear和传统的矩阵乘法，其他组件保持高精度，作者认为原因如下：</p><ul><li>残差连接和层归一化对大型语言模型的计算成本可以忽略不计</li><li>随着模型变大，QKV 变换的计算成本比参数投影小得多</li><li>保留输入/输出嵌入的精度，因为语言模型必须使用高精度概率来执行采样</li></ul><h3 id="bitlinear">BitLinear</h3><p>BitLinear把权重二值化为+1或-1。在训练的时候，为了保证反向传播的有效性，模型的参数$ W ^{n m} $是保持高精度的，但是forward的时候会进行量化操作：</p><p><span class="math display">\[\tilde{W} = \text{Sign}(W - \alpha), \quad\text{Sign}(W_{ij}) = \begin{cases}+1, & \text{if } W_{ij} > 0, \\-1, & \text{if } W_{ij} \leq 0,\end{cases} \quad\alpha = \frac{1}{nm} \sum_{ij} W_{ij}\]</span></p><p>激活也会量化到$[-Q_{b},Q_{b}] (Q_{b}=2^{b-1})$，同时添加细致扰动防止clip时溢出：</p><p><span class="math display">\[\tilde{x} = \text{Quant}(x) = \text{Clip}\left( x \times\frac{Q_b}{\gamma}, -Q_b + \epsilon, Q_b - \epsilon \right) \\\text{Clip}(x, a, b) = \max(a, \min(b, x)), \quad \gamma = \lVert x\rVert_{\infty}\]</span></p><p>对于非线性函数之前的激活，会缩放到<span class="math inline">\([0,Q_{b}] (Q_{b}=2^{b-1})\)</span>：</p><p><span class="math display">\[\tilde{x} = \text{Quant}(x) = \text{Clip}\left( (x - \eta) \times\frac{Q_b}{\gamma}, \epsilon, Q_b - \epsilon \right), \quad \eta =\min_{ij} x_{ij}\]</span></p><p>其中BitLinear的forward过程为：</p><p><span class="math display">\[\\\text{LN}(x) = \frac{x - E(x)}{\sqrt{\text{Var}(x)} + \epsilon}, \quad\beta = \frac{1}{nm} \lVert W \rVert_1 \\y = \tilde{W} \tilde{x} = \tilde{W} \, \text{Quant}(\text{LN}(x)) \times\frac{\beta \gamma}{Q_b}\]</span></p><blockquote><p>下面这段分析我也不是很理解，一直不知道约等于是怎么来的？</p></blockquote><p>分析：</p><p><span class="math display">\[\begin{align*}y &= \tilde{W} \tilde{x} \ ,\\\text{Var}(y) &= n \, \text{Var}(\tilde{w} \tilde{x}) \\\quad &= n E[\tilde{w}^2] E[\tilde{x}^2] \\\quad &= n \beta^2 E[\tilde{x}^2] \approx E[\tilde{x}^2]\end{align*}\]</span></p><p>当使用归一化操作后，<span class="math inline">\(Var(y) ≈ E[LN(\tilde{x} )^2] = 1\)</span></p><p>同时，为了支持张量并行（一个张量拆分到多卡上），部分参数的需要通过<code>all-reduce</code>来确定，但是会增加通信成本，因此考虑分组确定，即将权重和激活分为几组，然后独立估计每组的参数：</p><p><span class="math display">\[\alpha_g = \frac{G}{nm} \sum_{ij} W_{ij}^{(g)}, \quad \beta_g =\frac{G}{nm} \lVert W^{(g)} \rVert_1\]</span></p><h3 id="模型训练">模型训练</h3><h4 id="ste">STE</h4><p>由于有量化操作不可微分，因此考虑引入<strong>STE</strong>进行梯度的近似。</p><h4 id="混合精度">混合精度</h4><p>虽然权重和激活被量化为低精度，但梯度和优化器状态以高精度存储，以确保训练的稳定性和准确性。以高精度格式为可学习参数维护一个潜在权重，以累积参数更新。潜在权重在前向传播过程中被动态二值化，并且从不用于推理过程。</p><h4 id="增大学习率">增大学习率</h4><p>潜在权重的小幅度更新可能不会引起1位权重的变化，为了加速收敛，考虑增大学习率的值。实验表明，BitNet在收敛方面受益于较大的学习率，而 FP16 Transformer在相同学习率的训练开始时会发散。</p><h3 id="计算能效">计算能效</h3><p>论文还给出了理论的计算能效，主要关注矩阵乘法部分。</p><p><img src="/8948/1730712131791.png"></p><p>对于transformer里的矩阵乘法，两个矩阵维度分别为<span class="math inline">\(m \times n\)</span>和<span class="math inline">\(n\times m\)</span>，能效计算公式为：</p><p><span class="math display">\[E_{add} = m \times (n - 1) \times p \times \hat{E}_{add} \\E_{mul} = m \times n \times p \times \hat{E}_{mul}\]</span></p><p>对于BitNet，矩阵权重为1比特的，因此矩阵乘法的能耗主要由加法决定，和transformer的加法能耗公式相同，而用于放缩的乘法能耗公式为：</p><p><span class="math display">\[E_{mul} = (m \times p + m \times n) \times \hat{E}_{mul}\]</span></p><h2 id="位transformer对比">16位transformer对比</h2><p>使用各种规模的 BitNet 训练一系列自回归语言模型，范围从 125M 到30B。这些模型在英语语料库上进行训练，该语料库由 Pile 数据集、CommonCrawl 快照、RealNews 和 CC-Stories数据集组成。具体的训练超参可以阅读原文。同时训练作为对比的transformer。</p><p>从测试可以发现，模型的loss与transformer相比有类似的scaling low。</p><p><img src="/8948/1730721059917.png"></p><p>能耗也有类似的规律。</p><p><img src="/8948/1730721352940.png"></p><p>当增大学习率的时候，BitNet可以更好的保持性能。</p><p><img src="/8948/1730721428081.png"></p><h2 id="与ptq对比">与PTQ对比</h2><p>使用与前文相同的设置训练BitNet和transformer，在训练好的transformer上尝试PTQ量化。</p><p>结果如下所示：</p><p><img src="/8948/1730721567241.png"></p><p><img src="/8948/1730721573391.png"></p><p>在PPL和Acc上结果明显优于目前最优的PTQ方法。</p><h2 id="消融实验">消融实验</h2><p>作者还尝试了消融实验：</p><p><img src="/8948/1730721660913.png"></p><p>BitNet使用的是<code>absmax</code>+<code>SubLn</code>。Elastic代表弹性的量化函数，通过可学习的参数动态调整尺度。Pre-LN是 GPT 相关的默认架构，而 BMT 已被证明可以提高二值化模型的稳定性。</p><h2 id="代码">代码</h2><p>核心代码文件为：<a href="https://github.com/kyegomez/BitNet/blob/main/bitnet/bitlinear.py">BitNet/bitnet/bitlinear.pyat main · kyegomez/BitNet</a></p><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href="https://arxiv.org/abs/2310.11453">BitNet: Scaling 1-bitTransformers for Large Language Models</a></li><li><a href="https://github.com/kyegomez/BitNet">kyegomez/BitNet:Implementation of "BitNet: Scaling 1-bit Transformers for Large LanguageModels" in pytorch</a></li></ul></blockquote>]]></content>
<categories>
<category> 科研 </category>
<category> 论文阅读 </category>
</categories>
<tags>
<tag> 量化 </tag>
</tags>
</entry>
<entry>
<title>Hexo+Github搭建个人Wiki风格博客</title>
<link href="//13640/"/>
<url>//13640/</url>
<content type="html"><![CDATA[<h2 id="介绍">介绍</h2><p>以前一直不理解更新博客的用处，后来发现记录一些学到的东西和处理问题的经验对个人还是互联网都是有促进作用的(<del>希望不是在生产互联网垃圾</del>)。</p><p>所以本文会介绍一下个人搭建这个博客的过程。</p><blockquote><p>后面博客有添加双主题的教程。</p></blockquote><h2 id="博客风格">博客风格</h2><ul><li>简洁（<del>本来想弄点二次元风格的，但是博客还是减少点无用东西吧</del>）（<del>后来还是加了二次元主题来使用双主题</del>）</li><li>多级分类：多级分类可以帮助来快速浏览学过的知识点</li><li>标签：标签还是比较重要的，可以实习对相关博客的快速定位</li></ul><h2 id="主题选择">主题选择</h2><p>基于上述的需求，最终选择了<a href="https://blog.zthxxx.me/post/personal-wiki-system-theme-for-hexo/#%E7%94%A8-hexo-%E5%81%9A%E4%B8%AA%E4%BA%BA-wiki-%E7%9F%A5%E8%AF%86%E7%AE%A1%E7%90%86%E7%B3%BB%E7%BB%9F">Wikitten</a>作为自己的博客主题</p><p>顺便放一下这个大佬的相关链接：</p><ul><li>Wiki地址：<a href="http://wiki.zthxxx.me/">http://wiki.zthxxx.me/</a></li><li>Wikitten主题地址：<a href="https://github.com/zthxxx/hexo-theme-Wikitten/">https://github.com/zthxxx/hexo-theme-Wikitten/</a></li></ul><h2 id="环境搭建">环境搭建</h2><p>参考地址:<a href="https://zhuanlan.zhihu.com/p/60578464">使用Hexo+GitHub 搭建个人免费博客教程（小白向） - 知乎 (zhihu.com)</a></p><ol type="1"><li><p>Github创建项目并取名为 <code>用户名.github.io</code></p></li><li><p>使用 npm 一键安装 Hexo 博客程序</p><p></p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token function">npm</span> <span class="token function">install</span> <span class="token parameter variable">-g</span> hexo-cli<span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre><p></p></li><li><p>准备一个空文件，进行hexo初始化：</p><p></p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash">hexo init <span class="token comment"># 初始化</span><span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre><p></p></li><li><p>使用npm安装package.json里面的依赖</p><p></p><pre class="line-numbers language-bash" data-language="bash"><code class="language-bash"><span class="token function">npm</span> <span class="token function">install</span><span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre><p></p></li><li><p>安装用于部署的包<strong>hexo-deployer-git</strong></p><p></p><pre class="line-numbers language-none"><code class="language-none">npm install hexo-deployer-git --save<span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre><p></p></li><li><p>修改_config.yml文件末尾的Deployment部分</p><p></p><pre class="line-numbers language-none"><code class="language-none">deploy:type: gitrepository: git@github.com:用户名/用户名.github.io.gitbranch: master<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span></span></code></pre><p></p></li></ol><h2 id="公式">公式</h2><p>公式引擎有 <code>mathjax</code>和<code>katex</code>两种，前者的功能多一点，后者则更加轻量化。可以根据自己的需要进行选择或者尝试后再做选择。</p><h3 id="mathjax">Mathjax</h3><p>参考文章：<a href="https://blog.csdn.net/qq_52466006/article/details/126924064">Hexo显示Latex公式最新解决方案_hexolatex-CSDN博客</a></p><ol type="1"><li><p>卸载部分插件</p><pre class="line-numbers language-none"><code class="language-none">npm un hexo-mathnpm un hexo-renderer-marked<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span></span></code></pre></li><li><p>安装hexo-renderer-pandoc渲染器</p><pre class="line-numbers language-none"><code class="language-none">npm i hexo-renderer-pandoc<span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre></li><li><p>配置主题配置下的mathjax设置(文件位置在<code>\themes\{主题名}\ _config.yml</code></p><pre class="line-numbers language-none"><code class="language-none"># MathJaxmathjax: enable: true per_page: true<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span></span></code></pre></li><li><p>安装Pandoc</p><p>去Pandoc官网下载<strong>最新版本</strong>pandoc：<a href="https://pandoc.org/index.html" title="Pandoc - About pandoc">Pandoc - About pandoc</a> （参考文章说<code>Anaconda</code>自带的<code>pandoc</code>可能会引起问题并且提供了解决方案，但是笔者使用的是<code>miniconda</code>，没有遇到任何问题</p></li></ol><h3 id="katex">Katex</h3><p>参考文章：<a href="https://proton.lat/2024/06/19/Mathjax/">如何在Butterfly 主题中使用 KaTeX 数学公式 | Proton's Blog</a></p><ol type="1"><li><p>卸载部分插件（如果还装了什么其他的旧渲染器，也要一并卸载</p><pre class="line-numbers language-powershell" data-language="powershell"><code class="language-powershell">sudo npm un hexo-renderer-marked <span class="token operator">--</span>save<span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre></li><li><p>安装 <code>hexo-renderer-markdown-it-katex</code></p><pre class="line-numbers language-none"><code class="language-none">npm i hexo-renderer-markdown-it-katex<span aria-hidden="true" class="line-numbers-rows"><span></span></span></code></pre></li><li><p>然后在hexo的博客文件 <code>_config.yml</code>里添加</p><pre class="line-numbers language-none"><code class="language-none">markdown: render: html: true xhtmlOut: false breaks: true linkify: true typographer: true plugins: anchors: level: 1 collisionSuffix: ''<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre></li></ol><h2 id="图片">图片</h2><p>参考文章：<a href="https://leay.net/2019/12/25/hexo/">Hexo引用本地图片以及引用本地任意位置图片的一点思路 | 养恐龙(leay.net)</a></p><p>对于图片显示，<code>hexo</code>的原生设置较为冷门，<code>hexo-asset-image</code>等插件也提供了一定的解决方法，在博客文件同目录下设置个同名文件夹存放图片。但是笔者习惯使用<code>vscode</code>编辑<code>markdown</code>文章，而vscode默认在同目录下的<code>/image/{文件名}</code>下存放图片文件。</p><p>笔者最后没有找到已有的较好的解决方案，于是写了个脚本文件进行处理（仅供参考）。</p><p>首先安装 <code>hexo-asset-image</code>插件，然后在<code>_config.yml</code>里设置：</p><pre class="line-numbers language-none"><code class="language-none">post_asset_folder: true # 注意这个不能简单设置为false，否则插件hexo-asset-image会直接跳过（可以看看源码marked: prependRoot: true postAsset: true<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span></span></code></pre><p>然后构建一个脚本文件在每次更新完后进行预处理，其中重要函数为</p><pre class="line-numbers language-none"><code class="language-none">import osimport shutilimport refrom functools import partialdef 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)<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><h2 id="hexo常用命令">Hexo常用命令</h2><pre class="line-numbers language-none"><code class="language-none">hexo clean #清除生成的网页文件hexo g #生成静态网页hexo s #本地运行博客hexo d #将网页文件推送至远程服务器<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span></span></code></pre><h2 id="hexo常用文件夹">Hexo常用文件夹</h2><table><thead><tr><th style="text-align: center;">文件夹</th><th style="text-align: center;">备注</th></tr></thead><tbody><tr><td style="text-align: center;">node_modules</td><td style="text-align: center;">依赖文件</td></tr><tr><td style="text-align: center;">.deploy_git</td><td style="text-align: center;">推送到远程的文件</td></tr><tr><td style="text-align: center;">public</td><td style="text-align: center;">生成的网页文件</td></tr><tr><td style="text-align: center;">themes</td><td style="text-align: center;">主题文件夹</td></tr><tr><td style="text-align: center;">scaffolds</td><td style="text-align: center;">博客模板文件夹</td></tr><tr><td style="text-align: center;">source</td><td style="text-align: center;">博客源文件</td></tr></tbody></table><h2 id="主题安装">主题安装</h2><p>Wikitten主题地址：<a href="https://github.com/zthxxx/hexo-theme-Wikitten/">https://github.com/zthxxx/hexo-theme-Wikitten/</a>里面提供了双语详细的安装步骤,笔者使用的版本是 <code>5b0d493</code></p><blockquote><p><strong>注意</strong>:里面有个可选步骤<strong>配置mathjax渲染</strong>，笔者发现进行这个步骤后会出现生成网页文件失败的情况，跳过即可，并且暂时没发现有什么问题</p></blockquote><h2 id="评论系统giscus">评论系统giscus</h2><p>由于不知名的原因，Gitment和Gitalk无法使用，选择了<a href="https://giscus.app/zh-CN#category">giscus</a>来替代,参考<a href="https://blog.webrelay.cn/giscus/">Hexo静态博客使用giscus评论系统教程</a></p><p><strong>1.打开自己的GitHub，选择博客所在仓库或可新建一个仓库</strong></p><ul><li>确保仓库是公开的(新建的时候选择 <code>private</code>或者在仓库的<code>Settings - General</code>，选择<code>change visibility - change to public</code>)</li><li>确保仓库开启了 <code>Discussions</code>(在仓库的<code>Settings - General</code>，勾选 <code>Discussions</code>)</li><li>确保安装了 <a href="https://github.com/apps/giscus">giscusapp</a></li></ul><p><strong>2.打开官方配置页面<a href="https://giscus.app/zh-CN#category">giscus</a>，生成代码</strong></p><ul><li>语言</li><li>仓库：填写格式：你的用户名/你的仓库名</li><li>页面 与 discussion映射关系：由于本博客会分级，所以选择路径pathname</li><li>Discussion分类：General</li><li>特性:按个人喜好即可，本博客加载了：<code>启用主贴上的反应</code>,<code>将评论框放在评论上方</code>,<code>懒加载评论</code></li><li>主题：选择与博客风格一致的主题</li></ul><p><strong>3.修改主题 <code>_config.yml</code></strong>在文件末尾添加</p><pre class="line-numbers language-none"><code class="language-none">giscus: enable: true<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span></span></code></pre><p>方便以后直接从配置文件开关评论区</p><p><strong>4.粘贴代码</strong>网页会自动生成代码,复制粘贴到网页模板文件即可不同主题的模板文件位置可能不同，wiki主题在<code>themes/Wikitten/layout/comment/giscus.ejs</code>下添加代码(然后检查同目录的引入giscus的文件：<code>counter.ejs</code>，<code>index.ejs</code>，<code>scripts.ejs</code>，仿照之前代码添加引入)</p><pre class="line-numbers language-none"><code class="language-none"><% 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="title" 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> <% } %><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><p>然后修改<code>themes/Wikitten/layout/common/article.ejs</code>文件，把</p><pre class="line-numbers language-none"><code class="language-none"><% if (!index) { %> <%- partial('comment/index') %><% } %><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span></span></code></pre><p>移动到</p><pre class="line-numbers language-none"><code class="language-none"><footer class="article-footer"></footer><span aria-hidden="true" class="line-numbers-rows"><span></span><span></span></span></code></pre><p>前面，两个代码块在同一个 <code>div</code>内。</p><p>然后在 <code>themes/Wikitten/_config.yml</code>内修改：</p><pre class="line-numbers language-none"><code class="language-none">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'<span aria-hidden="true" class="line-numbers-rows"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></span></code></pre><blockquote><p>对于不同的主题添加的方式可能不同</p></blockquote><h2 id="常见qa">常见QA</h2><ol type="1"><li><p><strong>修改配置文件应该修改站点的 <code>_config.yml</code>还是主题的 <code>_config.yml</code>?</strong></p><p>具体使用哪个，要看主题的源代码，如果是<code>config.xxx</code>那就是用的根目录配置文件，如果是<code>theme.xxx</code>那就用的是主题目录的配置文件。</p></li><li><p><strong>怎么让自己的博客可以被常用搜索引擎搜索到?</strong></p><p>很多搜索引擎可以在搜索框里用 <code>site:网址</code>来判断是否被收录<strong>Google</strong></p><ol type="1"><li>打开Google搜索，搜索“Google Search Console”</li><li>根据提示登录你的Google账号</li><li>选择资源类型</li><li>选择验证方式(本博客用的是<strong>HTML标记</strong>,把对应代码添加到主题文件里面,本主题是<code>themes/Wikitten/layout/common/head.ejs</code>)</li><li>在Google Search Console后台添加站点地图</li></ol></li></ol><h2 id="参考资料">参考资料</h2><blockquote><ul><li><a href="https://zhuanlan.zhihu.com/p/60578464">使用 Hexo+GitHub搭建个人免费博客教程（小白向）</a></li><li><a href="https://blog.zthxxx.me/post/personal-wiki-system-theme-for-hexo/#%E7%94%A8-hexo-%E5%81%9A%E4%B8%AA%E4%BA%BA-wiki-%E7%9F%A5%E8%AF%86%E7%AE%A1%E7%90%86%E7%B3%BB%E7%BB%9F">Hexo的个人 Wiki 主题 - Wikitten</a></li><li><a href="https://godweiyang.com/2018/04/13/hexo-blog/#toc-heading-14">超详细Hexo+Github博客搭建小白教程</a></li><li><a href="https://blog.csdn.net/qq_52466006/article/details/126924064">Hexo显示Latex公式最新解决方案_hexolatex-CSDN博客</a></li><li><a href="https://proton.lat/2024/06/19/Mathjax/">如何在 Butterfly主题中使用 KaTeX 数学公式 | Proton's Blog</a></li><li><a href="https://leay.net/2019/12/25/hexo/">Hexo引用本地图片以及引用本地任意位置图片的一点思路 | 养恐龙(leay.net)</a></li><li><a href="https://blog.webrelay.cn/giscus/">Hexo静态博客使用giscus评论系统教程</a></li><li><a href="https://hexo.io/zh-cn/">Hexo官方文档</a></li></ul></blockquote>]]></content>
<categories>
<category> SmallProjects </category>
<category> 博客搭建 </category>
</categories>
<tags>
<tag> 博客 </tag>
<tag> Hexo </tag>
<tag> Wiki </tag>
</tags>
</entry>
<entry>
<title>快速启动工具——utools</title>
<link href="//44392/"/>
<url>//44392/</url>
<content type="html"><![CDATA[<h1 id="介绍">介绍</h1><p>这里接受一个快速启动的工具utools和常用的插件。</p><h1 id="utools">utools</h1><p>utools已经被很多人开始使用了，无论是<code>alt</code>+<code>space</code>还是鼠标中键等快速启动方式，都可以使用户不要来回在鼠标和键盘之间切换从而提升效率。内置的一些默认插件已经可以极大的提升效率了。</p><p>utools优势：</p><ul><li><strong>完善的生态市场</strong>：里面有很多人在开发各种插件，并且插件的体积都非常小，也支持插件数据迁移，基本你想到的功能都可以在插件市场找到</li><li><strong>多平台</strong>：utools在多个平台都可以使用，也可以多平台进行数据迁移</li></ul><h1 id="插件推荐">插件推荐</h1><h2 id="音速启动">音速启动</h2><p>utools搜索框可以使用且快速启动的大概为系统安装的软件搜素、文件搜索、网络搜索、插件搜索等，但是假如你有复杂的命令以及一个别名使用多个命令等，这是原生的utools无法使用的，而下面这款插件就可以使用。</p><p>音速启动插件是utools官方开发的插件，可以让utools快速启动的能力再次得到提高。在音速启动的配置界面，你可以配置一些命令，并且给这些常用的命令起别名，这样在utools搜索框内就可以通过别名快速运行一些命令。</p>]]></content>
<categories>
<category> 工具 </category>
</categories>
<tags>
<tag> 工具 </tag>
<tag> 效率 </tag>
</tags>
</entry>
</search>