kerlym pong.py does not work with default settings

100%

kerlym pong.py does not work with default settings

✓ Published0🌍 Public

Last edited Jun 12, 2016

Created on Jun 12, 2016

This visualization compares the training progress of DQN and DDQN agents over 55,000 episodes of the Atari Pong-v0 environment, showing that neither algorithm converges to a winning strategy. The plot uses Gym’s evaluation API to fetch reward-per-episode data from two public evaluation records. The chart displays raw episode rewards as thin gray lines with a bold moving average overlay, directly exposing the high variance and lack of improvement in both agents’ performance. The code uses Python with matplotlib for plotting and requests to load JSON data from the Gym evaluation endpoints.

AI-generated description

Similar vizzes

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

67% 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

66% match

Loading thumbnail…

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

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.

SSohojoe

52% match

Loading thumbnail…

Training Performance

The visualization shows training progress across four reinforcement-learning environments—Hopper, Walker, Humanoid, and Ant—by comparing their total training steps, wall-clock time, and throughput. It uses a table-style layout rendered with plain HTML and CSS, drawing data from a TSV file. Each environment row displays its metrics, with the steps-per-second value visually encoded as a horizontal bar, making the relative performance of each task immediately comparable. The code loads the data via `d3.tsv` and constructs the bar chart using SVG `rect` elements scaled by the parsed numeric values.

SSohojoe

51% match

Loading thumbnail…

Simple Neuroevolution Cartpole

This example shows a neuroevolution system training agents to solve the CartPole-v0 balancing task using OpenAI Gym. A population of 100 neural networks evolves over 100 epochs, with each network’s fitness determined by its average score across 5 episodes. The Keras models use densely connected layers with ReLU activation, while the evolution process selects and mutates networks based on their performance. Agent scores are collected and then the top performers are used to generate the next generation, gradually improving the population’s ability to keep the pole upright.

SSohojoe

50% match

Loading thumbnail…

Untitled

This interactive visualization shows how a deep reinforcement learning agent’s performance evolves over training timesteps, with multiple score series tracking different agents or runs. The chart animates through the training timeline, allowing viewers to compare score trajectories and observe how performance improves over time. Built with D3.js v7, the SVG-based visualization uses a slider to scrub through timesteps and dynamically update the line chart. The data comes from a hardcoded score list, and the page includes tabbed navigation and buttons to switch between overview and detailed views of the training process.

Llloydy8

49% match

Loading thumbnail…

Let's make a face with D3.js!

This line chart shows the performance of the VPG reinforcement learning algorithm in the Walker environment over time, plotting average episode return against the number of interactions. The visualization is rendered as an SVG using D3.js v5, with the `scaleLinear`, `axisLeft`, and `axisBottom` functions for the axes, and the `line` function with `curveBasis` to create the smoothed data path. Data is loaded from a remote CSV via `d3.csv` and styled with custom CSS for labels and title.

CChrisKort

48% match

Loading thumbnail…

Pokemon GO Final Viz

This interactive visualization explores a Pokémon dataset from Kaggle, displaying a selected Pokémon's base stats, type effectiveness, and movepool alongside a level-scaling CP curve. The interface uses D3.js to render a radar chart comparing stats to maximum values, a line graph for CP growth, and a matchup table, with dropdowns and an input box to select different Pokémon. The CP curve can be toggled to show absolute values, though labeling is limited in that mode.

Aabell@wpi.edu

47% match