Keras 错误：尺寸必须相等，但对于输入形状为 [8,10]、[8,2] 的“loss/output_1_loss/SquaredDifference”，尺寸为 10 和 2

Question

I'm working on a simple mlp model. The input shape for model fitting is here.

fea_train_np.shape = (6000, 1, 15, 21, 512)
fea_val_np.shape = (1500, 1, 15, 21, 512)
y_train_np.shape = (6000, 2)
y_val_np.shape = (1500, 2)

And here is the mlp I'm working on. The last layer using linear activation as I want to do regression instead of classification.

mlp1 = keras.Sequential(
    [
        layers.Flatten(),
        layers.Dense(256, activation='relu'),   # Add a fully-connecte layer with 16 units and relu activation function as the hidden layer
        layers.Dense(10, activation='linear')
    ], 
)

mlp1.compile(optimizer = optimizers.Adam(learning_rate = 0.001),
           loss = keras.losses.MeanSquaredError(),
           metrics = [keras.metrics.MeanSquaredError()])

mlp = mlp1.fit(fea_train_np, y_train_np, epochs=20, batch_size=8, validation_data=(fea_val_np, y_val_np))
result = mlp.predict(fea_val_np, y_val_np)

And I got this error when I was trying to fit my model:

Train on 6000 samples, validate on 1500 samples
Epoch 1/20
   8/6000 [..............................] - ETA: 12s
---------------------------------------------------------------------------
InvalidArgumentError                      Traceback (most recent call last)
C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\framework\ops.py in _create_c_op(graph, node_def, inputs, control_inputs)
   1618   try:
-> 1619     c_op = c_api.TF_FinishOperation(op_desc)
   1620   except errors.InvalidArgumentError as e:

InvalidArgumentError: Dimensions must be equal, but are 10 and 2 for 'loss/output_1_loss/SquaredDifference' (op: 'SquaredDifference') with input shapes: [8,10], [8,2].

During handling of the above exception, another exception occurred:

ValueError                                Traceback (most recent call last)
<ipython-input-32-37335a6a8cd3> in <module>
     11            metrics = [keras.metrics.MeanSquaredError()])
     12 
---> 13 mlp = mlp1.fit(fea_train_np, y_train_np, epochs=20, batch_size=8, validation_data=(fea_val_np, y_val_np))
     14 result = mlp.predict(fea_val_np, y_val_np)

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\keras\engine\training.py in fit(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_freq, max_queue_size, workers, use_multiprocessing, **kwargs)
    817         max_queue_size=max_queue_size,
    818         workers=workers,
--> 819         use_multiprocessing=use_multiprocessing)
    820 
    821   def evaluate(self,

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\keras\engine\training_v2.py in fit(self, model, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_freq, max_queue_size, workers, use_multiprocessing, **kwargs)
    340                 mode=ModeKeys.TRAIN,
    341                 training_context=training_context,
--> 342                 total_epochs=epochs)
    343             cbks.make_logs(model, epoch_logs, training_result, ModeKeys.TRAIN)
    344 

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\keras\engine\training_v2.py in run_one_epoch(model, iterator, execution_function, dataset_size, batch_size, strategy, steps_per_epoch, num_samples, mode, training_context, total_epochs)
    126         step=step, mode=mode, size=current_batch_size) as batch_logs:
    127       try:
--> 128         batch_outs = execution_function(iterator)
    129       except (StopIteration, errors.OutOfRangeError):
    130         # TODO(kaftan): File bug about tf function and errors.OutOfRangeError?

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\keras\engine\training_v2_utils.py in execution_function(input_fn)
     96     # `numpy` translates Tensors to values in Eager mode.
     97     return nest.map_structure(_non_none_constant_value,
---> 98                               distributed_function(input_fn))
     99 
    100   return execution_function

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\eager\def_function.py in __call__(self, *args, **kwds)
    566         xla_context.Exit()
    567     else:
--> 568       result = self._call(*args, **kwds)
    569 
    570     if tracing_count == self._get_tracing_count():

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\eager\def_function.py in _call(self, *args, **kwds)
    613       # This is the first call of __call__, so we have to initialize.
    614       initializers = []
