Linearization is a powerful technique in machine learning applied to both model

approximation and analysis. Here's a breakdown of its usage and considerations:

Concept:

Linearization involves approximating a non-linear function with a linear function

around a specific point. This simplified version captures the local behavior of the
non-linear function near that point.

Applications in ML:

1. Model Initialization: Initializing model parameters near good solutions can

accelerate training in algorithms like Neural Networks. Linearization around
initial points can guide such initialization based on local gradient information.
2. Local Explanations (XAI): Understanding how models make decisions is
crucial for interpretability. Linearization around a specific input allows building
a local linear model that approximates the original model's behavior nearby,
providing insights into the factors influencing that specific prediction.
3. Gradient-based Optimization: Many optimization algorithms rely on gradients
to update model parameters. For non-linear models, these gradients are
calculated using approximations, and linearization is sometimes used in such
approximations.
4. Symbolic Analysis: In theoretical or analytical studies, linearization around
specific points can simplify calculations and provide insights into model
behavior or properties.

Limitations and Considerations:

 Accuracy: Linearization only captures local behavior and loses accuracy as

you move away from the chosen point. Understanding the limitations of the
approximation is crucial.
 Choice of Point: The point around which you linearize significantly impacts the
approximation's accuracy and relevance. Choosing meaningful points for
analysis or interpretation is essential.
 Interpretability: Although linear models are easier to understand, interpreting
the linearized version might not directly translate to understanding the original
complex model. Careful consideration of this potential gap is necessary.

Examples:

 Approximating a non-linear activation function with a linear function around a

specific input.
 Building a local linear model to explain an individual prediction from a complex
model.
  Analyzing the stability of a non-linear system using linearized equations
around an equilibrium point.

Let's discuss how these concepts are relevant in the context of Machine Learning (ML):
1. Changing Basis:

 Principal Component Analysis (PCA): PCA is a technique used for dimensionality reduction.
It involves changing the basis of the data to represent it in terms of principal components,
which are orthogonal eigenvectors of the covariance matrix.

2. Orthogonal Matrices:

 Rotation Matrices: In ML, orthogonal matrices can be used for rotation operations. For
example, in image processing or computer vision, orthogonal matrices can be employed to
rotate images without distorting them.

3. Eigenvalues and Eigenvectors:

 PCA in Feature Extraction: In PCA, the eigenvectors of the covariance matrix represent the
directions of maximum variance in the data. These eigenvectors (principal components) can
be used as new features, and their corresponding eigenvalues indicate the amount of
variance captured by each component.

 Kernel Methods: In some ML algorithms, such as Support Vector Machines (SVMs),

eigenvectors and eigenvalues are used in the context of kernel matrices. The eigenvalues of a
kernel matrix can help determine the importance of different data points.

4. Diagonalization of Matrices:

 Spectral Clustering: Spectral clustering involves using the eigenvalues and eigenvectors of a
matrix derived from the data (e.g., affinity matrix) to perform clustering. Diagonalization can
be related to finding a more suitable representation for clustering.

 Markov Chains: In some cases, matrices representing transition probabilities in Markov

Chains can be diagonalized, simplifying long-term predictions.

These concepts are foundational for understanding the mathematical operations that take place in
many ML algorithms. They play a crucial role in optimization, dimensionality reduction, and
understanding the underlying structure of data. For example, PCA is often used for feature
extraction, and eigenvectors are essential in various algorithms and mathematical formulations in
ML.

In Machine Learning (ML), data comes in various types, and understanding the nature of the data is
crucial for selecting appropriate algorithms, preprocessing techniques, and evaluation methods. Here
are some common types of data in the context of ML:

1. Numerical Data:

 Continuous Data: Represents measurements and can take any real value within a range (e.g.,
temperature, height).

 Discrete Data: Consists of distinct, separate values (e.g., counts of items, number of
bedrooms).

2. Categorical Data:
  Nominal Data: Represents categories with no inherent order or ranking (e.g., colors, types of
fruit).

 Ordinal Data: Categories with a meaningful order or ranking (e.g., education levels, customer
satisfaction ratings).

3. Text Data:

 Natural Language Text: Unstructured textual data, often requiring specialized techniques like
Natural Language Processing (NLP) for analysis (e.g., reviews, articles).

