What made this year’s Indaba so special was not just the high-level technical sessions, but the entire experience. From the inspiring keynotes to the sponsor showcases, from engaging poster sessions to hands-on workshops, every moment was an opportunity to learn, connect, and dream bigger. The cultural dinner and the beauty of Kigali added even more depth, making it a celebration of both knowledge and community.

As a kid, I was deeply intrigued by science and studied it for six years in high school, though I left that part of me behind when I moved into tech. Recently, being named a finalist for the Falling Walls Engage 2025 Science Engagement category in Germany rekindled that early passion. At Indaba, it all came full circle when I attended Max Welling’s keynote, “How AI Could Transform the Sciences.”

Max presented a powerful argument for #AI4Science, calling it the “fifth paradigm of scientific discovery.” He showed how AI is already proving math theorems, accelerating molecular simulations for drug discovery, and enabling breakthroughs in sustainable materials. It was a compelling reminder that AI is more than today’s applications; it is becoming a new superpower for scientists tackling humanity’s greatest challenges.

I attended several sponsor sessions and found them highly informative and inspiring:

Google Research Africa (GRA): I joined the session by Mohammed Elfatih MohamedKhair and Nasha Meoli, which focused on AI applications in disaster response, healthcare, and climate resilience. As a climate activist, I was intrigued by how GRA leverages AI to drive sustainable development and social good across Africa.

Through Indaba, I was accepted into the Google Career Launchpad + DeepMind AI Research Foundations program, and I am so excited about this opportunity.

Microsoft Research: I attended the talk by Muchai Mercy and Millicent Ochieng on equitable AI. The discussion on reducing biases in generative models and promoting representation across languages and cultures resonated strongly with me. It helped with my interest in applying AI for climate and social impact.

InstaDeep: Arnu Pretorius’ session on Geospatial Machine Learning for Good was extremely valuable. I learned about end-to-end deployment of AI solutions for climate challenges, responsible use of data, and actionable strategies for scaling projects across African contexts.

I was pained that I could not attend the Research In Africa Showcase on Tuesday because I fell sick. This showcase invites researchers to present substantial, original, and impactful work addressing Africa’s unique challenges.

For workshops, I attended the 3rd Workshop on Robotics and Automation in Africa, which aimed to advance robotics and machine learning research across the continent while exploring practical applications in agriculture, healthcare, energy, and manufacturing. I was fascinated by the projects, particularly Open Organic Robotics, where you simply write a prompt to build a robot; absolutely intriguing.

Another highlight for me was the tutorial by Arnu Pretorius, “Reinforcement Learning: The Intuition Behind Policy Gradients,” followed by the practical sessions. I recently discovered reinforcement learning and even worked on a project in it (see quick demo), so choosing RL over LLMs felt natural.

The tutorial was engaging and focused on intuition rather than heavy math. It clarified fundamentals of agents, environments, rewards, and policies, and I took extensive notes.

The RL practical, on the other hand, was eye-opening. The questions asked and discussions sparked were proof of how brilliant and curious Africans are. For the first time, I was introduced to JAX and discovered the animate method that helps visualize RL agents’ behaviors. For someone used to TensorFlow, PyTorch, and VS Code over Colab, this was a breakthrough moment.

Beyond the technical side, I was inspired by my fellow women winning awards left and right. As a strong intersectional feminist, I felt proud of my queens leading the way. I also saw my fellow Nigerians doing bold and innovative work like building Nollywood datasets and working on a reinforcement learning project with IoT. It reminded me of a female Nollywood producer’s call years ago to take action.

What if the best dataset design didn’t come from experts but from the people living the problem every day?

I participated in the Ideathon with my team, pitching Ikimera (AI-Powered Multimodal Crop Disease Detection and Precision Intervention System for Smallholder Farmers), an idea we worked on at the ALU-x-Meta-AI-Hackathon in 2024 as Team CAESA, where we came fifth with an overall score of 4.1/5.0 amongst nine teams. Launched in 2022, the Ideathon creates a unique platform where diverse pan-African teams collaborate across borders to develop groundbreaking ML projects. Congratulations to us; our improved idea has proceeded to the next stage 🎉.

🎉UPDATE: The Ikimera team, led by me, was awarded an Honourable Mention in the 2025 Deep Learning Indaba Ideathon (Applications Track).

Out of 54 submissions, 11 in research and 35 in applications, we were one of the 14 teams that advanced to the review stage to pitch our project and engage in discussions with the judges.

During the final stage, teams and judges were assigned to different rooms. Among the three teams in our room, the Ikimera team emerged as the sole winner, earning us the honourable mention.

The competition this year was exceptionally strong, and receiving this recognition is a significant achievement that my team is incredibly proud of. Watch our demo video here and learn more about all the 2025 Ideathon projects here.

My team decided to take things up a notch by getting legally registered in Rwanda. Now that our idea and solution have been officially validated by the Indaba Ideathon team as, in their words, “great idea and good problem space to be working in,” we lock in this coming year, 2026!

A special part of this Indaba was hosting delegates on a tour of my campus, the African Leadership University. That simple act sparked potential collaborations with the EU in Nigeria and even opened MB’s mind to applying to CMU-Africa for graduate school.

As Amal Nammouchi wrote in her blog post “Did you do your homework for the Deep Learning Indaba?” which I highly recommend as a pre-read for every future participant, “The Indaba isn’t just one conference. It’s more like ten conferences happening at once.” I felt so overwhelmed by the sheer number of things happening, but having a community changes everything. You go through the trials and tribulations together and have fun while at it 😅.

Some of the lessons I carry with me from this Indaba are simple but profound:

• Instead of being led by the methods you know, focus on solving a specific problem.
• Define clear, measurable goals and build your solution with those targets in mind.
• Understand the limitations of AI, and work within those realistic boundaries.
• Leverage AI as a powerful tool to create meaningful change.

What an extraordinary week it has been at the 7th edition of the Deep Learning Indaba! For six days, over 1,000 of us came together under the inspiring theme “Urunana (Hand in Hand) for AI in Africa.”

I leave this Indaba not only with new skills and ideas but also with new knowledge, new friendships, and renewed clarity about the future I want to build in AI. This was not just a conference; it was a community experience that reminded me of my roots, my passions, and the power of African voices shaping AI for the world. I look forward to the ripple effect of the inspiration I received in my work with the Climiradi Roberts Foundation.

To the organizers: I am deeply grateful for creating a space that combines technical learning, community engagement, and cultural celebration. I hope the Indaba continues to expand opportunities for interaction, mentorship, and hands-on projects, especially for first-time attendees and participants from underrepresented regions. I would be excited to contribute to future events in any way I can.

To the Indaba community: Being part of Africa’s largest gathering of AI minds was an honor. The brilliance, creativity, and passion of participants reminded me of the talent Africa has to offer. Stay curious, problem-driven, and collaborative, and continue building solutions that address real challenges in our communities.

PS: I think we can all agree that there’s a special glow that comes with attending Indaba; see for yourself :)

If you’ve attended Indaba before, don’t lose your spark, and if you will be attending for the first time, let’s meet at subsequent Indaba(s). Until then, keep building!

My Links: https://linktr.ee/climiradi

You are here because you still struggle with slow learning models, exploding gradients, or training instability. You see, a fast learning model is not just about having massive dataset; it is also about using clever optimisation techniques.

Think of it like this: training a deep learning model is like teaching a dog a new trick. You need patience, the right approach, and maybe a few treats along the way. Optimisation techniques act as “you- the coach” that refine these models, ensuring they learn efficiently from data.

You know, in my recent Water Potability project, I used an L2 Regularised Model with the SGD (Stochastic Gradient Descent) optimiser. Over time, the model learned to make better predictions, decreasing the loss and increasing the accuracy (as shown in the image above). This process is heavily influenced by the choice of optimisation technique.

In this post, we will demystify some of the most popular optimisation techniques used in deep learning. We will break down what they do, how they work, and when to use them. No complicated jargon, just plain English (and maybe a little bit of Python!).

Before we get started, let’s define our key word: Optimisation techniques.

What are Optimisation Techniques?

Optimisation techniques are like the secret sauce behind successful deep learning models. They are algorithms and methods used to adjust the parameters of a model (think of them as knobs and dials) to minimise the difference between the model’s predictions and the actual values (the error). By fine-tuning these parameters, the model gradually learns to make more accurate predictions. Optimisation techniques play a vital role in training deep learning models efficiently and effectively, enabling them to solve complex problems across various domains.

Imagine you are trying to sculpt a statue, and you start with a big block of marble. Optimisation techniques are like the different tools you use — the chisel, the hammer, the file — to gradually shape the marble into the desired form.

Common Optimisation Techniques

1. Feature Scaling or Normalisation: Getting Your Data in Shape

Imagine trying to build a house with bricks of all different sizes and shapes. It would be a nightmare, right? Feature scaling is like making sure all your bricks are the same size so your model can build a solid foundation.

Mechanics: Feature scaling involves transforming the range of your features (input variables). Two common methods are:

• Min-Max Scaling (Rescaling/Min-Max Normalisation): Scales values to a range between 0 and 1. Formula: x_scaled = (x - x_min) / (x_max - x_min)
• Standardisation (Z-score normalisation): Scales values to have a mean of 0 and a standard deviation of 1. Formula: x_scaled = (x - mean) / standard_deviation

Example:

import numpy as np
from sklearn.preprocessing import MinMaxScaler, StandardScaler

# Sample data
data = np.array([[1, 10], [2, 20], [3, 30]])

# Min-Max Scaling
scaler = MinMaxScaler()
scaled_data = scaler.fit_transform(data)
print("Min-Max Scaled Data:\n", scaled_data)

# Standard Scaler
scaler = StandardScaler()
scaled_data = scaler.fit_transform(data)
print("Standard Scaled Data:\n", scaled_data)

Other feature scaling techniques are Mean Normalisation, where values are centered around the mean and scaled between -1 and 1. Formula: x_p = (x - mean) / (x_max - x_min)

Another method is Unit Length Normalisation, which transforms feature values into unit vectors by dividing by their L2 norm (Euclidean distance) or L1 norm (sum of absolute values). Formula: x_p = x / ||x||_2 or x_p = x / ||x||_1

These methods are useful in cases where the magnitude of features matters, such as text classification and clustering algorithms.

Pros:

• Faster Convergence: Helps gradient descent converge faster.
• Improved Accuracy: Prevents features with larger values from dominating the learning process.
• Better for Algorithms Sensitive to Feature Scales: Essential for algorithms like Support Vector Machines (SVMs) and k-Nearest Neighbors (KNN).

Cons:

• Not Always Necessary: Algorithms like decision trees are not affected by feature scaling.
• Can Distort Data: Outliers can have a significant impact on the scaled range.

Note: Not all machine learning algorithms require Feature Scaling

2. Batch Normalisation: Keeping Things Stable

Batch normalisation is like adding a stabiliser to a shaky camera, it helps to keep the image clear and steady, even when things get a little bumpy. It helps to stabilise the learning process and allows you to use higher learning rates.

Mechanics:

• Batch normalisation standardises the output of each hidden layer by applying Z-score normalisation to the pre-activated output.
• Calculates the mean and variance of the output in the mini-batch.
• Instead of just applying standard normalisation (i.e., setting the mean to 0 and variance to 1), we introduce learnable parameters: gamma (scaling factor) and beta (shifting factor).
• This makes the process more flexible, allowing the network to scale and shift the normalised values as needed to retain useful patterns.

Formula: z_bn = gamma * z_norm + beta

where, z_norm is the normalised pre-activated output, gamma and beta are parameters learned during training

By doing this, batch normalisation helps to maintain the stability of the learning process and improves convergence speed, even with higher learning rates.

Pros:

• Higher Learning Rates: Allows for faster training and can be paired with other optimisation methods like SGD w/ momentum, RMSprop, and Adam.
• Deeper Networks with Shorter Training Time: Facilitates building deeper networks without increasing training time significantly.
• Stability with Large Batch Sizes: Maintains stability, especially when working with larger batch sizes.
• Reduced Internal Covariate Shift: Helps make the learning process more stable, improving the overall performance.
• Regularisation Effect: Adds regularising effects, potentially reducing the need for additional regularisation techniques like dropout, early stopping, or batch normalisation, because it already imposes a form of control on the model’s complexity, depending on the specific model and problem being addressed.

Regularisation techniques produce regularising effects like improved generalisation, reduced overfitting, stabilised learning process, and improved convergence speed.

Cons:

• Increased Complexity: Adds extra parameters to the model.
• Mini-Batch Dependency: Performance can be affected by small batch sizes.
• Not good for RNNs (Recurrent Neural Networks) / LSTMs (Long Short-Term Memory networks).
• Have to use a different calculation between training and testing.

3. Mini-Batch Gradient Descent or Stochastic Gradient Descent (SGD): Taking Smaller Steps

Imagine climbing a mountain, but instead of trying to leap to the summit in one go, you take lots of small, manageable steps. That is mini-batch gradient descent!

Mechanics:

• Splits the training data into smaller batches (mini-batches).
• Perform Back-propagation: Calculates the gradient of the loss function for each mini-batch. Completing back-prop on all mini-batches is an epoch. Some forms randomise the data at the beginning of each epoch.
• Updates the model’s parameters based on the average gradient across the mini-batch.

Pros:

• Faster Updates: This means speeding up gradient descent because the parameters are updated more frequently than in batch gradient descent, where updates only happen after processing the entire dataset. In mini-batch gradient descent, updates are made after each mini-batch, speeding up the convergence process.
• Less Memory Intensive: Requires less memory than batch gradient descent.
• Escapes Local Minima: The noise introduced by mini-batches can help the model escape local minima, giving it a more stable convergence.

Cons:

• Hyperparameter Tuning: Requires selecting an appropriate mini-batch size, which can be difficult to determine.
• Noisy Updates: Updates tend to be noisier compared to batch gradient descent, leading to more fluctuation in the learning process.
• Optimisation Challenges: Can struggle with saddle points, ravines, and local optima, making it harder to find the global minimum.

Saddle points, ravines, and local optima are types of regions in the loss landscape of a neural network: saddle points are where the gradient is zero but they are not minima (the surface curves up in some directions and down in others), ravines are steep, narrow areas that can slow down convergence due to large gradients in one direction and small gradients in another, and local optima are points where the loss function is lower than in neighbouring areas but not necessarily the lowest point overall (which is the global optimum).

4. SGD w/ Momentum: Speeding Things Up

Stochastic Gradient Descent (SGD) with Momentum is like a car accelerating downhill. Once it picks up speed, it keeps going faster, even if you briefly take your foot off the pedal. It helps the model converge more quickly by reducing oscillations and speeding up the learning process.

Mechanics:

Momentum builds on the idea of storing a running average of past gradients, allowing the model to keep moving in the same direction and avoid unnecessary back-and-forth adjustments.

Formula:

v_t = beta * v_t-1 + alpha * Grad(w)

w = w — v_t

Where: v_t​ is the velocity (momentum), beta is the momentum coefficient (usually between 0.8 and 0.99), alpha is the learning rate, and Grad(w) is the gradient of the loss with respect to the weights.

By using the previous gradients, the model gains momentum in directions with consistent gradients, leading to faster and more stable convergence.

Pros:

• Faster Convergence: Helps the model reach optimal weights more quickly.
• Reduces Oscillations: More stable learning, particularly in areas with high curvature like ravines and local optima.
• Smoother Updates: Helps escape shallow local minima by smoothing out updates.

Cons:

• Hyperparameter Sensitivity: Requires tuning the momentum and learning rate.
• Can Over-Accelerate: Too much momentum can cause the model to overshoot the minimum. One has to remember to scale down the learning rate by a factor of (1 — beta)

5. Gradient Descent with Momentum: Remembering the Past

Back to the mountain analogy — Imagine that as you are climbing that mountain, you remember the direction you were previously heading. That is momentum! It helps you to keep moving in the right direction and avoid getting stuck in small dips.

Mechanics:

• Adds a fraction of the previous update to the current update.
• Helps to accelerate gradient descent in the relevant direction and dampen oscillations.

Pros:

• Faster Convergence: Can converge faster than standard gradient descent.
• Reduces Oscillations: Dampens oscillations in the learning process.
• Escapes Local Minima: Can help the model escape local minima.

Cons:

• Additional Hyperparameter: Requires tuning the momentum parameter.

6. RMSProp Optimisation: Adapting to the Terrain

RMSProp is like having a smart hiking pole that adjusts to the terrain. If the slope is steep, it shortens your stride; if it is shallow, it lengthens it.

Divide the gradient by the square root of the moving (propagated) average (mean) of the square of the gradient

Formula:

s_t = beta * s_t-1 + (1-beta)square(Grad(w))

w_t = w_t-1—alpha * Grad(w) / sqrt(s_t)

Mechanics:

• Adapts the learning rate for each parameter based on the historical squared gradients.
• Divides the learning rate by the root mean square of the past gradients.

Pros:

• Handles Sparse Gradients and Faster Convergence: Well-suited for problems with sparse gradients, enabling faster convergence compared to standard gradient descent.
• Reduces Oscillations and Helps with Ravines/Saddle Points: Reduces oscillations in the learning process, making it easier to navigate challenging regions like ravines and saddle points.
• Allows Larger Learning Rates: The stability and faster convergence enable the use of larger learning rates without overshooting.

Cons:

• Hyperparameter Tuning: Requires tuning the learning rate and decay rate.

7. Adam Optimisation: The Best of Both Worlds

Adam is like having a combination of SGD w/ momentum and RMSProp, it is like the ultimate hiking companion!

Formula:

m_t = beta1 * m_t-1 + (1-beta1) * Grad(w); v_t = beta2 * v_t-1 + (1-beta2) * (Grad(W)^ 2)

m_tnorm = m_t / (1 — (beta1 ^ t)); v_tnorm = m_t/ 1-(beta2 ^ t))

w_t = w_t-1 — alpha * m_tnorm / sqrt(v_tnorm)

Mechanics:

• Combines the ideas of momentum and RMSProp.
• Calculates an exponentially decaying average of past gradients and squared gradients.
• Adapts the learning rate for each parameter based on these averages.

Pros:

• Fast Convergence: Often converges faster than other optimisation algorithms, especially in cases with sparse gradients and ravines.
• Adaptive Learning Rates: Adapts the learning rate for each parameter, making it efficient for problems with sparse gradients and online learning.
• Good at Navigating Ravines and Saddle Points: Particularly effective in avoiding local minima and accelerating optimisation in areas with complex landscape.

Cons:

• More Complex: More complex than other optimisation algorithms.
• Hyperparameter Tuning: Requires tuning multiple hyperparameters.

Note:

Adam does not always achieve the optimal results relative to other optimisation methods.

When using RMSprop or Adam optimisers, it is essential to include a small epsilon value in the denominator to prevent division by zero.

8. Learning Rate Decay: Slowing Down to Reach the Goal

Imagine that as you get closer to the summit of the mountain, you start taking smaller and smaller steps. That is learning rate decay! It helps you to fine-tune your position and avoid overshooting the peak.

Mechanics:

• Gradually reduces the learning rate as it approaches the optimum during training so that it does not overshoot
• Can be implemented using various schedules, such as step decay, exponential decay, or cosine annealing.

Learning Rate Decay Methods:

1. Exponential decay: lr = lr_0 * e^(-d * t)

The learning rate decreases exponentially over time, controlled by a decay factor d and time step t. This method allows for smooth decay as the training progresses.

2. Time-based decay: lr = lr_0 / (1 + d*t)

The learning rate decreases gradually over time. The rate of decay depends on the decay factor d and time step t, ensuring that the learning rate decreases over epochs but at a slower pace compared to exponential decay.

3. Step decay: lr = lr_0 * d^(epoch // epoch_drops)

The learning rate is reduced by a factor d after a fixed number of epochs (defined by epoch_drops). This creates a more sudden decrease in the learning rate at certain intervals.

Pros:

• Improved Convergence: Can help the model converge to a better solution.
• Fine-Tuning: Allows for fine-tuning the model’s parameters in the later stages of training.

Cons:

• Hyperparameter Tuning: Requires tuning the decay rate and schedule, which can be challenging due to the large number of hyperparameters.
• Difficult to determine when the learning rate should drop during training.
• Traditional methods lack adaptability, making them less efficient compared to adaptive learning rate optimisation methods like RMSprop and Adam.

Since I used L2 regularisation in my Water Potability project, you may be curious about what it does. Read about it in my previous blog post here.

So, there you have it! A tour of some common optimisation techniques. Remember, choosing the right optimisation technique depends on your specific problem and dataset and experimentation is key!

The more you understand them, the better equipped you will be to build powerful and accurate models. Even with the best tools, it takes practice to master the art of deep learning!

As Albert Einstein once said, “If you can’t explain it simply, you don’t understand it well enough.” I hope this post has helped simplify these concepts for you.

Let’s meet again in my next post to unravel another AI/ML mystery :)

One of the most effective ways to combat overfitting is by using regularisation techniques.

Think of regularisation as adding a little bit of “noise” or a constraint to your model’s learning process, preventing it from memorising the training data and forcing it to learn more generalisable patterns.

In this blog post, we will explore some popular regularisation techniques, breaking down the mechanics, pros, and cons of each. Let’s dive in!

Before jumping into the techniques, let’s solidify our understanding of overfitting. Imagine you are trying to fit a curve to some data points.

• What is Overfitting?

An overfit model is like drawing a super wiggly line that passes through every single data point, even the outliers (noisy data). While it perfectly matches the training data, it won’t generalise well to new, unseen data.

Regularisation helps us find a “sweet spot” — a curve that fits the data reasonably well without being overly complex.

Now, let’s meet the regularisation techniques.

1. L1 Regularisation (Lasso Regression)

L1 regularisation adds a penalty to the cost function of your model based on the absolute value of the coefficients (weights) of the features. The cost function is what the model is trying to minimise during training.

Mathematically, it looks like this:

Cost Function = Original Cost Function + λ * Σ |coefficients|

Where:

λ (lambda) is the regularisation parameter (a hyperparameter you need to tune). A larger λ means a stronger penalty.

Σ |coefficients| is the sum of the absolute values of all the model's coefficients.

Pros:

• Feature Selection: L1 regularisation can drive some coefficients to exactly zero. This effectively performs feature selection, as features with zero coefficients are removed from the model. This can lead to simpler, more interpretable models.
• Sparsity: L1 regularisation promotes sparsity in the model, meaning it encourages a model with fewer non-zero coefficients.

Cons:

• Non-Differentiable: The absolute value function is not differentiable at zero, which can cause some optimisation challenges.
• Can be unstable: In situations where features are highly correlated, L1 regularisation may arbitrarily select one feature over another.

Example:

Imagine you are building a model to predict house prices. You have features like square footage, number of bedrooms, location, and the color of the front door. L1 regularisation might identify that the color of the front door is not a significant predictor and set its coefficient to zero, effectively removing it from the model.

2. L2 Regularisation (Ridge Regression)

L2 regularisation is similar to L1, but instead of penalising the absolute value of the coefficients, it penalises the square of the coefficients.

Mathematically:

Cost Function = Original Cost Function + λ * Σ (coefficients)^2

Pros:

• Differentiable: The squared term is differentiable, making it easier to optimise.
• Reduces Overfitting: L2 regularisation shrinks the coefficients towards zero, preventing any single feature from dominating the model and reducing overfitting.

Cons:

• No Feature Selection: L2 regularisation doesn’t force coefficients to zero, so it doesn’t perform feature selection. All features are kept in the model, although their impact is reduced.
• Less Robust to Outliers: Because it squares the coefficients, L2 regularisation is more sensitive to outliers than L1 regularisation.

Example:

Again, consider predicting house prices. L2 regularisation will shrink the impact of all features (square footage, bedrooms, location, etc.) but won’t eliminate any of them completely. This prevents the model from relying too heavily on any single feature.

3. Dropout

Dropout is a regularisation technique specifically used in neural networks. During training, dropout randomly “drops out” (sets to zero) a certain percentage of neurons in a layer. This means these neurons are temporarily ignored during that training iteration.

Pros:

• Prevents Co-adaptation: Dropout prevents neurons from becoming overly reliant on each other. Each neuron is forced to learn more robust and independent features.
• Simple to Implement: Dropout is relatively easy to implement in most deep learning frameworks.

Cons:

• Increases Training Time: Because dropout effectively creates a different network for each training iteration, it can increase training time.
• Inference Time Adjustment: During inference (when you are using the trained model to make predictions), you need to adjust the activations of the neurons to account for the fact that dropout was used during training.

Example:

Imagine a neural network trying to recognise faces. Without dropout, some neurons might learn to only activate when they see a specific combination of features (e.g., a particular nose shape and eye spacing). Dropout forces other neurons to learn to recognise faces even when those specific features are missing, making the model more robust.

4. Data Augmentation

Data augmentation involves creating new training data by applying various transformations to the existing data. These transformations could include:

• Image Data: Rotations, flips, zooms, crops, color adjustments.
• Text Data: Synonym replacement, random insertion, deletion, or swapping of words.
• Audio Data: Adding noise, time stretching, pitch shifting.

Pros:

• Increases Dataset Size: Data augmentation artificially increases the size of your training dataset, which can significantly improve model performance, especially when you have limited data.
• Improves Generalisation: By exposing the model to variations of the training data, data augmentation helps it learn more robust and generalisable features.

Cons:

• Can Introduce Noise: If not done carefully, data augmentation can introduce unrealistic or irrelevant variations, which can hurt model performance.
• Requires Domain Knowledge: Choosing appropriate data augmentation techniques requires some understanding of the underlying data and the problem you’re trying to solve.

Example:

If you are training a model to recognise cats, you could augment your data by rotating the cat images, flipping them horizontally, zooming in, or changing the brightness. This helps the model learn to recognise cats in different poses, lighting conditions, and angles.

5. Early Stopping

Early stopping involves monitoring the performance of your model on a validation set during training. Training is stopped when the performance on the validation set starts to degrade (i.e., the validation loss starts to increase).

The validation set is a portion of your data that is not used for training but is used to evaluate the model’s performance

Pros:

• Simple and Effective: Early stopping is a very simple and effective way to prevent overfitting.
• Reduces Training Time: By stopping training early, you can save significant time and computational resources.

Cons:

• Requires a Validation Set: Early stopping requires you to split your data into training and validation sets, which reduces the amount of data available for training.
• Sensitivity to Validation Set: The performance of early stopping can be sensitive to the choice of the validation set.

Example:

You are training a neural network. After each epoch (a complete pass through the training data), you evaluate the model on the validation set. You notice that the validation loss is decreasing for the first 10 epochs, but then it starts to increase. Early stopping would stop the training at epoch 10, preventing the model from overfitting to the training data.

Regularisation is a crucial tool in machine learning. Knowing when to use L1 Regulariser (Lasso Regression) for feature selection, L2 Regulariser (Ridge Regression) for reducing overfitting, Dropout for deep learning, Data Augmentation for expanding datasets, and Early Stopping for efficient training can make or break your model’s performance.

Experiment with these techniques and find what works best for your specific problem. Happy modeling, and I will see you in the next post!

Come with me, as I share insights from my internship, detailing the projects I worked on and the valuable lessons learned along the way.

Project 1: Random Password Generator

The first project I tackled was developing a Random Password Generator. This command-line tool was designed to help users generate secure passwords based on specific criteria. It was a fantastic introduction to Python, allowing me to explore concepts like randomisation, user input validation, and character set handling.

Key Features:

• Random Password Generation: Creates passwords with a specified length and character set.
• Character Types: Includes options for uppercase and lowercase letters, numbers, and symbols.
• User Input Validation/Error Handling: Ensures valid input for password length and character types.

Learning Outcomes:

This project taught me the importance of secure coding practices and user input validation, both critical for creating reliable software applications.

• Mastery of Python’s random module for generating random characters.
• Developing robust input validation to ensure user inputs meet specific criteria.
• Enhancing user experience by incorporating error handling mechanisms.

Demo Video:

• YouTube | Click Here

Project 2: Voice Assistant — Asiri

Building Asiri, a semi-advanced voice assistant, was a really challenging yet rewarding experience. Asiri can respond to various voice commands, perform web searches, play YouTube videos, send emails, and provide interesting facts, making it a versatile assistant. This project was particularly exciting as it combined multiple functionalities and required integrating several Python libraries.

Key Features:

• Greeting Response: The assistant responds to greetings.
• Date and Time: Provides the current date and time.
• Web Search: Searches the web for information and reads out the results.
• YouTube Video Playback: Plays videos based on user commands.
• Email Sending: Sends emails as per user requests.
• Interesting Facts: Shares interesting facts with the user.

Learning Outcomes:

Working on Asiri enhanced my understanding of natural language processing and integrating various APIs to build a functional voice assistant.

• Implementing voice recognition and processing using Python.
• Integrating web scraping for information retrieval.
• Managing asynchronous tasks to handle multiple commands efficiently.

Demo Video:

• YouTube | Click Here

Project 3: BMI Calculator

The final project was the BMI Calculator, a command-line tool that calculates the Body Mass Index based on user inputs for weight and height. It helps the users to understand their BMI and its classification according to Wikipedia health standards.

Key Features:

• User-friendly Interface: Simple and intuitive command-line interactions.
• Input Validation: Ensures valid entries for weight and height.
• BMI Calculation: Accurately calculates BMI using the standard formula.
• Classification: Categorises BMI into health ranges (Underweight, Normal weight, Overweight, Obesity). It also sub-classify these categories into different classes like Severe Thinness, Class III Obesity, etc

Learning Outcomes:

This project reinforced the importance of user input validation and provided insights into developing health-related applications.

• Accurate implementation of mathematical formulas in Python.
• Enhancing user experience through clear prompts and feedback.
• Categorising and interpreting BMI results for health awareness.

Demo Video:

• YouTube | Click Here

Reflections and Future Directions

This internship has been an invaluable experience. It provided me with hands-on experience in Python development, enabling me to work on projects that are both functional and educational. Each project taught me something new, from secure coding practices to integrating APIs and validating user input.

As I look to the future, I am excited about the endless possibilities that Python offers. I am particularly interested in exploring more advanced topics like machine learning and artificial intelligence, where I can further integrate my love for technology with impactful real-world applications.

I am deeply grateful to Oasis Infobyte for this opportunity and for the supportive environment that fostered my growth. Thank you to my supervisor, Oreol Noumodong & friend, Emmanuel Obolo for their never-ending encouragement. This experience has reaffirmed my commitment to continuous learning and innovation in the field of technology.

Contact Information:

If you have any questions, feedback, or collaboration requests, please feel free to reach out to me at;

• Email: e.adewusi@alustudent.com
• Links: https://linktr.ee/climiradi
• Oasis Infobyte: http://oasisinfobyte.com/
• GitHub: https://github.com/eadewusic

Thank you for taking the time to read about my journey. Stay tuned for more updates and feel free to share your thoughts and experiences!

Before we dive in, let’s understand the keywords in the topic: Class, instance, and attribute.

• What is a Class?

Imagine a class as a blueprint or a set of instructions that helps us create specific types of objects. It’s like a recipe for baking cookies. The class defines the properties and behaviors (characteristics and actions) that all objects of that type will have. For example, if we have a class called “Car,” it will describe what a car should have, such as the number of wheels, color, and how it can drive.

• What is an Instance?

An instance is like a real cookie made from the recipe we have in the class. It is a specific, individual object created using the instructions provided by the class. For instance, if we have the “Car” class, an instance of that class would be a particular car with its unique properties, like a red car with four wheels.

• What is an Attribute?

An attribute is a characteristic or property of an object. It’s like an adjective that describes the object. For example, going back to our “Car” class, attributes could be the car’s color, the number of wheels it has, and its speed. Each car (instance) created from the “Car” class will have its own set of attribute values, which makes them unique.

In simple terms, think of a class as a blueprint for creating objects, an instance as a specific object created from that blueprint, and an attribute as a characteristic that tells us something about the object. Just like how a recipe guides us to make cookies (class), and each cookie made is a unique cookie (instance) with its own taste, shape, and size (attributes).

Refer to my last blog post here for other definitions.

What is a Class Attribute?

A class attribute is a property that belongs to the class itself rather than to its instances (objects). It is shared among all instances of the class and remains the same across all instances. Class attributes are defined within the class body but outside of any methods. They are accessed using the class name.

Example:

#!/usr/bin/python3
class Car:
    wheels = 4  # 'wheels' is a class attribute

car1 = Car()
car2 = Car()

print(car1.wheels)  # Output: 4
print(car2.wheels)  # Output: 4

What is an Instance Attribute?

An instance attribute, on the other hand, is unique to each instance of the class. It is defined inside the class’s methods and is initialised for each object created from the class. Instance attributes represent the specific characteristics or state of individual objects.

Example:

#!/usr/bin/python3
class Car:
    def __init__(self, color):
        self.color = color  # 'color' is an instance attribute

car1 = Car("red")
car2 = Car("blue")

print(car1.color)  # Output: "red"
print(car2.color)  # Output: "blue"

A class attribute is a property that belongs to the class itself and is shared among all instances of that class. It is defined within the class body and accessed using the class name. Class attributes are used to maintain values that remain the same for all objects created from the class.

An instance attribute is a property that is unique to each individual object (instance) created from the class. It is defined within the methods of the class and accessed using the self keyword. Instance attributes represent the specific characteristics or state of each object.

