Leveraging Quadratic Polynomials in Python for Advanced Data Analysis

2.1 Design and development environment

In this study, we focused on applying quadratic polynomials in Python for data analysis, highlighting the importance of these mathematical expressions in modeling and interpreting complex datasets using the following key concepts:

A quadratic polynomial is an algebraic equation of the second degree, which includes a term raised to a power of two (squared). The general form of a quadratic polynomial is$y=a{x}^2+\mathit{bx}+c$, where $\left(y\right)$ is the dependent variable; $\left(x\right)$ is the independent variable; and $\left(a\right),\left(b\right),\left(c\right)$ are the coefficients of the polynomial estimated by the regression model. The quadratic term ($a{x}^2)$ allows the model to capture the curvature in the data, which is indicative of acceleration increases or decreases that are common in many natural phenomena.

Some key features of quadratic polynomials are that they have two terms with a variable $\left(x\right)$ - one is $\left(x\right)$ - squared, and the other is $\left(x\right)$ to the first power. The $\left(x^2\right)$ term has a non-zero coefficient $\left(a\right)$. This makes it a quadratic polynomial rather than a linear polynomial. When plotted, quadratic polynomials form a parabolic shape rather than a straight line. The quadratic polynomials have up to two distinct real roots for the equation $x^2+\mathit{bx}+c=0$. These solutions were obtained by factoring or by using a quadratic formula. Examples of quadratic polynomials include the vertex form $y=a{(x-h)}^2+k$, and the standard form $y=a{x}^2+\mathit{bx}+c$. A quadratic polynomial has a squared, linear, and constant term, graphs as a parabola, and two roots at most.

Understanding their structures allows many mathematical and real-world problems to be solved. We provide an example of the Python script below, which employs a quadratic polynomial fitting technique–a method used in regression analysis to model the relationship between a dependent variable and one or more independent variables. In this case, the independent variable is time (represented in months), and the dependent variable is the metric of interest (such as pollution levels).

After fitting the quadratic polynomial to the data, the script generated a smooth fitted curve that represented the estimated values of the dependent variable across a range of independent variables. This curve helps to visualize the overall trend and any potential seasonal patterns or anomalies in the dataset.

The coefficient of determination, commonly known as R-squared $\left(R^2\right)$, was then calculated to quantify the goodness of fit of the polynomial model. It is a statistical measure that indicates the proportion of variance in the dependent variable that is predictable from independent variable(s). An $\left(R^2\right)$ value of one (1) indicated a perfect fit, indicating that the model explained all the data variability around its mean. In contrast, an $\left(R^2\right)$ value closer to zero (0) indicates that the model fails to accurately model the data.

For more in-depth information on quadratic polynomial fitting and calculation of the coefficient of determination, the following sources (Norman R. Draper and Harry Smith, 2014; Douglas et al., 2021) provide a comprehensive overview of seminal works on regression analysis and detailed explanations of various regression techniques, including quadratic polynomial fitting and interpretation $\left(R^2\right)$.

Next, we applied quadratic polynomial fitting and R-squared in Python for the data analysis.

In this case, the Python script exemplifies the application of regression analysis using the NumPy, Matplotlib, scikit-learn, and Pandas libraries to model and visualize trends in time-series data. A core component of this analysis is the fitting of a quadratic polynomial to the data, grounded in the principles of statistical learning.

The schematic block diagram on Figure 1 shows the framework of the explanted application in this research: implementing quadratic polynomials in Python for advanced data analysis.

Figure 1. The schematic block diagram of the implementing quadratic polynomials in python for advanced data analysis.

2.2 Data preprocessing

2.2.1 Handling missing data

Before fitting the quadratic model, it is crucial to address any missing values in the dataset to ensure the accuracy and reliability of the model. Common techniques for handling missing data include:

In the context of machine learning, the exclusion of rows containing missing values without the application of imputation techniques can result in substantial data attrition, particularly in datasets with a high incidence of missing entries. This practice can diminish the statistical power of the analysis and introduce bias into the results. Imputation mitigates this bias by populating missing values with plausible data points, thus enabling the model to utilize the maximum amount of available data. Models that are trained on complete datasets, including imputed values, exhibit greater consistency and robustness compared to those trained on datasets with omitted missing values (Liu et al., 2020; Dubey & Rasool, 2021).

For numerical data, simple imputation methods, such as substituting missing values with the mean or median, are both effective and straightforward. This approach operates under the assumption that the data is missing at random, thereby not introducing significant bias. In the context of more complex datasets, advanced imputation techniques, including K-Nearest Neighbors (KNN), regression imputation, or multiple imputation, can yield more accurate estimations of missing values (Suh & Song, 2023; Karrar, 2022). It is important to note that numerous machine learning algorithms are incapable of processing missing data and will either fail or generate errors in the presence of such data (Fleck et al., 2019). Imputation ensures the completeness and compatibility of the dataset with these algorithms.

Appropriate imputation techniques are crucial for preserving the inherent relationships and variability within the data, which in turn enhances the accuracy and reliability of the resulting models.

Let’s consider a situation where we are analyzing the impact of outdoor air pollution at a highway intersection on different days of the week. Depending on various factors, data may not always be recorded daily. Thus, when analyzing a dataset for an entire calendar year, simply removing rows with missing data would not provide a complete assessment of the full year. Imputation allows us to fill these gaps, maintaining a complete and continuous dataset for analysis. For real practice cases, for example, the incidence of secondary air pollution by formaldehyde, arising from photochemical reactions in urban environments, is exhibiting an increasing trend (Voloshkina et al., 2019). To accurately assess non-carcinogenic and carcinogenic risks and thereby mitigate disease incidence in the population, it is imperative to utilize the most comprehensive datasets of air pollution parameters (Sipakov et al., 2018). However, obtaining such extensive datasets is often not technically feasible. In such scenarios, the aforementioned imputation can play a pivotal role in addressing these data deficiencies.

Additionally, we would like to note that in the context of the dataset and its analysis, the user needs to determine what is most appropriate for the given case: the technique of removing rows with missing values or imputation based on a number of factors. With a small amount of missing data, up to 5 percent, removing such rows from the dataset will not significantly impact the analysis results. However, with a large amount of missing data, more than 5 percent, simply deleting rows can lead to a significant loss of information, making imputation the most appropriate option. If the data in the dataset under consideration is missing randomly, filling in using the mean or median value may be a more effective method. If there is a pattern in the missing data (for example, specific days of the week), more complex filling methods specific to the particular domain will be required. However, it is important to pay significant attention to the specific application of the dataset. For example, if we are analyzing daily air pollution indicators collected every day, data from Monday to Thursday from 8 AM to 5 PM in urban areas will likely be similar to each other under stable weather conditions. But they can differ significantly with changes in weather conditions, day of the week (Monday vs. Saturday), and time of day (day vs. night), particularly in terms of traffic congestion on highways, for instance.

2.2.2 Outlier detection and treatment

While collecting data from air pollution sensor recorders, we encountered anomalous readings that were either significantly lower or higher than expected. This could be due to temporary equipment malfunctions or sensor contamination. Therefore, in addition to removing empty rows from the dataset, we must process rows containing outlier data.

Outliers are data points that differ significantly from other observations. They can significantly affect the performance of the quadratic model and distort its results, making it essential to detect and handle them properly (Yerlikaya-Özkurt et al., 2016).

Various methods have been proposed to detect outliers, such as nonparametric approaches and robust regression techniques (Fan et al., 2006; Toshiaki et al., 2021). These methods aim to identify and remove outliers effectively to ensure the robustness of the analysis. Outlier detection often involves comparing the local density of data points to that of their neighbors, highlighting the importance of considering the context of neighboring points (Latecki et al., 2007).

Our study will examine two main methods to detect outliers: statistical and data normalization or scaling. Normalization or scaling ensures that different features contribute equally to the analysis, which is crucial when features have varying units or scales.

2.3 Fitting the quadratic model

In Python, this was achieved using the 'Polynomial.fit' method from the NumPy library, which computes the least-squares fit of a polynomial of specified degree to the given data. The snippet calculates the optimal values for coefficients $\left(a\right),\left(b\right),\left(c\right)$ that minimize the sum of the squared differences between the observed values and values predicted by the polynomial, thereby effectively “fitting” the curve to the data, which Python-formatted version of code snippet similar to:

# Fit the quadratic polynomialcoefs = Polynomial.fit(months, values, 2).convert().coef

With the fitted polynomial, our script generates a curve across a continuum of points within the data range, which was visualized using Matplotlib’s plotting function and the Python-formatted version of the code snippet similar to:

# Generate a smooth curve by evaluating the polynomial at many pointsx = np.linspace(months.min(), months.max(), 200)
y = coefs[0] + coefs[1] * x + coefs[2] * x**2

# Plot the data and the fitted curveplt.plot(x, y, color='purple', label='Fitted curve')

The coefficient of determination, $R^2$, was subsequently computed to assess the fit quality. Python was used to compare the variance of the residuals (the differences between the observed and predicted values) with the total variance of the data, and the corresponding code snippet is similar to:

# Calculate R-squared value

# Predicted values from the polynomial
y_pred = coefs[0] + coefs[1] * months + coefs[2] * months**2

# Residuals
residuals = values - y_pred

# Sum of squares of residuals
ss_res = np.sum (residuals**2)

# Total sum of squares
ss_tot = np.sum((values - np.mean (values))**2)

# R-squared
r_squared = 1 - (ss_res/ss_tot)

An $\left(R^2\right)$ value close to one (1) suggests that the model explains a large portion of the variance in the response variable, indicating a strong fit. Conversely, a value near zero (0) suggests the model does not explain the variance well.

2.4 Implementation

This section details the implementation of quadratic polynomial models in Python that are used in various applications, as demonstrated in this study. The core of the implementation involved the use of Python NumPy and Matplotlib libraries for mathematical operations and visualizations. The polynomial model is defined by the equation ${ax}^2+\mathit{bx}+c$, where $\left(a\right),\left(b\right),\left(c\right)$, are the coefficients optimized to fit the data points collected in different studies. The fitting process utilizes the 'Polynomial.fit' method, which employs a least-squares polynomial fit. To ensure robustness and accuracy, the implementation also included calculation of the coefficient of determination $\left(R^2\right)$ using NumPy’s correlation function. This metric helps to assess the polynomial fit to the data, which is essential for the applications discussed, ranging from trend analysis in software usage to predicting the material properties of nanocomposites.

In the next step, we used Python to present an applied exploration of quadratic polynomial fitting and the coefficient of determination (R-squared) within the context of data analysis.

The following Python script is a practical implementation tool for researchers and analysts: It begins by prompting the user to describe the dataset, such as a location or a specific environmental metric, such as the PM2.5 air pollution index. This interactivity ensures that the resulting visualization is tailored and informative. The Python-formatted version of the code snippet of this part of our script is similar to:

# User inputs for the descriptive elements of the plotdescription = input("Enter the location description (e.g., Kyiv, Shcherbakovskaya St.):")
pollution_name = input("Enter the pollution name (e.g., PM2.5):")
y_label = input("Enter the y-axis label (e.g., PM2.5 Index):")

The script reads data from a CSV file using Pandas, a library that excels in data manipulation. The data consists of monthly observations of the chosen metric. You can see this implementation in the Python-formatted version of the code snippet similar to:

# Read data from a CSV file# Use the direct link to the raw CSV file from the GitHub repositorydata = pd.read_csv('https://raw.githubusercontent.com/rsipakov/QuadraticPolynomialsPyDA/main/notebooks/pm_data.csv')# Or downloading CSV file to the local# data = pd.read_csv('/path/pm_data.csv') # Update the path to your CSV filemonths = data['Month'].to_numpy()
values = data['Values'].to_numpy()

