Why ScholarMind

ScholarMind helps researchers:

• Capture structured notes from papers
• Compare multiple papers side-by-side
• Support critical literature reviews with explicit gaps, methods, and assumptions

This makes it especially suitable for graduate-level research and peer-review–oriented analysis.

Demo (Bilibili in Chinese)

Purchase Link (Xiaohongshu)

↗ Shop for this (in Chinese)

Update note: I will progressively implement and publish this framework on GitHub (code + diagrams + docs). This post is the conceptual blueprint, and I will keep iterating on it as the implementation matures.

• GitHub: https://github.com/alfredzhang98/Genesis_AGI

1) The Body (Execution & Perception)

“The body is the container of intelligence; it interacts with the physical/digital world.”

• Sandbox (Docker / container)
  • Role: hands and feet
  • What happens here: Python execution, shell commands (e.g., pip install), file I/O, web crawling
  • Property: isolation and safety (protects the host from destructive actions)
• Host launcher (process supervisor)
  • Role: spinal cord / nervous system
  • Responsibilities: keep the process alive, enforce stable runtime settings (e.g., UTF-8), route signals between brain and body (pipes for stdout)
  • Self-healing: detects crashes and can restart/rollback to restore baseline functionality
• Sensors (perception interface)
  • Primary modality: terminal output captured from execution logs
  • The agent “sees” results and “hears” errors by reading its own runtime traces

2) The Brain (Cognition & Control)

“The brain is a state machine (e.g., via LangGraph). The core is context synthesis and robustness control.”

• Planner (Prefrontal cortex)
  • Breaks down tasks, writes code, decides next actions
  • Context synthesis (rolling context): each iteration fuses
    • current goal
    • retrieved memory
    • last generated code
    • last error logs
    • last analysis
  • Produces an updated prompt like: “Given error X and code Y, propose fix Z.”
• Critic (Safety / risk controller)
  • Blocks unsafe or unstable self-modification before it ships
  • Guardrails:
    • Syntax fence: parse/validate (e.g., AST) before writing code to prevent SyntaxError
    • Logic fence: detect destructive changes (e.g., removing required init fields, breaking contracts)
  • If anything fails: feeds back failure type + cause to the Planner and forces a repair iteration
• Learner (Hippocampus)
  • Extracts durable knowledge from interaction traces
  • Distills:
    • Error lessons: “avoid this pitfall” principles
    • Successful solutions: crystallize into reusable skills

3) The Skills (Capability Layer)

“MCP-first, self-forged fallback.”

• MCP integration (primary)
  • Prefer calling standardized tools (filesystem, git, database, etc.) over generating fragile scripts
  • Benefits: stability, reuse, and fast capability acquisition
• Self-forged tools (fallback)
  • Only when MCP coverage is missing (long-tail scraping patterns, custom data cleaning)
  • Evolution path: write script → validate → generalize → package into a reusable tool/module
• Abstract capabilities (meta-skill)
  • The system generalizes from tasks (“fetch weather”) to operations (“information retrieval & extraction”)
  • Next time: first ask “Can an MCP tool do this?” otherwise “What code pattern should I generate?”

4) Memory & Soul (Neurodynamics for Self-Evolving RAG)

“Memory is the engine of evolution. A Vector DB + Neo4j graph enables a jump from raw experience to abstract wisdom.”

4.1 Dual-store memory

• Vector DB (semantic recall / hippocampus): retrieves similar situations via embeddings
  • Stores: task descriptions, error traces, prompt contexts (embedded)
  • Used for: fuzzy recall (“this feels like that other problem”)
• Neo4j (knowledge pyramid / cortex): organizes knowledge into abstraction layers

Knowledge pyramid

• L0: Concrete — Experience, Snippet, ErrorLog (raw inputs/outputs, code, traces)
• L1: Tags — Tag nodes that index and connect similar experiences
• L2: Summaries — Pattern / Insight (natural-language best practices over a tag cluster)
• L3: Wisdom — Principle / Capability (cross-domain rules)

Evolution strategy

• Tag extraction on each result: create new Tag if missing; otherwise link to existing
• Recursive summarization: when a tag accumulates enough experiences, summarize into/refresh Pattern; optionally distill upward to Principle
• Quality gating: only high-confidence experiences participate in higher-level distillation

4.2 High-dimensional memory matrix

Each memory node (N) carries a dynamic weight vector:

Activation probability (for retrieval/usage) is:

Where (\Delta t) is the time since the node was last successfully validated.

• (w_{decay}) (time decay): fights path dependence; stale knowledge becomes harder to activate
• (w_{chaos}) (exploration / entropy): occasionally boosts non-obvious paths (e.g., (\epsilon)-greedy exploration)
• (w_{abstract}) (abstraction level): biases retrieval toward principles over raw snippets when appropriate

