Creating a predictive models to assess the risk of mortgage clients

alias copyfirst100='copycsv() { mkdir -p "$1/first_100s"; for f in "$1"/*.csv; do head -n 100 "$f" > "$1/first_100s/$(basename "$f")"; done; }; copycsv'


import os
import pandas as pd

# Directory containing the CSV files
directory = '/Users/brettyoung/Desktop/dev_24/kaggle_credit/data/home-credit-credit-risk-model-stability/csv_files/test/first_100s'

# Required columns based on your initial list
required_columns = ['totaldebt_9A', 'overdueamountmax_155A', 'profession_152M', 'pmtaverage_3A', 'maritalst_385M', 'gender_992L','education_1103M',
    'actualdpd_943P', 'amount_1115A', 'annualeffectiverate_63L', 'annuity_780A', 
    'applications30d_658L', 'avgmaxdpdlast9m_3716943P', 'credamount_590A', 
    'currdebt_22A', 'dpdmax_139P', 'numactivecreds_622L'
]

# Dictionary to hold the filenames and their associated matching columns
matched_files = {}

# Iterate through all files in the directory
for filename in os.listdir(directory):
    if filename.endswith('.csv'):  # Check if the file is a CSV file
        file_path = os.path.join(directory, filename)  # Full path of the file
        try:
            # Read only the headers to check the columns
            df = pd.read_csv(file_path, nrows=0)
            # Find any matching required columns in the CSV
            matching_columns = [column for column in required_columns if column in df.columns]
            if matching_columns:  # If there are any matching columns
                matched_files[filename] = matching_columns  # Add filename and matching columns to the dictionary
        except Exception as e:
            print(f"Error reading {filename}: {e}")

# Print out matched files and their associated matches
print("CSV files containing any of the required columns and their associated matches:")
for filename, matches in matched_files.items():
    print(f"{filename}: {matches}")


import pickle

# Assuming combined_sequences and combined_sequences_val are some sort of data structure 
def save_data_to_pickle(data, filename):
    with open(filename, 'wb') as file:
        pickle.dump(data, file)


save_data_to_pickle(combined_sequences, 'combined_sequences.pkl')

# Save combined_sequences_val

def load_data_from_pickle(filename):
    with open(filename, 'rb') as file:
        data = pickle.load(file)
    return data


combined_sequences = load_data_from_pickle('combined_sequences.pkl')

import wandb

# Start a new W&B run
wandb.init(project='my-kaggle-project')
# Log hyperparameters (optional)
wandb.config.learning_rate = 0.01
# Log metrics within your training loop
for epoch in range(10):
    # Replace the following with your actual loss and accuracy calculation
    loss, accuracy = simulate_training(epoch)  # Placeholder function
    # Log metrics to W&B
    wandb.log({"loss": loss, "accuracy": accuracy})


[56, 101, 150] 

class SimpleTransformer(nn.Module):
    def __init__(self, input_dim, model_dim, num_classes, num_heads=2, num_layers=1, dropout=0.1):
        super(SimpleTransformer, self).__init__()
        self.embed = nn.Embedding(input_dim, model_dim)
        encoder_layer = nn.TransformerEncoderLayer(d_model=model_dim, nhead=num_heads, dropout=dropout)
        self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
        self.output_layer = nn.Linear(model_dim, num_classes)
        self.positional_encoding = self.create_positional_encoding(174+1, model_dim)  # Create positional encoding

    def create_positional_encoding(self, max_len, model_dim):
        """Create positional encoding matrix."""
        # Create a matrix that contains the positional encodings for all possible positions
        pe = torch.zeros(max_len, model_dim)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, model_dim, 2).float() * (-math.log(10000.0) / model_dim))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0)  # Add batch dimension for broadcasting
        return pe.cuda()


    def forward(self, x):
        x = self.embed(x)  # Convert token indices to embeddings
        x = x + self.positional_encoding# Add positional encoding to embeddings
        x = self.transformer_encoder(x)
        x = torch.mean(x, dim=1)  # Average pooling
        return self.output_layer(x)