{"record":{"id":"cf0b431fae13c4c8","repo":"keras-team/keras","slug":"only-input-tensors-may-be-passed-as-positional-arg","errorCode":null,"errorMessage":"Only input tensors may be passed as positional arguments. The following argument value should be passed as a keyword argument: {arg} (of type {type(arg)})","messagePattern":"Only input tensors may be passed as positional arguments\\. The following argument value should be passed as a keyword argument: (.+?) \\(of type (.+?)\\)","errorType":"validation","errorClass":"ValueError","httpStatus":null,"severity":"error","filePath":"keras/src/layers/layer.py","lineNumber":908,"sourceCode":"                backend.set_keras_mask(y, mask)\n            return y\n\n        # Used to avoid expensive `tree` operations in the most common case.\n        if (\n            kwargs\n            or len(args) != 1\n            or not is_backend_tensor_or_symbolic(args[0], allow_none=False)\n            or backend.standardize_dtype(args[0].dtype) != self.input_dtype\n        ) and self._convert_input_args:\n            args = tree.map_structure(maybe_convert, args)\n            kwargs = tree.map_structure(maybe_convert, kwargs)\n\n        ##########################################################\n        # 2. Enforce that only tensors can be passed positionally.\n        if not self._allow_non_tensor_positional_args:\n            for arg in tree.flatten(args):\n                if not is_backend_tensor_or_symbolic(arg, allow_none=True):\n                    raise ValueError(\n                        \"Only input tensors may be passed as \"\n                        \"positional arguments. The following argument value \"\n                        f\"should be passed as a keyword argument: {arg} \"\n                        f\"(of type {type(arg)})\"\n                    )\n\n        # Caches info about `call()` signature, args, kwargs.\n        call_spec = CallSpec(\n            self._call_signature, self._call_context_args, args, kwargs\n        )\n\n        ############################################\n        # 3. Check input spec for 1st positional arg.\n        # TODO: consider extending this to all args and kwargs.\n        self._assert_input_compatibility(call_spec.first_arg)\n\n        ################\n        # 4. Call build","sourceCodeStart":890,"sourceCodeEnd":926,"githubUrl":"https://github.com/keras-team/keras/blob/7a34a03db60bf60042242d6a556fc3be119046a5/keras/src/layers/layer.py#L890-L926","documentation":"When calling a layer, only backend tensors (or None/symbolic tensors) may be passed as positional arguments; everything else must be a keyword argument. This guard catches e.g. passing an int or a Python object positionally where only inputs belong.","triggerScenarios":"layer(x, training) instead of layer(x, training=training); layer(x, mask, True); custom layers called with config objects positionally when _allow_non_tensor_positional_args is False.","commonSituations":"Converting Keras 2 call signatures where mask was a valid 2nd positional; refactoring call() to accept new non-tensor options; passing Python bools/ints positionally.","solutions":["Pass non-tensor arguments as keywords: layer(x, training=True, mask=m)","If your custom layer legitimately takes non-tensor positionals, set self._allow_non_tensor_positional_args = True in __init__"],"exampleFix":"# before\nout = layer(x, mask)\n# after\nout = layer(x, mask=mask)","handlingStrategy":"validation","validationCode":"assert all(keras.ops.is_tensor(a) for a in tree.flatten(args)), 'pass non-tensors as kwargs'","typeGuard":null,"tryCatchPattern":null,"preventionTips":["Always pass training, mask, and options as keyword arguments","Set _allow_non_tensor_positional_args=True only for layers that genuinely need them"],"tags":["keras","layers","call-arguments","tensor-validation"],"backgroundTag":"positional-argument-type-invalid","analyzedSha":"7a34a03db60bf60042242d6a556fc3be119046a5","analyzedAt":"2026-08-25T21:25:25.994Z","schemaVersion":2},"datasetVersion":"2026-08-26T02:17:13.382Z"}