Why is my Keras leap year model predicting biased outputs?

Below is a summary of the two key issues and suggestions for how to address them:

---

1. Incorrect Threshold Conversion in Prediction

Your code converts the sigmoid output into a label with:

PYTHONCopied
prediction_01 = 1 if prediction <= 0.5 else 0

Since the sigmoid output represents the probability of a leap year (1 for leap), the correct conversion should be:

PYTHONCopied
prediction_01 = 1 if prediction > 0.5 else 0

This mistake in the threshold condition is why nearly all predictions are being assigned to one class.

---

2. Difficulty Learning the Leap Year Rule from Raw Years

A neural network that takes the full numerical year as a single feature may have trouble learning the leap year calculation (which involves modulo arithmetic, divisibility by 4, 100, and 400). Here are a couple of suggestions:

• Feature Engineering:
  Instead of feeding the raw year, provide additional features calculated from the year. For example:

  • year % 4
  • year % 100
  • year % 400

  These features directly encode the arithmetic conditions used to decide leap years.

• Normalization/Scaling:
  Even if you decide to keep the raw year values, you may need to scale them (e.g., dividing by 10000) to help the network handle their magnitude. However, note that normalization may not be sufficient if the model is expected to learn a modulo operation without direct hints.

---

Revised Code Example

Below is an updated example implementing the corrected threshold logic and a basic feature engineering approach:

PYTHONCopied
import tensorflow as tf
import numpy as np
import calendar

# ------------------- UTILITY FUNCTIONS -------------------
def is_leap(year):
    """Checks if a year is a leap year."""
    return calendar.isleap(year)

def generate_data(num_samples, feature_engineering=False):
    """
    Generates training data and labels.
    If feature_engineering is True, returns year mod features along with the raw year.
    """
    inputs = []
    outputs = []
    for _ in range(num_samples):
        year = np.random.randint(10000, 20001)
        outputs.append(1 if is_leap(year) else 0)
        
        if feature_engineering:
            # Feature engineering: provide mod operations
            inputs.append([year % 4, year % 100, year % 400])
        else:
            inputs.append([float(year)])  # as a list for consistency (each sample is a vector)

    return np.array(inputs, dtype='float32'), np.array(outputs, dtype='float32')

# ------------------- MODEL CREATION AND TRAINING -------------------
def create_model(input_dim):
    """Creates a sequential Keras model."""
    model = tf.keras.models.Sequential([
        tf.keras.layers.Input(shape=(input_dim,)),
        tf.keras.layers.Dense(128, activation='relu'),
        tf.keras.layers.Dense(64, activation='relu'),
        tf.keras.layers.Dense(1, activation='sigmoid')
    ])
    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
    return model

def train_model(model, inputs, outputs, epochs=20):
    """Trains the model."""
    model.fit(inputs, outputs, epochs=epochs)

# ------------------- MAIN -------------------
if __name__ == "__main__":
    # Use feature_engineering=True to train with mod-4, mod-100, and mod-400 features.
    feature_eng = True  
    num_samples = 10000
    inputs, labels = generate_data(num_samples, feature_engineering=feature_eng)

    # Create and train the model. Adjust the input_dim accordingly.
    input_dim = inputs.shape[1]
    model = create_model(input_dim)
    train_model(model, inputs, labels, epochs=60)

    # Generate test data.
    test_inputs, test_labels = generate_data(100, feature_engineering=feature_eng)
    predictions = model.predict(test_inputs)

    # Prints the results with the corrected threshold condition.
    print("---------- MODEL TEST ----------")
    for i in range(test_inputs.shape[0]):
        prediction = predictions[i][0]
        # Correct thresholding: assign 1 if prediction > 0.5, else 0
        prediction_01 = 1 if prediction > 0.5 else 0
        real = test_labels[i]
        # If using engineered features, print the raw year for reference might require storing it separately.
        print(f"Test sample {i}: Prediction: {prediction:.5f} ({prediction_01}), Real: {real}")

---

Summary

• Threshold Issue: Change the threshold logic to check if the prediction is greater than 0.5 for a positive (leap year) classification.
• Feature Engineering: Since leap year detection depends on mod arithmetic, consider providing additional features such as year % 4, year % 100, and year % 400 to make it easier for the neural network to learn this rule.

These adjustments should help you obtain more sensible prediction values and improve the model's learning process.