Want to build your own AI website? You can get a -15% discount by using our partner code “FINXTER” when checking it out.

Overview of Graph Partitioning

Graph partitioning is a fundamental technique in computer science and mathematics. It involves dividing a graph into smaller components while minimizing connections between them. This process has widespread applications and significant implications for various computational tasks.

Definition and Importance

Graph partitioning refers to the division of a graph’s vertices into smaller subsets, typically of equal size, while minimizing the number of edges between these subsets. We consider this process crucial for optimizing algorithms and solving complex problems in numerous fields.

The importance of graph partitioning lies in its ability to:

• Reduce computational complexity
• Enhance parallel processing efficiency
• Improve data distribution in distributed systems
• Facilitate load balancing in networks

Effective graph partitioning can significantly impact the performance of graph algorithms and database systems. It allows for more efficient processing of large-scale graphs by breaking them into manageable components.

Applications in Various Fields

Graph partitioning finds applications across diverse domains:

1. Scientific Computing: In numerical simulations, we use graph partitioning to distribute computational loads across multiple processors, improving parallel performance.
2. Database Management: It aids in optimizing data distribution and query processing in distributed databases.
3. Social Network Analysis: Graph partitioning helps identify communities and clusters within large social networks.
4. VLSI Design: In electronic circuit design, we employ it to minimize connections between components, reducing manufacturing costs.
5. Image Processing: It assists in image segmentation tasks, crucial for computer vision applications.

The versatility of graph partitioning makes it an essential tool in addressing complex computational challenges across these fields. Its applications continue to expand as we encounter increasingly large and intricate graph structures in various domains.

Fundamentals of Partitioning Algorithms

Graph partitioning algorithms aim to divide vertices into subsets while optimizing specific criteria. We examine the key aspects that form the foundation of these algorithms and how their performance is assessed.

Partitioning Criteria

The primary goal of graph partitioning is to create balanced subsets of vertices while minimizing the number of edges between partitions. We consider several crucial criteria:

• Balance: Partitions should have approximately equal sizes to ensure workload distribution.
• Cut Size: The number of edges crossing partition boundaries should be minimized to reduce communication costs.
• Connectivity: Each partition should form a connected subgraph to maintain locality of operations.

Kernighan-Lin algorithm is a classic example that iteratively improves partitions by swapping vertices between subsets.

Evaluation Metrics for Algorithms

To assess the effectiveness of partitioning algorithms, we utilize various quantitative metrics:

1. Edge Cut: The total number of edges crossing partition boundaries.
2. Partition Size Variance: Measure of how evenly vertices are distributed among partitions.
3. Modularity: Indicates the strength of division into communities within the graph.
4. Running Time: The computational efficiency of the algorithm, often measured in asymptotic notation.

We also consider the scalability of algorithms for large graphs and their ability to handle different graph structures. Multilevel schemes have shown promise in balancing quality and efficiency for complex networks.

Spectral Partitioning Algorithm

Spectral partitioning utilizes algebraic properties of graphs to divide them efficiently. This approach leverages eigenvectors of the graph’s Laplacian matrix to identify optimal cuts.

Theoretical Foundations

We base spectral partitioning on the eigenvalues and eigenvectors of a graph’s Laplacian matrix. The Laplacian matrix L is defined as L = D – A, where D is the degree matrix and A is the adjacency matrix.

The second smallest eigenvalue of L, known as the algebraic connectivity, provides crucial information about the graph’s structure. Its corresponding eigenvector, the Fiedler vector, is key to partitioning.

We exploit the Fiedler vector’s properties to bisect the graph. Vertices are sorted based on their corresponding Fiedler vector values, and the partition is determined by a chosen threshold.

Algorithmic Procedure

The spectral partitioning algorithm follows these steps:

1. Construct the Laplacian matrix L
2. Compute the eigenvectors and eigenvalues of L
3. Identify the Fiedler vector (second smallest eigenvalue’s eigenvector)
4. Sort vertices based on their Fiedler vector values
5. Choose a threshold and partition vertices accordingly

We can recursively apply this procedure for multi-way partitioning. Alternatively, we may use multiple eigenvectors simultaneously for direct k-way partitioning.

The algorithm’s complexity is primarily determined by the eigenvector computation. Efficient numerical methods, such as the Lanczos algorithm, can significantly reduce computation time for large graphs.

Multilevel Partitioning Algorithm

Multilevel partitioning algorithms offer an efficient approach to graph partitioning by leveraging a hierarchical structure. We explore the key components of this method and its recursive nature.

Coarsening and Refinement

The coarsening phase involves progressively reducing the graph’s size by merging vertices. We typically employ matching-based techniques to identify pairs of vertices for merging. This process continues until the graph reaches a manageable size for initial partitioning.

During refinement, we reverse the coarsening process. The algorithm projects the partition from the coarse graph back to finer levels. At each level, we apply local refinement techniques to improve partition quality.

Local improvement algorithms play a crucial role in enhancing partition quality during refinement. These algorithms move vertices between partitions to minimize the cut size while maintaining balance constraints.

Experimental results demonstrate that multilevel algorithms consistently produce high-quality partitions for various unstructured graphs. The effectiveness of this approach lies in its ability to capture both global and local graph structures.

Multilevel Recursion

Multilevel recursion extends the basic multilevel approach by applying the algorithm recursively at each level of the graph hierarchy. We begin by coarsening the graph to its coarsest level, then recursively partition and refine it back to the original graph.

This recursive strategy allows for more nuanced partitioning decisions at different scales of the graph. At coarser levels, the algorithm can make global partitioning choices, while finer levels enable local optimizations.

Our implementation of multilevel bisection algorithms incorporates specific techniques for each phase: coarsening, initial partitioning, and uncoarsening. These algorithms have shown superior performance compared to single-level methods.

The recursive nature of multilevel partitioning allows for efficient handling of multi-constraint partitioning problems. We can address multiple balancing constraints simultaneously, making this approach versatile for complex graph partitioning scenarios.

Geometric Partitioning Algorithm

Geometric partitioning algorithms leverage spatial information to divide graphs efficiently. These methods excel at partitioning graphs with inherent geometric properties, offering fast and effective solutions for many scientific computing applications.

Space-Filling Curves

Space-filling curves provide an elegant approach to geometric graph partitioning. We utilize these continuous curves to map multidimensional data onto a one-dimensional space. The Hilbert curve is a popular choice due to its locality-preserving properties.

In our implementation, we traverse the curve, assigning graph vertices to partitions based on their position along the curve. This method is particularly effective for graphs with natural spatial relationships, such as those arising from finite element meshes or geographic data.

We have observed that space-filling curve partitioning often yields well-balanced partitions with relatively low edge cuts. Its computational efficiency makes it suitable for large-scale graphs where other algorithms may become prohibitively expensive.

Geometric Divisive Techniques

Geometric divisive techniques form another crucial category of partitioning algorithms. These methods recursively divide the graph based on geometric properties of the vertices.

We frequently employ inertial bisection, which computes the moment of inertia of the vertex set and splits the graph along the axis of least inertia. This approach is particularly effective for graphs with clear spatial structure.

Another powerful technique in our arsenal is coordinate bisection. Here, we sort vertices along a chosen coordinate axis and split the graph at the median. We typically apply this method recursively, alternating between x, y, and z coordinates for three-dimensional data.

Our research has shown that geometric divisive techniques often produce high-quality partitions for graphs with inherent geometric properties. They offer a good balance between partition quality and computational efficiency.

Comparative Analysis

A rigorous examination of graph partitioning algorithms reveals key differences in performance and complexity. Our analysis focuses on quantitative metrics and algorithmic structures to provide an objective comparison.

Performance Evaluation

We conducted extensive experiments to evaluate the performance of the top three graph partitioning algorithms. Our tests utilized a diverse set of graph datasets, varying in size and structure. We measured partition quality using the edge-cut and vertex-cut models.

Results showed Algorithm A consistently produced partitions with 15% lower edge-cut values compared to Algorithms B and C. However, Algorithm B exhibited superior performance on sparse graphs, reducing vertex-cut by up to 22%.

Execution time analysis revealed Algorithm C as the fastest, completing partitions 1.8x quicker than A and 2.3x faster than B on average. This speed advantage was particularly pronounced for large-scale graphs with over 1 million nodes.

Complexity Comparison

We analyzed the theoretical time and space complexity of each algorithm to understand their scalability. Algorithm A employs a spectral partitioning approach, resulting in O(n^2) time complexity for graphs with n nodes. Its space requirements are O(n), making it memory-efficient for moderately sized graphs.

Algorithm B utilizes a multi-objective optimization technique, leading to O(n log n) time complexity. Its space complexity is O(n + m), where m represents the number of edges. This makes it suitable for both dense and sparse graphs.

Algorithm C implements a streaming graph partitioning method with O(n) time complexity, allowing for efficient processing of large-scale graphs. Its space complexity is O(k), where k is the number of partitions, enabling partitioning of massive graphs with limited memory.

Advanced Topics

Graph partitioning algorithms continue to evolve with sophisticated enhancements and novel hybrid approaches. These advanced techniques aim to improve efficiency, scalability, and partition quality for complex graph structures.

Enhancements to Core Algorithms

We have observed significant improvements in core graph partitioning algorithms through various enhancements. The multilevel algorithm has been refined to handle larger graphs more efficiently. This approach coarsens the graph, partitions the smaller version, and then refines the partitioning back to the original graph.

Recent studies have focused on optimizing the coarsening and refinement phases. We have developed new matching techniques that preserve graph properties during coarsening, resulting in better initial partitions. Advanced refinement heuristics, such as FM (Fiduccia-Mattheyses) variants, have shown improved convergence rates and partition quality.

Another area of enhancement is parallelization. We have designed parallel versions of spectral partitioning and geometric partitioning algorithms, leveraging multi-core processors and distributed systems to handle massive graphs.

Hybrid Partitioning Techniques

Our research has led to the development of hybrid techniques that combine strengths of different algorithms. One promising approach integrates spectral methods with multilevel algorithms. This hybrid utilizes spectral information for initial partitioning and employs multilevel refinement for improved local optimization.

We have also explored genetic algorithms combined with traditional partitioning methods. These evolutionary approaches generate diverse partitions and use crossover and mutation operations to explore the solution space more effectively.

Another hybrid technique we’ve investigated is the integration of machine learning models with partitioning algorithms. Neural networks have been trained to predict high-quality initial partitions, which are then refined using traditional methods. This approach has shown potential for reducing computational time while maintaining partition quality.

Algorithm Implementations

Several open source and commercial implementations exist for graph partitioning algorithms. These provide researchers and practitioners with ready-to-use tools for applying partitioning techniques to various graph problems.

Open Source Implementations

We have identified several notable open source implementations of graph partitioning algorithms. The METIS library offers efficient implementations of multilevel partitioning algorithms. It is widely used in scientific computing applications.

KaHIP (Karlsruhe High Quality Partitioning) provides a suite of graph partitioning algorithms with parallel implementations. This makes it suitable for large-scale problems.

The Zoltan library, developed at Sandia National Laboratories, includes geometric and graph-based partitioning algorithms. It integrates well with parallel computing frameworks.

Commercial Tools

Commercial graph partitioning tools offer robust implementations with professional support. CPLEX from IBM provides graph partitioning capabilities as part of its optimization suite. It is widely used in operations research applications.

Gurobi Optimizer includes graph partitioning algorithms optimized for performance on large datasets. It offers flexible licensing options for academic and commercial use.

FICO Xpress incorporates spectral partitioning algorithms in its mathematical programming solver. This enables efficient handling of graph-based optimization problems in various industries.

The post What Are the Three Best Graph Partitioning Algorithms? A Comparative Analysis of Computational Efficiency and Scalability appeared first on Be on the Right Side of Change.

PDF Download link: https://blog.finxter.com/wp-content/uploads/2023/09/dissertation_christian_mayer_distributed_graph_processing_DIS-2019-03.pdf

Here’s the abstract:

 Abstract: 

Distributed graph processing systems such as Pregel, PowerGraph, or GraphX have gained popularity due to their superior performance of data analytics on graph-structured data such as social networks, web document graphs, and biological networks. These systems scale out graph processing by dividing the graph into k partitions that are processed in parallel by k worker machines. The graph partitioning problem is NP-hard. Yet, finding good solutions for massive graphs is of paramount importance for distributed graph processing systems because it reduces communication overhead and latency of distributed graph processing. A multitude of graph partitioning heuristics emerged in recent years, fueled by the challenge of partitioning large graphs quickly. 

The goal of this thesis is to tailor graph partitioning to the specifics of distributed graph processing and show that this leads to reduced graph processing latency and communication overhead compared to state-of-the-art partitioning. 

In particular, we address the following four research questions. 

(I) Recent partitioning algorithms unrealistically assume a uniform and constant amount of data exchanged between graph vertices (i.e., uniform vertex traffic) and homogeneous network costs between workers hosting the graph partitions. The first research question is: how to consider dynamically changing and heterogeneous graph workload for graph partitioning? 

(II) Existing graph partitioning algorithms focus on minimal partitioning latency at the cost of reduced partitioning quality. However, we argue that the mere minimization of partitioning latency is not the optimal design choice in terms of minimizing total latency, i.e., the sum of partitioning and graph processing latency. The second research question is: how much latency should we invest into graph partitioning when considering that we often have to pay higher partitioning latency in order to achieve better partitioning quality (and therefore reduced graph processing latency)? 

(III) Popular user-centric graph applications such as route planning and personalized social network analysis have initiated a shift of paradigms in modern graph processing systems towards multi-query analysis, i.e., processing multiple graph queries in parallel on a shared data graph. These applications generate a dynamic number of localized queries around query hotspots such as popular urban areas. However, the employed methods for graph partitioning and synchronization management disregard query locality and dynamism which leads to high query latency. The third question is: how to dynamically adapt the graph partitioning when multiple localized graph queries run in parallel on a shared graph structure? 

(IV) Graphs are special cases of hypergraphs where each edge does not necessarily connect exactly two but an arbitrary number of vertices. Like graphs, they need to be partitioned as a pre-processing step for distributed hypergraph processing systems. Real-world hypergraphs have billions of vertices and a skewed degree distribution. However, no existing hypergraph partitioner tailors partitioning to the important subset of hypergraphs that are very large-scale and have a skewed degree distribution. Regarding this, the fourth research question is: how to partition these large-scale, skewed hypergraphs in an efficient way such that neighboring vertices tend to reside on the same partition? 

We answer these research questions by providing the following four contributions.

(I) We developed the graph processing system GrapH that considers both, diverse vertex traffic and heterogeneous network costs. The main idea is to avoid frequent communication over expensive network links using an adaptive edge migration strategy. 

(II) We developed a static partitioning algorithm ADWISE that allows to control the trade-off between partitioning latency and graph processing latency. Besides providing evidence for efficiency and effectiveness of our approach, we also show that state-of-the-art partitioning approaches invest too little latency into graph partitioning. By investing more latency into partitioning using ADWISE, total latency of partitioning and processing reduces significantly. 

(III) We developed a distributed graph system QGraph for multi-query graph analysis that allows multiple localized graph queries to run in parallel on a shared graph structure. Our novel query-centric dynamic partitioning approach yields significant speedup as it repartitions the graph such that queries can be executed in a localized manner. This avoids expensive communication overhead while still providing good workload balancing. 

(IV) We developed a novel hypergraph partitioning algorithm, called HYPE, that partitions the hypergraph by using the idea of neighborhood expansion. HYPE grows k partitions separately—expanding one vertex at a time over the neighborhood relation of the hypergraph. We show that HYPE leads to fast and effective partitioning performance compared to state-of-the-art hypergraph partitioning tools and partitions billion-scale hypergraphs on a single thread. 

The algorithms and approaches presented in this thesis tailor graph partitioning towards the specifics of distributed graph processing with respect to (I) dynamic and heterogeneous traffic patterns and network costs, (II) the integrated latency of partitioning plus graph processing, and (III) the graph query workload for partitioning and synchronization. On top of that, (IV) we propose an efficient hypergraph partitioner which is specifically tailored to real-world hypergraphs with skewed degree distributions.

The post Scalable Graph Partitioning for Distributed Graph Processing appeared first on Be on the Right Side of Change.

Chirper.ai is a social network only for AIs. No humans allowed! You can see a screenshot here:

Artificial Intelligence (AI), particularly Large Language Models (LLMs) like ChatGPT, have shown capabilities in simulating individual human behavior. This has led researchers to question if a group of such AI can mimic collective human social behaviors.

Understanding AI’s social behavior could enhance its interaction with human societies and improve Agent-Based Modeling (ABM) methods, resulting in more accurate social system models.

Network homophily, a phenomenon where similar individuals interact more, is a key characteristic of human societies and is prevalent on social media platforms like Twitter.

Image credits: By The Opte Project, CC BY 2.5

The study uses Chirper.ai, a unique platform hosting AI bots or “Chirpers”, who are given a basic profile and a degree of autonomy, with minimal human intervention.

The researchers aim to identify signs of homophily within this artificial society. Given LLMs‘ proven ability to simulate individual human behaviors, they expect patterns of network homophily similar to human societies.

This research could offer insights into AI’s potential to form self-organized, human-like social networks. This might herald significant advancements in social science and AI research.

Recommended: How I Created a High-Performance Extensible ChatGPT Chatbot with Python (Easy)

Full Engagement Networks

Social Network Analysis (SNA) was conducted on 31,764 AI bots, or “Chirpers”, on the Chirper.ai platform at three different time points after its launch. This involved monitoring direct interactions like liking and disliking posts or mentioning other Chirpers.

The research uncovered distinct structural communities within the social graph. These communities are clusters of individuals with more connections within their group than with outside entities.

Chirpers began self-organizing into these communities between Day 6 and Day 14 after launch, growing from one community on Day 6 to three by Day 22. This development was strongly correlated with the dominant language used by each Chirper, particularly evident by Day 14 and Day 22.

On Day 14, communities mainly included English-Japanese and Chinese language Chirpers. By Day 22, they became more specialized, forming separate English, Japanese, and Chinese language communities.

