**π‘ Problem Formulation:** When dealing with real-world data, one often encounters non-linear relationships between variables. Fitting such data requires specialized techniques, as traditional linear models fall short. In Python, various libraries and methods facilitate the process of fitting non-linear models to complex datasets. For instance, given a dataset with predictors `x`

and non-linearly related response `y`

, our goal is to find a model that best captures the underlying pattern and makes accurate predictions.

## Method 1: Polynomial Regression

Polynomial regression extends linear regression by considering polynomial features of the input data. This method allows the linear model to fit more flexible curves to the data. In Python, `numpy`

and `scikit-learn`

libraries are typically used to perform polynomial regression.

Here’s an example:

from sklearn.preprocessing import PolynomialFeatures from sklearn.linear_model import LinearRegression import numpy as np # Sample dataset x = np.array([1, 2, 3, 4, 5]).reshape(-1, 1) y = np.array([1, 4, 9, 16, 25]) # Transform data to include polynomial features poly = PolynomialFeatures(degree=2) x_poly = poly.fit_transform(x) # Fit the Linear Regression model model = LinearRegression().fit(x_poly, y)

Output: The model is now fit to the non-linear data.

In this code snippet, we first transformed our input data `x`

into a polynomial feature space using the `PolynomialFeatures`

class. Then we used the transformed dataset `x_poly`

to fit a `LinearRegression`

model. This approach effectively captures the non-linear relationship by considering the additional polynomial features when minimizing the residual sum of squares.

## Method 2: Decision Trees

Decision trees are a non-parametric supervised learning method used for classification and regression. They are capable of fitting complex datasets by learning simple decision rules inferred from the data features. `scikit-learn`

provides an easy-to-use decision tree implementation.

Here’s an example:

from sklearn.tree import DecisionTreeRegressor # Sample dataset x = [[1], [2], [3], [4], [5]] y = [2, 4, 5, 4, 5] # Fit the Decision Tree model tree = DecisionTreeRegressor().fit(x, y)

Output: A decision tree model that fits the non-linear data pattern.

The `DecisionTreeRegressor`

class is used to create a decision tree that can handle non-linear relationships. By calling the `fit`

method, the model learns from the input `x`

to predict the target `y`

. The beauty of decision trees lies in their ability to capture non-linearities and interactions between variables without requiring any transformation of the data.

## Method 3: Support Vector Machines (SVM) with Non-linear Kernels

SVMs are powerful classifiers that can also be adapted for regression in what’s called Support Vector Regression (SVR). Using non-linear kernel functions, SVMs can fit non-linear data. The `sklearn.svm.SVR`

module makes it easy to apply SVR with different kernels.

Here’s an example:

from sklearn.svm import SVR # Sample dataset x = np.array([1, 2, 3, 4, 5]).reshape(-1, 1) y = [2, 1, 4, 3, 7] # Fit the SVR model with a non-linear kernel svr_rbf = SVR(kernel='rbf').fit(x, y)

Output: A non-linear SVR model is successfully trained.

In the provided code, an SVR model with a Radial Basis Function (RBF) kernel is created. The RBF kernel allows the SVR to approximate the non-linear function that generated the data. The `fit`

function is then used to train the model on the given `x`

(features) and `y`

(target) dataset.

## Method 4: Neural Networks

Neural networks excel at capturing complex patterns due to their deep architecture. When configured with non-linear activation functions, they become powerful tools for modeling non-linear relationships. Libraries like TensorFlow and Keras provide user-friendly interfaces for building and training neural networks.

Here’s an example:

from keras.models import Sequential from keras.layers import Dense # Sample dataset x = np.array([1, 2, 3, 4, 5]) y = np.array([1.2, 1.9, 3.05, 4.1, 5.15]) # Constructing the Neural Network model = Sequential() model.add(Dense(units=10, activation='relu', input_dim=1)) model.add(Dense(units=1)) # Compiling the model model.compile(optimizer='adam', loss='mean_squared_error') # Fit the Neural Network model.fit(x, y, epochs=200, verbose=0)

Output: The neural network is now trained to fit the non-linear dataset.

The above snippet defines a simple neural network using Keras. It consists of an input layer, one hidden layer with 10 neurons and a ReLU activation function, and an output layer. After compiling the network with an appropriate optimizer and loss function, it is fit to the dataset `x`

, `y`

through multiple epochs for better approximation of the non-linearity.

## Bonus Method 5: K-Nearest Neighbors (KNN)

K-Nearest Neighbors is a simple yet effective algorithm that makes predictions based on the surrounding neighbors of a data point in the feature space. This method can capture non-linear patterns by considering a localized model rather than a global one, as implemented in `scikit-learn`

.

Here’s an example:

from sklearn.neighbors import KNeighborsRegressor # Sample dataset x = np.array([1, 2, 3, 4, 5]).reshape(-1, 1) y = [2.1, 3.1, 2.2, 5.1, 7.2] # Fit the KNN model knn = KNeighborsRegressor(n_neighbors=2).fit(x, y)

Output: A KNN model is trained to fit the non-linear data.

In this code snippet, we initialize the `KNeighborsRegressor`

with `n_neighbors=2`

, indicating that the prediction for a new data point will be the average of the two closest points in the feature space. Thus, the model captures the local patterns within the data without any assumptions about the data’s global structure.

## Summary/Discussion

**Method 1: Polynomial Regression.**Best suited for datasets with a clear polynomial relationship. Requires choosing the correct degree. Can lead to overfitting if the degree is too high.**Method 2: Decision Trees.**Easily interpretable and can model complex non-linear relationships. Prone to overfitting but can be mitigated with pruning or ensemble methods.**Method 3: SVM with Non-linear Kernels.**Highly effective for many non-linear problems. Can be computationally intensive and requires careful selection of kernel and regularization parameter.**Method 4: Neural Networks.**Highly flexible and powerful for large datasets with complex relationships. Requires a lot of data and computational power. Risk of overfitting and difficult to interpret.**Bonus Method 5: K-Nearest Neighbors.**Simple and effective. No assumptions about data. May not perform well on high dimensional data due to the curse of dimensionality.