S

Sohojoe

@Sohojoe·19 public vizzes

Loading thumbnail…

screwing around with active inference

This example models a debugging decision as a two-option active-inference problem, showing how free-energy calculations shift between the actions of fixing a bug yourself versus asking a colleague. It displays a text-based simulation tracking free energy, beliefs, and the chosen action over 30 steps in the terminal. The Python script uses NumPy’s `log` function to compute free energy from belief, complexity, and prior terms, and iteratively updates beliefs via multiplicative decay. A second script extends the model into an interactive, multi-step decision tool that asks users for problem, actions, initial beliefs, priors, and complexities, then recommends the action with the lowest free energy.

Loading thumbnail…

Gist f760b119be511c3b97e0f496b4dc1e1c

This example demonstrates a custom lossless image compression algorithm that encodes 16x16 pixel art using Sharp for image processing and node-base91 for encoding. It converts between 4-bit and 8-bit color formats to preserve the original artistic intent, as seen with the reference star and zero images. The code includes functions for converting RGB values to and from short hex codes, and encodes image data through Sharp's WebP lossless format before base91 encoding. The visualization shows compression results as encoded strings, verifying that the algorithm successfully reproduces the original images through lossless decoding.

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.

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.

Loading thumbnail…

MarathonEnviroments fix for globalization

This example shows a Unity-based system that parses MuJoCo XML files to spawn and configure robotic environments for machine-learning agents. The `MarathonSpawner` script reads XML definitions, builds the scene hierarchy by parsing `worldbody`, `actuator`, and `sensor` elements, and applies materials, physics materials, and optional 2D constraints. It uses `XElement` for XML parsing, configures Unity `Rigidbody` and `Collider` components, and supports random perturbation at episode start. Data sources include the `Xml` `TextAsset` and optional timestep settings.

Loading thumbnail…

OpenAi.Gym.Baselines.DeepQ Restoring checkpoint in next training

This example demonstrates a continuous training loop for OpenAI Gym’s CartPole-v0 using the Baselines DeepQ algorithm. It shows how a model checkpoint is saved and restored across alternating training and evaluation sessions, allowing training to resume seamlessly. The code uses `deepq.learn` and `deepq.load` from Baselines, with a custom `ActWrapper` that serializes the model via dill and TensorFlow’s `U.save_state`. A shell script alternates between `train_worker.py` and `enjoy_worker.py`, pausing training to render episodes and report rewards before resuming.

Loading thumbnail…

Force Editor

An interactive force-directed graph editor demonstrates node-link diagram manipulation. Users drag from existing nodes to create new nodes or links, click to select elements, and use the DELETE key to remove them. The visualization supports panning and zooming through D3’s zoom behavior. The code uses d3.layout.force for physics simulation and d3.scale.category20 for node coloring. The graph redraws incrementally during simulation ticks, with elastic transitions on node creation.

Loading thumbnail…

Force Layout with labels on edges

This example shows a force-directed network graph with ten nodes and thirteen edges, where each edge carries a label that automatically flips to remain readable. The graph uses the D3.js v3 `d3.layout.force` for physics simulation and renders all elements onto a Canvas via its 2D context (`getContext('2d')`). Edge paths are drawn as invisible paths that host SVG `<textPath>` elements, which are rotated 180 degrees when the target node is left of the source. Node labels and arrowheads are also included, with the simulation updating positions on each tick.

Loading thumbnail…

argh

This example demonstrates CRUD operations against the Orions.Cloud data service using the `HttpDataProxy` classes, showing both untyped and typed data objects. It creates a `GenericIdDataObject` and a custom `TestData1` class, then reads each back by ID, logging the unique ID, creation timestamp, and last-updated timestamp for both. The code relies on ServiceStack.Text for JSON handling and the async `CreateAsync` and `GetAsync` methods from the Orions.Cloud.Client.Http library, with all output written to the console.

Loading thumbnail…

New Public Gist

This example shows the top 165 GitHub repositories for the ServiceStack organization, sorted by watcher count, by fetching JSON data from the GitHub API. The code uses the `GetJsonFromUrl` method with a custom User-Agent to retrieve the repository list, then parses it with `FromJson<GithubRepository[]>` and orders it via `OrderByDescending`. The result is printed as a top-five list and a full dump, leveraging ServiceStack.Text's `Print` and `PrintDump` utilities for console output.

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.

Loading thumbnail…

kerlym pong.py does not work with default settings

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.

Loading thumbnail…

Gist 125a08076cec47c50dcbbfd530c810b4

This example shows a force-directed simulation of a network, with nodes and links rendered on a canvas. The code uses d3.forceSimulation to compute node positions and d3.drag for interactive movement, while drawing the graph via Canvas 2D API calls. The visualization also includes a color legend and node labels, though the underlying data appears to be generated programmatically rather than loaded from an external file. A time-based animation updates the layout continuously, and the interface allows zooming and panning through d3.zoom.

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.

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.

Loading thumbnail…

A Princess of Mars

This visualization displays the table of contents from Edgar Rice Burroughs’ *A Princess of Mars*, sourced via a gist. It uses D3.js to render chapter titles as a network, with the author’s name and dedication also included. The data is read from a JSON structure, and the visualization likely employs a force-directed layout to position text elements, emphasizing the book’s structural hierarchy through spatial arrangement.

Loading thumbnail…

Crowded Fiction

This example shows a growing, branching narrative text that updates over time, with each new line or phrase added to a crowded visual space. It uses d3.forceSimulation to position and collide text elements, while transitions animate the entry of new strings into the scene. The data comes from a gist, consisting of sequential addString commands, some paired with withFXAnimation and FXAnimDrip for special effects. The view is a live, evolving typographic composition where history and edits accumulate like a stream of consciousness.

Loading thumbnail…

AppyLinks

AppyLinks visualizes a curated list of links as a force-directed network, where each node is a website title and connections suggest relationships. The graph uses `d3.forceSimulation` to position nodes and `d3.drag` for interaction, with links drawn as simple lines. Data comes from a hardcoded list of three URLs, and the layout stabilizes through iterative simulation. The example demonstrates a minimal, dependency-light approach to network visualization.

Loading thumbnail…

testOpenGist

This example visualizes the structure of a Gist, presenting a hierarchical layout of its files and metadata as a network diagram. The visualization uses the `d3.forceSimulation` API for physics-based node positioning and `d3.geoPath` to render connecting links as curved paths. The underlying data is directly loaded from the Gist’s JSON representation, which the code parses to extract file names and content summaries. Node size and color encode file length and type, while interactive hover reveals a tooltip with file details. The layout dynamically stabilizes through force-directed iterations, showing the relationship between the Gist’s components in real time.