4. Image Data:

 Pixel Values: Represented as matrices of pixel intensities, commonly used in computer vision
tasks (e.g., image classification, object detection).

5. Time Series Data:

 Temporal Data: Data collected over a sequence of time intervals (e.g., stock prices, weather
data).

6. Geospatial Data:

 Spatial Coordinates: Represents locations on the Earth's surface (e.g., GPS coordinates,
maps).

7. Audio Data:

 Waveform Data: Represents sound signals, often used in tasks like speech recognition.

8. Graph Data:

 Nodes and Edges: Represents relationships between entities in a graph (e.g., social
networks, citation networks).

9. Binary Data:

 Boolean Values: Takes on only two possible values (0 or 1), often used in binary classification
problems.

10. Mixed Data:

 Combination of Types: Datasets that contain multiple types of data (e.g., a dataset with
numerical, categorical, and text features).

Understanding the type of data is essential for feature engineering, handling missing values, and
choosing appropriate models. Different ML algorithms may be more suited to certain types of data,
and preprocessing steps may vary accordingly. For instance, decision trees and ensemble methods
may handle categorical data well, while linear regression may be more suitable for numerical data.
Preprocessing techniques such as normalization, encoding, and scaling depend on the characteristics
of the data.

In Python, handling different types of data in the context of machine learning involves using various
libraries and techniques. Here's an overview of how you might work with different types of data in
Python:

1. Numerical Data:
  Libraries: NumPy is a fundamental library for numerical operations in Python.

 Example Code:

import numpy as np

# Creating a NumPy array for numerical data

numerical_data = np.array([1.0, 2.0, 3.0])

2. Categorical Data:

 Libraries: Pandas is commonly used for working with tabular data, including categorical
variables.

 Example Code:

import pandas as pd

# Creating a Pandas DataFrame with categorical data

data = {'Category': ['A', 'B', 'A', 'C']}

df = pd.DataFrame(data)

3. Text Data:

 Libraries: The Natural Language Toolkit (NLTK) and Scikit-learn are often used for text
processing.

 Example Code:

from sklearn.feature_extraction.text import CountVectorizer

# Creating a bag-of-words representation of text data

text_data = ['This is a sample sentence.', 'Another example sentence.']

vectorizer = CountVectorizer()

X = vectorizer.fit_transform(text_data)

4. Image Data:

 Libraries: OpenCV and Pillow are commonly used for image processing.

 Example Code:

from PIL import Image

# Reading and displaying an image

image = Image.open('example_image.jpg')
image.show()

5. Time Series Data:

 Libraries: Pandas is well-suited for handling time series data.

 Example Code:

import pandas as pd

# Creating a time series with Pandas

time_series_data = pd.Series([1, 2, 3], index=pd.date_range('2022-01-01', periods=3))

6. Geospatial Data:

 Libraries: GeoPandas is an extension of Pandas for working with geospatial data.

 Example Code:

import geopandas as gpd

# Reading a shapefile with GeoPandas

gdf = gpd.read_file('example_shapefile.shp')

7. Audio Data:

 Libraries: Librosa is commonly used for audio processing.

 Example Code:

import librosa

# Loading an audio file with Librosa

audio_data, sample_rate = librosa.load('example_audio.wav')

8. Graph Data:

 Libraries: NetworkX is a powerful library for working with graph data.

 Example Code:

import networkx as nx

# Creating a graph with NetworkX

G = nx.Graph()

G.add_nodes_from([1, 2, 3])

G.add_edges_from([(1, 2), (2, 3)])

9. Binary Data:

 Libraries: No specific library required, standard Python operations are sufficient.

 Example Code:

# Working with binary data in Python binary_data = b'\x01\x02\x03'

10. Mixed Data:

 Libraries: Combining the above libraries as needed for different data types.

 Example Code:

# Working with a mixed dataset using Pandas and NumPy

mixed_data = pd.DataFrame({'Numerical': [1, 2, 3], 'Category': ['A', 'B', 'A']})

These examples provide a high-level overview of how to work with various types of data using
common Python libraries. Depending on your specific ML task, you might use different libraries and
techniques for data preprocessing, analysis, and model training.

Reading Data in Python

Reading data in Python often depends on the type of data and the format it is stored in. Here are
examples for reading common types of data using popular libraries:

1. Reading Numerical Data (CSV file):

 Library: Pandas

 Example Code:

