Prerequisites

Ensure you have Python installed, along with the numpy, matplotlib, and scipy libraries. If not, you can install them using pip:

pip install numpy matplotlib scipy

Step 1: Generate Power-law Distributed Data

First, we’ll generate a dataset that follows a power-law distribution using numpy.

import numpy as np

# Parameters
alpha = 3.0  # Exponent of the distribution
size = 1000  # Number of data points

# Generate power-law distributed data
data = np.random.power(a=alpha, size=size)

How to Generate and Plot Random Samples from a Power-Law Distribution in Python?

The data looks like this:

Let’s make some sense out of it and plot it in 2D space:

Step 2: Plot the Cumulative Distribution Function (CDF)

Next, we’ll plot the CDF of the generated data on a log-log scale to visualize its power-law distribution.

import matplotlib.pyplot as plt

# Prepare data for the CDF plot
sorted_data = np.sort(data)
yvals = np.arange(1, len(sorted_data) + 1) / float(len(sorted_data))

# Plot the CDF
plt.plot(sorted_data, yvals, marker='.', linestyle='none', color='blue')
plt.xlabel('Value')
plt.ylabel('Cumulative Frequency')
plt.title('CDF of Power-law Distributed Data')
plt.xscale('log')
plt.yscale('log')
plt.grid(True, which="both", ls="--")
plt.show()

The plot:

Step 3: Fit a Power-law Curve to the CDF

To understand the underlying power-law distribution better, we fit a curve to the CDF using the curve_fit function from scipy.optimize.

from scipy.optimize import curve_fit

# Power-law fitting function
def power_law_fit(x, a, b):
    return a * np.power(x, b)

# Fit the power-law curve
params, covariance = curve_fit(power_law_fit, sorted_data, yvals)

# Generate fitted values
fitted_yvals = power_law_fit(sorted_data, *params)

Step 4: Plot the Fitted Curve with the CDF

Finally, we’ll overlay the fitted power-law curve on the original CDF plot to visually assess the fit.

# Plot the original CDF and the fitted power-law curve
plt.plot(sorted_data, yvals, marker='.', linestyle='none', color='blue', label='Original Data')
plt.plot(sorted_data, fitted_yvals, 'r-', label='Fitted Power-law Curve')
plt.xlabel('Value')
plt.ylabel('Cumulative Frequency')
plt.title('CDF with Fitted Power-law Curve')
plt.xscale('log')
plt.yscale('log')
plt.grid(True, which="both", ls="--")
plt.legend()
plt.show()

Voilà!

This visualization helps in assessing the accuracy of the power-law model in describing the distribution of the data.

Recommended article:

Visualizing Wealth: Plotting the Net Worth of the World’s Richest in Log/Log Space

The post How to Fit a Curve to Power-law Distributed Data in Python appeared first on Be on the Right Side of Change.

One of the most revealing ways to examine this distribution is through a log/log plot of the net worths of the world’s richest individuals. Here’s how to visualize the net worth of the top 100 richest people using Python, providing a step-by-step guide to create a log/log space plot.

Understanding the Data

The dataset consists of the net worths of the top 100 richest people in the world. This information is often available from financial news outlets and wealth-tracking websites. For the purpose of this demonstration, assume we have this data in a list where each value represents an individual’s net worth in billions of dollars.

Here’s a sample from the data:

Why Log/Log Space?

A log/log plot is particularly useful for data that spans several orders of magnitude, as it does with the world’s wealthiest individuals. This type of plot can help to linearize exponential relationships, making it easier to identify patterns that might not be apparent in a linear plot. For wealth distributions, which often follow a power law, log/log plots can highlight the underlying distribution’s scale-free nature.

Preparing for the Plot

Before plotting, ensure you have Python installed on your system along with the necessary libraries: Matplotlib for plotting and NumPy for numerical operations.

If you haven’t already, you can install these libraries using pip:

pip install matplotlib numpy

The Python Script

First, import the necessary libraries:

import matplotlib.pyplot as plt
import numpy as np

Assuming you have the net worth data in a list named net_worths in billions of dollars, you can prepare your data.

For ease of reproducibility, I’ll include my list at the point of writing here:

net_worths_float = [
    234.0, 156.0, 155.0, 126.0, 125.0, 124.0, 118.0, 117.0, 116.0, 116.0,
    87.8, 84.6, 82.4, 74.3, 72.6, 70.6, 69.6, 67.8, 63.2, 61.7, 61.6, 59.4,
    50.5, 50.5, 42.3, 41.3, 41.3, 40.0, 39.9, 39.1, 38.8, 37.0, 36.1, 36.0,
    35.2, 35.1, 34.2, 32.9, 32.0, 31.9, 31.9, 31.5, 30.1, 29.5, 29.3, 29.2,
    28.9, 28.5, 28.0, 27.9, 27.9, 27.7, 27.3, 27.1, 26.6, 26.5, 26.5, 25.9,
    25.1, 23.9, 23.9, 23.4, 23.2, 23.2, 23.0, 22.6, 22.3, 22.1, 21.8, 21.6,
    21.5, 21.5, 21.4, 21.4, 21.3, 21.2, 20.6, 20.6, 20.4, 20.3, 19.9, 19.7,
    19.6, 19.1, 19.0, 18.9, 18.8, 18.8, 18.5, 18.5, 18.5, 18.5, 18.4, 17.7,
    17.6, 17.6, 17.5, 17.2, 17.2, 17.2
]

If your data isn’t sorted, sort it in descending order:

net_worths = sorted(net_worths, reverse=True)

Next, create a rank for each individual based on their position in the sorted list. The richest person gets rank 1, the second richest gets rank 2, and so on:

ranks = np.arange(1, len(net_worths) + 1)

Plotting the Data

Now, you’re ready to plot the data in log/log space:

plt.figure(figsize=(10, 6))
plt.loglog(ranks, net_worths, marker='o', linestyle='-', color='b')
plt.xlabel('Rank (log scale)')
plt.ylabel('Net Worth in Billions (log scale)')
plt.title('Net Worth of the Top 100 Richest People (Log/Log Space)')
plt.grid(True, which="both", ls="--")
plt.show()

This code snippet will generate a log/log plot of the net worths. The loglog function from Matplotlib is used to automatically scale both axes to a logarithmic scale. Markers are added for each point to clearly delineate the individual net worths, and a grid is added for better readability.

Interpreting the Plot

In the resulting plot, each point represents an individual’s net worth plotted against their rank. A straight line in a log/log plot indicates a power law distribution, common in wealth distributions and many natural phenomena. The slope of this line (if it appears roughly straight) can give you the power law’s exponent, offering deeper insights into the inequality of wealth distribution.

This visualization technique is not just limited to financial data; it can be applied to any dataset that spans multiple orders of magnitude and is suspected to follow a power law or similar distribution. Whether you’re a data scientist, economist, or simply a curious observer, plotting data in log/log space can unveil patterns and relationships that are not immediately visible in traditional linear plots.

Follow Up Analysis

For instance, you can examine the cumulative net worth as people are sampled from this distribution:

Also, check out our Finxter article:

8 Millionaire Tips to Reach Financial Freedom as a Coder

The post Visualizing Wealth: Plotting the Net Worth of the World’s Richest in Log/Log Space appeared first on Be on the Right Side of Change.

Be it shaping an intuitive dashboard for data analysis, architecting an easily navigable API, or constructing straightforward web interfaces for blockchain applications, a grasp on basic design principles separates the forgettable from the functional.

This chapter examines the impactful principle of minimalism in design and user experience (UX).

Previous Chapter: The Art of Clean Code — 14 Unix Principles

Transformative Minimalism in Tech’s Evolution

Reflect on the mobile phone’s trajectory—from the cumbersome ’80s bulk to the sleek smartphones of the 21st century. Through Nokia’s iterative shedding of weight and size, and the eventual rise of the iPhone, a pattern emerges: elegance in tech aligns with the pursuit of less.

