Wouldn’t it be swell to learn how to deploy a local LLM that we could ask about… most anything, research or otherwise? Yes, and I can think of a few reasons why:

• Lack of connectivity: There may be situations (e.g., a flight) when using any of the Internet-based LLMs is not feasible.

• Privacy: Research (and teaching) often requires opening and/or analyzing potentially private data, and sharing this data with LLM providers seems like a pretty bad idea.

• Versatility: Installing and using a local LLM means having the ability to decide which specific LLM to use and from which company.

• Iteration: Often, data analysis requires iteration over many rows of data – for example, computing the sentiment of a dataset of online reviews, or cleaning a dataset. While slower than Internet-based counterparts, local deployment (with a bit of Python programming) provides full control over how the LLM iterates over multiple observations and what it does with each.

But a secondary, yet nagging, fear, is compute. The big C. Often, we think our computers are too slow, our resources too thin, and submit to paying OpenAI through the nose for API calls.

Enough! Here’s a thought: your potato computer is better than you give it credit for. Your hardware can pull it off. Can it? Can we effectively transform a potato into an oracular potato that runs LLMs for research… or will our power supplies and motherboards fry?

Can we do it with AI? We’ll try to demystify the process of deploying LLMs locally in a multi-part post, covering Mac and Windows. We will:

1. Learn how to deploy a reasonably accurate oracular potato: a less-than-stellar, potato Windows or Mac computer running a Qwen LLM locally. We’ll use LMStudio, an easy-to-use, almost “plug and play” application.

2. Learn how to use Python (virtual environment setup and programming) to use an LLM without any user interface. We’ll use the Ollama application for further learning.

3. Analyze data with LLMs using FOR cycles…. slowly 🦥. Here, we won’t use either LMStudio or Ollama, but a custom deployment for maximum privacy and flexibility.

Project overview

Deploy an oracular potato, Part 1

• 🗒️ Topics: Research; text genAI; Qwen; LMStudio.

• 🔨 Tools: LMStudio; various Qwen LLMs.

• 💸 Cost: $0 (you already have a potato computer, right?)

• ⌛ Time to completion: Around one hour (mostly spent downloading files).

Napkin planning

Let’s think before we tinker. Planning on a napkin, along with stating our goals, is always useful.

• Goal: Locally deploy a reasonably accurate LLM on a less-than-reasonable computer.

• Accuracy goal: High – the LLM should be accurate enough to be useful.

• Creativity goal: Medium – this guide focuses on verifiable, technical prompts. You can also experiment with using a local LLM for creative work.

Here, the napkin emphasizes a series of steps to assemble and use an oracular potato. It will be slow -oh yes, it will- but it will be accurate, a benevolent, zen-like LLM sloth taking his sweet time to eventually throw a dart and hit bullseye. The process will take some explanation (hence the multi-part series), but, overall, the time investment will pay off in spades.

Doing It With AI

Potatoes

Let “potato” be a less-than-ideal computer not generally thought of as being capable of running LLMs. Note that I am constrained to the devices I own. Therefore, my potatoes will be:

1. Windows: A laptop with a 4-core, 2.8 GHz AMD Ryzen 5 7520U processor, integrated graphics, 16GB of RAM, and a 256GB hard drive.

2. Mac: A MacBook Air with an M2 processor, 8 GB of RAM, and a 256GB hard drive.

3. Linux (Mint): A laptop with a 4-core, 1.6 GHz Intel Core i5-8250U processor, integrated graphics, 20GB of RAM, and a 1TB hard drive.

As can be seen, the Windows computer is quite the potato: while not a Chromebook, it scores quite low on CPUBenchmark compared to an Intel Ultra 9 285K, one of the faster consumer-grade desktop processors at the moment. Its saving grace is having 16GB of RAM. The Mac, on the other hand, has less RAM, but a better processor (which is, nevertheless, three generations old).

