How do I solve "pyrunfile is not suppoted" error in MATLAB Function ?

Hi @翼 ,

You mentioned, “I got these errors in MATLAB Function. I tried everything but I couldn't figure out how to solve. I'm not sure. Could you give me any advice? I'd be happy if you could tell me why this happens and where I'm missing. Also, I'm now executing this model on MATLAB Online.

Error1

The function 'pyrunfile' is not supported in code generation. Function 'MATLAB Function' (#24.95.220), line 2, column 13:. “pyrunfile(“scikit_learn_model.py”, “output_vars”,in1=input1,in2=input2,in3=input3")

Error2

Terminal width or dimension error. 'Output terminal 1' in 'MATLAB Function/input7' is a 1-dimensional vector with 1 element”

Please see my response to your comments below.

Let me address your query regarding, “Error 1: pyrunfile Not Supported for Code Generation”

The error you are encountering with pyrunfile arises because this function is not compatible with MATLAB's code generation capabilities. In scenarios where code generation is required (like when using Simulink), you should replace calls to pyrunfile with a mechanism that allows MATLAB to call Python functions without generating code for them. So, in your comments, you mentioned,

That means I need to use coder.extrinsic instead of pyrunfile to execute my .slx model? If it's true, It'd be nice if you could give me what the code is.This error is something to do with using MATLAB Online, isn't it?

Yes, you have to utilize coder.extrinsic. Here’s how you can modify your MATLAB Function:

function [trq, brake] = RunPython(input1, input2, input3, input4, 
input5, input6,input7)
coder.extrinsic('pyrunfile'); % Declare pyrunfile as extrinsic
outputs = pyrunfile("scikit_learn_model.py", "output_vars", ...
                       pyName1=input1, pyName2=input2, pyName3=input3, 
                       ...
                       pyName4=input4, pyName5=input5, pyName6=input6,   
                       pyName7=input7);

    trq = outputs(1);
    brake = outputs(2);
  end

So, in this code, the coder.extrinsic (pyrunfile) line tells the code generator to skip generating code for pyrunfile, allowing it to run during simulation instead. Make sure that you pass the inputs correctly as keyword arguments.

Now, let me address your query regarding “Error 2: Terminal Width or Dimension Error”

This error suggests that one of your output terminals in Simulink expects a different dimension than what it is receiving. Specifically, it seems that the output from your MATLAB Function may not match what Simulink expects.

Make sure that trq and brake have the expected dimensions. If they are supposed to be scalars and your Python model returns vectors or arrays, this mismatch will trigger an error. So, what you need to do is reshape or extract the specific values from your output variable. For example:

trq = double(outputs(1)); % Ensure output is a double scalar
brake = double(outputs(2)); % Ensure output is a double scalar

Here are some additions insights that will help you further. If possible, test your MATLAB function locally outside of Simulink to make sure it runs without errors before integrating it back into your Simulink model. Utilize MATLAB's debugging tools (disp, breakpoints) to inspect variable dimensions at runtime. This will help identify mismatches before they become runtime errors in Simulink.

By following these recommendations and making the necessary adjustments in your code and model configurations, you should be able to resolve the errors you are encountering. If issues persist, consider consulting MATLAB documentation or forums by clicking links below for further assistance tailored to your specific use case.

https://www.mathworks.com/help/simulink/ug/overview-of-integrating-python-code-with-simulink.html

https://www.mathworks.com/help/matlab/ref/pyrunfile.html

https://www.mathworks.com/help/matlab/matlab_external/ways-to-call-python-from-matlab.html

Please let us know if you need further assistance or help.

Hi @翼,

After doing analysis of your code and errors, it indicates that the outputs from the Python script are being treated as mxArray, which is not supported in the context of code generation. Specifically, the error messages suggest that MATLAB requires explicit definitions for the output variables. Additionally, the Python code does not properly handle the input variables, as they are referenced without being defined. So, to resolve these issues, you need to make sure that the output variables in the MATLAB function are explicitly defined with known types. Here’s how you can modify the MATLAB function:

function [trq, brake] = RunPython(input1, input2, input3, input4, 
input5, input6,input7)
  coder.extrinsic("pyrunfile");

    % Ensure outputs are initialized with known types
    trq = 0; % Initialize as a double
    brake = 0; % Initialize as a double

    outputs = pyrunfile("scikit_learn_model.py", "output_vars", ...
                        pyName1=input1, pyName2=input2, ...
                        pyName3=input3, pyName4=input4, ...
                        pyName5=input5, pyName6=input6, ...
                        pyName7=input7);

    % Convert outputs to double
    trq = double(outputs(1));
    brake = double(outputs(2));
  end

In the Python code, make sure that the input variables are defined correctly. For example:

import pickle

# Load the model
with open('surrogate_model.pkl', 'rb') as f:
  model = pickle.load(f)

# Define inputs from MATLAB
inputs = [in1, in2, in3, in4, in5, in6, in7] 

# Make predictions
output1, output2 = model.predict([inputs])  # Ensure inputs are passed   
correctly
output_vars = [output1, output2]

Please let me know if this helps resolve your issues.

Hi @翼 ,

You mentioned, _I changed my code as you said and I executed my model on MATLAB Online.But ,on this code here,

   outputs=pyrunfile("scikit_learn_model.py","output_vars", ...
    pyName1=input1,pyName2=input2,pyName3=input3,pyName4=input4, ...
    pyName5=input5,pyName6=input6,pyName7=input7);

I got the following error

Python Error: ModuleNotFoundError: No module named 'sklearn'

Is this because I'm executing it on MATLAB Online not on local?

or

Is this because .pkl file is created by scikit-learn?_

Please see my response to your comments below.

The error message you received, ModuleNotFoundError: No module named sklearn, typically indicates that the Python environment in which your code is running does not have the scikit-learn library installed. This can happen for several reasons:

Execution Environment: MATLAB Online may not have access to all libraries available in your local Python environment. Specifically, it often has a limited set of pre-installed libraries and may not include scikit-learn.

Library Installation: If you are running the code locally and it works there, but fails on MATLAB Online, it's likely that scikit-learn is not available in the MATLAB Online Python environment.

I will suggest following potential solutions to resolve the errors you encountered.

Check Installed Libraries: In MATLAB Online, you can check which Python libraries are available by running:

py.list();

This command will display a list of modules that can be imported.

Use Local Environment: If you need specific libraries like scikit-learn, consider running your model in a local installation of MATLAB where you can control the Python environment better.

MATLAB Online Limitations: If you must use MATLAB Online, check if MathWorks provides a method to request additional packages or consider using a different service that allows more extensive Python support.

Now, let me address your query regarding the Pickle File, the .pkl file format is used for serializing Python objects, and it doesn't inherently relate to your error unless you're trying to load a model saved in this format without ensuring that the appropriate libraries are available in your current environment. If you want to load a model from a .pkl file, make sure that pickle is available (which should be included by default). Load it correctly using:

pickle = py.importlib.import_module('pickle');
fh = py.open('model.pkl', 'rb');
model = pickle.load(fh);
fh.close();

However, ensure that any dependencies required by your model (like scikit-learn) are also present. I would also refer to you to read more about reading pickleball file in matlab by clicking the link below.

Run pickle file in matlab

Now, If you are working locally and want to ensure you have scikit-learn, you can install it via pip:

   pip install scikit-learn

Please let me know if this helps resolve your problems.

Hi @翼,

Given the compatibility table provided in the link below, MATLAB R2024b supports Python versions 3.9, 3.10, 3.11, and 3.12. This means you can technically use any of these versions to run your MATLAB functions that rely on Python.

https://www.mathworks.com/support/requirements/python-compatibility.html

My recommendation is mentioned below.

Use Python 3.11.0b4: Since you have already set this version as your local version in the specified folder (where your .python-version file is located), it makes sense to continue using it for your project, especially if you have already installed scikit-learn in this environment. If you run into any issues with compatibility or stability while using the beta version (3.11.0b4), consider switching to the stable version (3.10.5 or even 3.12). Also, make sure that you have scikit-learn installed in the active virtual environment linked to Python 3.11.0b4 using bash command.

   poetry add scikit-learn

MATLAB Configuration: Make sure that MATLAB is correctly configured to point to the Python executable from your selected version (3.11.0b4). You can set this in MATLAB using:

   pyenv('Version', 'path_to_python_executable'); % Update with your path

After setting up, you can test whether the integration works by executing a simple command in MATLAB:

   py.importlib.import_module('sklearn');

This should not return any errors if everything is configured correctly. Please bear in mind that while newer versions of Python often come with performance improvements and new features, they may also introduce breaking changes or bugs—especially beta versions like 3.11.0b4.

Hope this helps.

Hi @翼 ,

Let me address your first query regarding, “Which path should I set at ‘path_to_python_executable'here ?C:\Users\ts-yoshikawa\.pyenv\pyenv-win\versions\3.11.0b4\python.exe or C:\Users\ts-yosh\Desktop\myPython\ver3110b4\caret\.venv\Scripts\python.exe?”

In your case, you should set the `path_to_python_executable` to the executable located within your virtual environment, which is:

C:\Users\tsyosh\Desktop\myPython\ver3110b4\caret\.venv\Scripts\python.exe

This is because when you use poetry, it creates a virtual environment that contains all the dependencies (like pandas and sklearn) specifically for that project. Setting the path to the virtual environment's Python executable ensures that when you run commands from MATLAB, they utilize the packages installed in that environment.

Now, let me address your second query regarding, “I set "C:\Users\ts-yoshikawa\.pyenv\pyenv-win\versions\3.11.0b4\python.exe" and executed below command on my MATLAB,py.importlib.import_module('sklearn'); but I got this error. importlib_find_and_load_unlocked ModuleNotFoundError: No module named 'pandas' In the active virtual environment (env name: "caret"), I did “poetry run pip list" on my Command promt. “pandas" and "sklearn" and stuff has been displayed. Why is this happening? I couldn't figure out what is a problem....”

The error you encountered (ModuleNotFoundError: No module named pandas) suggests that MATLAB is not accessing the same Python environment where pandas is installed. Here are steps to troubleshoot:

Verify Active Environment: Make sure that your MATLAB session is indeed using the virtual environment's Python by running: pyenv, this will show you which Python executable is currently being used.

Reconfigure MATLAB's Python Environment: If it's pointing to a different version or installation, reconfigure it: pyenv('Version', 'C:\Users\ts-yosh\Desktop\myPython\ver3110b4\caret\.venv\Scripts\python.exe');

Check Installed Packages: After setting the path, run:

py.importlib.import_module('pandas');

If this still fails, double-check whether you are running MATLAB from an environment that has access to your virtual environment.

MATLAB Command Window Restart: Sometimes changes require restarting the MATLAB command window or even restarting MATLAB itself to take effect.

Here are some additional insights that I would like to share with you.

Virtual Environments: Using virtual environments like those created by poetry helps isolate project dependencies, preventing conflicts with system-wide packages.

Package Management: Always verify that the necessary packages are installed in your virtual environment using poetry run pip list. If a package is missing, install it via bash: poetry add pandas

Hope this helps. Please let me know if you have any further questions.

Hi @翼 ,

After going through your comments, now I understand what was the main reason behind all these issues because you are trying to enhance the processing speed of the Vehicle Control Unit (VCU) subsystem by leveraging the capabilities of a pre-trained scikit-learn model in Python. However, you have encountered performance issues, with the MATLAB function being slower than the original VCU calculations. Based on your observations, this slowdown appears to be linked to the use of the pyrunfile function, which loads the Python file each time it is called. My comments regarding to performance analysis are listed below.

Overhead of pyrunfile: The pyrunfile function shared by you introduces overhead because it must load the Python environment and execute the script every time it is called. This can significantly slow down execution, especially if your surrogate model is called frequently within simulations.

MATLAB-Python Integration: The integration between MATLAB and Python can be slow due to data type conversions and the need to pass data back and forth between environments. Each call to pyrunfile entails serializing inputs and deserializing outputs, which adds latency.

Model Loading Time: Loading your model with pickle in each function call can also contribute to delays. Ideally, you want to load the model once and reuse it.

So, my recommendations for improvement would be modifying your Python script so that the model is loaded only once at the start rather than during each function call. You can use global variables or singleton patterns in your Python code:

   import pandas as pd
   import pickle

   model = None  # Global variable

   def load_model(model_path='surrogate_model_new.pkl'):
       global model
       if model is None:
           with open(model_path, 'rb') as f:
               model = pickle.load(f)
       return model

If possible, batch your inputs together and process them in one call instead of individual calls for each input. This reduces the overhead associated with multiple calls. Make sure your calculations can be expressed using MATLAB's built-in functions or if you can convert your scikit-learn model to a format compatible with MATLAB (e.g., using MATLAB's Statistics and Machine Learning Toolbox), this might yield better performance. If possible use MATLAB’s Profiler (profile on;) to identify bottlenecks in your code execution. This will help you understand where time is being spent and guide further optimization efforts. For more information on profiling, please refer to

https://www.mathworks.com/help/matlab/matlab_prog/profiling-for-improving-performance.html

Some additional insights to help you out would be

Integration Alternatives: Consider using MATLAB's built-in support for Python functions more efficiently with py.<module>.<function> syntax instead of pyrunfile. This method may provide better performance.

Data Type Considerations: Make sure that data types being passed between MATLAB and Python are optimized for speed (e.g., using NumPy arrays).

Hopefully, by implementing these strategies, you should see an improvement in the processing speed of your surrogate model integration between MATLAB and Python.

Please let me know if you have any further questions.

Hi @翼 ,

Let me first address your challenge with predicting multiple outputs in MATLAB, you are correct that the Statistics and Machine Learning Toolbox is primarily designed for single-output models. This limitation can indeed pose difficulties when working with complex datasets that require simultaneous predictions across multiple outputs. Given your situation, here are some tailored solutions and insights:

Deep Learning Toolbox: Since you are considering using the Deep Learning Toolbox, this is a promising direction. The toolbox supports various architectures that can handle multiple outputs effectively. For instance, you can create a feedforward neural network with multiple output layers. Let’s say that your model has seven input features and two output targets, you could define a network structure where the final layer consists of two neurons (one for each output). This allows the network to learn from the inputs while simultaneously predicting both outputs.

Model Structure: Consider using a simple feedforward neural network or a more complex architecture like LSTM if your data has sequential dependencies. You can define your model using the layerGraph function to customize the architecture according to your needs.

Training Data: Make sure that your training data is structured appropriately, with inputs organized in a matrix form (7 columns for 7 inputs) and outputs in another matrix (2 columns for 2 outputs). Use functions like trainNetwork to train your model once it’s defined.

Here’s a simplified example of how you might set up a neural network in MATLAB for multi-output prediction:

% Define input and output sizes
inputSize = 7; % Number of inputs
outputSize = 2; % Number of outputs

% Generate synthetic training data
numSamples = 100; % Number of training samples
XTrain = rand(numSamples, inputSize); % Random input data
YTrain = rand(numSamples, outputSize); % Random output data

% Create layers
layers = [
  featureInputLayer(inputSize)
  fullyConnectedLayer(10) % Hidden layer with 10 neurons
  reluLayer % ReLU activation function
  fullyConnectedLayer(outputSize) % Output layer for two outputs
  regressionLayer]; % Use regression layer for continuous output

% Specify training options
options = trainingOptions('adam', ...
  'MaxEpochs', 100, ... % Maximum number of epochs
  'Plots', 'training-progress', ... % Plot training progress
  'Verbose', 0); % Suppress verbose output