import pandas as pd # Reading a CSV file with Pandas numerical_data =

pd.read_csv('numerical_data.csv')

2. Reading Categorical Data (CSV file):

 Library: Pandas

 Example Code:

import pandas as pd # Reading a CSV file with Pandas categorical_data =

pd.read_csv('categorical_data.csv')

3. Reading Text Data (Text file):

 Standard Python Operations:

 Example Code:
# Reading a text file in Python with open('text_data.txt', 'r') as file: text_data = file.read()

4. Reading Image Data:

 Library: Pillow

 Example Code:

from PIL import Image # Opening an image file with Pillow image = Image.open('example_image.jpg')

5. Reading Time Series Data (CSV file):

 Library: Pandas

 Example Code:

import pandas as pd # Reading a CSV file with time series data using Pandas time_series_data =
pd.read_csv('time_series_data.csv', parse_dates=['timestamp'], index_col='timestamp')

6. Reading Geospatial Data (Shapefile):

 Library: GeoPandas

 Example Code:

import geopandas as gpd # Reading a shapefile with GeoPandas gdf =

gpd.read_file('example_shapefile.shp')

7. Reading Audio Data:

 Library: Librosa

 Example Code:

import librosa # Loading an audio file with Librosa audio_data, sample_rate =

librosa.load('example_audio.wav')

8. Reading Graph Data:

 Library: NetworkX

 Example Code:

import networkx as nx # Reading a graph from an edge list file with NetworkX G =
nx.read_edgelist('graph_data.txt')

9. Reading Binary Data (Binary file):

 Standard Python Operations:

  Example Code:

# Reading binary data in Python with open('binary_data.bin', 'rb') as file: binary_data = file.read()

10. Reading Mixed Data (CSV file with mixed types):

 Library: Pandas

 Example Code:

import pandas as pd # Reading a CSV file with mixed data types using Pandas

mixed_data = pd.read_csv('mixed_data.csv')

Mathematical operations play a crucial role in data analysis for machine learning (ML). Here are
some common mathematical operations and their applications in ML:

1. Summation and Mean:

 Purpose: Compute the sum or mean of numerical data.

 Application: Calculating averages, central tendency.

import numpy as np

data = np.array([1, 2, 3, 4, 5])

sum_data = np.sum(data)

mean_data = np.mean(data)

2. Variance and Standard Deviation:

 Purpose: Measure the spread or dispersion of data.

 Application: Assessing data variability.

import numpy as np data = np.array([1, 2, 3, 4, 5]) variance_data = np.var(data) std_dev_data =

np.std(data)

3. Matrix Operations:

 Purpose: Manipulate matrices for linear algebra operations.

 Application: Feature scaling, dimensionality reduction.

import numpy as np matrix_A = np.array([[1, 2], [3, 4]]) matrix_B = np.array([[5, 6], [7, 8]]) # Matrix
multiplication matrix_result = np.dot(matrix_A, matrix_B)

4. Normalization:

 Purpose: Scale numerical features to a standard range.

  Application: Preprocessing data for ML algorithms.

from sklearn.preprocessing import MinMaxScaler data = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])
scaler = MinMaxScaler() normalized_data = scaler.fit_transform(data)

5. Dot Product:

 Purpose: Calculate the dot product of vectors.

 Application: Similarity computations, projection.

import numpy as np vector_A = np.array([1, 2, 3]) vector_B = np.array([4, 5, 6]) dot_product =

np.dot(vector_A, vector_B)

6. Eigenvalue and Eigenvector Decomposition:

 Purpose: Analyze the dominant directions and magnitudes in data.

 Application: Principal Component Analysis (PCA), dimensionality reduction.

import numpy as np matrix_A = np.array([[1, 2], [3, 4]]) eigenvalues, eigenvectors =

np.linalg.eig(matrix_A)

7. Logarithm and Exponential:

 Purpose: Transform data to handle large or small values.

 Application: Feature engineering, dealing with skewed distributions.

import numpy as np data = np.array([1, 10, 100]) log_transformed = np.log(data)

exponential_transformed = np.exp(data)

8. Cross-Product:

 Purpose: Calculate the cross-product of vectors.

 Application: 3D geometry, orientation determination.

import numpy as np vector_A = np.array([1, 2, 3]) vector_B = np.array([4, 5, 6]) cross_product =

np.cross(vector_A, vector_B)

9. Correlation Coefficient:

 Purpose: Measure the strength and direction of a linear relationship between two variables.

 Application: Feature selection, understanding feature importance.

import numpy as np x = np.array([1, 2, 3, 4, 5]) y = np.array([2, 4, 5, 4, 5]) correlation_coefficient =
np.corrcoef(x, y)[0, 1]

10. Integration and Differentiation:

 Purpose: Analyze functions, calculate area under curves.

 Application: Signal processing, anomaly detection.

from scipy.integrate import quad

from scipy.misc import derivative

def f(x):

return x**2 # Integration area, error = quad(f, 0, 1) # Differentiation derivative_at_x_1 = derivative(f,

1.0, dx=1e-6)

Handling missing values is a crucial step in the data preprocessing pipeline for machine learning.
Different strategies can be employed based on the nature of the data and the extent of missingness.
Here are several common techniques for handling missing values in Python:

1. Dropping Missing Values:

Description: Remove rows or columns containing missing values.

Library: Pandas

python

import pandas as pd

# Drop rows with any missing values

df_without_missing = df.dropna()

# Drop columns with any missing values

df_without_missing_columns = df.dropna(axis=1)

2. Imputation:

Description: Fill missing values with a substitute value (e.g., mean, median, mode).

Library: Pandas

python
import pandas as pd

# Impute missing values with mean

df_filled_mean = df.fillna(df.mean())

# Impute missing values with median

df_filled_median = df.fillna(df.median())

3. Forward Fill (or Backward Fill):

Description: Fill missing values with the previous (or next) non-missing value.

Library: Pandas

python

import pandas as pd

# Forward fill missing values

df_forward_filled = df.ffill()

# Backward fill missing values

df_backward_filled = df.bfill()

4. Interpolation:

Description: Estimate missing values based on the values before and after.

Library: Pandas

python

import pandas as pd

# Linear interpolation

df_interpolated = df.interpolate()

5. Using Scikit-Learn:

Description: Scikit-learn provides an Imputer class for imputation.

Library: Scikit-learn
python

from sklearn.impute import SimpleImputer

# Create an imputer object

imputer = SimpleImputer(strategy='mean')

# Fit and transform the data

df_imputed = pd.DataFrame(imputer.fit_transform(df), columns=df.columns)

6. Advanced Imputation Techniques:

Description: Utilize more sophisticated imputation methods.

Library: Fancyimpute, impyute

python

from fancyimpute import KNN

# Impute missing values using K-nearest neighbors

df_imputed_knn = pd.DataFrame(KNN(k=3).fit_transform(df))

7. Indicator for Missing Values:

Description: Create a binary indicator variable for missing values.

Library: Pandas

python

import pandas as pd

# Create a binary indicator for missing values

df['missing_indicator'] = df.isnull().astype(int)

8. Delete Columns with High Missingness:

Description: Remove columns with a high percentage of missing values.

Library: Pandas

python
import pandas as pd

# Drop columns with more than 30% missing values

threshold = 0.3

df_filtered = df.dropna(thresh=len(df) * (1 - threshold), axis=1)

The multivariate chain rule plays a crucial role in various aspects of machine
learning:

1. Backpropagation in Neural Networks:

 Neural networks consist of layers of interconnected nodes where each node

performs a weighted sum and nonlinear activation.
 Backpropagation calculates the gradients of the loss function with respect to
each weight in the network.
 This calculation utilizes the chain rule repeatedly to differentiate the complex
composition of layers and activation functions, ultimately allowing updates to
adjust weights in the direction that minimizes the loss.

2. Feature Engineering:

 Many feature engineering techniques involve transforming or combining

existing features.
 Understanding how these transformations impact the final predictions often
requires applying the chain rule.
 For example, imagine calculating the derivative of a logistic regression output
with respect to a transformed feature created using another function.

3. Symbolic Differentiation:

 Symbolic differentiation tools like SymPy can handle the chain rule
automatically, allowing for theoretical analysis of models or feature
transformations.
 This analysis can provide insights into model behavior and limitations.

4. Optimization Algorithms:

 Some optimization algorithms rely on gradient information to update model

parameters during training.
  The chain rule is essential for calculating accurate gradients in scenarios
