Introducing Efaimo Dashboard: A Practical ML Training Log Analysis Tool

After months of experimenting with neural network compression techniques, we found ourselves constantly wrestling with training logs scattered across terminal windows, text files, and half-forgotten experiment notes. Parsing these logs manually became tedious, especially when trying to diagnose overfitting or compare validation trends across runs.

So we built Efaimo Dashboard (app.efaimo.com): a lightweight, browser-based tool for analyzing ML/DL training logs in real-time.

The Problem: Training Logs Are a Mess

If you’ve trained deep learning models, you know the drill. Your terminal spits out something like this:

Epoch 1/100 - train_loss: 0.523 - val_loss: 0.487 - val_r2: 0.89
Epoch 2/100 - train_loss: 0.412 - val_loss: 0.398 - val_r2: 0.92
...

Or maybe you’re dealing with CSV logs from TensorBoard, pipe-delimited outputs from custom loggers, or multi-line formats where each metric lives on its own row. The formats vary wildly depending on your framework, logging library, or personal preferences.

Most of us end up manually scrolling through thousands of lines to find the best epoch, or copy-pasting into Excel and writing one-off Python scripts. You squint at terminal output trying to spot overfitting trends, and inevitably lose track of which experiment had which hyperparameters. There had to be a better way.

The Solution: Smart Parsing + Automated Analysis

Efaimo Dashboard is a single-page web application that takes your raw training log (in almost any format) and parses it automatically. No manual column mapping required for most formats. It then visualizes your metrics with interactive charts that have smoothing options, diagnoses training patterns to flag overfitting or underfitting, and provides actionable recommendations based on your loss curves.

The best part? It all runs client-side in your browser. No server uploads, no API keys, no privacy concerns.

Core Features

1. Automatic Format Detection

The parser handles a surprising variety of log formats out of the box. CSV and TSV files with headers work fine. Hyphen-delimited text logs like Epoch 1/100 - train_loss: 0.523 - val_loss: 0.487 get parsed correctly. Pipe-separated formats and even multi-line formats where each metric lives on its own row are all supported.

Under the hood, we test multiple delimiters (commas, semicolons, tabs, pipes, spaces) and use scoring heuristics to pick the best one. The system also normalizes metric names aggressively, so train_loss, Training Loss, and TRAIN_LOSS all map to the same internal key.

2. Intelligent Pattern Recognition

Once your log is parsed, the analysis engine examines your training curves and classifies what’s happening. If your train loss keeps decreasing while validation loss increases, it flags overfitting. When both losses stay high and stagnant, that’s underfitting. High variance in validation loss across epochs signals unstable training. If your best epoch is near the end and validation loss is still improving, more training might help. And when losses have stabilized at reasonable levels, you’ve got good convergence.

Each diagnosis comes with a plain-language explanation and specific recommendations. Instead of just showing you charts, the dashboard tells you things like “Increase dropout rate” or “Reduce learning rate by 50%”. It also warns you about potential data issues.

This automated feedback loop saves a lot of time compared to manually inspecting plots and guessing what went wrong.

3. Real-Time Visualization

The dashboard renders your metrics using Recharts, with separate charts for loss trends (train/val), accuracy or R² scores, error metrics (MAE, RMSE, MAPE, MSE), and any other custom metrics you’re tracking.

You can toggle Exponential Moving Average (EMA) smoothing to reduce noise and see trends more clearly. The smoothing strength is adjustable via a slider. For large logs with thousands of epochs, the tool automatically downsamples data points to keep rendering fast without losing important trends.

4. Metric Mapping (Manual Override)

If your column names don’t follow conventions, you can manually map them. Just select which column represents train_loss, val_loss, and so on. This is useful for custom logging setups or non-standard naming.

5. Export and Share

Need to share results with your team or save them for a report? You can export to CSV to download the parsed data as a clean spreadsheet, or just copy the metrics like best epoch and final losses for your notes.

Technical Design

We intentionally kept the architecture simple and client-focused. The frontend uses React for UI components and Recharts for chart rendering. Theme and language state (light/dark mode, English/Korean) are managed via Context API.

The parsing engine is multi-strategy. It tries CSV first, then falls back to text-based patterns. We use regex-based metric extraction with fallback heuristics, and normalize metric keys for robustness.

The analysis logic uses linear regression on recent epochs to detect trends, variance-based instability detection, and configurable thresholds in analysisConfig.js.

Everything processes in the browser using JavaScript. No data leaves your machine, which eliminates privacy concerns entirely. Training logs can contain proprietary information like model architectures, hyperparameters, and dataset names. By keeping everything local, we avoid that problem altogether. The tool even works offline after the first load.

How to Use It

Go to app.efaimo.com and paste your log into the text area (or upload a .txt, .log, .csv file). Click “Start Analysis” and the dashboard will parse your log automatically, display a table of all parsed epochs, render interactive charts, and show training pattern diagnosis with recommendations.

If the auto-detection fails (which is rare), you can use the Metric Mapping section to manually specify which columns correspond to which metrics.

Use Cases

We’ve been using Efaimo Dashboard internally for quick sanity checks. Questions like “Did this overnight training run overfit?” or “Which epoch should I use for my final checkpoint?” get answered in seconds.

It’s also useful for comparing runs. Paste logs from different experiments side-by-side (in separate tabs) and you can quickly spot which hyperparameters led to stable convergence.

For educational purposes, the tool is great for demonstrating overfitting versus underfitting to students or colleagues, and visualizing the impact of regularization techniques.

When debugging failed experiments, it helps identify unstable training early and provides actionable suggestions without manually analyzing hundreds of epochs.

Limitations and Future Work

Right now the dashboard only handles single-run analysis. There’s no built-in multi-experiment comparison yet, and it’s limited to numeric metrics (can’t parse text annotations or images). We also haven’t integrated with TensorBoard or Weights & Biases yet.

We’re planning to add multi-run comparison views and hyperparameter tracking. Chart export to PNG/SVG is coming soon, along with integration options for popular logging libraries (possibly an optional backend service for teams who want that).

One particularly interesting direction we’re exploring is language-model-assisted analysis. Instead of just pattern matching, we want to use language models to provide more nuanced explanations of what’s happening in your training runs. Imagine asking “Why did my validation loss spike at epoch 47?” and getting a contextual answer that considers your specific setup. We’re also looking at anomaly detection that goes beyond simple variance thresholds, potentially catching subtle issues that current heuristics miss.

Why “Efaimo”?

Efaimo stands for Efficient AI Models, which reflects our broader research focus on neural network compression and deployment optimization. The dashboard started as an internal tool for tracking quantization experiments, but we found it useful enough to polish and release publicly.

If you’re interested in our compression research, check out our posts on quantization techniques and symmetric vs. asymmetric quantization.

Try It Now

Live demo: app.efaimo.com Feedback: We’d love to hear what you think — drop us a note at [email protected].

Training neural networks is hard enough. Parsing logs shouldn’t be.