Quality of Service Generalization using Parallel Turing Integration Paradigm to Support Machine Learning

Abstract

The Quality-of-Service (QoS) provision in machine learning is affected by lesser accuracy, noise, random error, and weak generalization (ML). The Parallel Turing Integration Paradigm (PTIP) is introduced as a solution to lower accuracy and weak generalization. A logical table (LT) is part of the PTIP and is used to store datasets. The PTIP has elements that enhance classifier learning, enhance 3-D cube logic for security provision, and balance the engineering process of paradigms. The probability weightage function for adding and removing algorithms during the training phase is included in the PTIP. Additionally, it uses local and global error functions to limit overconfidence and underconfidence in learning processes. By utilizing the local gain (LG) and global gain (GG), the optimization of the model’s constituent parts is validated. By blending the sub-algorithms with a new dataset in a foretelling and realistic setting, the PTIP validation is further ensured. A mathematical modeling technique is used to ascertain the efficacy of the proposed PTIP. The results of the testing show that the proposed PTIP obtains lower relative accuracy of 38.76% with error bounds reflection. The lower relative accuracy with low GG is considered good. The PTIP also obtains 70.5% relative accuracy with high GG, which is considered an acceptable accuracy. Moreover, the PTIP gets better accuracy of 99.91% with a 100% fitness factor. Finally, the proposed PTIP is compared with cutting-edge, well-established models and algorithms based on different state-of-the-art parameters (e.g., relative accuracy, accuracy with fitness factor, fitness process, error reduction, and generalization measurement). The results confirm that the proposed PTIP demonstrates better results as compared to contending models and algorithms.

1. Introduction

The performance of machine learning depends significantly on the properties of the algorithms [1]. ML is made up of various cutting-edge algorithms that correctly predict events and help systems make informed judgments [2,3]. However, some of the current issues in ML include under-fitting, overfitting, bias, inconsistencies, and reduced accuracy [4]. Numerous algorithms have been developed, although they may not be entirely capable of solving these problems [5,6,7]. However, given the advent of digital and e-data, particularly in the fields of Big data and social networking data, ML has made appreciable development in data science [8,9].

Predictive analytics in ML uses a variety of models, approaches, and algorithms [10,11]. Recent research has focused on blending models and features [12,13,14]. To tackle bias, mistakes, overfitting/underfitting, and poor generalization, this work presents a novel technique of blending, in contrast to other recent advancements in data science research.

Many computations are performed concurrently to provide the solution more quickly. Therefore, faster computation and QoS provisioning can be made feasible by integrating the features of parallel computing and artificial intelligence (AI) [15]. Additionally, Turing can calculate complex tasks, which can be computed by any computer or supercomputer [16]. However, there is a need for the parallel Turing machine to increase the efficiency of given models and algorithms. Thus, the model is trained using the suggested PTIP paradigm to determine the supporting algorithm, and it is then blended to increase the prediction accuracy and classifier fitness. The concept, questions, contributions, and anatomy of the article are introduced in the next subsections. Our motivation stems from the fact that we are using data from social networking in conjunction with academic and professional data to enhance predictive analytics. Several cutting-edge algorithms have been studied [17,18] to comprehend the proposed PTIP paradigm. The following general research questions are what this work aims to explore and answer:

▪

Can matching, fitness, and accuracy ratings be used to fine-tune and combine algorithms?

▪

Is it possible for a blended model to perform better than a single algorithmic model when it comes to handling bias, over- or under-fitting, poor generalization, and low accuracy?

▪

Can error be used/programmed to govern the model for lower and upper bounds to avoid bias and over-learning?

▪

Can algorithms be added and deleted algorithmically in real-time as the classifier processes the provided raw data for ML predictions?

▪

Can overfitting and underfitting be pushed to a logical space of the optimum fitting?

▪

Finally, can a blended model learn from its incorrect predictions?

1.1. Research Problem

The main challenge that data scientists, researchers, and analysts come across is to know which algorithm or model is the best for the problem(s)/data to be used? There are many unknowns and uncertainties. Each algorithm may behave differently for different dataset and variables/features. Evaluation of a model or algorithm is crucial for various classifiers. It becomes highly challenging to choose a classifier type based on new or unseen data. The standard rule adapted by the scientists and researchers is assessing some of the classifiers that algorithm produces [19]. We consider this as a research problem to see if an improved model with algorithms, uniquely engineered with built-in parallel processing, can be introduced for such predictive modeling using enhanced blending and tuning.

1.2. Research Contributions

We see the potential of data science in the creation of new algorithms as well as enhancements to current strategies, while considering the most recent requirements and applications in the big data environment. The following is a summary of the paper’s contributions:

▪

The proposed PTIP has the ability to measure the accuracy, fitness, and matching scores in order to create a blended process;

▪

The proposed approach demonstrates that blending is performed depending on how well each algorithm, as chosen from the pool of options, fits the sort of data model being trained. Furthermore, the proposed approach guarantees that the model is neither biased nor overfit in comparison to any particular algorithm;

▪

The proposed classifier is trained to be able to add a good-fit algorithm (one with better metrics) or get rid of a bad-fit algorithm (one with inferior metrics);

▪

The enhanced metrics, which control the model’s performance dimension, are produced. In this manner, the proposed approach is simultaneously cross-checked while learning from the data (during training);

▪

The proposed model’s design is represented in 3-D logical space. In addition, the proposed model is shifted to z-space coordinates to get the optimal fitness;

▪

A novel strategy to using a meaningful measure in machine learning is created (i.e., Error). The presented model has been trained to be managed by minimum and maximum error-bounds. As a result, acceptable bias and fitness, including overlearning, may be preserved. The lowest and maximum error boundaries for GG and LG are 20% and 80%, respectively.

1.3. Paper Structure

The remainder of the paper is structured into the following sections:

Section 2 presents the salient features of the current studies. Section 3 outlines the proposed parallel turning integration paradigm. Section 4 presents the experimental findings and discussion. In Section 5, the entire article is concluded.

2. Related Work

This section summarizes the most important aspects of existing approaches. Ref. [20] described an iterative approach for continuous variational methods that use the boundary value issues. More specifically, they investigated a parallelization technique that makes use of the capability of multiple cores GPUs (graphics cards) and CPU (Central processing unit). They also investigated the parallel technique for first- and second-order Lagrangians and demonstrated its superior performance in two intriguing applications: a fuel-optimal navigation issue, known as Zermelo’s navigation problem, and an extrapolation problem. The cross-modal Turing test was used as an all-purpose communication interface that enabled an embodied cognitive agent’s “message” and “medium” to be tested against another [21]. Two competing modules might undergo a sequential cross-modal Turing test with the usage of reciprocating environments and systems. Such a strategy could prove to be crucial in systems that require rapid learning and model adjustment, (e.g., cyber-physical systems), which are formed at the intersection of many technical–scientific engineering solutions. This strategy may be successful in the field of transfer learning, where a pre-trained network fragment might well be linked with input that is essentially unrelated to neural networks.

Researchers looked into potential increases in sampling efficiency [22]. To depict computationally ubiquitous models, a polynomial-time Turing machine was utilized, and Boolean circuits were used to represent artificial neural networks (ANNs) functioning on finite-precision digits. Direct connections between their inquiry and the outcomes of computational complexity were shown by their study. On the anticipated increases in sample efficiency, they offered lower and upper bounds. The input bit size of the required Boolean function defined their bounds. They also emphasized the close connections between the intensity of these limitations and the standard open Circuit Complexity concerns. Deep learning in machine learning seeks a general-purpose computing device that could carry out challenging algorithms resembling those in the human brain. Neural Turing Machine (NTM) integrated a Turing machine with a long-term memory, which was used as a controller to accomplish deep learning techniques [23]. Basic controllers are used by NTM to carry out a variety of simple and sophisticated tasks, including sort, copy, N-gram, etc. Complex jobs, such as classifications, were disregarded, and NTM’s weights could not be improved.

Super-Turing models’ expressiveness hierarchy was introduced [24]. A-decidable and i-decidable algorithms (e.g., D-complete, U-complete, and H-complete) complexity classes—inspired by NP-complete and PSPACE-complete classes for intractable problems—were introduced as first steps. Similar to how to approximate, randomized and parallel algorithms enabled workable solutions for intractable problems. This study might be seen as the first step toward feasible approximations of answers to the Turing machine’s inherently unknowable issues. All of the existing methods focused on decision making and model adjustment. Contrary, the proposed PTIP is able to quantify the matching, fitness, and accuracy scores to establish a tuning and blended process. The proposed PTIP also ensures that the model is neither overfit nor biased, as compared to any single algorithm under test. Furthermore, a distinctive approach of employing a significant metric in machine learning (i.e., Error) is developed. Finally, the proposed model is trained to be administered by minimum and maximum error bounds. Thus, acceptable bias and fitness including overlearning can be maintained. The contemporary nature of existing approaches is given in

Table 1. Contemporary contributions of existing studies.

Approaches	Turing Operations for Machine Learning	Features	Vulnerabilities
IMDV [20]	Iterative approach for continuous variational methods	A parallel approach that employs the capabilities of several cores of GPUs (graphics cards) and CPUs (Central processing unit) for addressing the extrapolation problem	Its performance is limitted to two applications:a fuel-optimal and navigation problem.
CMTT [21]	Cross-modal Turing testing process	The cross-modal Turing test was employed as an all-purpose communication interface for the rapid learning and model adjustment	This method could only work for transfer learning.
PTTM [22]	Utilization of the polynomial-time Turing machine	Projected increases in sample efficiency, offered lower and upper bounds between the intensity of these limitations	Increased circuit complexity
NTM [23]	Neural Turing Machine with a long-term memory,	Neural Turing Machine is integrated as a Turing machine with a long-term memory, to carry out variety of simple and sophisticated tasks, including sort, copy, N-gram, etc. Complex jobs, such as classifications	The weights of neural Turing machine could not be improved
AIA [24]	Introduction of AIA algorithm based on super-Turing models	Approximate, randomised, and parallel algorithms were used to solve intractable problems	Inaccurate for decision-making
Proposed PTIP	Parallel Turing integration paradigm	Proposed PTIP is able to quantify the matching, fitness, and accuracy. Furthermore, the proposed PTIP ensures that the model is neither overfit nor biased	Trained to be administered by minimum and maximum error bounds

.

3. Proposed Parallel Turing Integration Paradigm

The latest trend in the ML research [25] has shown an immense potential to evaluate various algorithms in parallel [26]. We take a research opportunity to enhance the accuracy for the state-of-the-art algorithms of the ML. The proposed PTIP consists of four components to play an important role for accuracy enhancement of the ML algorithms.

▪

Improved Machine Learning Engine

▪

Develovement of Pre-processing Internals

▪

Measurement and Risk Optimization

▪

Final framework of PTIP

3.1. Improved Machine Learning Engine

The proposed PTIP leverages the features of an improved machine learning engine (IMLE) that increases accuracy depicted in Figure 1. The IMLE consists of state-of-the-art components, which help guarantee the QoS provision, especially accuracy. The PTIP is discussed at the abstract level.

▪

Enhanced Algorithms Blend and Turing (EABT): The EABT uses ensemble, bagging, and boosting to choose the best blend until the improved metrics are evaluated, then it applies the current ML and predictive modelling techniques (e.g., Logistic Regression, Linear Regression, Multiple Regression, Bayesian, Decision trees, SVM, and Classification). This scheme exploits the potential of parallel processing of the techniques. Errors and bad predictions made during a test are sent back to the algorithm in this phase so it can continue to learn from its errors (AI).

▪

Enhanced Feature Engineering and Selection (EFES): It improves feature engineering to extract more information (e.g., feature development and transformation). Finding the best collection of characteristics or features for the relationship between “predictor-target” variables is the best fit. Additionally, it makes sure to include features with the greatest fitness scores and eliminate features with the lowest. Each feature may be validated by the EFES.

▪

Enhanced Weighted Performance Score (EWPM): It ensures that the model should neither be overfit nor underfit by generating a unique metric based on standard metrics. It also acts as the measuring instrument to ensure the precision of overall performance metrics.

▪

Improved Cross Confirmation and Split (ICCS): This component develops and employs a novel strategy to train-test data splitting in order to improve existing validation approaches such as cross-validation.

3.2. Development of Pre-Processing Internals

The pre-processing internals reduce the inaccuracies in the datasets. Therefore, the pre-processing internals can be created using the Logical Table (LT). The complete modular details of the Logical Table (LT) are outside the scope of this article. However, the brief detail is provided. The method that best fits the PTIP is to use of the logical table, which expands with the quantized output. We determine that the proposed model’s minimum value is where LT controls the process. According to Algorithm 1, it makes an entry for each dimension (X, Y, and Z). The threshold value is set for the LT; if the LT value < 0.5, binary “0” is assigned; if ≥ 0.5, binary “1” is assigned. Thus, the binary truth table can be formed from those values. The primary goal of Algorithm 1 is to employ LT to produce pre-processing internals in order to correct the inaccuracies in datasets.

Steps 1–2 of Algorithm 1 depict the input and output procedures. The variables utilized in the Algorithm 1 are initialized in steps 3–5. The logical table objects and nodes are created in step 6. The IMLE is generated in step 7 to increase accuracy. Step 8 configures the IMLE’s component (FFES) (which helps to increase accuracy). The value for error removal in the IMLE is shown in steps 9 through 12, and the error removal procedure continues until no more errors are found, in every direction. Step 13 involves the error and data validation processes.

Step 14 provides the distance function’s correct arguments. Steps 15–16 show the activation processes of Turing and blended functions, which provide the alert on the logical table. If an error is discovered, the error classifier functions of ${\mathbb{B}}_A, {\mathbb{T}}_A$ are invoked and the best set of features is determined in steps 17 through 19. The alert is set on the logical table to identify errors in tuples and blocks in step 20. Additionally, steps 21–22 establish the ideal fitness range. The suggested PTIP has an updated logical table. Step 23 involves setting the strategy function for each dimension. The classifier sets and triggers the cost function for error and data validation. If a value of error < 0.5 is found inaccuracy removal is commenced, and the logical table is eventually modified in steps 24–30.

Algorithm 1: Inaccuracy removal $\mathsf{\psi }\left(\mathrm{n}\right)$ in logical table for development of pre-processing internals

Input:$\mathrm{A}.\mathrm{P}=\left\{{\mathrm{A}}_1,{ \mathrm{A}}_2,{ \mathrm{A}}_3,\dots \dots ..,{ \mathrm{A}}_{\mathrm{n}}\right\}$, Raw Dataset $\mathrm{DS}\left(\mathrm{sig},\mathrm{noi}\right)$ Output:$\left(\mathsf{\psi }\left(\mathrm{n}\right)\right)$ Initialization(A): $\{ \mathbb{S}\left(\mathrm{x}.\mathrm{y},\mathrm{z}\right):$ strategy function for all dimensions;$\mathrm{Op}.\mathrm{F}$: optimal fitness; $\mathrm{C}$: cost function} Initialization(B):$\left\{\mathrm{IMLE}, \mathrm{EFES}\right\}$ Initialization(C):$\{\mathrm{A}$: error,${ \mathrm{A}}_{\mathrm{n}}$: total number of errors;${ \mathrm{H}}_{\mathrm{i}}\left({\mathrm{p}}_{\mathrm{i}}\right)$: entire datasets;${ \mathrm{H}}_{\mathrm{i}}\left({\mathrm{p}}_{\mathrm{i}}{}^{\prime }\right)$: removal of data; $\nabla \mathrm{d}\left({\mathrm{A}}_1,{ \mathrm{A}}_2\right)$: distance between two data items; $\varnothing \left(\mathrm{D}, \mathrm{t}\right)$: arguments of distance function; ${\mathbb{B}}_{\mathrm{A}}$: blended function for algorithm; ${\mathbb{T}}_{\mathrm{A}}$: Turing function; ${\mathrm{LT}}^{\forall }$: alert on logical table; Generate LT object, Nodes Generate IMLE Set$\mathrm{FFES}, \mathrm{EWPM}, \mathrm{ICCS},\mathrm{EAB}$ While ($\mathsf{\psi }\left(\mathrm{n}\right))\left.〈0.5 \right| \left(\mathrm{e},\mathrm{E}\to \mathrm{IMLE}\right)$ Do Create Logical Table Object $\mathrm{LT}\left(\mathrm{x},\mathrm{y},\mathrm{z}\right)$ For each (A $\in$ ${\mathrm{A}}_{\mathrm{n}})$ Do Compute$\nabla \mathrm{d}\left({\mathrm{A}}_1,{ \mathrm{A}}_2\right)=\sqrt{\left(\sum _{\mathrm{i}=1}^{\mathrm{M}}\left({\mathrm{H}}_{\mathrm{i}}\left({\mathrm{p}}_{\mathrm{i}}\right)-{\left({\mathrm{H}}_{\mathrm{i}}\left({\mathrm{p}}_{\mathrm{i}}{}^{\prime }\right)\right)}^2\right)\right)}$ Validate (A $\in$ ${\mathrm{A}}_{\mathrm{n}})$ and $\nabla \mathrm{d}\left({\mathrm{A}}_1,{ \mathrm{A}}_2\right)$ Compute$\varnothing \left(\mathrm{D}, \mathrm{t}\right)$ Compute LT.${\mathbb{B}}_{\mathrm{A}}, {\mathbb{T}}_{\mathrm{A}}$ If${\mathrm{LT}}^{\forall }{\mathbb{B}}_{\mathrm{A}}, {\mathbb{T}}_{\mathrm{A}}$then Retrain classifier (${\mathbb{B}}_{\mathrm{A}}, {\mathbb{T}}_{\mathrm{A}})$ Update$\mathrm{EFES}\to \varnothing \left(\mathrm{D}, \mathrm{t}\right)$ End If Compute$\mathrm{Op}.\mathrm{F}\left\{0:1\right\}$ End For Update: LT of $\mathrm{PTIP}$ Set$\mathbb{S}\left(\mathrm{x}.\mathrm{y},\mathrm{z}\right)=\sum _{\mathrm{j}=1}^{\mathrm{N}}\varnothing ({\mathrm{D}}_{\mathrm{j}}, \mathsf{\tau }({\mathrm{p}}_{\mathrm{j}},{ \mathrm{S}\prime }_{\mathrm{x},\mathrm{y},\mathrm{z}})$ Set$\mathrm{C}$ If (C is flagged by Classifier) then Compute$\nabla \mathrm{d}\left({\mathrm{A}}_1,{ \mathrm{A}}_2\right)$ Detect$\mathsf{\psi }\left(\mathrm{n}\right)$ Update LT End If End While

LT operates in the memory and is dynamically updated. It keeps track of the algorithms $\mathrm{A}\left(\mathrm{x},\mathrm{y},\mathrm{z}\right)=\{{\mathrm{A}}_1,$ ${\mathrm{A}}_2,.........,{ \mathrm{A}}_{\mathrm{n}},\}$ as the ML process evolves to accomplish the final optimum fitting after it has incorporated all the algorithms from the pool. This helps achieve the optimum blending and tuning. This logical table stores data based on three dimensions, where ‘x’ = overfitness, ‘y’ = underfitness and ‘z’ = optimum-fitness.

3.3. Measurement and Risk Optimization

The measurement and risk optimization (MRO) component deals with applying various algorithms one by one to observe the outcomes (i.e., measures), and then prepares the model for risk estimation and algorithm blending. This construct also compares the two algorithms at the same time and then groups them based on Euclidean distance for similarity scores in terms of fitness. This sub-model finally produces the set of algorithms for the best fit for a given dataset. The end goal is to engineer inaccuracy removal that can be done through classifier function.

Let us define that standard distance function, which consists of $\nabla d\left(A_1, A_2\right)$ that demonstrate the distance between two data items. The $H_i\left(p_i\right)$ can be identified as entire datasets, and $H_i\left(p_i{}^{\prime }\right)$ be the removal of data from the datasets.

$$\nabla d\left(A_1, A_2\right)=\sqrt{\left({\displaystyle \sum }_{i=1}^M\left(H_i\left(p_i\right)-{\left(H_i\left(p_i{}^{\prime }\right)\right)}^2\right)\right)}$$

(1)

Let $S^{\prime }$ be the strategy function for all dimensions, and $p_i$ is the training problem set (dataset vector) in distribution of time $\varnothing \left(D, t\right)$ being the arguments for distance function in $\varnothing .$

$$\mathbb{S}\left(x.y,z\right)={\displaystyle \sum }_{j=1}^N\varnothing (D_j, \tau (p_j, S{\prime }_{x,y,z})$$

(2)

Therefore, the correct arguments of distance function can be calculated as:

$$\left\{\varnothing \left(D, t\right)=\begin{array}{c}\frac{\overline{T}}{\left(D+1\right)} t=\infty \\ \frac{t}{\left(D+1\right)} e \in N, \overline{T} \ge T\end{array}\right.$$

(3)

Theorem 1. 

Algorithm evaluation process$\left\{A_{\left(1, n\right)}\right\}$makes suitability scores for the fitness.

Proof. 

Let $\nabla d\left(A_1, A_2\right)$ be the Euclidean distance between the two algorithms since there must be a matching factor (M.F) for the best fitness between them. Thus, $Op.F\left\{0:1\right\} \ge 0.5$, as optimum Fitness scores and $0.2\left.〈err\right|Err\left\{0:1\right\}<0.8$, are bounds of LE (err) in GE (Err).

With the pointers x denoting Overfitness, y denoting underfitness, and z denoting optimal fitness, let $\mathbb{S}\left(x.y,z\right)$ compute the appropriateness scores for the fitness of the provided method in 3-D space. Let $\psi \left(n\right)$ be the classifier function, which the model learns to categorize in order to be able to identify the ideal combination of methods for a particular dataset and issue. □

3-D Cube Logic for Security Provision

In encryption transmission, the 3D cube logic is used to maintain a security, and the activity is carried out based on the pattern generated by the transmitting side rather than supplying the whole cube structure. A key that is utilized for encryption and decryption is deduced through a sequence of steps that match the 3D CUBE pattern.

The proposed technique decrypts the encrypted text provided by the receiver using a key derived by completing the shuffling of 3D CUBE based on artificial intelligence (AI), which overcomes the challenge of secured key exchange by removing the key exchange procedure from the conventional symmetric key encryption. Because it is impossible to deduce a key used by a third party using AI-based learning, the 3D CUBE logic can also provide higher security than the conventional symmetric key encryption scheme.

As it is used to handle keys and transmit them correctly in the symmetric key encryption system, the procedure after generating the key in the 3D CUBE technique is identical to that in that mechanism. In the symmetric encryption system, instead of participants sharing keys used during initial encryption communication, the transmitter sends a 3D element key pattern as a randomized 3D CUBE sequence by which the key can be activated, and the recipient obtains the secret key by incorporating it through AI-based learning. By using the XOR operation on the sequence’s 3D CUBE pattern, the secret key is formed here based on the randomized order as a sequence.

Assume a dataset $Des\left(\mathrm{sig},\mathrm{noi}\right)$, where “sig” denotes the signal and “noi” denotes the noisy component of the dataset that can be transmitted. The classifier function with a loss function $\mathrm{L}\left(\mathrm{x},\mathrm{y},\mathrm{z}\right)| \left(0:1\right),$ for which we loop in n-sample blocks such that loss function remains in the defined boundary as estimated, for which the feature sets exist in the function $F=\{f_1, f_2, f_3,\dots \dots ..,f_n$ with optimal score > 0.5. The classifier for the upper boundaries of generalization error in the probability $Ć\left(x,y,z\right)$, for n blocks of data sample can be provided by:

$$Ć\left(x,y,z\right)=L\left(x\right)\le L\left(y\right)\le L\left(z\right)+\frac{1}{n} {\displaystyle \sum }_{k=1}^n{\left(U.Des-L.Des\right)}^k+\sqrt[3]{\frac{-\log \left(\frac{p}{2}\right)}{2\phi }}$$

(4)

where $\phi$ is the pattern identified as signals (removing noises) with the probability of 1 − p. Here, we create a straightforward approach to calculate the loss function in noisy and signal data(N) that affects classifier construction.

$$L(DS(S\left(x,y,z\right),N\left(x,y,z\right)=\left\{\begin{array}{c}0, \left(N(x,y,z\right)\ge 0.5 \ge S\left(x,y,z\right)) \\ 1, \left(S\left(x,y,z\right)\ge 0.5 \ge N\left(x,y,z\right)\right)\end{array}\right.$$

(5)

Thus, for each algorithm in the pool, the optimum fitness can simply be determined as:

$$Op.F\left\{0:1\right\}= (Ć\left(x,y,z\right)-L(DS(S\left(x,y,z\right),N\left(x,y,z\right){ }^2\times \mathit{log}\frac{{\left(err\right)}^2}{\left(err+Err\right)}$$

(6)

Based on the Equations (4)–(6), the optimum fitness values can be calculated, which are given in

Table 2. Quantified comparison of optimal fitness.

$\mathbf{O}\mathbf{p}.\mathbf{F}\left(\mathbf{x}\right)$	$\mathbf{O}\mathbf{p}.\mathbf{F}\left(\mathbf{x},\mathbf{y}\right)$	$\mathbf{O}\mathbf{p}.\mathbf{F}\left(\mathbf{x},\mathbf{y},\mathbf{z}\right)$
0.00028723	0.00238712	0.03489120
0.234356	0.93	0.87
0.659023	+0.73	+0.78

.

As previously mentioned, our model is built on 3-D space for the x, y, and z dimensions, which the algorithm employs to optimize the blend’s fitness (Op.F) to the supplied data. It is important to highlight that using this technique, the model is designed to be highly generalizable for any supplied data with any kind of attributes. We thus engineer the mix utilizing matrix (real-valued) space manipulation and the Frobenius norm provided by:

$$\Vert M\Vert \left(x,y,z\right)=\sqrt{{\displaystyle \sum }_{x=1}^X{\displaystyle \sum }_{y=1}^Y{\displaystyle \sum }_{z=1}^Z{M}_{x,y,z}^2}$$

(7)

The matrix manipulation for each dimension to evaluate the blend can be built as:

$$\psi \left(n\right)=\underset{\left(x,y,z \in Z\right)}{Extract}(\Vert M\Vert \left(x,y,z\right))+\log {{\displaystyle \sum }}_{k=1}^Z{\gamma }^{z+1} . Op.F\left\{0:1\right\}$$

(8)

The illustration in Figure 2 supports the mechanics of the Theorem 1. As we observe the visualization of three functions, err|Err $(e/E)$, Op.F and Cost (C) being rotated based on distance function, as shown. Thus, Blender Filter Switch (logical) connect the value to the Suitability and Evaluation Score 3-D logical construct. The value of $\psi \left(n\right)$ in each dimension swing between 0 and 1, based on Op.F response from Tuning Synthesizer block.

Table 3. Shows the results of ten experiments performed on developed functions.

Function	1	2	3	4	5	6	7	8	9	10
$\psi \left(x\right)$	0.0141	0.0132	0.0296	0.0910	0.1384	0.2780	0.4692	0.5901	0.6220	0.6793
$\psi \left(y\right)$	0.9301	0.9100	0.0410	0.8323	0.7928	0.6029	0.5921	0.4301	0.3120	0.2872
$\psi \left(z\right)$	0.0130	0.0570	0.0962	0.1502	0.9991	0.4170	0.4288	0.5919	0.6129	0.7709
$\psi \left(x,y,z\right)min$	0.0021	0.0091	0.0101	0.1303	0.2920	0.3409	0.3110	0.3300	0.3419	0.3910
$\psi \left(x,y,z\right)max$	0.5412	0.5900	0.6001	0.6400	0.6408	0.6604	0.6923	0.7129	0.7021	0.7400

The red circled values should be considered as errors that require further investigation.

shows the results of developed functions.

Theorem 2. 

Risk Estimation, Local Errors, and Metrics Evaluation—$Algo.Ris{k}_{emp}\left[f\right]$

The algorithm generalization evaluation error {AGE(Err)} is inbound of all LE err(n), for which each occurrence of the error at any point in x and y space, exists inside all theoretical values of Err, such that$err\left(A\right)\in Err\left(A+1\right), where 0.8<e<0.2$. Let there be a maximum risk function (Φ) with mean square error$\left(MSE\right)$on the set of features as$F=\left\{f_1, f_2, f_3, ......, f_n\right\},$and unknown means as$\left\{m_1, m_2, m_3, ......, m_n\right\}.$

The algorithm generalization assessment error, or AGE(Err), is an aggregate of all LE err(n), in which each instance of the error at any location in x and y space occurs within all conceivable values of Err, so that$err\left(A\right)\in Err\left(A+1\right), where 0.2<e<0.8$. Assume that the maximum risk function (Φ) has unknown means (m 1, m 2, m 3, m n) and mean square error (MSE) on the set of features (F= f 1, f 2, f 3, …, f n).

Construction. 

To prevent underfitting and overfitting in terms of the errors to be regulated by the upper and lower bounds. We construct the minimum and maximum error boundaries logical limit. We initially force the mistake to be at a low threshold before making it high. The algorithm then learns to keep between the min(e:0.2) and max(e:0.8) boundaries, and accuracy is obtained.

$$max\left(e:0.8\right)=\frac{1}{E} {\displaystyle \sum }_{i=1}^{Ne}\{(RMS{E}_i)-\left(100+0.2\right)/E\}$$

(9)

$$min\left(e:0.2\right)=\frac{1}{E} {\displaystyle \sum }_{i=1}^{Ne}\{(RMS{E}_i)-\left(100+0.8\right)/E\}$$

(10)

Let us define our optimum error (dynamically governed by algorithm tuning and blending process), as:

$$E_{opt} (max, min |e_{\left(x,y,z\right)}=\left(\frac{\int \partial \left(x,y,z\right)}{\left(1-E\right)}\right)\times {\displaystyle \sum }_{j=1}^{Nt}\left(\max {\left(e\right)}_j-\min {\left(e\right)}_j\right) * g.f$$

(11)

where the PTIP algorithm generates (g.f), the error gain factor. Each method tends to cause more mistakes when they are combined, hence the combined errors of both global and local functions must stay within the given range. There are two types of errors for generic machine learning modelling: estimation and approximation [27]. Its collective name is generalization error, and finding a specific function f′(x, y) that tends to reduce the risk of training in the targeted space is what we aim to do in this case (i.e., X, Y, Z), shown as:

$$Risk{\left[f^{\prime }\right]}_{x,y,z}={{\displaystyle \int }}_{X\times Y\times Z}L \left(y, f^{\prime }\left(x,y\right)\right) P\left(x,y,z\right)dxdydz$$

(12)

Figure 3 shows the concept of correlation of error bounds and risk function. As we propose the novel idea of limiting the error between 20% and 80% for optimum realistic fitness for the real-world prediction, it shows that the Risk Estimation (emp) stays in bounds of logical cube shown on the right. The center point shows the ideal co-variance of function $ն$. P (x, Y, Z) will be unknowable at this time. Based on the “empirical risk minimization principle”, which is statistical learning theory that can employed to determine the risk.

$$Ris{k}_{emp}\left[f^{\prime }\right]=\frac{1}{m} {\displaystyle \sum }_{i=1}^{m}L ( y^i , f\prime \left(x^i\right))$$

(13)

Here, we require to fulfill two conditions, which are given below:

(i)

$\underset{m \to \infty }{\lim }Ris{k}_{emp}\left[f^{\prime }\right]=Risk{\left[f^{\prime }\right]}_{x,y,z}$

(ii)

$\underset{m \to \infty }{lim} \underset{f \in H}{\min }Ris{k}_{emp}\left[f^{\prime }\right]=\underset{f \in H}{min} Risk{\left[f\right]}_{x,y,z}$.

These two conditions could be binding when $H$ is comparatively trivial. The second condition needs minimal convergence. Thus, following bound can be constructed that is being held valid with probability of 1 − $\delta$ is $R\left[f\right] \le Ris{k}_{emp}\left[f^{\prime }\right]+ɀ$. Thus, $ɀ$ can be determined as:

$$\sqrt{ɀ=\left(\frac{h \mathit{ln}\left(\frac{2m}{h}+1\right)-\mathit{ln}\left(\frac{\delta }{4}\right)}{m}\right) }$$

(14)

The sub-estimator function is $\widehat{m_k}=c\left(F_k,\vartheta \right)$. Hence, the regularization parameter $\vartheta$ is positive and it has been observed that the sub-estimator function $c\left(F_k,\vartheta \right)=F$ such that, $\vartheta =0 | \widehat{m_i}=F_k$. We deduce that $\vartheta =\infty$, corresponds to maximal shrinking, which is $\left\{\widehat{m_k}=0, for k=1,,,,,,n\right\}$. In this case we use Stein’s unbiased risk estimate (SURE) and cross validation (CV) technique, where prominent estimators include (lasso), (ridge) and (pretest). We use the squared error loss function, sometimes called compound loss, as the basis for loss and risk estimation.

$$Los{s}_n\left(F, c\left(k,\vartheta \right), D\right)=\frac{1}{n} \sum _{k=1}^n{\left(c\left(F_k, \vartheta \right)-m_k\right)}^2$$

(15)

where $D=\left\{d_1,d_2,\dots \dots \dots ,d_n\right\}$ shows the distribution of Features F {p, q, r}. It should be observed that Loss is highly dependent on ‘D’ through value of ‘m’. We can construct the regularization parameter for which the algorithm blend fits the model to maximum relevance, such that: $\vartheta \left(D\right)=\underset{\vartheta \in \left[0,\infty \right)}{\max }B \left(c\left(. , \vartheta \right), \pi \right)$.

Therefore, the risk of algorithm $\left(Algo.Ris{k}_{emp}\left[f\right]\right)$ can be calculated as:

$$Algo.Ris{k}_{emp}\left[f\right]=Risk{\left[f^{\prime }\right]}_{x,y,z}\times {\displaystyle \prod }_{EDGE\left(Los{s}_n\right)}{ɀ}_n$$

(16)

Consequently, Equations (15) and (16) can be used to determine the maximum risk of algorithm $\Phi$.

$$\Phi =\max \left(Algo.Ris{k}_{emp}\left[f\right]\right)+\underset{0.2<err<0.8}{\lim }Risk{\left[f\prime \right]}_{x,y,z}$$

(17)

where $Risk{\left[f\prime \right]}_{x,y,z}$ is the risk of distribution features of algorithm.

The risk estimation process of algorithm in 3-d space is depicted in Figure 4 to support in-bound local evaluation (LE) and global evaluation (GE).

Algorithm 2 maximizes fitness, this algorithm computes the risk estimation function, local error bounds, and metrics evaluation. It builds on Theorem 1. It tunes the blend to stay within error bounds for ensuring optimum fitness based on the Risk Estimation Function and observed errors, and then assesses metrics to ensure the blend’s overall performance.

Algorithm 2: Computation of risk estimation process

Input: $\mathsf{\psi }\left(\mathrm{n}\right):$ classifier Function, $\mathrm{F}\left\{\mathrm{n}\right\}:$ Features set for sampling

Output: $\mathsf{\Phi },{ \mathrm{Risk}}_{\mathrm{emp}}\left[\mathrm{f}\right], \mathrm{e}, \mathrm{E}$, $Ё$

Initialization: $\mathrm{e} \leftarrow 0, \mathrm{E} \leftarrow 0$

Create: LTObject, ${\mathrm{NODES}}_{\mathrm{i}\in \mathrm{N}}$, $\mathrm{PTIP}$ Generate ObjectIMLE(h)/* Generate an object reference for improved machine learning engine application programming interface (API)*/ Set ObjectIMLE.PublicFunctions(h.IMLE, h.EFES, h.EWPM, h.ICCS)/* managing the four constructs*/ While ($\mathrm{e}〈0.2 \mathrm{OR}〉0.8)$Do Compute max(e) and min(e) bounds Compute$\sum _{\mathrm{j} =1}^{\mathrm{Nt}}\left(\max {\left(\mathrm{e}\right)}_{\mathrm{j}}-\min {\left(\mathrm{e}\right)}_{\mathrm{j}}\right) * \mathrm{g}.\mathrm{f}$ /* The optimum error function */ Create Logical Table Object $\mathrm{LT}\left(\mathrm{x},\mathrm{y},\mathrm{z}\right)$ Create h.ICCS(${\mathrm{S}}_1,{\mathrm{S}}_2,,,,,,{\mathrm{S}}_{\mathrm{n}})$ /* Create Test Train Split using ICCS library. */ For (Each node in ${\mathrm{NODES}}_{\mathrm{i}\in \mathrm{N}}$) Do Compute${\mathrm{Risk}}_{\mathrm{emp}}\left[ \mathrm{f} \prime \right]\leftarrow \frac{1}{\mathrm{m}} \sum _{\mathrm{i}=1}^{\mathrm{m}}\mathrm{L} ({\mathrm{y}}^{\mathrm{i}}, \mathrm{f} \prime \left({\mathrm{x}}^{\mathrm{i}}\right)$ Compute Loss Function $\leftarrow \frac{1}{\mathrm{n}} \sum _{\mathrm{k}=1}^{\mathrm{n}}{\left(\mathrm{c}\left({\mathrm{F}}_{\mathrm{k}}, \vartheta \right)-{ \mathrm{m}}_{\mathrm{k}}\right)}^2$ If$(\vartheta \left(\mathrm{D}\right) \ge \mathrm{Last} \mathrm{updated} \underset{\vartheta \in \left[0,\infty \right)}{\max }\mathrm{B} \left(\mathrm{c}\left(. ,\vartheta \right), \mathsf{\pi }\right)$) then Replace$\vartheta \left(\mathrm{D}\right)$ Recompute Loss Function End If Compute$ɀ$ Set$\mathrm{R}\left[\mathrm{f}\right] \le { \mathrm{Risk}}_{\mathrm{emp}}\left[{\mathrm{f}}^{\prime }\right]+ɀ$ Examine error bounds for regularization If (error > 0.2 and < 0.8) Then Update the LTobject.LT(x, y, z) Update x, y, z from Logical Table End If End For Compute$(\mathrm{Algo}.{\mathrm{Risk}}_{\mathrm{emp}}\left[\mathrm{f}\right]$, LT) Compute$\mathsf{\Phi }$ Compute e, E and ${\mathrm{E}}_{\mathrm{opt}}$ /*Using Risk Function and LTobject Update * End While Return$\mathsf{\Phi },{ \mathrm{Risk}}_{\mathrm{emp}}\left[\mathrm{f}\right], \mathrm{e}, \mathrm{E}$, ${\mathrm{E}}_{\mathrm{opt}}$

Theorem 3. 

$Algo.Blend\left(p,q,r\right)$,$Algo.GG(\mathsf{₲}\left(p,q,r\right),$and$Algo.Error\left(p,q,r\right)$support the parallel Turing integration paradigm.

Proof. 

Let us take the pools of the supervised learning algorithms such as $\mathrm{A}\left(\mathrm{p},\mathrm{q},\mathrm{r}\right)=\left\{{\mathrm{A}}_1,{\mathrm{A}}_2,.........,{\mathrm{A}}_{\mathrm{n}}\right\}$, which acquires the given data $D_s=\left\{{\mathrm{ds}}_1,{ \mathrm{ds}}_1,{ \mathrm{ds}}_3,........,{\mathrm{ds}}_{\mathrm{n}}\right\}$; thus, the correlation exists. Therefore, matching factor $M_f$ can be expressed as $M_f\left(\mathrm{p}\to 0,\mathrm{q}\to 0,\mathrm{r}\to \infty \right)$. The LG exists for each algorithm such that GG is available in optimized fashion that is illustrated as $\mathrm{g} \in \left(1-\mathsf{₲}\right) \left|\right|(\mathrm{A} \in \{1,2,. . . ,\mathrm{n})$. The optimization functions exist for each algorithm. Therefore, each algorithm possesses the set of predictor characteristics, such that ${\mathrm{S}}_{\mathrm{input}}=\left\{1,2, . . . ,{\mathrm{T}}_{\mathrm{n}}\right\},$ and targeted variables, ${\mathrm{S}}_{\mathrm{output}}=\left\{1,2,3,4, . . .,{ \mathrm{T}}_{\mathrm{n}}\right\}$. Thus, each given algorithm $A$ performs well in the blend for each set of features $S_{fe}$. Hence, the enhanced weighted performance metric $W_{pm}$ should be $\ge 0.75$ for each specified parameter, which remains above the threshold value of the measurement until $W_{pm}$ falls below 0.75. Therefore, $\mathrm{A} \in {\mathrm{All} \mathrm{in} \mathrm{A}}_{\mathrm{x},\mathrm{y},\mathrm{z}\leftarrow 0.1}$. The LE becomes very unstable in blend, and thus the model creates a complex error function ($\mathbb{E}\left(\mathrm{x},\mathrm{y},\mathrm{z},\right)$ such that $\mathrm{e} \in \mathbb{E} | \log \left({\mathbb{E}}^{\mathrm{e}}-1\right)$ > 0, and let $\mathsf{⍱}$ be the measure of complexity of the GE within a probability $\mathrm{p} >1- \mathsf{\delta } , \mathrm{where} \mathrm{all} \mathsf{\delta } \subseteq \frac{1-\mathrm{p}}{{\mathrm{p}}^2}$. There must be a hypothesis “h” on GE that travels in the x, y, and z directions. It shows nonlinearity that is dependent on the number of algorithms in the blend. Moreover, it is distributed linearly throughout the space in the LE. □

Construction. 

The $E_d,H_d,M_d$ functions can be employed in the space. The optimum GG is used for induction. Therefore, Euclidean distance can be used for measuring the distance that is given by:

$$E_d=\sqrt{{\left(x_1-x_2\right)}^2+{\left(y_1-y_2\right)}^2}$$

(18)

Similarity can then be obtained using Hamming distance $H_d$, which is specified by:

$$H_d={\displaystyle \sum }_{j=1}^k\left|x_j-y_j\right|$$

(19)

Thus, Minkowski distance $M_d$ can be calculated as:

$$M_d={\left({\displaystyle \sum }_{j=1}^k{\left|x_j-y_j\right|}^p\right)}^{\frac{1}{p}}$$

(20)

We create the related matching factor (MF) based on these data at the point when each distance reduces to the smallest potential value with the least amount of theoretical GE (Err).

$$MF\left(x,y,z\right)=\frac{1}{S}{\displaystyle \sum }_{i=1}^n\left(A_i\right)\pm \left\{\frac{\left(E_d+H_d+M_d\right)}{n}\right\}, Err<0.5$$

(21)

The triangles are built for our blend using the 3-D space and axis align method. Let $\Delta =\left\{{\Delta }_1,{\Delta }_2, {\Delta }_3,..........,{\Delta }_n\right\}$, which specifies the immeasurable number of triangles in disseminated fashion which are given as:

$${\Delta }_{\left(x,y,z\right)}^{\left(a,b\right)}=\left\{\mathbb{W}(x\leftarrow a , y\leftarrow b, z\leftarrow ab : a\le b, and ab>0\right\}$$

(22)

The following function describes the search for optimal coordinates: where $\mathbb{W}=\left\{\begin{array}{c}1, a\le b\\ 0, ab>0\end{array}\right.$ and EWPM is obtainable through IMLE API. Let us assume that EWPM should remain above 0.5 for optimal zone in the 3D rational space. Thus, the co-ordinates for the y-axis can be expressed as:

$$Y_i=\alpha +{\left[\begin{array}{c}\alpha \\ {\beta }_1\\ {\beta }_n\end{array}\right]}_1{X}_{i,1}+........ {\left[\begin{array}{c}\alpha \\ {\beta }_1\\ {\beta }_n\end{array}\right]}_n{X}_{i,n}+{ϵ}_i, \mathrm{Where} ϵ=\left[\begin{array}{c}{ϵ}_1\\ {ϵ}_2\\ ...\\ ...\\ {ϵ}_n\end{array}\right] \mathrm{in} \mathrm{each} \mathrm{dimension}$$

As a result, given corresponding values and blend of the algorithms switches from multidimensional space to lower dimension. After tuning has been accomplished (Theorems 1–3), an error happened as a complicated function, dependent on a variety of variables and the fundamental blend of algorithms. The global err is displayed in Figure 5 as every algorithm’s LE is no longer applicable mathematically. The Each algorithm’s standard deviation error ($\sigma )$ tends to rise when it is coupled with another algorithm. A common statistical method that models relationships between n+ variables using a linear equation to determine its fitness is developed by:

$$Standard Deviation Error=\sigma =\sqrt{\left(\frac{{\sum }_j{\gamma }^2{}_j}{ \left(n-p-1\right)}\right)}$$

(23)

$$y_i=f\left(x\right)=\left\{\begin{array}{l}0, If error falls above the threshold\\ 1, If error is acceptable.\end{array}\right.$$

(24)

The distribution can be written using Bernoulli Distribution process:

$$Y_i: Prob\left\{Y_i=y_i \right\}={\pi }_i^{y_i}{\left(1-{\pi }_i\right)}^{1-y_i}$$

The bounds of 20% and 80% should be tuned. The small circles demonstrate the $\left(x,y,z\right)$ infinite space in the logical cube depicted in Figure 6. Note that each point varies between 0 and 100%. It is ideally used when output is binary, such as 1 or 0, Yes or No, etc. A logit function governs the linear model in LR. Thus, we can finally construct using Equation (25).

$$Er{r}^2={\left(\sqrt{\frac{\left(Er{r}_{Measured}-Er{r}_{Calculated}\right)}{n}}\right)}^{n^2}$$

(25)

$$H\left(s\right)=-p_{1}log p_1-p_{1}lo{g}_1......-p_{2}log p_2......-p_{n}log p_n$$

(26)

Normally we encounter classification error with training error and testing error. If we assume D to be the distribution and ‘exp’ is an example from D, and let us define target function to be f(exp) indicating the true labeling of each example, exp. During the experiment of training, we give the set of examples as $ex{p}_1,ex{p}_2,ex{p}_3,ex{p}_4......ex{p}_n$ and labelled as $l(ex{p}_{1)},l\left(ex{p}_2\right),l\left(ex{p}_3\right),l\left(ex{p}_4\right)......l\left(ex{p}_n\right)$.

We examine for incorrectly classified examples with the likelihood of failure in distribution D in order to identify the overfitting.

Then, for each algorithm, we build a gain function that is dependent on fundamental performance metrics including bias, underfitting, overfitting, accuracy, speed and error [28]. We only consider bias-ness (B), underfitness (UF), and overfitness (OF) as factors that influence how the fundamental algorithm learns. As a result, we may start creating the gain function $\mathsf{₲}=gain \left\{A \in \left(1,2,3,4,....., n\right)\right\}$. As illustrated in Figure 7, we establish the GG to ensure that the LG for every blend reduces the distance between the two triangles in order to create the blend function. Furthermore, Figure 7 also illustrates over-probability stretch using three dimensions. The correlation of the features $g$, gain function $ɀ$ and over probability $\rho$ can be determined as:

$$0\le g\left(a,b,c\right)\le {\displaystyle \sum }_{i=0}^n\left(\begin{array}{c}a,b,c\\ C\end{array}\right)\le \rho$$

(27)

Overfitness (z) is observed to be reduced in the $x$ and $y$ coordinates. The primary purpose of GG is to maintain the point in the area where the mistake “err” is acceptable.

We tweak the gain function to ensure that in the final blend we may filter the algorithm and progressively blend to be as optimal as is feasible. This is done in considering the fact that LG will be extremely high in lower dimension, and GG designated as $ɀ$ will be lower in lower dimension. As rationally demonstrated in the algorithm formulation, the approximation function (AF) connects the score factor between a collection of predictor characteristics $S_{input}$ = {1, 2, 3, 4,......, $T_n$} and target variables $S_{output}$ = {1, 2, 3, 4,......, $T_n$}. As a result, we compute GG by employing Equations (24)–(28).

$$\mathsf{₲}=\frac{(L{F}_1-L{F}_2) }{Norm \to \left(\alpha ,\beta ,\gamma \right)}\times e^n \frac{1}{2} {\displaystyle \sum }_{i=1}^m{\displaystyle \sum }_{j=1}^m\alpha \beta {\gamma }_{i,j}‹{\alpha }_{i,j},{\beta }_{i,j},{\gamma }_{i,j}› +{\displaystyle \sum }_{k=1}^K\left({\left(\alpha \beta \gamma \right)}_k\right)$$

(28)

3.4. Final Framework of PTIP

A robust framework that combines hardware, firmware and software optimization is needed to optimize an ML space and algorithm. Several cutting-edge algorithms are utilized to support the software optimization tactics. The final framework is supported by the regularized risk reduction approach and kernel learning in different segments.

Let $\Omega \left(*,x\left|y\right|z\right)$ be a convex function for unconstrained minimization of the learning the regularized risk minimization, where space is considered distributed in 3-D dimension, for which our goal is to optimize the algorithm blend in z-dimension with minimum cost function $ℂ\left(a,b,c\right)$, such that the averaged empirical risk function (Φ(t)) associated with algorithm blend inside the boundaries of convex function. Thus, we construct:

$$\Omega \left(*,a\left|b\right|c\right)=\Omega \left(*,a\left|b\right|c\right)\in \left(\mathbb{F}.\rho \left\{\frac{f\left(A,B,C\right)}{{\left(x-xy\right)}^2\times \left(y-z\right)}\right\}\right)$$

(29)

To conduct the experiments, typical experimental values for the local gain, global gain, and cost function have been chosen which are provided in

Table 4. Typical experimental values during training.

	Min	Max	Averaged	Out of Bounds
LG{g(a, b, c)}	0.21	0.72	0.58	−1.8
$GG\left\{\beta \right\}$	0.39	0.82	0.72	−1.2
$ℂ\left(a,b,c\right)$	0.11	0.79	0.63	+2.3

.

Figure 8 depicts the cost function reduction based on LG function. As we can see, LG, based on M.D as constructed earlier in theory, decides the widening or shrinking of the green shape, as shown.

As the arrow moves in the 3-D space (cube) in either direction (optimum for z) then the COST function changes, for which the following conditions apply in optimum space in acceptable Gain function as explained earlier, such that $\mathbb{F} \in \underset{\mathbb{F} \in \left(\mathcal{R}+\mathbf{1}\right)}{\mathbf{min}}\left(\mathit{\Phi }\left(\mathit{t}\right)\right)$, for $\mathit{t} \to {\left(\mathit{T}+\mathbf{1}\right)}^{\mathcal{R}}$, and ${\mathcal{R}}^n \to \mathcal{R}$ for infinite point in 3-D space.

Finally, we can write the generic form of our three constructs that this theorem aimed to develop. The following algorithm aims to govern these and provides to the external layer that can be built as:

$$lgo.Blend\left(x,y,z\right))={\displaystyle \prod }_{i=0}^{new N}\mathbb{F}{ }_i+{\displaystyle \sum }_{j=0}^{new K}{ℂ}_j\left| \left(\mathbb{F}{ }_i\times {ℂ}_j \right)\right|-{\displaystyle \sum }_{m,n,o}^{X,Y,Z}\left(A_m+A_n+A_0\right)$$

(30)

$$lgo.Blend\left(x,y,z\right))={\displaystyle \prod }_{i=0}^{new N}\mathbb{F}{ }_i+{\displaystyle \sum }_{j=0}^{new K}{ℂ}_j\left| \left(\mathbb{F}{ }_i\times {ℂ}_j \right)\right|-{\displaystyle \sum }_{m,n,o}^{X,Y,Z}\left(A_m+A_n+A_0\right)$$

(31)

$$\mathbb{E}\left(\left(\mathsf{₲}\left(x,y,z\right)\right)=Algo.Error\left(x,y,z\right)\right)={\displaystyle \sum }_{i=1}^{g\left(x,y,z\right)}Algo.GG(\left(\mathsf{₲}\left(x,y,z\right)\right)-{\displaystyle \sum }_{j=1}^{err\left(x,y,z\right)}Er{r}^2{ }_j$$

(32)

The optimization of the model is critical. As a result, there is a requirement for experimental examination of various functions to be employed for improvement, as indicated in

Table 5. Experimental analysis of the functions including GG function.

Metrics	1	2	3	4	5	6	7	8	9	10
$\mathsf{₲}\left(GG\right)$	0.0112	0.0325	0.0321	0.0790	0.1390	0.2007	0.3892	0.5802	0.6419	0.6912
$\Omega \left(*,x\left|y\right|z\right)$	0.0012	0.0024	0.0079	0.0083	0.0097	0.0293	0.0301	0.0402	0.0511	0.5990
$g\left(x,y,z\right)$	0.2198	0.2500	0.2698	0.3312	0.3900	0.4319	0.4901	0.5510	0.5912	0.6339
O.F	0.9123	0.8121	0.8821	0.7102	0.65103	0.6615	0.5805	0.5210	0.5190	0.4231
U.F	0.7000	0.6812	0.6617	0.6101	0.5512	0.5100	0.4913	0.4301	0.4100	0.3809

.

Definition 1. 

PTIP explains the principles of the two essential functions of tuning and blending. These constructions proved to be really helpful for classification objectives. Additionally, this definition builds the Binary decomposition function that the LT object uses to define and calculate the cost function.

The Algorithm 3 builds on Theorem 3, which computes the complex error function, gain function, and Blend function. The Algorithm 3 lowers model parameter errors in order to produce a resilient framework. Figure 9 depicts the proposed PTIP at a higher elevation. The framework is an enhancement to the normal machine learning approach for training and assessing raw data. The innovative ideas of LE, GE, LG, and GG are presented in the final framework, which jointly aid in enhancement.

Algorithm 3: Blended and optimal computation for a resilient framework

Input:$\mathsf{\Phi },{ \mathrm{Risk}}_{\mathrm{emp}}\left[\mathrm{f}\right], \mathrm{e}, \mathrm{E}$, $Ё ,$$\mathrm{F}\left\{\mathrm{n}\right\},$ The features set, Data Sets for Sampling

Output:$\mathbb{E}$, $\mathrm{Algo}.\mathrm{Blend}\left(\mathrm{x},\mathrm{y},\mathrm{z}\right)$), $\mathrm{Algo}.\mathrm{GG}(\left(\mathsf{₲}\left(\mathrm{x},\mathrm{y},\mathrm{z}\right)\right)$

Initialization: $\mathrm{e} \leftarrow 0, \mathrm{E} \leftarrow 0\prime$

Create LTObject, ${\mathrm{NODES}}_{\mathrm{i}\in \mathrm{N}}$, $\mathrm{PTIP}$ Generate ObjectIMLE(h)/* Generate an object reference for improved machine learning engine application programming interface (API)*/ Set ObjectIMLE.PublicFunctions(h.IMLE, h.EFES, h.EWPM, h.ICCS)/* managing the four constructs*/ Compute Global SDE $\mathsf{\sigma } \leftarrow \sqrt{\left(\frac{{\sum }_{\mathrm{j}}{\mathsf{\gamma }}^2{}_{\mathrm{j}}}{ \left(\mathrm{n}-\mathrm{p}-1\right)}\right)}$ Initialize${\mathrm{Y}}_{\mathrm{i}}, ϵ$ For (each row in LTobject) Do Construct: the $\mathbb{W}$ from the LT Construct Logical 3D Triangle /* As shown in Figure 7 */ Compute LE /*Using equations (19) */ While (Distance Function Reduces and $\mathbb{E} \ge \mathrm{e} \&\& \mathrm{E} \in \left(0:1\right))) Do$ Compute${\mathrm{E}}_{\mathrm{d}}\leftarrow \sqrt{{\left({\mathrm{x}}_1-{\mathrm{x}}_2\right)}^2+{\left({\mathrm{y}}_1-{ \mathrm{y}}_2\right)}^2}$ Compute${\mathrm{H}}_{\mathrm{d}}\leftarrow \sum _{\mathrm{j}=1}^{\mathrm{k}}\left|{\mathrm{x}}_{\mathrm{j}}-{\mathrm{y}}_{\mathrm{j}}\right|$ Set$\mathrm{P}\left\{{\mathrm{Y}}_{\mathrm{i}}={ \mathrm{y}}_{\mathrm{i}} \right\} \leftarrow { \mathsf{\pi }}_{\mathrm{i}}^{{\mathrm{y}}_{\mathrm{i}}}{\left(1-{ \mathsf{\pi }}_{\mathrm{i}}\right)}^{1-{\mathrm{y}}_{\mathrm{i}}}$ Update LTObject (${\mathrm{E}}_{\mathrm{d}}$, ${\mathrm{H}}_{\mathrm{d}}$) If (${\mathrm{E}}_{\mathrm{d}}$ and ${\mathrm{H}}_{\mathrm{d}}$ < $\sqrt{{\mathbb{W}}^{{\mathrm{Y}}_{\mathrm{i}}}) }$) then Compute:${\mathrm{M}}_{\mathrm{d}}\leftarrow {\left(\sum _{\mathrm{j}=1}^{\mathrm{k}}{\left|{\mathrm{x}}_{\mathrm{j}}-{\mathrm{y}}_{\mathrm{j}}\right|}^{\mathrm{p}}\right)}^{\frac{1}{\mathrm{p}}}$ Compute: LG $\mathrm{g}\left(\mathrm{x},\mathrm{y},\mathrm{z}\right)$ Compute ObjectIMLE.Fitness(g.EFES) Recompute${\mathrm{E}}_{\mathrm{d}}$ and ${\mathrm{H}}_{\mathrm{d}}$ /* Based on g.EFES) */ Set$\mathrm{Norm} \to \left(\mathsf{\alpha },\mathsf{\beta },\mathsf{\gamma }\right)$ Compute$\mathsf{₲}$ End If Compute${\mathrm{LF}}_1 \leftarrow$$\left(\frac{{\mathrm{p}}_1}{1-{\mathrm{p}}_1}\right)$ Compute${\mathrm{LF}}_2 \leftarrow$$\left(\frac{{\mathrm{p}}_2}{1-{\mathrm{p}}_2}\right)$ Set${\mathcal{R}}^{\mathrm{n}} \to \mathcal{R}$ Set$\mathrm{t} \to {\left(\mathrm{T}+1\right)}^{\mathcal{R}}$ /* T is averaged of t */ Set$\mathrm{e}\left(\mathrm{L}\right),\mathrm{e}\left(\mathrm{H}\right)\leftarrow \left(\mathrm{x}\in \mathrm{X},\mathrm{y}\in \mathrm{Y},\mathrm{z}\in \mathrm{Z}\right)$ /* Based on LT object values */ End While Examine ObjectIMLE.Optimize(${\mathrm{LF}}_1,{ \mathrm{LF}}_2, \mathsf{₲})$ Update LTObject.Metrics(ObjectIMLE) Compute$\mathbb{E}, \mathrm{Algo}.\mathrm{Blend}\left(\mathrm{x},\mathrm{y},\mathrm{z}\right)$), $\mathrm{Algo}.\mathrm{GG}(\left(\mathsf{₲}\left(\mathrm{x},\mathrm{y},\mathrm{z}\right)\right)$ End For Return$\mathbb{E}, \mathrm{Algo}.\mathrm{Blend}\left(\mathrm{x},\mathrm{y},\mathrm{z}\right)$), $\mathrm{Algo}.\mathrm{GG}(\left(\mathsf{₲}\left(\mathrm{x},\mathrm{y},\mathrm{z}\right)\right)$

Definition 2. 

PTIP includes a thorough explanation of the Cost function theory based on Definition 1. This cost function is also essential for evaluating the algorithms, comparing components and features, as well as for computing the precise quantification of the blending and tuning functions.

Case Study 1. 

The proposed PTIP solves two major issues, weaker generalization and reduced accuracy. The proposed PTIP can be expanded to popular machine learning scenarios. Generalization in machine learning shows how well a trained model categorizes or predicts previously unobserved data. When a machine learning model is generalized, it may be trained to function across all subsets of unknown data. One instance is the intricate clinical processes involved in medication manufacture. Particularly with today’s high-tech treatments dependent on particular ingredients and manufacturing processes, medication creation takes time. The entire process is divided into several stages, some of which are contracted out to specialized suppliers. Therefore, these procedures need to be carried out accurately.

It has currently been observed with COVID-19 vaccine production that it requires generalization. The vaccine’s creators provide the production blueprint, which is then carried out in sterile production facilities. The vaccine is transported in tanks to businesses that fill it in clinical settings in tiny dosages before another business produces the supply. Additionally, medications may only be kept for a short period of time and frequently require particular storage conditions. Accurate treatment should be provided for these disorders. Clinical conditions can be accurately provided by the PTIP. The entire planning process is a very complex process that starts with having the appropriate input materials available at the appropriate time, continues with having enough production capacity, and ends with having the appropriate number of medications stored to meet demand. In addition, this has to be handled for countless treatments, each with a particular set of circumstances. The management of this complexity requires the use of computational approaches. For instance, PTIP with supervised learning techniques is used to choose the best partners for the production process.

4. Experimental Result and Discussion

This section presents various experimental results with necessary discussion and information. Each figure is accompanied with detailed information and comments to elaborate on the experimental analysis of the proposed model.

4.1. Research Methodology and Datasets

4.1.1. Research Methodology

Extensive research, acquaintance, and assessment are critical aspects in establishing the foundation of our proposed PTIP paradigm. As a result, we implemented the proposed PTIP and compared it to existing state-of-the-art algorithms, and as a further result, libraries used for existing algorithms are used for getting the outcomes. For diverse research topics and datasets we investigated the literature and reported their conclusions. Some of the results are compared to our proposed approach, as indicated in the results in the following sections. The goal of our study is to learn the current status of these ML algorithms so that we may progress them with our work, as detailed in this paper. To summarize, the genuine comparison is rather difficult due to the nature of the issue and datasets for which the algorithms are designed. In other words, one may outperform the other in some instances, but the reverse outcomes may be found in others. The scope of this article does not allow for a detailed comparison and experimental examination of each. A broad comparison of several of the algorithms is offered.

4.1.2. Datasets

We made use of information from the following several domains. Some datasets are available in raw, CSV, and SQL light formats, complete with parameters and field descriptions. All of our input data were converted and stored in the SQL Server database system. Some datasets have been discovered to be appropriate for performing tasks such as stock market, healthcare prevention, criminal control prediction, and epidemic identification.

▪

http://www.Kaggle.com, accessed on 1 August 2022. Iris species, credit card fraud detection, flight delays and cancellations, human resource analytics, daily news for market prediction, SMS spam collection, 1.88 Million US wildfires, gender classification, Twitter users, retail data Analytics, US mass shootings, breast cancer, exercise pattern prediction, fatal police shootings, Netflix prize data, student survey, Pima Indians diabetes Database, Zika virus epidemic, WUZZUF Job Posts.

▪

Social networking APIs.

▪

http://snap.standford.edu, accessed on 1 August 2022. Twitter, Facebook, bitcoin and Wiki dataset.

▪

https://aws.amazon.com/datasets/, accessed on 1 August 2022. Japan Census data, Enron email data, 1000 Genomics Project.

▪

http://archive.ics.uci.edu/ml/index.php, accessed on 1 August 2022. heart disease dataset, Iris, car evaluation, bank marketing data.

▪

https://docs.microsoft.com/en-us/azure/sql-database/sql-database-public-data-sets, accessed on 1 August 2022.

▪

https://www.reddit.com/r/bigquery/wiki/das, accessed on 1 August 2022.

4.1.3. Tools

The preliminary work is done using a Microsoft SQL Server and machine learning, and Microsoft Azure. The R language, C#, and Python were used to assess the efficacy of the proposed approach and underlying algorithms. Python libraries such as Pandas, SciPy, Matplotlib, Numpy, statsmodels, scikit-learn, fuel, SKdata, ScientificPython, and fuel, mILK have been implemented. Additionally, R libraries such as KlaR, gbm, RWeka, tree, CORELearn, ipred, rpart, MICE Package, CARET, PARTY, and random forest were utilized. Finally, GraphPad Prism is used to generate the simulated findings.

Based on the testing, we obtained the following interesting metrics:

▪

Accuracy with fitness factor;

▪

Relative Accuracy;

▪

PTIP with Fitness function;

▪

Error Reduction;

▪

Generalization measurement.

4.2. Accuracy

We ran 10 experiments (using 200 data samples) for various datasets to observe the overall performance of the algorithms: Support vector machine (SVMs), K-Nearest Neighbor (KNN), Logistic Regression, Multiple Linear Regression (MLR) [29], Decision tree (DR) [30], Graph-based boosting (GB) [31], and Random forest (RF) algorithm [32]. The PTIP is implemented and compared with existing techniques. The results are produced as depicted in Figure 10a. We used CART and ID3 for DT, and it has been observed that the proposed PTIP is found to be efficient. When the number of data samples is increased to more than 300+, the performance of the proposed PTIP still remains stable as compared to competing algorithms depicted in Figure 10b. On the other hand, the accuracy of the contending algorithms is greatly affected. It is imperative to note that we observed through our experiments that the outcome of various algorithms is not highly consistent. Hence, it is our motivation to pursue this research to stabilize the outcome and create a modified version that may be generalizable for many different problems and datasets.

4.3. Relative Accuracy

The relative accuracy shows that the measured value should be almost comparable to the standard value. The proposed method PTIP delivers the optimum fitting. Figure 11a shows how to calculate relative accuracy using error limits reflection. In the case of underfitting, outfitting, and global assessment error, a modest global gain is employed. The proposed PTIP’s performance was compared to the following state-of-the-art methods: an iterative method for discrete variational (IMDV) [20]; cross-modal Turing test (CMTT) [21]; polynomial-time Turing machine (PTTM) [22]; neural Turing machine (NTM) [23]; and a-decidable and i-decidable algorithms (AIA) [24]. According to the experimental data, the PTIP generates the least relative accuracy with error bounds reflection.

The lower relative accuracy with low GG is considered good. The PTIP obtains 38.76% relative accuracy with error bounds reflection. While the contending methods produce 48.7–61.2% relative accuracy with error bounds reflection, that is considered worse. Figure 11b demonstrates the relative accuracy with a high GG. Based on the result, it is observed that PTIP produces better relative accuracy that helps improve the classifier. The main reason for getting better relative accuracy with high GG is to use of improved optimum fitness function. The PTIP obtains 70.5% relative accuracy with high GG, which is considered an acceptable accuracy. On the other hand, the contending methods gain low relative accuracy with high GG which is considered worse. The contending methods obtain 42.4–55.3% relative accuracy with high GG. The findings were derived from 10 separate datasets using an experiment with an average of 20 runs.

4.4. Fitness Process

A fitness function is a type of objective function generated by the proposed PTIP in order to define a single figure of merit. The testing is carried out, and the findings are classified into four colors: in each dimension the blue signifies extreme overfitting.

Green and yellow show that the classifier is unable to distinguish between overfitting and underfitting, while orange shows the best fit. Figure 12a shows the best fitness capability in each dimension. The inaccuracy at the negative value has been noted based on the results. The perfect performance of the LT optimum fitness function is depicted in Figure 12b. The absence of the blue tint is noticeable. Furthermore, it indicates that the z-dimension has the largest convergence, which is preferably required. As a consequence, the data are filtered using PTIP to find the optimal fitness range.

4.5. Error Reduction

The PTIP is capable of reducing errors. The error reduction method is depicted in Figure 13a–d. Figure 13a depicts the gain function dispersed across ten experimental runs. This result shows that the blended function in PTIP is distributed randomly along all axes. It demonstrates that GG is exceedingly low, and the model’s fitness is quite bad. Figure 13b depicts the progress of the PTIP as the number of errors decreases. Figure 13c depicts the tuning process’s evolution. As can be observed, the x and y dimensions have faded, and z has outrun the fitness limitations. However, the yellow color in the z-axis indicates an inaccuracy of more than 80%, which is still unacceptable for model application. Figure 13d finally shows the error in bounds of the (20–80%) rule, and the z-dimension has finally been optimized. The values displayed for 1.0 are optimistic, and the realistic values are observed from ranging 0.6–0.85.

4.6. Generalization Measurement

The generalization measurement process is depicted in Figure 14a–d. The experiment for 200 random datasets has been demonstrated using the proposed PTIP for generalization improvement. The proposed PTIP’s GE and LE functions are depicted. A circle represents the GE function, whereas a square represents the LE function. It should be highlighted that these findings come after measuring the model’s accuracy as an ideal fit across many thousand iterations.

Figure 14a depicts the development of a random distribution of local and global complex error functions. Figure 14b depicts the better separation of the two functions. Figure 14c depicts the model gradually learning (self-teaching) the distinction of LE and GE. Finally, Figure 14d shows the optimal separation of both functions. It should be observed that both functions overlap since one is local and the other is global. It is concluded that the overall generalization is greatly improved.

5. Conclusions and Future Work

This section summarizes the whole outcome of the proposed approach as well as its benefits.

5.1. Conclusions

The parallel Turing integration paradigm is described in this study to facilitate dataset storage. The proposed PTIP approach comprises of three cutting-edge building blocks: (a) it demonstrates the expansion of a logical 3-D cube that administers the algorithms to ensure optimal performance; (b) it demonstrates the improvement in a blend of algorithms based on parallel tuning of model and classifiers; and (c) it provides the ultimate model engineering to learn from its errors (wrong predictions) and explain itself to choose the correct algorithm and eliminate the incorrect predictions.

The outcomes of several tests are discussed in this article. To fine-tune the model and produce simulated data for the study, we ran 10–20 trials. In 3D space, the LG and GG functions have been developed and improved. Finally, the proposed PTIP offered better outcomes with the ability to generalize on a particular collection of facts and issues.

5.2. Future Work

We will test more algorithms, particularly in the fields of unsupervised learning, to enhance the PTIP and its components. We will be improving/developing a model called the “Predicting Educational Relevance For an Efficient Classification of Talent (PERFECT) algorithm Engine” (PAE). The PAE may be used in conjunction with PTIP and includes three cutting-edge algorithms: Good Fit Student (GFS); Noise Removal and Structured Data Detection (NR-SDD); and Good Fit Job Candidate (GFC).