How to make AI in Python

Python offers a powerful and accessible path to build artificial intelligence. Its extensive libraries and clean syntax make it an ideal choice for both beginners and experts who want to develop AI solutions.

You'll explore core techniques and practical tips for your first project. We'll also cover real-world applications and share debugging advice, so you can confidently build and deploy your own AI solutions.

Using scikit-learn for your first AI model

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

model = RandomForestClassifier()
model.fit(X_train, y_train)

print(f"Model accuracy: {model.score(X_test, y_test):.2f}")--OUTPUT--Model accuracy: 0.96

This code snippet walks through a fundamental machine learning workflow with scikit-learn. The key isn't just building a model, but building one you can trust. That's why the data is split before training.

• The train_test_split function separates your data. You train the model on one part and test it on the other, which it has never seen. This prevents the model from simply memorizing the answers.
• A RandomForestClassifier is used for the actual prediction. It's a powerful ensemble model that combines many decision trees to make a final choice.
• Finally, model.score() measures accuracy on the test set, giving you a reliable sense of how the model will perform on new, real-world data.

Building neural networks with popular frameworks

Building on the basics of scikit-learn, you can tackle more advanced problems with neural network frameworks like TensorFlow and PyTorch or language processing with NLTK.

Creating a neural network with TensorFlow and Keras

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

model = Sequential([
Dense(128, activation='relu', input_shape=(4,)),
Dense(64, activation='relu'),
Dense(3, activation='softmax')
])

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
print(model.summary())--OUTPUT--Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
dense (Dense) (None, 128) 640
dense_1 (Dense) (None, 64) 8256
dense_2 (Dense) (None, 3) 195
=================================================================
Total params: 9,091
Trainable params: 9,091
Non-trainable params: 0
_________________________________________________________________
None

This example uses TensorFlow and its Keras API to construct a neural network. You're building a Sequential model, which is essentially a linear stack of layers—an intuitive way to define a network architecture.

• The model consists of Dense layers, where every neuron connects to every neuron in the next layer. The relu activation function introduces non-linearity, allowing the model to learn complex relationships.
• The final layer uses a softmax activation to convert the output into class probabilities.
• Finally, model.compile() configures the learning process by setting the optimizer and loss function.

Implementing machine learning with PyTorch

import torch
import torch.nn as nn

class SimpleNN(nn.Module):
def __init__(self):
super(SimpleNN, self).__init__()
self.layer1 = nn.Linear(4, 64)
self.layer2 = nn.Linear(64, 3)
self.relu = nn.ReLU()

def forward(self, x):
x = self.relu(self.layer1(x))
x = self.layer2(x)
return x

model = SimpleNN()
print(model)--OUTPUT--SimpleNN(
(layer1): Linear(in_features=4, out_features=64, bias=True)
(layer2): Linear(in_features=64, out_features=3, bias=True)
(relu): ReLU()
)

PyTorch provides a more object-oriented way to build models. Instead of a sequential list, you define your network architecture inside a class that inherits from nn.Module.

• The __init__ method is where you initialize the network's layers, such as nn.Linear.
• The forward method defines the data's path through the network, giving you explicit control over how calculations are performed.

Natural language processing with NLTK

import nltk
from nltk.tokenize import word_tokenize
from nltk.sentiment import SentimentIntensityAnalyzer

nltk.download('punkt', quiet=True)
nltk.download('vader_lexicon', quiet=True)

text = "I love working with artificial intelligence in Python!"
tokens = word_tokenize(text)
analyzer = SentimentIntensityAnalyzer()
sentiment = analyzer.polarity_scores(text)

print(f"Tokens: {tokens[:5]}...")
print(f"Sentiment: {sentiment}")--OUTPUT--Tokens: ['I', 'love', 'working', 'with', 'artificial']...
Sentiment: {'neg': 0.0, 'neu': 0.492, 'pos': 0.508, 'compound': 0.8074}

The Natural Language Toolkit (NLTK) is essential for processing human language. This example demonstrates two core NLP tasks: tokenization and sentiment analysis.

• First, word_tokenize splits the sentence into a list of individual words, or tokens. This is a foundational step for most text-based analysis.
• Then, SentimentIntensityAnalyzer gauges the emotional tone. The polarity_scores function analyzes the text and returns a dictionary of scores for negative, neutral, and positive sentiment, plus a compound score summarizing the overall feeling.

Advanced AI techniques and applications

Beyond the fundamentals of model building and text analysis, Python also powers specialized fields like reinforcement learning, computer vision, and generative AI.

Reinforcement learning with OpenAI Gym

import gym
import numpy as np

env = gym.make('CartPole-v1')
observation = env.reset()

total_reward = 0
for _ in range(100):
action = env.action_space.sample() # Random action
observation, reward, done, info = env.step(action)
total_reward += reward
if done:
break

print(f"Observation shape: {observation.shape}")
print(f"Total reward: {total_reward}")--OUTPUT--Observation shape: (4,)
Total reward: 23.0

Reinforcement learning teaches a model to make decisions through trial and error. OpenAI Gym is a toolkit that provides standardized environments, like the classic CartPole-v1 game used here, to train and test these models. The objective is to learn a policy that maximizes a cumulative reward.

• The code initializes the environment using gym.make(). Each simulation loop begins with a call to env.reset().
• Instead of a smart strategy, env.action_space.sample() selects a random action. The environment processes this with env.step(), which returns the outcome and a reward.
• The total_reward tracks the score. While this example acts randomly, a true AI would learn to choose actions that maximize this score over time.

Computer vision with OpenCV

import cv2
import numpy as np

image = np.zeros((200, 200, 3), dtype=np.uint8)
cv2.rectangle(image, (50, 50), (150, 150), (0, 255, 0), -1)
cv2.circle(image, (100, 100), 30, (0, 0, 255), -1)

gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(gray, 30, 100)

print(f"Image shape: {image.shape}")
print(f"Detected edges: {np.sum(edges > 0)} pixels")--OUTPUT--Image shape: (200, 200, 3)
Detected edges: 628 pixels

OpenCV is a powerful library for computer vision, letting you programmatically analyze and manipulate images. This code first uses NumPy to create a blank image, then draws a rectangle and a circle on it with OpenCV functions. It's a simple demonstration of how you can generate or modify image data directly.

• The image is converted to grayscale with cv2.cvtColor(). This is a common preprocessing step that simplifies many vision tasks.
• Next, cv2.Canny() is used to perform edge detection—a foundational technique for finding object boundaries and features in an image.

Generative AI with GANs

import tensorflow as tf
from tensorflow.keras.layers import Dense, Reshape, Input
from tensorflow.keras.models import Model

def build_generator():
input_layer = Input(shape=(100,))
x = Dense(128, activation='relu')(input_layer)
x = Dense(784, activation='sigmoid')(x)
output = Reshape((28, 28, 1))(x)
return Model(input_layer, output)

generator = build_generator()
print(f"Input shape: {generator.input_shape}")
print(f"Output shape: {generator.output_shape}")--OUTPUT--Input shape: (None, 100)
Output shape: (None, 28, 28, 1)

Generative Adversarial Networks (GANs) are models that learn to create new data. This code defines the generator half of a GAN—its job is to produce synthetic images from random noise.

• The build_generator function constructs a model that takes a 100-dimension vector as input.
• It uses Dense layers to transform this random input into a flat array of 784 values.
• Finally, the Reshape layer molds this array into a 28x28 pixel image, ready to be evaluated by the GAN's other half, the discriminator.

Move faster with Replit

Replit is an AI-powered development platform where all Python dependencies are pre-installed, so you can skip setup and start coding instantly. Instead of piecing together the techniques shown above, you can use Agent 4 to build complete applications directly from a description.

Describe the app you want to build, and Agent 4 will take it from idea to working product. You could create practical tools like:

