小编Jav*_*Jav的帖子

背景:我正在使用完全卷积网络来执行图像分割.通常,输入是RGB图像shape = [512, 256],并且目标是定义注释区域的2通道二元掩模(第二通道与第一通道相反).

问:我使用Tensorflow和Keras实现了相同的CNN实现.但Tensorflow模型并没有开始学习.实际上,loss甚至随着时代的数量而增长!这个Tensorflow实现有什么问题阻止它学习？

设置:数据集分为3个子集:训练(78%),测试(8%)和验证(14%)集合,这些集合由8个图像批量馈送到网络.图表显示了loss每个子集的演变.图像显示了prediction两个不同图像的10个时期之后.

Tensorflow实施和结果

import tensorflow as tf

tf.reset_default_graph()
x = inputs = tf.placeholder(tf.float32, shape=[None, shape[1], shape[0], 3])
targets = tf.placeholder(tf.float32, shape=[None, shape[1], shape[0], 2])

for d in range(4):
    x = tf.layers.conv2d(x, filters=np.exp2(d+4), kernel_size=[3,3], strides=[1,1], padding="SAME", activation=tf.nn.relu)
    x = tf.layers.max_pooling2d(x, strides=[2,2], pool_size=[2,2], padding="SAME")

x = tf.layers.conv2d(x, filters=2, kernel_size=[1,1])
logits = tf.image.resize_images(x, [shape[1], shape[0]], align_corners=True)
prediction = tf.nn.softmax(logits)

loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=targets, logits=logits))
optimizer = tf.train.RMSPropOptimizer(learning_rate=0.001).minimize(loss)

sess …

嵌套 NamedTuples 的 JSON 序列化非常简单：

import json\nfrom typing import NamedTuple\n\nclass A(NamedTuple):\n    a: int\nclass B(NamedTuple):\n    a: A\n    b: str\ns = json.dumps(B(A(42), "auie"))\nprint(s) # outputs the following string: "[[42], 'auie']"\n

另一方面，JSON 反序列化需要一些工作\xe2\x80\xa6 最好的方法是什么？我想过使用递归函数，但我希望有一个更干净的实现\xe2\x80\xa6

def deserialize(T,l):\n    for i, k in enumerate(T._field_types):\n        if hasattr(T._field_types[k], "_field_types"): # I'm open to a more robust check\n            l[i] = deserialize(T._field_types[k], l[i])\n    return T(*l)\n    \nprint(deserialize(B, json.loads(s))) # prints B(a=A(a=42), b='auie')\n

当我循环浏览所有文件时,foo我会这样做

for f in foo* ; do echo "result = $f" ; done

问题是当我没有文件开始时foo:

result = foo*

意味着循环执行一次,即使没有文件开始foo.

这怎么可能？如何循环遍历所有文件(如果没有文件则不循环)？

使用 AWS，我正在构建一个定义以下内容的云形成堆栈：

1. 几个资源（为了简单起见，下面没有转录）
2. 称为MyPolicy允许使用这些资源的策略（为简单起见，未在下面转录）
3. 称为MyRole提交给该策略的角色

堆栈将由管理员创建；一旦创建，目标是允许（从堆栈外）一些用户假设MyRole以使用多个资源。

我的问题：应该如何定义角色才能由用户承担（特定用户将被允许来自堆栈外）？

在AWS帮助页面，他们给的例子在那里"Service": [ "ec2.amazonaws.com" ]，这意味着一个 ec2实例被允许承担该角色......但我不明白它是如何转化为用户，并给出关于该方案中没有例子。

以下是我使用JSON格式的堆栈定义：

{
    "AWSTemplateFormatVersion" : "2010-09-09",
    "Resources" : {
        "MyRole" : {
            "Type": "AWS::IAM::Role",
            "RoleName": "MyRole",
            "AssumeRolePolicyDocument": {
                "Version": "2012-10-17",
                "Statement": [
                    {
                        "Effect": "Allow",
                        "Principal": { "Service": [ "??" ] },
                        "Action": [ "sts:AssumeRole" ]
                    }
                ]
            },
            "ManagedPolicyArns": [ { "Fn::GetAtt" : [ "MyPolicy", "Arn" ] } ],
        }
    } …

我有一个自定义训练循环，可以简化如下

inputs = tf.keras.Input(dtype=tf.float32, shape=(None, None, 3))
model = tf.keras.Model({"inputs": inputs}, {"loss": f(inputs)})
optimizer = tf.keras.optimizers.SGD(learning_rate=0.1, momentum=0.9, nesterov=True)

for inputs in batches:
    with tf.GradientTape() as tape:
        results = model(inputs, training=True)
    grads = tape.gradient(results["loss"], model.trainable_weights)
    optimizer.apply_gradients(zip(grads, model.trainable_weights))

ExponentialMovingAverage 的 TensorFlow 文档并不清楚如何在从头开始的训练循环中使用它。有人用过这个吗？

此外，如果影子变量仍然在内存中，应该如何将影子变量恢复到模型中，以及如何检查训练变量是否已正确更新？

我想返回一个,uint64_t但结果似乎被截断:

在lib.c:

uint64_t function()
{
    uint64_t timestamp = 1422028920000;
    return timestamp;
}

在main.c:

uint64_t result = function();
printf("%llu  =  %llu\n", result, function());

结果:

394745024  =  394745024

在编译时,我收到一个警告:

warning: format '%llu' expects argument of type 'long long unsigned int', but argument 2 has type 'uint64_t' [-Wformat]
warning: format '%llu' expects argument of type 'long long unsigned int', but argument 3 has type 'int' [-Wformat]

为什么编译器认为我的函数的返回类型是int？我们怎样才能解释打印的reslut与函数发送的值不同function()？

我对编译器如何通过如下指令进行float转换感兴趣int:

    float x_f = 3.1415
    int x = (int)x_f;

特别是谈论速度.它是否像内置处理器指令一样超快？还是需要计算？

如果它float总是包含一个精确的整数(ex :),它也会改变x_f = 3.0000.

编辑:这个问题是针对intel x86处理器使用的gcc编译器.

EDIT2:如果有变化x_f = 3.0吗？

在Intel(R)Core(TM)i7-4790上运行这段代码,我得到了奇怪的结果:

#include <stdio.h>
#define CALCULUS 2052 - 1.0 - margin
void main(void)
{
    float margin = 1.0001;
    float a = CALCULUS;
    printf("%2.6f\t%2.6f\n", a, CALCULUS);
}

我有

$ gcc test2.c && ./a.out
2050.000000 2049.999900

有人可以解释这种行为吗？我知道,当我使用它不会发生double,而不是float,但我觉得奇怪的舍入发生在这样一个小数目.