Skip to main content
We support four plot types: Scatter, Line, Bar and Histograms. In order to plot data, you first need at least one table in your interface, which is used to define the data which will be used for the plot axes. You can also plot data which spans across multiple tables, but we’ll focus on the single table case for now. So let’s dive in and go through each plot type 🤿

​
Scatter Graphs

Scatter graphs can be used to plot two numerical columns against each other. For example, let’s log the following: Open in your console 
import unify
import random

for i in range(10):
    unify.log(
        x=i,
        y=i+random.uniform(-0.25, 0.25)
    )
We can then select the x column for the x-axis and the y column for the y-axis.
click image to maximize
We can also overlay several plots on the graph, by selecting another column to group by (based on value equality, the same as grouping in the table). Let’s make an example. Open in your console 
import unify
import random

gender_factors = {"male": 2000, "female": 1000}
for gender in ["male", "female"]:
    for age in range(20, 55):
        age += random.randint(-5, 5)
        unify.log(
            gender=gender,
            age=age,
            salary=(
                age*500 +
                age*gender_factors[gender]*random.random()
            ),
        )
We can then select age for the x-axis, salary for the y-axis and group by gender. We can also add a line of best fit to each group in the plot.
click image to maximize
If we want to group across multiple independent variables, we can just create a new derived column to express the desired group. Let’s assume we also log the nationality of the person. Open in your console 
import unify
import random

gender_factors = {"male": 1500, "female": 750}
loc_offsets = {"UK": 15000, "US": 45000}
for gender in ["male", "female"]:
    for loc in ["UK", "US"]:
        for age in range(20, 55):
            unify.log(
                gender=gender,
                nationality=loc,
                age=age,
                salary=(
                    age*500 +
                    age*gender_factors[gender]*random.random() +
                    loc_offsets[loc]*random.random()
                ),
            )
In order to plot against both variables, let’s create a new derived column called gender + nationality with the equation gender + nationality. We can then group by this new column.
click image to maximize
We could then create three plots for example: one which groups by gender, one which groups by location and one which groups by both. We can then save this and revisit this dashboard again any time in future, whenever more data is added into the project.
click image to maximize

​
Line Graphs

Line graphs are similar to scatter graphs, but a line is drawn between each from left to right. This makes them especially suitable for plotting time-series data. Let’s take the same example as before, but plot it as a line graph. Open in your console 
import unify
import random

for i in range(10):
    unify.log(
        x=i,
        y=i+random.uniform(-0.25, 0.25)
    )
click image to maximize
As before, we can also group by another column. Let’s imagine we want to plot the speed of different models across time, which are being continually streamed. Open in your console 
import unify
import random
from datetime import datetime

model_speeds = {
    "llama-3.1-8b-chat": 12,
    "llama-3.1-70b-chat": 7,
    "llama-3.1-405b-chat": 4
}
while True:
    for model, speed in model_speeds.items():
        unify.log(
            model=model,
            time=datetime.now().isoformat(),
            speed=speed+random.uniform(-3, 3)
        )
We can then select time for the x-axis, speed for the y-axis and group by model.
click image to maximize
By default, new data will not be loaded into the interface unless something triggers a reload, such as filtering, grouping or sorting. The table can be refreshed manually using the refresh button, or streaming mode can be turned on in order to continually stream new data into the platform. if we want a moving window of the runtime, we can turn streaming on for both the table and the plot, and then limit the time horizon to the last 5 minutes, for example.
click image to maximize
Similar to the derived identity column before, we can create a derived endpoint column to plot a unique line for each model + provider combination. Let’s create some dummy data for this scenario: Open in your console 
import unify
import random

model_speeds = {
    "llama-3.1-8b-chat": 12,
    "llama-3.1-70b-chat": 7,
    "llama-3.1-405b-chat": 4
}
provider_speeds = {
    "fireworks-ai": 10,
    "together-ai": 9,
    "aws-bedrock": 8
}
for i in range(25):
    for model, model_speed in model_speeds.items():
        for provider, provider_speed in provider_speeds.items():
            unify.log(  
                model=model,
                provider=provider,
                time=i,
                speed=(
                    model_speed + 
                    provider_speed + 
                    random.uniform(-2, 2)
                )
            )
Let’s then create the derived column and plot results for each unique endpoint.
click image to maximize

​
Bar Charts

Bar charts are different to line graphs and scatter graphs. The x axis does not represent individual numerical values, but instead represents groups of data of any type (which share the same value). The y axis then represents a reduction across the data in each group (bar) in the graph. For example, let’s say we’ve run two experiments, which vary the tool use and the system message. Open in your console 
import unify
import random

base_msg = "You are a helpful assistant."
for tool_use in [True, False]:
    with unify.Params(tool_use=tool_use):
        for sys_msg in [
            base_msg,
            base_msg + " You can use tools.",
            base_msg + " You can use tools and search the web."
        ]:
            with unify.Params(sys_msg=sys_msg):  
                for example_idx in range(10):
                    unify.log(
                        example_idx=example_idx,
                        score=random.uniform(0, 10)
                    )
We can then create a bar chart which groups by the system message and tool use. Let’s plot the mean score on the y-axis, to see how each of our experiments performed across the 10 examples.
click image to maximize

​
Histograms

Finally, we can also plot histograms, which take a single numeric column, and then bucket this data into n bins on the x-axis, and plot the count of data in each bin on the y-axis. For example, let’s say we want to see the distribution of user traffic over the past year. Has our product been gaining traction? Open in your console 
import unify
import random

n = 10
for month in range(1, 13):
    num_queries = random.randint(month*n, (month+10)*n)
    unify.create_logs(
        entries=[
            {
                "date": date(
                    2025, month, random.randint(1, 28)
                ).isoformat()
            }
            for _ in range(num_queries)
        ]
    )
Let’s take a look at the corresponding histogram.
click image to maximize
We can see that the usage has been steadily increasing throughout the year, good stuff! 📈
⌘I