标签: quantization

有一个非线性动态系统,x_n = f(x_n,eta)其功能形式是x[n+1] = 2*x[n] mod 1.这是一个混乱的动力系统,称为锯齿图或伯努利图.我在实现Eq(4)和Eq(5)给出的逆映射的两个表示时面临困难.以下是该问题的简要说明.

其中序列(s[n+k])_k=1 to N-1是状态的符号描述x[n].该描述源于下面描述的单位间隔的划分.

设分区数M = 2,符号空间= {0,1},分配符号的规则是

 s[n+1] = 1 if x[n] >= 0.5, otherwise s[n+1] = 0

本文作者:

Linear, Random Representations of Chaos

对于方程(5),我在反向之后没有获得相同的时间序列,在进行二进制到实数转换之后几个值不同.有人可以让我正确的程序吗？

我试图为Eqs(4)和(5)实现Bijective图,但它不起作用.

公式(5)的代码 - 我将二进制二进制化.x包含实数; s是每个真实的0/1二进制等价物; y是转换s成真实后的答案.s1是x的+ 1/-1二进制等价物; b是转换为真实后的答案.在+ 1/-1的情况下,当我从符号表示转换为实数时,我将-1切换为0然后在公式(5)中应用公式.从答案,但可以看出,y和b不一样的x做转换后.当原始的实数都是无符号的理性时,我也得到了负的实数!我怎样才能正确实施以使它们相同？

N  =10;
x(1) = 0.1;
for i =1 : N
       x(i+1) = mod(x(i)*2, 1);
end
    y = x;
 s …

读者注意事项:这是一个很长的问题,但它需要一个背景来理解问题.

该颜色量化技术通常用于获取主色的图像.其中一个着名的色彩量化库是Leptonica通过修改的中值切割量化(MMCQ)和八叉树量化(OQ) Github的Color-thief by @lokesh是一个非常简单的MMCQ算法JavaScript实现:

var colorThief = new ColorThief();
colorThief.getColor(sourceImage);

从技术上讲,<img/>HTML元素上的图像支持在一个<canvas/>元素上:

var CanvasImage = function (image) {
    this.canvas  = document.createElement('canvas');
    this.context = this.canvas.getContext('2d');

    document.body.appendChild(this.canvas);

    this.width  = this.canvas.width  = image.width;
    this.height = this.canvas.height = image.height;

    this.context.drawImage(image, 0, 0, this.width, this.height);
};

TVML正如我们稍后将看到的那样,这就是问题所在.

我最近发现的另一个实现与本文相关联使用imagemagick,awk和kmeans来查找链接到使用python生成令人敬畏的linux桌面主题的图像中的主色.作者发表了一篇关于使用python和k-means来查找在那里使用的图像中的主色的文章(抱歉所有这些链接,但我正在追溯我的历史......).

作者非常高效,并添加了一个我在这里发布的JavaScript版本:使用JavaScript和k-means来查找图像中的主色

在这种情况下,我们正在生成图像的主色,而不是使用MMCQ(或OQ)算法,而是使用K-Means.问题是图像必须是一个:

<canvas id="canvas" style="display: none;" width="200" height="200"></canvas>

然后

function …

我想做的事

我正在尝试创建facenet中使用的Inception-ResNet-v1模型的量化版本- 根据Tensorflow的graph_transform指南,不仅有量化权重,还有量化节点.

我试过了什么

使用在CASIA网络数据集上预训练的模型,我尝试通过添加以下行来假设量化节点微调模型

tf.contrib.quantize.create_training_graph(quant_delay=0)

在计算总损失(第178行)之后,在facenet训练脚本train_softmax.py中,以及在保存检查点之前的下一行(第462行):

tf.contrib.quantize.create_eval_graph()

然后,我使用学习率0.0005对预训练模型进行了1000次迭代的微调:

python3 src/train_softmax.py \
--logs_base_dir ~/logs/facenet/ \
--models_base_dir ${model_path} \
--data_dir ${casia_path} \
--image_size 160 \
--model_def models.inception_resnet_v1 \
--lfw_dir ${lfw_path} \
--optimizer ADAM \
--learning_rate -1 \
--max_nrof_epochs 150 \
--keep_probability 0.8 \
--random_crop \
--random_flip \
--use_fixed_image_standardization \
--learning_rate_schedule_file data/learning_rate_schedule_classifier_casia.txt \
--weight_decay 5e-4 \
--embedding_size 128 \
--lfw_distance_metric 1 \
--lfw_use_flipped_images \
--lfw_subtract_mean \
--validation_set_split_ratio 0.05 \ …

编辑：附加一些代码以帮助生成类似的结果（附加在末尾）

我有一个非常小的模型，其架构[2, 3, 6]中的隐藏层使用 ReLU，它是用于多类分类的 softmax 激活。离线训练并静态量化到 qint8。我现在想做的是提取权重，以便我可以通过矩阵乘法/加法在其他硬件上使用它们。我遇到的问题是它似乎没有按预期运行。以 state_dict() 的 GraphModule 输出为例：

OrderedDict([('input_layer_input_scale_0', tensor(0.0039)),
             ('input_layer_input_zero_point_0', tensor(0)),
             ('input_layer.scale', tensor(0.0297)),
             ('input_layer.zero_point', tensor(0)),
             ('input_layer._packed_params.dtype', torch.qint8),
             ('input_layer._packed_params._packed_params',
              (tensor([[-0.1180,  0.1180],
                       [-0.2949, -0.5308],
                       [-3.3029, -7.5496]], size=(3, 2), dtype=torch.qint8,
                      quantization_scheme=torch.per_tensor_affine, scale=0.05898105353116989,
                      zero_point=0),
               Parameter containing:
               tensor([-0.4747, -0.3563,  7.7603], requires_grad=True))),
             ('out.scale', tensor(1.5963)),
             ('out.zero_point', tensor(243)),
             ('out._packed_params.dtype', torch.qint8),
             ('out._packed_params._packed_params',
              (tensor([[  0.4365,   0.4365, -55.4356],
                       [  0.4365,   0.0000,   1.3095],
                       [  0.4365,   0.0000, -13.9680],
                       [  0.4365,  -0.4365,   4.3650],
                       [  0.4365,   0.4365,  -3.0555],
                       [  0.4365,   0.0000,  -1.3095],
                       [  0.4365,   0.0000,   3.0555]], size=(7, 3), …

这是我的"周末"爱好问题.

我从经典合成器的ROM中得到了一些广受欢迎的单周期波形.

这些是8位样本(256个可能的值).

因为它们只有8位,所以本底噪声非常高.这是由于量化误差造成的.量化误差非常奇怪.它稍微扰乱了所有频率.

我想采取这些循环并制作"干净"的16位版本.(是的,我知道人们喜欢脏版本,所以我会让用户在脏和干净之间插入他们喜欢的程度.)

这听起来不可能,因为我永远失去了低8位,对吧？但这已经在我的脑海中停留了一段时间,我很确定我能做到.

请记住,这些是单周期波形,只是反复重复播放,所以这是一个特例.(当然,合成器会做各种事情来使声音变得有趣,包括信封,调制,滤波器交叉渐变等)

对于每个单独的字节样本,我真正知道的是它是16位版本中的256个值之一.(想象一下反向过程,其中16位值被截断或舍入为8位.)

我的评估功能是试图获得最低噪声基底.我应该能够用一个或多个FFT来判断.

彻底的测试可能需要永远,所以我可以采取较低分辨率的第一次通过.或者我只是随机推送随机选择的值(在保持相同8位版本的已知值内)并进行评估并保持更清洁的版本？还是我能做得更快？当搜索空间中的其他地方可能有更好的最小值时,我是否有陷入局部最小值的危险？我已经在其他类似的情况下发生了这种情况.

我可以做出任何初步的猜测,也许是通过查看邻近值？

编辑:有几个人指出,如果我删除新波形将采样到原始波形的要求,问题会更容易.确实如此.事实上,如果我只是寻找更清晰的声音,解决方案是微不足道的.

我最近阅读了一篇非常有趣的论文（http://arxiv.org/pdf/1602.02830v3.pdf），提出了一种训练 CNN 的方法，其权重和激活约束为 [-1,1]。从功率/速度的角度来看，这是非常有益的。

Torch 和 Theano 中该方法的实现在 github 中公开可用： https://github.com/MatthieuCourbariaux/BinaryNet (Theano) https://github.com/itayhubara/BinaryNet (Torch)

我想知道上面的方法是否可以在 TensorFlow 中实现？有没有人试过实现这个？

我想训练量化网络,即在前向传递期间使用量化权重来计算损耗,然后在后向传递期间更新基础全精度浮点权重.

这个问题已经在这里提出但没有回答.

请注意,在我的情况下,"假量化"就足够了.这意味着权重仍然可以存储为32位浮点值,只要它们代表低位宽量化值即可.

在Pete Warden的博客文章中,他指出:

"[...]我们确实支持"虚假量化"运算符.如果你在图表中包含预期量化的点(例如在卷积之后),那么在正向传递中浮点值将是舍入到指定的级别数(通常为256)以模拟量化效果."

提到的运算符可以在TensorFlow API中找到.

谁能指出我如何使用这些功能？如果我在模型定义中的例如转换层之后调用它们,为什么要量化层中的权重而不是该层的输出(激活)？

这是我在MNIST数据集上测量量化的例子.我正在使用以下代码测试我的模型:

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
from tensorflow.python.framework import graph_util
from tensorflow.core.framework import graph_pb2
import numpy as np 


def test_model(model_file,x_in):
    with tf.Session() as sess:
        with open(model_file, "rb") as f:
            output_graph_def = graph_pb2.GraphDef()
            output_graph_def.ParseFromString(f.read())
            _ = tf.import_graph_def(output_graph_def, name="")
        x = sess.graph.get_tensor_by_name('Placeholder_1:0')
        y = sess.graph.get_tensor_by_name('softmax_cross_entropy_with_logits:0')
        new_scores = sess.run(y, feed_dict={x:x_in.test.images})
        print((orig_scores - new_scores) < 1e-6)
        find_top_pred(orig_scores)
        find_top_pred(new_scores)

#print(epoch_x.shape)
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True)
test_model('mnist_cnn1.pb',mnist)

我没有得到我提供错误值的地方.在这里,我添加了错误代码的完整跟踪.以下是错误:

Extracting /tmp/data/train-images-idx3-ubyte.gz
Extracting /tmp/data/train-labels-idx1-ubyte.gz
Extracting /tmp/data/t10k-images-idx3-ubyte.gz
Extracting /tmp/data/t10k-labels-idx1-ubyte.gz
Traceback (most recent call last):
  File …

我是张量量化的新手，并尝试做一些简单的事情

import torch
x = torch.rand(10, 3)
y = torch.rand(10, 3)

x@y.T

使用在 CPU 上运行的PyTorch量化张量。我因此尝试

scale, zero_point = 1e-4, 2
dtype = torch.qint32
qx = torch.quantize_per_tensor(x, scale, zero_point, dtype)
qy = torch.quantize_per_tensor(y, scale, zero_point, dtype)

qx@qy.T # I tried...

..并得到了错误

运行时错误：无法使用来自“QuantizedCPUTensorId”后端的参数运行“aten::mm”。'aten::mm' 仅适用于这些后端：[CUDATensorId、SparseCPUTensorId、VariableTensorId、CPUTensorId、SparseCUDATensorId]。

是不支持矩阵乘法，还是我做错了什么？

论文“使用小型前馈网络进行自然语言处理” https://arxiv.org/pdf/1708.00214.pdf指出：

我已经按照 python 中的上述方程实现了量化：

b = 128

embedding_matrix = [[20000,3000,1000],[1999999,20000,1999999], [20000,3000,1000]]

scaled = [ abs(round( (1 / (b - 1) * max(e)) , 3)) for e in embedding_matrix]

print(scaled)

i = 0

quantized = []
for e in embedding_matrix :
    for v in e : 
        quantized.append((v , math.floor(.5 + ( (v / scaled[i]) + b) )))
    i = i + 1
    
quantized

运行此代码quantized设置为：

[(20000, 255),
 (3000, 147),
 (1000, 134),
 (1999999, 255),
 (20000, 129),
 (1999999, 255),
 (20000, …