Python for AI Cheatsheet | Spider On The Web

📦 Core Libraries

NumPy

Numerical computing

pip install numpy

Pandas

Data manipulation

pip install pandas

PyTorch

Deep learning

pip install torch

Transformers

Pre-trained models

pip install transformers

LangChain

LLM applications

pip install langchain

OpenAI

GPT API client

pip install openai

Anthropic

Claude API client

pip install anthropic

Scikit-learn

Classical ML

pip install scikit-learn

🔢 NumPy Essentials

Creating Arrays

import numpy as np

# Create arrays
arr = np.array([1, 2, 3, 4, 5])
zeros = np.zeros((3, 3))
ones = np.ones((2, 4))
rand = np.random.randn(5, 5)  # Normal distribution
range_arr = np.arange(0, 10, 0.5)

# Reshaping
reshaped = arr.reshape(5, 1)
flattened = reshaped.flatten()

Common Operations

# Math operations
mean = np.mean(arr)
std = np.std(arr)
dot_product = np.dot(arr, arr)

# Matrix operations
A = np.random.randn(3, 3)
B = np.random.randn(3, 3)
matmul = A @ B  # Matrix multiplication
transpose = A.T
inverse = np.linalg.inv(A)

🐼 Pandas Essentials

import pandas as pd

# Create DataFrame
df = pd.DataFrame({
    'text': ['hello', 'world', 'test'],
    'label': [1, 0, 1],
    'score': [0.9, 0.2, 0.8]
})

# Load data
df = pd.read_csv('data.csv')
df = pd.read_json('data.json')

# Filter and select
positive = df[df['label'] == 1]
high_score = df[df['score'] > 0.5]
selected = df[['text', 'label']]

# Apply functions
df['text_len'] = df['text'].apply(len)
df['text_upper'] = df['text'].str.upper()

🔥 PyTorch Basics

Tensors

import torch

# Create tensors
x = torch.tensor([1, 2, 3])
zeros = torch.zeros(3, 3)
rand = torch.randn(5, 5)

# GPU support
device = "cuda" if torch.cuda.is_available() else "cpu"
x = x.to(device)

# Gradients
x = torch.tensor([2.0], requires_grad=True)
y = x ** 2
y.backward()
print(x.grad)  # tensor([4.])

Simple Neural Network

import torch.nn as nn

class SimpleNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.layer1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.layer2 = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        x = self.layer1(x)
        x = self.relu(x)
        x = self.layer2(x)
        return x

model = SimpleNN(10, 64, 2)
model.to(device)

🤗 Transformers (Hugging Face)

Quick Pipeline

from transformers import pipeline

# Sentiment analysis
classifier = pipeline("sentiment-analysis")
result = classifier("I love this product!")
# [{'label': 'POSITIVE', 'score': 0.9998}]

# Text generation
generator = pipeline("text-generation", model="gpt2")
result = generator("Once upon a time", max_length=50)

# Question answering
qa = pipeline("question-answering")
result = qa(question="What is Python?", context="Python is a programming language.")

Load Models Directly

from transformers import AutoTokenizer, AutoModel

# Load tokenizer and model
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
model = AutoModel.from_pretrained("bert-base-uncased")

# Tokenize
inputs = tokenizer("Hello, world!", return_tensors="pt")

# Get embeddings
with torch.no_grad():
    outputs = model(**inputs)
    embeddings = outputs.last_hidden_state

📊 Text Embeddings

OpenAI Embeddings

from openai import OpenAI

client = OpenAI()

response = client.embeddings.create(
    model="text-embedding-3-small",
    input="Hello world"
)

embedding = response.data[0].embedding  # List of floats

Sentence Transformers

from sentence_transformers import SentenceTransformer

model = SentenceTransformer('all-MiniLM-L6-v2')

sentences = ["Hello world", "How are you?"]
embeddings = model.encode(sentences)

# Compute similarity
from sklearn.metrics.pairwise import cosine_similarity
similarity = cosine_similarity([embeddings[0]], [embeddings[1]])

🔌 LLM API Calls

OpenAI

from openai import OpenAI

client = OpenAI()  # Uses OPENAI_API_KEY env var

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello!"}
    ]
)

print(response.choices[0].message.content)

Anthropic Claude

import anthropic

client = anthropic.Anthropic()  # Uses ANTHROPIC_API_KEY env var

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system="You are a helpful assistant.",
    messages=[
        {"role": "user", "content": "Hello!"}
    ]
)

print(message.content[0].text)

⚙️ Environment Setup

# Create virtual environment
python -m venv venv
source venv/bin/activate  # Linux/Mac
venv\Scripts\activate     # Windows

# Install common AI packages
pip install numpy pandas torch transformers
pip install openai anthropic langchain
pip install sentence-transformers scikit-learn

# Environment variables (.env file)
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...

Tip: Use python-dotenv to load .env files: from dotenv import load_dotenv; load_dotenv()