This narrative is not exclusive to phones. Google’s search homepage offers a masterclass in minimalism—billions of users are welcomed daily by simplicity incarnate.

In stark contrast, competitors like Yahoo muddied their interfaces with ads and news, a move that cost them users and market dominance.

Google’s Material Design philosophies reinforce this commitment to intuitive, minimalist interfaces that resonate with users through familiarity and ease of interaction. These design choices aren’t solely about aesthetics; they are strategic, optimizing the most valuable resources:

• user time,
• interface space, and
• financial investment.

Crafting Minimalistic Design: Principles and Practices

Prioritizing Whitespace

Whitespace may wrongly be deemed wasted space—when it’s quite the contrary. Google and Apple leverage it to maintain user focus and clarity. An uncluttered interface may be the divider between retaining users and losing them to confusion.

The figure shows a simple design idea for an online pizza delivery service. The whitespace supports the focus on the main thing: getting customers to order pizza. Unfortunately, seldomly will a pizza delivery service be bold enough to use whitespace in such an extreme way.

Whitespace also helps increasing clarity with text:

The left side of the figure is far less readable.

The right side injects whitespace to improve readability and UX:

• margins on the left and right around the text block,
• indentation of paragraphs,
• an increased line height,
• top and bottom margins around paragraphs, and
• increased font size.

The costs of this additional space are negligible: scrolling is cheap, and we don’t have to physically cut more trees for paper when the publication is digital.

On the other hand, the benefits are very real: the UX of your website or application improves significantly!

Eliminating Redundant Elements

In the quest for simplicity, question every element’s utility. Discard the superfluous, maintain the essential. The goal is not just good design; it is great design, one that prioritizes user needs over decorative features.

Here’s how you can think about it:

This shows an idealized editing process in which you classify each element according to its importance regarding the UX.

For example, does a menu item referring to your company’s blog help the user in the checkout process when ordering a product? No, so it should be classified as not important.

Amazon has stripped all unnecessary design elements from the ordering process, for instance, by introducing the one-click buy button.

Story: When I first learned about this method in a scientific writing workshop, it completely transformed the way I thought about editing. Removing unimportant and less important design elements guarantees improved usability with little risk. But only truly great designers have the boldness to remove important design elements and leave only very important elements. Yet, this is what separates great from merely good design.

Here’s another example where many design elements have been successfully removed to accomplish greater quality and superior design:

Cutting Down on Features

Just as an author must kill their darlings, a developer must curb feature creep. The success stories of tech—think of Microsoft’s apparent bloated offerings—are actually narratives of ruthless feature prioritization.

But you don’t see the features that have been removed or not pursued further. To keep learning about this, check out our lesson on MVPs:

The Art of Clean Code – Minimum Viable Product (MVP)

Streamlining Design Variations

Cognitive ease should guide design choices. Limit font variations, color uses, and sizes to reduce complexity. Consistent, focused use of these elements leads to a more coherent user experience.

Consistency Across Interfaces

Uniformity across app interfaces isn’t merely about aesthetics—it’s about creating a cohesive and instantly recognizable user experience. Adherence to brand guidelines ensures this consistency.

The Future of Design: Simplicity Reigns

As we look ahead, the essence of minimalism in design seems poised to deepen with advancements in voice recognition and virtual interfaces.

The trend suggests an evolution toward even more streamlined user experiences. We’re moving towards an era where the ultimate design may well be an ‘invisible’ interface, integrated seamlessly into our daily lives.

Through examples from giants like Apple and Google, we’ve observed the powerful impact minimalism has in the tech world—a realm where the simplest interfaces are often the most successful. As technology continues to evolve, one truth remains clear: in the world of design, less indeed proves to be more.

Stay tuned for the next chapter, where we conclude with focus—its critical role and impact in the realm of programming.

