Prod Publish

.gitattributes

@@ -0,0 +1,37 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,3 @@
+---
+license: mit
+---

app/app.py

@@ -0,0 +1,86 @@
+import os
+import gradio as gr
+import pandas as pd
+import matplotlib.pyplot as plt
+
+base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+orig_data_path = os.path.join(base_dir, 'data', 'orig_processed.parquet')
+combined_data_path = os.path.join(base_dir, 'data', 'final_data.parquet')
+
+orig_df = pd.read_parquet(orig_data_path)
+combined_df = pd.read_parquet(combined_data_path)
+
+for df in [orig_df, combined_df]:
+    if 'Date' in df.columns:
+        df['Date'] = pd.to_datetime(df['Date'])
+
+orig_df = orig_df.sort_values(['Ticker', 'Date']).reset_index(drop=True)
+combined_df = combined_df.sort_values(['Ticker', 'Date']).reset_index(drop=True)
+
+FEATURE_COLS = [c for c in ['Open', 'High', 'Low', 'Close', 'Volume'] if c in orig_df.columns]
+
+def plot_ticker_data(ticker, feature):
+    """
+    Plot last 10 years of time series for selected feature for original and combined datasets.
+    """
+    if feature not in FEATURE_COLS:
+        return f"Feature '{feature}' not found in dataset."
+
+    orig_data = orig_df[orig_df['Ticker'] == ticker].sort_values('Date').reset_index(drop=True)
+    synth_data = combined_df[combined_df['Ticker'] == ticker].sort_values('Date').reset_index(drop=True)
+
+    if orig_data.empty and synth_data.empty:
+        return f"No data found for ticker: {ticker}"
+    if orig_data.empty:
+        return f"No original data found for {ticker}"
+    if synth_data.empty:
+        return f"No combined/synthetic data found for {ticker}"
+
+    latest_date = min(orig_data['Date'].max(), synth_data['Date'].max())
+    cutoff_date = latest_date - pd.DateOffset(years=5)
+
+    orig_data = orig_data[orig_data['Date'] >= cutoff_date]
+    synth_data = synth_data[synth_data['Date'] >= cutoff_date]
+
+    orig_series = orig_data[['Date', feature]].dropna()
+    synth_series = synth_data[['Date', feature]].dropna()
+
+    fig, axes = plt.subplots(2, 1, figsize=(12, 8), sharex=False)
+    fig.suptitle(f"{ticker} — {feature} (Last 10 Years)", fontsize=14)
+
+    axes[0].plot(orig_series['Date'], orig_series[feature], linewidth=1.0, alpha=0.9)
+    axes[0].set_title("Original Data")
+    axes[0].set_ylabel(feature)
+    axes[0].grid(True)
+
+    axes[1].plot(synth_series['Date'], synth_series[feature], linewidth=1.0, alpha=0.9)
+    axes[1].set_title("Synthetic Data")
+    axes[1].set_ylabel(feature)
+    axes[1].grid(True)
+
+    try:
+        min_date = min(orig_series['Date'].min(), synth_series['Date'].min())
+        max_date = max(orig_series['Date'].max(), synth_series['Date'].max())
+        axes[0].set_xlim(min_date, max_date)
+        axes[1].set_xlim(min_date, max_date)
+    except Exception:
+        pass
+
+    plt.tight_layout(rect=[0, 0, 1, 0.96])
+    return fig
+
+unique_tickers = sorted(orig_df['Ticker'].unique())
+
+demo = gr.Interface(
+    fn=plot_ticker_data,
+    inputs=[
+        gr.Dropdown(unique_tickers, label="Select Stock Ticker"),
+        gr.Dropdown(FEATURE_COLS, label="Select Feature (Open/High/Low/Close/Volume)")
+    ],
+    outputs=gr.Plot(label="Time Series Comparison"),
+    title="Real vs Synthetic Time Series Viewer",
+    description="Pick a ticker and feature to view the last 5 years of data from original and synthetic datasets."
+)
+
+if __name__ == "__main__":
+    demo.launch()

data/final_data.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4244f7ab9fa70bfa9aa16a0c03796528c3744f63f5d27d8cfd13ac664646e133
+size 44822597

data/orig_processed.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f2357e122e5ccaeaa0cdc08d0b593e947b72603ff96841ddf33674deec8567f
+size 56514266

models/ae_hyperparameters.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5619bc38b522cbed5839c4f0ab9193e199ceae0fb901d45b5afecaf1fd7806e7
+size 100

models/ae_lstm_autoencoder.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bf07dca9322668dcad0023c8bed0ac604a1bba11bea98ac039e8e1e3afa4650e
+size 289111

models/conditional_gan_metrics.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:07b4ba961a2be1762511554a33e26d2d555799fee7d6bb794966e0e36a7f05b0
+size 12670

models/gan_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:74d6b40cb6c6794bfe64995bfe5639cb2551cce7983c643e49531ef177ab4fe9
+size 261

models/latent_gan_discriminator_conditional.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:666dfd51a80772671418dd2d6dbf36816869b7297349aeb4f878f3539548a099
+size 127690

models/latent_gan_generator_conditional.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f538c56f0ffccb35235a6f9280b2452dc522ced62bf0106d1371c174c389ff6
+size 160022

models/model_combined.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:55baabc1a62fda48e5c3b344bdc9ea74d6e54a8971f8437a55a40ddb8f6cd5b7
+size 31596

models/model_original.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:781876452c9e781bead24a6b4880ecc2e5a4f57407b8b78612c0f85fb961b26e
+size 31596

requirements.txt

@@ -0,0 +1,7 @@
+torch
+pandas
+scikit-learn
+gradio
+matplotlib
+numpy
+pyarrow

src/ae_decoder.py

