To address intricate problems, extensive amounts of data and substantial computational capabilities are essential for the functioning of deep learning algorithms. These algorithms are versatile in handling various types of data. 

This article will delve into a comprehensive exploration of the Diffusion Model, a prominent member of the deep learning domain and the driving force behind Stable Diffusion, which is pretty popular and widely used in generative AI these days.

Stable Diffusion has been praised for making AI image generation accessible and flexible, becoming one of the key tools for creative professionals and hobbyists working with generative AI.

Before we begin, let’s see the overview of Latent Diffusion Models architecture:

What is Deep Learning?

Deep learning is a subfield of machine learning that solves complex problems using artificial neural networks. These neural networks are made up of interconnected nodes arranged in multiple layers that extract features from input data. Large datasets are used to train these models, allowing them to detect patterns and correlations that humans would find difficult or impossible to detect.

The impact of deep learning on artificial intelligence has been substantial. It has paved the way for the development of intelligent systems capable of independent learning, adaptation, and decision-making. Deep learning has led to remarkable advancements in various domains, encompassing image and speech recognition, natural language processing, machine translation, text generation, image generation (as would be reviewed in this article), autonomous driving, and numerous others.

Why Python for Deep Learning?

Python has gained widespread popularity as a programming language due to its versatility and ease of use in diverse domains of computer science, especially in the field of deep learning. Thanks to its extensive range of libraries and frameworks specially tailored for deep learning, Python has emerged as a top choice among many machine learning professionals.

Python has emerged as the language of choice for deep learning, and here are some of the reasons why:

1. Simple to learn and use:

Python is a high-level programming language that is easy to learn and use, even for those who are new to programming. Its concise and uncomplicated syntax makes it easy to write and understand. This allows developers to concentrate on solving problems without worrying about the details of the language.

2. Abundant libraries and frameworks:

Python has a vast ecosystem of libraries and frameworks that cater specifically to deep learning. Some of these libraries include TensorFlow, PyTorch, Keras, and Theano. These libraries provide pre-built functions and modules that simplify the development process, reducing the need to write complex code from scratch.

3. Strong community support:

Python has a large and active community of developers contributing to its development, maintenance, and improvement. This community offers support and guidance to beginners, making it easier to learn and use Python for deep learning.

4. Platform independence:

Python is platform-independent, which means that code written on one platform can be easily executed on another platform without any modification. This makes it easier to deploy deep learning models on different platforms and devices.

5. Easy integration with other languages:

Python can be easily integrated with other programming languages, such as Delphi, C++, and Java, making it ideal for building complex systems that require integrating different technologies.

Overall, Python’s ease of use, an abundance of libraries and frameworks, strong community support, platform independence, and ease of integration with other languages make it an indispensable tool for machine learning practitioners. Its popularity continues to soar as a result.

What are Diffusion and Latent Diffusion Models?

A diffusion model is a type of generative model in machine learning designed to create data by reversing a noise-adding process. It models the way data can evolve from randomness (pure noise) to meaningful structures, such as images, audio, or other complex data distributions.

The following table shows how the diffusion model is compared with other generative models^[8]:

To dive deeper into GAN, read our previous article below:

On the other hand, a Latent Diffusion Model (LDM) is an advanced type of diffusion model that operates in a compressed (latent) space rather than directly on pixel data, making it more computationally efficient. LDMs, such as Stable Diffusion, enable faster image generation without compromising quality, which is especially useful for large-scale generative tasks like text-to-image synthesis.

The following table shows how LDMs improve over traditional diffusion models^[8]:

What is Stable Diffusion?

Stable Diffusion is a generative artificial intelligence (generative AI) model that allows us to produce unique, high-quality, or even photorealistic images from text and image prompts^[1]. Stable Diffusion leverages the Latent Diffusion model^[2][5][10], developed by researchers from the Machine Vision and Learning group at LMU Munich, a.k.a CompVis.

Model checkpoints were publicly released at the end of August 2022 by a collaboration of Stability AI, CompVis, and Runway with support from EleutherAI and LAION^[7][9]. For more information, you can check out their official blog post^[13][14].

At the time this article was written, Stable Diffusion 3 Medium had already been released. Stable Diffusion 3 Medium is the latest and most advanced text-to-image AI model in our Stable Diffusion 3 series, comprising two billion parameters. It excels in photorealism, processes complex prompts, and generates clear text.

Try Stable Diffusion online with no-code approach

Before we dive deeper into Stable Diffusion with Python, let’s try it online first, with online Stable Diffusion 2.1 Demo:

For faster generation and API access, you can try: DreamStudio Beta.

Or, you can try Playground AI, which enables us to try dozens of different filters and presets, to generate far better outputs:

How do you get started in Stable Diffusion with Python using Hugging Face’s Diffusers library?

The easiest way to get started with Stable Diffusion and other diffusion models with Python is by using Hugging Face’s Diffusers library.

What is 🤗 Diffusers library?

🤗 Diffusers is a leading library for state-of-the-art pre-trained diffusion models, enabling the generation of images, audio, and even 3D structures of molecules. It serves as a modular toolkit suitable for both simple inference tasks or training your own custom diffusion model.

🤗 Diffusers library is designed with a focus on usability over performance, simplicity over easy, and customizability over abstractions. One goal of the 🤗 Diffusers library is to make diffusion models accessible to a wide range of deep learning practitioners.

The underlying model of 🤗 Diffusers library, a neural network, is trained to predict a way to slightly denoise the image in each step. After a certain number of steps, a sample is obtained.

The following is the architecture of the neural network (commonly follows the U-net architecture as proposed by reference^[4] and improved upon in the Pixel++ paper):

Some of the highlights of the architecture are:

• this model predicts images of the same size as the input
• the model makes the input image go through several blocks of ResNet layers which halves the image size by 2
• then through the same number of blocks that upsample it again
• skip connections link features on the downsample path to corresponding layers in the upsample path.

How to install Diffusers on your local machine?

Move to your chosen or preferred working directory, and then create a new virtual environment, and install Python version 3.10.

Create a virtual environment called “diffusers”, and install Python 3.10:

conda create --name diffusers python=3.10

To activate this environment, use:

conda activate diffusers

To deactivate an active environment, use this command:

conda deactivate

Before we begin any further, make sure we have all the necessary libraries installed using the following pip command:

pip install --upgrade diffusers accelerate transformers

We would install the following two libraries:

• Accelerate: To speed up model loading for inference and training.
• Transformers: This is required to run the most popular diffusion models, such as Stable Diffusion.

There are three main components of the library to know about:

1. DiffusionPipeline

The DiffusionPipeline is a high-level end-to-end class designed to rapidly generate samples from popular pre-trained diffusion models for inference, in a user-friendly fashion.

We’ll begin by importing a pipeline first. We’ll use the google/ddpm-celebahq-256 model developed by Google and U.C. Berkeley. It’s a model that utilizes the Denoising Diffusion Probabilistic Models (DDPM) algorithm that is trained on a dataset of celebrities images.

Hands-on and selected outputs:

The following is a code snippet for the basic use of DiffusionPipeline, and a sufficient explanation of selected outputs:

from diffusers import DDPMPipeline

image_pipe = DDPMPipeline.from_pretrained("google/ddpm-celebahq-256")
image_pipe.to("cpu")

images = image_pipe().images
# Show an example of the generated image from the Hugging Face Hub (DDPM-CelebHQ)
images[0].show()

# Browse what was the building blocks of the pipeline:
image_pipe

To generate an image, we simply run the pipeline and don’t even need to give it any input, it will generate a random initial noise sample and then iterate the diffusion process.

The pipeline returns as output a dictionary with a generated sample of interest:

Let’s take a look at the image by running images[0].show() on PyScripter IDE:

Run image_pipe on PyScripter, to see what the pipeline is made of, so we can try to understand better what was going on under the hood:

Now we can see what’s inside the pipeline: A scheduler and a UNet model. Let’s look closely at them and what this pipeline just did under the hood.

2. Pretrained models

Popular pre-trained model architectures and modules can be used as building blocks for creating diffusion systems.

Instances of the model class are neural networks that take a noisy sample as well as a timestep as inputs to predict a less noisy output sample. In this subsection, we’ll load a pre-trained model and play around with it to understand the model API. We’ll load a simple unconditional image generation model of type UNet2DModel which was released with the DDPM Paper^[3] and for instance, take a look at another checkpoint trained on church images: google/ddpm-church-256.

Hands-on and selected outputs

The following is a code snippet for the basic use of the models, and a sufficient explanation of selected outputs:

import os
os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
from diffusers import UNet2DModel

repo_id = "google/ddpm-church-256"
model = UNet2DModel.from_pretrained(repo_id, use_safetensors=False)

model
model.config

model_random = UNet2DModel(**model.config)

model_random.save_pretrained("my_model")

# Add random gaussian sample
import torch

torch.manual_seed(0)

noisy_sample = torch.randn(1, model.config.in_channels, model.config.sample_size, model.config.sample_size)
noisy_sample.shape

# Inference
with torch.no_grad():
    noisy_residual = model(sample=noisy_sample, timestep=2).sample

Now let’s take a look at the model’s configuration. By accessing the config attribute using model.config on PyScripter IDE, we can browse all the necessary parameters to define the model architecture:

You can access all the complete output of the model and model.config in the repository [3].

A couple of important config parameters are:

• sample_size: defines the height and width dimension of the input sample.
• in_channels: defines the number of input channels of the input sample.
• down_block_types and up_block_types: define the type of down- and upsampling blocks that are used to create the UNet architecture as was seen in the figure at the beginning of this notebook.
• block_out_channels: defines the number of output channels of the downsampling blocks, also used in reversed order for the number of input channels of the upsampling blocks.
• layers_per_block: defines how many ResNet blocks are present in each UNet block.

Coming back to the trained model, let’s now see how you can use the model for inference. First, you need a random gaussian sample in the shape of an image (batch_size × in_channels × sample_size × sample_size). We have a batch axis because a model can receive multiple random noises. A channel axis because each one consists of multiple channels (such as red-green-blue). And finally, sample_size corresponds to the height and width. Let’s confirm the output shapes match using noisy_sample.shape:

The predicted noisy_residual has the exact same shape as the input and we use it to compute a slightly less noisy image. Let’s confirm the output shapes match using noisy_residual.shape:

3. Schedulers

Schedulers are algorithms wrapped into a Python class that define the noise schedule, which is used to add noise to the model during training and also define the algorithm to compute the slightly less noisy sample given the model output (noisy_residual). This article only focuses on how to use scheduler classes for inference.

We will use DDPMScheduler, the denoising algorithm proposed in the DDPM Paper^[4].

Hands-on and selected outputs

The following is a code snippet for the basic use of the schedulers, and a sufficient explanation of selected outputs:

import os
os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
from diffusers import UNet2DModel
from diffusers import DDPMScheduler

repo_id = "google/ddpm-ema-church-256"
model = UNet2DModel.from_pretrained(repo_id, use_safetensors=False)
scheduler = DDPMScheduler.from_pretrained(repo_id)

scheduler.config

scheduler.save_config("my_scheduler")
new_scheduler = DDPMScheduler.from_pretrained("my_scheduler")

# Add random gaussian sample
import torch

torch.manual_seed(0)

noisy_sample = torch.randn(1, model.config.in_channels, model.config.sample_size, model.config.sample_size)
noisy_sample.shape

# Inference
with torch.no_grad():
    noisy_residual = model(sample=noisy_sample, timestep=2).sample

less_noisy_sample = scheduler.step(model_output=noisy_residual, timestep=2, sample=noisy_sample).prev_sample
less_noisy_sample.shape

# Define the denoising loop
import PIL.Image
import numpy as np

def display_sample(sample, i):
    image_processed = sample.cpu().permute(0, 2, 3, 1)
    image_processed = (image_processed + 1.0) * 127.5
    image_processed = image_processed.numpy().astype(np.uint8)

    image_pil = PIL.Image.fromarray(image_processed[0])
    print(f"Image at step {i}")
    image_pil.show()

# Display the progress, at every 50th step
import tqdm

sample = noisy_sample

for i, t in enumerate(tqdm.tqdm(scheduler.timesteps)):
    # 1. predict noise residual
    with torch.no_grad():
    residual = model(sample, t).sample

    # 2. compute less noisy image and set x_t -> x_t-1
    sample = scheduler.step(residual, t, sample).prev_sample

    # 3. optionally look at image
    if (i + 1) % 50 == 0:
        display_sample(sample, i + 1)

Let’s take a look at the scheduler configuration here, by running scheduler.config on PyScripter IDE:

Different schedulers are usually defined by different parameters. The following are the most important ones that we need to know:

• num_train_timesteps defines the length of the denoising process, e.g. how many timesteps are needed to process random Gaussian noise to a data sample.
• beta_schedule defines the type of noise schedule that shall be used for inference and training.
• beta_start and beta_end define the smallest and highest noise values of the schedule.

We’ll try to use the model output from the previous section. We can see that the computed sample has the exact same shape as the model input, which means that we are ready to pass it to the model again in the next step.

The last step is to bring it all together and define the denoising loop. This loop prints out the (less and less) noisy samples along the way for better visualization in the denoising loop.

In the code above, we already define a display function that takes care of post-processing the denoised image, and then convert it to a PIL.Image and display it. Here is the output (displayed using the PIL.Image) of the 50th step:

It takes quite some time to see a meaningful shape, it can be seen after 800 steps. And, here is the final result, the 1000th step:

By saving the image results after the 50th step and its multiples until the 1000th step and aggregating them, we can see the following denoising progress:

Isn’t it amazing? We should now have a solid foundational understanding of the schedulers and all other components of the 🤗 Diffusers library. The key points to keep in mind are:

1. Schedulers have no trainable weights (parameter-free).

2. During inference, schedulers specify the algorithm that computes the slightly less noisy sample.

To end the subsection about models and schedulers, please also note that we very much deliberately try to keep models and schedulers as independent from each other as possible. This means a scheduler should never accept a model as an input and vice-versa. The model predicts the noise residual or slightly less noisy image with its trained weights, while the scheduler computes the previous sample given the model’s output.

How to perform text-to-image using Stable Diffusion on 🤗 Diffusers? 

In this section, we will try text-to-image or image generation from text, using the Diffusers library. We will try it using two different classes: DiffusionPipeline and StableDiffusionPipeline.

Using DiffusionPipeline

Load the model with the from_pretrained() method:

from diffusers import DiffusionPipeline

pipeline = DiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", use_safetensors=True)

The DiffusionPipeline downloads and caches all modeling, tokenization, and scheduling components.

You’ll see that the Stable Diffusion pipeline is composed of the UNet2DConditionModel and PNDMScheduler among other things:

The following is the complete code example to generate an image from a text prompt using Diffusers:

from diffusers import DiffusionPipeline

pipeline = DiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", use_safetensors=True)

image = pipeline("A painting of a cat playing bass guitar").images[0]
image
image.save("painting_of_cat_playing_bass2.png")

Run it on PyScripter IDE, the “A painting of a cat playing bass guitar” prompt would generate the following output:

Using StableDiffusionPipeline

In this second example, we will generate an image from a text prompt, directly using StableDiffusionPipeline from the diffusers library.

Run the following code and your prompt on PyScripter IDE:

import torch
from diffusers import StableDiffusionPipeline

model_id = "runwayml/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id)

prompt = "A man coding on his laptop"

pipe = pipe.to("cpu")
generator = torch.Generator("cpu").manual_seed(0)

image = pipe(prompt, generator=generator).images[0]
image
image.save("a_man_coding_on_his_laptop.png")

Other interesting implementations

The advancement of generative AI-particularly Stable Diffusion, enables us to do creativity-demanding tasks such as creating video art, with just a few clicks away. Below are videos I generate using combinations of text-to-image, image-to-image, frame interpolation, and text/image-to-video using Playground AI and Runway ML, which all are rooted in Stable Diffusion.

Text/image to video

Text/image to video is a multimodal AI system that can generate novel videos from text, images, or video clips.

Here is the collection of 11 short videos (4 seconds each) that I generated or animated from existing images with additional guidance from text prompts, with help from Runway ML:

The following are the prompts I use to guide the image-to-video generation process:

1. A cat playing bass guitar
2. An astronaut working on ISS
3. Human and robot handshake
4. Jackson Pollock's No. 1 (Lavender Mist) live drip painting
5. Typing on keyboard
6. A woman working with her laptop
7. Two software developers brainstorming
8. The startup founder gives a presentation
9. A PhD student teaches us about her research
10. A young mathematician struggling to solve equations on a blackboard
11. An alien gray staring at us

Text-to-image + frame interpolation

Frame interpolation is a technique to turn a sequence of images into an animated video, by filling in between images with smooth transitions. 

First, I generate 120 images from unusual, obscure, and complex text prompts using Playground AI. The following are the prompts I used to generate images:

1. Photographs of Space-Time Anomalies
2. Illustration of a future Artificial General Intelligence (AGI)
3. Illustration of deep learning and AI community
4. Very advanced alien civilizations that live inside black hole
5. Vibrating membrane from brane theory and m-theory
6. First ever photo of an atom, First ever photo of a proton taken using electron microscope
7. Deep sea, Deep sea with deep sea creatures, Deep sea monsters
8. A battalion of military robots
9. Dream of the Future of Humanity: Interplanetary, Interstellar, and Intergalactic Colony
10. Surface of exoplanet
11. Reimagine newton's apple and universal law of gravitation
12. Draw Feynman diagram in artistic but scientifically formal way

Then, I create a video by automatically generating smooth transitions between those images using frame interpolation from Runway ML:

Conclusion

In conclusion, leveraging Python for deep learning with diffusion models unlocks immense potential for generative AI, take Stable Diffusion as a perfect example. These models, particularly Latent Diffusion Models (LDMs), have revolutionized the field by combining computational efficiency with high-quality outputs, enabling accessible and versatile applications such as text-to-image synthesis.

We’ve also learned the hands-on parts of diffusion models by utilizing libraries like Hugging Face’s 🤗 Diffusers with Python, to draw picture from random noise (we explored pre-trained models, customizable pipelines, and efficient inference methods to draw church realistically) and performing text-to-image synthesis.

As we delve deeper into these cutting-edge advancements, diffusion models continue to shape the future of AI-driven innovation, empowering diverse domains ranging from art and design to scientific discovery.

I hope this article was successful in giving you a comprehensive and accessible introduction to diffusion models, and a solid understanding and workflow of how to implement them to your domains and project goals, so, it would inspire you to learn more and experiment with diffusion models yourself.

Check out the full repository here: github.com/Embarcadero/DL_Python07_ DiffusionModels

Click here to get started with PyScripter, a free, feature-rich, and lightweight Python IDE.

Download RAD Studio to create more powerful Python GUI Windows Apps in 5x less time.

Check out Python4Delphi, which makes it simple to create Python GUIs for Windows using Delphi.

Also, look into DelphiVCL4Python, which makes it simple to create Windows GUIs with Python.

References & further readings

[1] Amazon Web Services, Inc. (2024). 

What is Stable Diffusion? AWS What is. aws.amazon.com/what-is/stable-diffusion

[2] Hakim, M. A. (2023). 

How to bypass the ChatGPT information cutoff? A busy (or lazy) man guide to read more recent ML/DL papers. Paper-001: “Rombach et al., 2022”. hkaLabs blog. hkalabs.com/blog/how-to-read-deep-learning-papers-using-bing-chat-ai-001

[3] Hakim, M. A. (2024).

Article47 – Deep Learning Python 07 – Diffusion Models. embarcaderoBlog-repo. GitHub repository. github.com/MuhammadAzizulHakim/ embarcaderoBlog-repo/tree/main/Article47%20-%20Deep%20Learning%20Python%2007%20-%20Diffusion%20Models

[4] Ho, J., Jain, A., & Abbeel, P. (2020). 

Denoising diffusion probabilistic models. Advances in neural information processing systems, 33, 6840-6851.

[5] Hugging Face. (2024). 

Diffusers. Hugging Face docs. huggingface.co/docs/diffusers/index

[6] Hugging Face. (2023). 

diffusers_intro.ipynb: Introducing Hugging Face’s new library for diffusion models. Hugging Face GitHub repository. colab.research.google.com/github/huggingface/ notebooks/blob/main/diffusers/diffusers_intro.ipynb

[7] Hugging Face. (2023). 

The Stable Diffusion Guide. Hugging Face docs. huggingface.co/docs/diffusers/v0.13.0/en/ stable_diffusion

[8] OpenAI. (2024). 

ChatGPT (Nov version) [Large language model]. chat.openai.com/chat

[9] Patil, S., Cuenca, P., Lambert, N., and von Platen, P. (2024). 

Stable Diffusion with 🧨 Diffusers. Hugging Face blog. huggingface.co/blog/stable_diffusion

[10] Rombach, R., Blattmann, A., Lorenz, D., Esser, P., & Ommer, B. (2022). 

High-resolution image synthesis with latent diffusion models. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition (pp. 10684-10695).

[11] Rombach, R., Blattmann, A., Lorenz, D., Esser, P., & Ommer, B. (2022).

latent-diffusion: High-Resolution Image Synthesis with Latent Diffusion Models. CompVis – Computer Vision and Learning LMU Munich. GitHub repository. github.com/CompVis/latent-diffusion

[12] Ronneberger, O., Fischer, P., & Brox, T. (2015). 

U-net: Convolutional networks for biomedical image segmentation. In Medical image computing and computer-assisted intervention–MICCAI 2015: 18th international conference, Munich, Germany, October 5-9, 2015, proceedings, part III 18 (pp. 234-241). Springer International Publishing.

[13] Stability AI. (2024).

Stability AI: Activating humanity’s potential through generative AI. Stability AI official website. stability.ai

[14] Stability AI. (2024).

Stable Diffusion Public Release. Stability AI news. stability.ai/news/stable-diffusion-public-release

[15] Towards AI Editorial Team. (2023).

Diffusion Models vs. GANs vs. VAEs: Comparison of Deep Generative Models. Toward AI blog. towardsai.net/p/generative-ai/diffusion-models-vs-gans-vs-vaes-comparison-of-deep-generative-models

The post Unlock the Power of Python for Deep Learning with Diffusion Model – The Engine behind Stable Diffusion first appeared on Python GUI.

Radial Basis Function Networks (RBFNs) are a powerful tool for specific types of problems, particularly those involving interpolation and function approximation. Their simplicity and effectiveness in these areas make them a valuable model in the machine learning and deep learning toolbox.

RBFNs are special types of feedforward neural networks that use radial basis functions as activation functions. They have an input layer, a hidden layer, and an output layer and are mostly used for classification, regression, and time-series prediction.

If you are interested in learning how to use Python for deep learning with Radial basis function networks (RBFNs), this article is perfect for you. 

Before we begin, let’s see the diagram of RBFN architecture:

What is Deep Learning?

Deep learning is a branch of machine learning focused on solving complex problems through the use of artificial neural networks. These networks are composed of multiple layers of interconnected nodes that work together to extract features from input data. By training on large datasets, deep learning models can identify patterns and correlations that are often beyond human capability to detect.

The influence of deep learning on artificial intelligence has been substantial. It has paved the way for the creation of intelligent systems that can learn, adapt, and make autonomous decisions. This technology has driven significant advancements in various fields, including function approximation, classification, time-series prediction, image and speech recognition, natural language processing, machine translation, and autonomous driving, among others.

The following is a scheme of the use of neural networks in the Global Positioning System (GPS):

4 Reasons to Use Python for Deep Learning

Python’s rise in popularity is attributed to its adaptability and simplicity, particularly in the realm of deep learning. It has become the go-to language for many professionals in machine learning, deep learning, AI, and data science due to its comprehensive libraries and frameworks designed for these purposes.

Here are four compelling reasons why Python excels as a deep learning language:

1. Straightforward syntax and readability

Python’s straightforward syntax and readability make it an ideal choice for deep learning. Its high-level nature allows developers to write clean, understandable code, which is particularly beneficial for those new to programming or deep learning. This simplicity helps researchers and developers focus on creating and refining models without being bogged down by complex syntax, enabling faster experimentation and iteration.

2. Extensive ecosystem of libraries and frameworks

The extensive ecosystem of libraries and frameworks is another major advantage of using Python for deep learning. Libraries such as TensorFlow, PyTorch, and Keras offer powerful tools for building, training, and deploying deep learning models. These frameworks come with pre-built components that handle many aspects of deep learning, from data preprocessing to model evaluation, significantly reducing the amount of boilerplate code developers need to write. This makes the development process more efficient and allows for rapid prototyping.

3. Strong community support

Python’s strong community support enhances its appeal in the deep learning field. The large and active community of Python developers contributes to a wealth of resources, including comprehensive documentation, tutorials, and forums. This support network is invaluable for troubleshooting, learning new techniques, and staying up-to-date with the latest advancements in deep learning. The collaborative environment fostered by the Python community ensures continuous improvement and innovation in the tools and libraries available for deep learning.

4. Cross-platform compatibility

Cross-platform compatibility is another significant benefit of using Python. Python’s platform independence means that code written on one operating system can be easily executed on another with minimal modifications. This flexibility is crucial for deploying deep learning models across various environments, from local machines to cloud-based platforms. Python’s compatibility with different operating systems ensures that deep learning solutions can be seamlessly integrated into diverse deployment scenarios, enhancing their usability and reach.

What Are Radial Basis Function Networks (RBFNs)?

Radial Basis Function Networks, abbreviated as RBFNs, are a class of artificial neural networks frequently employed for tasks such as function approximation, classification, and clustering. These networks excel in addressing challenges involving nonlinear or discontinuous data.

The fundamental concept of RBFNs revolves around the use of radial basis functions as their activation functions. Positioned at specific locations within the input space, these functions enable the transformation of input data into a higher-dimensional space, facilitating easier separation and classification of the data.

What Python tools and libraries are needed for RBFN development?

Developing a Radial Basis Function Network (RBFN) in Python can be facilitated using several libraries and tools. Here’s a list of the most commonly used ones:

Core Libraries

1. NumPy:

• Purpose: For numerical operations and handling arrays.
• Installation: pip install numpy

2. SciPy:

• Purpose: For scientific computing, including optimization and special functions.
• Installation: pip install scipy

3. scikit-learn:

• Purpose: Although scikit-learn doesn’t have a dedicated RBFN implementation, it provides tools for clustering (e.g., k-means) which can be useful for selecting centers, and other utilities for data preprocessing.
• Installation: pip install scikit-learn

Data Handling and Visualization

4. Pandas:

• Purpose: For data manipulation and analysis.
• Installation: pip install pandas

5. Matplotlib:

• Purpose: For plotting and visualizing data.
• Installation: pip install matplotlib

6. Seaborn:

• Purpose: For statistical data visualization, built on top of Matplotlib.
• Installation: pip install seaborn

Example Code

Here’s a basic example of how you can implement an RBFN using these libraries:

import numpy as np
from scipy.spatial.distance import cdist
from sklearn.cluster import KMeans
from sklearn.linear_model import LinearRegression

class RBFN:
    def __init__(self, num_centers, spread):
        self.num_centers = num_centers
        self.spread = spread
    def _rbf(self, X, centers, spread):
        return np.exp(-cdist(X, centers) ** 2 / (2 * spread ** 2))
    def fit(self, X, y):
        # Step 1: Use k-means to find centers
        kmeans = KMeans(n_clusters=self.num_centers)
        kmeans.fit(X)
        self.centers = kmeans.cluster_centers_
        # Step 2: Calculate the RBF activations
        RBF_X = self._rbf(X, self.centers, self.spread)
        # Step 3: Train linear regression on RBF activations
        self.regressor = LinearRegression()
        self.regressor.fit(RBF_X, y)
    def predict(self, X):
        RBF_X = self._rbf(X, self.centers, self.spread)
        return self.regressor.predict(RBF_X)

# Sample usage
if __name__ == "__main__":
    from sklearn.datasets import make_regression
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import mean_squared_error
    # Generate synthetic data
    X, y = make_regression(n_samples=100, n_features=2, noise=0.1)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    # Initialize and train RBFN
    rbfn = RBFN(num_centers=10, spread=1.0)
    rbfn.fit(X_train, y_train)
    # Predict and evaluate
    y_pred = rbfn.predict(X_test)
    mse = mean_squared_error(y_test, y_pred)
    print(f"Mean Squared Error: {mse}")
    # Plot results
    import matplotlib.pyplot as plt
    plt.scatter(y_test, y_pred)
    plt.xlabel("True Values")
    plt.ylabel("Predictions")
    plt.title("RBFN Predictions vs True Values")
    plt.show()

These libraries provide a solid foundation for developing and experimenting with RBFNs in Python.

Radial basis function networks (RBFNs) as building blocks for more complex networks in AI

Radial basis function networks (RBFNs) are the building blocks for various applications in machine learning and neural networks, particularly for tasks involving pattern recognition, function approximation, and time-series prediction. They are characterized by their use of radial basis functions as activation functions, which measure the distance between input data points and a set of center points. This unique feature allows RBFNs to capture local patterns in the data, making them highly effective for interpolation and classification tasks. 

Moreover, RBFNs serve as foundational components in more complex architectures and algorithms, such as support vector machines and Gaussian processes, further extending their utility in the field of artificial intelligence.

The following is an example of the employment of RBFNNs for Navigation Systems:

RBFNs vs MLPs

Radial Basis Function Networks (RBFNs) and Multilayer Perceptrons (MLPs) are both types of artificial neural networks used in machine learning, but they have distinct structures and mechanisms for processing information.

Comparison

Structure and Complexity: 

RBFNs are simpler in structure compared to MLPs. RBFNs have a single hidden layer, while MLPs can have multiple hidden layers.

Training Process: 

The training of RBFNs is typically faster as it involves finding centers and spreads followed by linear output weights. MLPs require iterative backpropagation, which can be computationally intensive.

Interpretability: 

RBFNs, with their localized response to input data, can be more interpretable than MLPs, where the influence of individual neurons is harder to decipher.

Function Approximation: 

RBFNs are often preferred for tasks requiring interpolation and where the relationship between inputs and outputs is locally smooth. MLPs, on the other hand, are more versatile and can handle more complex, non-linear relationships.

Generalization: 

MLPs generally have better generalization capabilities due to their deeper architecture and non-linear activations, making them suitable for a broader range of tasks compared to the typically shallow architecture of RBFNs.

In summary, while both RBFNs and MLPs are powerful tools in machine learning, they are suited to different types of problems and have distinct strengths and weaknesses. RBFNs are often used for their simplicity and effectiveness in local function approximation, while MLPs are favored for their flexibility and ability to model complex global patterns in data.

RBFNs vs LSTMs

On the other hand, the following are the key differences between RBFNs and LSTMs:

Architecture

RBFNs:

• Structure: Comprise three layers—input, hidden (with radial basis functions as activation functions), and output.
• Hidden Layer: Uses radial basis functions (e.g., Gaussian functions) that respond to the distance between the input and a center.
• Output: Produces a linear combination of the hidden layer activations.
• Training: Involves determining centers and widths of the radial basis functions, followed by training the output weights using linear regression techniques.

LSTMs:

For more details on LSTMs, please refer to our previous article:

• Structure: A type of recurrent neural network (RNN) with cells that include gates to manage memory and state.
• Cells: Each LSTM cell has input, output, and forget gates to control the flow of information.
• Memory: Designed to retain information over long sequences, addressing the vanishing gradient problem common in traditional RNNs.
• Training: Uses backpropagation through time (BPTT) to update weights, which can be computationally intensive.

Applications

RBFNs:

• Function Approximation: Well-suited for interpolating functions in multi-dimensional space.
• Classification: Can classify data by learning decision boundaries.
• Regression: Useful for predicting continuous values.
• Time-Series Prediction: Applied to forecasting future values based on past data, though not as effective as LSTMs for long sequences.

LSTMs:

• Sequential Data: Ideal for tasks involving sequences, such as natural language processing (NLP), speech recognition, and time-series prediction.
• Memory Retention: Effective in capturing long-term dependencies in data sequences.
• Complex Patterns: Capable of learning intricate patterns over time, making them suitable for tasks like language translation, sentiment analysis, and video analysis.

Strengths and Weaknesses

RBFNs:

• Strengths:

• Weaknesses:

LSTMs:

• Strengths:

• Weaknesses:

Summary

• RBFNs are best suited for problems involving interpolation, classification, and simple time-series prediction. 

They are easier to train and understand but may not scale well with large and complex datasets.

• LSTMs excel in handling sequential data with long-term dependencies, such as in NLP and advanced time-series prediction. 

They are more complex and require more computational resources but are highly effective for tasks involving sequences.

Choosing between RBFNs and LSTMs depends on the specific nature of the problem at hand. If the task involves learning from sequential data with long-term dependencies, LSTMs are generally the better choice. For simpler problems involving function approximation or classification in multi-dimensional space, RBFNs might be more appropriate.

Hands-On RBFNs 1: Stock market prediction

This example uses synthetic data for simplicity, but you can replace it with actual stock market data:

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error
import matplotlib.pyplot as plt

# Generate synthetic stock market data
np.random.seed(42)
X = np.linspace(0, 10, 100).reshape(-1, 1)
y = np.sin(X).ravel() + np.random.normal(scale=0.1, size=X.shape[0])

# Split data into training and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Standardize the data
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

class RBFNetwork:
    def __init__(self, num_input, num_hidden, num_output, sigma=1.0):
        self.num_input = num_input
        self.num_hidden = num_hidden
        self.num_output = num_output
        self.sigma = sigma
        self.centers = None
        self.weights = None

    def _calculate_centers(self, X):
        idx = np.random.choice(X.shape[0], self.num_hidden, replace=False)
        centers = X[idx]
        return centers

    def _compute_activation(self, X):
        activation = np.zeros((X.shape[0], self.num_hidden))
        for i in range(self.num_hidden):
            activation[:, i] = np.exp(-np.linalg.norm(X - self.centers[i], axis=1) ** 2 / (2 * self.sigma ** 2))
        return activation

    def fit(self, X, y):
        self.centers = self._calculate_centers(X)
        activation = self._compute_activation(X)
        self.weights = np.dot(np.linalg.pinv(activation), y)

    def predict(self, X):
        activation = self._compute_activation(X)
        output = np.dot(activation, self.weights)
        return output

# Initialize RBF network
num_hidden_neurons = 10
rbf_net = RBFNetwork(num_input=X_train_scaled.shape[1], num_hidden=num_hidden_neurons, num_output=1, sigma=1.0)

# Train the network
rbf_net.fit(X_train_scaled, y_train)

# Make predictions
y_train_pred = rbf_net.predict(X_train_scaled)
y_test_pred = rbf_net.predict(X_test_scaled)

# Evaluate the model
train_mse = mean_squared_error(y_train, y_train_pred)
test_mse = mean_squared_error(y_test, y_test_pred)

print(f'Train MSE: {train_mse:.4f}')
print(f'Test MSE: {test_mse:.4f}')

# Plot the results
plt.figure(figsize=(10, 6))
plt.plot(X, y, 'b-', label='True Data')
plt.plot(X_train, y_train_pred, 'ro', label='Train Predictions')
plt.plot(X_test, y_test_pred, 'go', label='Test Predictions')
plt.legend()
plt.xlabel('X')
plt.ylabel('y')
plt.title('RBF Network - Stock Market Prediction')
plt.show()

To execute the code above seamlessly without any errors, we can utilize the PyScripter IDE.

What did the code above do?

Let’s break down the important parts of the code above.

We’ll use the numpy library for numerical operations and sklearn for preprocessing. Here’s the step-by-step code:

1. Import Libraries

Import the necessary libraries.

2. Prepare Data

Load and preprocess your stock market data. For demonstration, we will create synthetic stock market data. Replace this with your actual data.

3. Define the RBF Network

Implement the RBF network class.

4. Train the Model

Train the RBFN on the training data.

5. Make Predictions

Use the trained model to make predictions.

This is a basic implementation to demonstrate how an RBFN can be applied to stock market prediction. 

For real-world applications, you should:

1. Use Real Stock Market Data

Replace the synthetic data generation with actual stock market data loading and preprocessing.

2. Tune Hyperparameters

Optimize the number of hidden neurons, sigma, and other hyperparameters using cross-validation or other techniques.

3. Feature Engineering

Use relevant financial indicators and features that affect stock prices.

4. Regularization and Advanced Techniques

Incorporate regularization, cross-validation, and more advanced techniques to improve model robustness and performance.

Hands-On RBFNs 2: Anomaly detection

Below is a Python example of how you can use a Radial Basis Function Network (RBFN) for anomaly detection. This example uses synthetic data for simplicity, but you can replace it with actual data.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.datasets import make_classification
from sklearn.linear_model import LinearRegression
from sklearn.metrics import accuracy_score
import scipy.spatial.distance as distance

class RadialBasisFunctionNeuralNetwork:
    def __init__(self, num_of_rbf_units=10):
        self.num_of_rbf_units = num_of_rbf_units

    def _rbf_unit(self, rbf_center, point_in_dataset):
        return np.exp(-self.beta * distance.cdist([point_in_dataset], [rbf_center], 'euclidean')**2).flatten()[0]

    def _construct_interpolation_matrix(self, input_dataset):
        interpolation_matrix = np.zeros((len(input_dataset), self.num_of_rbf_units))
        for idx, point_in_dataset in enumerate(input_dataset):
            for center_idx, rbf_center in enumerate(self.rbf_centers):
                interpolation_matrix[idx, center_idx] = self._rbf_unit(rbf_center, point_in_dataset)
        return interpolation_matrix

    def train_model(self, input_dataset, target_dataset):
        self.kmeans_clustering = KMeans(n_clusters=self.num_of_rbf_units, random_state=0).fit(input_dataset)
        self.rbf_centers = self.kmeans_clustering.cluster_centers_
        self.beta = 1.0 / (2.0 * (self.kmeans_clustering.inertia_ / input_dataset.shape[0]))
        interpolation_matrix = self._construct_interpolation_matrix(input_dataset)
        self.model_weights = np.linalg.pinv(interpolation_matrix.T.dot(interpolation_matrix)).dot(interpolation_matrix.T).dot(target_dataset)

    def predict(self, input_dataset):
        interpolation_matrix = self._construct_interpolation_matrix(input_dataset)
        predicted_values = interpolation_matrix.dot(self.model_weights)
        return predicted_values

if __name__ == "__main__":
    # Generating a simple classification dataset
    input_dataset, target_dataset = make_classification(n_samples=500, n_features=2, n_informative=2, n_redundant=0, n_classes=2)

    # Initializing and training the RBF neural network
    rbf_neural_network = RadialBasisFunctionNeuralNetwork(num_of_rbf_units=20)
    rbf_neural_network.train_model(input_dataset, target_dataset)

    # Predicting the target values
    predictions = rbf_neural_network.predict(input_dataset)

    # Converting continuous output to binary labels
    binary_predictions = np.where(predictions > 0.5, 1, 0)

    # print("Accuracy: {}".format(accuracy_score(target_dataset, binary_predictions)))
    print(f"Accuracy: {accuracy_score(target_dataset, binary_predictions)}")

    # Plotting the results
    plt.scatter(input_dataset[:, 0], input_dataset[:, 1], c=binary_predictions, cmap='viridis', alpha=0.7)
    plt.scatter(rbf_neural_network.rbf_centers[:, 0], rbf_neural_network.rbf_centers[:, 1], c='red')
    plt.title('Classification Result')
    plt.show()

To execute the code above seamlessly without any errors, we can utilize the PyScripter IDE.

What did the code above do?

Let’s break down the important parts of the code above.

1. Import Libraries

Import necessary libraries.

2. Prepare Data

• Generate and preprocess data. For demonstration, we will create synthetic normal and anomalous data.
• Split the data into training and test sets.
• Standardize the data.

3. Define the RBF Network

Implement the RBF network class: Define an RBF network class with methods to fit the model, predict outputs, and calculate reconstruction errors.

4. Train the Model

Train the RBF network using only the normal data.

5. Anomaly Detection

Use the trained model to detect anomalies. We use the trained model to detect anomalies based on reconstruction error:

• Calculate the reconstruction error for both training and test sets.
• Determine a threshold for anomaly detection (e.g., the 95th percentile of training errors).
• Classify anomalies based on whether their reconstruction error exceeds the threshold.
• Evaluate and visualize the results.

This example demonstrates how to use an RBF network for anomaly detection. For real-world applications, you should adjust the data preprocessing, network parameters, and threshold determination based on the specific characteristics of your data and use case.

Hands-On RBFNs 3: Signal processing

Radial Basis Function Networks (RBFNs) are a type of artificial neural network used for various applications, including signal processing. Below is a Python code example demonstrating signal processing using an RBFN.

For this example, let’s use the scikit-learn library, which provides tools to work with RBFNs through its RBFSampler and MLPRegressor classes.

Here is the Python code for signal processing using an RBFN:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.kernel_approximation import RBFSampler
from sklearn.linear_model import Ridge

# Generate a sample signal (e.g., a noisy sine wave)
np.random.seed(42)
n_samples = 100
X = np.linspace(0, 4 * np.pi, n_samples).reshape(-1, 1)
y = np.sin(X).ravel() + np.random.normal(scale=0.1, size=n_samples)

# Plot the original noisy signal
plt.figure(figsize=(10, 6))
plt.plot(X, y, label='Noisy signal')
plt.title('Original Noisy Signal')
plt.xlabel('Time')
plt.ylabel('Amplitude')
plt.legend()
plt.show()

# Use RBFSampler to approximate the RBF kernel
rbf_sampler = RBFSampler(gamma=1.0, n_components=100, random_state=42)
X_features = rbf_sampler.fit_transform(X)

# Train a Ridge regression model on the RBF features
model = Ridge(alpha=1.0)
model.fit(X_features, y)

# Predict the signal using the trained model
y_pred = model.predict(X_features)

# Plot the original noisy signal and the filtered signal
plt.figure(figsize=(10, 6))
plt.plot(X, y, label='Noisy signal')
plt.plot(X, y_pred, label='Filtered signal', color='red')
plt.title('Signal Processing using RBFN')
plt.xlabel('Time')
plt.ylabel('Amplitude')
plt.legend()
plt.show()

To execute the code above seamlessly without any errors, we can utilize the PyScripter IDE.

What did the code above do?

1. Generate a Sample Signal 

We create a noisy sine wave as an example signal.

2. Plot the Original Noisy Signal 

We visualize the noisy signal.

3. RBFSampler 

We use the RBFSampler to approximate the RBF kernel, transforming the input data X into a higher-dimensional feature space.

4. Ridge Regression

We use Ridge regression on the transformed features to fit the model. Ridge regression is used here due to its robustness in handling collinearity and overfitting.

5. Predict the Signal

We use the trained model to predict the signal.

6. Plot the Original and Filtered Signal

We visualize the noisy signal alongside the filtered signal obtained through the RBFN.

Notes

• The parameter gamma in RBFSampler controls the width of the RBF kernel. You might need to tune this parameter for your specific application.
• The n_components parameter determines the number of features generated by the RBFSampler. Increasing this value can improve the model’s performance but will also increase computational complexity.
• Ridge regression is used for its simplicity and effectiveness in this example. Depending on your application, other regression methods or neural network models could be used.

This code provides a basic framework for using RBFNs for signal processing tasks. You can further customize and optimize it for your specific requirements.

Conclusion

Radial Basis Function Networks (RBFNs) are a versatile and powerful tool in the deep learning and machine learning toolbox, particularly suited for tasks such as interpolation, classification, and regression. Their unique architecture and use of radial basis functions as activation functions allow them to effectively capture local patterns in data, making them highly valuable for specific applications.

By leveraging the power of Python and its rich ecosystem of libraries, you can efficiently implement and experiment with RBFNs for a wide range of tasks. Whether you are tackling stock market predictions, anomaly detection, or signal processing, Python’s straightforward syntax, extensive libraries, and strong community support make it an ideal choice for developing deep learning models.

RBFNs, with their simplicity and effectiveness, serve as building blocks for more complex neural networks and machine learning algorithms. While they may not always match the complexity and scalability of other models like Multilayer Perceptrons (MLPs) or Long Short-Term Memory networks (LSTMs), RBFNs offer a practical and interpretable approach to solving specific types of problems.

As you delve deeper into the world of deep learning and explore the capabilities of RBFNs, you’ll find that these networks provide a robust foundation for building intelligent systems that can learn and adapt. By continuously experimenting and refining your models, you can unlock the full potential of Python for deep learning with Radial Basis Function Networks.

Check out the full repository here:

github.com/Embarcadero/DL_Python06_RBFN

Click here to get started with PyScripter, a free, feature-rich, and lightweight Python IDE.

Download RAD Studio to create more powerful Python GUI Windows Apps in 5x less time.

Check out Python4Delphi, which makes it simple to create Python GUIs for Windows using Delphi.

Also, look into DelphiVCL, which makes it simple to create Windows GUIs with Python.

References & further readings

[1] Biswal, A. (2023). 

Top 10 Deep Learning Algorithms You Should Know in 2023. Simplilearn. simplilearn.com/tutorials/deep-learning-tutorial/deep-learning-algorithm

[2] Buhmann, M. D. (2000). 

Radial basis functions. Acta numerica, 9, 1-38.

[3] Jwo, D. J., Biswal, A., & Mir, I. A. (2023). 

Artificial neural networks for navigation systems: A review of recent research. Applied Sciences, 13(7), 4475.

[4] Lowe, D., & Broomhead, D. (1988). 

Multivariable functional interpolation and adaptive networks. Complex systems, 2(3), 321-355.

[5] Olabanjo, O. A., Wusu, A. S., & Manuel, M. (2022). 

A machine learning prediction of academic performance of secondary school students using radial basis function neural network. Trends in Neuroscience and Education, 29, 100190.

[6] Park, J., & Sandberg, I. W. (1991). 

Universal approximation using radial-basis-function networks. Neural computation, 3(2), 246-257.

[7] scikit-learn developers. (2007-2024).

1.17.1. Multi-layer Perceptron, in 1.17. Neural network models (supervised). scikit-learn docs. scikit-learn.org/stable/modules/ neural_networks_supervised.html#multi-layer-perceptron

[8] Simplilearn. (2023). 

What are Radial Basis Functions Neural Networks? Everything You Need to Know. Simplilearn. simplilearn.com/tutorials/machine-learning-tutorial/what-are-radial-basis-functions-neural-networks

The post Unlock the Power of Python for Deep Learning with Radial Basis Function Networks (RBFNs) first appeared on Python GUI.

Generative adversarial networks (GANs) are an exciting (and relatively) recent innovation in machine learning and deep learning. GANs are generative deep learning algorithms that create new data instances that resemble the training data. GAN has two components: A generator, which learns to generate fake data, and a discriminator, which learns from that false information.

GANs are also the engine behind DALL-E, a recent breakthrough from OpenAI that can generate images from any text description.

If you are interested in learning how to use Python for deep learning with generative adversarial networks (GANs); which are a powerful technique for creating realistic and diverse synthetic data, this article is perfect for you. 

Before we begin, let’s see the remarkable ability of DALL-E (GAN) to generate a seemingly scientific photo of an atom:

What is Deep Learning?

Deep learning, a branch of machine learning, addresses intricate problems through the utilization of artificial neural networks. These networks consist of interconnected nodes organized in multiple layers, extracting features from input data. Extensive datasets are employed to train these models, enabling them to identify patterns and correlations that might be challenging or impossible for humans to perceive.

The impact of deep learning on artificial intelligence has been substantial. It has paved the way for the development of intelligent systems capable of independent learning, adaptation, and decision-making. Deep learning has led to remarkable advancements in various domains, encompassing image and speech recognition, natural language processing, machine translation, text generation, image generation (as would be reviewed in this article), autonomous driving, and numerous others.

Why Python for Deep Learning?

Python has gained widespread popularity as a programming language due to its versatility and ease of use in diverse domains of computer science, especially in the field of deep learning. Thanks to its extensive range of libraries and frameworks specially tailored for deep learning, Python has emerged as a top choice among many machine learning professionals.

Python has emerged as the language of choice for deep learning, and here are some of the reasons why:

1. Simple to learn and use:

Python is a high-level programming language that is easy to learn and use, even for those who are new to programming. Its concise and uncomplicated syntax makes it easy to write and understand. This allows developers to concentrate on solving problems without worrying about the details of the language.

2. Abundant libraries and frameworks:

Python has a vast ecosystem of libraries and frameworks that cater specifically to deep learning. Some of these libraries include TensorFlow, PyTorch, Keras, and Theano. These libraries provide pre-built functions and modules that simplify the development process, reducing the need to write complex code from scratch.

3. Strong community support:

Python has a large and active community of developers contributing to its development, maintenance, and improvement. This community offers support and guidance to beginners, making it easier to learn and use Python for deep learning.

4. Platform independence:

Python is platform-independent, which means that code written on one platform can be easily executed on another platform without any modification. This makes it easier to deploy deep learning models on different platforms and devices.

5. Easy integration with other languages:

Python can be easily integrated with other programming languages, such as Delphi, C++, and Java, making it ideal for building complex systems that require integrating different technologies.

Overall, Python’s ease of use, an abundance of libraries and frameworks, strong community support, platform independence, and ease of integration with other languages make it an indispensable tool for machine learning practitioners. Its popularity continues to soar as a result.

What is DALL-E? A revolutionary image generation model

DALL-E is a remarkable GAN model that can generate images from text descriptions (even an intricate one), such as “a cat wearing a bow tie” or “a painting of a landscape in the style of Van Gogh”. It is based on a large-scale dataset of text-image pairs, and a transformer architecture that can encode both text and image modalities.

DALL-E can create plausible and diverse images for a wide range of concepts, such as animals, objects, scenes, and transformations, and control their attributes, viewpoints, and perspectives. DALL-E can also combine multiple concepts, such as “an armchair in the shape of an avocado” or “a snail made of a harp”, and generate novel and creative images that do not exist in the real world. DALL-E demonstrates the power and potential of GANs for image synthesis and multimodal understanding.

Applications beyond DALL-E: GANs in various domains

DALL-E is based on a large-scale dataset of text-image pairs, and a transformer architecture that can encode both text and image modalities. DALL-E demonstrates the power and potential of GANs for image synthesis and multimodal understanding.

However, DALL-E is not the only application of GANs. GANs have been successfully applied to various domains and tasks, such as computer vision, natural language generation, audio synthesis, video prediction, and more. Some of the examples of GAN applications are:

1. Image generation

GANs can generate realistic and diverse images of objects, scenes, faces, animals, and more, from random noise or text descriptions.

2. Image-to-image translation

GANs can transform images from one domain to another, such as changing the style, season, or content of the images.

3. Image enhancement

GANs can improve the quality and resolution of images, such as super-resolution, deblurring, denoising, inpainting, and colorization.

4. Text generation

GANs can generate realistic and diverse texts, such as stories, poems, reviews, captions, and more, from random noise or keywords.

5. Text-to-speech

GANs can synthesize natural and expressive speech from text, such as voice cloning, style transfer, and emotion modulation.

6. Speech enhancement

GANs can improve the quality and intelligibility of speech, such as noise reduction, dereverberation, and bandwidth extension.

7. Video generation

GANs can generate realistic and diverse videos, such as animations, simulations, and future predictions, from random noise or text descriptions.

8. Video-to-video translation

GANs can transform videos from one domain to another, such as changing the style, content, or viewpoint of the videos.

What is Generative Adversarial Networks (GANs)?

Generative Adversarial Networks (GANs) are a breakthrough innovation in deep learning that can generate realistic and diverse data from random noise or text descriptions. GANs have many applications in various domains, such as computer vision, natural language generation, audio synthesis, and more. GANs can also enable creativity, accessibility, and fairness by generating novel and inclusive data that do not exist in the real world.

GANs consist of two neural networks that compete with each other in a game-like scenario: 

1. Discriminator

A discriminator that tries to distinguish between real and fake data.

More formally, given a set of data instances X and a set of labels Y: Discriminative models capture the conditional probability p(Y | X).

Illustration of the discriminative model in the handwritten digits generation use cases (we will explore the hands-on of it in the next sections):

2. Generator

A generator that tries to create fake data.

More formally, given a set of data instances X and a set of labels Y: Generative models capture the joint probability p(X, Y), or just p(X) if there are no labels.

Illustration of generative model in the handwritten digits generation use cases (we will explore the hands-on of it in the next sections):

The discriminator and the generator are trained simultaneously, in an adversarial manner, until they reach an equilibrium, where the generator can fool the discriminator about half the time. GANs can learn to produce high-quality and diverse data, such as images, text, audio, and video, by leveraging large-scale datasets and advanced network architectures.

Here’s a picture of the whole GAN system:

What are Python tools and libraries needed for GAN development?

Python is one of the most popular and widely used programming languages for machine learning and artificial intelligence, especially for developing generative adversarial networks (GANs). Python offers a rich set of tools and libraries that can help you implement and train GAN models with ease and efficiency. 

Some of the most useful and popular Python tools and libraries for GAN development are:

1. PyTorch

PyTorch is an open-source deep learning framework that provides a flexible and dynamic way of building and running GAN models. PyTorch supports automatic differentiation, GPU acceleration, distributed training, and various GAN architectures and loss functions. PyTorch also has a large and active community that contributes to the development and improvement of the framework^[10].

2. TensorFlow

TensorFlow is another open-source deep learning framework that offers a comprehensive and scalable platform for building and deploying GAN models. TensorFlow supports eager execution, graph optimization, tensor operations, and various GAN architectures and loss functions. TensorFlow also has a high-level API called Keras, which simplifies the process of creating and training GAN models^[10].

3. PyGAN

PyGAN is a Python library that implements GANs and its variants, such as conditional GANs, adversarial auto-encoders, and energy-based GANs. PyGAN allows you to design generative models based on statistical machine learning problems and optimize them using various algorithms and metrics^[10].

4. TorchGAN

TorchGAN is a Python library that provides a collection of GAN models, loss functions, and evaluation metrics, built on top of PyTorch. TorchGAN enables you to easily create and customize your own GAN models, as well as reproduce the results of existing GAN papers^[10].

5. VeGANs

VeGANs is another Python library that provides a variety of GAN models, loss functions, and evaluation metrics, built on top of PyTorch. VeGANs aims to make GAN development accessible and user-friendly, by offering a simple and consistent interface, as well as tutorials and examples^[10].

Without further ado, let’s get our hands dirty with the hands-on GANs with Python, with three different use cases: Numerical mathematics (approximate a plot of a sine function), generating handwritten digits, and generating realistic human faces.

Hands-On GAN 1: Generate random numbers using GAN, to approximate sine plot

In this section, we will explore how GANs can be used to generate data that follows a simple sine function, between interval 0 and 2π. We will implement a GAN using PyTorch and show how the generator and the discriminator networks interact and improve over time. We will also demonstrate the results of our GAN by comparing the generated data with the original sine function data.

The following is the complete Python code to automatically generate random numbers using GAN, to approximate sine plot:

import torch
from torch import nn
import math
import matplotlib.pyplot as plt

torch.manual_seed(111)

train_data_length = 1024
train_data = torch.zeros((train_data_length, 2))
train_data[:, 0] = 2 * math.pi * torch.rand(train_data_length)
train_data[:, 1] = torch.sin(train_data[:, 0])
train_labels = torch.zeros(train_data_length)
train_set = [
    (train_data[i], train_labels[i]) for i in range(train_data_length)
]

# Plot training data
plt.plot(train_data[:, 0], train_data[:, 1], ".")
plt.show()

# Create a PyTorch data loader
batch_size = 32
train_loader = torch.utils.data.DataLoader(
    train_set, batch_size=batch_size, shuffle=True
)

# Implementing the Discriminator
class Discriminator(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Linear(2, 256),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(64, 1),
            nn.Sigmoid(),
        )

    def forward(self, x):
        output = self.model(x)
        return output

# Instantiate a Discriminator object
discriminator = Discriminator()

# Implementing the Generator
class Generator(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Linear(2, 16),
            nn.ReLU(),
            nn.Linear(16, 32),
            nn.ReLU(),
            nn.Linear(32, 2),
        )

    def forward(self, x):
        output = self.model(x)
        return output

generator = Generator()

# Training the models
lr = 0.001
num_epochs = 300
loss_function = nn.BCELoss()

# Create the optimizers using Adam optimizer
optimizer_discriminator = torch.optim.Adam(discriminator.parameters(), lr=lr)
optimizer_generator = torch.optim.Adam(generator.parameters(), lr=lr)

# Implement a training loop in which training samples are fed to the models, and their weights are updated to minimize the loss function:
for epoch in range(num_epochs):
    for n, (real_samples, _) in enumerate(train_loader):
        # Data for training the discriminator
        real_samples_labels = torch.ones((batch_size, 1))
        latent_space_samples = torch.randn((batch_size, 2))
        generated_samples = generator(latent_space_samples)
        generated_samples_labels = torch.zeros((batch_size, 1))
        all_samples = torch.cat((real_samples, generated_samples))
        all_samples_labels = torch.cat(
            (real_samples_labels, generated_samples_labels)
        )

        # Training the discriminator
        discriminator.zero_grad()
        output_discriminator = discriminator(all_samples)
        loss_discriminator = loss_function(
            output_discriminator, all_samples_labels)
        loss_discriminator.backward()
        optimizer_discriminator.step()

        # Data for training the generator
        latent_space_samples = torch.randn((batch_size, 2))

        # Training the generator
        generator.zero_grad()
        generated_samples = generator(latent_space_samples)
        output_discriminator_generated = discriminator(generated_samples)
        loss_generator = loss_function(
            output_discriminator_generated, real_samples_labels
        )
        loss_generator.backward()
        optimizer_generator.step()

        # Show loss
        if epoch % 10 == 0 and n == batch_size - 1:
            print(f"Epoch: {epoch} Loss D.: {loss_discriminator}")
            print(f"Epoch: {epoch} Loss G.: {loss_generator}")

# Checking the samples generated by the GAN
latent_space_samples = torch.randn(100, 2)
generated_samples = generator(latent_space_samples)

generated_samples = generated_samples.detach()
plt.plot(generated_samples[:, 0], generated_samples[:, 1], ".")
plt.show()

To execute the code above seamlessly without any errors, we can utilize the PyScripter IDE.

What did the code above do?

Let’s break down the important parts of the code above:

1. Data generation:

• train_data_length specifies the number of data points to be generated.
• train_data is a tensor of shape (train_data_length, 2) where the first column represents random values between 0 and 2π, and the second column is the sine of the first column.
• train_labels is a tensor of zeros.
• train_set is a list of tuples, each containing a data point and its corresponding label.

2. Data visualization:

• The generated training data is plotted using matplotlib.

3. Data loader:

• batch_size is set to 32.
• train_loader is a PyTorch data loader that shuffles and batches the training data.

4. Discriminator model:

• The Discriminator class is defined as a subclass of nn.Module.
• It consists of a feedforward neural network with layers of sizes 2 (input) → 256 → 128 → 64 → 1, followed by a Sigmoid activation.
• Dropout layers with a dropout probability of 0.3 are added for regularization.

5. Generator model:

• The Generator class is defined, similar to the Discriminator.
• It is a neural network with layers of sizes 2 (input) → 16 → 32 → 2.

6. Model initialization:

• Instances of the Discriminator and Generator classes are created.

7. Training configuration:

• Learning rate (lr) is set to 0.001.
• num_epochs is set to 300.
• Binary Cross Entropy Loss (nn.BCELoss()) is used as the loss function.

8. Optimizer initialization:

• Adam optimizers are created for both the discriminator and generator.

9. Training loop:

• The code runs a training loop for the specified number of epochs.
• For each epoch, it iterates through batches of data from the train_loader.
• For the discriminator:
• For the generator:
• Losses for the discriminator and generator are printed every 10 epochs.

10. Generated samples visualization:

• After training, 100 samples are generated using the trained generator, and they are plotted.

In summary, the code above implements a simple Generative Adversarial Network (GAN) where the generator and discriminator are trained adversarially to generate realistic samples. The generator generates fake samples to try and fool the discriminator, while the discriminator learns to distinguish between real and fake samples.

Here are a few selected outputs from all the process above:

Selected outputs:

Examine the training data by plotting each point (x₁, x₂):

Plot the generated samples. We show you the screenshot of the plotting results in epoch 300, which almost perfectly resemble the sine plot:

To see the progression between epoch (from 0 to 300) more clearly, please watch the following video:

Hands-On GAN 2: Generate handwritten digits using GAN

In this section, we will explore how GANs can be used to generate realistic images of handwritten digits. For that, you’ll train the models using the MNIST dataset of handwritten digits, which is included in the torchvision package. We will implement a GAN using PyTorch and show how the generator will produce fake images and the discriminator will try to tell them apart.

The following is the complete Python code to automatically generate handwritten digits using GAN:

import torch
from torch import nn, optim
import torchvision
import torchvision.transforms as transforms
import math
import matplotlib.pyplot as plt
import os

torch.manual_seed(111)

device = ''
if torch.cuda.is_available():
    device = torch.device('cuda')
else:
    device = torch.device('cpu')

transform = transforms.Compose(
    [transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))])

train_set = torchvision.datasets.MNIST(root='.',
                                       train=True,
                                       download=True,
                                       transform=transform)

batch_size = 32
train_loader = torch.utils.data.DataLoader(train_set,
                                           batch_size=batch_size,
                                           shuffle=True)

plt.figure(dpi=150)
real_samples, mnist_labels = next(iter(train_loader))
for i in range(16):
    ax = plt.subplot(4, 4, i+1)
    plt.imshow(real_samples[i].reshape(28, 28), cmap='gray_r')
    plt.xticks([])
    plt.yticks([])
plt.tight_layout()

class Discriminator(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Linear(784, 1024),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(1024, 512),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )

    def forward(self, x):
        x = x.view(x.size(0), 784)
        output = self.model(x)
        return output

discriminator = Discriminator().to(device=device)

class Generator(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Linear(100, 256),
            nn.ReLU(),
            nn.Linear(256, 512),
            nn.ReLU(),
            nn.Linear(512, 1024),
            nn.ReLU(),
            nn.Linear(1024, 784),
            nn.Tanh()
        )

    def forward(self, x):
        #x = x.view(x.size(0), 100)
        output = self.model(x)
        output = output.view(x.size(0), 1, 28, 28)
        return output

generator = Generator().to(device=device)

lr = 0.0001
num_epochs = 50
loss_function = nn.BCELoss()

optimizer_discriminator = torch.optim.Adam(discriminator.parameters(), lr=lr)
optimizer_generator = torch.optim.Adam(generator.parameters(), lr=lr)

latent_space_samples_plot = torch.randn((16, 100)).to(device=device)

# Load trained NN when it exists, or train a new NN
if os.path.isfile('discriminator.pt') and os.path.isfile('generator.pt'):
    discriminator.load_state_dict(torch.load('./discriminator.pt'))
    generator.load_state_dict(torch.load('./generator.pt'))
else:
    for epoch in range(num_epochs):
        for n, (real_samples, mnist_labels) in enumerate(train_loader):
            # Data for training the discriminator
            real_samples = real_samples.to(device=device)
            real_samples_labels = torch.ones((batch_size, 1)).to(device=device)
            latent_space_samples = torch.randn((batch_size, 100)).to(device=device)
            generated_samples = generator(latent_space_samples)
            generated_samples_labels = torch.zeros(
                (batch_size, 1)).to(device=device)
            all_samples = torch.cat((real_samples, generated_samples))
            all_samples_labels = torch.cat(
                (real_samples_labels, generated_samples_labels))

            # Training the discriminator
            discriminator.zero_grad()
            output_discriminator = discriminator(all_samples)
            loss_discriminator = loss_function(
                output_discriminator, all_samples_labels)
            loss_discriminator.backward()
            optimizer_discriminator.step()

            # Data for training the generator
            latent_space_samples = torch.randn((batch_size, 100)).to(device=device)

            # Training the generator
            generator.zero_grad()
            generated_samples = generator(latent_space_samples)
            output_discriminator_generated = discriminator(generated_samples)
            loss_generator = loss_function(
                output_discriminator_generated, real_samples_labels)
            loss_generator.backward()
            optimizer_generator.step()

            # Show loss
        	if n == batch_size - 1:
                print(f"Epoch: {epoch} Loss D.: {loss_discriminator}")
                print(f"Epoch: {epoch} Loss G.: {loss_generator}")

latent_space_samples = torch.randn(batch_size, 100).to(device=device)

generated_samples = generator(latent_space_samples)

generated_samples = generated_samples.cpu().detach()
plt.figure(dpi=150)
for i in range(16):
    ax = plt.subplot(4, 4, i+1)
    plt.imshow(generated_samples[i].reshape(28, 28), cmap='gray_r')
    plt.xticks([])
    plt.yticks([])
plt.tight_layout()

# Save trained NN parameters
torch.save(generator.state_dict(), 'generator.pt')
torch.save(discriminator.state_dict(), 'discriminator.pt')

To execute the code provided seamlessly, without any errors, we can utilize the PyScripter IDE.

What did the code above do?

Let’s break down the important parts of the code above:

1. Importing necessary libraries

• torch for PyTorch, 
• nn for neural network modules, 
• optim for optimizers, 
• torchvision for handling datasets like MNIST, 
• transforms for data transformations, 
• math for mathematical functions, 
• matplotlib.pyplot for plotting, and 
• os for operating system related functions.

2. Checking if a CUDA-enabled GPU is available and setting the device accordingly.

3. Defining a data transformation pipeline using transforms.Compose. 

It converts the images to PyTorch tensors and normalizes them.

4. Loading the MNIST dataset for training, 

specifying the root directory, setting it for training, downloading it if not available, and applying the defined transformation.

5. Creating a PyTorch data loader to handle batching and shuffling of the training data.

6. Plotting 16 real samples from the MNIST dataset using matplotlib.

7. Defining the Discriminator class, 

which is a neural network with several fully connected layers, ReLU activations, and Dropout layers. The final layer has a Sigmoid activation.

8. Implementing the forward method for the Discriminator class

and creating an instance of the Discriminator class, moving it to the specified device.

9. Defining the Generator class, 

which is another neural network with fully connected layers, ReLU activations, and a hyperbolic tangent (Tanh) activation.

10. Implementing the forward method for the Generator class

and creating an instance of the Generator class, moving it to the specified device.

11. Setting hyperparameters: 

• learning rate (lr), 
• number of epochs (num_epochs), and using 
• Binary Cross Entropy Loss (nn.BCELoss()). 
• Initializing Adam optimizers for both the discriminator and generator.

12. Generating random samples in the latent space for visualization.

13. Loading pre-trained models if available, 

otherwise training the models for a specified number of epochs.

14. Generating and plotting 16 samples from the generator.

15. Saving the trained model parameters for future use.

Here are a few selected outputs from all the process above:

Selected outputs:

Download and extract the dataset:

Train the model with seed=111:

The following is the visualization of the excerpt of the MNIST dataset:

vs the results of generated handwriting by GAN in epoch 50:

To see the progression between epoch (from 0 to 50) more clearly, please see the following video:

Hands-On 3: Generate realistic human faces using GAN

In this section, we will learn how to generate realistic human faces using GANs. The GAN consists of two competing networks: A generator that creates fake images from random noise, and a discriminator that distinguishes real images from fake ones. We will use a large dataset of celebrity images to train our GAN and produce high-quality and diverse faces. However, as this task consumes large computational power, we will perform it using Kaggle’s GPU, while we will also show you the limitations and challenges of using a regular laptop.

Introduction to Kaggle’s GPU Options: P100 vs. T4

Kaggle offers its users a 30-hour weekly time cap for GPU access, allowing them to choose between NVIDIA T4 and P100 GPUs. However, many Kaggle users may lack clarity on which GPU is best suited for their specific needs.

In general, the T4 GPU is an optimal choice for inference workloads that demand high throughput and low power consumption. On the other hand, the P100 GPU excels in handling training workloads, thanks to its superior performance and increased memory capacity.^[11].

It’s important to note that TPUs (Tensor Processing Units) are not part of this comparison, as they represent a distinct type of hardware accelerator designed by Google. When considering GPUs, the P100 is recommended for training tasks, while both the GPU P100 and GPU T4 can be utilized for inference purposes. Selecting the appropriate GPU depends on the specific requirements of the given machine learning task.^[11].

The complete code for generating realistic human faces using GAN, and what did it do?

The following is the complete Python code to automatically generate realistic human faces using GAN:

import numpy as np # Linear algebra
import pandas as pd # Data processing, CSV file I/O (e.g. pd.read_csv)
import os
from matplotlib import pyplot as plt
from tqdm import tqdm
from PIL import Image as Img
from keras import Input
from keras.layers import Dense, Reshape, LeakyReLU, Conv2D, Conv2DTranspose, Flatten, Dropout
from keras.models import Model
from keras.optimizers import RMSprop

for dirname, _, filenames in os.walk('/kaggle/input'):
    for filename in filenames:
        print(os.path.join(dirname, filename))

# Load the data and resize the images
PIC_DIR = f'../input/celeba-dataset/img_align_celeba/img_align_celeba/'

IMAGES_COUNT = 10000

ORIG_WIDTH = 178
ORIG_HEIGHT = 208
diff = (ORIG_HEIGHT - ORIG_WIDTH) // 2

WIDTH = 128
HEIGHT = 128

crop_rect = (0, diff, ORIG_WIDTH, ORIG_HEIGHT - diff)

images = []
for pic_file in tqdm(os.listdir(PIC_DIR)[:IMAGES_COUNT]):
    pic = Image.open(PIC_DIR + pic_file).crop(crop_rect)
    pic.thumbnail((WIDTH, HEIGHT), Image.ANTIALIAS)
    images.append(np.uint8(pic))

#Image shape
images = np.array(images) / 255
print(images.shape)

#Display first 25 images
plt.figure(1, figsize=(10, 10))
for i in range(25):
    plt.subplot(5, 5, i+1)
    plt.imshow(images[i])
    plt.axis('off')
plt.show()

# Create Generator
LATENT_DIM = 32
CHANNELS = 3

def create_generator():
    gen_input = Input(shape=(LATENT_DIM, ))

    x = Dense(128 * 16 * 16)(gen_input)
    x = LeakyReLU()(x)
    x = Reshape((16, 16, 128))(x)

    x = Conv2D(256, 5, padding='same')(x)
    x = LeakyReLU()(x)

    x = Conv2DTranspose(256, 4, strides=2, padding='same')(x)
    x = LeakyReLU()(x)

    x = Conv2DTranspose(256, 4, strides=2, padding='same')(x)
    x = LeakyReLU()(x)

    x = Conv2DTranspose(256, 4, strides=2, padding='same')(x)
    x = LeakyReLU()(x)

    x = Conv2D(512, 5, padding='same')(x)
    x = LeakyReLU()(x)
    x = Conv2D(512, 5, padding='same')(x)
    x = LeakyReLU()(x)
    x = Conv2D(CHANNELS, 7, activation='tanh', padding='same')(x)

    generator = Model(gen_input, x)
    return generator

# Create Discriminator
def create_discriminator():
    disc_input = Input(shape=(HEIGHT, WIDTH, CHANNELS))

    x = Conv2D(256, 3)(disc_input)
    x = LeakyReLU()(x)

    x = Conv2D(256, 4, strides=2)(x)
    x = LeakyReLU()(x)

    x = Conv2D(256, 4, strides=2)(x)
    x = LeakyReLU()(x)

    x = Conv2D(256, 4, strides=2)(x)
    x = LeakyReLU()(x)

    x = Conv2D(256, 4, strides=2)(x)
    x = LeakyReLU()(x)

    x = Flatten()(x)
    x = Dropout(0.4)(x)

    x = Dense(1, activation='sigmoid')(x)
    discriminator = Model(disc_input, x)

    optimizer = RMSprop(
        lr=.0001,
        clipvalue=1.0,
        decay=1e-8
    )

    discriminator.compile(
        optimizer=optimizer,
        loss='binary_crossentropy'
    )

    return discriminator

# Define a GAN Model
from IPython.display import Image
from keras.utils.vis_utils import model_to_dot

generator = create_generator()
generator.summary()

Image(model_to_dot(generator, show_shapes=True).create_png())

discriminator = create_discriminator()
discriminator.trainable = False
discriminator.summary()

Image(model_to_dot(discriminator, show_shapes=True).create_png())

gan_input = Input(shape=(LATENT_DIM, ))
gan_output = discriminator(generator(gan_input))
gan = Model(gan_input, gan_output)

optimizer = RMSprop(lr=.0001, clipvalue=1.0, decay=1e-8)
gan.compile(optimizer=optimizer, loss='binary_crossentropy')

gan.summary()

# Training the GAN model
import time

iters = 15000
batch_size = 16

RES_DIR = 'res2'
FILE_PATH = '%s/generated_%d.png'
if not os.path.isdir(RES_DIR):
    os.mkdir(RES_DIR)

CONTROL_SIZE_SQRT = 6
control_vectors = np.random.normal(size=(CONTROL_SIZE_SQRT**2, LATENT_DIM)) / 2

start = 0
d_losses = []
a_losses = []
images_saved = 0

for step in range(iters):
    start_time = time.time()
    latent_vectors = np.random.normal(size=(batch_size, LATENT_DIM))
    generated = generator.predict(latent_vectors)

    real = images[start:start + batch_size]
    combined_images = np.concatenate([generated, real])

    labels = np.concatenate([np.ones((batch_size, 1)), np.zeros((batch_size, 1))])
    labels += .05 * np.random.random(labels.shape)

    d_loss = discriminator.train_on_batch(combined_images, labels)
    d_losses.append(d_loss)

    latent_vectors = np.random.normal(size=(batch_size, LATENT_DIM))
    misleading_targets = np.zeros((batch_size, 1))

    a_loss = gan.train_on_batch(latent_vectors, misleading_targets)
    a_losses.append(a_loss)

    start += batch_size
    if start > images.shape[0] - batch_size:
        start = 0

    if step % 50 == 49:
        gan.save_weights('/gan.h5')

        print('%d/%d: d_loss: %.4f,  a_loss: %.4f.  (%.1f sec)' % (step + 1, iters, d_loss, a_loss, time.time() - start_time))

        control_image = np.zeros((WIDTH * CONTROL_SIZE_SQRT, HEIGHT * CONTROL_SIZE_SQRT, CHANNELS))
        control_generated = generator.predict(control_vectors)

        for i in range(CONTROL_SIZE_SQRT ** 2):
            x_off = i % CONTROL_SIZE_SQRT
            y_off = i // CONTROL_SIZE_SQRT
            control_image[x_off * WIDTH:(x_off + 1) * WIDTH, y_off * HEIGHT:(y_off + 1) * HEIGHT, :] = control_generated[i, :, :, :]
        im = Img.fromarray(np.uint8(control_image * 255))#.save(StringIO(), 'jpeg')
        im.save(FILE_PATH % (RES_DIR, images_saved))
        images_saved += 1

plt.figure(1, figsize=(12, 8))
plt.subplot(121)
plt.plot(d_losses, color='red')
plt.xlabel('epochs')
plt.ylabel('discriminant losses')
plt.subplot(122)
plt.plot(a_losses)
plt.xlabel('epochs')
plt.ylabel('adversary losses')
plt.show()

To execute the code provided seamlessly, without any errors, we can utilize the PyScripter IDE.

Let’s break down the important parts of the code above:

1. Importing necessary libraries for:

• numerical operations (numpy), 
• data processing (pandas), 
• plotting (matplotlib), 
• tqdm for progress bars, and
• components from keras for building a Generative Adversarial Network (GAN).

2. Walking through the Kaggle input directory and printing the filenames.

3. Setting up parameters for loading and resizing images from the CelebA dataset.

Cropping and resizing images to a specified size.

4. Converting the list of images to a NumPy array 

and normalizing pixel values to the range [0, 1].

5. Displaying the first 25 images from the dataset.

6. Defining the generator model architecture using Keras.

7. Defining the discriminator model architecture using Keras.

8. Creating an instance of the generator and displaying its summary.

9. Creating an instance of the discriminator and displaying its summary. 

Setting trainable to False to prevent it from being trained during the GAN training phase.

10. Creating the GAN model by connecting the generator and discriminator. 

Compiling the GAN model with a binary cross-entropy loss.

11. Setting up parameters for training the GAN model and creating directories for saving generated images.

12. Training the GAN model, 

• saving weights periodically, and plotting the losses during training. 
• Images are also generated and saved for visualization.

Selected outputs:

Load and resize CelebA dataset:

Show image shape:

Display first 25 images:

Generator summary:

Generator scheme (as generated automatically using model_to_dot function from keras.utils.vis_utils):

Discriminator summary:

Discriminator scheme (also generated automatically using model_to_dot function from keras.utils.vis_utils):

GAN summary:

_________________________________________________________________
Model: "model_2"
_________________________________________________________________
Layer (type)             	Output Shape          	Param #   
=================================================================
input_3 (InputLayer)     	[(None, 32)]          	0    	 
_________________________________________________________________
model (Functional)       	(None, 128, 128, 3)   	14953987  
_________________________________________________________________
model_1 (Functional)     	(None, 1)             	4211713   
=================================================================
Total params: 19,165,700
Trainable params: 14,953,987
Non-trainable params: 4,211,713
_________________________________________________________________

After the step above, further training and output production would require a sufficient GPU, so, for the next steps, I move on using Kaggle (with GPU P100 as accelerator). 

Here is the screenshot of the last step that can be done without GPU using PyScripter IDE (if you have your own GPU, you can continue run the code on your PyScripter IDE seamlessly):

Plot of Discriminant and Adversary losses:

Quoting Reference [3] to help in interpreting the plot of Discriminant and Adversary losses: “GAN convergence is hard to identify. As the generator improves with training, the discriminator performance gets worse because the discriminator can’t easily tell the difference between real and fake. If the generator succeeds perfectly, then the discriminator has a 50% accuracy. In effect, the discriminator flips a coin to make its prediction.

This progression poses a problem for convergence of the GAN as a whole: the discriminator feedback gets less meaningful over time. If the GAN continues training past the point when the discriminator is giving completely random feedback, then the generator starts to train on junk feedback, and its quality may collapse.”

After 300 epochs, the code would produce the following realistic human faces:

• On Kaggle /output:

• On my computer:

Image output for the first epoch (0) vs the 300th epoch (299):

To see the progression between epoch (from 0 to 299) more clearly, please see the following video:

Out of curiosity, I retrain the model until epoch 599, which you can see the results (from epoch 300 to 599) in the following video:

Conclusion

GANs are a powerful and versatile class of deep generative models that can produce realistic and diverse data, such as images, text, audio, and video, from random noise. You also learned how GANs can generate realistic and diverse data using text descriptions as demonstrated by DALL-E.

This article has highlighted and demonstrated the potential use of deep learning, specifically within the context of the GANs architecture in the domain of numerical mathematics (approximate a plot of a function), generating handwritten digits, and generating realistic human faces. All are implemented with hands-on Python examples.

I hope this article was successful in giving you a comprehensive and accessible introduction to GANs, and a solid understanding and workflow of how to implement GANs to your domains and project goals, so, it would inspire you to learn more and experiment with GANs yourself.

Check out the full repository here:

github.com/Embarcadero/DL_Python05_GAN

Click here to get started with PyScripter, a free, feature-rich, and lightweight Python IDE.

Download RAD Studio to create more powerful Python GUI Windows Apps in 5x less time.

Check out Python4Delphi, which makes it simple to create Python GUIs for Windows using Delphi.

Also, look into DelphiVCL, which makes it simple to create Windows GUIs with Python.

References & further readings

[1] Biswal, A. (2023).

Top 10 Deep Learning Algorithms You Should Know in 2023. Simplilearn. simplilearn.com/tutorials/deep-learning-tutorial/deep-learning-algorithm.

[2] Candido, R. (2021).

Generative Adversarial Networks: Build Your First Models. Real Python. realpython.com/generative-adversarial-networks.

[3] Chauhan, N. S. (2021).

Generate Realistic Human Face using GAN. Kaggle. kaggle.com/code/nageshsingh/generate-realistic-human-face-using-gan.

[4] Google for Developers. (2024).

Generative Adversarial Networks. Advanced courses, machine learning, Google for Developers. developers.google.com/machine-learning/gan.

[5] LeCun, Y. (1998).

The MNIST database of handwritten digits. yann.lecun.com/exdb/mnist.

[6] Liu, Z., Luo, P., Wang, X., & Tang, X. (2018).

Large-scale celebfaces attributes (celeba) dataset. Retrieved August, 15(2018), 11. mmlab.ie.cuhk.edu.hk/projects/CelebA.html.

[7] Goodfellow, I., Pouget-Abadie, J., Mirza, M., Xu, B., Warde-Farley, D., Ozair, S., … & Bengio, Y. (2014).

Generative adversarial nets. Advances in neural information processing systems, 27.

[8] Goodfellow, I., Pouget-Abadie, J., Mirza, M., Xu, B., Warde-Farley, D., Ozair, S., … & Bengio, Y. (2020).

Generative adversarial networks. Communications of the ACM, 63(11), 139-144.

[9] Ramesh, A., Pavlov, M., Goh, G., Gray, S., Chen, M., Child, R., Misra, V., Mishkin, P., Krueger, G., Agarwal, S., & Sutskever, I. (2015-2023).

DALL·E: Creating images from text. DALL-E, OpenAI research. openai.com/research/dall-e.

[10] Sagar, R. (2020).

Top Libraries For Quick Implementation Of GANs. Analytics India Magazine. analyticsindiamag.com/generative-adversarial-networks-python-libraries.

[11] Siddhartha. (2023).

GPU T4 vs GPU P100 | Kaggle | GPU. Medium. siddhartha01writes.medium.com/gpu-t4-vs-gpu-p100-kaggle-gpu-cd852d56022c.

The post Unlock the Power of Python for Deep Learning with Generative Adversarial Networks (GANs) – The Engine behind DALL-E first appeared on Python GUI.

Our destination? An elegant form housing a search bar that opens up a world of meteorological insight. With three distinct tabs – historical, current, and prediction – we’ll explore the weather’s past, present, and future, bringing it all to your fingertips. So, let’s dive into the world of weather forecasting with DelphiFMX and Weatherstack, and let the forecasts begin!

How to Build a Feature-Packed Weather App With Delphi FMX?

Creating a weather application with DelphiFMX involves a series of key steps. First, install the Delphi Integrated Development Environment (IDE) and the Python FireMonkey GUI framework on your PC. These are the fundamental tools you’ll need to craft your weather app. Also, ensure you have the Delphi4PythonExporter tool set up along with a text editor or an IDE that supports Python, such as PyScripter. If you haven’t set up these essential tools yet, consider referring to the article “Setting Up a Robust Python GUI Project” for a head start.

Furthermore, it’s crucial to prepare for data retrieval from Weatherstack API. To do this, sign up and subscribe to a plan on Weatherstack’s website. While this tutorial uses the plan providing access to all endpoints, you can certainly begin with the free plan, utilizing the current weather endpoint to get started.

To access the source code and resources for this tutorial, you can download them from our GitHub repository using the following link:

https://github.com/Embarcadero/PythonBlogExamples/tree/main/WeatherApp

What Kind of a Form do I Need For this Python GUI App?

Let’s launch the Delphi application and set up a new project. Navigate to the File menu, choose New -> Multi-Device Application, and select Blank Application before clicking OK. For this tutorial, we’ve given our project the name “WeatherApp.”
If you’re not yet familiar with the different sections and features within the Delphi IDE, we recommend checking out our complimentary eBook bundle. This resource offers a comprehensive overview of the Delphi Python EcoSystem and various Python GUI offerings.

Now, let’s assign a name to our primary form. Right-click on the form and choose QuickEdit. In this case, we’ll name our form MainForm and add the caption Weather App.

To simplify file tracking, we’ll rename the source file for MainForm to WeatherApp.pas. Additionally, you can adjust the form’s dimensions using the Object Inspector, modifying ClientWidth and ClientHeight properties, or simply by dragging and resizing it with your mouse.

For this weather app, we’ll utilize the TTabControl component in the IDE to create two tabs on our form: one for current weather and the other for weather predictions. You can find this component in the Palette, and it can be added by simply dragging and dropping it onto the form.

How To Create A Weather App With The Python Delphi Ecosystem and Weatherstack API

Expand the component to cover the entire form area. This is how our form looks like.

Right-click on the component and select AddTabItem to add tabs to the form. As previously mentioned, we will include three tabs: one for displaying current weather, one for historical weather data, and another for future weather predictions. Then, use QuickEdit to rename the tabs to Current, Historical, and Prediction respectively.

Before, adding components to our tabs, let’s add a drop down menu, using the TComboBox component to help the user select a city for the app, as well as a few TLabel components. We will also use the text settings property of each label to make them more visually appealing. Here is what our form looks like:

Now that we’ve completed the top of our form, let’s start adding components to each tab of our TTabControl component. We will start by opening up the prediction tab of our form. Here we will be adding three different components. The TMemo component will be used to show the user the weather data. A TSpinBox component will be used to ask the user the number of days after which the user will show the data. Finally a TButton component will be used to call on the API to retrieve the weather data. We will also add a few TLabel components to help the user navigate through the form. Here is what our form looks like:

Now that our prediction tab is completed let’s complete our Current weather tab. Start by opening up the tab, and just like the Prediction tab, we will be adding a TMemo component to display our results as well as a TButton component to get the data. In addition, we will also be adding a TImage component that will be used to display an image consistent with our current weather. Here is what our form looks like:

Finally, let’s add some components to our Historical tab. Similar to the Prediction and Current Tab’s we will be adding a TButton and TMemo component. However, we will also be adding a TCalender component to help the user select the data for a specific historical date. Here is what our form looks like:

Now that we are done with the form’s, let’s infuse some style to make them more appealing. To do this, you’ll need to obtain the free eBook bundle, which includes various styles. Download the eBook and extract the FMX styles ZIP file to your preferred directory. Now select the style you want to use, in this tutorial we’ll be using the Dark.style from the bundle.

Now Go to the Palette and add the TStyleBook component to your form.

Double-click on the StyleBook1 component to access the Style Designer. Now click the open button, which will prompt a dialog box to appear.

Navigate to the .style file within the dialog box, select the file, and then click exit.

Now, select the form and access the Object Inspector. Locate the StyleBook property, choose the drop-down menu, and select StyleBook1.

Here’s what our form looks like:

With the forms now complete, the last step requires us to add functionality to each button of our form. To do this, navigate to the location of each button in the form and double-click on each button. This action creates an OnClick method for that button subsequently creating a procedure in the .pas file and corresponds it to the .fmx file. This will allow you to add unique functionalities to each button when clicked.

However, due to the Delphi4PythonExporter’s lack of runtime implementation, we need to include at least one comment (//) in each procedure to preserve its function when exporting the form.

How Can I Export The Form Into a Python Script?

Now that our form is ready, we can export the project by navigating to Tools > Export To Python > Export Current Entire Project.

Here, we will give the project the title Weather App. Next, select the directory of your choosing and click on Export:

Because we had one form, Delphi generated two Python files and one .pyfmx file. The WeatherApp.py file will be used to run the application, whereas the Main.py file contains the class for the MainForm. The Main.pyfmx file contains the visual information for the MainForm. Here are the contents for each file.

WeatherApp.py:

from delphifmx import *
from Main import MainForm

def main():
    Application.Initialize()
    Application.Title = 'Weather App'
    Application.MainForm = MainForm(Application)
    Application.MainForm.Show()
    Application.Run()
    Application.MainForm.Destroy()

if __name__ == '__main__':
    main()

Main.py:

import os
from delphifmx import *

class MainForm(Form):

    def __init__(self, owner):
        self.TabControl1 = None
        self.HistoricalTab = None
        self.HistoryButton = None
        self.Calendar1 = None
        self.HistoricalMemo = None
        self.DateLabel = None
        self.CurrentTab = None
        self.CurrentButton = None
        self.Image1 = None
        self.CurrentMemo = None
        self.PredictionTab = None
        self.Edit2 = None
        self.TabControl2 = None
        self.TabItem1 = None
        self.Button1 = None
        self.Calendar2 = None
        self.Memo1 = None
        self.Label1 = None
        self.TabItem2 = None
        self.Button2 = None
        self.Image2 = None
        self.Memo2 = None
        self.TabItem3 = None
        self.Edit1 = None
        self.PredictButton = None
        self.SpinBox1 = None
        self.PredictLabel = None
        self.PredictLabel2 = None
        self.PredictMemo = None
        self.TitleLabel = None
        self.CityLabel = None
        self.CityCombo = None
        self.StyleBook1 = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

    def HistoryButtonClick(self, Sender):
        pass

    def CurrentButtonClick(self, Sender):
        pass

    def PredictButtonClick(self, Sender):
        pass

How Can I Use the Weatherstack API to Add Functionality to this Form?

Now the only thing that remains is to add functionality to our app. Let’s start by opening up the Main.py file and importing some libraries.

import os
from delphifmx import *

# Additional Imports
import requests

Next, navigate to the __init__ function. Here we will populate the CityCombo box using APILayer’s geolocation API. We will use the API to retrieve all the cities in the United States, and then populate the combo box. Here is what our __init__ funciton looks like:

def __init__(self, owner):
        self.TabControl1 = None
        self.HistoricalTab = None
        self.HistoryButton = None
        self.Calendar1 = None
        self.CurrentTab = None
        self.CurrentButton = None
        self.Image1 = None
        self.PredictionTab = None
        self.Edit2 = None
        self.PredictButton = None
        self.TitleLabel = None
        self.CityLabel = None
        self.HistoricalMemo = None
        self.DateLabel = None
        self.CurrentMemo = None
        self.SpinBox1 = None
        self.PredictLabel = None
        self.PredictLabel2 = None
        self.PredictMemo = None
        self.CityCombo = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

        # Get all cities in a particular country
        url = "https://api.apilayer.com/geo/country/cities/US"

        payload = {}
        headers= {
        "apikey": "your_api_key"
        }

        response = requests.request("GET", url, headers=headers, data = payload)
        result = response.json()

        # Store all cities in a list and even populate the combo box
        self.cities = []
        for city in result:
            self.CityCombo.Items.Add(city["name"])
            self.cities.append(city["name"])

Now that our CityCombo box is populated, let’s head over to the HistoryButtonClick function. Here we will start off by retrieving the date from the TCalender component and, using a combination of .format() and .zfill(), convert it to an appropriate format.

def HistoryButtonClick(self, Sender):
        date = '{}-{}-{}'.format(self.Calendar1.DateTime[0], str(self.Calendar1.DateTime[1]).zfill(2), str(self.Calendar1.DateTime[2]).zfill(2)) # Storing date from calendar in the required format

Next, we will define some parameters for our API, then use the ‘historical‘ endpoint of the weatherstack API to retrieve the historical data for a selected city. Here is what our final HistoryButtonClick function looks like:

def HistoryButtonClick(self, Sender):
        date = '{}-{}-{}'.format(self.Calendar1.DateTime[0], str(self.Calendar1.DateTime[1]).zfill(2), str(self.Calendar1.DateTime[2]).zfill(2)) # Storing date from calendar in the required format
       
        params = {
        'access_key': 'your_api_access_key',
        'query': self.cities[self.CityCombo.ItemIndex],
        'historical_date': date
        }
       
        api_result = requests.get('http://api.weatherstack.com/historical', params)
        api_response = api_result.json()

        self.HistoricalMemo.Lines.Add("Location : " + api_response["location"]["name"])
        self.HistoricalMemo.Lines.Add("Min Temperature : " + str(api_response["historical"][date]["mintemp"]))
        self.HistoricalMemo.Lines.Add("Max Temperature : " + str(api_response["historical"][date]["maxtemp"]))
        self.HistoricalMemo.Lines.Add("Avg Temperature : " + str(api_response["historical"][date]["avgtemp"]))
        self.HistoricalMemo.Lines.Add("UV_Index : " + str(api_response["historical"][date]["uv_index"]))

Now similarly to the HistoryButtonClick function, we will define our CurrentClickButton. Here, instead of the ‘historical‘ endpoint, we will be using the ‘current‘ endpoint to retrieve the data weather data. We will then uses the .Add method of the TMemo component to display it on our form:

def CurrentButtonClick(self, Sender):
        params = {
        'access_key': 'your_api_access_key',
        'query': self.cities[self.CityCombo.ItemIndex]
        }
       
        api_result = requests.get('http://api.weatherstack.com/current', params)
        api_response = api_result.json()

        self.CurrentMemo.Lines.Add("Location : " + api_response["location"]["name"])
        self.CurrentMemo.Lines.Add("Temperature: " + str(api_response["current"]["temperature"]))
        self.CurrentMemo.Lines.Add("Feels Like: " + str(api_response["current"]["feelslike"]))
        self.CurrentMemo.Lines.Add("Description: " + api_response["current"]["weather_descriptions"][0])
        self.CurrentMemo.Lines.Add("Percipitation : " + str(api_response["current"]["precip"]))
        self.CurrentMemo.Lines.Add("Humidity: " + str(api_response["current"]["humidity"]))
        self.CurrentMemo.Lines.Add("Windspeed: " + str(api_response["current"]["wind_speed"]))
        self.CurrentMemo.Lines.Add("Pressure: " + str(api_response["current"]["pressure"]))
        self.CurrentMemo.Lines.Add("UV_Index: " + str(api_response["current"]["uv_index"]))
        self.CurrentMemo.Lines.Add("Visibility: " + str(api_response["current"]["visibility"]))

In addition to this, we will also use the image_url parameter generated by the API, to first save the image and then display the image on our Current tab. Here is what our final function looks like:

def CurrentButtonClick(self, Sender):
        params = {
        'access_key': 'your_api_access_key',
        'query': self.cities[self.CityCombo.ItemIndex]
        }
       
        api_result = requests.get('http://api.weatherstack.com/current', params)
        api_response = api_result.json()

        self.CurrentMemo.Lines.Add("Location : " + api_response["location"]["name"])
        self.CurrentMemo.Lines.Add("Temperature: " + str(api_response["current"]["temperature"]))
        self.CurrentMemo.Lines.Add("Feels Like: " + str(api_response["current"]["feelslike"]))
        self.CurrentMemo.Lines.Add("Description: " + api_response["current"]["weather_descriptions"][0])
        self.CurrentMemo.Lines.Add("Percipitation : " + str(api_response["current"]["precip"]))
        self.CurrentMemo.Lines.Add("Humidity: " + str(api_response["current"]["humidity"]))
        self.CurrentMemo.Lines.Add("Windspeed: " + str(api_response["current"]["wind_speed"]))
        self.CurrentMemo.Lines.Add("Pressure: " + str(api_response["current"]["pressure"]))
        self.CurrentMemo.Lines.Add("UV_Index: " + str(api_response["current"]["uv_index"]))
        self.CurrentMemo.Lines.Add("Visibility: " + str(api_response["current"]["visibility"]))

        # URL of the image you want to load
        image_url = api_response["current"]["weather_icons"][0]

        # Send a GET request to the URL to retrieve the image data
        response = requests.get(image_url)

        if response.status_code == 200:
            # Read the image data from the response content
            image_data = response.content

            # Local path to save the image
            local_path = "image.png"        
            # Save the image locally
            with open(local_path, "wb") as image_file:
                image_file.write(image_data)
           
            self.Image1.Bitmap.LoadFromFile(local_path)

Finally, navigate to the PredictButtonClick function and, like the previous functions, we will use the ‘forecast‘ endpoint to retrieve the future prediction. Additionally, we will also use the .Text property of the TSpinBox component to get the number of days. Here is what our function looks like:

def PredictButtonClick(self, Sender):
        params = {
        'access_key': 'your_api_access_key',
        'query': self.cities[self.CityCombo.ItemIndex],
        'forecast_days': self.SpinBox1.Text,
        }
       
        api_result = requests.get('http://api.weatherstack.com/forecast', params)
        api_response = api_result.json()

        forecast = api_response["forecast"]

        # Iterate through the forecast dates
        for date, date_data in forecast.items():
            self.PredictMemo.Lines.Add("Date: " + date)
            self.PredictMemo.Lines.Add("Min Temperature: " + str(date_data["mintemp"]))
            self.PredictMemo.Lines.Add("Max Temperature: " + str(date_data["maxtemp"]))
            self.PredictMemo.Lines.Add("Avg Temperature: " + str(date_data["avgtemp"]))
            self.PredictMemo.Lines.Add("UV_Index: " + str(date_data["uv_index"]))
            self.PredictMemo.Lines.Add("")  # Add an empty line for separation

Here is what our final Main.py file looks like:

import os
from delphifmx import *

# Additional Imports
import requests

class MainForm(Form):

    def __init__(self, owner):
        self.TabControl1 = None
        self.HistoricalTab = None
        self.HistoryButton = None
        self.Calendar1 = None
        self.CurrentTab = None
        self.CurrentButton = None
        self.Image1 = None
        self.PredictionTab = None
        self.Edit2 = None
        self.PredictButton = None
        self.TitleLabel = None
        self.CityLabel = None
        self.HistoricalMemo = None
        self.DateLabel = None
        self.CurrentMemo = None
        self.SpinBox1 = None
        self.PredictLabel = None
        self.PredictLabel2 = None
        self.PredictMemo = None
        self.CityCombo = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

        # Get all cities in a particular country
        url = "https://api.apilayer.com/geo/country/cities/US"

        payload = {}
        headers= {
        "apikey": "'your_api_key'"
        }

        response = requests.request("GET", url, headers=headers, data = payload)
        result = response.json()

        # Store all cities in a list and even populate the combo box
        self.cities = []
        for city in result:
            self.CityCombo.Items.Add(city["name"])
            self.cities.append(city["name"])

    def HistoryButtonClick(self, Sender):
        date = '{}-{}-{}'.format(self.Calendar1.DateTime[0], str(self.Calendar1.DateTime[1]).zfill(2), str(self.Calendar1.DateTime[2]).zfill(2)) # Storing date from calendar in the required format
       
        params = {
        'access_key': 'your_api_access_key',
        'query': self.cities[self.CityCombo.ItemIndex],
        'historical_date': date
        }
       
        api_result = requests.get('http://api.weatherstack.com/historical', params)
        api_response = api_result.json()

        self.HistoricalMemo.Lines.Add("Location : " + api_response["location"]["name"])
        self.HistoricalMemo.Lines.Add("Min Temperature : " + str(api_response["historical"][date]["mintemp"]))
        self.HistoricalMemo.Lines.Add("Max Temperature : " + str(api_response["historical"][date]["maxtemp"]))
        self.HistoricalMemo.Lines.Add("Avg Temperature : " + str(api_response["historical"][date]["avgtemp"]))
        self.HistoricalMemo.Lines.Add("UV_Index : " + str(api_response["historical"][date]["uv_index"]))


    def CurrentButtonClick(self, Sender):
        params = {
        'access_key': 'your_api_access_key',
        'query': self.cities[self.CityCombo.ItemIndex]
        }
       
        api_result = requests.get('http://api.weatherstack.com/current', params)
        api_response = api_result.json()

        self.CurrentMemo.Lines.Add("Location : " + api_response["location"]["name"])
        self.CurrentMemo.Lines.Add("Temperature: " + str(api_response["current"]["temperature"]))
        self.CurrentMemo.Lines.Add("Feels Like: " + str(api_response["current"]["feelslike"]))
        self.CurrentMemo.Lines.Add("Description: " + api_response["current"]["weather_descriptions"][0])
        self.CurrentMemo.Lines.Add("Percipitation : " + str(api_response["current"]["precip"]))
        self.CurrentMemo.Lines.Add("Humidity: " + str(api_response["current"]["humidity"]))
        self.CurrentMemo.Lines.Add("Windspeed: " + str(api_response["current"]["wind_speed"]))
        self.CurrentMemo.Lines.Add("Pressure: " + str(api_response["current"]["pressure"]))
        self.CurrentMemo.Lines.Add("UV_Index: " + str(api_response["current"]["uv_index"]))
        self.CurrentMemo.Lines.Add("Visibility: " + str(api_response["current"]["visibility"]))

        # URL of the image you want to load
        image_url = api_response["current"]["weather_icons"][0]

        # Send a GET request to the URL to retrieve the image data
        response = requests.get(image_url)

        if response.status_code == 200:
            # Read the image data from the response content
            image_data = response.content

            # Local path to save the image
            local_path = "image.png"        
            # Save the image locally
            with open(local_path, "wb") as image_file:
                image_file.write(image_data)
           
            self.Image1.Bitmap.LoadFromFile(local_path)

    def PredictButtonClick(self, Sender):
        params = {
        'access_key': 'your_api_access_key',
        'query': self.cities[self.CityCombo.ItemIndex],
        'forecast_days': self.SpinBox1.Text,
        }
       
        api_result = requests.get('http://api.weatherstack.com/forecast', params)
        api_response = api_result.json()

        forecast = api_response["forecast"]

        # Iterate through the forecast dates
        for date, date_data in forecast.items():
            self.PredictMemo.Lines.Add("Date: " + date)
            self.PredictMemo.Lines.Add("Min Temperature: " + str(date_data["mintemp"]))
            self.PredictMemo.Lines.Add("Max Temperature: " + str(date_data["maxtemp"]))
            self.PredictMemo.Lines.Add("Avg Temperature: " + str(date_data["avgtemp"]))
            self.PredictMemo.Lines.Add("UV_Index: " + str(date_data["uv_index"]))
            self.PredictMemo.Lines.Add("")  # Add an empty line for separation

What Does the Completed Project Look Like?  

Now that everything is complete, all we need to do is open up the WeatherApp.py file and run it.

Let’s head over to the Current tab and select a city using the CityCombo box. Next, click on Get Data to retrieve the current weather information.

Now, let’s head over to the Historical tab and select a date for historical data. Next, click on the Get History button to retrieve the data.

Finally, we can even get the predicted weather for “New York City.” Head over to the Prediction tab and select the number of days for prediction. Now click on the Predict button to get the predicted data.

Are You Ready to Create Your Own Amazing Apps?

Congratulations! Thanks to the dynamic duo of DelphiFMX and Weatherstack, you’ve gained the skills to craft your own weather app. The app development world is within your grasp, and the possibilities are endless. Now, you’re not just forecasting the weather; you’re shaping innovative applications that can revolutionize how we engage with the world. But this is only the start. The DelphiFMX ecosystem provides a vast range of tools and resources, all at your disposal.

Ready to explore the vast app development landscape and bring your unique ideas to life? Get started now and dive into the world of app creation. 

What Are Some FAQs Related to this Post?

Do I need prior experience with Delphi to follow this tutorial?

While prior experience with Delphi could be helpful, the tutorial is designed to provide step-by-step guidance, making it accessible to both beginners and experienced developers.

Can I use Weatherstack for free, or are there subscription plans?

Weatherstack offers both free and paid subscription plans. In this tutorial, a subscription plan providing access to all endpoints is used, but you can start with the free plan, which includes access to the current weather endpoint.

Can I deploy a weather app created with DelphiFMX on multiple platforms?

Yes, one of the advantages of using DelphiFMX is its ability to create cross-platform applications. You can deploy your weather app on platforms like Windows and macOS.

Can I use the knowledge from this tutorial to create other types of apps?

Absolutely! The principles and techniques covered in this tutorial can be applied to a wide range of app development projects, not just weather apps. Delphi is a versatile tool for creating various types of applications.

Can I customize the design and features of my weather app beyond what’s covered in this tutorial? 

Yes, you can further enhance your weather app by customizing its design and adding additional features to meet your specific requirements. DelphiFMX offers flexibility for creative app development.

The post How To Create A Weather App With The Python Delphi Ecosystem and Weatherstack API first appeared on Python GUI.

This music player app will have an option for users to create playlists as well as play, stop, and pause songs. Users can even monitor song durations and real-time timestamps. Users can easily adjust the volume and navigate through their music in 10-second intervals. Throughout this journey, we’ll introduce you to advanced Delphi components that seamlessly integrate Python’s versatility with Delphi’s strength.

How to Build a Feature-Packed Music Player With DelphiFMX? 

Let’s go over the building of a music player app in a step by step manner.

What Are the Prerequisites for this Project?

Before we dive into building our feature-packed music player with DelphiFMX, let’s ensure we have all the necessary tools and components in place.

First and foremost, make sure you have Delphi Software installed. Delphi will be our creative canvas, allowing us to craft a music player with an enticing user interface that sings with functionality.

Next up, you’ll need the Delphi4PythonExporter tool. This nifty utility acts as the bridge connecting Delphi and Python, making the integration seamless and painless.

You’ll require a text editor or an integrated development environment (IDE) that supports Python programming to code in Python. We highly recommend PyScripter, a user-friendly environment that harmoniously blends Python coding within Delphi. If you haven’t already set up these tools, consider exploring our article “Powerful Python GUI Project Setup” to help you get started on the right foot.

Finally, you will need a codec pack to playback of all your music and video files. For this, we will need the K-Lite Codec Pack, which is a free software bundle shipped with decoders needed to view any movie, video, or music file. For this tutorial, you will need to download and install the basic codec pack from their official website.

With these prerequisites in place, you’ll be all set to embark on the journey of creating a feature-packed music player that will elevate your music experience to new heights. And if you’re eager to dive right in, you can access the complete code and resources for this tutorial from our GitHub repository at the following link:

https://github.com/Embarcadero/PythonBlogExamples/tree/main/Music_Player

How to Use the Delphi IDE to Create a Stunning GUI for this App?

Let’s start by launching our Delphi app and creating a new application. Search for the Create New tab on your welcome page and click on Multi-Device Application. Next, opt for the Blank Application and click on OK. For this tutorial, we’ve named our project “MusicPlayerProject.”

If you’re not well-acquainted with the different sections of the Delphi IDE, we suggest referring to our complimentary eBook bundle. This resource comprehensively covers the Delphi Python EcoSystem and all Python GUI offerings.

Now, we will start off by naming our form. Right-click on the form and select Quick Edit. Here, we will set the name of our form as MusicPlayerWindow with the caption “Music Player.” We will also rename the source file of our project from Unit1.pas to MusicPlayer.pas to help us keep track.

Next, let’s resize our form. Select your form and head over to the Object Inspector. Under the properties tab, search for the ClientWidth and ClientHeight properties and adjust the sizes accordingly.

We will add a few tabs to the form for this project. So, head over to the Palette and search for the TTabControl object. Drag and Drop this object to your form and adjust its size accordingly. Next, right-click on the TTabControl object and add two tabs to the form: Songs and Now Playing. The Songs tab will display all the songs in the app, while the Now Playing tab will serve as the main music player. We will also add a TRectangle component to the top of the form that will serve as the placeholder for the title and a button (which we will define later).

Here is what our form looks like:

Note: We will be customizing the text style of each label using the TextSettings property of the component. This will help us customize the feel of the form.

Now, let’s add a few labels to the form. Search for the TLabel component in the Palette and add it to the form. We will add a few of these components to indicate multiple things, including filename, song directory, artist, and time. We will also use them as placeholders to indicate multiple other components. Here is what our form looks like:

Next, let’s add a few buttons. Head to the Palette, search for the TButton component and add a few buttons to the form. Here, we will add a Create Playlist button, forward and backward buttons (which will change the time by 10 seconds), and Pause, Play, and Stop for the music player. Additionally, for each player button, we are going to customize their appearance by heading over to the Object Inspector and changing their style using the StyleLookup property:

This is what our form looks like so far:

Now, let’s add a few TTrackBar components. One track bar component will help adjust the volume of our music player, while the other will serve as a tracker to track the progress of our music. We will also add a TImage component that will help display the album cover of our music file. Here is what our form looks like:

Finally, we’ll add a TOpenDialog to help select files we want to play. We will also add a TTimer and a TMediaPlayer component to help us play our music files. The placement of these components does not matter as they will be invisible:

Now that our Now Playing tab is complete, head over to the Songs tab and add a TListBox component. This will serve as a placeholder for all our music files.

Now that our form is ready, the last step is to add functionality to each button. To do this, double-click on each button on the form. This will generate an OnClick method for that button and create a procedure in the .pas file, enabling us to program the button.

Due to the Delphi4PythonExporter’s lack of runtime implementation, we must include at least one comment (//) in each procedure to preserve its function when we export the form.

How to Add Functionality to this GUI?

With our forms now ready, we can begin exporting our forms. Navigate to Tools > Export To Python and click on Export Current Entire Project.

Here we will give our project the title Music Player. Now, select the directory of your choosing and click on Export.

Delphi will generate two Python and one .pyfmx file. The MusicPlayerProject.py file will be used to run the application, whereas the MusicPlayer.py file will contain the class of our form. The MusicPlayer.pyfmx contains the visual information of our form. Below are the contents of each Python file.

MusicPlayerProject.py:

from delphifmx import *
from MusicPlayer import MusicPlayerWindow

def main():
    Application.Initialize()
    Application.Title = 'Music Player'
    Application.MainForm = MusicPlayerWindow(Application)
    Application.MainForm.Show()
    Application.Run()
    Application.MainForm.Destroy()

if __name__ == '__main__':
    main()

MusicPlayer.py:

import os
from delphifmx import *

class MusicPlayerWindow(Form):

    def __init__(self, owner):
        self.top_rectangle = None
        self.top_heading = None
        self.create_playlist = None
        self.tab_ctrl = None
        self.songs_tab = None
        self.audio_list_box = None
        self.now_playing_tab = None
        self.audio_embedded_image = None
        self.audio_track_bar = None
        self.play_btn = None
        self.pause_btn = None
        self.stop_btn = None
        self.fwd_btn = None
        self.bwd_btn = None
        self.volume_track_bar = None
        self.vol_label = None
        self.location_label = None
        self.current_time_label = None
        self.song_name_label = None
        self.artist_label = None
        self.duration_label = None
        self.open_audio_dialog = None
        self.media_player = None
        self.timer = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "MusicPlayer.pyfmx"))

    def create_playlistClick(self, Sender):
        pass

    def audio_list_boxChange(self, Sender):
        pass

    def play_btnClick(self, Sender):
        pass

    def pause_btnClick(self, Sender):
        pass

    def stop_btnClick(self, Sender):
        pass

    def fwd_btnClick(self, Sender):
        pass

    def bwd_btnClick(self, Sender):
        pass

    def volumeChange(self, Sender):
        pass

    def update_current_time(self, Sender):
        pass

The only thing we need to do now is start adding functionality to our forms. Start by opening up MusicPlayer.py in the text editor of your choice and importing the TinyTag library:

# Additional Imports
from tinytag import TinyTag

Next, head over to the __init__ function and start by adding a custom style for the form. You’ll first need to obtain the free eBook bundle, which includes various styles. Download the eBook and extract the FMX styles ZIP file to your preferred directory. Then select the style you wish to use; in this instance, we’ll opt for transparent.style from the bundle. In addition, we will also set the default value of the volume bar to 100. Our __init__ function looks like:

class MusicPlayerWindow(Form):

    def __init__(self, owner):
        # Initialize all GUI elements
        self.top_rectangle = None
        self.top_heading = None
        self.create_playlist = None
        self.tab_ctrl = None
        self.songs_tab = None
        self.audio_list_box = None
        self.now_playing_tab = None
        self.audio_embedded_image = None
        self.audio_track_bar = None
        self.play_btn = None
        self.pause_btn = None
        self.open_audio_dialog = None
        self.media_player = None
        self.timer = None
        self.stop_btn = None
        self.fwd_btn = None
        self.bwd_btn = None
        self.nxt_btn = None
        self.volume_track_bar = None
        self.vol_label = None
        self.location_label = None
        self.current_time_label = None
        self.song_name_label = None
        self.artist_label = None
        self.duration_label = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "MusicPlayer.pyfmx"))

        # Set up the style manager and apply a custom style
        self.__sm = StyleManager()
        self.__sm.SetStyleFromFile(os.path.join(os.getcwd(), "StylesTransparent.style"))

        # Set the initial position of TrackBar to the middle (50%)
        self.volume_track_bar.Value = 100

Now, let’s program our Play, Pause, and Stop buttons. Head over to the play_btnClick function and start by turning the button off after it is pressed. Next, we will enable the Stop and Pause buttons, while calling the media player to play the music. Here is what our function looks like:

def play_btnClick(self, Sender):
        # Handle play button click
        self.play_btn.Enabled = False
        self.pause_btn.Enabled = True
        self.stop_btn.Enabled = True
        self.media_player.Play()

Similarly, we can add functionalities for our Stop and Pause buttons. Here is what the functions look like:

def pause_btnClick(self, Sender):
        # Handle pause button click
        self.play_btn.Enabled = True
        self.pause_btn.Enabled = False
        self.media_player.Stop()

    def stop_btnClick(self, Sender):
        # Handle stop button click
        self.stop_btn.Enabled = False
        self.pause_btn.Enabled = False
        self.play_btn.Enabled = True
        self.media_player.FileName = self.open_audio_dialog.FileName

Next, let’s add some functionality to the forward and backward buttons. Navigate to the fwd_btnClick function and start by getting the CurrentTime of the music:

def fwd_btnClick(self, Sender):
        # Handle forward button click
        current_time_seconds = self.media_player.CurrentTime / 10000000

Now add 10 seconds to the current time and then check if the duration is less than the duration of the song. If this condition is satisfied, we set the current time to the new time. Here is what the function looks like:

def fwd_btnClick(self, Sender):
        # Handle forward button click
        current_time_seconds = self.media_player.CurrentTime / 10000000
        new_time_seconds = current_time_seconds + 10
   
        if new_time_seconds < self.tag.duration:
            self.media_player.CurrentTime = round(new_time_seconds * 10000000)

Similarly, we can program the bwd_btnClick function but instead check if the new time is less than 0. Here is what the function looks like:

def bwd_btnClick(self, Sender):
        # Handle backward button click
        current_time_seconds = self.media_player.CurrentTime / 10000000
        new_time_seconds = current_time_seconds - 10
   
        if new_time_seconds >= 0:
            self.media_player.CurrentTime = round(new_time_seconds * 10000000)

Next, lets add some functionality to the volume track bar. Head over to the volumeChange function and start by getting the current volume stated in the bar. Next, assign the new volume value to the media player. Here is our final volumeChange function:

def volumeChange(self, Sender):
        # Handle volume control change
        volume = self.volume_track_bar.Value / 100.0
        self.media_player.Volume = volume

Now, let’s head over to the update_current_time function and use it to display the current time using the media_player. We will also display the current time in our current_time_label:

def update_current_time(self, Sender):
        # Update the current playback time
        current_time_seconds = self.media_player.CurrentTime / 10000000

        self.audio_track_bar.Value = current_time_seconds

        # Format the current time as MM:SS
        minutes = int(current_time_seconds // 60)
        seconds = int(current_time_seconds % 60)
        self.current_time_label.Text = f"{minutes:02}:{seconds:02}"

Next, we will move on to the create_playlistClick function. We will use this function to populate our playlist in the Songs tab. So, we will start by opening up the dialog box for file selection. Next, if the user selects the song, we will append it to the ListBoxItem and add it to our playlist. Here is what the function looks like:

def create_playlistClick(self, Sender):
        # Open a file dialog to select audio files and populate the playlist
        if self.open_audio_dialog.Execute():
            self.audio_list_box.Clear()
            mp3_files_list = self.open_audio_dialog.Files.ToList()
            self.listbox_song_paths = []
            self.listbox_items = []
            for mp3_file_path in mp3_files_list:
                self.listbox_song_paths.append(mp3_file_path)
                mp3_file_name = os.path.splitext(os.path.basename(mp3_file_path))[0]
                lb_item_audio_name = ListBoxItem(self.audio_list_box)
                lb_item_audio_name.SetProps(Parent=self.audio_list_box,
                                            Height=40,
                                            Text=mp3_file_name)
                self.listbox_items.append(lb_item_audio_name)

We are finally ready to add the main code to our Media player. Head over to the audio_list_boxChange function and start by retrieving the item selected in the list box:

def audio_list_boxChange(self, Sender):
        # Handle selection of an audio item in the list box
        selected_lb_item = self.audio_list_box.Selected

Next, change the tab to the Now Playing tab and use TinyTag to retrieve information about the selected song:

self.tab_ctrl.TabIndex = 1
        mp3_file_path = self.listbox_song_paths[self.listbox_items.index(selected_lb_item)]
       
        # Use TinyTag to retrieve audio file information
        self.tag = TinyTag.get(mp3_file_path, image=True)

        mins = self.tag.duration // 60
        sec = self.tag.duration % 60
        self.duration_label.Text = f"{int(mins)}:{int(sec)}"

Next, set the various labels we have with information about the song and update the embedded image if there is one available:

# Set various labels and update the embedded image if available
        self.audio_track_bar.Max = self.tag.duration
        self.artist_label.Text = "Artist: {}".format(self.tag.artist)
        self.location_label.Text = "Location: {}".format(mp3_file_path)
        self.song_name_label.Text = "Song Name: {}".format(selected_lb_item.Text)

        image_data = self.tag.get_image()
        if image_data is not None:
            bs = BytesStream(image_data)
            self.audio_embedded_image.Bitmap.LoadFromStream(bs)
        else:
            self.audio_embedded_image.Bitmap = None

Finally, load and play the selected audio file. Here is what our function looks like:

def audio_list_boxChange(self, Sender):
        # Handle selection of an audio item in the list box
        selected_lb_item = self.audio_list_box.Selected
        self.tab_ctrl.TabIndex = 1
        mp3_file_path = self.listbox_song_paths[self.listbox_items.index(selected_lb_item)]
       
        # Use TinyTag to retrieve audio file information
        self.tag = TinyTag.get(mp3_file_path, image=True)

        mins = self.tag.duration // 60
        sec = self.tag.duration % 60
        self.duration_label.Text = f"{int(mins)}:{int(sec)}"

        # Set various labels and update the embedded image if available
        self.audio_track_bar.Max = self.tag.duration
        self.artist_label.Text = "Artist: {}".format(self.tag.artist)
        self.location_label.Text = "Location: {}".format(mp3_file_path)
        self.song_name_label.Text = "Song Name: {}".format(selected_lb_item.Text)

        image_data = self.tag.get_image()
        if image_data is not None:
            bs = BytesStream(image_data)
            self.audio_embedded_image.Bitmap.LoadFromStream(bs)
        else:
            self.audio_embedded_image.Bitmap = None

        # Load and play the selected audio file
        self.media_player.FileName = mp3_file_path
        self.media_player.Play()

        # Set up a timer to update the current playback time
        self.timer.Interval = 1000  # Set the interval to 1000 milliseconds (1 second)
        self.timer.Enabled = True

        # Enable playback control buttons
        self.pause_btn.Enabled = True
        self.stop_btn.Enabled = True

Here is what our final MusicPlayer.py file looks like:

import os
from delphifmx import *
from tinytag import TinyTag

class MusicPlayerWindow(Form):

    def __init__(self, owner):
        # Initialize all GUI elements
        self.top_rectangle = None
        self.top_heading = None
        self.create_playlist = None
        self.tab_ctrl = None
        self.songs_tab = None
        self.audio_list_box = None
        self.now_playing_tab = None
        self.audio_embedded_image = None
        self.audio_track_bar = None
        self.play_btn = None
        self.pause_btn = None
        self.open_audio_dialog = None
        self.media_player = None
        self.timer = None
        self.stop_btn = None
        self.fwd_btn = None
        self.bwd_btn = None
        self.nxt_btn = None
        self.volume_track_bar = None
        self.vol_label = None
        self.location_label = None
        self.current_time_label = None
        self.song_name_label = None
        self.artist_label = None
        self.duration_label = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "MusicPlayer.pyfmx"))

        # Set up the style manager and apply a custom style
        self.__sm = StyleManager()
        self.__sm.SetStyleFromFile(os.path.join(os.getcwd(), "StylesTransparent.style"))

        # Set the initial position of TrackBar to the middle (50%)
        self.volume_track_bar.Value = 100
   
        self.tag = None

    def create_playlistClick(self, Sender):
        # Open a file dialog to select audio files and populate the playlist
        if self.open_audio_dialog.Execute():
            self.audio_list_box.Clear()
            mp3_files_list = self.open_audio_dialog.Files.ToList()
            self.listbox_song_paths = []
            self.listbox_items = []
            for mp3_file_path in mp3_files_list:
                self.listbox_song_paths.append(mp3_file_path)
                mp3_file_name = os.path.splitext(os.path.basename(mp3_file_path))[0]
                lb_item_audio_name = ListBoxItem(self.audio_list_box)
                lb_item_audio_name.SetProps(Parent=self.audio_list_box,
                                            Height=40,
                                            Text=mp3_file_name)
                self.listbox_items.append(lb_item_audio_name)

    def audio_list_boxChange(self, Sender):
        # Handle selection of an audio item in the list box
        selected_lb_item = self.audio_list_box.Selected
        self.tab_ctrl.TabIndex = 1
        mp3_file_path = self.listbox_song_paths[self.listbox_items.index(selected_lb_item)]
       
        # Use TinyTag to retrieve audio file information
        self.tag = TinyTag.get(mp3_file_path, image=True)

        mins = self.tag.duration // 60
        sec = self.tag.duration % 60
        self.duration_label.Text = f"{int(mins)}:{int(sec)}"

        # Set various labels and update the embedded image if available
        self.audio_track_bar.Max = self.tag.duration
        self.artist_label.Text = "Artist: {}".format(self.tag.artist)
        self.location_label.Text = "Location: {}".format(mp3_file_path)
        self.song_name_label.Text = "Song Name: {}".format(selected_lb_item.Text)

        image_data = self.tag.get_image()
        if image_data is not None:
            bs = BytesStream(image_data)
            self.audio_embedded_image.Bitmap.LoadFromStream(bs)
        else:
            self.audio_embedded_image.Bitmap = None

        # Load and play the selected audio file
        self.media_player.FileName = mp3_file_path
        self.media_player.Play()

        # Set up a timer to update the current playback time
        self.timer.Interval = 1000  # Set the interval to 1000 milliseconds (1 second)
        self.timer.Enabled = True

        # Enable playback control buttons
        self.pause_btn.Enabled = True
        self.stop_btn.Enabled = True

    def update_current_time(self, Sender):
        # Update the current playback time
        current_time_seconds = self.media_player.CurrentTime / 10000000

        self.audio_track_bar.Value = current_time_seconds

        # Format the current time as MM:SS
        minutes = int(current_time_seconds // 60)
        seconds = int(current_time_seconds % 60)
        self.current_time_label.Text = f"{minutes:02}:{seconds:02}"

    def play_btnClick(self, Sender):
        # Handle play button click
        self.play_btn.Enabled = False
        self.pause_btn.Enabled = True
        self.stop_btn.Enabled = True
        self.media_player.Play()

    def pause_btnClick(self, Sender):
        # Handle pause button click
        self.play_btn.Enabled = True
        self.pause_btn.Enabled = False
        self.media_player.Stop()

    def stop_btnClick(self, Sender):
        # Handle stop button click
        self.stop_btn.Enabled = False
        self.pause_btn.Enabled = False
        self.play_btn.Enabled = True
        self.media_player.FileName = self.open_audio_dialog.FileName

    def fwd_btnClick(self, Sender):
        # Handle forward button click
        current_time_seconds = self.media_player.CurrentTime / 10000000
        new_time_seconds = current_time_seconds + 10
   
        if new_time_seconds < self.tag.duration:
            self.media_player.CurrentTime = round(new_time_seconds * 10000000)

    def bwd_btnClick(self, Sender):
        # Handle backward button click
        current_time_seconds = self.media_player.CurrentTime / 10000000
        new_time_seconds = current_time_seconds - 10
   
        if new_time_seconds >= 0:
            self.media_player.CurrentTime = round(new_time_seconds * 10000000)

    def volumeChange(self, Sender):
        # Handle volume control change
        volume = self.volume_track_bar.Value / 100.0
        self.media_player.Volume = volume

What Are the Final Results?

Now that everything is complete, it’s time to test out our app. Open up MusicPlayerProject.py and run the file.

Next, click the Create Playlist button and select the files you want to play. Now navigate to the Songs tab to see your playlist:

Finally, double-click on a song to start playing:

What Have You Learned in this Article?

Conclusively, in this tutorial, we’ve transformed a basic music player into a versatile tool. You’ve learned to craft playlists effortlessly, fine-tune playback, and enhance your music experience with song duration and timestamps.

But this is just the beginning. Delphi opens doors to endless possibilities. Whether you’re a novice or an experienced developer, it’s time to harness the power of Delphi. Elevate your software development skills, create exceptional applications, and leave your digital mark.

Delphi offers boundless opportunities. So, why wait? Dive into the world of Delphi today and turn your ideas into reality. Your next innovation is just a step away.

What Are Some Relevant FAQs?

What is DelphiFMX, and why should I use it for building a music player?

DelphiFMX is a framework for creating cross-platform applications with Delphi. It provides a powerful and user-friendly way to build applications with rich user interfaces. Using it for a music player allows you to create a visually appealing and feature-packed player easily.

Can I use other programming languages besides Python with DelphiFMX?

DelphiFMX primarily supports the Delphi programming language, but you can use external libraries like the Python4Delphi bridge to incorporate Python into your Delphi applications, as demonstrated in this tutorial.

Are there any licensing requirements for using Delphi and Python together?

Delphi and Python can be used together without any additional licensing requirements. However, make sure to review the licenses of any third-party libraries or components you use in your project.

Can I customize the appearance and behavior of Delphi components to match the design of my music player?

Yes, Delphi components are highly customizable. You can adjust properties such as colors, fonts, sizes, and styles to achieve the desired look and feel for your music player’s user interface.

What are some commonly used Delphi components for building a music player?

For a music player, you might use components like TMediaPlayer, TListBox for playlists, TButton for playback controls, TProgressBar for tracking song progress, and TTrackBar for volume control, among others.

The post How To Create A Music Player With The Python Delphi Ecosystem first appeared on Python GUI.

Please note: As GPT-3 and higher versions are not available for public access at the time of writing, the demonstration showcased in this article employs GPT-2.

Before we begin, let’s see the remarkable ability of ChatGPT to describe itself:

It can even praise itself very highly :). Read reference [2] and [3], if you want to see how powerful ChatGPT is in assisting you to understand a research paper in the deep learning field.

What is Deep Learning?

Deep learning is a subfield of machine learning that solves complex problems using artificial neural networks. These neural networks are made up of interconnected nodes arranged in multiple layers that extract features from input data. Large datasets are used to train these models, allowing them to detect patterns and correlations that humans would find difficult or impossible to detect.

Deep learning has had a significant impact on artificial intelligence. It has facilitated the development of intelligent systems capable of learning, adapting, and making decisions on their own. Deep learning has enabled remarkable progress in a variety of fields, including image and speech recognition, natural language processing, machine translation, large-language models; chatbots; & content generators (as would be reviewed in this article), image generations, autonomous driving, and many others.

Why Python for Deep Learning, Machine Learning, and Artificial Intelligence?

Python has gained widespread popularity as a programming language due to its versatility and ease of use in diverse domains of computer science, especially in the field of deep learning, machine learning, and AI. 

We’ve reviewed several times about why Python is great for Deep Learning, Machine Learning, and Artificial Intelligence (also all the requirements), in the following articles:

What is GPT?

GPT stands for “Generative Pre-trained Transformer,” and it is a type of artificial intelligence language model developed by OpenAI. The GPT models are built on the Transformer architecture, which is a deep learning model architecture specifically designed for natural language processing tasks.

The key features of GPT are:

1. Generative: GPT is capable of generating human-like text based on the input it receives. It can produce coherent and contextually relevant responses, making it useful for a variety of natural language generation tasks.
2. Pre-trained: GPT models are initially trained on large-scale datasets that contain diverse text from the internet, books, articles, and other sources. This pre-training phase helps the model learn grammar, syntax, semantics, and factual knowledge from the vast amount of data it processes.
3. Transformer architecture: The Transformer architecture is a neural network architecture that allows the model to process input text in parallel, making it more efficient and scalable compared to earlier sequential models. The self-attention mechanism in Transformers enables the model to weigh the importance of different words in the input context, leading to better contextual understanding.
4. Transfer Learning: GPT leverages the concept of transfer learning. After pre-training on a large corpus of text, the model can be further fine-tuned on specific tasks or datasets to adapt its capabilities to more targeted use cases.

GPT has seen several iterations, with each version being an improvement over its predecessors in terms of size, performance, and language understanding capabilities. These models have found applications in various domains, including chatbots, language translation, text summarization, content generation, and more, due to their ability to understand and generate human-like text.

What is GPT-2?

GPT-2 is a large transformer-based language model with 1.5 billion parameters, trained on a dataset of 8 million web pages. GPT-2 is trained with a simple objective: predict the next word, given all of the previous words within some text. The diversity of the dataset causes this simple goal to contain naturally occurring demonstrations of many tasks across diverse domains. GPT-2 is a direct scale-up of GPT, with more than 10X the parameters and trained on more than 10X the amount of data.

GPT-2 outperforms other language models trained on specific domains (like Wikipedia, news, or books) without needing to use these domain-specific training datasets. On language tasks like question answering, reading comprehension, summarization, and translation, GPT-2 begins to learn these tasks from the raw text, using no task-specific training data.

What is Transformer architecture?

The Transformer architecture is a deep learning model architecture specifically designed for natural language processing (NLP) tasks. It was introduced in the paper “Attention is All You Need” by Vaswani et al. in 2017 (see Reference [8]) and has since become a fundamental building block for many state-of-the-art NLP models, including GPT (Generative Pre-trained Transformer) and BERT (Bidirectional Encoder Representations from Transformers).

The key innovation of the Transformer architecture is the concept of self-attention. Traditional sequence-to-sequence models, like RNNs (Recurrent Neural Networks), process input sequentially, which can lead to inefficiencies and limitations in capturing long-range dependencies. In contrast, the Transformer allows for parallel processing of input sequences, making it highly scalable and efficient.

What are the main components of Transformer architecture?

1. Encoder-Decoder Structure

The Transformer architecture consists of an encoder and a decoder. In NLP tasks like machine translation, the encoder processes the input sequence, while the decoder generates the output sequence.

2. Self-Attention Mechanism

Self-attention allows the model to weigh the importance of different words in the input sequence concerning each other. It computes attention scores between all pairs of words in the sequence, and the words with higher attention scores have a stronger influence on the representation of each word. This enables the model to capture dependencies between words regardless of their distance in the sequence.

3. Multi-Head Attention

The self-attention mechanism is extended with multiple attention heads. Each head learns a different representation of the input sequence, allowing the model to capture different types of relationships and dependencies.

4. Feed-Forward Neural Networks

After the self-attention layers, the model typically employs feed-forward neural networks to process the attended representations further.

5. Positional Encoding

Since the Transformer processes words in parallel, it lacks the inherent order information found in sequential models. To address this, positional encoding is added to the input embeddings, providing the model with information about the word’s position in the sequence.

The Transformer architecture has shown remarkable performance improvements in various NLP tasks, and its ability to capture long-range dependencies and context has been instrumental in the success of modern language models. Its widespread adoption has transformed the NLP landscape, leading to the development of more powerful and efficient AI language models.

What are the requirements for running the GPT-2?

To perform this experiment, I use the following hardware, software, and environment setup:

Hardware

Regular laptop (I am not using any additional GPU). 

Processor: Intel(R) Core(TM) i5-8th Gen

Memory: 12Gb of RAM

Graphic: Intel(R) UHD Graphics 620

OS: Windows 10

Software

Please be very careful in following each step of installations, to avoid any complex errors!

Create new Python environment using conda

This step is very necessary to make you stay away from any problems in the future.

The following is the command to create new Python environment named gpt2_4D:

conda create --name gpt2_4D

Activate the environment using this command:

conda activate gpt2_4D

Python version: Python 3.6. 

Since GPT-2 needs TensorFlow 1.12 that is compatible only with Python 3.6., I even need to downgrade my Python version.

Use the following command to install specific Python version:

conda install python=3.6

Setup for PyScripter IDE, so it can finds your recently installed Python 3.6. distribution in Windows

On PyScripter IDE, click the following menu, to load additional Python versions, in our case Python 3.6 (it even can successfully load Python that is installed in virtual environments):

Run -> Python Versions -> Setup Python Versions -> Click the + Button -> Add the C:/Users/YOUR_USERNAME/anaconda3/envs/gpt2_4D environment directory. 

If successfully loaded, it will show up like the following screenshots:

Python 3.6 and all the environment for running the GPT-2 is loaded successfully:

Install TensorFlow v1.14 as already mentioned before

Use the following command to install a specific version of TensorFlow (v1.14):

pip install tensorflow==1.14.0

If the TensorFlow version 1.14.0 not work well with you, try the following versions:

conda install -c issxia tensorflow=1.12
conda install -c issxia tensorflow=1.13.1

Other library requirements

The following command is to install all the required library individually:

pip install fire>=0.1.3
pip install regex==2017.4.5
pip install requests==2.21.0
pip install tqdm==4.31.1
pip install toposort==1.5

Or, simply run this command, and you will install all of the requirements seamlessly:

pip install -r requirements.txt

Download models

Use the following command to install the 124M model (don’t forget to keep yourself stay on the gpt-2 folder, or if not, go to the gpt-2 folder using cd gpt-2):

python download_model.py 124M

Or, if you prefer a bigger model, use the following command to install the 345M (but, as a consequence, it would consume very large memory, or even can’t run at all, on the regular laptop without an additional GPU):

python download_model.py 345M

Screenshots:

How to test if the GPT-2 is already installed and working correctly?

Test it by running generate_unconditional_samples.py added with temperature parameter

Run the generate_unconditional_samples.py file using the following command:

python src/generate_unconditional_samples.py --temperature=2.0

If you installed everything correctly, you will get the following output:

For the sake of curiosity, I let the code run for hours, and here is the output of SAMPLE 100:

Test it by generate_unconditional_samples.py samples

Next, you can test the installation by running the generate_unconditional_samples.py code using the following command:

python src/generate_unconditional_samples.py --model_name=124M

Again, for the sake of curiosity, I let the code run for hours, and here is the output of SAMPLE 100:

Test it to perform interactive conversations on cmd

To do this, you need to run interactive_conditional_samples.py using the following command (if you use the lowest spec model (124M)):

And I used the following prompts:

• First prompt: “What is Python language?”

• Second prompt: “What is Delphi programming language?”

• Third prompt: “How to cook delicious eggs?”

• For the fourth prompt, I test it using the same example as the one provided by the official article by OpenAI (see Reference [6]).“Please continue the following paragraph: "In a shocking finding, scientist discovered a herd of unicorns living in a remote, previously unexplored valley, in the Andes Mountains. Even more surprising to the researchers was the fact that the unicorns spoke perfect English.“

How’s the results? Convincing enough to made-up a sci-fi or fairy tale stories, right (or even worse, generate fake news and hoaxes, as concerned and worried by the creators of GPT products)? 🙂

It is stated by OpenAI that GPT-2 generates synthetic text samples in response to the model being primed with an arbitrary input; the model is chameleon-like in that it adapts to the style and content of the conditioning text, allowing the user to generate realistic and coherent continuations about a topic of their choice, as demonstrated by the sample above.

Why not use bigger models?

“Why not use bigger models?”. You might ask.

For example, to use bigger model (in this example, 345M) use the following command:

python src/interactive_conditional_samples.py --model_name=345M

The answer is simple, it would exceed the allocated memory of a regular laptop.

And if you still insist on using the model to answer your prompts, you might get less satisfying answers, compared to the answers provided by the lowest spec model (124M).

Here are the answers on the same questions:

How to retrain GPT-2 to generate custom text content?

Retrain GPT-2 to built Progressive Metal lyrics generator

In this section, we will retrain GPT-2 to generate any text that suits our purposes. We will explore all the required steps to retrain GPT-2 using any custom text, on Windows.

We can use any kind of text data, as long as they are in English. For example:

1. Song lyrics
2. Poems
3. Short stories, light novels, novels
4. Questions and answers
5. Synopsis or abstract
6. News, letters, articles, or papers

In this article, I retrained the GPT-2 with Progressive Metal lyrics, out of curiosity. I chose Progressive Metal genre to retrain GPT-2, as this genre has very specific characteristics, such as powerful, deep, dark, and more intricate and complex lyrics, compared to other genres (even compared to other Metal subgenres). The lyrics might explore concept albums or thematic lyrics that explore philosophical, spiritual, existential themes, exploring unusual sides of relationships and humanity, etc.

So, I think it must be fun to see how the machine can handle such complicated things. 🙂

Download required files

The required repository for this training is a clone and fine-tuned version of the original GPT-2 repository provided by @nshepperd. Go to the following Github link [4] and click on the “Clone or download” button.

Download 124M model

The next thing to do is to download the base model like we’ve done in the previous sections. But, this time, we downloaded the model for the GPT-2 cloned version.

First, don’t forget to navigate to the gpt-2-finetuning directory, and run the following command:

python download_model.py 124M

Preparing custom text dataset

For the experiment performed in this article, I am using collections of Progressive Metal lyrics as training data. I collected all studio album lyrics ever created by four Progressive Metal legends: Such as Dream Theater, Opeth, Porcupine Tree, and TOOL, which achieve 20,000+ lines of text file, that I save as lyrics.txt, as training data.  

I built the training data manually via copy and paste method from the following website: darklyrics.com and azlyrics.com. Once you have completed your training data, move the file to the src directory.

Encode the data

First, don’t forget to navigate to the gpt-2-finetuning directory, and run the following command:

python encode.py lyrics.txt lyrics.npz

If you run it successfully, you will get the following output:

Train the data

Change the directory to gpt-2-finetuningsrc, and then, use the following command to train model using the new dataset:

python train.py --dataset lyrics.npz --batch_size 2 --learning_rate 0.0001

If everything is working correctly, the training should start and you should have the following output after a while:

From the screenshot above, we can interpret the output [1 | 45.25] loss=3.92 avg=3.92 as follow:

1. 1: Refers to the number of training steps. Think of it as a counter that will increase by 1 after each run.
2. 45.25: Time elapsed since the start of training in seconds. You can use the first step as reference to determine how long it takes to run one step.
3. loss and avg: Both of them refer to the cross-entropy (log loss) and the average loss. You can use this to determine the performance of your model. In theory, as training steps increase, the loss should decrease until it converges at a certain value. The lower, the better.

How to stop the training?

You can stop the training by using Ctrl+C.

By default, the model will be saved once every 1000 steps and a sample will be generated once every 100 steps.

The following are the automatically generated samples after the first 100 steps of training:

And the following are the checkpoint files inside the run1 folder:

The following is the complete directory to the checkpoints:

/../gpt-2-finetuning/src/checkpoint/run1

The outputs that related with our last step of training:

1. model-431.data-00000-of-00001
2. model-431.index
3. model-431.meta

How to resume training from the last checkpoint?

You can simply use the following code to resume the training:

python train.py --dataset lyric.npz

Or the following command:

python train.py --dataset lyrics.npz --batch_size 2 --learning_rate 0.0001

That’s the same as before.

The following is the log loss and average loss achieved after 1000 steps of training:

Let’s see what the model can do, after such a long training.

Generate samples

Create a folder for the model

In the src/models folder, you should have just one folder called 124M (if you only installed this model). 

Create another folder to store your model alongside with the original model. I made a new folder called lyric. Now, I have two folders in src/models, one is called 124M and the other is called lyric.

Go to src/checkpoint/run1 folder, and copy the following files:

1. checkpoint
2. model-xxxx.data-00000-of-00001
3. model-xxxx.index
4. model-xxxx.meta

xxxx refers to the step number. Since I have trained for 1394 steps, I have model-1394.index.

Paste them into the newly created folder (in my case, the folder is called lyric). Next, go to the 124M folder and copy the following files:

1. encoder.json
2. hparams.json
3. vocab.bpe

Paste them into the lyric folder. Double check that you should have 7 files in it. With this, we are ready to generate samples.

In general, there are two ways to generate samples: By generating unconditional vs interactive conditional samples.

Generate unconditional sample

Unconditional sample refers to randomly generated samples without taking into account any user input. Think of it as a random sample. 

Make sure you are in the src directory and simply use the following code to generate samples.

python generate_unconditional_samples.py --model_name lyric

Beware of the output! Some of it may be quite humorous,  some others may use strong and profanity languages (for unknown reason, but it’s likely based on the some lyrics written by TOOL band), while some of it seems good enough in producing lyrics that are a little bit similar with progressive metal style that used in training data.

The quality of the lyrics might get better if we add the training data, or stop the training at the right time or right training step (to avoid overfitting or underfitting).

You can also get better results by removing the bad words using profanity filter API, as follow:

For the sake of curiosity and completeness, I save all the 100 output samples into different files, and upload them to the following directory /samples/generate_unconditional_samples.py--model_name_lyric_outputs inside the following code repository.

Generate unconditional sample using parameter tuning

The most important parameters we need to know before tuning them are top_k and temperature.

top_k: Integer value controlling diversity. 1 means only 1 word is considered for each step (token), resulting in deterministic completions, while 40 means 40 words are considered at each step. 0 (default) is a special setting that means no restrictions. 40 generally is a good value.

temperature: Float value controlling randomness in boltzmann distribution. Lower temperature results in less random completions. As the temperature approaches zero, the model will become deterministic and repetitive. Higher temperature results in more random completions. Default value is 1.

For example, to generate unconditional sample using 0.8 temperature and 40 top_k, type the following command:

python generate_unconditional_samples.py --temperature 0.8 --top_k 40 --model_name lyric

For the sake of curiosity and completeness, I save all the 100 sample outputs using the command above, and upload them to the following directory /samples/generate_unconditional_samples.py--temperature0.8top_k40 inside the following code repository.

Generate interactive conditional sample

Interactive conditional sample refers to generating samples based on user input. In other words, you input some text, and GPT-2 will do its best to fill in the rest.

Type the following command to generate interactive conditional samples:

python interactive_conditional_samples.py --temperature 0.8 --top_k 40 --model_name lyric

After running the command above, type your desired prompt, for example:

Write me a lyrics in the style of Dream Theater band

And here is the screenshot of the excerpt of the output:

Generate interactive conditional sample on PyScripter IDE

Before running the interactive_conditional_sample.py on PyScripter IDE, you need to change the model_name parameter on the interact_model function from 124M to lyric (see the line 12 on the interactive_conditional_sample.py file).

model_name='lyric'

And then, you can run the code normally, and type your prompt. For example:

Please continue the following lyrics: "Somewhere like a scene from a memory"

Conclusion

The Transformer architecture has revolutionized the field of natural language processing and machine learning as a whole. Its self-attention mechanism and parallel processing capabilities have led to remarkable breakthroughs in tasks like machine translation, sentiment analysis, and text generation (as we demonstrated in this article).

This article has highlighted and demonstrated the potential use of deep learning, specifically within the context of the Transformer architecture in the domain of music or arts, specifically in producing lyrics in certain musical genre.

I hope this article was successful in giving you a basic understanding and workflow of how to retrain GPT-2 according to your project goals.

Check out the full repository here:

github.com/Embarcadero/DL_Python04_Transformer

Click here to get started with PyScripter, a free, feature-rich, and lightweight Python IDE.

Download RAD Studio to create more powerful Python GUI Windows Apps in 5x less time.

Check out Python4Delphi, which makes it simple to create Python GUIs for Windows using Delphi.

Also, look into DelphiVCL, which makes it simple to create Windows GUIs with Python

References & further readings

[1] Foong, Ng Wai. (2019).

Beginner’s Guide to Retrain GPT-2 (117M) to Generate Custom Text Content. AI2 Labs, Medium. medium.com/ai-innovation/beginners-guide-to-retrain-gpt-2-117m-to-generate-custom-text-content-8bb5363d8b7f

[2] Hakim, M. A. (2023).

How to read Machine Learning/Deep Learning papers for a busy (or lazy) man. Paper-001: “Hinton et al., 2015”. hkaLabs AI blog. hkalabs.com/blog/how-to-read-deep-learning-papers-for-a-busy-or-lazy-man-paper-001

[3] Hakim, M. A. (2023).

How to bypass the ChatGPT information cutoff? A busy (or lazy) man guide to read more recent ML/DL papers. Paper-001: “Rombach et al., 2022”. hkaLabs AI blog. hkalabs.com/blog/how-to-read-deep-learning-papers-using-bing-chat-ai-001

[4] nshepherd. (2021).

Forked and fine-tuned version of GPT-2 for custom datasets: Code for the paper “Language Models are Unsupervised Multitask Learners”. GitHub repository. github.com/nshepperd/gpt-2

[5] Radford, A., Narasimhan, K., Salimans, T., & Sutskever, I. (2018).

Improving language understanding by generative pre-training.

[6] Radford, A., Wu, J., Amodei, D., Amodei, D., Clark, J., Brundage, M., & Sutskever, I. (2019).

Better language models and their implications. OpenAI blog, 1(2).

[7] Uszkoreit, J. (2017).

Transformer: A Novel Neural Network Architecture for Language Understanding. Google Research Blog.

[8] Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., … & Polosukhin, I. (2017).

Attention is all you need. Advances in neural information processing systems, 30.

The post Unlock the Power of Python for Deep Learning with Transformer Architecture – The Engine Behind ChatGPT first appeared on Python GUI.

How to create an image editing app with DelphiFMX? 

Developing an image editing application with DelphiFMX involves a series of steps. First, install Delphi Integrated Development Environment (IDE) and the Python FireMonkey GUI framework on your computer. These are essential tools for creating the image editor. Additionally, you’ll need a text editor or an IDE that supports Python, such as PyScripter, along with the Delphi4PythonExporter tool. If you don’t have these tools already, we suggest referring to the article “Setting Up a Powerful Python GUI Project” article to help you get started.

Furthermore, it’s crucial to have the requests and cloudinary Python libraries installed. You can achieve this by executing the following commands in your command prompt:

pip install cloudinary
pip install requests

To access the source code for this tutorial, you can download it from our GitHub repository using the following link:

https://github.com/Embarcadero/PythonBlogExamples/tree/main/Image_Editor_App

What kind of forms do we need for an image editing app?

Let’s begin by launching the Delphi application and initiating a new project. Go to the File menu, select New, then choose Multi-Device Application, and finally, opt for Blank Application and click OK. In this tutorial, we’ve named our project “ImageEditor.”

If you’re not well-acquainted with the different sections of the Delphi IDE, we suggest referring to our complimentary eBook bundle. This resource comprehensively covers the Delphi Python EcoSystem and all Python GUI offerings.

Now, let’s provide a name for our form. Right-click on the form and select QuickEdit. Here, we’ll name our form MainForm with the caption “Image Editor.”

We’ll also rename the source file for our MainForm to Main.pas to simplify tracking. Next, adjust the form’s dimensions in the Object Inspector using ClientWidth and ClientHeight under the properties tab or simply using the mouse.

We can use the TTabControl component of this IDE to add two tabs to our form, one for image editing and the other for background removal. Search for the component in the Palette and drop this component onto the form.

Next, stretch out the component so it occupies the whole form. Here is what our form looks like:

Right-click on the component and click on AddTabItem to add a tab to the form. As mentioned, we will add two tabs, one for image editing and the second for background removal. Next, we’ll use QuickEdit to rename the tabs to Edit and BackgroundRemoval.

Now, let’s incorporate a few labels that will be required for our application. To achieve this, access the standard Palette and locate the TLabel component. Then, drag and drop this component onto the form.

Next, we’ll customize the text style by utilizing the TextSettings property of each label. To do this, navigate to the Object Inspector and search for the TextSettings property. Click on the ellipsis button (...) adjacent to the Font property to explore options for adjusting the label according to your preferences. In this instance, we’ve configured our font family as SemiBold Segoe UI with varying font sizes for each label. Here’s what our form looks like:

Now, let’s add a couple of buttons to our form. For this purpose, we’ll utilize the TButton component. We’ll include two buttons in this tab: FileButton to facilitate file selection for image editing and a TransformButton to edit and display the transformed image.

Next, we’ll add a TImage component to the tab where the selected and edited images will be displayed. A TComboBox will also be used for giving options of all possible image filters to the user. At the same time, a TSpinBox next to it will allow the user to input the intensity of the selected filter. We will also add a TCheckBox component that, when checked, will enable users to change the image’s dimensions by specifying the height and width. We will also add two TEdit components for the user to specify the new image dimensions.

To complete our form, we’ll introduce the TOpenDialog component, enabling us to open a dialog box for file selection from our system. Access the Palette, search for this component, and then drag and drop it onto our form. Here is what the tab looks like:

Now that our Edit tab is complete, we will head to the BackgroundRemoval tab. Here, we will add a TImage component and a TButton component. Here is what the tab looks like:

Finally, let’s infuse some style into our form. To achieve this, you’ll need to obtain the free eBook bundle, which includes various styles. Download the eBook and extract the FMX styles ZIP file to your preferred directory. Select the style you wish to use; in this instance, we’ll opt for GoldenGraphite.style from the bundle. You can explore more DelphiFMX styles online, such as at delphistyles.com.

Go to the Palette and add the TStyleBook component to your form.

Double-click on the StyleBook1 component to access the Style Designer. Now click the open button, which will prompt a dialog box to appear.

Navigate to the .style file within the dialog box, select the file, and then click exit. 

Now, select the form and access the Object Inspector. Locate the StyleBook property, choose the drop-down menu, and select StyleBook1.

Here’s what our form looks like:

Now that the form is fully configured, the last step involves adding functionality to each button within the form. To achieve this, double-click on each button. This action will generate an OnClick method for that button. This will create a procedure in the .pas file corresponding to the .fmx form, enabling you to incorporate unique functionality for each button when clicked.

Due to the Delphi4PythonExporter’s lack of runtime implementation, including at least one comment (//) in each procedure to preserve its function when exporting the form is essential.

How can I export these forms into Python code?

Now that our form is ready, we can export the project by navigating to Tools > Export To Python > Export Current Entire Project.

Here, we will give the project the title Image Editor App. Next, select the directory of your choosing and click on Export:

Because we had one form, Delphi generated two Python files and one .pyfmx file. The ImageEditor.py file will be used to run the application, whereas the Main.py file contains the class for the MainForm. The Main.pyfmx file contains the visual information for the MainForm. Here are the contents for each file.

ImageEditor.py:

from delphifmx import *
from Main import MainFrom

def main():
    Application.Initialize()
    Application.Title = 'Image Editor App'
    Application.MainForm = MainFrom(Application)
    Application.MainForm.Show()
    Application.Run()
    Application.MainForm.Destroy()

if __name__ == '__main__':
    main()

Main.py:

import os
from delphifmx import *

class MainFrom(Form):

    def __init__(self, owner):
        self.TabControl1 = None
        self.Edit = None
        self.FilenameLabel = None
        self.EffectLabel = None
        self.IntensityLabel = None
        self.WidthLabel = None
        self.HeightLabel = None
        self.TransformButton = None
        self.FileButton = None
        self.EffectComboBox = None
        self.SpinBox1 = None
        self.DimensionsCheckBox = None
        self.EditImage = None
        self.BackgroundRemoval = None
        self.RemoveBgImage = None
        self.RemoveButton = None
        self.OpenDialog1 = None
        self.StyleBook1 = None
        self.WidthEdit = None
        self.HeightEdit = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

    def TransformButtonClick(self, Sender):
        pass

    def FileButtonClick(self, Sender):
        pass

    def RemoveButtonClick(self, Sender):
        pass

How can I add functionality to our image editing form?

The only thing we need to do now is start adding functionality to our forms. Start by opening up Main.py in the text editor of your choice and importing some libraries:

# Additional Imports
import cloudinary
from cloudinary import uploader
from cloudinary import CloudinaryImage
import requests
import time

Next, navigate to the __init__ function. Here, we will define our effect_options in a dictionary and use it to populate our EffectComboBox. Next, we will define our Cloudinary API using our cloud credentials. Here is what our __init__ function looks like:

def __init__(self, owner):
        self.TabControl1 = None
        self.Edit = None
        self.FilenameLabel = None
        self.EffectLabel = None
        self.IntensityLabel = None
        self.WidthLabel = None
        self.HeightLabel = None
        self.TransformButton = None
        self.FileButton = None
        self.EffectComboBox = None
        self.SpinBox1 = None
        self.DimensionsCheckBox = None
        self.EditImage = None
        self.BackgroundRemoval = None
        self.RemoveBgImage = None
        self.RemoveButton = None
        self.OpenDialog1 = None
        self.StyleBook1 = None
        self.WidthEdit = None
        self.HeightEdit = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

        # Defining different effect options
        self.effect_options = {0:"--", 1:"cartoonify", 2:"pixelate", 3:"sepia", 4:"vignette", 5:"grayscale"}

        # Populating ComboBox
        for option in list(self.effect_options.values()):
            self.EffectComboBox.Items.Add(option)

        # Configure Cloudinary with your account details
        cloudinary.config(
        cloud_name = "your_cloud_name",
        api_key = "your_api_key",
        api_secret = "your_api_secret"
        )

Next, let’s head over to the FileButtonClick function. Here, we will start by defining the title of the Dialog Box and filter the results only to show image formats:

def FileButtonClick(self, Sender):
        # Filepicker window title
        self.OpenDialog1.Title = "Select an Image"

        # Filtering only image formats to show
        self.OpenDialog1.Filter = "Image files (*.jpg;*.jpeg;*.png;*.bmp,*.webp)|*.jpg;*.jpeg;*.png;*.bmp;*.webp|All files (*.*)|*.*"

Once the user selects the image, we open it up and extract its information, including its location and name. Here is what our FilebuttonClick function looks like:

def FileButtonClick(self, Sender):
        # Filepicker window title
        self.OpenDialog1.Title = "Select an Image"

        # Filtering only image formats to show
        self.OpenDialog1.Filter = "Image files (*.jpg;*.jpeg;*.png;*.bmp,*.webp)|*.jpg;*.jpeg;*.png;*.bmp;*.webp|All files (*.*)|*.*"
       
        if self.OpenDialog1.Execute():
            self.FilenameLabel.Text = os.path.basename(self.OpenDialog1.FileName) # Display selected image name
            self.EditImage.Bitmap.LoadFromFile(self.OpenDialog1.FileName)
            self.RemoveBgImage.Bitmap.LoadFromFile(self.OpenDialog1.FileName)
            self.public_id = self.FilenameLabel.Text.split('.')[0]

Next, we will create a BoxChecked function to turn our Width and Height edit labels on or off. Here is what the function looks like:

def BoxChecked(self, Sender):
        if self.DimensionsCheckBox.IsChecked:
            # Enable the WidthEdit and HeightEdit controls
            self.WidthEdit.Enabled = True
            self.HeightEdit.Enabled = True
        else:
            # Disable the WidthEdit and HeightEdit controls
            self.WidthEdit.Enabled = False
            self.HeightEdit.Enabled = False

Before moving forward, we will define a helper function to help us download our images from the Cloudinary cloud. Start by creating a download function inside the MainForm class. Next, we will use requests to retrieve the image using a url provided in the results parameter. The image is then saved in the path defined in the local_file_path parameter. Finally, it is then loaded onto the form using the image parameter. Here is what our final function looks like:

def Download(self, result, local_file_path, image):
        # Retrieving Image
        response = requests.get(result, stream=True)

        if response.status_code == 200:
            with open(local_file_path, "wb") as file:
                for chunk in response.iter_content(1024):
                    file.write(chunk)
            print(f"Transformed image saved to: {local_file_path}")

            # Load and display the downloaded image in the DownloadedImage control
            image.Bitmap.LoadFromFile(local_file_path)
        else:
            print("Failed to download the image.")

Now, let’s define our TransformButtonClick function. We will start by defining an empty list called transformations that will be used to pass our transformation parameters to the Cloudinary API. Next, we will check if the DimensionsCheckBox has been checked. If it has, we will add a width and height transformation to the list:

def TransformButtonClick(self, Sender):
        transformations = []
        # Adding Height and Width Parameters if Checkbox is checked
        if self.DimensionsCheckBox.IsChecked:
            if self.WidthEdit.Text.isdigit() and self.HeightEdit.Text.isdigit():
                transformations.append({"height": int(self.HeightEdit.Text), "width": int(self.WidthEdit.Text), "crop": "fill"})

Next, we will retrieve the transformation selected in the combo box as well as its intensity from the spin box. We will then add these transformations to the list and call the uploader function to upload the image with said transformation. Next, we will download the transformed image using our download function. Here is what our complete function looks like:

def TransformButtonClick(self, Sender):
        transformations = []
        # Adding Height and Width Parameters if Checkbox is checked
        if self.DimensionsCheckBox.IsChecked:
            if self.WidthEdit.Text.isdigit() and self.HeightEdit.Text.isdigit():
                transformations.append({"height": int(self.HeightEdit.Text), "width": int(self.WidthEdit.Text), "crop": "fill"})
       
        # Adding Effect Paramets along with Intensity
        if self.EffectComboBox.ItemIndex in list(self.effect_options.keys()) and self.effect_options[self.EffectComboBox.ItemIndex] != "--" and self.SpinBox1.Text.isdigit():
            if 0 < int(self.SpinBox1.Text) <= 100:
                transformations.append({"effect": "{}:{}".format(self.effect_options[self.EffectComboBox.ItemIndex], self.SpinBox1.Text)})

        # Upload the image to Cloudinary with the specified public ID
        result = uploader.upload(self.OpenDialog1.FileName, public_id=self.public_id, transformation=transformations)['secure_url']

        # Define the local file path where you want to save the image
        local_file_path = ".Imagesedited_"+self.FilenameLabel.Text  # Change to your desired local path

        # Download the transformed image and save it locally
        self.Download(result, local_file_path, self.EditImage)

Finally, we can complete our app by defining the RemoveButtonClick function. Like the TransformButtonClick function, we will make a simple API call to the Cloudinary cloud with a background_removal parameter. This parameter uses the Cloudinary AI Background Removal addon which removes the background from our image. You can learn more about this addon here. Here is what our final function looks like:

def RemoveButtonClick(self, Sender):
        self.public_id+='_removal'

        # Uploading Image with background removal API
        result = uploader.upload(self.OpenDialog1.FileName, public_id=self.public_id, background_removal = "cloudinary_ai")
        print(result)
        result= result['secure_url']
        image = CloudinaryImage(self.public_id)

        # Retrieving Image URL
        result = image.url + ".png"
        print(result)

        # Defining Local Save Path
        local_file_path = ".Imagesbg_removed_"+self.public_id+".png" # Change to your desired local path

        # Adding Time for background removal completion
        time.sleep(5)

        # Downloading Image
        self.Download(result, local_file_path, self.RemoveBgImage)

Here is what our final Main.py file looks like:

import os
from delphifmx import *

# Additional Imports
import cloudinary
from cloudinary import uploader
from cloudinary import CloudinaryImage
import requests
import time

class MainFrom(Form):
    def __init__(self, owner):
        self.TabControl1 = None
        self.Edit = None
        self.FilenameLabel = None
        self.EffectLabel = None
        self.IntensityLabel = None
        self.WidthLabel = None
        self.HeightLabel = None
        self.TransformButton = None
        self.FileButton = None
        self.EffectComboBox = None
        self.SpinBox1 = None
        self.DimensionsCheckBox = None
        self.EditImage = None
        self.BackgroundRemoval = None
        self.RemoveBgImage = None
        self.RemoveButton = None
        self.OpenDialog1 = None
        self.StyleBook1 = None
        self.WidthEdit = None
        self.HeightEdit = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

        # Defining different effect options
        self.effect_options = {0:"--", 1:"cartoonify", 2:"pixelate", 3:"sepia", 4:"vignette", 5:"grayscale"}

        # Populating ComboBox
        for option in list(self.effect_options.values()):
            self.EffectComboBox.Items.Add(option)

        # Configure Cloudinary with your account details
        cloudinary.config(
        cloud_name = "dzte1natd",
        api_key = "558364876947471",
        api_secret = "Llc8TFU56g17mjPWK_kEgNd--mE"
        )

    def BoxChecked(self, Sender):
        if self.DimensionsCheckBox.IsChecked:
            # Enable the WidthEdit and HeightEdit controls
            self.WidthEdit.Enabled = True
            self.HeightEdit.Enabled = True
        else:
            # Disable the WidthEdit and HeightEdit controls
            self.WidthEdit.Enabled = False
            self.HeightEdit.Enabled = False

    def TransformButtonClick(self, Sender):
        transformations = []
        # Adding Height and Width Parameters if Checkbox is checked
        if self.DimensionsCheckBox.IsChecked:
            if self.WidthEdit.Text.isdigit() and self.HeightEdit.Text.isdigit():
                transformations.append({"height": int(self.HeightEdit.Text), "width": int(self.WidthEdit.Text), "crop": "fill"})
       
        # Adding Effect Paramets along with Intensity
        if self.EffectComboBox.ItemIndex in list(self.effect_options.keys()) and self.effect_options[self.EffectComboBox.ItemIndex] != "--" and self.SpinBox1.Text.isdigit():
            if 0 < int(self.SpinBox1.Text) <= 100:
                transformations.append({"effect": "{}:{}".format(self.effect_options[self.EffectComboBox.ItemIndex], self.SpinBox1.Text)})

        # Upload the image to Cloudinary with the specified public ID
        result = uploader.upload(self.OpenDialog1.FileName, public_id=self.public_id, transformation=transformations)['secure_url']

        # Define the local file path where you want to save the image
        local_file_path = ".Imagesedited_"+self.FilenameLabel.Text  # Change to your desired local path

        # Download the transformed image and save it locally
        self.Download(result, local_file_path, self.EditImage)

    def FileButtonClick(self, Sender):
        # Filepicker window title
        self.OpenDialog1.Title = "Select an Image"

        # Filtering only image formats to show
        self.OpenDialog1.Filter = "Image files (*.jpg;*.jpeg;*.png;*.bmp,*.webp)|*.jpg;*.jpeg;*.png;*.bmp;*.webp|All files (*.*)|*.*"
       
        if self.OpenDialog1.Execute():
            self.FilenameLabel.Text = os.path.basename(self.OpenDialog1.FileName) # Display selected image name
            self.EditImage.Bitmap.LoadFromFile(self.OpenDialog1.FileName)
            self.RemoveBgImage.Bitmap.LoadFromFile(self.OpenDialog1.FileName)
            self.public_id = self.FilenameLabel.Text.split('.')[0]

    def RemoveButtonClick(self, Sender):
        self.public_id+='_removal'

        # Uploading Image with background removal API
        result = uploader.upload(self.OpenDialog1.FileName, public_id=self.public_id, background_removal = "cloudinary_ai")
        print(result)
        result= result['secure_url']
        image = CloudinaryImage(self.public_id)

        # Retrieving Image URL
        result = image.url + ".png"
        print(result)

        # Defining Local Save Path
        local_file_path = ".Imagesbg_removed_"+self.public_id+".png" # Change to your desired local path

        # Adding Time for background removal completion
        time.sleep(5)

        # Downloading Image
        self.Download(result, local_file_path, self.RemoveBgImage)

    def Download(self, result, local_file_path, image):
        # Retrieving Image
        response = requests.get(result, stream=True)

        if response.status_code == 200:
            with open(local_file_path, "wb") as file:
                for chunk in response.iter_content(1024):
                    file.write(chunk)
            print(f"Transformed image saved to: {local_file_path}")

            # Load and display the downloaded image in the DownloadedImage control
            image.Bitmap.LoadFromFile(local_file_path)
        else:
            print("Failed to download the image.")

What does the final Python image editing app look like?  

Now that everything is complete, all we need to do is open up the ImageEditor.py file and run it.

Next, click on the File button and load up an image file. For now, we will be loading using an image of a teacher as a reference.

Once you’ve selected your image, you can add an effect to your image. Here, we will add a pixelate effect with an intensity of 30.

Finally, click the Transform button to add the effect to your image.

Next, let’s head over to the Background Removal tab.

Now click on Remove to remove the background of the subject.

Are you ready to create more apps with DelphiFMX?

Creating an image editing application with DelphiFMX empowers developers to leverage AI tools and elevate their image manipulation capabilities. By seamlessly integrating the Delphi IDE with the DelphiFMX Python library, you can lay the foundation for a robust image editor. Moreover, Delphi’s flexibility allows you to harness external APIs like Cloudinary for enhanced functionality, enabling features like advanced filters, dimension adjustments, and even background removal while managing to provide one of the best GUI tools.

Ready to embark on your creative journey? Dive into the world of image editing with DelphiFMX and unlock a realm of possibilities!

What are some important FAQs about creating great apps with Python and Delphi?

What are the benefits of using Delphi for image editing apps?

Delphi offers a powerful and flexible development environment for building image editing applications. It provides access to various libraries, APIs, and tools that streamline the development process and enable rich functionality.

Is DelphiFMX suitable for cross-platform development?

Yes, DelphiFMX is known for its cross-platform compatibility. You can develop apps for Windows, macOS, iOS, and Android using a single codebase, which is advantageous for reaching a wider audience.

Can I use external APIs like Cloudinary in my DelphiFMX app?

DelphiFMX allows you to integrate external APIs like Cloudinary to enhance your app’s capabilities. You can use APIs for image storage, management, and manipulation.

Can I monetize my image editing app created with DelphiFMX?

Yes, you can monetize your app through various means, such as offering it as a paid download, integrating ads, or offering in-app purchases for premium features

The post How to Build An Image Editor Using DelphiFMX Python Package first appeared on Python GUI.

What is Langchain?

LangChain is a framework for creating language model-driven applications. Language models are artificial intelligence programs that can produce text in natural language in response to inputs like questions, prompts, or documents. With LangChain, you can link a language model to additional data sources like files, databases, or web pages and communicate with them using natural language. Using different components and APIs offered by LangChain, you may also alter how the language model and application behave. With LangChain, you may create various apps, such as chatbots, code generators, document summarization tools, and more.

How to build a custom chat app with  LangChain and DelphiFMX?

In this article, we intend to go over the basics of LangChain in Python and use Openai’s LLM model to create a chat app that considers the user’s age and gives answers according to this information. So the GUI will involve two screens. Some user data is taken on the first screen, while the second screen is the chat screen with widgets like a memo, button, and textbox.

What are the prerequisites of the custom chat app project?

To create the custom chat application, you should install the Delphi IDE, the Delphi4PythonExporter tool, and the DelphiFMX library on your device. Additionally, you will need a text editor or IDE that supports Python, such as PyScripter. If you don’t have these tools installed, we recommend checking out the article “Powerful Python GUI Project Setup” to help you get started. 

Next, install Langchain and OpenAI by using the following command:

pip install langchain openai

Lastly, you can get the complete code for this project from our GitHub repository:

https://github.com/Embarcadero/PythonBlogExamples/tree/main/Custom_Chat_App

How to use a prompt template in LangChain?

You might be asking yourself, what are Prompt Templates? Why should we use them in Chatbots? In simple words, Prompt Templates are pre-defined recipes that help generate prompts for language models. These templates may include certain instructions, some examples to help the chatbot, or even specific contexts and/or questions to help the chatbot with a certain task.

Take, for example, ChatGPT. If you ask ChatGPT, “What is the definition of a Machine Learning model?” It might give you an in-depth and detailed answer. A prompt will help give ChatGPT instructions on how the user might want the question answered. For example, A prompt may append text to a query to modify the model’s output like the query above may change into “What is the definition of a Machine Learning model? Explain it to me like a 5-year-old.” This will change the answer, and the model may reduce complex words to make it easy for the user to understand.

LangChain, as a framework, provides many tools to create and work with prompt templates. Let’s start by creating a simple prompt template that helps our OpenAI chatbot. Start by creating a new file called LLMChat.py in your project directory and start importing some modules:

from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain.memory import ConversationBufferMemory

Next, create an LLM class with an __init__ and a getReply method:

class LLM():
    def __init__(self, name, age) -> None:
        pass

    def getReply(self, qs):
        pass

Start by initializing your name and age variables in the __init__ function and create an LLM model, a template for queries, and a ConversationBufferMemory to help store your previous conversations. You need to create your OpenAI api key and replace your key in the openai_api_key variable’s value:

class LLM():
    def __init__(self, name, age) -> None:
        self.age = age
        self.name = name

        llm = OpenAI(openai_api_key="**PUT YOUR API KEY HERE**", temperature=0) # Create instance of openai llm
        temp = "You are a nice chatbot having a conversation with a human of age {}.".format(age)
        template = temp + """ So respond appropriately and preferably in around 2 sentences.

        Previous conversation:
        {chat_history}

        New human question: {question}
        Response:"""
        prompt = PromptTemplate.from_template(template) # Create template for prompt to openai
        memory = ConversationBufferMemory(memory_key="chat_history") # Create buffer memory for multiturn conversation

Finally, we chain all the components using an LLMChain, completing our __init__ function:

def __init__(self, name, age) -> None:
        self.age = age
        self.name = name

        llm = OpenAI(openai_api_key="**PUT YOUR API KEY HERE**", temperature=0) # Create instance of openai llm
        temp = "You are a nice chatbot having a conversation with a human of age {}.".format(age)
        template = temp + """ So respond appropriately and preferably in around 2 sentences.

        Previous conversation:
        {chat_history}

        New human question: {question}
        Response:"""
        prompt = PromptTemplate.from_template(template) # Create template for prompt to openai
        memory = ConversationBufferMemory(memory_key="chat_history") # Create buffer memory for multiturn conversation
        self.conversation = LLMChain( # Chain all components
            llm=llm,
            prompt=prompt,
            memory=memory
        )

Next, navigate to the getReply method and simply use the model to generate a response to a question and then return the response. Here is what our complete LLMChat.py looks like:

from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain.memory import ConversationBufferMemory

class LLM():
    def __init__(self, name, age) -> None:
        self.age = age
        self.name = name

        llm = OpenAI(openai_api_key="your_openai_api_key", temperature=0) # Create instance of openai llm
        temp = "You are a nice chatbot having a conversation with a human of age {}.".format(age)
        template = temp + """ So respond appropriately and preferably in around 2 sentences.

        Previous conversation:
        {chat_history}

        New human question: {question}
        Response:"""
        prompt = PromptTemplate.from_template(template) # Create template for prompt to openai
        memory = ConversationBufferMemory(memory_key="chat_history") # Create buffer memory for multiturn conversation
        self.conversation = LLMChain( # Chain all components
            llm=llm,
            prompt=prompt,
            memory=memory
        )

    def getReply(self, qs):
        response = self.conversation({"question": qs}) # Provide conversation to LLM to get appropriate answer
        return response["text"]

How to design the user interface for our custom chat app in Delphi?

Now that our LangChain model is complete, we can start working on the user interface for our Delphi app.

Open up Delphi CE and create a new project using File > New > Multi-Device Application > Blank Application > Ok. Next, set up a name for the project. Here we are naming our project ChatApplication.

If you are unfamiliar with the various sections of the Delphi IDE, we recommend consulting our complimentary eBook bundle, which covers the Delphi Python Ecosystem and provides insights into all Python GUI offerings.

Next, let’s rename our form by right-clicking on it and selecting QuickEdit. Here we will set our form name as BioScreen with the caption Chat Application.

Next, we’ll rename the project’s source file to help us keep track of it. Head over to the Projects tab on the top-right corner of your screen and locate Unit1.pas file. This is the source file of your form. We will rename it to Bio.pas.

Next, we’ll use the head to the Object Inspector and resize our form using the ClientWidth and ClientHeight properties under the Properties tab.

Now, we’ll add a few labels to our form. Head over to the Palette and search for the TLabel component. Drop a few of these into your form.

Rename these components by right-clicking on them and opening up QuickEdit. Next, head over to the Object Inspector and customize the text style for each label using the TextSettings property based on your needs. You could additionally set the HorzAlign and VertAlign properties to Center to align your text. Here is what our form looks like:

Now, we’ll add a text box next to the Name label and a number box next to the Age label. Open up the Palette and search for the TEdit and TNumberBox components. As the name implies, the TEdit component will be used to input text to our form, whereas the TNumberBox will be used to input the age. Here is what our form looks like:

Next, let’s add a button to our form, which will be used to open up the chat screen. For this, we will use the TButton component, so navigate to the Palette and search for the component.

Next, modify the button using its Text Settings property. Finally, rename the button and set its caption. Here we’ve named our button StartButton with the caption Start Chatting.

Here is what our form looks like:

Finally, let’s finish our form by adding an image. Head over to the Palette and search for the TImage component. Add this component to your form.

Now select the TImage component and open the MultiResBitMap property in the Properties tab of the Object Inspector. Next, click the open button and select the image you want to use.

Here is what our form looks like:

Now that our BioScreen form is complete, we can move on and create our chat screen. Head over to the projects tab, and after right-clicking on ChatApplication.exe, select Add New > Multi-Device Form.

This will create a new form which we have named as ChatScreen, and the corresponding source file as Chat.pas. We have also renamed the form caption to Chat.

Next, let’s add a THeader and a TFooter component to our form. We also add a few labels, buttons, and an edit box to our form. Here is what our form looks like:

Finally, we need to add a text box to display our chats. For this, we’ll add a TMemo component that will be large enough to display all our messages and have a scroll to move up and down in the chat. Here is what our final form looks like:

Now that we’ve completed our forms, it’s time to add a few final touches. To do this, download the free ebook bundle, which comes shipped with a multitude of styles that you can choose from. Once downloaded, extract the FMX styles zip. Next, select the style you want to use. Here we will be using AquaGraphite.style available in the bundle.

Now, head to the Palette and add a TStyleBook component to your form. The placement does not matter for this component, as it will be invisible.

Now, double-click on the StyleBook1 component to open up your Style Designer. Click on the open button to open up a dialog box.

Now navigate to the Dark.style file in your styles directory, select your file and click exit and save.

Select your form and head over to the Object Inspector. Here search for the StyleBook property. Now, select the drop-down menu and select StyleBook1. This will add style to your form.

Here is what our final forms look like:

How to combine everything into our finished custom chat app? 

Now that our forms are complete, we need to add some functionality to the button so we don’t lose it when we export it in Python. To do this, double-click on each button on the forms. This will add an OnClick method to that button, creating a procedure in the .pas file of the form. This allows you to add unique functionality to each button when clicked.

Because the Delphi4PythonExporter does not use run-time implementation, we must add at least one comment (//) to each procedure to preserve the function when we export the form.

With this, we are ready to export our project. Select Tools > Export To Python > Export Current Entire Project to export the project.

Here we will give the project the title Chat Application. Next, select the directory of your choosing and click on Export:

Once the export is complete, head over to the project directory. Delphi will generate three Python files and two .pyfmx files. The ChatApplication.py file will be used to run the application, whereas the Bio.py and Chat.py files contain the class for the BioScreen and ChatScreen forms. The .pyfmx files contain the visual information for the forms. Here are the contents for each file.

ChatApplication.py:

from delphifmx import *
from Bio import BioScreen

def main():
    Application.Initialize()
    Application.Title = 'Chat Application'
    Application.MainForm = BioScreen(Application)
    Application.MainForm.Show()
    Application.Run()
    Application.MainForm.Destroy()

if __name__ == '__main__':
    main()

Bio.py:

import os
from delphifmx import *

class BioScreen(Form):

    def __init__(self, owner):
        self.TitleLabel = None
        self.AgeLabel = None
        self.NameLabel = None
        self.AgeNumberBox = None
        self.NameEdit = None
        self.Image1 = None
        self.StartButton = None
        self.StyleBook1 = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Bio.pyfmx"))

    def StartButtonClick(self, Sender):
        pass

Chat.py:

import os
from delphifmx import *

class ChatScreen(Form):

    def __init__(self, owner):
        self.SendButton = None
        self.UserQsEdit = None
        self.Header = None
        self.HeaderLabel = None
        self.Footer = None
        self.BackButton = None
        self.ChatMemo = None
        self.StyleBook1 = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Chat.pyfmx"))

    def SendButtonClick(self, Sender):
        pass

    def BackButtonClick(self, Sender):
        pass

Now, let’s begin adding functionality to our code. Start by copying and pasting the LLMChat.py file that we created earlier to the project folder. Next, open up Bio.py and import the ChatScreen form from Chat.py:

from chat import ChatScreen

Next, head over to the StartButtonClick function. Here we are simply going to create the ChatScreen, pass in our name and age variables, and then open up the screen. Here is what the StartButtonClick function looks like:

def StartButtonClick(self, Sender):
        chat = ChatScreen(self, name=self.NameEdit.Text, age=self.AgeNumberBox.Text)
        chat.Show()

Here is what our final Bio.py file looks like:

import os
from delphifmx import *
# Import chat form
from Chat import ChatScreen


class BioScreen(Form):

    def __init__(self, owner):
        self.TitleLabel = None
        self.AgeLabel = None
        self.NameLabel = None
        self.AgeNumberBox = None
        self.NameEdit = None
        self.Image1 = None
        self.StartButton = None
        self.StyleBook1 = None
        self.ErrorLabel = None
        self.LoadProps(os.path.join(os.path.dirname(
            os.path.abspath(__file__)), "Bio.pyfmx"))

    def StartButtonClick(self, Sender):
        chat = ChatScreen(self, name=self.NameEdit.Text,
                          age=self.AgeNumberBox.Text)
        chat.Show()

Next, open up Chat.py and start by importing the LLM class from the LLMChat.py file. 

from LLMChat import LLM

Now head over to the __init__ function and start by adding some additional name and age parameters to the function. Next, we’ll re-initialize the HeaderLabel with the name of our user and store the name and age in new variables. Finally, we’ll create an instance of our LLM class in the constructor. Here is what our __init__ function looks like:

def __init__(self, owner, name, age):
        self.SendButton = None
        self.UserQsEdit = None
        self.Header = None
        self.HeaderLabel = None
        self.Footer = None
        self.BackButton = None
        self.ChatMemo = None
        self.StyleBook1 = None
        self.LoadProps(os.path.join(os.path.dirname(
            os.path.abspath(__file__)), "Chat.pyfmx"))

        self.HeaderLabel.Text = "{}'s Chat".format(name)
        self.age = age
        self.name = name
        self.llm = LLM(name, age)  # Create LLM chain instance

Next, in our SendButtonClick function, we’ll simply add a formatted user query to the ChatMemo. Once we get a reply from the LLM model, we will append that to the ChatMemo too. Here is what our final function looks like:

def SendButtonClick(self, Sender):
        # Add user's question to the memo for chat history
        self.ChatMemo.Lines.Add("{}: {}".format(
            self.name, self.UserQsEdit.Text))
        # Get the reponse to the question
        reply = self.llm.getReply(self.UserQsEdit.Text)
        # Add the response to the memo as well
        self.ChatMemo.Lines.Add("Chatbot:{}".format(reply))

Finally, our BackButtonClick will only be used to close the chat screen, which we can simply do using self.Destroy(). Here is what our final Chat.py file looks like:

import os
from delphifmx import *
# More required imports
from LLMChat import LLM


class ChatScreen(Form):

    def __init__(self, owner, name, age):
        self.SendButton = None
        self.UserQsEdit = None
        self.Header = None
        self.HeaderLabel = None
        self.Footer = None
        self.BackButton = None
        self.ChatMemo = None
        self.StyleBook1 = None
        self.LoadProps(os.path.join(os.path.dirname(
            os.path.abspath(__file__)), "Chat.pyfmx"))

        self.HeaderLabel.Text = "{}'s Chat".format(name)
        self.age = age
        self.name = name
        self.llm = LLM(name, age)  # Create LLM chain instance

    def SendButtonClick(self, Sender):
        # Add user's question to the memo for chat history
        self.ChatMemo.Lines.Add("{}: {}".format(
            self.name, self.UserQsEdit.Text))
        # Get the reponse to the question
        reply = self.llm.getReply(self.UserQsEdit.Text)
        # Add the response to the memo as well
        self.ChatMemo.Lines.Add("Chatbot:{}".format(reply))

    def BackButtonClick(self, Sender):
        self.Destroy()

Now that our application is ready let’s test it out. Head over to ChatApplication.py and run the file.

Next, add your name and age and click on Start Chatting.

This should open up your chat screen.

Now simply start messaging on the chat app.

What have you learned in this custom chat app tutorial?

In today’s world of advanced communication, we’re talking about smart chatbots like ChatGPT and tools like LangChain that make them work better together. This tutorial has shown us how LangChain, DelphiFMX, and Python can be paired to make a custom chat app with an amazing GUI.

LangChain is like the main character, letting computers talk like humans using trained language models. With this magic, we’re making a chat app that talks in a smart way, depending on how old you are. We saw how Delphi allows us to add more personalization by adding the user’s name in several places of the GUI. This tutorial shows how exciting things can happen when smart tech and good GUIs come together, inviting us to change how we talk and connect using computers.

Ready to get creative? Dive into the world of DelphiFMX and start crafting your own unique apps today. Download Delphi and unleash your imagination!

What are some FAQs related to this custom chat app tutorial?

What is LangChain, and how does it relate to chat applications?

LangChain is a framework that uses language models to create text-based applications. In the context of chat apps, LangChain enables the creation of chatbots and other communication tools that understand and generate natural language responses.

Do I need to be an expert in machine learning to use LangChain?

LangChain is designed to simplify the process of using language models for developers. While some familiarity with machine learning concepts could be helpful, the framework aims to make it accessible to a wider range of developers.

What is DelphiFMX, and why is it used in this tutorial?

DelphiFMX is a graphical user interface framework that allows developers to create cross-platform applications with rich UI experiences. It’s used in this tutorial to design the user interface for the chat app.

Do I need prior experience with Delphi to follow this tutorial?

While prior experience with Delphi could be beneficial, the tutorial should provide step-by-step guidance to help you create the chat app, even if you’re new to Delphi programming.

The post How To Use LangChain and DelphiFMX To Create a Custom Chat App first appeared on Python GUI.

This tutorial will create a powerful Iris Flower Classification app using DelphiFMX and Support Vector Machines (SVM). Harnessing the prowess of machine learning and the Delphi ecosystem, we will enable users to classify iris flowers accurately and efficiently. Experience the excitement of building an ML-powered app with DelphiFMX and providing users with real-time insights into flower species right at their fingertips.

Why Are Support Vector Machines Gaining Popularity?

Support Vector Machines (SVM) have become increasingly popular in machine learning due to their remarkable effectiveness in classification tasks. They exhibit versatility in handling binary and multi-class classification problems, making them suitable for various applications. SVMs thrive in high-dimensional feature spaces, making them well-suited for complex datasets, including text classification, image recognition, and bioinformatics. One of their key strengths lies in their robustness against overfitting leading to reliable generalization. 

Additionally, SVMs utilize the kernel trick to efficiently deal with non-linearly separable data by transforming the feature space into a higher-dimensional space. This attribute and their memory efficiency ensure practical applicability with large datasets. Moreover, SVMs provide clear decision boundaries, contributing to their interpretability and explainability, which are essential in scenarios where understanding model reasoning is crucial. 

How to Create the Iris Flower Classification App with DelphiFMX?

Creating a flower classification app involves several steps. Before we get into the detailed tutorial, let’s check the requirements for this project.

Install the RAD Studio with Delphi IDE and the DelphiFMX on your device to create the flower classification app. You will need a text editor or IDE that supports Python, such as PyScripter and the Delphi4PythonExporter tool. If you don’t have these tools installed, checking out the article “Powerful Python GUI Project Setup” is recommended. 

You should also install Python’s scikit-learn library by running the following command in the cmd:

pip install -U scikit-learn

You can retrieve the project code from the following GitHub link:

https://github.com/Embarcadero/PythonBlogExamples/tree/main/Iris_Flower_Classifier

Which Dataset Can be Used for Such a Task?

For the Iris Flower Classification app, the ideal dataset to use is the famous Iris dataset from the scikit-learn library. The Iris dataset is a well-known and widely used dataset in the field of machine learning. It contains 150 samples of iris flowers, with each sample representing a different iris species: setosa, versicolor, or virginica. For each sample, four features are recorded: sepal length, sepal width, petal length, and petal width.

How to Train a Support Vector Machine Classifier?

Training an SVM classifier is very simple in Python:

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC

# Load the Iris dataset
iris = load_iris()
X, y = iris.data, iris.target

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train the Support Vector Machine Classifier
svm = SVC()
svm.fit(X_train, y_train)

The above code utilizes scikit-learn to train an SVM classifier for Iris flower classification. The Iris dataset is loaded, containing features and target labels representing different iris species. The data is split into training and testing sets, and an SVM classifier is instantiated. The classifier is then trained on the training data, learning to separate the iris species based on their features. The SVM algorithm aims to find the optimal decision boundary with the maximum margin between classes, making it a powerful tool for classification tasks like iris flower classification.

How to Design the User Interface with DelphiFMX?

Now that we know how to create our train our classifier let’s start creating our Delphi app.
Start by opening up Delphi CE and create a new project by navigating to File > New > Multi-Device Application > Blank Application > Ok. For this tutorial, we are naming our project IrisFlowerClassifier.

If you are unfamiliar with the various sections of the Delphi IDE, we recommend consulting our complimentary eBook bundle, which covers the Delphi Python Ecosystem and provides insights into all Python GUI offerings.

Next, we will rename our form. To do this, right-click on your form and select QuickEdit. This will open up your edit box. Here we will set our form name as MainForm with the caption Iris Flower Classifier App.

Now head over to the Projects tab on the top-right corner of your screen and locate the Unit1.pas file. This is the source file of your form. We will rename it to Main.pas to help us keep track of our form.

Finally, we will resize our form to make it more appealing. Select your form and head over to the Object Inspector. Here click on the properties tab and search for the ClientWidth and ClientHeight properties. We will resize our form by setting them to 360 and 500, respectively.

With the basics out of the way, we can start by adding elements to our form. Head to the Palette in the bottom-right corner and search for the TLabel component. Now drag and drop this component on your form. We will add six labels to our form. Five of our Labels will be static, i.e. they will not change and will be used as indicators. This includes our title, sepal length, sepal width, petal length, and petal width labels which we’ve named as Title, SLength, SWidth, PLength, and PWidth. One of our labels which we’ve named Result will be used to show the prediction of the flower.

Next, we will select each label and head over to the Object Inspector. Here we’ll customize the text style for each label using the TextSettings property. Click on the ellipsis button (…) next to the Font property to explore various options for modifying the label. As always, we will use the SemiBold Segue UI font family and distinct font sizes for each label. Additionally, we’ll set our labels’ HorzAlign and VertAlign properties to Center.

Here is what our form looks like:

Next, let’s add a button to our form. This button will be used to trigger the prediction function. For this, we will use the TButton component, so navigate to the Palette and search for the component.

Next, modify the button using its Text Settings property. Finally, rename the button and set its caption. Here we’ve named our button Predict with the caption Classify Flower. Here is what our form looks like:

Finally, let’s add text boxes before our labels to allow the user to input some text. To do this, open up the Palette and search for TEdit. Add this component to your form. We will follow the same naming convention as our labels but add an Edit to the end. For example, our sepal length edit box will be named as SLengthEdit. Here is what our form looks like:

Now that our form is ready, we can add a few final touches by adding styles. To do this, download the free ebook bundle, which comes shipped with a multitude of styles that you can choose from. 

Once your ebook has been downloaded, extract the FMX styles zip in your chosen directory. Next, select the style you want to use. Here we will be using AquaGraphite.style available in the bundle.

To use this style, head to the Palette and add a TStyleBook component to your form. The placement does not matter for this component, as it will be invisible.

Next, double-click on the StyleBook1 component. This will open up your Style Designer. Next, click on the open button to open up a dialog box.

Now navigate to the AquaGraphite.style file in your styles directory, select your file, and click exit and save. 

Now select your form and head over to the Object Inspector. Here search for the StyleBook property. Next, select the drop-down menu and select StyleBook1. This will add style to your form.

Here is what our final form looks like:

How to Put it Altogether?

Now that our form is ready, we need to add some functionality to the Predict button so that we don’t lose it when we export it in Python. To do this, double-click the button on the form. This will add an OnClick method to that button, creating a procedure in the .pas file of the form. This allows you to add unique functionality to each button when clicked.

Because the Delphi4PythonExporter does not use run-time implementation, we must add at least one comment (//) to each procedure to preserve the function when we export the form.

With this, we are ready to export our project. Select Tools > Export To Python > Export Current Entire Project to export the project.

Here we will give the project the title Iris Flower Classifier App. Next, select the directory of your choosing and click on Export:

Once the export is complete, head over to the project directory. Because we only had a single form, Delphi will generate two Python files and one .pyfmx file. The IrisFlowerClassifier.py file will be used to run the application, whereas the Main.py file contains the class for the MainForm. The Main.pyfmx file contains the visual information for the MainForm. Here are the contents for each file.

IrisFlowerClassifier.py:

from delphifmx import *
from Main import Form1

def main():
    Application.Initialize()
    Application.Title = 'Iris Flower Classifier App'
    Application.MainForm = MainForm(Application)
    Application.MainForm.Show()
    Application.Run()
    Application.MainForm.Destroy()

if __name__ == '__main__':
    main()

Main.py:

import os
from delphifmx import *

class MainForm(Form):

    def __init__(self, owner):
        self.Title = None
        self.SLength = None
        self.SWidth = None
        self.PLength = None
        self.PWidth = None
        self.Result = None
        self.SLengthEdit = None
        self.SWidthEdit = None
        self.PLengthEdit = None
        self.PWidthEdit = None
        self.Predict = None
        self.StyleBook1 = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

    def PredictClick(self, Sender):
        pass

Now, let’s begin adding functionality to our code. Start by opening up Main.py and importing the relevant libraries.

# Additional imports
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier

Next, head over to the __init__ function. Here we will start by loading the Iris dataset, splitting the data set into testing and training sets, and finally, training the SVC model. Here is what our __init__ function will look like:

def __init__(self, owner):
        self.Title = None
        self.SLength = None
        self.SWidth = None
        self.PLength = None
        self.PWidth = None
        self.Result = None
        self.SLengthEdit = None
        self.SWidthEdit = None
        self.PLengthEdit = None
        self.PWidthEdit = None
        self.Predict = None
        self.StyleBook1 = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

        # Load the Iris dataset
        self.iris = load_iris()
        X, y = self.iris.data, self.iris.target

        # Split the data into training and testing sets
        X_train, _, y_train, _ = train_test_split(X, y, test_size=0.2, random_state=42)

        # Train the SVC model
        self.knn = SVC()
        self.knn.fit(X_train, y_train)

Next, lets move to the PredictButton click function. This function will only be triggered when we click on the Classify Flower button. To predict our flowers, we will first need to retrieve the values from our TEdit boxes. So we will use a try-except block so that our app does not crash.

Start by taking out the length and width values for the petal and sepal and convert them into floating point numbers inside the try block. Next, convert these values into a nested list and pass them into the classifiers predict function:

def PredictClick(self, Sender):
        # User input for flower measurements
        try:
            sepal_length = float(self.SLengthEdit.Text)
            sepal_width = float(self.SWidthEdit.Text)
            petal_length = float(self.PLengthEdit.Text)
            petal_width = float(self.PWidthEdit.Text)
            new_flower = [[sepal_length, sepal_width, petal_length, petal_width]]
            predicted_species = self.knn.predict(new_flower)

Now map the predicted label to the corresponding name of the species, and show the result in the Result label:

def PredictClick(self, Sender):
        # User input for flower measurements
        try:
            sepal_length = float(self.SLengthEdit.Text)
            sepal_width = float(self.SWidthEdit.Text)
            petal_length = float(self.PLengthEdit.Text)
            petal_width = float(self.PWidthEdit.Text)
            new_flower = [[sepal_length, sepal_width, petal_length, petal_width]]
            predicted_species = self.knn.predict(new_flower)

            # Map the predicted label to the corresponding species name
            species_names = self.iris.target_names
            predicted_species_name = species_names[predicted_species[0]]
            self.Result.Text = "Species name: {}".format(predicted_species_name.capitalize())

Finally, if any of the fields are missing, we will return an error in our Result label using the except block. Here is what our PredictClick function looks like:

def PredictClick(self, Sender):
        # User input for flower measurements
        try:
            sepal_length = float(self.SLengthEdit.Text)
            sepal_width = float(self.SWidthEdit.Text)
            petal_length = float(self.PLengthEdit.Text)
            petal_width = float(self.PWidthEdit.Text)
            new_flower = [[sepal_length, sepal_width, petal_length, petal_width]]
            predicted_species = self.knn.predict(new_flower)

            # Map the predicted label to the corresponding species name
            species_names = self.iris.target_names
            predicted_species_name = species_names[predicted_species[0]]
            self.Result.Text = "Species Name: {}".format(predicted_species_name.capitalize())
        except:
            self.Result.Text = "Error! Incomplete or invalid input fields."

Here is what our final Main.py file looks like:

import os
from delphifmx import *
# Additional imports
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC

class MainForm(Form):

    def __init__(self, owner):
        self.Title = None
        self.SLength = None
        self.SWidth = None
        self.PLength = None
        self.PWidth = None
        self.Result = None
        self.SLengthEdit = None
        self.SWidthEdit = None
        self.PLengthEdit = None
        self.PWidthEdit = None
        self.Predict = None
        self.StyleBook1 = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))
       
        # Load the Iris dataset
        self.iris = load_iris()
        X, y = self.iris.data, self.iris.target

        # Split the data into training and testing sets
        X_train, _, y_train, _ = train_test_split(X, y, test_size=0.2, random_state=42)

        # Train the SVC model
        self.knn = SVC()
        self.knn.fit(X_train, y_train)

    def PredictClick(self, Sender):
        # User input for flower measurements
        try:
            sepal_length = float(self.SLengthEdit.Text)
            sepal_width = float(self.SWidthEdit.Text)
            petal_length = float(self.PLengthEdit.Text)
            petal_width = float(self.PWidthEdit.Text)
            new_flower = [[sepal_length, sepal_width, petal_length, petal_width]]
            predicted_species = self.knn.predict(new_flower)

            # Map the predicted label to the corresponding species name
            species_names = self.iris.target_names
            predicted_species_name = species_names[predicted_species[0]]
            self.Result.Text = "Species Name: {}".format(predicted_species_name.capitalize())
        except:
            self.Result.Text = "Error! Incomplete or invalid input fields."

Does the App Meet Expectations When Tested?

Now that our application is ready, let’s test it out. Head over to IrisFlowerClassifier.py and run the file.

Let’s add a few values to our app that satisfy the values for the Setosa flower:

Finally, click on the Classify button to get the prediction:

Now, let’s test it out for another random flower:

Clicking on the Classify button, we get the prediction that our random flower is actually Verginica:

Are You Ready to Create ML-Powered Apps of Your Own?

Building image classification apps is both a fascinating and rewarding endeavor. It empowers developers to accurately identify and classify objects within images, opening up a world of possibilities for diverse applications. We recommend exploring the Delphi ecosystem to streamline your development journey and unlock enhanced potential. With DelphiFMX at its core, alongside Delphi IDE and Delphi4PythonExporter, you gain access to a comprehensive suite of tools and frameworks for GUI development, seamlessly integrating with Python ML backends.

Are you excited to venture into the world of flower classification apps? Download the IDE to embrace the power of Delphi and embark on an enriching journey of ML-based app development! 

What Are Some FAQs Related to this Topic?

What is a Support Vector Machine (SVM)?

A Support Vector Machine is a supervised machine learning algorithm used for classification and regression tasks. It aims to find the optimal hyperplane that best separates different classes in the data.

Can SVM handle imbalanced datasets?

SVMs can be sensitive to imbalanced datasets. Techniques like class weighting or using different cost functions can be applied to address this issue.

What are the advantages of using SVM over other classifiers?

SVMs are effective in high-dimensional spaces, robust against overfitting, and have good generalization properties. They work well with both small and large datasets.

What is DelphiFMX (FireMonkey)?

DelphiFMX (FireMonkey) is a powerful cross-platform GUI (Graphical User Interface) framework provided by Embarcadero’s Delphi IDE. It enables developers to create visually stunning and responsive user interfaces for applications running on multiple platforms, such as Windows, macOS, iOS, and Android, using a single codebase.

What are the key advantages of using DelphiFMX?

DelphiFMX offers several advantages, including cross-platform support, native performance on different operating systems, access to native controls, and the ability to create visually appealing apps with rich animations and effects.

Can I use third-party components with DelphiFMX?

Yes, DelphiFMX allows developers to use third-party components and libraries to extend the functionality of their applications. This flexibility enables developers to integrate additional features and tools into their projects.

The post How To Build an Iris Flower Classification GUI App With DelphiFMX first appeared on Python GUI.

What is Art Style Transfer and Why is it Exciting?

Art Style Transfer or more technically known as Neural Style Transfer, is a technique that uses deep neural networks to apply the artistic style of one image (the style image) to the content of another image (the content image). This process results in a new image that combines the original image’s content with the style image’s visual characteristics. It opens up a world of possibilities for creating artistic and imaginative images that blend different artistic styles seamlessly. So in this tutorial, we employ deep learning to create an image in the style of another image, a process commonly referred to as neural style transfer.

What is the Python Delphi Ecosystem Consist of?

The Python Delphi ecosystem consists of the Delphi IDE (Integrated Development Environment) and Delphi FMX (FireMonkey), which enable developers to build cross-platform applications with visually stunning and responsive user interfaces. Delphi FMX supports multi-platform development, allowing apps to run on Windows, macOS, iOS, and Android using a single codebase. 

Additionally, the ecosystem includes the Delphi4Python Exporter, a vital tool that facilitates the seamless integration of Python code within Delphi. This integration empowers developers to leverage Python’s vast libraries and AI capabilities while harnessing the visual prowess of Delphi FMX, offering a powerful environment for creating innovative applications, particularly in AI and machine learning domains.

How to Create an Art Style Transfer App? 

What Are the Prerequisites for this Art Style Transfer App?

To create our art style transfer app, ensure you have Delphi IDE and the FireMonkey GUI framework installed on your device. Moreover, you will need a text editor or IDE that supports Python, such as PyScripter, along with the Delphi4PythonExporter tool for Python integration. If you don’t have these tools already, refer to the article “Powerful Python GUI Project Setup” for guidance.

Furthermore, make sure to install the required Python libraries by running the following commands in the command prompt or terminal:

pip install pillow
pip install tensorflow
pip install tensorflow-hub

Lastly, to access the code for this tutorial, you can download it from our GitHub repository through the following link:

https://github.com/Embarcadero/PythonBlogExamples/tree/main/Art_Style_Transfer_App

By meeting these prerequisites, you’ll be fully equipped to dive into the exciting world of AI art and create your own art style transfer app using the Delphi ecosystem and Python libraries.

Are there any Python Libraries for Implementing the Neural Style Transfer Algorithm?

Yes, there are Python libraries available for implementing the Neural Style Transfer algorithm. One prominent library is TensorFlow Hub. TensorFlow Hub provides pre-trained models that can be used to easily apply the optimization technique to blend a content image with a style reference image, producing an output image that adopts the reference style while preserving the original image’s content.

How to Build the User Interface with Delphi?

Let’s begin by launching the Delphi CE application and creating a new project. To achieve this, navigate to File > New > Multi-Device Application > Blank Application > Ok. For this tutorial, we’ve named our project ArtStyleTransferApp.

If you are unfamiliar with the various sections of the Delphi IDE, we recommend consulting our complimentary eBook bundle, which covers the Delphi Python Ecosystem and provides insights into all Python GUI offerings.

Let’s begin by renaming our form. Right-click on the form and select QuickEdit. This will open up an edit box, where we will set the name of our form as MainForm with the caption Art Style Transfer App.

Now, head over to the Projects tab and rename the source file of the form from Unit1.pas to Main.pas. We are doing this to help us keep track of our forms.

Now let’s start working on our form. First, we will resize our forms by heading to the Object Inspector and searching for the ClientWidth and ClientHeight in the properties tab. We will resize our form by setting them to 624 and 640, respectively.

Next, we’ll proceed by adding a few labels to our app. Access the standard palette and locate the TLabel component. Drag and drop this component onto the form to include it. We will be adding three labels to our form. The first will be a title label, Title, displayed at the top of the form. The second and third labels, StyleImageLabel and ContentImagelabel, will be used to indicate the style image and the image to be converted.

Following that, we’ll customize the text style using the TextSettings property of each label. To do so, access the Object Inspector and search for TextSettings. Click on the ellipsis button (...) next to the Font property to explore various options for modifying the label’s appearance based on your preferences. In this case, we’ve chosen the SemiBold Segoe UI font family and distinct font sizes for each label. Additionally, we’ll set our labels’ HorzAlign and VertAlign properties to Center.

Here is what our form looks like:

Next, let’s add a few buttons to our form. For this, we will use the TButton component, so navigate to the Palette and search for the component.

We will add two Upload buttons to our form. One button called UploadStyleButton will be used to upload a style image that will be used for reference. The second upload button that, we will name UploadContentButton will help us select the file to be converted. Finally, we will add an Apply button, ApplyButton, to run the image generation algorithm.

Next, we’ll customize the text style using the TextSettings property of each button. Here is what our form looks like:

Now, we will add two TOpenDialog components to our form. These components will help us open a dialog box to select a file from our system. So open up the Palette and search for the component. Next, drag and drop this component anywhere into your form. The placement of these components will not matter as they will be invisible.

Finally, let’s finish our forms by adding some holders showing our images. Head over to the Palette and search for the TImage component. Add three of these components to your form.

Now, right-click on each component and define its name. Here we will set the left image component under Style Image as StyleImage, the component under Content Image as ContentImage, and finally, the component at the bottom as FinalImage. Here is what our form looks like:

With this, the functional components of our form are ready. Now we can add a few final touches to make our form more visually appealing. We will do this by downloading the free ebook bundle, which comes shipped with a multitude of styles that you can choose from. 

After downloading your free ebook, extract the FMX styles zip in your chosen directory. Next, select the style you want to use. Here we will be using Drak.style available in the bundle.

To use this style, head to the Palette and add the TStyleBook component to your form. Again, the placement does not matter for this component, as this, too, will be invisible.

Double-click on the StyleBook1 component to open up your Style Designer. Next, click on the open button to open up a dialog box.

Now navigate to the Dark.style file in your styles directory, select your file and finally click on exit.

Once you’ve finalized your style, select the MainForm and head to the Object Inspector. Here we will search for the StyleBook property. Select the drop-down menu and select StyleBook1.

Here is what our final form looks like:

How to Integrate the Style Transfer Algorithm into the App?

Before integrating the style transfer algorithm into our app, we must export it using the Delphi4Python exporter. However, exporting right now will cause the buttons to lose their function. Therefore, we will need to add functionality to each button in the form. 

To do this, double-click on each button on the form. This will add an OnClick method to that button. The procedure will be created in the .pas file of the form. This allows you to add unique functionality to each button when clicked.

Because the Delphi4PythonExporter does not use run-time implementation, we must add at least one comment (//) to each procedure to preserve the function when we export the form.

Now that our form is ready, we are ready to export. Select Tools > Export To Python > Export Current Entire Project to export the project.

Here we will give the project the title Art Style Transfer App. Next, select the directory of your choosing and click on Export:

Because we had one form, Delphi will generate two Python files and one .pyfmx file. The ArtStyleTransferApp.py file will be used to run the application, whereas the Main.py file contains the class for the MainForm. The Main.pyfmx file contains the visual information for the MainForm. Here are the contents for each file.

KMeansClustering.py:

from delphifmx import *
from Main import MainForm

def main():
    Application.Initialize()
    Application.Title = 'Art Style Transfer App'
    Application.MainForm = MainForm(Application)
    Application.MainForm.Show()
    Application.Run()
    Application.MainForm.Destroy()

if __name__ == '__main__':
    main()

Main.py:

import os
from delphifmx import *

class MainForm(Form):

    def __init__(self, owner):
        self.Title = None
        self.StyleImageLabel = None
        self.ContentImageLabel = None
        self.UploadContentButton = None
        self.UploadStyleButton = None
        self.ApplyButton = None
        self.StyleImage = None
        self.ContentImage = None
        self.FinalImage = None
        self.OpenDialog1 = None
        self.OpenDialog2 = None
        self.StyleBook1 = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

    def UploadContentButtonClick(self, Sender):
        pass

    def UploadStyleButtonClick(self, Sender):
        pass

    def ApplyButtonClick(self, Sender):
        pass

Now, the only thing we need to do is add functionality to our form. Start by opening up Main.py in the text editor of your choice and importing some libraries:

# Additional Imports
import tensorflow as tf
import numpy as np
import PIL.Image
import tensorflow_hub as hub

Next, head over to the __init__ function. Here we will use the os library to load compressed models from tensorflow. Here is what our __init__ function looks like:

def __init__(self, owner):
        self.Title = None
        self.StyleImageLabel = None
        self.ContentImageLabel = None
        self.UploadContentButton = None
        self.UploadStyleButton = None
        self.ApplyButton = None
        self.StyleImage = None
        self.ContentImage = None
        self.FinalImage = None
        self.OpenDialog1 = None
        self.OpenDialog2 = None
        self.StyleBook1 = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

        # Load compressed models from tensorflow_hub
        os.environ['TFHUB_MODEL_LOAD_FORMAT'] = 'COMPRESSED'

Now let’s define a helper function called load_img that will help us load and preprocess an image using a provided path. We will start by defining the maximum dimensions as 512 and load and convert the image data type to float32.

def load_img(self, path_to_img):
        # Function to load and preprocess an image
        max_dim = 512
        img = tf.io.read_file(path_to_img)
        img = tf.image.decode_image(img, channels=3)
        img = tf.image.convert_image_dtype(img, tf.float32)

Next, we will cast the image, reshape it and finally return it. Here is what our final load_img function looks like:

def load_img(self, path_to_img):
        # Function to load and preprocess an image
        max_dim = 512
        img = tf.io.read_file(path_to_img)
        img = tf.image.decode_image(img, channels=3)
        img = tf.image.convert_image_dtype(img, tf.float32)

        shape = tf.cast(tf.shape(img)[:-1], tf.float32)
        long_dim = max(shape)
        scale = max_dim / long_dim

        new_shape = tf.cast(shape * scale, tf.int32)

        img = tf.image.resize(img, new_shape)
        img = img[tf.newaxis, :]
        return img

Next, we will define another function called tensor_to_image which, as the name implies, will help convert a tensor image to a PIL image that we can save. Here is a simple code on how we can do that:

def tensor_to_image(self, tensor):
        # Function to convert a tensor to a PIL Image
        tensor = tensor*255
        tensor = np.array(tensor, dtype=np.uint8)
        if np.ndim(tensor) > 3:
            assert tensor.shape[0] == 1
            tensor = tensor[0]
        return PIL.Image.fromarray(tensor)

Now we can move on and finish our button functions. Head to the UploadContentButtonClick function and open a dialog box using the OpenDialog1 component. We will filter the files to only show the different image files in the dialogbox. Once the user selects the image, use the .Bitmap.LoadFromFile() method to display it in the ContentImage placeholder. Here is what our final UploadContentButtonClick function looks like:

def UploadContentButtonClick(self, Sender):
        self.OpenDialog1.Title = "Select your Content Image"

        # Filtering only image formats to show for file pick
        self.OpenDialog1.Filter = "Image files (*.jpg;*.jpeg;*.png)|*.jpg;*.jpeg;*.png|All files (*.*)|*.*"
       
        if self.OpenDialog1.Execute():
            # Load the selected image into ContentImage component
            self.ContentImage.Bitmap.LoadFromFile(self.OpenDialog1.FileName)

Moving on, let’s define our UploadStyleButtonClick function similarly using the OpenDialog2 component. Here is what our function looks like:

def UploadStyleButtonClick(self, Sender):
        self.OpenDialog2.Title = "Select your Style Image"

        # Filtering only image formats to show for file pick
        self.OpenDialog2.Filter = "Image files (*.jpg;*.jpeg;*.png)|*.jpg;*.jpeg;*.png|All files (*.*)|*.*"
       
        if self.OpenDialog2.Execute():
            # Load the selected image into StyleImage component
            self.StyleImage.Bitmap.LoadFromFile(self.OpenDialog2.FileName)

Finally, let’s complete our ApplyButtonClick function. Start by loading our images using the load_img function:

def ApplyButtonClick(self, Sender):
        content_image = self.load_img(self.OpenDialog1.FileName)
        style_image = self.load_img(self.OpenDialog2.FileName)

Next, we will load a model using tensorflow_hub and pass in our StyleImage and ContentImage to generate a stylized image.

def ApplyButtonClick(self, Sender):
        content_image = self.load_img(self.OpenDialog1.FileName)
        style_image = self.load_img(self.OpenDialog2.FileName)

        # Load the Hub model for image stylization
        hub_model = hub.load('https://tfhub.dev/google/magenta/arbitrary-image-stylization-v1-256/2')
        stylized_image = hub_model(tf.constant(content_image), tf.constant(style_image))[0]
        stylized_image = self.tensor_to_image(stylized_image)

Finally, we will save the stylized image locally with a specific filename and load the image to our FinalImage component. Here is what our ApplyButtonClick function looks like:

def ApplyButtonClick(self, Sender):
        content_image = self.load_img(self.OpenDialog1.FileName)
        style_image = self.load_img(self.OpenDialog2.FileName)

        # Load the Hub model for image stylization
        hub_model = hub.load('https://tfhub.dev/google/magenta/arbitrary-image-stylization-v1-256/2')
        stylized_image = hub_model(tf.constant(content_image), tf.constant(style_image))[0]
        stylized_image = self.tensor_to_image(stylized_image)

        # Save the stylized image locally with a specific filename
        fname = "{}_{}_result.jpg".format(os.path.splitext(os.path.basename(self.OpenDialog1.FileName))[0], os.path.splitext(os.path.basename(self.OpenDialog2.FileName))[0])
        output_path = os.path.join(os.path.dirname(self.OpenDialog1.FileName), fname)
        stylized_image.save(output_path)
       
        # Load the stylized image into the FinalImage component
        self.FinalImage.Bitmap.LoadFromFile(output_path)

Here is what our final Main.py file looks like:

import os
from delphifmx import *
# Additional Imports
import tensorflow as tf
import numpy as np
import PIL.Image
import tensorflow_hub as hub

class MainForm(Form):

    def __init__(self, owner):
        self.Title = None
        self.StyleImageLabel = None
        self.ContentImageLabel = None
        self.UploadContentButton = None
        self.UploadStyleButton = None
        self.ApplyButton = None
        self.StyleImage = None
        self.ContentImage = None
        self.FinalImage = None
        self.OpenDialog1 = None
        self.OpenDialog2 = None
        self.StyleBook1 = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

        # Load compressed models from tensorflow_hub
        os.environ['TFHUB_MODEL_LOAD_FORMAT'] = 'COMPRESSED'

    def load_img(self, path_to_img):
        # Function to load and preprocess an image
        max_dim = 512
        img = tf.io.read_file(path_to_img)
        img = tf.image.decode_image(img, channels=3)
        img = tf.image.convert_image_dtype(img, tf.float32)

        shape = tf.cast(tf.shape(img)[:-1], tf.float32)
        long_dim = max(shape)
        scale = max_dim / long_dim

        new_shape = tf.cast(shape * scale, tf.int32)

        img = tf.image.resize(img, new_shape)
        img = img[tf.newaxis, :]
        return img
   
    def tensor_to_image(self, tensor):
        # Function to convert a tensor to a PIL Image
        tensor = tensor*255
        tensor = np.array(tensor, dtype=np.uint8)
        if np.ndim(tensor) > 3:
            assert tensor.shape[0] == 1
            tensor = tensor[0]
        return PIL.Image.fromarray(tensor)

    def UploadContentButtonClick(self, Sender):
        self.OpenDialog1.Title = "Select your Content Image"

        # Filtering only image formats to show for file pick
        self.OpenDialog1.Filter = "Image files (*.jpg;*.jpeg;*.png)|*.jpg;*.jpeg;*.png|All files (*.*)|*.*"
       
        if self.OpenDialog1.Execute():
            # Load the selected image into ContentImage component
            self.ContentImage.Bitmap.LoadFromFile(self.OpenDialog1.FileName)

    def UploadStyleButtonClick(self, Sender):
        self.OpenDialog2.Title = "Select your Style Image"

        # Filtering only image formats to show for file pick
        self.OpenDialog2.Filter = "Image files (*.jpg;*.jpeg;*.png)|*.jpg;*.jpeg;*.png|All files (*.*)|*.*"
       
        if self.OpenDialog2.Execute():
            # Load the selected image into StyleImage component
            self.StyleImage.Bitmap.LoadFromFile(self.OpenDialog2.FileName)

    def ApplyButtonClick(self, Sender):
        content_image = self.load_img(self.OpenDialog1.FileName)
        style_image = self.load_img(self.OpenDialog2.FileName)

        # Load the Hub model for image stylization
        hub_model = hub.load('https://tfhub.dev/google/magenta/arbitrary-image-stylization-v1-256/2')
        stylized_image = hub_model(tf.constant(content_image), tf.constant(style_image))[0]
        stylized_image = self.tensor_to_image(stylized_image)

        # Save the stylized image locally with a specific filename
        fname = "{}_{}_result.jpg".format(os.path.splitext(os.path.basename(self.OpenDialog1.FileName))[0], os.path.splitext(os.path.basename(self.OpenDialog2.FileName))[0])
        output_path = os.path.join(os.path.dirname(self.OpenDialog1.FileName), fname)
        stylized_image.save(output_path)
       
        # Load the stylized image into the FinalImage component
        self.FinalImage.Bitmap.LoadFromFile(output_path)

Now that our application is ready, let’s test it out. Head over to ArtStyleTransferApp.py and run the file.

Next, we will upload our style and content images by clicking the Upload buttons. Here we will be using Vincent van Gogh’s Starry Night as the Style image and a picture of penguins as our Content image.

Once you’ve selected your image, it should appear on the image placeholders:

Now press the Apply button to evaluate your image. Your result image should appear in the FinalImage placeholder:

Your file should also be saved in the same directory as your image:

What Are the Key Take Aways of this Tutorial?

In conclusion, our Art Style Transfer app demonstrates the exciting potential of AI art and the capabilities of the Delphi ecosystem in creating innovative applications. By providing users with a simple and interactive platform for artistic expression, we encourage creativity and exploration in the field of AI-generated art.

By harnessing the fusion of Delphi’s visual capabilities and Python’s extensive libraries, the Art Style Transfer app exemplifies the exciting potential of AI in the art world. Whether you’re an experienced developer or a newcomer, embracing the Delphi ecosystem can revolutionize your app development journey.

Ready to explore the captivating realm of AI art and create your own Art Style Transfer app? Unleash your creativity and join us on this fascinating journey. Download the Delphi IDE to embark on an innovative and rewarding development experience. 

What Are Some FAQs Related to this Tutorial?

How does Neural Style Transfer work?

Using a convolutional network, neural Style Transfer works by extracting content and style reference statistics from the content and style reference images. It then optimizes an output image to match the content statistics of the content image and the style statistics of the style reference image.

What is TensorFlow Hub?

TensorFlow Hub is a Python library that provides a collection of pre-trained models and modules for various tasks, including Neural Style Transfer. It simplifies the implementation of complex algorithms by offering access to pre-trained convolutional networks and other resources.

Do I need to train the model from scratch for Neural Style Transfer?

No, one of the advantages of using TensorFlow Hub is that it provides pre-trained models for Neural Style Transfer. You can use these models directly without the need for training from scratch.

Can I adjust the intensity of style transfer in the output image?

Yes, you can adjust the intensity of style transfer by controlling the weight of the style loss during optimization. This allows you to fine-tune the artistic style of the content image.

Is Neural Style Transfer computationally intensive?

Neural Style Transfer can be computationally intensive, especially when working with large images and complex styles. However, using pre-trained models from TensorFlow Hub can significantly reduce the computation time.

Are there other libraries besides TensorFlow Hub for Neural Style Transfer?

Yes, other libraries and frameworks, such as PyTorch, offer implementations of Neural Style Transfer. Each library may have its advantages and specific use cases, so developers can choose based on their preferences and project requirements.

What programming languages are supported by Delphi?

Delphi primarily supports Object Pascal as its native programming language. However, it also provides support for C++ through the use of the C++Builder IDE.

Is Delphi suitable for beginners in programming?

Delphi is considered beginner-friendly due to its visual programming features and user-friendly IDE. It provides an excellent learning platform for newcomers to programming.

The post How To Implement an Art Style Transfer GUI App with the Python Delphi Ecosystem first appeared on Python GUI.

What is Unsupervised Learning and When is it Useful?

Unsupervised learning is a type of machine learning where the model learns patterns and structures from unlabeled data without any predefined target variable. In unsupervised learning, the goal is to discover the underlying structure or relationships within the data. Unlike supervised learning, where the model is trained on labeled data with known outputs, unsupervised learning algorithms work on unannotated data. These algorithms aim to find hidden patterns, clusters, or associations within the data.

For instance, unsupervised learning algorithms can help understand the data by identifying patterns, outliers, and relationships between variables. This exploratory analysis can provide insights into the dataset before further analysis or modeling.

Clustering algorithms, such as K-means, DBSCAN, or hierarchical clustering, group similar data points together based on their features or distances. It is valuable for customer segmentation, market research, image segmentation, and anomaly detection. More applications include dimensionality reduction, feature extraction, and anomaly detection.

Which Tools Can Be Used For Creating GUIs for AI-Related Apps?

We will leverage DelphiFMX’s powerful components and functionality to create our K-means clustering visualization app. We will design an intuitive user interface that allows users to interact with the app and input their data. The app will then perform the K-means clustering algorithm on the provided data and visualize the resulting clusters using dynamic charts and visual elements.

Creating visualization apps can be thrilling and rewarding, especially with the right tools. Delphi FMX offers a rich ecosystem that simplifies and accelerates the development process, making it an excellent choice for creating a K-means clustering visualization app. By combining the power of Delphi FMX’s GUI development tools (such as Delphi IDE and Delphi4PythonExporter) and its seamless integration capabilities, we can unlock the full potential of the K-means algorithm and provide users with an intuitive and interactive visualization experience.

How to Create a K-Means Clustering Desktop App With a Stunning GUI?

What Libraries and Software Do You Need for this Tutorial?

To implement the code that utilizes the Python libraries Pillow, NumPy, OpenCV (cv2), and scikit-learn (sklearn), you need to set up some prerequisites. Firstly, ensure that you have installed Delphi Software. These tools will enable you to create the K-means app with a visually appealing user interface. Additionally, make sure to have the Delphi4PythonExporter tool installed, as it facilitates seamless integration between Delphi and Python. 

You will need a text editor or integrated development environment (IDE) that supports Python programming. We recommend using PyScripter, which provides a convenient environment for editing and executing Python code within Delphi. If you don’t have these tools installed, we recommend checking out the article “Powerful Python GUI Project Setup” to help you get started.

Lastly, to run the code successfully, install the necessary Python libraries. Execute the following commands in the command prompt or terminal:

pip install pillow
pip install opencv-python
pip install numpy
pip install scikit-learn

You can access the complete code for this tutorial from our GitHub repository. Simply visit the following link to obtain the code and related resources:

https://github.com/Embarcadero/PythonBlogExamples/tree/main/K_Means_Clustering_App

How to Create the Back-End by Implementing K-Means With SKlearn?

Once you’ve installed the necessary libraries, we are now ready to create our own K-Means class. Start by creating a new file called KMeans.py in your project directory, import the cv2 library, and import KMeans from sklearn.

import cv2
from sklearn.cluster import KMeans

Now create a class called KMeansClustering with three functions, init, load_image, and apply:

class KMeansClustering:
    def __init__(self):
        pass
   
    def load_image(self):
        pass
   
    def apply(self):
        pass

First, let’s start by defining the init function. Head over to the function and initialize the function with an additional parameter called K. This will define the number of clusters to make in an image. Next, we will define some new variables. The self.K variable will be used to define the number of clusters, whereas self.image will be used to store our image. Here is what our init function looks like:

def __init__(self, K: int):
        self.K = K  # Number of clusters for K-means algorithm
        self.image = None  # Placeholder for the image array

Next, for the load_image function, all we need to do is load an image file from the system. To do this, we will define an additional parameter called filename and then use the .imread() method to load the image file. Here is what our load_image function looks like:

def load_image(self, filename: str):
        self.image = cv2.imread(filename)  # Load the image array using OpenCV

Finally, let’s define our apply function. We will start by converting the image in the self.image variable from the BGR color space to the RGB color space. Next, we will reshape our image to produce a 2D array of pixels:

def apply(self):
        # Convert the image from BGR color space to RGB color space
        image_rgb = cv2.cvtColor(self.image, cv2.COLOR_BGR2RGB)

        # Reshape the image to a 2D array of pixels
        pixels = image_rgb.reshape(-1, 3)

Once we’ve finished reformatting our image, we will apply the KMeans clustering algorithm and assign cluster labels to each pixel to create a segmented image. Finally, we will return the newly generated image. Here is what our apply function looks like:

def apply(self):
        # Convert the image from BGR color space to RGB color space
        image_rgb = cv2.cvtColor(self.image, cv2.COLOR_BGR2RGB)

        # Reshape the image to a 2D array of pixels
        pixels = image_rgb.reshape(-1, 3)

        # Apply K-means clustering algorithm
        kmeans = KMeans(n_clusters=self.K, random_state=42)
        kmeans.fit(pixels)
        labels = kmeans.labels_
        centers = kmeans.cluster_centers_

        # Assign cluster labels to each pixel in the image to create a segmented image
        segmented_image = centers[labels].reshape(image_rgb.shape)

        return segmented_image

Here is what our KMeans.py file looks like:

import cv2
from sklearn.cluster import KMeans

class KMeansClustering:
    def __init__(self, K: int):
        self.K = K  # Number of clusters for K-means algorithm
        self.image = None  # Placeholder for the image array
   
    def load_image(self, filename: str):
        self.image = cv2.imread(filename)  # Load the image array using OpenCV
   
    def apply(self):
        # Convert the image from BGR color space to RGB color space
        image_rgb = cv2.cvtColor(self.image, cv2.COLOR_BGR2RGB)

        # Reshape the image to a 2D array of pixels
        pixels = image_rgb.reshape(-1, 3)

        # Apply K-means clustering algorithm
        kmeans = KMeans(n_clusters=self.K, random_state=42)
        kmeans.fit(pixels)
        labels = kmeans.labels_
        centers = kmeans.cluster_centers_

        # Assign cluster labels to each pixel in the image to create a segmented image
        segmented_image = centers[labels].reshape(image_rgb.shape)

        return segmented_image

How to Create a Stunning GUI For the App?

Now that the backend of our app is ready, we can utilize the Delphi ecosystem to create a very attractive GUI for such an ML task.
Start by opening the Delphi CE application and creating a blank project by navigating to File > New > Multi-Device Application > Blank Application > Ok. In this tutorial, we have named our project KMeansClustering.

If you are not familiar with the various sections of the Delphi IDE, we recommend referring to our free eBook bundle, which covers the Delphi Python EcoSystem and all Python GUI offerings.

Let’s start by giving the form a name. Right-click on the form and select QuickEdit. Here, we will name our form MainForm with the caption KMeansClustering App.

Next, rename the source file of our MainForm to Main.pas. This will help us keep track of our project files. Now, let’s resize the form. So go to the Object Inspector and search for ClientWidth and ClientHeight in the properties tab. We will set them to 480 and 640, respectively.

Now, let’s add a title to our app. Navigate to the standard palette and locate the TLabel component. Drag and drop this component onto the form.

Next, right-click on the label and set the Name as Title with the Text as KMeansClustering App.

We will now modify the text style by using the TextSettings property of the label. We will do this by navigating to the Object Inspector and searching for TextSettings. Now, click on the ellipses button (...) next to the Font property to see options for modifying the label based on your preferences. Like our other projects, we will set our font family as SemiBold Segoe UI. In addition, we will set the HorzAlign and VertAlign properties for our labels as Center.

Here is what our form looks like:

Next, we will add a text field to allow the user to specify the number of clusters for the algorithm. So, head over to the Palette and search for the TEdit component. Drag and drop this component into our form. Next, right-click on the component and Name it as KValue.

Here is what our form looks like:

Next, let’s add a few buttons to our form. For this, we will use the TButton component, so navigate to the Palette and search for the component.

We will add two buttons, UploadButton, to help us select the file, and an ApplyButton, to help us apply the algorithm to our image.

Now, we will add a TOpenDialog component, which will help us open a dialog box to select a file from our system. Open up the Palette and search for the component. Next, drag and drop this component anywhere into your form. The placement does not matter, as this component will be invisible.

Finally, let’s complete our form by adding image holders for our before and after Images. Head over to the Palette and search for the TImage component. Add this component to your form.

Next, right-click on each component to define its name. Here we will set the left image as BeforeImage and the right image as AfterImage.

Now that our form is ready, let’s add a few final touches by adding style. To do this, you will need to download the free ebook bundle, which comes shipped with a multitude of styles that you can choose from. 

Start by downloading your free ebook and extracting the FMX styles zip in the directory of your choosing. Next, select the style you want to use. Here we will be using AquaGraphite.style available in the bundle.

To use this style, head to the Palette and add the TStyleBook component to your form. Again, the placement does not matter for this component.

Double-click on the StyleBook1 component to open up your Style Designer. Next, click on the open button to open up a dialog box.

Now navigate to the .style file of your choosing in the dialog box, select your file, and finally click on exit. 

Once you’ve finalized your style, select the MainForm and head to the Object Inspector. Here we will search for the StyleBook property. Select the drop-down menu and select StyleBook1.

Here is what our final form looks like:

How to Export These Forms to Python Code?

Now that our project is complete, we only need to export it using the Delphi4Python exporter. However, exporting right now will cause the Upload and Apply buttons to lose their function. Therefore, we will need to add some functionality to each button in the form. 

To do this, double-click on each button on the form. This will add an OnClick method to that button. The procedure will be created in the .pas file of the form. This allows you to add unique functionality to each button when clicked.

Because the Delphi4PythonExporter does not use run-time implementation, we must add at least one comment (//) to each procedure to preserve the function when we export the form.

Now that our form is ready, we are ready to export. Select Tools > Export To Python > Export Current Entire Project to export the project.

Here we will give the project the title KMeansClustering App. Next, select the directory of your choosing and click on Export:

Because we had one form, Delphi will generate two Python files and one .pyfmx file. The KMeansClustering.py file will be used to run the application, whereas the Main.py file contains the class for the MainForm. The Main.pyfmx file contains the visual information for the MainForm. Here are the contents for each file.

KMeansClustering.py:

from delphifmx import *
from Main import MainForm

def main():
    Application.Initialize()
    Application.Title = 'KMeansClustering App'
    Application.MainForm = MainForm(Application)
    Application.MainForm.Show()
    Application.Run()
    Application.MainForm.Destroy()

if __name__ == '__main__':
    main()

Main.py:

import os
from delphifmx import *

class MainForm(Form):

    def __init__(self, owner):
        self.Title = None
        self.KValue = None
        self.KLabel = None
        self.ApplyButton = None
        self.UploadButton = None
        self.OpenDialog1 = None
        self.BeforeImage = None
        self.AfterImage = None
        self.StyleBook1 = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

    def ApplyButtonClick(self, Sender):
        pass

    def UploadButtonClick(self, Sender):
        pass

How to Put it All Together Into a Fully Functional App? 

Now that we have exported our project, all we need to do is bring it all together. Let’s start by opening up Main.py in the text editor of your choice and importing some libraries:

# Additional Imports
from KMeans import KMeansClustering
from PIL import Image
import numpy as np

Next, let’s complete our UploadButton. Head over to the UploadButtonClick function and start by opening the file picker dialog box and filtering the files to show only the image files. Once the user selects the image, use the .Bitmap.LoadFromFile() method to display it in the BeforeImage placeholder. Our final UploadButtonClick function looks like:

def UploadButtonClick(self, Sender):
        self.OpenDialog1.Title = "Select an Image"

        # Filtering only image formats to show for file pick
        self.OpenDialog1.Filter = "Image files (*.jpg;*.jpeg;*.png;*.webp)|*.jpg;*.jpeg;*.png;*.webp|All files (*.*)|*.*"
       
        if self.OpenDialog1.Execute():
            # Load the selected image into BeforeImage
            self.BeforeImage.Bitmap.LoadFromFile(self.OpenDialog1.FileName)

Next, let’s define our ApplyButtonClick function. Start by creating an instance of our KMeansClustering class and initialize it with the K value from the KValue edit box. Next, load the image using the load_image method and apply the Kmeans clustering algorithm:

def ApplyButtonClick(self, Sender):
        # Create an instance of KMeansClustering
        kmeans = KMeansClustering(int(self.KValue.Text))

        # Load the image from the stream in KMeansClustering
        kmeans.load_image(self.OpenDialog1.FileName)

        # Apply K-means clustering
        segmented_image = kmeans.apply()

Now, simply convert the segmented image to a PIL Image and save the image in the same directory as the before image. Finally, show the image in the AfterImage placeholder. Here is what our ApplyButtonClick function looks like:

def ApplyButtonClick(self, Sender):
        # Create an instance of KMeansClustering
        kmeans = KMeansClustering(int(self.KValue.Text))

        # Load the image from the stream in KMeansClustering
        kmeans.load_image(self.OpenDialog1.FileName)

        # Apply K-means clustering
        segmented_image = kmeans.apply()

        # Convert the segmented image array to PIL Image
        pil_image = Image.fromarray(segmented_image.astype(np.uint8))

        # Save the image to the same directory as the before image
        output_path = os.path.join(os.path.dirname(self.OpenDialog1.FileName), "segmented_image.png")
        pil_image.save(output_path)

        # Load the segmented image in the AfterImage
        self.AfterImage.Bitmap.LoadFromFile(output_path)

Here is what our final Main.py file looks like:

import os
from delphifmx import *
# Additional Imports
from KMeans import KMeansClustering
from PIL import Image
import numpy as np


class MainForm(Form):

    def __init__(self, owner):
        self.Title = None
        self.KValue = None
        self.KLabel = None
        self.ApplyButton = None
        self.UploadButton = None
        self.OpenDialog1 = None
        self.BeforeImage = None
        self.AfterImage = None
        self.StyleBook1 = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

    def ApplyButtonClick(self, Sender):
        # Create an instance of KMeansClustering
        kmeans = KMeansClustering(int(self.KValue.Text))

        # Load the image from the stream in KMeansClustering
        kmeans.load_image(self.OpenDialog1.FileName)

        # Apply K-means clustering
        segmented_image = kmeans.apply()

        # Convert the segmented image array to PIL Image
        pil_image = Image.fromarray(segmented_image.astype(np.uint8))

        # Save the image to the same directory as the before image
        output_path = os.path.join(os.path.dirname(self.OpenDialog1.FileName), "segmented_image.png")
        pil_image.save(output_path)

        # Load the segmented image in the AfterImage
        self.AfterImage.Bitmap.LoadFromFile(output_path)

    def UploadButtonClick(self, Sender):
        self.OpenDialog1.Title = "Select an Image"

        # Filtering only image formats to show for file pick
        self.OpenDialog1.Filter = "Image files (*.jpg;*.jpeg;*.png;*.webp)|*.jpg;*.jpeg;*.png;*.webp|All files (*.*)|*.*"
       
        if self.OpenDialog1.Execute():
            # Load the selected image into BeforeImage
            self.BeforeImage.Bitmap.LoadFromFile(self.OpenDialog1.FileName)

Now that our application is ready, let’s test it out. Head over to KMeansClustering.py and run the file.

Let’s first define the KValue as 3. Next, press the Upload button. This will open up a dialog box for your to select an image. Navigate to the directory of your image and open your image. Here we will be using a free stock image from Unsplash:

Once you’ve selected your image, it should appear on the BeforeImage placeholder:

Now press the Apply button to evaluate your image. Your result image should appear in the AfterImage placeholder:

Your file should also be saved in the same directory as your image:

Are You Ready to Create More Amazing GUIs With Delphi FMX?

In this tutorial, we have embarked on an exciting journey of creating a K-means clustering visualization app using Delphi FMX. We have explored the powerful capabilities of Delphi FMX and its seamless integration with the K-means algorithm, enabling us to develop an intuitive and interactive app. By empowering users with the ability to visualize and analyze their data, we can unlock valuable insights and make data-driven decisions. 

Download Delphi and start your journey into the world of K-means clustering visualization with Delphi FMX and transform how you analyze and understand data.

What Are the Top FAQs Related to this Tutorial?

What is K-means clustering?

K-means clustering is an unsupervised machine learning algorithm that groups similar data points into clusters based on their feature similarity. It aims to minimize the sum of squared distances between the data points and their cluster centroids.

Why use Delphi for building a K-means clustering app?

Delphi is a powerful development platform that provides a rich ecosystem and GUI framework, such as FireMonkey (FMX), for creating visually appealing and interactive applications. It seamlessly integrates with Python, enabling you to leverage Python’s machine learning libraries and algorithms.

What is Delphi FMX?

Delphi FMX (FireMonkey) is a cross-platform GUI framework provided by Delphi. It allows you to develop visually stunning user interfaces with a single codebase that can run on multiple platforms, including Windows, macOS, iOS, and Android.

How can I integrate the K-means algorithm with Delphi FMX?

Delphi FMX integrates with Python through tools like the Delphi4PythonExporter, allowing you to write and execute Python code within your Delphi application. You can use Python’s scikit-learn library to implement the K-means algorithm and leverage its clustering capabilities.

Are there any specific data requirements for K-means clustering?

K-means clustering works with numerical data and requires a predefined number of clusters (K). Ensure your data is suitable for clustering by preprocessing it and selecting an appropriate value for K based on your specific application and dataset.

The post How To Create a K-Means Clustering Visualization App Using DelphiFMX first appeared on Python GUI.

What is Deep Learning?

Deep learning, a branch of machine learning, addresses intricate problems through the utilization of artificial neural networks. These networks consist of interconnected nodes organized in multiple layers, extracting features from input data. Extensive datasets are employed to train these models, enabling them to identify patterns and correlations that might be challenging or impossible for humans to perceive.

The impact of deep learning on artificial intelligence has been substantial. It has paved the way for the development of intelligent systems capable of independent learning, adaptation, and decision-making. Deep learning has led to remarkable advancements in various domains, encompassing image and speech recognition, natural language processing, machine translation, autonomous driving, and numerous others.

Why Use Python for Deep Learning, Machine Learning, and Artificial Intelligence?

Python has gained widespread popularity as a programming language due to its versatility and ease of use in diverse domains of computer science, especially in the field of deep learning, machine learning, and AI. 

We’ve reviewed several times about why Python is great for Deep Learning, Machine Learning, and Artificial Intelligence (also all the prerequisites), in the following articles:

What is a Long-Short-Term Memory Network (LSTM)?

Long Short-Term Memory (LSTM) networks are a modified version of recurrent neural networks, which makes it easier to remember past data in memory.  LSTM is introduced to solve the performance degradation of RNNs in long-term sequences (vanishing gradient problem). Read more about it from Hochreiter, S., & Schmidhuber, J. paper (reference [4]).

LSTM is well-suited to classify, process, and predict time series given time lags of unknown duration. It trains the model by using back-propagation. In an LSTM network, three gates are present: The input gate, forget gate, and the output gate.

I’ve talked a little bit about LSTM as an advanced RNN architectures, as well as GRU, in the previous deep learning article:

How does LSTM work for Machine Translation?

Sequence to Sequence modeling is one of the many intriguing uses of natural language processing. Both language translation systems and question-answering systems make extensive use of it.

The goal of sequence-to-sequence (Seq2Seq) modeling is to develop models that can convert sequences from one domain to another, such as translating English to German. The LSTM encoder and decoder execute this Seq2Seq modeling [7].

Here’s how it works:

• Feed the embedding vectors for source sequences (German), to the encoder network, one word at a time.
• Encode the input sentences into fixed-dimension state vectors. At this step, we get the hidden and cell states from the encoder LSTM and feed it to the decoder LSTM.
• These states are regarded as initial states by the decoder. Additionally, it also has embedding vectors for target words (English).
• Decode and output the translated sentence, one word at a time. In this step, the output of the decoder is sent to a softmax layer over the entire target vocabulary.

A typical seq2seq model has 2 major components: An encoder, and a decoder. Both these parts are essentially two different recurrent neural network (RNN) models combined into one giant network:

How do I build and train an LSTM for Machine Translation from scratch?

Let’s get hands-on with some Python code to build and train your own LSTMs from scratch.

In this article, we will create a language translation model using seq2seq architecture and LSTM network, as it is a very famous application of neural machine translation (including Google Translate). Brace yourself, this article is a little bit more intense, compared to all my previous tutorials.

We will work with the Kaggle Bilingual Sentence Pairs dataset (reference [3]) to train the LSTM, so it can predict the unseen data, or even more, perform machine translation. The original source of the dataset is the Tatoeba Project (to download the dataset, see Reference [1 & 3]).

The actual data contains over 150,000 sentence pairs. However, we will use only the first 50,000 sentence pairs in the 1st demo, and the first 20,000 sentence pairs in the 2nd demo to reduce the training time of the model,  (of course, this will lead to not-really-satisfying results, but this article will still serve its purpose as proof-of-concept). You can increase this number if you are equipped with a powerful computer.

Hands-on and selected outputs (1st example)

This example is modified from reference [5]. The original reference already shows excellent results when predicting the unseen data in English. However, I modified the code slightly, so we can test it to predict the unseen data in German.

The following is the code example of implementing LSTM for machine translation:

# Import libraries
import string
import re
from numpy import array, argmax, random, take
import pandas as pd
from keras.models import Sequential
from keras.layers import Dense, LSTM, Embedding, RepeatVector
from keras.preprocessing.text import Tokenizer
from keras.callbacks import ModelCheckpoint
from keras.preprocessing.sequence import pad_sequences
from keras.models import load_model
from keras import optimizers
import matplotlib.pyplot as plt

pd.set_option('display.max_colwidth', 200)

# Function to read raw text file
def read_text(filename):
    # open the file
    file = open(filename, mode='rt', encoding='utf-8')

    # read all text
    text = file.read()
    file.close()
    return text

# Split a text into sentences
def to_lines(text):
    sents = text.strip().split('n')
    sents = [i.split('t') for i in sents]
    return sents

# Load dataset
data = read_text("data/bilingual-sentence-pairs/deu.txt")
deu_eng = to_lines(data)
deu_eng = array(deu_eng)
## We will use only the first 50,000 sentence pairs to reduce the training time of the model
deu_eng = deu_eng[:50000,:]

# Remove punctuation
deu_eng[:,0] = [s.translate(str.maketrans('', '', string.punctuation)) for s in deu_eng[:,0]]
deu_eng[:,1] = [s.translate(str.maketrans('', '', string.punctuation)) for s in deu_eng[:,1]]

deu_eng

# Convert text to lowercase
for i in range(len(deu_eng)):
    deu_eng[i,0] = deu_eng[i,0].lower()
    deu_eng[i,1] = deu_eng[i,1].lower()

# Empty lists
eng_l = []
deu_l = []

# Populate the lists with sentence lengths
for i in deu_eng[:,0]:
    eng_l.append(len(i.split()))

for i in deu_eng[:,1]:
    deu_l.append(len(i.split()))
## Plot the distributions
import pylab as pl
length_df = pd.DataFrame({'eng':eng_l, 'deu':deu_l})
length_df.hist(bins = 30)
pl.suptitle("Distributions of sentence lengths (eng vs deu)")
plt.show()
## Find the max sentence length for each language
max_eng_sentence_length = max(length_df['eng'])
max_deu_sentence_length = max(length_df['deu'])
print('Max sentence length for eng: %d' % max_eng_sentence_length)
print('Max sentence length for deu: %d' % max_deu_sentence_length)

# Function to build a tokenizer
def tokenization(lines):
    tokenizer = Tokenizer()
    tokenizer.fit_on_texts(lines)
    return tokenizer

# Prepare english tokenizer
eng_tokenizer = tokenization(deu_eng[:, 0])
eng_vocab_size = len(eng_tokenizer.word_index) + 1
## Choose "7" as the max sentence length
eng_length = 7
print('English Vocabulary Size: %d' % eng_vocab_size)

# Prepare Deutch tokenizer
deu_tokenizer = tokenization(deu_eng[:, 1])
deu_vocab_size = len(deu_tokenizer.word_index) + 1
## Choose "7" as the max sentence length
deu_length = 7
print('Deutch Vocabulary Size: %d' % deu_vocab_size)

# Encode and pad sequences
def encode_sequences(tokenizer, length, lines):
    seq = tokenizer.texts_to_sequences(lines)
    ## Pad sequences with 0 values
    seq = pad_sequences(seq, maxlen=length, padding='post')
    return seq

# Model building
from sklearn.model_selection import train_test_split
## Split data into train and test set
train, test = train_test_split(deu_eng, test_size=0.2, random_state = 12)

# Prepare training data
trainX = encode_sequences(deu_tokenizer, deu_length, train[:, 1])
trainY = encode_sequences(eng_tokenizer, eng_length, train[:, 0])

# Prepare validation data
testX = encode_sequences(deu_tokenizer, deu_length, test[:, 1])
testY = encode_sequences(eng_tokenizer, eng_length, test[:, 0])

# Define the model
## Build NMT model
def define_model(in_vocab,out_vocab, in_timesteps,out_timesteps,units):
    model = Sequential()
    model.add(Embedding(in_vocab, units, input_length=in_timesteps, mask_zero=True))
    model.add(LSTM(units))
    model.add(RepeatVector(out_timesteps))
    model.add(LSTM(units, return_sequences=True))
    model.add(Dense(out_vocab, activation='softmax'))
    return model
## Model compilation
model = define_model(deu_vocab_size, eng_vocab_size, deu_length, eng_length, 512)
rms = optimizers.RMSprop(lr=0.001)
model.compile(optimizer=rms, loss='sparse_categorical_crossentropy')

# Fit the model
## Save the model with the lowest validation loss
filename = 'model.h1.28_may_23'
checkpoint = ModelCheckpoint(filename, monitor='val_loss', verbose=1, save_best_only=True, mode='min')

# Train model
history = model.fit(trainX, trainY.reshape(trainY.shape[0], trainY.shape[1], 1),
                	epochs=30, batch_size=512, validation_split = 0.2,callbacks=[checkpoint],
                	verbose=1)
## Plot validation loss
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.legend(['train','validation'])
plt.show()

# Prediction on unseen data
from keras.models import load_model
model = load_model('model.h1.28_may_23')
preds = model.predict_classes(testX.reshape((testX.shape[0],testX.shape[1])))

# Present the results in dataframe (eng)
def get_word(n, tokenizer):
    for word, index in tokenizer.word_index.items():
        if index == n:
            return word
    return None

preds_text_eng = []
for i in preds:
    temp = []
    for j in range(len(i)):
        t = get_word(i[j], eng_tokenizer)
        if j > 0:
            if (t == get_word(i[j-1], eng_tokenizer)) or (t == None):
                temp.append('')
            else:
                temp.append(t)
        else:
            if(t == None):
                temp.append('')
            else:
                temp.append(t)

    preds_text_eng.append(' '.join(temp))

pred_df_eng = pd.DataFrame({'actual' : test[:,0], 'predicted' : preds_text_eng})
## Print 15 rows randomly
print(pred_df_eng.head(15))

# Present the results in dataframe (deu)
def get_word(n, tokenizer):
    for word, index in tokenizer.word_index.items():
        if index == n:
            return word
    return None

preds_text_deu = []
for i in preds:
    temp = []
    for j in range(len(i)):
        t = get_word(i[j], deu_tokenizer)
        if j > 0:
            if (t == get_word(i[j-1], deu_tokenizer)) or (t == None):
                temp.append('')
        	else:
                temp.append(t)
        else:
            if(t == None):
                temp.append('')
        	else:
                temp.append(t)

    preds_text_deu.append(' '.join(temp))

pred_df_deu = pd.DataFrame({'actual' : test[:,1], 'predicted' : preds_text_deu})
## Print 15 rows randomly
print(pred_df_deu.head(15))

To execute the code provided, we can utilize the PyScripter IDE. Here are a few selected outputs:

1. Visualizing the distribution of sentence lengths (eng vs deu)

We will generate a plot to illustrate the distribution of sentence lengths. For this purpose, we will store the lengths of all English sentences in one list and the lengths of all German sentences in another.

2. Maximum sentence length and vocabulary size (eng vs deu)

It is quite intuitive that the maximum length of German sentences is 15, whereas for English phrases, it is 7.

To facilitate the utilization of a Seq2Seq model, it is necessary to convert both input and output sentences into fixed-length integer sequences. To achieve this, we employ the Tokenizer() class from Keras, which transforms our sentences into sequences of integers. These sequences are then padded with zeros to ensure uniform length across all sequences.

In order to prepare for this process, we create tokenizers for both German and English sentences. At the same time, we also counted the vocabulary size for both languages and printed them out as can be seen above.

3. Model training and saving the best result

For the training process, we will run the model for 30 epochs, utilizing a batch_size of 512 and a validation_split of 20%. This means that 80% of the data will be allocated for training the model, while the remaining 20% will be used for evaluation. Feel free to experiment and modify these hyperparameters to suit your needs.

To ensure that we capture the model’s best performance, we will employ the ModelCheckpoint() function, which saves the model with the lowest validation loss (val_loss). The resulting model with the best performance will be automatically stored in the “model.h1.28_may_23” folder.

Here is the validation loss score for each epoch:

Epoch-01:

Epoch-02:

Epoch-03:

Epoch-04:

Epoch-05:

Epoch-06:

Epoch-07:

Epoch-08:

Epoch-09:

Epoch-10:

Epoch-11:

Epoch-12:

Epoch-13:

Epoch-14:

Epoch-15:

Epoch-16:

Epoch-17:

Epoch-18:

Epoch-19:

Epoch-20:

Epoch-21:

Epoch-22:

Epoch-23:

Epoch-24:

Epoch-25:

Epoch-26:

Epoch-27:

Epoch-28:

Epoch-29:

Epoch-30:

The model training processes are executed flawlessly within the PyScripter IDE, ensuring a smooth and error-free experience without any delays or disruptions.

4. Plot train loss vs validation loss

Let’s plot and compare the training loss and the validation loss.

As you can see in the plot above, the validation loss plateaus after the 20th epoch, indicating that the model has likely converged and will not improve further with additional training.

5. Generating predictions for unseen data

The generated predictions consist of sequences represented by integers. To make these predictions more understandable, we must convert these integers back into their respective words.

Once the conversion is complete and the original sentences are placed in the test dataset while the predicted sentences are stored in a data frame, we can randomly display some instances of actual sentences compared to their corresponding predicted sentences. This allows us to assess the performance of our model:

Prediction results (eng):

For the English results, the model is doing a pretty decent job. 

Let’s do similar things for Deutsch, and here are the prediction results (deu):

Unfortunately, the predictions for Deutsch are still unsatisfactory, and in some cases, completely incorrect. For instance, the model failed to identify that “Boston” refers to a city and “Tom” is a person’s name. To identify these errors, you can cross-reference them using Google Translator.

Eventually, after enough training epochs, using more training data and building a better (or more complex) model (if you have enough computational power to do so), the results will gradually improve over time. These are the challenges we will face regularly in NLP. But these aren’t immovable obstacles.

This is how you would use LSTM to solve a sequence prediction task. Let’s try another scenario of implementation, in the next subsection.

Hands-on and selected outputs (2nd example)

This second implementation scenario refers to Reference [7]. But, that excellent blog post is implementing the neural machine translation from English to French. In this article, we will try English to Deutsch, instead. 

In this 2nd example of LSTM implementation for machine translation, we still use the same dataset, but, for the word embedding, we will utilize the GloVe (Global Vectors for Word Representation) word embeddings (see reference [8]).

The following is the second example of implementing LSTM for machine translation:

# Import libraries
import os
import sys
from keras.models import Model
from keras.layers import Input, LSTM, GRU, Dense, Embedding
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
from keras.utils import to_categorical
import numpy as np
import matplotlib.pyplot as plt
from numpy import array # For loading GloVe data
from numpy import asarray # For loading GloVe data
from numpy import zeros # For loading GloVe data
from keras.utils import plot_model # For plotting DL models

# Set values for different parameters
BATCH_SIZE = 64
EPOCHS = 30
LSTM_NODES = 256
NUM_SENTENCES = 20000
MAX_SENTENCE_LENGTH = 50
MAX_NUM_WORDS = 20000
EMBEDDING_SIZE = 100

# Data preprocessing
input_sentences = []
output_sentences = []
output_sentences_inputs = []

count = 0
for line in open("data/bilingual-sentence-pairs/deu.txt", encoding="utf-8"):
    count += 1

    if count > NUM_SENTENCES:
        break

    if 't' not in line:
        continue

    input_sentence, output, _ = line.rstrip().split('t')

    output_sentence = output + ' <eos>'
    output_sentence_input = '<sos> ' + output

    input_sentences.append(input_sentence)
    output_sentences.append(output_sentence)
    output_sentences_inputs.append(output_sentence_input)

print("num samples input:", len(input_sentences))
print("num samples output:", len(output_sentences))
print("num samples output input:", len(output_sentences_inputs))

# Randomly print sentences
print(input_sentences[172])
print(output_sentences[172])
print(output_sentences_inputs[172])

# Tokenization (for inputs)
input_tokenizer = Tokenizer(num_words=MAX_NUM_WORDS)
input_tokenizer.fit_on_texts(input_sentences)
input_integer_seq = input_tokenizer.texts_to_sequences(input_sentences)

word2idx_inputs = input_tokenizer.word_index
print('Total unique words in the input: %s' % len(word2idx_inputs))

max_input_len = max(len(sen) for sen in input_integer_seq)
print("Length of longest sentence in input: %g" % max_input_len)

# Tokenization (for outputs)
output_tokenizer = Tokenizer(num_words=MAX_NUM_WORDS, filters='')
output_tokenizer.fit_on_texts(output_sentences + output_sentences_inputs)
output_integer_seq = output_tokenizer.texts_to_sequences(output_sentences)
output_input_integer_seq = output_tokenizer.texts_to_sequences(output_sentences_inputs)

word2idx_outputs = output_tokenizer.word_index
print('Total unique words in the output: %s' % len(word2idx_outputs))

num_words_output = len(word2idx_outputs) + 1
max_out_len = max(len(sen) for sen in output_integer_seq)
print("Length of longest sentence in the output: %g" % max_out_len)

# Padding
encoder_input_sequences = pad_sequences(input_integer_seq, maxlen=max_input_len)
print("encoder_input_sequences.shape:", encoder_input_sequences.shape)
print("encoder_input_sequences[172]:", encoder_input_sequences[172])
## Verify the integer values for "go" and "away" (sentence index 172)
print(word2idx_inputs["go"])
print(word2idx_inputs["away"])
## In the same way, padd the decoder outputs and the decoder inputs (deu):
decoder_input_sequences = pad_sequences(output_input_integer_seq, maxlen=max_out_len, padding='post')
print("decoder_input_sequences.shape:", decoder_input_sequences.shape)
print("decoder_input_sequences[172]:", decoder_input_sequences[172])
### Print the corresponding integers from the word2idx_outputs (sentence index 172)
print(word2idx_outputs["<sos>"])
print(word2idx_outputs["mach"])
print(word2idx_outputs["’ne"])
print(word2idx_outputs["fliege!"])

# Create word embeddings for the inputs by load the GloVe word vectors into memory
embeddings_dictionary = dict()

glove_file = open("data/glove/glove.6B.100d.txt", encoding="utf-8")

for line in glove_file:
    records = line.split()
    word = records[0]
    vector_dimensions = asarray(records[1:], dtype='float32')
    embeddings_dictionary[word] = vector_dimensions
glove_file.close()

## Create a matrix where the row number will represent the integer value for the word and the columns will correspond to the dimensions of the word
num_words = min(MAX_NUM_WORDS, len(word2idx_inputs) + 1)
embedding_matrix = zeros((num_words, EMBEDDING_SIZE))
for word, index in word2idx_inputs.items():
    embedding_vector = embeddings_dictionary.get(word)
    if embedding_vector is not None:
        embedding_matrix[index] = embedding_vector
## Print the word embeddings for the word "go" using the GloVe word embedding dictionary.
print(embeddings_dictionary["go"])
print(embedding_matrix[20])
## Creates the embedding layer for the input
embedding_layer = Embedding(num_words, EMBEDDING_SIZE, weights=[embedding_matrix], input_length=max_input_len)

# Create the model
## The final shape of the output: (number of inputs, length of the output sentence, the number of words in the output)
## Creates the empty output array:
decoder_output_sequences = []  # Define decoder_output_sequences variable

for seq in output_integer_seq:
    decoder_output_sequences.append(seq[1:])  # Remove the first element "<sos>"

decoder_targets_one_hot = np.zeros((
    len(input_sentences),
    max_out_len,
    num_words_output
), dtype='float32')
## Prints the shape of the decoder:
print(decoder_targets_one_hot.shape)
## To make predictions, the final layer of the model will be a dense layer, therefore we need the outputs in the form of one-hot encoded vectors.
for i, d in enumerate(decoder_output_sequences):
    for t, word in enumerate(d):
        decoder_targets_one_hot[i, t, word] = 1
## Create the encoder for LSTM:
encoder_inputs_placeholder = Input(shape=(max_input_len,))
x = embedding_layer(encoder_inputs_placeholder)
encoder = LSTM(LSTM_NODES, return_state=True)

encoder_outputs, h, c = encoder(x)
encoder_states = [h, c]
## Create the decoder for LSTM:
decoder_inputs_placeholder = Input(shape=(max_out_len,))

decoder_embedding = Embedding(num_words_output, LSTM_NODES)
decoder_inputs_x = decoder_embedding(decoder_inputs_placeholder)

decoder_lstm = LSTM(LSTM_NODES, return_sequences=True, return_state=True)
decoder_outputs, _, _ = decoder_lstm(decoder_inputs_x, initial_state=encoder_states)
## Pass the output from the decoder LSTM through a dense layer, to predict decoder outputs
decoder_dense = Dense(num_words_output, activation='softmax')
decoder_outputs = decoder_dense(decoder_outputs)

# Compile the model
model = Model([encoder_inputs_placeholder,
           	decoder_inputs_placeholder], decoder_outputs)
model.compile(
	optimizer='rmsprop',
	loss='categorical_crossentropy',
	metrics=['accuracy']
)
## Plot our model
plot_model(model, to_file='plot_LSTMModelForMachineTranslation.png', show_shapes=True, show_layer_names=True)

# Train the model using the fit() method:
r = model.fit(
	[encoder_input_sequences, decoder_input_sequences],
	decoder_targets_one_hot,
	batch_size=BATCH_SIZE,
	epochs=EPOCHS,
	validation_split=0.1,
)

# Modifying the model for predictions
## The encoder model remains the same:
encoder_model = Model(encoder_inputs_placeholder, encoder_states)
## Modify our model to accept the hidden and cell states
decoder_state_input_h = Input(shape=(LSTM_NODES,))
decoder_state_input_c = Input(shape=(LSTM_NODES,))
decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c]
## At each time step, there will be only single word in the decoder input, we need to modify the decoder embedding layer as follows:
decoder_inputs_single = Input(shape=(1,))
decoder_inputs_single_x = decoder_embedding(decoder_inputs_single)
## Create the placeholder for decoder outputs:
decoder_outputs, h, c = decoder_lstm(decoder_inputs_single_x, initial_state=decoder_states_inputs)
## To make predictions, the decoder output is passed through the dense layer:
decoder_states = [h, c]
decoder_outputs = decoder_dense(decoder_outputs)
## The final step is to define the updated decoder model, as shown here:
decoder_model = Model(
	[decoder_inputs_single] + decoder_states_inputs,
	[decoder_outputs] + decoder_states
)
## Plot our modified decoder LSTM that makes predictions:
plot_model(decoder_model, to_file='plot_modifiedLSTMModelForMachineTranslation.png', show_shapes=True, show_layer_names=True)

# Making predictions
## Create new dictionaries for both inputs and outputs where the keys will be the integers and the corresponding values will be the words:
idx2word_input = {v:k for k, v in word2idx_inputs.items()}
idx2word_target = {v:k for k, v in word2idx_outputs.items()}

## Create translate_sentence() method to accept an input-padded sequence English sentence (in the integer form) and will return the translated French sentence.
def translate_sentence(input_seq):
    states_value = encoder_model.predict(input_seq)
    target_seq = np.zeros((1, 1))
    target_seq[0, 0] = word2idx_outputs['<sos>']
    eos = word2idx_outputs['<eos>']
    output_sentence = []

    for _ in range(max_out_len):
        output_tokens, h, c = decoder_model.predict([target_seq] + states_value)
        idx = np.argmax(output_tokens[0, 0, :])

        if eos == idx:
            break

        word = ''

        if idx > 0:
            word = idx2word_target[idx]
            output_sentence.append(word)

        target_seq[0, 0] = idx
        states_value = [h, c]

    return ' '.join(output_sentence)

# Testing the model
i = np.random.choice(len(input_sentences))
input_seq = encoder_input_sequences[i:i+1]
translation = translate_sentence(input_seq)
print('-')
print('Input:', input_sentences[i])
print('Response:', translation)

Let’s run the above code using PyScripter IDE. And the following are some selected outputs:

1. Word embeddings

This part shows the implementation of word embeddings for neural machine translation.Here is the printed result of the word embeddings for the word “go” using the GloVe word embedding dictionary.

check the 20th index of the word embedding matrix (the word “go”), and its shows a consistent result:

2. Plot our LSTM model for machine translation

Another interesting part of this second approach is, after we compile the model, we can plot it using tf.keras.utils.plot_model. So, we can keep tracking and communicate about all the inputs, outputs, steps, layers, etc clearly.

3. Plot the modified model for prediction

Before making any predictions, first, we need to modify our model.

The following is the plot of our model after some modification performed to make predictions:

4. Train the model

I trained the model in 30 epochs, you can modify the number of epochs to see if you can get better results. The model is trained on 18,000 sentences and tested on the remaining 2,000 sentences. You can also add the number of records if you want to get better results, and if you have capable computational resources.

5. Test the model

To test the code, we will randomly choose a sentence from the input_sentences list, retrieve the corresponding padded sequence for the sentence, and will pass it to the translate_sentence() method. The method will return the translated sentence as shown below.

1st attempt of the test:

2nd attempt:

3rd attempt:

Again, it seems that the results in Deutsch are still far from satisfying. To identify these errors, you can cross-reference them using Google Translator. 

Eventually, after enough training epochs, using more training data and building a better (or more complex) model (if you have enough computational power to do so), will give better and better results over time. These are the challenges we will face regularly in NLP.

Endnotes

LSTMs are a very promising solution to sequence-related problems. It has tons of very useful implementations out there, from time series prediction, weather forecasting, machine translation, speech recognition, and many more. According to Google Scholar, no other computer science paper of the 20th century is receiving as many citations per year as the original 1997 journal publication on Long Short-Term Memory (LSTM) artificial neural networks (NNs) [9]. 

However, the one disadvantage that I find about them is the difficulty in training them. A lot of data, training epochs/time, and system resources are needed to go into training even a simple model. But that is just a hardware constraint, and PyScripter IDE handles it very well, lightweight, with zero error or lag! 

I hope this article was successful in giving you a basic understanding and workflow of how these networks work.

Check out the full repository here:

github.com/Embarcadero/DL_Python03_LSTM

Click here to get started with PyScripter, a free, feature-rich, and lightweight Python IDE.

Download RAD Studio to create more powerful Python GUI Windows Apps in 5x less time.

Check out Python4Delphi, which makes it simple to create Python GUIs for Windows using Delphi.

Also, look into DelphiVCL, which makes it simple to create Windows GUIs with Python.

References & further readings

[1] All sentences and translations are from Tatoeba’s (tatoeba.org) massive and awesome dataset, released under a CC-BY License.

[2] Biswal, A. (2023).

Top 10 Deep Learning Algorithms You Should Know in 2023. Simplilearn. simplilearn.com/tutorials/deep-learning-tutorial/deep-learning-algorithm

[3] Cijov, A. (2021).

Bilingual Sentence Pair: Dataset for Translator Projects. Kaggle. kaggle.com/datasets/alincijov/bilingual-sentence-pairs

[4] Hochreiter, S., & Schmidhuber, J. (1997).

Long short-term memory. Neural computation, 9(8), 1735-1780.

[5] Jain, H. (2021).

Machine Translation | Seq2Seq | LSTMs. Kaggle. kaggle.com/code/harshjain123/machine-translation-seq2seq-lstms

[6] Kumar, V. (2020).

Sequence-to-Sequence Modeling using LSTM for Language Translation. Analytics India Magazine. analyticsindiamag.com/sequence-to-sequence-modeling-using-lstm-for-language-translation

[7] Malik, U. (2022).

Python for NLP: Neural Machine Translation with Seq2Seq in Keras. StackAbuse. stackabuse.com/python-for-nlp-neural-machine-translation-with-seq2seq-in-keras

[8] Pennington, J., Socher, R., & Manning, C. D. (2014, October).

Glove: Global vectors for word representation. In Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP) (pp. 1532-1543). nlp.stanford.edu/projects/glove

[9] Schmidhuber, J. (2022).

2022: 25th anniversary of 1997 papers: Long Short-Term Memory. All computable metaverses. Hierarchical reinforcement learning (RL). Meta-RL. Abstractions in generative adversarial RL. Soccer learning. Low-complexity neural nets. Low-complexity art. Others. AI Blog. IDSIA, Lugano, Switzerland.

[10] Wu, Y., Schuster, M., Chen, Z., Le, Q. V., Norouzi, M., Macherey, W., … & Dean, J. (2016).

Google’s neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144.

The post Unlock the Power of Python for Deep Learning with Long-Short-Term Memory Networks first appeared on Python GUI.

In this article, we’ll explore the fusion of Delphi’s development process and the precision of deep learning. By leveraging the flexibility of Delphi’s FMX framework, we’ll create an intuitive user interface, complete with a file picker and text input, enabling users to analyze sentiment effortlessly. And to take our app to the next level, we’ll enrich the user experience and provide an understanding of the analyzed text.

Why Have Transformers Become Popular in Deep Learning?

Transformers have become widely popular in sentiment analysis apps due to their groundbreaking impact on natural language processing (NLP). With their attention mechanism, transformers excel at capturing contextual relationships within the text, enabling more accurate sentiment analysis by capturing subtle nuances and dependencies.

Moreover, transformers have revolutionized transfer learning in sentiment analysis. Developers can leverage comprehensive language representations by pre-training models on extensive datasets and fine-tuning them on sentiment-specific tasks, saving valuable time and resources. This approach has significantly accelerated the development process of sentiment analysis apps, enabling them to decipher sentiments in a context-aware manner accurately.

Which Tools Can Be Used For Creating GUIs for ML-Powered Apps?

When creating GUIs for ML-powered apps, the Delphi IDE and Delphi FMX (FireMonkey) framework are powerful tools at your disposal.

The Delphi IDE provides a comprehensive set of visual design tools and components that enable you to create stunning and intuitive user interfaces for your ML-powered applications. With its drag-and-drop interface, you can easily design and customize GUI elements, such as buttons, input fields, and data displays, to create a seamless user experience.

The Delphi FMX framework is a cross-platform UI framework that allows you to build visually appealing and responsive user interfaces. FMX supports multiple platforms, including Windows, macOS, Android, and iOS, making it suitable for creating ML-powered apps that can be deployed on different devices.

Furthermore, if you’re working with ML models developed in Python, you can leverage the Delphi4PythonExporter tool. This tool seamlessly integrates Delphi and Python, allowing you to export and utilize your Python-based ML models within your Delphi application. 

How to Create a Sentiment Analysis App With a Stunning GUI for Desktop?

What Are the Prerequisites For Creating A Sentiment Analysis App?

To create a sentiment analysis app, specific prerequisites need to be met. Install Delphi IDE and the FMX Python library on your device. These tools will provide the foundation for developing the app’s graphical user interface. You will also require a text editor or IDE that supports Python, such as PyScripter, along with the Delphi4PythonExporter tool for seamless integration between Delphi and Python.

If any of these tools are not yet installed, it is recommended to refer to the article titled “Powerful Python GUI Project Setup” to assist you in getting started. In terms of Python libraries, the transformers library is essential for working with pre-trained models and performing sentiment analysis tasks. You can install this library by executing the following command:

pip install transformers

Finally, to access the code for this tutorial, you can retrieve it from the GitHub repository provided below:

https://github.com/Embarcadero/PythonBlogExamples/tree/main/Sentiment_Analysis_App

Can I Download Pre-trained Sentiment Analysis Models From Online Platforms?

Yes, you can download pre-trained models from online platforms, and one popular platform for accessing and downloading pre-trained models is Hugging Face. This platform provides a wide range of pre-trained models for various NLP tasks, including sentiment analysis, text classification, machine translation, question answering, and more. These models are trained on large datasets and have already learned language representations, making them valuable resources for building NLP applications.

To download pre-trained models from Hugging Face, you can use their Python library called “transformers.” This library lets you easily access and utilize pre-trained models in your machine-learning projects. You can select a specific model based on your task requirements, such as sentiment analysis, and then download the model files and the associated tokenizer.

Once downloaded, you can use the pre-trained model in your ML pipeline, fine-tune it on your specific dataset, or integrate it into your ML-powered app using frameworks like PyTorch or TensorFlow.

How to Create a Stunning GUI For Our Sentiment Analysis App?

Let’s start by opening up Delphi CE and creating a blank project. We will do this by selecting Multi-Device Application > Blank Application and clicking Ok. Here, we have named our project as Sentiment_Analysis_App.

If you need to become more familiar with the various sections of the Delphi IDE, we recommend referring to our free eBook bundle, which covers the Delphi Python EcoSystem and all Python GUI offerings.

Let’s start by renaming our form. To do this, right-click on the form and select QuickEdit. Here we will name our form MainForm with the caption Sentiment Analysis App.

Next, we will rename our source file from Unit1.pas to Main.pas to make it easier to keep track of. 

Now, we will resize our form. To do this, select the form and navigate to the Object Inspector. Here we will search for the ClientWidth and ClientHeight properties in the Properties tab. We will set these properties to 500 and 500, respectively.

Now let’s start adding a few labels to our form. To do this, navigate to the standard Palette and search for the TLabel component. Drag and drop this component onto the form.

Now modify the style by using the TextSettings property of the label. We will do this by navigating to the Object Inspector and searching for the TextSettings property. Next, click the ellipses button next to the Font property to see options for modifying the label based on your preferences. Here we will set our font family as SemiBold Segoe UI with different font sizes for each label. In addition, we will set the HorzAlign and VertAlign properties for our labels as Center.

Here is what our form looks like:

As you can see in the form, we have added three labels to our form. The Title label will serve only as a placeholder to display the title. The Result label will show the result of the sentiment analysis algorithm. Finally, the FileName label will simply display the filename.

Next, let’s add a few buttons to our form. For this, we will use the TButton component, so navigate to the Palette and search for the component.

We will add two buttons to our form. The ResultButton will evaluate the sentiment of our input, whereas the FilePickButton will help us select a file that will be analyzed.

We have also disabled the FilePickButton by default by setting the Enabled property to False.

To allow the user to select a file, we will add a TOpenDialog component, which will help us open a dialog box to select a file from our system. So open up the Palette and search for the TOpenDialog component. Drag and drop this component anywhere on your form.

Now, let’s add a text box to our form to allow the user to input some text the model will analyze. To do this, open up the Palette and search for TEdit. Add this component to your form and rename it to SentimentTextEdit. 

Turn off this button by setting the Enabled property to False.

To complete our form, we will add a few TRadioButton components. These will help the user select the file picker or the text box to analyze some text. So open up the Palette and search for the TRadioButton component. Add this component to your form. We will add two radio buttons FilePickerRadio, and TextboxRadio, that will help us select either of them. Here is what our form looks like:

How to Create Stylish Forms in Delphi IDE?

Now that our form is ready, let’s add some style. But before that, you will need to download the free ebook bundle, which comes shipped with a multitude of styles that you can choose from. 

First, download your free ebook and extract the FMX styles zip to your chosen directory. Next, select the style you want to use. For this project, we will use AquaGraphite.style available in the bundle.

To use this style, head to the Palette and add the TStyleBook component to your form.

Next, double-click on the StyleBook1 component to open up your Style Designer. Now, click on the open button to open up a dialog box.

Navigate to the .style file of your choosing in the dialog box, select your file, and finally click on exit. 

Once you’ve finalized your style, select the MainForm and head to the Object Inspector. Here we will search for the StyleBook property. Select the drop-down menu and select StyleBook1.

Here is what our form looks like:

Let’s complete our form by adding an image. Start by making some room for our image. We will move all the components down by a few pixels for this. Next, head over to the Palette and search for the TImage component. Add this component to your form.

Next, head to the object inspector and click on the ellipses (...) next to the MultiResBitMap property.

Click on the Fill All From File button and select your chosen image. Now Click on the exit button to load the image.

Finally, adjust the image to your needs. Here is what our final form looks like:

Can I Export These Forms to Python Code?

Now that the form is complete, we can export it using the Delphi4Python exporter. But before we can do that, we need to add some functionality to each button in the form. 

To do this, double-click on each button on the form. This will add an OnClick method to that button. The procedure will be created in the .pas file of the form. This allows you to add unique functionality to each button when clicked.

Because the Delphi4PythonExporter does not use run-time implementation, we must add at least one comment (//) to each procedure to preserve the function when we export the form.

Now that our form is ready, we are ready to export. Select Tools > Export To Python > Export Current Entire Project to export the project.

Here we will give the project the title Sentiment Analysis App. Next, select the directory of your choosing and click on Export:

Because we had one form, Delphi will generate two Python files and one .pyfmx file.The Sentiment_Analysis_App.py file will be used to run the application, whereas the Main.py file contains the class for the MainForm. The .pyfmx file contains the visual information for the MainForm. Below are the contents for each Python file.

Sentiment_Analysis_App.py:

from delphifmx import *
from Main import MainForm

def main():
    Application.Initialize()
    Application.Title = 'Sentiment Analysis App'
    Application.MainForm = MainForm(Application)
    Application.MainForm.Show()
    Application.Run()
    Application.MainForm.Destroy()

if __name__ == '__main__':
    main()

Main.py:

import os
from delphifmx import *

class MainForm(Form):

    def __init__(self, owner):
        self.Title = None
        self.Result = None
        self.FileName = None
        self.FilePickButton = None
        self.ResultButton = None
        self.OpenDialog1 = None
        self.SentimentTextEdit = None
        self.TextboxRadio = None
        self.FilePickerRadio = None
        self.Image1 = None
        self.StyleBook1 = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

    def FilePickButtonClick(self, Sender):
        pass

    def ResultButtonClick(self, Sender):
        pass

How to Put it All Together Into a Full-Fledged Sentiment Analysis App? 

Now that we are done with the form, all we need to do is add functionality. Let’s start by opening up Main.py in the text editor of your choice and importing some libraries:

# Additional imports
from transformers import AutoTokenizer, AutoModelForSequenceClassification

Next, head over to the __init__ function and initialize the model and tokenizer for the transformer model. Here we will use the "ProsusAI/finbert" sentiment analyzer model available on HuggingFace. Here is what our final __init__ function looks like:

def __init__(self, owner):
        self.Title = None
        self.Result = None
        self.FileName = None
        self.FilePickButton = None
        self.ResultButton = None
        self.OpenDialog1 = None
        self.SentimentTextEdit = None
        self.TextboxRadio = None
        self.FilePickerRadio = None
        self.Image1 = None
        self.StyleBook1 = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

        # Initialize model and tokenizer
        self.tokenizer = AutoTokenizer.from_pretrained("ProsusAI/finbert")
        self.model = AutoModelForSequenceClassification.from_pretrained("ProsusAI/finbert")

Next, navigate to the FilePickButtonClick function. Here we will open the file picker dialog box and filter the files to show only the .txt files. Our final FilePickButtonClick function looks like:

def FilePickButtonClick(self, Sender):
        self.OpenDialog1.Title = "Select an Image"

        # Filtering only image formats to show
        self.OpenDialog1.Filter = "Text files (*.txt)|*.txt|All files (*.*)|*.*"

        if self.OpenDialog1.Execute():
                    self.FileName.Text = "Filename: " + os.path.basename(self.OpenDialog1.FileName)

Now, let’s define our ResultButtonClick function. We will start by checking which radio button is checked. If the TextboxRadio button is checked, we will extract the text from the SentimentTextEdit text box and store it in our text variable. We will then use our predict function (which we will define later) to predict the sentiment of the text. The predict function will also display the sentiment in the Result label:

def ResultButtonClick(self, Sender):
        if self.TextboxRadio.IsChecked:
            text = self.SentimentTextEdit.Text
            print(text)
            self.predict(text)

Next, if the FilePickerRadio button is checked, we open the text file and store the data in the text variable. We then use the predict function to predict the sentiment. Our final ResultButtonClick function looks like:

def ResultButtonClick(self, Sender):
        if self.TextboxRadio.IsChecked:
            text = self.SentimentTextEdit.Text
            print(text)
            self.predict(text)
        elif self.FilePickerRadio.IsChecked:
            with open(self.OpenDialog1.FileName, 'r') as file:
                text = file.read()
            print(text)
            self.predict(text)
        else:
            pass

Now, let’s define our predict function. We will start by processing our text to generate tokens. We will then pass these tokens to the model to generate an output based on the text. We then extract the output from the last layer of the model to get the predicted_label. Next, we use the predicted_label and the model config to decode our prediction. Here is what our predict function looks like:

def predict(self, text):
        tokens = self.tokenizer.encode_plus(text, return_tensors='pt', padding=True, truncation=True)
        output = self.model(**tokens)
        logits = output.logits
        predicted_label = logits.argmax().item()

        self.Result.Text = "Result: " + self.model.config.id2label[predicted_label]

Finally, we need a way to enable/disable our textbox and button based on which radio button is ticked. We will do this by first opening up Main.pyfmx and creating an OnChange event for both our TextboxRadio and FilePickerRadio buttons.

Next, let’s define our RadioChange function. Open up Main.py and create a new RadioChange function. We define this function by checking if the TextboxRadio button is checked. If checked, we enable the SentimentTextEdit text box and disable the FilePickButton. Otherwise, if the FilePickerRadio button is checked, we simply turn off the SentimentTextEdit text box and enable the FilePickButton. Here is what our RadioChange function looks like:

def RadioChange(self, Sender):
        if self.TextboxRadio.IsChecked:
            self.SentimentTextEdit.Enabled = True
            self.FilePickButton.Enabled = False
        if self.FilePickerRadio.IsChecked:
            self.SentimentTextEdit.Enabled = False
            self.FilePickButton.Enabled = True

Here is what our final Main.py file looks like:

import os
from delphifmx import *

# Additional imports
from transformers import AutoTokenizer, AutoModelForSequenceClassification

class MainForm(Form):

    def __init__(self, owner):
        self.Title = None
        self.Result = None
        self.FileName = None
        self.FilePickButton = None
        self.ResultButton = None
        self.OpenDialog1 = None
        self.SentimentTextEdit = None
        self.TextboxRadio = None
        self.FilePickerRadio = None
        self.Image1 = None
        self.StyleBook1 = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

        # Initialize model and tokenizer
        self.tokenizer = AutoTokenizer.from_pretrained("ProsusAI/finbert")
        self.model = AutoModelForSequenceClassification.from_pretrained("ProsusAI/finbert")

    def FilePickButtonClick(self, Sender):
        self.OpenDialog1.Title = "Select an Image"

        # Filtering only image formats to show
        self.OpenDialog1.Filter = "Text files (*.txt)|*.txt|All files (*.*)|*.*"

        if self.OpenDialog1.Execute():
                    self.FileName.Text = "Filename: " + os.path.basename(self.OpenDialog1.FileName)

    def ResultButtonClick(self, Sender):
        if self.TextboxRadio.IsChecked:
            text = self.SentimentTextEdit.Text
            print(text)
            self.predict(text)
        elif self.FilePickerRadio.IsChecked:
            with open(self.OpenDialog1.FileName, 'r') as file:
                text = file.read()
            print(text)
            self.predict(text)
        else:
            pass

    def predict(self, text):
        tokens = self.tokenizer.encode_plus(text, return_tensors='pt', padding=True, truncation=True)
        output = self.model(**tokens)
        logits = output.logits
        predicted_label = logits.argmax().item()

        self.Result.Text = "Result: " + self.model.config.id2label[predicted_label]

    def RadioChange(self, Sender):
        if self.TextboxRadio.IsChecked:
            self.SentimentTextEdit.Enabled = True
            self.FilePickButton.Enabled = False
        if self.FilePickerRadio.IsChecked:
            self.SentimentTextEdit.Enabled = False
            self.FilePickButton.Enabled = True

Now that our application is ready, let’s test it out. Head over to Sentiment_Analysis_App.py and run the file.

Now let’s test our application by selecting the Textbox radio button. This will enable the text box. Next, add some text to test out:

Finally, click on the Analyze Sentiment button to check out the result:

Similarly, we can test out the file picker by selecting the File Picker radio button. This enables the Select File button. Now press the button to open a dialog box and select a text file to analyze. For now, we will be using test.txt. Here are the contents of our file: “The movie was an absolute disaster, with terrible acting, a nonsensical plot, and cringe-worthy dialogue. I wouldn’t recommend it to anyone.”

Once you’ve selected your text file, your file name should appear on the FileName label:

Now click on the Analyze Sentiment button to check out the result:

What Are the Key Takeaways?

Congrats! We have successfully created a Sentiment Analysis app by leveraging Delphi’s powerful IDE, Delphifmx Python library, and incorporating a deep learning model from Hugging Face. This user-friendly application allows users to classify text as neutral, positive, or negative, empowering them to extract valuable insights from textual data. Delphi’s versatility, extensive features, and cross-platform capabilities make it an ideal choice for developers looking to build innovative applications. 

With the fusion of Delphi and deep learning, the possibilities are boundless. Begin your app development journey with Delphi and unlock the potential to create special applications that revolutionize how we analyze and interpret sentiment in text.

What Are Some FAQs About this Topic?

What is Delphi?

Delphi is an IDE that allows developers to build applications using the Object Pascal programming language. It provides various tools and components for creating GUI-based applications across various platforms.

What is sentiment analysis?

Sentiment analysis determines a given text’s sentiment or emotional tone, such as a review, social media post, or customer feedback. It involves classifying the text as positive, negative, or neutral, providing insights into the writer’s opinion or attitude.

What is a deep learning model?

A deep learning model is a machine learning model that utilizes artificial neural networks with multiple layers to learn and extract complex patterns and representations from data. Deep learning models have been particularly successful in various domains, including NLP tasks like sentiment analysis.

What is Hugging Face?

Hugging Face is an open-source platform that provides a wide range of pre-trained models and tools for NLP. It offers resources such as transformer models, tokenizers, and libraries like Transformers, facilitating the development and deployment of NLP applications.

Can Delphi be used for building machine-learning applications?

Yes, Delphi can be used for building machine-learning applications. With its versatile IDE and frameworks like Delphi FMX, developers can create visually appealing and user-friendly GUIs for ML-powered applications. Additionally, tools like Delphi4PythonExporter enable integration with Python-based machine learning models, expanding the capabilities of Delphi in the ML domain.

The post How To Create A Sentiment Analysis App Using DelphiFMX And AI first appeared on Python GUI.

What ML Models Are Used For Classification Tasks?

Classification tasks in machine learning utilize various models that have proven effective in producing accurate results. These models include logistic regression for binary classification, decision trees for hierarchical partitioning, random forests for ensemble learning, and support vector machines for optimal hyperplane separation. 

In recent years, neural networks, particularly deep learning models, have gained immense popularity due to their ability to learn complex patterns and hierarchies in data. Neural networks, especially transformers, have gained prominence, excelling in NLP and image classification tasks.  For instance, the Swin and Vision Transformer (ViT) leverages the power of transformers to process image patches, enabling effective classification based on visual information. Transformers capture complex dependencies and have revolutionized NLP with self-attention and multi-head attention mechanisms. Their adaptability to diverse data domains makes them a powerful choice for accurate classification in machine-learning applications.

Which Tools Can Be Used For Creating GUIs for ML-based Apps?

Delphi CE (Community Edition), Delphi4PythonExporter, and Delphi FMX (FireMonkey) are excellent choices for creating GUIs specifically tailored for ML-based apps. Delphi CE provides a comprehensive, integrated development environment (IDE) that enables rapid application development with various components and controls for creating visually appealing interfaces. It allows seamless integration with ML backends implemented in Python using frameworks like TensorFlow and PyTorch.

Delphi FMX, a cross-platform GUI framework, empowers developers to create visually stunning and responsive interfaces for ML-based apps. With Delphi FMX, developers can design seamless GUIs on various platforms, including Windows, macOS, iOS, and Android. The framework supports integrating ML models developed with Python frameworks, such as TensorFlow, PyTorch, or Hugging Face, into the Delphi FMX-based interfaces.

How to Create a Food Classification Desktop App?

Creating a food classification desktop app involves several steps. Before we get into the detailed tutorial, let’s look at the requirements for this project.

What Are the Prerequisites For this Article?

Install Delphi CE and the FireMonkey GUI framework on your device to create the food classification app. You will need a text editor or IDE that supports Python, such as PyScripter and the Delphi4PythonExporter tool. If you don’t have these tools installed, we recommend checking out the article “Powerful Python GUI Project Setup” to help you get started. 

You should also install transformers and pillow Python libraries by running the following commands in the cmd:

pip install pillow
pip install transformers

You can grab the code for this tutorial from our GitHub repository using the following link:

https://github.com/Embarcadero/PythonBlogExamples/tree/main/Food_Image_Classifier

How to Download Pre-trained Models From HuggingFace?

You can follow a few simple steps to download pre-trained models from Hugging Face. Start by visiting the Hugging Face Model Hub website at https://huggingface.co/models. Once there, you can search for the specific pre-trained model you need using relevant keywords or for specific model names. For instance, if you are looking for a pre-trained model for food classification, you can search for “food classification” or specific model names associated with food classification.

You can Import the necessary modules in your Python script by replacing <model> with the specific model you want to use:

from transformers import <model>

Then load the pre-trained model using the from_pretrained() method while replacing <model> with the model class you imported and <model_name> with the name or path of the pre-trained model:

model = <model>.from_pretrained('<model_name>')

This will download the pre-trained weights if not already cached on your system. Now, you can use the loaded model for your tasks by calling its appropriate methods or attributes. For instance, you will have to get its feature extractor to extract features from unseen data before providing it to the model. You can refer to the documentation of the specific model class for more details on how to use it. 

For this tutorial, we will use a food classification model that classifies images into 7 categories (apple pie, falafel, french toast, ice cream, ramen, sushi, and tiramisu). This pre-trained model is finetuned on the Swin transformer model:

https://huggingface.co/Kaludi/Food-Classification

You can grab the code for this tutorial from our GitHub repository using the following link:

https://github.com/Embarcadero/PythonBlogExamples/tree/main/Food_Image_Classifier

What Kind of a GUI Can We Create For Such an App?

Using the Delphi ecosystem, we can create a very attractive GUI for such an ML task.

How to Create Stylish Delphi Forms?

We will start by opening the Delphi CE application and creating a blank project. To do this, navigate to File > New > Multi-Device Application > Blank Application > Ok. In this tutorial, we have named our project MLFoodClassifier.

If you are not familiar with the various sections of the Delphi IDE, we recommend referring to our free eBook bundle, which covers the Delphi Python EcoSystem and all Python GUI offerings.

To start, let’s give our form a name. Right-click on the form and select QuickEdit. Here, we will name our form MainForm with the caption Food Classification App.

We will also rename the source file of our MainForm to Main.pas to make it easier to keep track of. Next, we will resize the form. So go to the Object Inspector and search for ClientWidth and ClientHeight in the properties tab. We will set them to 360 and 500, respectively.

Next, let’s start by adding a few labels to our app. To do this, navigate to the standard palette and locate the TLabel component. Next, drag and drop this component onto the form.

Next, we’ll modify the text style by using the TextSettings property of each label. To do this, navigate to the Object Inspector and search for TextSettings. Click on the ellipses button (...) next to the Font property to see options for modifying the label based on your preferences. Here we have set our font family as SemiBold Segoe UI with different font sizes for each label. In addition, we will set the HorzAlign and VertAlign properties for our labels as Center.

Here is what our form looks like:

As you can see, we have added 4 TLabel components, Title, FileName, FileNameLabel, and ResultLabel. The FileName label will be used to display the file name of the image to be classified, whereas the ResultLabel will help us display the output of our classifier.

Next, let’s add a few buttons to our form. For this, we will use the TButton component, so navigate to the Palette and search for the component.

We will add two buttons, FileSelectButton, to help us select the file to classify, and a ClassifyButton, to help us evaluate our image.

To complete our form, we will add a TOpenDialog component, which will help us open up a dialog box to select a file from our system. So open up the Palette and search for the component. Next, drag and drop this component into your form.

Finally, let’s add some style to our form. For this, you will need to download the free ebook bundle which comes shipped with various styles. Download your free ebook and extract the FMX styles zip to your chosen directory. Next, select the style you want to use. For this we will be using GoldenGraphite.style available in the bundle. You can find more DelphiFMX styles online, such as at delphistyles.com.

Now head to the Palette and add the TStyleBook component to your form.

Next, double-click on the StyleBook1 component. This will open up your Style Designer. Now, click on the open button. This will open up a dialog box.

Navigate to the .style file of your choosing in the dialog box, select your file, and finally click on exit. Now select the form and head over to the Object Inspector. Here we will search for the StyleBook property. Select the drop-down menu and select StyleBook1.

Here is what our MainForm looks like:

Now that the form is complete, the final step will be to add some functionality to each button in the form. To do this, double-click each button. This will add an OnClick method to that button. The procedure will be created in the .pas file corresponding to the .fmx form. This allows you to add unique functionality to each button when clicked.

Because the Delphi4PythonExporter does not use run-time implementation, we will need to add at least one comment (//) to each procedure to preserve the function when we export the form.

How to Export These Forms into Python Scripts?

Now that our form is ready, we can export it using the Delphi4Python exporter. Save our project by selecting Tools > Export To Python > Export Current Entire Project.

Here we will give the project the title MLFoodClassifier. Next, select the directory of your choosing and click on Export:

Delphi will generate two Python files and one .pyfmx file. The MLFoodClassifier.py file will be used to run the application, whereas the Main.py file contains the class for the MainForm. The .pyfmx file contains the visual information for the MainForm. Below are the contents for each Python file.

Main.py:

import os
from delphifmx import *

class MainForm(Form):

    def __init__(self, owner):
        self.Title = None
        self.FileNameLabel = None
        self.ResultLabel = None
        self.FileName = None
        self.FileSelectButton = None
        self.ClassifyButton = None
        self.OpenDialog1 = None
        self.StyleBook1 = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

    def FileSelectButtonClick(self, Sender):
        pass

    def ClassifyButtonClick(self, Sender):
        pass

MLFoodClassifier.py:

from delphifmx import *
from Main import MainForm

def main():
    Application.Initialize()
    Application.Title = 'MLFoodClassifier'
    Application.MainForm = MainForm(Application)
    Application.MainForm.Show()
    Application.Run()
    Application.MainForm.Destroy()

if __name__ == '__main__':
    main()

How to Develop This Project Into a Fully Functional App? 

Now that we are done with the form, all we need to do is add functionality to our form. Let’s start by opening up Main.py in the text editor of your choice. We will start by importing some libraries:

# Additional imports
from PIL import Image
from transformers import AutoModelForImageClassification, AutoImageProcessor

Next, head over to the __init__ function and initialize your transformer models. Here we will be using the Kaludi food classification model available on HuggingFace. Additionally, we will also set the FileName label as empty:

self.FileName.Text = ""
       
        # Loading pre-trained transformer model and feature extractor during app initialization
        self.extractor = AutoImageProcessor.from_pretrained("Kaludi/Food-Classification")
        self.model = AutoModelForImageClassification.from_pretrained("Kaludi/Food-Classification")

Here is what our final __init__ function looks like:

def __init__(self, owner):
        self.Title = None
        self.FileNameLabel = None
        self.ResultLabel = None
        self.FileName = None
        self.FileSelectButton = None
        self.ClassifyButton = None
        self.OpenDialog1 = None
        self.StyleBook1 = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

        self.FileName.Text = ""
       
        # Loading pre-trained transformer model and feature extractor during app initialization
        self.extractor = AutoImageProcessor.from_pretrained("Kaludi/Food-Classification")
        self.model = AutoModelForImageClassification.from_pretrained("Kaludi/Food-Classification")

Now let’s code our FileSelectButton. Head over to the FileSelectButtonClick method, and start by adding a title to the dialog box:

# Filepicker window title
        self.OpenDialog1.Title = "Select an Image"

Next, we will filter the files only to show image files in different formats:

# Filtering only image formats to show
        self.OpenDialog1.Filter = "Image files (*.jpg;*.jpeg;*.png;*.gif;*.bmp, *.webp)|*.jpg;*.jpeg;*.png;*.gif;*.bmp;*.webp|All files (*.*)|*.*"

Finally, if the user presses the open button, we will save the directory of the file in Filename. Here is our FileSelectButtonClick function code:

def FileSelectButtonClick(self, Sender):
        # Filepicker window title
        self.OpenDialog1.Title = "Select an Image"

        # Filtering only image formats to show
        self.OpenDialog1.Filter = "Image files (*.jpg;*.jpeg;*.png;*.gif;*.bmp, *.webp)|*.jpg;*.jpeg;*.png;*.gif;*.bmp;*.webp|All files (*.*)|*.*"
       
        if self.OpenDialog1.Execute():
            self.FileName.Text = os.path.basename(self.OpenDialog1.FileName) # Display selected image

Finally, to evaluate the image, we will need to complete the ClassifyButton. Head over to the ClassifyButtonClick method and start by opening the image file:

def ClassifyButtonClick(self, Sender):
        # Load image from local file
        image = Image.open(self.OpenDialog1.FileName)

Next, preprocess the image using the image processor:

# Preprocess image
        inputs = self.extractor(images=image, return_tensors="pt")

Finally, make the prediction using the model. Here is what our final ClassifyButtonClick method looks like:

def ClassifyButtonClick(self, Sender):
        # Load image from local file
        image = Image.open(self.OpenDialog1.FileName)

        # Preprocess image
        inputs = self.extractor(images=image, return_tensors="pt")

        # Make prediction
        outputs = self.model(**inputs)
        predicted_class_idx = outputs.logits.argmax(-1).item()
        predicted_class = self.model.config.id2label[predicted_class_idx]

        self.ResultLabel.Text = "Result: " + predicted_class # Display prediction

Here is what our final Main.py file looks like:

import os
from delphifmx import *

# Additional imports
from PIL import Image
from transformers import AutoModelForImageClassification, AutoImageProcessor

class MainForm(Form):

    def __init__(self, owner):
        self.Title = None
        self.FileNameLabel = None
        self.ResultLabel = None
        self.FileName = None
        self.FileSelectButton = None
        self.ClassifyButton = None
        self.OpenDialog1 = None
        self.StyleBook1 = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

        self.FileName.Text = ""
       
        # Loading pre-trained transformer model and feature extractor during app initialization
        self.extractor = AutoImageProcessor.from_pretrained("Kaludi/Food-Classification")
        self.model = AutoModelForImageClassification.from_pretrained("Kaludi/Food-Classification")


    def FileSelectButtonClick(self, Sender):
        # Filepicker window title
        self.OpenDialog1.Title = "Select an Image"

        # Filtering only image formats to show
        self.OpenDialog1.Filter = "Image files (*.jpg;*.jpeg;*.png;*.gif;*.bmp, *.webp)|*.jpg;*.jpeg;*.png;*.gif;*.bmp;*.webp|All files (*.*)|*.*"
       
        if self.OpenDialog1.Execute():
            self.FileName.Text = os.path.basename(self.OpenDialog1.FileName) # Display selected image

    def ClassifyButtonClick(self, Sender):
        # Load image from local file
        image = Image.open(self.OpenDialog1.FileName)

        # Preprocess image
        inputs = self.extractor(images=image, return_tensors="pt")

        # Make prediction
        outputs = self.model(**inputs)
        predicted_class_idx = outputs.logits.argmax(-1).item()
        predicted_class = self.model.config.id2label[predicted_class_idx]

        self.ResultLabel.Text = "Result: " + predicted_class # Display prediction

Now that our code is ready, it’s time to test our app. Head over to the MLFoodClassifier.py and run the file.

Next, press the Select Image button. This will open up a dialog box for your to select an image. Navigate to the directory of your image and open your image. Here we will be using a sample image from wikipedia:

Once you’ve selected your image your file name should appear on the FileName label:

Now press the Classify button to evaluate your image. Your result should appear in the ResultLabel:

Are You Ready to Create Your Own Image Classification Apps?

Creating your image classification apps can be exciting and rewarding. With the right tools and techniques, you can develop powerful applications to classify and identify objects in images accurately. We highly recommend exploring the Delphi ecosystem to streamline your development process and unlock even more possibilities. Delphi CE, Delphi4PythonExporter, and Delphi FMX provide a comprehensive suite of tools and frameworks for GUI development and seamless integration with Python ML backends.

So, are you ready to dive into the world of image classification apps? Get started with Delphi and transform your ML-based app development journey now!

What Are the FAQs Related to This Topic?

Can I use pre-trained models for food classification, or is self-training required?

Yes, you can leverage pre-trained models for food classification. Pretrained models trained on large-scale datasets can provide excellent performance. However, fine-tuning or training your models on a specific food dataset can yield better results.

What are the challenges in food classification?

Food classification faces challenges such as variations in food appearance, lighting conditions, occlusions, and complex backgrounds. It requires handling large amounts of data and ensuring the model’s generalization across different food categories.

How do I improve the accuracy of my food classification model?

You can try data augmentation, transfer learning, fine-tuning, model ensemble, and experimenting with different architectures or hyperparameters to improve accuracy.

What is Delphi?

Delphi is an integrated development environment (IDE) that allows developers to build cross-platform applications using the Object Pascal programming language. It provides powerful tools and libraries for creating visually appealing and feature-rich applications.

Is Delphi suitable for beginners?

Yes, Delphi is beginner-friendly. It offers a visually-driven development environment with a drag-and-drop interface, making it easy for beginners to create GUI applications without extensive coding knowledge. Delphi also provides comprehensive documentation and a supportive community.

The post How To Create An ML-Powered Food Classification App Using The Python Delphi Ecosystem first appeared on Python GUI.

What Are the Rules of a Hi-Lo Game?

The Hi-Lo app for Android is a fast-paced game that challenges your mind on the go. The app presents you with a random number as the starting number, and your goal is to guess whether the next number will be higher or lower. If you guess correctly, the app reveals the next number, and you continue to the next round. However, if you guess incorrectly, the game ends, and your score is based on the number of correct guesses you made in a row. Your aim is to achieve the highest score possible by making correct guesses for as long as you can. 

Why Use Delphi For Python to Create this App?

Delphi for Python is a useful set of tools for Python developers looking to create such a game with efficient and visually appealing Graphical User Interfaces (GUIs). These tools, such as Delphi FMX provides powerful tools and cross-platform support, enabling developers to build flexible and sophisticated GUIs that operate across multiple platforms without writing separate code for each. Delphi’s UI design tools, including the Delphi4PythonExporter tool, can help accelerate development and ensure functional and aesthetically appealing GUIs. The open-source Delphi Community Edition and PythonFMXBuilder are also available for developers who prefer to work with open-source tools. Delphi for Python can help streamline the development process and ensure smooth and efficient operation across all platforms.

How to Create an Amazing Hi-Lo App?

What Are the Prerequisites for this App?

To create the memory game desktop app, you must install Delphi and the FireMonkey GUI framework on your device. Additionally, you will need a text editor or IDE that supports Python, such as PyScripter and the Delphi4PythonExporter tool.

If you don’t have these tools installed, we recommend checking out the article “Powerful Python GUI Project Setup” to help you get started. Once you have all the required tools, you can proceed with the tutorial to create your memory game desktop app using Delphi

You can grab the code for this tutorial from our GitHub repository using the following link: https://github.com/Embarcadero/PythonBlogExamples/tree/main/HiLo_Game

How To Create Basic Forms For this App in Delphi CE?

We will start by opening the Delphi CE application and creating a blank project. To do this, navigate to File > New > Multi-Device Application > Blank Application > Ok. In this tutorial, we have named our project HiLoGame.

If you are not familiar with the various sections of the Delphi IDE, we recommend referring to our free eBook bundle, which covers the Delphi Python EcoSystem and all Python GUI offerings.

To start, let’s give our form a name. Right-click on the form and select QuickEdit. Here, we will name our form MainForm with the caption MainMenu.

Next, we need to resize our form which will help it fit in our Android devices. So, go to the object inspector and search ClientHeight and ClientWidth in the properties tab. We will set them to 500 and 360, respectively.

Moreover, we will also rename the source file of our MainMenu form to MainMenu.pas to make it easier to keep track of.

As you may have guessed, this form will serve as the main screen of our app where the users will be greeted and can start the game. Now what we will need to do is enhance the user experience by adding components to our app. First, let’s start by adding a title to our app. To do this, navigate to the standard palette and locate the TLabel component. Next, drag and drop this component onto the form.

Next, let’s modify the text style. To do this we will use the TextSettings property. So, navigate to the Object Inspector and search for TextSettings. Select Font beneath it and click “...” to see options for modifying the label’s font, size, and style based on your preferences. Here we have set our font family as Segoe UI with a font size of 48.

Next, we will center the text using the HorzAlign and VertAlign properties in TextSettings. So select the label component and select the adjust the properties to Center.

Additionally, we must follow intuitive naming convention for our app components so that they can be tracked more easily. Therefore, we will name our TLabel component “Title” with the “Memory Game” text.

Next, let’s add another label that will display the rules for our app.

Next, we need a way to navigate to our game form where we will be playing our game. To do this, we will be using a TButton component. So go to the Palette and add a button using the TButton component.

Now, let’s make this button a bit more appealing. Let’s change the font size to Segoe UI with a font size of 18 and change the size of the button. Additionally, we will name the button Start and display the text as “START”. Here is what our form looks like:

Finally, let’s adjust the form’s background color by navigating to the Object Inspector and selecting the form’s fill property.

Here is what our form looks like:

Finally, we can explore the power of styles using DelphiFMX. To do this you will need to download the free ebook bundle which comes with a variety of styles. Download your FMX styles zip file and extract it into your desktop. Next, select a style that you want to use. You can find other styles online, such as delphistyles.com. For now we will be using Light.style available in the bundle.

Head to Palette and TStyleBook object to your form

Next, double click on the object. This will open up your Style Designer. Now press the click on the open button.

Navigate to the .style file of your choosing and click on exit. Now select the form and head over to the Object Inspector. Here we will search for the StyleBook property. Select the drop down menu and select StyleBook1.

This will apply the style to your form. Here is what our final MainForm looks like:

Now that we are done with the main menu, let’s create a new form that will display our game. So right-click on HiLoGame.exe and select Add New > Multi-Device Form.

This will create a new form that will serve the main game. Here we have named the form as GameForm and its corresponding source file as Game.pas. We also used QuickEdit to change the form Caption to HiLo Game and changed its dimension to match our MainForm.

Now, let’s start by changing the background of our form using the fill property.

Next, we will add labels and buttons to our form. We will first add three labels to our form. The first label, which we will name Number will help show the number that is to be predicted. The next label is the ScoreLabel which will display the current score of the user. For now, we will set the default caption of Number as “-” and the ScoreLabel as “Score :0”. Finally, we add a third label StatusLabel right below the ScoreLabel to help us display some information. We will set its default caption as empty.

Finally, we will add 3 buttons to our app. The HighButton and LowButton will help the user predict whether the next number will be high or low, respectively. The AgainButton will help the user restart the game.

Additionally, we will set the AgainButton as disabled by selecting the button and setting its Enabled property as False.

Finally, apply the style of your choosing to your form. Here is what our final GameForm looks like:

Now that our forms are complete, the final step is to add functionality to each button. So go to each form and double-click each button to add an OnClick method to that button. The procedure will be created in the .pas file corresponding to the .fmx form. This allows you to add unique functionality to each button when clicked.

After creating the OnClick method for each button, add at least one comment (//) to each procedure. This is recommended to preserve the method when you export the form as a Python file, as we do not export the run-time implementation using the Delphi4PythonExporter.

Can I Export This GUI to Python Code?

Now that our forms are ready, we can save our project as a Python script by selecting Tools > Export To Python > Export Current Entire Project.

Here rename your project to HiLoGame, and select the main form as MainForm. Finally, select the directory of your choosing and click Export:

Delphi will generate 5 files, 3 Python scripts named MainMenu.py, Game.py, and HiLoGame.py. The HiLoGame.py is used to launch our Delphi app, while Game.py, MainMenu.py python files contain the classes for the individual forms. Along with the Python file for each form, Delphi also generates a .pyfmx script of the same name as each form that contains the visual information of that form. Here are the contents of each file.

HiLoGame.py:

from delphifmx import *
from MainMenu import MainForm

def main():
    Application.Initialize()
    Application.Title = 'HiLoGame'
    Application.MainForm = MainForm(Application)
    Application.MainForm.Show()
    Application.Run()
    Application.MainForm.Destroy()

if __name__ == '__main__':
    main()

MainMenu.py:

import os
from delphifmx import *

class MainForm(Form):

    def __init__(self, owner):
        self.Title = None
        self.Rules = None
        self.Start = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "MainMenu.pyfmx"))

    def StartClick(self, Sender):
        pass

Game.py:

import os
from delphifmx import *

class GameForm(Form):

    def __init__(self, owner):
        self.ScoreLabel = None
        self.Number = None
        self.HighButton = None
        self.LowButton = None
        self.AgainButton = None
        self.StatusLabel = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Game.pyfmx"))

    def HighButtonClick(self, Sender):
        pass

    def LowButtonClick(self, Sender):
        pass

    def AgainButtonClick(self, Sender):
        pass

How Can I Add Functionality to This Amazing GUI?

Now that our forms are ready, we can add functionality to our game. Let’s start with our MainForm. So open up MainMenu.py and navigate to the StartClick function. 
The MainForm only serves the purpose of launching the game. The StartClick will enable us to launch our GameForm. So start by importing the GameForm, from Game.py:

from Game import GameForm

Next, in the StartClick function, create a new variable named Game, and initialize it with a new instance of the GameForm. Now, we will simply use the Show() method to display our GameForm. Here is what the StartClick function looks like:

def StartClick(self, Sender):
        Game = GameForm(self)
        Game.Show()

Finally, lets display the rules of the game by defining them in the Rules label. This is done using the .Text property of the label component:

self.Rules.Text = """Rules: nThe rules for the game are simple.
The game will generate a random number between 1 and 10.
Your job will be to predict whether the next number will be higher or lower than the current number.
        """

Here are the contents of our final MainMenu.py:

import os
from delphifmx import *
from Game import GameForm


class MainForm(Form):
    def __init__(self, owner):
        self.Title = None
        self.Rules = None
        self.Start = None
        self.LoadProps(
            os.path.join(os.path.dirname(os.path.abspath(__file__)), "MainMenu.pyfmx")
        )

        self.Rules.Text = """Rules: nThe rules for the game are simple.
The game will generate a random number between 1 and 10.
Your job will be to predict whether the next number will be higher or lower than the current number.
        """

    def StartClick(self, Sender):
        Game = GameForm(self)
        Game.Show()

Now, lets open up Game.py and start coding our game.

Let’s start by navigating to our __init__ function. The first thing we will need to do is create a variable named self.Score and initialize it to a value of 0. This will help keep track of our score.

self.Score = 0

Next, we import the random library in our Game.py file.

import random

Now, navigate to the __init__ function and generate a random integer between 0 and 10. Next, we display this value to our Number label using the .Text property. Here is what our __init__ function looks like:

def __init__(self, owner):
        self.ScoreLabel = None
        self.Number = None
        self.HighButton = None
        self.LowButton = None
        self.AgainButton = None
        self.StatusLabel = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Game.pyfmx"))

        # Additional initializations
        self.Score = 0
        self.GuessNumber = random.randint(0, 10)  # Generate a random number between 0 and 10
        self.Number.Text = str(self.GuessNumber)

Next, let’s define a function called __UpdateGame that takes in a single string parameter compare to compare the GuessNumber to the selected button. The compare parameter will either be a > or a < string that will help compare the current GuessNumber. We start by clearing the StatusLabel of any text and then storing the current GuessNumber in a new variable called prev. We will use prev to check whether the guess is correct or not. 

Next, we then generate a new random number and store it in GuessNumber and, finally, display the next number into our Number label regardless of the users’ prediction.

def __UpdateGame(self, compare):
        self.StatusLabel.Text = ""  # Clear the status label each time button clicked
        prev = self.GuessNumber  # Store the guess number
        self.GuessNumber = random.randint(0, 10)  # Generate a new random number within a range
        self.Number.Text = str(self.GuessNumber)

Now that we have our guess number, we start comparing. We will use an if statement to check which button the user has pressed based on the compare parameter. If compare equals “>“, then the user presses the HighButton. We then check if the last number is greater than the new number. If this is true, we update the Status label to show that the user was correct. We then increment the Score, and display it as a string into our ScoreLabel. Similarly, if the user presses the LowButton, the compare parameter will be defined as “<“, which we would then use to compare whether the user predicts the next number to be less than or equal to the current number.

def __UpdateGame(self, compare):
        self.StatusLabel.Text = ""  # Clear the status label each time button clicked
        prev = self.GuessNumber  # Store the guess number
        self.GuessNumber = random.randint(0, 10)  # Generate a new random number within a range
        self.Number.Text = str(self.GuessNumber)
        if compare==">" and prev > self.GuessNumber: # If the player guessed lower and the new number is actually lower
            self.StatusLabel.Text = "That's right"
            self.Score +=1  # Increment the score
            self.ScoreLabel.Text = "Score:" + str(self.Score)  
        elif compare=="<" and prev <= self.GuessNumber:  # If the player guessed higher and the new number is actually higher
            self.StatusLabel.Text = "That's right"
            self.Score +=1  # Increment the score
            self.ScoreLabel.Text = "Score:" + str(self.Score)

Finally, if the user guesses the number wrong, then we simply set the StatusLabel to “GAME OVER“. We then disable the HighButton, and LowButton buttons and enable the AgainButton. Here is what our final __UpdateGame function looks like:

def __UpdateGame(self, compare):
        self.StatusLabel.Text = ""  # Clear the status label each time button clicked
        prev = self.GuessNumber  # Store the guess number
        self.GuessNumber = random.randint(0, 10)  # Generate a new random number within a range
        self.Number.Text = str(self.GuessNumber)
        if compare==">" and prev > self.GuessNumber: # If the player guessed lower and the new number is actually lower
            self.StatusLabel.Text = "That's right"
            self.Score +=1  # Increment the score
            self.ScoreLabel.Text = "Score:" + str(self.Score)  
        elif compare=="<" and prev <= self.GuessNumber:  # If the player guessed higher and the new number is actually higher
            self.StatusLabel.Text = "That's right"
            self.Score +=1  # Increment the score
            self.ScoreLabel.Text = "Score:" + str(self.Score)
        else:  # If the player guessed wrong
            self.StatusLabel.Text = "GAME OVER"
            self.LowButton.Enabled = False  # Disable the low button
            self.HighButton.Enabled = False  # Disable the high button
            self.AgainButton.Enabled = True  # Enable the again button

Now that our __UpdateFunction is ready, all we need to do is call it in the HighButtonClick and LowButtonClick functions. If the HighButton button is pressed, we call the HighButtonClick function with the __UpdateFunction with the “<” parameter. Similarly, if the LowButtion is pressed, we call the LowButtonClick function with the “>” parameter in the LowButtonClick function. Here is what our button functions look like:

def HighButtonClick(self, Sender):
        self.__UpdateGame("<")  # If the high button is clicked, update the game

    def LowButtonClick(self, Sender):
        self.__UpdateGame(">")  # If the low button is clicked, update the game

We are now ready to implement our final AgainButtonClick function.

The purpose of the AgainButtonClick function is to reset the game. This button will only be enabled when the game ends, which we have defined in our __UpdateFunction. Therefore, to implement this function, we all need to generate a new random number, reset all the buttons, and reset all the labels to their default values. Here is what our AgainButtonClick function looks like:

def AgainButtonClick(self, Sender):
        self.Score = 0  # Reset the score to 0
        self.ScoreLabel.Text = "Score:" + str(self.Score)  # Update the score label
        self.GuessNumber = random.randint(0, 10)  # Generate a new random number between 0 and 10
        self.Number.Text = str(self.GuessNumber)  
        self.LowButton.Enabled = True  # Enable the low button
        self.HighButton.Enabled = True  # Enable the high button
        self.AgainButton.Enabled = False  # disable the again button
        self.StatusLabel.Text = ""  # Clear the status label

Here is what our final Game.py file looks like:

import os
from delphifmx import *
import random

class GameForm(Form):

    def __init__(self, owner):
        self.ScoreLabel = None
        self.Number = None
        self.HighButton = None
        self.LowButton = None
        self.AgainButton = None
        self.StatusLabel = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Game.pyfmx"))

        # Additional initializations
        self.Score = 0
        self.GuessNumber = random.randint(0, 10)  # Generate a random number between 0 and 10
        self.Number.Text = str(self.GuessNumber)

    def __UpdateGame(self, compare):
        self.StatusLabel.Text = ""  # Clear the status label each time button clicked
        prev = self.GuessNumber  # Store the guess number
        self.GuessNumber = random.randint(0, 10)  # Generate a new random number within a range
        self.Number.Text = str(self.GuessNumber)
        if compare==">" and prev > self.GuessNumber: # If the player guessed lower and the new number is actually lower
            self.StatusLabel.Text = "That's right"
            self.Score +=1  # Increment the score
            self.ScoreLabel.Text = "Score:" + str(self.Score)  
        elif compare=="<" and prev <= self.GuessNumber:  # If the player guessed higher and the new number is actually higher
            self.StatusLabel.Text = "That's right"
            self.Score +=1  # Increment the score
            self.ScoreLabel.Text = "Score:" + str(self.Score)
        else:  # If the player guessed wrong
            self.StatusLabel.Text = "GAME OVER"
            self.LowButton.Enabled = False  # Disable the low button
            self.HighButton.Enabled = False  # Disable the high button
            self.AgainButton.Enabled = True  # Enable the again button

    def HighButtonClick(self, Sender):
        self.__UpdateGame("<")  # If the high button is clicked, update the game

    def LowButtonClick(self, Sender):
        self.__UpdateGame(">")  # If the low button is clicked, update the game

    def AgainButtonClick(self, Sender):
        self.Score = 0  # Reset the score to 0
        self.ScoreLabel.Text = "Score:" + str(self.Score)  # Update the score label
        self.GuessNumber = random.randint(0, 10)  # Generate a new random number between 0 and 10
        self.Number.Text = str(self.GuessNumber)  
        self.LowButton.Enabled = True  # Enable the low button
        self.HighButton.Enabled = True  # Enable the high button
        self.AgainButton.Enabled = False  # disable the again button
        self.StatusLabel.Text = ""  # Clear the status label

How Does the Desktop App look like?

Now, we can run our app by executing HiLoGame.py. Here is what MainForm looks like:

We can start the game by clicking the START button. Here is what our GameForm looks like:

Can I Create an Android App From this Code?

Now that our HiLoGame is running let’s convert this into an Android application.

But before we can create our app, we need to make important changes to the code to allow us to run our project on Android. Let’s create a new file named HiLoGame_Android.py and paste the contents of HiLoGame.py.

Next, open up the HiLoGame_Android.py file and start making some changes. Firstly, because Delphi initialed Android applications automatically, we don’t need to initialize it or set a title manually. The Application.MainForm doesn’t need to be initialized either but just needs a variable. Finally, like the MainForm initialization, we don’t need to launch or destroy the program as Android handles both tasks. Here are the contents of our final HiLoGame_Android.py:

from delphifmx import *
from MainMenu import MainForm

def main():
    Application.MainForm = MainForm(Application)
    Application.MainForm.Show()

if __name__ == '__main__':
    main()

Now open up FMXBuilder and click on Project > New project on the toolbar. Enter the name of the project that you want to build here. Here we define our project as HiLoGame.

Next, add your Python and .pyfmx files by right-clicking on the App and selecting Add file. We won’t add HiLoGame.py, but instead will be adding the HiLoGame_Android.py. HiLoGame.py will only be used to run our desktop application.

Now, right-click on HiLoGame_Android.py file and set it to the main file.

Now that everything is ready, we must create the .apk file for the app using the Build Project button.

When the .apk is fully generated, you will be prompted with a “Build process done” message in the Messages box. You can then check out your generated file in the pathtoPythonFMXBuilderGUIexeFolderappsHiLoGamebin folder.

Now, you must copy the .apk file into your phone’s storage. Next, install this file by accessing it on your Android device. Once your app is installed, you can use it like any other app on your phone.

Does the App Run as Expected on an Android Device?

Here is what our app looks like:

When we press the start button, we are taken to the main game screen:

Upon making a correct guess, the user is prompted and their score is incremented:

Upon an incorrect guess for the next number, the user is prompted and the play again button is enabled while the other two buttons are disabled:

Now, we can reset the game and play again:

Are You Ready to Create Other Android Apps with Delphi For Python?

With the help of a robust ecosystem of development tools and libraries, cross-platform compatibility, and access to the FireMonkey GUI framework, DelphiFMX is a strong and adaptable solution for Python developers. DelphiFMX is the perfect option for developers wishing to create cross-platform games that may appeal to a wider audience, including Android users, thanks to its aesthetically pleasing and highly functional user interfaces.

We invite Python developers interested in producing aesthetically appealing and highly functioning games to learn more about DelphiFMX and utilize its features and tools. You can speed up the app creation process and produce apps that work flawlessly on several platforms with DelphiFMX. 

So, what are you waiting for? Start building your next app with DelphiFMX today.

What Are Some FAQs Related to this Article?

Can I create apps for mobile devices using DelphiFMX?

DelphiFMX provides cross-platform support, allowing developers to build apps for various mobile devices, including Android and iOS.

What is the best approach to building games with Python and DelphiFMX?

The best approach to building games with Python and DelphiFMX is to start with a clear design and choose appropriate game mechanics. Then, utilize the features of DelphiFMX to create a visually appealing and highly functional user interface. Finally, optimize the game’s performance and test it thoroughly before release.

What resources are available to help me learn how to use DelphiFMX for game development?

Many resources are available to help you learn how to use DelphiFMX for game development. The Embarcadero website provides documentation, tutorials, and sample projects to get you started. Additionally, there are online communities and forums where developers can ask questions and share ideas about game development with DelphiFMX. Lastly, Delphi’s ebook would help you understand the entire Delphi ecosystem much better, allowing you to kickstart your career in Python GUI!

Is Python the only language I can use with DelphiFMX for app development?

No, DelphiFMX supports several programming languages, including C++ and Object Pascal. However, Python developers may find it beneficial to use DelphiFMX. It provides an efficient way to build graphical user interfaces (GUIs) and supports cross-platform development, making it easier to create apps that work across multiple devices and operating systems.

The post How to Create A Hi-Lo Game With DelphiFMX Python GUI Package first appeared on Python GUI.

Why Create a Memory Game Using Delphi For Python?

Using Delphi for Python to create a memory game can be advantageous for Python developers looking for an efficient way to build Graphical User Interfaces (GUIs) for their game. Delphi for Python gives developers powerful tools and cross-platform support. It allows them to build visually appealing and functional user interfaces that operate across multiple platforms without writing separate code for each. Developers can build sophisticated and flexible GUIs with access to the FireMonkey GUI framework, making the development process faster and more efficient.

Furthermore, Delphi’s UI design tools, such as the Delphi4PythonExporter tool, can help accelerate development while ensuring that the resulting GUIs are functional and aesthetically appealing. Finally, Delphi Community Edition and PythonFMXBuilder are open-source tools ideal for developers who prefer to work with open-source tools whenever feasible. In conclusion, using Delphi for Python to create a memory game can assist Python developers in streamlining their development process and ensuring that their game works smoothly and efficiently across all platforms.

How to Create this Game as a Desktop App?

Delphi offers powerful tools that make developing visually appealing and engaging games easily. So, let’s dive in and start creating your own memory game for Android using Delphi.

What Are the Requirements to Create this App?

To create the memory game desktop app, you must have Delphi installed on your device and the FireMonkey GUI framework. Additionally, you will need a text editor or IDE that supports Python, such as PyScripter and the Delphi4PythonExporter tool.

If you don’t have these tools installed, we recommend checking out the article “Powerful Python GUI Project Setup” to help you get started. Once you have all the required tools, you can proceed with the tutorial to create your memory game desktop app using Delphi

You can grab the code for this tutorial from our GitHub repository using the following link: https://github.com/Embarcadero/PythonBlogExamples/tree/main/Memory_Game

How to Create Forms in Delphi CE?

Begin by opening Delphi CE and creating a blank application. To do this, navigate to File > New > Multi-Device Application > Blank Application > Ok. In this tutorial, we have named our project MemoryGame.

If you are not familiar with the various sections of the Delphi IDE, we recommend referring to our free eBook bundle, which covers the Delphi Python EcoSystem and all Python GUI offerings.

To start, let’s give our form a name. Right-click on the form and select QuickEdit. Here, we will name our form MainForm with the caption MainMenu.

Next, let’s resize our form. Go to the object inspector and search ClientHeight and ClientWidth in the properties tab. We will set them to 500 and 360, respectively.

We will also rename the source file of our main form to MainMenu.pas to make it easier to keep track of.

This form will be the primary screen where users can start the game. To enhance the user experience, let us add a label that will display the title of our app. To do this, navigate to the standard palette and locate the TLabel component. Next, drag and drop this component onto the form.

To modify the text style to reflect the title, we will use TextSettings. Navigate to the Object Inspector and locate TextSettings. Select Font beneath it and click “...” to see options for modifying the label’s font, size, and style based on your preferences. Here we have set our font family as Britannic with a font size of 48.

Rename each label’s text by right-clicking on the label and selecting Quick Edit. Following an intuitive naming convention for the labels is crucial so they can be tracked more easily. Here, we called our TLabel component “Title” with the text “Memory Game“.

Here we also centered the text using the HorzAlign and VertAlign properties to ensure that the text appears symmetrical.

We can adjust the form’s background color by navigating to the Object Inspector and selecting the form’s fill property.

Finally, we need a method for navigating to the next form where the main game would be played. To accomplish this, go to the Palette and add a button using the TButton component.

Let’s give this button a suitable name. Additionally, we changed the font size and style of these button texts (as we did for the TLabels above) to make them more prominent. Here, we used Segoe UI with a font size of 18.

After making these changes, our form will be much more visually appealing:

Now, let’s add some styles to our forms using the power of DelphiFMX styles. The Delphi ebook bundle comes shipped with a variety of styles that you can use for your applications.

So first download the free ebook bundle and extract the styles zip file into a folder of your choosing. Now select the style you want to choose, for this project we will be using Light.style. You can find other styles online, such as delphistyles.com.

Head to the Palette and search of the TStyleBook object. Add this to your form.

Next, double click on the object. This will open up your Style Designer. Now press the click on the open button.

Now head to the directory of your extracted style files, select the style of your choosing, and click on exit. Next, select the form and head over to the Object Inspector. Here we will search for the StyleBook property. Select the drop down menu and select StyleBook1.

This will apply the style to your form. Here is what our final MainForm looks like:

Now that we are done with the main form of our app, let’s create a new form that will display our Memory Game. So right-click on MemoryGame.exe and select Add New > Multi-Device Form.

This will create a new form which we have named as GameForm, and the corresponding source file as Game.pas. We have also renamed the form caption to Memory Game, and changed the form dimensions to match our MainForm.

Next, let’s start by adding labels and buttons to our form. We will first add two labels to the top of our form which we will name ScoreLabel and TriesLabel, with the captions Score: and Tries: respectively. These labels will help us display the score the player has scored as well as the number of tries they have made.

We have also changed their font style to Britannica with a font size of 24.

Next, we will add 8 buttons to our form that will help us play our game.

For each button we added a default caption as ? and named each of them as Button1, Button2, and so on. We also added two extra buttons Back and Reset that will help us navigate our forms. As you can see we have disabled the Reset button by default which will only open when the player has finished the game.

Finally, we added 3 new labels to the form. The Card1 and Card2 label will help the user remember the card he had selected in his try. The additional label, which we have named Status, lies right above the Back and Reset buttons. It will help display the status of the game. Finally add the Light style to our form. Here is what our final form looks like:

Now that our forms are ready, the last step would be to add functionality to each button. So navigate to each form and double-click each button to create an OnClick method for that button in your .pas file corresponding to your .fmx form. This will enable you to add distinct functionality for each button when clicked.

After creating the OnClick method for each button, adding at least one comment (//) to each procedure is recommended to preserve it when you save the Python file. As we do not export the run-time implementation using the Delphi4PythonExporter, there is no need to write any run-time implementation code.

How Can We Export this App as Python Code?

Now that our forms are ready, we can save our project as a Python script by selecting Tools > Export To Python > Export Current Entire Project.

Here rename your project to MemoryGame, and select the main form as MainForm. Finally, select the directory of your choosing and click Export:

Delphi will generate 5 files, 3 Python scripts named MainMenu.py, Game.py, and MemoryGame.py. The Game.py, MainMenu.py python files contain the classes for the individual forms, and the MemoryGame.py is used to launch our Delphi app. Along with each Python file, Delphi also generates a .pyfmx script of the same name as each form that contains the visual information of that form. Now, let’s take a look at the exported Python files.

MemoryGame.py:

from delphifmx import *
from MainMenu import MainForm

def main():
    Application.Initialize()
    Application.Title = 'MemoryGame'
    Application.MainForm = MainForm(Application)
    Application.MainForm.Show()
    Application.Run()
    Application.MainForm.Destroy()

if __name__ == '__main__':
    main()

Game.py:

import os
from delphifmx import *

class GameForm(Form):

    def __init__(self, owner):
        self.ScoreLabel = None
        self.TriesLabel = None
        self.Button1 = None
        self.Button2 = None
        self.Button3 = None
        self.Button4 = None
        self.Button5 = None
        self.Button6 = None
        self.Button7 = None
        self.Button8 = None
        self.Button9 = None
        self.Button10 = None
        self.BackButton = None
        self.ResetButton = None
        self.Card1Label = None
        self.Card2Label = None
        self.Status = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Game.pyfmx"))

    def Button1Click(self, Sender):
        pass

    def Button2Click(self, Sender):
        pass

    def Button3Click(self, Sender):
        pass

    def Button4Click(self, Sender):
        pass

    def Button5Click(self, Sender):
        pass

    def Button6Click(self, Sender):
        pass

    def Button7Click(self, Sender):
        pass

    def Button8Click(self, Sender):
        pass

    def Button9Click(self, Sender):
        pass

    def Button10Click(self, Sender):
        pass

    def BackButtonClick(self, Sender):
        pass

    def ResetButtonClick(self, Sender):
        pass

MainMenu.py:

import os
from delphifmx import *

class MainForm(Form):

    def __init__(self, owner):
        self.Title = None
        self.StartButton = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "MainMenu.pyfmx"))

    def StartButtonClick(self, Sender):
        pass

How to Add Functionality to This App Using the Delphi FMX Library?

Now that our forms are ready, we can start adding functionality to our game. Let’s start by opening up MainMenu.py and navigating to the StartButtonClick function. 

The MainForm only serves the purpose of launching the game and the StartButtonClick will help us do that. So start by importing the GameForm, from Game.py:

from Game import GameForm

Next, in the StartButtonClick function, create a new variable named Game, and create a new instance of the GameForm. We will then use the Show() method to display our GameForm. Here is what the StartButtonClick function looks like:

def StartButtonClick(self, Sender):
        Game = GameForm(self)
        Game.Show()

Here is what our MainMenu.py looks like:

import os
from delphifmx import *
from Game import GameForm

class MainForm(Form):

    def __init__(self, owner):
        self.Title = None
        self.StartButton = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "MainMenu.pyfmx"))

    def StartButtonClick(self, Sender):
        Game = GameForm(self)
        Game.Show()

Now that our MainForm is ready, let’s now add functionality to our GameForm. Start by opening Game.py and navigating to the __init__ function. In the __init__ function the first thing we will have to do is initialize our score and tries. Along with this we will keep track of the previous attempt by the user and add a flag that will help us later on:

self.prev = (self.Button1, "") # Store the first selected card data
        self.score = 0 # Game score counter
        self.tries = 0 # Tries counter
        self.flag = 0 # Flag to check if one complete try/guess has been made

Next, we will call a function called __RandomizeCards(), which we will define later:

# Randomly assign values to all cards at the start
        self.__RandomizeCards()

Here is what our final __init__ function looks like:

def __init__(self, owner):
        self.Button1 = None
        self.Button2 = None
        self.Button3 = None
        self.Button4 = None
        self.Button5 = None
        self.Button6 = None
        self.Button7 = None
        self.Button8 = None
        self.Button9 = None
        self.Button10 = None
        self.ScoreLabel = None
        self.Card1Label = None
        self.Card2Label = None
        self.Status = None
        self.BackButton = None
        self.ResetButton = None
        self.TriesLabel = None
        self.LoadProps(os.path.join(os.path.dirname(
            os.path.abspath(__file__)), "Game.pyfmx"))

        # Randomly assign values to all cards at the start
        self.__RandomizeCards()

        self.prev = (self.Button1, "")  # Store the first selected card data
        self.score = 0  # Game score counter
        self.tries = 0  # Tries counter
        self.flag = 0  # Flag to check if one complete try/guess has been made

Now the lets move on and define the __RandomizeCards() function. Let’s start by importing random:

# Additional imports
import random

The __RandomizeCards() function uses the Keys from all the buttons that we have defined for our GameForm. It then shuffles a bunch of alphabets that we have defined in our values variable. Finally, it assigns each button a sigle value by the means of a dictionary. This dictionary is stored in a new variable called self.d. Here is what our final __RandomizeCards() function looks like:

def __RandomizeCards(self):
        # Define the keys for the dictionary
        keys = ["Button1", "Button2", "Button3", "Button4", "Button5",
                "Button6", "Button7", "Button8", "Button9", "Button10"]

        # Define the values to randomly select from
        values = ["A", "A", "B", "B", "C", "C", "D", "D", "E", "E"]

        # Shuffle the values randomly
        random.shuffle(values)

        # Create the dictionary
        self.d = dict(zip(keys, values))

Now let’s define our Back and Reset buttons. Start by going to the BackButtonClick function. Here all we need to do is destroy the current form. So here is what our BackButtonClick function will look like:

# Go back to the main screen
    def BackButtonClick(self, Sender):
        self.Destroy()

Next, we need to define our Reset button. The Reset button will call the __RandomizeCards function once again, while resetting the tries, score, flag and all the necessary labels of our form. It will then disable the Reset button and reset the text on all the buttons on our form. Here is what our ResetButtonClick function will look like:

# Play game again so bring back to initial state
    def ResetButtonClick(self, Sender):
        # Randomize the card/button values and reset all labels
        self.__RandomizeCards()
        self.prev = (self.Button1, "")
        self.score = 0
        self.tries = 0
        self.flag = 0
        self.TriesLabel.Text = "Tries: "
        self.ScoreLabel.Text = "Score: "
        self.Status.Text = ""
        self.ResetButton.Enabled = False

        # Hide all cards/buttons (so show ?) and enable them so that they can be clicked
        Buttons = [self.Button1, self.Button2, self.Button3, self.Button4, self.Button5,
                   self.Button6, self.Button7, self.Button8, self.Button9, self.Button10]
        for Button in Buttons:
            Button.Text = "?"
            Button.Enabled = True

Now let’s define the main functionality of our game. To do this, let’s create a function called __Functionality that takes in two parameters, the button that presses it, as well as the name of the button. The function uses the name parameter in self.d to get the value assigned to it:

def __Functionality(self, Button, name):
        val = self.d[name]  # Get value against this button

Now that we have our value, we need to check whether the user is one his first or second try. To do this we will use the flag variable. If flag is equal to 1 then the user is on his second try.

Now if the user is on his second try, we first need to update the tries label and reset the flag to 0:

def __Functionality(self, Button, name):
        val = self.d[name]  # Get value against this button

        # If one complete try has been done
        if self.flag == 1:
            self.tries += 1  # Then increase tries counter
            self.TriesLabel.Text = "Tries: "+str(self.tries)
            self.flag = 0  # Reset tires flag

Next, we need to check whether the value of the previous try was the same as this new try. For this we will use the self.prev variable. Now if the new values match, we increment the score and update the relevant labels. Additionally, we also disable the new selected button, as well as the previous button. 

Finally, once we have made the relevant updates, we need to check if the current score is equal to 5. This would indicate that the user has selected all buttons, and thus has won the game. In this case, we update the Status label and enable the Reset button. Here is what our __Functionality function looks like so far:

def __Functionality(self, Button, name):
        val = self.d[name]  # Get value against this button

        # If one complete try has been done
        if self.flag == 1:
            self.tries += 1  # Then increase tries counter
            self.TriesLabel.Text = "Tries: "+str(self.tries)
            self.flag = 0  # Reset tires flag

            # If the two cards/buttons selected are the same
            if self.prev[1] == val:
                self.score += 1  # Then increase score counter
                self.ScoreLabel.Text = "Score: "+str(self.score)
                Button.Text = val  # Show the value behind
                Button.Enabled = False  # Disable the cards/buttons so that they cannot be clicked
                self.prev[0].Enabled = False

                # If score is 5 then all the cards/buttons have been matched
                if self.score == 5:
                    self.Status.Text = "You Win!"
                    self.ResetButton.Enabled = True  # Now reset button can be clicked

Now, we add a check if the two buttons selected are not the same. In that case, we show the respective cards in the Card1Label and Card2Label, we then hide the previous button and reset the self.prev variable:

def __Functionality(self, Button, name):
        val = self.d[name]  # Get value against this button

        # If one complete try has been done
        if self.flag == 1:
            self.tries += 1  # Then increase tries counter
            self.TriesLabel.Text = "Tries: "+str(self.tries)
            self.flag = 0  # Reset tires flag

            # If the two cards/buttons selected are the same
            if self.prev[1] == val:
                self.score += 1  # Then increase score counter
                self.ScoreLabel.Text = "Score: "+str(self.score)
                Button.Text = val  # Show the value behind
                Button.Enabled = False  # Disable the cards/buttons so that they cannot be clicked
                self.prev[0].Enabled = False

                # If score is 5 then all the cards/buttons have been matched
                if self.score == 5:
                    self.Status.Text = "You Win!"
                    self.ResetButton.Enabled = True  # Now reset button can be clicked

            # If the two cards/buttons selected are not the same
            else:
                # Show the respective values below the cards
                self.Card1Label.Text = "Card 1: " + self.prev[1]
                self.Card2Label.Text = "Card 2: " + val
                Button.Text = val
                Button.Text = "?"  # Hide the cards again0
                self.prev[0].Text = "?"

Finally, to complete the function we add an else for when the user is on his first try. The Card1Label and Card2Label will remain the same, but the selected button flips to show the value behind it. We then update the flag to 1 and then update the self.prev variable. Here is what our completed __Functionality function looks like:

def __Functionality(self, Button, name):
        val = self.d[name]  # Get value against this button

        # If one complete try has been done
        if self.flag == 1:
            self.tries += 1  # Then increase tries counter
            self.TriesLabel.Text = "Tries: "+str(self.tries)
            self.flag = 0  # Reset tires flag

            # If the two cards/buttons selected are the same
            if self.prev[1] == val:
                self.score += 1  # Then increase score counter
                self.ScoreLabel.Text = "Score: "+str(self.score)
                Button.Text = val  # Show the value behind
                Button.Enabled = False  # Disable the cards/buttons so that they cannot be clicked
                self.prev[0].Enabled = False

                # If score is 5 then all the cards/buttons have been matched
                if self.score == 5:
                    self.Status.Text = "You Win!"
                    self.ResetButton.Enabled = True  # Now reset button can be clicked

            # If the two cards/buttons selected are not the same
            else:
                # Show the respective values below the cards
                self.Card1Label.Text = "Card 1: " + self.prev[1]
                self.Card2Label.Text = "Card 2: " + val
                Button.Text = val
                Button.Text = "?"  # Hide the cards again0
                self.prev[0].Text = "?"

        # If just one card/button has been selected and
        # the other has to be selected to complete the guess
        else:
            self.Card1Label.Text = "Card 1:"
            self.Card2Label.Text = "Card 2:"
            Button.Text = val  # Show the value behind
            self.flag += 1  # Increase flag to show that first card selected from the try and one more left
            self.prev = (Button, val)  # Store this button info to compare

Now all we need to do is call the __Functionality function in each button. So head over to each button and call the function. Here is what this looks like for Button1:

def Button1Click(self, Sender):
        self.__Functionality(self.Button1, "Button1")

Here is what our final Game.py file looks like:

import os
from delphifmx import *
# Additional imports
import random


class GameForm(Form):

    def __init__(self, owner):
        self.Button1 = None
        self.Button2 = None
        self.Button3 = None
        self.Button4 = None
        self.Button5 = None
        self.Button6 = None
        self.Button7 = None
        self.Button8 = None
        self.Button9 = None
        self.Button10 = None
        self.ScoreLabel = None
        self.Card1Label = None
        self.Card2Label = None
        self.Status = None
        self.BackButton = None
        self.ResetButton = None
        self.TriesLabel = None
        self.LoadProps(os.path.join(os.path.dirname(
            os.path.abspath(__file__)), "Game.pyfmx"))

        # Randomly assign values to all cards at the start
        self.__RandomizeCards()

        self.prev = (self.Button1, "")  # Store the first selected card data
        self.score = 0  # Game score counter
        self.tries = 0  # Tries counter
        self.flag = 0  # Flag to check if one complete try/guess has been made

    def __RandomizeCards(self):
        # Define the keys for the dictionary
        keys = ["Button1", "Button2", "Button3", "Button4", "Button5",
                "Button6", "Button7", "Button8", "Button9", "Button10"]

        # Define the values to randomly select from
        values = ["A", "A", "B", "B", "C", "C", "D", "D", "E", "E"]

        # Shuffle the values randomly
        random.shuffle(values)

        # Create the dictionary
        self.d = dict(zip(keys, values))

    def __Functionality(self, Button, name):
        val = self.d[name]  # Get value against this button

        # If one complete try has been done
        if self.flag == 1:
            self.tries += 1  # Then increase tries counter
            self.TriesLabel.Text = "Tries: "+str(self.tries)
            self.flag = 0  # Reset tires flag

            # If the two cards/buttons selected are the same
            if self.prev[1] == val:
                self.score += 1  # Then increase score counter
                self.ScoreLabel.Text = "Score: "+str(self.score)
                Button.Text = val  # Show the value behind
                Button.Enabled = False  # Disable the cards/buttons so that they cannot be clicked
                self.prev[0].Enabled = False

                # If score is 5 then all the cards/buttons have been matched
                if self.score == 5:
                    self.Status.Text = "You Win!"
                    self.ResetButton.Enabled = True  # Now reset button can be clicked

            # If the two cards/buttons selected are not the same
            else:
                # Show the respective values below the cards
                self.Card1Label.Text = "Card 1: " + self.prev[1]
                self.Card2Label.Text = "Card 2: " + val
                Button.Text = val
                Button.Text = "?"  # Hide the cards again0
                self.prev[0].Text = "?"

        # If just one card/button has been selected and
        # the other has to be selected to complete the guess
        else:
            self.Card1Label.Text = "Card 1:"
            self.Card2Label.Text = "Card 2:"
            Button.Text = val  # Show the value behind
            self.flag += 1  # Increase flag to show that first card selected from the try and one more left
            self.prev = (Button, val)  # Store this button info to compare

    # Implement this functionality when any of the 10 buttons/cards are selected
    def Button1Click(self, Sender):
        self.__Functionality(self.Button1, "Button1")

    def Button2Click(self, Sender):
        self.__Functionality(self.Button2, "Button2")

    def Button3Click(self, Sender):
        self.__Functionality(self.Button3, "Button3")

    def Button4Click(self, Sender):
        self.__Functionality(self.Button4, "Button4")

    def Button5Click(self, Sender):
        self.__Functionality(self.Button5, "Button5")

    def Button6Click(self, Sender):
        self.__Functionality(self.Button6, "Button6")

    def Button7Click(self, Sender):
        self.__Functionality(self.Button7, "Button7")

    def Button8Click(self, Sender):
        self.__Functionality(self.Button8, "Button8")

    def Button9Click(self, Sender):
        self.__Functionality(self.Button9, "Button9")

    def Button10Click(self, Sender):
        self.__Functionality(self.Button10, "Button10")

    # Go back to the main screen
    def BackButtonClick(self, Sender):
        self.Destroy()

    # Play game again so bring back to initial state
    def ResetButtonClick(self, Sender):
        # Randomize the card/button values and reset all labels
        self.__RandomizeCards()
        self.prev = (self.Button1, "")
        self.score = 0
        self.tries = 0
        self.flag = 0
        self.TriesLabel.Text = "Tries: "
        self.ScoreLabel.Text = "Score: "
        self.Status.Text = ""
        self.ResetButton.Enabled = False

        # Hide all cards/buttons (so show ?) and enable them so that they can be clicked
        Buttons = [self.Button1, self.Button2, self.Button3, self.Button4, self.Button5,
                   self.Button6, self.Button7, self.Button8, self.Button9, self.Button10]
        for Button in Buttons:
            Button.Text = "?"
            Button.Enabled = True

Can I Create this Game for Android Devices?

Let’s proceed to convert our time widget application into an Android application.

As the Delphi4Python Exporter only exports the initialization logic for desktop-based applications, we need PythonFMXBuilder to convert it to an Android app. To begin, open FMXBuilder, click on the toolbar’s Project > New project option, and provide the project’s name. We named ours MemoryApp.

Before adding our Python files, we must modify some code to allow our project to run on Android. First, we need to create a new file called MemoryGame_Android.py and copy the contents of MemoryGame.py. Next, add your Python and other supporting project files used to build your application. We won’t add MemoryGame.py; it will only run our desktop application.

Right-click on the MemoryGame_Android.py file and set it as the main file. Before building the app, we need to make some important code changes.

In Android applications, Delphi applications are automatically initialized. Therefore, we don’t need to initialize or set a title manually. The Application.MainForm variable only needs to be initialized without launching or destroying the program because Android handles both tasks.

After making the necessary code changes, save the file.

Now connect your mobile to your computer device and enable USB tethering. Next, click on the refresh icon and select your device from the drop down menu.

Finally, choose your device and click on the Run Project button. This will install the app on your Android phone and run it.

This will install the app directly on your mobile device.

Is this App Working as Expected?

Now that our app is ready, you can launch it on your Android device and be greeted with the MainForm screen:

Next click on the START button, which will open up the GameForm:

As you can see the Reset button is disabled and will only open when the game has finished. You can then start playing the game. Clicking on each button will reveal the letter behind that button:

If you don’t guess your alphabet in your try, then the Card1 and Card2 labels show your previous attempt:

If you can guess a button correctly, then your score increments and the buttons get disabled:

Finally, you can continue along with the game until you get everything right:

As you can see the Reset button gets enabled once the game is finished. You can click on it to restart the game with new random alphabets.

Are You Ready to Create Other Apps With Delphi?

To summarize, developing a memory game for Android with Delphi is a rewarding experience for developers looking to hone their skills and build engaging applications. Developers can quickly build visually appealing and functional user interfaces that work on multiple devices using Delphi’s powerful tools and cross-platform support. Whether you’re an experienced developer or a beginner, this piece has given you the information you need to create your own memory game for Android using Delphi.

Now that you’ve learned how to make a memorization game in Delphi for Android, it’s time to put your knowledge to use. You can improve your coding skills and make a game that is engaging and enjoyable to play by doing so. Remember to test your game on various devices to ensure it works smoothly and efficiently. 

Why wait? Start making your own memory game with Delphi for Android today to advance your programming skills.

What Are Some FAQs Related to this Tutorial?

What is Delphi?

Delphi is a rapid application development tool for Windows that allows developers to create Graphical User Interfaces (GUIs) quickly and easily.

What is FireMonkey?

FireMonkey is a powerful, flexible GUI framework to create visually appealing and functional user interfaces.

Is Delphi for Python a good choice for developing memory games?

Delphi for Python is a great solution for developers looking to create memory games quickly and efficiently, with cross-platform support and powerful tools.

Do I need previous programming experience to use Delphi for Python?

Some programming experience is recommended, but beginners can still use Delphi for Python to create simple applications and gradually improve their skills.

Can I create a memory game for other platforms besides Android using Delphi for Python?

Yes, Delphi for Python provides cross-platform support, allowing you to create memory games that work on various platforms such as Windows, macOS, iOS, and more.

Are there any open-source tools available for Delphi for Python?

Delphi Community Edition and PythonFMXBuilder are open-source tools that offer an ideal solution for developers who prefer open-source tools whenever possible.

The post How To Create a Memory Game For Android With DelphiFMX Python Package first appeared on Python GUI.

If you are looking for Convolutional Neural Network algorithm, read our article about it here:

What is Deep Learning?

Deep learning is a subfield of machine learning that solves complex problems using artificial neural networks. These neural networks are made up of interconnected nodes arranged in multiple layers that extract features from input data. Large datasets are used to train these models, allowing them to detect patterns and correlations that humans would find difficult or impossible to detect.

Deep learning has had a significant impact on artificial intelligence. It has facilitated the development of intelligent systems capable of learning, adapting, and making decisions on their own. Deep learning has enabled remarkable progress in a variety of fields, including image and speech recognition, natural language processing, machine translation, autonomous driving, and many others.

7 reasons why Python is the perfect choice for Deep Learning

Python has grown in popularity as a programming language due to its versatility and ease of use in a wide range of computer science domains, particularly deep learning. Python has emerged as a top choice among many Machine Learning, Deep Learning, AI, and Data Science professionals due to its extensive range of libraries and frameworks specifically tailored for deep learning.

Here are seven reasons why Python is an excellent deep learning language:

1. Easy to learn

Python is a simple and easy-to-learn language, making it an excellent choice for beginners who want to learn deep learning.

2. Abundant libraries and frameworks

Python has a vast number of libraries and frameworks for deep learning, including TensorFlow, PyTorch, and Keras, which provide a lot of functionality and make it easy to build deep learning models.

3. Great community support

Python has a large and active community that provides excellent support, documentation, and resources for deep learning developers.

4. Versatile language

Python is a versatile language that can be used for a variety of tasks, including data science, automation, and web development.

5. Rapid prototyping

Python’s ease of use and simplicity make it easy to prototype deep learning models quickly.

6. Good visualization libraries

Python has excellent visualization libraries such as Matplotlib, which makes it easier to visualize data and results.

7. Cross-platform support

Python is a cross-platform language, which means that it can be used on multiple operating systems, including Windows, Mac, and Linux.

What is a Recurrent Neural Network (RNN)?

Quoting Reference [10]: “Recurrent neural networks have been an important focus of research and development during the 1990s. They are designed to learn sequential or time-varying patterns. A recurrent net is a neural network with feedback (closed loop) connections [5]. Examples include BAM, Hopfield, Boltzmann machine, and recurrent back propagation nets [8].

Recurrent neural network techniques have been applied to a wide variety of problems. Simple partially recurrent neural networks were introduced in the late 1980s by several researchers including Rumelhart, Hinton, and Williams [12] to learn strings of characters. Many other applications have addressed problems involving dynamical systems with time sequences of events.”

Below is how an unfolded RNN looks like:

The image below are the comparison between the scheme of 2 advanced RNN example (LSTM and GRU): 

Illustration of (a) LSTM and (b) gated recurrent units. (a) i, f and o are the input, forget and output gates, respectively. c and denote the memory cell and the new memory cell content. (b) r and z are the reset and update gates, and h and are the activation and the candidate activation. Image source: Reference [4].

Are there any advanced RNN architectures?

Long Short-Term Memory (LSTM): What is it, and how does it work?

Long Short-Term Memory (LSTM) is a type of recurrent neural network (RNN) that is designed to handle the issue of the vanishing gradient problem faced by traditional RNNs. LSTMs were first proposed by Hochreiter and Schmidhuber in 1997 and have since been used in a wide range of applications, including speech recognition, machine translation, and image captioning [9].

LSTM networks have a unique architecture that allows them to store and access information over long periods. They are built with memory cells that can retain information over time, and gates that control the flow of information into and out of the memory cells. The gates are made up of sigmoid activation functions that determine how much information is passed on to the next time step. The input gate controls how much new information is added to the memory cell, while the output gate determines how much information is output from the memory cell to the next time step. The forget gate is responsible for deciding which information to discard from the memory cell. LSTM networks are designed to learn which information to remember and which to forget, making them well-suited for tasks that require the retention of long-term dependencies.

Gated-Recurrent units (GRU): What are they, and how do they work?

Gated Recurrent Units (GRUs) are a type of recurrent neural network (RNN) architecture that was proposed by Cho, et al. in 2014 [4]. Like LSTMs, GRUs are designed to address the issue of the vanishing gradient problem in traditional RNNs. However, GRUs have a simpler architecture than LSTMs, which makes them faster and easier to train.

GRUs have two gates, a reset gate and an update gate, that control the flow of information in the network. The update gate decides how much of the previous hidden state should be retained, and how much new information should be added to the current hidden state. The reset gate determines how much of the previous hidden state should be forgotten and how much new information should be added to the current hidden state. The reset and update gates work together to allow the network to selectively remember or forget information over time, enabling it to handle long-term dependencies. GRUs have been used in a variety of applications, including machine translation, speech recognition, and image captioning, and have shown competitive performance compared to LSTMs while requiring fewer computational resources.

How do RNN work to forecast stock prices?

The diagram above depicts a simplified representation of recurrent neural networks. If we use simple data to forecast stock prices [46,55,49,45,60,…], each input from X0 to Xt will contain a past value. For example, X0 has 46 and X1 has 55, and these values are used to predict the next number in a sequence [1].

How do I build and train a Recurrent Neural Network from scratch?

Let’s get hands-on with some Python code to build and train your own RNN from scratch.

We will train the LSTM and GRU models to forecast the stock price using Kaggle’s MasterCard stock dataset from May 25th, 2006 to October 11th, 2021 (to download the dataset, see Reference [11]). This is a simple project-based tutorial where we will analyze data, preprocess the data to train it on advanced RNN models, and finally evaluate the results (source: Reference [1]).

Prerequisites for building and training RNNs with Python

The following are some of the prerequisites for performing RNNs with Python in this project:

1. Use pandas for data manipulation

Read more about it here:

2. NumPy is used for data manipulation in Python

Read more about it here:

3. matplotlib.pyplot for data visualization with Python

Read more about how to use Matplotlib with Python here:

4. scikit-learn for scaling and evaluation

The following article explains how to use scikit-learn in a Delphi app with Python.

5. TensorFlow for modeling

To find out about TensorFlow, which is very popular for AI with Python read the following article. We will also set seeds for reproducibility.

Demo video:

6. Keras for modeling

Keras is one of the de facto standards for Python and AI. 

Demo video:

7. Set seed for reproducibility

We will also set seeds for reproducibility.

Hands-on and selected outputs

The following is the code example for RNN:

# Import libraries.
## Data manipulation.
import numpy as np
import pandas as pd
## Data visualization.
import matplotlib.pyplot as plt
## Scaling & evaluation.
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error
## Modeling.
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM, Dropout, GRU, Bidirectional
from tensorflow.keras.optimizers import SGD
from tensorflow.random import set_seed
## Set seed.
set_seed(455)
np.random.seed(455)

# EDA (exploratory data analysis).
## Load data, handle datetime, & drop unnecessary columns.
dataset = pd.read_csv(
    "data/Mastercard_stock_history.csv", index_col="Date", parse_dates=["Date"]
).drop(["Dividends", "Stock Splits"], axis=1)
print(dataset.head())
## Descriptive statistics.
print(dataset.describe())
## Identify the missing values.
print(dataset.isna().sum())
## Split train-test set, and also plot it.
tstart = 2016
tend = 2020
def train_test_plot(dataset, tstart, tend):
    dataset.loc[f"{tstart}":f"{tend}", "High"].plot(figsize=(16, 4), legend=True)
    dataset.loc[f"{tend+1}":, "High"].plot(figsize=(16, 4), legend=True)
    plt.legend([f"Train (Before {tend+1})", f"Test ({tend+1} and beyond)"])
    plt.title("MasterCard stock price")
    plt.show()
train_test_plot(dataset, tstart, tend)

# Data preprocessing
## Really split the dataset into a train-test set this time.
def train_test_split(dataset, tstart, tend):
    train = dataset.loc[f"{tstart}":f"{tend}", "High"].values
    test = dataset.loc[f"{tend+1}":, "High"].values
    return train, test
training_set, test_set = train_test_split(dataset, tstart, tend)
## Standardize the data using MinMaxScaler, to avoid any outliers/anomalies.
sc = MinMaxScaler(feature_range=(0, 1))
training_set = training_set.reshape(-1, 1)
training_set_scaled = sc.fit_transform(training_set)
## Setup training steps (you can reduce or increase the number of steps to optimize model performance).
def split_sequence(sequence, n_steps):
    X, y = list(), list()
    for i in range(len(sequence)):
        end_ix = i + n_steps
        if end_ix > len(sequence) - 1:
            Break
        seq_x, seq_y = sequence[i:end_ix], sequence[end_ix]
        X.append(seq_x)
        y.append(seq_y)
    return np.array(X), np.array(y)
n_steps = 60
features = 1
## Split into samples.
X_train, y_train = split_sequence(training_set_scaled, n_steps)
## Reshaping X_train to fit on the LSTM model.
X_train = X_train.reshape(X_train.shape[0],X_train.shape[1],features)

# LSTM model.
## The LSTM architecture.
model_lstm = Sequential()
model_lstm.add(LSTM(units=125, activation="tanh", input_shape=(n_steps, features)))
model_lstm.add(Dense(units=1))
## Compiling the model.
model_lstm.compile(optimizer="RMSprop", loss="mse")
model_lstm.summary()
## Train model.
model_lstm.fit(X_train, y_train, epochs=50, batch_size=32)

# LSTM Results.
## Implement to the test dataset (repeat preprocessing, standardize, transform & split into samples, reshape, predict, and inverse transform the predictions into standard form).
dataset_total = dataset.loc[:,"High"]
inputs = dataset_total[len(dataset_total) - len(test_set) - n_steps :].values
inputs = inputs.reshape(-1, 1)
### Scaling.
inputs = sc.transform(inputs)
### Split into samples.
X_test, y_test = split_sequence(inputs, n_steps)
### Reshape.
X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], features)
### Prediction.
predicted_stock_price = model_lstm.predict(X_test)
### Inverse transform the values.
predicted_stock_price = sc.inverse_transform(predicted_stock_price)
## Plot real vs predicted line chart (visualize the difference between actual & predicted values).
def plot_predictions(test, predicted):
    plt.plot(test, color="gray", label="Real")
    plt.plot(predicted, color="red", label="Predicted")
    plt.title("MasterCard Stock Price Prediction")
    plt.xlabel("Time")
    plt.ylabel("MasterCard Stock Price")
    plt.legend()
    plt.show()
def return_rmse(test, predicted):
    rmse = np.sqrt(mean_squared_error(test, predicted))
    print("The root mean squared error is {:.2f}.".format(rmse))
plot_predictions(test_set,predicted_stock_price)
## Print out RMSE.
return_rmse(test_set,predicted_stock_price)

# GRU model.
## The GRU architecture.
model_gru = Sequential()
model_gru.add(GRU(units=125, activation="tanh", input_shape=(n_steps, features)))
model_gru.add(Dense(units=1))
## Compiling the model.
model_gru.compile(optimizer="RMSprop", loss="mse")
model_gru.summary()
## Train model.
model_gru.fit(X_train, y_train, epochs=50, batch_size=32)

# GRU Results.
GRU_predicted_stock_price = model_gru.predict(X_test)
GRU_predicted_stock_price = sc.inverse_transform(GRU_predicted_stock_price)
plot_predictions(test_set, GRU_predicted_stock_price)
## Print out RMSE.
return_rmse(test_set,GRU_predicted_stock_price)

Let’s run the above code using PyScripter IDE. The following are a selection of the outputs:

1. Descriptive statistics

The .describe() function allows us to thoroughly examine the data. Let’s concentrate on the High column because we’ll be using it to train the model. We can also choose Close or Open columns for a model feature, but High makes more sense because it tells us how high the share prices were on the given day.

2. Train-test split and visualize it

The train_test_plot function plots a simple line graph with three arguments: dataset, tstart, and tend. The tstart and tend are time limits expressed in years. We can modify these arguments to examine specific time periods. The line plot is split into two sections: train and test. This will allow us to decide how the test dataset will be distributed.

MasterCard’s stock price has been rising since 2016. It experienced a drop in the first quarter of 2020, but recovered to a stable position in the second half of the year. Our test dataset spans one year, from 2021 to 2022, with the remaining data used for training.

3. LSTM model summary

The model consists of a single hidden layer of LSTM and an output layer. You can play around with the number of units, as more units will produce better results. For this experiment, we will set LSTM units to 125, tanh as activation, and set input size.

We don’t have to create LSTM or GRU models from scratch because the TensorFlow library is user-friendly. To construct the model, we will simply use the LSTM or GRU modules.

Finally, we will compile the model with an RMSprop optimizer with mean square error (mse) as the loss function.

4. Train the LSTM model

The model will be trained using 50 epochs and 32 batch_sizes. You can adjust the hyperparameters to shorten the training time or improve the results. The model training was completed successfully with the lowest possible loss.

5. LSTM results

The plot_predictions function will generate a line chart comparing Real and Predicted values. This will enable us to see the difference between the actual and predicted values.The return_rmse function takes in test and predicted arguments and prints out the root mean square error (rmse) metric.

The single-layered LSTM model performed well, as shown by the line plot above.

6. LSTM RMSE

The results appear promising, with the model achieving 6.70 rmse on the test dataset.

7. GRU model summary

To properly compare the results, we’ll keep everything the same and simply replace the LSTM layer with the GRU layer. The model structure consists of a single GRU layer with 125 units and an output layer.

8. Train the GRU model

The model was trained successfully with 50 epochs and a batch_size of 32.

9. GRU results

As we can see, the Real and Predicted values are relatively close. The predicted line chart almost perfectly matches the actual values.

10. GRU RMSE

The GRU model achieved 5.50 rmse on the test dataset, outperforming the LSTM model.

Congratulations, now you have learned how to build and train a Recurrent Neural Network (RNN) from scratch, and successfully run it inside PyScripter IDE with high speed & performance.

Visit our other AI-related articles here:

Click here to get started with PyScripter, a free, feature-rich, and lightweight Python IDE.

Download RAD Studio to create more powerful Python GUI Windows Apps in 5x less time.

Check out Python4Delphi, which makes it simple to create Python GUIs for Windows using Delphi.

Also, look into DelphiVCL, which makes it simple to create Windows GUIs with Python.

References & further readings

[1] Awan, A. A. (2022).

Recurrent Neural Network Tutorial (RNN). DataCamp Blog. datacamp.com/tutorial/tutorial-for-recurrent-neural-network

[2] Biswal, A. (2023).

Top 10 Deep Learning Algorithms You Should Know in 2023. Simplilearn. simplilearn.com/tutorials/deep-learning-tutorial/deep-learning-algorithm

[3] ChatGPT, personal communication, May 14, 2023.

[4] Chung, J., Gulcehre, C., Cho, K., & Bengio, Y. (2014).

Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555.

[5] Fausett, L. (1994).

Fundamentals of neural networks. Prentice Hall, Englewood Cliffs, NJ, 7632.

[6] fdeloche. (2017).

A diagram for a one-unit Gated Recurrent Unit (GRU). Wikimedia. commons.wikimedia.org/wiki/ File:Gated_Recurrent_Unit.svg

[7] fdeloche. (2017).

A schema for LSTM neural network architecture. Wikimedia. commons.wikimedia.org/wiki/File:Long_Short-Term_Memory.svg

[8] Hecht-Nielsen, R. (1990).

Neurocomputing. Addison-Wesley, Reading, PA.

[9] Hochreiter, S., & Schmidhuber, J. (1997).

Long short-term memory. Neural computation, 9(8), 1735-1780.

[10] Medsker, L. R., & Jain, L. C. (2001).

Recurrent neural networks. Design and Applications, 5, 64-67.

[11] Rahman, K. (2023).

MasterCard Stock Data – Latest and Updated: MasterCard Stock Data – Downloaded using a Python Script and Yahoo! Finance API. Kaggle. kaggle.com/datasets/kalilurrahman/mastercard-stock-data-latest-and-updated

[12] Rumelhart, D. E., Hinton, G. E., and Williams, R. J. (1986).

Learning internal representations by error propagation, in Parallel Distributed Processing: Explorations in the Microstructure of Cognition. Rumelhart, D. E. and McClelland, J. L., Eds., MIT Press, Cambridge, 45.

The post Unlock the Power of Python for Deep Learning with Recurrent Neural Networks first appeared on Python GUI.

With the help of Python and the Delphi ecosystem, you can create an easy-to-use and interactive BMI app that anyone can use. In this post, we’ll provide a step-by-step guide to building a BMI app using Python GUI. So, let’s begin exploring the world of Python GUI programming!

Why is a BMI Calculator App Important?

A BMI calculator app is useful because it allows people to monitor and track their body mass index, which is an important indicator of their overall health and well-being.  

Such an app can be useful for individuals who want to maintain a healthy weight or for healthcare professionals who need to monitor their patients’ health. It can also detect potential health issues, such as obesity, leading to serious health problems like heart disease, diabetes, and stroke.

With the help of a BMI calculator app, users can easily track their BMI and get feedback on their progress toward achieving a healthy weight. Additionally, these apps often provide helpful tips on maintaining a healthy diet and lifestyle, making them an excellent tool for promoting healthy habits and overall wellness.

What Information do you Need to Calculate the BMI?

To calculate BMI (Body Mass Index), you need two pieces of information:

1. Weight: The weight of the person in kilograms (kg) or pounds (lbs).
2. Height: The height of the person in meters (m) or feet (ft) and inches (in).

Using these two pieces of information, you can calculate the BMI using the following formula:

BMI = Weight (kg) / Height² (m²)

Alternatively, you can use the following formula if you weigh pounds and height in inches:

BMI = (Weight (lbs) / Height² (in²)) x 703

Once you have calculated the BMI, you can use it to determine the weight status of the person based on the following categories:

• Underweight: BMI less than 18.5
• Normal weight: BMI between 18.5 and 24.9
• Overweight: BMI between 25 and 29.9
• Obese: BMI of 30 or higher

BMI is a useful tool for determining weight status but ignores things like muscle mass and body composition. Therefore, checking in with a healthcare professional for a more thorough health assessment is best.

What Kinds of Tools can be Useful in Building This App?

Delphi for Python is a powerful tool for developers who want to create cross-platform desktop applications using Python. With its comprehensive features, including powerful user interface (UI) design tools and cross-platform support, Delphi for Python can help developers create desktop applications that operate smoothly across multiple platforms. 

The Delphi FMX framework enables developers to build visually appealing and efficient GUIs that work seamlessly on Windows, macOS, iOS, and Android devices. The Delphi Community Edition is a free, open-source version of the Delphi IDE, and the PythonFMXBuilder is also available for developers who prefer to work with open-source tools. With Delphi for Python, developers can reduce the time and effort required to develop cross-platform desktop applications, ensure consistent and reliable operation across all platforms, and create robust and feature-rich applications.

How Can You Create A BMI Calculator for Android Using These Tools?

What Are the Software Requirements to Complete this Task?

Before we dive into creating a BMI app with Delphi Ecosystem and Python, there are a few things you will need to have installed on your machine:

1. Delphi IDE: You can download the community edition from the Embarcadero website for free.
2. Delphi4PythonExporter tool: You can install this plugin by searching for it in the Delphi CE environment.
3. Python: You can download the latest version of Python from the official website.
4. Python4Delphi and PythonFMXBuilder: This library allows you to call Python functions from Delphi code. You can download it from the Python4Delphi Github repository.
5. PyScripter or any other IDE that supports Python.

If you haven’t installed any of these tools, we recommend checking out the article “Powerful Python GUI Project Setup” to help you get started. In addition, you should have a basic understanding of Python and Delphi programming concepts to follow along with this tutorial.

Once you have all the required tools, you can proceed with the tutorial to create your BMI app using Delphi Ecosystem and Python.

You can grab the code for this tutorial from our GitHub repository using the following link:

https://github.com/Embarcadero/PythonBlogExamples/tree/main/BMI_Calculator_App

Let’s get started with creating our BMI Calculator App!

How to Create a Form in Delphi CE?

Let us start by opening Delphi CE and creating our first blank project. We will do this by clicking Create a new Project… under the Develop tab.

Next, select Multi-Device Application:

Finally, select Blank Application and click Ok.

For this tutorial, we have named our project as BMI_Calculator_App.

Let’s start by giving our form a name. To do this, right-click on the form and select QuickEdit. Here, we will name our form MainForm with the caption BMI Calculator.

If you need to become more familiar with the various sections of the Delphi IDE, we recommend referring to our free eBook bundle, which covers the Delphi Python EcoSystem and all Python GUI offerings.

Next, we need to resize our form. To do this, head to the object inspector and search for ClientHeight and ClientWidth. Here, we will set them to 500 and 360, respectively.

This form will serve as the main view of our application, where the user will be able to calculate their BMI. Therefore, let us add some components to this form to make it more functional. 

First, let’s add a few labels to make it look more like an app. To do this, head on over to the Palette and search for the TLabel Component. Then, drag and drop this component into the form.

Next, right-click on the label and go to QuickEdit. Here we will give the name Title, and caption of BMI Calculator App.

Now let’s modify the text style. Again, select the label and head to the Object Inspector. Next, search for TextSettings and click on the ... right next to the Font property to modify the label’s font, size, and style based on your preferences.

Now, center the text using the HorzAlign and VertAlign properties in TextSettings. So select the label component, and again, under the TextSettings select the HorzAlign and VertAlign properties and adjust the properties to Center.

Here is what our form looks like:

Similarly, let’s have a few more labels that will indicate the input fields for our app.

Note that we have also added another label Status in the form that is not visible as it does not have any text. We will use this to display error messages to the user.

Now, we need to add a button that will help our user calculate their BMI and send them to the next form. For this, we will be using a TButton component. So go to the Palette and add a button using the TButton component.

Next, we will modify this button to make it more appealing. But before that, we need to change the text on the Button. So right-click the button and, using QuickEdit, rename it to ResultsButton with the caption Results.

Next, select the button and head to TextSettings. Here we will change the font size to Segoe UI with a font size of 16 and change the size of the button.

Our MainForm is almost complete. Now, we just need to add two more components allowing the user to input their measurements. Head to the Palette and search for the TEdit Label. Again, we will use QuickEdit to give these components intuitive names. Here we are adding 3 TEdit components WeightEdit, HeightFeetEdit, and HeightInchEdit, that, as the name implies, allow our users to input their weight and height, respectively.

Finally, we must allow users to add their weight in either imperial or metric units. To do this, we will use a radio button. So again, head to the Palette and search for the TRadioButton component.

We will add two radio buttons to our form, giving them a name of PoundsRadio, and KgRadio. We will also modify their appearance using TextSettings.

Finally, let’s adjust the form’s background color by navigating to the Object Inspector and selecting the form’s fill property.

This completes our MainForm. Now let’s create a new form that will display our app. So right-click on BMI_Calculator_App.exe and select Add New > Multi-Device Form.

This will create a new form that will serve the result screen. Here we have named the form ResultsForm and its corresponding source file Results.pas. We also changed its dimension to match our MainForm.

Next, similarly to our MainForm let’s add color to our ResultsForm and add a few labels and buttons. This form will only be used to display the results to our users. Here is what our form looks like:

Finally, we add a DetailsLabel to display a custom message to our users based on their BMI.

How to Create a BMI App With Delphi Ecosystem And Python. App screen

Now that our forms are completed, we must ensure that the buttons remain functional when we export our application as a Python project. To do this, go to each form and double-click each button to add an OnClick method to that button. The procedure will be created in the .pas file corresponding to the .fmx form.

Next, add at least one comment (//) to each procedure. This will ensure the procedure is preserved when you export it as a Python file.

Can this Form be Easily Exported Into Python Code?

To export our project as Python scripts, we only need to select Tools > Export To Python > Export Current Entire Project.

Next, we name our project BMI Calculator, and select the main form as MainForm. Finally, select the directory of your choosing and click Export:

This will generate 3 Python scripts and 2 .pyfmx scripts in our specified directory. The BMI_Calculator_App.py is used to launch our Delphi app, while Results.py, and Main.py Python files contain the classes for the individual forms. Along with the Python file for each form, Delphi also generates a .pyfmx script of the same name as each form that contains the visual information of that form. Here are the contents of each file.

BMI_Calculator_App.py:

from delphifmx import *
from Main import MainForm

def main():
    Application.Initialize()
    Application.Title = 'BMI Calculator'
    Application.MainForm = MainForm(Application)
    Application.MainForm.Show()
    Application.Run()
    Application.MainForm.Destroy()

if __name__ == '__main__':
    main()

Main.py:

import os
from delphifmx import *

class MainForm(Form):

    def __init__(self, owner):
        self.WeightEdit = None
        self.HeightFeetEdit = None
        self.ResultsButton = None
        self.HeightLabel = None
        self.WeightLabel = None
        self.Title = None
        self.PoundsRadio = None
        self.KgRadio = None
        self.FeetLabel = None
        self.HeightInchEdit = None
        self.InchLabel = None
        self.Status = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

    def ResultsButtonClick(self, Sender):
        pass

Results.py:

import os
from delphifmx import *

class ResultsForm(Form):

    def __init__(self, owner):
        self.BMIScore = None
        self.Label1 = None
        self.DetailsLabel = None
        self.CategoryLabel = None
        self.Title = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Results.pyfmx"))

How to Add Functionality to this Application?

Now that our Python scripts are ready let’s start adding functionality to our code. Start by opening our MainForm in Main.py and navigating to the __init__ function.

In our __init__ function, we will only initialize a new variable self.BMI that will store the BMI of our individual. This will then be passed to the ResultsForm, where it will be displayed. Here is what our __init__ function looks like:

def __init__(self, owner):
        self.WeightEdit = None
        self.HeightFeetEdit = None
        self.ResultsButton = None
        self.HeightLabel = None
        self.WeightLabel = None
        self.Title = None
        self.PoundsRadio = None
        self.KgRadio = None
        self.FeetLabel = None
        self.HeightInchEdit = None
        self.InchLabel = None
        self.Status = None
        self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Main.pyfmx"))

        self.BMI = 0 # Initialize BMI that would be calculated and sent to next form

Next, let’s create a GetBMI function that uses the height and weight of our individual to calculate the BMI of our user:

def GetBMI(self, weight, heightft, heightin):
        # For BMI Calculation, Weight should be in kg and Height in meters
        if self.PoundsRadio.IsChecked:
            weight = weight / 2.205
        height = heightft * 0.3048 + heightin * 0.0254 # Conversion to meters
        return round(weight / (height**2), 2) # BMI = Weight/ (Height)^2

The BMI function checks whether the radio button for lbs is checked. If it is, it adds a conversion layer to convert the weight in pounds back into kilograms. It then uses the weight and height to generate a BMI based on our formula earlier and rounds it to 2 decimal places.

Now, let’s add functionality to our Results button. Head to the ResultsButtonClick function and start by checking whether the user has input in any fields. If the user does not have input in any fields, we use the Status label to display an error.

def ResultsButtonClick(self, Sender):
        # Error Handling
        if (self.PoundsRadio==False and self.KgRadio==False) or self.HeightFeetEdit.Text=="" or self.HeightInchEdit.Text=="" or self.WeightEdit.Text=="":
            self.Status.Text = "Please fill in all fields"

Next, we check whether the height input in inches is between 0 and 11:

elif int(self.HeightInchEdit.Text) < 0 or int(self.HeightInchEdit.Text) > 11:
            self.Status.Text = "Give inches between 0 and 11"

Finally, if there are no errors, we call the GetBMI function and send the BMI to our results form. First, we import the ResultsForm from the Results.py file: