Solved in one article, anaconda creates a virtual environment, Python model is packaged, the C++ program calls the py file, and the entire program writing process is called.

Then, in the current environment, use conda install ipykernel to install the package, and then enter the python -m ipykernel install –name py3 command to complete the activation. When you open Jupyter Notebook againyou can select the desired virtual environment.

At this point, the virtual environment creation task is completed.

02-Python model export and use

Export model

Because before calling the C++ program, the model needs to be established first, that is, the model has been trained. Therefore, we do not need to continue to add the model in the .py file that needs to be called. For training, you only need to export the pkl file through the following command. This is the trained model. When needed, import it in the .py file. Execute the code below. You can get the .pkl model file

import joblib # Import package

# Divide the data set
X_train, X_test, y_train, y_test = train_test_split(X,y1,test_size=0.3,random_state=2023)
#Training data
gbdt = GradientBoostingRegressor(learning_rate=0.0409, max_depth=4, n_estimators=500, random_state=2023)
# Fit the data
gbdt.fit(X_train,y_train)
# Export model pkl file
joblib.dump(gbdt,'../pkl/Pred.pkl')

Use models

The following is how to use the model. Since the current .pkl file is already a trained model, the data can be directly imported for calculation. The method is shown in the code below. After executing the code, the y_pred obtained is the prediction result of the trained YP_Pred_102.pkl model file, which is very convenient to use.

import joblib # Import package

# Get files
pkl_file = '../pkl/Pred.pkl'
# Download model
gbdt=joblib.load(pkl_file)
# Make predictions, where X_pred represents the data set to be predicted
y_pred= gbdt.predict(X_pred)

03-Create py file

The py file is the main file we use to connect to the C++ program. It is both a file for python packaging and a file for calling in the C++ program. This file mainly contains two parts:

(1) Just import the data package you need to use directly (there are program instructions below).

(2) Define several required functions. This function is used to call in C++ programs, and data processing, pkl file import, and model calculation are all implemented in this function. (The procedure is as follows)

The code at the top of the code %%writefile hello_C + + .py, can convert the .ipynb file into a .py file (because in The python file created in Anaconda is in the .ipynb file format by default, and you need to use the .py file for subsequent packaging) Below is the py file we need, which is named hello_C++ file, Import the required package, and then create the function Pred(). When using the C++ program to call the hello_C++ file, then perform the function Pred ()Call, you can import data into the function, execute all the programs in the function, and get the calculation results.

#%%writefile hello_C++.py
import pandas as pd
import numpy as np
import math
#from sklearn.externals import joblib
import joblib
from joblib import load
import encodings
import codecs
import warnings
import geatpy as ea
warnings.filterwarnings("ignore", category=DeprecationWarning)


# This is just one function. If you need other model calculations, you need to create other functions.
def Pred(Paralist):

    X1=Paralist[0]
    X2=Paralist[1]
    X3=Paralist[2]
    X4 =Paralist[3]
    X5 =Paralist[4]
   
    ....... # Due to special reasons, part of the code is shown below. The process is similar


    X_pred_dict = {'A':[X1],'B':[X2],'C':[X3],
                   'D':[X4],'E':[X5],...}
    order=[ 'A','B', 'C','D', 'E',...]
    X_pred=pd.DataFrame(data=X_pred_dict)
    X_pred=X_pred[order]
    X_pred=X_pred.apply(pd.to_numeric,axis=0)

    X_pred['A'] = pd.to_numeric(X_pred['A'],errors='coerce')
    X_pred['B'] = pd.to_numeric(X_pred['B'],errors='coerce')
    X_pred['C'] = pd.to_numeric(X_pred['C'],errors='coerce')
    X_pred['D'] = pd.to_numeric(X_pred['D'],errors='coerce')
    X_pred['E'] = pd.to_numeric(X_pred['E'],errors='coerce')
    ...

    if st_product_no== 101 :
        pkl_file='./pkl/Pred.pkl'
    ...
    else:
        pkl_file='./pkl/.pkl'

    gbdt=joblib.load(pkl_file)

    y_pred= gbdt.predict(X_pred)

    return y_pred

04-py file packaging

Preliminary preparation

First, you need to check whether you have installed the installation package pyinstaller that supports packaging. The viewing method is as shown in the figure below. Because you are used to installing the installation package on the D drive, you need to switch it first and then enter pyinstaller< /strong>, if it looks like the picture below, it proves that the package has been installed. Otherwise, enter pip install pyinstaller to install it.

if (path_deploy == "local")
{
Py_SetPythonHome(L"d://Anaconda3//envs//py3");
}
else
{
Py_SetPythonHome((wchar_t*)(L"python37"));
}

try
{
Py_Initialize();//Before using python, you need to call Py_Initialize(); this function to initialize
}
catch(...)
{
system("pause");
}


if (!Py_IsInitialized())
{
sys_state = "Py_Initialize fail";

console_WFC_thread->error("Py_Initialize failed");
emit sys_state_update_link("1 Py_Initialize fail");
return 0;
}
else
{
sys_state = "Py_Initialize success";
console_WFC_thread->info("Py_Initialize() successful [HDGL_SYSTEM_Init]");
emit sys_state_update_link("0 Py_Initialize success");
}
\t
PyRun_SimpleString("import sys");
PyRun_SimpleString("sys.path.append('./')");//This step is very important, modify the Python path

float test()
{

PyObject * pModule = NULL; // Declare variables
PyObject * pFunc = NULL; // Declare variables

pModule = PyImport_ImportModule("hello_C + + ");//This is the file name to be called
if (pModule == NULL || PyErr_Occurred())
{
PyErr_Print();
cout << "User package import error" << endl;
system("pause");
}
\t
pFunc = PyObject_GetAttrString(pModule, "Pred");//This is the function name to be called
\t
PyObject* pLists = PyList_New(0);
PyObject* pArgs = PyTuple_New(1);

PyList_Append(pLists, Py_BuildValue("f", A)); // All data is passed in here
PyList_Append(pLists, Py_BuildValue("f", B));
PyList_Append(pLists, Py_BuildValue("f", C));

PyList_Append(pLists, Py_BuildValue("f", D));
PyList_Append(pLists, Py_BuildValue("f", E));
    ...

PyTuple_SetItem(pArgs, 0, pLists);

PyObject* pRet = PyEval_CallObject(pFunc, pArgs);

float Pred;
//Get results
PyArg_Parse(pRet, "f", & amp;Pred);//Convert return type
\t
return Pred;
\t
}