They get that we’re not just managing APIs. We’re building complex systems, and increasingly, those systems involve AI. And as AI technologies race ahead Postman is right there to help you keep up.

I’ve been using Postman for years, and I was thrilled to be invited to POST/CON 2025 in Los Angeles. It was an amazing experience, and I want to share some of the highlights.

If you want the full rundown of the conference, you can check out the official recap here. I want to share my personal highlights and thoughts on the event.

Day 1: Full day workshop - “Mastering AI agent Automation with Postman Flows”

There I learned:

🔥 How easy it is to connect things together with flow

🔥 How to tie together AI agents into a seamless workflow and deploy it

🔥 Learn best practices for design

Then a fireside chat with Ryan Reynolds and Justine Davis that had almost nothing to do with code and everything to do with building great products that solve real problems, and taking care of people.

Day 2: Keynote and Sessions

Attended the Keynote where I learned about

🛠️ Postman VS code extensions

🛠️ GitHub Integration

🛠️ Postman Insights (lots of great analytics)

🛠️ AI Agent Builder

🛠️ Model Comparison Template

🛠️ MCP Server Generator (REALLY)

and so much more. You can get all the details here.

Sessions

I attended some amazing sessions, where I learned a ton about

🧠 Agent Orchestration using API-driven workflows

🧠 Building multi-agent experiences with Agent Builder

🧠 Automating API Testing in CI/CD pipelines with CircleCI and Postman

🧠 Composable API Ecosystems and the MCP Protocol

and tons of great lightning talks.

One of the best conferences I’ve attended

The energy at this conference was amazing. It’s one of the best I’ve attended. Postman is at the forefront of tech. They’ve created great tools to keep YOU ahead of the game. They focus on building their product well and help you create your best products, too.

I highly suggest going to the next POST/CON. If you do, let me know and let’s meet up!

Thank you so much to Postman for sending me to this conference. Now, if you’ll excuse me, I have some new tools to try out!

– Jeremy

I got lucky and got my hands on the newest, very affordable Jetson, the Jetson Orin Nano.

Today, we’ll dive into everything from unboxing this little gem to testing its performance with AI models. Ready to explore what makes this device so cool? Let’s get started!

If you’d rather see a video version of this review here it is.

What’s Inside the Box?

First impressions matter, and the Orin Nano’s packaging is as clean and straightforward as you’d expect. Here’s what you get:

• A robust power supply with both European and American plugs.

• A quick start manual (kinda)

• And, of course, the star of the show: the Jetson Orin Nano.

You do need to purchase an SD card for it, aas it’s not shipped with one.

The device is sleek, lightweight, and full of potential. It includes HDMI, USB, Ethernet, GPIO, and video input ports. Whether you’re making an AI robot or building computer vision stuff (I know I will), this device has you covered.

The Specs: Why It’s Called a “Raspberry Pi on Steroids”

Let’s talk hardware. Look at what’s packed into this small device:

• CPU: A six-core ARM Cortex 64-bit processor.

• GPU: NVIDIA Ampere architecture, tuned for AI workloads.

• RAM: 8 GB of high-speed memory.

• Connectivity: Ethernet and wireless ready.

• Storage Options: NVMe support for all your AI model needs.

Think of it as a supercharged Raspberry Pi with a serious focus on AI.

Setting It Up: The Good, The Tricky, and The Rewarding

Getting the Orin Nano up and running wasn’t exactly plug-and-play, but it wasn’t rocket science either. Here’s how it went down:

1. Firmware Update: Before diving in, I updated the firmware to version 36.x. This step required temporarily installing Jetpack 5.1.3. Then, you update the firmware from there. (Pro tip: don’t skip this. You want the new firmware and Jetpack)

2. Jetpack 6.1 Installation: After the firmware update, I installed Jetpack 6.1, NVIDIA’s tailored OS for the Jetson lineup. It’s smooth, intuitive, and optimized for AI tasks.

If you’re purchasing this devcie, then burning SD cards and flashing firmware shouldn’t be a problem.

Performance Tests: How Does It Handle AI Models?

Here’s where the fun begins—I tested the Orin Nano with AI models using Ollama, a platform designed for running large language models (LLMs).

Check out Ollama here

Here’s what I discovered:

• 1 Billion Parameter Models: Smooth sailing! These models ran effortlessly, perfect for tasks like chatbots or real-time applications.

• 3 Billion Parameter Models: Still impressive, though with slightly longer loading times.

• 7 Billion Parameter Models: Houston, we have a problem. The Orin Nano hit its limits here, occasionally freezing or locking up.

While it’s not designed for massive models, this performance is impressive for a device in this price range.

You can view the performance tests I did in this video.

Pros and Cons: The Real Deal

What I Loved:

1. Compact and Lightweight: Perfect for edge AI projects where space is a premium.

2. Impressive Performance: At $250, you’re getting serious bang for your buck.

3. Quiet Operation: Even under load, it’s quiet—a big plus for home projects.

4. User-Friendly OS: Jetpack is intuitive and packed with features.

What Needs Improvement:

1. Limits on Larger Models: It’s not a deal-breaker, but don’t expect it to handle anything beyond 7 billion parameters comfortably.

2. Occasional Glitches: Some random lockups and an odd “system throttled due to overcurrent” error. I’m looking into it. Manageable, but worth noting.

Final Verdict: Is It Worth It?

Absolutely. The NVIDIA Jetson Orin Nano is a fantastic choice for developers exploring AI at the edge or prototyping innovative solutions.

It’s not built for heavy-duty production workloads, but for $250, it’s hard to beat the value and potential.

What’s Next?

I’ll explore the Orin Nano’s features more in upcoming projects, so stay tuned. If you’re interested in edge AI or want to try out large language models, this device is a perfect start.

Have questions or suggestions for tests? Just drop a comment or message me on social media. Let’s see what this small device can really do!

Happy experimenting! 🚀

You can order the NVIDIA Jetson Orin Nano from the following places (Though right now there is no stock, check back!)

• Amazon

• Arrow Electronics

• Sparkfun

• Seeed Studio

Questions, comments? Want more details? Yell at me!!

Let’s make the game more fun with scoring and difficulty progression.

1. Adding a Score

Modify the create function to display a score:

this.score = 0;
this.scoreText = this.add.text(16, 16, 'Score: 0', { fontSize: '24px', fill: '#fff' });

Now you'll see a score in the upper left hand corner of the screen:

Let’s update the score when the player catches an item. In the update function where we created collision detection, add the following to update the score:

this.score += 10;
this.scoreText.setText('Score: ' + this.score);

So change this:

if (Phaser.Geom.Intersects.RectangleToRectangle(this.player.getBounds(), this.item.getBounds())) {
        console.log('Caught an item!');
        this.item.y = 50;
        this.item.x = Phaser.Math.Between(50, 750);
}

to this:

if (Phaser.Geom.Intersects.RectangleToRectangle(this.player.getBounds(), this.item.getBounds())) {
        console.log('Caught an item!');
        this.item.y = 50;
        this.item.x = Phaser.Math.Between(50, 750);
        this.score += 10;
        this.scoreText.setText('Score: ' + this.score);
}

And now every time you catch a block, the score updates:

2. Increasing Difficulty

Let's make this more difficult and make the items fall faster as the score increases:

In our create function, add this:

this.itemSpeed = 3;

in our update() function, delete this:

    // Move falling item
    this.item.y += 3;

And replace it with this:

  this.item.y += this.itemSpeed;

    if (this.score > 0 && this.score % 500 === 0) {
        this.itemSpeed += 0.5;
        console.log('Going faster! Speed is now: ' + this.itemSpeed);
    }

Now, every time you get 500 points, your speed increases, and it gets more difficult!

3. Retro Feel Enhancements

So let's add some graphics to this to make it more exciting.

I just drew up these images, don't judge me.

You can download the pail.png from here

in preload, add the following:

// Load the player sprite
this.load.image('player', 'pail.png');

Then remove this:

// Player (Blue rectangle)
this.player = this.add.rectangle(400, 550, 50, 50, 0x0000ff);

And replace it with this:

   // Replace rectangle with sprite
    this.player = this.add.sprite(400, 550, 'player');
    this.player.setScale(1); // Adjust this value if needed to match desired size

Let's turn the falling objects into apples.

You can download the apple.png from here

In preload(), add:

this.load.image('apple', 'apple.png');  // Loa

In create(), delete this:

    // Falling item (Green rectangle)
    this.item = this.add.rectangle(400, 50, 50, 50, 0x00ff00);

and replace it with this:

    // Apple sprite
    this.item = this.add.sprite(400, 50, 'apple');
    this.item.setScale(1); // Adjust scale if needed

And now you'll see a different look!

Now we see an apple and a pail, but it's in a dark room. Let's enhance our look by adding in a background.

You can download the background.png from here

In preload():

 this.load.image('background', 'background.png');  // Load background image

and in create():

    // Add background first so it appears behind other sprites
    this.add.image(400, 300, 'background');  // Position at center of game (800/2, 600/2)

And let's make the score black so we can see it:

this.scoreText = this.add.text(16, 16, 'Score: 0', { fontSize: '24px', fill: '#fff' });

Now save it and reload it:

Hey that looks awesome!

Final Thoughts

Congratulations! 🎉 You’ve built a working "Catch the Items" game using Phaser 3. Here’s a playable version of it as well.

Next Steps to try on your own:

• Customize the shapes with images or sprites.

• Add sound effects.

• Experiment with game parameters like speed and item spawn rates.

Keep practicing, and have fun creating your games. The possibilities are endless—go make something awesome! 🚀

Note: If you'd rather have a video tutorial, here it is:

Note: If you'd rather have a video tutorial, here it is:

The full source code is here. Here’s a playable version of the final game.

1. Adding Placeholder Graphics

Update the create function to add shapes representing the player and falling items:

function create() {
    // Player (Blue rectangle)
    this.player = this.add.rectangle(400, 550, 50, 50, 0x0000ff);

    // Falling item (Green rectangle)
    this.item = this.add.rectangle(400, 50, 50, 50, 0x00ff00);

    // Enable physics
    this.physics.add.existing(this.player);
    this.physics.add.existing(this.item);

    // Player controls
    this.cursors = this.input.keyboard.createCursorKeys();
}

2. Moving the Player Left and Right

Add movement logic to the update function:

function update() {
    // Move player left
    if (this.cursors.left.isDown) {
        this.player.x -= 5;
    }
    // Move player right
    else if (this.cursors.right.isDown) {
        this.player.x += 5;
    }
}

• The player can now move left and right using arrow keys!

3. Adding Simple Collision Logic

We need to update our config:

change:

   type: Phaser.AUTO, // Auto-detect WebGL or Canvas
   width: 800,        // Game width
   height: 600,       // Game height

To this, to add physics and gravity to our scene.

type: Phaser.AUTO,
            width: 800,
            height: 600,
            physics: {
                default: 'arcade',
                arcade: {
                    gravity: { y: 0 }
                }
            },

Make the falling item reset its position when it reaches the bottom:

function update() {
    // Move falling item
    this.item.y += 3;

    // Reset item position
    if (this.item.y > 600) {
        this.item.y = 50;
        this.item.x = Phaser.Math.Between(50, 750); // Random x-position
    }

    // Check for overlap
    if (Phaser.Geom.Intersects.RectangleToRectangle(this.player.getBounds(), this.item.getBounds())) {
        console.log('Caught an item!');
        this.item.y = 50;
        this.item.x = Phaser.Math.Between(50, 750);
    }
}

Now you'll see a screen that looks like this: and you should see green blocks falling. You can also move the player with your arrow keys:

📝 Recap: You added player movement, falling items, and basic collision detection. Your game is interactive! Now on to part 3

Note: If you'd rather have a video tutorial, it’s available here.

Note: If you'd rather have a video tutorial, here it is:

The full source code is here. Here’s a playable version of the final game.

Tutorial 1: Project Setup & Basics

Let’s start by setting up the environment, introducing key JavaScript concepts, and creating our first Phaser scene.