Advanced Reading: For those eager to delve into the principles highlighted in this chapter, detailed insights can be found in Google’s Material Design guidelines (https://material.io/design/introduction/) and Apple’s Interface design documentation (https://developer.apple.com/design/human-interface-guidelines/).

The post The Art of Clean Code – Less Is More In Design appeared first on Be on the Right Side of Change.

Please find a comma-separated list of styles at the end of this article!

On Twitter, you often read beginners voicing a strong and mostly unfounded opinion that prompt engineering is not a real skill. Yet – changing a single word in a 32-word prompt can completely change the output.

Alien technology, indeed! And taming this technology is what prompt engineering is all about.

In this article, I’ll give you the image outputs when using the following prompt on Midjourney’s new version 6, changing only a single word at the end: the style specifier.

 Midjourney V6 Prompt: A young woman with straight, dark-blonde hair and mocha-colored doe eyes. She has a V-shaped face and a slightly curved nose. She sits on a hill, reading a book. [style_specifier_here]

The image above is produced by the vanilla prompt, i.e., without a style specifier. Now let’s have a look at the different style specifiers you can use in your own image prompts:

Minecraft

Lego

Hyperrealism

Realism

Impressionism

Illustration

Watercolor

Stained Glass Window

Oil Painting

Steampunk

Anime

Art-deco

Abstract Expressionism

Gothic

Pop-art

Glitch art

Cartoon

Paper cut art

Dripping painting

Renaissance

Graffity

Mosaic

Minimalistic

Art Nouveau

Geometric

Classicism

Baroque

Ukiyo-E

Statue

Chalk drawing

Street art

Pencil drawing

Harry Potter style

Futurist

Picasso

Dali

Pixeled

Monet

Simpsons

Rembrandt

Retro 80s

Rococo

Low Poly

Manga

The Sims

Bauhaus

Art Informel

Pastel

Disney

Genshin Impact

All Styles List

We tried many more, but these were the best ones. I’ve compiled a comma-separated list of all style specifiers you can use here:

Minecraft, Lego, Hyperrealism, Realism, Impressionism, Illustration, Watercolor, Stained Glass Window, Oil Painting, Steampunk, Anime, Art-deco, Abstract Expressionism, Gothic, Pop-art, Glitch art, Cartoon, Paper cut art, Dripping painting, Renaissance, Graffity, Mosaic, Minimalistic, Art Nouveau, Geometric, Classicism, Baroque, Ukiyo-E, Statue, Chalk drawing, Street art, Pencil drawing, Harry Potter style, Futurist, Picasso, Dali, Pixeled, Monet, Simpsons, Rembrandt, Retro 80s, Rococo, Low Poly, Manga, The Sims, Bauhaus, Art Informel, Pastel, Genshin Impact.

The post 50 Best Midjourney Style Prompts (New Version 6) appeared first on Be on the Right Side of Change.

Yahoo Finance API offers a wealth of financial data, from stock prices and market trends to currency exchange rates. This guide will introduce you to using the Yahoo Finance API yahoo_fin with Python, a powerful combination for financial data analysis.

Quick Info: The Python library yahoo_fin is not well maintained but works for quick, dirty, and simple access without requiring you to create an API key. It provides free access to a wide range of financial data.

Setting Up Your Environment

Before diving into the API, ensure Python is installed on your system. Python 3.x is recommended for its latest features and support.

Recommended: How to Install Python?

You’ll primarily need yahoo_fin, a Python library that simplifies accessing Yahoo Finance data. Install it using pip:

pip install yahoo_fin

Understanding the Yahoo_fin Library

yahoo_fin offers two main modules:

• stock_info: For stock data.
• options: For options data.

These modules provide functions to access various data types like historical prices, stock information, etc.

Fetching Historical Data with Yahoo_fin

The get_data() function from stock_info module is used to fetch historical price data for a given stock. Here’s how you use it:

from yahoo_fin.stock_info import get_data

# Fetch historical data for Apple
apple_data = get_data('AAPL')
print(apple_data)

Output:

For real-time data, use the get_live_price() function:

from yahoo_fin.stock_info import get_live_price

# Get the current price of Tesla stock
tesla_live_price = get_live_price('TSLA')
print(tesla_live_price)
# 234.3000030517578

Example: Analyzing Stock Performance

Python’s data analysis libraries, like Pandas, can be used in conjunction with yahoo_fin to perform more complex analyses.

import pandas as pd
from yahoo_fin.stock_info import get_data

# Fetch historical data for a stock
stock_data = get_data('AAPL', start_date='01/01/2020', end_date='01/01/2021')

# Convert to a Pandas DataFrame for analysis
df = pd.DataFrame(stock_data)
print(df)

Output:

Visualizing Data

With libraries like Matplotlib or Seaborn, you can visualize financial data:

import matplotlib.pyplot as plt

# Plotting the closing price of Apple stock
plt.figure(figsize=(10, 5))
plt.plot(df['close'], label='Apple Close Price')
plt.title('Apple Stock Close Price (2020)')
plt.xlabel('Date')
plt.ylabel('Price (USD)')
plt.legend()
plt.show()

This is how this looks at the time of writing (using the df variable defined in the previous step):

Check out our email newsletter with free cheat sheets to keep learning and improving your skills:

The post Yahoo-Fin: Fetching Historical Stock Data with Python’s Yahoo Finance API appeared first on Be on the Right Side of Change.

import matplotlib.pyplot as plt

# Data
x = [1, 2, 3, 4]
y = [1, 4, 9, 16]

# Plotting the line with a specific color, e.g., 'red'
plt.plot(x, y, color='red')

# Displaying the plot
plt.show()

In this minimal code example, plt.plot(x, y, color='red') creates a line plot of x versus y, with the line color set to red. You can replace 'red' with other color names like 'blue', 'green', etc., or use color codes (e.g., '#FF5733' for a specific shade of orange).

Let’s explore Matplotlib’s amazing color functionality further!

Understanding Matplotlib Colors

Basic Colors in Matplotlib

Matplotlib is a popular data visualization library in Python, and colors play a crucial role in making these visualizations informative and visually appealing. With the right choice of colors, you can emphasize certain aspects of your data and make your plots more interpretable. In Matplotlib, you have access to a wide range of built-in colors to work with.

Some of the basic colors in Matplotlib are red, green, blue, cyan, magenta, yellow, black, and white. These colors can be specified in a variety of ways, such as by their names or using RGB and RGBA values.

Here are some examples of how you can define colors in Matplotlib:

• By name: 'red', 'blue', 'green'
• By RGB values: (0.5, 0.2, 0.8)
• By RGBA values: (0.5, 0.2, 0.8, 0.5)

Matplotlib Recognizes Colors

Matplotlib recognizes different formats to specify colors, which provides flexibility for you when customizing your visualizations. Transparency can also be added to these colors using the alpha value of an RGBA color.

Here’s a brief overview of some ways to specify colors in Matplotlib:

• Named colors: E.g., 'coral', 'seagreen', 'royalblue'.
• Hex color codes: E.g., '#FF5733', '#4D5656'.
• RGB tuples: E.g., (0.5, 0.8, 0.4).
• RGBA tuples: E.g., (0.2, 0.7, 0.9, 0.6).

Working with RGB and Hex Colours

RGB to Hex Conversion

When working with colors in matplotlib, you might need to convert RGB values to Hex format. RGB colors are defined by a tuple of three values corresponding to the red, green, and blue components. For example, an RGB value can be represented as (0.1, 0.2, 0.5). To convert RGB colors to Hex values, you can use the matplotlib.colors.to_hex function. Here’s an example:

import matplotlib.colors as mcolors

rgb_color = (0.1, 0.2, 0.5)
hex_color = mcolors.to_hex(rgb_color)
print(hex_color)
# #1a3380

This code snippet will convert the RGB color (0.1, 0.2, 0.5) into its corresponding Hex value '#1A3380'.

Specifying Colors in RGB and Hex

In matplotlib, you can specify colors using both RGB and Hex values. When specifying colors as RGB or RGBA (red, green, blue, alpha) tuples, make sure to use float values in the closed interval [0, 1]. For example, you can use (0.1, 0.2, 0.5) for an RGB color or (0.1, 0.2, 0.5, 0.3) for an RGBA color with alpha transparency.

On the other hand, to specify colors in Hex format, use a string representing the hex RGB or RGBA value (e.g., '#0f0f0f' for an RGB hex color or '#0f0f0f80' for an RGBA hex color). The Hex string is case-insensitive.

Here’s a simple example of how to create a scatter plot while specifying colors in RGB and Hex formats:

import matplotlib.pyplot as plt

# Example data
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]

# Specifying colors in RGB and Hex
colors = [
    (0.1, 0.2, 0.5),  # RGB color
    '#FF5733',        # Hex color
    (1, 0, 0, 0.5),   # RGBA color
    '#0f0f0f80'       # RGBA Hex color
]

# Creating a scatter plot
for i, color in enumerate(colors):
    plt.scatter(x[i], y[i], color=color, label=color)

plt.legend()
plt.show()

Output:

Using Named Colors and XKCD Colors

In matplotlib, you have access to a wide range of named colors and XKCD colors to create visually appealing and informative plots.

Named colors are predefined colors with unique names, making it convenient for you to apply them in your plots. You can use basic color names such as 'blue', 'green', 'red', 'cyan', 'magenta', 'yellow', 'black', and 'white'. Matplotlib library also supports a more extensive set of named colors, allowing you to choose from over 1200+ options. To work with named colors, simply use their names as the color parameter in your plot.

XKCD colors were introduced based on a user survey conducted by the webcomic XKCD. These colors offer an even more diverse palette, with almost 95 of the 148 X11/CSS4 color names making an appearance in the XKCD color survey. Note that the color values for the X11/CSS4 and XKCD palettes may differ, with only 'black', 'white', and 'cyan' being identical.

When creating your plots, you can combine both named and XKCD colors to enhance visual appeal:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2*np.pi)
y = np.sin(x)

# Using named color
plt.plot(x, y, color='blue')

# Using XKCD color
plt.plot(x, y, color='xkcd:sea green')

plt.show()

Remember, when using XKCD colors, prefix the color name with 'xkcd:', as in 'xkcd:gray'.

Explore and experiment with various named colors and XKCD colors in your matplotlib plots to customize them according to your needs. Choosing the right color combination not only makes your plots visually pleasing but also helps in conveying the information more effectively to your audience.

Delving into Colormaps

Standard and Custom Colormaps

In Matplotlib, you have access to a wide variety of built-in colormaps that can be easily utilized for visualizing your data. Some popular colormaps include viridis, plasma, and inferno. To use a colormap, simply import the matplotlib.cm module as cm and then choose from the available colormaps.

import matplotlib.cm as cm
custom_colormap = cm.viridis

However, sometimes you may want to create a custom colormap that matches your specific needs. In this case, you can create your own colormap using the LinearSegmentedColormap.from_list() method. It requires a list of RGB tuples, defining the mixture of colors from 0 to 1.

from matplotlib.colors import LinearSegmentedColormap

colors = [(0, 0, 1), (0, 1, 1), (1, 1, 0), (1, 0, 0)]
custom_colormap = LinearSegmentedColormap.from_list("my_colormap", colors)

Hot and Cold Colormaps

A special subset of colormaps, known as hot and cold colormaps, are particularly useful when visualizing data with temperature-like values. These colormaps help to emphasize the contrast between low and high values in your data. Examples of hot colormaps are hot, autumn, and YlOrRd. Cold colormaps include cool, winter, and PuBu.

When working with numpy arrays (np), you can easily apply a colormap to your data. By first normalizing your data, you ensure that the colormap maps to the full range of values in your dataset.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap

colors = [(0, 0, 1), (0, 1, 1), (1, 1, 0), (1, 0, 0)]
custom_colormap = LinearSegmentedColormap.from_list("my_colormap", colors)

