Skip to main content
SimilarExport ZIP
100%

dyna-maze based on https://github.com/thehawkgriffith/dyna-maze

✓ Published0🌍 Public
SSohojoe
Last edited Jul 15, 2020
Created on Jul 15, 2020

This example animates a reinforcement-learning agent navigating a 6×9 grid maze toward a goal state, using the Dyna-Q algorithm to balance exploration and planning. The visualization shows the agent’s current position as a marker, a live policy heatmap of action values, and the cumulative reward per episode. Built with Matplotlib and NumPy, the scene renders in a terminal via `Environment.render()`, while the agent’s state and action history drive the displayed trajectories. The maze layout, obstacles, and reward structure come from the `dyna-maze` repository’s hardcoded environment.

AI-generated description

Similar vizzes

Loading thumbnail…

Random Search

This visualization animates a random search algorithm solving a maze, which was itself generated via random traversal. A magenta path highlights the best-known route from the top-right corner to the bottom-left, updating as the search progresses. The code uses D3 v3's timer API to drive the animation and a Canvas context for all drawing. The underlying maze and search logic are implemented directly with JavaScript arrays and bitwise operations to represent cell connections.

Mmbostock
62% match
Loading thumbnail…

Gist 7814a13dbae9fde1771606fe6081513d

This interactive visualization tracks the training progress of a Dueling Double Deep Q-Network (Duel DDQN) agent within the OpenAI Gym CartPole-v0 environment. It plots the reward per episode over time, showing how the agent's performance improves as it learns to balance the pole. The code uses the Python libraries `gym` for the environment and `torch` for the neural network, with command-line arguments specifying hyperparameters like `--gamma` and `--batch_size`. The chart updates in real time, rendering the learning curve as the agent iterates through episodes.

SSohojoe
62% match
Loading thumbnail…

Better-Only Search

A maze is generated using random traversal, then solved with “better-only search,” a best-first search variant restricted to north and east moves. The canvas renders the maze as a white grid on black, with gray fill marking explored cells and magenta highlighting the current best path. The solver uses a min-heap frontier and animation via d3.timer, updating ten cells per tick to show the search progression toward the goal.

Mmbostock
62% match
Loading thumbnail…

Randomized Depth-First II

A maze is generated using randomized depth-first traversal, then flooded with color to reveal its structure. Hue encodes the Manhattan distance from the starting cell, making the maze’s branching patterns visually comparable. The animation is rendered on a Canvas 2D context, drawing cells and passages incrementally as the flood expands. The code uses D3’s `d3.timer` to drive the animation loop and `d3.hsl` to cycle hue over time, while a custom `generateMaze` function builds the maze and `fillRect` calls paint each cell and connecting corridor.

Mmbostock
61% match
Loading thumbnail…

Gist c9d1f7872865db4e5bfc0991636376c8

This example visualizes the training progress of a Dueling Double Deep Q-Network (Duel DDQN) agent across 10,000 episodes in the MountainCar-v0 environment. It uses the Python library `duel.py` from the Duel_DDQN repository, invoking it via a command-line call with the `--gym_record` flag to capture the agent’s performance over time. The chart presents episode-by-episode reward trends, showing how the agent’s policy improves as training advances, with the underlying data generated by OpenAI Gym’s environment simulation.

SSohojoe
60% match
Loading thumbnail…

Random Search II

A maze generated with Wilson’s algorithm is solved through random search. The gray frontier cells expand in random order, while the magenta path highlights the current best-scoring route toward the goal. The visualization uses D3 v3 and Canvas 2D drawing, with a timer running ten random frontier explorations per frame. Cell scores are computed as squared Euclidean distance to the goal, and the animation stops when the goal cell is reached.

Mmbostock
60% match
Loading thumbnail…

Random Traversal II

A maze is generated by random traversal and then flooded with colored light. Hue encodes the Manhattan distance from the starting cell, creating a vibrant gradient that reveals the maze’s branching structure. The animation uses a canvas, with `d3.timer` driving the flood fill, while `context.fillRect` paints each cell and corridor. The maze itself is built from an edge-bit array, and the color progression cycles through the HSL spectrum via `d3.hsl`.

Mmbostock
59% match
Loading thumbnail…

Basic Laberinth

This interactive D3 maze generator creates a 15x15 tile-based labyrinth. Players navigate by clicking directional arrows along the board’s edges to slide entire rows or columns of tiles, demonstrating a classic sliding-puzzle mechanic. The visualization uses SVG paths and gradients for the stone-textured board and colored tiles, with a redundant spare tile that moves as rows and columns shift. The code employs D3 selections and event handlers, including `select`, `range`, and custom `touch` logic, to manage tile state and animation on user input.

IIan Newby
59% match