@@ -0,0 +1,130 @@
+import os
+import sys
+import torch
+import pickle
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from src.model import LSTMAutoEncoder
+
+
+def decode_latent_vectors(
+    model_path,
+    synthetic_latent_path,
+    ticker_map_path,
+    output_path,
+    model_params,
+    seq_len=90,
+    device=None
+):
+    """
+    Decode latent vectors back into OHLCV sequences using the trained LSTM Autoencoder.
+    """
+
+    device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+
+    model = LSTMAutoEncoder(
+        input_dim=5,
+        num_tickers=model_params["num_tickers"],
+        embed_dim=model_params["embed_dim"],
+        hidden_size=model_params["hidden_size"],
+        latent_dim=model_params["latent_dim"],
+        num_layers=model_params["num_layers"]
+    ).to(device)
+
+    model.load_state_dict(torch.load(model_path, map_location=device))
+    model.eval()
+    print(f"Loaded trained LSTM Autoencoder from {model_path}")
+
+    latent_vectors = np.load(synthetic_latent_path)
+    ticker_ids_path = synthetic_latent_path.replace("latent_vectors", "latent_tickers")
+
+    if not os.path.exists(ticker_ids_path):
+        raise FileNotFoundError(f"Ticker mapping not found at {ticker_ids_path}")
+
+    ticker_ids = np.load(ticker_ids_path)
+
+    latent_t = torch.tensor(latent_vectors, dtype=torch.float32).to(device)
+    ticker_t = torch.tensor(ticker_ids, dtype=torch.long).to(device)
+
+    decoded_batches = []
+    batch_size = 128
+
+    for i in tqdm(range(0, len(latent_t), batch_size), desc="Decoding latent sequences"):
+        batch_latent = latent_t[i:i + batch_size]
+        batch_ticker = ticker_t[i:i + batch_size]
+
+        with torch.no_grad():
+            ticker_emb = model.ticker_embed(batch_ticker)
+            latent_cat = torch.cat([batch_latent, ticker_emb], dim=1)
+            latent_cat = latent_cat.unsqueeze(1).repeat(1, seq_len, 1)
+            dec_input = model.fc_dec(latent_cat)
+            reconstructed, _ = model.decoder(dec_input)
+
+        decoded_batches.append(reconstructed.cpu().numpy())
+
+    decoded = np.concatenate(decoded_batches, axis=0)
+    print(f"Decoded {decoded.shape[0]} sequences of length {seq_len}")
+
+    with open(ticker_map_path, "rb") as f:
+        label_encoder = pickle.load(f)
+
+    if hasattr(label_encoder, "inverse_transform"):
+        tickers = label_encoder.inverse_transform(ticker_ids)
+    elif isinstance(label_encoder, (np.ndarray, list)):
+        tickers = np.array(label_encoder)[ticker_ids]
+    elif isinstance(label_encoder, dict):
+        tickers = [label_encoder[int(i)] for i in ticker_ids]
+    else:
+        raise TypeError(f"Unrecognized ticker mapping format: {type(label_encoder)}")
+
+
+    records = []
+    for i in range(len(decoded)):
+        ticker = tickers[i]
+        for t in range(seq_len):
+            o, h, l, c, v = decoded[i, t]
+            records.append({
+                "Ticker": ticker,
+                "Ticker_Encoded": int(ticker_ids[i]),
+                "TimeStep": t,
+                "Open": o,
+                "High": h,
+                "Low": l,
+                "Close": c,
+                "Volume": v
+            })
+
+    decoded_df = pd.DataFrame(records)
+    decoded_df.to_parquet(output_path, index=False)
+    print(f"Decoded OHLCV data saved to {output_path}")
+
+    return decoded_df
+
+
+if __name__ == "__main__":
+    base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    model_path = os.path.join(base_dir, "models", "lstm_autoencoder.pth")
+    synthetic_latent_path = os.path.join(base_dir, "data", "latent", "synthetic_latent_vectors.npy")
+    ticker_map_path = os.path.join(base_dir, "data", "processed", "ticker_label_encoder.pkl")
+    output_path = os.path.join(base_dir, "data", "processed", "decoded_synthetic_ohlcv.parquet")
+
+    model_params = {
+        "num_layers": 2,
+        "hidden_size": 64,
+        "latent_dim": 32,
+        "embed_dim": 16,
+        "num_tickers": 503
+    }
+
+    decode_latent_vectors(
+        model_path=model_path,
+        synthetic_latent_path=synthetic_latent_path,
+        ticker_map_path=ticker_map_path,
+        output_path=output_path,
+        model_params=model_params,
+        seq_len=90
+    )

src/ae_evaluate.py

@@ -0,0 +1,76 @@
+import os
+import sys
+import torch
+import json
+import numpy as np
+import pandas as pd
+from torch.utils.data import DataLoader
+from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
+import matplotlib.pyplot as plt
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from src.model import QuarterlyStockDataset, LSTMAutoEncoder  # uses updated version with embeddings
+
+if __name__ == "__main__":
+    base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    processed_data_path = os.path.join(base_dir, 'data', 'processed', 'stock_data.parquet')
+    model_path = os.path.join(base_dir, 'models', 'lstm_autoencoder.pth')
+    metrics_path = os.path.join(base_dir, 'resources', 'metrics.json')
+
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    df = pd.read_parquet(processed_data_path)
+
+    test_df = df[df['Date'] >= '2024-01-01']
+
+    sequence_length = 90
+    test_dataset = QuarterlyStockDataset(test_df, sequence_length=sequence_length)
+    test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)
+
+    best_params = {
+        'hidden_size': 64,
+        'latent_dim': 32,
+        'num_layers': 2,
+        'embed_dim': 16   
+    }
+
+    num_tickers = df['Ticker_Encoded'].nunique()
+
+    model = LSTMAutoEncoder(
+        input_dim=5,
+        num_tickers=num_tickers,
+        embed_dim=best_params['embed_dim'],
+        hidden_size=best_params['hidden_size'],
+        latent_dim=best_params['latent_dim'],
+        num_layers=best_params['num_layers']
+    ).to(device)
+
+    model.load_state_dict(torch.load(model_path, map_location=device))
+    model.eval()
+
+    all_actual, all_recon = [], []
+
+    with torch.no_grad():
+        for batch_x, batch_ticker in test_loader:
+            batch_x, batch_ticker = batch_x.to(device), batch_ticker.to(device)
+            recon = model(batch_x, batch_ticker)
+            all_actual.append(batch_x.cpu().numpy())
+            all_recon.append(recon.cpu().numpy())
+    X_test = np.concatenate(all_actual, axis=0)
+    X_recon = np.concatenate(all_recon, axis=0)
+    X_test_flat = X_test.reshape(-1, X_test.shape[-1])
+    X_recon_flat = X_recon.reshape(-1, X_recon.shape[-1])
+
+    mae = mean_absolute_error(X_test_flat, X_recon_flat)
+    rmse = np.sqrt(mean_squared_error(X_test_flat, X_recon_flat))
+    r2 = r2_score(X_test_flat, X_recon_flat)
+
+    metrics = {
+        "MAE": float(mae),
+        "RMSE": float(rmse),
+        "R2": float(r2)
+    }
+
+    with open(metrics_path, 'w') as f:
+        json.dump(metrics, f, indent=4)
+    print(f"✅ Test metrics saved at: {metrics_path}")

