echarlaix HF Staff commited on
Commit
16166b0
·
1 Parent(s): bc83e0f

commit file to HF hub

Browse files
config.json ADDED
@@ -0,0 +1,28 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "_name_or_path": "textattack/bert-base-uncased-SST-2",
3
+ "architectures": [
4
+ "BertForSequenceClassification"
5
+ ],
6
+ "attention_probs_dropout_prob": 0.1,
7
+ "classifier_dropout": null,
8
+ "finetuning_task": "sst2",
9
+ "gradient_checkpointing": false,
10
+ "hidden_act": "gelu",
11
+ "hidden_dropout_prob": 0.1,
12
+ "hidden_size": 768,
13
+ "initializer_range": 0.02,
14
+ "intermediate_size": 3072,
15
+ "layer_norm_eps": 1e-12,
16
+ "max_position_embeddings": 512,
17
+ "model_type": "bert",
18
+ "num_attention_heads": 12,
19
+ "num_hidden_layers": 12,
20
+ "pad_token_id": 0,
21
+ "position_embedding_type": "absolute",
22
+ "problem_type": "single_label_classification",
23
+ "torch_dtype": "float32",
24
+ "transformers_version": "4.10.2",
25
+ "type_vocab_size": 2,
26
+ "use_cache": true,
27
+ "vocab_size": 30522
28
+ }
lpot_config.yml ADDED
@@ -0,0 +1,1441 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ advance: null
2
+ approach: post_training_static_quant
3
+ calib_iteration: 7
4
+ framework: pytorch
5
+ op:
6
+ ? !!python/tuple
7
+ - quant
8
+ - QuantStub
9
+ : activation:
10
+ dtype: uint8
11
+ scheme: asym
12
+ granularity: per_tensor
13
+ algorithm: minmax
14
+ ? !!python/tuple
15
+ - bert.encoder.layer.0.attention.self.quant
16
+ - QuantStub
17
+ : activation:
18
+ dtype: uint8
19
+ scheme: asym
20
+ granularity: per_tensor
21
+ algorithm: minmax
22
+ ? !!python/tuple
23
+ - bert.encoder.layer.0.attention.self.query
24
+ - Linear
25
+ : weight:
26
+ dtype: int8
27
+ scheme: sym
28
+ granularity: per_channel
29
+ algorithm: minmax
30
+ bit: 7.0
31
+ activation:
32
+ dtype: uint8
33
+ scheme: sym
34
+ granularity: per_tensor
35
+ algorithm: kl
36
+ ? !!python/tuple
37
+ - bert.encoder.layer.0.attention.self.key
38
+ - Linear
39
+ : weight:
40
+ dtype: int8
41
+ scheme: sym
42
+ granularity: per_channel
43
+ algorithm: minmax
44
+ bit: 7.0
45
+ activation:
46
+ dtype: uint8
47
+ scheme: sym
48
+ granularity: per_tensor
49
+ algorithm: kl
50
+ ? !!python/tuple
51
+ - bert.encoder.layer.0.attention.self.value
52
+ - Linear
53
+ : weight:
54
+ dtype: int8
55
+ scheme: sym
56
+ granularity: per_channel
57
+ algorithm: minmax
58
+ bit: 7.0
59
+ activation:
60
+ dtype: uint8
61
+ scheme: sym
62
+ granularity: per_tensor
63
+ algorithm: kl
64
+ ? !!python/tuple
65
+ - bert.encoder.layer.0.attention.output.quant
66
+ - QuantStub
67
+ : activation:
68
+ dtype: uint8
69
+ scheme: asym
70
+ granularity: per_tensor
71
+ algorithm: minmax
72
+ ? !!python/tuple
73
+ - bert.encoder.layer.0.attention.output.dense
74
+ - Linear
75
+ : weight:
76
+ dtype: int8
77
+ scheme: sym
78
+ granularity: per_channel
79
+ algorithm: minmax
80
+ bit: 7.0
81
+ activation:
82
+ dtype: uint8
83
+ scheme: sym
84
+ granularity: per_tensor
85
+ algorithm: kl
86
+ ? !!python/tuple
87
+ - bert.encoder.layer.0.intermediate.quant
88
+ - QuantStub
89
+ : activation:
90
+ dtype: uint8
91
+ scheme: asym
92
+ granularity: per_tensor
93
+ algorithm: minmax
94
+ ? !!python/tuple
95
+ - bert.encoder.layer.0.intermediate.dense
96
+ - Linear
97
+ : weight:
98
+ dtype: int8
99
+ scheme: sym
100
+ granularity: per_channel
101
+ algorithm: minmax
102
+ bit: 7.0
103
+ activation:
104
+ dtype: uint8
105
+ scheme: sym
106
+ granularity: per_tensor
107
+ algorithm: kl
108
+ ? !!python/tuple
109
+ - bert.encoder.layer.0.output.quant
110
+ - QuantStub
111
+ : activation:
112
+ dtype: uint8
113
+ scheme: asym
114
+ granularity: per_tensor
115
+ algorithm: minmax
116
+ ? !!python/tuple
117
+ - bert.encoder.layer.0.output.dense
118
+ - Linear
119
+ : weight:
120
+ dtype: int8
121
+ scheme: sym
122
+ granularity: per_channel
123
+ algorithm: minmax
124
+ bit: 7.0
125
+ activation:
126
+ dtype: uint8
127
+ scheme: sym
128
+ granularity: per_tensor
129
+ algorithm: kl
130
+ ? !!python/tuple
131
+ - bert.encoder.layer.1.attention.self.quant
132
+ - QuantStub
133
+ : activation:
134
+ dtype: uint8
135
+ scheme: asym
136
+ granularity: per_tensor
137
+ algorithm: minmax
138
+ ? !!python/tuple
139
+ - bert.encoder.layer.1.attention.self.query
140
+ - Linear
141
+ : weight:
142
+ dtype: int8
143
+ scheme: sym
144
+ granularity: per_channel
145
+ algorithm: minmax
146
+ bit: 7.0
147
+ activation:
148
+ dtype: uint8
149
+ scheme: sym
150
+ granularity: per_tensor
151
+ algorithm: kl
152
+ ? !!python/tuple
153
+ - bert.encoder.layer.1.attention.self.key
154
+ - Linear
155
+ : weight:
156
+ dtype: int8
157
+ scheme: sym
158
+ granularity: per_channel
159
+ algorithm: minmax
160
+ bit: 7.0
161
+ activation:
162
+ dtype: uint8
163
+ scheme: sym
164
+ granularity: per_tensor
165
+ algorithm: kl
166
+ ? !!python/tuple
167
+ - bert.encoder.layer.1.attention.self.value
168
+ - Linear
169
+ : weight:
170
+ dtype: int8
171
+ scheme: sym
172
+ granularity: per_channel
173
+ algorithm: minmax
174
+ bit: 7.0
175
+ activation:
176
+ dtype: uint8
177
+ scheme: sym
178
+ granularity: per_tensor
179
+ algorithm: kl
180
+ ? !!python/tuple
181
+ - bert.encoder.layer.1.attention.output.quant
182
+ - QuantStub
183
+ : activation:
184
+ dtype: uint8
185
+ scheme: asym
186
+ granularity: per_tensor
187
+ algorithm: minmax
188
+ ? !!python/tuple
189
+ - bert.encoder.layer.1.attention.output.dense
190
+ - Linear
191
+ : weight:
192
+ dtype: int8
193
+ scheme: sym
194
+ granularity: per_channel
195
+ algorithm: minmax
196
+ bit: 7.0
197
+ activation:
198
+ dtype: uint8
199
+ scheme: sym
200
+ granularity: per_tensor
201
+ algorithm: kl
202
+ ? !!python/tuple
203
+ - bert.encoder.layer.1.intermediate.quant
204
+ - QuantStub
205
+ : activation:
206
+ dtype: uint8
207
+ scheme: asym
208
+ granularity: per_tensor
209
+ algorithm: minmax
210
+ ? !!python/tuple
211
+ - bert.encoder.layer.1.intermediate.dense
212
+ - Linear
213
+ : weight:
214
+ dtype: int8
215
+ scheme: sym
216
+ granularity: per_channel
217
+ algorithm: minmax
218
+ bit: 7.0
219
+ activation:
220
+ dtype: uint8
221
+ scheme: sym
222
+ granularity: per_tensor
223
+ algorithm: kl
224
+ ? !!python/tuple
225
+ - bert.encoder.layer.1.output.quant
226
+ - QuantStub
227
+ : activation:
228
+ dtype: uint8
229
+ scheme: asym
230
+ granularity: per_tensor
231
+ algorithm: minmax
232
+ ? !!python/tuple
233
+ - bert.encoder.layer.1.output.dense
234
+ - Linear
235
+ : weight:
236
+ dtype: int8
237
+ scheme: sym
238
+ granularity: per_channel
239
+ algorithm: minmax
240
+ bit: 7.0
241
+ activation:
242
+ dtype: uint8
243
+ scheme: sym
244
+ granularity: per_tensor
245
+ algorithm: kl
246
+ ? !!python/tuple
247
+ - bert.encoder.layer.2.attention.self.quant
248
+ - QuantStub
249
+ : activation:
250
+ dtype: uint8
251
+ scheme: asym
252
+ granularity: per_tensor
253
+ algorithm: minmax
254
+ ? !!python/tuple
255
+ - bert.encoder.layer.2.attention.self.query
256
+ - Linear
257
+ : weight:
258
+ dtype: int8
259
+ scheme: sym
260
+ granularity: per_channel
261
+ algorithm: minmax
262
+ bit: 7.0
263
+ activation:
264
+ dtype: uint8
265
+ scheme: sym
266
+ granularity: per_tensor
267
+ algorithm: kl
268
+ ? !!python/tuple
269
+ - bert.encoder.layer.2.attention.self.key
270
+ - Linear
271
+ : weight:
272
+ dtype: int8
273
+ scheme: sym
274
+ granularity: per_channel
275
+ algorithm: minmax
276
+ bit: 7.0
277
+ activation:
278
+ dtype: uint8
279
+ scheme: sym
280
+ granularity: per_tensor
281
+ algorithm: kl
282
+ ? !!python/tuple
283
+ - bert.encoder.layer.2.attention.self.value
284
+ - Linear
285
+ : weight:
286
+ dtype: int8
287
+ scheme: sym
288
+ granularity: per_channel
289
+ algorithm: minmax
290
+ bit: 7.0
291
+ activation:
292
+ dtype: uint8
293
+ scheme: sym
294
+ granularity: per_tensor
295
+ algorithm: kl
296
+ ? !!python/tuple
297
+ - bert.encoder.layer.2.attention.output.quant
298
+ - QuantStub
299
+ : activation:
300
+ dtype: uint8
301
+ scheme: asym
302
+ granularity: per_tensor
303
+ algorithm: minmax
304
+ ? !!python/tuple
305
+ - bert.encoder.layer.2.attention.output.dense
306
+ - Linear
307
+ : weight:
308
+ dtype: int8
309
+ scheme: sym
310
+ granularity: per_channel
311
+ algorithm: minmax
312
+ bit: 7.0
313
+ activation:
314
+ dtype: uint8
315
+ scheme: sym
316
+ granularity: per_tensor
317
+ algorithm: kl
318
+ ? !!python/tuple
319
+ - bert.encoder.layer.2.intermediate.quant
320
+ - QuantStub
321
+ : activation:
322
+ dtype: uint8
323
+ scheme: asym
324
+ granularity: per_tensor
325
+ algorithm: minmax
326
+ ? !!python/tuple
327
+ - bert.encoder.layer.2.intermediate.dense
328
+ - Linear
329
+ : weight:
330
+ dtype: int8
331
+ scheme: sym
332
+ granularity: per_channel
333
+ algorithm: minmax
334
+ bit: 7.0
335
+ activation:
336
+ dtype: uint8
337
+ scheme: sym
338
+ granularity: per_tensor
339
+ algorithm: kl
340
+ ? !!python/tuple
341
+ - bert.encoder.layer.2.output.quant
342
+ - QuantStub
343
+ : activation:
344
+ dtype: uint8
345
+ scheme: asym
346
+ granularity: per_tensor
347
+ algorithm: minmax
348
+ ? !!python/tuple
349
+ - bert.encoder.layer.2.output.dense
350
+ - Linear
351
+ : weight:
352
+ dtype: int8
353
+ scheme: sym
354
+ granularity: per_channel
355
+ algorithm: minmax
356
+ bit: 7.0
357
+ activation:
358
+ dtype: uint8
359
+ scheme: sym
360
+ granularity: per_tensor
361
+ algorithm: kl
362
+ ? !!python/tuple
363
+ - bert.encoder.layer.3.attention.self.quant
364
+ - QuantStub
365
+ : activation:
366
+ dtype: uint8
367
+ scheme: asym
368
+ granularity: per_tensor
369
+ algorithm: minmax
370
+ ? !!python/tuple
371
+ - bert.encoder.layer.3.attention.self.query
372
+ - Linear
373
+ : weight:
374
+ dtype: int8
375
+ scheme: sym
376
+ granularity: per_channel
377
+ algorithm: minmax
378
+ bit: 7.0
379
+ activation:
380
+ dtype: uint8
381
+ scheme: sym
382
+ granularity: per_tensor
383
+ algorithm: kl
384
+ ? !!python/tuple
385
+ - bert.encoder.layer.3.attention.self.key
386
+ - Linear
387
+ : weight:
388
+ dtype: int8
389
+ scheme: sym
390
+ granularity: per_channel
391
+ algorithm: minmax
392
+ bit: 7.0
393
+ activation:
394
+ dtype: uint8
395
+ scheme: sym
396
+ granularity: per_tensor
397
+ algorithm: kl
398
+ ? !!python/tuple
399
+ - bert.encoder.layer.3.attention.self.value
400
+ - Linear
401
+ : weight:
402
+ dtype: int8
403
+ scheme: sym
404
+ granularity: per_channel
405
+ algorithm: minmax
406
+ bit: 7.0
407
+ activation:
408
+ dtype: uint8
409
+ scheme: sym
410
+ granularity: per_tensor
411
+ algorithm: kl
412
+ ? !!python/tuple
413
+ - bert.encoder.layer.3.attention.output.quant
414
+ - QuantStub
415
+ : activation:
416
+ dtype: uint8
417
+ scheme: asym
418
+ granularity: per_tensor
419
+ algorithm: minmax
420
+ ? !!python/tuple
421
+ - bert.encoder.layer.3.attention.output.dense
422
+ - Linear
423
+ : weight:
424
+ dtype: int8
425
+ scheme: sym
426
+ granularity: per_channel
427
+ algorithm: minmax
428
+ bit: 7.0
429
+ activation:
430
+ dtype: uint8
431
+ scheme: sym
432
+ granularity: per_tensor
433
+ algorithm: kl
434
+ ? !!python/tuple
435
+ - bert.encoder.layer.3.intermediate.quant
436
+ - QuantStub
437
+ : activation:
438
+ dtype: uint8
439
+ scheme: asym
440
+ granularity: per_tensor
441
+ algorithm: minmax
442
+ ? !!python/tuple
443
+ - bert.encoder.layer.3.intermediate.dense
444
+ - Linear
445
+ : weight:
446
+ dtype: int8
447
+ scheme: sym
448
+ granularity: per_channel
449
+ algorithm: minmax
450
+ bit: 7.0
451
+ activation:
452
+ dtype: uint8
453
+ scheme: sym
454
+ granularity: per_tensor
455
+ algorithm: kl
456
+ ? !!python/tuple
457
+ - bert.encoder.layer.3.output.quant
458
+ - QuantStub
459
+ : activation:
460
+ dtype: uint8
461
+ scheme: asym
462
+ granularity: per_tensor
463
+ algorithm: minmax
464
+ ? !!python/tuple
465
+ - bert.encoder.layer.3.output.dense
466
+ - Linear
467
+ : weight:
468
+ dtype: int8
469
+ scheme: sym
470
+ granularity: per_channel
471
+ algorithm: minmax
472
+ bit: 7.0
473
+ activation:
474
+ dtype: uint8
475
+ scheme: sym
476
+ granularity: per_tensor
477
+ algorithm: kl
478
+ ? !!python/tuple
479
+ - bert.encoder.layer.4.attention.self.quant
480
+ - QuantStub
481
+ : activation:
482
+ dtype: uint8
483
+ scheme: asym
484
+ granularity: per_tensor
485
+ algorithm: minmax
486
+ ? !!python/tuple
487
+ - bert.encoder.layer.4.attention.self.query
488
+ - Linear
489
+ : weight:
490
+ dtype: int8
491
+ scheme: sym
492
+ granularity: per_channel
493
+ algorithm: minmax
494
+ bit: 7.0
495
+ activation:
496
+ dtype: uint8
497
+ scheme: sym
498
+ granularity: per_tensor
499
+ algorithm: kl
500
+ ? !!python/tuple
501
+ - bert.encoder.layer.4.attention.self.key
502
+ - Linear
503
+ : weight:
504
+ dtype: int8
505
+ scheme: sym
506
+ granularity: per_channel
507
+ algorithm: minmax
508
+ bit: 7.0
509
+ activation:
510
+ dtype: uint8
511
+ scheme: sym
512
+ granularity: per_tensor
513
+ algorithm: kl
514
+ ? !!python/tuple
515
+ - bert.encoder.layer.4.attention.self.value
516
+ - Linear
517
+ : weight:
518
+ dtype: int8
519
+ scheme: sym
520
+ granularity: per_channel
521
+ algorithm: minmax
522
+ bit: 7.0
523
+ activation:
524
+ dtype: uint8
525
+ scheme: sym
526
+ granularity: per_tensor
527
+ algorithm: kl
528
+ ? !!python/tuple
529
+ - bert.encoder.layer.4.attention.output.quant
530
+ - QuantStub
531
+ : activation:
532
+ dtype: uint8
533
+ scheme: asym
534
+ granularity: per_tensor
535
+ algorithm: minmax
536
+ ? !!python/tuple
537
+ - bert.encoder.layer.4.attention.output.dense
538
+ - Linear
539
+ : weight:
540
+ dtype: int8
541
+ scheme: sym
542
+ granularity: per_channel
543
+ algorithm: minmax
544
+ bit: 7.0
545
+ activation:
546
+ dtype: uint8
547
+ scheme: sym
548
+ granularity: per_tensor
549
+ algorithm: kl
550
+ ? !!python/tuple
551
+ - bert.encoder.layer.4.intermediate.quant
552
+ - QuantStub
553
+ : activation:
554
+ dtype: uint8
555
+ scheme: asym
556
+ granularity: per_tensor
557
+ algorithm: minmax
558
+ ? !!python/tuple
559
+ - bert.encoder.layer.4.intermediate.dense
560
+ - Linear
561
+ : weight:
562
+ dtype: int8
563
+ scheme: sym
564
+ granularity: per_channel
565
+ algorithm: minmax
566
+ bit: 7.0
567
+ activation:
568
+ dtype: uint8
569
+ scheme: sym
570
+ granularity: per_tensor
571
+ algorithm: kl
572
+ ? !!python/tuple
573
+ - bert.encoder.layer.4.output.quant
574
+ - QuantStub
575
+ : activation:
576
+ dtype: uint8
577
+ scheme: asym
578
+ granularity: per_tensor
579
+ algorithm: minmax
580
+ ? !!python/tuple
581
+ - bert.encoder.layer.4.output.dense
582
+ - Linear
583
+ : weight:
584
+ dtype: int8
585
+ scheme: sym
586
+ granularity: per_channel
587
+ algorithm: minmax
588
+ bit: 7.0
589
+ activation:
590
+ dtype: uint8
591
+ scheme: sym
592
+ granularity: per_tensor
593
+ algorithm: kl
594
+ ? !!python/tuple
595
+ - bert.encoder.layer.5.attention.self.quant
596
+ - QuantStub
597
+ : activation:
598
+ dtype: uint8
599
+ scheme: asym
600
+ granularity: per_tensor
601
+ algorithm: minmax
602
+ ? !!python/tuple
603
+ - bert.encoder.layer.5.attention.self.query
604
+ - Linear
605
+ : weight:
606
+ dtype: int8
607
+ scheme: sym
608
+ granularity: per_channel
609
+ algorithm: minmax
610
+ bit: 7.0
611
+ activation:
612
+ dtype: uint8
613
+ scheme: sym
614
+ granularity: per_tensor
615
+ algorithm: kl
616
+ ? !!python/tuple
617
+ - bert.encoder.layer.5.attention.self.key
618
+ - Linear
619
+ : weight:
620
+ dtype: int8
621
+ scheme: sym
622
+ granularity: per_channel
623
+ algorithm: minmax
624
+ bit: 7.0
625
+ activation:
626
+ dtype: uint8
627
+ scheme: sym
628
+ granularity: per_tensor
629
+ algorithm: kl
630
+ ? !!python/tuple
631
+ - bert.encoder.layer.5.attention.self.value
632
+ - Linear
633
+ : weight:
634
+ dtype: int8
635
+ scheme: sym
636
+ granularity: per_channel
637
+ algorithm: minmax
638
+ bit: 7.0
639
+ activation:
640
+ dtype: uint8
641
+ scheme: sym
642
+ granularity: per_tensor
643
+ algorithm: kl
644
+ ? !!python/tuple
645
+ - bert.encoder.layer.5.attention.output.quant
646
+ - QuantStub
647
+ : activation:
648
+ dtype: uint8
649
+ scheme: asym
650
+ granularity: per_tensor
651
+ algorithm: minmax
652
+ ? !!python/tuple
653
+ - bert.encoder.layer.5.attention.output.dense
654
+ - Linear
655
+ : weight:
656
+ dtype: int8
657
+ scheme: sym
658
+ granularity: per_channel
659
+ algorithm: minmax
660
+ bit: 7.0
661
+ activation:
662
+ dtype: uint8
663
+ scheme: sym
664
+ granularity: per_tensor
665
+ algorithm: kl
666
+ ? !!python/tuple
667
+ - bert.encoder.layer.5.intermediate.quant
668
+ - QuantStub
669
+ : activation:
670
+ dtype: uint8
671
+ scheme: asym
672
+ granularity: per_tensor
673
+ algorithm: minmax
674
+ ? !!python/tuple
675
+ - bert.encoder.layer.5.intermediate.dense
676
+ - Linear
677
+ : weight:
678
+ dtype: int8
679
+ scheme: sym
680
+ granularity: per_channel
681
+ algorithm: minmax
682
+ bit: 7.0
683
+ activation:
684
+ dtype: uint8
685
+ scheme: sym
686
+ granularity: per_tensor
687
+ algorithm: kl
688
+ ? !!python/tuple
689
+ - bert.encoder.layer.5.output.quant
690
+ - QuantStub
691
+ : activation:
692
+ dtype: uint8
693
+ scheme: asym
694
+ granularity: per_tensor
695
+ algorithm: minmax
696
+ ? !!python/tuple
697
+ - bert.encoder.layer.5.output.dense
698
+ - Linear
699
+ : weight:
700
+ dtype: int8
701
+ scheme: sym
702
+ granularity: per_channel
703
+ algorithm: minmax
704
+ bit: 7.0
705
+ activation:
706
+ dtype: uint8
707
+ scheme: sym
708
+ granularity: per_tensor
709
+ algorithm: kl
710
+ ? !!python/tuple
711
+ - bert.encoder.layer.6.attention.self.quant
712
+ - QuantStub
713
+ : activation:
714
+ dtype: uint8
715
+ scheme: asym
716
+ granularity: per_tensor
717
+ algorithm: minmax
718
+ ? !!python/tuple
719
+ - bert.encoder.layer.6.attention.self.query
720
+ - Linear
721
+ : weight:
722
+ dtype: int8
723
+ scheme: sym
724
+ granularity: per_channel
725
+ algorithm: minmax
726
+ bit: 7.0
727
+ activation:
728
+ dtype: uint8
729
+ scheme: sym
730
+ granularity: per_tensor
731
+ algorithm: kl
732
+ ? !!python/tuple
733
+ - bert.encoder.layer.6.attention.self.key
734
+ - Linear
735
+ : weight:
736
+ dtype: int8
737
+ scheme: sym
738
+ granularity: per_channel
739
+ algorithm: minmax
740
+ bit: 7.0
741
+ activation:
742
+ dtype: uint8
743
+ scheme: sym
744
+ granularity: per_tensor
745
+ algorithm: kl
746
+ ? !!python/tuple
747
+ - bert.encoder.layer.6.attention.self.value
748
+ - Linear
749
+ : weight:
750
+ dtype: int8
751
+ scheme: sym
752
+ granularity: per_channel
753
+ algorithm: minmax
754
+ bit: 7.0
755
+ activation:
756
+ dtype: uint8
757
+ scheme: sym
758
+ granularity: per_tensor
759
+ algorithm: kl
760
+ ? !!python/tuple
761
+ - bert.encoder.layer.6.attention.output.quant
762
+ - QuantStub
763
+ : activation:
764
+ dtype: uint8
765
+ scheme: asym
766
+ granularity: per_tensor
767
+ algorithm: minmax
768
+ ? !!python/tuple
769
+ - bert.encoder.layer.6.attention.output.dense
770
+ - Linear
771
+ : weight:
772
+ dtype: int8
773
+ scheme: sym
774
+ granularity: per_channel
775
+ algorithm: minmax
776
+ bit: 7.0
777
+ activation:
778
+ dtype: uint8
779
+ scheme: sym
780
+ granularity: per_tensor
781
+ algorithm: kl
782
+ ? !!python/tuple
783
+ - bert.encoder.layer.6.intermediate.quant
784
+ - QuantStub
785
+ : activation:
786
+ dtype: uint8
787
+ scheme: asym
788
+ granularity: per_tensor
789
+ algorithm: minmax
790
+ ? !!python/tuple
791
+ - bert.encoder.layer.6.intermediate.dense
792
+ - Linear
793
+ : weight:
794
+ dtype: int8
795
+ scheme: sym
796
+ granularity: per_channel
797
+ algorithm: minmax
798
+ bit: 7.0
799
+ activation:
800
+ dtype: uint8
801
+ scheme: sym
802
+ granularity: per_tensor
803
+ algorithm: kl
804
+ ? !!python/tuple
805
+ - bert.encoder.layer.6.output.quant
806
+ - QuantStub
807
+ : activation:
808
+ dtype: uint8
809
+ scheme: asym
810
+ granularity: per_tensor
811
+ algorithm: minmax
812
+ ? !!python/tuple
813
+ - bert.encoder.layer.6.output.dense
814
+ - Linear
815
+ : weight:
816
+ dtype: int8
817
+ scheme: sym
818
+ granularity: per_channel
819
+ algorithm: minmax
820
+ bit: 7.0
821
+ activation:
822
+ dtype: uint8
823
+ scheme: sym
824
+ granularity: per_tensor
825
+ algorithm: kl
826
+ ? !!python/tuple
827
+ - bert.encoder.layer.7.attention.self.quant
828
+ - QuantStub
829
+ : activation:
830
+ dtype: uint8
831
+ scheme: asym
832
+ granularity: per_tensor
833
+ algorithm: minmax
834
+ ? !!python/tuple
835
+ - bert.encoder.layer.7.attention.self.query
836
+ - Linear
837
+ : weight:
838
+ dtype: int8
839
+ scheme: sym
840
+ granularity: per_channel
841
+ algorithm: minmax
842
+ bit: 7.0
843
+ activation:
844
+ dtype: uint8
845
+ scheme: sym
846
+ granularity: per_tensor
847
+ algorithm: kl
848
+ ? !!python/tuple
849
+ - bert.encoder.layer.7.attention.self.key
850
+ - Linear
851
+ : weight:
852
+ dtype: int8
853
+ scheme: sym
854
+ granularity: per_channel
855
+ algorithm: minmax
856
+ bit: 7.0
857
+ activation:
858
+ dtype: uint8
859
+ scheme: sym
860
+ granularity: per_tensor
861
+ algorithm: kl
862
+ ? !!python/tuple
863
+ - bert.encoder.layer.7.attention.self.value
864
+ - Linear
865
+ : weight:
866
+ dtype: int8
867
+ scheme: sym
868
+ granularity: per_channel
869
+ algorithm: minmax
870
+ bit: 7.0
871
+ activation:
872
+ dtype: uint8
873
+ scheme: sym
874
+ granularity: per_tensor
875
+ algorithm: kl
876
+ ? !!python/tuple
877
+ - bert.encoder.layer.7.attention.output.quant
878
+ - QuantStub
879
+ : activation:
880
+ dtype: uint8
881
+ scheme: asym
882
+ granularity: per_tensor
883
+ algorithm: minmax
884
+ ? !!python/tuple
885
+ - bert.encoder.layer.7.attention.output.dense
886
+ - Linear
887
+ : weight:
888
+ dtype: int8
889
+ scheme: sym
890
+ granularity: per_channel
891
+ algorithm: minmax
892
+ bit: 7.0
893
+ activation:
894
+ dtype: uint8
895
+ scheme: sym
896
+ granularity: per_tensor
897
+ algorithm: kl
898
+ ? !!python/tuple
899
+ - bert.encoder.layer.7.intermediate.quant
900
+ - QuantStub
901
+ : activation:
902
+ dtype: uint8
903
+ scheme: asym
904
+ granularity: per_tensor
905
+ algorithm: minmax
906
+ ? !!python/tuple
907
+ - bert.encoder.layer.7.intermediate.dense
908
+ - Linear
909
+ : weight:
910
+ dtype: int8
911
+ scheme: sym
912
+ granularity: per_channel
913
+ algorithm: minmax
914
+ bit: 7.0
915
+ activation:
916
+ dtype: uint8
917
+ scheme: sym
918
+ granularity: per_tensor
919
+ algorithm: kl
920
+ ? !!python/tuple
921
+ - bert.encoder.layer.7.output.quant
922
+ - QuantStub
923
+ : activation:
924
+ dtype: uint8
925
+ scheme: asym
926
+ granularity: per_tensor
927
+ algorithm: minmax
928
+ ? !!python/tuple
929
+ - bert.encoder.layer.7.output.dense
930
+ - Linear
931
+ : weight:
932
+ dtype: int8
933
+ scheme: sym
934
+ granularity: per_channel
935
+ algorithm: minmax
936
+ bit: 7.0
937
+ activation:
938
+ dtype: uint8
939
+ scheme: sym
940
+ granularity: per_tensor
941
+ algorithm: kl
942
+ ? !!python/tuple
943
+ - bert.encoder.layer.8.attention.self.quant
944
+ - QuantStub
945
+ : activation:
946
+ dtype: uint8
947
+ scheme: asym
948
+ granularity: per_tensor
949
+ algorithm: minmax
950
+ ? !!python/tuple
951
+ - bert.encoder.layer.8.attention.self.query
952
+ - Linear
953
+ : weight:
954
+ dtype: int8
955
+ scheme: sym
956
+ granularity: per_channel
957
+ algorithm: minmax
958
+ bit: 7.0
959
+ activation:
960
+ dtype: uint8
961
+ scheme: sym
962
+ granularity: per_tensor
963
+ algorithm: kl
964
+ ? !!python/tuple
965
+ - bert.encoder.layer.8.attention.self.key
966
+ - Linear
967
+ : weight:
968
+ dtype: int8
969
+ scheme: sym
970
+ granularity: per_channel
971
+ algorithm: minmax
972
+ bit: 7.0
973
+ activation:
974
+ dtype: uint8
975
+ scheme: sym
976
+ granularity: per_tensor
977
+ algorithm: kl
978
+ ? !!python/tuple
979
+ - bert.encoder.layer.8.attention.self.value
980
+ - Linear
981
+ : weight:
982
+ dtype: int8
983
+ scheme: sym
984
+ granularity: per_channel
985
+ algorithm: minmax
986
+ bit: 7.0
987
+ activation:
988
+ dtype: uint8
989
+ scheme: sym
990
+ granularity: per_tensor
991
+ algorithm: kl
992
+ ? !!python/tuple
993
+ - bert.encoder.layer.8.attention.output.quant
994
+ - QuantStub
995
+ : activation:
996
+ dtype: uint8
997
+ scheme: asym
998
+ granularity: per_tensor
999
+ algorithm: minmax
1000
+ ? !!python/tuple
1001
+ - bert.encoder.layer.8.attention.output.dense
1002
+ - Linear
1003
+ : weight:
1004
+ dtype: int8
1005
+ scheme: sym
1006
+ granularity: per_channel
1007
+ algorithm: minmax
1008
+ bit: 7.0
1009
+ activation:
1010
+ dtype: uint8
1011
+ scheme: sym
1012
+ granularity: per_tensor
1013
+ algorithm: kl
1014
+ ? !!python/tuple
1015
+ - bert.encoder.layer.8.intermediate.quant
1016
+ - QuantStub
1017
+ : activation:
1018
+ dtype: uint8
1019
+ scheme: asym
1020
+ granularity: per_tensor
1021
+ algorithm: minmax
1022
+ ? !!python/tuple
1023
+ - bert.encoder.layer.8.intermediate.dense
1024
+ - Linear
1025
+ : weight:
1026
+ dtype: int8
1027
+ scheme: sym
1028
+ granularity: per_channel
1029
+ algorithm: minmax
1030
+ bit: 7.0
1031
+ activation:
1032
+ dtype: uint8
1033
+ scheme: sym
1034
+ granularity: per_tensor
1035
+ algorithm: kl
1036
+ ? !!python/tuple
1037
+ - bert.encoder.layer.8.output.quant
1038
+ - QuantStub
1039
+ : activation:
1040
+ dtype: uint8
1041
+ scheme: asym
1042
+ granularity: per_tensor
1043
+ algorithm: minmax
1044
+ ? !!python/tuple
1045
+ - bert.encoder.layer.8.output.dense
1046
+ - Linear
1047
+ : weight:
1048
+ dtype: int8
1049
+ scheme: sym
1050
+ granularity: per_channel
1051
+ algorithm: minmax
1052
+ bit: 7.0
1053
+ activation:
1054
+ dtype: uint8
1055
+ scheme: sym
1056
+ granularity: per_tensor
1057
+ algorithm: kl
1058
+ ? !!python/tuple
1059
+ - bert.encoder.layer.9.attention.self.quant
1060
+ - QuantStub
1061
+ : activation:
1062
+ dtype: uint8
1063
+ scheme: asym
1064
+ granularity: per_tensor
1065
+ algorithm: minmax
1066
+ ? !!python/tuple
1067
+ - bert.encoder.layer.9.attention.self.query
1068
+ - Linear
1069
+ : weight:
1070
+ dtype: int8
1071
+ scheme: sym
1072
+ granularity: per_channel
1073
+ algorithm: minmax
1074
+ bit: 7.0
1075
+ activation:
1076
+ dtype: uint8
1077
+ scheme: sym
1078
+ granularity: per_tensor
1079
+ algorithm: kl
1080
+ ? !!python/tuple
1081
+ - bert.encoder.layer.9.attention.self.key
1082
+ - Linear
1083
+ : weight:
1084
+ dtype: int8
1085
+ scheme: sym
1086
+ granularity: per_channel
1087
+ algorithm: minmax
1088
+ bit: 7.0
1089
+ activation:
1090
+ dtype: uint8
1091
+ scheme: sym
1092
+ granularity: per_tensor
1093
+ algorithm: kl
1094
+ ? !!python/tuple
1095
+ - bert.encoder.layer.9.attention.self.value
1096
+ - Linear
1097
+ : weight:
1098
+ dtype: int8
1099
+ scheme: sym
1100
+ granularity: per_channel
1101
+ algorithm: minmax
1102
+ bit: 7.0
1103
+ activation:
1104
+ dtype: uint8
1105
+ scheme: sym
1106
+ granularity: per_tensor
1107
+ algorithm: kl
1108
+ ? !!python/tuple
1109
+ - bert.encoder.layer.9.attention.output.quant
1110
+ - QuantStub
1111
+ : activation:
1112
+ dtype: uint8
1113
+ scheme: asym
1114
+ granularity: per_tensor
1115
+ algorithm: minmax
1116
+ ? !!python/tuple
1117
+ - bert.encoder.layer.9.attention.output.dense
1118
+ - Linear
1119
+ : weight:
1120
+ dtype: int8
1121
+ scheme: sym
1122
+ granularity: per_channel
1123
+ algorithm: minmax
1124
+ bit: 7.0
1125
+ activation:
1126
+ dtype: uint8
1127
+ scheme: sym
1128
+ granularity: per_tensor
1129
+ algorithm: kl
1130
+ ? !!python/tuple
1131
+ - bert.encoder.layer.9.intermediate.quant
1132
+ - QuantStub
1133
+ : activation:
1134
+ dtype: uint8
1135
+ scheme: asym
1136
+ granularity: per_tensor
1137
+ algorithm: minmax
1138
+ ? !!python/tuple
1139
+ - bert.encoder.layer.9.intermediate.dense
1140
+ - Linear
1141
+ : weight:
1142
+ dtype: int8
1143
+ scheme: sym
1144
+ granularity: per_channel
1145
+ algorithm: minmax
1146
+ bit: 7.0
1147
+ activation:
1148
+ dtype: uint8
1149
+ scheme: sym
1150
+ granularity: per_tensor
1151
+ algorithm: kl
1152
+ ? !!python/tuple
1153
+ - bert.encoder.layer.9.output.quant
1154
+ - QuantStub
1155
+ : activation:
1156
+ dtype: uint8
1157
+ scheme: asym
1158
+ granularity: per_tensor
1159
+ algorithm: minmax
1160
+ ? !!python/tuple
1161
+ - bert.encoder.layer.9.output.dense
1162
+ - Linear
1163
+ : weight:
1164
+ dtype: int8
1165
+ scheme: sym
1166
+ granularity: per_channel
1167
+ algorithm: minmax
1168
+ bit: 7.0
1169
+ activation:
1170
+ dtype: uint8
1171
+ scheme: sym
1172
+ granularity: per_tensor
1173
+ algorithm: kl
1174
+ ? !!python/tuple
1175
+ - bert.encoder.layer.10.attention.self.quant
1176
+ - QuantStub
1177
+ : activation:
1178
+ dtype: uint8
1179
+ scheme: asym
1180
+ granularity: per_tensor
1181
+ algorithm: minmax
1182
+ ? !!python/tuple
1183
+ - bert.encoder.layer.10.attention.self.query
1184
+ - Linear
1185
+ : weight:
1186
+ dtype: int8
1187
+ scheme: sym
1188
+ granularity: per_channel
1189
+ algorithm: minmax
1190
+ bit: 7.0
1191
+ activation:
1192
+ dtype: uint8
1193
+ scheme: sym
1194
+ granularity: per_tensor
1195
+ algorithm: kl
1196
+ ? !!python/tuple
1197
+ - bert.encoder.layer.10.attention.self.key
1198
+ - Linear
1199
+ : weight:
1200
+ dtype: int8
1201
+ scheme: sym
1202
+ granularity: per_channel
1203
+ algorithm: minmax
1204
+ bit: 7.0
1205
+ activation:
1206
+ dtype: uint8
1207
+ scheme: sym
1208
+ granularity: per_tensor
1209
+ algorithm: kl
1210
+ ? !!python/tuple
1211
+ - bert.encoder.layer.10.attention.self.value
1212
+ - Linear
1213
+ : weight:
1214
+ dtype: int8
1215
+ scheme: sym
1216
+ granularity: per_channel
1217
+ algorithm: minmax
1218
+ bit: 7.0
1219
+ activation:
1220
+ dtype: uint8
1221
+ scheme: sym
1222
+ granularity: per_tensor
1223
+ algorithm: kl
1224
+ ? !!python/tuple
1225
+ - bert.encoder.layer.10.attention.output.quant
1226
+ - QuantStub
1227
+ : activation:
1228
+ dtype: uint8
1229
+ scheme: asym
1230
+ granularity: per_tensor
1231
+ algorithm: minmax
1232
+ ? !!python/tuple
1233
+ - bert.encoder.layer.10.attention.output.dense
1234
+ - Linear
1235
+ : weight:
1236
+ dtype: int8
1237
+ scheme: sym
1238
+ granularity: per_channel
1239
+ algorithm: minmax
1240
+ bit: 7.0
1241
+ activation:
1242
+ dtype: uint8
1243
+ scheme: sym
1244
+ granularity: per_tensor
1245
+ algorithm: kl
1246
+ ? !!python/tuple
1247
+ - bert.encoder.layer.10.intermediate.quant
1248
+ - QuantStub
1249
+ : activation:
1250
+ dtype: uint8
1251
+ scheme: asym
1252
+ granularity: per_tensor
1253
+ algorithm: minmax
1254
+ ? !!python/tuple
1255
+ - bert.encoder.layer.10.intermediate.dense
1256
+ - Linear
1257
+ : weight:
1258
+ dtype: int8
1259
+ scheme: sym
1260
+ granularity: per_channel
1261
+ algorithm: minmax
1262
+ bit: 7.0
1263
+ activation:
1264
+ dtype: uint8
1265
+ scheme: sym
1266
+ granularity: per_tensor
1267
+ algorithm: kl
1268
+ ? !!python/tuple
1269
+ - bert.encoder.layer.10.output.quant
1270
+ - QuantStub
1271
+ : activation:
1272
+ dtype: uint8
1273
+ scheme: asym
1274
+ granularity: per_tensor
1275
+ algorithm: minmax
1276
+ ? !!python/tuple
1277
+ - bert.encoder.layer.10.output.dense
1278
+ - Linear
1279
+ : weight:
1280
+ dtype: int8
1281
+ scheme: sym
1282
+ granularity: per_channel
1283
+ algorithm: minmax
1284
+ bit: 7.0
1285
+ activation:
1286
+ dtype: uint8
1287
+ scheme: sym
1288
+ granularity: per_tensor
1289
+ algorithm: kl
1290
+ ? !!python/tuple
1291
+ - bert.encoder.layer.11.attention.self.quant
1292
+ - QuantStub
1293
+ : activation:
1294
+ dtype: uint8
1295
+ scheme: asym
1296
+ granularity: per_tensor
1297
+ algorithm: minmax
1298
+ ? !!python/tuple
1299
+ - bert.encoder.layer.11.attention.self.query
1300
+ - Linear
1301
+ : weight:
1302
+ dtype: int8
1303
+ scheme: sym
1304
+ granularity: per_channel
1305
+ algorithm: minmax
1306
+ bit: 7.0
1307
+ activation:
1308
+ dtype: uint8
1309
+ scheme: sym
1310
+ granularity: per_tensor
1311
+ algorithm: kl
1312
+ ? !!python/tuple
1313
+ - bert.encoder.layer.11.attention.self.key
1314
+ - Linear
1315
+ : weight:
1316
+ dtype: int8
1317
+ scheme: sym
1318
+ granularity: per_channel
1319
+ algorithm: minmax
1320
+ bit: 7.0
1321
+ activation:
1322
+ dtype: uint8
1323
+ scheme: sym
1324
+ granularity: per_tensor
1325
+ algorithm: kl
1326
+ ? !!python/tuple
1327
+ - bert.encoder.layer.11.attention.self.value
1328
+ - Linear
1329
+ : weight:
1330
+ dtype: int8
1331
+ scheme: sym
1332
+ granularity: per_channel
1333
+ algorithm: minmax
1334
+ bit: 7.0
1335
+ activation:
1336
+ dtype: uint8
1337
+ scheme: sym
1338
+ granularity: per_tensor
1339
+ algorithm: kl
1340
+ ? !!python/tuple
1341
+ - bert.encoder.layer.11.attention.output.quant
1342
+ - QuantStub
1343
+ : activation:
1344
+ dtype: uint8
1345
+ scheme: asym
1346
+ granularity: per_tensor
1347
+ algorithm: minmax
1348
+ ? !!python/tuple
1349
+ - bert.encoder.layer.11.attention.output.dense
1350
+ - Linear
1351
+ : weight:
1352
+ dtype: int8
1353
+ scheme: sym
1354
+ granularity: per_channel
1355
+ algorithm: minmax
1356
+ bit: 7.0
1357
+ activation:
1358
+ dtype: uint8
1359
+ scheme: sym
1360
+ granularity: per_tensor
1361
+ algorithm: kl
1362
+ ? !!python/tuple
1363
+ - bert.encoder.layer.11.intermediate.quant
1364
+ - QuantStub
1365
+ : activation:
1366
+ dtype: uint8
1367
+ scheme: asym
1368
+ granularity: per_tensor
1369
+ algorithm: minmax
1370
+ ? !!python/tuple
1371
+ - bert.encoder.layer.11.intermediate.dense
1372
+ - Linear
1373
+ : weight:
1374
+ dtype: int8
1375
+ scheme: sym
1376
+ granularity: per_channel
1377
+ algorithm: minmax
1378
+ bit: 7.0
1379
+ activation:
1380
+ dtype: uint8
1381
+ scheme: sym
1382
+ granularity: per_tensor
1383
+ algorithm: kl
1384
+ ? !!python/tuple
1385
+ - bert.encoder.layer.11.output.quant
1386
+ - QuantStub
1387
+ : activation:
1388
+ dtype: uint8
1389
+ scheme: asym
1390
+ granularity: per_tensor
1391
+ algorithm: minmax
1392
+ ? !!python/tuple
1393
+ - bert.encoder.layer.11.output.dense
1394
+ - Linear
1395
+ : weight:
1396
+ dtype: int8
1397
+ scheme: sym
1398
+ granularity: per_channel
1399
+ algorithm: minmax
1400
+ bit: 7.0
1401
+ activation:
1402
+ dtype: uint8
1403
+ scheme: sym
1404
+ granularity: per_tensor
1405
+ algorithm: kl
1406
+ ? !!python/tuple
1407
+ - bert.pooler.quant
1408
+ - QuantStub
1409
+ : activation:
1410
+ dtype: uint8
1411
+ scheme: asym
1412
+ granularity: per_tensor
1413
+ algorithm: minmax
1414
+ ? !!python/tuple
1415
+ - bert.pooler.dense
1416
+ - Linear
1417
+ : weight:
1418
+ dtype: int8
1419
+ scheme: sym
1420
+ granularity: per_channel
1421
+ algorithm: minmax
1422
+ bit: 7.0
1423
+ activation:
1424
+ dtype: uint8
1425
+ scheme: sym
1426
+ granularity: per_tensor
1427
+ algorithm: kl
1428
+ ? !!python/tuple
1429
+ - classifier
1430
+ - Linear
1431
+ : weight:
1432
+ dtype: int8
1433
+ scheme: sym
1434
+ granularity: per_channel
1435
+ algorithm: minmax
1436
+ bit: 7.0
1437
+ activation:
1438
+ dtype: uint8
1439
+ scheme: sym
1440
+ granularity: per_tensor
1441
+ algorithm: kl
pytorch_model.bin ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:179044d0850f8afbccb6984920932163008d58888bad9c938d7d26ea548f936b
3
+ size 182910677
quantization.yml ADDED
@@ -0,0 +1,14 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ device: cpu
2
+ model:
3
+ framework: pytorch
4
+ name: bert
5
+ quantization:
6
+ approach: post_training_static_quant
7
+ tuning:
8
+ accuracy_criterion:
9
+ relative: 0.01
10
+ exit_policy:
11
+ max_trials: 1200
12
+ timeout: 0
13
+ random_seed: 9527
14
+ version: 1.0
special_tokens_map.json ADDED
@@ -0,0 +1 @@
 
 
1
+ {"unk_token": "[UNK]", "sep_token": "[SEP]", "pad_token": "[PAD]", "cls_token": "[CLS]", "mask_token": "[MASK]"}
tokenizer_config.json ADDED
@@ -0,0 +1 @@
 
 
1
+ {"do_lower_case": true, "unk_token": "[UNK]", "sep_token": "[SEP]", "pad_token": "[PAD]", "cls_token": "[CLS]", "mask_token": "[MASK]", "tokenize_chinese_chars": true, "strip_accents": null, "model_max_length": 512, "special_tokens_map_file": "/home/ella/.cache/huggingface/transformers/c7c9b9c5d8bab3ba2ddaa08b138aa385f9790f30e8dce3bfe47e3f10bd97f4ad.dd8bd9bfd3664b530ea4e645105f557769387b3da9f79bdb55ed556bdd80611d", "name_or_path": "textattack/bert-base-uncased-SST-2", "do_basic_tokenize": true, "never_split": null, "tokenizer_class": "BertTokenizer"}
training_args.bin ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:c152f8d6703bcfb25907ed7f88687985141b19e631a632e3a8923f6e07defe49
3
+ size 2671
vocab.txt ADDED
The diff for this file is too large to render. See raw diff