% Train the network
net = trainNetwork(XTrain, YTrain, layers, options);

Now addressing your comments regarding, “I'm curious about these points. Does that mean we could make it better with just Python and MATLAB code without relying on Toolbox?If so, what would you refine my MATLAB function and python code?I wonder if it's better and faster to use Julia instead of Python. I imagine it's kind of like you make the same surrogate model with Julia and execute Julia in the Simulink model.I wish I could get better performance with this idea....”

By utilizing the py.<module>.<function> syntax instead of pyrunfile, you can directly call Python functions, which is generally more efficient. This approach minimizes overhead by avoiding the need to run an entire script each time.

     result = py.module_name.function_name(arg1, arg2);

This method enhances performance by allowing for better data type management, especially when using NumPy arrays, which are optimized for speed.

Data Type Considerations: Make sure that data types passed between MATLAB and Python are compatible and optimized. For instance, using NumPy arrays in Python allows for faster computations compared to standard lists.

     import numpy as np
     arr = np.array([1, 2, 3])

Generally, consider vectorization in MATLAB. Replace loops with vectorized operations where possible to enhance speed. Minimize data conversion overhead by keeping data in compatible formats.

Now finally, addressing your comment, “considering Julia as an Alternative”

Performance Benefits: Julia is designed for high performance, particularly in numerical and scientific computing. Benchmarks show that Julia often outperforms both MATLAB and Python, especially with larger datasets.