src/ae_latent_extract.py

@@ -0,0 +1,84 @@
+import os
+import sys
+import torch
+import pandas as pd
+import numpy as np
+from torch.utils.data import DataLoader
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from src.model import LSTMAutoEncoder, QuarterlyStockDataset  # pylint: disable=import-error
+from src.logger import get_logger
+
+logger = get_logger(__name__)
+
+if __name__ == "__main__":
+    try:
+        base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        processed_data_path = os.path.join(base_dir, "data", "processed", "stock_data.parquet")
+        model_path = os.path.join(base_dir, "models", "lstm_autoencoder.pth")
+        latent_vectors_path = os.path.join(base_dir, "..", "GAN", "data", "processed", "latent_vectors.npy")
+        ticker_mapping_path = os.path.join(base_dir, "..", "GAN", "data", "processed", "ticker_mapping.npy")
+
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        df = pd.read_parquet(processed_data_path)
+        tickers = df["Ticker"].unique()
+        num_tickers = df["Ticker_Encoded"].nunique()
+
+        model = LSTMAutoEncoder(
+            input_dim=5,
+            num_tickers=num_tickers,
+            embed_dim=16,
+            hidden_size=64,
+            latent_dim=32,
+            num_layers=2
+        ).to(device)
+
+        model.load_state_dict(torch.load(model_path, map_location=device))
+        model.eval()
+
+        def encode(model, x, ticker_id):
+            ticker_emb = model.ticker_embed(ticker_id).unsqueeze(1).repeat(1, x.size(1), 1)
+            x_in = torch.cat([x, ticker_emb], dim=2)
+            enc_out, _ = model.encoder(x_in)
+            latent = model.fc_enc(enc_out[:, -1, :])
+            return latent
+
+        all_latents = []
+        all_tickers = []
+
+        for ticker in tickers:
+            ticker_df = df[df["Ticker"] == ticker].copy()
+            if len(ticker_df) < 90:
+                continue
+
+            dataset = QuarterlyStockDataset(ticker_df, sequence_length=90)
+            loader = DataLoader(dataset, batch_size=64, shuffle=False)
+
+            ticker_latents = []
+
+            with torch.no_grad():
+                for batch_x, batch_ticker in loader:
+                    batch_x, batch_ticker = batch_x.to(device), batch_ticker.to(device)
+                    latent = encode(model, batch_x, batch_ticker)
+                    ticker_latents.append(latent.cpu().numpy())
+
+            if ticker_latents:
+                ticker_latents = np.concatenate(ticker_latents, axis=0)
+                all_latents.append(ticker_latents)
+                all_tickers.extend([ticker] * len(ticker_latents))
+                logger.info(f"Extracted {len(ticker_latents)} latent vectors for {ticker}.")
+
+        all_latents = np.concatenate(all_latents, axis=0)
+        all_tickers = np.array(all_tickers)
+
+        np.save(latent_vectors_path, all_latents)
+        np.save(ticker_mapping_path, all_tickers)
+
+        logger.info(f"Saved {len(all_latents)} latent vectors to {latent_vectors_path}")
+        logger.info(f"Saved ticker mapping to {ticker_mapping_path}")
+
+    except Exception as e:
+        logger.error("Error extracting latent space vectors: %s", e)
+        raise

src/ae_model.py

