Ziqian Bi 毕梓仟

A deployment-oriented solar-panel defect-detection project covering EL/PV imagery, dataset organization, model workflow, and public documentation. It is a strong applied computer-vision project because it connects defect recognition with deployable project packaging instead of stopping at a notebook result.

A local-first LLM benchmark platform built with Django, Vue, PostgreSQL, RabbitMQ, Celery, SSE, and multi-provider model execution. It combines evaluation orchestration, dataset pipelines, runtime control, streaming feedback, and experiment management in one coherent AI infrastructure system.

A full-stack AI learning-card system built with Django, Vue, SSE streaming, and multi-provider LLM integration. It combines structured study flows, interactive follow-up, quiz generation, and persistent learning sessions in a polished application layer.

A full-stack ReAct AI agent system built with Python, Django, SSE streaming, and Docker sandboxing for algorithmic problem solving. It combines reasoning-and-acting loops, runtime control, safe code execution, phased trace visualization, and web interaction. The project is closer to agent engineering and systems integration than to a simple prompt wrapper.

A multi-language LeetCode best-solution repository covering C, C++, Java, Python, Python3, C#, JavaScript, TypeScript, PHP, Swift, Kotlin, Dart, Go, Ruby, Scala, Rust, Racket, Erlang, and Elixir. Beyond collecting answers, it emphasizes accurate generation, resumable workflows, structured logs, and unittest coverage, making it a strong algorithm-engineering and automation project rather than a loose solution dump.

A from-scratch educational 64-bit RISC-V emulator with Vector extension support and the ability to boot Linux. The project turns instruction decoding, privilege levels, memory management, devices, vector execution, and operating-system boot into an inspectable systems-engineering implementation.

An AI flashcards application built with Django, Vue, PostgreSQL, and Ollama. It supports study-card generation, follow-up learning chat, question interactions, and session-based review in a complete full-stack learning workflow.

A reproduced China Post customer-service intelligent assistant built around Django, django-ninja, SSE streaming, PostgreSQL + pgvector, FAISS, and a swappable LLM backend adapter. It demonstrates a full web/API/RAG workflow for postal-domain dialogue and ticket-generation scenarios while keeping internal internship data and infrastructure out of the public repository.

A hybrid VLM gallery system that turns a local image collection into a searchable multimodal workflow with image understanding, embedding generation, FAISS-style indexing, and a web-facing interaction layer. It is a concrete end-to-end system project covering ingestion, representation, retrieval, and interface delivery rather than a standalone model demo.

A profiling-oriented project that connects training-side instrumentation with a Django-based dashboard for Apple Silicon workflows. It reflects my interest in observability and practical system measurement, especially when running ML workloads on local hardware rather than cloud GPUs.

A distributed consensus teaching lab using FastAPI backend nodes and a Vue dashboard to visualize Raft-style leader election, heartbeats, crash simulation, restart behavior, and cluster state across a 5 x 7 node control panel.

A local-first RAG workspace for industrial documents, compliance references, standards, datasheets, and manuals. The working FAISS version combines Django, HDF5, Celery, SSE, SQLite, and local or routed LLM providers to support document upload, embedding, retrieval, and interactive question answering.

A from-scratch browser guessing-game AI that narrows candidates through yes/no questions and exposes the reasoning path in a simple interactive interface. It is useful as an educational search and decision-tree style demo.

A local Django and django-ninja application for high-throughput MRI quality-control screening. It supports large local or mounted MRI folders, paged NIfTI/DICOM/image previews, slice and axis navigation, rotation, bulk selection, and export of selected MRI paths for downstream filtering workflows.

A real-time industrial sensing system built with Python, Django, Django Ninja, Redis, and RS485/Modbus communication flows for concrete-sensor monitoring. The repository covers protocol handling, backend API services, data acquisition modes, and live monitoring paths, making it much closer to an industrial telemetry platform than to a simple polling script.

A route-planning and city-network visualization platform built around real street graphs. It combines algorithmic routing with high-resolution city rendering, so it is both an algorithms project and a visualization/storytelling project about urban structure.

A Python simulator for mesh-based MIMO FMCW radar scenes with front-facing visibility filtering, signal-generation logic, and multiprocessing acceleration. The repository connects 3D geometry, radar signal modeling, parallel simulation, and sensing-oriented experimentation, which aligns closely with my mmWave and radar-security research background.

