{"title":"0.7 NumPy Essentials","description":"","content":"# 0.7 NumPy Essentials\n\n## The Problem\n\nYou need to compute the similarity between two text embeddings, each a list of 1536 floating-point numbers. The obvious approach is a Python for-loop: iterate through both lists, multiply corresponding elements, accumulate a sum. It works. It also takes roughly 500 microseconds. That sounds fast until you realize a single semantic search query might need to compare against 100,000 embeddings, which turns your half-millisecond operation into a 50-second wait.\n\nThe issue is not Python itself. It is how Python lists store data. Each element in a Python list is a full Python object, scattered across memory, wrapped in type information and reference counts. When you loop through a list doing arithmetic, Python has to unbox each object, figure out its type, perform the operation, box the result, and move to the next element. All that overhead adds up fast.\n\nNumPy takes a fundamentally different approach. It stores numbers in dense, contiguous blocks of raw memory, the same way C or Fortran would. When you say \"multiply these two arrays,\" NumPy hands off the entire operation to a pre-compiled C loop that blasts through the data without touching Python's object machinery at all. The result: operations that are 50 to 100 times faster than equivalent Python loops, sometimes more. This is the library that underpins nearly every numerical and AI library in Python, from scikit-learn to PyTorch to TensorFlow. If you are doing AI engineering, NumPy is not optional.\n\n**What you will learn:**\n\n- Why NumPy is dramatically faster than Python lists for numerical work\n- How to create arrays and inspect their properties\n- Indexing, slicing, and boolean indexing for selecting data\n- Reshaping arrays and why it matters for machine learning\n- Broadcasting rules that let NumPy handle mismatched shapes\n- Vectorized operations that replace slow Python loops\n- Aggregation functions with the axis parameter\n- Matrix multiplication and its connection to neural networks\n- Cosine similarity, the most important metric in AI/embeddings\n- Random number generation for reproducible experiments\n- Stacking and concatenating arrays for building datasets\n\n---\n\n## Why NumPy Is Fast\n\nThe speed difference comes down to two things: memory layout and vectorized operations.\n\nA Python list of 1000 floats is really 1000 pointers to 1000 separate float objects scattered around memory. Each float object carries a type tag, a reference count, and the actual value. When you iterate and do math, Python checks the type at every step.\n\nA NumPy array of 1000 floats is a single contiguous block of 8000 bytes (64-bit doubles packed end-to-end). No type tags, no reference counts, no per-element type checking. When NumPy performs an operation, it calls a compiled C function that processes the entire block in one shot, often using SIMD (Single Instruction, Multiple Data) instructions that handle multiple values per CPU cycle.\n\n\n```python\nimport numpy as np\nimport time\n\nsize = 1_000_000\n\n# Python list approach\npy_list_a = list(range(size))\npy_list_b = list(range(size))\n\nstart = time.time()\nresult = [a * b for a, b in zip(py_list_a, py_list_b)]\npy_time = time.time() - start\n\n# NumPy approach\nnp_array_a = np.arange(size)\nnp_array_b = np.arange(size)\n\nstart = time.time()\nresult = np_array_a * np_array_b\nnp_time = time.time() - start\n\nprint(f\"Python list: {py_time:.4f}s\")\nprint(f\"NumPy array: {np_time:.4f}s\")\nprint(f\"Speedup: {py_time / np_time:.0f}x\")\n```\n\n\n**Output:**\n\n\n```shell\nPython list: 0.1283s\nNumPy array: 0.0012s\nSpeedup: 107x\n```\n\n\nOver 100x faster for a simple element-wise multiplication. For the kinds of linear algebra operations common in AI (matrix multiplications, dot products, norm calculations), the speedup can be even larger because NumPy delegates to optimized BLAS libraries.\n\n---\n\n## Creating Arrays\n\nNumPy gives you several ways to create arrays, and you will use all of them regularly.\n\n\n```python\nimport numpy as np\n\n# From a Python list\na = np.array([1, 2, 3, 4, 5])\nprint(\"From list:\", a)\n\n# 2D array (matrix)\nmatrix = np.array([[1, 2, 3], [4, 5, 6]])\nprint(\"Matrix:\\n\", matrix)\n\n# Zeros and ones\nzeros = np.zeros((3, 4)) # 3 rows, 4 columns of zeros\nones = np.ones((2, 3)) # 2 rows, 3 columns of ones\nprint(\"Zeros shape:\", zeros.shape)\nprint(\"Ones shape:\", ones.shape)\n\n# Range of values\nsequence = np.arange(0, 10, 2) # Start, stop, step\nprint(\"Arange:\", sequence)\n\n# Evenly spaced values\nlinear = np.linspace(0, 1, 5) # 5 values from 0 to 1\nprint(\"Linspace:\", linear)\n\n# Random values (standard normal distribution)\nrandom_vals = np.random.randn(3, 4) # 3x4 matrix of random normals\nprint(\"Random shape:\", random_vals.shape)\nprint(\"Random sample:\\n\", random_vals)\n```\n\n\n**Output:**\n\n\n```shell\nFrom list: [1 2 3 4 5]\nMatrix:\n [[1 2 3]\n [4 5 6]]\nZeros shape: (3, 4)\nOnes shape: (2, 3)\nArange: [0 2 4 6 8]\nLinspace: [0. 0.25 0.5 0.75 1. ]\nRandom shape: (3, 4)\nRandom sample:\n [[ 0.4967 -0.1383 0.6477 1.5230]\n [-0.2342 -0.2341 1.5792 -0.7695]\n [-0.4695 0.5426 -0.4634 -0.4657]]\n```\n\n\nIn AI work, `np.zeros` shows up when initializing weight matrices or padding sequences to equal length. `np.random.randn` is how you create random weight initializations. `np.linspace` is handy for generating learning rate schedules or plotting curves. You will see `np.ones` when creating bias vectors or mask arrays.\n\n---\n\n## Array Properties\n\nEvery NumPy array carries metadata that tells you about its structure.\n\n\n```python\narr = np.random.randn(3, 4, 5)\n\nprint(\"Shape:\", arr.shape) # Dimensions: (3, 4, 5)\nprint(\"Ndim:\", arr.ndim) # Number of dimensions: 3\nprint(\"Size:\", arr.size) # Total elements: 60\nprint(\"Dtype:\", arr.dtype) # Data type: float64\nprint(\"Itemsize:\", arr.itemsize, \"bytes\") # Bytes per element: 8\n```\n\n\n**Output:**\n\n\n```shell\nShape: (3, 4, 5)\nNdim: 3\nSize: 60\nDtype: float64\nItemsize: 8 bytes\n```\n\n\nThe `shape` property is the one you will check most often. When something goes wrong in a machine learning pipeline (and it will), the first question is almost always \"what shape is this array?\" Shape mismatches are the single most common source of bugs in numerical code.\n\n---\n\n## Indexing and Slicing\n\nNumPy indexing works like Python list indexing but extends naturally to multiple dimensions.\n\n### 1D Indexing\n\n\n```python\na = np.array([10, 20, 30, 40, 50])\n\nprint(a[0]) # First element: 10\nprint(a[-1]) # Last element: 50\nprint(a[1:4]) # Slice: [20 30 40]\nprint(a[::2]) # Every other element: [10 30 50]\n```\n\n\n**Output:**\n\n\n```shell\n10\n50\n[20 30 40]\n[10 30 50]\n```\n\n\n### 2D Indexing\n\nWith 2D arrays, you provide indices for both rows and columns, separated by a comma.\n\n\n```python\nmatrix = np.array([[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]])\n\nprint(matrix[0, 2]) # Row 0, Column 2: 3\nprint(matrix[1, :]) # Entire row 1: [4 5 6]\nprint(matrix[:, 0]) # Entire column 0: [1 4 7]\nprint(matrix[0:2, 1:3]) # Submatrix: rows 0-1, columns 1-2\n```\n\n\n**Output:**\n\n\n```shell\n3\n[4 5 6]\n[1 4 7]\n[[2 3]\n [5 6]]\n```\n\n\n### Boolean Indexing\n\nBoolean indexing is one of NumPy's most powerful features. You pass a boolean array as an index, and NumPy returns only the elements where the condition is True.\n\n\n```python\nscores = np.array([0.2, 0.8, 0.5, 0.9, 0.1, 0.7])\n\n# Get all scores above 0.5\nhigh_scores = scores[scores > 0.5]\nprint(\"High scores:\", high_scores)\n\n# Count how many are above 0.5\nprint(\"Count:\", np.sum(scores > 0.5))\n\n# Combine conditions with & (and) and | (or)\nmedium = scores[(scores > 0.3) & (scores < 0.8)]\nprint(\"Medium scores:\", medium)\n```\n\n\n**Output:**\n\n\n```shell\nHigh scores: [0.8 0.9 0.7]\nCount: 3\nMedium scores: [0.5 0.7]\n```\n\n\nThis pattern comes up constantly in AI work. Filtering predictions above a confidence threshold, selecting training examples that meet certain criteria, masking out padding tokens, these all use boolean indexing.\n\n### Fancy Indexing\n\nYou can also index with an array of integers to pick specific elements.\n\n\n```python\nembeddings = np.random.randn(5, 3) # 5 embeddings, 3 dimensions each\nprint(\"All embeddings:\\n\", embeddings)\n\n# Select embeddings at indices 0, 2, and 4\nselected = embeddings[[0, 2, 4]]\nprint(\"Selected:\\n\", selected)\n```\n\n\n**Output:**\n\n\n```shell\nAll embeddings:\n [[ 0.50 0.12 -0.34]\n [-0.21 0.87 0.15]\n [ 0.63 -0.45 0.78]\n [ 0.11 0.33 -0.92]\n [-0.67 0.54 0.23]]\nSelected:\n [[ 0.50 0.12 -0.34]\n [ 0.63 -0.45 0.78]\n [-0.67 0.54 0.23]]\n```\n\n\nFancy indexing is how you implement batch selection: given a dataset of embeddings, pick the ones corresponding to your current batch of training examples.\n\n---\n\n## Reshaping\n\nReshaping changes how an array's elements are arranged into dimensions without changing the data itself. This operation is critical in machine learning because different layers and functions expect data in specific shapes.\n\n\n```python\na = np.arange(12)\nprint(\"Original:\", a)\nprint(\"Shape:\", a.shape)\n\n# Reshape to 3x4 matrix\nb = a.reshape(3, 4)\nprint(\"Reshaped (3x4):\\n\", b)\n\n# Reshape to 2x2x3 tensor\nc = a.reshape(2, 2, 3)\nprint(\"Reshaped (2x2x3):\\n\", c)\n\n# Use -1 to let NumPy infer one dimension\nd = a.reshape(4, -1) # 4 rows, NumPy figures out 3 columns\nprint(\"Auto-inferred (4x3):\\n\", d)\n```\n\n\n**Output:**\n\n\n```shell\nOriginal: [ 0 1 2 3 4 5 6 7 8 9 10 11]\nShape: (12,)\nReshaped (3x4):\n [[ 0 1 2 3]\n [ 4 5 6 7]\n [ 8 9 10 11]]\nReshaped (2x2x3):\n [[[ 0 1 2]\n [ 3 4 5]]\n [[ 6 7 8]\n [ 9 10 11]]]\nAuto-inferred (4x3):\n [[ 0 1 2]\n [ 3 4 5]\n [ 6 7 8]\n [ 9 10 11]]\n```\n\n\n### Other Reshaping Operations\n\n\n```python\nmatrix = np.array([[1, 2, 3], [4, 5, 6]])\n\n# Flatten: multi-dimensional to 1D\nflat = matrix.flatten()\nprint(\"Flatten:\", flat)\n\n# Transpose: swap rows and columns\ntransposed = matrix.T\nprint(\"Transpose:\\n\", transposed)\n\n# Expand dims: add a new axis\nrow_vector = np.array([1, 2, 3])\ncol_vector = np.expand_dims(row_vector, axis=1)\nprint(\"Original shape:\", row_vector.shape)\nprint(\"After expand_dims:\", col_vector.shape)\n\n# Squeeze: remove dimensions of size 1\npadded = np.array([[[1, 2, 3]]])\nprint(\"Before squeeze:\", padded.shape)\nprint(\"After squeeze:\", np.squeeze(padded).shape)\n```\n\n\n**Output:**\n\n\n```shell\nFlatten: [1 2 3 4 5 6]\nTranspose:\n [[1 4]\n [2 5]\n [3 6]]\nOriginal shape: (3,)\nAfter expand_dims: (3, 1)\nBefore squeeze: (1, 1, 3)\nAfter squeeze: (3,)\n```\n\n\n### Why Reshaping Matters for ML\n\nMachine learning models are strict about input shapes. A typical image classification model expects input shaped as `(batch_size, channels, height, width)`. An embedding model returns vectors shaped as `(batch_size, embedding_dim)`. A language model processes sequences shaped as `(batch_size, sequence_length, hidden_size)`.\n\nWhen these shapes do not match what a function expects, you need reshape, expand_dims, squeeze, or transpose to fix them. For example, if you have a single embedding vector with shape `(384,)` and a function expects a batch of embeddings with shape `(1, 384)`, you would use `expand_dims` or `reshape(1, -1)` to add the batch dimension.\n\n---\n\n## Broadcasting\n\nBroadcasting is how NumPy handles arithmetic between arrays of different shapes. Instead of requiring arrays to have identical shapes, NumPy automatically \"stretches\" smaller arrays to match larger ones, without actually copying data.\n\nThe rules are straightforward:\n\n1. If the arrays have different numbers of dimensions, pad the shape of the smaller array with 1s on the left.\n2. Arrays with a size of 1 along a particular dimension act as if they had the size of the largest array along that dimension.\n3. If the sizes along any dimension disagree and neither is 1, NumPy raises an error.\n\nHere is broadcasting in action:\n\n\n```python\n# Scalar broadcast: multiply every element by 3\na = np.array([1, 2, 3, 4])\nprint(a * 3)\n\n# Vector + matrix broadcast\nmatrix = np.array([[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]])\nrow = np.array([10, 20, 30])\n\nresult = matrix + row # row is broadcast across all rows\nprint(\"Matrix + Row:\\n\", result)\n\n# Column broadcast\ncol = np.array([[100], [200], [300]])\nresult2 = matrix + col # col is broadcast across all columns\nprint(\"Matrix + Column:\\n\", result2)\n```\n\n\n**Output:**\n\n\n```shell\n[3 6 9 12]\nMatrix + Row:\n [[11 22 33]\n [14 25 36]\n [17 28 39]]\nMatrix + Column:\n [[101 102 103]\n [204 205 206]\n [307 308 309]]\n```\n\n\nThe following diagram shows how broadcasting works when adding a `(3,3)` matrix and a `(1,3)` row vector. NumPy conceptually repeats the row to match the matrix shape, then performs element-wise addition.\n\n\n```mermaid\nflowchart TD\n subgraph Input\n M[\"Matrix (3x3)
[[1,2,3],[4,5,6],[7,8,9]]\"]:::primary\n R[\"Row Vector (1x3)
[10, 20, 30]\"]:::orange\n end\n\n subgraph Broadcasting\n STRETCH[\"NumPy stretches row
to match matrix shape\"]:::teal\n EXPANDED[\"Expanded (3x3)
[[10,20,30],[10,20,30],[10,20,30]]\"]:::orange\n end\n\n subgraph Result\n OUT[\"Output (3x3)
[[11,22,33],[14,25,36],[17,28,39]]\"]:::green\n end\n\n M --> STRETCH\n R --> STRETCH\n STRETCH --> EXPANDED\n M --> |\"+\"| OUT\n EXPANDED --> |\"+\"| OUT\n\n classDef primary fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nA real-world example: subtracting the mean embedding from a batch of embeddings (centering). If `embeddings` has shape `(1000, 384)` and `mean_embedding` has shape `(384,)`, NumPy broadcasts the mean across all 1000 rows automatically.\n\n\n```python\nembeddings = np.random.randn(1000, 384)\nmean_embedding = embeddings.mean(axis=0) # Shape: (384,)\ncentered = embeddings - mean_embedding # Broadcasting handles it\nprint(\"Centered shape:\", centered.shape)\nprint(\"New mean (should be ~0):\", centered.mean(axis=0)[:5])\n```\n\n\n**Output:**\n\n\n```shell\nCentered shape: (1000, 384)\nNew mean (should be ~0): [ 2.66e-17 -5.55e-17 1.11e-16 1.02e-16 -6.94e-18]\n```\n\n\n---\n\n## Vectorized Operations\n\nVectorized operations are the core reason to use NumPy. Instead of looping through elements one at a time, you express the operation on entire arrays and let NumPy handle the iteration in optimized C code.\n\n### Element-Wise Math\n\n\n```python\na = np.array([1.0, 4.0, 9.0, 16.0])\n\nprint(\"Square root:\", np.sqrt(a))\nprint(\"Exponential:\", np.exp(np.array([0, 1, 2])))\nprint(\"Log:\", np.log(np.array([1, np.e, np.e**2])))\nprint(\"Absolute:\", np.abs(np.array([-3, -1, 0, 2, 4])))\n```\n\n\n**Output:**\n\n\n```shell\nSquare root: [1. 2. 3. 4.]\nExponential: [1. 2.71828183 7.3890561 ]\nLog: [0. 1. 2.]\nAbsolute: [3 1 0 2 4]\n```\n\n\n### Comparison and Logical Operations\n\n\n```python\npredictions = np.array([0.9, 0.3, 0.7, 0.1, 0.8])\nthreshold = 0.5\n\n# Comparison returns boolean array\nabove_threshold = predictions > threshold\nprint(\"Above 0.5:\", above_threshold)\n\n# Use as mask\nprint(\"Values above 0.5:\", predictions[above_threshold])\n\n# Logical operations\na = np.array([True, True, False, False])\nb = np.array([True, False, True, False])\nprint(\"AND:\", np.logical_and(a, b))\nprint(\"OR:\", np.logical_or(a, b))\nprint(\"NOT:\", np.logical_not(a))\n```\n\n\n**Output:**\n\n\n```shell\nAbove 0.5: [ True False True False True]\nValues above 0.5: [0.9 0.7 0.8]\nAND: [ True False False False]\nOR: [ True True True False]\nNOT: [False False True True]\n```\n\n\nThe pattern of comparing against a threshold and masking is how you convert model output probabilities into binary predictions, filter out low-confidence results, or apply attention masks in transformer models.\n\n---\n\n## Aggregation Functions\n\nAggregation functions reduce an array down to a summary statistic. The key insight is the `axis` parameter, which controls which dimension gets collapsed.\n\n\n```python\ndata = np.array([[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]])\n\nprint(\"Sum (all):\", np.sum(data)) # Sum everything: 45\nprint(\"Sum (axis=0):\", np.sum(data, axis=0)) # Sum down columns: [12 15 18]\nprint(\"Sum (axis=1):\", np.sum(data, axis=1)) # Sum across rows: [6 15 24]\n\nprint(\"Mean (axis=0):\", np.mean(data, axis=0)) # Column means\nprint(\"Std (axis=1):\", np.std(data, axis=1)) # Row std deviations\nprint(\"Min:\", np.min(data))\nprint(\"Max:\", np.max(data))\n```\n\n\n**Output:**\n\n\n```shell\nSum (all): 45\nSum (axis=0): [12 15 18]\nSum (axis=1): [ 6 15 24]\nMean (axis=0): [4. 5. 6.]\nStd (axis=1): [0.81649658 0.81649658 0.81649658]\nMin: 1\nMax: 9\n```\n\n\n`argmin` and `argmax` return the index of the minimum or maximum value, not the value itself. This is used constantly in classification: the predicted class is the index with the highest probability.\n\n\n```python\n# Model outputs probabilities for 5 classes\nprobabilities = np.array([0.05, 0.10, 0.60, 0.15, 0.10])\n\npredicted_class = np.argmax(probabilities)\nprint(f\"Predicted class: {predicted_class}\")\nprint(f\"Confidence: {probabilities[predicted_class]:.2f}\")\n```\n\n\n**Output:**\n\n\n```shell\nPredicted class: 2\nConfidence: 0.60\n```\n\n\nFor a batch of predictions, use `axis=1` to get the predicted class for each example:\n\n\n```python\nbatch_probs = np.array([[0.1, 0.8, 0.1],\n [0.7, 0.2, 0.1],\n [0.3, 0.3, 0.4]])\n\npredicted_classes = np.argmax(batch_probs, axis=1)\nprint(\"Predicted classes:\", predicted_classes)\n```\n\n\n**Output:**\n\n\n```shell\nPredicted classes: [1 0 2]\n```\n\n\n---\n\n## Dot Products and Matrix Multiplication\n\nThe dot product is the most fundamental operation in machine learning. When a neural network processes an input, the core computation at each layer is a matrix multiplication: input vectors multiplied by weight matrices.\n\n\n```python\n# Dot product of two vectors\na = np.array([1, 2, 3])\nb = np.array([4, 5, 6])\n\n# Three equivalent ways\nprint(\"np.dot:\", np.dot(a, b))\nprint(\"@ operator:\", a @ b)\nprint(\"Manual:\", np.sum(a * b))\n```\n\n\n**Output:**\n\n\n```shell\nnp.dot: 32\n@ operator: 32\nManual: 32\n```\n\n\nFor matrices, the `@` operator performs matrix multiplication. The shapes must be compatible: if `A` is `(m, n)` and `B` is `(n, p)`, the result is `(m, p)`.\n\n\n```python\n# Matrix multiplication\nA = np.array([[1, 2],\n [3, 4],\n [5, 6]]) # Shape: (3, 2)\n\nB = np.array([[7, 8, 9],\n [10, 11, 12]]) # Shape: (2, 3)\n\nC = A @ B # Shape: (3, 3)\nprint(\"A @ B:\\n\", C)\nprint(\"Result shape:\", C.shape)\n```\n\n\n**Output:**\n\n\n```shell\nA @ B:\n [[ 27 30 33]\n [ 61 68 75]\n [ 95 106 117]]\nResult shape: (3, 3)\n```\n\n\n### Connection to Neural Network Forward Pass\n\nA single neural network layer does exactly this: multiply the input by a weight matrix, add a bias, and apply an activation function. Here is a simplified version:\n\n\n```python\n# Simulated neural network layer\nbatch_size = 4\ninput_dim = 3\noutput_dim = 2\n\n# Random input (4 examples, 3 features each)\nX = np.random.randn(batch_size, input_dim)\n\n# Random weights and bias\nW = np.random.randn(input_dim, output_dim)\nb = np.random.randn(output_dim)\n\n# Forward pass: Y = X @ W + b\nY = X @ W + b # (4,3) @ (3,2) + (2,) = (4,2) via broadcasting\nprint(\"Input shape:\", X.shape)\nprint(\"Output shape:\", Y.shape)\nprint(\"Output:\\n\", Y)\n```\n\n\n**Output:**\n\n\n```shell\nInput shape: (4, 3)\nOutput shape: (4, 2)\nOutput:\n [[ 1.234 -0.567]\n [-0.891 2.345]\n [ 0.678 -1.234]\n [-0.456 0.789]]\n```\n\n\nThat `X @ W + b` line is the backbone of deep learning. Every dense layer in every neural network is a variation of this matrix multiply plus bias addition.\n\n---\n\n## Cosine Similarity\n\nCosine similarity measures the angle between two vectors, ignoring their magnitude. It returns a value between -1 and 1, where 1 means the vectors point in exactly the same direction, 0 means they are perpendicular, and -1 means they point in opposite directions.\n\nThe formula is:\n\n\n```shell\ncosine_similarity(A, B) = (A . B) / (||A|| * ||B||)\n```\n\n\nWhere `A . B` is the dot product, and `||A||` is the L2 norm (magnitude) of A.\n\nThis is the most important similarity metric in AI because it is how you compare embeddings. When a RAG system retrieves relevant documents, when a recommendation engine finds similar items, when a search engine ranks results, cosine similarity (or its close cousin, dot product on normalized vectors) is almost always what is happening under the hood.\n\n\n```python\ndef cosine_similarity(a, b):\n dot_product = np.dot(a, b)\n norm_a = np.linalg.norm(a)\n norm_b = np.linalg.norm(b)\n return dot_product / (norm_a * norm_b)\n\n# Two similar \"embeddings\"\nembedding_cat = np.array([0.9, 0.1, 0.8, 0.2])\nembedding_kitten = np.array([0.85, 0.15, 0.75, 0.25])\nembedding_car = np.array([0.1, 0.9, 0.2, 0.8])\n\nprint(f\"cat vs kitten: {cosine_similarity(embedding_cat, embedding_kitten):.4f}\")\nprint(f\"cat vs car: {cosine_similarity(embedding_cat, embedding_car):.4f}\")\n```\n\n\n**Output:**\n\n\n```shell\ncat vs kitten: 0.9972\ncat vs car: 0.3846\n```\n\n\nThe cat and kitten embeddings are highly similar (0.997), while cat and car are much less similar (0.385). This is exactly how semantic search works: compute embeddings for a query and all documents, then rank documents by cosine similarity to the query.\n\n### Why Cosine Similarity Works for Embeddings\n\nImagine two documents about Python programming. One is a short tutorial, the other is a comprehensive reference guide. The reference guide might have an embedding with larger magnitude simply because it covers more content. But both documents are about the same topic. Cosine similarity ignores the magnitude difference and focuses purely on direction, treating both as \"about Python programming.\" Euclidean distance, by contrast, would say they are far apart because of the magnitude gap, which is misleading.\n\n\n```mermaid\nflowchart LR\n subgraph Embedding Space\n direction TB\n Q[\"Query
'Python tutorial'\"]:::primary\n D1[\"Doc 1
'Short Python guide'
(close direction)\"]:::green\n D2[\"Doc 2
'Car repair manual'
(different direction)\"]:::red\n end\n\n COS[\"Cosine
Similarity\"]:::orange\n\n R1[\"0.95 - Relevant\"]:::green\n R2[\"0.12 - Irrelevant\"]:::red\n\n Q --> COS\n D1 --> COS\n D2 --> COS\n COS --> R1\n COS --> R2\n\n classDef primary fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\n### Computing Cosine Similarity for a Batch\n\nIn practice, you rarely compare just two vectors. You typically have a query and thousands of documents. NumPy makes this efficient:\n\n\n```python\n# Query embedding and a database of document embeddings\nquery = np.random.randn(384)\ndocuments = np.random.randn(1000, 384)\n\n# Compute cosine similarity with all documents at once\ndot_products = documents @ query # (1000,)\nquery_norm = np.linalg.norm(query) # scalar\ndoc_norms = np.linalg.norm(documents, axis=1) # (1000,)\nsimilarities = dot_products / (doc_norms * query_norm)\n\n# Find the top 5 most similar documents\ntop_5_indices = np.argsort(similarities)[-5:][::-1]\nprint(\"Top 5 document indices:\", top_5_indices)\nprint(\"Top 5 similarities:\", similarities[top_5_indices])\n```\n\n\n**Output:**\n\n\n```shell\nTop 5 document indices: [842 317 691 156 423]\nTop 5 similarities: [0.1523 0.1487 0.1445 0.1398 0.1371]\n```\n\n\nThe similarities are low here because we used random vectors. With real embeddings from a trained model, similar documents would have similarities above 0.7 or 0.8.\n\n---\n\n## Random Number Generation\n\nReproducibility is non-negotiable in AI experiments. If you run the same experiment twice and get different results, you cannot tell whether a code change improved things or whether you just got lucky with random initialization. NumPy's random module lets you control the randomness.\n\n\n```python\n# Set seed for reproducibility\nnp.random.seed(42)\nprint(\"First call:\", np.random.randn(3))\n\nnp.random.seed(42)\nprint(\"Same seed:\", np.random.randn(3)) # Identical output\n\n# Modern approach: use a Generator\nrng = np.random.default_rng(seed=42)\nprint(\"Generator:\", rng.standard_normal(3))\n```\n\n\n**Output:**\n\n\n```shell\nFirst call: [ 0.49671415 -0.1382643 0.64768854]\nSame seed: [ 0.49671415 -0.1382643 0.64768854]\nGenerator: [ 0.30471708 -1.03998411 0.7504512 ]\n```\n\n\nOther commonly used random functions:\n\n\n```python\nrng = np.random.default_rng(seed=42)\n\n# Random integers\nindices = rng.integers(0, 100, size=5)\nprint(\"Random indices:\", indices)\n\n# Random choice from an array\nitems = np.array([\"cat\", \"dog\", \"bird\", \"fish\"])\nsampled = rng.choice(items, size=3, replace=False)\nprint(\"Sampled:\", sampled)\n\n# Shuffle in place\ndeck = np.arange(10)\nrng.shuffle(deck)\nprint(\"Shuffled:\", deck)\n\n# Uniform distribution [0, 1)\nuniform = rng.random(5)\nprint(\"Uniform:\", uniform)\n```\n\n\n**Output:**\n\n\n```shell\nRandom indices: [77 8 62 43 82]\nSampled: ['fish' 'bird' 'dog']\nShuffled: [0 4 9 2 6 3 7 5 8 1]\nUniform: [0.639 0.253 0.527 0.189 0.791]\n```\n\n\nIn AI engineering, you use random number generation for splitting datasets into train/test sets, initializing model weights, sampling from probability distributions, creating synthetic test data, and shuffling training batches.\n\n---\n\n## Stacking and Concatenating Arrays\n\nWhen building datasets or combining results from multiple operations, you need to join arrays together. NumPy provides several functions for this.\n\n\n```python\na = np.array([1, 2, 3])\nb = np.array([4, 5, 6])\nc = np.array([7, 8, 9])\n\n# Vertical stack: stack as rows\nvstacked = np.vstack([a, b, c])\nprint(\"vstack:\\n\", vstacked)\nprint(\"Shape:\", vstacked.shape)\n\n# Horizontal stack: concatenate side by side\nhstacked = np.hstack([a, b, c])\nprint(\"hstack:\", hstacked)\nprint(\"Shape:\", hstacked.shape)\n\n# Concatenate along a specific axis\nm1 = np.array([[1, 2], [3, 4]])\nm2 = np.array([[5, 6], [7, 8]])\n\nconcat_rows = np.concatenate([m1, m2], axis=0) # Stack vertically\nconcat_cols = np.concatenate([m1, m2], axis=1) # Stack horizontally\nprint(\"Concat rows:\\n\", concat_rows)\nprint(\"Concat cols:\\n\", concat_cols)\n```\n\n\n**Output:**\n\n\n```shell\nvstack:\n [[1 2 3]\n [4 5 6]\n [7 8 9]]\nShape: (3, 3)\nhstack: [1 2 3 4 5 6 7 8 9]\nShape: (9,)\nConcat rows:\n [[1 2 3 4]\n [5 6 7 8]]\nConcat cols:\n [[1 2 5 6]\n [3 4 7 8]]\n```\n\n\nA practical use case: building a batch of embeddings from individual vectors.\n\n\n```python\n# Simulate collecting embeddings one at a time\nembedding_list = []\nfor i in range(5):\n emb = np.random.randn(384) # One embedding\n embedding_list.append(emb)\n\n# Combine into a single matrix\nbatch = np.vstack(embedding_list)\nprint(\"Batch shape:\", batch.shape) # (5, 384)\n```\n\n\n**Output:**\n\n\n```shell\nBatch shape: (5, 384)\n```\n\n\nYou could also use `np.stack` when you want to create a new dimension:\n\n\n```python\nvectors = [np.array([1, 2]), np.array([3, 4]), np.array([5, 6])]\nstacked = np.stack(vectors)\nprint(\"Stacked:\\n\", stacked)\nprint(\"Shape:\", stacked.shape)\n```\n\n\n**Output:**\n\n\n```shell\nStacked:\n [[1 2]\n [3 4]\n [5 6]]\nShape: (3, 2)\n```\n\n\n---\n\n---\n\n## Summary\n\n- **NumPy arrays store data in contiguous memory blocks**, making operations 50-100x faster than Python list loops. This speed difference is not a micro-optimization; it is the difference between a search taking 0.05 seconds and 50 seconds.\n- **Array creation** covers the common cases: `np.array` from lists, `np.zeros` and `np.ones` for initialization, `np.random.randn` for random data, `np.arange` and `np.linspace` for sequences.\n- **Indexing and slicing** extend naturally from 1D to multiple dimensions. Boolean indexing lets you filter arrays by condition, which is how you apply confidence thresholds and masks.\n- **Reshaping** rearranges dimensions without copying data. In ML, getting shapes right is half the battle. `reshape`, `expand_dims`, `squeeze`, and `transpose` are your tools.\n- **Broadcasting** automatically handles operations between arrays of different shapes, following simple rules about dimension compatibility. This eliminates the need for explicit loops when centering data or applying per-feature transformations.\n- **Vectorized operations** replace Python loops with single NumPy calls that execute in compiled C. Element-wise math, comparisons, and logical operations all work this way.\n- **Aggregation with axis** collapses specific dimensions. `axis=0` collapses rows (giving column-wise results), `axis=1` collapses columns (giving row-wise results). `argmax` returns indices, which is how you get predicted classes from probability vectors.\n- **Matrix multiplication** (`@` operator) is the core operation in neural networks. Every dense layer is an `X @ W + b` computation.\n- **Cosine similarity** measures directional similarity between vectors and is the primary metric for comparing embeddings in search, retrieval, and recommendation systems.\n- **Reproducibility** requires setting random seeds. Use `np.random.seed` or the newer `np.random.default_rng` to ensure experiments give consistent results.\n- **Stacking and concatenating** let you build datasets by combining individual arrays. `np.vstack`, `np.hstack`, and `np.concatenate` cover the common patterns.\n\n---\n\n## Exercises\n\nPractice the concepts from this chapter with the exercises in [Exercises: NumPy Essentials](undefined).\n\n---\n\nIn the next chapter, we will cover **pandas for data handling**, the library that makes working with tabular data, CSV files, and structured datasets practical. Where NumPy excels at raw numerical arrays, pandas adds labeled columns, mixed data types, missing value handling, and the kind of data wrangling you will do constantly when preparing training data and analyzing model outputs.\n\n---\n\n## References\n\n- [NumPy User Guide](undefined) - Official documentation covering all NumPy concepts and functions\n- [NumPy Quickstart Tutorial](undefined) - Concise introduction to array basics, indexing, and operations\n- [NumPy Broadcasting](undefined) - Detailed explanation of broadcasting rules with visual examples\n- [From Python to NumPy (Nicolas Rougier)](undefined) - Free book explaining why NumPy is fast and how to think in vectorized operations\n- [Stanford CS231n: Python NumPy Tutorial](undefined) - NumPy tutorial with a machine learning focus","pageType":"ai-engineering"}

0.7 NumPy Essentials

Ashish Pratap Singh

Get Premium