--> 615       self._initialize(args, kwds, add_initializers_to=initializers)
    616     finally:
    617       # At this point we know that the initialization is complete (or less

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\eager\def_function.py in _initialize(self, args, kwds, add_initializers_to)
    495     self._concrete_stateful_fn = (
    496         self._stateful_fn._get_concrete_function_internal_garbage_collected(  # pylint: disable=protected-access
--> 497             *args, **kwds))
    498 
    499     def invalid_creator_scope(*unused_args, **unused_kwds):

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\eager\function.py in _get_concrete_function_internal_garbage_collected(self, *args, **kwargs)
   2387       args, kwargs = None, None
   2388     with self._lock:
-> 2389       graph_function, _, _ = self._maybe_define_function(args, kwargs)
   2390     return graph_function
   2391 

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\eager\function.py in _maybe_define_function(self, args, kwargs)
   2701 
   2702       self._function_cache.missed.add(call_context_key)
-> 2703       graph_function = self._create_graph_function(args, kwargs)
   2704       self._function_cache.primary[cache_key] = graph_function
   2705       return graph_function, args, kwargs

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\eager\function.py in _create_graph_function(self, args, kwargs, override_flat_arg_shapes)
   2591             arg_names=arg_names,
   2592             override_flat_arg_shapes=override_flat_arg_shapes,
-> 2593             capture_by_value=self._capture_by_value),
   2594         self._function_attributes,
   2595         # Tell the ConcreteFunction to clean up its graph once it goes out of

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\framework\func_graph.py in func_graph_from_py_func(name, python_func, args, kwargs, signature, func_graph, autograph, autograph_options, add_control_dependencies, arg_names, op_return_value, collections, capture_by_value, override_flat_arg_shapes)
    976                                           converted_func)
    977 
--> 978       func_outputs = python_func(*func_args, **func_kwargs)
    979 
    980       # invariant: `func_outputs` contains only Tensors, CompositeTensors,

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\eager\def_function.py in wrapped_fn(*args, **kwds)
    437         # __wrapped__ allows AutoGraph to swap in a converted function. We give
    438         # the function a weak reference to itself to avoid a reference cycle.
--> 439         return weak_wrapped_fn().__wrapped__(*args, **kwds)
    440     weak_wrapped_fn = weakref.ref(wrapped_fn)
    441 

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\keras\engine\training_v2_utils.py in distributed_function(input_iterator)
     83     args = _prepare_feed_values(model, input_iterator, mode, strategy)
     84     outputs = strategy.experimental_run_v2(
---> 85         per_replica_function, args=args)
     86     # Out of PerReplica outputs reduce or pick values to return.
     87     all_outputs = dist_utils.unwrap_output_dict(

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\distribute\distribute_lib.py in experimental_run_v2(self, fn, args, kwargs)
    761       fn = autograph.tf_convert(fn, ag_ctx.control_status_ctx(),
    762                                 convert_by_default=False)
--> 763       return self._extended.call_for_each_replica(fn, args=args, kwargs=kwargs)
    764 
    765   def reduce(self, reduce_op, value, axis):

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\distribute\distribute_lib.py in call_for_each_replica(self, fn, args, kwargs)
   1817       kwargs = {}
   1818     with self._container_strategy().scope():
-> 1819       return self._call_for_each_replica(fn, args, kwargs)
   1820 
   1821   def _call_for_each_replica(self, fn, args, kwargs):

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\distribute\distribute_lib.py in _call_for_each_replica(self, fn, args, kwargs)
   2162         self._container_strategy(),
   2163         replica_id_in_sync_group=constant_op.constant(0, dtypes.int32)):
-> 2164       return fn(*args, **kwargs)
   2165 
   2166   def _reduce_to(self, reduce_op, value, destinations):

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\autograph\impl\api.py in wrapper(*args, **kwargs)
    290   def wrapper(*args, **kwargs):
    291     with ag_ctx.ControlStatusCtx(status=ag_ctx.Status.DISABLED):
--> 292       return func(*args, **kwargs)
    293 
    294   if inspect.isfunction(func) or inspect.ismethod(func):

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\keras\engine\training_v2_utils.py in train_on_batch(model, x, y, sample_weight, class_weight, reset_metrics, standalone)
    431       y,
    432       sample_weights=sample_weights,
--> 433       output_loss_metrics=model._output_loss_metrics)
    434 
    435   if reset_metrics:

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\keras\engine\training_eager.py in train_on_batch(model, inputs, targets, sample_weights, output_loss_metrics)
    310           sample_weights=sample_weights,
    311           training=True,
