Unlocking the Potential of PyTorch: A Guide to Matrix-Vector Multiplication

In PyTorch, you can perform matrix-vector multiplication using two primary methods:

1. torch.mm Function:

   • This function is specifically designed for matrix multiplication.
   • It requires the following conditions for proper operation:
     • Both input tensors (matrix and vector) must be two-dimensional (2D).
     • The number of columns in the matrix (inner dimension) must be equal to the size of the vector (outer dimension).

   Example:

   import torch
   
   # Create a matrix and a vector
   matrix = torch.tensor([[1, 2, 3], [4, 5, 6]])
   vector = torch.tensor([7, 8, 9])
   
   # Perform matrix-vector multiplication using torch.mm
   result = torch.mm(matrix, vector)
   print(result)  # Output: tensor([38, 66])
   

   Explanation:

   • The matrix has dimensions (2, 3), meaning it has 2 rows and 3 columns.
   • The vector has dimensions (3,), indicating it has 3 elements.
   • torch.mm multiplies each row of the matrix with the vector, resulting in a new 1D tensor (vector) with the dot products.

2. torch.matmul Function (Recommended):

   • This is the more versatile function for matrix operations in PyTorch.
   • It can handle various combinations of input dimensions, including:
     • Matrix-matrix multiplication (both inputs are 2D)
     • Matrix-vector multiplication (one input is 2D, the other is 1D)
     • Vector-vector dot product (both inputs are 1D)
   • It also supports broadcasting, allowing operations on tensors with compatible but different shapes.

   import torch
   
   # Create a matrix and a vector (same as before)
   matrix = torch.tensor([[1, 2, 3], [4, 5, 6]])
   vector = torch.tensor([7, 8, 9])
   
   # Perform matrix-vector multiplication using torch.matmul
   result = torch.matmul(matrix, vector)
   print(result)  # Output: tensor([38, 66])
   

   • torch.matmul behaves similarly to torch.mm in this case, performing matrix-vector multiplication.

Choosing the Right Function:

• If you're certain both inputs are 2D and want a more specific function, torch.mm is suitable.
• For broader compatibility, handling different dimension combinations, and potential broadcasting, torch.matmul is generally preferred.

Additional Considerations:

• Ensure the dimensions of the matrix and vector are compatible for multiplication.
• The resulting tensor from the multiplication will have dimensions (m, 1), where m is the number of rows in the matrix.
• PyTorch tensors can be created on different devices (CPU or GPU) using torch.device. Make sure your tensors are on the desired device before performing the multiplication.

import torch

# Create a 2D matrix and a 1D vector
matrix = torch.tensor([[1, 2, 3], [4, 5, 6]])
vector = torch.tensor([7, 8, 9])

# Perform matrix-vector multiplication using torch.mm (explicitly for 2D inputs)
result = torch.mm(matrix, vector)
print("Result (torch.mm):", result)

Using torch.matmul for versatility (handles different dimensions and broadcasting):

import torch

# Create a 2D matrix and a 1D vector (same as before)
matrix = torch.tensor([[1, 2, 3], [4, 5, 6]])
vector = torch.tensor([7, 8, 9])

# Option 1: Explicit multiplication (same as torch.mm for 2D inputs)
result = torch.matmul(matrix, vector)
print("Result (torch.matmul, explicit):", result)

# Option 2: Broadcasting (vector treated as a row matrix)
vector_as_row_matrix = vector.unsqueeze(0)  # Add a new dimension (becomes 1x3)
result_broadcasted = torch.matmul(matrix, vector_as_row_matrix)
print("Result (torch.matmul, broadcasting):", result_broadcasted.squeeze(0))  # Remove added dimension

This method is suitable if you want to perform a component-wise multiplication between the matrix and the vector, treating them as if they have the same dimensions. However, this is not true matrix-vector multiplication, which calculates the dot product.

import torch

# Create a matrix and a vector (same as before)
matrix = torch.tensor([[1, 2, 3], [4, 5, 6]])
vector = torch.tensor([7, 8, 9])

# Element-wise multiplication with broadcasting (not true matrix multiplication)
result_elementwise = matrix * vector
print("Element-wise multiplication:", result_elementwise)

Note: This approach will only work if the shapes of the matrix and vector are compatible for broadcasting. The resulting tensor will have the same dimensions as the matrix.

Using a Loop (for Custom Control):

If you need fine-grained control over the matrix-vector multiplication process, you can iterate through the rows of the matrix and calculate the dot product with the vector manually using a loop. However, this is generally less efficient than using built-in functions like torch.mm or torch.matmul.

import torch

# Create a matrix and a vector (same as before)
matrix = torch.tensor([[1, 2, 3], [4, 5, 6]])
vector = torch.tensor([7, 8, 9])

# Matrix-vector multiplication using a loop (less efficient)
result_loop = torch.zeros(matrix.shape[0], 1)  # Create a zero tensor for results
for i in range(matrix.shape[0]):
  result_loop[i] = torch.dot(matrix[i], vector)
print("Matrix-vector multiplication (loop):", result_loop)

• For standard matrix-vector multiplication, prefer torch.mm for clarity (explicit 2D inputs) or torch.matmul for versatility (handles different dimensions and broadcasting).
• Use element-wise multiplication with caution, as it's not true matrix multiplication.
• Opt for a loop-based approach only if you require custom control over the computation, understanding the trade-off in efficiency.