What is Jacobian Matrix?

Have you ever considered how the shortest route to your location is determined by Google Maps? Or how you’re automatically moving the steering wheel will impact the motion of your vehicle when you spin it? Well, it all comes down to the Jacobian Matrix. The Jacobian Matrix is a matrix of partial derivatives of a vector function. The transformation of Jacobian spherical coordinates is where the Jacobian is most commonly used. It addresses the idea of Jacobian spherical coordinates transformation in differentiation. In this article, we’ll be discussing the mathematical concept of the Jacobian Matrix, its formula, determinants, and how we’re using it in our daily lives.

What is the Jacobian?

The Jacobian matrix and its determinants are defined for a finite number of functions with the same number of variables, and are referred to as “Jacobian”. It tells us how changes in one set of variables affect another set of variables in a function that maps between different spaces.

In this scenario, the first partial derivative of the same function concerning the variables is found in each row. The matrix can be of either form – a square matrix with an equal number of rows and columns, or a rectangular matrix with an uneven number of rows and columns.

Example: While trekking through a mountain with an upside-down trail, there is usually a direction and a degree of steepness. No matter where you are on the mountain, the Jacobian is like having your guide who tells you how steep your climb will be and which way you are going.

Also Read: Mathematics behind Machine Learning – The Core Concepts you Need to Know

What is a Jacobian Matrix?

Now, a Jacobian matrix is a matrix consisting of partial derivatives that shows the transformation of an input vector into an output vector by a function. It explains how each output changes with respect to every input variable. For a function f: ℝⁿ → ℝᵐ  having total number of m components and n variables, the Jacobian formula can be represented as:

Symbolic Jacobian matrix:
Matrix([[2*x, -1], [2*y, 2*x]])

Jacobian at point (2, 3):
Matrix([[4, -1], [6, 4]])

Determinant of Jacobian (symbolic):
4*x**2 + 2*y

Determinant at point (2, 3):
22

Numerical Jacobian at point (2, 3):

[[ 4.000001 -1.      ]  
 [ 6.        4.      ]]

Here, the Jacobian Formula will give local linear approximation to a function around a point and give explanation about how the function is stretching, rotating, and transforming space.

Mathematical Foundations of the Jacobian Matrix

In order to understand the Jacobian Matrix fully, we’ll be discussing different foundations of mathematics:

1. Vector-valued Functions & Multivariable Calculus

It basically refers to the functions that map points from one space to another. These functions have multiple outputs corresponding to multiple inputs. Such functions give the foundation structures of real-life systems like fluid dynamics.

The Jacobian combines linear algebra and multi-variable calculus. Scalar derivatives tell us about the rate of change in single-variable functions. It also explains about rates of change in functions with multiple inputs and outputs presented in matrix format.

Also Read: 12 Matrix Operations You Should Know While Starting your Deep Learning Journey

2. Notation & Dimensions

The structure and the formatting of a Jacobian matrix explain important information about the representation of the transformation. For a function f: ℝⁿ into ℝᵐ, where ‘n’ represents the input and ‘m’ output, the Jacobian is an ‘m’ by ‘n’ matrix. The entries of the Jacobian matrix denote Jᵢⱼ=∂fᵢ/∂xⱼ , the representation of i’th output functions change with respect to the j’th input variable.

So, the dimensions of a matrix affect the transformation. From a 3D space to a 2D space, Jacobian will have rows equal to outputs and columns equal to inputs, which results in a 2*3 matrix.

3. Geometric Interpretations

The functional behaviour of the Jacobian also explains the visual insights with the algebraic definition. The following interpretation helps us in identifying how the Jacobian matrix describes the local behaviour of functions in geometric terms.

• Local Linear Transformation: The Jacobian gives the function the most linear approximation in the neighbourhood of the points. It explains how an infinitely small region about an input point maps to the output one.
• Tangent Approximation: The Jacobian translates tangent vectors from the input space to the output space, and conversely. When thought of as surfaces, it gives a local description of how those surfaces are turned with respect to each other.

4. Jacobian & Invertibility of Jacobian Function

The relationship between the Jacobian and Invertibility proved necessary information. It provided insights into the local behavior of the function at a particular point.

• |J| > 0: The local orientation is preserved by the function.
• |J| < 0: The local orientation is reversed by the function.
• |J| = 0: Invertibility at particular critical point is lost

A function is said to be invertible in a neighbourhood whenever the Jacobian is non-singular, its determinant being not equal to zero. Then coinciding with that point we’ll have our Inverse Function theorem. But whenever the Jacobian determinant becomes zero, the output domain undergoes folding, compaction, or localization.

Also Read: A Comprehensive Beginners Guide to Linear Algebra for Data Scientists

Properties of the Jacobian

Now let’s understand the properties of the Jacobian.