@@ -0,0 +1,190 @@
+import os
+import sys
+import json
+import optuna
+import warnings
+import torch
+import torch.nn as nn
+import pandas as pd
+from torch.utils.data import Dataset, DataLoader
+
+warnings.simplefilter(action='ignore', category=FutureWarning)
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from src.logger import get_logger  # pylint: disable=import-error
+logger = get_logger(__name__)
+
+class QuarterlyStockDataset(Dataset):
+    def __init__(self, df, sequence_length=90):
+        try:
+            self.sequence_length = sequence_length
+            self.samples = []
+
+            df = df.sort_values(by=["Ticker", "Date"]).reset_index(drop=True)
+            tickers = df['Ticker'].unique()
+            feature_cols = ['Open', 'High', 'Low', 'Close', 'Volume']
+
+            for ticker in tickers:
+                ticker_df = df[df['Ticker'] == ticker]
+                data = ticker_df[feature_cols].values
+                ticker_id = ticker_df['Ticker_Encoded'].iloc[0] 
+
+                for i in range(0, len(data) - sequence_length + 1, sequence_length):
+                    window = data[i:i+sequence_length]
+                    self.samples.append((torch.tensor(window, dtype=torch.float32),
+                                         torch.tensor(ticker_id, dtype=torch.long)))
+
+            print(f"Created {len(self.samples)} quarterly sequences across {len(tickers)} tickers.")
+        except Exception as e:
+            logger.error("Error batching dataset: %s", e)
+            raise
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        return self.samples[idx]
+
+
+class LSTMAutoEncoder(nn.Module):
+    def __init__(self, input_dim, num_tickers, embed_dim=8, hidden_size=64, latent_dim=16, num_layers=1):
+        super(LSTMAutoEncoder, self).__init__()
+        self.ticker_embed = nn.Embedding(num_tickers, embed_dim)
+
+        # Encoder
+        self.encoder = nn.LSTM(input_dim + embed_dim, hidden_size, num_layers=num_layers, batch_first=True)
+        self.fc_enc = nn.Linear(hidden_size, latent_dim)
+
+        # Decoder
+        self.fc_dec = nn.Linear(latent_dim + embed_dim, hidden_size)
+        self.decoder = nn.LSTM(hidden_size, input_dim, num_layers=num_layers, batch_first=True)
+
+    def forward(self, x, ticker_id):
+        ticker_emb = self.ticker_embed(ticker_id).unsqueeze(1).repeat(1, x.size(1), 1)
+
+        x_in = torch.cat([x, ticker_emb], dim=2)
+
+        # Encoder
+        enc_out, (h, c) = self.encoder(x_in)
+        latent = self.fc_enc(enc_out[:, -1, :]) 
+
+        latent_cat = torch.cat([latent, self.ticker_embed(ticker_id)], dim=1)
+        latent_cat = latent_cat.unsqueeze(1).repeat(1, x.size(1), 1)
+
+        # Decoder
+        dec_input = self.fc_dec(latent_cat)
+        out_dec, _ = self.decoder(dec_input)
+        return out_dec
+
+def objective(trial, df, sequence_length=90, device='cpu'):
+    try:
+        num_layers = trial.suggest_int("num_layers", 1, 3)
+        hidden_size = trial.suggest_categorical("hidden_size", [32, 64, 128])
+        latent_dim = trial.suggest_categorical("latent_dim", [8, 16, 32])
+        lr = trial.suggest_loguniform("lr", 1e-4, 1e-2)
+        embed_dim = trial.suggest_categorical("embed_dim", [4, 8, 16])
+
+        train_df = df[df['Date'] < '2023-01-01']
+        val_df = df[(df['Date'] >= '2023-01-01') & (df['Date'] < '2024-01-01')]
+
+        train_dataset = QuarterlyStockDataset(train_df, sequence_length)
+        val_dataset = QuarterlyStockDataset(val_df, sequence_length)
+
+        train_loader = DataLoader(train_dataset, batch_size=64, shuffle=False)
+        val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False)
+
+        num_tickers = df['Ticker_Encoded'].nunique()
+        model = LSTMAutoEncoder(
+            input_dim=5, num_tickers=num_tickers, embed_dim=embed_dim,
+            hidden_size=hidden_size, latent_dim=latent_dim, num_layers=num_layers
+        ).to(device)
+
+        criterion = nn.MSELoss()
+        optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+
+        epochs = 20
+        for epoch in range(epochs):
+            model.train()
+            total_train_loss = 0
+            for batch_x, batch_ticker in train_loader:
+                batch_x, batch_ticker = batch_x.to(device), batch_ticker.to(device)
+                optimizer.zero_grad()
+                recon = model(batch_x, batch_ticker)
+                loss = criterion(recon, batch_x)
+                loss.backward()
+                optimizer.step()
+                total_train_loss += loss.item()
+
+            model.eval()
+            total_val_loss = 0
+            with torch.no_grad():
+                for batch_x, batch_ticker in val_loader:
+                    batch_x, batch_ticker = batch_x.to(device), batch_ticker.to(device)
+                    recon = model(batch_x, batch_ticker)
+                    loss = criterion(recon, batch_x)
+                    total_val_loss += loss.item()
+
+        avg_val_loss = total_val_loss / len(val_loader)
+        return avg_val_loss
+    except Exception as e:
+        logger.error("Error training Model : %s", e)
+        raise
+
+if __name__ == "__main__":
+    base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    processed_data_path = os.path.join(base_dir, 'data', 'processed', 'stock_data.parquet')
+    model_path = os.path.join(base_dir, 'models', 'lstm_autoencoder.pth')
+    loss_path = os.path.join(base_dir, 'resources', 'loss_values.json')
+    hyperparams_path = os.path.join(base_dir, 'models', 'hyperparameters.json')
+
+    df = pd.read_parquet(processed_data_path)
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+    study = optuna.create_study(direction="minimize")
+    study.optimize(lambda trial: objective(trial, df, device=device), n_trials=10)
+
+    best_trial = study.best_trial
+    best_params = best_trial.params
+
+    train_df = df[df['Date'] < '2024-01-01']
+    full_dataset = QuarterlyStockDataset(train_df, sequence_length=90)
+    full_loader = DataLoader(full_dataset, batch_size=64, shuffle=False)
+
+    num_tickers = df['Ticker_Encoded'].nunique()
+    best_model = LSTMAutoEncoder(
+        input_dim=5,
+        num_tickers=num_tickers,
+        embed_dim=best_params.get('embed_dim', 8),
+        hidden_size=best_params['hidden_size'],
+        latent_dim=best_params['latent_dim'],
+        num_layers=best_params['num_layers']
+    ).to(device)
+
+    criterion = nn.MSELoss()
+    optimizer = torch.optim.Adam(best_model.parameters(), lr=best_params['lr'])
+
+    epochs = 50
+    train_losses = []
+    for epoch in range(epochs):
+        best_model.train()
+        total_loss = 0
+        for batch_x, batch_ticker in full_loader:
+            batch_x, batch_ticker = batch_x.to(device), batch_ticker.to(device)
+            optimizer.zero_grad()
+            recon = best_model(batch_x, batch_ticker)
+            loss = criterion(recon, batch_x)
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+        avg_loss = total_loss / len(full_loader)
+        train_losses.append(avg_loss)
+        print(f"Epoch [{epoch+1}/{epochs}] Loss: {avg_loss:.6f}")
+
+    torch.save(best_model.state_dict(), model_path)
+    with open(loss_path, 'w') as f:
+        json.dump(train_losses, f)
+    with open(hyperparams_path, 'w') as f:
+        json.dump(best_params, f)
+
+    print(f"Model, losses, and hyperparameters saved successfully.")