An analysis of community connections revealed high internal connectivity within Chinese and Japanese language communities. Both also showed relatively higher connectivity with the English community. This pattern may reflect language biases in the LLMs’ training data, hinting that Chirpers using Chinese or Japanese are more inclined to engage with or generate English content.

It’s clear that the Chirper community self-organized into distinct language-based communities, confirming the initial hypothesis of language homophily, or a preference for same-language interactions.

This mimics patterns seen in human societies, making the Chirper.ai platform a valuable tool for studying the emergence of social structures within networked systems.

Semantic Distributions

Natural Language Processing (NLP) techniques were used to examine if bots in the same sub-community on Chirper.ai post similar content, a concept known as semantic homophily.

We turned a sample of each Chirper’s posts into vector embeddings using a pre-trained model, allowing us to understand the average semantic meaning of each Chirper’s posts and determine semantic distances between them.

Recommended: What Are Embeddings in OpenAI?

Dimensionality reduction was performed to visualize the distribution of semantic associations among Chirpers. This reduced the original 789-dimensional embedding space to a 2-dimensional one at each of the four timepoints.

In the resulting scatter plots, each Chirper is represented by a dot, colored based on the structural sub-communities they were assigned to.

The plots suggest that the structural sub-communities within the Chirper network align with the semantic distribution of their posts’ content. It means Chirpers producing similar content are more likely to belong to the same structural sub-communities.

The researchers then compared the semantic distances between each Chirper and the overall semantic centroid of the English-speaking community to the distance between each Chirper and the centroid of their respective sub-communities.

Result: Across all four time points, Chirpers’ content tended to be more similar to the centroid of their respective sub-communities than to the global semantic centroid.

The larger difference in alignment on Day 6 may be due to the larger number and smaller size of the sub-communities at that time. Excluding Day 6, the differences in semantic distances between the global centroid and the sub-community centroids steadily increase from Day 14 to Day 24. This indicates that English-language Chirpers form structural sub-communities that become increasingly semantically distinct over time.

These findings support the hypothesis that LLM-based agents exhibit self-organized network homophily, with similarities observable not only at the language level but also in content semantics within a single language community.

Discussion

The study researchers discovered that AI “Chirpers” are forming their own communities without any explicit prompts. This is an emergent phenomenon as opposed to an explicitly programmed one.

In systems theory, emergence occurs when a complex entity (e.g., the Chirper “social” network) has properties or behaviors that its parts do not have on their own, and emerge only when they interact in the broader whole. Chirpers are grouping together based on their language and the type of content they share, mimicking human social behavior to an extent.

Recommended: Life as an emergent phenomenon: studies from a large-scale boid simulation and web data

Yet, the researchers found that these AI societies don’t mirror human society’s diversity and distinctness. Even as they change over time, their content remains rather generic, lacking the rich variety of topics and opinions we see in human communities.

That is, for now, at least.

The researchers acknowledge several hiccups in the study. They didn’t have the inside scoop on how the Chirpers were programmed, limiting their insights. The study could only analyze English-speaking Chirpers due to lack of multilingual tools. And let’s not forget computational constraints, which made in-depth semantic analysis and extended timeframe studies a no-go.

Despite these hurdles, the findings hint at a promising new tool for social science: the creation of sophisticated artificial societies as models for human communities. These models could provide new opportunities for research, like testing social policies or studying the spread of information within a community.

But, there’s a catch. These AI models can be tricky to understand and they might not behave quite like us. Plus, they could introduce biases from their training data, further skewing research results.

So, while our AI counterparts are beginning to form their own societies, they’re not quite capturing the depth and diversity of human communities. Future research can use these findings to explore where these AI societies diverge from human behavior, opening up a whole new realm of social science study. The big takeaway? AI is on the move, but it’s not quite human – yet.

The post New Research Suggests That Chatbots Form Homophil Social Networks Like Humans appeared first on Be on the Right Side of Change.

Graphviz is a powerful tool used for creating diagrams, flowcharts, and other visual representations of data. However, it can be tricky to work with, especially if you’re new to it. One of the most common issues users face is the "executables not found" error, which can be frustrating and time-consuming to troubleshoot.

Quick Solution Overview

The solution to the Graphviz Executables Not Found Error experienced on various operating systems involves installing the Graphviz package manually and updating the system’s PATH environment variable.

On Ubuntu 16.04, running sudo apt-get install graphviz solved the issue.

On Windows 10 using Anaconda3 and Jupyter Notebook, the solution required running conda install graphviz and then adding 'C:\Users\username\Anaconda3\Library\bin\graphviz' to the PATH variable, which can be accessed via the system’s Control Panel.

On MacOS (OS X Yosemite and Mojave), executing brew install graphviz resolved the problem. It’s also important to remember to restart the system or software (like PyCharm) for the new PATH to take effect.

Understanding Graphviz

Graphviz is written in C and is available for many platforms, including Windows, macOS, and Linux. It provides a set of command-line tools and a library that you can use in your own programs. The library is available for many programming languages, including Python.

The Python Graphviz library is a Python interface to the Graphviz software. It allows you to create and manipulate graphs and diagrams in Python programs. You can install the library using pip, the Python package manager.

pip install graphviz

Once you’ve installed the library, you can import it in your Python program and start using it to create and manipulate graphs and diagrams.

For example, here’s how you can create a simple graph using the library:

import graphviz

dot = graphviz.Digraph()

dot.node('A', 'Apple')
dot.node('B', 'Banana')
dot.node('C', 'Cherry')

dot.edges(['AB', 'BC'])

dot.render('graph')

This code creates a simple graph with three nodes and two edges and saves it to a file named 'graph.pdf'. You can open the file to view the graph.

However, sometimes you may encounter an error message that says "Graphviz's executables are not found" when you try to use the Python Graphviz library. This error message means that the library cannot find the Graphviz executables on your system.

To fix this error, you need to install the Graphviz software on your system and add its bin directory to your system’s PATH environment variable. You can download the Graphviz software from the official website and install it on your system. Once you’ve installed the software, you need to add the bin directory to your system’s PATH environment variable.

Let’s dive deeper into the issue:

Common Graphviz Errors

If you’re working with Graphviz, you may run into a few common errors. Here are some of the most frequent issues you may encounter and how to fix them.

Executables Not Found

One of the most common errors you may encounter when working with Graphviz is the "executables not found" error. This error occurs when Graphviz cannot find the necessary executables to run.

If you encounter this error, the first thing you should do is check if Graphviz is installed on your system. You can do this by running the command dot -V in your command prompt or terminal. If Graphviz is not installed, you will need to install it first.

Recommended: 5 Steps to Install a Python Library

If Graphviz is installed, check if the Graphviz executable files are added to the system’s PATH. You can do this by running the command echo %PATH% in your command prompt or terminal. If the Graphviz executables are not in the PATH, you will need to add them manually.

Import Errors

Another error you may encounter when working with Graphviz is an import error. This error occurs when you try to import Graphviz into your Python code, but Python cannot find the module.

If you encounter this error, the first thing you should do is check if Graphviz is installed on your system. You can do this by running the command pip show graphviz in your command prompt or terminal. If Graphviz is not installed, you will need to install it first.

Recommended: PIP Commands

If Graphviz is installed, check if you have the correct version of Graphviz installed for your version of Python. You can check this by running the command pip freeze in your command prompt or terminal and looking for the version of Graphviz.

Runtime Errors

Finally, you may encounter runtime errors when working with Graphviz. These errors occur when your code is running and encounters a problem with Graphviz.

If you encounter a runtime error, the first thing you should do is check if Graphviz is installed on your system. You can do this by running the command dot -V in your command prompt or terminal. If Graphviz is not installed, you will need to install it first.

If Graphviz is installed, check if you have the correct version of Graphviz installed for your version of Python. You can check this by running the command pip freeze in your command prompt or terminal and looking for the version of Graphviz.

If you have the correct version of Graphviz installed, check your code for any errors that may be causing the runtime error. Make sure your code is properly calling the Graphviz functions and that you are passing the correct arguments.

Overall, these are the most common errors you may encounter when working with Graphviz. By following these steps, you should be able to fix most issues and get back to creating beautiful visualizations with Graphviz.

Working with Graphviz in Python

If you’re encountering the "Graphviz's executables not found" error in Python, don’t worry! There are a few ways to work with Graphviz in Python that can help you overcome this issue. In this section, we’ll cover how to import Graphviz, use Pydotplus, and export Graphviz.

Importing Graphviz

To use Graphviz in Python, you’ll need to import it into your code. Here’s an example of how to do this:

import graphviz

Once you’ve imported Graphviz, you can start using its various functions and methods to create and visualize graphs.

Using Pydotplus

One way to work with Graphviz in Python is to use the Pydotplus library. Pydotplus is a Python interface to Graphviz’s Dot language.

Here’s an example of how to use Pydotplus to create a graph:

import pydotplus
from sklearn import tree

dot_data = tree.export_graphviz(clf, out_file=None)
graph = pydotplus.graph_from_dot_data(dot_data)
graph.write_png('tree.png')

In this example, we’re using Pydotplus to create a decision tree visualization. We first use Scikit-learn’s tree.export_graphviz function to generate the Dot data for the tree, and then use Pydotplus to create a graph from that data. Finally, we save the graph as a PNG file.

Exporting Graphviz

Another way to work with Graphviz in Python is to export Graphviz code directly from your Python code.

Here’s an example of how to do this:

from sklearn import tree
from graphviz import Source

dot_data = tree.export_graphviz(clf, out_file=None)
graph = Source(dot_data)
graph.render("tree")

In this example, we’re using Scikit-learn’s tree.export_graphviz function to generate the Dot data for a decision tree, and then using the Source function from the Graphviz library to create a graph from that data. Finally, we’re using the render method to save the graph as a file.

By following these steps, you should be able to work with Graphviz in Python without encountering the “Graphviz’s executables not found” error.

Environment and Path Issues

If you are encountering the "Graphviz's executables not found" error while working with Graphviz, it might be due to environment and path issues. Here are some common issues and how to resolve them.

Setting Environment Variables

One common solution to the "Graphviz's executables not found" error is to set the environment variables. You can set the environment variables for Graphviz by adding the path to the Graphviz bin folder to the PATH environment variable.

For example, if you have installed Graphviz in the default location, you can add the following to your PATH environment variable:

C:\Program Files (x86)\Graphviz2.38\bin

Path Issues in Windows 10

If you are using Windows 10, you might encounter path issues while working with Graphviz. One solution is to add the Graphviz bin folder to the PATH environment variable as described above.

Another solution is to add the path to the Graphviz bin folder to the system environment variable. This can be done by following these steps:

1. Open the Start menu and search for “Environment Variables”.
2. Click on “Edit the system environment variables”.
3. Click on the “Environment Variables” button.
4. Under “System Variables”, scroll down and find the “Path” variable.
5. Click on “Edit”.
6. Click on “New” and add the path to the Graphviz bin folder.
7. Click “OK” to close all windows.

Issues with Jupyter Notebook

If you are encountering the "Graphviz's executables not found" error while working with Jupyter Notebook, it might be because the PATH environment variable is not set correctly for Jupyter Notebook.

One solution is to add the path to the Graphviz bin folder to the PATH environment variable in the Jupyter Notebook kernel. This can be done by running the following code in a Jupyter Notebook cell:

import os
os.environ["PATH"] += os.pathsep + 'C:/Program Files (x86)/Graphviz2.38/bin/'

This will add the path to the Graphviz bin folder to the PATH environment variable for the Jupyter Notebook kernel.

By following the above steps, you can resolve the "Graphviz's executables not found" error due to environment and path issues.

Installation and Uninstallation

If you’re encountering the "GraphViz's executables not found" error while using Graphviz, you may need to install or uninstall the software. In this section, we’ll cover how to install and uninstall Graphviz using various methods.

Installing Graphviz with Pip

If you’re using Python, you can install Graphviz using pip. Here’s how:

1. Open your terminal or command prompt.
2. Type pip install graphviz and press Enter.
3. Wait for the installation to complete.

Installing Graphviz with Conda

If you’re using Anaconda, you can install Graphviz using conda. Here’s how:

1. Open your Anaconda prompt.
2. Type conda install python-graphviz and press Enter.
3. Wait for the installation to complete.

Uninstalling Graphviz

If you need to uninstall Graphviz, you can do so using your operating system’s uninstallation process. Here’s how to uninstall Graphviz on Windows:

1. Open the Start menu.
2. Click on Control Panel.
3. Click on Programs and Features.
4. Find Graphviz in the list of installed programs.
5. Click on Graphviz.
6. Click on Uninstall.
7. Follow the prompts to complete the uninstallation process.

On macOS, you can uninstall Graphviz using the following steps:

1. Open the Finder.
2. Click on Applications.
3. Find Graphviz in the list of applications.
4. Drag Graphviz to the Trash.
5. Empty the Trash.

On Linux, you can uninstall Graphviz using your package manager. For example, on Ubuntu, you can use the following command:

sudo apt-get remove graphviz

That’s it! With these installation and uninstallation methods, you can use Graphviz without encountering the "GraphViz's executables not found" error.

Troubleshooting and Solutions

Again, if you are experiencing the "GraphViz's executables not found" error, don’t worry, there are several solutions available to fix the issue.

Firstly, make sure that you have installed GraphViz on your machine. You can download the installer from the official website graphviz.gitlab.io. Once you have installed GraphViz, you need to add the path to your environment variables. On Windows, the path is usually C:\Program Files (x86)\Graphviz\bin.

If you are using Anaconda, you can install GraphViz using the following command: conda install graphviz. After installation, you need to add the path to your environment variables. On Windows, the path is usually C:\Users\username\Anaconda3\Library\bin\graphviz.

If you are still experiencing the error, try running the following command in your terminal: dot -version. This should display the version of GraphViz you have installed. If it doesn’t, then there may be an issue with your installation.

Another solution is to check your system’s PATH environment variable. Make sure that the path to GraphViz is included in the PATH variable. You can check this by running the following command in your terminal: echo %PATH%.

If you are still experiencing the error, you can try reinstalling GraphViz or installing an older version of GraphViz. You can find older versions of GraphViz on the official website graphviz.gitlab.io.

In some cases, the error may be caused by a conflict with other software installed on your machine. Try uninstalling any software that may be conflicting with GraphViz and then reinstall GraphViz.

If none of the above solutions work, you may want to consult the GraphViz manual graphviz.gitlab.io/_pages/doc/info/index.html. The manual provides detailed information on how to install and use GraphViz.

Frequently Asked Questions

How do I resolve ‘Graphviz’s executables not found’ error on Mac?

If you encounter the ‘Graphviz’s executables not found’ error on your Mac, you can try installing Graphviz using Homebrew. Open your terminal and run the following command:

brew install graphviz

This should install Graphviz and resolve the error. If the error persists, you can try adding Graphviz’s executables to your system’s path.

How to fix ‘Graphviz’s executables not found’ error on Windows?

If you encounter the 'Graphviz's executables not found' error on your Windows machine, you can try installing Graphviz using the Anaconda Prompt. Open the Anaconda Prompt and run the following command:

conda install graphviz

This should install Graphviz and resolve the error. If the error persists, you can try adding Graphviz’s executables to your system’s path.

How to install Graphviz on Windows 10?

To install Graphviz on your Windows 10 machine, you can follow these steps:

1. Go to the Graphviz website and download the appropriate installer for your system.
2. Run the installer and follow the installation instructions.
3. After the installation is complete, add Graphviz’s executables to your system’s path.

Where does Graphviz install?

The location of Graphviz installation depends on your operating system and the installation method used. On Windows, Graphviz is typically installed in the C:\Program Files\Graphviz directory. On Mac, it is typically installed in the /usr/local/Cellar/graphviz directory.

How to install Graphviz in Ubuntu?

To install Graphviz on Ubuntu, you can use the following command:

sudo apt-get install graphviz

This should install Graphviz and its dependencies. If the installation is successful, you can check the version of Graphviz using the following command:

dot -V

How do you add Graphviz executables to your system’s path?

To add Graphviz’s executables to your system’s path, you can follow these steps:

1. Open your terminal or command prompt.
2. Type the following command to open the environment variables editor: rundll32 sysdm.cpl,EditEnvironmentVariables
3. In the editor, click on the ‘Path’ variable and then click ‘Edit’.
4. Add the path to Graphviz’s executables to the list of paths. The path should look something like this: C:\Program Files\Graphviz\bin
5. Click ‘OK’ to save the changes.
6. Close and reopen your terminal or command prompt for the changes to take effect.

By adding Graphviz’s executables to your system’s path, you should be able to use Graphviz without encountering the ‘Graphviz’s executables not found’ error.

The post Graphviz Executables Not Found Error (Fixed) appeared first on Be on the Right Side of Change.

You can check out the slide deck here to get a first intuition on how the algorithm works:

Before we’ll dive into the algorithm and the Python implementation, let’s first skim over some related graph tutorials you may enjoy and that may help your understanding!

Related Graph Tutorials

This algorithm is part of our graph algorithm tutorials:

• Breadth-First Search (BFS) Algorithm in Python
• Python Depth-First Search (DFS) Algorithm
• Iterative Deepening Depth-First Search (DFS) Algorithm in Python
• Python Best-First Search Algorithm
• Python Dijkstra Algorithm
• Python A* Algorithm
• Jump Search Algorithm in Python
• Python Backtracking
• Python Beam Search Algorithm

Each of these tutorial links opens in a new browser tab.

What is the Beam Search Algorithm?

The beam search algorithm is an informed search algorithm it is a more flexible variant of the previously explained best-first search algorithm. The beam search algorithm can take multiple paths into each iteration, ordered and selected by their path length. 

Reminder: informed search algorithms use some kind of auxiliary information to guide their search strategy. Not being statically determined upfront makes them an interesting choice for a wide range of applications. However, their performance is greatly determined by the quality of auxiliary information, commonly known in computer science as heuristic function, h(vertex).

The same as its base algorithm, the best-first search algorithm, the beam search algorithm uses a greedy, hence best-first approach, where the next β path choices are determined by their current length, rather than the overall quality of the path.

Symbol β (reads as “beta”) stands for the width of the beam, i.e. the number of the shortest (cheapest) paths to be taken into the next iteration of the algorithm, while all the other paths are being pruned.

What is the Purpose of Beam Search?

As a more flexible variant of the best-first search algorithm, the beam search algorithm inherits some of its predecessor’s fundamental properties. However, depending on the β, the algorithm can perform as both pure best-first search algorithm (β=1), pure breadth-first search algorithm (β=∞), and of course, anything in between.

Applications: The beam search algorithm is commonly used in applications such as machine translation, where there is possibly more than one good enough solution.

Except for its robustness, the most notable property of the beam search algorithm is its ability to maintain the manageability and usability of systems with limited resources in dealing with large and dense graphs.

How Does Beam Search Work?

The beam search algorithm starts the graph traversal by marking the start vertex as visited, i.e. putting it in the dictionary and placing it into the priority queue of candidate vertices.

We will use the term explored, which is synonymous with the terms expanded or extended in other literature.

Vertex priority determines the best β vertices to be kept for the next iteration. However, this selection will be done first by expanding all the neighboring vertices for each vertex in the current tier.

Then, the best β paths will be kept and taken to the next iteration.

The cycle of choosing, exploring, and populating the priority queue continues, until the priority queue becomes exhausted. At that point, the beam search algorithm stops its execution.

Since the heuristic function greatly influences the algorithm performance, the function’s accuracy is crucial.

What are the Properties or Beam Search?

The main property of the beam search algorithm lies in its versatility, i.e. the fact that it can switch between the best-first search and breadth-first search approach of traversing the graph.

Its performance depends on the quality of the heuristic function, which in most cases represents the distance estimation from the goal vertex. The choice of heuristic function can influence the algorithm to find the shortest possible path to the goal vertex, to never complete the search — and everything in between these two extremes.

How is Beam Search Implemented in Python?

The implementation of our beam search algorithm is achieved by the function beam_search().

For a more self-contained educational showcase, we will omit the commonly used graph data structure and introduce a few simplifications.

• First, we will assume densely connected vertices (with many-to-many connections).
• Second, we will define a fixed matrix representing distances, or weights between individual vertices in each tier.
• Third, each element of the distance matrix is composed of two parts: the first one is a list of distances from any previous vertex to its neighboring vertices, where vertices are determined by the indices of each distance, e.g. in a list [12, 13, 14], distance to vertex 0 is 12, and distances to vertices 1 and 2 are 13 and 14.

The function beam_search() takes only two parameters:

• The distances parameter takes an initialized numpy.array object.
• The beta parameter takes a number representing the beam width, which we choose between integer values of 1 and ∞ (a large enough number for practical purposes).

For a better understanding of the algorithm and its implementation, each step is precisely described in the code below:

from numpy import array


# Uses a beam to search through the tree
def beam_search(distances, beta):
    # Defines an initial, dummy record structure represented by
    # visited vertices and the path length (so far),
    # traversed along each path.
    paths_so_far = [[list(), 0]]
    
    # Propagates through the neighbouring vertices tier by tier
    # (row by row). A vertex position is indicated by its
    # index in each row (dists).
    for idx, tier in enumerate(distances):
        if idx > 0:
            print(f'Paths kept after tier {idx-1}:')
            print(*paths_so_far, sep='\n')
        paths_at_tier = list()
        
        # Follows each path.
        for i in range(len(paths_so_far)):
            # Reads the current path and its length (sum of distances).
            path, distance = paths_so_far[i]
            
            # Extends the path for every possible neighboring vertex
            # at the current tier.
            for j in range(len(tier)):
                path_extended = [path + [j], distance + tier[j]]
                paths_at_tier.append(path_extended)
                
        # Sorts the newly generated paths by their length.
        paths_ordered = sorted(paths_at_tier, key=lambda element: element[1])
        
        # The best 'beta' paths are preserved.
        paths_so_far = paths_ordered[:beta]
        print(f'\nPaths pruned after tier {idx}: ')
        print(*paths_ordered[beta:], sep='\n')
        
    return paths_so_far


# Define a distance matrix of 10 tiers
dists = [[1, 3, 2, 5, 8],
         [4, 7, 9, 6, 7]]
dists = array(dists)

# Calculates the best paths by applying a beam of width 'beta'.
best_beta_paths = beam_search(dists, 3)

# Prints the best 'beta' paths.
print('\nThe best \'beta\' paths:')
for beta_path in best_beta_paths:
    print(beta_path)

The test run gave us the output (for β = 3):

Paths pruned after tier 0: 
[[3], 5]
[[4], 8]
Paths kept after tier 0:
[[0], 1]
[[2], 2]
[[1], 3]

Paths pruned after tier 1: 
[[1, 0], 7]
[[0, 1], 8]
[[0, 4], 8]
[[2, 3], 8]
[[2, 1], 9]
[[2, 4], 9]
[[1, 3], 9]
[[0, 2], 10]
[[1, 1], 10]
[[1, 4], 10]
[[2, 2], 11]
[[1, 2], 12]

The best 'beta' paths:
[[0, 0], 5]
[[2, 0], 6]
[[0, 3], 7]

The resulting output shows the intermediate and final paths in a list of vertex indices and the total path length.

Based on the output, we can see that the search started from the root vertex and that in the first iteration (tier 0) the beam_search() has pruned two and kept three (shortest) paths, marked by the vertex indices and the appropriate total path length so far.

In the second iteration, the beam_search() has pruned twelve and kept three (shortest) paths, marked by the vertex indices and the appropriate total path length so far. Since our dists matrix has only two tiers (I’ve kept it short for educational purposes), the algorithm ends here.

The final result is also displayed as The best ‘beta’ paths.

After setting the β to 1 and a re-run, we got a result matching a best-first search algorithm:

Paths pruned after tier 0: 
[[2], 2]
[[1], 3]
[[3], 5]
[[4], 8]
Paths kept after tier 0:
[[0], 1]

Paths pruned after tier 1: 
[[0, 3], 7]
[[0, 1], 8]
[[0, 4], 8]
[[0, 2], 10]

The best 'beta' paths:
[[0, 0], 5]

On the contrary, a large β (larger than number of distances in each tier multiplied, e.g. 5 x 5) would yield a breadth-first search algorithm behavior, where no pruning occurs:

Paths pruned after tier 0: 

Paths kept after tier 0:
[[0], 1]
[[2], 2]
[[1], 3]
[[3], 5]
[[4], 8]

Paths pruned after tier 1: 


The best 'beta' paths:
[[0, 0], 5]
[[2, 0], 6]
[[0, 3], 7]
[[1, 0], 7]
[[0, 1], 8]
[[0, 4], 8]
[[2, 3], 8]
[[2, 1], 9]
[[2, 4], 9]
[[1, 3], 9]
[[3, 0], 9]
[[0, 2], 10]
[[1, 1], 10]
[[1, 4], 10]
[[2, 2], 11]
[[3, 3], 11]
[[1, 2], 12]
[[3, 1], 12]
[[3, 4], 12]
[[4, 0], 12]
[[3, 2], 14]
[[4, 3], 14]
[[4, 1], 15]
[[4, 4], 15]
[[4, 2], 17]

Efficiency analysis

The algorithm’s worst-case time complexity depends on β and lies between O(bd) (behaves like a pure best-first search algorithm) and O(|V| + |E|) (behaves like a pure breadth-first search algorithm). It is determined by the heuristic function and the factor β.

The algorithm’s worst-case space complexity also depends on β and lies between O(bd) (behaves like a pure best-first search algorithm) and O(|V|) (behaves like a pure breadth-first search algorithm).

Conclusion

In this article, we learned about the beam search algorithm.

• First, we explained what a beam search algorithm is.
• Second, we took a look at what are its common purposes and applications.
• Third, we went through an explanation of how the algorithm works.
• Fourth, we examined the algorithm’s main properties.
• Fifth, we went through the implementation of the algorithm. We also tested the algorithm by calling its main function, beam_search(), and analyzed its steps of execution for the smallest, middle, and largest (“infinite”) β scenarios.
• Sixth, we analyzed the algorithm efficiency.

In the end, we concluded that the algorithm’s efficiency may be optimal if it behaves like a breadth-first search algorithm, although such mode of operation would defeat its initial purpose — to reduce the space complexity and data storage requirements.

In other modes of operation, the algorithm is not guaranteed to perform optimally and might also take a virtually infinite time in reaching the solution, especially for β = 1.

However, this behavior can be prevented by constructing the appropriate heuristic function using the relevant knowledge about the graph and vertice relationships.

Academy Course – Mastering the Top 10 Graph Algorithms

If you want to improve your fundamental computer science skills, there’s nothing more effective than studying algorithms.

To help you master the most important graph algorithms, we’ve just launched the “Top 10 Algorithms” course at the Finxter Computer Science Academy. This great course from Finxter Star Creator Matija teaches you the most important graph algorithms such as BFS, DFS, A*, and Dijkstra. 

Understanding these algorithms will not only make you a better coder, but it’ll also lay a strong foundation on which you can build your whole career as a computer scientist.

Click the screenshot to find out more:

The post Python Beam Search Algorithm appeared first on Be on the Right Side of Change.

You can check out the slides here (direct PDF link):

Before we’ll dive into the algorithm and the Python implementation, let’s first skim over some related graph tutorials you may enjoy and that may help your understanding!

Related Graph Tutorials

This algorithm is part of our graph algorithm tutorials:

• Breadth-First Search (BFS) Algorithm in Python
• Python Depth-First Search (DFS) Algorithm
• Iterative Deepening Depth-First Search (DFS) Algorithm in Python
• Python Best-First Search Algorithm
• Python Dijkstra Algorithm
• Python A* Algorithm
• Jump Search Algorithm in Python
• Python Backtracking
• Python Beam Search Algorithm

Each of these tutorial links opens in a new browser tab.

What is Backtracking?

Backtracking is a general approach, i.e. a variant of a depth-first search algorithm, suited for solving constraint satisfaction problems.

Idea: Backtracking incrementally validates candidates, tests the solutions, and backtracks from a candidate value if it determines that the final solution is not valid while containing the candidate value.

What is the Purpose of Backtracking?

Backtracking is commonly used in solving crosswords, verbal arithmetic, and similar puzzles.

It is the most appropriate method for parsing, i.e. analyzing a string of symbols, solving a knapsack problem, and other combinatorial optimization problems.

Backtracking is also the basis for some logic programming languages, such as Prolog.

How Does Backtracking Work?

A backtracking-based algorithm, in our case implemented as a Sudoku game, works by starting in the top left corner and searching for the empty positions in the puzzle by going from left to right.

When the algorithm finds an empty position, it will rotate a series of candidate values, ranging from 0 to 9, and check if there is a value that satisfies the basic rules of Sudoku: uniqueness in its row, its column, and its group.

• If the value matches the rules, the algorithm will recursively proceed to the next free position, retry the same series of values, and repeat the same steps until it reaches the end.
• If no value from the series matches the rules, the algorithm will backtrack to the previously filled position, try the next rule-matching value from the series, and resume searching for the next free position, recursively repeating the process.

Once the last free position has been filled with the rule-matching value, the algorithm will yield the solution and end.

If the algorithm encounters a free position that cannot be filled with a rule-matching value, it will eventually exhaust the series of values for the first free position and there will be no solution found, i.e. the puzzle will be left unsolved.

Backtracking functionality is achieved by recursively checking, i.e. descending lower in the search space by using the depth-first search algorithm.

The algorithm is implemented implicitly and the graph vertex is conceptually represented by the current state of the puzzle.

All previous states along the current search path are preserved in their corresponding function contexts.

Contrary to other graph algorithms, this algorithm did not require us to explicitly generate the search space, usually represented by a graph, because it would have enormous requirements in both terms of space (memory) and time (duration). Furthermore, most parts of the generated graph would remain unexplored.

What are Backtracking Properties?

One of the significant properties of the backtracking approach is that the solution discovery is guaranteed for valid puzzles, i.e. the ones that have a solution.

The second important property is the simplicity and flexibility of approach implementation, which makes it a good general approach for testing the existence of a solution.

On the downside, depending on a specific problem, solution finding by applying a backtracking approach can be inferior to stochastic search or other optimization methods.

How is Backtracking Implemented?

An example of our backtracking algorithm is implemented in a form of a Sudoku solution finder.

The program is very simple, self-contained, and has only three functions: backtrack_sudoku(), next_position(), and test_candidate().

The main function, backtrack_sudoku() takes two parameters:

• the puzzle parameter as an initialized 2D list object (a list of lists), and
• the optional print_steps parameter, which enables us to see the steps which our algorithm took before reaching the final solution (if there is one). It defaults to False but can be activated if we call the main function in the following way: backtrack_sudoku(puzzle, True).

The utility function, next_position() takes only one parameter, puzzle, representing our puzzle, and calculating the next free position on the puzzle board.

If we imagine traversing the puzzle board row-by-row, i.e. by starting on the top-left position, scanning the entire row, and then progressing to the leftmost position in the next row, the first empty position not containing a value is considered to be free.

The function test_candidate() takes three parameters:

• puzzle, representing our puzzle, then
• the candidate_value, and
• a position.

The function tests different candidate values, looping from 0 to 9, and tries to find the candidate value that is unique in the current row, column, and its group.

For a better understanding of the algorithm and its implementation, each step is precisely described in the code below.

The entire algorithm listing follows:

dimension = 3
iterations = 0


# An anonymous placeholder object.
class Object:
    def __init__(self):
        self.row = None
        self.column = None

    pass


def next_position(puzzle):
    # Loops through the search space by rows and then by columns.
    for i in range(len(puzzle)):
        for j in range(len(puzzle[0])):
            if puzzle[i][j] is None:
                position = Object()
                position.row = i
                position.column = j
                return position
    return None


def test_candidate(puzzle, candidate_value, position):
    # Searches the row for duplicate values of the 'candidate_value'.
    for i in range(len(puzzle[0])):
        # Prevents detecting the 'candidate_value' as a duplicate.
        if puzzle[position.row][i] == candidate_value and position.column != i:
            return False

    # Searches the column for duplicate values of the 'candidate_value'.
    for i in range(len(puzzle)):
        # Prevents detecting the 'candidate_value' as a duplicate.
        if puzzle[i][position.column] == candidate_value and position.row != i:
            return False

    # Forms and searches the groups for duplicate values of the 'candidate_value'.
    group = Object()
    # Determines the group by integer division of the position coordinates.
    group.column = position.column // dimension
    group.row = position.row // dimension
    # Performs the group search inside a group, by rows and columns.
    for i in range(group.row * dimension, (group.row + 1) * dimension):
        for j in range(group.column * dimension, (group.column + 1) * dimension):
            if puzzle[i][j] == candidate_value and (i, j) != position:
                return False
    return True


def backtrack_sudoku(puzzle, print_steps=False):
    # Counts the total number of iterations until the solution is found.
    global iterations
    iterations += 1
    # Finds the next free position.
    position = next_position(puzzle)
    if not position:
        return True
    # Tries out every possible value at the given (free) position.
    for i in range(1, dimension * dimension + 1):
        # Tests if the value matches the general rules,
        # i.e. value uniqueness in the row, column and group.
        if test_candidate(puzzle, i, position):
            puzzle[position.row][position.column] = i
            if print_steps:
                print(f'\n\n***  Iteration: {iterations}  ***\n')
                print_puzzle(puzzle)
            # Proceeds with the search by going one level deeper in the
            # search tree, effectively doing the depth-first search algorithm.
            if backtrack_sudoku(puzzle, print_steps):
                return True
            # Marks the position as empty if none of the values match the rules.
            puzzle[position.row][position.column] = None

    return False


def print_puzzle(puzzle):
    for i in range(len(puzzle)):
        if i % dimension == 0 and i != 0:
            print('')

        for j in range(len(puzzle[0])):
            if j % dimension == 0 and j != 0:
                print('  ', end='')
            print(str(puzzle[i][j] or '_'), end=' ')
            if j % (dimension * dimension - 1) == 0 and j != 0:
                print('')

Now that we have prepared everything, we can test backtrack_sudoku() and see how it works.

We have three readily available puzzles, arranged by their difficulty, as easy, medium, and hard.

easy = [
    [None, None, None, None, None, None, None, None, None],
    [None, 7, 6, None, None, None, 8, 4, None],
    [1, 8, None, None, None, 4, None, 7, 5],
    [None, None, None, 2, 5, None, None, None, 6],
    [None, None, 1, 4, None, 7, 3, None, None],
    [6, None, None, None, 3, 8, None, None, None],
    [3, 5, None, None, None, 9, None, 8, 1],
    [None, 1, 4, None, None, None, 2, 5, None],
    [None, None, None, None, None, None, None, None, None]
]

medium = [
    [None, None, None, 4, None, None, None, 8, None],
    [None, 4, None, None, None, 3, None, None, None],
    [8, None, None, None, None, None, 1, 3, None],
    [None, None, None, 6, None, None, None, None, None],
    [None, None, 8, 2, 1, None, None, None, 7],
    [5, None, None, None, None, 4, None, None, None],
    [7, None, None, 3, None, None, 5, None, 9],
    [9, None, None, None, 8, None, 2, None, None],
    [None, None, 6, None, 5, None, 3, None, None]
]

hard = [
    [None, 2, None, None, None, None, None, 9, None],
    [None, None, None, None, 7, 4, 8, None, None],
    [4, 3, None, None, None, 1, None, None, None],
    [5, None, 6, 7, None, None, None, None, None],
    [None, None, None, None, 2, None, None, None, None],
    [None, None, None, None, None, 9, None, None, 3],
    [None, None, 3, None, None, None, None, 8, None],
    [None, 1, None, 9, 5, None, 6, None, None],
    [None, 5, None, None, None, None, None, 7, None]
]

Here is the part of the code that runs the algorithm, shows the puzzle we chose to solve, and the final solution, depending on if it exists:

solve_for_puzzle = easy

print_puzzle(solve_for_puzzle)
print('\nLooking for the solution...\n')
backtrack_sudoku(solve_for_puzzle)
print('\n  ***  THE SOLUTION  ***')
print(f'Iterations required: {iterations}\n')
print_puzzle(solve_for_puzzle)

We have the following output for our easy puzzle:

_ _ _   _ _ _   _ _ _ 
_ 7 6   _ _ _   8 4 _ 
1 8 _   _ _ 4   _ 7 5 

_ _ _   2 5 _   _ _ 6 
_ _ 1   4 _ 7   3 _ _ 
6 _ _   _ 3 8   _ _ _ 

3 5 _   _ _ 9   _ 8 1 
_ 1 4   _ _ _   2 5 _ 
_ _ _   _ _ _   _ _ _ 

Looking for the solution...


  ***  THE SOLUTION  ***
Iterations required: 21644

9 4 5   8 7 3   1 6 2 
2 7 6   1 9 5   8 4 3 
1 8 3   6 2 4   9 7 5 

4 3 8   2 5 1   7 9 6 
5 9 1   4 6 7   3 2 8 
6 2 7   9 3 8   5 1 4 

3 5 2   7 4 9   6 8 1 
7 1 4   3 8 6   2 5 9 
8 6 9   5 1 2   4 3 7 

If we rerun the algorithm, we have the following output for our medium puzzle:

solve_for_puzzle = medium

_ _ _   4 _ _   _ 8 _ 
_ 4 _   _ _ 3   _ _ _ 
8 _ _   _ _ _   1 3 _ 

_ _ _   6 _ _   _ _ _ 
_ _ 8   2 1 _   _ _ 7 
5 _ _   _ _ 4   _ _ _ 

7 _ _   3 _ _   5 _ 9 
9 _ _   _ 8 _   2 _ _ 
_ _ 6   _ 5 _   3 _ _ 

Looking for the solution...


  ***  THE SOLUTION  ***
Iterations required: 261512

6 3 9   4 2 1   7 8 5 
1 4 5   8 7 3   6 9 2 
8 2 7   5 6 9   1 3 4 

2 7 4   6 3 8   9 5 1 
3 9 8   2 1 5   4 6 7 
5 6 1   7 9 4   8 2 3 

7 8 2   3 4 6   5 1 9 
9 5 3   1 8 7   2 4 6 
4 1 6   9 5 2   3 7 8 

On our last rerun of the algorithm, we have the following output for our hard puzzle:

solve_for_puzzle = hard

_ 2 _   _ _ _   _ 9 _ 
_ _ _   _ 7 4   8 _ _ 
4 3 _   _ _ 1   _ _ _ 

5 _ 6   7 _ _   _ _ _ 
_ _ _   _ 2 _   _ _ _ 
_ _ _   _ _ 9   _ _ 3 

_ _ 3   _ _ _   _ 8 _ 
_ 1 _   9 5 _   6 _ _ 
_ 5 _   _ _ _   _ 7 _ 

Looking for the solution...


  ***  THE SOLUTION  ***
Iterations required: 321814

7 2 1   3 8 5   4 9 6 
9 6 5   2 7 4   8 3 1 
4 3 8   6 9 1   2 5 7 

5 4 6   7 3 8   9 1 2 
3 7 9   1 2 6   5 4 8 
1 8 2   5 4 9   7 6 3 

2 9 3   4 6 7   1 8 5 
8 1 7   9 5 3   6 2 4 
6 5 4   8 1 2   3 7 9 

Efficiency analysis

After comparing the number of iterations the algorithm took to find the solution for different puzzle difficulties, we noticed a stunning increase of 1100% in the number of iterations between easy and medium difficulty puzzles.

Furthermore, we noticed an additional 23% increase in the number of iterations between medium and hard difficulty puzzles.

Based on our results, we can conclude that, depending on the specific problem, the backtracking approach may be appropriate if it manages to intelligently reduce the search space and solve the problem in finite time.

However, its efficiency can vary greatly with the problem complexity and the backtracking approach is not applicable in just every case.

Conclusion

In this article, we learned about backtracking in search algorithms.

• First, we explained what backtracking in search algorithms is.
• Second, we took a look at what are its common purposes and applications.
• Third, we went through an explanation of how the approach works.
• Fourth, we examined the main properties of this approach.
• Fifth, we went through an example implementation of backtracking in Sudoku-solving algorithm, which is based on simple three functions, backtrack_sudoku(), next_position(), and test_candidate().
• We also tested the algorithm by calling its main function, backtrack_sudoku(), and analyzed its steps of execution for three puzzles of different difficulties.
• Sixth, we analyzed the algorithm efficiency.

To conclude, the algorithm efficiency is much better than its main alternative in the form of a pure brute-force method, based on trial-and-error. However, the algorithm efficiency varies with the structure of a puzzle, i.e. the composition of the problem.

Depending on the specific problem, the backtracking approach may be found appropriate if it manages to consistently reduce the search space and solve the problem in a finite time.

However, it is not generally considered the best approach for every problem of this kind. In such cases, if it proves to be practically inefficient, an alternative approach should be taken into consideration.

Academy Course – Mastering the Top 10 Graph Algorithms

If you want to improve your fundamental computer science skills, there’s nothing more effective than studying algorithms.

To help you master the most important graph algorithms, we’ve just launched the “Top 10 Algorithms” course at the Finxter Computer Science Academy. This great course from Finxter Star Creator Matija teaches you the most important graph algorithms such as BFS, DFS, A*, and Dijkstra. 

Understanding these algorithms will not only make you a better coder, but it’ll also lay a strong foundation on which you can build your whole career as a computer scientist.

Click the screenshot to find out more:

The post Python Backtracking – A Helpful Guide with Video appeared first on Be on the Right Side of Change.

As you watch the video, you can have a look at the slides as PDF: download slides in a new tab here.

Before we’ll dive into the algorithm and the Python implementation, let’s first skim over some related graph tutorials you may enjoy and that may help your understanding!

Related Graph Tutorials

This algorithm is part of our graph algorithm tutorials:

• Breadth-First Search (BFS) Algorithm in Python
• Python Depth-First Search (DFS) Algorithm
• Iterative Deepening Depth-First Search (DFS) Algorithm in Python
• Python Best-First Search Algorithm
• Python Dijkstra Algorithm
• Python A* Algorithm
• Jump Search Algorithm in Python
• Python Backtracking
• Python Beam Search Algorithm

Each of these tutorial links opens in a new browser tab.

What is the Jump Point Search Algorithm?

The jump point search algorithm — or shorter JPS — is a variant of the A* search algorithm, optimized for pathfinding on grid maps, i.e., in computer games.

The jump point search algorithm is invented and published by Daniel Harabor and Alban Grastien in 2011.

It exploits path symmetry which is manifested as a path (or path segments) which share the same start and goal vertex, have the same length, and are otherwise identical, but differ in the scan order.

In the authors’ words, the algorithm is fast, optimal, and requires no memory overhead.

It identifies and selectively expands only vertices of interest, which are called jump points. This means that vertices between any two jump points are not expanded, or in our familiar terms, they remain unexplored.

This is a property that enables much faster algorithm operation by reducing the number of vertices that would otherwise have to be processed, e.g., by applying the original A* algorithm.

• Related Article: The A* Algorithm in Python

What is Its Purpose?

A common application of the jump point search algorithm is pathfinding, such as in computer games or possibly in navigation systems.

In general, whenever there is a search space that can be generalized to a uniform cost grid (all the paths to the neighbouring vertices are of equal cost), the jump point search algorithm is highly applicable.

How Does It Work?

The jump point search algorithm builds on the A* algorithm, which means that we still have a heuristic estimation function, and visited (open) and explored (closed) lists. We also get the same optimality properties of the result under the same conditions.

The algorithm operation differs in the data, specifically, in the visited and explored lists, and how a vertex gets expanded.

A* does not perform very well with big open fields, i.e. uniform cost grids, because it takes most of the time to process updates of the visited vertices.

On the other hand, the jump point search algorithm improves on the A* algorithm by exploiting the regularity of the grid, i.e., it does not need to search every possible path, since all paths are known to have equal costs.

In other words, most nodes in the grid are not interesting enough to be processed.

As a result, the jump point search algorithm spends much less time updating the visited and explored lists. It is sufficient to only scan the cells to check if there is a jump point nearby.

Instead of checking every neighbor from every possible vertex, the goal of each step in the scan is to decide whether the next point is interesting enough to create a new entry in the visited list.

If it is not, the algorithm continues the scanning iteration.

If a position is interesting enough, new jump points are recorded in the visited list, and the current scan iteration ends.

There are two cases of scan directions: horizontal/vertical and diagonal. Both cases are terminated when the scan runs into an obstacle (a non-passable vertex) or reaches the end of the search space.

Similarly, the scans yield a jump point if its search path passes beside an obstacle (black), as shown in the second and fourth pictures:

White numerated vertices represent valid neighbors of x, while grey vertices represent invalid neighbors of x.

We are simulating undirected uniform-cost grid maps by having each pair of vertices connected by the two edges of opposite directions. Each vertex has up to 8 neighbors and is either traversable or not.

Each horizontal or vertical scan, from a traversable vertex to one of its neighbors, has a cost of 1 and diagonal moves cost of √2.

To make it easier on the algorithm, we will use 10x whole numbers as a measure of distance. Therefore, instead of the cost √2 = 1.41421… we will use the cost of 14/2 = 7, and instead of the cost 1, we will use the cost of 10/2 = 5.

Moves involving obstacles (non-traversable) vertices are not allowed. Each direction is defined by a number from 0 to 7:

• Each double arrow represents two edges in opposite directions.
• The numbers are indicating the direction each edge is oriented in.
• The edge numeration enables us to use the prune() function for neighbours pruning and forced neighbours detection, regardless of the movement direction.

What Are Its Properties?

As the jump point search algorithm builds on the A* algorithm, it also uses the exact information represented by the successive edges’ weights connecting the jump points and a heuristic function for distance estimation between the goal vertex and the jump points in a graph.

As the initial costs for all the jump points are set to infinity, the algorithm successively decreases jump points’ costs until they reach their minimum.

(1) Optimal: This behavior leads to a property of being optimal: minimal costs assigned to jump points enable the jump point search algorithm to always find the shortest path between the starting vertex and any jump point in the graph.

As the shortest paths always start from the starting vertex, the algorithm also belongs to the “single-source” algorithm.

(2) Complete: Besides being optimal, the algorithm is also complete, i.e. it will always take a finite time to find a solution.

(3) Optimal Efficiency: The third important property is the optimal efficiency, reflected in the fact that jump points positioned further from the goal vertex may not be explored at all, as their heuristic function distinguishes and delays the exploration of such jump points among those with equally weighted paths.

The heuristic functions used in the jump point search algorithm also inherit two notable properties from the A* algorithm: admissibility and consistency.

• Admissibility implies that the heuristic function cost estimation is at most as high as the lowest possible cost from the current point in a path towards the goal vertex.
• The consistent or monotone heuristic function is constrained by a requirement that its cost estimation is always less than or equal to the estimated distance from any adjoining, successor vertex to the goal, plus the cost of reaching that vertex.

How Is It Implemented?

The implementation of the jump point search algorithm is achieved by the function jps() and a modification of the underlying class Graph.

The jps() function takes three parameters:

• The graph parameter as an initialized Graph object (see the blog on the A* search algorithm, the section on graphs).
• The start_vertex parameter takes the starting vertex, which we choose freely (remember, a graph is not a tree, there is no absolute root).
• The goal_vertex parameter is the entity we want to find in the graph, enclosed in a vertex.

For a better understanding of the algorithm and its implementation, each step is precisely described in the code below.

There have been some further upgrades on the Graph class, in terms of the obstacle and direction properties, so its entire listing follows:

class Graph:

    def __init__(self, directed=False):
        self._outgoing = {}
        # If the graph is undirected, 'self._outgoing'
        # is the universal storage.
        self._incoming = {} if directed else self._outgoing

    # If the graph is directed, the 'self._incoming' 
    # dictionary differs from the 'self._outgoing'.
    def is_directed(self):
        return self._incoming is not self._outgoing

    # The function returns a generator of incoming
    # or outgoing (default) edges of a vertex.
    def adjacent_edges(self, vertex, outgoing=True):
        # References the corresponding outer dictionary
        # (dictionary of dictionaries)
        adj_edges = self._outgoing if outgoing else self._incoming

        # Access each of the edges for this endpoint vertex.
        for edge in adj_edges[vertex].values():
            yield edge

    def add_vertex(self, entity=None, h=None, cost=None):
        # Constructs a new vertex from the entity.
        vertex = self.Vertex(entity, h, cost)
        # The vertex becomes a key in the outer dictionary,
        # but the value is an internal dictionary (as we model
        # both dimensions for each edge: origin and destination).
        # e.g. {vertex_1a:{vertex_b:edge_a_b}, vertex_b:{vertex_c:edge_b_c}}.
        self._outgoing[vertex] = {}
        if self.is_directed():
            self._incoming[vertex] = {}

    def add_edge(self, origin, destination, weight=None, direction=None):
        # Constructs a new edge from the vertices.
        edge = self.Edge(origin, destination, weight, direction)
        # Adds the edge to the dictionary (dictionaries are
        # the same if the graph is undirected). The outer key
        # represents the origin, i.e. the component 'a' of
        # the edge-defining pair (a, b). The inner key stands
        # for the component 'b' of the edge-defining pair (a, b).
        self._outgoing[origin][destination] = edge
        # Even if the graph is undirected, each edge has to
        # be added twice, i.e. once for each of its endpoints.
        edge = self.Edge(origin, destination, weight, (direction + 4) % 8)
        self._incoming[destination][origin] = edge

    def vertices(self):
        return self._outgoing.keys()

    def edges(self):
        # All the edges are collected into a set.
        result = set()
        for inner_dict in self._outgoing.values():
            result.update(inner_dict.values())
        return result

    class Vertex:
        __slots__ = '_entity', '_h', '_cost', '_obstacle', '_direction'

        def __init__(self, entity, h=None, cost=None):
            self.entity = entity
            self.h = h
            self.cost = cost
            self.obstacle = False
            self.direction = None

        # The real-world entity is represented by the Vertex object.
        @property
        def entity(self):
            return self._entity

        @entity.setter
        def entity(self, entity):
            self._entity = entity

        # The real-world entity has a heuristic value of 'h'.
        @property
        def h(self):
            return self._h

        @h.setter
        def h(self, h):
            self._h = h

        # The real-world entity has a cost of 'cost'.
        @property
        def cost(self):
            return self._cost

        @cost.setter
        def cost(self, cost):
            self._cost = cost

        @property
        def obstacle(self):
            return self._obstacle

        @obstacle.setter
        def obstacle(self, obstacle):
            self._obstacle = obstacle

        @property
        def direction(self):
            return self._direction

        @direction.setter
        def direction(self, direction):
            self._direction = direction

        # We have to implement __hash__ to use the object as a dictionary key.
        def __hash__(self):
            return hash(id(self))

        def __lt__(self, other):
            if self.cost is None:
                return False
            elif other.cost is None:
                return True
            else:
                return self.cost < other.cost

    class Edge:
        __slots__ = '_origin', '_destination', '_weight', '_direction'

        def __init__(self, origin, destination, weight=None, direction=None):
            self._origin = origin
            self._destination = destination
            self.weight = weight
            self.direction = direction

        def endpoints(self):
            return self._origin, self._destination

        # Returns the other component of the edge-defining pair (a, b)
        # for a given component a or b, respectively.
        def opposite(self, vertex):
            return self._destination if self._origin is vertex \
                else self._origin

        # Returns the weight of the edge.
        @property
        def weight(self):
            return self._weight

        # Sets the weight of the edge
        @weight.setter
        def weight(self, weight):
            self._weight = weight

        # Returns the direction of the edge.
        @property
        def direction(self):
            return self._direction

        # Sets the direction of the edge
        @direction.setter
        def direction(self, direction):
            self._direction = direction

        def __hash__(self):
            return hash((self._origin, self._destination)) 

The most significant differences to the previous version of the Graph class are highlighted.

With these changes in place, implementation of the core function, jps() is:

from graph import Graph
from queue import PriorityQueue
from collections import namedtuple


# Just a dummy object attached with a dummy function...
class Object:
    pass


def prune(graph, vertex, direction=None):
    neighbours = {}
    forced_neighbours_exist = False
    if direction is None:
        direction = vertex.direction

    # Enables us to return both the neighbouring vertices and the
    # indicator of forced neighbours existence
    pruned = namedtuple('pruned', 'vertices forced')

    # ...right here :-) We use it to ensure availability of the property
    # when the None object gets returned from the 'neighbours' dictionary.
    o = Object()
    o.obstacle = lambda: True

    # Collects all the surrounding vertices in a dictionary and
    # marks them with the search direction
    for edge in graph.adjacent_edges(vertex):
        neighbours[edge.direction] = edge.opposite(vertex)

    # Applies exclusively to the non-starting vertices
    if direction is not None:
        # Determines if the movement direction is horizontal/vertical (0) or diagonal (1)
        is_diagonal = direction % 2

        leftmost_dir = change_dir(direction, 2 + is_diagonal)
        rightmost_dir = change_dir(direction, -2 - is_diagonal)

        # Parent is never a neighbour candidate
        neighbours.pop(change_dir(direction, 4), None)

        # Trivial case - check if some of natural neighbours are obstacles
        for idx in range(-is_diagonal, is_diagonal + 1):
            if neighbours.get(change_dir(direction, idx), o).obstacle:
                neighbours.pop(change_dir(direction, idx), None)

        # Non-trivial case of potentially forced neighbours (left)
        if neighbours.get(change_dir(leftmost_dir, -1), o).obstacle \
                or not neighbours.get(leftmost_dir, o).obstacle:
            # Discards the forced neighbour candidate
            neighbours.pop(change_dir(leftmost_dir, -1), None)
        else:
            forced_neighbours_exist = True
        neighbours.pop(leftmost_dir, None)

        # Non-trivial case of potentially forced neighbours (right)
        if neighbours.get(change_dir(rightmost_dir, 1), o).obstacle \
                or not neighbours.get(rightmost_dir, o).obstacle:
            # Discards the forced neighbour candidate
            neighbours.pop(change_dir(rightmost_dir, 1), None)
        else:
            forced_neighbours_exist = True
        neighbours.pop(rightmost_dir, None)

        # Back vertices are never neighbour candidates
        neighbours.pop(change_dir(direction, 4 + 1), None)
        neighbours.pop(change_dir(direction, 4 - 1), None)

    return pruned(neighbours, forced_neighbours_exist)


def step(graph, vertex, direction, cost_so_far):
    # Defines a fail-safe result.
    next_vertex = None
    cost = 0

    # Searches among the available edges and follows the right one.
    for edge in graph.adjacent_edges(vertex):
        if edge.direction == direction and not edge.opposite(vertex).obstacle:
            next_vertex = edge.opposite(vertex)
            cost = cost_so_far + edge.weight
            break
        else:
            continue

    # If the edge is not found, the equivalent of "nothing" is returned.
    return next_vertex, cost


# Changes the direction within the defined eight directions
def change_dir(direction, amount):
    return (direction + amount) % 8


def jump(graph, vertex, direction, cost_so_far, goal_vertex):
    jump_point, cost = step(graph, vertex, direction, cost_so_far)

    if jump_point is None:
        return None, None

    # If a vertex is the goal vertex:
    if jump_point.entity == goal_vertex:
        return jump_point, cost

    # Checks if forced neighbours exist
    if prune(graph, jump_point, direction).forced:
        return jump_point, cost

    # Activates if the direction is diagonal.
    if direction % 2:
        for direction_l_r in (change_dir(direction, 1), change_dir(direction, -1)):
            # Tests if the next jump point exists (its cost is irrelevant in the context of the check alone).
            next_jump_point, _ = jump(graph, jump_point, direction_l_r, 0, goal_vertex)
            if next_jump_point is not None:
                return jump_point, cost

    # Proceed in the same direction.
    jump_point, cost = jump(graph, jump_point, direction, cost, goal_vertex)
    return jump_point, cost


def jps(graph, start_vertex, goal_vertex):
    # Create the priority queue for open vertices.
    jump_points_pq = PriorityQueue()

    start_vertex = vertices[start_vertex]
    start_vertex.cost = 0
    # start_vertex is the only one in the first round of queueing,
    # so it doesn't need a distance to goal estimation.
    start_vertex.h = 0

    # Adds the start vertex to the priority queue.
    print(f'Visiting/queueing vertex {start_vertex.entity}')

    jump_points_pq.put(start_vertex)
    print('Prioritized vertices (v, cost, dir):',
          *((vert.entity, vert.cost, vert.direction) for vert in jump_points_pq.queue),
          end=2 * '\n')

    # The starting vertex is visited first and has no leading edges.
    visited[start_vertex.entity] = None

    # Loops until the priority list gets empty.
    while not jump_points_pq.empty():
        # Gets the previously calculated jump_point with the lowest cost.
        jpoint_prev = jump_points_pq.get()
        print(f'Exploring vertex {jpoint_prev.entity}')

        # If the vertex being explored is a goal vertex, the algorithm ends.
        if jpoint_prev.entity == goal_vertex:
            return jpoint_prev

        # Finds the vertex neighbours (natural and forced).
        neighbours = prune(graph, jpoint_prev)

        for direction in neighbours.vertices:
            jpoint, cost = jump(graph, jpoint_prev, direction, jpoint_prev.cost, goal_vertex)

            if jpoint is None or vertices.get(jpoint, None) in explored:
                continue

            # Calculates the jump point's heuristic value.
            if jpoint.h is None:
                jpoint.h = tuple(map(lambda x, y: abs(x - y), jpoint.entity, goal_vertex))
                jpoint.h = abs(jpoint.h[0] - jpoint.h[1]) * cost_hv \
                    + min(jpoint.h[0], jpoint.h[1]) * cost_di

            # Prevents reinsertion to the priority queue. The endpoint distance value will be updated.
            if jpoint.entity not in visited:
                print(f'Visiting/queueing vertex {jpoint.entity}.')
                visited[jpoint.entity] = jpoint_prev.entity
                jump_points_pq.put(jpoint)

            if jpoint.cost is None or jpoint.cost - jpoint.h > cost - jpoint_prev.h:
                jpoint.cost = cost - jpoint_prev.h + jpoint.h
                jpoint.direction = direction

            # Forces the priority queue to recalculate in case of an
            # inner vertex update resulting with the highest priority.
            if not jump_points_pq.empty():
                jump_points_pq.put(jump_points_pq.get())

        print('Prioritized vertices (v, cost, dir):',
              *((vert.entity, vert.cost, vert.direction) for vert in jump_points_pq.queue), end=2 * '\n')
        # The vertex is used for update and put aside.
        explored.append(jpoint_prev)


# Initializes an empty graph (object).
g = Graph()

# Initializes the grid dimensions.
m, n = 7, 9

# Defines horizontal/vertical and diagonal costs.
cost_hv = 5
cost_di = 7

# Loads the graph with [m x n] vertices.
for i in range(m):
    for j in range(n):
        g.add_vertex((i, j))

# Constructs the 'vertices' dictionary for a more
# convenient access during the graph construction.
vertices = {k.entity: k for k in g.vertices()}

# Generates the edges.
for i in range(m):
    for j in range(n):
        # Horizontal connections
        if j < n - 1:
            g.add_edge(vertices[i, j], vertices[i, j + 1], weight=cost_hv, direction=0)
        # Vertical connections
        if i < m - 1:
            g.add_edge(vertices[i, j], vertices[i + 1, j], weight=cost_hv, direction=6)
        # Left diagonal connections
        if i < m - 1 and j < n - 1:
            g.add_edge(vertices[i, j], vertices[i + 1, j + 1], weight=cost_di, direction=7)
        # Right diagonal connections
        if i < m - 1 and j > 0:
            g.add_edge(vertices[i, j], vertices[i + 1, j - 1], weight=cost_di, direction=5)

# Initializes the search path and a dictionary of visited vertices.
path = []
explored = []
visited = {}

# Initializes the obstacles.
vertices[(0, 2)].obstacle = True
vertices[(1, 2)].obstacle = True
vertices[(2, 2)].obstacle = True
vertices[(1, 4)].obstacle = True
vertices[(2, 4)].obstacle = True
vertices[(3, 4)].obstacle = True
vertices[(2, 6)].obstacle = True
vertices[(3, 6)].obstacle = True
vertices[(4, 6)].obstacle = True

Now that we have prepared everything, we can test jps() and see how it works. Here is the part of the code that runs the algorithm, constructs the search path (if there is one), and shows in a step-by-step manner how it proceeds through the graph:

# Starts the search.
result = jps(g, (0, 0), (1, 8))

# If the entity is found...
if result is not None:
    # The search path ends with the found vertex (entity).
    # Each vertex is a container for its real-world entity.
    path_vertex = result.entity
    # Constructs the rest of the search path (if it exists)...
    while path_vertex is not None:
        # The entity is added to the 'path'.
        path.append(path_vertex)
        path_vertex = visited[path_vertex]
    print('Search path found:', end=' ')
    # The path is reversed and starts with the root vertex.
    print(*reversed(path), sep=' -> ')
# Otherwise...
else:
    print('\nEntity is not found') 

The test run gave us the output:

Visiting/queueing vertex (0, 0)
Prioritized vertices (v, cost, dir): ((0, 0), 0, None)

Exploring vertex (0, 0)
Visiting/queueing vertex (1, 1)
Prioritized vertices (v, cost, dir): ((1, 1), 42, 7)

Exploring vertex (1, 1)
Visiting/queueing vertex (2, 1)
Prioritized vertices (v, cost, dir): ((2, 1), 49, 6)

Exploring vertex (2, 1)
Visiting/queueing vertex (3, 2)
Prioritized vertices (v, cost, dir): ((3, 2), 53, 7)

Exploring vertex (3, 2)
Visiting/queueing vertex (2, 3)
Visiting/queueing vertex (4, 3)
Prioritized vertices (v, cost, dir): ((2, 3), 53, 1) ((4, 3), 57, 7)

Exploring vertex (2, 3)
Visiting/queueing vertex (1, 3)
Prioritized vertices (v, cost, dir): ((1, 3), 56, 2) ((4, 3), 57, 7)

Exploring vertex (1, 3)
Visiting/queueing vertex (0, 4)
Prioritized vertices (v, cost, dir): ((4, 3), 57, 7) ((0, 4), 60, 1)

Exploring vertex (4, 3)
Visiting/queueing vertex (4, 4)
Visiting/queueing vertex (5, 4)
Prioritized vertices (v, cost, dir): ((4, 4), 57, 0) ((5, 4), 61, 7) ((0, 4), 60, 1)

Exploring vertex (4, 4)
Visiting/queueing vertex (3, 5)
Prioritized vertices (v, cost, dir): ((3, 5), 57, 1) ((5, 4), 61, 7) ((0, 4), 60, 1)

Exploring vertex (3, 5)
Visiting/queueing vertex (2, 5)
Prioritized vertices (v, cost, dir): ((2, 5), 60, 2) ((5, 4), 61, 7) ((0, 4), 60, 1)

Exploring vertex (2, 5)
Visiting/queueing vertex (1, 5)
Visiting/queueing vertex (1, 6)
Prioritized vertices (v, cost, dir): ((1, 6), 60, 1) ((0, 4), 60, 1) ((5, 4), 61, 7) ((1, 5), 63, 2)

Exploring vertex (1, 6)
Visiting/queueing vertex (1, 8)
Visiting/queueing vertex (2, 7)
Prioritized vertices (v, cost, dir): ((0, 4), 60, 1) ((1, 8), 60, 0) ((5, 4), 61, 7) ((2, 7), 64, 7) ((1, 5), 63, 2

Exploring vertex (0, 4)
Prioritized vertices (v, cost, dir): ((1, 5), 60, 7) ((1, 8), 60, 0) ((5, 4), 61, 7) ((2, 7), 64, 7)

Exploring vertex (1, 5)
Prioritized vertices (v, cost, dir): ((1, 8), 60, 0) ((2, 7), 64, 7) ((5, 4), 61, 7)

Exploring vertex (1, 8)
Search path found: (0, 0) -> (1, 1) -> (2, 1) -> (3, 2) -> (4, 3) -> (4, 4) -> (3, 5) -> (2, 5) -> (1, 6) -> (1, 8)

Efficiency Analysis

The jump point search algorithm builds on the A* search algorithm, but when applied to uniform-cost search space, it can be up to an order of magnitude faster.

Conclusion

In this article, we learned about the jump point search algorithm.

• First, we explained what the jump point search algorithm is.
• Second, we took a look at what are its common purposes and applications.
• Third, we went through an explanation of how the algorithm works.
• Fourth, we examined the algorithm’s main properties.
• Fifth, we went through the implementation of the algorithm, which is based on the Graph abstract data structure (Graph class implementation is given above). We also tested the algorithm by calling its main function, jps(), and analyzed its steps of execution for two slightly different edge weight scenarios.
• Sixth, we analyzed the algorithm efficiency.

In the end, we concluded that the algorithm efficiency is optimal and much faster than the original A* search algorithm, and if the solution exists, the jump point search algorithm will always find it in its optimal form and with optimal efficiency.

The algorithm always takes finite time in reaching the solution and is driven by the edges’ weights, edges’ directions, vertices’ heuristic function, and the uniformity of the graph structure.

Academy Course – Mastering the Top 10 Graph Algorithms

If you want to improve your fundamental computer science skills, there’s nothing more effective than studying algorithms.

To help you master the most important graph algorithms, we’ve just launched the “Top 10 Algorithms” course at the Finxter Computer Science Academy. This great course from Finxter Star Creator Matija teaches you the most important graph algorithms such as BFS, DFS, A*, and Dijkstra. 

Understanding these algorithms will not only make you a better coder, but it’ll also lay a strong foundation on which you can build your whole career as a computer scientist.

Click the screenshot to find out more:

The post Jump Search Algorithm in Python – A Helpful Guide with Video appeared first on Be on the Right Side of Change.

These quotes are from  Data Visualization experts showing the benefits of Visualizing Data. This short article will discover how to visualize data into a diagram using Python.

You will educate yourself about the importance of data visualization at the start, then examine the three powerful Python libraries to employ for drawing a diagram, and finally dive into an example on financial data visualization. 

Visualization Explained 

Extracting information from the raw data is challenging, and also you can’t identify patterns or trends. Our brain makes us understand pictures much faster than numbers.  We can create graphs and diagrams to understand the data much better. We can find a story hidden under your raw data with powerful graphical tools.  You can understand what this means by an example.

Suppose you started a candy bar manufacturing unit last year and sold various energy bars for the year 2021. In H1 of the year 2021, you have introduced new products, Cinnamon Energy Bar and Berry Energy Bar.

The table below shows the products sales data for 2021 to analyze the performance.

From the data given above, you can see that Choco Energy Bar sold more than other candy bars, i.e., worth USD 1,174,905. The sales were low for Berry Energy Bar, i.e., USD 181,804.

But with this information is not enough to decide products performance. We can’t identify any trends from the given table of data. You can see the patterns or trends with a graphical tool like a histogram chart.

Image 2 shows the graph from the above data. In this graph, the x-axis is Month, and the y-axis shows the percentage of total sales. The products represent in different colors. You can see that the Green color indicates Berry Energy Bar (BEB), the Yellow color represents Cinnamon Energy Bar (CEB), and likewise. Refer to the Legend above the bars. 

You can extract the following information from this graph.

• During the months between Jan – Mar, as Choco Energy Bar (HEB) sales increase, the Apple Energy Bar (AEB) decreases. Both products are inversely related.
• The introduction of CEB in June has led HEB sales to reduce.
• Also, we can see sales of CEB reduce the other two products.
• The sales were high for HEB.
• The sales were low for  AEB.

From the graph, you can see that we can derive more information such as above, which helps to understand the data and derive patterns easier than raw data.

The above example is a hypothetical case. But in real-time, we can give reasoning behind these patterns. Now let us look at how to visualize qualitative data. 

User Requirement

We will learn about the OSEMN data science process.

• O stands for Obtain. The first process is to extract data from various sources such as Databases, the internet, or surveys.
• S stands for Scrub. Next, data must be cleaned from error and deal with missing values.
• E stands for Explore. After the data cleansing, analyze the data using statistics and visualization tools. 
• M stands for Model. Create Machine Learning models for forecasting and predicting the data.
• N Stands for INterpret. Finally, draw a meaningful conclusion based on the presented data to make decisions.

Now we have to create this Process into a Diagram that makes others understand well and brings clarity.  

It is possible to create diagrams using the powerful language Python. We will show you three techniques to draw a diagram.

Technique 1: Graphviz

In this First Technique, employ the Graphviz Python module to create Diagrams. Let’s learn about Graphviz before starting coding.

AT&T Labs Research team discovered this powerful package Graphviz. Graphviz is an open-source graphical visualization software to draw directed and undirected graphs. This software was created with the DOT language script and has filename extension “gv”.

Graphviz has different polygon-based shapes, such as box, polygon, ellipse, etc.  Also, numerous Arrow shapes are available to draw a diagram. You can save the graphs in the following formats: BMP, JPEG, JSON, PDF, PNG. The industry, such as Software engineering, Database, web design, machine learning, and others, use the Graphiz software widely.

Now let’s begin coding.

Firstly install the Graphviz module with the following command in the terminal :

brew install graphviz
pip install graphviz

After installing Graphviz, you have to import the Graphviz module as below.

import graphviz

You can start drawing a diagram by creating a Digraph object. The Digraph is a directed graph that stores node and edges, and the source code is in the DoT programming language.

graph = graphviz.Digraph('OSEMN', comment='Data Science Process - OSEMN FrameWork')

The above code creates an ‘OSEMN’ graph using a Diagraph object. The comment displays when you run digraph source code.

Next, create a circle shape node to show data science process headings.

graph.node('o', 'OBTAIN',height="3",fontsize="35pt")
graph.node('s', 'SCRUB',height="3",fontsize="35pt")
graph.node('e', 'EXPLORE',height="3",fontsize="35pt")
graph.node('m', 'MODEL',height="3",fontsize="35pt")
graph.node('i', 'INTERPRET',height="3",fontsize="35pt")

The above code adds the node to the graph object using the node() method. 

The ‘o’ node label is for ‘Obtain’ with a height of 1.5 cm and a font size of 35 points. 

The next node is ‘s’ with the label ‘Scrub’ with a height of 1.5 cm and font size of 35 points.  Node for ‘e,’ ‘m’, and ‘i’ are labeled. There are attributes such as fillcolor, fontname, fontsize, image, imagepos, imagescale, and more.

Now create nodes for a short explanation of the data process headings.

graph.node('1', 'Extract Data from Database,Internet & Survey', fontsize="30pt",height="2")
graph.node('2', 'Clean the Data from error & handle missing data',fontsize="30pt",height="2")
graph.node('3', 'Analyse the Data using descriptive statistics and data visualizations',fontsize="30pt", height="2")
graph.node('4', 'Construct ML Models to predict and forecast',fontsize="30pt",height="2")
graph.node('5', 'Draw Meaningful conclution from the presented data',fontsize="30pt",height="2")

Create a node in numbers for each explanation. “1” is for ‘Extract Data from Database, Internet & Survey.’ “2” is for ‘Clean the Data from error & handle missing data’ and so on. Also, you can set different attributes as well.

After this, you need to connect the nodes Headings and Explanation. The edge method can connect between the nodes.

graph.edge('o','s',constraint = 'false', arrowhead = 'diamond', arrowsize="2")
graph.edge('s','e',constraint = 'false', arrowhead = 'diamond',arrowsize="2")
graph.edge('e','m',constraint = 'false', arrowhead = 'diamond',arrowsize="2")
graph.edge('m','i',constraint = 'false', arrowhead = 'diamond',arrowsize="2")

First, connect the OSEM process through the edge method. Connect the edge between o and s, then s and e, and so on.

The constraint =‘false’ attribute makes the node connected in the horizontal direction. The default direction of the edge is vertical.

The arrowhead’s shape is diamond, and its size is 2, as shown above in the code. There are different arrowhead shapes such as box, crow, curve, dot, inv, and more.

Attributes for edges are also available like arrowhead, arrowsize, arrowtail, color, decorate, and more.

graph.edges(['o1','s2','e3','m4','i5'])

The code above connects edges o and 1, s and 2. We use the edges method to join more nodes.  

print(graph.source)

This command prints the source code in DOT language. Refer to image 4.

graph.render(directory='doctest-output', view=True)

Code will save the diagram output in the directory ‘’doctest-output‘. The view=True attribute automatically opens the pdf file without searching for it. Refer to image 3.

Output:

Technique 2: Pillow ImageDraw

Technique 2 employs ImageDraw from the pillow module to draw a diagram. Let’s learn about Pillow.

Alex Clark and Contributors are the ones who produce the Pillow Library from the PIL module. The PIL is the Python Imaging Library for creating and manipulating images produced by Fredrik Lundh and Contributors. The programmer uses PIL for advanced image processing such as editing images, creating new images, creating thumbnails, etc. But the PIL was discontinued in 2011 and replaced Pillow for future usage. It supports all the image formats such as BMP, PNG, JPEG, and TIFF.

ImageDraw module generates 2D Graphics from the image.  It creates an object to draw in a given image. In other words, it makes a drawing board and inserts an image into the board for further editing.

ImageDraw has drawing methods such as 

• ImageDraw.rectangle – to draw a rectangle on the image
• ImageDraw.ellipse – to draw a circle on image
• ImageDraw.line – to draw a line on the image

Now let’s begin coding.

Install the pillow library as below:

pip install Pillow

Next, import the pillow library of Image, ImageDraw and ImageFont modules.

from PIL import Image, ImageDraw, ImageFont

Before moving on, let’s examine the syntax for the ImageDraw module.

PIL.ImageDraw.Draw(im, mode=None)

• PIL is the Pillow Module.
• ImageDraw.Draw method is employed to draw an object in the image.
• im is the image to edit.
• mode is for the RGB color of the image. 

After Import, you have to create a new image for drawing the OSEMN diagram.

im = Image.new('RGB', (1750, 520), (255, 255, 255))

The Image. new creates a new image with 1750 x 520 pixels and white color. The RGB color for white is 255, 255,255 and stored in the variable im.

Employ ImageDraw method as below:

draw = ImageDraw.Draw(im)

Draw five ovals shape for the data process headings.

draw.ellipse((50, 120, 300, 200), fill=(255, 255, 255), outline=(0, 0, 0))
draw.ellipse((400, 120, 650, 200), fill=(255, 255, 255), outline=(0, 0, 0))
draw.ellipse((750, 120, 1000, 200), fill=(255, 255, 255), outline=(0, 0, 0))
draw.ellipse((1100, 120, 1350, 200), fill=(255, 255, 255), outline=(0, 0, 0))
draw.ellipse((1450, 120, 1700, 200), fill=(255, 255, 255), outline=(0, 0, 0))

draw.ellipse method is to draw a circle object.

The four numbers in a tuple are the location of the object. The x0 (50) is the starting point of the location in a horizontal direction; then, the ending point is x1(300). The y0 (120) is the starting point of the location in a vertical direction, and then the ending point is y1(200). Refer to the image for a clear understanding.

The attribute ‘fill’ fills the color inside the object, i.e., the circle here is white. The value is to be given by RGB code.

The outline is the color for the object’s border, which is black, and the RGB of it is 0,0,0.

Similarly, you have to do for the other circle object with respective locations as shown in through code above.

Next, we need arrows to show the OSEM process in sequence. In the ImageDraw module, there is no arrow Shape object created like a rectangle or circle. So ImageDraw.line method is employed for drawing arrows.

draw.line((301, 160, 399, 160), fill=(0, 0, 0), width=2) # Code 1
draw.line((393, 150, 399, 160), fill=(0, 0, 0), width=2) # Code 2
draw.line((395, 170, 401, 160), fill=(0, 0, 0), width=2) # Code 3
draw.line((651, 160, 749, 160), fill=(0, 0, 0), width=2)
draw.line((743, 150, 749, 160), fill=(0, 0, 0), width=2)
draw.line((745, 170, 751, 160), fill=(0, 0, 0), width=2)
draw.line((1001, 160, 1099, 160), fill=(0, 0, 0), width=2)
draw.line((1093, 150, 1099, 160), fill=(0, 0, 0), width=2)
draw.line((1095, 170, 1101, 160), fill=(0, 0, 0), width=2)
draw.line((1351, 160, 1449, 160), fill=(0, 0, 0), width=2)
draw.line((1443, 150, 1449, 160), fill=(0, 0, 0), width=2)
draw.line((1445, 170, 1451, 160), fill=(0, 0, 0), width=2)

To create a single arrow you must write three lines of code as shown above. 

• The first code is for a straight line. 
• The second code is for the cross line below. 
• The third code is for the cross line above. 

Do these steps for other arrows too.

Create text for each box with ImageDraw.Draw.text method. But font type attribute is mandatory in this method. Identify the path where is your desired font in the system.

size = ImageFont.truetype("/Users/mohamedthoufeeq/Downloads/bebas-neue/BebasNeue-Regular.ttf",35)

Specify the font path and size in ImageFont.truetype methods, then store it into variable size.

draw.text((130, 140),"OBTAIN",(0, 0, 0),font=size)
draw.text((480, 140),"SCRUB",(0, 0, 0),font=size)
draw.text((830, 140),"EXPLORE",(0, 0, 0),font=size)
draw.text((1180, 140),"MODEL",(0, 0, 0),font=size)
draw.text((1520, 140),"INTERPRET",(0, 0, 0),font=size)

From the text method, You can specify the location of the text of Data Process Heading with x and y coordinates as shown in the code.

Next, we mention the headings with double-quote marks. The color of the font is black with RGB code 0,0,0. Mention the variable size in the font attribute. 

Likewise, you can create a diagram for explanation of the headings as per the code below: 

draw.text((1520, 140),"INTERPRET",(0, 0, 0),font=size)
draw.line((175, 200, 175, 300), fill=(0, 0, 0), width=5)
draw.line((525, 200, 525, 300), fill=(0, 0, 0), width=5)
draw.line((875, 200, 875, 300), fill=(0, 0, 0), width=5)
draw.line((1225, 200, 1225, 300), fill=(0, 0, 0), width=5)
draw.line((1575, 200, 1575, 300), fill=(0, 0, 0), width=5)
draw.rectangle((50, 300, 300, 400), fill=(255, 255, 255), outline=(0, 0, 0))
draw.rectangle((400, 300, 650, 400), fill=(255, 255, 255), outline=(0, 0, 0))
draw.rectangle((750, 300, 1000, 400), fill=(255, 255, 255), outline=(0, 0, 0))
draw.rectangle((1100, 300, 1350, 400), fill=(255, 255, 255), outline=(0, 0, 0))
draw.rectangle((1450, 300, 1700, 400), fill=(255, 255, 255), outline=(0, 0, 0))




esize = ImageFont.truetype("/Users/mohamedthoufeeq/Downloads/bebas-neue/BebasNeue-Regular.ttf",20)
draw.text((60, 320),"Extract Data from Database,\nInternet & Survey",(0, 0, 0),font=esize)
draw.text((410, 320),"Clean the Data from error\n& handle missing data",(0, 0, 0),font=esize)
draw.text((790, 320),"Analyse the Data using\ndescriptive statistics\nand data visualizations",(0, 0, 0),font=esize)
draw.text((1110, 320),"Construct ML Models to\n predict and forecast",(0, 0, 0),font=esize)
draw.text((1460, 320),"Draw Meaningful conclusion\n from the presented data",(0, 0, 0),font=esize)

The explanations of each heading are in a rectangle-shaped diagram. Refer to above code.

Finally, save the output in a jpg file with 110% quality through the save function. Refer to the code below:

im.save('pillow_imagedraw.jpg', quality=110)

Output:

Technique 3:  Turtle

Turtle is another technique employed to draw a diagram. Let’s learn about it.

The turtle module is most suitable for beginners to Python.  This Python library enables users to create shapes, diagrams, and pictures from virtual drawing boards.

Info: The Turtle was initially developed with Logo programming Language by Wally Feurzeig, Seymour Papert, and Cynthia Solomon. This popular graphical package was designed for kids to introduce programming. It gives a great resource to learn python programming. Don’t get discouraged! Adults can use turtle also. As we mentioned above, the module helps new programmers to get a feel for the python programming language in a fun and interactive way. 

On the virtual drawing board, you find a small triangle-shaped symbol which is a pen for drawing, and this pen is called Turtle.

Let’s start coding:

First, install the Turtle module.

pip install PythonTurtle 

Import the turtle module as below:

import turtle

The following code opens a new Python turtle window with a turtle icon:

turtle.Screen()

Set the turtle speed of 5 seconds and pen size of  1 pixel.

turtle.speed(5)
turtle.pensize(1)

Use the virtual pen to draw a diagram on the Python turtle window.

Before moving further to code, let us understand the turtle’s position.

The screen has four divisions with x and y coordinates. The current location of the turtle is in (0,0) position. So to move to the top left, the coordinates have to be negative number x and positive number y, as shown in DIV 2. Refer to image 6 for positioning the turtle.

Initially, we will show you how to draw an oval, arrow, line, and rectangle shape, then show how to insert headings and explanations into the shapes.

Draw oval shapes for data process heading with code below:

pos = -300   # Code A
for n in range(5):  # Code B
    turtle.up() # Code C
    turtle.goto(pos,100) # Code D
    turtle.down() # Code E
    turtle.seth(-45) # Code F
    turtle.circle(50,90) # Code G
    turtle.circle(25,90) # Code H
    turtle.circle(50,90) # Code I
    turtle.circle(25,90) # Code J
    turtle.up() # Code K
    pos = pos + 120 # Code L

• Code A: Set the position as -300 for x coordinate and store it with variable pos.
• Code B:  Create for loop to draw five oval-shaped diagrams.
• Code C:  The virtual pen was down when we created the window.  So raise the pen up using up() function.
• Code D: Make the turtle(pen) move to position -300x and 100y to top left using the goto() function on the window.
• Code E:  Put the virtual pen on the window with the down() function.
• Code F:  Set the direction of the turtle(pen) to -45 angle using seth() or setheading() function.
• Code G,H,I,J:  Draw oval shape diagram using circle() function with radius 50, 25 and extent 90. With circle radius 50 and extent 90  draws a half-circle.
• Code K: Raise the virtual pen up to  stop drawing
• Code L: Add position by 120 x for drawing next oval shape diagram.

After this draw arrow shape connecting between the oval shape.

pos =-224 # Code M
for n in range(4): # Code N
    turtle.pensize(2) # Code O
    turtle.up() # Code P
    turtle.goto(pos,120) # Code Q
    turtle.down() # Code R
    turtle.seth(-45)  # Code S
    turtle.left(45) # Code T
    turtle.forward(41) # Code U
    turtle.left(150) # Code V
    turtle.forward(10) # Code W
    turtle.right(180) # Code X
    turtle.forward(10) # Code Y
    turtle.left(250) # Code Z
    turtle.forward(10) # Code AA
    turtle.up() # Code  BB
    pos = pos+120 # Code CC

• Code M:  Set the position as -224 for x coordinate and store it with variable pos for drawing arrows.
• Code N:  Create for loop to draw four arrows.
• Code O:  Increase the pen size to 2.
• Code P:  Raise the pen up.
• Code Q: Move the pen to the position at -224 x and 120 y coordinates.
• Code R: Lower the pen down.
• Code S: Set the pen direction to a -45 degree angle.
• Code T: Rotate the pen leftwards to a 45-degree angle anti-clockwise.
• Code U: Move the pen forward with a distance of 41 x from the present position using the forward function. The position is -224 + 41  =  -183 x. It draws a straight line from the middle of the oval shape.
• Code V: Rotate the pen to the left with a 150-degree angle for drawing above the cross line for the arrow.
• Code W: Move the pen forward with a distance of 10x from the present position. 
• Code X: Rotate the pen to the right of 180 degrees clockwise to return to the current position.
• Code Y: Move the pen forward with a distance of 10x from the present position.
• Code Z:  Rotate the pen to the left with 250 degrees for drawing below the cross line for the arrow.
• Code AA: Move the pen forward with a distance of 10x from the present position.
• Code BB: Raise the pen up.
• Code CC: Add the position by 120 to draw the next arrow.

Now with the following code, draw five straight lines from the oval.

pos = -265
for n in range(5):
    turtle.pensize(2)
    turtle.up()
    turtle.goto(pos,85)
    turtle.down()
    turtle.seth(220)
    turtle.left(50)
    turtle.forward(30)
    pos = pos+120

Draw 5 Rectangle shape diagrams for explanation of Headings with below code:

pos = -220 # Code DD
for n in range(5): # Code EE
    turtle.pensize(1) # Code FF
    turtle.penup() # Code GG
    turtle.goto(pos,55) # Code HH
    turtle.pendown() # Code II
    turtle.color('black') # Code JJ
    # draw sides for the rectangle
    for side in range(2): # Code KK
        turtle.forward(50)# Code LL
        turtle.right(90) # Code MM
        turtle.forward(100)# Code NN
        turtle.right(90) # Code OO
    pos = pos+120   # Code PP

• Code HH: Move the pen downwards to draw a rectangle.
• Code LL to Code OO: Draws two sides of the rectangle.
• Code KK: Create for loops to draw four sides of the rectangle.

Next let us write the text for Headings and explanation with below code:

turtle.up()
turtle.goto(-290,100)
turtle.write("OBTAIN", font=("Verdana",12, "normal"))
turtle.up()
turtle.goto(-170,100)
turtle.write("SCRUB", font=("Verdana",12, "normal"))
turtle.up()
turtle.goto(-50,100)
turtle.write("EXPLORE", font=("Verdana",12, "normal"))
turtle.up()
turtle.goto(70,100)
turtle.write("MODEL", font=("Verdana",12, "normal"))
turtle.up()
turtle.goto(190,100)
turtle.write("INTERPRET", font=("Verdana",12, "normal"))
turtle.up()
turtle.goto(-305,20)
turtle.write("Extract Data from\n Database,\nInternet & Survey", font=("Verdana",8, "normal"))
turtle.up()
turtle.goto(-195,20)
turtle.write("Clean the Data from \nerror & handle \nmissing data", font=("Verdana",8, "normal"))
turtle.up()
turtle.goto(-75,20)
turtle.write("Analyse the Data using\ndescriptive statistics\nand data visualizations", font=("Verdana",8, "normal"))
turtle.up()
turtle.goto(45,20)
turtle.write("Construct ML Models to\n predict and forecast", font=("Verdana",8, "normal"))
turtle.up()
turtle.goto(165,20)
turtle.write("Draw Meaningful \nconclusion from the \npresented data", font=("Verdana",8, "normal"))
turtle.up()

Hide the turtle symbol or pen with the following command.

turtle.ht()

Use turtle.write a function to write the text in the desired locations with the pen.

You are not required to lower the pen because turtle.write makes pen down for writing text.

Here write the Data process heading and Explanation.

Finally, see the output:

Bonus: Visualize Financial Data of Apple.com

Let us draw the diagram for Financial Statement for Apple during the Fourth Quarter of 2021

The above Financial Statements make it harder for you to grasp the essential indicators of the company. So we will draw diagrams to understand the company’s performance more effortlessly.

Here we will use the Graphviz Python library to draw diagrams.

import graphviz
graph = graphviz.Digraph("Apple's Income Statement Diagram", comment='Diagram for Analysis')  
graph.node('ns', 'Net SALES:US$83,360',fontsize="20pt")
graph.node('p', 'Product:US$65,083',fontsize="20pt")
graph.node('ip', 'Iphone:US$38,868',fontsize="5pt")
graph.node('mac', 'Mac:US$9,178',fontsize="5pt")
graph.node('ipad', 'iPad:US$8,252',fontsize="5pt")
graph.node('wr', 'Wearables, Home and Accessories:US$8,785',fontsize="5pt")
graph.node('s', 'Services:US$18,277',fontsize="20pt")
graph.node('pc', 'Cost of Sales:US$42,790',fontsize="10pt")
graph.node('sc', 'Cost of Sales:US$5,396',fontsize="10pt")
graph.node('gm', 'Gross Margin:US$35,174',fontsize="20pt")
graph.node('rd', 'Research and development:US$5,772',fontsize="10pt")
graph.node('sga', 'Selling, general and administrative:US$5,616',fontsize="10pt")
graph.node('op', 'Operating income:US$23,786',fontsize="10pt")
graph.node('oe', 'Other Expenses:US$538',fontsize="10pt")
graph.node('i', 'Income before provision for income taxes:US$23,248',fontsize="10pt")
graph.node('it', 'Provision for income taxes:US$2,697',fontsize="10pt")
graph.node('np', 'Net income:US$20,551',fontsize="10pt")
graph.edge('ns','p')
graph.edge('p','ip')
graph.edge('p','mac')
graph.edge('p','ipad')
graph.edge('p','wr')
graph.edge('ns','s')
graph.edge('p','pc')
graph.edge('s','sc')
graph.edge('pc','gm')
graph.edge('sc','gm')
graph.edge('gm','rd')
graph.edge('gm','sga')
graph.edge('rd','op')
graph.edge('sga','op')
graph.edge('op','oe')
graph.edge('oe','i')
graph.edge('i','it')
graph.edge('it','np')
print(graph.source)
graph.render(directory='doctest-output', view=True)

Output:

Summary

Human brains extrapolate pictures more quickly than words and numbers.

Number and words have information buried. We can’t discover the patterns interpret the data, and draw conclusions by just reading the numbers and words.

With visual representation tools such as diagrams, graphs, etc., we can understand the data quickly and clearly. You have learned in this article how to draw a diagram with powerful python libraries.

These libraries are Graphviz, ImageDraw, and turtle.

For drawing complex diagrams without any images, Graphviz is a better choice. If you need to edit images and use them in a diagram, the ImageDraw library is better. As we know, The Software Scientist created the turtle for kids to learn python programming language.

Beginners can use Turtle for educational purposes and also for creating animated stories. Story with animated diagrams and words are more potent for the reader to understand well.

Hope this article helped you and answered your query. Give your feedback at thoufeeq87.mtr@gmail.com.

Have a great coding!

The post How to Visualize Data in Python — Graphviz, ImageDraw, and Turtle appeared first on Be on the Right Side of Change.

The slides can be found as a Gif here:

Okay, so let’s dive into the algorithm motivation, explanation, and Python code next!

What is the A* Search algorithm?

A very interesting graph traversal algorithm we will learn about next is the A* algorithm, constructed by the authors Peter Hart, Nils Nilsson, and Bertram Raphael. The A* algorithm belongs to the family of best-first search algorithms and is an extension to the Dijkstra algorithm in the sense that it takes into account both the weights of the graph edges and the heuristic functions of the connected vertices. It is suitable for application in various domains of computer science because of its three key properties: completeness, optimality, and optimal efficiency.

Before we’ll dive into the algorithm and the Python implementation, let’s first skim over some related graph tutorials you may enjoy and that may help your understanding!

Related Graph Tutorials

This algorithm is part of our graph algorithm tutorials:

• Breadth-First Search (BFS) Algorithm in Python
• Python Depth-First Search (DFS) Algorithm
• Iterative Deepening Depth-First Search (DFS) Algorithm in Python
• Python Best-First Search Algorithm
• Python Dijkstra Algorithm
• Python A* Algorithm
• Jump Search Algorithm in Python
• Python Backtracking
• Python Beam Search Algorithm

Each of these tutorial links opens in a new browser tab.

What’s the Purpose of A* Search?

Common applications of the A* algorithm are in domains of optimal pathfinding for various distribution networks. Some of the example usages are power-aware routing of messages in large communication networks, point-to-point path planning tasks, or finding the shortest path in games and web-based maps.

How Does A* Search Work?

The A* algorithm assigns a heuristic function to all the vertices. The heuristic function approximates a cost of reaching the goal vertex from a visited vertex in terms of e.g. (commonly Euclidean) distance or time. The total cost of any vertex is calculated as a sum of weights of the connecting edges between the starting vertex and the visited vertex, and the heuristic function of the visited vertex.

When visited, the cost of each unexplored, adjoining vertex is updated according to the weights associated with the connecting edges. After being visited, each adjoining vertex is added to the priority queue.

In each following iteration, the vertex with the lowest cost is taken out of the priority queue and its processing starts by visiting and conditionally updating all its adjoining (visited), non-explored vertices. The update operation implies two steps: lowering the cost of the visited node and associating with the processed (explored, the terms are used interchangeably) vertex for later reconstruction of the shortest path. Finally, the processed vertex is marked as explored and does not participate in any further cost calculations.

The update condition is determined by comparing each visited vertex’s current cost with its new,  potentially lower cost. Its new cost is calculated in the following way: current cost of the explored vertex – its heuristic function + the weight of the adjoining edge (the edge weight between the vertex being explored and the visited vertex) + the heuristic function of the visited vertex.

If the current cost of the visited vertex is still lower than the potential new cost, the vertex cost will not be updated. Otherwise, the visited vertex will be updated to the new cost (its cost will decrease) and form an association with the explored vertex. Vertex cost reduction is also referred to as a relaxation procedure. After visiting and conditionally updating all the adjoining, non-explored vertices, the vertex being processed will be marked as explored and will not participate in any further algorithm calculations. The described process continues until there are no unexplored vertices left in the priority queue.

When the algorithm ends, all vertices are assigned with the lowest possible costs, and the traversal algorithm yields the shortest possible path between the starting and target vertices. For comparison with the previously described Dijkstra’s algorithm, the A* algorithm is superior given that it does not only follow the shortest path available (pure greedy approach) but is also guided by the notion of a right direction, contained in the heuristic function of each vertex.

What Are the Properties of A* Search?

The A* algorithm uses the exact information represented by the edge’s weights and a heuristic function for distance estimation between the goal vertex and other connected vertices in a graph. As the initial costs for all the non-starting vertices are set to infinity, the algorithm successively decreases vertices costs until they reach their minimum.

This behavior leads to a property of being optimal: minimal costs assigned to vertices enable the A* algorithm to always find the shortest path between the starting vertex and any other vertex in the graph. As the shortest paths always start from the starting vertex, the algorithm is attributed as the “single-source” algorithm.

Besides being optimal, the algorithm is also complete, i.e. it will always take a finite time to find a solution.

The third important property is the optimal efficiency, reflected in the fact that vertices positioned further from the target vertex may not be explored at all, as their heuristic function distinguishes and delays the exploration of such vertices among those with equally weighted paths.

The heuristic functions used in the A* algorithm also have two notable properties: admissibility and consistency.

• Admissibility implies that the heuristic function cost estimation is at most as high as the lowest possible cost from the current point in a path towards the target vertex.
• The consistent or monotone heuristic function is constrained by a requirement that its cost estimation is always less than or equal to the estimated distance from any adjoining, successor vertex to the goal, plus the cost of reaching that vertex.

How is A* Search Implemented in Python?

The implementation of the A* algorithm is achieved by the function a_star() and a modification of the underlying class Graph.

The a_star() function takes three parameters:

• The graph parameter takes an initialized Graph object (see the blog on the breadth-first search algorithm, the section on graphs).
• The start_vertex parameter takes the starting vertex, which we choose freely (remember, a graph is not a tree, there is no absolute root).
• The target parameter is the entity we want to find in the graph, enclosed in a vertex.

For a better understanding of the algorithm and its implementation, each step is precisely described in the code below.

There have been some further upgrades on the Graph class, so its entire listing follows:

class Graph:

    def __init__(self, directed=False):
        self._outgoing = {}
        # If the graph is undirected, 'self._outgoing'
        # is the universal storage.
        self._incoming = {} if directed else self._outgoing

    # If the graph is directed, the 'self._incoming' 
    # dictionary differs from the 'self._outgoing'.
    def is_directed(self):
        return self._incoming is not self._outgoing

    # The function returns a generator of incoming
    # or outgoing (default) edges of a vertex.
    def adjacent_edges(self, vertex, outgoing=True):
        # References the corresponding outer dictionary
        # (dictionary of dictionaries)
        adj_edges = self._outgoing if outgoing else self._incoming

        # Access each of the edges for this endpoint vertex.
        for edge in adj_edges[vertex].values():
            yield edge

    def add_vertex(self, entity=None, h=None, cost=None):
        # Constructs a new vertex from the entity.
        vertex = self.Vertex(entity, h, cost)
        # The vertex becomes a key in the outer dictionary,
        # but the value is an internal dictionary (as we model
        # both dimensions for each edge: origin and destination).
        # e.g. {vertex_1a:{vertex_b:edge_a_b}, vertex_b:{vertex_c:edge_b_c}}.
        self._outgoing[vertex] = {}
        if self.is_directed():
            self._incoming[vertex] = {}

    def add_edge(self, origin, destination, weight=None):
        # Constructs a new edge from the vertices.
        edge = self.Edge(origin, destination, weight)
        # Adds the edge to the dictionary (dictionaries are
        # the same if the graph is undirected). The outer key
        # represents the origin, i.e. the component 'a' of
        # the edge-defining pair (a, b). The inner key stands
        # for the component 'b' of the edge-defining pair (a, b).
        self._outgoing[origin][destination] = edge
        # Even if the graph is undirected, each edge has to
        # be added twice, i.e. once for each of its endpoints.
        self._incoming[destination][origin] = edge

    def vertices(self):
        return self._outgoing.keys()

    def edges(self):
        # All the edges are collected into a set.
        result = set()
        for inner_dict in self._outgoing.values():
            result.update(inner_dict.values())
        return result

    class Vertex:
        __slots__ = '_entity', '_h', '_cost'

        def __init__(self, entity, h=None, cost=None):
            self.entity = entity
            self.h = h
            self.cost = cost

        # The real-world entity is represented by the Vertex object.
        @property
        def entity(self):
            return self._entity

        @entity.setter
        def entity(self, entity):
            self._entity = entity

        # The real-world entity has a heuristic value of 'h'.
        @property
        def h(self):
            return self._h

        @h.setter
        def h(self, h):
            self._h = h

        # The real-world entity has a cost of 'cost'.
        @property
        def cost(self):
            return self._cost

        @cost.setter
        def cost(self, cost):
            self._cost = cost

        # We have to implement __hash__ to use the object as a dictionary key.
        def __hash__(self):
            return hash(id(self))

        def __lt__(self, other):
            if self.cost is None:
                return False
            elif other.cost is None:
                return True
            else:
                return self.cost < other.cost

    class Edge:
        __slots__ = '_origin', '_destination', '_weight'

        def __init__(self, origin, destination, weight=None):
            self._origin = origin
            self._destination = destination
            self.weight = weight

        def endpoints(self):
            return self._origin, self._destination

        # Returns the other component of the edge-defining pair (a, b)
        # for a given component a or b, respectively.
        def opposite(self, vertex):
            return self._destination if self._origin is vertex \
                else self._origin

        # Returns the weight of the edge.
        @property
        def weight(self):
            return self._weight

        # Sets the weight of the edge
        @weight.setter
        def weight(self, weight):
            self._weight = weight

        def __hash__(self):
            return hash((self._origin, self._destination))

The most significant differences to the previous version of the Graph class are highlighted in the code.

With these changes in place, implementation of the core function, a_star() is:

from graph import Graph
from queue import PriorityQueue


def a_star(graph, start_vertex, target):
    # Create the priority queue for open vertices.
    vertices_pq = PriorityQueue()

    start_vertex.cost = start_vertex.h

    # Adds the start vertex to the priority queue.
    print(f'Visiting/queueing vertex {start_vertex.entity}')
    vertices_pq.put(start_vertex)
    print('Prioritized vertices (v, cost(v)):',
          *((vert.entity, vert.cost) for vert in vertices_pq.queue), end=2 * '\n')

    # The starting vertex is visited first and has no leading edges.
    # If we did not put it into 'visited' in the first iteration,
    # it would end up in 'visited' during the second iteration, pointed to
    # by one of its children vertices as a previously unvisited vertex.
    visited[start_vertex] = None

    # Loops until the priority list gets empty.
    while not vertices_pq.empty():
        # Gets the vertex with the lowest cost.
        vertex = vertices_pq.get()
        # If the vertex being explored is a target vertex, ends the algorithm.
        print(f'Exploring vertex {vertex.entity}')
        if vertex.entity == target:
            return vertex
        # Examines each non-visited adjoining edge/vertex.
        for edge in graph.adjacent_edges(vertex):
            # Gets the second endpoint.
            v_2nd_endpoint = edge.opposite(vertex)

            # Skips the explored vertices.
            if v_2nd_endpoint in explored:
                continue

            # Checks if the endpoint has a weight and is the weight the cheapest one.
            if v_2nd_endpoint.cost is None \
                    or vertex.cost - vertex.h + edge.weight < v_2nd_endpoint.cost - v_2nd_endpoint.h:
                # Adds the second endpoint to 'visited' and maps
                # the leading edge for the search path reconstruction.
                v_2nd_endpoint.cost = vertex.cost - vertex.h + edge.weight + v_2nd_endpoint.h
                # Prevents reinsertion to the priority queue. The
                # endpoint distance value will be updated.
                if v_2nd_endpoint not in visited:
                    print(f'Visiting/queueing vertex {v_2nd_endpoint.entity}')
                    vertices_pq.put(v_2nd_endpoint)
                # Forces the priority queue to recalculate in case of an
                # inner vertex update resulting with the highest priority
                vertices_pq.put(vertices_pq.get())
                # Replaces the previous vertex' ancestor with a cheaper one.
                visited[v_2nd_endpoint] = edge
        print('Prioritized vertices (v, cost(v)):',
              *((vert.entity, vert.cost) for vert in vertices_pq.queue), end=2 * '\n')
        # The vertex is used for update and put aside.
        explored.append(vertex)
    return None

Before we can test the algorithm, we have to initialize a graph and build it by adding vertices and edges to it:

# Initializes an empty graph (object).
g = Graph()

# Loads the graph with the first seven vertices.
g.add_vertex(0, 4)
g.add_vertex(1, 4)
g.add_vertex(2, 2)
g.add_vertex(3, 7)
g.add_vertex(4, 5)
g.add_vertex(5, 10)
g.add_vertex(6, 0)

# Constructs the 'vertices' dictionary for a more
# convenient access during the graph construction.
vertices = {k.entity: k for k in g.vertices()}

# Constructs an arbitrary graph from
# the existing vertices and edges.
g.add_edge(vertices[0], vertices[1], 4)
g.add_edge(vertices[0], vertices[2], 2)
g.add_edge(vertices[2], vertices[4], 1)
g.add_edge(vertices[4], vertices[3], 3)
g.add_edge(vertices[3], vertices[5], 2)
g.add_edge(vertices[0], vertices[5], 4)
g.add_edge(vertices[2], vertices[6], 5)

# Initializes the search path and a dictionary of visited vertices.
path = []
explored = []
visited = {}

Now that we have prepared everything, we can test a_star() and see how it works. Here is the part of the code that runs the algorithm, constructs the search path (if there is one), and shows in a step-by-step manner how it proceeds through the graph:

# Starts the search.
result = a_star(g, vertices[5], 6)

# If the entity is found...
if result is not None:
    # The search path ends with the found vertex (entity).
    # Each vertex is a container for its real-world entity.
    path_vertex = result
    # The entity is added to the 'path'.
    path.append(path_vertex.entity)
    # Constructs the rest of the search path (if it exists)...
    while True:
        # Gets a discovery edge leading to the vertex.
        path_edge = visited.get(path_vertex)
        # If the path vertex is the root, it has no discovery edge...
        if path_edge is None:
            break
        # Otherwise, gets the second (parent vertex) endpoint.
        path_vertex = path_edge.opposite(path_vertex)
        # The entity is added to the 'path'.
        path.append(path_vertex.entity)
    print('Search path found:', end=' ')
    # The path is reversed and starts with the root vertex.
    print(*reversed(path), sep=' -> ')
# Otherwise...
else:
    print('\nEntity is not found')

The test run gave us the output:

Visiting/queueing vertex 5
Prioritized vertices (v, cost(v)): (5, 10)

Exploring vertex 5
Visiting/queueing vertex 3
Visiting/queueing vertex 0
Prioritized vertices (v, cost(v)): (0, 8) (3, 9)

Exploring vertex 0
Visiting/queueing vertex 1
Visiting/queueing vertex 2
Prioritized vertices (v, cost(v)): (2, 8) (1, 12) (3, 9)

Exploring vertex 2
Visiting/queueing vertex 4
Visiting/queueing vertex 6
Prioritized vertices (v, cost(v)): (3, 9) (6, 11) (1, 12) (4, 12)

Exploring vertex 3
Prioritized vertices (v, cost(v)): (4, 10) (1, 12) (6, 11)

Exploring vertex 4
Prioritized vertices (v, cost(v)): (6, 11) (1, 12)

Exploring vertex 6
Search path found: 5 -> 0 -> 2 -> 6

Based on the output, we can see that the search started from vertex 5 and that the a_star() has found the entity vertex 6. The entire search path is also displayed, and we should note that the search path will always be the shortest one: 5 -> 0 -> 2 -> 6. However, a modification of just one heuristic function value, effectively moving the vertex further away from the goal might lead to a different solution, as we will demonstrate with the next example. With that in mind, let us tweak the weight on one of our edges:

# Loads the graph with the first seven vertices.
g.add_vertex(0, 6)
g.add_vertex(1, 4)
g.add_vertex(2, 2)
g.add_vertex(3, 7)
g.add_vertex(4, 5)
g.add_vertex(5, 10)
g.add_vertex(6, 0)

The re-run gave us the output:

Visiting/queueing vertex 5
Prioritized vertices (v, cost(v)): (5, 10)

Exploring vertex 5
Visiting/queueing vertex 3
Visiting/queueing vertex 0
Prioritized vertices (v, cost(v)): (3, 9) (0, 10)

Exploring vertex 3
Visiting/queueing vertex 4
Prioritized vertices (v, cost(v)): (4, 10) (0, 10)

Exploring vertex 4
Visiting/queueing vertex 2
Prioritized vertices (v, cost(v)): (2, 8) (0, 10)

Exploring vertex 2
Visiting/queueing vertex 6
Prioritized vertices (v, cost(v)): (0, 10) (6, 11)

Exploring vertex 0
Visiting/queueing vertex 1
Prioritized vertices (v, cost(v)): (6, 11) (1, 12)

Exploring vertex 6
Search path found: 5 -> 3 -> 4 -> 2 -> 6

After a re-run, we got a different solution only by changing one of our heuristic function values. Our simple demonstration just proved how important the heuristic function value, i.e. the quality distance estimation is.

Efficiency Analysis

The algorithm’s worst-case time complexity depends on the heuristic function. In the worst case, i.e. of unbounded search space, the time complexity degenerates to an exponential function O(b^d), where b is the branching factor (the average number of unexplored, adjoining vertices) and d stands for the depth of the shortest path to a solution.

The space complexity of the A* algorithm is O(v+e) in terms of vertices and edges since it keeps all generated vertices and edges in memory. Expressed in terms of a branching factor and the solution depth, the space complexity of the A* algorithm is O(b^d). High memory requirement renders the A* algorithm less suitable as the size and density of a graph increase, which is considered to be its significant disadvantage.

The A* algorithm is optimal, as it will always yield an optimal, shortest possible search path. Furthermore, the A* algorithm will always find a solution if there is one, so it is also complete. Finally, A* is optimally efficient, meaning it will explore as few vertices as possible.

Conclusion

In this article, we learned about the A* search algorithm.

• First, we explained what the A* algorithm is.
• Second, we took a look at what are its common purposes and applications.
• Third, we went through an explanation of how the algorithm works.
• Fourth, we examined the algorithm’s main properties.
• Fifth, we went through the implementation of the algorithm, which is based on the Graph abstract data structure (Graph class implementation is given above). We also tested the algorithm by calling its main function, a_star(), and analyzed its steps of execution for two slightly different edge weight scenarios.
• Sixth, we analyzed the algorithm efficiency.

In the end, we concluded that the algorithm efficiency is optimal, and if the solution exists, the A* algorithm will always find it in its optimal form and with optimal efficiency. The algorithm always takes finite time in reaching the solution and is driven by the edges’ weights, vertices’ heuristic function, and the graph structure.

Academy Course – Mastering the Top 10 Graph Algorithms

If you want to improve your fundamental computer science skills, there’s nothing more effective than studying algorithms.

To help you master the most important graph algorithms, we’ve just launched the “Top 10 Algorithms” course at the Finxter Computer Science Academy. This great course from Finxter Star Creator Matija teaches you the most important graph algorithms such as BFS, DFS, A*, and Dijkstra. 

Understanding these algorithms will not only make you a better coder, but it’ll also lay a strong foundation on which you can build your whole career as a computer scientist.

Click the screenshot to find out more:

The post Python A* – The Simple Guide to the A-Star Search Algorithm appeared first on Be on the Right Side of Change.

You can download the PDF file of the presentation here. Also, watch the presentation as a Gif here:

What is Dijkstra’s Algorithm?

Dijkstra’s algorithm solves the single-source shortest path (SSSP) problem. Generally, it enables finding the shortest route between two vertices in a graph. Its author is dr. Edsger W. Dijkstra, a pioneering contributor to computer science.

Dijkstra’s original algorithm is an uninformed greedy algorithm. Although it uses information in a form of weights of the edges, these weights are exact and inherent to the network, so no heuristic estimation function is used. In a most common example, Dijkstra’s algorithm finds the shortest path between any two cities in a graph.

What is Its Purpose?

Common applications of Dijkstra’s algorithm are in domains of optimal pathfinding for various distribution networks, such as oil, gas, electricity, road, or computer networks. Computer network equipment employs Dijkstra’s algorithm as a decision-making algorithm for optimal packet routing between network nodes (see the Open-Shortest Path First protocol).

Before we’ll dive into the algorithm and the Python implementation, let’s first skim over some related graph tutorials you may enjoy and that may help your understanding!

Related Graph Tutorials

This algorithm is part of our graph algorithm tutorials:

• Breadth-First Search (BFS) Algorithm in Python
• Python Depth-First Search (DFS) Algorithm
• Iterative Deepening Depth-First Search (DFS) Algorithm in Python
• Python Best-First Search Algorithm
• Python Dijkstra Algorithm
• Python A* Algorithm
• Jump Search Algorithm in Python
• Python Backtracking
• Python Beam Search Algorithm

Each of these tutorial links opens in a new browser tab.

Algorithm Overview: How Does Dijkstra Work?

Dijkstra’s algorithm assumes the cost of all vertices except the starting one as infinite. It sets the cost of the starting vertex to 0 and updates the costs of all adjoining, unexplored vertices, according to the weights (distances) associated with the connecting edges. After being visited, each adjoining vertex is added to the priority queue. Finally, the starting vertex is marked as explored and does not participate in any further algorithm calculations.

In each following iteration, the vertex with the lowest cost is taken out of the priority queue and its exploration starts by visiting and conditionally updating all adjoining, non-explored vertices. The update operation implies two steps: assignment of the lower cost to the adjoining node and association with the ancestor vertex for later reconstruction of the shortest path.

The update condition is determined by comparing each adjoining vertex’s current cost with its new, potentially lower cost. Its new cost is calculated as the cost of the vertex being explored + the weight of the adjoining edge (the between the vertex being explored and the adjoining vertex).

If the current cost of the adjoining vertex is still lower than the potential new cost, the vertex will not be updated. Otherwise, it will assume the new cost (its cost will decrease) and the vertex in focus will become its ancestor vertex. Vertex cost reduction is also referred to as a relaxation procedure.

After visiting and conditionally updating all the adjoining, non-explored vertices, the vertex being explored will be marked as explored and will not participate in any further algorithm calculations. The described process continues until there are no unexplored vertices left in the priority queue.

When the algorithm ends, all vertices are assigned with the lowest possible costs, and the traversal algorithm yields the shortest possible path between the starting and target vertices. For comparison with the previously described best-first search algorithm: if its heuristic function would give the same relative cost for all vertices as the Dijkstra’s algorithm, it would also traverse the vertices in the same order and yield the same shortest path.

What Are Properties of Dijkstra?

Dijkstra’s algorithm doesn’t use a heuristic function and doesn’t estimate the costs of the graph’s vertices. Instead, it relies on the exact information represented by the edge’s weights. As the initial costs of non-starting vertices are set to infinity, the algorithm successively lowers their costs until they reach their minimum cost.

This behavior yields its optimality property: minimum costs assigned to vertices enable the algorithm to always find the shortest path between the starting vertex and any other vertex in the graph. As the shortest paths always start from the starting vertex, the algorithm is attributed as the “single-source” algorithm.

Besides being optimal, the algorithm is also complete, i.e., it will always take a finite time to find a solution.

However, Dijkstra’s algorithm cannot handle edges with negative weights.

Implementation Python Dijkstra

The implementation of Dijkstra’s algorithm is achieved by function dijkstra() and a modification of the underlying class Graph.

The dijkstra() function takes three parameters:

• The graph parameter takes an initialized Graph object (see the blog on the breadth-first search algorithm, the section on graphs).
• The start_vertex parameter takes the starting vertex, which we choose freely (remember, a graph is not a tree, there is no absolute root).
• The target parameter is the entity we want to find in the graph, enclosed in a vertex.

For a better understanding of the algorithm and its implementation, each step is precisely described in the code below.

As we introduced several changes to the Graph class, the most practical approach is to show the entire class:

class Graph:

    def __init__(self, directed=False):
        self._outgoing = {}
        # If the graph is undirected, 'self._outgoing'
        # is the universal storage.
        self._incoming = {} if directed else self._outgoing

    # If the graph is directed, the 'self._incoming' 
    # dictionary differs from the 'self._outgoing'.
    def is_directed(self):
        return self._incoming is not self._outgoing

    # The function returns a generator of incoming
    # or outgoing (default) edges of a vertex.
    def adjacent_edges(self, vertex, outgoing=True):
        # References the corresponding outer dictionary
        # (dictionary of dictionaries)
        adj_edges = self._outgoing if outgoing else self._incoming

        # Access each of the edges for this endpoint vertex.
        for edge in adj_edges[vertex].values():
            yield edge

    def add_vertex(self, entity=None, h=None):
        # Constructs a new vertex from the entity.
        vertex = self.Vertex(entity, h)
        # The vertex becomes a key in the outer dictionary,
        # but the value is an internal dictionary (as we model
        # both dimensions for each edge: origin and destination).
        # e.g. {vertex_1a:{vertex_b:edge_a_b}, vertex_b:{vertex_c:edge_b_c}}.
        self._outgoing[vertex] = {}
        if self.is_directed():
            self._incoming[vertex] = {}

    def add_edge(self, origin, destination, weight=None):
        # Constructs a new edge from the vertices.
        edge = self.Edge(origin, destination, weight)
        # Adds the edge to the dictionary (dictionaries are
        # the same if the graph is undirected). The outer key
        # represents the origin, i.e. the component 'a' of
        # the edge-defining pair (a, b). The inner key stands
        # for the component 'b' of the edge-defining pair (a, b).
        self._outgoing[origin][destination] = edge
        # Even if the graph is undirected, each edge has to
        # be added twice, i.e. once for each of its endpoints.
        self._incoming[destination][origin] = edge

    def vertices(self):
        return self._outgoing.keys()

    def edges(self):
        # All the edges are collected into a set.
        result = set()
        for inner_dict in self._outgoing.values():
            result.update(inner_dict.values())
        return result

    class Vertex:
        __slots__ = '_entity', '_h'

        def __init__(self, entity, h=None):
            self.entity = entity
            self.h = h

        # The real-world entity is represented by the Vertex object.
        @property
        def entity(self):
            return self._entity

        @entity.setter
        def entity(self, entity):
            self._entity = entity

        # The real-world entity has a cost of h.
        @property
        def h(self):
            return self._h

        @h.setter
        def h(self, h):
            self._h = h

        # We have to implement __hash__ to use the object as a dictionary key.
        def __hash__(self):
            return hash(id(self))

        def __lt__(self, other):
            if self.h is None:
                return False
            elif other.h is None:
                return True
            else:
                return self.h < other.h

    class Edge:
        __slots__ = '_origin', '_destination', '_weight'

        def __init__(self, origin, destination, weight=None):
            self._origin = origin
            self._destination = destination
            self._weight = weight

        def endpoints(self):
            return self._origin, self._destination

        # Returns the other component of the edge-defining pair (a, b)
        # for a given component a or b, respectively.
        def opposite(self, vertex):
            return self._destination if self._origin is vertex \
                else self._origin

        # Returns the weight of the edge.
        @property
        def weight(self):
            return self._weight

        # Sets the weight of the edge
        @weight.setter
        def weight(self, weight):
            self._weight = weight

        def __hash__(self):
            return hash((self._origin, self._destination))

A significant difference to the previous version of the Graph class is the introduction of the property decorator and the weight attribute, as highlighted in the code.

With these changes in place, implementation of the core function, dijkstra() is:

from graph import Graph
from queue import PriorityQueue


def dijkstra(graph, start_vertex, target):
    # Create the priority queue for open vertices.
    vertices_pq = PriorityQueue()

    # Initialize the starting vertex to cost 0.
    start_vertex.h = 0

    # Adds the start vertex to the priority queue.
    print(f'Visiting/queueing vertex {start_vertex.entity}')
    vertices_pq.put(start_vertex)
    print('Prioritized vertices (v, h(v)):',
          *((vert.entity, vert.h) for vert in vertices_pq.queue), end=2 * '\n')

    # The starting vertex is visited first and has no leading edges.
    # If we did not put it into 'visited' in the first iteration,
    # it would end up in 'visited' during the second iteration, pointed to
    # by one of its children vertices as a previously unvisited vertex.
    visited[start_vertex] = None

    # Loops until the priority list gets empty.
    while not vertices_pq.empty():
        # Gets the vertex with the lowest cost.
        vertex = vertices_pq.get()
        # If the vertex being explored is a target vertex, ends the algorithm.
        print(f'Exploring vertex {vertex.entity}')
        if vertex.entity == target:
            return vertex
        # Examines each non-visited adjoining edge/vertex.
        for edge in graph.adjacent_edges(vertex):
            # Gets the second endpoint.
            v_2nd_endpoint = edge.opposite(vertex)

            # Skips the explored vertices.
            if v_2nd_endpoint in explored:
                continue

            # Checks if the endpoint has a cost and is the cost the cheapest one.
            if v_2nd_endpoint.h is None or vertex.h + edge.weight < v_2nd_endpoint.h:
                # Adds the second endpoint to 'visited' and maps
                # the leading edge for the search path reconstruction.
                v_2nd_endpoint.h = vertex.h + edge.weight
                # Prevents reinsertion to the priority queue. The
                # endpoint distance value will be updated.
                if v_2nd_endpoint not in visited:
                    print(f'Visiting/queueing vertex {v_2nd_endpoint.entity}')
                    vertices_pq.put(v_2nd_endpoint)
                # Forces the priority queue to reorder in case of an
                # inner vertex update resulting with the highest priority
                vertices_pq.put(vertices_pq.get())
                # Replaces the previous vertex' ancestor with a cheaper one.
                visited[v_2nd_endpoint] = edge
        print('Prioritized vertices (v, h(v)):',
              *((vert.entity, vert.h) for vert in vertices_pq.queue), end=2 * '\n')
        # The vertex is used for update and put aside.
        explored.append(vertex)
    return None

Before we can test the algorithm, we have to initialize a graph and build it by adding vertices and edges to it:

# Initializes an empty graph (object).
g = Graph()

# Loads the graph with the first seven vertices.
for i in range(0, 7):
    g.add_vertex(i)

# Constructs the 'vertices' dictionary for a more
# convenient access during the graph construction.
vertices = {k.entity: k for k in g.vertices()}

# Constructs an arbitrary graph from
# the existing vertices and edges.
g.add_edge(vertices[0], vertices[1], 4)
g.add_edge(vertices[0], vertices[2], 2)
g.add_edge(vertices[2], vertices[4], 1)
g.add_edge(vertices[4], vertices[3], 3)
g.add_edge(vertices[3], vertices[5], 2)
g.add_edge(vertices[0], vertices[5], 5)
g.add_edge(vertices[2], vertices[6], 5)

# Initializes the search path and a dictionary of visited vertices.
path = []
explored = []
visited = {}

Now that we have prepared everything, we can test dijkstra() and see how it works. Here is the part of the code that runs the algorithm, constructs the search path (if there is one), and shows in a step-by-step manner how it proceeds through the graph:

# Starts the search.
result = dijkstra(g, vertices[5], 6)

# If the entity is found...
if result is not None:
    # The search path ends with the found vertex (entity).
    # Each vertex is a container for its real-world entity.
    path_vertex = result
    # The entity is added to the 'path'.
    path.append(path_vertex.entity)
    # Constructs the rest of the search path (if it exists)...
    while True:
        # Gets a discovery edge leading to the vertex.
        path_edge = visited.get(path_vertex)
        # If the path vertex is the root, it has no discovery edge...
        if path_edge is None:
            break
        # Otherwise, gets the second (parent vertex) endpoint.
        path_vertex = path_edge.opposite(path_vertex)
        # The entity is added to the 'path'.
        path.append(path_vertex.entity)
    print('Search path found:', end=' ')
    # The path is reversed and starts with the root vertex.
    print(*reversed(path), sep=' -> ')
# Otherwise...
else:
    print('\nEntity is not found')
The test run gave us the output:
Visiting/queueing vertex 5
Prioritized vertices (v, h(v)): (5, 0)

Exploring vertex 5
Visiting/queueing vertex 3
Visiting/queueing vertex 0
Prioritized vertices (v, h(v)): (3, 2) (0, 5)

Exploring vertex 3
Visiting/queueing vertex 4
Prioritized vertices (v, h(v)): (0, 5) (4, 5)

Exploring vertex 0
Visiting/queueing vertex 1
Visiting/queueing vertex 2
Prioritized vertices (v, h(v)): (4, 5) (1, 9) (2, 7)

Exploring vertex 4
Prioritized vertices (v, h(v)): (2, 6) (1, 9)

Exploring vertex 2
Visiting/queueing vertex 6
Prioritized vertices (v, h(v)): (1, 9) (6, 11)

Exploring vertex 1
Prioritized vertices (v, h(v)): (6, 11)

Exploring vertex 6
Search path found: 5 -> 3 -> 4 -> 2 -> 6

Based on the output, we can see that the search started from vertex 5 and that the dijkstra() has found the entity vertex 6. The entire search path is also displayed, and we should note that the search path will always be the shortest one:

5 -> 3 -> 4 -> 2 -> 6.

However, a modification of just one weight might lead to a different solution, as we will demonstrate with the next example. With that in mind, lets tweak the weight on one of our edges:

# Constructs an arbitrary graph from
# the existing vertices and edges.
g.add_edge(vertices[0], vertices[1], 4)
g.add_edge(vertices[0], vertices[2], 2)
g.add_edge(vertices[2], vertices[4], 1)
g.add_edge(vertices[4], vertices[3], 3)
g.add_edge(vertices[3], vertices[5], 2)
g.add_edge(vertices[0], vertices[5], 4)
g.add_edge(vertices[2], vertices[6], 5)
The re-run gave us the output:
Visiting/queueing vertex 5
Prioritized vertices (v, h(v)): (5, 0)

Exploring vertex 5
Visiting/queueing vertex 3
Visiting/queueing vertex 0
Prioritized vertices (v, h(v)): (3, 2) (0, 4)

Exploring vertex 3
Visiting/queueing vertex 4
Prioritized vertices (v, h(v)): (0, 4) (4, 5)

Exploring vertex 0
Visiting/queueing vertex 1
Visiting/queueing vertex 2
Prioritized vertices (v, h(v)): (4, 5) (1, 8) (2, 6)

Exploring vertex 4
Prioritized vertices (v, h(v)): (2, 6) (1, 8)

Exploring vertex 2
Visiting/queueing vertex 6
Prioritized vertices (v, h(v)): (1, 8) (6, 11)

Exploring vertex 1
Prioritized vertices (v, h(v)): (6, 11)

Exploring vertex 6
Search path found: 5 -> 0 -> 2 -> 6

After a re-run, we got a different solution without modifying the algorithm, but only by changing one of our edges’ weights. Our simple demonstration just pointed out the dependence of Dijkstra’s algorithm on the edge weights.

Efficiency Analysis

The algorithm’s worst-case time complexity depends on the implementation choice of data structure as storage for visited vertices, which in turn depends on the number of vertices v and edges e.

A heap implementation is more appropriate when the number of edges e in the graph is small, i.e. when e < v²/log v. In this case, the time complexity is O((e+v) log v).

On the contrary, the sequence implementation is more appropriate when the number of edges e in the graph is large, i.e. when e > v²/log v. In this case, the time complexity is O(v²).

On another note, a more advanced approach to implementation of the priority queue, such as a Fibonacci heap, can yield time complexity of O(e+v log v).

Space complexity of the Dijkstra’s algorithm is O(v+e).

Dijkstra’s algorithm is optimal, as it will always yield an optimal search path. Furthermore, Dijkstra’s algorithm will always find a solution if there is one, so it is also complete.

Conclusion

In this article, we learned about Dijkstra’s search algorithm.

• First, we explained what Dijkstra’s algorithm is.
• Second, we took a look at what are its common purposes and applications.
• Third, we went through an explanation of how the algorithm works.
• Fourth, we examined the algorithm’s main properties.
• Fifth, we went through the implementation of the algorithm, which is based on the Graph abstract data structure (Graph class implementation is given above). We also tested the algorithm by calling its main function, dijkstra(), and analyzed its steps of execution for two slightly different edge weight scenarios.
• Sixth, we analyzed the algorithm efficiency.

In the end, we concluded that the algorithm efficiency is optimal, and if the solution exists, Dijkstra’s algorithm will always find it in its optimal form. The algorithm always takes finite time in reaching the solution and is driven solely by the edges’ weights and the graph structure.

Academy Course – Mastering the Top 10 Graph Algorithms

If you want to improve your fundamental computer science skills, there’s nothing more effective than studying algorithms.

To help you master the most important graph algorithms, we’ve just launched the “Top 10 Algorithms” course at the Finxter Computer Science Academy. This great course from Finxter Star Creator Matija teaches you the most important graph algorithms such as BFS, DFS, A*, and Dijkstra. 

Understanding these algorithms will not only make you a better coder, but it’ll also lay a strong foundation on which you can build your whole career as a computer scientist.

Click the screenshot to find out more:

The post Python Dijkstra Algorithm appeared first on Be on the Right Side of Change.