Keras ValueError: размеры должны быть равными
Даже после применения предложений в ответе и комментариях похоже, что проблема несоответствия размеров сохраняется. Это точный код и файл данных для репликации: https://drive.google.com/drive/folders/1q67s0VhB-O7J8OtIhU2jmj7Kc4LxL3sf?usp=sharing
Как это можно исправить!? Последний код, сводка модели, используемые функции и ошибка, которую я получаю, приведены ниже.
type_ae=='dcor'
#Wrappers for keras
def custom_loss1(y_true,y_pred):
dcor = -1*distance_correlation(y_true,encoded_layer)
return dcor
def custom_loss2(y_true,y_pred):
recon_loss = losses.categorical_crossentropy(y_true, y_pred)
return recon_loss
input_layer = Input(shape=(64,64,1))
encoded_layer = Conv2D(filters = 128, kernel_size = (5,5),padding = 'same',activation ='relu',
input_shape = (64,64,1))(input_layer)
encoded_layer = MaxPool2D(pool_size=(2,2))(encoded_layer)
encoded_layer = Dropout(0.25)(encoded_layer)
encoded_layer = (Conv2D(filters = 64, kernel_size = (3,3),padding = 'same',activation ='relu'))(encoded_layer)
encoded_layer = (MaxPool2D(pool_size=(2,2)))(encoded_layer)
encoded_layer = (Dropout(0.25))(encoded_layer)
encoded_layer = (Conv2D(filters = 64, kernel_size = (3,3),padding = 'same',activation ='relu'))(encoded_layer)
encoded_layer = (MaxPool2D(pool_size=(2,2)))(encoded_layer)
encoded_layer = (Dropout(0.25))(encoded_layer)
encoded_layer = Conv2D(filters = 1, kernel_size = (3,3),padding = 'same',activation ='relu',
input_shape = (64,64,1),strides=1)(encoded_layer)
encoded_layer = ZeroPadding2D(padding=(28, 28), data_format=None)(encoded_layer)
decoded_imag = Conv2D(8, (2, 2), activation='relu', padding='same')(encoded_layer)
decoded_imag = UpSampling2D((2, 2))(decoded_imag)
decoded_imag = Conv2D(8, (3, 3), activation='relu', padding='same')(decoded_imag)
decoded_imag = UpSampling2D((2, 2))(decoded_imag)
decoded_imag = Conv2D(16, (3, 3), activation='relu', padding='same')(decoded_imag)
decoded_imag = UpSampling2D((2, 2))(decoded_imag)
decoded_imag = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(decoded_imag)
flat_layer = Flatten()(decoded_imag)
dense_layer = Dense(256,activation = "relu")(flat_layer)
dense_layer = Dense(64,activation = "relu")(dense_layer)
dense_layer = Dense(32,activation = "relu")(dense_layer)
output_layer = Dense(9, activation = "softmax")(dense_layer)
autoencoder = Model(input_layer, [encoded_layer,output_layer])
autoencoder.summary()
autoencoder.compile(optimizer='adadelta', loss=[custom_loss1,custom_loss2])
autoencoder.fit(x_train,[x_train, y_train],batch_size=32,epochs=3,shuffle=True,
validation_data=(x_val, [x_val,y_val]))
Данные имеют размеры:
x_train.shape: (4000, 64, 64, 1)
x_val.shape: (1000, 64, 64, 1)
y_train.shape: (4000, 9)
y_val.shape: (1000, 9)
потери выглядят так:
def custom_loss1(y_true,y_pred):
dcor = -1*distance_correlation(y_true,encoded_layer)
return dcor
def custom_loss2(y_true,y_pred):
recon_loss = losses.categorical_crossentropy(y_true, y_pred)
return recon_loss
Корреляционная функция основана на тензорах следующим образом:
def distance_correlation(y_true,y_pred):
pred_r = tf.reduce_sum(y_pred*y_pred,1)
pred_r = tf.reshape(pred_r,[-1,1])
pred_d = pred_r - 2*tf.matmul(y_pred,tf.transpose(y_pred))+tf.transpose(pred_r)
true_r = tf.reduce_sum(y_true*y_true,1)
true_r = tf.reshape(true_r,[-1,1])
true_d = true_r - 2*tf.matmul(y_true,tf.transpose(y_true))+tf.transpose(true_r)
concord = 1-tf.matmul(y_true,tf.transpose(y_true))
#print(pred_d)
#print(tf.reshape(tf.reduce_mean(pred_d,1),[-1,1]))
#print(tf.reshape(tf.reduce_mean(pred_d,0),[1,-1]))
#print(tf.reduce_mean(pred_d))
tf.check_numerics(pred_d,'pred_d has NaN')
tf.check_numerics(true_d,'true_d has NaN')
A = pred_d - tf.reshape(tf.reduce_mean(pred_d,1),[-1,1]) - tf.reshape(tf.reduce_mean(pred_d,0),[1,-1]) + tf.reduce_mean(pred_d)
B = true_d - tf.reshape(tf.reduce_mean(true_d,1),[-1,1]) - tf.reshape(tf.reduce_mean(true_d,0),[1,-1]) + tf.reduce_mean(true_d)
#dcor = -tf.reduce_sum(concord*pred_d)/tf.reduce_sum((1-concord)*pred_d)
dcor = -tf.log(tf.reduce_mean(A*B))+tf.log(tf.sqrt(tf.reduce_mean(A*A)*tf.reduce_mean(B*B)))#-tf.reduce_sum(concord*pred_d)/tf.reduce_sum((1-concord)*pred_d)
#print(dcor.shape)
#tf.Print(dcor,[dcor])
#dcor = tf.tile([dcor],batch_size)
return (dcor)
резюме модели выглядит так:
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
input_5 (InputLayer) (None, 64, 64, 1) 0
_________________________________________________________________
conv2d_30 (Conv2D) (None, 64, 64, 128) 3328
_________________________________________________________________
max_pooling2d_13 (MaxPooling (None, 32, 32, 128) 0
_________________________________________________________________
dropout_13 (Dropout) (None, 32, 32, 128) 0
_________________________________________________________________
conv2d_31 (Conv2D) (None, 32, 32, 64) 73792
_________________________________________________________________
max_pooling2d_14 (MaxPooling (None, 16, 16, 64) 0
_________________________________________________________________
dropout_14 (Dropout) (None, 16, 16, 64) 0
_________________________________________________________________
conv2d_32 (Conv2D) (None, 16, 16, 64) 36928
_________________________________________________________________
max_pooling2d_15 (MaxPooling (None, 8, 8, 64) 0
_________________________________________________________________
dropout_15 (Dropout) (None, 8, 8, 64) 0
_________________________________________________________________
conv2d_33 (Conv2D) (None, 8, 8, 1) 577
_________________________________________________________________
zero_padding2d_5 (ZeroPaddin (None, 64, 64, 1) 0
_________________________________________________________________
conv2d_34 (Conv2D) (None, 64, 64, 8) 40
_________________________________________________________________
up_sampling2d_10 (UpSampling (None, 128, 128, 8) 0
_________________________________________________________________
conv2d_35 (Conv2D) (None, 128, 128, 8) 584
_________________________________________________________________
up_sampling2d_11 (UpSampling (None, 256, 256, 8) 0
_________________________________________________________________
conv2d_36 (Conv2D) (None, 256, 256, 16) 1168
_________________________________________________________________
up_sampling2d_12 (UpSampling (None, 512, 512, 16) 0
_________________________________________________________________
conv2d_37 (Conv2D) (None, 512, 512, 1) 145
_________________________________________________________________
flatten_4 (Flatten) (None, 262144) 0
_________________________________________________________________
dense_13 (Dense) (None, 256) 67109120
_________________________________________________________________
dense_14 (Dense) (None, 64) 16448
_________________________________________________________________
dense_15 (Dense) (None, 32) 2080
_________________________________________________________________
dense_16 (Dense) (None, 9) 297
=================================================================
Total params: 67,244,507
Trainable params: 67,244,507
Non-trainable params: 0
_________________________________________________________________
Это ошибка:
InvalidArgumentError Traceback (most recent call last)
~/anaconda3/lib/python3.6/site-packages/tensorflow/python/framework/ops.py in _create_c_op(graph, node_def, inputs, control_inputs)
1658 try:
-> 1659 c_op = c_api.TF_FinishOperation(op_desc)
1660 except errors.InvalidArgumentError as e:
InvalidArgumentError: Dimensions must be equal, but are 1 and 64 for 'loss_1/zero_padding2d_5_loss/MatMul' (op: 'BatchMatMul') with input shapes: [?,64,64,1], [1,64,64,?].
During handling of the above exception, another exception occurred:
ValueError Traceback (most recent call last)
<ipython-input-11-0e924885fc6b> in <module>
40 autoencoder = Model(input_layer, [encoded_layer,output_layer])
41 autoencoder.summary()
---> 42 autoencoder.compile(optimizer='adadelta', loss=[custom_loss1,custom_loss2])
43 autoencoder.fit(x_train,[x_train, y_train],batch_size=32,epochs=3,shuffle=True,
44 validation_data=(x_val, [x_val,y_val]))
~/anaconda3/lib/python3.6/site-packages/keras/engine/training.py in compile(self, optimizer, loss, metrics, loss_weights, sample_weight_mode, weighted_metrics, target_tensors, **kwargs)
340 with K.name_scope(self.output_names[i] + '_loss'):
341 output_loss = weighted_loss(y_true, y_pred,
--> 342 sample_weight, mask)
343 if len(self.outputs) > 1:
344 self.metrics_tensors.append(output_loss)
~/anaconda3/lib/python3.6/site-packages/keras/engine/training_utils.py in weighted(y_true, y_pred, weights, mask)
402 """
403 # score_array has ndim >= 2
--> 404 score_array = fn(y_true, y_pred)
405 if mask is not None:
406 # Cast the mask to floatX to avoid float64 upcasting in Theano
<ipython-input-11-0e924885fc6b> in custom_loss1(y_true, y_pred)
2 #Wrappers for keras
3 def custom_loss1(y_true,y_pred):
----> 4 dcor = -1*distance_correlation(y_true,encoded_layer)
5 return dcor
6
<ipython-input-6-f282528532cc> in distance_correlation(y_true, y_pred)
2 pred_r = tf.reduce_sum(y_pred*y_pred,1)
3 pred_r = tf.reshape(pred_r,[-1,1])
----> 4 pred_d = pred_r - 2*tf.matmul(y_pred,tf.transpose(y_pred))+tf.transpose(pred_r)
5 true_r = tf.reduce_sum(y_true*y_true,1)
6 true_r = tf.reshape(true_r,[-1,1])
~/anaconda3/lib/python3.6/site-packages/tensorflow/python/ops/math_ops.py in matmul(a, b, transpose_a, transpose_b, adjoint_a, adjoint_b, a_is_sparse, b_is_sparse, name)
2415 adjoint_b = True
2416 return gen_math_ops.batch_mat_mul(
-> 2417 a, b, adj_x=adjoint_a, adj_y=adjoint_b, name=name)
2418
2419 # Neither matmul nor sparse_matmul support adjoint, so we conjugate
~/anaconda3/lib/python3.6/site-packages/tensorflow/python/ops/gen_math_ops.py in batch_mat_mul(x, y, adj_x, adj_y, name)
1421 adj_y = _execute.make_bool(adj_y, "adj_y")
1422 _, _, _op = _op_def_lib._apply_op_helper(
-> 1423 "BatchMatMul", x=x, y=y, adj_x=adj_x, adj_y=adj_y, name=name)
1424 _result = _op.outputs[:]
1425 _inputs_flat = _op.inputs
~/anaconda3/lib/python3.6/site-packages/tensorflow/python/framework/op_def_library.py in _apply_op_helper(self, op_type_name, name, **keywords)
786 op = g.create_op(op_type_name, inputs, output_types, name=scope,
787 input_types=input_types, attrs=attr_protos,
--> 788 op_def=op_def)
789 return output_structure, op_def.is_stateful, op
790
~/anaconda3/lib/python3.6/site-packages/tensorflow/python/util/deprecation.py in new_func(*args, **kwargs)
505 'in a future version' if date is None else ('after %s' % date),
506 instructions)
--> 507 return func(*args, **kwargs)
508
509 doc = _add_deprecated_arg_notice_to_docstring(
~/anaconda3/lib/python3.6/site-packages/tensorflow/python/framework/ops.py in create_op(***failed resolving arguments***)
3298 input_types=input_types,
3299 original_op=self._default_original_op,
-> 3300 op_def=op_def)
3301 self._create_op_helper(ret, compute_device=compute_device)
3302 return ret
~/anaconda3/lib/python3.6/site-packages/tensorflow/python/framework/ops.py in __init__(self, node_def, g, inputs, output_types, control_inputs, input_types, original_op, op_def)
1821 op_def, inputs, node_def.attr)
1822 self._c_op = _create_c_op(self._graph, node_def, grouped_inputs,
-> 1823 control_input_ops)
1824
1825 # Initialize self._outputs.
~/anaconda3/lib/python3.6/site-packages/tensorflow/python/framework/ops.py in _create_c_op(graph, node_def, inputs, control_inputs)
1660 except errors.InvalidArgumentError as e:
1661 # Convert to ValueError for backwards compatibility.
-> 1662 raise ValueError(str(e))
1663
1664 return c_op
ValueError: Dimensions must be equal, but are 1 and 64 for 'loss_1/zero_padding2d_5_loss/MatMul' (op: 'BatchMatMul') with input shapes: [?,64,64,1], [1,64,64,?].
конечно .. добавил его туда, где импорт (зависимость), используемый для работы custom_loss1, является «из dcor import Distance_correlation»
Я думаю, вы уже знаете причину ошибки, как я вижу из комментариев ниже. encoded_layer в custom_loss1 имеет форму, отличную от вашей y_true. Я посмотрел на вашу модель, и я не понимаю, чего именно вы хотите достичь. Может быть, если вы немного объясните это, я смогу предложить вам изменения в модели.
Если вы хотите вычислить custom_loss1 по исходному изображению и custom_loss2 по скалярным меткам, которые вы передаете в fit, думаю, у меня есть для вас решение. Но я не уверен, действительно ли вы пытаетесь это сделать.
@ Анакин Совершенно верно. Я хочу пользовательскую потерю 1 по отношению к закодированному исходному изображению. И кастомные лейблы loss 2 wrt... при подгонке
хорошо, я думаю, что ответ @mujjiga почти полностью правильный, но я предложу небольшую модификацию в качестве своего ответа.
Ответы 2
У вас есть две функции потерь, поэтому вам нужно передать две y (наземные истины) для оценки потерь по отношению к прогнозам.
Ваш первый прогноз — это результат слоя encoded_layer, который имеет размер (None, 8, 8, 128), как видно из модели.резюме для conv2d_59 (Conv2D)
Но то, что вы проходите в подгонке y, есть [x_train, y_train]. Loss_1 ожидает ввода размера (None, 8, 8, 128), но вы передаете x_train, который имеет другой размер.
Если вы хотите, чтобы loss_1 нашел корреляцию входного изображения с закодированным изображением, сложите свертки таким образом, чтобы результат сверток приводил к форме, которая совпадает с формой вашего изображения x_train. Используйте model.summary, чтобы увидеть выходную форму извилин.
Не используйте отступы, шаги и размер ядра слоя свертки, чтобы получить желаемый выходной размер сверток. используйте формулы W2=(W1−F+2P)/S+1 и H2=(H1−F+2P)/S+1, чтобы найти выходную ширину и высоту сверток. Проверьте это ссылка
В вашем подходе есть две основные проблемы.
- Ваша функция потерь проверяет корреляцию между закодированным изображением и фактическим изображением. Правильный способ сделать это - декодировать изображение обратно из закодированного изображения, а затем проверить корреляцию между декодированным изображением и фактическим изображением (в строках автоэнкодера).
- Ваша потеря 1 использует массивы numpy. Чтобы функция потерь была частью графа вычислений, она должна использовать тензорные операции, а не числовые операции.
Ниже приведен рабочий код. Однако для потери 1 я использую норму l2 двух изображений. Если вы хотите использовать корреляцию, вам нужно каким-то образом преобразовать ее в тензорные операции (что отличается от этого вопроса)
def image_loss(y_true,y_pred):
return tf.norm(y_true - y_pred)
def label_loss(y_true,y_pred):
return categorical_crossentropy(y_true, y_pred)
input_img = Input(shape=(64, 64, 1))
enocded_imag = Conv2D(16, (3, 3), activation='relu', padding='same')(input_img)
enocded_imag = MaxPooling2D((2, 2), padding='same')(enocded_imag)
enocded_imag = Conv2D(8, (3, 3), activation='relu', padding='same')(enocded_imag)
enocded_imag = MaxPooling2D((2, 2), padding='same')(enocded_imag)
enocded_imag = Conv2D(8, (3, 3), activation='relu', padding='same')(enocded_imag)
enocded_imag = MaxPooling2D((2, 2), padding='same')(enocded_imag)
decoded_imag = Conv2D(8, (2, 2), activation='relu', padding='same')(enocded_imag)
decoded_imag = UpSampling2D((2, 2))(decoded_imag)
decoded_imag = Conv2D(8, (3, 3), activation='relu', padding='same')(decoded_imag)
decoded_imag = UpSampling2D((2, 2))(decoded_imag)
decoded_imag = Conv2D(16, (3, 3), activation='relu', padding='same')(decoded_imag)
decoded_imag = UpSampling2D((2, 2))(decoded_imag)
decoded_imag = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(decoded_imag)
flat_layer = Flatten()(enocded_imag)
dense_layer = Dense(32,activation = "relu")(flat_layer)
output_layer = Dense(9, activation = "softmax")(dense_layer)
model = Model(input_img, [decoded_imag, output_layer])
model.compile(optimizer='adadelta', loss=[image_loss, label_loss])
images = np.random.randn(10,64,64,1)
model.fit(images, [images, np.random.randn(10,9)])
Функция потерь distance_correlation, которую вы закодировали, предполагает, что каждая строка в y_true и y_pred представляет изображение. Когда вы используете слои Dense, это будет работать, потому что слой Dense выводит пакет векторов (строк), где каждый вектор представляет отдельное изображение. Однако двумерные свертки работают с пакетом двумерных тензоров с несколькими каналами (у вас есть только 1 канал). Таким образом, чтобы использовать функцию потерь distance_correlation, вы должны изменить свой тензор так, чтобы каждая строка соответствовала изображению. Добавьте ниже две строки, чтобы изменить форму ваших тензоров.
def distance_correlation(y_true,y_pred):
y_true = tf.reshape(tf.squeeze(y_true), [-1,64*64])
y_pred = tf.reshape(tf.squeeze(y_pred), [-1,64*64])
.... REST OF THE CODE ....
чтобы сложить свертки так, чтобы результат сверток приводил к форме, которая совпадает с формой вашего изображения x_train: я использую Reshape? Я получил ошибку с этим. Каков хороший способ гарантировать, что результат этого преобразования будет соответствовать размеру моих изображений ?? это правда, что я пытаюсь использовать эту корреляцию между изображением и выводом этой свертки. Я знаю, что размеры должны совпадать. Я изо всех сил пытаюсь изменить размер вывода этого конверсионного слоя. Как это сделать?
Обновленный ответ с дополнительной информацией
У меня все еще есть ошибка после применения предложения в вашем ответе! Обновлен вопрос в конце на основе того, что я увидел после применения вашего ответа.
Обновлена корреляция fn, теперь она основана только на тензорах. Обновлен внизу вопроса снова. Все еще получаю ту же ошибку!
@hearse, не могли бы вы обновить код построения модели своим «модифицированным» кодом.
добавлен последний код модели, подробное описание модели в вопросе, как вы предложили. дайте мне знать, почему ошибка остается и как ее можно исправить. начал щедрость, а также на этом
@hearse, это другая проблема. У вашего distance_correlation проблемы. Не могли бы вы рассказать, что вы пытаетесь сделать в методе distance_correlation?
Мне нужно вычислить корреляцию расстояния или журнал корреляции расстояния en.wikipedia.org/wiki/Distance_correlation в этой функции. dcor.readthedocs.io/en/latest/?badge=latest — хороший пакет для того же. Либо Distance_correlation должен быть написан таким образом, чтобы он работал с моим кодом, либо пакет dcor должен использоваться таким образом, чтобы он работал с кодом.
обновление: Distance_correlation работает, если слои не сверточные, а обычные плотные слои. Ошибка отображается в настройке conv2d, как и в моем вопросе, для которого ее необходимо исправить.
@hearse Мое обновление (к моему ответу) решило вашу проблему сейчас?
Намерение состоит в том, чтобы использовать исходное изображение в custom_loss1 и значения скалярной метки в custom_loss2. Я думаю, что рабочий код @mujjiga в его ответе почти правильный. Я предлагаю одну небольшую модификацию.
В model.compile() передайте входной тензор в потерю, которая в этом нуждается. Держите другой таким же. model.fit() просто проходит мимо ярлыков.
model.compile(optimizer='adadelta', loss=[custom_loss1(input_layer), custom_loss2])
mode.fit(x_train, y_train)
Внутри пользовательских функций потерь:
def custom_loss1(input):
def loss1(y_true, y_pred):
return tf.norm(input - y_pred) # use your custom loss 1
return loss1
def custom_loss2(y_true, y_pred):
return categorical_crossentropy(y_true, y_pred) # use your custom loss 2
Сначала попробуйте это с помощью простых встроенных функций потерь Keras. Если это работает хорошо, изучите свои собственные функции потерь.
images будет вашим x_trainaxis=1 добавляет столбец, а не строку
основное отличие заключается в доступе только к фрагменту метки по мере необходимости с помощью соответствующей функции потерь, а не в использовании всего. Итак, в loss1 вы получаете доступ к исходному изображению, в loss2 вы получаете доступ к скалярным значениям. я отредактировал свой ответ с комментариями для лучшего понимания.
При попытке вашего предложения, в частности части, np.append(x_train, y_train, axis = 1) выдает ошибку. Я получаю ValueError: все входные массивы должны иметь одинаковое количество измерений. print(x_train.shape) и print(y_train.shape) дают (4000, 64, 64, 1) и (4000, 9) в качестве фигур. Добавление должно быть выполнено правильно, прежде чем использовать его в model.fit. Как исправить? Это точный код и файл данных для репликации: drive.google.com/drive/folders/…
Хорошо, извините, предыдущее предложение не работает из-за несоответствия формы. Я использовал его в случае, когда мои train_data и label были массивами. Я обновил ответ другим способом обработки. Может быть, вы можете попробовать это.
Но разве нестандартная потеря 1 не является функцией двух аргументов? Ничего, если я оставлю потерю fn таким же образом и все же передам один аргумент, как вы говорите при компиляции? Постараюсь независимо и дам вам знать здесь
custom_loss1 — это функция-оболочка, она вызывает внутреннюю функцию с двумя правильными аргументами. Я пробовал аналогичную пользовательскую потерю, но только с одной функцией потери. Таким образом, я не уверен, что в случае с множественными потерями это будет работать так же. Но стоит попробовать.
При подгонке я получаю эту ошибку при попытке вашего предложения: ValueError: Ошибка при проверке цели модели: список массивов Numpy, которые вы передаете своей модели, не соответствует размеру ожидаемой модели. Ожидалось увидеть 2 массива(ов), но вместо этого получил следующий список из 1 массива: [массив([[0., 0., 0., ..., 0., 0., 0.], [0. , 0., 0., ..., 0., 0., 0.], [0., 0., 0., ..., 0., 0., 0.], ..., [ 0., 0., 0., ..., 0., 0., 1.], [0., 0., 0., ..., 0., 0., 0....
Хорошо, я проверю проблему с простой реализацией и дам вам знать.
ладно, смотрю вперед. Distance_correlation работает, если слои не сверточные, а обычные плотные слои. Ошибка отображается в настройке conv2d, как и в моем вопросе, для которого ее необходимо исправить.
Можете ли вы показать нам код для
custom_loss1иcustom_loss2