• A sentiment analysis tool that processes user feedback and outputs an emotional score, using the same methods as the NLTK example.
• An image utility that applies edge detection to uploaded photos to identify object outlines, similar to the OpenCV workflow.
• A simple game bot that learns the optimal strategy for the CartPole-v1 environment to maximize its score.

Simply describe your app, and Replit will write the code, test it, and fix issues automatically, all within your browser.

Common errors and challenges

Building AI in Python is powerful, but you'll inevitably encounter a few common hurdles; here’s how to clear them.

When using scikit-learn, your model will likely throw an error if your dataset contains missing values, often represented as NaN. The algorithms expect a complete dataset to function correctly, so you'll need to handle these gaps before training.

• One common solution is to use an imputer, such as scikit-learn’s SimpleImputer, to replace empty fields with the mean, median, or most frequent value from that column.
• Alternatively, if the dataset is large enough, you can simply remove the rows or columns that contain missing data.

In TensorFlow, a frequent error is a shape mismatch. This occurs when the dimensions of your input data don't align with the input_shape your model's first layer is expecting. The model can't process the data if it doesn't arrive in the right format.

• To fix this, you must ensure your data's structure matches the input_shape argument specified in your initial layer, like a Dense layer.
• This often involves reshaping your data arrays with a library like NumPy to make them compatible with the model's input requirements.

With PyTorch, you might run into memory issues during model evaluation. By default, PyTorch tracks all operations to build a computation graph for calculating gradients, which is essential for training but wasteful during inference.

• You can prevent this by wrapping your evaluation code in a with torch.no_grad(): block.
• This signals to PyTorch that it should not track gradients, which conserves memory and speeds up execution.

Handling missing values in scikit-learn models

When you try to train a model on data with missing values, it will fail. The code below intentionally adds NaN values to a dataset, which causes the fit method to raise a ValueError, stopping the training process cold.

from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
import numpy as np

X, y = load_diabetes(return_X_y=True)
X[10:20, 0] = np.nan # Create missing values

model = RandomForestRegressor()
model.fit(X, y) # Will fail with missing values

By assigning np.nan to a slice of the data, the code deliberately introduces missing values. The model can't handle these gaps, which triggers the error. The following example shows how you can address this common problem.

from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.impute import SimpleImputer
import numpy as np

X, y = load_diabetes(return_X_y=True)
X[10:20, 0] = np.nan # Create missing values

imputer = SimpleImputer(strategy='mean')
X_imputed = imputer.fit_transform(X)
model = RandomForestRegressor()
model.fit(X_imputed, y)

The fix is straightforward. Before training, you can use SimpleImputer to fill in the gaps. This tool replaces all missing values, marked as np.nan, with a calculated value—in this case, the column’s average, set by strategy='mean'. The fit_transform method applies this logic and returns a clean dataset, X_imputed. Now your model can train without errors. This is a crucial preprocessing step whenever your data isn't complete.

Fixing input shape errors in TensorFlow models

In TensorFlow, a shape mismatch error is a frequent hurdle. It occurs when the dimensions of your input data don't match the input_shape defined in your model's first layer. The following code intentionally creates this mismatch to show what happens.

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

model = Sequential([
Dense(64, activation='relu', input_shape=(20,)),
Dense(10, activation='softmax')
])

X_train = tf.random.normal((100, 28)) # Mismatch with model input shape
model.fit(X_train, tf.random.normal((100, 10)), epochs=5)

The model's first layer is configured for an input_shape of (20,). The training data, X_train, is then created with 28 features, which doesn't align with the model's expectation. The following code shows how to correct this.

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

X_train = tf.random.normal((100, 28))
y_train = tf.random.normal((100, 10))

model = Sequential([
Dense(64, activation='relu', input_shape=(28,)), # Fixed input shape
Dense(10)
])
model.fit(X_train, y_train, epochs=5)

The fix is simple: you just need to ensure your model's input_shape matches your data's dimensions. The corrected code adjusts the first Dense layer's input_shape to (28,) to align with the training data.