4.3 The recursive memory loop

1. Initialize & retrieve: vector recall + graph lookup
2. Propose: Planner generates solution V1
3. Execute & verify (the crucible)
   • On error: store ErrorLog, synthesize new context, iterate
   • On success: store final solution as a Skill, distill lessons into Principle, update indexes
4. Reuse: future tasks start from principles + templates, reducing repeated failures

Why this improves RAG

• Grounds generation in actionable memory (execution logs + validated skills), not just text
• Promotes stable reuse (MCP-first) while keeping a controlled path for new tool creation
• Uses decay + abstraction to reduce outdated or overfitted retrievals
• Adds exploration pressure to avoid local optima and enable genuine evolution

• Repository: https://github.com/alfredzhang98/NeoPeak

Project Overview

NeoPeak is an ultra-compact intelligent terminal featuring:

• LVGL Graphics Framework (v8.1) - Embedded GUI library
• MVC Architecture - Modular firmware design
• Message Framework - Pub/Sub event system
• WiFi/Bluetooth - ESP32 wireless capabilities
• 3D Engine (in development) - 3D model visualization
• Display: 240×240 16-bit color TFT, 60fps target

Key Technical Highlights

Hardware Platform: ESP32-Pico-V3-02

MCU selection requires:

• Main frequency > 150MHz
• RAM ≥ 200KB (112KB for LVGL buffer)
• SPI speed ≥ 50Mbps (for 60fps refresh)

ESP32-Pico-V3-02 chosen for:

• Dual-core, built-in WiFi/Bluetooth
• Arduino ecosystem friendly
• Cost and availability

Firmware Architecture

Three-layer design:

• HAL: Low-level drivers, sensors, MCU peripherals
• Framework: LVGL display, page lifecycle, message system
• Application: UI pages and business logic

Display Integration

• Driver: ST7789 (240×240, 16-bit) via TFT_eSPI
• SPI clock: > 50MHz (IOMUX required for maximum speed)
• LVGL buffer: 112KB, dynamically allocated
• Memory: ESP32’s fragmented 300KB dataRAM requires careful allocation order

Page Scheduling

Inspired by iOS ViewController, implements structured page lifecycle:

• onViewLoad: Initialize views
• onViewDidAppear: Transition animations
• onViewWillDisappear/onViewDidDisappear: Cleanup
• onViewDidUnload: Resource cleanup

Message Framework

Pub/Sub system for sensor data and events:

• HAL publishes sensor events (GPS, IMU, barometer)
• Data processors subscribe and compute metrics
• UI pages subscribe to processed data
• Reactive updates on event changes

Key Implementation Details

• LVGL Porting: Display/File/Input port implementations
• SPI Config: HSPI MISO pin remap to GPIO26 (avoid GPIO12 flash boot conflict)
• Memory: Dynamic allocation for display buffer, careful initialization order
• File System: lv_fs_drv_t must be static/global (not stack-allocated)

References

• Peak - Original hardware and firmware
• X-Track - Framework architecture and LVGL integration
• LVGL - Graphics library
• TFT_eSPI - SPI display driver
• ESP32 Docs - Microcontroller resources

Check out the repository and contribute!

• Repository:
  • GitHub: https://github.com/alfredzhang98/atom_aiot

What this repo is for

Hands-on “edge intelligence + hardware,” including:

• Power‑up (“bring‑up”) of common development boards and peripheral drivers (UART, I2C/SPI, timers, PWM, DMA, ADC, etc.)
• Sensor/actuator integration and debugging (IMU, barometer, motors/servos, displays, radios, etc.)
• Reusable firmware scaffolding and drivers (primarily C/C++)
• Measurements and tuning logs (power, timing, link robustness, debouncing and filtering)

Repository structure (growing)

• iot_developboards/: PCB development boards hardware folder
  • Schematics, layouts (e.g., Altium), BOM, test points, power domains
  • Board bring‑up notes, self‑test checklist, minimal working examples
• iot_items/: Interface code folder
  • Peripheral interface/driver code (GPIO, UART, I2C, SPI, PWM, ADC, DMA)
  • Device modules (IMU, pressure/force, displays, motors/servos, radios)
  • Small reference demos with comments

• Repo links:
  • GitHub: https://github.com/alfredzhang98/PyTorch_study
  • README: https://github.com/alfredzhang98/PyTorch_study/blob/main/Readme.md

Repository structure

As described in the README, the repo is organized into three parts:

1) Basic: PyTorch prerequisites and fundamentals (NumPy basics, Tensor basics and advanced usage) 2) Training: Building and training neural networks with PyTorch (autograd, nn module, optim module, and the end-to-end training loop) 3) Application: Practical projects (e.g., computer vision, LSTM motion prediction)

Currently, the Basic, Training and Application parts are complete.

Basic

• Environment sanity check
  • 00_test.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Basic/00_test.ipynb
    • Print PyTorch/CUDA versions and GPU info; quick CPU vs GPU timing.
• NumPy basics
  • 01_numpy.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Basic/01_numpy.ipynb
    • Array creation; shape/ndim; reshape; arange/linspace; axis-wise reductions; simple plotting.
• NumPy for images
  • 02_numpy_pics.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Basic/02_numpy_pics.ipynb
    • PIL/OpenCV interop; channel split/merge; argsort, top-k, and mask generation mini tasks.
• Tensor basics and advanced
  • 03_tensor.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Basic/03_tensor.ipynb
    • Scalar/vector/matrix concepts; core Tensor operations.
  • 04_tensor_advanced.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Basic/04_tensor_advanced.ipynb
    • Indexing/index_select; unbind; chunk/split; and more practical snippets.

Training

• Data pipeline
  • 05_dataset_dataload.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Training/05_dataset_dataload.ipynb
    • Dataset/DataLoader; MNIST example; transform parameters explained.
• Vision preprocessing
  • 06_torchvision.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Training/06_torchvision.ipynb
    • torchvision.transforms: Resize/CenterCrop/RandomCrop/FiveCrop/Flip/Normalize/RandomErasing; PIL ↔ Tensor conversions.
• Pretrained models and fine-tuning
  • 07_models.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Training/07_models.ipynb
    • torchvision.models (e.g., GoogLeNet); transfer learning; utils.make_grid/save_image visualization.
• Convolution and visualization
  • 08_conv01.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Training/08_conv01.ipynb
    • Conv2d parameters (kernel/stride/padding/dilation/groups/bias); manual convolution; dilated conv; channel-wise pseudo-color visualization.
• Loss functions
  • 10_loss.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Training/10_loss.ipynb
    • Squared loss, MSE/MAE recap and derivation snippets.
• Autograd and gradients
  • 11_grad.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Training/11_grad.ipynb
    • Feedforward networks; derivatives/partials and an intuition for autograd.
• Optimization methods
  • 12_optimise.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Training/12_optimise.ipynb
    • BGD/SGD/Mini-batch; Momentum, RMSProp, Adam; NumPy-only demos (shuffle indices, batch splits, parameter updates); common pitfalls and references.
• Training visualization
  • 14_visual.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Training/14_visual.ipynb
    • wandb/tensorboard usage; SummaryWriter for logging loss; suggested log directory structure and commands.
• Speeding up training and distributed
  • 15_train_fast.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Training/15_train_fast.ipynb
    • Single-/multi-GPU and multi-node setups; nccl/gloo backends; init_process_group/env vars; enumerating devices; DDP best practices.

Application

• Image Classification
  • 16_image_classification_basic.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Application/16_image_classification_basic.ipynb
    • Basics of image classification tasks.
  • 17_image_cllssification_code.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Application/17_image_cllssification_code.ipynb
    • Practical code examples for image classification.
• Image Segmentation
  • 18_image_segmentation_basic.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Application/18_image_segmentation_basic.ipynb
    • Introduction to image segmentation concepts.
  • 19_image_segmentation_code.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Application/19_image_segmentation_code.ipynb
    • Implementation of segmentation models (UNet etc.) and training scripts.
    • 19_image_segmentation_train.py: Training script for image segmentation.
    • 19_image_segmentation_val.py: Validation script for image segmentation.
• NLP Basics
  • 20_nlp_basic.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Application/20_nlp_basic.ipynb
    • Natural Language Processing fundamentals.
  • 21_nlp_attention.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Application/21_nlp_attention.ipynb
    • Understanding Attention mechanisms.
• Advanced NLP Applications
  • 22_lstm_emotion.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Application/22_lstm_emotion.ipynb
    • Emotion classification using LSTM.
    • 22_lstm_emotion.py: Python script version of the LSTM emotion classification.
  • 23_bert_emotion.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Application/23_bert_emotion.ipynb
    • Emotion classification using BERT.
  • 24_bart_abstract.ipynb: https://github.com/alfredzhang98/PyTorch_study/blob/main/Application/24_bart_abstract.ipynb
    • Text summarization/abstract generation using BART.
    • 24_bart_main.py: Main execution script for BART summarization.
    • 24_bert_test.py: Test script for BERT/BART models.

How to use