1. Chain Rule: For composite functions, the Jacobians can be multiplied to obtain the Jacobian of the composition.
2. Directional derivatives: The Jacobian can be used to calculate the directional derivative along any direction.
3. Linear approximation: The approximation of the function near any point is given by f(x + Δx) ≈ f(x) + J(x) · Δx.

Computing the Jacobian Matrix

Now, we’ll see three different methods of computing the Jacobian Matrix and transformation of Jacobian spherical coordinates – Analytical Derivation, Numerical Approximation and Automatic Differentiation.

Analytical Derivation of Jacobian Matrix

It is the classical way that relies on direct computation of the partial derivatives to produce the Jacobian matrix providing insight into the transformation structure. It is achieved by systematically differentiating each component function with respect to each input variable.

Let’s consider an example where vector function  f: ℝⁿ → ℝᵐ with components f₁, f₂, …, fₘ, and variables x₁, x₂, …, xₙ is computed with the partial derivative ∂fi/∂xj for each j=1,2,….n.

J(x) = [
∂f₁/∂x₁  ∂f₁/∂x₂  ...  ∂f₁/∂xₙ
∂f₂/∂x₁  ∂f₂/∂x₂  ...  ∂f₂/∂xₙ
...      ...      ...  ...
∂fₘ/∂x₁  ∂fₘ/∂x₂  ...  ∂fₘ/∂xₙ
]

Example: f(x,y) = (x²-y, 2xy), the partial derivatives evaluated are:

∂f₁/∂x = 2x
∂f₁/∂y = -1
∂f₂/∂x = 2y
∂f₂/∂y = 2x

And by this we can say that the Jacobian matrix observed is:

J(x,y) = [2x  -1
2y  2x]

By this method, we can see exact results. However, things can get complicated while dealing with multiple variables at a time or complicated functions where computations are not possible.

Numerical Approximation of the Jacobian Matrix

Whenever an analytical derivation is either too bulky to carry out or when a function lacks a form expression, numerical methods offer practical alternative solutions that compute partial derivatives using finite differences. The two principal finite difference methods are:

1. Forward difference:

∂fi/∂xⱼ ≈ [f(x₁,...,xⱼ+h,...,xₙ) - f(x₁,...,xⱼ,...,xₙ)]/h

2. Central difference with higher accuracy

∂fi/∂xⱼ ≈ [f(x₁,...,xⱼ+h,...,xₙ) - f(x₁,...,xⱼ-h,...,xₙ)]/(2h)

Here, h = small step that typically would be of order of 10⁻⁶ for double precision.

It is all about choosing the right size of step to take. Too big brings in approximation errors while small causes numerical instability due to floating point limitations. Advanced techniques using adaptive step sizing or Richardson extrapolation can improve accuracy further.

Automatic Differentiation of Jacobian Matrix

Automatic differentiation which combines analytical accuracy with computational automation is very high on the list. It is different from the numerical method in that AD computes exact derivatives rather than approximating them which leads to avoiding errors of discretization. The basis principles of automatic differentiation are:

1. Application of Chain Rule: It systematically applies the chain rule for elementary operations that comprise the function.
2. Representation of the computational graph: The function is decomposed into a pointed graph in primitive operations with known derivatives.
3. Forward and Reverse Nodes: Forward mode propagates derivatives from input to output while reverse mode propagates the derivatives back from the output to the input.

This makes automatic differentiation very accessible and efficient for modern software frameworks such as TensorFlow, PyTorch, JAX. They prefer it for computing Jacobians in machine learning, and optimization problems with the scientific ones.

Calculating Jacobian Matrix and determinant using Python

Let’s see how we can implement a Jacobian matrix and jacobian spherical coordinates using Python. We’ll use both symbolic computation and numerical approximation with SymPy and NumPy respectively.

Step 1: Set Up the Environment

Import the necessary paths required to run the function.

import numpy as np
import sympy as sp
import matplotlib.pyplot as plt
from matplotlib.patches import Ellipse

Step 2: Perform the Symbolic Computation

Write the function for symbolic computation with SymPy.

def symbolic_jacobian():
   x, y = sp.symbols('x y')
   f1 = x**2 - y
   f2 = 2*x*y
  
   # Define the function vector
   f = sp.Matrix([f1, f2])
   X = sp.Matrix([x, y])
  
   # Calculate the Jacobian matrix
   J = f.jacobian(X)
  
   print("Symbolic Jacobian matrix:")
   print(J)
  
   # Calculate the Jacobian at point (2, 3)
   J_at_point = J.subs([(x, 2), (y, 3)])
   print("\nJacobian at point (2, 3):")
   print(J_at_point)
  
   # Calculate the determinant
   det_J = J.det()
   print("\nDeterminant of Jacobian (symbolic):")
   print(det_J)
   print("\nDeterminant at point (2, 3):")
   print(det_J.subs([(x, 2), (y, 3)]))
  
   return J, det_J

Step 3: Add the Numerical Approximation

Write the function for numerical approximation with NumPy.