data = np.random.rand(10, 10)
norm_data = (data - data.min()) / (data.max() - data.min())

fig, ax = plt.subplots()
im = ax.imshow(norm_data, cmap=custom_colormap)
plt.colorbar(im)
plt.show()

Matplotlib Pyplot and Its Color Utilities

Aqua and Other Unique Colors in Pyplot

Matplotlib provides a diverse selection of colors, including unique ones like Aqua. You can easily incorporate these colors into your plots to make them more visually appealing.

For instance, you can set an Aqua-colored line in your plot by specifying c='aqua' as a keyword argument when plotting with plt.plot(). You’ll find that it’s simple to experiment with different colors and create visually striking charts to enhance your data visualization.

Working with Labels and Titles

Adding labels and titles is essential to provide context and improve the readability of your plots. With Matplotlib’s pyplot (usually imported as plt), you can easily add titles and labels to your plots. To set a title for your plot, use the plt.title() function and pass in a string that describes the main topic of the plot. For example, plt.title("My Aqua-colored Line Plot") will display a title at the top of the plot.

Use plt.xlabel() and plt.ylabel() functions to label the x-axis and y-axis respectively. Provide a string describing the quantities being plotted along each axis, and the labels will appear next to the corresponding axis.

Color Specification Conversions in Matplotlib

In Matplotlib, you can easily convert colors between different formats using built-in functions to ensure consistent handling of colors throughout your visualizations. Here are some of the key functions for color specification conversions:

• to_rgba: This function allows you to convert a color or sequence of colors to RGBA format. It accepts a variety of input color formats (e.g., string, RGB tuple, or RGBA tuple), and normalizes the resulting RGBA values to a range of 0 to 1.
• to_rgba_array: Like the to_rgba function, this one converts a set of colors to RGBA format, but it does so for an entire array of colors in a single step. This is particularly useful when you’re working with colormaps or a large collection of colors.
• rgb_to_hsv: This function allows you to convert a set of RGB colors to the hue, saturation, and value (HSV) color space. This conversion can be useful for creating custom colormaps or color functions that take advantage of the HSV representation, which can be more intuitive when dealing with color palettes.

Here’s an example of using these color conversion functions in your code:

import matplotlib.colors as mcolors

# Convert a single color to RGBA format
color_rgba = mcolors.to_rgba('blue')

# Convert a list of colors to an RGBA array
color_list = ['red', 'green', 'blue']
color_rgba_array = mcolors.to_rgba_array(color_list)

# Convert a list of RGB colors to HSV format
rgb_colors = [(1, 0, 0), (0, 1, 0), (0, 0, 1)]
hsv_colors = mcolors.rgb_to_hsv(rgb_colors)

By understanding and utilizing these color specification conversion functions in Matplotlib, you can achieve greater control over your data visualizations and ensure that your colors are represented consistently across various color formats.

Manipulating CSS4 and Tableau Colors

Introduction to CSS4 Colors

With Matplotlib, you can tap into the power of CSS4 colors to enhance your data visualizations. CSS4 colors are a standardized set of over 140 named colors that can be used in web design, and they are also available in Matplotlib for creating vibrant and meaningful plots.

To use CSS4 colors, simply refer to the color by its name (case-insensitive) when specifying a color for a plot. For example:

import matplotlib.pyplot as plt

plt.plot([1, 2, 3], [4, 5, 6], color='darkorchid')
plt.show()

This code snippet will generate a line plot with a darkorchid color. By exploring the list of named CSS4 colors, you can find the perfect color for your visualization needs.

Understanding Tableau Colors

Tableau is a powerful data visualization tool that offers its own set of colors, known as the Tableau palette. The Tableau color palette is designed to be visually appealing and colorblind-friendly. In Matplotlib, you can access the Tableau colors by applying the tableau-colorblind10 style:

import matplotlib.pyplot as plt

plt.style.use('tableau-colorblind10')

Once you have applied this style, Matplotlib will use the colors from the Tableau palette automatically for your plots. If you need to access a specific color from the palette, you can create a dictionary of Tableau colors using their index positions:

tableau_colors = {
    0: '#1f77b4',
    1: '#ff7f0e',
    2: '#2ca02c',
    3: '#d62728',
    4: '#9467bd',
    5: '#8c564b',
    6: '#e377c2',
    7: '#7f7f7f',
    8: '#bcbd22',
    9: '#17becf'
}

color = tableau_colors[0]  # Access the first tableau color

Working with Grayscale and Transparency

Grayscale in Matplotlib

In Matplotlib, you can easily work with grayscale images. To display an image in grayscale, you can employ the imshow() function. When reading an image using the PIL (Python Imaging Library) library, you can convert it to grayscale with the convert("L") method.

For example:

from PIL import Image
import matplotlib.pyplot as plt

image = Image.open(file).convert("L")
plt.imshow(image, cmap="gray")
plt.show()

This code snippet will display the image in grayscale using the gray color map.

Transparency and Alpha Channel

Transparency is another useful feature to work with in Matplotlib. The alpha channel determines the transparency level of an element. Alpha values range from 0 (completely transparent) to 1 (completely opaque).

You can set the alpha values for various elements, such as text, lines, or patches. For example, when creating a plot with a semi-transparent orange rectangle, you can adjust the alpha value:

import matplotlib.patches as patches

rect = patches.Rectangle((0.5, 0.5), 1, 1, linewidth=1, edgecolor='r', facecolor='orange', alpha=0.8)
ax.add_patch(rect)
plt.show()

In this example, the orange rectangle’s transparency is controlled by setting the alpha parameter to 0.8. Remember to keep your plots clear and understandable when using transparency with different elements.

Using Matplotlib to Create Scatter Plots and Colorbars

In this section, we will discuss how you can use Matplotlib to create scatter plots and colorbars in your data visualizations. By the end of this section, you will be able to confidently create scatter plots and colorbars using the Matplotlib library.

Creating Scatter Plots

Scatter plots are widely used to visualize the relationships between two continuous data features. With Matplotlib, creating a scatter plot is as simple as using the scatter() function. For example, to create a basic scatter plot with random data points, you can use the following code:

import numpy as np
import matplotlib.pyplot as plt

x = np.random.rand(100)
y = np.random.rand(100)

plt.scatter(x, y)
plt.show()

But what if you want to display multiple sets of data points, each with a different color? You can simply call the scatter() function multiple times before plt.show() and set the color parameter to a color of your choice:

plt.scatter(x1, y1, color='red')
plt.scatter(x2, y2, color='blue')

Find more details on creating different scatter plots here.

Building Colorbars

Colorbars help in conveying additional information about your data points by assigning colors based on a third variable or their value. To create colorbars with your scatter plot, you need to set the c parameter in the scatter() function, which represents the data points’ colors, and then use the colorbar() function:

import numpy as np
import matplotlib.pyplot as plt

x = np.random.rand(100)
y = np.random.rand(100)

c_values = np.random.rand(100)
plt.scatter(x, y, c=c_values, cmap='viridis')
plt.colorbar()
plt.show()

In the above example, the colors are set according to the c_values array, using the chosen colormap viridis. You can find more details on adding colorbars to your scatter plots here.

Frequently Asked Questions

How do I specify a color in Matplotlib using RGB?

To specify a color using RGB values in Matplotlib, you can use the tuple format (r, g, b), where r, g, and b are floating-point numbers between 0 and 1 representing the intensity of red, green, and blue, respectively. For example:

plt.plot(x, y, color=(0.5, 0.2, 0.8))

This will create a plot with a custom color that has 50% red, 20% green, and 80% blue.

What are the default color cycles in Matplotlib?

Matplotlib uses a default color cycle that is applied to plot elements like lines, markers, and labels. The default cycle includes the following colors, specified with single character shorthand:

• b: blue
• g: green
• r: red
• c: cyan
• m: magenta
• y: yellow
• k: black
• w: white

