Tin tức

Thuật Toán Baum-Welch – Người Tiền Phong Của Machine Learning

26/09/2026 Đặng Trí Thanh 106 lượt xem ~26 phút đọc
Mục lục bài viết
    Thuật Toán Baum-Welch – Người Tiền Phong Của Machine Learning

    Thuật toán Baum-Welch, được đồng phát triển bởi Leonard “Lenny” Baum, không chỉ là một cột mốc quan trọng trong lịch sử Machine Learning mà còn là nền tảng cho phương pháp giao dịch định lượng tại Renaissance Technologies – quỹ đầu cơ thành công nhất mọi thời đại. Từ việc giải mã mật mã trong Chiến tranh Lạnh đến dự đoán chuyển động giá trên thị trường tài chính, thuật toán này đã thay đổi cách chúng ta hiểu và khai thác dữ liệu.

    🧬 Nguồn Gốc Toán Học

    Leonard “Lenny” Baum – Nhà Toán Học Thiên Tài

    Background:

    Leonard E. Baum (1931-2017)
    
    Education:
    - PhD Mathematics, Harvard University (1958)
    - Chuyên ngành: Probability Theory, Statistics
    
    Career:
    - 1960s: Institute for Defense Analyses (IDA)
    - Codebreaker cho NSA
    - Sau này: Đối tác đầu tiên của Jim Simons

    Vai trò tại Renaissance:

    Lenny Baum là đối tác đầu tư đầu tiên của James Simons tại công ty Monemetrics (tiền thân của Renaissance Technologies, thành lập 1978).

    Partnership:
    Jim Simons (geometry, codebreaker) 
    + Lenny Baum (probability, statistics)
    = Quantitative trading pioneers

    Connection:

    Cả Simons và Baum đều từng làm việc trong lĩnh vực cryptography và codebreaking, nơi họ học cách:

    • Tìm patterns trong noise
    • Xử lý massive datasets
    • Áp dụng toán học vào bài toán thực tế
    • Giữ bí mật tuyệt đối

    Sự Hợp Tác Với Lloyd Welch

    Thập niên 1960s – Institute for Defense Analyses (IDA)

    Lloyd Welch:

    Lloyd R. Welch (1927-2013)
    
    Background:
    - Electrical engineer & information theorist
    - Pioneer in coding theory
    - Worked on error-correcting codes
    
    Famous for:
    - Viterbi algorithm (với Andrew Viterbi)
    - Baum-Welch algorithm (với Leonard Baum)

    Collaboration context:

    Cold War era (1960s):
    - US military needs better codebreaking
    - Speech recognition for surveillance
    - Pattern recognition in communications
    
    IDA mission:
    → Develop mathematical tools for defense
    → Analyze complex signals
    → Decrypt enemy communications

    The problem they solved:

    Challenge:
    "How do we model systems where we can see 
     the outputs but not the internal states?"
    
    Examples:
    - Speech: Hear sounds, but don't see tongue position
    - Markets: See prices, but don't see trader intentions
    - Communications: Intercept signals, but don't know original message
    
    Solution:
    → Hidden Markov Models (HMM)
    → Baum-Welch algorithm to train them

    🔗 Chuỗi Markov và Mô Hình Ẩn

    Markov Chains (Chuỗi Markov)

    Định nghĩa:

    Chuỗi Markov là một chuỗi sự kiện mà xác suất của sự kiện tiếp theo chỉ phụ thuộc vào trạng thái hiện tại, chứ không phải các sự kiện trước đó.

    “Markov Property” (Tính chất Markov):

    “The future is independent of the past, given the present.”

    Ví dụ đơn giản: Thời tiết

    States: {Sunny, Rainy, Cloudy}
    
    Transition probabilities:
    
    If today is Sunny:
      Tomorrow: 70% Sunny, 20% Cloudy, 10% Rainy
    
    If today is Rainy:
      Tomorrow: 20% Sunny, 30% Cloudy, 50% Rainy
    
    If today is Cloudy:
      Tomorrow: 40% Sunny, 40% Cloudy, 20% Rainy
    
    Key insight:
    Tomorrow's weather ONLY depends on today's weather,
    NOT on yesterday's, last week's, etc.

    Biểu diễn toán học:

    P(X_t+1 = s_j | X_t = s_i, X_t-1, X_t-2, ..., X_0)
    = P(X_t+1 = s_j | X_t = s_i)
    
    Only current state matters!

    Transition matrix:

             Sunny  Rainy  Cloudy
    Sunny  [  0.7    0.1    0.2  ]
    Rainy  [  0.2    0.5    0.3  ]
    Cloudy [  0.4    0.2    0.4  ]
    
    Each row sums to 1.0 (probabilities)

    Ví dụ trong tài chính: Bull/Bear markets

    States: {Bull Market, Bear Market, Sideways}
    
    If current = Bull:
      Next month: 70% Bull, 10% Bear, 20% Sideways
    
    If current = Bear:
      Next month: 30% Bull, 50% Bear, 20% Sideways
    
    Simple Markov model of market regimes

    Hidden Markov Models (HMM)

    Vấn đề với Markov Chains thông thường:

    Problem:
    "What if we can't observe the states directly?"
    
    Real-world scenarios:
    
    1. Speech recognition:
       Observable: Sound waves
       Hidden: Phonemes, words being spoken
    
    2. Stock markets:
       Observable: Prices, volume
       Hidden: Market regime (bull/bear), trader sentiment
    
    3. Weather (more realistic):
       Observable: Temperature, humidity readings
       Hidden: Actual weather system (high/low pressure)

    Hidden Markov Model structure:

    Hidden States (unobservable):
    S1 → S2 → S3 → S4 → ...
    
     ↓    ↓    ↓    ↓
    
    Observable Outputs:
    O1   O2   O3   O4   ...
    
    We see: O1, O2, O3, O4
    We don't see: S1, S2, S3, S4
    We want to infer: S1, S2, S3, S4

    Ví dụ cụ thể: Market regimes

    Hidden States: {Accumulation, Markup, Distribution, Markdown}
    
    Observable: Price & Volume
    
    Accumulation phase:
      → Hidden state: Smart money buying
      → Observable: Low volume, prices flat/slightly up
      → Emission: 60% low_vol_up, 30% low_vol_flat, 10% low_vol_down
    
    Markup phase:
      → Hidden state: Rally
      → Observable: High volume, prices rising
      → Emission: 70% high_vol_up, 20% med_vol_up, 10% high_vol_flat
    
    Distribution phase:
      → Hidden state: Smart money selling
      → Observable: High volume, prices topping
      → Emission: 40% high_vol_up, 40% high_vol_flat, 20% high_vol_down
    
    Markdown phase:
      → Hidden state: Decline
      → Observable: High volume, prices falling
      → Emission: 80% high_vol_down, 15% med_vol_down, 5% low_vol_down

    Three key problems for HMM:

    1. Evaluation:
       Given model parameters and observations,
       what's the probability of this sequence?
       → Forward algorithm
    
    2. Decoding:
       Given observations, what's the most likely
       sequence of hidden states?
       → Viterbi algorithm
    
    3. Learning:
       Given observations, what are the best
       model parameters (transitions, emissions)?
       → Baum-Welch algorithm ⭐

    Tại Sao HMM Quan Trọng?

    Modeling the “unobservable”:

    Trong thế giới thực, chúng ta thường:

    • Thấy effects (kết quả)
    • Không thấy causes (nguyên nhân)

    HMM giúp infer causes from effects.

    Applications:

    1. Speech Recognition:

    Hidden: Words being spoken
    Observable: Sound frequencies
    
    HMM learns:
    "When I hear THIS sound pattern,
     it's probably THAT word"

    2. Bioinformatics:

    Hidden: Gene structure (exons, introns)
    Observable: DNA sequence
    
    HMM finds:
    "Where are the genes in this DNA?"

    3. Financial Markets:

    Hidden: Market regime, trader intent
    Observable: Price, volume, order flow
    
    HMM predicts:
    "Market is probably in accumulation phase
     → Expect markup soon → Buy now"

    4. Natural Language Processing:

    Hidden: Parts of speech (noun, verb, etc.)
    Observable: Words in sentence
    
    HMM tags:
    "This word is probably a noun"

    🧮 Thuật Toán Baum-Welch

    Cách Hoạt Động (High-Level)

    The learning problem:

    Given:
    - Observable sequence: O = [O1, O2, O3, ..., OT]
    - Number of hidden states: N
    
    Find:
    - Transition probabilities: A[i][j] = P(S_t+1=j | S_t=i)
    - Emission probabilities: B[i][k] = P(O_t=k | S_t=i)
    - Initial probabilities: π[i] = P(S_0=i)
    
    Such that:
    P(O | model) is maximized
    (Model explains observations best)

    Iterative approach:

    Baum-Welch is an EM algorithm:
    (Expectation-Maximization)
    
    Step 1: Initialize parameters randomly
            (or with educated guess)
    
    Step 2: Expectation (E-step)
            Given current parameters,
            estimate hidden state probabilities
    
    Step 3: Maximization (M-step)
            Given estimated states,
            update parameters to maximize likelihood
    
    Step 4: Repeat until convergence
            (likelihood stops improving)

    Visual intuition:

    Iteration 0:
    Parameters: Random guesses
    Likelihood: Low (model doesn't fit data)
    
    Iteration 1:
    E-step: Estimate states given bad parameters
    M-step: Improve parameters based on estimates
    Likelihood: Better
    
    Iteration 2:
    E-step: Estimate states given better parameters
    M-step: Further improve parameters
    Likelihood: Even better
    
    ...
    
    Iteration 100:
    Parameters: Converged
    Likelihood: Maximized (or local maximum)
    Model now fits data well!

    Mathematics (Simplified)

    Notation:

    N = number of hidden states
    M = number of observable symbols
    T = length of observation sequence
    
    λ = (A, B, π) = model parameters
    
    A = transition matrix [N × N]
        A[i][j] = P(q_t+1 = j | q_t = i)
    
    B = emission matrix [N × M]
        B[i][k] = P(o_t = k | q_t = i)
    
    π = initial state distribution [N]
        π[i] = P(q_0 = i)

    E-step: Forward-Backward algorithm

    Forward probabilities (α):

    α_t(i) = P(o_1, o_2, ..., o_t, q_t = i | λ)
    
    "Probability of observing first t symbols
     AND being in state i at time t"
    
    Recursion:
    α_1(i) = π[i] * B[i][o_1]
    α_t+1(j) = [Σ_i α_t(i) * A[i][j]] * B[j][o_t+1]

    Backward probabilities (β):

    β_t(i) = P(o_t+1, o_t+2, ..., o_T | q_t = i, λ)
    
    "Probability of observing remaining symbols
     GIVEN we're in state i at time t"
    
    Recursion (backward):
    β_T(i) = 1
    β_t(i) = Σ_j [A[i][j] * B[j][o_t+1] * β_t+1(j)]

    State occupation probability:

    γ_t(i) = P(q_t = i | O, λ)
    
    "Probability of being in state i at time t,
     given the entire observation sequence"
    
    γ_t(i) = (α_t(i) * β_t(i)) / P(O | λ)
    
    Where:
    P(O | λ) = Σ_i α_T(i)

    Transition probability:

    ξ_t(i,j) = P(q_t = i, q_t+1 = j | O, λ)
    
    "Probability of transition i→j at time t"
    
    ξ_t(i,j) = (α_t(i) * A[i][j] * B[j][o_t+1] * β_t+1(j)) / P(O | λ)

    M-step: Re-estimate parameters

    Update transition probabilities:
    A'[i][j] = (Sum over t of ξ_t(i,j)) / (Sum over t of γ_t(i))
    
    "Expected transitions i→j / Expected time in state i"
    
    Update emission probabilities:
    B'[i][k] = (Sum over t where o_t=k of γ_t(i)) / (Sum over t of γ_t(i))
    
    "Expected emissions of symbol k from state i / Expected time in state i"
    
    Update initial probabilities:
    π'[i] = γ_1(i)
    
    "Expected frequency of starting in state i"

    Convergence:

    Repeat E-step and M-step until:
    
    |log P(O | λ_new) - log P(O | λ_old)| < threshold
    
    Usually converges in 50-200 iterations
    Guaranteed to find local maximum (not necessarily global)

    Pseudocode

    def baum_welch(observations, n_states, n_iter=100):
        """
        Train HMM using Baum-Welch algorithm
    
        Args:
            observations: Sequence of observed symbols
            n_states: Number of hidden states
            n_iter: Max iterations
    
        Returns:
            A, B, π: Trained model parameters
        """
        # Initialize parameters randomly
        A = random_matrix(n_states, n_states)  # Transitions
        B = random_matrix(n_states, n_symbols)  # Emissions
        π = random_vector(n_states)             # Initial
    
        # Normalize to valid probabilities
        A = normalize_rows(A)
        B = normalize_rows(B)
        π = normalize(π)
    
        for iteration in range(n_iter):
            # E-STEP: Compute forward-backward probabilities
            α = forward(observations, A, B, π)
            β = backward(observations, A, B, π)
    
            # Compute γ (state occupation)
            γ = compute_gamma(α, β)
    
            # Compute ξ (transition probabilities)
            ξ = compute_xi(observations, α, β, A, B)
    
            # M-STEP: Re-estimate parameters
            A_new = update_transitions(ξ, γ)
            B_new = update_emissions(γ, observations)
            π_new = γ[0]  # Initial state = γ at t=0
    
            # Check convergence
            likelihood = compute_likelihood(observations, A, B, π)
            if converged(likelihood):
                break
    
            # Update parameters
            A, B, π = A_new, B_new, π_new
    
        return A, B, π

    Ví Dụ Thực Tế: Dự Đoán Thời Tiết

    Problem setup:

    Hidden states: {Sunny, Rainy}
    Observable symbols: {Dry, Damp, Wet}
    
    We observe humidity:
    Day 1: Dry
    Day 2: Damp  
    Day 3: Wet
    Day 4: Damp
    Day 5: Dry
    
    We want to infer:
    What was the actual weather each day?
    What are the transition/emission probabilities?

    Python implementation:

    import numpy as np
    
    # Observations (encoded)
    observations = [0, 1, 2, 1, 0]  # Dry, Damp, Wet, Damp, Dry
    n_obs = 3  # Dry, Damp, Wet
    n_states = 2  # Sunny, Rainy
    
    # Initialize random parameters
    np.random.seed(42)
    A = np.random.rand(n_states, n_states)  # Transitions
    B = np.random.rand(n_states, n_obs)      # Emissions
    π = np.random.rand(n_states)             # Initial
    
    # Normalize
    A = A / A.sum(axis=1, keepdims=True)
    B = B / B.sum(axis=1, keepdims=True)
    π = π / π.sum()
    
    print("Initial parameters (random):")
    print("Transitions (Sunny/Rainy → Sunny/Rainy):")
    print(A)
    print("nEmissions (Sunny/Rainy → Dry/Damp/Wet):")
    print(B)
    
    # Run Baum-Welch
    for iteration in range(100):
        # Forward algorithm
        α = np.zeros((len(observations), n_states))
        α[0] = π * B[:, observations[0]]
    
        for t in range(1, len(observations)):
            for j in range(n_states):
                α[t, j] = np.sum(α[t-1] * A[:, j]) * B[j, observations[t]]
    
        # Backward algorithm
        β = np.zeros((len(observations), n_states))
        β[-1] = 1
    
        for t in range(len(observations)-2, -1, -1):
            for i in range(n_states):
                β[t, i] = np.sum(A[i, :] * B[:, observations[t+1]] * β[t+1])
    
        # Compute γ (state probabilities)
        γ = α * β
        γ = γ / γ.sum(axis=1, keepdims=True)
    
        # Compute ξ (transition probabilities)
        ξ = np.zeros((len(observations)-1, n_states, n_states))
        for t in range(len(observations)-1):
            for i in range(n_states):
                for j in range(n_states):
                    ξ[t, i, j] = (α[t, i] * A[i, j] * 
                                  B[j, observations[t+1]] * β[t+1, j])
            ξ[t] = ξ[t] / ξ[t].sum()
    
        # M-step: Update parameters
        A = ξ.sum(axis=0) / γ[:-1].sum(axis=0, keepdims=True).T
    
        for k in range(n_obs):
            mask = (np.array(observations) == k)
            B[:, k] = γ[mask].sum(axis=0) / γ.sum(axis=0)
    
        π = γ[0]
    
    print("nnLearned parameters (after Baum-Welch):")
    print("Transitions:")
    print(A)
    print("nEmissions:")
    print(B)
    
    # Decode most likely state sequence (Viterbi)
    states = ["Sunny", "Rainy"]
    symbols = ["Dry", "Damp", "Wet"]
    
    print("nnMost likely weather sequence:")
    for t, obs in enumerate(observations):
        state = states[np.argmax(γ[t])]
        symbol = symbols[obs]
        print(f"Day {t+1}: Observed {symbol:4s} → Likely {state}")

    Output example:

    Initial parameters (random):
    Transitions:
    [[0.52 0.48]
     [0.61 0.39]]
    
    Emissions:
    [[0.41 0.33 0.26]
     [0.28 0.35 0.37]]
    
    Learned parameters (after Baum-Welch):
    Transitions:
    [[0.85 0.15]  ← Sunny→Sunny: 85%, Sunny→Rainy: 15%
     [0.30 0.70]]  ← Rainy→Sunny: 30%, Rainy→Rainy: 70%
    
    Emissions:
    [[0.70 0.25 0.05]  ← Sunny: 70% Dry, 25% Damp, 5% Wet
     [0.10 0.30 0.60]]  ← Rainy: 10% Dry, 30% Damp, 60% Wet
    
    Most likely weather sequence:
    Day 1: Observed Dry  → Likely Sunny
    Day 2: Observed Damp → Likely Sunny
    Day 3: Observed Wet  → Likely Rainy
    Day 4: Observed Damp → Likely Rainy
    Day 5: Observed Dry  → Likely Sunny

    Key insights:

    The algorithm learned from data that:

    1. Sunny days tend to stay sunny (85%)
    2. Rainy days tend to stay rainy (70%)
    3. Sunny days → Usually dry
    4. Rainy days → Usually wet

    Without being explicitly told these rules!

    🚀 Ảnh Hưởng Đến Công Nghệ

    1. Speech Recognition (Nhận Dạng Giọng Nói)

    The problem:

    Input: Audio waveform (continuous signal)
    Output: Text transcription
    
    Challenges:
    - Accents, dialects
    - Background noise
    - Co-articulation (sounds blend together)
    - Homonyms (same sound, different words)

    HMM approach:

    Hidden states: Phonemes (basic sound units)
    Observable: Acoustic features (MFCCs, spectrograms)
    
    Model structure:
    
    Text: "hello"
           ↓
    Phonemes: /h/ /ɛ/ /l/ /oʊ/
           ↓    ↓    ↓    ↓
    Audio: [acoustic features over time]
    
    HMM learns:
    "When I see THIS acoustic pattern,
     it's probably phoneme /h/,
     followed by phoneme /ɛ/, etc."

    Training data:

    1. Collect thousands of hours of speech
    2. Human annotators label the phonemes
    3. Baum-Welch learns:
       - Transition probabilities (phoneme sequences)
       - Emission probabilities (acoustic → phoneme)
    4. Deploy trained model

    IBM’s breakthrough (1980s-1990s):

    James Baker (Dragon Systems) and Frederick Jelinek (IBM) pioneered statistical speech recognition using HMM.

    Key figures:

    • Peter Brown (IBM researcher)
    • Robert Mercer (IBM researcher)
      ← Later joined Renaissance Technologies!

    Their innovation:

    Previous approach:
    - Rule-based (linguists hand-craft rules)
    - Brittle, doesn't generalize
    
    HMM approach:
    - Data-driven (learn from examples)
    - Statistical (handles uncertainty)
    - Scalable (more data = better model)
    
    Result:
    IBM's speech recognition accuracy improved from 50% → 95%+

    Modern systems:

    Evolution:
    1980s: HMM (Baum-Welch)
    1990s: HMM + Neural networks (hybrid)
    2010s: Deep learning (RNN, LSTM)
    2020s: Transformers (Whisper, etc.)
    
    But HMM was the foundation!
    Today's systems still use HMM concepts:
    - Sequence modeling
    - Handling uncertainty
    - Learning from data

    Applications:

    • Siri, Alexa, Google Assistant
    • Dictation software (Dragon NaturallySpeaking)
    • Call center transcription
    • Subtitle generation

    2. Google Search

    Connection to Baum-Welch:

    Google’s early search algorithms drew from information retrieval and statistical NLP, both heavily influenced by HMM research.

    Specific applications:

    Query understanding:

    User types: "apple"
    
    HMM can model:
    Hidden: User intent
    Observable: Query terms + context
    
    States:
    - Fruit shopping intent
    - Tech product intent
    - Company research intent
    
    Emissions:
    - Previous searches
    - Time of day
    - Geographic location
    - Device type
    
    HMM predicts:
    "This user probably means Apple Inc."

    Spelling correction:

    User types: "machne lerning"
    
    HMM approach:
    Hidden: Intended words
    Observable: Typed characters
    
    Given character sequence "machne",
    what's the most likely intended word?
    
    Baum-Welch trains on millions of queries:
    "machne" → 95% meant "machine"
    "lerning" → 98% meant "learning"
    
    → Suggest: "Did you mean: machine learning?"

    Ranking signals:

    HMM for user behavior modeling:
    
    Hidden states:
    - Navigational search (looking for specific site)
    - Informational search (learning)
    - Transactional search (buying)
    
    Observable:
    - Click patterns
    - Dwell time
    - Bounce rate
    
    Learn:
    Which results satisfy which intents?
    → Improve ranking

    Google Translate (early versions):

    Statistical Machine Translation (SMT):
    - Used phrase-based models
    - HMM for word alignment
    - Baum-Welch to learn translation probabilities
    
    Example:
    English: "I love you"
    French: "Je t'aime"
    
    HMM learns:
    P("Je" | "I") = 0.8
    P("t'aime" | "love you") = 0.7
    ...

    3. Natural Language Processing (NLP)

    Part-of-Speech (POS) Tagging:

    Sentence: "The cat sat on the mat"
    
    Task: Tag each word with its role
    
    Hidden: POS tags
    Observable: Words
    
    HMM learns:
    The → DET (determiner)
    cat → NOUN
    sat → VERB
    on → PREP (preposition)
    the → DET
    mat → NOUN
    
    Pattern:
    DET + NOUN + VERB + PREP + DET + NOUN

    Named Entity Recognition (NER):

    Sentence: "Steve Jobs founded Apple in California"
    
    Task: Identify entities
    
    HMM states:
    - PERSON
    - ORGANIZATION  
    - LOCATION
    - OTHER
    
    Training:
    Label thousands of sentences
    Baum-Welch learns:
    "Steve Jobs" → 95% PERSON
    "Apple" (after "founded") → 90% ORGANIZATION
    "California" → 99% LOCATION

    Machine Translation:

    Already discussed above (Google Translate).

    4. Bioinformatics

    Gene Finding:

    DNA sequence:
    ATGCGATCGATCG...
    
    Hidden states:
    - Exon (coding region)
    - Intron (non-coding)
    - Intergenic (between genes)
    
    Observable:
    - Nucleotide sequence (A, T, G, C)
    
    HMM learns:
    Patterns that distinguish coding vs. non-coding regions
    
    Applications:
    - Genome annotation
    - Finding genes in new organisms

    Protein Structure Prediction:

    Amino acid sequence → 3D structure
    
    HMM for secondary structure:
    Hidden: Alpha helix, Beta sheet, Random coil
    Observable: Amino acid types
    
    Helps predict protein folding

    5. Computational Finance

    Market Regime Detection:

    Hidden states:
    - Bull market
    - Bear market
    - Sideways/Consolidation
    - High volatility
    - Low volatility
    
    Observable:
    - Price changes
    - Volume
    - Volatility measures
    
    HMM detects:
    "We just transitioned from bull to distribution phase
     → Reduce long positions"

    Credit Risk Modeling:

    Hidden: Company financial health
    Observable: Credit metrics, stock price, etc.
    
    Predict:
    Probability of default

    Algorithmic Trading:

    (Covered in detail in next section – Renaissance Technologies)

    💼 Peter Brown & Robert Mercer – Từ IBM Đến RenTech

    Công Việc Tại IBM

    IBM Research – Speech Recognition Group (1980s-1990s)

    Peter Brown:

    Peter F. Brown
    
    Background:
    - PhD Computer Science, Carnegie Mellon
    - Joined IBM Research (1980s)
    
    Specialty:
    - Statistical NLP
    - Machine translation
    - Speech recognition

    Robert Mercer:

    Robert Mercer
    
    Background:
    - PhD Computer Science, University of Illinois
    - Worked on compilers, programming languages
    - Joined IBM Research
    
    Specialty:
    - Speech recognition
    - Statistical models
    - Computational linguistics

    Their approach at IBM:

    Philosophy:
    "Language is a stochastic process"
    
    Key insight:
    "Treat speech/language as a probabilistic game"
    
    Methods:
    - Hidden Markov Models (HMM)
    - N-gram language models
    - Baum-Welch for training
    - Viterbi for decoding
    
    Results:
    IBM's speech recognition → Industry-leading accuracy

    Specific innovations:

    1. Statistical Machine Translation:

    # Brown et al.'s IBM Models (1990)
    
    # Model 1: Word-by-word translation
    P(french | english) = Π P(f_word | e_word)
    
    # Model 2: Add word positions
    P(f, alignment | e) = Π P(f_i | e_j) * P(j | i)
    
    # ... up to Model 5 (most complex)
    
    # Trained using EM algorithm (like Baum-Welch)

    2. Language Modeling:

    N-gram models:
    
    Unigram: P(word)
    Bigram: P(word | previous_word)
    Trigram: P(word | previous_2_words)
    
    Example:
    P("trading" | "algorithmic") = 0.15
    P("trading" | "algorithmic", "quantitative") = 0.35
    
    Used for:
    - Speech recognition (predict next word)
    - Text generation
    - Spelling correction

    3. Acoustic Modeling:

    HMM for phonemes:
    
    Each phoneme = HMM with 3-5 states
    Transitions: Left-to-right (time progression)
    Emissions: Gaussian mixtures (acoustic features)
    
    Trained with Baum-Welch on labeled speech data

    Chuyển Đổi Triết Lý Sang Tài Chính

    The leap from IBM to Renaissance:

    Year: 1993
    Event: Jim Simons recruits Peter Brown & Robert Mercer
    
    Why?
    - Renaissance's early models were underperforming
    - Needed fresh perspective
    - Brown & Mercer = Statistical modeling experts

    Key insight:

    “If we can model language as a stochastic process,
    why not model markets the same way?”

    Parallels between speech and markets:

    Speech Recognition Financial Markets
    Observable: Audio signals Observable: Prices, volume
    Hidden: Phonemes, words Hidden: Market regimes, trader intent
    Sequence: Sounds over time Sequence: Price movements over time
    Noise: Background sounds Noise: Random fluctuations
    Goal: Transcribe text Goal: Predict price direction
    Method: HMM + Baum-Welch Method: HMM + Baum-Welch

    Conceptual translation:

    Speech:

    "What's the probability that THIS sound
     is the word 'trading'?"
    
    P(word = "trading" | audio_features)

    Markets:

    "What's the probability that THIS price pattern
     leads to an upward move?"
    
    P(price_up | recent_price_action, volume, etc.)

    Both are:

    • Sequence prediction problems
    • Noisy observations
    • Hidden underlying structure
    • Solved with probabilistic models

    “Các Chuỗi Từ” = Chuyển Động Giá Cả

    Language as sequence:

    Sentence:
    "The" → "stock" → "market" → "rose" → "today"
    
    Each word follows probabilistically from previous words
    
    P("market" | "stock") = 0.35
    P("rose" | "stock", "market") = 0.12

    Markets as sequence:

    Price movement:
    +1% → -0.5% → +2% → -0.3% → +1.5%
    
    Each move follows probabilistically from previous moves (?)
    
    P(up | down, up) = 0.55
    P(strong_up | weak_up, down) = 0.48

    The analogy:

    Language Model:
    P(w_t | w_t-1, w_t-2, ..., w_1)
    
    "Predict next word given previous words"
    
    Market Model:
    P(r_t | r_t-1, r_t-2, ..., r_1)
    
    "Predict next return given previous returns"

    Brown & Mercer’s approach:

    1. Feature extraction (like acoustic features):

    # Speech: MFCC features from audio
    mfcc = extract_mfcc(audio_waveform)
    
    # Markets: Statistical features from price
    features = {
        'return_1d': (price[-1] - price[-2]) / price[-2],
        'return_5d': (price[-1] - price[-6]) / price[-6],
        'volatility': std(returns[-20:]),
        'volume_ratio': volume[-1] / mean(volume[-20:]),
        'rsi': compute_rsi(price, period=14),
        # ... hundreds more
    }

    2. Sequence modeling (HMM):

    # Speech: Phoneme sequences
    states = ['phoneme_a', 'phoneme_e', 'phoneme_i', ...]
    
    # Markets: Market regimes
    states = ['trending_up', 'mean_reverting', 'high_vol', 'low_vol', ...]
    
    # Both use Baum-Welch to learn:
    # - State transitions
    # - Emission probabilities

    3. Prediction:

    # Speech: Most likely word sequence
    best_transcription = viterbi_decode(audio, hmm_model)
    
    # Markets: Most likely next move
    predicted_direction = viterbi_decode(price_history, hmm_model)
    
    if predicted_direction == 'up':
        place_long_order()

    4. Portfolio of models:

    Just like speech systems use:
    - Acoustic model
    - Language model  
    - Pronunciation dictionary
    
    Renaissance uses:
    - Thousands of mini-models
    - Each predicting different patterns
    - Ensemble for final decision

    Specific example:

    # Simplified RenTech-style model
    
    class MarketRegimeHMM:
        def __init__(self):
            self.states = [
                'strong_trend',
                'weak_trend',
                'mean_reverting',
                'high_volatility',
                'low_volatility'
            ]
    
            # Learn these via Baum-Welch
            self.transition_probs = None
            self.emission_probs = None
    
        def train(self, price_history):
            """Train HMM on historical prices"""
            features = self.extract_features(price_history)
    
            # Baum-Welch algorithm
            self.transition_probs, self.emission_probs = 
                baum_welch(features, n_states=len(self.states))
    
        def predict(self, current_features):
            """Predict next regime and expected return"""
            # Forward algorithm to get current state probabilities
            current_state_probs = self.forward(current_features)
    
            # Expected next state
            next_state_probs = current_state_probs @ self.transition_probs
    
            # Expected return in each state
            expected_returns = {
                'strong_trend': 0.02,
                'weak_trend': 0.005,
                'mean_reverting': -0.01,  # Fade current move
                'high_volatility': 0.0,
                'low_volatility': 0.001
            }
    
            # Weighted average
            expected_return = sum(
                next_state_probs[i] * expected_returns[state]
                for i, state in enumerate(self.states)
            )
    
            return expected_return
    
    # Usage
    model = MarketRegimeHMM()
    model.train(historical_prices)
    
    predicted_return = model.predict(current_market_features)
    
    if predicted_return > threshold:
        buy()
    elif predicted_return < -threshold:
        sell()

    Impact at Renaissance

    Timeline:

    1993: Brown & Mercer join Renaissance
    1994-1995: Medallion Fund performance improves dramatically
    1996+: Consistent 40-60%+ annual returns
    
    Coincidence? Unlikely.

    What they brought:

    1. Statistical rigor:

    Before: More ad-hoc pattern recognition
    After: Formal probabilistic framework

    2. Machine learning expertise:

    Before: Simpler models
    After: Sophisticated ML (for the era)

    3. Data-driven culture:

    Philosophy from IBM:
    "Don't assume, learn from data"
    "More data = Better models"
    "Test everything rigorously"

    4. Scalable infrastructure:

    IBM experience in large-scale computing
    → Build RenTech's supercomputers
    → Process massive datasets
    → Run thousands of backtests

    Legacy:

    Peter Brown:
    - Co-CEO of Renaissance (2009-present)
    - Net worth: $1+ billion
    
    Robert Mercer:
    - Co-CEO of Renaissance (2009-2017)
    - Net worth: $1+ billion
    - Controversial political involvement (Breitbart, Cambridge Analytica)
    
    Their contribution:
    Transformed Renaissance from good to legendary

    🎯 Ứng Dụng Trong Quant Trading

    Renaissance Technologies’ Approach

    How they use HMM & Baum-Welch:

    1. Market Regime Detection

    # Identify current market state
    
    class RegimeDetectionHMM:
        states = [
            'bull_trend',
            'bear_trend',
            'sideways',
            'accumulation',
            'distribution',
            'high_vol_crisis',
            'low_vol_complacency'
        ]
    
        def detect_regime(self, price_data, volume_data, macro_data):
            # Extract features
            features = self.extract_features(price_data, volume_data, macro_data)
    
            # Run Viterbi algorithm
            most_likely_sequence = self.viterbi(features)
    
            current_regime = most_likely_sequence[-1]
            return current_regime
    
        def get_strategy(self, regime):
            strategies = {
                'bull_trend': 'momentum_long',
                'bear_trend': 'momentum_short',
                'sideways': 'mean_reversion',
                'accumulation': 'long_value',
                'distribution': 'reduce_longs',
                'high_vol_crisis': 'volatility_arbitrage',
                'low_vol_complacency': 'sell_vol'
            }
            return strategies[regime]
    
    # Usage
    hmm = RegimeDetectionHMM()
    hmm.train(historical_market_data)
    
    current_regime = hmm.detect_regime(recent_prices, recent_volume, macro_indicators)
    strategy = hmm.get_strategy(current_regime)
    
    print(f"Current regime: {current_regime}")
    print(f"Recommended strategy: {strategy}")

    2. Pattern Recognition

    # Find recurring price patterns
    
    class PatternRecognitionHMM:
        def __init__(self, n_patterns=50):
            self.n_patterns = n_patterns
            self.hmms = []
    
        def discover_patterns(self, price_sequences):
            """
            Learn common patterns in price movements
            """
            for pattern_id in range(self.n_patterns):
                # Initialize HMM for this pattern
                hmm = HiddenMarkovModel(n_states=5)
    
                # Sample random subsequences
                samples = random.sample(price_sequences, 1000)
    
                # Train with Baum-Welch
                hmm.train(samples, algorithm='baum-welch')
    
                self.hmms.append(hmm)
    
        def match_pattern(self, current_sequence):
            """
            Which pattern does current price action match?
            """
            likelihoods = []
    
            for hmm in self.hmms:
                # Compute P(sequence | pattern_hmm)
                likelihood = hmm.score(current_sequence)
                likelihoods.append(likelihood)
    
            # Best matching pattern
            best_pattern = np.argmax(likelihoods)
            return best_pattern
    
        def predict_next_move(self, current_sequence):
            """
            Based on pattern, predict next price move
            """
            pattern_id = self.match_pattern(current_sequence)
            hmm = self.hmms[pattern_id]
    
            # What typically follows this pattern?
            predicted_distribution = hmm.predict_next(current_sequence)
    
            return predicted_distribution
    
    # Usage
    pattern_model = PatternRecognitionHMM(n_patterns=100)
    pattern_model.discover_patterns(all_historical_price_sequences)
    
    # Current market
    current = recent_price_action()
    pattern_id = pattern_model.match_pattern(current)
    next_move_prob = pattern_model.predict_next_move(current)
    
    print(f"Current price action matches Pattern #{pattern_id}")
    print(f"Probability of up move: {next_move_prob['up']:.2%}")
    print(f"Probability of down move: {next_move_prob['down']:.2%}")
    
    if next_move_prob['up'] > 0.60:
        place_long_trade()

    3. Order Flow Analysis

    # Model hidden liquidity and intentions
    
    class OrderFlowHMM:
        """
        Hidden states: Institutional trading intent
        Observable: Order book changes, trade flow
        """
    
        states = [
            'institutional_accumulation',  # Smart money buying quietly
            'institutional_distribution',  # Smart money selling quietly
            'retail_buying_panic',          # FOMO
            'retail_selling_panic',         # Fear
            'market_maker_neutral',         # Just providing liquidity
            'algorithmic_arbitrage'         # Bots balancing
        ]
    
        def analyze_order_flow(self, order_book_snapshots, trade_flow):
            """
            Infer hidden trader intentions from observable order flow
            """
            features = self.extract_flow_features(order_book_snapshots, trade_flow)
    
            # Baum-Welch trained on historical flow patterns
            hidden_states = self.hmm.predict(features)
    
            current_intent = hidden_states[-1]
            return current_intent
    
        def extract_flow_features(self, order_book, trades):
            return {
                'bid_ask_imbalance': self.compute_imbalance(order_book),
                'large_order_ratio': self.detect_large_orders(trades),
                'sweep_activity': self.detect_sweeps(trades),
                'iceberg_indicators': self.detect_icebergs(order_book),
                'microstructure_noise': self.compute_noise(trades)
            }
    
        def trading_decision(self, intent):
            if intent == 'institutional_accumulation':
                return 'JOIN_THE_SMART_MONEY_BUY'
            elif intent == 'institutional_distribution':
                return 'AVOID_OR_SHORT'
            elif intent == 'retail_buying_panic':
                return 'FADE_THE_MOVE_SELL'
            elif intent == 'retail_selling_panic':
                return 'CONTRARIAN_BUY'
            else:
                return 'NO_STRONG_SIGNAL'
    
    # Real-time usage
    flow_analyzer = OrderFlowHMM()
    flow_analyzer.train(historical_order_book_data)
    
    while True:
        current_order_book = get_order_book_snapshot()
        recent_trades = get_recent_trades()
    
        intent = flow_analyzer.analyze_order_flow(current_order_book, recent_trades)
        decision = flow_analyzer.trading_decision(intent)
    
        if decision != 'NO_STRONG_SIGNAL':
            execute_trade(decision)
    
        time.sleep(0.1)  # High-frequency (10 Hz)

    4. Multi-Asset Correlation

    # Model relationships between assets
    
    class MultiAssetHMM:
        """
        Model how assets move together in different regimes
        """
    
        def __init__(self, assets):
            self.assets = assets
            self.n_assets = len(assets)
    
            # HMM states = Correlation regimes
            self.states = [
                'high_correlation',     # Risk-on: All up together
                'negative_correlation', # Flight to safety
                'asset_specific',       # Uncorrelated, idiosyncratic
                'sector_rotation',      # Some up, some down
                'crisis_mode'           # Everything correlated to 1
            ]
    
        def train(self, multi_asset_returns):
            """
            Learn how correlation regime transitions
            """
            # Features: Rolling correlations, volatilities
            features = self.compute_correlation_features(multi_asset_returns)
    
            # Baum-Welch to learn regime dynamics
            self.hmm = HMM(n_states=len(self.states))
            self.hmm.fit(features, algorithm='baum-welch')
    
        def current_regime(self, recent_returns):
            features = self.compute_correlation_features(recent_returns)
            regime = self.hmm.predict(features)[-1]
            return self.states[regime]
    
        def optimal_portfolio(self, regime):
            if regime == 'high_correlation':
                # Diversification doesn't help, reduce risk
                return self.construct_portfolio(target_volatility=0.10)
    
            elif regime == 'negative_correlation':
                # Perfect for risk parity
                return self.construct_portfolio(strategy='risk_parity')
    
            elif regime == 'asset_specific':
                # Stock picking works, increase concentration
                return self.construct_portfolio(strategy='concentrated')
    
            elif regime == 'crisis_mode':
                # Go to cash or hedged
                return self.construct_portfolio(strategy='defensive')
    
    # Usage for portfolio construction
    port_model = MultiAssetHMM(assets=['SPY', 'TLT', 'GLD', 'BTC', 'USD'])
    port_model.train(historical_returns)
    
    regime = port_model.current_regime(recent_returns)
    optimal_weights = port_model.optimal_portfolio(regime)
    
    print(f"Current correlation regime: {regime}")
    print(f"Optimal portfolio weights: {optimal_weights}")
    rebalance_portfolio(optimal_weights)

    Modern Extensions

    Beyond classical HMM:

    Renaissance has evolved far beyond vanilla Baum-Welch, but the foundational ideas remain:

    1. Deep Learning + HMM:

    # Neural HMM (hybrid approach)
    
    class NeuralHMM:
        def __init__(self):
            # Use neural network to learn emission probabilities
            self.emission_network = NeuralNetwork([
                Dense(256, activation='relu'),
                Dense(128, activation='relu'),
                Dense(n_states, activation='softmax')
            ])
    
            # Traditional HMM for transitions
            self.transition_matrix = None
    
        def train(self, sequences):
            # E-step: Use neural network for emissions
            emission_probs = self.emission_network.predict(sequences)
    
            # M-step: Update transition matrix (traditional)
            self.transition_matrix = self.estimate_transitions(emission_probs)
    
            # Backprop to update neural network
            self.emission_network.train(sequences, labels=hidden_states_estimate)

    2. Regime-Switching Models:

    # Markov regime-switching models
    
    class RegimeSwitchingModel:
        """
        Different dynamics in different regimes
        Example: Bull market vs Bear market have different return distributions
        """
    
        def __init__(self):
            # Each regime = Different ARIMA/GARCH model
            self.regime_models = {
                'bull': ARIMA(p=2, d=1, q=2),
                'bear': ARIMA(p=3, d=1, q=3),
                'sideways': GARCH(p=1, q=1)
            }
    
            # HMM for regime switching
            self.regime_hmm = HMM(n_states=3)
    
        def predict(self, recent_data):
            # Detect current regime
            regime = self.regime_hmm.predict(recent_data)
    
            # Use appropriate model for that regime
            model = self.regime_models[regime]
            forecast = model.forecast(horizon=1)
    
            return forecast

    3. Hierarchical HMM:

    Multiple levels:
    
    Level 1: Macro regimes (bull/bear)
        ↓
    Level 2: Sector rotation
        ↓  
    Level 3: Individual stock patterns
    
    Each level = Separate HMM
    Trained jointly

    4. Continuous-State HMM:

    # States are continuous (not discrete)
    
    class ContinuousHMM:
        """
        Hidden states = Continuous variables (e.g., "bullishness score")
        Not discrete categories
        """
    
        def __init__(self):
            # Gaussian process for continuous states
            self.state_gp = GaussianProcess()
    
        # Training uses Kalman filter instead of Baum-Welch
        # But conceptually similar

    📚 Kết Luận

    Tại Sao Baum-Welch Quan Trọng?

    1. Foundation of Machine Learning:

    Before Baum-Welch (pre-1960s):
    - Rule-based systems
    - Expert knowledge required
    - Brittle, doesn't generalize
    
    After Baum-Welch:
    - Data-driven learning
    - Automatically extract patterns
    - Scalable, adaptive
    
    Baum-Welch proved:
    "Machines can learn from data without explicit programming"
    
    This philosophy underpins ALL modern ML

    2. Bridge from Theory to Practice:

    Academic achievement:
    - Elegant mathematical framework
    - Solves unsupervised learning problem
    - Guaranteed convergence (to local optimum)
    
    Practical impact:
    - Actually works in real world
    - Scales to large datasets
    - Robust to noise
    
    Rare combination of theoretical beauty + practical utility

    3. Versatility Across Domains:

    Speech recognition ✓
    Natural language processing ✓
    Bioinformatics ✓
    Finance ✓
    Robotics ✓
    Computer vision ✓
    
    Any problem involving:
    - Sequential data
    - Hidden structure
    - Uncertainty
    → Baum-Welch applicable

    4. Inspiration for Modern AI:

    Baum-Welch → EM algorithm → Variational inference
                ↓
             RNNs, LSTMs
                ↓
          Transformers (attention)
                ↓
          GPT, BERT, etc.
    
    The idea of learning hidden structure from observations
    is central to all modern deep learning

    Renaissance Technologies: Living Proof

    The ultimate validation:

    Theoretical algorithm (1960s)
           ↓
    Applied to finance (1990s)
           ↓
    $40,000 return on $1 investment (30 years)
           ↓
    $31 billion for Jim Simons
    $1+ billion each for Brown & Mercer
    
    Numbers don't lie.
    Baum-Welch + Data + Genius = Unprecedented wealth

    Bài Học Cho Traders/Investors

    Key takeaways:

    1. Data > Intuition

    Traditional: "I feel like BTC will go up"
    Baum-Welch: "Given observed patterns, P(up) = 0.67"
    
    Emotion vs. Probability

    2. Hidden structure exists

    Markets SEEM random
    But underlying regimes exist
    
    HMM reveals them

    3. Automation is possible

    If speech can be recognized by algorithms,
    If languages can be translated by algorithms,
    Then markets can be traded by algorithms
    
    It's all pattern recognition

    4. Math works

    Baum, Welch, Simons, Brown, Mercer:
    All mathematicians/scientists
    
    Not MBAs, not finance bros
    PhDs in STEM
    
    The quantitative approach WORKS

    5. Continuous learning required

    Baum-Welch is iterative (EM algorithm)
    → Keep improving with more data
    
    Similarly, traders must:
    - Continuously update models
    - Adapt to new market regimes
    - Never stop learning

    Tương Lai

    Evolution continues:

    1960s: Baum-Welch (classical HMM)
    1990s: Applied to finance (RenTech)
    2010s: Deep learning revolution
    2020s: LLMs, transformers
    2030s: ???
    
    But core principles remain:
    - Learn from data
    - Model uncertainty
    - Find hidden patterns
    - Iterate and improve
    
    Baum-Welch lives on in spirit

    Opportunities for individuals:

    # You can use Baum-Welch TODAY
    
    from hmmlearn import hmm
    import numpy as np
    
    # Your trading data
    returns = get_price_returns()
    
    # Train HMM
    model = hmm.GaussianHMM(n_components=3, covariance_type="full")
    model.fit(returns.reshape(-1, 1))
    
    # Predict regime
    current_regime = model.predict(returns[-20:].reshape(-1, 1))[-1]
    
    if current_regime == 0:  # Bull regime
        go_long()
    elif current_regime == 1:  # Bear regime
        go_short()
    else:  # Neutral
        stay_flat()

    Resources to learn more:

    Books:

    • “Speech and Language Processing” – Jurafsky & Martin
    • “Pattern Recognition and Machine Learning” – Bishop
    • “The Man Who Solved the Market” – Zuckerman

    Courses:

    • Coursera: Probabilistic Graphical Models (Stanford)
    • EdX: Machine Learning (MIT)

    Libraries:

    • hmmlearn (Python)
    • Hidden Markov Model Toolbox (MATLAB)
    • Stan (Bayesian HMM)

    Lời Kết

    “The Baum-Welch algorithm is a testament to the power of mathematical thinking applied to real-world problems. From codebreaking to speech recognition to financial markets, it has transformed how we handle uncertainty and extract knowledge from data.”

    Leonard Baum’s legacy:

    Academic: Foundational algorithm in ML
    Practical: Enabled speech recognition, NLP, and more
    Financial: Helped create the most successful hedge fund ever
    
    Not bad for a mathematician.

    For aspiring quants:

    Learn the math (probability, statistics, optimization)
    Study the algorithms (HMM, EM, ML)
    Get the data (collect, clean, process)
    Build the models (backtest, validate)
    Deploy (automate, monitor, iterate)
    
    Follow the path of Baum, Simons, Brown, Mercer
    
    The tools are available.
    The data is accessible.
    The opportunity is real.
    
    Will you be the next Renaissance?

    📚 Tài Liệu Tham Khảo

    Sách

    “The Man Who Solved the Market” – Gregory Zuckerman

    “Speech and Language Processing” – Dan Jurafsky & James H. Martin

    • HMM for NLP
    • Baum-Welch algorithm explained
    • Viterbi algorithm

    “Pattern Recognition and Machine Learning” – Christopher Bishop

    • Chapter 13: Sequential Data
    • HMM theory and applications

    Papers

    Original Baum-Welch papers:

    • Baum, L. E. (1972). “An Inequality and Associated Maximization Technique in Statistical Estimation of Probabilistic Functions of a Markov Process”
    • Baum, L. E., et al. (1970). “A Maximization Technique Occurring in the Statistical Analysis of Probabilistic Functions of Markov Chains”

    IBM’s statistical NLP:

    • Brown, P. F., et al. (1990). “A Statistical Approach to Machine Translation”
    • Jelinek, F. (1998). “Statistical Methods for Speech Recognition”

    Online Resources

    Tutorials:

    Code:

    # hmmlearn library
    pip install hmmlearn
    
    # Example notebook
    https://github.com/hmmlearn/hmmlearn/blob/main/examples/

    Khóa Học

    Bootcamp Blockchain Mastery

    Module: Machine Learning for Trading

    Học cách áp dụng ML (bao gồm HMM) vào giao dịch:

    • Hidden Markov Models for regime detection
    • Time series analysis
    • Statistical arbitrage
    • Backtesting ML strategies

    👉 Tham gia Bootcamp Blockchain Mastery

    Bắt Đầu Trading

    Bitget – API cho algorithmic trading:

    • Python API integration
    • Real-time data feeds
    • Low-latency execution
    • Built-in trading bots

    Bài viết được biên soạn bởi Hướng Nghiệp Công Nghệ. Nguồn: “The Man Who Solved the Market”, academic papers on HMM, Renaissance Technologies history. Tìm hiểu thêm về machine learning và quant trading.

    Tags: #BaumWelch #HMM #MachineLearning #QuantTrading #Renaissance #Algorithms

    Đặng Trí Thanh

    Đặng Trí Thanh

    Giám đốc Công nghệ · DNT Digital · Giảng viên HNDL Hướng Nghiệp Dữ Liệu
    1.398 Bài viết
    15.4k Người theo dõi
    120k+ Lượt đọc

    Đặng Trí Thanh — Founder & CTO · Hướng Nghiệp Dữ Liệu - DNT Digital. Chuyên đào tạo và triển khai thực chiến Python, MT5 và hệ thống bot auto trading / IB cho học viên và doanh nghiệp.

    Thẻ: (chưa gắn thẻ)

    Bài viết liên quan

    DNT DIGITAL

    🤖 AI CODE: Vibe Code NEEDED! 🚀 🏦 SSI • DNSE • MT5 • Bitget ⚡

    Zalo 0934145100
    Khóa đào tạo
    Hỗ trợ

    Được học lại miễn phí · Hỗ trợ trọn đời · Cập nhật miễn phí

    Đội ngũ hỗ trợ

    Đặng Trí Thanh
    Đặng Trí Thanh
    Giám đốc Công nghệ DNT Digital
    Zalo 0934145100
    Mộng Cầm
    Mộng Cầm
    Hỗ trợ khách hàng · Huấn luyện viên
    Zalo 0927909257
    Khánh Linh
    Khánh Linh
    Hỗ trợ khách hàng · Huấn luyện viên
    Zalo 0927909582