def numerical_jacobian(func, x, epsilon=1e-6):
   n = len(x)  # Number of input variables
   m = len(func(x))  # Number of output variables
  
   jacobian = np.zeros((m, n))
  
   for i in range(n):
       x_plus = x.copy()
       x_plus[i] += epsilon
      
       jacobian[:, i] = (func(x_plus) - func(x)) / epsilon
      
   return jacobian

Step 4: Write the Execution Function

Write the main function for the execution of above function and visualization of transformation.

def f(x):
   return np.array([x[0]**2 - x[1], 2*x[0]*x[1]])


# Visualize the transformation
def visualize_transformation():
   # Create a grid of points
   x = np.linspace(-3, 3, 20)
   y = np.linspace(-3, 3, 20)
   X, Y = np.meshgrid(x, y)
  
   # Calculate transformed points
   U = X**2 - Y
   V = 2*X*Y
  
   # Plot original and transformed grid
   fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 6))
  
   # Original grid
   ax1.set_title('Original Space')
   ax1.set_xlabel('x')
   ax1.set_ylabel('y')
   ax1.grid(True)
   ax1.plot(X, Y, 'k.', markersize=2)
  
   # Add a unit circle
   circle = plt.Circle((0, 0), 1, fill=False, color='red', linewidth=2)
   ax1.add_artist(circle)
   ax1.set_xlim(-3, 3)
   ax1.set_ylim(-3, 3)
   ax1.set_aspect('equal')
  
   # Transformed grid
   ax2.set_title('Transformed Space')
   ax2.set_xlabel('u')
   ax2.set_ylabel('v')
   ax2.grid(True)
   ax2.plot(U, V, 'k.', markersize=2)
  
   # Calculate the transformation of the unit circle
   theta = np.linspace(0, 2*np.pi, 100)
   x_circle = np.cos(theta)
   y_circle = np.sin(theta)
   u_circle = x_circle**2 - y_circle
   v_circle = 2*x_circle*y_circle
   ax2.plot(u_circle, v_circle, 'r-', linewidth=2)
  
   # Show the local linear approximation at point (1, 0)
   point = np.array([1, 0])
   J = numerical_jacobian(f, point)
  
   # Calculate how the Jacobian transforms a small circle at our point
   scale = 0.5
   transformed_points = []
   for t in theta:
       delta = scale * np.array([np.cos(t), np.sin(t)])
       transformed_delta = J @ delta
       transformed_points.append(transformed_delta)
  
   transformed_points = np.array(transformed_points)
  
   # Plot the approximation
   base_point_transformed = f(point)
   ax2.plot(base_point_transformed[0] + transformed_points[:, 0],
            base_point_transformed[1] + transformed_points[:, 1],
            'g-', linewidth=2, label='Linear Approximation')
  
   ax2.legend()
   plt.tight_layout()
   plt.show()


# Execute the functions
symbolic_result = symbolic_jacobian()
point = np.array([2.0, 3.0])
numerical_result = numerical_jacobian(f, point)


print("\nNumerical Jacobian at point (2, 3):")
print(numerical_result)


# Visualize the transformation
visualize_transformation()

Output:

Output Review:

The nonlinear mapping f(x,y) = (x²-y, 2xy) is proposed, and the Jacobian properties are highlighted. The original space is shown at left with a uniform grid and a unit circle, while the right map shows the space after transformation, where the circle has morphed into a figure-eight.

The Jacobian matrix is calculated both symbolically (Matrix([[2x, -1], [2y, 2*x]])) and at the numerical point (2,3). It shows a determinant equal to 22. This signifies a large stretch of area locally. Thus, this analysis provides a mathematical view of how the transformation distorts the area. The linearization (green curve) represents the local structure of this nonlinear mapping.

Applications of the Jacobian Matrix

The latest ML frameworks include automatic differentiation tools that compute the Jacobian matrix for us. This is a game changer for complex applications such as:

1. Velocity control by Robotic Arm: With the help of Jacobian, one can indicate how the application’s angular joint velocities would correlate with the end-effector velocities, which allows precision paths for movement.
2. Stability Analysis of Dynamical Systems: The system stability will determine how well it is in line with the movement of its eigenvalues, where equilibria are found.
3. Snake Robot Obstacle Navigation: These use the Jacobian to relate joint speeds to head velocity and create locomotion strategies in tight spaces.
4. Motion Planning for Manipulators: The Jacobian computes the joint trajectories needed to reach desired end-effector positions, critical in pick and place operations in automation.
5. Force-Torque Transformation in Robotics: It means converting end-effector forces like grip strength to join equivalent torques necessary in force-sensitive applications.

Conclusion

Calculus, differential geometry, and linear algebra are all disciplines of mathematics that the Jacobian Matrix ties together and applies to real-world applications. From the advanced surgical robots to GPS locations, the Jacobian plays a huge role in making the technology more responsive. It’s an example of how mathematics can both describe our universe and help us interact with it more effectively and efficiently.

Frequently Asked Questions