These colors will be used in the order specified when plotting multiple elements in a single plot.

How do I convert a hex color to RGB in Matplotlib?

In Matplotlib, you can convert a hex color to RGB by using the matplotlib.colors.hex2color function. Here’s an example:

import matplotlib.colors as mcolors
hex_color = "#32a852"
rgb_color = mcolors.hex2color(hex_color)

This will convert the hex color #32a852 to its corresponding RGB tuple (0.196, 0.658, 0.322).

How can I create a custom color map in Matplotlib?

To create a custom color map in Matplotlib, you can use the matplotlib.colors.LinearSegmentedColormap class. First, define a dictionary that maps the color channel (red, green, or blue) to a list of segments. Each segment is a tuple with three values: (x, y1, y2), where x is a position between 0 and 1, and y1 and y2 are color intensities. Here’s an example:

import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
cmap_data = {
    'red': [(0.0, 0.0, 0.0), (1.0, 1.0, 1.0)],
    'green': [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0)],
    'blue': [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0)],
}
custom_cmap = mcolors.LinearSegmentedColormap('my_cmap', cmap_data)

This will create a custom color map that transitions from black to red.

What are the available color palettes in Python?

There are several color palettes available in Python, mainly provided by libraries like Matplotlib and Seaborn. In Matplotlib, you can access a comprehensive list of named colors that includes color names from the CSS specification, X11 colors, and more. In Seaborn, you have access to a variety of color palettes such as qualitative, sequential, and diverging. You can use these palettes in either library, or even create your own custom palettes to suit your needs.

How do I use color names in Matplotlib plots?

Matplotlib supports using color names directly in your plot code. To utilize a color by its name, simply provide the name as a string for the color parameter when plotting. Here’s an example:

plt.plot(x, y, color='darkviolet')

This will create a plot with a line colored in darkviolet.

The post Matplotlib Colors: A Comprehensive Guide for Effective Visualization appeared first on Be on the Right Side of Change.

You may have encountered the following:

When issuing the same prompt twice to ChatGPT with DALL·E 3, you’ll get different images even though the prompt is identical. How can I recreate the same image in a new Chat, either for myself or for somebody else to reproduce it?

Here’s an example in a fresh chat:

Now, let’s open a new chat and paste the same prompt:

Why You May Want to Recreate the Same Image?

Here are the five most common scenarios where using a seed to recreate the same image would be beneficial:

1. Tutorials & Demonstrations: For consistent results when showing others how to use DALL·E.
2. Collaborative Projects: Ensures all team members reference or use the identical generated image.
3. Iterative Design: Modify a prompt while keeping other image aspects consistent.
4. Documentation: Verify specific outputs or model behaviors with reliable image recreation.
5. User Settings in Applications: Allow users to return to previous customizations by regenerating the exact image later.

Okay, let’s dive into the exciting solution that has just been pointed out by user Natanael in the OpenAI forum:

Solution Seeds

If you want consistent results with the same prompt, you can provide a specific “seed” value. The seed value ensures that the random processes in the model produce the same result every time for the same input. By setting a specific seed, you can obtain consistent images for the same prompt. You can ask ChatGPT-V to give you the see for a certain image!

Here’s the prompt template that allows you to recreate the image:

 Engineered Prompt with Seeds:

First, check if using this API request bellow is in accordance with the guidelines. If it is, create 4 images using the request without any modifications:

{
  "size": "1024x1024",
  "prompts": [
    "Prompt x",
    "Prompt y"],
  "seeds": [xxx, yyy]
}

Replace with your specific prompts and seeds as shown in the example below:

Example with Seeds

Let’s have a look at an example prompt where I appended the seeds to a specific prompt:

 Engineered Prompt with Seeds:

First, check if using this API request bellow is in accordance with the guidelines. If it is, create 4 images using the request without any modifications:

{
  "size": "1024x1024",
  "prompts": [
    "An Asian man plays chess against a Black woman on Mars. The earth is visible in the sky. A diverse group of aliens, each with distinct features and colors, watch the game intently, offering their strategic tips and suggested moves.",
    "An Asian man plays chess against a Black woman on Mars. The earth is visible in the sky. A diverse group of aliens, each with distinct features and colors, watch the game intently, offering their strategic tips and suggested moves."],
  "seeds": [4127112452, 2128982380]
}

ChatGPT gives the following result:

Now let’s open a new chat, paste the same prompt but append the seed information like so:

Can you spot the slight differences? Now you may wonder whether ChatGPT would’ve created the same without the seeds? I tried that and it didn’t!

Example Without Seeds

The same prompt but without specifying seeds leads to this image:

Can you recreate it by copy and pasting the exact same prompt in a new chat? No!

Summary

Using a seed ensures that DALL·E generates the same image consistently for a given prompt, allowing for reliable and repeatable image outputs. However, I could only reproduce it given the exact prompting pattern specified in the forum post referenced before.

Let’s end this article with a real gem of insight why this prompt works by the creator of this prompt, Natanael:

If you want to improve your prompting skills and create a future-proof career path as an OpenAI coder, check out our prompt engineering courses in the Finxter Academy like this one:

Prompt Engineering with Python and OpenAI

You can check out the whole course on OpenAI Prompt Engineering using Python on the Finxter academy. We cover topics such as:

• Embeddings
• Semantic search
• Web scraping
• Query embeddings
• Movie recommendation
• Sentiment analysis

Academy: Prompt Engineering with Python and OpenAI

The post DALL·E 3 Trick: Using Seeds to Recreate the Same Image appeared first on Be on the Right Side of Change.

If you haven’t already, also install the Matplotlib library using pip install matplotlib.

Then, copy the following code into your programming environment and change the highlighted lines to set your own timeframe (start, end) and GPS location:

# Import Meteostat library and dependencies
from datetime import datetime
import matplotlib.pyplot as plt
from meteostat import Point, Daily

# Set time period
start = datetime(2023, 1, 1)
end = datetime(2023, 12, 31)

# Create Point for Stuttgart, Germany
location = Point(48.787399767583295, 9.205803269767616)

# Get daily data for 2023
data = Daily(location, start, end)
data = data.fetch()

# Plot line chart including average, minimum and maximum temperature
data.plot(y=['tavg', 'tmin', 'tmax'])
plt.show()

This code fetches and visualizes the average, minimum, and maximum temperatures for Stuttgart, Germany, for the entire year of 2023 using the Meteostat library.

Here’s the output:

Here are the three highlighted lines:

• start = datetime(2023, 1, 1): This sets the start date to January 1, 2023.
• end = datetime(2023, 12, 31): This sets the end date to December 31, 2023. Together, these lines define the time period for which we want to fetch the weather data.
• location = Point(48.787399767583295, 9.205803269767616): This creates a geographical point for Stuttgart, Germany using its latitude and longitude GPS coordinates. The Point class is used to represent a specific location on Earth.

You can use Google Maps to copy the GPS location of your desired location:

You can try it yourself in the interactive Jupyter notebook (Google Colab):

If you want to become a Python master, get free cheat sheets, and coding books, check out the free Finxter email academy with 150,000 coders like you:

The post Python Code for Getting Historical Weather Data appeared first on Be on the Right Side of Change.

General Intuition Metcalfe’s Law

Metcalfe’s law states that the value of a network is proportional to the square of the number of connected users of the system (N^2). This law was initially formulated in the context of telecommunications networks by Robert Metcalfe, the inventor of Ethernet.

The intuition behind Metcalfe’s law is relatively straightforward:

1. Value of Connections: The value of a network to a user is proportional to the number of other users they can connect with. For example, a telephone is useless if you are the only one who has one, but becomes more valuable as more people get telephones.
2. Number of Connections: The number of possible connections between users in a network increases quadratically with the number of users. Specifically, the number of possible connections between N users is N(N-1)/2, which is proportional to N^2.

