Keras自编码器处理[-1,1]范围IQ数据时负损失问题咨询

Let's break down your two core questions and fix the problems you're seeing:

1. Are the Added Dense Layers Correct? Do They Break the Network? #

Adding dense layers to a convolutional autoencoder is totally valid—this is called a hybrid autoencoder, and it's a common approach if you want to inject a more abstract, vectorized representation into the pipeline. However, your current implementation has a couple of critical issues that are likely causing problems:

Problem 1: Misplaced Softmax Layer #

You added a Dense(128, activation='softmax') right before reshaping back to a convolutional feature map. Softmax is designed for multi-class classification: it normalizes outputs to sum to 1, turning them into probability distributions. This is terrible for a feature map that feeds into convolutional decoder layers—convolutions expect continuous feature values, not probabilities. This will distort the signal passed to the decoder and hurt reconstruction performance.

Problem 2: Trying to Force Classification Into the Reconstruction Path #

Your goal is to have the autoencoder learn to classify while reconstructing, but shoving the classification layer into the encoder-decoder flow isn't the right approach. The autoencoder's primary loss is reconstruction (binary crossentropy right now), so the model will prioritize minimizing that loss over learning useful classification features.

Fix for Classification #

Instead, build a multi-output model where you have two separate heads:

• One for reconstructing the input IQ signal
• One for predicting the class label

Here's how to adjust your code:

# Encoder part (keep the conv/pool layers as-is)
input_signal = Input(shape=(28, 28, 2))
x = Conv2D(16, (3, 3), activation='relu', padding='same')(input_signal)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(8, (3, 3), activation='relu', padding='same')(x)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(8, (3, 3), activation='relu', padding='same')(x)
encoded = MaxPooling2D((2, 2), padding='same', name='encoder')(x)

# Flatten for dense layers
encoded_flat = Flatten()(encoded)

# Classification head (separate from decoder)
num_classes = YOUR_CLASS_COUNT  # Replace with your actual number of classes
classification_output = Dense(num_classes, activation='softmax', name='classification')(encoded_flat)

# Decoder part (use the flattened encoded features, no extra dense layers here)
decoder_input = Reshape((4, 4, 8))(encoded_flat)
x = Conv2D(8, (3, 3), activation='relu', padding='same')(decoder_input)
x = UpSampling2D((2, 2))(x)
x = Conv2D(8, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
x = Conv2D(16, (3, 3), activation='relu')(x)
x = UpSampling2D((2, 2))(x)
# Use tanh instead of sigmoid here—your IQ data is [-1,1], tanh outputs match that range
decoded_output = Conv2D(2, (3, 3), activation='tanh', padding='same')(x)

# Build multi-output model
autoencoder = Model(inputs=input_signal, outputs={'decoded': decoded_output, 'classification': classification_output})

# Compile with two losses (adjust weights based on your priority)
autoencoder.compile(optimizer='adam',
                    loss={'decoded': 'mse', 'classification': 'categorical_crossentropy'},
                    loss_weights={'decoded': 1.0, 'classification': 0.5})  # Weight classification lower if reconstruction is more important

# Train with both reconstruction targets and class labels
autoencoder.fit(Xtrain, 
                {'decoded': Xtrain, 'classification': ytrain_one_hot},  # ytrain_one_hot should be one-hot encoded
                epochs=100,
                batch_size=128,
                shuffle=True,
                validation_data=(Xtest, {'decoded': Xtest, 'classification': ytest_one_hot}))

2. Negative Loss & 0 Accuracy on IQ Signal Data #

This is a straightforward issue with your choice of loss function and data normalization:

Why Negative Loss? #

You're using binary_crossentropy, which is designed for inputs in the [0,1] range. The formula for binary crossentropy is:
-y * log(y_pred) - (1 - y) * log(1 - y_pred)
When your IQ data is normalized to [-1,1], y can be -1. Plugging that in:

• -y becomes 1, and log(y_pred) (which is between 0 and 1) is negative—so this term becomes negative
• (1 - y) becomes 2, and log(1 - y_pred) is also negative—this term is also negative
  Adding two negatives gives you a negative loss value, which is meaningless for this task.

Why 0 Accuracy? #

The default binary_accuracy metric compares predictions (sigmoid outputs in [0,1]) to your true values ([-1,1]) using a 0.5 threshold. Since your true values are never in [0,1], almost all predictions will be "wrong," leading to 0 accuracy.

Fixes for IQ Signal Training #

1. Use the right loss function: For reconstructing continuous values in [-1,1], Mean Squared Error (MSE) is a much better choice. It works for any numerical range and measures the average squared difference between predictions and targets.
2. Match output activation to data range: Replace the final sigmoid activation with tanh—tanh outputs values in [-1,1], which exactly matches your normalized IQ data.
3. Don't take absolute values: As you noted, this destroys critical phase information in IQ signals. Keep the data in [-1,1] and adjust your model to match.

Final Quick Tips #

• For the encoder you want to use for classification later, you can create a separate model that outputs the classification_output or the encoded_flat vector, depending on whether you want probabilities or raw features.
• If you don't need to do reconstruction and classification at the same time, you could first train the autoencoder for reconstruction, then freeze the encoder layers and add a classification head on top. This is called transfer learning and can work well if you have limited labeled data.

内容的提问来源于stack exchange，提问作者Randy Vogel