This error often appears when you first pass data to the fit method, so always double-check that your input features correspond to the shape your model is built to accept.

Preventing memory leaks with PyTorch gradients

In PyTorch, gradients accumulate with each training loop. If you don't clear them, your model's memory usage will grow uncontrollably, eventually crashing your program. This is a common mistake that's easy to make and even easier to fix.

The following code demonstrates this issue. When you repeatedly call loss.backward() without resetting the gradients, they build up with each pass, leading to a memory leak.

import torch

model = torch.nn.Linear(1000, 1000)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
x = torch.randn(100, 1000)

for i in range(10):
y_pred = model(x)
loss = y_pred.sum()
loss.backward() # Gradients accumulate without clearing
optimizer.step()

Each time optimizer.step() runs, it uses gradients that have been accumulating since the first iteration. This not only consumes memory but also leads to incorrect weight updates. See how to correct this workflow in the code below.

import torch

model = torch.nn.Linear(1000, 1000)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
x = torch.randn(100, 1000)

for i in range(10):
optimizer.zero_grad() # Clear previous gradients
y_pred = model(x)
loss = y_pred.sum()
loss.backward()
optimizer.step()

The fix is to call optimizer.zero_grad() at the start of every training loop. This is crucial because PyTorch accumulates gradients by default.

• Calling optimizer.zero_grad() clears the old gradients before you calculate new ones with loss.backward().
• This prevents memory consumption from growing with each pass and ensures your model's weight updates are correct.

It's a standard step you should make a habit in any PyTorch training loop.

Real-world applications

With these techniques and troubleshooting skills, you can tackle complex real-world applications like forecasting and hyperparameter optimization.

Time series forecasting with Prophet

Prophet simplifies time series forecasting by automatically modeling trends and seasonality, allowing you to generate robust predictions with minimal setup.

from prophet import Prophet
import pandas as pd
import numpy as np

# Create example data
df = pd.DataFrame({
'ds': pd.date_range(start='2020-01-01', periods=365),
'y': np.random.normal(0, 1, 365).cumsum() + 100
})

model = Prophet()
model.fit(df)
future = model.make_future_dataframe(periods=30)
forecast = model.predict(future)
print(forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail(3))

This code showcases a standard forecasting workflow with Prophet. It starts by preparing a pandas DataFrame with two specific columns: ds for dates and y for the values you want to predict. The process is straightforward:

• First, you train the model on your historical data with the fit() method.
• Then, make_future_dataframe() creates a set of future dates for the model to predict on.
• Finally, predict() generates the forecast, which includes the predicted value (yhat) and confidence intervals, giving you a range of likely outcomes.

Optimizing model hyperparameters with Optuna

Optuna automates the trial-and-error process of tuning hyperparameters, systematically searching for the settings that will give your model the best performance.

import optuna
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score

def objective(trial):
X, y = load_iris(return_X_y=True)
n_estimators = trial.suggest_int('n_estimators', 10, 100)
max_depth = trial.suggest_int('max_depth', 2, 10)

model = RandomForestClassifier(n_estimators=n_estimators, max_depth=max_depth)
return cross_val_score(model, X, y, cv=5).mean()

study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=20)
print(f"Best parameters: {study.best_params}")
print(f"Best accuracy: {study.best_value:.4f}")

This code uses Optuna to find the best settings for a machine learning model. The entire process is wrapped in an objective function, which Optuna calls repeatedly to run experiments.

• In each trial, Optuna suggests new integer values for the model’s n_estimators and max_depth hyperparameters.
• A RandomForestClassifier is created with these suggested values, and its performance is measured with cross_val_score.
• The study.optimize method runs this process for 20 trials, working to maximize the model's accuracy score.

Get started with Replit

Turn your knowledge into a working application. Tell Replit Agent: "Build a sentiment analysis tool for user reviews" or "Create an app that applies edge detection to uploaded images."

Replit Agent writes the code, tests for errors, and deploys your app from a simple description. Start building with Replit.