Note: In many of our tutorials we use Node/Vite to set up our games. But I want to keep this as simple as possible. To run this you can install the NPM package serve or just open the document with Chrome.

1. What is Phaser 3?

Phaser 3 is a popular 2D game development framework for creating browser-based games using JavaScript. It’s beginner-friendly, flexible, and powerful—perfect for making retro-inspired games like this one!

2. Setting Up Your Development Environment

To keep things simple, we’ll use Phaser via its CDN link. Here’s the setup:

1. Create a project folder:

   • Make a new folder on your computer, e.g., catch-game.

   • Inside the folder, create a file named index.html.

2. Add the basic HTML structure: Paste the following code into your index.html file:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Catch the Items</title>
    <script src="https://cdn.jsdelivr.net/npm/phaser@3.55.2/dist/phaser.js"></script>
</head>
<body>
    <script>
        // Phaser Game Configuration
        const config = {
            type: Phaser.AUTO, // Auto-detect WebGL or Canvas
            width: 800,        // Game width
            height: 600,       // Game height
            scene: {
                preload: preload,
                create: create,
                update: update
            }
        };

        const game = new Phaser.Game(config);

        function preload() {
            // Preload assets (none yet)
        }

        function create() {
            // Add game objects here
            this.add.text(300, 250, 'Hello, Phaser!', { fontSize: '32px', fill: '#fff' });
        }

        function update() {
            // Game loop (empty for now)
        }
    </script>
</body>
</html>

3. Run your game:

   • Open the index.html file in any browser (Chrome is recommended).

   • You should see a simple canvas with the text "Hello, Phaser!".

🎉 Congratulations! You’ve set up Phaser and displayed your first scene!

3. JavaScript Basics for Phaser

Before diving deeper, let’s quickly review some JavaScript concepts:

• Variables: Store data.

    let playerName = 'PhaserHero';
  

• Functions: Reusable blocks of code.

    function greetPlayer() {
        console.log('Welcome to the game!');
    }
    greetPlayer();
  

• Objects: Collections of properties and methods.

    let player = {
        name: 'Hero',
        score: 0,
        jump: function() {
            console.log('Player jumps!');
        }
    };
    player.jump();
  

You’ll use these concepts as you develop your game in Phaser.

4. Creating a Minimal Phaser Scene

Modify the create function to display a basic game canvas and some text:

function create() {
    this.add.text(300, 250, 'Catch the Items!', { fontSize: '32px', fill: '#fff' });
    this.add.rectangle(400, 300, 50, 50, 0xff0000); // Red square
}

• Reload the browser—you should see a red square in the center of the screen.

What does create() mean?

Phaser uses three core functions to manage the game lifecycle: preload, create, and update.

Let's break down what each function does:

• preload(): This function is called before the game starts. It's where you load your game assets like images, sounds, and more.

• create(): This function is called after the assets are loaded. It's where you create your game objects, set up the game world, and define initial game settings.

• update(): This function is called repeatedly throughout the game loop. It's where you update the game state, handle user input, and make things happen in your game world.

This diagram may not make sense now but it will as you get deeper into Phaser.

We'll be using these functions extensively as we build our games in this tutorial and future tutorials.

📝 Recap: You’ve set up a Phaser game, learned some JavaScript basics, and displayed simple shapes on the canvas. Great start! Now on to Part 2!

Why Python?

First off, why should you learn Python? Well, Python is one of the easiest programming languages to get started with. It’s used everywhere—web development, data science, automation, artificial intelligence, you name it! Whether you’re automating boring tasks or building the next big app, Python has your back.

But the best part? Python is super beginner-friendly. Its syntax (fancy word for how code is written) is clean and straightforward, so you can focus more on what you want to do rather than how to do it.

Pretty cool, right?

What Can You Build with Python?

• Websites (ever heard of Django or Flask?)

• Automation scripts (goodbye repetitive tasks!)

• Data analysis and machine learning models

• Games (even 2D ones like the classics!)

• IoT projects (you know, like controlling lights with a Raspberry Pi)

Okay, enough hype—let’s get started!

Step 1: Setting Up Python

Before we can write any Python code, we need to set up our environment. Don’t worry, this is easier than it sounds.

Install Python

First, you'll need to install Python if you don't have it already. Go to the official Python website python.org, download the latest version, and follow the instructions.

For Windows: During installation, make sure to check the box that says “Add Python to PATH.” This will let you run Python from anywhere on your system.

For macOS/Linux: Python usually comes pre-installed, but if you need the latest version, you can install it via a package manager like Homebrew (brew install python3).

If you want, you can also run Python in a Web Browser here.

Verify the Installation

Once installed, open a terminal (or Command Prompt on Windows) and type:

python --version

If you see something like Python 3.x.x, congratulations! Python is ready to roll.

Running Python Code

You can run Python code in two ways:

1. Interactive Mode: Just type python in your terminal, and you can start writing Python code line-by-line. This is great for quick tests.

   Demo idea: Try it out right now! Type python in your terminal and then type:

    print("Testing in interactive mode!")
   

   Hit enter, and you’ll see the result immediately. This is a fun way to experiment.

2. Script Mode: Write your Python code in a .py file (like hello.py), then run it by typing:

    python hello.py
   

Step 2: Your First Python Program

Alright, let’s write your very first Python program. We’re going to create the classic “Hello, World!” program.

Write Your Code

Open your favorite text editor (VSCode, Sublime, or even Notepad), and type the following:

print("Hello, World!")

Save the file as hello.py, then run it from the terminal:

python hello.py

Boom! You should see:

Hello, World!

🎉 Congrats, you just wrote your first Python program! 🎉

Make It Interactive (Optional Demo)

Want to take this a step further? Try prompting the user for input:

name = input("What's your name? ")
print("Nice to meet you, " + name + "!")

Save it as hello_interactive.py and run it. When prompted, type your name and see how Python responds! This little demo shows how Python can interact with users, making it feel more like a conversation and less like static code.

Step 3: Understanding the Basics

Let’s go over some fundamental concepts in Python. These are building blocks that we’ll use in the next parts of this series.

Variables

Think of variables as boxes where you can store information, like numbers or text.

# This is a variable storing a number
age = 30

# This is a variable storing a string (text)
name = "Alice"

You can use these variables later in your code:

print("My name is", name)
print("I am", age, "years old")

Data Types

Python has several data types you’ll use frequently:

• Integers: Whole numbers (e.g., 42)

• Floats: Decimal numbers (e.g., 3.14)

• Strings: Text (e.g., "Hello, World!")

• Booleans: True or False

You can even check the type of any variable with:

print(type(age))  # Outputs: <class 'int'>
print(type(name)) # Outputs: <class 'str'>

Comments

Sometimes you need to add notes to your code. Python ignores comments, so they’re just for you (or anyone else reading the code).

# This is a comment. Python won't run this.

Math Operations

Python can handle math like a calculator:

x = 10
y = 5

print(x + y)  # Addition
print(x - y)  # Subtraction
print(x * y)  # Multiplication
print(x / y)  # Division

Make a Simple Calculator (Demo)

Now that you know variables and math, let’s make a tiny calculator program:

num1 = int(input("Enter a number: "))
num2 = int(input("Enter another number: "))
print("Sum:", num1 + num2)
print("Product:", num1 * num2)

Run this, and you can quickly see Python doing something practical—performing math operations on the fly!

A Quick Variable Experiment

Try this short experiment to understand how strings can be combined:

message = "Hello"
message += ", World!"
print(message)

This shows you how variables can evolve as your program runs.

Step 4: Next Steps

Now that you've got Python set up and written your first program, you're ready to take the next step. In Part 2 of this series, we’ll explore conditions and loops, where Python will start making decisions for you and performing repetitive tasks. It’s going to be fun!

Practice Challenge

Before we wrap up, try writing a Python script that does the following:

• Stores your name in a variable.

• Prints a greeting like "Hello, [Your Name]!"

• Multiplies two numbers and prints the result.

Here’s a hint for the multiplication part:

result = 8 * 7
print(result)

Got it? Awesome! You’re on your way to becoming a Python pro. 🚀

See you in Part 2, where we’ll make Python even more powerful!

Happy coding!

Reminder: This is also available on LinkedIn if you’d rather receive it there.

AI in the News

Introducing ChatGPT Pro

OpenAI releases ChatGPT Pro, a subscription service with powerful new features

OpenAI has released a new subscription service called ChatGPT Pro. This service provides unlimited access to OpenAI’s most advanced models, including o1, o1-mini, GPT-4o, and Advanced Voice. It also includes o1 pro mode, which uses more compute to provide more reliable and accurate answers to difficult questions. ChatGPT Pro is designed for researchers, engineers, and other professionals who need to use AI for complex tasks.

Details:

ChatGPT Pro provides unlimited access to OpenAI’s most advanced models, including o1, o1-mini, GPT-4o, and Advanced Voice. It also includes o1 pro mode, which uses more compute to provide more reliable and accurate answers to difficult questions. ChatGPT Pro is designed for researchers, engineers, and other professionals who need to use AI for complex tasks.

Why it Matters:

ChatGPT Pro is a powerful new tool that can be used for a variety of tasks, including writing, research, and development. With its unlimited access to OpenAI’s most advanced models, ChatGPT Pro can help you to be more productive and creative.

Click here to read more

Make Movies with Text! This AI Writes Videos for You

OpenAI Unveils Sora, a Powerful New Video Generation Model

OpenAI has released a new AI model called Sora that can create realistic videos from just a text description. This means you can create movies, explainer videos, or even home videos using just your imagination and some text!

Details:

Sora can generate videos in a variety of styles, from photorealistic to cartoonish. It can also be used to create videos with special effects or to animate existing images.

Why it Matters:

Sora is a powerful new tool that could revolutionize the way videos are created. It could make it possible for anyone to create professional-quality videos, even if they don’t have any filmmaking experience.

Click here to read more

Unleash Your Creativity with Amazon Nova, the Powerful New AI

Generate Stunning Videos and Images, and More!

Do you ever feel limited by your imagination? Amazon Nova is here to help! This new generation of AI can be used to generate all sorts of creative content, from videos and images to who-knows-what-else. Amazon Nova is also being used to improve the customer shopping experience on Amazon. Keep reading to learn more about how Amazon Nova can help you!

Details:

• Amazon Nova is a new generation of foundation models that can be used to generate creative content.

• Amazon Nova is also being used to improve the customer shopping experience on Amazon.

Why it Matters:

Amazon Nova is a powerful new tool that can be used to generate creative content and improve the customer shopping experience. If you’re looking for a way to boost your creativity or make shopping on Amazon even easier, then Amazon Nova is definitely worth checking out.

Click here to read more

Google Releases Revolutionary AI Model, Gemini 2.0

Google unveils its latest AI model, Gemini 2.0, promising to revolutionize the field of AI agent creation. Gemini 2.0 boasts advanced capabilities that push the boundaries of what’s possible in AI. But with great power comes great responsibility, and Google emphasizes its commitment to developing AI responsibly, with safety and security at the forefront.

Details:

• Gemini 2.0 is more capable than previous versions, with native image and audio output and tool use.

• Gemini 2.0 Flash is available to developers and trusted testers, with wider availability planned for early next year.

• Google is exploring agentic experiences with Gemini 2.0, including Project Astra, Project Mariner, and Jules.

• Google is committed to building AI responsibly, with safety and security as key priorities.

Why it Matters:

Gemini 2.0 has the potential to revolutionize various fields by enabling the creation of powerful and intelligent AI agents. Google’s commitment to responsible AI development ensures these advancements are made with safety and security in mind.

Click here to read more

Apple’s New AI Can Turn Your Thoughts Into Emojis!

Tired of boring emojis? Apple Intelligence has just received a major upgrade, bringing you Image Playground and Genmoji to revolutionize the way you express yourself.

Image Playground lets you unleash your creativity and create unique images using your imagination. It’s like having a mini art studio right on your device!

Genmoji takes emojis to a whole new level. Generate custom emojis that perfectly capture your mood or personality.

Apple Intelligence is available now as a free software update, so you can start creating and expressing yourself in exciting new ways. But hurry, this update is only available for iPhone 16 and later, iPad with A17 Pro or M1 and later, and Mac with M1 and later!

Why it Matters:

Apple Intelligence’s new features offer a fun and creative way to express yourself through images and emojis. It’s a free update available for compatible devices, so there’s no reason not to try it out!

Click here to read more

Apple Secretly Developing AI Chip to Rival NVIDIA

Apple is reportedly working with Broadcom to develop its own AI chip, code-named Baltra, to power its AI services and reduce reliance on Nvidia. This move positions Apple alongside other tech giants like Google in the race to develop cutting-edge AI hardware.

Details:

• Apple is developing its first server chip specifically for AI processing.

• This move aims to reduce reliance on Nvidia’s high-priced and often unavailable processors.

• Baltra is expected to be ready for mass production by 2026.

• Apple and Broadcom have a history of collaboration, including a recent multi-billion-dollar deal for 5G components.

• This development highlights the growing importance of AI hardware and the increasing competition in the AI chip market.

Click here to read more

Talk to Santa AND See Him Live!s

OpenAI just dropped a major update for the holiday season! You can now chat with Santa Claus in real-time using video calls and screen sharing. This new “Advanced Voice Mode” feature allows you to:

• Ask Santa anything: Get advice on beard care, hear about life at the North Pole, or have him tell you a story!

• See Santa’s jolly face: Experience the magic of Christmas firsthand with live video chat.

• Get help with tricky responses: Brainstorm the perfect reply to a friend’s Christmas message using screen sharing.

• This feature is rolling out now:

Available on mobile apps first, then desktop apps and web. Free for everyone to chat with Santa on the first try, even if you’ve used your voice limit. Full access to video and screen sharing for Plus, Pro, and Teams users (Europe rollout coming soon). Enterprise and EDU plans get access early next year.

Click here to read more

Anthropic’s New AI Model: Is it Worth the Hype (and the Higher Price)?

Claude 3.5 Haiku is here, but does it live up to the promise?

Anthropic has released Claude 3.5 Haiku, a powerful new AI model that boasts improved coding, data analysis, and content moderation capabilities. However, this upgrade comes with a higher price tag, sparking debate among developers.

Details:

Claude 3.5 Haiku surpasses its predecessor, 3 Opus, in key areas, offering enhanced performance in coding, data extraction, and content moderation.

It can generate longer pieces of text and boasts a more up-to-date knowledge base. However, 3.5 Haiku lacks image analysis capabilities, limiting its versatility compared to other Anthropic models. The model’s release was initially met with controversy due to an unexpected price increase.

Click here to read more

AI Tools

Create Engaging Video Training Content in Minutes with Lupo

Lupo is a platform that helps businesses create high-quality video training content quickly and easily. With Lupo, you can use Markdown and Marp to create courses, and even leverage their agency services if needed.

Why you might need this tool:

• Create high-quality video training content quickly and easily

• Use Markdown and Marp to create courses

• Leverage their agency services if needed

Click here to read more

Want to Build AI Tools Like a Pro? This Low-Code Platform Makes it Easy (Even Without Coding Skills!)

AISmartCube is a low-code AI tool platform that allows users to build AI tools without any coding required. The platform provides access to global large models, various plugins, a shared knowledge base, and ready-to-use tools and assistants. It also offers flexible pricing with points and a free credit allowance.

Click here to read more

Want to run any program automatically?

Pinokio is a browser that lets you install, run, and programmatically control any application, automatically. You can use Pinokio scripts, which are shared by the community, to automate tasks or create new functionalities.

Why you might need this tool:

With Pinokio, you can:

• Automate repetitive tasks

• Create custom functionalities for your favorite applications

• Be more productive by letting Pinokio handle the boring stuff

Click here to read more

Build Stunning Websites in 3D, Without Code - Dora!

Dora is a no-code platform that allows you to create 3D animated websites. With Dora, you can create beautiful and engaging websites without having to write any code.

Why you might need this tool:

Create stunning and unique websites that will stand out from the competition. No coding required, so even those with no coding experience can create professional websites. Large community of users to help you learn and grow.

Click here to read more

Build Websites and Landing Pages in Minutes - No Coding Required!

Sitekick AI is an AI-powered tool that allows you to create landing pages and websites easily. It can generate text, images, and code for your website, so you don’t need any coding or design skills.

Why you might need this tool:

Easy to use: Sitekick AI does not require any coding or design skills, so it is perfect for people who do not have any experience with web development. Affordable: Sitekick AI is affordable, and it has a 30-day money-back guarantee, so you can try it out risk-free. Saves time: Sitekick AI can help you create websites and landing pages quickly and easily, so you can save time and focus on other important tasks.

Click here to read more

Learn about AI

Learn Anything Faster with the Power of AI

KodeKloud has recently released an AI tutor that can personalize the training for you, providing real-time feedback and guides to craft a custom learning sequence just for you. Each task is validated for accuracy and it supports multiple languages.

Personalized learning: The AI-powered learning suite tailors the learning experience to your individual needs and goals.

Real-time feedback: The AI Assistant provides real-time feedback on your progress, so you can identify and address any areas of difficulty.

Custom learning sequences: The AI Tutor creates a custom learning sequence for any tech topic you want to master.

Accuracy validation: Each task is validated for accuracy, so you can be sure that you are learning the correct information.

Multilingual support: The AI Assistant supports multiple languages, so you can learn in your preferred language.

Click here to read more

Build a Multimodal AI Agent with Gemini 2.0

In this tutorial, we’ll build a Multimodal AI Agent using Google’s Gemini 2.0 Flash model that can simultaneously analyze videos and conduct web searches. This powerful combination allows the agent to provide comprehensive responses by understanding both visual content and related web information.

Click here to read more

Learn AI Assisted Development

A course built by yours truly, you can learn AI-assisted programming, project planning, backend and frontend development, plus documentation using tools like ChatGPT, GitHub Copilot, BlackboxAI, Tabnine, and Cursor

Click here to read more

Thanks for reading!!

I started this newsletter to share all the cool stuff I’m finding in AI over time. Keep updated on the latest stuff with this newsletter. I’m glad you’re here.

Share this on your LinkedIn page if you think your friends might be interested in this stuff.

BTW Check out my YouTube Channel for more cool stuff with Generative AI. Tips, tutorials, reviews of AI tools and more.

Think of Python’s syntax like the grammar rules of a language. Just as English has rules about how to structure sentences to make meaning clear, Python has rules about how to write code so both humans and computers can understand it.

Understanding Python’s Basic Syntax

The Building Blocks

Let’s start with the simplest elements of Python syntax:

# This is a comment - Python ignores anything after the '#' symbol
student_name = "Alice"    # A variable holding text (string)
student_age = 15         # A variable holding a number (integer)
# Using variables in a sentence (string formatting)
print(f"Hello, my name is {student_name} and I'm {student_age} years old.")

In this example, we’re using several basic elements of Python:

• Comments (lines starting with #)

• Variables (student_name and student_age)

• String formatting (the f”…” syntax)

• The print function

Basic Operations

Python can perform calculations and comparisons just like a calculator:

# Basic math operations
total_score = 95 + 87    # Addition
average = total_score / 2 # Division
# Comparisons
if student_age >= 15:
    print(f"{student_name} can take advanced classes")

The Heart of Python: Understanding Indentation

Here’s where Python gets truly unique: instead of using brackets or special symbols to group code together, Python uses indentation. This might seem strange at first, but it makes Python code exceptionally clear and readable.

How Indentation Creates Structure

Think of indentation like the way you might organize a detailed outline:

def make_sandwich():
    print("1. Get two slices of bread")  # First level
    if has_cheese:
        print("2. Add cheese")           # Second level
        print("3. Add tomatoes")         # Still second level
    else:
        print("2. Add butter")           # Second level in else block
    print("4. Put the slices together")  # Back to first level

Each indented block tells Python “these lines belong together.” It’s like creating a sub-list in an outline — everything indented under “if has_cheese:” is part of that condition.

The Rules of Indentation

Let’s look at the key rules for Python indentation:

def process_grade(score):
    # Rule 1: Use exactly 4 spaces for each indentation level
    if score >= 90:
        print("Excellent!")
        if score == 100:
            print("Perfect score!")
# Rule 2: Aligned blocks work together
    elif score >= 80:
        print("Good job!")
        print("Keep it up!")  # This line is part of the elif block
    # Rule 3: Unindented lines end the block
    print("Processing complete")  # This runs regardless of score

Nested Indentation: Going Deeper

As your programs get more complex, you’ll often need multiple levels of indentation:

def check_weather(temperature, is_raining):
    # First level: inside function
    if temperature > 70:
        # Second level: inside if
        if is_raining:
            # Third level: nested condition
            print("It's warm but raining")
            print("Take an umbrella")
        else:
            print("It's a warm, sunny day")
            print("Perfect for outdoors")
    else:
        print("It's cool outside")
        print("Take a jacket")

Complex Structures and Indentation

Let’s look at a more complex example that shows how indentation helps organize code:

def process_student_grades(students):
    for student in students:            # First level loop
        print(f"Checking {student['name']}'s grades...")
total = 0
        for grade in student['grades']: # Second level loop
            if grade > 90:              # Third level condition
                print("Outstanding!")
            total += grade
        average = total / len(student['grades'])
        # Back to first loop level
        if average >= 90:
            print("Honor Roll")
            if student['attendance'] > 95:  # Another level
                print("Perfect Attendance Award")

Common Patterns and Best Practices

Handling Multiple Conditions

# Good: Clear and easy to follow
def check_eligibility(age, grade, attendance):
    if age < 18:
        return "Too young"
if grade < 70:
        return "Grades too low"
    if attendance < 80:
        return "Attendance too low"
    return "Eligible"
# Avoid: Too many nested levels
def check_eligibility_nested(age, grade, attendance):
    if age >= 18:
        if grade >= 70:
            if attendance >= 80:
                return "Eligible"
            else:
                return "Attendance too low"
        else:
            return "Grades too low"
    else:
        return "Too young"

Working with Functions and Classes

class Student:
    def __init__(self, name):
        self.name = name
        self.grades = []
def add_grade(self, grade):
        # Notice the consistent indentation in methods
        if isinstance(grade, (int, float)):
            if 0 <= grade <= 100:
                self.grades.append(grade)
                print(f"Grade {grade} added")
            else:
                print("Grade must be between 0 and 100")
        else:
            print("Grade must be a number")

Common Mistakes and How to Fix Them

Indentation Errors

# WRONG - Inconsistent indentation
if score > 90:
print("Great job!")    # Error: no indentation
    print("Keep it up!")   # Error: inconsistent indentation
# RIGHT - Proper indentation
if score > 90:
    print("Great job!")
    print("Keep it up!")

Mixing Tabs and Spaces

# WRONG - Mixed tabs and spaces (don't do this!)
def calculate_average(numbers):
    total = 0
    count = 0    # This line uses a tab
    for num in numbers:    # This line uses spaces
        total += num

Practice Exercise: Putting It All Together

Try writing this program to practice indentation and syntax:

def grade_assignment(score, late_days):
    # Start with the base score
    final_score = score
# Check if the assignment is late
    if late_days > 0:
        if late_days <= 5:
            # Deduct 2 points per late day
            final_score -= (late_days * 2)
        else:
            # Maximum lateness penalty
            final_score -= 10
    # Ensure score doesn't go below 0
    if final_score < 0:
        final_score = 0
    # Determine letter grade
    if final_score >= 90:
        return "A", final_score
    elif final_score >= 80:
        return "B", final_score
    elif final_score >= 70:
        return "C", final_score
    else:
        return "F", final_score
# Test the function
score = 95
late_days = 2
letter_grade, final_score = grade_assignment(score, late_days)
print(f"Original Score: {score}")
print(f"Late Days: {late_days}")
print(f"Final Score: {final_score}")
print(f"Letter Grade: {letter_grade}")

Key Takeaways

1. Python uses indentation to understand code structure

2. Always use 4 spaces for each level of indentation

3. Be consistent with your indentation throughout your code

4. Simpler, flatter code structure is usually better than deeply nested code

5. Proper indentation makes code more readable and helps prevent errors

Next Steps

Now that you understand Python’s basic syntax and indentation:

• Practice writing simple programs focusing on proper indentation

• Learn about different data types (strings, numbers, lists)

• Explore functions and classes

• Study loops and control structures

• Start working with Python modules and libraries

Remember: Good indentation habits form the foundation of becoming a skilled Python programmer. Take your time to master these concepts, and the rest will follow naturally!

Why This Matters

First things first—why should we care about syntax and variables in Python? Here’s the deal:

• Readability: Python’s clean, intuitive syntax means less time decoding code and more time solving problems.

• Efficiency: Proper use of variables keeps your code efficient and streamlined.

• Debugging: A solid grasp of syntax helps you pinpoint errors faster than a debugger.

• Scalability: Writing clear, organized code ensures that your projects can grow without turning into a tangled mess.

Convinced? Great. Let’s start with the basics.

Python Syntax Basics

Indentation: Python’s Secret Sauce

In Python, indentation isn’t just for looks—it’s how you define blocks of code. Forget braces ({}) and semicolons—just align your code with consistent spacing.

Here’s an example:

if True:
    print("Hello, Python!")

That’s it. The print statement is indented to show it belongs to the if block. Forget to indent, or mix spaces and tabs, and Python will call you out with a syntax error.

Comments: Talk to Your Future Self

Comments in your code are lifesavers when you revisit it months (or years) later. Python supports:

• Single-line comments: Start with #.

• Multi-line comments: Enclose with triple quotes (''' or """).

Here’s how:

# Single-line comment
"""
Multi-line comment
spanning several lines.
"""

Python is Case-Sensitive

Python distinguishes between Variable, variable, and VARIABLE. Keep this in mind to avoid pesky bugs.

Variables in Python

What Are Variables?

Think of variables as labeled storage containers for your data. Python is dynamically typed, so you don’t need to declare types upfront. Here’s a quick example:

x = 10  # Integer
y = 3.14  # Float
z = "Hello, World!"  # String

Naming Variables

To keep your code clean and readable, follow these rules:

• Rules:

  • Start with a letter or underscore, not a number.

  • Use only letters, numbers, and underscores—no spaces or special characters.

  • Avoid Python keywords like if, class, or def.

• Conventions:

  • Use snake_case (e.g., user_name).

  • Choose meaningful names—score is better than s.

Assigning Values

Assigning values is as simple as:

a, b, c = 1, 2, 3  # Multiple assignments

Common Python Data Types

Here’s a rundown of Python’s built-in data types:

• Numeric:

  • int: Whole numbers (e.g., 42)

  • float: Decimal numbers (e.g., 3.14)

• Strings: Enclosed in single, double, or triple quotes:

    greeting = "Hello, Python!"
  

• Booleans: True or False

    is_active = True
  

• Lists: Ordered, mutable collections:

    fruits = ["apple", "banana", "cherry"]
  

• Dictionaries: Key-value pairs:

    person = {"name": "Alice", "age": 25}
  

Performing Operations with Variables

Arithmetic

Python handles math like a champ:

x = 10
y = 3

print(x + y)  # Addition
print(x - y)  # Subtraction
print(x * y)  # Multiplication
print(x / y)  # Division

Strings

You can concatenate or repeat strings easily:

name = "Alice"
print(name + " Smith")  # Alice Smith
print(name * 3)  # AliceAliceAlice

Logical Operations

Logical operators (and, or, not) are super handy:

x = True
y = False

print(x and y)  # False
print(x or y)  # True
print(not x)  # False

Best Practices

Write clean, efficient Python by following these tips:

• Descriptive Names: Use meaningful variable names.

• DRY Principle: Don’t Repeat Yourself—reuse your code.

• Follow PEP 8: Stick to Python’s style guide.

• Comment Smartly: Explain why, not what.

• Avoid Globals: Keep variables local to their functions when possible.

Common Pitfalls (And How to Avoid Them)

1. Indentation Errors: Stick to spaces or tabs (not both), and use four spaces per level.

2. Scope Issues: Know the difference between local and global variables.

3. Type Mismatches: Python doesn’t mix types:

    x = "5"
    y = 10
    print(x + y)  # TypeError
   

FAQ

Q: What’s the difference between variables and constants?

Variables can change; constants stay fixed. Use all caps to indicate constants (e.g., PI = 3.14).

Q: How can I check a variable’s type?

Use type():

x = 10
print(type(x))  # <class 'int'>

Q: Can I change a variable’s type?

Sure can! Python allows dynamic typing:

x = 10
x = "Now a string"

Wrapping Up

Mastering Python syntax and variables is your gateway to writing cleaner, more effective code. With practice, these basics will become second nature. In our next article, we’ll dive into conditional statements (if/else) and explore how they can help you write more dynamic and responsive code.

Whether you are a beginner or an experienced developer, you'll be up and running in no time. This is a great way to evaluate different open-source models or create a sandbox to write AI applications on your own machine.

We'll go from easy to use to a solution that requires programming.

Products we're using:

1. LM Studio: User-Friendly AI for Everyone

2. Ollama: Efficient and Developer-Friendly

3. Hugging Face Transformers: Advanced Model Access

If you'd rather watch a video of this tutorial, here it is:

1. LM Studio: User-Friendly AI for Everyone

LM Studio is an excellent starting point for both beginners and experts. It provides an intuitive interface for exploring and using various AI models.

Getting Started with LM Studio

1. Visit lmstudio.ai and download the appropriate version for your Mac.

2. Install LM Studio by dragging the downloaded file into your Applications folder.

3. Launch LM Studio and accept any security prompts.

Exploring Models

1. In the main interface, click "Load a model" or select a model from the "New and Noteworthy" list.

2. we'll use the "llama2 3B" model for this tutorial. Click on it to download.

3. Once downloaded, click "Load model" to activate it.

Using the Chat Interface

1. With the model loaded, you can start interacting with it in the chat interface.

2. Try asking a question like "Tell me a funny joke about Python."

3. Observe the model's response and the performance metrics (tokens per second, context usage).

Utilizing the API Server

LM Studio also provides an OpenAI-compatible API server, making it easy to integrate with your applications:

1. Click on the server icon in the left sidebar.

2. Start the server by clicking the "Start Server" button. [6]

3. Copy the provided server address (usually http://localhost:1234).

You can see a set of endpoints available:

GET http://localhost:1234/v1/models
POST http://localhost:1234/v1/chat/completions
POST http://localhost:1234/v1/completions
POST http://localhost:1234/v1/embeddings

You can now use this address to send requests to the model using tools like Postman or your own code. Here's an example using Postman:

1. Create a new POST request to http://localhost:1234/v1/chat/completions.

2. Set the body to raw JSON with the following content:

{
        "model": "lmstudio-community/Qwen2.5-14B-Instruct-GGUF/Qwen2.5-14B-Instruct-Q4_K_M.gguf",
        "messages": [
            {
                "role": "system",
                "content": "You are a helpful jokester who knows a lot about Python"
            },
            {
                "role": "user",
                "content": "Tell me a funny Python joke."
            }
        ],
        "response_format": {
            "type": "json_schema",
            "json_schema": {
                "name": "joke_response",
                "strict": "true",
                "schema": {
                    "type": "object",
                    "properties": {
                        "joke": {
                            "type": "string"
                        }
                    },
                    "required": [
                        "joke"
                    ]
                }
            }
        },
        "temperature": 0.7,
        "max_tokens": 50,
        "stream": false
    }

3. Send the request and observe the model's response.

LM Studio is perfect for quickly testing different models and integrating them into your projects with minimal setup.

2. Ollama: Efficient and Developer-Friendly

Ollama is a lightweight and powerful tool for deploying LLMs, which is ideal for developers who prefer working from the command line.

Installing Ollama

1. Visit the Ollama website and download the Mac version.

2. Install Ollama by dragging the downloaded file into your Applications folder.

3. Launch Ollama and accept any security prompts.

Using Ollama from the Terminal

1. Open a terminal window.

2. List available models by running: Ollama list

3. To download and run a model, use: Ollama run <model-name> For example: Ollama run qwen2.5-14b

4. Once the model is loaded, you can interact directly with it in the terminal.

Ollama Commands and Features

• Use /? to see available commands within a model session.

• Exit a model session with /bye.

• Run models with verbose output using --verbose flag.

Using Ollama's API

Ollama also provides an API for integration with your applications:

1. Ensure Ollama is running (you'll see the icon in your menu bar).

2. Send POST requests to http://localhost:11434/api/generate.

Example using Postman:

{
      "model": "qwen2.5:14b",
      "prompt": "Tell me a funny joke about Python",
      "stream": false
}

Ollama Python Library

For Python developers, Ollama offers a convenient library:

1. Install the library: pip install ollama

2. Use it in your Python scripts:

import ollama
response = ollama.chat(model='qwen2.5:14b', messages=[
  {
    'role': 'user',
    'content': 'Tell me a funny joke about Golang!',
  },
])
print(response['message']['content'])

Ollama provides a great balance between ease of use and flexibility, making it an excellent choice for developers building AI-powered applications.

3. Hugging Face Transformers: Advanced Model Access

Hugging Face Transformers is a powerful library that gives you access to many models and more control over their usage.

Setting Up Hugging Face Transformers

1. Create a new Python virtual environment:

python -m venv env    source env/bin/activate

2. Install required libraries:

pip install torch transformers accelerate

3. Install Hugging Face CLI:

pip install -U huggingface_hub[cli]`

4. Log in to Hugging Face:

huggingface-cli login

(You'll need to create a user access token on the Hugging Face website)

Using a Model with Transformers

Here's a simple example using the LLaMA 3.2 3B model:

import torch
from transformers import pipeline

model_id = "meta-llama/Llama-3.2-3B-Instruct"
pipe = pipeline(
    "text-generation",
    model=model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
messages = [
    {"role": "system", "content": "You are a pirate chatbot who always responds in pirate speak!"},
    {"role": "user", "content": "Who are you?"},
]
outputs = pipe(
    messages,
    max_new_tokens=256,
)
print(outputs[0]["generated_text"][-1])

Advantages of Hugging Face Transformers

1. Access to a vast library of models

2. Fine-grained control over model parameters

3. Ability to fine-tune models for specific tasks

4. Integration with popular deep learning frameworks

While Hugging Face Transformers requires more coding knowledge, it offers unparalleled flexibility and access to cutting-edge AI models.

Conclusion

We've explored three powerful tools for running AI models locally on your Mac:

1. LM Studio: Perfect for beginners and quick experimentation

2. Ollama: Ideal for developers who prefer command-line interfaces and simple API integration

3. Hugging Face Transformers: Best for advanced users who need access to a wide range of models and fine-grained control

Each tool has its strengths, and the choice depends on your specific needs and technical expertise. By running these models locally, you gain more control over your AI applications, ensure data privacy, and avoid the costs associated with cloud-based services.

Consider your Mac's specifications when working with larger models, as they can be resource-intensive. Start with smaller models and work up as you become more familiar with the tools and your hardware capabilities.

Happy coding, and enjoy exploring the world of local AI on your Mac!

If you have any questions or feedback feel free to reach out or leave a comment below.

Bookmark this page because it will be updated frequently. I’ll also do this with some other tools I use (image generation, code generation, video, etc.).

Am I missing anything? Feel free to reach out to me!

Here are the top conversational AI tools out there right now.

Perplexity

• URL: https://www.perplexity.ai/

• Title: Perplexity AI

• Description: Perplexity — Where Knowledge Begins

• Why it’s awesome: It pulls from different sources to verify the information presented. Very magic.

Claude

• URL: https://claude.ai

• Title: Claude

• Description: Talk with Claude, an AI assistant from Anthropic

• Why it’s awesome: Excels in writing, and analysys.

Globe Explorer

• URL: https://explorer.globe.engineer/

• Title: Globe Explorer

• Description: No description found

• Why it’s awesome: It pulls from many different sources to really deep dive into a subject.

Poe

• URL: https://poe.com/

• Title: Poe — Fast, Helpful AI Chat

• Description: Poe lets you ask questions, get instant answers, and have back-and-forth conversations with AI. It gives access to GPT-4, GPT-3.5-turbo, Claude from Anthropic, and various other bots.

• Why it’s awesome: There are so many connections to other services, and the interface is very cohesive.

Grok

• URL: https://x.com/i/grok

• Title: x.com

• Description: AI Assistant, powered by X

• Why it’s awesome: It uses X as an additional source, and it is very up to date.

Gemini

• URL: https://gemini.google.com/app

• Title: Gemini — chat to supercharge your ideas

• Description: Bard is now Gemini. Get help with writing, planning, learning, and more from Google AI.

• Why it’s awesome: Backed by Google, exciting and factual results.

Groq

• URL: https://groq.com/

• Title: Groq is Fast AI Inference

• Description: The LPU™ Inference Engine by Groq is a hardware and software platform that delivers exceptional compute speed, quality, and energy efficiency. Groq provides cloud and on-prem solutions at scale for AI applications.

• Why it’s awesome: Screaming fast and smart, great for applications.

ChatGPT

• URL: https://openai.com/chatgpt/

• Title: ChatGPT by OpenAI

• Description: A conversational AI system that listens, learns, and challenges

• Why it’s awesome: It’s the OG, and Custom GPTs are awesome

Hugging Face Chat Models

• URL: https://huggingface.co/chat/models

• Title: HuggingChat — Models

• Description: The first open source alternative to ChatGPT.

• Why it’s awesome: A wide variety of models to choose from

Bing AI (Copilot)

• URL: https://www.bing.com/chat

• Title: Microsoft Copilot in Bing

• Description: Chat, get answers, create amazing content, and discover information effortlessly with Bing’s AI-powered chat. Transform the way you search and get answers with Microsoft Copilot in Bing.

• Why it’s awesome: Fast and great for programming/coding stuff.

Conclusion

This is the list of Conversational AI models I use constantly. I will update this as I go. If you can think of one I’m missing out on, Contact me!

Also if you’re into Computer Vision and other cool AI tech, you should subscribe to my AI Architect Newsletter to keep up with the latest stuff!

This tutorial will help you learn about image compression with OpenCV, covering theory and practical applications. By the end, you’ll understand how to compress photos successfully for computer vision projects (or any other projects you might have).

What is Image Compression?

Image compression is reducing an image’s file size while maintaining an acceptable level of visual quality. There are two main types of compression:

1. Lossless compression: Preserves all original data, allowing exact image reconstruction.

2. Lossy compression: Discards some data to achieve smaller file sizes, potentially reducing image quality.

Why Compress Images?

If “disk space is cheap,” as we often hear, then why compress images at all? At a small scale, image compression doesn’t matter much, but at a large scale, it’s crucial.

For instance, if you have a few images on your hard drive, you can compress them and save a few megabytes of data. This is not much of an impact when hard drives are measured in Terabytes. But what if you had 100,000 images on your hard drive? Some basic compression saves real time and money. From a performance perspective, it’s the same. If you have a website with a lot of images and 10,000 people visit your website a day, compression matters.

Here’s why we do it:

• Reduced storage requirements: Store more images in the same space

• Faster transmission: Ideal for web applications and bandwidth-constrained scenarios

• Improved processing speed: Smaller images are quicker to load and process

Theory Behind Image Compression

Image compression techniques exploit two types of redundancies:

1. Spatial redundancy: Correlation between neighboring pixels

2. Color redundancy: Similarity of color values in adjacent regions

Spatial redundancy takes advantage of the fact that neighboring pixels tend to have similar values in most natural images. This creates smooth transitions. Many photos “look real” because there is a natural flow from one area to the other. When the neighboring pixels have wildly different values, you get “noisy” images. Pixels changed to make those transitions less “smooth” by grouping pixels into a single color, making the image smaller.

Color redundancy, on the other hand, focuses on how adjacent areas in an image often share similar colors. Think of a blue sky or a green field—large portions of the image might have very similar color values. They can also be grouped together and made into a single color to save space.

OpenCV offers solid tools for working with these ideas. Using spatial redundancy, OpenCV’s cv2.inpaint() function, for example, fills in missing or damaged areas of a picture using information from nearby pixels. OpenCV lets developers use cv2.cvtColor() to translate images between several color spaces regarding color redundancy. This can be somewhat helpful as a preprocessing step in many compression techniques since some color spaces are more effective than others in encoding particular kinds of images.

We’ll test out some of this theory now. Let’s play with it.

Hands on Image Compression

Let’s explore how to compress images using OpenCV’s Python bindings. Write out this code or copy it:
(you can also download the source code here)

import cv2
import numpy as np

def compress_image(image_path, quality=90):
    # Read the image
 img = cv2.imread(image_path)

    # Encode the image with JPEG compression
 encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), quality]
 _, encoded_img = cv2.imencode('.jpg', img, encode_param)

    # Decode the compressed image
 decoded_img = cv2.imdecode(encoded_img, cv2.IMREAD_COLOR)

    return decoded_img

# Example usage
original_img = cv2.imread('original_image.jpg')
compressed_img = compress_image('original_image.jpg', quality=50)

# Display results
cv2.imshow('Original', original_img)
cv2.imshow('Compressed', compressed_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

This example contains a compress_image function that takes two parameters:

• Image path (where the image is located)

• Quality (the quality of the image desired)

Then, we’ll load the original image into original_img. We then compress that same image by 50% and load it into a new instance, compressed_image.

Then we’ll show the original and compressed images so you can view them side by side.

We then calculate and display the compression ratio.

This example demonstrates how to compress an image using JPEG compression in OpenCV. The quality parameter controls file size and image quality tradeoff.

Let’s run it:

While initially looking at the images, you see little difference. However, zooming in shows you the difference in the quality:

And after closing the windows and looking at the files, we can see the file was reduced in size dramatically:

Also, if we take it down further, we can change our quality to 10%

compressed_img = compress_image('sampleimage.jpg', quality=10)

And the results are much more drastic:

And the file size results are more drastic as well:

You can adjust these parameters quite easily and achieve the desired balance between quality and file size.

Evaluating Compression Quality

To assess the impact of compression, we can use metrics like:

1. Mean Squared Error (MSE)

Mean Squared Error (MSE) measures how different two images are from each other. When you compress an image, MSE helps you determine how much the compressed image has changed compared to the original.

It does this by sampling the differences between the colors of corresponding pixels in the two images, squaring those differences, and averaging them. The result is a single number: a lower MSE means the compressed image is closer to the original. In comparison, a higher MSE means there’s a more noticeable loss of quality.

Here’s some Python code to measure that:

def calculate_mse(img1, img2):
    return np.mean((img1 - img2) ** 2)

mse = calculate_mse(original_img, compressed_img)
print(f"Mean Squared Error: {mse:.2f}")

Here’s what our demo image compression looks like:

1. Peak Signal-to-Noise Ratio (PSNR)

Peak Signal-to-Noise Ratio (PSNR) is a measure that shows how much an image’s quality has degraded after compression. This is often visible with your eyes, but it assigns a set value. It compares the original image to the compressed one and expresses the difference as a ratio.

A higher PSNR value means the compressed image is closer in quality to the original, indicating less loss of quality. A lower PSNR means more visible degradation. PSNR is often used alongside MSE, with PSNR providing an easier-to-interpret scale where higher is better.

Here is some Python code that measures that:

def calculate_psnr(img1, img2):
 mse = calculate_mse(img1, img2)
    if mse == 0:
        return float('inf')
 max_pixel = 255.0
    return 20 * np.log10(max_pixel / np.sqrt(mse))

psnr = calculate_psnr(original_img, compressed_img)
print(f"PSNR: {psnr:.2f} dB")

Here’s what our demo image compression looks like:

“Eyeballing” your images after compression to determine quality is fine; however, at a large scale, having scripts do this is a much easier way to set standards and ensure the images follow them.

Let’s look at a couple other techniques:

Advanced Compression Techniques

For more advanced compression, OpenCV supports various algorithms:

1. PNG Compression:

You can convert your images to PNG format, which has many advantages. Use the following line of code, and you can set your compression from 0 to 9, depending on your needs. 0 means no compression whatsoever, and 9 is maximum. Keep in mind that PNGs are a “lossless” format, so even at maximum compression, the image should remain intact. The big trade-off is file size and compression time.

Here is the code to use PNG compression with OpenCV:

cv2.imwrite('compressed.png', img, [cv2.IMWRITE_PNG_COMPRESSION, 9])

And here is our result:

Note: You may notice sometimes that PNG files are actually larger in size, depending on the image.

1. WebP Compression:

You can also convert your images to .webp format. This is a newer method of compression that’s gaining in popularity. I have been using this compression on the images on my blog for years.

In the following code, we can write our image to a webp file and set the compression level from 0 to 100. It’s the opposite of PNG’s scale because 0, because we’re setting quality instead of compression. This small distinction matters, because a setting of 0 is the lowest possible quality, with a small file size and significant loss. 100 is the highest quality, which means large files with the best image quality.

Here’s the Python code to make that happen:

cv2.imwrite('compressed.webp', img, [cv2.IMWRITE_WEBP_QUALITY, 80])

And here is our result:

These two techniques are great for compressing large amounts of data. You can write scripts to compress thousands or hundreds of thousands of images automatically.

Conclusion

Image compression is fantastic. It’s essential for computer vision tasks in many ways, especially when saving space or increasing processing speed. There are also many use cases outside of computer vision anytime you want to reduce hard drive space or save bandwidth. Image compression can help a lot.

By understanding the theory behind it and applying it, you can do some powerful things with your projects.

Remember, the key to effective compression is finding the sweet spot between file size reduction and maintaining acceptable visual quality for your application.

Thanks for reading, and feel free to reach out if you have any comments or questions!

Also if you're into Computer Vision and other cool AI tech, you should subscribe to my AI Architect Newsletter to keep up with the latest stuff!

I’ve been running several LLMs and other generative AI tools on my computer lately. I’ve discovered this web UI from oobabooga for running models, and it’s incredible. You have a ton of options, and it works great.

That’s what we will set up today in this tutorial.

The easy way

If you’re in Windows using WSL, you can run a simple batch file, and it might work great. Super easy.

Clone the repo:

git clone https://github.com/oobabooga/text-generation-webui.git

Then run the batch file:

start_wsl.bat

It will ask you to choose your GPU/platform setup:

And it’s up and running:

If this works, skip to the Run the WebUI step.

But if it fails (which I’ve seen), you must do it manually. Below are the instructions to install it manually in WSL. It’s also the instructions to install this in regular old Linux. Let’s get started.

Install Anaconda

I’m using Ubuntu in WSL. So here are the commands we’ll run:

sudo apt-get update

Always a good idea.

sudo apt-get install wget

Change into the tmp directory:

cd /tmp

Then, we want to get the latest version of the installation script from this directory. At the time of this writing, this is the most current version for Linux-x86_64:

wget https://repo.anaconda.com/archive/Anaconda3-2023.09-0-Linux-x86_64.sh

This script is huge. After it’s done downloading, you should see something like this:

Then you’ll want to validate it:

sha256sum Anaconda3-2023.09-0-Linux-x86_64.sh

and if you don’t see any errors, you’re good to go:

Now it’s time to run it!

bash Anaconda3-2023.09-0-Linux-x86_64.sh

Accept the license terms (if you want to use it) and press enter.

It will ask where you want to install it. I chose the default location:

Then, grab a beverage and wait a while. I prefer ice water with lemon.

It’s going to ask if you want to initialize Conda automatically. I do a ton of Python stuff, so I select yes. Choose whatever works best for you.

Now exit the shell and restart your WSL window.

Install the Text UI

Next, we will install the Web UI interface for our models. This is a Gradio web UI for Large Language Models.

As stated in the repo, their goal is to become the AUTOMATIC1111/stable-diffusion-webui of text generation.

Clone it into a folder you’ll want to work in:

git clone https://github.com/oobabooga/text-generation-webui.git

Now type in

conda deactivate

If you have a base version running. We’ll then create a new environment:

conda create -n textgen python=3.11
conda activate textgen

If you see (textgen) in front of your prompt, it’s working.

Now, we need to install PyTorch. I’m using an NVidia card, so I type in:

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

If you aren’t using an NVidia card and want to do CPU only, use this:

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu

You’ll see a lot of this:

Wait for it to finish. If you are running an NVidia card, you may need to do this:

conda install -y -c "nvidia/label/cuda-12.1.0" cuda-runtime

Next, we need to install some more dependencies. This will depend on your machine.

cd text-generation-webui
pip install -r <requirements file according to table below>

Requirements file to use:

(this comes from the instructions)

After everything is installed, you should be ready to run the WebUI.

Run the WebUI

Now we’re ready to run! In the text-generation-webui directory, run the following:

python server.py

And you should see this:

Awesome! Let’s load it up in the web browser:

If you see this, you’re golden! However, you can’t do anything with it yet. You’ll need a model.

Downloading an LLM model

Your models will be downloaded and placed in the text-generation-webui/models folder. There are several ways to download the models, but the easiest way is in the web UI.

Click on “Model” in the top menu:

Here, you can click on “Download model or Lora” and put in the URL for a model hosted on Hugging Face.

There are tons to choose from. The first one I will load up is the Hermes 13B GPTQ.

I only need to place the username/model path from Hugging Face to do this.

TheBloke/Nous-Hermes-13B-GPTQ

And I can then download it through the web interface.

After I click refresh, I can see the new model available:

Select it, and press load. Now we’re ready to go!

Having a Chat

There are a ton of parameters you can adjust. You can get lost in the settings, and once I learn more about it, I’ll certainly share it here.

Here was my test chat:

Hey! It works! Awesome, and it’s running locally on my machine.

I decided to ask it about a coding problem:

Okay, not quite as good as GitHub Copilot or ChatGPT, but it’s an answer! I’ll play around with this and share what I’ve learned soon.

Conclusion

You may want to run a large language model locally on your own machine for many reasons. I’m doing it because I want to understand LLMs better and understand how to tune and train them. I am deeply curious about the process and love playing with it. You may have your own reasons for doing it, such as content generation or a chatbot to joke around with. The fact that you don’t have to be connected to the internet or pay a monthly fee is awesome.

What are you doing with LLMs today? Let me know! Let’s talk.

Also if you have any questions or comments, feel free to reach out.

Happy hacking!

If you're into Computer Vision and other cool AI tech, you should subscribe to my AI Architect Newsletter to keep up with the latest stuff!

What is OCR? Tesseract?

Optical Character Recognition, or OCR has been around for a long time. It's a technique that “reads” different types of documents into editable and searchable text. It works by recognizing characters in the image and converting them into machine-readable text. It’s a lot of magic, but it works well.

Tesseract is an open-source OCR engine developed by Google. It is highly accurate and supports multiple languages. This library will do all the heavy lifting for us. We’ll use it in this tutorial to quickly read the text in some images.

Step 1: Set up your Python Environment

First, you’ll need to make sure Python is installed. We’re going to create a virtual environment.

• How to install Python and set up a virtual environment in Windows

• How to set up your Python environment on a Mac

• How to setup Python environment in Linux

I’m using Linux, so I’ll create a directory named textreader and type in

python -m venv textreader

Then

source textreader/bin/activate

Step 2: Install the Required Libraries

First, we’ll need to install Tesseract on your system. Here are the instructions to install Tesseract on your chosen operating system.

Make sure Tesseract is installed by typing:

tesseract -v

and you should see output that looks like this:

Then, we’ll install a couple of Python libraries.

Pytesseract is a Python library that is a wrapper for the Tesseract OCR engine. This makes it easy to use in Python applications. We’ll install that and Pillow.

Pillow is the Python Image Library. It’s used for image processing and manipulation. It’s used to pre-process images before applying OCR techniques. It does things like image thresholding and other steps to the image to enhance the accuracy of the reading.

Next, we’ll install Pytesseract and Pillow together for our first application:

pip install pytesseract
pip install pillow

Your output should look something like this:

In some cases, like above, it may say the requirement is already satisfied for Pillow.

And we’re ready to go.

Step 3: Select your Image

To start, I’m going to choose something easy. I’ll use a screenshot from my website. This will be clear, easy-to-read text that should work great.

I’ll save that as image-1.jpg in my folder.

Step 4: Write the Script

Now, we’re ready to build our Python script to read the text from that image and output it to the screen.

First, we’ll import the libraries:

import pytesseract
from PIL import Image

Then open the image:

image = Image.open('image-1.jpg')

And then, we’ll use Tesseract to convert the text in the image to a string. Didn’t I say this library does all the heavy lifting for us?

text = pytesseract.image_to_string(image)

Finally, we’ll print it out:

print(text)

Let’s run it and see what it looks like.

Step 5: Watch the Magic Happen

We run our script and get this:

Awesome! So it’s not perfect, but it’s pretty darn good. You can read the text from the image we sent, and it’s somewhat formatted the way it is in the image. That’s awesome!

Congrats! You can now read the text from images in Python. Next, we’ll look at some more advanced stuff.

Learning the Limitations

In our first example, we had a very clear image. The text is formatted and crisp in that image, so it’s easy to read. Let’s step it up a bit.

I picked a more challenging image, one from Pexels, that isn’t quite so easy.

Let’s see what the output is when reading this image:

Oof. Nothing. I included this because it’s important to know the limitations of this process. Unusual fonts and different angles will affect how well this works. There isn’t much we can do to read this image without some extensive work.

Conclusion

In this tutorial, we learned how to use Tesseract to read text from an image and put it into a machine-readable form. We can read many other things with OCR, and we’ll deep dive into some of this stuff in future articles.

Feel free to play around with this and see what you can come up with! In a future tutorial, we’ll use OpenCV to refine things and do more pre-processing of the images we’ll read from. It will be fun.

Bookmark this blog and come back for more cool Python tutorials.

Questions? Comments? Yell at me!

If you're into Computer Vision and other cool AI tech, you should subscribe to my AI Architect Newsletter to keep up with the latest stuff!

Recently, I’ve been using Midjourney more for image generation. Dall-E 2 was good, but not as good as Midjourney. Has that changed? Let’s throw a few simple prompts at it to see.

Prompt: A realistic portrait of a cat wearing a wizard’s hat

Dall-E 3

Midjourney

This first example is clear. Midjourney definitely looks better. More realistic and detailed. Our prompt may be too simplistic. Let’s try something else.

Prompt: A red Tesla Roadster driving down a highway. Illustrated in the style of Looney Tunes. In the background is a typical Looney Tunes city. However, the car is a modern Tesla.

Dall-E 3

Midjourney

Okay, once again, Midjourney is blowing Dall-E out of the water. Neither look like a Looney Tunes cartoon, but Midjourney certainly comes closer.

Let’s take some prompts from “The 30 best Dall-E 2 prompts for amazing results” and see what we can come up with.

Prompt: Whimsical painting of an enchanted forest with mythical creatures, vibrant colors, and intricate details.

Dall-E 3

Midjourney

Prompt: Victorian-era painting of a masquerade ball with elaborate costumes, contrasting colors, and soft lighting.

Dall-E 3

Midjourney

This one is a little closer. I like the Midjourney one better, but only because of the paintings’ additional detail and different framing. The angles and framing of the Dall-E renderings are dull, and the subject isn’t clear. But it’s fairly close.

Let’s try the #1 best prompt according to that article.

Prompt: Realistic painting of a dystopian industrial city with towering factories, pollution-filled air, and a gloomy sky.

Dall-E 3

Midjourney

With this one, the style and the rendering of Dall-E 3 aren’t bad. It looks more like an actual painting. However, the Midjourney one is far more exciting and engaging.

Let’s try one of my favorite prompts: putting a 2005 Mustang GT Like mine in different settings.

Prompt: a 3D render of a red 2005 Ford Mustang GT on a deserted country highway

Dall-E 3

Midjourney

The difference here is drastic. One certainly looks more like a 3D rendering than the other.

Conclusion

Midjourney still produces better images overall than Dall-E. However, this is my experience, and with enough prompt tuning, I’m confident someone can make a fool of me and generate a much better image with Dall-E. Also, the ChatGPT integration is a nice bonus. Being able to tweak prompts using advanced techniques makes all the difference.

What has your experience been like? Let me know!

If you're into Computer Vision and other cool AI tech, you should subscribe to my AI Architect Newsletter to keep up with the latest stuff!

Why would anyone do this? Here are a few reasons:

• It’s educational

• You can generate as many images as you want

• It’s free

With this tutorial’s help, you can generate images with AI on your own computer with Stable Diffusion.

Let’s get started.

Step 1: Requirements

There are some requirements for doing this on your own machine. It must have:

Hardware:

• A modern AMD or Intel CPU

• 16 Gigabytes of RAM

• SATA or NVMe solid state drive

• NVidia GeForce GPU with at least 8 gigabytes of GDDR6 RAM

Software:

• You must have Python installed (How to install Python in Windows 11).

• You can use Anaconda if you want (How to install Anaconda in Windows 11).

• You must have Git Installed (How to install Git in Windows 11).

• You need an account at HuggingFace (it’s a free account)

Check your Python version to make sure it’s up to snuff:

And make sure Git is installed:

And you’re ready to go.

Step 2: Install Stable Diffusion Web UI

Create a folder somewhere where you want the software to live. Go to that folder:

cd /your/project/directory

(for me it’s C:\Users\jerem\Projects)

Then clone the repository:

git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui.git stable-diffusion-demo

You should see the folder you just created:

stable-diffusion-demo

Now we need to go into the models folder:

cd stable-diffusion-demo\models\Stable-diffusion

It should look like this:

This is where we’ll put the Stable Diffusion models when we download them.

Step 3: Download the Model from Hugging Face

Next, we need a stable diffusion model, and we can get one from Hugging Face.

Let’s try the v1-5-pruned-emaonly.ckpt model. Download it to the stable-diffusion-demo/models/Stable-diffusion folder:

It might take a while to download (4GB at the time of this article).

Ok, now.. you’re ready to run the web app!

Step 4: Run the Stable Diffusion Web UI

At your command prompt, make sure you’re in the folder you created in step 2.

cd stable-diffusion-demo

Then run webui-user.bat

The first time you do this, it will install everything needed, so it may take a few minutes.

Once it’s completed, your command prompt will look something like this:

And the web server will be up and running.

Step 5: The Web Interface

Load up the following URL in your web browser:

http://127.0.0.1:7860/

It may load up automatically in the browser as well. But you’ll see a full web interface you can use to generate images:

Awesome! Let’s try it out!

The sampling method is the first thing you might notice in the generation tab. There are a LOT of them:

I suggest spending some time adjusting and playing with this. But for now, we’ll use DPM++ 2M Karras that’s selected as default.

Here are some settings to pay attention to:

• Sampling steps - This will repeatedly try to improve the image as it generates. Low values will be low quality, but fast. High values will be higher quality and slower to generate.

• Width and height - These will control the size of the generated image. Like above, larger images will look better and take longer.

• CFG Scale - This will change how “random” the result is. A higher value will attempt to take the prompt as literally as possible. Lower values will produce more creative results.

• Seed - This value determines the output of the random number generator. You can use it as a key. If you use the same prompt with the same seed, you’ll get the same image. You can create many variations from the same “key”.

So today, I will leave everything at the default settings. The only thing I will do is create a seed to progressively improve the same image as we go.

And I’ll add in a prompt to make something silly.

‘a photo of an anthropomorphic frog riding a skateboard in Times Square`

It took about a minute to generate this image. (Laptop with RTX 3060)

And it’s pretty cool! It’s impressive, considering it’s being run on my local machine. Let’s improve this image!

Step 6: Improving Images

Here’s the actual image I produced:

Let’s mess with the settings to see what we can improve. Let’s change the Sampling steps. This is how often it goes through the image and tries to improve it. The default setting is 20. Let’s set it to the maximum number of 150. This will take more than a minute to produce now.

I will leave the prompt and the seed the same and click “Generate” again.

I’ll warn you: it can work the GPU when you do this.

Here is the result after 150 sampling steps:

So it’s certainly different, but not in a significant way. We don’t want to scale up our generating time by 10x for this small change. I’ll change it back to 20 and change CFG Scale to 5. This will make the model more “creative”.

Here are the settings:

And here is the result:

Ok, that’s too creative. But you can see the changes that occur when you adjust it. You can also use different sampling methods as well:

DPM++ SDE Karras

This model’s output is kind of neat because it shows the frog skateboarding better.

Euler

DPM++ 3M SDE

When attempting to draw things in cartoon, especially anthropomorphic models, it can come out very bizarre.

But that’s all there is to it!

Conclusion

In this tutorial, we:

• Installed the Stable Diffusion Web UI

• Downloaded a model

• Generated AI images

• Modified the output

All from our local machine! Here are the benefits and downsides of this method compared to something like Midjourney:

Pros:

• It’s free!

• Generate as many images as you like

• Runs locally and is not dependent on an internet connection

Cons:

• Nowhere near the level of quality as Midjourney and others

• You need a good machine to run this

• It may take longer to generate images

So there you have it! Now, you can generate images on your machine and show your creations to the world. We are barely getting started with the possibilities available from this model. We’ll explore it more in the coming weeks.

If you have any questions, feel free to reach out!

– Jeremy

Questions? Comments? Yell at me!

If you're into Computer Vision and other cool AI tech, you should subscribe to my AI Architect Newsletter to keep up with the latest stuff!

“I’ll just write a quick Python script for this” - me, a bunch of times

One of the things Python does well is abstracting complexity. One example of that is the Python function. A function is a reusable set of instructions to perform a task. Functions aren’t unique to Python; they work mostly the same as in other languages.

If you want to know how to write and call a function in Python, here’s a step-by-step guide.

The Anatomy of a Python Function

Before you can call a function, you have to write a function. Thankfully, that’s easy. Let’s look at the main components of a function.

def function_name(parameters):
    # Your code goes here
    return

The keyword ‘def’ refers to a function definition followed by your chosen function name and parentheses enclosing optional parameters. Parameters are anything you want to put into the function.

The action happens in the function body (Where it says your code goes here). This is where we put statements that make the function do work.

The return keyword allows you to send data out of the function. Note: You don’t always need to return a value. It’s optional.

So the main parts are

• definition (def keyword)

• function name

• parameters

• body (what the function does)

• return value

All of these, put together, form a function.

Calling a Python Function

Once we’ve defined a function, calling it is as straightforward as writing the function’s name followed by parentheses. If our function requires parameters, we place these inside the parentheses. These are optional.

Let’s build a simple function to display Hello World whenever we call it.

def hello_world():
    print("Hello, World!")

Even though there are no parameters or a return value, this is a function in Python. The “output” of the function is printing Hello World.

We can call this function with this line of code:

hello_world()

And this will output “Hello, World!” to your console whenever we call it.

In fact, if we call it five times:

hello_world()
hello_world()
hello_world()
hello_world()
hello_world()

It will display the same thing five times.

Congratulations, you’ve just written your first function in Python.

The Power of Function Parameters in Python

Parameters are pieces of data we pass into the function. The work of the function depends on what we pass into it. Parameters enable us to make our Python functions dynamic and reusable. We can define a function that takes parameters, allowing us to pass different arguments each time we call the function.

def greet(name):
    print("Hello, " + name + "!")

greet("Jeremy")
greet("Susie")
greet("Jim")

Here, the greet() function takes one parameter, ‘name’. When we call the function, we can pass any name we wish to greet.

Dealing with Multiple Parameters

Python functions can accept multiple parameters, allowing us to add dynamic inputs to our function calls.

def greet(name, city):
    print("Hello, " + name + " from " + city + "!")

greet("Jeremy", "Gaston")
greet("Susie", "Forest Grove")
greet("Jim", "Cornelius")

Now greet() takes two parameters, ‘name’ and ‘city’.

And it’s that easy. Congrats, you can now pass data into a function in Python.

Leveraging Default Parameters in Python Functions

Sometimes, you want to set a value for a parameter as a default. This allows the function to be called even if no data was passed. Rather than throwing an error, it will populate the value with anything you specify.

def greet(name="User"):
    print("Hello, " + name + "!")

greet()
greet("Alice")

Here, ‘greet()’ function has a default parameter ‘name’ set to ‘User’. If no argument is passed, the function greets ‘User’. If we provide a name, it greets that name instead.

It’s a good way to set defaults.

Python Return Statement

The ‘return’ statement exits a function and returns a value. With it, we can store the output of a function in a variable for future use.

def square(number):
    return number * number

result = square(5)
print(result)

In this case, square() function returns the square of the input number. The output can be stored in a variable and used later.

The return keyword is used to push values out of the function to use in your program.

Functions are awesome!

Python functions are a powerful tool in a programmer’s arsenal. They encapsulate code blocks for specific tasks, enhancing the readability and maintainability of the code. Understanding how to call a function in Python, employ parameters, and leverage the ‘return’ statement is fundamental to proficient Python programming.

Remember, practice is key! The more you use this, the more second nature it will be for you.

The Versatility of Variable Arguments in Python

Python introduces an interesting feature in functions: variable-length arguments. Sometimes we don’t know how many arguments will be passed to a function. Python’s variable arguments (*args and **kwargs) solve this problem.

def add_numbers(*args):
    return sum(args)

print(add_numbers(3, 5, 7, 9))

In the example, add_numbers() uses *args to accept any number of parameters. The function then sums up all the numbers and returns the total.

In-Depth with Python Keyword Arguments

Python functions also allow keyword arguments, which enable us to identify arguments by name. This can be extremely handy when a function has many parameters, and it improves the readability of our code.

def describe_pet(pet_name, animal_type='dog'):
    print("I have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name + ".")

describe_pet(pet_name='Willie')

In this scenario, ‘describe_pet()’ is called with the ‘pet_name’ keyword argument. The function also includes a default argument, ‘animal_type’, set to ‘dog’.

Grasping Anonymous Functions in Python: Lambda

Python’s ‘lambda’ function is a small, anonymous function defined with the ‘lambda’ keyword, rather than ‘def’. Lambda functions can accept any number of arguments but only have one expression.

multiply = lambda x, y: x * y

print(multiply(5, 4))

In the code above, a lambda function is defined to multiply two numbers, and it’s called with two arguments: 5 and 4. The function returns the result of the multiplication.

Conclusion

Congratulations, you now know how to work with functions in Python. We have covered:

• The main parts of a function

• Calling a Python function

• Using function parameters

• Using multiple parameters

• Creating default parameters

• Returning data with the return statement

• Using variable parameters

• Leveraging lambda functions

Functions in Python provide a way of organizing and reusing code to create cleaner programming solutions.

As a next step, we recommend you delve deeper into advanced Python function topics such as recursive functions, decorators, and generator functions. I’ll be adding more content like this to this blog very soon.

Bookmark this blog and come back for more cool Python tutorials.

Questions? Comments? Yell at me!

What is Blurring?

First off, let's understand what blurring is. Blurring is a process where we reduce the sharpness of an image by blending the colors of neighboring pixels. Basically, we smooth out the image, which can be useful for reducing noise, improving the overall look, or creating artistic effects.

How Does Blurring Work?

To blur an image, we need to apply a filter, which is simply a small matrix of numbers called a kernel. Don't worry if you don't know what a matrix is. Think of it as a grid of numbers. The kernel moves across the image, and for each pixel, it calculates the weighted average of the neighboring pixels' colors using the kernel values.

There are different types of kernels, and today we'll explore two common ones: the Gaussian blur and the Median blur.

Let's Write Some Code!

Before we start coding, make sure you have Python installed, and OpenCV set up. I prefer to use Python virtual environments for my projects, and it's easy to setup.

python -m venv opencvdemo

Here I am naming my environment opencvdemo but you can name it whatever you like.

Then, activate OpenCV:

In Linux or Mac:

source opencvdemo/bin/activate

In Windows:

.\opencvdemo\Scripts\activate

You'll need to install OpenCV. You can do that by using pip:

pip install opencv-python

Now, let's create a Python file and import the necessary libraries.

I named my script blurring.py.

import cv2
import numpy as np

Loading the Image

We'll begin by loading an image from your computer. Replace 'sampleimage.png' with the actual path to your image. (It can also be .jpg if you like).

image = cv2.imread('sampleimage.png')

Here's the sample I'm using. Feel free to use it yourself. Download it here

I generated it with Dall-E, so I don't own it.

Gaussian Blur

Let's start with the Gaussian blur. This kernel uses the Gaussian function, a bell-shaped curve that spreads the blur evenly around the pixel, making it look more natural.

To apply the Gaussian blur, we'll use OpenCV's GaussianBlur() function, which takes three arguments:

• The input image.

• The kernel size (width and height). They must be odd numbers.

• The standard deviation (0 means it will be calculated automatically).

gaussian_blur_image = cv2.GaussianBlur(image, (11, 11), 0)

Now, let's display the original image and the blurred one side by side:

cv2.imshow('Original Image', image)
cv2.imshow('Gaussian Blurred Image', gaussian_blur_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

And it looks like this:

Awesome, right? Just a few lines of code, and you can blur images.

Median Blur

Now let's do a Median blur. This kernel takes the median value (the middle value in a sorted list) of the neighboring pixels' colors, which reduces noise while preserving edges.

We'll use OpenCV's medianBlur() function to apply the Median blur, which takes two arguments: the input image and the kernel size (an odd number).

median_blur_image = cv2.medianBlur(image, 11)

And once again, let's display the original and blurred images:

cv2.imshow('Original Image', image)
cv2.imshow('Median Blurred Image', median_blur_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

Let's run it!

This is a different kind of blur you may want to use.

It's pretty easy stuff.

Saving Your Images

We know how to display these images on the screen, but that's only part of it. What if you want to save them? It's easy with this one line of code:

cv2.imwrite("output.png", median_blur_image)

Of course, you can change output.png to whatever you want.

We used the cv2.imread() function to read the image, then performed some modifications to it, and use cv.imwrite() to write it to a new image. Chances are, you'll want to use this later.

Summary

In this tutorial, we learned about

• Blurring - what it is and how it works

• Loading images with OpenCV

• Gaussian blurs

• Median blurs

• Saving image after modification

Go ahead and experiment with this code. Change the kernel sizes and standard deviations to see how they affect blurring.

Remember, practice makes perfect.

You've unlocked a powerful skill in computer vision, and this is just the beginning! Often you'll want to apply a blur or other modifications before performing operations on an image, so now you know how.

There's much more to explore, like edge detection, object recognition, and even facial recognition. I'll be covering all these in future tutorials. The possibilities are endless.

Questions? Comments? Yell at me!

If you're into Computer Vision and other cool AI tech, you should subscribe to my AI Architect Newsletter to keep up with the latest stuff!

I will use Python in this example, but it's a similar process in many different languages. I often work with OpenCV in Go and C# as well. But let's stay on topic here.

This will be a step-by-step guide to quickly resize and save an image using OpenCV.

Step 1: Create a Python Virtual Environment

Whenever I do anything with Python, I create a Virtual Environment. It's like a container for your Python application. It makes it portable and easy to manage dependencies. I'm using Linux for this, but it's the same commands in other operating systems.

Open up a terminal window and choose the directory you'll be building your application under. I'm using a directory named "imageresizer" because I'm great at naming things creatively.

Type in:

python -m venv imageresizer

I'm going to name the Virtual Environment as "imageresizer". Again creativity. Let's activate the environment:

source imageresizer/bin/activate

Great! Your Virtual Environment is ready to use.

Step 2: Select your Image

For this tutorial, I'm going to download a Photo by Philip Jahn from Unsplash.

It's a beautiful photo and looks like this:

And as you can see, it's quite large:

5304x7592 is excellent for printing. Not so much for the web. So how can we resize this thing without making it look funny?

We can use OpenCV! Keep reading.

Step 3: Install OpenCV

Next, we'll need to install OpenCV in our Virtual Environment.

Type in:

pip install opencv-python

And of course, I need to update pip. Just like it says, you type in:

pip install --upgrade pip

Ok, now OpenCV is installed. Let's build our script.

Step 4: Create a Python Script

Let's create the Python Script using OpenCV to resize the images.

The first line imports our library.

import cv2

Then we need to load the image we want to resize.

image = cv2.imread('original.jpg')

Now let's get the original dimensions of the image:

height, width = image.shape[:2]

This uses the shape function and stores the width and height of the image.

Now we need to set the output size of the image. This determines the size you want the new image to be.

output_size = (400, 400)

One thing to note, OpenCV will scale this. So the larger dimension of the image will be 400, and the smaller dimension will be scaled with a factor.

We need to calculate that scaling factor. Since the original dimensions are not square, resizing it to a square will distort the image. This will scale the smaller dimension appropriately.

scaling_factor = min(output_size[0]/width, output_size[1]/height)

This divides the original image dimensions by the intended dimensions, then picks the smaller result for your scaling factor.

Now, we'll resize the image. We'll pass in the original image, x and y scaling factors, and set interpolation to cv2.INTER_AREA:

resized_image = cv2.resize(image, None, fx=scaling_factor, fy=scaling_factor, interpolation=cv2.INTER_AREA)

Finally, we'll write the file.

cv2.imwrite('output.jpg', resized_image)

Awesome. Let's run it!

Step 5: Run the Script

At the prompt, type in:

python resize.py

If it's successful, you won't see any output.

Now you can inspect your images. If you check the directory, you will see different file sizes, which tells you the image has changed:

Now, if we open the image, we can see it's 267x400! Quite a bit smaller.

Congratulations! You just resized an image with OpenCV!

Here is the final code:

import cv2

# Load the image
image = cv2.imread('original.jpg')

# Get current image size
height, width = image.shape[:2]

# Set your output size
output_size = (400, 400)

# Set the scaling factor
scaling_factor = min(output_size[0]/width, output_size[1]/height)

# Resize the image in memory
resized_image = cv2.resize(image, None, fx=scaling_factor, fy=scaling_factor, interpolation=cv2.INTER_AREA)

# Write it to a new file
cv2.imwrite('output.jpg', resized_image)

Extra Credit

We can make this script more useful. Let's take in a parameter for the image name and the size we'd like to make it.

add the following line to the top:

import sys

Then, indent all the lines of code one tab.

Then add:

if len(sys.argv) > 1:

This statement says if arguments are passed to the command line, run the statements we just wrote to modify the image.

and change:

image = cv2.imread('original.jpg')

to

image = cv2.imread(sys.argv[1])

Then at the bottom of the script, add the following:

else:
    print("You must provide a filename of the original image")

Now when you run the script, you can put in any image name you want:

python resize.py original.jpg

If you don't enter a filename, the script will ask you to:

There you go! Have fun playing around with this!

Summary

In this tutorial, we learned how to resize images with OpenCV. It's pretty straightforward once you get the hang of it. It can get very complicated, however.

This is one of many tutorials I'll be doing to help you get started with OpenCV. Bookmark my blog and come back for more!

Questions? Comments? Yell at me!

Follow along with me while we develop a Blazor app and deploy it without ever using a Windows machine. Here's what we're going to do:

• Set up our (Linux) developer machine
• Build a small Blazor app
• Deploy it to a Linux VM

So let's get started.

1. Setup Your Desktop

First, we have to set up a developer environment. To do this, I will start with a fresh Ubuntu desktop install, it's never had anything done to it so we can include all the steps you need to get started.

Install Git

The first thing we want to do is install Git. You probably already have it, but it's one of the steps needed. Open up a terminal and type:

sudo apt install git

Once we have Git installed, we need to get some sort of IDE. I recommend Visual Studio Code, and that's what I'll be using in this tutorial.

Install Visual Studio Code

First, we need to install some dependencies:

sudo apt update
sudo apt install software-properties-common apt-transport-https wget

Then we'll import the Microsoft GPG Key:

wget -q https://packages.microsoft.com/keys/microsoft.asc -O- | sudo apt-key add -

Next, we'll enable the VSCode repository:

sudo add-apt-repository "deb [arch=amd64] https://packages.microsoft.com/repos/vscode stable main"

and then install it:

sudo apt update
sudo apt install code

And now you have Visual Studio Code installed.

Before you send me hate mail, yes I know you can go into the software manager and install VS Code. I am showing how to do it manually for a reason, always know what's going on with your Linux system and install things intentionally so you have full control. If you want to click the button in the software manager, that's cool too.

Install .NET Core

To make Blazor work you must install .NET Core on your local machine. There are a few ways to do this. We're going to install the .NET Core SDK and Runtime, straight from the directions at Microsoft. Depending on the version of Linux you're using it may be different. See the instructions for your distro.

First you'll need to register the Microsoft key and feed:

wget -q https://packages.microsoft.com/config/ubuntu/19.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb

Then we'll install the .NET Core SDK

sudo apt-get update
sudo apt-get install dotnet-sdk-3.1

You can verify your install is correct by typing in:

dotnet --version

It should look like this: (though the version may be newer later)

You've got the SDK Installed! Now we're ready to create a Blazor project on our local machine.

2. Create A Blazor App (WebAssembly)

So you've probably seen a few tutorials about creating Blazor apps, and most of them are Visual Studio in a Windows environment. It's super easy and the push of a button. However, in Linux or Mac you don't have a suitable version of Visual Studio, but you have the dotnet CLI, and it's nearly just as easy to create a Blazor app here.

Important Note

There are two ways we can run a Blazor application. From Microsoft:

Blazor is a web framework designed to run client-side in the browser on a WebAssembly-based .NET runtime (Blazor WebAssembly) or server-side in ASP.NET Core (Blazor Server)

We will run it client side first, which means:

• The Blazor app, its dependencies, and the .NET runtime are downloaded to the browser.
• The app is executed directly on the browser UI thread.

We will deploy it as a standalone deployment.

Standalone deployment - A standalone deployment serves the Blazor WebAssembly app as a set of static files that are requested directly by clients. Any static file server is able to serve the Blazor app.

There are some downsides to this method and we'll discuss those, but for now we want to build this so it can be hosted on any static server.

Blazor server is included in .NET Core 3.0, but WebAssembly is still in preview. So we need to install a template for it.

You can grab the template with the following command:

dotnet new -i Microsoft.AspNetCore.Blazor.Templates::3.1.0-preview4.19579.2

Next we'll create a new Blazor WebAssembly App

dotnet new blazorwasm -o BlazorDemo

Go into the directory and run it:

cd BlazorDemo
dotnet run

Your terminal window should look like this:

Now you can open it up in a web browser and view the page:

Open it up in VS Code and make your own modifications and play around with it.

So now we'll take this basic Blazor app and deploy it in different places.

3. Deploy it to a Linux Server (WebAssembly)

Let's see what it will take to push this to a regular Linux hosting server. For this I will use a Digital Ocean $5 special server. I'm creating it from scratch, again to show all the steps needed to get it up and running. We'll run CentOS 7 on it.

Set up our Server

To set this up, I'm just going to update it:

sudo yum update

Then I'll install Nginx on it to serve up our static files.

sudo yum install epel-release
sudo yum install nginx

If you already have a web server set up that serves static files, you don't have to follow these steps.

I'll then start up our Nginx server:

sudo systemctl start nginx

And it's ready to go.

Build a Deployment (WebAssembly)

Now we want to deploy our application.

Now open a command prompt to the home folder of your application and run the following:

dotnet publish -c Release -r linux-x64

And we'll go into our publish folder and look for the dist folder:

cd bin/Release/netstandard2.1/linux-x64/publish/BlazorDemo/dist

Here I can see a listing of files.

I will copy these over to my new Linux server. I'm using SCP, but you can use whatever method you feel works:

scp -r * web@sillyblazordemo.jeremymorgan.com:/usr/share/nginx/html

And now I load it up in my web browser:

Well, that's pretty cool! So this .NET Core application has been turned into static files I can host anywhere. I can put this on IIS, or S3, or wherever and it will work great. You can even Host it on Github Pages!.

This is great because C# and Razor files are compiled into .NET assemblies, and Blazor WebAssembly bootstraps the .NET runtime and loads the assemblies all right there in the browser.

But it requires modern browsers and has a huge payload to download to the browser to do that.

To truly leverage the power of Blazor we should set up a Blazor Server package. If you really want to know the differences, you can learn more here.

4. Create a Blazor App (Blazor Server)

Now we will to create a Blazor Server application.

dotnet new blazorserver -o BlazorServerDemo

This creates another Blazor application, and we type in

dotnet run

and it spins up our local application:

and it looks pretty familiar. Only now I don't have the rabbit head.

So let's publish it. We will publish this as a self-contained application, so we can run it on our Nginx server without installing the .NET Framework.

dotnet publish -c Release --self-contained -r linux-x64

Then we'll go into our publish directory:

cd bin/Release/netcoreapp3.1/linux-x64/publish/

And we'll copy those over to an app directory created on the host (yours may vary)

scp -r * web@sillyblazordemo.jeremymorgan.com:/home/web/apps/BlazorServerDemo

5. Set up the Server for .NET Core

To run .NET Core applications (even self-contained) there are some dependencies. We will install the following for CentOS, if you're using a different OS, you can check what dependencies you need here.

Here's the command to install the needed dependencies with Yum:

sudo yum install lttng-ust libcurl openssl-libs krb5-libs libicu zlib

Next, there's an SELinux setting you need to change that might hang you up:

setsebool -P httpd_can_network_connect 1

Now we can just run the executable:

./BlazorServerDemo --urls http://0.0.0.0:5000

And we have a server up and ready at port 5000:

And we can load it up in our Web Browser!

We're now up and running, but we don't want to just run it listening on a port like this, so let's use Nginx as a reverse proxy. Shut down the process.

Then let's run this in the background, by adding the ampersand at the end:

./BlazorServerDemo --urls http://0.0.0.0:5000 &

Now if you type in "jobs" you should see it running.

Now, create the following two folders:

sudo mkdir /etc/nginx/sites-available
sudo mkdir /etc/nginx/sites-enabled

And then edit your default file

vi /etc/nginx/sites-available/default

And add in the following into your server directive:

location / {
    proxy_pass         http://localhost:5000;
    proxy_http_version 1.1;
    proxy_set_header   Upgrade $http_upgrade;
    proxy_set_header   Connection keep-alive;
    proxy_set_header   Host $host;
    proxy_cache_bypass $http_upgrade;
    proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header   X-Forwarded-Proto $scheme;
}

Now restart nginx:

sudo systemctl reload nginx

Now you see your new page up and running!

Now you have a full fledged Blazor server on a Linux VM instance.

Conclusion

So in this tutorial, we built a Blazor application (both WebAssembly and Blazor Server) on an Ubuntu machine and pushed it up to a CentOS machine. We didn't need any Windows machines to do it.

My intent was to show how easy it is to develop Blazor and .NET Core applications if you're a Linux developer. I started out as a Linux developer, fell in love with C#/.NET, and now I can do both things together and I love it. You will to.

.NET Core is amazing, and I think Blazor will be too. I'm excited to develop more Blazor applications and push the limits of it.

If you want to learn more about Blazor, Pluralsight has just released some really cool courses on it.

• Blazor - The Big Picture
• Blazor - Getting Started
• Blazor - Authentication and Authorization

So try it out! Let me know what you think of Blazor and share your experiences in the comments!