where functions involve multiple variables or nested computations.

5. Understanding Model Behavior:

 By applying the chain rule, you can analyze how specific input changes
contribute to changes in the model's predictions.
 This can be helpful for interpreting model behavior and gaining insights into its
decision-making process.
 import sympy as sp

 # Define symbolic variables
 x, y = sp.symbols('x y')

 # Define a symbolic function
 f = sp.sin(x * y) + sp.exp(x + y)

 # Calculate partial derivatives
 df_dx = f.diff(x)
 df_dy = f.diff(y)

 # Print the partial derivatives
 print("Partial derivative with respect to x:", df_dx)
 print("Partial derivative with respect to y:", df_dy)

Building Approximate Functions: Powerful Tools for

Simplification
Building approximate functions is a vital technique in various fields, including
mathematics, physics, engineering, and even machine learning. It allows you to
simplify complex functions or represent them in a more manageable form while still
capturing their essential characteristics. Here are some key methods for building
approximate functions:

1. Taylor Series:

 Concept: Represents a function as an infinite series of polynomial terms

around a specific point.
 Application: Used to approximate functions near that point, often providing
high accuracy for functions with smooth behavior.
 Example: Approximating sin(x) near x = 0 using sin(x) ≈ x - x^3/3! + x^5/5!.
 Limitations: Approximation accuracy diminishes as we move away from the
center point.
2. Pade Approximations:

 Concept: Represent a function as the ratio of two polynomials.

 Application: Can achieve high accuracy over a wider range compared to
Taylor series for certain functions.
 Example: Approximating e^x over a large interval using a rational function.
 Limitations: Finding optimal Pade approximants can be computationally
expensive.

3. Chebyshev Polynomials:

 Concept: Orthonormal polynomial basis set defined on the interval [-1, 1].
 Application: Excellent for approximating smooth functions on closed intervals
due to their optimality properties.
 Example: Approximating a complex function defined on [-1, 1] using a
Chebyshev series expansion.
 Limitations: Less intuitive compared to Taylor series, requires special
numerical techniques for calculations.

4. Fourier Series:

 Concept: Represent a periodic function as an infinite series of sine and cosine

terms.
 Application: Ideal for representing and analyzing periodic signals and
systems.
 Example: Approximating a square wave using a Fourier series of sine
functions.
 Limitations: Limited to periodic functions, may require complex number
representation.

5. Wavelets:

 Concept: Localized basis functions allowing multi-scale approximation.

 Application: Useful for representing functions with sharp features or
discontinuities.
 Example: Approximating a signal with abrupt changes using wavelet
decomposition.
 Limitations: Choosing appropriate wavelets and complexity can be
challenging.

Choosing the Right Tool:

The best method for building an approximate function depends on the specific
problem at hand. Consider factors like:

 Type of function: Is it periodic, smooth, or has discontinuities?

 Desired accuracy: How close does the approximation need to be?
 Range of validity: Over what domain is the approximation needed?
 Computational complexity: How easy is it to implement and calculate the
approximation?
Building approximate functions plays a crucial role in various areas of machine
learning:

1. Model Representation and Simplification:

 Deep Neural Networks: These inherently complex models can be

approximated using methods like knowledge distillation, where a smaller
network learns from a larger, pre-trained network. This reduces computational
cost and storage requirements while maintaining comparable performance.
 Decision Trees and Rule-Based Models: Building simpler approximations of
complex models like Random Forests can improve interpretability and
understanding of their decision-making process.
 Feature Engineering: Transforming features based on approximations of
complex relationships can improve model performance and efficiency.

2. Learning Algorithms and Optimization:

 Surrogate Models: In computationally expensive problems, building

approximate models of objective functions or data distributions allows faster
optimization and training.
 Bayesian Inference: Variational Inference and other techniques approximate
complex probability distributions with simpler ones to make inference and
learning tractable.

3. Uncertainty Quantification and Confidence Estimation:

 Ensemble Methods: Aggregating predictions from multiple models provides an

approximation of the overall prediction uncertainty.
 Dropout and Monte Carlo Methods: These techniques introduce randomness
during training, leading to an ensemble of models and uncertainty estimates
for predictions.

4. Anomaly Detection and Outlier Identification:

  One-Class Classification: Training a model on normal data points allows
