AI Engineering in 5 Months
Python Programming
Python and AI
If artificial intelligence had an official language, it would be Python. It's clean, readable, and supported by a massive community. More importantly, it has powerful libraries—collections of pre-written code—that do the heavy lifting for complex tasks like data analysis and machine learning.
Python has become the cornerstone of Artificial Intelligence (AI) development, primarily due to its simplicity, readability, and extensive library ecosystem.
Think of it this way: you don't need to build a car from scratch every time you want to drive. You just use a car that's already built. Python's libraries are like that car—they give you the tools to get moving without worrying about the low-level mechanics.
Basic Building Blocks
Like any language, Python has rules for how to write it. We start by storing information in variables. A variable is just a name you give to a piece of data, like a number or some text.
# Assigning text to a variable
greeting = "Hello, AI world!"
# Assigning a number to a variable
year = 2024
# You can print the variables to see their values
print(greeting)
print(year)```
But we often need to handle more than one piece of data at a time. For that, Python gives us data structures. The most common one is a list, which is just an ordered collection of items.
# A list of numbers
feature_values = [0.1, 0.5, 0.23, 0.8]
# You can access items by their position (index), starting from 0
print(feature_values[0]) # Prints 0.1
# You can add new items to the end
feature_values.append(0.9)
print(feature_values)```
Another incredibly useful structure is the dictionary. It stores data in key-value pairs, much like a real dictionary links a word to its definition. This is great for labeling information.
# A dictionary describing a dataset
dataset_info = {
"name": "Iris Flowers",
"features": 4,
"classes": 3
}
# Access a value using its key
print(dataset_info["name"]) # Prints "Iris Flowers"```
Finally, there are sets. A set is a collection where every item must be unique. If you need to track a list of things without any duplicates, a set is the perfect tool.
Making Decisions and Repeating Actions
Programming isn't just about storing data; it's about doing things with it. To make our code smart, we need it to make decisions. We do this with conditional statements like if, elif (else if), and else.
accuracy = 0.95
if accuracy > 0.9:
print("Model performance is excellent!")
elif accuracy > 0.7:
print("Model performance is good.")
else:
print("Model needs improvement.")```
We also need to repeat actions. Imagine you have a list of a thousand data points. You don't want to write a line of code for each one. That's where loops come in. A for loop lets you perform an action for every single item in a collection.
# A list of training data files
files = ["data_batch_1.csv", "data_batch_2.csv", "data_batch_3.csv"]
# Loop through each file in the list and print its name
for filename in files:
print("Processing file:", filename)```
Organizing Your Code
As your code gets more complex, you'll want to organize it. Functions are reusable blocks of code that perform a specific task. You define a function once and can then "call" it whenever you need it, which keeps your code clean and avoids repetition.
# Define a function to calculate the average of a list of numbers
def calculate_average(numbers):
total = sum(numbers)
return total / len(numbers)
# Use the function
scores = [88, 92, 100, 78]
average_score = calculate_average(scores)
print("Average score:", average_score)```
Related functions can be grouped together into files called modules. You can then import these modules into your scripts to use the functions they contain. Python's power comes from its vast collection of modules (or libraries) built by the community.
Working with Data Libraries
In AI, you're always working with data, often in large quantities. Two Python libraries are essential for this: NumPy and Pandas.
NumPy is the go-to for numerical operations. It provides a powerful object called an array, which is a grid of values. It's much faster for mathematical computations than standard Python lists.
import numpy as np
# Create a NumPy array
data_points = np.array([1, 2, 3, 4, 5])
# Perform a mathematical operation on the entire array at once
scaled_points = data_points * 10
print(scaled_points) # Output: [10 20 30 40 50]```
Pandas is built on top of NumPy and is perfect for working with structured data, like what you'd find in a spreadsheet or a database table. It introduces the DataFrame, a two-dimensional table with labeled rows and columns. It makes cleaning, manipulating, and analyzing data much more intuitive.
import pandas as pd
# Create a dictionary of data
data = {
'sensor_id': ['A1', 'A2', 'B1'],
'reading': [22.5, 23.1, 22.8]
}
# Create a DataFrame from the dictionary
df = pd.DataFrame(data)
print(df)```
We often load data from files. Pandas makes this simple. For example, you can load an entire CSV file into a DataFrame with a single line of code.
# This assumes you have a file named 'sensor_data.csv'
# df = pd.read_csv('sensor_data.csv')
# print(df.head()) # .head() shows the first 5 rows```
With these fundamentals, you have the core tools to start writing scripts that can process data—the first major step in any AI project.
Now, let's test your understanding of these core Python concepts.
What is a primary reason Python is so popular for artificial intelligence?
If you need to store a collection of email addresses for a mailing list and want to ensure there are no duplicates, which Python data structure is the most suitable?
Mastering these basics is the foundation upon which all your future AI development skills will be built.