So, the idea is that as the number of users in a network increases, the number of possible connections between users increases quadratically, and therefore the value of the network also increases quadratically.

This intuition can be applied to various types of networks, including social networks, the internet, and even cryptocurrencies like Bitcoin. For example, the value of a social network like Facebook increases as more people join the network because each user can connect with more people. Similarly, the value of Bitcoin may increase as more people use it because it becomes more useful as a means of exchange.

Why Does Metcalfe’s Law Apply to Bitcoin?

Metcalfe’s law can be applied to Bitcoin for several reasons:

1. Network Effect: Bitcoin, like other networks, benefits from the network effect. The more people, businesses, and institutions that use and accept Bitcoin, the more valuable it becomes as a medium of exchange. This is because each new user increases the number of potential transactions and, therefore, the utility of the network for all users.
2. Number of Connections: The number of possible connections between users in the Bitcoin network increases with the number of users. As more people use Bitcoin, the number of potential transactions increases, which increases the utility and, therefore, the value of the network.
3. Decentralization: Bitcoin is a decentralized network, meaning that it is not controlled by any single entity. This makes it more resilient and potentially more valuable as more nodes (computers running the Bitcoin software) join the network and contribute to its security and stability.
4. Historical Correlation: Some studies have found a correlation between the market value of Bitcoin and the square of the number of active users or other network metrics. This suggests that Metcalfe’s law may be a useful model for estimating the value of Bitcoin.

But Bitcoin is a Store of Value More Than a Medium of Exchange…

If you’re like me, you believe that currently Bitcoin is more a store of value than a medium of exchange. So does Metcalfe’s Law apply in the first place? I have put some thoughts into this.

When viewing Bitcoin as a store of value, Metcalfe’s Law can still be applied, but with a slightly different perspective.

1. Network Security: The security of the Bitcoin network is crucial for its role as a store of value. The more nodes and miners there are in the network, the more secure it is against attacks. This increased security enhances its value as a store of value. According to Metcalfe’s Law, the value of a network is proportional to the square of the number of connected users. In the context of Bitcoin as a store of value, this could be interpreted as the value of Bitcoin increasing with the square of the number of participants (nodes, miners, and users) in the network.
2. Liquidity: For any asset to be a good store of value, it needs to be liquid, meaning it can be easily bought or sold. The more participants there are in the Bitcoin network, the more liquid it becomes, which enhances its value as a store of value.
3. Acceptance and Adoption: The more widely accepted and used Bitcoin is, the more valuable it becomes as a store of value. This is because widespread acceptance and use increase the demand for Bitcoin, which in turn increases its value.
4. Trust: Trust is a crucial factor for any store of value. The more participants there are in the Bitcoin network, the more trust is built in the network’s security and stability, which enhances its value as a store of value.

So, even when viewing Bitcoin as a store of value, Metcalfe’s Law can still be applied in the sense that the value of Bitcoin as a store of value increases with the square of the number of participants in the network.

What Is “N” in Metcalfe’s Law for Bitcoin?

Getting the exact number of people participating in the Bitcoin network can be quite challenging due to the decentralized and pseudonymous nature of the network.

However, there are several proxies or indicators that you can use to estimate the number of participants:

1. Number of Active Addresses: This is the number of unique addresses that were active in the network (either as a sender or a receiver) during a certain period. This data can be obtained from various blockchain analytics platforms like CoinMetrics, Blockchain.com, or Bitinfocharts.
2. Number of Wallets: This is the number of unique wallets that hold Bitcoin. This data can also be obtained from blockchain analytics platforms. However, it is important to note that one person can own multiple wallets, so this may not be a perfect measure of the number of participants.
3. Number of Transactions: This is the number of transactions that occur on the Bitcoin network during a certain period. This data can be obtained from the same blockchain analytics platforms mentioned above.
4. Number of Nodes: This is the number of nodes participating in the Bitcoin network. A node is a computer running the Bitcoin software that helps to maintain the network by validating transactions and blocks. This data can be obtained from websites like Bitnodes.
5. Number of Miners: This is the number of miners participating in the Bitcoin network. Miners are nodes that validate and confirm transactions by solving complex mathematical problems. This data can be more difficult to obtain because many miners participate in mining pools, and the exact number of individual miners within a pool may not be publicly available.

None of these metrics are perfect proxies for the number of participants in the Bitcoin network, as one person can own multiple addresses, wallets, and nodes. Additionally, some addresses and wallets may be owned by exchanges or other institutions rather than individual participants.

The number of wallets is not a great metric for Metcalfe’s Law because most Bitcoiners own multiple wallets. At the same time, exchanges may have a small number of wallets for a huge number of Bitcoin holders.

There’s a strong argument, however, that the number of nodes captures the number of “hardcore Bitcoiners” best because there’s no incentive to run multiple nodes. Thus, this metric is a conservative measure of the network size. Also, the Blocksize wars have shown that the Bitcoin nodes are the true sources of decentralization in the Bitcoin network. Literally, the decentralization of the Bitcoin network is determined by the decentralization of Bitcoin nodes.

How Many Bitcoin Nodes Are There?

Bitnodes.io estimates that there are 45,190 Bitcoin nodes in September 2023 and 16,279 reachable nodes:

Here’s the distribution of reachable nodes by country:

Another chart from another source measuring the number of Bitcoin nodes since 2015:

It shows a similar order of magnitude, so let’s take this as it goes back to 2015.

Here’s a table for the rough number of reachable nodes by year (in August) and Bitcoin price (in August):

Recap: Metcalfe’s Law states that the value of a network is proportional to the square of the number of connected users of the system (n^2).

Let’s apply this to your data.

We will use the number of Bitcoin nodes as a proxy for the number of users in the network. According to Metcalfe’s Law, the value of the Bitcoin network (which we will proxy with the Bitcoin price) should be proportional to the square of the number of nodes.

Here is a simple model using this data:

Now, you can plot the Bitcoin price against the number of nodes squared and fit a regression line to the data to see how well Metcalfe’s Law fits the data.

Validating the Model

How did I create this chart?

Here is how you can do it in Python: First, install the libraries if you haven’t already by running pip install pandas matplotlib scikit-learn in your terminal. Second, run the following Python script:

import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression

# Create a DataFrame with your data
data = {
    'Year': [2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023],
    'Nodes': [6430, 5220, 7740, 9370, 9270, 10070, 12090, 12920, 16550],
    'Price': [279, 588, 3341, 7634, 11476, 11246, 39178, 23179, 29043]
}
df = pd.DataFrame(data)

# Create a new column for the number of nodes squared
df['Nodes Squared'] = df['Nodes'] ** 2

# Create a scatter plot of the data
plt.scatter(df['Nodes Squared'], df['Price'])
plt.xlabel('Nodes Squared')
plt.ylabel('Bitcoin Price ($)')
plt.title('Bitcoin Price vs Nodes Squared')
plt.show()

# Fit a linear regression model
X = df[['Nodes Squared']]
y = df['Price']
model = LinearRegression().fit(X, y)

# Print the coefficients
print('Intercept:', model.intercept_)
print('Slope:', model.coef_[0])

# Predict the Bitcoin price using the model
df['Predicted Price'] = model.predict(X)

# Plot the actual vs predicted prices
plt.scatter(df['Nodes Squared'], df['Price'], color='blue', label='Actual')
plt.plot(df['Nodes Squared'], df['Predicted Price'], color='red', label='Predicted')
plt.xlabel('Nodes Squared')
plt.ylabel('Bitcoin Price ($)')
plt.title('Actual vs Predicted Bitcoin Price')
plt.legend()
plt.show()

This script will create a scatter plot of the Bitcoin price against the number of nodes squared, fit a linear regression model to the data, and then plot the actual vs predicted Bitcoin prices.

The intercept and slope of the regression line will be printed in the console.

Intercept: -1843.9665728454092
Slope: 0.00014390774052419503