Creating Class and Instance Attributes:

There are several ways to create class and instance attributes in Python but we will discuss just one:

• Class Attributes: As shown earlier, class attributes are defined within the class body and outside any methods. They are usually initialised directly with a value.
• Instance Attributes: Instance attributes are created within the __init__ method of the class. They are unique to each object and are assigned values specific to that instance.

The Pythonic Way:

This is the most common and recommended approach that follows the conventions and best practices of the Python programming language.

The Pythonic way of creating class attributes is by defining them directly in the class body. For instance attributes, it is recommended to initialise them within the __init__ method using the self keyword.

Example:

#!/usr/bin/python3
class MyClass:
    class_attr = "I am a class attribute"
    
    def __init__(self, instance_attr):
        self.instance_attr = instance_attr

Differences between Class and Instance Attributes:

• Class attributes are shared among all instances, while instance attributes are unique to each object.
• Class attributes are defined at the class level and accessed using the class name, whereas instance attributes are defined within methods and accessed using the self keyword.

Advantages and Drawbacks:

1. Class Attributes:

Advantages:

• Efficient memory usage as the attribute is shared among all instances.
• Easy to update and maintain values that are consistent across instances.

Drawbacks:

• Lack of flexibility as the attribute’s value remains the same for all objects of the class.

2. Instance Attributes:

Advantages:

• Flexibility to have different values for each instance.
• Encapsulation, as instance attributes can have different access levels (public, private, etc.).

Drawbacks:

• Slightly higher memory usage when creating many instances.

Python’s dict and Attributes:

• What is __dict__?

__dict__ is a special attribute in Python that exists for every object, whether it's a class or an instance. It behaves like a dictionary and stores all the attributes and their corresponding values associated with that particular object.

You can say __dict__ is a dictionary containing the object’s attributes.

For instance attributes, __dict__ contains the names of the instance-specific attribute names and their values, while for class attributes, it stores the names of the class attributes and their values.

Example:

#!/usr/bin/python3
class MyClass:
    class_attr = "I am a class attribute"

    def __init__(self, instance_attr):
        self.instance_attr = instance_attr

obj1 = MyClass("Instance 1")
print(obj1.__dict__)
# Output: {'instance_attr': 'Instance 1'}

print(MyClass.__dict__)
# Output: {..., 'class_attr': 'I am a class attribute', ...}

Explanation of dict in simple terms:

Think of __dict__ as a magical drawer that holds a list of all the special features (attributes) of a thing (object). This drawer is available for every object you create, whether it's a blueprint (class) or a real thing made from the blueprint (instance). Inside the drawer, you can find the names of the features and their values. For example, if you have a "Car" blueprint, inside the drawer of each car you create (instances), you can find the attributes like color, number of wheels, and speed, along with their specific values.

The __dict__ attribute helps Python keep track of all the characteristics of an object, making it easy to access and update them when needed. It's like a handy organiser that makes sure your objects know everything about themselves, just like a car knows its own color and how fast it can go!

Access Flow to an Instance Attribute:

• An instance attribute is directly accessible as a public attribute of the instance. For example, car1.color in the earlier example.
• If an instance attribute is not found, Python looks for it in the class attributes. If present, it returns the class attribute value. However, this does not affect the actual instance attribute.

Impact of Updating Class Attributes:

When a class attribute is updated, the new value applies to all future instances created from that class, but it does not affect the existing instances.

Example:

#!/usr/bin/python3
class MyClass:
    class_attr = 10

obj1 = MyClass()
obj2 = MyClass()

print(obj1.class_attr)  # Output: 10
print(obj2.class_attr)  # Output: 10

MyClass.class_attr = 20

print(obj1.class_attr)  # Output: 20
print(obj2.class_attr)  # Output: 20

Cases to Use Class Attributes:

Class attributes are particularly useful in the following scenarios:

• Constants: Values that remain the same for all instances, such as mathematical constants, configuration values, etc.
• Default Values: Setting default values for attributes that are commonly used by instances.
• Tracking Values Between Instances: Maintaining values that need to be tracked across all instances of a class.

In Python, class attributes and instance attributes play different roles in defining the characteristics and behavior of objects.

Class attributes provide consistency across instances, while instance attributes allow customisation and encapsulation.

Understanding their distinctions and use cases is crucial to effective object-oriented programming.

Let’s meet again in my next post to unravel another Python mystery :)

Greetings from the Python world, inquisitive minds! It’s been an intense few weeks of learning about this programming language and running programs; therefore, I want to take you on a tour of what I have learned so far in studying the mysteries of Python programming.

Python is a versatile and powerful object-oriented language, which means you can define classes and create objects to build complex systems in a more structured and organised way. Everything in Python is an object and each object has its own unique properties and behavior. But before we dive in, we need to understand some basics;

• What is object-oriented programming?

Object-Oriented Programming is a programming style that revolves around the concept of objects. It allows developers to organise code by modelling real-world entities or abstract concepts as objects with specific behaviors. OOP promotes code reusability, making it easier to manage large projects and create modular and maintainable code.

Digest this sample about classes and objects before moving on;

Think of a class as a blueprint or slides presentation for constructing multiple objects called slides, and an object (each slide) as a single entity created from that blueprint.

• What is an object?

In Python, an object is a fundamental building block that represents a piece of data and the operations that can be performed on it. Everything in Python, like numbers or integers, strings, lists, and even functions, is an object. Each object has its own unique characteristics, like the data it holds, known as attributes, and the actions it can perform, known as methods.

• What is Class?

A class is like a blueprint or a template that defines how an object should look and behave. It specifies the attributes (data) the object will have and the methods (functions) it can use.

Remember our example about slide presentations? Let’s finish up;

Each of these slides is meant to do something, like passing on certain knowledge to the audience or viewer. That's it’s function, which is defined within the class as method. Each font, colour, image, and text used in each slide make up the quality of the information to be passed; thus, they can be referred to as fields or instance variables or attributes in Python.

In this blog post, we’ll explore the fundamentals of Python objects, their types, and the distinction between mutable and immutable objects. Understanding objects allows us to leverage their capabilities to create elegant and reusable code, and knowing these concepts is essential for writing efficient and bug-free Python code.

- ID and Type:

In Python, each object has a unique identifier (ID) that represents its memory address. The built-in function id() provides this identifier, enabling us to verify whether two variables point to the same object. The type() function, on the other hand, helps us identify the type of an object, such as int, str, list, tuple, etc.

#!/usr/bin/python3
# Example illustrating ID and Type
a = 10
b = a
print("ID of 'a':", id(a))
print("ID of 'b':", id(b))
print("Are 'a' and 'b' identical?", a is b)

# Output:
# ID of 'a': 140714611212128
# ID of 'b': 140714611212128
# Are 'a' and 'b' identical? True

print("Type of 'a':", type(a))
print("Type of 'b':", type(b))

# Output:
# Type of 'a': <class 'int'>
# Type of 'b': <class 'int'>

- Mutable vs. Immutable Objects:

• Mutable Objects:

Mutable objects are those that can be modified after creation. Lists, dictionaries, and sets are examples of mutable objects in Python. When we modify a mutable object, such as appending an element to a list, the object itself is changed, but its ID remains the same.

#!/usr/bin/python3
# Example illustrating Mutable Objects
lst1 = [1, 2, 3]
lst2 = lst1
lst2.append(4)
print("lst1:", lst1)
print("lst2:", lst2)
print("Are 'lst1' and 'lst2' identical?", lst1 is lst2)

# Output:
# lst1: [1, 2, 3, 4]
# lst2: [1, 2, 3, 4]
# Are 'lst1' and 'lst2' identical? True

• Immutable Objects:

Immutable objects, as the name suggests, cannot be altered after creation. Examples of immutable objects include integers, strings, and tuples. When we perform an operation on an immutable object, a new object is created with the updated value, preserving the original object’s integrity and the original object’s ID remains unchanged.

#!/usr/bin/python3
# Example illustrating Immutable Objects
x = 42
y = x
x += 10
print("x:", x)
print("y:", y)
print("Are 'x' and 'y' identical?", x is y)

# Output:
# x: 52
# y: 42
# Are 'x' and 'y' identical? False

• How an immutable object is stored in memory:

Immutable objects in Python are stored in memory with a fixed allocation of space during their creation. Each immutable object is given a unique memory address (ID) that remains constant throughout its lifetime, as its value cannot be modified. Since immutable objects cannot change their value after creation, they are hashable (meaning they can be used as dictionary keys or elements in sets) and can be safely shared across multiple threads.

Examples of immutable objects and how they are stored in memory using a simple memory schema representation:

• Immutable Object: Integer

#!/usr/bin/python3
# Example with an immutable object (integer)
x = 42

• Memory Schema Representation:

Memory Address: 0x1000
+------------------+
|       42         |
+------------------+
       ↑
       x

Explanation:

A memory block at address 0x1000 is allocated to store the integer value 42. The variable x points to the memory location 0x1000, representing the integer object.

• Immutable Object: String

#!/usr/bin/python3
# Example with an immutable object (string)
name = "John"

• Memory Schema Representation:

#!/usr/bin/python3
Memory Address: 0x2000
+------------------+
|   "John"         |
+------------------+
       ↑
      name

Explanation:

A memory block at address 0x2000 is allocated to store the string value "John". The variable name points to the memory location 0x2000, representing the string object.

• Differences between mutable and immutable objects:

• Why Does It Matter and How Python Treats Mutable and Immutable Objects Differently:

Understanding mutable and immutable objects is crucial for managing data and preventing unintended side effects. Python treats mutable and immutable objects differently due to their unique characteristics. Immutable objects are more memory-efficient since they don’t change, whereas mutable objects might require more memory as they grow. Additionally, mutable objects can lead to unexpected behavior when used as default arguments in functions, while immutable objects are safer in this context.

#!/usr/bin/python3
# Example illustrating the impact of mutable and immutable objects on function arguments
def modify_list(lst):
    lst.append(4)
    print("Inside the function:", lst)

my_list = [1, 2, 3]
print("Before function call:", my_list)
modify_list(my_list)
print("After function call:", my_list)

# Output:
# Before function call: [1, 2, 3]
# Inside the function: [1, 2, 3, 4]
# After function call: [1, 2, 3, 4]

• How Arguments are Passed to Functions and Implications for Mutable and Immutable Objects:

In Python, function arguments are passed using a reference mechanism. When passing immutable objects to functions, the function works with a copy of the object, leaving the original object unaffected. On the other hand, passing mutable objects to functions creates an alias, meaning any changes made within the function affect the original object outside of it.

#!/usr/bin/python3
# Example illustrating how function arguments behave with mutable and immutable objects
def modify_immutable(x):
    x += 10
    print("Inside the function:", x)

def modify_mutable(lst):
    lst.append(4)
    print("Inside the function:", lst)

a = 42
print("Before function call:", a)
modify_immutable(a)
print("After function call:", a)

# Output:
# Before function call: 42
# Inside the function: 52
# After function call: 42

my_list = [1, 2, 3]
print("Before function call:", my_list)
modify_mutable(my_list)
print("After function call:", my_list)

# Output:
# Before function call: [1, 2, 3]
# Inside the function: [1, 2, 3, 4]
# After function call: [1, 2, 3, 4]

• Special Case of Tuple and Frozen Set: Immutable Containers of Mutable Objects

In Python, a tuple is an ordered collection of elements, and a frozen set is an immutable version of a set. Both tuples and frozen sets are considered immutable data types because once created, their elements cannot be changed or modified.

However, there’s a special case with tuples and frozen sets when their elements are mutable objects. While the tuples and frozen sets themselves are immutable and their sizes cannot be changed, the mutable objects contained within them can still be modified.

For example, consider a tuple that contains a list:

#!/usr/bin/python3
my_tuple = ([1, 2, 3], "hello")

In this case, the tuple my_tuple contains a list [1, 2, 3] and a string "hello". The tuple itself cannot be changed or resized, but the list inside it can be modified because lists are mutable objects.

my_tuple[0].append(4)
print(my_tuple)  # Output: ([1, 2, 3, 4], 'hello')

As you can see, we modified the list within the tuple by appending the value 4 to it. The tuple remains unchanged, but the list it contains has been modified.

Similarly, the same applies to frozen sets. While a frozen set itself cannot be modified, if it contains mutable objects (like lists or other sets), those objects can still be modified.

my_frozen_set = (frozenset({1, 2}), [3, 4])

In this example, the frozen set my_frozen_set contains a frozen set {1, 2} and a list [3, 4]. The frozen set cannot be changed, but the list inside it can be modified.

my_frozen_set[1].append(5)
print(my_frozen_set)  # Output: (frozenset({1, 2}), [3, 4, 5])

Here, we modified the list within the frozen set by appending the value 5 to it.

This special case demonstrates that while tuples and frozen sets are generally considered immutable containers, the objects they contain can still be mutable and subject to modification.

It’s essential to be aware of this behavior when working with tuples and frozen sets containing mutable objects to avoid unintended changes and to design your code accordingly. If you need a fully immutable data structure, you should ensure that all elements within the container are themselves immutable.

- Differences between Assignment and Referencing:

Arguments:

• Assignment refers to the process of giving a value to a variable.
• When you assign a value to a variable, you are storing that value in a specific memory location associated with the variable’s name.
• In programming, the assignment operator (=) is used to perform assignment.
• After assigning a value to a variable, you can use that variable to access and manipulate the stored data.
• Reassigning a value to the same variable will overwrite the previous value in the memory location.