(Of course, the Linux is the true potato here, but I will only discuss it very briefly, for comparison purposes).

I have successfully transformed each laptop into an oracular potato, though those are the only potatoes I have, leaving little room for experimentation. So, as an educated guess, I believe that the minimum requirements for an oracular potato are:

• Windows: 12GB of RAM and a processor as capable as a Core i5-8250U (works, but very slow) or AMD Ryzen 5 7520U (works reasonably well!).

• Mac: an M2 or (maybe) M1 processor with 8GB of RAM.

In either case, a 256GB hard drive should do fine, assuming you have enough free space. Note that neither case requires a dedicated graphics card (e.g., an RTX 4090 or RTX 5090), which would be the resource of choice for a very powerful local setup. But we’re talking potatoes here, so let’s move on.

The setup

Regardless of your operating system (Windows, Mac, or Linux), our first experience using LLMs locally will be using LMStudio. LMStudio is an easy yet surprisingly customizable program to run LLMs locally. It has a very large pool of models to download and use as well. The disadvantage is that LMStudio is closed-source, which would add more security and transparency to the program. But, overall, it’s excellent, and I use it frequently to run LLMs.

To download LMStudio, visit their website and download the program. After installation, you’ll have to make a few decisions:

• User level: State that you’re a “Power User” so that the interface offers a few extra tabs and tools.

• Your first model: First, disable the option “Enable local LLM service on login”, and then, click Skip. You can download a model suitable for your potato later.

That’s… pretty much it! You will be greeted with a window featuring several icons on the left, and a huge chat window. Now we can begin playing with some LLMs! (For a quick primer on what these models are, read this introduction from AWS.)

Model search and installation

The next step is to search for a suitable LLM. I would recommend two options: either Qwen2.5-0.5B-Instruct or Qwen3-0.6B. These models are quite small and work well (if your computer is better, you can use better models, but first experiment with these).

There are several factors to account for by simply reading the model names:

• Model name: There are many model providers out there: OpenAI, Alibaba, Deepseek, Google, and others. Each of their model families has a name. I chose to use the Qwen family of models, developed by Alibaba, because they’re small and easy to use.

• Model version: As AI technologies evolve, model providers typically update their model portfolio. The first number you see (Qwen2.5, Qwen3) indicates the model version. While a higher version is usually associated with higher precision in analytical tasks, qualitatively, the models can vary widely, with some users strongly preferring older models, especially for personal support and creative work.

• Parameters: Each model has a parameter structure that can range from fewer than a billion to hundreds of billions of parameters. More parameters generally result in more precise handling of user prompts, but they also mean a larger model size. This is important because your potato is limited by the amount of RAM it has to run these models. I won’t cover hyperparameters, which govern how the LLM responds to a prompt (e.g., temperature, top-k) and can be changed in LMStudio’s settings – for a primer, check this document from IBM.

• Specialty: Certain models are specialized for different tasks. For example, the Qwen-Image-Edit model is specifically tailored to edit images. In our case, the Qwen2.5-0.5B-Instruct model was specifically designed to handle user prompts, whereas the Qwen3-0.6B model is more general. In fact, if you search for the latter model in the Qwen3 model repository, you will find no Instruct version of it at all! So, when selecting a model, you might want to first determine whether there are any specialty models that might work best for the task at hand.

In LMStudio, the red magnifying glass in the left panel can be used to search for models. Click it. Note that the list begins with “Staff picks” – I would stick to these unless they are not available for a specific model. Furthermore, the option “GGUF” is ticked. GGUF is a faster model format than standard models, which very slightly sacrifices accuracy (there are also Mac-specific MLX models). Since we have a potato, let’s keep the GGUF option enabled.

Search for “Qwen3-0.6B” in the search box. There are a lot of different models (none is a staff pick) – stick to the provider’s (in this case, Qwen). A good indicator of which model to download is also the number of downloads and likes a model has. Select “Qwen3-0.6B-GGUF” by Qwen, and download the model. Afterwards, a confirmation window appears.

