416 skills · sorted by relevance
Find why MNN CPU inference is slow by examining threads, scheduling, memory layout, and the processor instruction path actually used. Operator-level measurements and comparisons with other inference frameworks help identify which layer needs improvement across ARM, x86_64, and RISC-V.
Find the right workflow for MNN CPU work, from investigating slow execution to implementing calculation routines and planning tests. Compare ARM, x86_64, and RISC-V backend structures before choosing the relevant guidance.
Investigate Node.js bugs by pausing execution, examining variables, and stepping through code. Diagnose stalled asynchronous work and unreliable tests, or collect memory snapshots and CPU profiles to investigate growing memory use and slow execution.
Investigate high CPU usage in Java applications with Arthas. Identify busy threads, inspect method call paths, and produce an evidence-based diagnosis with specific methods to examine next.
Develop or port CPU kernels, the low-level calculation routines used by MNN. Follow staged implementation guidance, check data layout agreements, register functions, and verify correctness across processor instruction sets and numerical precision settings.
Run language models locally with llama.cpp on CPUs, Apple Silicon, or AMD and Intel GPUs. The skill guides model setup, memory-saving GGUF format choices, interactive chat, and serving models through an OpenAI-compatible API.
Get guidance on distributed training with PyTorch FSDP, which splits model parameters across devices. The skill covers implementation, mixed precision, moving data to CPU memory, communication setup, and debugging distributed training code.
Investigate performance bottlenecks in REA analysis workflows and improve caching, queries, or shared processing. Compare completed tasks before and after changes while preserving correct results, examined coverage, and access to supporting evidence.
Guides you through running large language models on CPUs, Apple Silicon, and AMD or Intel GPUs. Covers choosing GGUF model files, reducing memory through quantization, and starting an OpenAI-compatible chat server.
Convert LLMs to GGUF and reduce model size through quantization, which stores weights at lower numerical precision. Prepare models for CPU or Apple Silicon inference, compare compression levels, and integrate them with local AI tools.
Inspect CPU, memory, disk, and accelerator information alongside container and scheduler limits. Produce a JSON snapshot with identifying details removed and conservative worker and memory estimates for planning local workloads, without running stress tests.
Learn how GPT language models work by preparing text, training a small model, and generating samples. Covers CPU experiments, custom datasets, further training of pretrained GPT-2 models, and reproducing GPT-2 with multiple GPUs.
Diagnose frozen or slow Qwen Code sessions on the current machine by checking CPU and memory usage, process states, child processes, network connections, and debug logs. Receive a diagnostic report with suggested next steps, without stopping processes.
Adjust application capacity on GKE through manual scaling, HPA for changing the number of running pods, and VPA for adjusting CPU and memory allocations. Includes configuration templates and a workflow for reviewing resource requests against actual usage.
Learn how GPT language models work by preparing text, training a small model, and generating samples. Covers CPU experiments, custom datasets, further training of pretrained GPT-2 models, and reproducing GPT-2 with multiple GPUs.
Investigate slow rendering, choppy scrolling, and high CPU or memory use in SwiftUI apps. Review code for likely causes, guide user-run measurements with Instruments when needed, and prioritize fixes with evidence and validation steps.
Compare Zephyr changes using the same prepared dataset and matching execution settings. Analyze Finelog metrics for each processing stage to distinguish CPU efficiency, elapsed time, and peak memory changes, then report improvements, regressions, or tradeoffs.
Diagnose running Java applications with Arthas. Follow guides for high CPU usage, retrieving EagleEye request tracking IDs, and inspecting Spring configuration and managed objects, then summarize evidence and next steps.
Reduce Google Kubernetes Engine costs by adjusting CPU and memory requests, setting resource quotas, and choosing Spot VMs or committed use discounts. Match spending decisions to steady usage, variable demand, and workloads that tolerate interruptions.
Inspect Mac performance to find processes using excessive CPU, GPU, memory, or energy. Combine measurements with explanations of known system processes to diagnose slowness, heat, and startup load, then recommend actions without changing system settings.
Diagnose errors and incorrect inference results in MNN's QNN backend for Qualcomm HTP processors. Compare intermediate calculation data against CPU results to locate the first faulty operator, distinguish bugs from precision limits, and guide operator support and performance fixes.
Add PyTorch FSDP2 to training scripts so model state can be split across GPUs. Covers distributed initialization, mixed precision, CPU offloading, and checkpoint saving and loading for models that exceed a single GPU's memory.
Convert language models to GGUF and reduce their size through quantization, which stores model weights at lower precision. Guides cover compression choices, local inference on CPUs and Apple Silicon, and integration with tools such as Ollama.
Profile app launches and individual user flows in iOS Simulator with ETTrace. Collect traces with readable function names, identify CPU-heavy call stacks, and compare performance changes when recording conditions are consistent.