ローカルLLM study1-a: gemma4 e2b/e4b の MLX 版はどれだけ速いかThis article benchmarks gemma4 e2b/e4b models running via the MLX framework on…

Running large language models locally on consumer hardware has become one of the more practical frontiers in applied AI, and this benchmark narrows in on a specific corner of it: how quickly the Gemma models in their e2b and e4b configurations run through Apple's MLX framework on Apple Silicon. For developers deciding whether to keep inference on-device instead of routing requests to a cloud API, measured throughput is often the difference between a responsive interactive experience and one that feels frustratingly slow.

MLX is Apple's open-source array framework, built specifically around the unified memory architecture of its M-series chips. Unlike stacks that assume a discrete GPU with a separate memory pool, MLX exploits the fact that the CPU and GPU on Apple Silicon share the same physical memory, which removes copy overhead and lets larger models fit within a given RAM budget. Its API deliberately resembles NumPy and PyTorch, and the companion mlx-lm library provides convenient loading, quantization, and generation utilities for text models. That makes it a natural target for anyone trying to squeeze the most out of a MacBook or Mac mini without external accelerators.

The e2b and e4b labels are worth unpacking, because they do not map directly to raw parameter counts. In the relevant Gemma generation, these suffixes appear to denote "effective" parameter budgets, roughly two billion and four billion, achieved through architectural techniques that keep only part of the network active during inference. The practical implication is that the memory footprint and speed can differ from what a naive parameter count would suggest, which is exactly why an empirical benchmark is useful rather than relying on specification sheets alone. The larger e4b variant is likely to produce higher-quality outputs at the cost of slower generation and greater memory pressure, while e2b trades some capability for a lighter footprint.

The headline metrics in this kind of test are tokens generated per second, prompt processing speed, and peak memory usage, typically reported for a specific chip such as an M-series processor with a stated amount of unified memory. Quantization level matters a great deal here: models converted to 4-bit or 8-bit weights run faster and consume less memory than their full-precision counterparts, usually with a modest and often acceptable loss in output fidelity. Because results are so sensitive to hardware tier, quantization, context length, and batch settings, the numbers should be read as directional guidance for similar setups rather than universal figures. Readers replicating the test on a different Mac configuration should expect the absolute values to shift.

Context helps explain why this comparison is interesting beyond the raw numbers. MLX is not the only route to local inference on a Mac. Tools built on llama.cpp, including Ollama and LM Studio, use the GGUF format and Metal acceleration and remain extremely popular for their breadth of supported models and ease of setup. MLX has been gaining traction partly because it is engineered by Apple for its own silicon and can, in some scenarios, deliver competitive or better performance, though the ecosystem of pre-converted models and tooling is still maturing relative to the llama.cpp world. A benchmark that isolates MLX throughput therefore feeds into an ongoing question about which local runtime offers the best balance of speed, compatibility, and convenience.

Gemma itself is Google's family of open-weight models derived from the research behind its Gemini systems, released with licensing intended to permit local and commercial use under stated terms. Small, efficient variants like these reflect a broader industry push toward on-device AI, motivated by privacy, offline capability, latency, and cost avoidance, and echoed by other compact open models such as those in the Llama, Qwen, and Phi families. The e2b and e4b sizes sit squarely in the range that can plausibly run on a laptop, which is what makes their real-world speed on Apple hardware a meaningful data point.

For anyone evaluating a local deployment, the takeaway is that concrete measurements on a defined machine are more informative than architecture claims alone. If the reported tokens-per-second figures clear the threshold for a given use case, whether that is chat, summarization, or code assistance, then MLX-based Gemma appears to be a viable option worth testing directly on the target hardware before committing.