identifying deviations as potential anomalies using approximations of the
normal distribution boundaries.
 Reconstruction Error: Reconstructing data points using models and
comparing the reconstruction error can help identify unexpected outliers.

5. Explainable AI (XAI):

 Local Explanations: Building approximate local models around specific data

points can explain individual predictions and contribute to understanding
model behavior.
 Counterfactual Explanations: Approximating how different input changes
would affect the output provides insights into the factors influencing model
decisions.

Limitations and Considerations:

 Approximation methods introduce errors, so choosing the right method and

evaluating the trade-off between accuracy and efficiency is crucial.
 Interpretability of the original model might be lost when using approximations,
requiring careful selection and interpretation techniques.

The multivariate Taylor series extends the familiar single-variable Taylor series to
functions involving multiple variables. It provides a powerful tool for approximating
and analyzing such functions by expressing them as sums of polynomial terms
around a specific point.

Formal Definition:

Consider a function f(x_1, x_2, ..., x_n) where x_1, x_2, ..., x_n are
variables. The multivariate Taylor series of f centered at a = (a_1, a_2, ..., a_n)
is:

f(x) = f(a) + ∑(i=1)^(n) ∑(j=1)^(n) ∂^2 f / ∂x_i ∂x_j |_a (x_i - a_i)(x_j - a_j) + ...

 1/n! ∑(i1,...,in=1)^(n) ∂^n f / ∂x_i1 ... ∂x_in |_a (x_i1 - a_i1)(x_i2 - a_i2) ... (x_in
- a_in) + ...

where:

 ∂^n f / ∂x_i1 ... ∂x_in |_a denotes the nth-order partial derivative
of f with respect to x_i1, x_i2, ..., x_in evaluated at a.
 The summation represents all possible combinations of partial derivatives up
to a certain order.
  The higher-order terms contribute progressively less as the distance
from a increases.

Applications:

 Approximation: Taylor series provides accurate approximations of multivariate

functions near the center point, aiding in various scientific and engineering
fields.
 Optimization: By approximating objective functions in optimization problems,
Taylor series facilitates gradient-based techniques for finding optimal
solutions.
 Analysis: Analyzing the convergence properties of the Taylor series can
reveal valuable insights about the function's behavior and smoothness.

Limitations:

 The accuracy of the approximation depends on the number of terms included

and the proximity to the center point. As the distance increases, higher-order
terms become crucial.
 Calculating higher-order partial derivatives can be computationally expensive
for complex functions.

Comparison with Single-Variable Taylor Series:

The key difference is the summation structure, which accounts for all possible
combinations of partial derivatives in the multivariate case. While the basic idea of
polynomial approximation remains, the complexity increases significantly with
multiple variables.

Python Implementation:

While the multivariate Taylor series isn't directly used within machine learning
models themselves, it plays a crucial role in several key areas:

1. Understanding Model Behavior:

 Local Approximations: By constructing a local Taylor series approximation

around a specific input, you can gain insights into how a model makes
decisions close to that point. This can be helpful for interpreting complex
models like neural networks.
 Convergence Analysis: Analyzing the convergence behavior of Taylor series
expansions related to optimization algorithms used in machine learning can
provide insights into factors affecting generalization and overfitting.

2. Feature Engineering:
  Symbolic Transformations: In some cases, feature engineering involves
symbolic transformations of existing features. Understanding how these
transformations impact the final predictions often requires applying the chain
rule, which is essentially a multivariate Taylor series expansion of a composite
function.

3. Optimization Algorithms:

 Gradient Updates: Many optimization algorithms rely on gradients to update

model parameters during training. In specific scenarios, these gradients might
be calculated using approximations, and Taylor series expansions can
sometimes be involved in such approximations.

4. Symbolic Differentiation and Analysis:

 Theoretical Exploration: Symbolic differentiation tools like SymPy can handle

multivariate Taylor series, allowing for analyzing model behavior, feature
transformations, and other aspects without numerical calculations. This can
be valuable for theoretical studies and exploration.

5. Limitations and Considerations:

 Computational Cost: Calculating higher-order partial derivatives for complex

functions can be computationally expensive, limiting its practical use in large-
scale machine learning problems.
 Practical Use: While the underlying concepts are important, directly applying
multivariate Taylor series calculations within algorithms is less common
compared to other techniques.

Examples: