小编che*_*chi的帖子

我是一个深度学习和Tensorflow初学者,我正在尝试使用Tensorflow 在本文中实现该算法.本文使用Matconvnet + Matlab来实现它,我很好奇Tensorflow是否具有实现相同功能的等效功能.该报说:

使用Xavier方法[14]初始化网络参数.我们使用了在l2惩罚下的四个小波子带的回归损失,并且使用随机梯度下降(SGD)训练所提出的网络.正则化参数(λ)为0.0001,动量为0.9.学习率设定为10-1至10-4,在每个时期以对数标度减少.

本文使用小波变换(WT)和残差学习方法(其中残差图像= WT(HR)-WT(HR'),并且HR'用于训练).Xavier方法建议用变量初始化变量正态分布

stddev=sqrt(2/(filter_size*filter_size*num_filters)

Q1.我该如何初始化变量？以下代码是否正确？

weights = tf.Variable(tf.random_normal[img_size, img_size, 1, num_filters], stddev=stddev)

本文没有详细说明如何构造损失函数.我无法找到等效的Tensorflow功能来设置日志范围内的学习率(仅限exponential_decay).我理解MomentumOptimizer相当于具有动量的随机梯度下降.

Q2:是否可以设置对数刻度的学习率？

Q3:如何创建上述损失函数？

我按照这个网站编写了下面的代码.假设model()函数返回本文中提到的网络并且lamda = 0.0001,

inputs = tf.placeholder(tf.float32, shape=[None, patch_size, patch_size, num_channels])
labels = tf.placeholder(tf.float32, [None, patch_size, patch_size, num_channels])

# get the model output and weights for each conv
pred, weights = model()

# define loss function
loss = tf.nn.softmax_cross_entropy_with_logits_v2(labels=labels, logits=pred)

for weight in weights:
    regularizers += tf.nn.l2_loss(weight)

loss = tf.reduce_mean(loss + 0.0001 * regularizers) …

我试图使用不同的方法检测灰度图像中的白色矩形:轮廓检测和霍夫变换.不幸的是,我正在处理的图像有一些限制,即

1. 图像中有许多功能,矩形不是唯一的功能
2. 矩形可以合并到其他要素(例如,其中一个矩形边可以与长直线重叠)
3. 矩形可以包含一些其他功能(例如,矩形内的字母,数字或一些徽标)
4. 有些功能看起来像矩形(例如,字符"D"看起来像一个矩形,右上角和右下角有一个小弧形;另一个例子是梯形而不是平行四边形)
5. 矩形可以顺时针和逆时针旋转0到15度
6. 线条可能在不同的光照条件下被分成几条线(例如1个像素间隙),因此过滤线条的最小线条长度必须很小(例如在Hough变换中)
7. 当最小线长度设置为较小值时,更常见的是在不同方向上看到同一条线的重复线(即需要组合多条线)

对于contonours方法,一些图像的轮廓被打破.此外,图像可能包含矩形等特征(例如字符"D").我不确定这是不是一个好方法.

我看过许多文章/论坛建议使用Hough变换检测矩形,如下面的帖子.不幸的是,我必须设置最小行长度的小值,并看到重复的行.我不知道如何处理上面提到的几点(例如,组合所有重复的行并为每个边选择一行,如何区分大多数部分的特征是线但是像'D'那样的小弧,以及如何隔离正方形,其中一条边与一条长直线合并,等等.

用透视投影进行矩形识别的Hough变换与Contour检测

欢迎任何建议!

编辑:添加一些图片

角色D.

带徽标的矩形和边缘与长直线合并

梯形(顶部有阴影,底部形成梯形)

在Tensorflow中,我正在尝试构建一个模型来执行图像超分辨率(即回归任务)并使用TensorBoard分析结果.在训练期间,我发现均方误差(MSE)在大多数时间(甚至从头开始)在100到200之间反弹,并且从未收敛过.我希望将以下变量添加到tf.summary并分析导致此问题的原因.

graph_loss = get_graph_mean_square_error()
tf.summary.scalar('graph_loss', graph_loss)

regularization_loss = tf.add_n([tf.nn.l2_loss(weight) for weight in weights]) * regularization_param
tf.summary.scalar('reg_loss', regularization_loss)

tf.summary.scalar('overall_loss', regularization_loss + graph_loss)

for index in range(len(weights)):
    tf.summary.histogram("weight[%02d]" % index, weights[index])

optimizer = tf.train.AdamOptimizer()
capped_grad_and_vars = [(tf.clip_by_value(grad, -clip_value, clip_value), var) for grad, var in grad_and_vars if grad is not None]
train_optimizer = optimizer.apply_gradients(capped_grad_and_vars, global_step)

for grad, var in grad_and_vars:
    tf.summary.histogram(var.name + '/gradient', grad)

for grad, var in capped_grad_and_vars:
    tf.summary.histogram(var.name + '/capped_gradient', grad)

该模型是具有跳过连接的ResNET,其包含多个[卷积 - >批量标准化 - > ReLU]重复层.在"分发"选项卡中,我可以看到添加了以下模式的多个图形:

• BatchNorm_ [数字]/beta0/capped_gradient …

我正在尝试修改global_step检查点中的内容，以便可以将培训从一台机器移至另一台机器。

假设我在机器A上进行了几天的训练。现在，我购买了具有更好图形卡和更多GPU内存的新机器B，并希望将训练从机器A转移到机器B。

为了恢复机器B中的检查点，我之前已经在机器A中指定了global_stepin Saver.save，但是大小batch_size越来越小sub_iterations。

batch_size=10
sub_iterations=500
for (...)
    for i in range(sub_iterations):
        inputs, labels = next_batch(batch_size)
        session.run(optimizer, feed_dict={inputs: inputs, labels: labels})

saver = tf.train.Saver()
saver.save(session, checkpoints_path, global_step)

现在，我将包括检查点在内的所有文件从机器A复制到机器B。由于机器B具有更多的GPU内存，因此我可以将修改batch_size为更大的值，但使用更少的sub_iterations。

batch_size=100
sub_iterations=50 # = 500 / (100/10)
for (...)
    for i in range(sub_iterations):
        inputs, labels = next_batch(batch_size)
        session.run(optimizer, feed_dict={inputs: inputs, labels: labels})

但是，由于global_step机器B中的不同，我们无法直接还原复制的检查点。例如，由于机器B中减少的数量，tf.train.exponential_decay将产生不正确的检查点。learning_ratesub_iterations

learning_rate = tf.train.exponential_decay(..., global_step, sub_iterations, decay_rate, staircase=True)

是否可以修改global_step检查点中的？还是有替代的但更合适的方式来处理这种情况？ …

我想创建两个对象 A 和 B，每个对象都包含彼此。

class B;

class A
{
public:
    A(B * b) : _b(b) {}
    void printB(void)
    {
        if (0 != _b)
        {
            std::cout << "B is not null" << std::endl;
        }
        else
        {
            std::cout << "B is null" << std::endl;
        }
    }
private:
    B * _b;
};

class B
{
public:
    B(A * a) : _a(a) {}
    void printA(void)
    {
        if (0 != _a)
        {
            std::cout << "A is not null" << std::endl;
        }
        else
        {
            std::cout << …