Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-05-13· OpenAIAi2 WildChat-4.8M (AI2)

my loss goes to be negative, check and let me know about my mistakes, the loss is cosine…

  1. User

    my loss goes to be negative, check and let me know about my mistakes, the loss is cosine sim.import pandas as pd import numpy as np import tensorflow as tf from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score, roc_auc_score from sklearn.metrics import mean_absolute_error, explained_variance_score import matplotlib.pyplot as plt from sklearn.cross_decomposition import CCA

    Load data

    d1 = pd.read_csv("/zi/home/sajad.rezaei/clip/clip/02_Full_Pipeline/data/psytools/IMAGEN-IMGN_ADRS_CHILD_FU2-IMAGEN_DIGEST.csv") d2 = pd.read_csv("/zi/home/sajad.rezaei/clip/clip/02_Full_Pipeline/data/psytools/IMAGEN-IMGN_ANXDX_CHILD_FU2-IMAGEN_DIGEST.csv") d3 = pd.read_csv("/zi/home/sajad.rezaei/clip/clip/02_Full_Pipeline/data/psytools/IMAGEN-IMGN_AUDIT_CHILD_FU2-IMAGEN_DIGEST.csv") d4 = pd.read_csv("/zi/home/sajad.rezaei/clip/clip/02_Full_Pipeline/data/psytools/IMAGEN-IMGN_BIS_CHILD_FU2-IMAGEN_DIGEST.csv") d5 = pd.read_csv("//zi/home/sajad.rezaei/clip/clip/02_Full_Pipeline/data/psytools/IMAGEN-IMGN_CAPE_CHILD_FU2-IMAGEN_DIGEST.csv") d6 = pd.read_csv("/zi/home/sajad.rezaei/clip/clip/02_Full_Pipeline/data/psytools/IMAGEN-IMGN_CSI_CHILD_FU2-IMAGEN_DIGEST.csv") d7 = pd.read_csv("/zi/home/sajad.rezaei/clip/clip/02_Full_Pipeline/data/psytools/IMAGEN-IMGN_CTQ_CHILD_FU2-IMAGEN_DIGEST.csv") d8 = pd.read_csv("/zi/home/sajad.rezaei/clip/clip/02_Full_Pipeline/data/psytools/IMAGEN-IMGN_EDEQ_CHILD_FU2-IMAGEN_DIGEST.csv") d9= pd.read_csv("/zi/home/sajad.rezaei/clip/clip/02_Full_Pipeline/data/psytools/IMAGEN-IMGN_JVQ_CHILD_FU2-IMAGEN_DIGEST.csv") d10= pd.read_csv("/zi/home/sajad.rezaei/clip/clip/02_Full_Pipeline/data/psytools/IMAGEN-IMGN_TFEQ_CHILD_FU2-IMAGEN_DIGEST.csv") data_df= pd.read_csv('/zi/home/sajad.rezaei/clip/clip/01_scripts/00_Text_processing/00_data/01_IMAGEN/00_data/IMAGEN_FU2.csv')

    Preprocess data

    d7["User code"] = d7["User code"].str.replace("-I", "-C") df_list = [d1, d2, d3, d4, d5, d6, d7, d8, d9, d10]

    In[13]:

    patterns = [ "adrs", "ANXDX", "audit", "BIS", "CAPE42", "item", "CTQ", "EDEQ", "SCID", "IRI", "JVQ", "PAAQ", "RRS", "tci", "TFEQ", "User code" ]

    def process_dataframe(df, patterns, drop_zero_rows=False): df = df[df.columns[df.columns.str.contains('|'.join(patterns))]] df.loc[:,"User code"]= df.loc[:,"User code"].str.replace("-C", "") df.loc[:,"User code"]= df.loc[:,"User code"].str.lstrip("0")

    # Convert all elements to numeric, forcing non-numeric to NaN
    df_numeric = df.apply(pd.to_numeric, errors='coerce')
    
    # Replace NaN values with 0
    df_numeric.fillna(0, inplace=True)
    
    # Replace empty strings with 0
    df_numeric.replace("", 0, inplace=True)
    
    # remove the row with all zeros besiders the first column
    if drop_zero_rows:
        df_numeric = df_numeric.loc[(df_numeric.iloc[:, 1:] != 0).any(axis=1)]
    return df_numeric
    

    df_list_processed = [process_dataframe(df, patterns, drop_zero_rows=True) for df in df_list]

    drop rows with NaN

    df_list_processed = [df.dropna() for df in df_list_processed]

    merge all df on User code

    #merge all df on User code merged_df = df_list_processed[0] for i, df in enumerate(df_list_processed, start=2): merged_df = pd.merge(merged_df, df, on='User code', suffixes=('', f'_df{i}'))

    drop all row of data_df besides the first and the last

    data_df = data_df.drop(data_df.columns[1:-1], axis=1) data_df.rename(columns={'Unnamed: 0': 'User code'}, inplace=True)

    merge the merged_df with data_df

    merged_df = pd.merge(data_df, merged_df, on='User code')

    Pre-process dataframe for TensorFlow

    df = merged_df.drop(columns=['User code', "FilePath"]) non_binary_columns = [col for col in df.columns if len(df[col].unique()) > 2] df = pd.get_dummies(df, columns=non_binary_columns, drop_first=True) df = df.astype(float)

    Split data into train and validation sets

    X_train, X_val = train_test_split(df.values, test_size=0.20, random_state=42)

    Define the Autoencoder model

    class Autoencoder(tf.keras.Model):

    def init(self, input_size):

    super().init()

    self.encoder = tf.keras.Sequential([

    tf.keras.layers.Dense(128, activation="relu", input_shape=(input_size,)),

    tf.keras.layers.BatchNormalization(),

    tf.keras.layers.Dense(64, activation="relu"),

    tf.keras.layers.BatchNormalization(),

    tf.keras.layers.Dense(32, activation="relu"),

    tf.keras.layers.Dense(16, activation="relu")

    ])

    self.decoder = tf.keras.Sequential([

    tf.keras.layers.Dense(32, activation="relu"),

    tf.keras.layers.BatchNormalization(),

    tf.keras.layers.Dense(64, activation="relu"),

    tf.keras.layers.BatchNormalization(),

    tf.keras.layers.Dense(128, activation="relu"),

    tf.keras.layers.Dense(input_size, activation="sigmoid")

    ])

    def call(self, x):

    encoded = self.encoder(x)

    decoded = self.decoder(encoded)

        # return decoded
    

    Define the CNN Autoencoder model

    Define the CNN Autoencoder model

    class Autoencoder(tf.keras.Model): def init(self, input_size): super(Autoencoder, self).init() self.encoder = tf.keras.Sequential([ tf.keras.layers.Input(shape=(input_size, 1 )), tf.keras.layers.Conv1D(128, kernel_size=3, activation="relu", padding="same"), tf.keras.layers.BatchNormalization(), tf.keras.layers.MaxPooling1D(pool_size=3, padding="same"), tf.keras.layers.Conv1D(64, kernel_size=3, activation="relu", padding="same"), tf.keras.layers.BatchNormalization(), tf.keras.layers.MaxPooling1D(pool_size=3), ]) self.decoder = tf.keras.Sequential([ tf.keras.layers.UpSampling1D(size=3), tf.keras.layers.Conv1DTranspose(64, kernel_size=3, activation="relu", padding="same"), tf.keras.layers.BatchNormalization(), tf.keras.layers.UpSampling1D(size=3), tf.keras.layers.Conv1DTranspose(128, kernel_size=3, activation="relu"), tf.keras.layers.BatchNormalization(), tf.keras.layers.ZeroPadding1D(padding=2), # tf.keras.layers.Dense(input_size, activation="sigmoid")

            tf.keras.layers.Conv1D(1, kernel_size=3, activation="sigmoid")
        ])
    
    def call(self, x):
        x = tf.expand_dims(x, axis=-1)  # Add channel dimension
        encoded = self.encoder(x)
        decoded = self.decoder(encoded)
        decoded = tf.squeeze(decoded, axis=-1)  # Remove channel dimension
        return decoded
    

    cos = tf.keras.losses.CosineSimilarity( axis=-1, reduction="none", name="cosine_similarity" )

    Compile and train the model

    cos = tf.keras.losses.MeanSquaredLogarithmicError(

    reduction="sum_over_batch_size", name="mean_squared_logarithmic_error"

    )

    input_size = df.shape[1] autoencoder = Autoencoder(input_size) autoencoder.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.000001), loss=cos)

    early_stopping = tf.keras.callbacks.EarlyStopping(monitor="val_loss", patience=10, restore_best_weights=True)

    history = autoencoder.fit(X_train, X_train, epochs=100, batch_size=512, validation_data=(X_val, X_val), callbacks=[early_stopping])

    Evaluate the model

    train_predictions = autoencoder.predict(X_train) val_predictions = autoencoder.predict(X_val)

    train_mse = np.mean(np.square(train_predictions - X_train)) val_mse = np.mean(np.square(val_predictions - X_val)) train_mae = mean_absolute_error(X_train, train_predictions) val_mae = mean_absolute_error(X_val, val_predictions)

    train_explained_var = explained_variance_score(X_train, train_predictions) val_explained_var = explained_variance_score(X_val, val_predictions)

    print(f"Training MSE: {train_mse:.4f}, Validation MSE: {val_mse:.4f}")

    print(f"Training MSE: {train_mse:.4f}, Validation MSE: {val_mse:.4f}") print(f"Training MAE: {train_mae:.4f}, Validation MAE: {val_mae:.4f}") print(f"Training Explained Variance: {train_explained_var:.4f}, Validation Explained Variance: {val_explained_var:.4f}")

    Compute Canonical Correlations

    cca = CCA(n_components=min(X_train.shape[1], train_predictions.shape[1]))

    num_components = min(X_train.shape[0], train_predictions.shape[0]) cca = CCA(n_components=num_components) cca.fit(X_train, train_predictions) X_train_c, train_predictions_c = cca.transform(X_train, train_predictions)

    Compute the correlation for each pair of canonical variables

    cca_correlations = np.corrcoef(X_train_c.T, train_predictions_c.T)[:X_train_c.shape[1], X_train_c.shape[1]:]

    print("Canonical Correlations:") for i, corr in enumerate(cca_correlations.diagonal()): print(f"Canonical correlation {i+1}: {corr:.4f}")

    Plot loss curves for training and validation

    plt.plot(history.history["loss"], label="Training Loss") plt.plot(history.history["val_loss"], label="Validation Loss") plt.legend() plt.xlabel("Epochs") plt.ylabel("Loss") plt.title("Training and Validation Loss") plt.show()

    Calculate accuracy and AUC if needed

    Note: Since this is an autoencoder, calculating binary accuracy or AUC might not be meaningful in a reconstruction context

  2. Assistant

    When you encounter a negative loss with the CosineSimilarity loss function in TensorFlow, it typically means that the cosine similarity between your predicted values and your true values is high (since CosineSimilarity returns the negative of the cosine similarity, a higher similarity results in a more negative value). However, a negative loss can be non-intuitive because we usually expect losses to be positive. Let’s review your code to identify potential issues:

    Data Preprocessing

    Your preprocessing appears thorough, but let's ensure there are no mistakes:

    1. Make sure that your data contains meaningful information after preprocessing.
    2. Check that there is no issue with merged DataFrames.
    3. Ensure the data is correctly split into training and validation sets.

    Model Definition

    The autoencoder structure appears appropriate, but make sure the input data dimensions match the expected dimensions:

    • Ensure that X_train and X_val have the correct shapes.
    • Double-check padding and upsampling operations to make sure the decoder can reconstruct the input.

    Loss Calculation and Optimization

    You use CosineSimilarity which will return values in [-1, 1]. A few things to consider:

    1. In your compile method, ensure the ordering of arguments.
    2. CosineSimilarity returns high similarity values as negative (closer the vectors, more negative the loss).

    Learning Rate

    The learning rate of 0.000001 may be too low. This might prevent the model from learning effectively.

    Check for Mistakes

    1. Shape of Data: Confirm the shape of X_train and X_val before feeding them into the model.
    2. Scale of the Inputs and Outputs: Ensure that input values are appropriately scaled.
    3. Loss Function: Since you’re using cosine similarity, the training targets should ideally be normalized vectors.

    Here's the modified code including some checks and potential fixes:

    import pandas as pd
    import numpy as np
    import tensorflow as tf
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import mean_absolute_error, explained_variance_score
    import matplotlib.pyplot as plt
    from sklearn.cross_decomposition import CCA
    
    # Load and preprocess data
    # ... (Assume you have done this part correctly)
    
    # Define the CNN Autoencoder model
    class Autoencoder(tf.keras.Model):
        def __init__(self, input_size):
            super(Autoencoder, self).__init__()
            self.encoder = tf.keras.Sequential([
                tf.keras.layers.Input(shape=(input_size, 1)),
                tf.keras.layers.Conv1D(128, kernel_size=3, activation="relu", padding="same"),
                tf.keras.layers.BatchNormalization(),
                tf.keras.layers.MaxPooling1D(pool_size=3, padding="same"),
                tf.keras.layers.Conv1D(64, kernel_size=3, activation="relu", padding="same"),
                tf.keras.layers.BatchNormalization(),
                tf.keras.layers.MaxPooling1D(pool_size=3, padding="same"),
            ])
            self.decoder = tf.keras.Sequential([
                tf.keras.layers.UpSampling1D(size=3),
                tf.keras.layers.Conv1DTranspose(64, kernel_size=3, activation="relu", padding="same"),
                tf.keras.layers.BatchNormalization(),
                tf.keras.layers.UpSampling1D(size=3),
                tf.keras.layers.Conv1DTranspose(128, kernel_size=3, activation="relu", padding="same"),
                tf.keras.layers.BatchNormalization(),
                tf.keras.layers.Conv1D(1, kernel_size=3, activation="sigmoid", padding="same")
            ])
    
        def call(self, x):
            x = tf.expand_dims(x, axis=-1)  # Add the channel dimension
            encoded = self.encoder(x)
            decoded = self.decoder(encoded)
            decoded = tf.squeeze(decoded, axis=-1)  # Remove the channel dimension
            return decoded
    
    # Function to normalize input data to unit vectors (required for cosine similarity)
    def normalize(data):
        norm = np.linalg.norm(data, axis=1, keepdims=True)
        return data / norm
    
    # Normalize your data
    X_train = normalize(X_train)
    X_val = normalize(X_val)
    
    input_size = df.shape[1]
    autoencoder = Autoencoder(input_size)
    autoencoder.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001), loss=cos)  # A higher learning rate
    
    early_stopping = tf.keras.callbacks.EarlyStopping(monitor="val_loss", patience=10, restore_best_weights=True)
    
    history = autoencoder.fit(X_train, X_train,
                              epochs=100,
                              batch_size=512,
                              validation_data=(X_val, X_val),
                              callbacks=[early_stopping])
    
    # Evaluate the model
    train_predictions = autoencoder.predict(X_train)
    val_predictions = autoencoder.predict(X_val)
    
    train_mse = np.mean(np.square(train_predictions - X_train))
    val_mse = np.mean(np.square(val_predictions - X_val))
    train_mae = mean_absolute_error(X_train, train_predictions)
    val_mae = mean_absolute_error(X_val, val_predictions)
    
    train_explained_var = explained_variance_score(X_train, train_predictions)
    val_explained_var = explained_variance_score(X_val, val_predictions)
    
    print(f"Training MSE: {train_mse:.4f}, Validation MSE: {val_mse:.4f}")
    print(f"Training MAE: {train_mae:.4f}, Validation MAE: {val_mae:.4f}")
    print(f"Training Explained Variance: {train_explained_var:.4f}, Validation Explained Variance: {val_explained_var:.4f}")
    
    # Compute Canonical Correlations
    num_components = min(X_train.shape[1], train_predictions.shape[1])
    cca = CCA(n_components=num_components)
    cca.fit(X_train, train_predictions)
    X_train_c, train_predictions_c = cca.transform(X_train, train_predictions)
    
    # Compute the correlation for each pair of canonical variables
    cca_correlations = np.corrcoef(X_train_c.T, train_predictions_c.T)[:X_train_c.shape[1], X_train_c.shape[1]:]
    
    print("Canonical Correlations:")
    for i, corr in enumerate(cca_correlations.diagonal()):
        print(f"Canonical correlation {i+1}: {corr:.4f}")
    
    # Plot loss curves for training and validation
    plt.plot(history.history["loss"], label="Training Loss")
    plt.plot(history.history["val_loss"], label="Validation Loss")
    plt.legend()
    plt.xlabel("Epochs")
    plt.ylabel("Loss")
    plt.title("Training and Validation Loss")
    plt.show()
    

    This version normalizes the input data to unit vectors before training, which is essential when using CosineSimilarity. Also, the learning rate has been increased. You should monitor and adjust these parameters according to your specific dataset and requirements. If you still encounter issues, consider visualizing sample inputs, outputs, and reconstructions to debug further.

  3. User

    i a, still getting the negative loss, is it normal?

  4. Assistant

    Yes, it's perfectly normal to get a negative loss when using the CosineSimilarity loss function in TensorFlow. Here's why:

    The CosineSimilarity loss function measures the cosine of the angle between two vectors. The formula for cosine similarity is:

    [ \text{cosine_similarity} = \frac{\mathbf{A} \cdot \mathbf{B}}{|\mathbf{A}| |\mathbf{B}|} ]

    Which ranges from -1 to 1. TensorFlow's CosineSimilarity loss function actually returns the negative of this value (because lower loss values are considered better):

    [ \text{cosine_similarity_loss} = - \frac{\mathbf{A} \cdot \mathbf{B}}{|\mathbf{A}| |\mathbf{B}|} ]

    Interpretation:

    • If the vectors are perfectly aligned (i.e., they are the same or very similar), the cosine similarity will be close to 1, making the loss close to -1.
    • If the vectors are orthogonal, the cosine similarity will be 0, making the loss close to 0.
    • If the vectors are diametrically opposed, the cosine similarity will be -1, making the loss close to 1.

    Therefore, a more negative loss indicates higher cosine similarity between your predictions and the actual values, which means better performance.

    Summary of Code Review:

    Considering loss values in negative ranges is completely expected behavior for CosineSimilarity.

    Further Steps:

    1. Inspect the Loss History: You may want to inspect the loss history to see if the loss is becoming more negative (indicating training progress).
    2. Evaluation Metrics: Rely on other evaluation metrics such as Mean Squared Error (MSE), Mean Absolute Error (MAE), and Explained Variance Score to judge the model performance:
    # Evaluate the model in terms of reconstruction quality
    train_mae = mean_absolute_error(X_train, train_predictions)
    val_mae = mean_absolute_error(X_val, val_predictions)
    
    train_mse = np.mean(np.square(train_predictions - X_train))
    val_mse = np.mean(np.square(val_predictions - X_val))
    
    train_explained_var = explained_variance_score(X_train, train_predictions)
    val_explained_var = explained_variance_score(X_val, val_predictions)
    
    print(f"Training MSE: {train_mse:.4f}, Validation MSE: {val_mse:.4f}")
    print(f"Training MAE: {train_mae:.4f}, Validation MAE: {val_mae:.4f}")
    print(f"Training Explained Variance: {train_explained_var:.4f}, Validation Explained Variance: {val_explained_var:.4f}")
    

    Detecting if Learning is Occurring:

    Check if the loss (though negative) is improving (i.e., becoming more negative) over epochs. If loss stabilizes or starts to increase, consider:

    • Adjusting the learning rate.
    • Fine-tuning model hyperparameters.

    Visual Loss Progress:

    # Plot loss curves for training and validation
    plt.plot(history.history["loss"], label="Training Loss")
    plt.plot(history.history["val_loss"], label="Validation Loss")
    plt.legend()
    plt.xlabel("Epochs")
    plt.ylabel("Loss")
    plt.title("Training and Validation Loss")
    plt.show()
    

    Even though the loss is negative, if the curve shows a downward trend, this indicates improving cosine similarity between your predictions and the actual values.

    # Calculate and inspect explained variance and other metrics
    print(f"Training MSE: {train_mse:.4f}, Validation MSE: {val_mse:.4f}")
    print(f"Training MAE: {train_mae:.4f}, Validation MAE: {val_mae:.4f}")
    print(f"Training Explained Variance: {train_explained_var:.4f}, Validation Explained Variance: {val_explained_var:.4f}")
    

    If your metrics such as MSE, MAE, and explained variance are showing improvement, it further confirms that the model is learning well.

    Conclusion:

    The negative loss is an expected output for the cosine similarity loss function. Focus on the trend of the loss and complementary evaluation metrics to assess model performance effectively.

  5. User

    is there any other measurements for autoencoders which can be used in this project

  6. Assistant

    Certainly! Besides CosineSimilarity, there are various metrics for evaluating autoencoder performance that focus on the differences between the reconstructed output and the original input data. Here are a few commonly used metrics and loss functions you can consider:

    Loss Functions

    1. Mean Squared Error (MSE): Measures the average of the squares of the errors between predicted and actual values.

      mse = tf.keras.losses.MeanSquaredError()
      
    2. Mean Absolute Error (MAE): Measures the average of the absolute differences between predicted and actual values.

      mae = tf.keras.losses.MeanAbsoluteError()
      
    3. Mean Squared Logarithmic Error (MSLE): Measures the ratio or relative differences between predicted and actual values.

      msle = tf.keras.losses.MeanSquaredLogarithmicError()
      
    4. Huber Loss: A combination of MAE and MSE that's less sensitive to outliers:

      huber = tf.keras.losses.Huber()
      

    Evaluation Metrics

    Besides the loss function used during training, you can calculate additional metrics on the validation set for better evaluation:

    1. Root Mean Squared Error (RMSE):

      train_rmse = np.sqrt(mean_squared_error(X_train, train_predictions))
      val_rmse = np.sqrt(mean_squared_error(X_val, val_predictions))
      
      print(f"Training RMSE: {train_rmse:.4f}, Validation RMSE: {val_rmse:.4f}")
      
    2. R-squared (R2 Score): Measures how well the predicted values approximate the actual data.

      from sklearn.metrics import r2_score
      
      train_r2 = r2_score(X_train, train_predictions)
      val_r2 = r2_score(X_val, val_predictions)
      
      print(f"Training R2: {train_r2:.4f}, Validation R2: {val_r2:.4f}")
      

    Practical Implementation

    You can implement another loss function or evaluation metric for your autoencoder. For example, using MSE as a loss function:

    Model Definition and Compilation:

    # Define the CNN Autoencoder model
    class Autoencoder(tf.keras.Model):
        def __init__(self, input_size):
            super(Autoencoder, self).__init__()
            self.encoder = tf.keras.Sequential([
                tf.keras.layers.Input(shape=(input_size, 1)),
                tf.keras.layers.Conv1D(128, kernel_size=3, activation="relu", padding="same"),
                tf.keras.layers.BatchNormalization(),
                tf.keras.layers.MaxPooling1D(pool_size=3, padding="same"),
                tf.keras.layers.Conv1D(64, kernel_size=3, activation="relu", padding="same"),
                tf.keras.layers.BatchNormalization(),
                tf.keras.layers.MaxPooling1D(pool_size=3, padding="same"),
            ])
            self.decoder = tf.keras.Sequential([
                tf.keras.layers.UpSampling1D(size=3),
                tf.keras.layers.Conv1DTranspose(64, kernel_size=3, activation="relu", padding="same"),
                tf.keras.layers.BatchNormalization(),
                tf.keras.layers.UpSampling1D(size=3),
                tf.keras.layers.Conv1DTranspose(128, kernel_size=3, activation="relu", padding="same"),
                tf.keras.layers.BatchNormalization(),
                tf.keras.layers.Conv1D(1, kernel_size=3, activation="sigmoid", padding="same")
            ])
    
        def call(self, x):
            x = tf.expand_dims(x, axis=-1)  # Add the channel dimension
            encoded = self.encoder(x)
            decoded = self.decoder(encoded)
            decoded = tf.squeeze(decoded, axis=-1)  # Remove the channel dimension
            return decoded
    
    input_size = df.shape[1]
    autoencoder = Autoencoder(input_size)
    autoencoder.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001), loss='mse')  # Using Mean Squared Error loss
    
    early_stopping = tf.keras.callbacks.EarlyStopping(monitor="val_loss", patience=10, restore_best_weights=True)
    
    history = autoencoder.fit(X_train, X_train,
                              epochs=100,
                              batch_size=512,
                              validation_data=(X_val, X_val),
                              callbacks=[early_stopping])
    

    Evaluate the Model

    You can then evaluate the model using additional metrics:

    from sklearn.metrics import mean_squared_error, mean_absolute_error, explained_variance_score, r2_score
    
    train_predictions = autoencoder.predict(X_train)
    val_predictions = autoencoder.predict(X_val)
    
    # Metrics
    train_mse = mean_squared_error(X_train, train_predictions)
    val_mse = mean_squared_error(X_val, val_predictions)
    train_mae = mean_absolute_error(X_train, train_predictions)
    val_mae = mean_absolute_error(X_val, val_predictions)
    train_r2 = r2_score(X_train, train_predictions)
    val_r2 = r2_score(X_val, val_predictions)
    
    print(f"Training MSE: {train_mse:.4f}, Validation MSE: {val_mse:.4f}")
    print(f"Training MAE: {train_mae:.4f}, Validation MAE: {val_mae:.4f}")
    print(f"Training R2: {train_r2:.4f}, Validation R2: {val_r2:.4f}")
    
    # Plot loss curves for training and validation
    plt.plot(history.history["loss"], label="Training Loss")
    plt.plot(history.history["val_loss"], label="Validation Loss")
    plt.legend()
    plt.xlabel("Epochs")
    plt.ylabel("Loss")
    plt.title("Training and Validation Loss")
    plt.show()
    

    Conclusion

    Using additional metrics and evaluating multiple aspects of reconstruction quality can give you a better understanding of your autoencoder's performance. Depending on your specific use case and data characteristics, you might find certain metrics more insightful than others.