Close the window.

The model has been downloaded, but it now needs to be loaded into memory to run. To do this, click “Select a model to load” at the top of the screen. Simply pick the model, and you’re ready to go!

Prompting

At this point, you can start prompting the model. However, I generally use the following prompt when I first use any model:

Briefly describe your capabilities in no more than three paragraphs.

This is the response I got:

Note that the model engages in “thinking” for a while. In a potato, this can be a LONG while. So, how do we disable thinking? Some models include a button that allows thinking to be disabled, which is at the bottom of the prompt box:

However, the Qwen3-0.6B-GGUF model apparently does not offer that option. The keyword here is “apparently:” by reading the model’s description in the Qwen repository, we learn that by preceding a prompt with the term “/no_think”, thinking is disabled! This varies by provider, model family, and even specific model, and so getting into the habit of reading a model’s “fine print” is always useful. Try running the above prompt, disabling thinking, and compare the output and speed relative to when thinking is enabled.

A local LLM can be used for anything – I generally use it to learn new things about coding, decipher abstruse Windows or Linux terminal commands, etc. This can be done (reasonably) quickly, safely, and even offline (test this by disabling your Internet connection).

For a more useful example, suppose you want to learn how to write a FOR loop in Python. Open a new chat window by clicking the + button in the “Chats” pane (generally, do this every time you want to prompt something unrelated to your previous prompt). Here, you might use a prompt like

Briefly show me how a FOR loop is structured in Python /no_think

The output follows:

Behold, an oracular potato!!

You could also write

Briefly teach to me what a FOR loop is, and how to use FOR cycles in Python. Explain this step by step, so that I can learn how to use Python better. /no_think

I won’t include the resulting output here, but the explanation is much longer, comprehensive, and useful.

Also, note that LMStudio lets you attach files alongside a text prompt. Feel free to experiment!

When you are done, click “Eject” in the model bar at the top of LMStudio to remove the model from memory.

Model speed and quantization

Some models include different versions built on different quantization levels, which impact speed (and therefore are important when dealing with a potato).

To see this in action, in the Model search tab (the magnifying glass icon on the left pane), search for “Qwen3 1.7B”. Notice there’s a purple “staff pick” model. Upon selecting it, click “Download Options”.

These options (e.g., Q6_K, Q8_0) denote the same model but vary in quantization, which improves efficiency and memory usage. Models such as FP32 and FP16 are very high-precision, whereas models such as Q6 and Q4 have lower precision, although they generally preserve most of the model’s behavior. For this reason, feel free to experiment with different models! LMStudio will auto-select a recommended model.

How fast, or slow, might these models be? When you run a prompt in LMStudio, you will see a summary at the end of the output, indicating the number of tokens in your output and the tokens per second. The faster the tokens/second, the faster the model ran.

Are there any gains in speed from quantization? The tokens/second measure can help us assess that. I conducted a little experiment on my Linux potato. Using the Qwen3 1.7B model noted above, I ran the second Python FOR loop prompt, with and without thinking, and using the laptop’s battery power. These were the results.

As can be seen, there is some improvement in using models with different quantization (and a noticeable drop when Thinking is enabled). But the highest efficiency gains can be achieved by using a smaller model – for example, on the same potato, the Qwen-2.5-0.5B-Instruct results in runs up to 8.64 tokens/second, more than twice as fast as the 1.7B model. However, I would advise caution when using older, faster models, as they can be less precise.

Did We Do It?

Today, we set up a local LLM using LMStudio, and ran it successfully (even offline!) on a potato computer. This is great for privacy reasons, as well as for accessibility – yes, even your potato can run LLM models… slowly!

In the next installment, I’ll cover how to use Ollama to invoke these models in Python, so you can easily write scripts that might require you to repetitively send prompts to the LLM.

Should you do this with AI?

Since today’s article focused on installing LLMs, you might think this section might not exist. I thought the same. So, perhaps this section might instead ask: should you do AI with a potato? In my view, the answer is a resounding yes. In the words of my faithful AI assistant, DIWA: “Running AI locally won’t make it smarter.
It might make you slower — and that’s the point.“

Think about today’s LLM usage. A recent report claims that AI usage has resulted in the same CO2 emissions as New York City. The data center boom continues apace, using as much water and electricity as tens of thousands of homes and causing computer part prices to skyrocket, which will eventually impact the prices of most electronics. All the while, the powers that be hunger for more.

The destructive force that AI can be means that sending a simple chat request to ChatGPT or Gemini comes with a pang of guilt - especially when, even in Google, one cannot even opt out of generating AI results! In this environment, perhaps using oracular potatoes is a way to preserve resources - after all, there are a lot of potatoes lying about households, offices, and schools. Tapping into these dormant resources could be useful for research and learning. Deploying an oracular potato also preserves our identity and privacy, without all of it being potentially siphoned by AI companies.

So, when I want to do it with AI, I’ll make an effort to ask it (most of the time) on my potato - a slow and starchy act of rebellion!

(Stay tuned for Part 2: using Ollama and Python programming.)

Share

Subscribe now

Whether innate, due to the distractions of our age, or simply age, I am increasingly forgetful. This forgetfulness sometimes spills over to research, particularly into experimental work. There, researchers often work on -and must plan for- a long-winded series of steps to satisfy experimental validity and reviewer acidity. These steps are a hallmark of academic rigor and essential to scientific progress.

Which is why forgetting any of these is very annoying. Missing a manipulation check might require a weaker, post-hoc check that experienced reviewers will set their sights on like an old zebra straying from the pack; forgetting to clearly discuss experimental design or data exclusion details can easily confuse readers; failing to report reliability scores can cast doubt on the validity of a scale; and so forth.

Can we stop forgetting… with AI? Let’s try.

Project overview

Develop an experimental checklist with AI

• 🗒️ Topics: Research; Academia; Text GenAI

• 🔨 Tools: ChatGPT; Google Scholar.

• 💸 Cost: $0

• ⌛ Time to completion: No more than one hour; likely minutes.

Napkin planning

Let’s think before we tinker. Planning on a napkin, along with stating our goals, is always useful.

• Goal: Develop a checklist so I don’t forget experimental steps.

• Accuracy goal: High· – must include a comprehensive, logical set of steps.

• Creativity goal: Low (it’s just a list).

Admittedly, there was not too much to plan, so this was just an opportunity to have fun making this doodle.

Here, the napkin emphasizes information sources. The obvious source to start when developing an experimental checklist is a proxy for my memory: my previous work, which I should remember (right?). The second source is existing work: optional, “exemplar” research articles that might contain useful steps that my work might not have used. The third source is ChatGPT’s extensive knowledge of the academic review process and our ability to constrain it to adopt the persona of an academic reviewer. By combining these sources, I expect ChatGPT to provide a checklist that I might consult every time I plan to run an experiment.

Doing It With AI

Sources

We start by gathering the information sources. I selected four articles I published in the past that relied primarily on experiments: Grigsby et al. (2022); Hsieh et al. (2025); Meng et al. (2021); and Zamudio et al. (2025).

The second source is up to you – in this case, I provided a few articles I’m familiar with: Connors et al. (2021); Khan and Kalra (2021); Perez et al. (2022); and Sevilla and Kahn (2014).

The third source (ChatGPT) is prompted in the next step.

The prompt

I wrote the following prompt for ChatGPT. While my prompts are usually much more structured and detailed, this one worked just fine:

I want to build a checklist for myself about things I need to do while setting up experimental research. This is so I don’t forget any steps.

For example, in writing: state the research goal, state the experimental conditions, provide a discussion, etc. From the methodological side: include manipulation checks, discuss stimuli development, etc. From the reporting side: report effect sizes, report sample sizes, report sample breakdown by gender, etc.

If I provide you with (1) PDFs of previous articles I’ve published and (2) exemplar other articles both of which have experimental studies, could you provide me with such a checklist based on the articles as well as your own contribution, if you were to pretend you’re a Marketing scholar from a prestigious institution who routinely publishes in the Journal of Consumer Research and the Journal of Marketing Research?

Note the following important points:

• The goal: Here, the checklist requirement is clearly stated at the beginning, with the additional remark about reducing forgetfulness.

• The “sections”: To provide an a priori structure for the LLM, I provided a very brief set of examples in writing, methodological, and reporting sections, which mirror the usual flow of a research article.

• Explicit information sources: The three sources of information are clearly specified.

• Persona prompting: I explicitly requested the LLM to “pretend” to be a reviewer for target journals I’m interested in. While the empirical evidence in favor of persona prompting is mixed, I generally use it with reasonable success (of course, ideally, you might want to experiment by ablation, adding/removing a persona prompt, and evaluating your own resulting checklist).

But it got weird, quick

You might imagine that this prompt, coupled with the papers supplied, would provide a pretty reasonable checklist for immediate use. Well, it did – sort of.

I first used this prompt with ChatGPT 5 back in October. At the time, I did not use any exemplar articles. ChatGPT produced a pretty good checklist and, after going back and forth a bit, I was able to coax it into creating a single-page checklist that I could then edit in Adobe Acrobat to allow it … well, to be checked. ChatGPT stated that it could create a short, compact version, and my response was:

Okay, let’s give it a shot. Figure out what format might work best for a single-page checklist. Perhaps two columns and landscape orientation?

The result was pretty good! (You can download the PDF below)

Diwa Experimental Checklist Chatgpt 5 Original

3.58KB ∙ PDF file

Download

Download

But then something strange happened. I came back in November to complete this post, and used ChatGPT 5.1 (which had now been released) along with the exemplar articles. The new checklist was… odd. ChatGPT first produced a very long checklist, which was both verbose and unspecific. I therefore asked:

Could you please produce a fillable PDF version? Let it be a short version to use before conducting an experimental study.

You can see the checklist and judge it by yourself:

I tried several times to improve on this substandard checklist, to no avail. The same approach on ChatGPT 5 Instant was a little better (but much longer, so a link is provided below).

Diwa Experimental Checklist Chatgpt 5 Instant

40.9KB ∙ PDF file

Download

Download

I still preferred the original checklist. Going back to ChatGPT 5, even after removing the exemplar papers (which I suspected were a problem), the checklist was very wordy and had some tangential items:

The problem here is that with model updates, replicating a close version of the same work using the same prompt cannot be achieved. If this is the case for a simple checklist, I shudder to think what the vagaries of an enterprise-level AI implementation might output. Want that document you need for work? Well, not today! Try rolling back to the previous version of our AI model!

ChatGPT 4o to the rescue

When in doubt, I always fall back to ChatGPT 4o. It’s fast, it’s good enough for simple analytical work, and very good for creative work. So, I tried the original prompt with no exemplars and… it worked surprisingly well!

Diwa Experimental Checklist Chatgpt 4o

3.76KB ∙ PDF file

Download

Download

It’s not too wordy, it’s one page, and it seems to list what I need to remember.

What about Gemini 3?

The web version of Gemini 3 generated a checklist. It looked about the same quality as my two preferred ones above… except Gemini cannot export to PDF! Instead, it provided abstruse Python code that could be used to construct the PDF - clearly not what the average user should be expected to do. So, I skipped it.

Did We Do It?

Today, we constructed a quick experimental checklist for academic research. We built it using ChatGPT, which is widely accessible, and using a few research articles (in this case, mine). The old ChatGPT 5 produced good results, which weren’t replicable (to the best of my ability with ChatGPT 5.1/5. Fortunately, ChatGPT 4o was able to generate a similar checklist. Now I won’t have any excuses if I forget any part of my experimental workflow!

Oh! And DIWA, my faithful robot assistant, reminded me to tell you this: “For those teaching experimental methods or mentoring student researchers, having a reusable checklist template like this can be sanity-saving. Even if it’s AI-generated — just make sure to double-check it!”

Should you do this with AI?

This is a reasonably straightforward application, so I would say yes. While this example highlights that the output of AI applications can vary wildly (and we’re at the mercy of whatever new update is pushed by a few companies), figuring out which ChatGPT version to use was reasonably quick. At the same time, this example highlights the general problem of replicating AI-generated output. Solutions include a mammoth-sized template list (the original article lists many woes with inconsistent AI output) and esoteric methods that are not easily applicable by everyday users.

Speaking about predictability in the context of management, Gimpl and Dakin (1984) compared business forecasting to casting bones – superstitious behavior to maintain an illusion of control, particularly for Western managers. But, surprisingly, magical thinking sometimes provided a benefit, such as for Labrador Indians – paraphrasing the paper, bone-casting yielded mostly random maps that helped hunters avoid over-hunting particular areas.

Randomness in the context of AI output doesn’t provide these surprising benefits, however, since the goal is to produce consistently usable and reproducible output (perhaps less for image generative AI). Fickle, unstable, inaccurate, and immeasurably energy-voracious, we nevertheless boil our seas in reverence of this new machine god, which fittingly reminded me of H.P. Lovecraft’s description of “the blind idiot god Azathoth, Lord of All Things, encircled by his flopping horde of mindless and amorphous dancers, and lulled by the thin monotonous piping of a daemoniac flute held in nameless paws.”

But hey! We made a checklist!

Share

Subscribe now

Share

Subscribe now

Edgar Allan Poe

Gathering data is good, analyzing data is great, but visualizing data is absolutely essential. Data visualization is a window into a dataset’s insights – without insight and the ability to see and communicate the patterns underlying the data, analysis is often a futile endeavor. Indeed, as Poe might have put it, charts, without imagination, are often nothing but carcasses of data.

At the same time, while the “meat and potatoes” of visualizations are the data and its proper display, good visualizations are also aesthetically appealing, inspiring, and even fun to experience. On the flip side, drab charts with a lack of color, whimsy, and good copy are draining —why must we be subjected to whatever default Excel, R, or Python imposes on us?

I refuse to, and you should too. If we do not breathe life into our visualizations, we surrender our humanity —bar by bar, dot by dot. Yet a counterargument is reality: what if we’re not artists? Can we do it with AI?

Let’s try.

Project overview

Breathe life into a visualization with AI

• 🗒️ Topics: Data visualization; Creative work; Image GenAI.

• 🔨 Tools: NightCafe; Microsoft Office.

• 💸 Cost: $5-$10 (to buy enough NightCafe credits to experiment).

• ⌛ Time to completion: About one hour.

Napkin planning

Let’s think before we tinker. Planning on a napkin, along with stating our goals, is always useful.

• Goal: Reimagine a bar chart as a “bear chart”: a whimsical, wintery scene with bar icicles, polar bears, and other creatures.

• Accuracy goal: High

• Creativity goal: High

In my napkin, I emphasize geometry: anybody can reconstruct a chart using AI. The problem is that the relative geometry of the chart must be preserved. That means that if you stretch or squeeze the visualizations, the proportions and size of all the bars must remain (reasonably) identical.

Said differently, imagine if, after embellishing a bar chart with AI, two bars that used to be the same height are now completely different. You’d be lying with statistics!

Doing It With AI

Step 1: The Chart

We begin with a bar chart – any will do. In this case, I used a sample from Tableau’s “Superstore” dataset, which contains performance data from several Canadian provinces. I constructed a bar chart in Excel based on a small, random sample from this data (as such, the patterns shown here might not represent Tableau’s full dataset).

Importantly, while image generative AI has made significant strides in accurately displaying text within images, the large amount of text and numbers usually displayed in a chart implies a high chance of the AI-generated text within the chart being erroneous. Moreover, we do not want elements other than the bars in our reimagined chart. Hence, the chart needs to be cleaned up as shown below, by simply selecting and deleting all unnecessary elements.

Step 1: Reimagining the Chart

Now, the bar chart must be reimagined using image generative AI. There are several potential approaches that might be used here, such as inpainting or using a ControlNet. In multiple failed experiments, I did not encounter much success with these approaches:

However, we can take advantage of a recent development in image generative AI: the availability of image editing models. Specifically, we will use the FLUX KONTEXT model to reimagine the chart, which is available on the NightCafe platform. We need:

• The FLUX KONTEXT model (NightCafe offers three price variants: Dev, Pro, and Max)

• A start image (in this case, an image file of our cleaned chart – the higher the resolution, the better). If you’d like to replicate this exercise, download the image below.

• A text prompt, describing the edits to be made. Crucially, the prompt should also describe what should not vary and thus be preserved. In this case, the text prompt I wrote reads:

Transform this chart into a photorealistic, dramatic style. The background should be a snowy daylit scene, without clashing with the rest of the image. Each bar should be a blue icicle. Preserve the chart’s exact structure, bar size, and location.

I generated two reimagined bar charts with each of the three FLUX KONTEXT models in NightCafe. While the cheaper model’s output is bright, vibrant, and whimsical, the more expensive models generated much darker output, highlighting that more expensive models need not always yield the best results.

Moving forward with KONTEXT Dev as the model of choice, I generated two additional images and then overlaid the original bar chart (now orange, with white transparent color, for visibility). Was our accuracy goal satisfied? Is the relative geometry of all bars preserved?

As can be seen, the answer is not straightforward.

• While charts A, C, and D all preserve (for the most part) the location of the bars, those in chart B do not line up (some are closer to the foreground than others).

• When considering the smaller bar, Chart C seems to almost double its size, whereas in A and D, this is much less of an issue.

Considering that our goal was to keep the bars reasonably identical, I chose to move forward with A, which seemed the most visually appealing of the remaining pair.

Step 3: Breathing Life

While our bar chart looks cooler (no pun intended), it looks sterile —an ordinary bar chart wearing the skin of a whimsical photo. To further breathe life into the visualization, the trick is that FLUX KONTEXT can be used iteratively: start with an initial editing prompt and image, then save the new image, request further edits through a new editing prompt and image, save, and keep going.

To do so, however, we need a preliminary step, in which we’ll add visual elements that will represent areas for the FLUX KONTEXT model to edit. In the napkin plan, I added three red dashed circles – that’s where we’ll further edit. This can be done in PowerPoint. I first saved an upscaled version of our Icicle Chart A (available through NightCafe, which uses the Real-ERSGAN x4+ upscaler), and then added three objects manually as follows:

Here, the three colored spheres represent placeholders to be filled by FLUX KONTEXT. Going back to NightCafe, we can use this image as input, alongside a new editing prompt:

Replace the red dots with playful polar bears, and the yellow dot with a regal snowy owl in mid-flight. Preserve the picture’s exact structure, and the size and relative location of the vertical icicles.

Repeating this process two times, with each of the three FLUX KONTEXT models, yields the following results:

Interestingly, aesthetics aside, the cheaper Dev model didn’t correctly replace the yellow placeholder in one instance. What’s more, the bear cubs, though cute, oddly seem to have no necks and resemble a strange polar bear-corgi breed. The most expensive Max model seems to cut off the owl’s wing in the first try. The mid-range Pro model performs best, with good visual appeal, no strange proportions, and correct edits. But did any of these models satisfy our accuracy goal as well?

As in our first pass, the answer is a bit nuanced. By taking the original chart and resizing it to maintain its relative proportions, we can see that all of these examples are reasonably accurate to the naked eye. The stubborn exception remains the smaller bar, which, despite our efforts, is still a bit off. But it’s a reasonable attempt in my view – no “lying with statistics” here. Our bear chart is now almost complete!

Step 4: Final Touches

Having selected the leftmost FLUX KONTEXT Pro image, the final step is to add details, which can be done in any image editing software (for simplicity, I used PowerPoint). Adding x-axis labels and a title is straightforward:

(Yes, Canadian provinces have very long names.)

Adding the y-axis is a slightly more involved matter. We can again rely on the idea of overlaying the original chart on top of the reimagined one as follows, in order to add the y-axis ticks manually (it looks ugly, but that’s beside the point, since the goal is just to assess the bear chart’s geometry and edit the y-axis):

With an overlay of the original chart, we can see that the bars match very well, and the gridlines of the original chart can be used to form the new Y-axis:

Our bear chart is now complete! If you’re wondering if the chart is truly accurate, use the table below it to verify. With the exception of Newfoundland (the small bar, which is somewhat inaccurate despite our best attempts), the rest are very accurate.

Addendum: Claude’s Solution

The bear chart can also be constructed in Claude directly using two prompts, providing the original data table to first construct a simple bar chart, and then reimagining it:

(1) Take this data and construct a bar chart.

(2) Can you transform this chart into a whimsical image, with polar bears and the bars as icicles? The relative position, height, and width of all bars must be preserved.

After some tinkering (the chart originally didn’t display correctly), here’s Claude’s solution:

Is it ugly? Sure! Does it respect the initial chart’s original geometry? Sure! I respect that. But, still, I would opt for the FLUX KONTEXT, image generative AI approach. I think it strikes a much better balance between accuracy and visual appeal.

Did We Do It?

Today, we reimagined a bland bar chart into a more lively, whimsical bear chart with AI. We constructed it with affordable AI tools and edited it with MS Office. The reimagined chart is reasonably accurate, and simple edits to the one problematic bar (e.g., Photoshop) could be made to fix it. Alternatively, given the reasonably accurate output generated by FLUX KONTEXT Dev, a few more cheap variations might generate an even more accurate chart.

In my view, this is a satisfactory exercise for a number of reasons.

• The bear chart is clearly more engaging and visually interesting – ideal for projects where vividness and audience engagement are a plus.

• One would not create a set of these charts – instead, this might be a marquee visualization to highlight and explain a critical topic or insight. Considering this, the time required to construct it (about an hour or less) seems reasonable.

• The slightly lower accuracy of the bear chart is acceptable in my view – especially if further simple edits can tighten the overlap between charts. We do not need to “lie with statistics” to generate interesting, whimsical charts with AI.

A few limitations and improvements to consider:

• Tighten accuracy (see above).

• Arguably, a polar bear-themed chart is not the most appropriate for a retail results chart – in practice, breathing life into a chart would involve more careful consideration of the context and intended audience.

• Explore other charts (e.g., a line chart resembling a long children’s slide).

• Understand that some charts with complicated colors and geometries (such as a radar chart) might not be good candidates for the approach discussed here.

• I should have left more space for the axis, title, etc. – don’t forget that in your own applications!

Should you do this with AI?

If you don’t have the resources to hire a designer in-house, or you’re working on a personal project, sure.

However, while the bear chart is whimsical and visually interesting, it is not art. From the painstaking penciling of John Tukey’s charts, the scientific, yet poignant visual account of Napoleon’s fated 1812 march by Charles Minard, or the somber account of money in politics through Monopoly piece visuals by Wilson Andrews and colleagues at the NYT, the best visualizations are not those that merely feature appealing imagery: they all also possess a kernel of humanity, a je ne sais quoi that goes beyond mere data display.

We’re not getting that with this method – and I’m glad we don’t.

Share

Subscribe now

Subscribe now