AdamOptimizer возвращает неверную ошибку типа данных

Question

В последние пару дней я пытался это исправить, любая помощь будет признательна.

У меня есть сеть, которая выводит числовые местоположения x,y coordinates на изображении, следовательно, тип данных int32. Выход имеет размер (2,2). У наземной правды также есть местоположения как int32.

Затем я запускаю следующие две строки кода:

cost = tf.reduce_mean(tf.square(y_true - y_pred_cls))
optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(cost)

и получите следующую ошибку:

ValueError: Invalid type tf.int32 for Mean_7:0, expected: [tf.float32, tf.float64, tf.float16, tf.bfloat16].

Я понимаю, что среднее значение должно быть значением с плавающей точкой, но если я преобразую прогнозируемое значение в значение с плавающей точкой, я получаю ошибку "Градиенты не указаны".

Я также пытался использовать softmax_cross_entropy_with_logits_v2 Tensorflow, чтобы превратить мою проблему в проблему классификации, но та же ошибка. Буду очень признателен за любую помощь с решением.

Код

Код для ввода и метки

x_p = tf.placeholder(tf.float32, shape=[None, img_size_flat*num_channels], name='x_pred')
x_pred_image = tf.reshape(x_p, [-1, 10, 10, num_channels])
k = tf.constant(npatches)
y_true = tf.placeholder(tf.int32, shape=[None, 2, 2], name='y_true')
y_true_cls = tf.placeholder(tf.int32, shape=[None, 2, 2], name='y_true_cls')

Сверточный слой

def new_weights(shape, layer_name):
    initializer = tf.contrib.layers.xavier_initializer()
    return tf.Variable(initializer(shape), name=layer_name+'_W')

def new_bias(length, layer_name):
    return tf.Variable(tf.constant(0.05, shape=[length]), name=layer_name+'_b')

def new_conv_layer(input,
                   num_input_channels,
                   filter_size,
                   num_filters,
                   name_scope,
                   layer_name='',
                   use_pooling=True):

    with tf.name_scope(name_scope):
        shape = [filter_size, filter_size, num_input_channels, num_filters]
        weights = new_weights(shape, layer_name)
        biases = new_bias(num_filters, layer_name)

        layer = tf.add(tf.nn.conv2d(input=input, filter=weights, strides=[1,1,1,1], padding='SAME'), biases, name=layer_name)

        if use_pooling:
            layer = tf.nn.max_pool(value=layer,
                                   ksize=[1, 3, 3, 1],
                                   strides=[1, 2, 2, 1],
                                   padding='SAME', name=layer_name+'_max')

        layer = tf.nn.relu(layer, name=layer_name+'_activation')

    return layer, weights

Полностью подключенный слой

def new_fc_layer(input,
                num_inputs,
                num_outputs,
                name_scope,
                layer_name='',
                use_relu=True):

    with tf.name_scope(name_scope):
        weights = new_weights([num_inputs, num_outputs], layer_name)
        biases = new_bias(num_outputs, layer_name)

        layer = tf.add(tf.matmul(input, weights),biases,name=layer_name)
    #     layer = tf.matmul(input, weights) + biases

        if use_relu:
            layer = tf.nn.relu(layer, layer_name+'_activation')

    return layer

Код пользовательского слоя

with tf.name_scope(name_scope):
    resh_inp = tf.reshape(input, [-1, 10, 10])
    input_shape = tf.shape(resh_inp)
    rows, cols = input_shape[1], input_shape[2]
    d_rows, d_cols = 2, 2
    subm_rows, subm_cols = rows - d_rows + 1, cols - d_cols + 1
    ii, jj = tf.meshgrid(tf.range(subm_rows), tf.range(subm_cols), indexing='ij')
    d_ii, d_jj = tf.meshgrid(tf.range(d_rows), tf.range(d_cols), indexing='ij')

    subm_ii = ii[:, :, tf.newaxis, tf.newaxis] + d_ii
    subm_jj = jj[:, :, tf.newaxis, tf.newaxis] + d_jj
    subm = tf.gather_nd(resh_inp[0, :, :], tf.stack([subm_ii, subm_jj], axis=-1), name=layer_name + "_gather")
    subm_sum = tf.reduce_sum(subm, axis=(2, 3), name=layer_name + "_subm_sum")
    _, top_idx = tf.nn.top_k(tf.reshape(subm_sum, [-1]), tf.minimum(k, tf.size(subm_sum)), name=layer_name + "_top_idx")
    top_row = top_idx // subm_cols
    top_col = top_idx % subm_cols
    result = tf.stack([top_row, top_col], axis=-1, name=layer_name + "_result")
    result_shape = tf.shape(result)
    result = tf.reshape(result, [-1, result_shape[0], result_shape[1]], name=layer_name + "_shaped_result")

Результат кода выше передается как y_pred_cls в коде ниже

cost = tf.reduce_mean(tf.square(y_true - y_pred_cls))
optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(cost)