--> 312           output_loss_metrics=output_loss_metrics))
    313   if not isinstance(outs, list):
    314     outs = [outs]

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\keras\engine\training_eager.py in _process_single_batch(model, inputs, targets, output_loss_metrics, sample_weights, training)
    251               output_loss_metrics=output_loss_metrics,
    252               sample_weights=sample_weights,
--> 253               training=training))
    254       if total_loss is None:
    255         raise ValueError('The model cannot be run '

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\keras\engine\training_eager.py in _model_loss(model, inputs, targets, output_loss_metrics, sample_weights, training)
    165 
    166         if hasattr(loss_fn, 'reduction'):
--> 167           per_sample_losses = loss_fn.call(targets[i], outs[i])
    168           weighted_losses = losses_utils.compute_weighted_loss(
    169               per_sample_losses,

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\keras\losses.py in call(self, y_true, y_pred)
    219       y_pred, y_true = tf_losses_util.squeeze_or_expand_dimensions(
    220           y_pred, y_true)
--> 221     return self.fn(y_true, y_pred, **self._fn_kwargs)
    222 
    223   def get_config(self):

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\keras\losses.py in mean_squared_error(y_true, y_pred)
    769   y_pred = ops.convert_to_tensor(y_pred)
    770   y_true = math_ops.cast(y_true, y_pred.dtype)
--> 771   return K.mean(math_ops.squared_difference(y_pred, y_true), axis=-1)
    772 
    773 

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\ops\gen_math_ops.py in squared_difference(x, y, name)
  10037   try:
  10038     _, _, _op, _outputs = _op_def_library._apply_op_helper(
> 10039         "SquaredDifference", x=x, y=y, name=name)
  10040   except (TypeError, ValueError):
  10041     result = _dispatch.dispatch(

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\framework\op_def_library.py in _apply_op_helper(op_type_name, name, **keywords)
    740       op = g._create_op_internal(op_type_name, inputs, dtypes=None,
    741                                  name=scope, input_types=input_types,
--> 742                                  attrs=attr_protos, op_def=op_def)
    743 
    744     # `outputs` is returned as a separate return value so that the output

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\framework\func_graph.py in _create_op_internal(self, op_type, inputs, dtypes, input_types, name, attrs, op_def, compute_device)
    593     return super(FuncGraph, self)._create_op_internal(  # pylint: disable=protected-access
    594         op_type, inputs, dtypes, input_types, name, attrs, op_def,
--> 595         compute_device)
    596 
    597   def capture(self, tensor, name=None, shape=None):

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\framework\ops.py in _create_op_internal(self, op_type, inputs, dtypes, input_types, name, attrs, op_def, compute_device)
   3320           input_types=input_types,
   3321           original_op=self._default_original_op,
-> 3322           op_def=op_def)
   3323       self._create_op_helper(ret, compute_device=compute_device)
   3324     return ret

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\framework\ops.py in __init__(self, node_def, g, inputs, output_types, control_inputs, input_types, original_op, op_def)
   1784           op_def, inputs, node_def.attr)
   1785       self._c_op = _create_c_op(self._graph, node_def, grouped_inputs,
-> 1786                                 control_input_ops)
   1787       name = compat.as_str(node_def.name)
   1788     # pylint: enable=protected-access

C:\ForHDD\Anaconda\envs\CV\lib\site-packages\tensorflow_core\python\framework\ops.py in _create_c_op(graph, node_def, inputs, control_inputs)
   1620   except errors.InvalidArgumentError as e:
   1621     # Convert to ValueError for backwards compatibility.
-> 1622     raise ValueError(str(e))
   1623 
   1624   return c_op

ValueError: Dimensions must be equal, but are 10 and 2 for 'loss/output_1_loss/SquaredDifference' (op: 'SquaredDifference') with input shapes: [8,10], [8,2].

I tried to change loss = keras.losses.MeanSquaredError() to loss = [keras.losses.MeanSquaredError()] and the error keeps the same.

Can someone tell me what I did wrong here? Any suggestion will be appreciated.

Answer 1

I think the problem doesnt have to do with the loss function you use but with the dimensions of the data you use. I see that y_val_np.shape has 2 dimensions (shape[1]), but in the model mlp1 the last layer returns output of 10 dimensions. If this is helpful, and that is what u need to do, i believe changing the dims on the last layer of mlp1 to 2 instead of 10 will solve the problem