A pure frontend maze-algorithm visualization project built with HTML, CSS, and JavaScript. It compares BFS, DFS, A*, right-hand rule, Tremaux, ACO, and SMA on the same generated perfect maze, with synchronized animation controls, explanation panels, parameters, and runtime statistics.

A collection of whitebox machine-learning and deep-learning algorithm animations. Instead of only calling libraries for final outputs, it exposes the internal optimization steps behind SVMs, K-Means, t-SNE, UMAP, DBSCAN, PCA, Random Forests, XGBoost, and optimizers through visual demos.

A collection of experiments around classic chaotic systems and attractors. It is valuable as a mathematically flavored simulation project and as evidence that I enjoy building small exploratory environments, not only production-oriented AI systems.

An AI-assisted automatic-differentiation engine that traces scalar formulas into explicit computation graphs, computes analytical gradients, and exports graph structures as visual artifacts. The repository is useful because it directly shows graph construction and gradient-flow results rather than describing autodiff only at the concept level.

A browser-based Rust/Wasm Gomoku AI with search, evaluation, and a public demo plus documentation. It is a compact but polished game-AI project that makes the engine behavior directly inspectable in the browser.

A browser-based Rust/Wasm Othello AI with bitboards, alpha-beta search, exact endgame search, stability-aware evaluation, and Web Worker parallelism. It complements Gomoku-AI as a second polished game-search project with public demo and docs.

A notebook project that decomposes modern LLM building blocks into stepwise implementations, including tokenization, embeddings, attention, GQA, MLA, MoE, and related model-system ideas. It is designed to connect paper-level concepts with executable engineering intuition, which makes it a useful bridge between theory and implementation.

A GPT-2 inference engine built from scratch for Apple Silicon, moving across NumPy baselines, PyTorch MPS, and C++/Metal-oriented execution ideas. The repository emphasizes Transformer internals, KV cache behavior, memory layout, and inference-system tradeoffs. It is one of my clearest projects for showing model-systems understanding beyond high-level framework use.

An AI-assisted Python implementation of a core Visual Basic compiler pipeline covering lexical analysis, AST construction, semantic checking, IR generation, and emission to portable C. It is a language-systems project that demonstrates compiler architecture, translation pipelines, and program-analysis thinking beyond the usual AI-centered repository set.

A shared-GPU systems toolkit built in Python for environment checks, stress tests, tmux-based job hosting, and polite scheduling on multi-user servers. It addresses a practical infrastructure problem: validating CUDA/GPU health, managing long-running workloads, and resuming jobs responsibly in shared compute environments.

A structured notebook series on MCP systems, covering the path from LLMs and agents to runtime wiring, tool interoperability, and production-style integration. It mixes long-form explanation with runnable minimal implementations, making it useful both as a teaching artifact and as a reference for system integration patterns.

A medical LLM benchmark framework built in Python for exam-style and specialty question-bank evaluation. The project focuses on dataset normalization, model adapter unification, inference orchestration, and metric reporting under a cleaner evaluation skeleton. It is closely aligned with my work on LLM evaluation, medical AI, benchmark engineering, and reproducible experiment pipelines.

The English-facing companion version of ClinicaLLM-OmniBench, preserving the same Python evaluation framework, benchmark structure, and model integration flow. It highlights benchmark design, dataset organization, inference consistency, and reporting logic in a form that is easier to read for an international technical audience.

An agentic arXiv monitoring pipeline built with Python around scheduled scanning, local LLM summarization, Git-based archival, and long-running workflow automation. The repository emphasizes research intelligence, tool orchestration, and reliable agent-style operations rather than one-shot prompting, making it a strong example of AI automation infrastructure.

A from-scratch AI coding agent course and implementation series built with Jupyter Notebook and local Ollama models. It decomposes architecture, tool calling, file operations, planning loops, and execution control into explicit modules. The value of this repository is that it turns agent internals into an inspectable engineering system rather than a black-box demo.

An umbrella repository for from-scratch implementations spanning tokenizers, vision-model reconstruction, and systems-oriented learning modules. The common theme is rebuilding modern AI components in small, readable, testable units. It reflects a hands-on engineering style: understand architectures by implementing kernels, data flow, and interfaces directly.