• Browse online: click the GitHub links above to open each .ipynb.
• Run locally: create a fresh Conda env; install PyTorch, torchvision, numpy, matplotlib, Pillow, etc.; then open in Jupyter or VS Code.

Next steps

The learning phase is now complete. The next major update will focus on implementing modern architectures from scratch:

• Hand-rolled Implementations: Implementing Transformer, ViT (Vision Transformer), and other key frameworks from scratch to understand their inner workings.
• Minimal Testing: Performing minimal testing to verify the correctness of these implementations.
• Keep refining training/tuning/visualization patterns into reusable templates.

If you’re also learning PyTorch, feel free to star and discuss!

Acknowledgment & Reference

• The site is based on AcademicPages (MIT). Repository: link
• The theme is Minimal Mistakes (MIT). Many thanks to the authors and community.

Why these changes

• Better project presentation for research: ordering, date ranges, ongoing highlights, and readable funding.
• Bilingual browsing (EN/中文) while preserving the correct author name across translations.
• Layout stability across very short and very long pages; avoid footer “floating” and translation UI layout shifts.

Key changes (features and UX)

• Projects index and cards
  • Sorting: primary by front matter order (ascending), then by date (descending).
  • Ongoing detection based on start/end (supports present/now); subtle green glow on ongoing cards.
  • Media area fixed at 5:3; SVG covers use contain (no crop, full view).
  • Tighter preview text and spacing.
  • Date range normalized as “YYYY.MM — Until now/End time”.
• Funding rendering
  • Funding shown as non-wrapping chips on cards and project pages.
  • On cards, show up to two chips; overflow summarized as “+N”, with a tooltip listing the rest.
• Publications UX
  • Citation lines standardized (IEEE-like) with a copy-to-clipboard button.
  • Small spacing/presentation refinements; no noisy “read more” by default.
• Content authoring
  • PhD project: concise overview and research thrusts; links to the project website and transfer report; normalized dates/tags/cover.
  • RA (insole) project: summary written; contributions and future work clarified; images added; paper link included; metadata normalized.
  • RA (stimulator) project: limited to confirmed facts (stimulation, wireless charging, BLE); contributions summarized; PCB image included.
• Language switching and Chinese fit
  • EN / 中文 switch at top-right (Google Translate underneath); choice persisted via localStorage.
  • Tag “RA” mapped to the Chinese label “研究助理”.
  • Author name enforced: “Qingyu Zhang” ↔ “张清宇”; auto-fixes common mistranslations (e.g., “张庆余”, “Qinyu Zhang”).

  • The switch labels are protected from translation and auto-reset to “EN

    中文”.

  • A MutationObserver catches late DOM changes from the translator to keep labels/names correct.
• Layout and stability
  • Force-hide Google Translate banner/iframes to prevent layout shifts.
  • Footer reworked to a flex-based sticky layout:
    • When content is short, the footer sticks to the bottom.
    • When content is long, it follows naturally after content.
    • No absolute positioning; avoids “floating in the middle”.
  • CV page: stays centered and at a sensible width even with author_profile: false; the PDF viewer has a fallback link.

Compatibility and fallbacks

• Language switching applies run-time text corrections only; it does not modify source Markdown.
• If embedded PDF is blocked, the CV page provides an “Open in new tab” link.
• Sticky footer uses body{display:flex;min-height:100vh;flex-direction:column} and #main{flex:1}; works with and without the sidebar.

Key files (selected)

• Pages and layouts:
  • _pages/projects.html (projects index, ordering/filtering, funding on cards)
  • _layouts/cv-layout.html (CV layout with centered title and content area)
  • _layouts/single.html, _layouts/archive.html (based on Minimal Mistakes structure)
• Styles (Sass):
  • _sass/layout/_custom_overrides.scss (project cards, funding chips, PDF viewer, sticky-footer structure)
  • _sass/layout/_footer.scss (flex-based footer; no floats)
  • _sass/layout/_navigation.scss (language switch styling and interaction)
• Scripts:
  • assets/js/lang-switch.js (load translator, hide banner, switch logic, name correction, tag mapping, delayed fixes)
  • _includes/scripts.html (script includes)

Development & deployment

• Docker files are provided for quick local preview (Docker Desktop + docker compose).
• Ruby/Jekyll workflows also remain viable, consistent with AcademicPages.

Licensing & attribution

• MIT licenses from AcademicPages and Minimal Mistakes are preserved, along with acknowledgments.
• This document is an incremental changelog over the original template to help future maintainers.

Notes to readers

• If you see translation-induced issues on specific pages, please open an issue with page URL and browser details.

This post publicly claims authorship for the current site implementation and summarizes deltas from the original template.