import tensorflow as tf
import numpy as np
import pandas as pd
from tensorflow.keras import layers, Model
from sklearn.preprocessing import StandardScaler

# Generate synthetic tabular data
np.random.seed(42)
n_samples = 10000

# Categorical features
n_cities, n_devices, n_categories, n_dim = 500, 2000, 100, 128

data = {
    'city_id': np.random.randint(0, n_cities, n_samples),
    'device_id': np.random.randint(0, n_devices, n_samples),  
    'category_id': np.random.randint(0, n_categories, n_samples),

    # Numeric features
    'age': np.random.normal(35, 12, n_samples).clip(18, 80),
    'income': np.random.lognormal(10.5, 0.5, n_samples),
    'session_duration': np.random.exponential(300, n_samples),
    'previous_purchases': np.random.poisson(2, n_samples),
    'days_since_signup': np.random.exponential(365, n_samples)
}

df = pd.DataFrame(data)

# Create target variable with realistic relationships
df['target'] = (
    0.3 * (df['age'] > 30) +  
    0.2 * (df['income'] > 50000) +
    0.1 * (df['session_duration'] > 300) +
    0.2 * (df['previous_purchases'] > 1) +
    0.1 * (df['category_id'] < 20) +  # Some categories are more valuable
    np.random.normal(0, 0.3, n_samples)
).clip(0, 1)

# Preprocess numeric features
numeric_features = ['age', 'income', 'session_duration', 'previous_purchases', 'days_since_signup']
scaler = StandardScaler()
df[numeric_features] = scaler.fit_transform(df[numeric_features])

# Split data
train_size = int(0.8 * len(df))
train_df = df[:train_size]
val_df = df[train_size:]

def create_tabular_model(n_cities, n_devices, n_categories, n_numeric_features):
    # Categorical inputs
    city_input = layers.Input(shape=(), dtype=tf.int32, name='city_id')
    device_input = layers.Input(shape=(), dtype=tf.int32, name='device_id')
    category_input = layers.Input(shape=(), dtype=tf.int32, name='category_id')

    # Numeric inputs
    numeric_input = layers.Input(shape=(n_numeric_features,), dtype=tf.float32, name='numeric_features')

    # Embed categorical features with different dimensions based on cardinality
    city_embedding = layers.Embedding(
        input_dim=n_cities,
        output_dim=n_dim,
        name='city_embedding'
    )(city_input)

    device_embedding = layers.Embedding(
        input_dim=n_devices, 
        output_dim=n_dim,
        name='device_embedding'
    )(device_input)

    category_embedding = layers.Embedding(
        input_dim=n_categories,
        output_dim=n_dim,
        name='category_embedding'
    )(category_input)

    # Concatenate all features
    combined_features = layers.Concatenate(name='feature_concat')([
        city_embedding,
        device_embedding, 
        category_embedding,
        numeric_input
    ])

    # Deep neural network
    x = layers.Dense(256, activation='relu')(combined_features)
    x = layers.BatchNormalization()(x)
    x = layers.Dropout(0.3)(x)

    x = layers.Dense(128, activation='relu')(x)
    x = layers.BatchNormalization()(x)
    x = layers.Dropout(0.3)(x)

    x = layers.Dense(64, activation='relu')(x)
    x = layers.Dropout(0.2)(x)

    # Output layer
    output = layers.Dense(1, activation='sigmoid', name='prediction')(x)

    return Model([city_input, device_input, category_input, numeric_input], output)

# Build model
model = create_tabular_model(n_cities, n_devices, n_categories, len(numeric_features))

model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
    loss='binary_crossentropy',
    metrics=['auc', 'precision', 'recall']
)

# Prepare training data
def prepare_inputs(df):
    return {
        'city_id': df['city_id'].values,
        'device_id': df['device_id'].values, 
        'category_id': df['category_id'].values,
        'numeric_features': df[numeric_features].values
    }

train_inputs = prepare_inputs(train_df)
val_inputs = prepare_inputs(val_df)

# Train model
history = model.fit(
    train_inputs, train_df['target'].values,
    validation_data=(val_inputs, val_df['target'].values),
    batch_size=256,
    epochs=50,
)

        __
        __