src/gan_evaluate.py

@@ -0,0 +1,106 @@
+import os
+import sys
+import json
+import torch
+import numpy as np
+import pandas as pd
+from scipy.stats import ks_2samp
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from src.model import ConditionalGenerator 
+
+base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+processed_data_path = os.path.join(base_dir, "data", "processed", "stock_data.parquet")
+latent_dir = os.path.join(base_dir, "data","processed")
+resources_dir = os.path.join(base_dir, "resources")
+models_dir = os.path.join(base_dir, "models")
+
+latent_path = os.path.join(latent_dir, "latent_vectors.npy")
+tickers_path = os.path.join(latent_dir, "sequence_tickers.npy")
+label_encoder_path = os.path.join(base_dir, "data", "processed", "ticker_label_encoder.pkl")
+gen_path = os.path.join(models_dir, "latent_gan_generator_conditional.pth")
+gan_config_path = os.path.join(resources_dir, "gan_config.json")
+
+with open(gan_config_path, "r") as f:
+    params = json.load(f)
+
+noise_dim = params["noise_dim"]
+latent_dim = params["latent_dim"]
+hidden_dim = params["hidden_dim"]
+embed_dim = params.get("embed_dim", 8) 
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+import joblib
+label_encoder = joblib.load(label_encoder_path)
+num_tickers = len(label_encoder.classes_)
+
+G = ConditionalGenerator(
+    noise_dim=noise_dim,
+    latent_dim=latent_dim,
+    embed_dim=embed_dim,
+    num_tickers=num_tickers,
+    hidden_dim=hidden_dim
+).to(device)
+
+G.load_state_dict(torch.load(gen_path, map_location=device))
+G.eval()
+print(f"Loaded conditional generator (latent_dim={latent_dim}, embed_dim={embed_dim})")
+
+real_latent = np.load(latent_path)
+N_SAMPLES = real_latent.shape[0]
+batch_size = 512
+
+ticker_ids = np.random.randint(0, num_tickers, N_SAMPLES)
+samples = []
+
+for i in tqdm(range((N_SAMPLES + batch_size - 1) // batch_size), desc="Generating synthetic latents"):
+    b = min(batch_size, N_SAMPLES - i * batch_size)
+    z = torch.randn(b, noise_dim).to(device)
+    tickers_batch = torch.tensor(ticker_ids[i * batch_size: i * batch_size + b], dtype=torch.long).to(device)
+    out = G(z, tickers_batch).detach().cpu().numpy()
+    samples.append(out)
+
+synth_latent = np.vstack(samples)
+np.save(os.path.join(latent_dir, "synthetic_latent_vectors.npy"), synth_latent)
+np.save(os.path.join(latent_dir, "synthetic_latent_tickers.npy"), ticker_ids)
+
+print(f"Saved synthetic latent vectors to {latent_dir}")
+
+metrics = {"per_dimension": {}, "correlation": {}}
+min_dim = min(real_latent.shape[1], synth_latent.shape[1])
+real_latent = real_latent[:, :min_dim]
+synth_latent = synth_latent[:, :min_dim]
+
+for i in range(min_dim):
+    r = real_latent[:, i]
+    s = synth_latent[:, i]
+    min_n = min(len(r), len(s))
+    ks_stat, ks_p = ks_2samp(
+        np.random.choice(r, min_n, replace=False),
+        np.random.choice(s, min_n, replace=False)
+    )
+    metrics["per_dimension"][f"latent_{i}"] = {
+        "real_mean": float(r.mean()),
+        "synth_mean": float(s.mean()),
+        "mean_diff": float(s.mean() - r.mean()),
+        "real_std": float(r.std()),
+        "synth_std": float(s.std()),
+        "std_diff": float(s.std() - r.std()),
+        "ks_stat": float(ks_stat),
+        "ks_pvalue": float(ks_p),
+    }
+
+real_corr = np.corrcoef(real_latent, rowvar=False)
+synth_corr = np.corrcoef(synth_latent, rowvar=False)
+metrics["correlation"]["frobenius_diff"] = float(np.linalg.norm(real_corr - synth_corr, ord='fro'))
+
+# Save metrics
+METRICS_JSON = os.path.join(resources_dir, "conditional_gan_metrics.json")
+with open(METRICS_JSON, "w") as f:
+    json.dump(metrics, f, indent=4)
+
+print(f"Evaluation metrics saved to: {METRICS_JSON}")

src/gan_generate_synthetic_latent.py

@@ -0,0 +1,94 @@
+import os
+import sys
+import json
+import torch
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+import logging
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+try:
+    from src.logger import get_logger
+    logger = get_logger(__name__)
+except Exception:
+    logging.basicConfig(level=logging.INFO)
+    logger = logging.getLogger(__name__)
+
+from src.model import ConditionalGenerator
+
+
+if __name__ == "__main__":
+    try:
+        base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        models_dir = os.path.join(base_dir, "models")
+        resources_dir = os.path.join(base_dir, "resources")
+        data_dir = os.path.join(base_dir, "data", "processed")
+
+        model_path = os.path.join(models_dir, "latent_gan_generator_conditional.pth")
+        config_path = os.path.join(resources_dir, "gan_config.json")
+        latent_path = os.path.join(data_dir, "latent_vectors.npy")
+        ticker_path = os.path.join(data_dir, "sequence_tickers.npy")
+
+        output_latent_path = os.path.join(data_dir, "synthetic_latent_vectors.npy")
+        output_ticker_path = os.path.join(data_dir, "synthetic_ticker_mapping.npy")
+
+        real_latent = np.load(latent_path)
+        tickers = np.load(ticker_path)
+        n_samples = real_latent.shape[0]
+
+        logger.info(f"Loaded {n_samples} real latent vectors with shape {real_latent.shape}")
+        logger.info(f"Loaded ticker mapping shape: {tickers.shape}")
+
+        with open(config_path, "r") as f:
+            config = json.load(f)
+            
+        noise_dim = config["noise_dim"]
+        latent_dim = config["latent_dim"]
+        hidden_dim = config["hidden_dim"]
+        embed_dim = config["embed_dim"]
+        num_tickers = config["num_tickers"]
+
+        tickers = np.load(ticker_path)
+        n_samples = tickers.shape[0]
+
+        logger.info(f"Loaded {n_samples} tickers for conditional generation")
+
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        G = ConditionalGenerator(noise_dim, latent_dim, hidden_dim, num_tickers, embed_dim).to(device)
+        G.load_state_dict(torch.load(model_path, map_location=device))
+        G.eval()
+
+        logger.info(
+            f"Loaded Conditional WGAN-GP Generator "
+            f"(noise_dim={noise_dim}, latent_dim={latent_dim}, num_tickers={num_tickers})"
+        )
+
+        batch_size = 512
+        synthetic_latents = []
+        synthetic_tickers = []
+
+        for i in tqdm(range((n_samples + batch_size - 1) // batch_size), desc="Generating synthetic latent vectors"):
+            b = min(batch_size, n_samples - i * batch_size)
+            z = torch.randn(b, noise_dim).to(device)
+            ticker_batch = torch.tensor(tickers[i * batch_size:i * batch_size + b], dtype=torch.long).to(device)
+
+            with torch.no_grad():
+                fake_latent = G(z, ticker_batch).cpu().numpy()
+
+            synthetic_latents.append(fake_latent)
+            synthetic_tickers.append(ticker_batch.cpu().numpy())
+
+        synth_latent = np.vstack(synthetic_latents)
+        synth_tickers = np.concatenate(synthetic_tickers)
+
+        np.save(output_latent_path, synth_latent)
+        np.save(output_ticker_path, synth_tickers)
+
+        logger.info(f"Saved synthetic latent vectors: {output_latent_path} — shape {synth_latent.shape}")
+        logger.info(f"Saved synthetic ticker mapping: {output_ticker_path} — shape {synth_tickers.shape}")
+
+    except Exception as e:
+        logger.error("Error generating synthetic latent vectors: %s", e)
+        raise

src/gan_model.py

@@ -0,0 +1,214 @@
+# conditional_wgangp_train.py
+import os
+import sys
+import json
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+from sklearn.preprocessing import StandardScaler
+from torch.utils.data import Dataset, DataLoader
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+try:
+    from src.logger import get_logger
+    logger = get_logger(__name__)
+except Exception:
+    import logging
+    logging.basicConfig(level=logging.INFO)
+    logger = logging.getLogger(__name__)
+
+class LatentTickerDataset(Dataset):
+    def __init__(self, latent_path, ticker_path):
+        self.latents = np.load(latent_path)
+        self.tickers = np.load(ticker_path)
+        assert self.latents.shape[0] == self.tickers.shape[0], "Latents and tickers length mismatch"
+
+    def __len__(self):
+        return self.latents.shape[0]
+
+    def __getitem__(self, idx):
+        x = self.latents[idx].astype(np.float32)
+        y = int(self.tickers[idx])
+        return x, y
+
+class ConditionalGenerator(nn.Module):
+    def __init__(self, noise_dim, embed_dim, num_tickers, latent_dim, hidden_dim=128):
+        super().__init__()
+        self.ticker_emb = nn.Embedding(num_tickers, embed_dim)
+        input_dim = noise_dim + embed_dim
+        self.net = nn.Sequential(
+            nn.Linear(input_dim, hidden_dim),
+            nn.LeakyReLU(0.2),
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.LeakyReLU(0.2),
+            nn.Linear(hidden_dim, latent_dim)
+        )
+
+    def forward(self, z, ticker_ids):
+        emb = self.ticker_emb(ticker_ids) 
+        x = torch.cat([z, emb], dim=1)
+        return self.net(x)
+
+class ConditionalDiscriminator(nn.Module):
+    def __init__(self, latent_dim, embed_dim, num_tickers, hidden_dim=128):
+        super().__init__()
+        self.ticker_emb = nn.Embedding(num_tickers, embed_dim)
+        input_dim = latent_dim + embed_dim
+        self.net = nn.Sequential(
+            nn.Linear(input_dim, hidden_dim),
+            nn.LeakyReLU(0.2),
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.LeakyReLU(0.2),
+            nn.Linear(hidden_dim, 1)
+        )
+
+    def forward(self, x, ticker_ids):
+        emb = self.ticker_emb(ticker_ids)
+        x_cat = torch.cat([x, emb], dim=1)
+        return self.net(x_cat)
+
+def gradient_penalty_cond(D, real, fake, ticker_ids, device):
+    """Compute gradient penalty for conditional discriminator D(x, ticker_ids)."""
+    batch_size = real.size(0)
+    alpha = torch.rand(batch_size, 1).to(device)
+    interpolates = (alpha * real + (1 - alpha) * fake).requires_grad_(True)
+    d_interpolates = D(interpolates, ticker_ids)
+    grad_outputs = torch.ones_like(d_interpolates).to(device)
+    gradients = torch.autograd.grad(
+        outputs=d_interpolates,
+        inputs=interpolates,
+        grad_outputs=grad_outputs,
+        create_graph=True,
+        retain_graph=True,
+        only_inputs=True
+    )[0]
+    gradients = gradients.view(batch_size, -1)
+    gp = ((gradients.norm(2, dim=1) - 1) ** 2).mean()
+    return gp
+
+if __name__ == "__main__":
+    base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    latent_path = os.path.join(base_dir, "data", "processed", "latent_vectors.npy")
+    ticker_path = os.path.join(base_dir, "data", "processed", "sequence_tickers.npy")
+    models_dir = os.path.join(base_dir, "models")
+    resources_dir = os.path.join(base_dir, "resources")
+    os.makedirs(models_dir, exist_ok=True)
+    os.makedirs(resources_dir, exist_ok=True)
+
+    logger.info("Loading latent vectors from: %s", latent_path)
+    latent_vectors = np.load(latent_path)
+    logger.info("Loaded latent vectors shape: %s", latent_vectors.shape)
+
+    logger.info("Loading sequence ticker IDs from: %s", ticker_path)
+    sequence_tickers = np.load(ticker_path)
+    logger.info("Loaded ticker IDs shape: %s", sequence_tickers.shape)
+
+    scaler = StandardScaler()
+    latent_scaled = scaler.fit_transform(latent_vectors)
+    scaler_save = {"mean": scaler.mean_.tolist(), "scale": scaler.scale_.tolist()}
+    np.save(os.path.join(resources_dir, "latent_scaler.npy"), scaler_save)
+    logger.info("Saved latent scaler params to resources.")
+
+    dataset = LatentTickerDataset(latent_path, ticker_path)
+    dataset.latents = latent_scaled 
+    batch_size = 256
+    loader = DataLoader(dataset, batch_size=batch_size, shuffle=False, drop_last=True, num_workers=2)
+
+    noise_dim = 64
+    hidden_dim = 128
+    n_epochs = 300
+    lr = 1e-4
+    lambda_gp = 10
+    n_critic = 5
+    embed_dim = 16 
+
+    latent_dim = latent_scaled.shape[1]
+    num_tickers = int(sequence_tickers.max()) + 1
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    G = ConditionalGenerator(noise_dim=noise_dim, embed_dim=embed_dim,
+                             num_tickers=num_tickers, latent_dim=latent_dim,
+                             hidden_dim=hidden_dim).to(device)
+    D = ConditionalDiscriminator(latent_dim=latent_dim, embed_dim=embed_dim,
+                                 num_tickers=num_tickers, hidden_dim=hidden_dim).to(device)
+
+    opt_G = optim.Adam(G.parameters(), lr=lr, betas=(0.5, 0.9))
+    opt_D = optim.Adam(D.parameters(), lr=lr, betas=(0.5, 0.9))
+
+    losses = {"epoch": [], "D_loss": [], "G_loss": []}
+
+    logger.info("Starting Conditional WGAN-GP training...")
+    for epoch in range(n_epochs):
+        D_losses_epoch = []
+        G_losses_epoch = []
+
+        for real_batch, tickers_batch in tqdm(loader, desc=f"Epoch {epoch+1}/{n_epochs}", leave=False):
+            real = real_batch.to(device)
+            tickers = tickers_batch.to(device).long()
+            bsize = real.size(0)
+            
+            for _ in range(n_critic):
+                z = torch.randn(bsize, noise_dim).to(device)
+                fake = G(z, tickers)
+
+                d_real = D(real, tickers)
+                d_fake = D(fake.detach(), tickers)
+
+                gp = gradient_penalty_cond(D, real, fake.detach(), tickers, device)
+                d_loss = -(d_real.mean() - d_fake.mean()) + lambda_gp * gp
+
+                opt_D.zero_grad()
+                d_loss.backward()
+                opt_D.step()
+
+            z = torch.randn(bsize, noise_dim).to(device)
+            fake = G(z, tickers)
+            g_loss = -D(fake, tickers).mean()
+
+            opt_G.zero_grad()
+            g_loss.backward()
+            opt_G.step()
+
+            D_losses_epoch.append(d_loss.item())
+            G_losses_epoch.append(g_loss.item())
+
+        mean_D = float(np.mean(D_losses_epoch)) if len(D_losses_epoch) else 0.0
+        mean_G = float(np.mean(G_losses_epoch)) if len(G_losses_epoch) else 0.0
+
+        losses["epoch"].append(epoch + 1)
+        losses["D_loss"].append(mean_D)
+        losses["G_loss"].append(mean_G)
+
+        logger.info(f"[{epoch+1}/{n_epochs}] D_loss={mean_D:.4f}, G_loss={mean_G:.4f}")
+
+
+    losses_df = pd.DataFrame(losses)
+    losses_csv_path = os.path.join(resources_dir, "latent_gan_losses.csv")
+    losses_df.to_csv(losses_csv_path, index=False)
+    logger.info("Saved training losses to %s", losses_csv_path)
+
+    torch.save(G.state_dict(), os.path.join(models_dir, "latent_gan_generator_conditional.pth"))
+    torch.save(D.state_dict(), os.path.join(models_dir, "latent_gan_discriminator_conditional.pth"))
+    logger.info("Saved GAN models to models/")
+
+    with open(os.path.join(resources_dir, "gan_config.json"), "w") as f:
+        json.dump({
+            "model": "WGAN-GP-conditional",
+            "noise_dim": noise_dim,
+            "latent_dim": latent_dim,
+            "hidden_dim": hidden_dim,
+            "epochs": n_epochs,
+            "batch_size": batch_size,
+            "lr": lr,
+            "lambda_gp": lambda_gp,
+            "n_critic": n_critic,
+            "embed_dim": embed_dim,
+            "num_tickers": num_tickers
+        }, f, indent=4)
+
+    logger.info("Saved GAN config to resources/gan_config.json")
+    logger.info("Training completed successfully.")

src/nn_model.py

@@ -0,0 +1,157 @@
+import os
+import sys
+import pandas as pd
+import torch
+import torch.nn as nn
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+import json
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+orig_data_path = os.path.join(base_dir, 'data', 'orig_processed.parquet')
+combined_data_path = os.path.join(base_dir, 'data', 'final_data.parquet')
+resources_dir = os.path.join(base_dir, 'resources')
+os.makedirs(resources_dir, exist_ok=True)
+
+original_df = pd.read_parquet(orig_data_path)
+combined_df = pd.read_parquet(combined_data_path)
+
+for df in [original_df, combined_df]:
+    df.sort_values(['Ticker', 'Date'], inplace=True)
+    df.reset_index(drop=True, inplace=True)
+
+def add_trend_label(df):
+    df['Next_Close'] = df.groupby('Ticker')['Close'].shift(-1)
+    df['Trend'] = (df['Next_Close'] > df['Close']).astype(int)
+    df.dropna(subset=['Next_Close'], inplace=True)
+    return df
+
+original_df = add_trend_label(original_df)
+combined_df = add_trend_label(combined_df)
+
+le = LabelEncoder()
+original_df['TickerID'] = le.fit_transform(original_df['Ticker'])
+combined_df['TickerID'] = le.transform(combined_df['Ticker'])
+
+num_cols = ['Open', 'High', 'Low', 'Close', 'Volume']
+feature_cols = num_cols + ['TickerID']
+target_col = 'Trend'
+
+original_df = original_df.sort_values(['TickerID', 'Date']).reset_index(drop=True)
+combined_df = combined_df.sort_values(['TickerID', 'Date']).reset_index(drop=True)
+
+X_orig = original_df[feature_cols]
+y_orig = original_df[target_col]
+X_mix = combined_df[feature_cols]
+y_mix = combined_df[target_col]
+
+split_idx = int(len(X_orig) * 0.8)
+split_idx_mix = int(len(X_mix) * 0.8)
+
+X_train_orig, X_test = X_orig.iloc[:split_idx].copy(), X_orig.iloc[split_idx:].copy()
+y_train_orig, y_test = y_orig.iloc[:split_idx].copy(), y_orig.iloc[split_idx:].copy()
+
+X_train_mix, _ = X_mix.iloc[:split_idx_mix].copy(), X_mix.iloc[split_idx_mix:].copy()
+y_train_mix, _ = y_mix.iloc[:split_idx_mix].copy(), y_mix.iloc[split_idx_mix:].copy()
+
+scaler = StandardScaler()
+scaler.fit(X_train_orig[num_cols])
+
+X_train_orig.loc[:, num_cols] = scaler.transform(X_train_orig[num_cols])
+X_train_mix.loc[:, num_cols] = scaler.transform(X_train_mix[num_cols])
+X_test.loc[:, num_cols] = scaler.transform(X_test[num_cols])
+
+def to_tensor(X, y):
+    X_num = torch.tensor(X[num_cols].values, dtype=torch.float32)
+    X_ticker = torch.tensor(X['TickerID'].values, dtype=torch.long)
+    y = torch.tensor(y.values, dtype=torch.float32).view(-1, 1)
+    return X_num, X_ticker, y
+
+X_train_orig_num, X_train_orig_ticker, y_train_orig_t = to_tensor(X_train_orig, y_train_orig)
+X_train_mix_num, X_train_mix_ticker, y_train_mix_t = to_tensor(X_train_mix, y_train_mix)
+X_test_num, X_test_ticker, y_test_t = to_tensor(X_test, y_test)
+
+n_tickers_total = max(
+    X_train_orig_ticker.max().item(),
+    X_train_mix_ticker.max().item(),
+    X_test_ticker.max().item()
+) + 1
+
+class TrendNN(nn.Module):
+    def __init__(self, n_tickers, input_dim):
+        super().__init__()
+        self.ticker_embed = nn.Embedding(n_tickers, 8)
+        self.net = nn.Sequential(
+            nn.Linear(input_dim + 8, 64),
+            nn.ReLU(),
+            nn.Linear(64, 32),
+            nn.ReLU(),
+            nn.Linear(32, 1),
+            nn.Sigmoid()
+        )
+
+    def forward(self, x_num, ticker_id):
+        ticker_vec = self.ticker_embed(ticker_id)
+        x = torch.cat([x_num, ticker_vec], dim=1)
+        return self.net(x)
+
+def train_model(X_num, X_ticker, y, X_val, X_val_ticker, y_val, name, epochs=100, batch_size=1024):
+    model = TrendNN(n_tickers=n_tickers_total, input_dim=len(num_cols))
+    criterion = nn.BCELoss()
+    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
+
+    history = {"train_loss": [], "val_loss": [], "val_acc": []}
+    n_samples = len(X_num)
+
+    for epoch in range(epochs):
+        model.train()
+        perm = torch.randperm(n_samples)
+        total_loss = 0
+
+        for i in range(0, n_samples, batch_size):
+            idx = perm[i:i+batch_size]
+            batch_X_num, batch_ticker, batch_y = X_num[idx], X_ticker[idx], y[idx]
+
+            optimizer.zero_grad()
+            y_pred = model(batch_X_num, batch_ticker)
+            loss = criterion(y_pred, batch_y)
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+
+        model.eval()
+        with torch.no_grad():
+            y_val_pred = model(X_val, X_val_ticker)
+            val_loss = criterion(y_val_pred, y_val).item()
+            val_acc = ((y_val_pred > 0.5).float() == y_val).float().mean().item()
+
+        avg_train_loss = total_loss / (n_samples // batch_size)
+        history["train_loss"].append(avg_train_loss)
+        history["val_loss"].append(val_loss)
+        history["val_acc"].append(val_acc)
+
+        if (epoch + 1) % 5 == 0:
+            print(f"[{name}] Epoch {epoch+1}/{epochs} | "
+                  f"Train Loss: {avg_train_loss:.4f} | Val Loss: {val_loss:.4f} | Val Acc: {val_acc:.4f}")
+
+    model_path = os.path.join(resources_dir, f"model_{name.lower()}.pt")
+    torch.save(model.state_dict(), model_path)
+    return model, history
+
+model_orig, hist_orig = train_model(
+    X_train_orig_num, X_train_orig_ticker, y_train_orig_t,
+    X_test_num, X_test_ticker, y_test_t, "Original"
+)
+
+model_mix, hist_mix = train_model(
+    X_train_mix_num, X_train_mix_ticker, y_train_mix_t,
+    X_test_num, X_test_ticker, y_test_t, "Combined"
+)
+
+results = {
+    "original": hist_orig,
+    "combined": hist_mix
+}
+with open(os.path.join(resources_dir, 'training_metrics.json'), "w") as f:
+    json.dump(results, f, indent=4)