As described above, with the data in hand, the NumPy library’s 'Polynomial.fit' function is employed to fit a quadratic polynomial to these observations. This is an essential step in modeling nonlinear behavior, accommodating potential fluctuations in data that a simple linear model would miss. Subsequently, the script computes the fitted values and leverages them to calculate the R-squared values. This statistic conveys the proportion of variance in the dependent variable explained by the independent variable. The Matplotlib library was then used to graphically represent the data along with the fitted curve, visually comparing the actual data points with those of the predictive model.

The following sources (VanderPlas, 2016; McKinney, 2017) provide a comprehensive overview of Python’s theoretical background and practical application. These resources offer a deep dive into data analysis using Python, including comprehensive guidance on regression analysis, and robust examples that bridge theory with practice.

2.5 R-squared limitations

R-squared is a commonly used metric for assessing the goodness of fit of regression models. However, it has notable limitations that must be taken into account when evaluating model performance. One key limitation is its sensitivity to the number of predictors in the model. As more predictors are added, R-squared will invariably increase, even if these additional predictors are not truly relevant to the model. This phenomenon can lead to overfitting, where the model captures noise rather than the actual relationship in the data (Fox & Weisberg, 2018).

To enhance the evaluation of regression models and address limitations such as overfitting, researchers can utilize a combination of metrics beyond the traditional R-squared. Adjusted R-squared is recommended as it considers the number of predictors in the model, offering a more balanced assessment that considers model complexity and penalizes the inclusion of irrelevant predictors (Ajjaj et al., 2022). This adjustment helps prevent overfitting, ensuring that the model captures the underlying data patterns effectively. Additionally, Mean Squared Error (MSE) and Root Mean Squared Error (RMSE) are valuable metrics for assessing prediction accuracy by quantifying the average squared differences between observed and predicted values (Chicco et al., 2021). These metrics are particularly useful for comparing different models and providing an intuitive measure of prediction error.

To implement additional metrics like Adjusted R-squared, Mean Squared Error (MSE), and Root Mean Squared Error (RMSE) in our code, we provide below the Python-formatted version of the code snippet, similar to:

# Calculate Adjusted R-squared value
n = len (values_scaled) # number of data points
p = 2 # number of predictors (polynomial degree)
adjusted_r_squared = 1 - ((1 - r_squared) * (n - 1) / (n - p - 1))

# Calculate Mean Squared Error (MSE) and Root Mean Squared Error (RMSE)
mse = mean_squared_error(values_scaled, fitted_y_values)
rmse = np.sqrt (mse)

2.6 Operation

The software tool based on quadratic polynomial models requires the following system setup and workflow: Operating System—Windows, macOS, or Linux; Python Version—Python 3.6 or later; dependencies —NumPy, Matplotlib, Pandas, scikit-learn (the latest versions are recommended), memory, at least 4GB of RAM; Processor, minimum 1GHz processor, or faster. The software is accessible through MyBinder.org, requires no local installation, and is fully configured to run in any web browser, ensuring its ease of use and reproducibility.

2.7 Installation process

To begin the installation process, it is imperative to ensure that Python is installed in the operating system. If Python is not present, it can be acquired from Python’s official website python.org. After successful installation of Python, the next step involved installing the necessary libraries. This can be achieved through the Python Package Index (PyPI) using a PIP installer. Execute the following command in the command prompt or terminal to install the required libraries: 'pip install numpy pandas matplotlib scikit-learn'. This command installs NumPy, which is essential for numerical computations, Matplotlib, a library for plotting graphs and effectively visualizing the data, Pandas, a data manipulation and analysis library, and scikit-learn is a widely used tool in the field of machine learning.

After developing the script using the quadratic polynomial models described above, the complete Python code was hosted on GitHub (Sipakov, 2024), enabling replication and further exploration of the findings. To facilitate ease of use and accessibility, the code was made available through MyBinder.org (https://mybinder.org/v2/gh/rsipakov/QuadraticPolynomialsPyDA/main), allowing it to operate in a live environment without the need for local setup. This implementation ensures that other researchers can directly interact with the codebase, providing a dynamic way to validate and extend research findings.