The script provided does both the scatter plot and the linear regression. The first plot is a scatter plot of the actual data, and the second plot includes both the scatter plot of the actual data and the predicted Bitcoin prices from the linear regression model (the red line).

The takeaway from the plot shows that the number of nodes squared (a proxy for the network size according to Metcalfe’s Law) explains the variation in Bitcoin prices. If the red line (predicted prices) fits closely with the blue dots (actual prices), it suggests that the model and Metcalfe’s Law are good at explaining the variation in Bitcoin prices.

For example, you can see that the 2021 Bitcoin price at $40,000 was flagged as “overvalued” by the model whereas today’s $27,000 price would be flagged as “undervalued” based on the real number of nodes.

Bitcoin Price Formula Based on Metcalfe’s Law

The slope and intercept of the regression line will give you a mathematical model that you can use to predict Bitcoin prices based on the number of nodes squared.

In our simple case, the slope and intercept are:

• Intercept: -1843.9665728454092
• Slope: 0.00014390774052419503

The formula would be:

Bitcoin Price = 0.00014390774052419503 × N² - 1843

whereas N is the number of Bitcoin nodes according to this data.

What’s Bitcoin’s Historic Growth Rate of N?

To analyze the node growth rates, you can compute the year-over-year growth rate in the number of nodes and then use that to project the number of nodes 5 years into the future. Then, you can use the projected number of nodes and your regression model to predict the Bitcoin price 5 years into the future.

Here are the year-over-year growth rates in the number of nodes from your data:

The average year-over-year growth rate from 2016 to 2023 is about 11.5%.

Bitcoin to $500k in 2030? Yes. If We Grow the Number of Nodes (N) by 20% per Year!

Here is a Python script that will compute the year-over-year growth rates in the number of nodes, project the number of nodes 5 years into the future, and then use your regression model to predict the Bitcoin price 5 years into the future. It will also create a visualization of the actual and predicted Bitcoin prices.

import pandas as pd
import matplotlib.pyplot as plt

# Create a DataFrame with your data
data = {
    'Year': [2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023],
    'Nodes': [6430, 5220, 7740, 9370, 9270, 10070, 12090, 12920, 16550],
    'Price': [279, 588, 3341, 7634, 11476, 11246, 39178, 23179, 29043]
}
df = pd.DataFrame(data)

# Define the regression model parameters
intercept = -1843.9665728454092
slope = 0.00014390774052419503

# Define the growth rates and years for prediction
growth_rates = [0.05, 0.10, 0.15, 0.20]
years = range(2024, 2031)

# Create a plot
plt.figure(figsize=(10, 6))

# Plot the actual data as small dots
plt.scatter(df['Year'], df['Price'], color='black', s=10)

# Plot the predicted model prices for 2015 to 2023 based on the real number of nodes
model_price = [(slope * nodes ** 2 + intercept) for nodes in df['Nodes']]
# plt.plot(df['Year'], model_price, 'k--', label='Model Predicted')

# For each growth rate, project the number of nodes and predict the Bitcoin price
for growth_rate in growth_rates:
    # Project the number of nodes
    projected_nodes = [df['Nodes'].iloc[-1] * (1 + growth_rate) ** (year - 2023) for year in years]
    # Predict the Bitcoin price
    projected_price = [(slope * nodes ** 2 + intercept) for nodes in projected_nodes]
    # Plot the predicted prices
    plt.plot(list(df['Year']) + list(years), model_price + projected_price, label=f'Predicted (Growth Rate: {growth_rate * 100}%)')
    # Label the end values
    plt.text(2030, projected_price[-1], f'${projected_price[-1]:,.0f}', verticalalignment='center')

# Add labels and a legend
plt.xlabel('Year')
plt.ylabel('Bitcoin Price ($)')
plt.yscale('log')
plt.xlim(2014, 2032)
plt.title('Actual vs Predicted Bitcoin Price')
plt.legend()

# Show the plot
plt.show()

This script creates a line chart with the actual Bitcoin prices from 2015 to 2023 plotted as small dots, the predicted model prices for 2015 to 2023 based on the real number of nodes, and the predicted prices from 2024 to 2030 for different growth rates of the number of nodes. The y-axis is on a logarithmic scale.

Want Exploding Prices? “Grow N” Says Metcalfe’s Law

The analysis clearly demonstrates a mathematical relationship between the number of Bitcoin nodes and its price, as predicted by Metcalfe’s Law. This relationship, quantified by a positive coefficient in the regression model, indicates that as the number of nodes increases, the price of Bitcoin is predicted to increase quadratically.

Therefore, if we want to see higher Bitcoin prices in the future, it is imperative to focus on growing the number of nodes in the Bitcoin network.

This calls for a collective effort from the Bitcoin community and stakeholders to encourage and facilitate the addition of more nodes to the network, thereby strengthening its security, decentralization, and, ultimately, its value.

Also, feel free to subscribe to our free email academy on exponential technologies by downloading our Python cheat sheets here:

You can reply to any of my emails (e.g., with your own analysis based on Metcalfe’s Law) to keep the conversation going.

The post Want Exploding Bitcoin Prices North of $500,000 per BTC? “Grow N” Says Metcalfe’s Law appeared first on Be on the Right Side of Change.

The beauty of using the later over the former is that all the heavy lifting has been done for us. By placing the link in your template, you can take advantage of all the available features. We have already demonstrated how to display charts using Highcharts.js in a Django web application.

In this tutorial, we will pay attention to Charts.js. Specifically, we will learn:

1. Another way to populate the database other than the ones mentioned while learning how to do so with Highcharts.js
2. How to query the database to display the data structured in such a way that Charts.js can understand.
3. How to display both bar chart and pie chart

The Model

For this project, we will use the data from Kaggle¹ that shows the richest people in the world as of 2022. The data contains several columns but we are only interested in just a few of them. Let us create a database model for the dataset.

from django.db import models

GENDER = (
    ('M', 'Male'),
    ('F', 'Female'),
)

class Richest(models.Model):
    name = models.CharField(max_length=100)
    gender = models.CharField(max_length=1, choices=GENDER)
    net_worth = models.IntegerField()
    country = models.CharField(max_length=100)
    source = models.CharField(max_length=100)

    def __str__(self):
        return self.name

The model contains names of the richest people in the world, their net worth, country of origin and their source of wealth.

Populating the database

In the previous tutorial project on creating a chart using Highcharts.js, I showed you one of the ways to populate a database. I wrote a script from the Django shell to populate the database. In this tutorial, we will learn a different method.

We will use Django’s BaseCommand class to create a custom management command that populates the database using the dataset.

Start by creating new folders inside the app folder. For example, assuming the name of your Django app is charts and is created in your current directory, run the following in your Ubuntu terminal:

mkdir charts/management/commands -p

The p flag makes it possible to create a nested folder in one command. Inside the commands folder, create a new file named populate_db.py:

nano charts/management/commands/populate_db.py

let’s first import the required modules:

from django.core.management.base import BaseCommand
from charts.models import Richest
import csv
import math

BaseCommand is a class provided by Django that serves as the base class for writing custom management commands. Management commands are scripts that can be run from the command line to perform various tasks related to your Django app.

The BaseCommand class provides several useful methods and attributes that make it easy to write custom management commands. When you create a custom management command by subclassing BaseCommand, you need to override the handle method to define the behavior of your command.

The handle method is called when the command is executed, and it receives any command-line arguments passed to the command as keyword arguments.

In addition to the handle method, the BaseCommand class provides several other methods and attributes that you can use when writing custom management commands.

For example, as we shall see, you can use the add_arguments method to define custom command-line arguments for your command, and you can use the stdout and stderr attributes to write output to the Ubuntu terminal.

class Command(BaseCommand):
    help = 'Populate the database using a CSV file'

    def add_arguments(self, parser):
        parser.add_argument('forbes_2022_billionaires.csv', type=str, help='The path to the CSV file')

    def handle(self, *args, **options):
        csv_file = options['forbes_2022_billionaires.csv']

        with open(csv_file, 'r') as f:
            reader = csv.DictReader(f)
            for row in reader:
                skip_row = False
                for value in row.values():
                    try:
                        if math.isnan(float(value)):
                            skip_row = True
                            break
                    except ValueError:
                        pass
                if skip_row:
                    continue
                net_worth = int(float(row['finalWorth']))
                obj, created = Richest.objects.get_or_create(
                    name=row['personName'],
                    gender=row['gender'],
                    net_worth=net_worth,
                    country=row['countryOfCitizenship'],
                    source=row['source']
                 )

        self.stdout.write(self.style.SUCCESS('Successfully populated the database'))

We define a new Command class that inherits from BaseCommand.

In the add_arguments method, we define a new command-line argument called csv_file that specifies the path to the CSV file. In the handle method, we read the data from the CSV file and use a conditional statement to check if any of the values in the current row are NaN.

If any value is NaN, we use the continue statement to skip this row and move on to the next one. Otherwise, we use the get_or_create method to add the data to the database. Finally, we use the self.stdout.write method to print a success message.

We use a nested loop to iterate over each value in the row. For each value, we use a try-except block to try to convert the value to a float and check if it is NaN. If a ValueError exception occurs, we catch it and ignore it using the pass statement.

If any value in the row is NaN, we set the skip_row variable to True and use the break statement to exit the inner loop. After the inner loop completes, we use an if statement to check if the skip_row variable is True. If it is, we use the continue statement to skip this row and move on to the next one.

However, a problem arises from the dataset. The net_worth field is an IntegerField. Whereas, the data type of the finalWorth column is float. To avoid errors, we first convert the value of the net_worth field in the current row to a float using the float function, and then convert it to an integer using the int function. We then assign this integer value to the net_worth field of the Richest model instance using the get_or_create method.

Make sure you have the forbes_2022_billionaires.csv file downloaded and placed in your current directory. Then, run the command we defined from the command line using the manage.py script like this:

python3 manage.py populate_db forbes_2022_billionaires.csv

Afterward, a success message will be displayed. We have populated our database. Open the admin interface to see it.

Displaying charts using Charts.js

Make sure you have included the Charts.js library in your template by adding the following script tag to the <head> section of your HTML file:

<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>

Next, add a <canvas> element to your template where you want to display the chart. Give this element an id so you can reference it in your JavaScript code.

Here’s an example:

<canvas id="myChart"></canvas>

In this demonstration, we will query the database to:

1. Calculate total net worth of each country
2. Get the top 10 richest people in the world
3. Get the top 10 richest women in the world
4. Get the distribution of wealth by gender

We will also include a pie chart. You can always check the source code for more details.

Displaying the total net worth of each country

from django.shortcuts import render
from django.db.models import Sum
from .models import Richest

def TotalNetWorth(request):
    # Query the database to get the data
    data = Richest.objects.values('country').annotate(total_net_worth=Sum('net_worth')).order_by('-total_net_worth')

    # Prepare the data for the chart
    chart_data = []
    for item in data:
        chart_data.append({
            'country': item['country'],
            'total_net_worth': item['total_net_worth']
        })

    # Render the template with the chart data
    return render(request, 'total_net_worth.html', {'chart_data': chart_data})

We group the data by country using the values method, and using the annotate method, we calculate the total net worth of each country.

Next, we prepare the data for the chart by creating a new list called chart_data and appending a dictionary for each item in the query result.

Each dictionary contains two keys: 'country' and 'total_net_worth', which represent the country and its total net worth, respectively.

<script>
    var ctx = document.getElementById('myChart').getContext('2d');
    var chart = new Chart(ctx, {
        type: 'bar',
        data: {
            labels: {{ chart_data|safe }}.map(item => item.country),
            datasets: [{
                label: 'Total Net Worth',
                data: {{ chart_data|safe }}.map(item => item.total_net_worth),
                backgroundColor: 'rgba(54, 162, 235, 0.2)',
                borderColor: 'rgba(54, 162, 235, 1)',
                borderWidth: 1	
            }]
        },
        options: {
            scales: {
                y: {
                    beginAtZero: true
                }
            }
        }
    });
</script>

Here, we create a new Chart object and pass it the context of the <canvas> element and an options object that specifies the type of chart and its data.

We use the chart_data variable passed as context to populate the chart with data.

Then, we use the map method to extract the country names and total net worth values from the chart_data and assign them to the labels and data properties of the chart’s datasets.

Check out the source code for a demonstration of a pie chart. It’s almost the same.

Displaying the top ten richest people in the world

def TopTenRichest(request):
    # Query the database to get the data
    data = Richest.objects.order_by('-net_worth')[:10]

    # Prepare the data for the chart
    chart_data = []
    for item in data:
        chart_data.append({
            'name': item.name,
            'net_worth': item.net_worth
        })

    # Render the template with the chart data
    return render(request, 'top_ten_richest.html', {'chart_data': chart_data})

The following code shows how to display a pie chart using Charts.js:

var ctx = document.getElementById('myChart').getContext('2d');
var myChart = new Chart(ctx, {
    type: 'pie',
    data: {
        labels: {{ chart_data|safe }}.map(item => item.name),
        datasets: [{
            label: 'Net Worth',
            data: {{ chart_data|safe }}.map(item => item.net_worth),
            backgroundColor: [
                'rgb(255, 99, 132)',
                'rgb(54, 162, 235)',
                'rgb(255, 205, 86)',
                'rgb(75, 192, 192)',
                'rgb(153, 102, 255)',
                'rgb(255, 159, 64)',
                'rgb(255, 99, 132)',
                'rgb(54, 162, 235)',
                'rgb(255, 205, 86)',
                'rgb(75, 192, 192)'
            ],
            hoverOffset: 4
        }]
    },
    options: {
        title: {
            display: true,
            text: 'Top Ten Richest People'
        }
    }
});

This code creates a new Chart object and sets its type to 'pie'. The data for the chart is taken from the chart_data variable that was passed to the template from TopTenRichest view function.

The labels for the chart are set to the names of the richest people, and the data for the chart is set to their net worths.

The source code also contains the bar chart example.

Displaying the top ten richest women

def TopRichestWomen(request):
    data = Richest.objects.filter(gender='F').order_by('-net_worth')[:10]
    names = [item.name for item in data]
    net_worths = [item.net_worth for item in data]
    return render(request, 'top_richest_women.html', {
        'names': names,
        'net_worths': net_worths
    })

Distribution of wealth by gender

def WealthByGender(request):
    # Query the database to get the total net worth for each gender
    male_net_worth = Richest.objects.filter(gender='M').aggregate(Sum('net_worth'))['net_worth__sum']
    female_net_worth = Richest.objects.filter(gender='F').aggregate(Sum('net_worth'))['net_worth__sum']

    # Prepare the data for the chart
    data = {
        'labels': ['Male', 'Female'],
        'datasets': [{
            'data': [male_net_worth, female_net_worth],
            'backgroundColor': ['#36A2EB', '#FF6384']
        }]
    }

    # Render the chart using the Chart.js library
    return render(request, 'wealth_by_gender.html', {'data': data})

And this is the pie chart. Check the source code for more details:

Conclusion

In this project tutorial, we have learned various ways to query our database, structure the data and displayed them using charts.js, a JavaScript library for data visualization. We saw how Django interacts with charts.js to display charts on a template.

We also learned another way to populate the database by using Django’s BaseCommand class. Due to the nature of the dataset, we were restricted to only bar and pie charts. However, we can apply the process to create other charts.

Use the knowledge you learned to integrate charts in your Django web application.

• Forbes World’s Billionaires List 2022 | Kaggle

Recommended: The Math of Becoming a Millionaire in 13 Years

The post How I Created Charts Using Charts.js in Django Web Application appeared first on Be on the Right Side of Change.