56 posts tagged with "practice"

This is the third installment in the engineering series on the Air Combat Dynamic Mission Replanning System (SDC). In the previous episode, Air Combat Mission Replanning #2: Stack Spike & Doctrine, we validated the technology stack spike against 6 criteria and structured the operational threat matrix (T1T12) and system bottleneck hypotheses (H1H9) grounded in the ROK 2022 Defense White Paper.

This article documents the engineering work conducted on October 24, 2026, focusing on the M6 messaging and cryptographic security core engine. We address the challenges of ensuring reliable, tamper-proof state synchronization between ground Command & Control (C2) nodes and airborne fighters (F-16C, F-15K) over tactical data links (Link 16). We detail our zero-dependency implementation of RFC 8785 JSON Canonicalization Scheme (JCS) to eliminate cross-runtime (.NET/C# vs CPython) floating-point drift, our raw wire-byte Ed25519 multi-signature envelope architecture, and our resolutions for Defect A-01 (0.7 KB small envelope fragmentation failure) and Defect B-05 (signed delta benchmark distortion).

Figure 1: RFC 8785 deterministic JCS canonical hashing pipeline, Ed25519 raw wire-byte cryptographic envelope, and Link 16 MTU fragmentation architecture.

This is the second installment in the engineering series on the Air Combat Dynamic Mission Replanning System (SDC). In the previous episode, Air Combat Mission Replanning #1: Architecture & KLM Analysis, we established the multi-tier distributed architecture, overcame the CPython 14.5s latency barrier, optimized GPU memory to 0.80 GB, and numerically validated the F-16C fuel integration model via 4th-order Runge-Kutta (RK4).

This article documents the engineering facts from October 23, 2026, when we conducted Technology Stack Spike (a) to de-risk core feasibility before full distributed prototype implementation. We present the verification of 6 quantitative pass criteria, along with the formulation of Operational Threat Situations (T1~T12) and System Bottleneck Hypotheses (H1~H9) derived from official doctrine analysis.

Figure 1: Architectural overview of Stack Spike (a) verification metrics and the ROK 2022 Defense White Paper-grounded T1~T12 operational threat matrix.

💡 Executive Summary (TL;DR)

• The Target: Designing an end-to-end mission-critical software architecture for in-flight dynamic mission replanning (F-16 and F-15E air combat operations), generating and verifying tactical delta packages within 5.0 seconds over tactical data links (Link 16).
• Real Engineering Pitfalls Encountered:
  1. The 31.4s CPython Search Latency Wall: Pure Python A* graph search over a 100 km × 100 km Digital Elevation Model (10^7 nodes) consumed up to 31.42 seconds (48.0s in ridge lines) due to dynamic object boxing, heap fragmentation, and runtime ray-casting, failing quality standard Q_3(<= 5.0 s).
  2. 8GB VRAM Dual-LLM CUDA OOM Trap: Loading two generative 7B/8B language models simultaneously demanded 11.44 GB VRAM (weights + KV-cache + CUDA overhead), immediately triggering torch.cuda.OutOfMemoryError on single-GPU developer workstations.
  3. Ground-Truth Circularity in Fuel Metrics: Stating a "\pm 1\% calculation accuracy" without access to classified military aerodynamic polar tables created an untestable circular definition.
• Clean Production Fixes:
  1. Pre-baked Viewshed Maps & 2D Manifold A*: Pre-computed radar lines-of-sight into a contiguous 2D float NumPy matrix during scenario loading, combining 2D horizontal A* exploration with analytical altitude clamping to slash search latency to 0.259 seconds (1/20th of the 5.0s budget).
  2. KV-Cache Elimination & 4D Cost-Weight Vectorization: Discarded generative autoregressive text generation in favor of a 0.28 GB encoder (DeBERTa-v3-small) and an MLP predicting a 4D cost vector w ∈ [0, 1]^4, reducing required VRAM to 0.80 GB (90% headroom on 8GB GPU) with zero coordinate hallucination.
  3. RK4 Numerical Ground Truth: Formulated an independent Runge-Kutta 4th Order numerical integration engine calibrated via publicly released Breguet range equations (c_0 = 0.131227 hr^{-1), achieving a maximum relative error of 3.31 × 10^{-5 to mathematically verify Q_2.

💡 Executive Summary (TL;DR)

• The Target: Scaling automated fiscal surveillance to all 23,825 anomaly sub-items detected across the 677.4 trillion KRW South Korean national budget, executing standardized decisions via a 5-Option Matrix (full cut, mediation adjustment, 48-hour minister summons, criminal prosecution, legitimate exception pass).
• Real Engineering Pitfalls Encountered:
  1. sqlite3.OperationalError: database is locked and I/O starvation under rapid multi-record ingestion.
  2. Double-dipping risk cascades where multi-category violations produced aggregate cut recommendations exceeding 100% of the allocated budget.
  3. Markdown table rendering corruption and Jinja2 syntax crashes during minister summons dossier generation due to unescaped pipes and quotes in procurement titles.
• Clean Production Fixes:
  1. Switched SQLite to WAL mode with PRAGMA synchronous = NORMAL, batching commits into 1,000-case transaction chunks, boosting throughput to 95,000 inferences/sec (total playback in 0.25 seconds).
  2. Built a deterministic PriorityDecisionArbiter with criminal law priority overrides and hard invariant clamping (clamp(cut, 0, budget * 0.70)).
  3. Implemented a robust legal-clause cross-referencing normalizer and safe markdown serializer for the permanent ledger (CUMULATIVE_SURVEILLANCE_AUDIT_LEDGER.md), locking in 121.72 trillion KRW in provisional savings across 23,911 verified cases.

💡 Executive Summary (TL;DR)

• The Problem: Receiving Google AdSense rejection notices citing 'Needs Attention: Low Value Content' (가치가 별로 없는 콘텐츠) and intermittent 'Site Down or Unavailable' (사이트 다운 또는 사용할 수 없음) despite hosting over 70 original, deep engineering articles.
• 3 Deep Root Causes Identified:
  1. Thin/Scaled Content Penalty: 7 automated machine-translated locales (de, es, fr, ja, pt-BR, zh-Hans, zh-Hant) ballooned the crawl surface to over 650 URLs, diluting domain authority with thin programmatic translations.
  2. YMYL Sensitive Content Policy Risk: AdSense script declared statically in docusaurus.config.ts leaked ad tags and slots onto sensitive mental health crisis research posts (/blog/mental-crisis*).
  3. Cloudflare WAF Crawler Interception: Cloudflare's Bot Fight Mode and conflicting skip rules blocked Google AdSense crawlers (Mediapartners-Google) with HTTP 403 Forbidden challenges, triggering false "site unavailable" rejections.
• The Production Fix:
  1. Dynamic Contextual Script Injection: Built a client-side route guard in Root.tsx that enforces window['adsbygoogle'] = { pauseAdRequests: 1 } and strips ad containers on YMYL paths.
  2. Strict Locale Consolidation & GSC API Purge: Pruned the build down to 2 author-curated core languages (en, ko) and programmatically purged 7 obsolete sitemaps from Google Search Console via official Webmasters REST API.
  3. Cloudflare WAF Rule Optimization: Resolved Code 10041 parameter conflict, disabled indiscriminate Bot Fight Mode, and configured verified bot pass-throughs.

💡 Executive Summary (TL;DR)

• Nationwide Educational Scope: Extended our public budget surveillance architecture to encompass all 17 Metropolitan & Provincial Offices of Education (Seoul to Jeju), auditing 9.08 trillion KRW in targeted educational grant expenditures via K-EduFine (K-에듀파인) ledgers.
• 4 Critical Waste & Collusion Signatures: Automated deep audits on: (1) 학생 1인 1스마트기기 맞춤형 규격 독점 조달 및 입찰담합 (Smart Device Bidding Collusion), (2) 연말 교부금 불용 방지용 2천만 원 쪼개기 수의계약 (Facility Split Contracts), (3) 선심성 입학축하금·스마트바우처 현금 살포 (Populist Cash Handouts), and (4) 교부금 수조 원 안정화기금 적치 및 시중은행 금고 유착 (Stabilization Fund Collusion).
• 3 Production Bottlenecks Resolved:
  1. Variable Schema Drift & Primary Key Collisions: Standardized conflicting school entity keys across 17 isolated K-EduFine database instances using a composite salted identifier hash.
  2. Bipartite Graph Recursion Stack Overflow: Eliminated RecursionError and 3.8GB memory spikes on dense school-subcontractor loops using Tarjan's Strongly Connected Components (SCC) Cycle Breaker.
  3. HWPX Table Cell Span Mismatch: Resolved ParseError: mismatched tag during complex multi-statute penalty table generation via a declarative schema-strict XML table balancer.
• Quantitative Verification: Identified 282 serious violations totaling 1.51 trillion KRW in educational losses, issuing 2.41 trillion KRW in statutory clawbacks and discretionary grant reductions across all 17 Superintendents of Education via standard KS X 6101 HWPX legal notices (5/5 PASS).

💡 Executive Summary (TL;DR)

• Nationwide Scope: Expanded our public procurement audit intelligence system to encompass all 243 local governments (17 metropolitan and 226 basic municipal entities), ingesting 40.24 trillion KRW in local subsidies via the eHojo+ and Local Finance 365 backbones.
• 4 Critical Fraud Patterns: Automatically audited 4 severe leakages: (1) 국비 매칭결손 (Matching Deficit), (2) 가장납입 (Fictitious Self-Finance), (3) 간접비 붕괴 (DEI Indirect Cost Collapse), and (4) 중복수급 (Cross-Border Duplicate Grants).
• 3 Production Bottlenecks Resolved:
  1. Concurrency Deadlock: Fixed HTTP 504 Gateway Timeouts across 243 scrapers using asyncio.Semaphore(10) with jittered exponential backoff.
  2. Schema Discrepancy: Resolved unhandled XML structural variations between metropolitan nested trees and basic flat tables via a polymorphic SchemaAdapter DTO.
  3. File Descriptor Exhaustion: Fixed OSError: [Errno 24] during batch generation of 37 KS X 6101 HWPX recovery orders using deterministic ContextManager streams.
• Quantitative Verification: Identified 2,163 violations totaling 5.63 trillion KRW in losses, automatically issuing 10.55 trillion KRW in clawback orders (including statutory punitive surcharges under Public Finance Recovery Act Art. 9) across 37 high-risk jurisdictions with 100% test harness pass (5/5 PASS).

📌 Executive Summary (TL;DR)

• The Problem: Running npm audit fix --force on deep transitive dependencies (packages nested inside direct dependencies) frequently forces destructive major framework downgrades, breaking modern React 19 and bundler toolchains.
• The Solution: Declare targeted replacement rules using npm v8.3+ overrides in package.json to pin safe patch versions without waiting for upstream maintainer PR releases.
• CI/CD Hardening: Eliminate non-production build-tool noise in GitHub Actions workflows using npm audit --omit=dev --audit-level=high.

⚠️ Clinical Safety & Crisis Operations Protocol Notice
This article is a dedicated systems engineering whitepaper detailing model validation integrity and data leakage prevention algorithms for high-stakes crisis response infrastructure.

• United States / Canada: Call or text 988 (Suicide & Crisis Lifeline).
• United Kingdom: Call 111 (NHS Mental Health Services) or 116 123 (Samaritans).
• International: Visit findahelpline.com for verified confidential local crisis services worldwide.
  All logs, numerical walkthroughs, and text snippets in this article have been 100% pseudonymized and synthetically generated to strictly prevent clinical PII leakage.

⚠️ Clinical Safety & Crisis Operations Protocol Notice
This article is a dedicated systems engineering whitepaper detailing numerical stability and ordinal probability calibration algorithms for high-stakes crisis response infrastructure.

• United States / Canada: Call or text 988 (Suicide & Crisis Lifeline).
• United Kingdom: Call 111 (NHS Mental Health Services) or 116 123 (Samaritans).
• International: Visit findahelpline.com for verified confidential local crisis services worldwide.
  All logs, numerical walkthroughs, and text snippets in this article have been 100% pseudonymized and synthetically generated to strictly prevent clinical PII leakage.

[Clinical Helpline & Safety Notice]
This article explores the mathematical debugging, probability theory, and longitudinal time-series state fusion in high-stakes suicide crisis NLP systems. If you or someone you know is experiencing acute emotional distress or thoughts of self-harm, immediate professional help is available 24/7:

• United States: Call or text 988 (Suicide & Crisis Lifeline).
• United Kingdom: Call 111 (NHS Mental Health Services) or 116 123 (Samaritans).
• International: Visit findahelpline.com for verified confidential local crisis services worldwide.
  All logs, numerical walkthroughs, and text snippets in this article have been 100% pseudonymized and synthetically generated to strictly prevent clinical PII leakage.

In consumer chatbots or product recommendation engines, an artificial intelligence error rate of 5% is an acceptable trade-off or a minor nuisance. In AI systems engineered for suicide crisis monitoring and psychiatric emergency triage, a single False Negative (missed crisis) is catastrophic.

When an individual in acute despair reaches out or journals about ending their life, machine learning pipelines cannot afford to hide behind high overall accuracy or balanced macro-F1 averages.

Today, we officially inaugurate a major technical production series: [High-Stakes Crisis AI: Building a Precision Suicide & Mental Health NLP Detection Pipeline].

This comprehensive devlog documents the exact mathematical hurdles, algorithmic trade-offs, and runtime bugs encountered while engineering Maeumjigi, an enterprise-grade multimodal crisis detection system. In this Episode #1, we tackle the foundation of the architecture: sentence-level deep NLP crisis triage under extreme class imbalance, where active suicidality accounts for a mere 0.16% of daily discourse.

💡 Key Takeaways

• Inspector Web Portal v3.0 Completed: Transformed fragmented CLI scripts into a centralized, real-time command center featuring 7 dedicated workspaces (Overview, 6-Sector Partition, Summons Generator, e-Naradoum Subsidies, Bidding Rings Graph, Budget Cut Analyzer, Precedents & HWPX Validator).
• Full Verification Test Harness Passed (20/20 PASS): Achieved a 100% pass rate across all 20 end-to-end automated test suites, covering Text-to-SQL, GraphRAG, streaming anomaly monitors, DART registry tracking, bidding cartels, and HWPX cost validation.
• 2 Challenges Prevented in Design: (1) Mitigated server bottlenecks by decoupling heterogeneous audit engines behind 12 normalized RESTful DTO endpoints, (2) Prevented browser DOM bloat during continuous streaming via a Circular DOM Ring Buffer.
• 3 Unexpected Production Bugs Resolved: (1) Solved Vis.js infinite physics oscillation and UI freezing via stabilization-triggered physics freezing, (2) Resolved 50-page HWPX XML parsing event-loop blocking via ThreadPoolExecutor async worker queues, (3) Eliminated SQLite file lock contention during parallel test runs via process-isolated in-memory DB mounts.
• Series Grand Finale: Reflecting on the engineering evolution from a simple Text-to-SQL prototype to an enterprise-grade public procurement audit intelligence platform.

📌 Key Takeaways

• Divide & Conquer Full Suite: Filtering 85% routine consumables across 4 million public contracts, we expanded our targeted surveillance pipeline to encompass 6 high-risk sectors (Sectors 1–6) covering structural public corruption corridors.
• Unmasking 2 Elusive Blind Spots:
  1. Sector 5 ($40K Preferential Smurfing): Exploiting statutory affirmative action ceilings ($40,000 / 50M KRW) by clustering split contracts at $39,000 (99.0% threshold proximity), catching $180,000 in evasive awards.
  2. Sector 6 (December Fiscal Dumping): Rushing $120,000 across 3 consecutive sole-source awards within 4 days in late December to avoid budgetary clawbacks.
• 2 Preempted Architectural Hurdles:
  1. Built a Sweet Spot (96–99.8%) Proximity Engine distinguishing genuine social enterprise support from artificial splitting.
  2. Designed Temporal Density & Task Feasibility Analyzers distinguishing standard year-end settlements from rushed dumping where completion is physically impossible.
• 3 Real Production Bugs Resolved: Multi-sector classification collisions resolved via priority weighting, VAT gross/net confusion fixed by reverse-calculating supply costs, and fiscal year carry-over date shifts resolved.

📌 Key Takeaways

• Overcoming the Field Limitation: Addressing our honest admission from Part 2 that "procurement logs alone cannot identify borrowed-name dummy CEOs and decentralized shells", we built a real-time corporate governance ingestion client (CorporateRegistryClient) integrating DART filings and supreme court corporate registries.
• 2 Preempted Architectural Hurdles:
  1. Resolved identifier fragmentation across Tax IDs (10-digits), Court IDs (13-digits), and DART codes (8-digits) via a 3-way hash index bridge.
  2. Prevented knowledge graph explosion by enforcing governance significance thresholds (executive seats + 50%+ equity).
• 3 Real Production Bugs Resolved:
  1. Circular Cross-Shareholding: Fixed RecursionError crashes during recursive ownership traversals using NetworkX Strongly Connected Components (SCC) cycle condensation.
  2. Newly Minted Shell Blind Spots: Added delta-day calculations (<180 days) to flag entities incorporated immediately prior to high-value bids.
  3. 51:49 Spousal Equity Disguise: Unmasked dummy sole-source privilege fronts via compound family relation graph rules.
• Shipped Verification: Unmasked a $130,000 tender where a single hidden individual owned 80% and held board seats across two seemingly competing bidders; 17/17 test suites passed.

📌 Key Takeaways

• Eliminating Alert Fatigue: In massive public procurement feeds where 80–95% of transactions represent routine office consumables, our 3-Dimensional Sector Partition Manager filters out 85%+ noise, focusing deep AI reasoning onto high-risk sectors.
• Anticipated Challenges & Prevention: To handle public API latency and schema deprecations, we decoupled the ingestion tier with an isolated SQLite unaudited buffer queue and exponential backoff retry policies.
• 3 Real-World Production Bugs Resolved:
  1. Caret (^) Multi-Value Delimiters: Legacy API fields returning composite records flattened via regex parsers and strict type schemas.
  2. Browser UI Freezes in Vis.js: Visualizing thousands of knowledge graph nodes caused severe UI lockups, solved by Depth-1 Ego-Network subgraph virtualization, cutting latency by 98%.
  3. Duplicate Contract Alerts: Polling shifts triggered redundant findings, eliminated using SHA-256 fingerprint hashes guaranteeing pipeline idempotency.
• Shipped Artifact: Launched Inspector Web Portal v2.0 with live API sync, a 10-year precedent database, instant HWPX parsing, and 13/13 integration tests passed.

📌 Key Takeaways

• Interim Audit Deployment: Using our production-grade autonomous audit agent (national_budget_ai), we completed a full audit screening across representative public procurement datasets (5 major budget programs and 6 procurement contracts).
• 4 Core Fraud Findings (Strictly Anonymized):
  1. Split Private Contracts: Smurfing contracts under the $20,000 threshold across 12 days to evade competitive bidding ($43,000 total, 94.5% similarity to Supreme Audit rulings).
  2. Shared Address Shell Cartels: 3 dummy vendors sharing the exact same room and building winning exclusive tenders ($158,000 total).
  3. 7x–10x Unit Price Markup: Inflated advisory fees (7.0x median) and GPU server rentals (10.0x median) detected via automated HWPX table parsing.
  4. Low Delivery Efficiency (DEI 30.0%): Only 30.0% of funds reached target beneficiaries, with 70.0% absorbed in administrative overhead.
• System Performance Evaluation:
  • Precision: 0.00% financial calculation hallucination via deterministic SQL AST parsing; 11/11 test suites passed.
  • Throughput: 0.03s per contract to generate complete audit dossiers and statutory enforcement drafts.
  • Field Limitations: Blind spots in borrowed-name owners and multi-tier private subcontracts identified.

📌 Key Takeaways (TL;DR)

• The Goal: Build an autonomous AI agent to audit $500B annual public expenditures, tracking government procurement contracts (KONEPS), fiscal databases (dBrain+), and messy Korean HWPX budget tables to detect price gouging, split contracts, and paper-company cartels.
• Anticipated Challenges & Prevention: Prevented LLM numerical hallucinations by delegating calculations to a Deterministic Text-to-SQL Engine, while isolating relationship and cartel tracking to a Heterogeneous Knowledge Graph (GraphRAG) in a dual-brain architecture.
• Actual Bugs Encountered & Solved: (1) Solved company name and street address fragmentation breaking cartel detection via a robust EntityResolver, (2) Caught temporal split contracts slipping past date filters via a 30-day sliding window algorithm, (3) Overcame auditor distrust of AI black-boxes by building an XAI Dossier Generator binding findings 1:1 with statutory clauses and 10-year official audit precedents.
• Verification: 11 out of 11 regression test harness suites passed, successfully exposing a 38.5M KRW shared-address private procurement cartel and a 70% indirect overhead leakage (DEI score 30%).

Hosting an engineering blog on GitHub Pages under username.github.io/project is one of the most cost-effective and friction-free setups for developers. You push markdown files, Git workflows trigger, and GitHub serves your static artifacts worldwide.

However, as soon as you consider serious branding and monetization, you hit an uncompromising roadblock: Google AdSense strictly bans free secondary subdomains like *.github.io from site application. Furthermore, any search engine authority (PageRank and Domain Authority) you build remains tied to GitHub's domain rather than your personal asset.

To build a professional engineering presence, you need an apex custom domain (e.g., globaldevlog.com). In this first installment of our static blog infrastructure series, we walk through the exact zero-downtime migration blueprint from jbjihwan.github.io/global_blog to https://globaldevlog.com, powered by a high-availability Porkbun + Cloudflare + GitHub Pages 3-tier architecture.

📌 Key Takeaways (TL;DR)

• The Problem: Unlike traditional dynamic CMS platforms (WordPress, Ghost), static site generators (Docusaurus, Next.js SSG, Hugo) hosted on GitHub Pages or Cloudflare Pages frequently trigger the notorious "Earnings at Risk: ads.txt file missing" alert and fail site ownership checks due to client-side hydration delays and crawler blocking.
• The Solution: Inject the publisher verification meta tag directly into <head> using Docusaurus headTags configuration, place the plain ads.txt file in static/ads.txt for root-level deployment, and configure Cloudflare WAF bypass rules for the Googlebot-AdsTxt crawler.
• The Result: 100% automated crawler accessibility, zero 404 crawl errors on /ads.txt, seamless AdSense review compliance, and sustained Lighthouse SEO and performance scores above 95.

Hosting a developer blog on GitHub Pages under username.github.io/project is one of the quickest ways to share technical insights. However, as your readership grows and you prepare for professional monetization, you hit a hard architectural wall: Google AdSense strictly prohibits free subdomains like *.github.io. To qualify for AdSense publisher verification, establish domain equity, and secure multi-region organic reach, you need your own apex custom domain.

Migrating a static documentation or engineering site to a custom domain is not just a DNS record change. It involves coordinating registrar name delegation, edge SSL termination, canonical redirects, automated publisher ads.txt hosting, and navigating subtle search console UI quirks across global and regional search engines.

In this guide, we break down our end-to-end migration from jbjihwan.github.io/global_blog to https://globaldevlog.com, including our zero-downtime DNS architecture, AdSense integration, and actionable solutions for real-world indexing traps in Google Search Console, Naver Search Advisor, and Bing Webmaster Tools.

Every modern frontend developer has experienced this sudden spike of adrenaline: you run npm audit on your clean documentation or blog repository, and the terminal screams back in alarming red text:

45 vulnerabilities (15 moderate, 15 high, 15 critical)
To address all issues (including breaking changes), run:
  npm audit fix --force

Seeing words like Critical, Remote Code Execution (RCE), and Prototype Pollution triggers an immediate instinct: type npm audit fix --force to make the scary red warnings go away.

However, in the world of Static Site Generators (SSG) like Docusaurus, Next.js, or Hugo deployed to GitHub Pages or AWS S3, doing so is often an engineering mistake that breaks production builds without improving your actual security posture.

In this article, we dissect the static site threat model, explain why bundler vulnerabilities differ fundamentally from server vulnerabilities, and share a production-tested 4-Layer Security Hardening Blueprint to protect what actually matters: your secrets, client privacy, and repository integrity.

Welcome to the 24th installment of the Maeumjigi Capstone Project Dev Log.

Following our successful Semester 1 final defense and dual-layer safety wrapper deployment in June, our team officially kicked off Semester 2 (Fall 2026). In the first semester, our primary engineering focus centered on large language model (LLM) fine-tuning (Llama 3.1 8B, Qwen 2.5 32B/7B), synthetic dialogue generation, and prompt safety guardrails.

However, in clinical psychology and psychiatric triage, language is only half of the diagnostic puzzle. Patient risk escalates across time through longitudinal numerical markers: self-reported depression severity (PHQ-9), generalized anxiety (GAD-7), perceived stress, and insomnia scores.

Today's dev log documents our architectural breakthrough in clinical data engineering: moving away from naive imputation methods and engineering a robust 14-Day Last Observation Carried Forward (LOCF) pipeline equipped with Informative Missingness (Missing Not at Random / MNAR) Indicators.

📌 Key Takeaways (TL;DR)

• Problem: Single-frame OCR inevitably suffers from transient misreadings (e.g., 64아1511, 24가1511) due to vehicle yaw, glare, and vibration.
• Solution: Implemented Korean plate regex validation (^\d{2,3}[가-힣]\d{4}$) coupled with a temporal sliding window majority voting engine across a 7-frame buffer (plate_confirm_threshold=3).
• Result: Advanced through 11 system iterations (v01 to v11), transitioning from initial gibberish (ACCIIXOY-1Z01...) on June 5 to deterministic confirmation of 64가1511 on June 7 with 99.4% reliability.

📌 Key Takeaways (TL;DR)

• Problem: Cropped license plates from dashcam footage often measure under 40x20 pixels with heavy H.264 macroblocking; standard bicubic interpolation fails to resolve character contours.
• Solution: Integrated EDSR_x4 deep residual networks (EDSR_x4.pb) that omit batch normalization to preserve dynamic range, combined with temporal multi-frame image stacking across 3 to 5 consecutive frames.
• Result: Quadrupled plate pixel density and sharpened stroke edges, lifting downstream EasyOCR accuracy on Korean characters from 32% to over 91%.

📌 Key Takeaways (TL;DR)

• Problem: Searching for tiny plates (30x15 pixels) across the raw 640x480 frame generates massive false positives from roadside signs and drops inference speed below 10 FPS.
• Solution: Designed a two-stage hierarchical architecture: broad vehicle detection (YOLOv3-tiny) crops the vehicle ROI, within which a fine-tuned YOLOv5 (lp_det.pt, conf=0.6) locates the license plate. Integrated OpenCV CSRT correlation filter tracking with a 15-frame redetection interval.
• Result: Eliminated 98% of background false positives and slashed GPU overhead by 80%, sustaining real-time 50+ FPS continuous tracking.

📌 Key Takeaways (TL;DR)

• Problem: Dashcam footage contains heavy pavement specular reflection, tar cracks, and road shadows that induce false lane lines; simple coordinate checking cannot reliably catch the exact moment of lane encroachment.
• Solution: Implemented vanishing-point trapezoidal ROI masking, slope thresholding (|slope| > 0.5), and a 7-frame temporal moving average queue. Formulated intrusion as geometric IoU between vehicle tire footprints and lane boundaries.
• Result: Filtered out >95% of road texture noise while capturing vehicle lane crossing events with sub-frame accuracy.

📌 Key Takeaways (TL;DR)

• Problem: Low-resolution dashcam footage suffers from severe vehicle vibration, nighttime backlighting, and heavy motion blur, making direct license plate recognition and lane violation tracking extremely error-prone.
• Solution: Designed a unified 6-stage vision architecture: Canny/Hough lane extraction -> YOLOv3 vehicle detection -> polygon IoU lane violation calculation -> YOLOv5 plate localization -> EDSR_x4 super-resolution -> EasyOCR temporal voting.
• Result: Constructed an end-to-end Python pipeline achieving robust vehicle tracking and lane boundary monitoring even under degraded dashcam conditions.

June 18, 2026, marks the triumphant completion of the 1st semester of our university capstone engineering project. From our humble beginnings as a simple Android convention scraper in March, Maeumjigi has evolved into a full-scale, clinical-grade AI mental health counseling ecosystem.

Our final sprint focused on two mission-critical objectives:

1. The Dual-Layer Safety Wrapper: Engineering a bulletproof guardrail architecture to guarantee zero-hallucination crisis intervention.
2. Production Cloud Serving & Final Defense: Sizing AWS EC2 GPU infrastructure budgets and delivering our final faculty presentation.

The final week of May 2026 (May 27–30) proved to be the grand culmination of our experimental modeling phase. After weeks of hyperparameter tuning, GPU out-of-memory crashes, and dataset revisions, our 4th Fine-Tuning cycle (fine_tuning_4) crossed the finish line.

This post reveals the technical breakthrough that resolved the chronic "over-counseling" trap, quantitative validation of our golden weight Checkpoint-4400, and the end-to-end system architecture designed for real-world deployment.

On May 21st and 22nd, the Maeumjigi Capstone team embarked on massive data generation and preparation for the 4th Fine-Tuning (fine_tuning_4).

📌 Key Takeaways (TL;DR)

• Problem: Severe computational constraints on microcontrollers (Arduino Uno ATmega328P with only 2KB SRAM), non-linear wheel slip, noisy ultrasonic sensing, and the classical Reality Gap between Webots simulation physics and physical hardware.
• Solution: Designed a distributed I/O architecture (HC-06 Bluetooth at 115,200 baud) where a host PC runs OpenCV vision processing and Q-Table inference while the Arduino handles low-level PWM motor actuation. Overhead camera lens distortion correction and ArUco marker homography (vision.py) deliver sub-centimeter real-time (x, y, θ) tracking.
• Result: Zero-shot transfer of the simulation-trained 648-state Q-Table achieved an 86.7% target reaching success rate (26/30 trials) in a physical 1.2m × 1.2m arena, successfully closing the reality gap without real-world fine-tuning.

Over the two days of May 19th and 20th, the automation of evaluation for the 3rd fine-tuning (fine_tuning_3) and the enhancement of backend/frontend features for building the actual app service proceeded in parallel.

📌 Key Takeaways (TL;DR)

• Objective: Measure the pure, deterministic performance of the learned greedy policy (ε=0) without exploration noise, validating real-world deployability.
• Methodology: Implemented evaluate_qlearning.py running 30 independent trials across 5 round-robin evaluation seeds, rigorously tracking success rates, path efficiency vs. theoretical shortest routes, and obstacle near-miss counts.
• Result: Tabular Q-Learning attained a 93.3% deterministic success rate in the 12-wall arena with superior path smoothness and ultra-low 0.02ms inference latency, outperforming heavier DQN and SARSA baselines.

📌 Key Takeaways (TL;DR)

• Problem: When a goal lies directly behind an obstacle, the myopic nature of distance-delta rewards (+0.1 × Δdist) pulls the robot into head-on collisions, trapping it in severe Local Minima.
• Solution: Integrated 3-way head-scan obstacle perception (front/left/right) with long-horizon Bellman value propagation (γ=0.99), alongside an automated PowerShell Webots Headless pipeline (headless_run.ps1) executing multi-seed training across seeds 0, 1, and 2.
• Result: The agent successfully learned robust detour policies in the 12-wall arena, achieving a 90%+ goal success rate after 600 episodes.

📌 Key Takeaways (TL;DR)

• Problem: Sparse reward setups (+1.0 at goal, -1.0 at collision) cause severe exploration delays, causing the agent to wander or spin for thousands of episodes before stumbling upon the target.
• Solution: Implemented a multi-objective Dense Reward Shaping mechanism combining potential-based Euclidean distance delta rewards (+0.1 × Δdist) with step (-0.01), turning (-0.01), and backward (-0.05) penalties, paired with exponential epsilon decay (1.0 → 0.05).
• Result: The moving average reward shifted into a steady positive regime (0.7+) within 500 episodes in the no_obstacle scenario, achieving a 98%+ goal success rate.

📌 Key Takeaways (TL;DR)

• Problem: Continuous sensor readings (distance & heading) cause a state-space explosion for tabular Q-learning, and synchronous IPC with the Webots simulator requires low-latency coordination.
• Solution: Designed a geometrically partitioned 5-dimensional continuous sensor mapper producing 3 × 8 × 3 × 3 × 3 = 648 discrete states (discretizer.py) and a line-delimited JSON IPC socket pipeline over TCP port 5000.
• Result: Achieved O(1) fast Q-Table indexing and reliable 32ms physics synchronization between the simulator and Python agent.

Mid-May 2026 was supposed to be a calm interval after wrapping up our 2nd fine-tuning (fine_tuning_2). Instead, May 17th hit our team with a relentless double challenge: condensing hundreds of raw inference metrics into an automated technical report, while simultaneously battling a cryptic HTTP 401 Unauthorized cascading error across our newly integrated FastAPI and PostgreSQL backend.

Here is the complete post-mortem of how we automated our reporting and systematically neutralized the backend authentication breakdown.

On May 13th, after fixing the hardcoding bugs discovered yesterday, we finally resumed proper inference testing for the 2nd round fine-tuned models.

The 2nd round of fine-tuning (fine_tuning_2) parallel training, which was ambitiously started to correct the LoRA hyperparameter mistake (alpha/rank setup error), finally ended on May 12th!

May 8th was the day we were building our capstone design mid-term presentation (PPT) based on the fine-tuning results. However, while happily filling in the slides, I discovered a massive, chilling mistake.

May 7th was the day we synthesized the fine-tuning results of our 5 models (Llama3.3-70B, DSR1-70B, HCX-Omni-8B, Qwen35-9B, HCX-Text-1.5B) and proceeded with full-scale visualization and local environment setup.

On May 6th, we finally escaped the long swamp of fine-tuning! After several nights of work and hyperparameter tuning, the training for mid-size models like HCX-Omni-8B and Qwen35-9B was successfully completed.

After experiencing the OOM (Out of Memory) hell during the fine-tuning of massive 70B models, on May 4th, we attempted a bold change in strategy. By drastically reducing the batch size, we barely managed to push the 70B models (Llama3.3, DeepSeek-R1) to checkpoint-1200 and 1300, but the training time was absurdly long, resulting in terrible efficiency.

On May 3, having gained enough experience with the 8B models, our team finally challenged the ultimate kings of performance: fine-tuning massive 70B (70 billion parameters) models. We attempted to train both Llama 3.3 70B and DeepSeek-R1 70B, but as expected, we hit a massive hardware resource wall.

April 19 is the day we evaluated the performance of the model (M6) trained on the virtual synthetic dataset (v5) we painstakingly created, and wrote the 7th-week weekly report based on it. Was the data we generated while enduring a $10 bill bomb worth it?

April 14, 2026, was a masterclass in distributed pipeline fault tolerance. Following our temporary halt from unexpected API expenditure spikes, our team resumed synthetic data generation (v5) to enrich our empathy training set. However, unlocking higher billing tiers immediately exposed our worker scripts to severe rate-limiting (HTTP 429 Too Many Requests), partial file corruptions, and pipeline stalls.

Here is how we re-engineered the synthesis architecture into a self-healing, unmanned autonomous pipeline.

On April 9, using the Colab notebook we ambitiously completed yesterday, we finally attempted the first training (fine-tuning) of our artificial intelligence model (Llama 3.1). However, reality was not that easy, and we had to face numerous errors. It was also a tough day as we had to simultaneously create the presentation materials for the 6th week of the Capstone Design project.

April 8th was the day we experienced the biggest crisis and a 'laugh-and-cry' happening while working on the Maeumjigi project. It was the Claude API monthly limit exceeded & bill bomb incident.

April 7 was the day we attempted integration by running the frontend code built by a teammate in a local environment, and also the day we launched a massive script using Artificial Intelligence (AI) to 'synthesize' 60,000 new counseling data points to fill our dataset gaps.

April 5, 2026, marked a decisive operational turning point for the Maeumjigi capstone project. Having completed four iterative versions of data cleansing (v1 through v4), our team needed to accomplish two critical engineering objectives:

1. Automated Faculty Reporting: Synthesizing our 120,000-sample preprocessing journey into an executive DOCX report with dynamic statistical charts.
2. Next.js 14 Frontend Scaffolding: Launching the client-side architecture capable of handling low-latency server-sent events (SSE) for streaming model responses.

This is the record of April 3, the day we began in earnest the task of refining the training conversation data to feed into the deep learning model (Llama 3.1). It was also the day we ran a massive pipeline that makes the Artificial Intelligence (AI) read the text and judge the emotion on its own, going beyond simple data merging.

April 1, 2026, was the day our engineering team launched the automated preprocessing pipeline for the massive counseling corpora that would form the foundation of Maeumjigi. Training a high-performance open-source Large Language Model (LLM) like Meta Llama 3.1 requires rigorous data hygiene: converting unstructured multi-party dialogues into clean, token-bounded, and special-token-aligned instruction datasets.

This is the record of March 31, when we conducted the Android build test of the MND Convention reservation alarm app, which was the initial direction of the Maeumjigi project, while simultaneously starting the Llama 3.1 fine-tuning data preprocessing, hinting at a full transition into an AI-based project.

This is the record of March 30, when we officially started developing the 'MND Convention Reservation Alarm' application, which was the initial idea for the Maeumjigi project. Based on the coding rules we set last time, we established a detailed project plan and laid the foundation for Test-Driven Development (TDD).

March 26, 2026, marks the historic first day of our university capstone engineering project. Today laid the structural bedrock for everything to come: adopting an autonomous AI coding assistant (Claude Code), designing team collaboration protocols, and making the pivotal architectural decision that transformed a simple reservation alert tool into Maeumjigi, a specialized AI mental health counseling platform.