Seungkwon Lim

Creating my own Website 2021

I thought it would be more beneficial and rewarding if I created my own website instead of using free online website creator. Thus I edited HTML and CSS files to create my own website which showcases personal projects and information about my career. Then I deployed my website and secured it with HTTPS using a web hosting platform.

AI Assistant Program

The AI Assistant Program allows you to interact with OpenAI's GPT model through a desktop application without needing to visit 'chatgpt.com'.

Program Features

Generate and interact with AI-based chat sessions.
Save and export conversations to Word documents for later use.
Generate images using DALL-E from text descriptions.
Work offline by using the program as a standalone executable file.
Enjoy a clean and responsive UI with a dark theme for better usability.

Libraries Used

OpenAI API: For GPT interaction and image generation.
PyInstaller: Converts Python scripts into standalone executables.
Python-docx: Exports chat history to Word files.
Pillow: For image processing and generation.
Tkinter: GUI framework for the application.
Requests: For API requests and internet communication.

Whale Alert Bot

Monitors cryptocurrency transactions from wallets in Hyperliquid-a decentralized exchange- through HypurrScan.

The python program extracts information about the wallet's recent orders and open positions which then formats the data and converts into a telegram notification. This allows users to actively track whale's wallet whose trade can have a significant impact on the market.

Wallet address to be analyzed can be chosen by the user. Selenium and BeautifulSoup libraries were maninly used to scrape data which were later formated and sliced.

Features

Monitoring Orders: Fetches the latest orders of the target wallet and sends an alert every 5 seconds.
Monitoring Positions: Monitors open positions from the wallet and sends alerts for changes every minute.
Avoiding Duplicate Alerts: Ensures only new or updated orders/positions trigger alerts.
Periodic Checks: Checks for new orders and position updates at regular intervals for efficiency.

Libraries Used

`requests`: Used for sending HTTP requests, including Telegram messages.
`selenium`: Automates web browser interactions to scrape HypurrScan data.
`BeautifulSoup` (from `bs4`): Parses HTML and extracts data from the webpage.
`time`: Manages time-based operations like interval checks.
`os`: Import is included but not actively used in the code.
`collections.deque`: Maintains recent order identifiers to avoid duplicate alerts.

Baccarat Simulator & Data Analysis

A Python-based statistical simulation of Baccarat games with strategic betting analysis and visualization through Numpy and Matplotlib.

The analysis simulates 10,000 Baccarat hands and tracks outcomes (Banker, Player, Tie) while applying real-world rules such as the third-card draw rules.
The results were saved in a separate csv file in the local folder which was later analyzed in Jupyter Notebook.

Simple data such as the probability of each outcome was collected and later more complex patterns and their win rates were analyzed.
Applied real-life conditions such as commission to account for the house edge. Graphs hint that the initial margin converges to 0 as the number of played hands increases.

Features & Data Analysis

Bead Road Visualizer: Data was transformed into a color-coded grid similar to the actual casino scoreboard: outcomes over multiple random shoes (60–80 hands), with Banker (Red), Player (Blue), and Tie (Green).

Transition Matrix Analysis: Shows conditional probabilities based on previous hand outcomes to identify trends and suggest optimal bets. Ex: probability of a Player after Banker (image 2)

Bankroll Simulation: Tracks financial outcome over time for each strategy using real-world payout ratios: 0.95x on Banker, 1x on Player, Tie ignored. Dynamic graphs were later plotted to illustrate bankroll changes over hand numbers.

Strategies Tested

Strategy 1: Bet on Banker After Two Consecutive Player Wins

This strategy involves placing a bet on "Banker wins" only when the previous two game outcomes are "Player wins." The idea is to bet against a Player streak continuing beyond two wins, expecting the Banker to win next.

Win Rate: 48.25% (across 17 shoes)

Strategy 2: Bet on Player After a Tie

This strategy involves placing a bet on "Player wins" immediately after a "Tie" outcome. The rationale is that a Tie might signal a shift, and the next outcome is more likely to be a Player win.

Win Rate: 43.12% (across 17 shoes)

Libraries Used

`pandas`: Data manipulation and transition matrix creation.
`matplotlib`: Visualization of bead road patterns and bankroll simulation graphs.
`random`: Random shoe sizing and strategy outcomes.
`numpy`: Additional statistical and array operations.

NASDAQ100 Machine Learning Predictor

Project Overview

An advanced machine learning system for predicting daily NASDAQ US100 movements using sophisticated feature engineering, multiple model types, confidence-based filtering, and real-time signal generation. The system features trading logic, comprehensive backtesting with realistic condition, and potential integration for both historical analysis and live trading.

System Architecture & Workflow

Market Data & Feature Engineering

Retrieves up to ~10 years of historical data through MetaTrader 5 API
Builds 25+ engineered features capturing price action, volatility, trend, and patterns
Ensures data integrity with gap detection and missing-value handling
Organizes model outputs with consistent file naming for multi-symbol and multi-timeframe use

Model Training & Selection

Supports Random Forest, XGBoost, and LightGBM algorithms
Optional probability calibration via CalibratedClassifierCV
Uses time-series cross-validation for realistic evaluation
Automatically accounts for class imbalance (e.g., scale_pos_weight in XGBoost, balanced weights in Random Forest)
Optimizes confidence thresholds automatically (win-rate or PnL-based) for deployment

Advanced Feature Engineering

The system generates over 25 sophisticated features across multiple categories, each designed to capture different aspects of market behavior with enhanced robustness:

Enhanced Price Action & Candle Morphology

upper_wick_percent: Measures rejection at highs
lower_wick_percent: Captures support levels and buying interest
candle_range: Captures total movement (high–low) as a measure of volatility
gap: Opening price gap from previous close, measuring overnight sentiment

True Volatility & Risk Metrics

atr_14: True Average True Range using proper TR calculation
volatility_ratio: Current range relative to ATR-normalized volatility
range_change: Range expansion/contraction from previous session
vol_20: 20-period rolling volatility for adaptive threshold scaling

Multi-Timeframe Trend Analysis

ma_fast (5-period): Short-term trend direction and momentum
ma_slow (20-period): Intermediate trend confirmation
ema_200: Long-term trend bias and major support/resistance
trend_direction: Simple measure of short- vs. long-term moving averages, indicating overall trend bias.
above_ma_fast/ema_200: Binary indicators showing whether price is positioned above or below key moving averages.

Enhanced Momentum & Oscillators

rsi_14: Relative Strength Index (14-period), measuring momentum with smoothing
rsi_slope: Rate of change in RSI for momentum shift detection
macd: MACD main line using proper EMA calculation
macd_signal: MACD signal line for trend confirmation
macd_hist: MACD histogram showing momentum acceleration/deceleration

Breakout & Support/Resistance

prev_high/prev_low: Previous session's key levels for reference
breaks_prev_high: Binary flag for upside breakout confirmation
breaks_prev_low: Binary flag for downside breakdown confirmation

Advanced Candlestick Pattern Recognition

engulfing_bull/bear: Two-candle reversal patterns where the second candle fully engulfs the previous one.
confirmed_bullish_engulf: Bullish engulfing + uptrend + above EMA200
confirmed_bearish_engulf: Bearish engulfing + downtrend + below EMA200

Target Generation

Three target-labeling approaches are available, designed to adapt to varying market environments:

Standard Mode

Logic: Predicts the next bar’s direction based on price movement.

Label: Up if close[t+1] > close[t], otherwise Down.

Use Case: Provides broad market coverage with frequent trade opportunities.

Advantage: Maximizes data usage and captures all price shifts.

Strength: Ensures full alignment between backtest and live trading.

Fixed Threshold

Logic: A trade signal is only created if the next bar’s return is larger than a set threshold.

Labeling Rule:

1 (UP)

0 (DOWN)

Ignored

Use Case: Filters out small, noisy price moves.

Benefit: Focuses the model on significant movements, reducing false signals.

Adaptive Threshold

Logic: Dynamically adjusts entry thresholds based on market volatility.

Formula: Threshold = Base × (1 + 20 × Rolling Volatility).

Use Case: Maintains signal quality during both quiet and volatile markets.

Advantage: Reduces noise in low-volatility periods while capturing meaningful moves.

Feature Modes, Essentials Export & Threshold Selection

The system supports two feature modes for model training:

All Mode: Uses the complete engineered feature set (25+ features).
Essential Mode: Uses only the top-K most important features (default Top 10), automatically exported to suggested_essential_features.txt during backtests.

In addition, the backtest automatically optimizes the confidence threshold — the minimum probability required to generate a trade:

Win-Rate Mode: Selects the threshold that maximizes accuracy, subject to a minimum trade count for statistical reliability.
PnL Mode: Selects the threshold that yields the highest simulated profit and loss (using realistic execution costs).

This dual optimization ensures the chosen threshold balances signal quality and trade frequency, providing robust alignment between backtest performance and live deployment.

Interpreting Backtest Results

Backtest Visual Outputs

Running nasdaq_backtest.py not only saves CSVs and models, but also generates a range of visual performance analytics:

Equity Curve: Shows compounded account growth over time, reflecting win/loss streaks and drawdowns.
Confidence Sweep: Graphs how win-rate and trade count change as you vary the prediction threshold.
Calibration Curve (if enabled): Plots predicted probabilities vs actual outcomes for reliability analysis.
Feature Importance: Bar charts ranking which features had the highest impact on model predictions.
Return Distribution: Histogram of per-trade returns, useful for spotting outliers or fat-tail risks.

These visuals are saved alongside the CSV/model artifacts and provide a quick, intuitive way to understand the system’s strengths and weaknesses before deploying live.

Conducted Backtest Results

Train window: 2018-01-10 → 2023-12-15 · Test window: 2023-12-18 → 2025-09-03
Model: RandomForest · Mode: essential · Chosen Confidence > 0.58

Win Rate

64.29%

Based on 112 confident trades

Total PnL ($)

+228.21

Final Equity: $1,228.21

Max Drawdown ($)

-77.39

Peak-to-trough during test

Trades Taken

112

Confidence > 0.58

Prediction Balance

UP 70.8% / DOWN 29.2%

Across all predictions

Baseline Accuracy

54.15%

No confidence filter

With confidence > 0.58, the strategy achieved a 64.29% win rate over 112 trades, producing $228.21 total PnL (final equity $1,228.21) and a max drawdown of $77.39.
Essential Features Selected: rsi_14, rsi_slope, macd, candle_range, upper_wick_percent, atr_14, gap, macd_hist, lower_wick_percent, volatility_ratio

Backtest Artifacts

Saved model: US100Cash_16408_essential_randomforest.pkl
Confident trades CSV: US100Cash_16408_backtest.csv (112 trades @ thr=0.58)
Prob(UP) quantiles: [0.433, 0.490, 0.550, 0.6175, 0.6695]
Top 5 feature variances: macd, candle_range, atr_14, macd_hist, gap

Confidence sweep highlights: 0.58 → 112 trades @ 63.39%, 0.60 → 85 trades @ 64.71%, 0.62 → 64 trades @ 65.62%, 0.68 → 20 trades @ 75.00%.

Backtest Visual Outputs

Equity Curve: Compounded growth with drawdowns highlighted.
Confidence Sweep Plot: Win-rate vs. trades across thresholds (0.50–0.90).
Calibration Curve (if enabled): Probability reliability check.
Feature Importance: Tree-based importances (rsi_14, rsi_slope, macd, candle_range, atr_14, …).
Return Distribution: Per-trade PnL histogram for tail-risk insight.

Backtest Visualizations

Monthly PnL heatmap and feature importances

Practical Usage

The system can be used flexibly depending on your trading style. Here are the two most common setups:

End-of-Day (Daily) Prediction: Run main.py once at the close of the daily candle to forecast the next day’s direction. Best for swing/positional setups.
Intraday (5-Minute) Continuous Mode: Switch timeframe to M5 for rolling live signals. The system generates predictions at every bar close and can push them to a webhook_url for automated execution in futures or binary options trading.

Comprehensive Performance Analytics

Output File	Content	Purpose
`nasdaq_backtest_daily.csv`	Trade-by-trade results with equity curve	Detailed performance analysis and trade review
`{SYMBOL}_{N_BARS}_{FEATURE_MODE}_{MODEL}.pkl` e.g. `US100Cash_16408_all_randomforest.pkl`	Trained model + metadata (symbol, timeframe, features, model type encoded in filename)	Loaded in `main.py` for live trading via the `model_path` parameter
`suggested_essential_features.txt`	Top-K most important features	Feature reduction and model optimization

How to Use the System

Run Backtest: Execute nasdaq_backtest.py to generate performance metrics, equity curves, and suggested essential features.
Review Outputs:
- Check nasdaq_backtest_daily.csv for trade-by-trade results.
- Review suggested_essential_features.txt for the recommended feature set.
- Note the trained model file {SYMBOL}_{N_BARS}_{FEATURE_MODE}_{MODEL}.pkl.
Configure Live Trading: Update main.py with:
- Your chosen feature_mode (e.g., "essential" or "all") and the threshold
- The confidence threshold found during the sweep (balances win-rate and trade frequency).
- The trained model file path (model_path → e.g., "US100Cash_16408_all_randomforest.pkl").
Run Live Mode: Start main.py to generate signals (single-shot or continuous daily operation).
Monitor & Retrain: Periodically re-run backtests to recalibrate thresholds, update feature sets, and refresh the trained .pkl file as markets evolve.

Example: Using the Trained Model in main.py

# main.py (excerpt)
model = NASDAQTradingModel(
    model_path="US100Cash_16408_all_randomforest.pkl",  # from backtest
    symbol="US100cash",
    timeframe=mt5.TIMEFRAME_D1,
    feature_mode="all",
    model_type="randomforest",
    confidence_threshold=0.60,
    # ... other params
)
# The .pkl file is loaded and used for real-time predictions

PERSONAL PROJECTS

Work Experience

Seoul Metropolitan Office of Education | Seoul | 2023.04.06 – 2025.01.03

Work Experience

MH Technologies Research Engineer Co-op | Incheon | 2021 05 10 – 2021 08 27.

Work Experience

Hotel Management Internship Loft Hotel | Seoul | 2020 04 – 2020 10.

About Me

Seungkwon Lim

Enhanced Price Action & Candle Morphology

True Volatility & Risk Metrics

Multi-Timeframe Trend Analysis

Enhanced Momentum & Oscillators

Breakout & Support/Resistance

Advanced Candlestick Pattern Recognition

Standard Mode

Fixed Threshold

Adaptive Threshold

Example: Using the Trained Model in main.py

Core Libraries

Visualization & Utilities