Syntax Similarity: The syntax of Julia is similar to that of MATLAB, making the transition smoother for users familiar with MATLAB’s style.Example syntax comparison:

     % MATLAB
     for i = 1:N
         % do something
     end

     # Julia
     for i in 1:N
         # do something
     end

If you decide to explore Julia further, start with its basic constructs and gradually incorporate it into your projects to assess its capabilities. Also, consider using Julia alongside your existing workflows; it can serve as a powerful tool without fully abandoning the tools you currently use.

Please click the following links below to gain more information.

https://discourse.julialang.org/t/including-a-julia-model-in-simulink/80627

https://www.mathworks.com/support/search.html/answers/1582569-matlab-is-significantly-slower-than-julia-on-simple-evaluation.html?fq%5B%5D=asset_type_name:answer&fq%5B%5D=category:parallel-computing/gpu-computing&page=1

If you still have any further questions, please let me know.

Hi @翼,

Thanks for your kind words.

After going through documentation provided at the link below

https://www.mathworks.com/help/deeplearning/ref/deepnetworkdesigner-app.html

and analysis of your comments, please see my response below.

Performance Considerations: Python vs. Julia vs. MATLAB

When considering whether to use Python, Julia, or MATLAB for deep learning applications, each option has distinct advantages:

Python: Widely adopted with extensive libraries (e.g., TensorFlow, PyTorch), rich community support and resources. However, performance can be suboptimal for certain operations due to its interpreted nature.

Julia: Designed for high-performance numerical computing, Offers speed comparable to C in many cases, making it suitable for intensive computations, integrates well with existing libraries but may have a steeper learning curve and less community support compared to Python.

MATLAB (Deep Learning Toolbox)

Provides seamless integration with Simulink, making it ideal for model-based design.The toolbox simplifies the process of designing and exporting neural networks into Simulink.Performance can be highly optimized for specific tasks, especially when leveraging MATLAB’s built-in functions.

In your case, if you are primarily working within the MATLAB environment and need to interface directly with Simulink, continuing with the Deep Learning Toolbox might be more beneficial despite concerns about performance.

Replacing VCU Subsystem

To replace the VCU subsystem with a block exported from Deep Learning Toolbox:

Exporting the Model: After designing your LSTM model in Deep Network Designer, ensure you export it correctly to Simulink. Select "Export > Export to Simulink" to generate a corresponding block.

Connecting Inputs and Outputs

Your LSTM model has 7 inputs and 2 outputs. In Simulink, connect the inputs to your block by linking them directly to the input ports of the LSTM block.Ensure that your input data format matches what the network expects (e.g., [sequence length x number of features]). For outputs, connect the output ports of the block to wherever you need the predicted values in your system.

Input Data Format

The LSTM block expects inputs as an N-by-C matrix (where N is the number of sequences and C is the number of features). You may need to reshape or transpose your input data accordingly.

Training with CSV Data

To train your model using soc_10.csv, follow these steps:

Data Preparation: Load your CSV data into MATLAB using readtable or csvread. Ensure that you clean and preprocess your data (e.g., handling missing values).

    data = readtable('soc_10.csv');

Separating Inputs and Outputs: Identify which columns correspond to inputs (features) and which column is the output label.

Creating Training Data: Convert your table into matrices suitable for training:

    X = data{:, 1:7}; % Assuming first 7 columns are inputs
    Y = data{:, 8}; % Assuming 8th column is output

Using Deep Network Designer: In Deep Network Designer, create a new network or modify an existing one to accept your prepared dataset. Utilize options such as Train Networt after setting up training parameters.

Training: Ensure you define appropriate training options (e.g., learning rate, epochs) before starting the training process.

    options = trainingOptions('adam', ...
        'MaxEpochs', 100, ...
        'MiniBatchSize', 32, ...
        'Verbose', false);

    net = trainNetwork(X, Y, layers, options);

Always refer back to MATLAB's official documentation for detailed examples on configuring blocks and exporting models; this can provide clarity on specific functionalities you may not have explored yet.

By following these structured steps and considerations, you should be able to resolve your current challenges effectively while optimizing performance within your chosen environment.