#!/usr/bin/python3
# Assignment
x = 10
y = "Hello"

Referencing:

• Referencing refers to creating a reference or pointer to an existing variable or object in memory.
• Instead of creating a new copy of the data, referencing allows multiple variables to point to the same memory location where the data is stored.
• When you reference a variable, any changes made to the data through one reference will be reflected in all other references to that memory location.
• Referencing is especially relevant when dealing with mutable objects like lists or dictionaries.

#!/usr/bin/python3
# Referencing
list1 = [1, 2, 3]
list2 = list1  # Both list1 and list2 now point to the same list object in memory
list2.append(4)
print(list1)  # Output: [1, 2, 3, 4] (changes made through list2 are reflected in list1)

• How variable values are managed when passed to a function in Python using assignment by reference:

When a variable is passed to a function in Python, the value of the variable is assigned to a new parameter inside the function. This assignment is done by reference, which means that the parameter inside the function becomes an alias or a reference to the original variable outside the function. Changes made to the parameter inside the function affect the original variable outside the function, as they both point to the same memory location.

Examples:

• Passing Immutable Objects to a Function (Assignment by Reference): When you pass an immutable object (e.g., an integer, string, or tuple) to a function, any changes made to the parameter inside the function do not affect the original variable outside the function.

#!/usr/bin/python3
def modify_immutable(x):
    x += 10
    print("Inside the function:", x)

a = 42
print("Before function call:", a)
modify_immutable(a)
print("After function call:", a)

# Output:
# Before function call: 42
# Inside the function: 52
# After function call: 42

Explanation:

The variable a is an integer (immutable) and is passed to the function modify_immutable. Inside the function, the parameter x is created and assigned the value of a. Any changes made to x inside the function (e.g., x += 10) do not affect the original variable a.

• Passing Mutable Objects to a Function (Assignment by Reference): When you pass a mutable object (e.g., a list or dictionary) to a function, changes made to the parameter inside the function affect the original variable outside the function.

#!/usr/bin/python3
def modify_mutable(lst):
    lst.append(4)
    print("Inside the function:", lst)

my_list = [1, 2, 3]
print("Before function call:", my_list)
modify_mutable(my_list)
print("After function call:", my_list)

# Output:
# Before function call: [1, 2, 3]
# Inside the function: [1, 2, 3, 4]
# After function call: [1, 2, 3, 4]

Explanation:

The variable my_list is a list (mutable) and is passed to the function modify_mutable. Inside the function, the parameter lst is created and assigned the reference to my_list. Any changes made to lst inside the function (e.g., lst.append(4)) also affect the original variable my_list.

— -

Python’s Integer Pre-allocation: NSMALLPOSINTS and NSMALLNEGINTS

CPython is the most commonly used implementation of Python, specifically for Python 3 which is the latest major version of the Python programming language. It is written in the C programming language, and it is a “Python interpreter.”

An interpreter is a program that reads and executes Python code line by line, converting it into machine-understandable instructions.

In CPython, the reference implementation of Python, there is a fascinating mechanism called “integer pre-allocation.” This involves creating and storing a fixed number of small integer objects during the Python interpreter’s startup.

CPython maintains two constants, NSMALLPOSINTS and NSMALLNEGINTS, representing the number of pre-allocated small positive and negative integer objects, respectively. As of CPython 3.9, both are set to 257, meaning that Python pre-allocates 257 small positive integers (ranging from 0 to 256) and 257 small negative integers (ranging from -1 to -257).

The primary purpose of this pre-allocation is to enhance Python’s performance and optimise memory usage. Small integers are frequently used in Python code for various tasks such as loop counters, arithmetic calculations, and list indexing. Instead of creating new integer objects every time these small values are used, Python reuses the pre-allocated small integer objects, which reduces memory overhead and speeds up operations.

By pre-allocating the first 257 small positive and negative integers, Python covers a range of commonly used small values, enabling efficient and speedy execution of integer-related operations.

For instance, when you assign the value 42 to two variables a and b, both variables reference the same pre-allocated integer object for the value 42. This intelligent memory management allows Python to avoid unnecessary object creation for frequently used small integer values, making it a more efficient programming language.

The specific value 257 for NSMALLPOSINTS and NSMALLNEGINTS is chosen based on practical considerations and performance optimisations. It strikes a balance between memory usage and covering a broad range of frequently used small integer values.

Let’s see demonstration of the pre-allocation behavior in Python:

#!/usr/bin/python3
a = 10
b = 10

print(a is b)  # Output: True

Explanation:

In this example, we assign the value 10 to variables a and b. Since 10 is within the range of pre-allocated integers (-5 to 256), both a and b reference the same pre-allocated integer object for the value 10. Therefore, a is b returns True, indicating that a and b point to the same memory location.

This intelligent memory management allows Python to avoid unnecessary object creation for frequently used small integer values, making it a more efficient programming language.

The specific value 257 for NSMALLPOSINTS and NSMALLNEGINTS is chosen based on practical considerations and performance optimisations. It strikes a balance between memory usage and covering a broad range of frequently used small integer values.

Note: It’s important to note that the constants NSMALLPOSINTS and NSMALLNEGINTS are specific to the CPython implementation and may not apply to other Python implementations.

— -

- Mechanism of aliases:

In Python, an alias refers to multiple variables that point to the same memory location, sharing the same underlying object. When you assign one variable to another or pass a variable to a function, you are creating an alias. Changes made through one alias are reflected in all other aliases that point to the same memory location.

Example 1: Creating Aliases

#!/usr/bin/python3
# Creating an alias
x = [1, 2, 3]
y = x

# Both x and y now reference the same list object in memory

Variables x and y here are aliases as they point to the same list object in memory. Changes made through one variable affect the other.

Example 2: Modifying Through Aliases

#!/usr/bin/python3
# Modifying through aliases
x = [1, 2, 3]
y = x

y.append(4)

print(x)  # Output: [1, 2, 3, 4] (changes made through y are reflected in x)

Here, we modify the list through the alias y, and the changes are reflected in the original list referenced by x.

Example 3: Function Arguments as Aliases

#!/usr/bin/python3
# Function arguments as aliases
def modify_list(lst):
    lst.append(4)

my_list = [1, 2, 3]
modify_list(my_list)

print(my_list)  # Output: [1, 2, 3, 4] (changes made inside the function affect the original list)

This example shows how function arguments can also act as aliases. When we pass my_list to the function modify_list, the parameter lst becomes an alias to the original list. Changes made to lst inside the function affect the original list my_list.

Congratulations! You made it to the end. With the knowledge you and I have gained from this project, we can confidently navigate the world of Python programming together, leveraging the strengths of mutable and immutable objects to design efficient and elegant solutions.

Ensure we meet again in my next post :)