A PyTorch reimplementation and extension for enhancer-promoter interaction prediction in genomics. The repository expands the search space to multiple encoder families and fusion strategies, including Transformer-like and sequence-model variants, and is designed for reproducible comparison. It is a strong research-engineering project at the intersection of bioinformatics, deep learning, and experiment design.

The English-facing version of the GPU scheduler toolkit. I keep it to make the same systems work readable for a broader audience and to reduce friction when sharing my infrastructure tooling with non-Chinese collaborators or recruiters.

A natural-language search system over a very large MIDI corpus, powered by a ReAct-style local AI agent. The project combines retrieval, metadata indexing, query interpretation, and interactive search over millions of files. It shows how agent-style reasoning can be applied to domain-specific search systems beyond standard coding or QA demos.

A public-data tracking system for comparing Chinese and US LLM ecosystems across capability, pricing, context window, multimodality, and ecosystem signals. The repository combines data collection, normalization, analysis, and visualization, making it a strong example of model-landscape analytics rather than only model implementation work.

A foundational reference repository tied directly to my biomedical sequence-modeling work on enhancer-promoter interaction prediction. It preserves the original setup and serves as an important baseline for later PyTorch reproduction and extension work, making it a key anchor point in my genomics and medical AI project line.

A repository around large-scale Transformer training and distributed systems concerns. I use it to study training topology, parallelism strategy, optimizer behavior, and throughput-oriented engineering decisions. Its value in my portfolio comes from the systems perspective on scaling rather than from claiming authorship of the original framework.

An analysis-oriented notebook repository on vision foundation models, multimodal architectures, and self-supervised representation learning. It focuses on model structure, token/feature behavior, and implementation interpretation rather than only benchmark scores. This makes it useful for connecting papers to concrete engineering choices.

A playbook-style notebook repository for recurring agent patterns, workflow lessons, and reusable engineering practices. It records task decomposition, validation strategies, and day-to-day AI collaboration techniques. The repository is useful as a systems-thinking artifact around agents rather than as a single monolithic application.

The repository for this bilingual personal website, built as a static multi-page front-end system with JavaScript-driven content rendering, theme/language switching, interactive canvas backgrounds, and a local MIDI player. Beyond presentation, it reflects front-end architecture, information design, UI state management, and content-organization decisions in a real deployable site.

A pure-CPU Python renderer that compares rasterization, ray casting, Whitted ray tracing, radiosity, and physically based path tracing in a shared Cornell Box scene. It emphasizes energy conservation, reproducible validation, and a maintainable rendering architecture.

A PyTorch four-quadrant SFCN assessment framework for comparing real and generated MRI through age-bin classification experiments. It organizes real-to-real, real-to-generated, generated-to-real, and generated-to-generated evaluation into one reproducible medical-imaging workflow.

A reproducible CPU validation system for long-running Monte Carlo Tree Search self-play experiments. It preserves checkpoints, metrics, logs, and game records so training behavior can be inspected, resumed, and compared reliably over time.

A graphical RPN scientific calculator built in C++ around ATmega2560, LCD2004, ST7920 12864, a matrix keyboard, and persistent storage. The project combines embedded firmware design, display pipeline control, input ergonomics, math-expression handling, and device-oriented UI architecture, making it a substantial MCU systems project rather than a toy calculator demo.

A compact embedded RPN scientific calculator implemented in C++ on Arduino-class hardware. Compared with the graphical ATmega2560 version, this repository focuses more on resource-constrained firmware structure, stack-machine style input logic, display control, and building a maintainable calculator core under tighter MCU limits.

An embedded Conway's Game of Life implementation on ATmega2560 with LCD12864 graphics output, keypad interaction, and save/load support. Although compact in scope, it exercises framebuffer-style drawing, state-transition logic, storage management, and event-driven control on resource-constrained hardware.

A user-space tiny operating-system simulator in Python with virtual disks, file-system structures, process scheduling, persistence, and shell-like behavior. The project is deliberately systems-oriented: instead of imitating a fake kernel visually, it focuses on state models, storage semantics, scheduling logic, and testable module boundaries.

A high-precision arithmetic library that implements BigInt and BigFloat from scratch in Python without relying on decimal/fractions/mpmath. The repository covers internal number representation, carry/borrow propagation, precision control, and arithmetic API design, making it a concise but technically honest numerical-software project.

An AI-assisted long-horizon Python implementation project for reconstructing the core path from source code to `.pyc` artifacts and simplified virtual-machine execution. It touches tokenization, parsing, bytecode-oriented compilation ideas, and runtime behavior, with an emphasis on stable, testable compiler/runtime engineering rather than a throwaway interpreter demo.

A scientific calculator project that converts infix expressions into RPN and renders expression trees as images. It is a nice bridge between parsing, syntax trees, symbolic structure, and user-facing visualization, so it reads well for both software and education audiences.

An AI-assisted self-hosting C-subset compiler project whose goal is bootstrapping: compile its own compiler source and gradually reduce dependence on the original Python implementation. It brings together parsing, IR/code generation, toolchain interfacing, and bootstrap-chain design, making it one of the strongest low-level software-engineering projects in the portfolio.

A repository connected to multi-type data labeling and annotation workflows. In the context of my portfolio, it is useful as a practical data-engineering and dataset-preparation touchpoint rather than a pure model or algorithm artifact.

An AI-assisted controlled C-subset compiler implemented in Python with a clear pipeline from tokens to IR and backend C emission. It is a disciplined compiler-engineering repository that emphasizes readability, testing, and maintainability over flashy optimization claims.

A reproducible Python and Git workflow documentation project with MkDocs pages and repository-level maintenance notes. It is useful as a public example of disciplined documentation and repeatable development practice.

A fixed-point CORDIC reference implementation covering circular and hyperbolic modes with integer-only iterative kernels. It is a compact signal-processing and numerical-methods project that connects well with my hardware and embedded background.

A pure-Python automatic-differentiation implementation using only minimal numerical support. Compared with ACE, it is more educational and stripped down, making it useful for showing how I simplify complex ML concepts into small, teachable building blocks.

A prototype-grade adaptive Huffman archiver with custom binary packaging, streaming compression ideas, and support for multi-file directory structures. It stands out because it treats a classic algorithm as a full engineering artifact instead of a classroom-only coding exercise.

A DTMF encoder/decoder that generates and analyzes dual-tone telephone signals. It is a compact signal-processing project with direct value for communications understanding and also shows my comfort with lower-level numerical/audio handling work.

A set of robust backup scripts for exFAT-to-APFS workflows with error skipping and logging. Projects like this matter because they reveal how I solve real operational problems pragmatically, not only how I build academic or AI-focused systems.

A single-wire half-duplex Morse telegraph built on paired Arduino boards with symmetric design, bus arbitration, ACK handling, and retransmission logic. It is a small but elegant communication-systems project that shows protocol thinking on simple hardware.

A local AI chat application with personality switching, streaming responses, and markdown/code rendering. It is a good example of translating LLM capabilities into a user-facing product experience with persistence and interaction rather than only an API demo.

A repository dedicated to prime sieves, primality tests, and performance comparison under a unified knowledge structure. It is algorithmically simple to describe, but it reflects the way I package mathematical ideas into reusable, well-documented software artifacts.

A repository connected to the Z3 theorem prover, useful in my portfolio as a symbolic reasoning and formal methods touchpoint. Even when used mainly for study or experimentation, it broadens the range of systems and reasoning tools I am comfortable exploring.

A Python demonstration of the main ideas behind the Appel-Haken style proof of the Four Color Theorem. It is less about claiming a new theorem result and more about turning a mathematically historic proof strategy into a readable computational teaching artifact.

An embedded-media experiment that explores dithering and video-like playback on LCD12864 hardware. It is a playful project, but it still requires careful control of display constraints, preprocessing, timing, and hardware-oriented visual output.

A Bad Apple playback experiment on LCD12864-based hardware. Like the dither-TV project, it uses a familiar media motif to explore real embedded graphics constraints, data preprocessing pipelines, and device-oriented rendering strategies.

A falling-blocks game AI project implemented with Python and Pygame that includes multiple heuristic and search baselines. It is a beginner-friendly game-AI project and a useful example of making algorithms visually inspectable without relying on copyrighted project branding.

A 4096 expectimax AI project built around bitboard state encoding, heuristic evaluation, and search optimization. It keeps the project naming and presentation copyright-neutral while preserving the algorithmic value of the puzzle-AI work.

A browser recreation of the historical Tennis for Two interaction, packaged as a lightweight public demo. It sits in the portfolio as a small but clear interactive/game-history project.

A deliberately simplified Go AI repository that avoids pretending to fully reproduce AlphaGo Zero. I like it because it is honest about scope: it focuses on clear intermediate systems that help explain policy modeling and search ideas without overclaiming completeness.

A project around the Rome16K dataset for urban-scene 3D understanding. It reflects my interest in spatial representation, large-scale scene reasoning, and turning research datasets into a structured engineering playground for experimentation.

A PyTorch-oriented AlphaFold 2 style engineering reproduction targeting an end-to-end monomer prediction path. It is ambitious and research-heavy, and it demonstrates my willingness to tackle complex bio-AI systems that require both modeling awareness and pipeline orchestration.

A PyTorch reproduction effort for the AlphaFold v1/CASP13 route, with an emphasis on covering features, training, inference, structure optimization, and evaluation under a modern engineering layout. It complements the v2 project by showing historical depth as well as technical ambition.

A hardware observability terminal that bridges Prometheus metrics with an ESP32-driven analog display matrix. This project is especially useful in my portfolio because it sits at the intersection of embedded systems, monitoring infrastructure, and design-oriented physical computing.

A physical token-usage display device that maps AI consumption to electromechanical-style output and LCD feedback. It is a creative but practical observability project that turns abstract API usage into something immediately tangible.

A physical telemetry terminal that reads usage data and presents request and token windows on a small LCD display. It is a compact project, but it clearly shows my interest in connecting software analytics with embedded interfaces and low-power edge devices.

A destructive testing and stress framework for SQLite under concurrency, corruption, abnormal termination, and disk/resource pressure. The project is fundamentally about systems reliability: failure modes, crash behavior, recovery semantics, repeatable chaos scenarios, and how storage software behaves under hostile operating conditions.

A teaching-oriented repository for using SpecKit and spec-driven development in practice. It reflects how I turn workflow preferences and engineering discipline into reusable course-like material instead of keeping them as private habits.

A training project around ViT-H/14 on CIFAR-10 using more modern acceleration choices such as Flash Attention, bf16, and compiler support. It is a compact vision-training repo that still touches the kind of performance and scaling concerns relevant to serious model work.

A hardware burn-in and stress-testing project that uses ML workloads to push systems under load. It is useful because it turns abstract 'stress test' ideas into repeatable scripts with meaningful computational behavior rather than synthetic no-op pressure.

A large-scale automation project that generates bilingual LeetCode notes and backdates commits across years of problem history. Beyond interview prep, it is interesting as a content-generation and Git-history simulation pipeline built with repeatability in mind.

A local subtitle-generation tool using Apple Silicon-accelerated transcription plus local translation. It is a practical offline media-AI utility and a good example of combining model inference, platform optimization, and user-facing workflow design.

An automated generator for system-design interview questions and solutions using local LLMs. It shows how I package long-form structured reasoning into a repeatable content pipeline rather than only producing one-off answers manually.

A curated sandbox of MCU and embedded-system prototype ideas spanning sensors, displays, communication, control, and robotics. It acts as a design library for future hardware builds and captures the breadth of my embedded interests beyond any single finished board.

An automated AI paper-reading agent that tracks arXiv, generates Chinese technical interpretations, and commits them into a personal research knowledge base. It is a strong example of applying local LLMs to knowledge management instead of only chat interfaces.

A notebook-based HTTP server implementation using Python's lower-level networking primitives. It is a foundational systems-learning project that is valuable not because it competes with frameworks, but because it makes protocol handling and server structure explicit.

A weather-box system built around ESP32, MQTT, and Django, covering device firmware, communication, and backend services. It is a representative IoT full-stack project because it spans embedded code, transport protocols, and server-side data flow.

A repository summarizing multiple deep-learning projects on brain imaging datasets, including classification, regression, self-supervised learning, and interpretability analysis. It connects directly to my long-running medical AI work on neuroimaging and disease-related modeling.

A teaching-oriented notebook collection on heuristic algorithms with runnable experiments and visualization. It is useful because it shows my habit of presenting algorithms with structure, experiments, and explanations instead of leaving them as bare implementations.

A reinforcement-learning lab built around Gym/Gymnasium tasks, intended as a structured collection of experiments from simple control to more complex settings. It is a broad educational RL workspace rather than a single algorithm claim, which makes it useful for showing range.

A focused reinforcement-learning lab around inverted-pendulum environments, covering methods such as DQN, PPO, DDPG, and SAC. Compared with the broader Gym lab, this repository is more controlled and problem-specific, making it useful for deeper comparative experimentation.

A local AI-assisted LeetCode system with translation, solution generation, streaming output, persistent caching, and deployment support. It is noteworthy because it treats coding-practice tooling as a productized LLM application rather than as a thin wrapper around model calls.

A daily paper-screening and analysis workflow that uses local LLMs to generate Chinese technical notes from arXiv candidates. It complements my other paper projects by focusing on day-to-day research digestion rather than building a larger archival system.

A Gomoku self-play training system using AlphaGo Zero style MCTS and policy-value learning. It is useful as a reinforcement-learning and game-search project that connects planning, self-play data generation, and iterative training loops in a recognizable research format.

A Django demo project integrated with SpecKit ideas, featuring student-management operations and an AI assistant flow. It is small, but it concretely demonstrates how specification-driven workflows can shape a normal web application rather than only a theoretical methodology repo.

A Gomoku engine project built around minimax search and automated game export. It is a smaller search-oriented companion to the RL/MCTS work and shows that I am comfortable with both classical deterministic game search and learning-based approaches.

A tabular risk-modeling workspace that combines classical machine learning and deep learning around a unified preprocessing pipeline. It is useful as an example of practical ML engineering on structured data rather than only vision or language benchmarks.

A repository centered on mmWave FMCW cascade MIMO sensing experiments. Even when not packaged as a polished public framework, it represents the sensing-systems and radar-processing line of work that has been central to my Purdue research experience.

A large-scale ESP32-based intelligent racing-gate control system for drones or RC vehicles, built around centralized wireless networking and event timing. It is one of the more ambitious embedded/networking concepts in the portfolio because it combines distributed nodes, synchronization, telemetry, and control logic.

A workspace around immersive VR/XR security and telemetry ideas. Even if still exploratory, it shows my willingness to look beyond conventional web or model tooling and think about sensing, interaction, and security in more complex real-world environments.

A repository around mmWave radar sensing for security scenarios, especially user-leaving detection and data-protection contexts. It is important in my portfolio because it connects directly to my radar-security research line and to physical attack/defense thinking in sensing systems.

A structured sorting-algorithms repository with correctness validation, benchmarks, and contextual notes on stability and complexity. It is a clean example of how I like to package core CS material into reusable and comparable engineering artifacts.

A repository for search algorithms and data structures that validates lookup semantics and traversal behavior under a unified interface. It is a good foundational CS project and pairs naturally with the sorting repository as part of a broader algorithmic teaching toolkit.

A literature-discovery and taxonomy pipeline for LLM-, RAG-, and agent-related arXiv papers using embeddings, FAISS, and external classification. It is interesting because it treats survey-building as a systems problem involving retrieval, taxonomy design, and large-context classification.

A notebook collection for real-time vision experiments with YOLO, including static images, live camera streams, and multi-object tracking. It is a useful applied-computer-vision repository that shows I can connect models to live input and operational loops.

A notebook-centered LLM training and deployment study repository covering SFT, LoRA/QLoRA, preference optimization, reward-oriented RL data formats, quantization, inference, and deployment workflows for Qwen2.5-7B-Instruct and gpt-oss-20b.

A web-facing AI chat interface repository. Compared with the more customized chat projects, this one is useful as a simpler interaction prototype that captures UI ideas, prompt-to-interface wiring, and lightweight deployment-style presentation.

A deep-learning guide repository organized as long-form technical notes and runnable notebooks. It serves as a structured knowledge base across model foundations, training practice, and implementation details.

A facial-recognition project with public documentation, useful as a focused applied-computer-vision repository around identity features, model workflow, and dataset-facing engineering.

A recommender-systems repository covering classic recommendation workflows, ranking intuition, and experiment organization. It broadens the portfolio beyond vision and language into user-item modeling.

A generative-models repository for studying and implementing core ideas behind modern generation methods. It is useful as a compact research-learning project around modeling distributions and synthesis workflows.

A medical-imaging age and gender modeling project around balanced SFCN-style training. It connects deep-learning implementation with fairness-aware dataset balancing and neuroimaging workflows.

A receipt OCR and multimodal-LLM extraction project for turning messy receipt images into structured information. It fits the practical document-AI line of work around visual parsing, extraction quality, and downstream usability.