Gradient Descent optimization in an electrical circuit or transmission line

Is there any sample work of gradient descent based optimization of an electrical circuit or transmission line parameters done using MATLAB? I am trying to optimize the parameters of a nonlinear transmission line using gradient descent algorithm. I intend to use Matlab and LTspice. Any help regarding this problem would be greatly appreciated. Thanks.

Answer 1

[nick]

Hi Syed,

Here is a basic framework to get started for working with gradient descent optimization of an electrical cicuit :

Set Up MATLAB to Communicate with LTspice:

Use MATLAB to modify the LTspice netlist file to update the parameters. This can be done by reading and writing to the netlist file directly with the functions 'fopen' ,'fread', 'fwrite' and 'fclose' as shown:

function update_netlist_file(netlistFile, R_value)
    % Read the netlist file
    fid = fopen(netlistFile, 'r');
    fileContent = fread(fid, '*char')';
    fclose(fid);

    % Update the params value, here assume Resistor (assume a line like .param R=...)
    newContent =regexprep(fileContent, 'R=.*', sprintf('R=%.6f', R_value))

    % Write the updated content back to the file
    fid = fopen(netlistFile, 'w');
    fwrite(fid, newContent);
    fclose(fid);
end

function run_ltspice_simulation(ltspiceExe, netlistFile)
    % Execute LTspice simulation
    command = sprintf('"%s" -Run -b "%s"', ltspiceExe, netlistFile);
    system(command);
    pause(5); %Let the simulation be completed 
end

function results = extract_simulation_results(rawFile)
    % Use LTspice2Matlab or another method to read the .raw file
end

You can use 'LTspice2Matlab' a third party tool or can create your own parser to read the output file from LTspice. You can refer to the following documentation to learn more about these functions :

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

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

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

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

LTspice2Matlab: https://www.mathworks.com/matlabcentral/fileexchange/23394-fast-import-of-compressed-binary-raw-files-created-with-ltspice-circuit-simulator

Run LTspice Simulations from MATLAB:

Use MATLAB's system command to run LTspice simulations. You can execute LTspice from the command line using:

system('path_to_LTspiceXVII/XVIIx64.exe -Run -b netlist.cir');

After running the simulation, parse the output file (e.g., .raw or .log) to extract the results. You can refer to following documentation to learn more about 'system' function :

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

Implement Gradient Descent in MATLAB:

Use MATLAB's optimization toolbox or implement a custom gradient descent algorithm to minimize the error between the simulated and desired results.

Update the parameters in the LTspice netlist based on the gradient descent step.

Iterate Until Convergence:

Repeat the process of running simulations and updating parameters until the optimization converges to a satisfactory solution.

Hers's a skeletal MATLAB script that demonstrate the same

% Define initial parameters
params = [R_initial, L_initial, C_initial]; % Example parameters
learning_rate = 0.01;
tolerance = 1e-6;
max_iterations = 1000;

% Objective function to minimize
objective_function = @(params) run_simulation_and_get_error(params);

% Gradient descent loop
for iter = 1:max_iterations
    % Calculate the current error
    current_error = objective_function(params);
    
    % Compute the gradient 
    gradient = compute_gradient(params, objective_function);
    
    % Update parameters using gradient descent
    params = params - learning_rate * gradient;
    
    % Check for convergence
    if norm(gradient) < tolerance
        disp('Converged');
        break;
    end
    
    fprintf('Iteration %d: Error = %.4f\n', iter, current_error);
end

% Final optimized parameters
disp('Optimized Parameters:');
disp(params);

% Function to run LTspice simulation and get error
function error = run_simulation_and_get_error(params)
    % Parameters
    R_value = params(1); % Example parameter to optimize

    % File paths
    netlistFile = 'path_to_your_netlist_file.net';
    rawFile = 'path_to_your_output_file.raw';
    ltspiceExe = 'path_to_LTspice/LTspice.exe';

    % Update the netlist file with the new parameter
    update_netlist_file(netlistFile);

    % Run LTspice simulation
    run_ltspice_simulation(ltspiceExe, netlistFile);
    
    % Extract results from LTspice output
    simulationResults = extract_simulation_results(rawFile);

    % Compute the error between simulation results and desired results
    desiredResults = get_desired_results(); % Define your desired results
    error = compute_error(simulationResults, desiredResults);
end
function update_netlist_file(netlistFile, R_value)
    % Read the netlist file
    fid = fopen(netlistFile, 'r');
    fileContent = fread(fid, '*char')';
    fclose(fid);
    
    % Update the params value, here assume Resistor (assume a line like .param R=...)
    newContent =regexprep(fileContent, 'R=.*', sprintf('R=%.6f', R_value))

    % Write the updated content back to the file
    fid = fopen(netlistFile, 'w');
    fwrite(fid, newContent);
    fclose(fid);
end

function run_ltspice_simulation(ltspiceExe, netlistFile)
    % Execute LTspice simulation
    command = sprintf('"%s" -Run -b "%s"', ltspiceExe, netlistFile);
    system(command);
    pause(5); %Let the simulation be completed 
end

function results = extract_simulation_results(rawFile)
    % Use LTspice2Matlab or another method to read the .raw file
end

function error = compute_error(simulationResults, desiredResults)
    % Mean squared error
    error = mean((simulationResults - desiredResults).^2);
end

function desiredResults = get_desired_results()
    % Define your desired results for comparison
    % For example, a target voltage or current waveform
    desiredResults = [1, 2, 3, 4, 5]; %  Random data as a placeholder
end

function data = read_ltspice_raw(rawFile)
    % You can use third-party tools like LTspice2Matlab or write your own parser
    data = rand(1, 5); % Random data as a placeholder
end

% Function to compute gradient (finite differences as an example)
function grad = compute_gradient(params, objective_function)
    delta = 1e-5;
    grad = zeros(size(params));
    for i = 1:length(params)
        params_plus = params;
        params_plus(i) = params_plus(i) + delta;
        grad(i) = (objective_function(params_plus) - objective_function(params)) / delta;
    end
end

You can refer to the following article on 'Running LTspice from MATLAB" to learn more about running netlists:

https://medium.com/@amattmiller/running-ltspice-from-matlab-630d551032cc

Hope this helps.

[Syed Abid Sahdman]

@nick function data = read_ltspice_raw(rawFile)

% You can use third-party tools like LTspice2Matlab or write your own parser

data = rand(1, 5); % Random data as a placeholder

end

Here, what does the data represent? Suppose, I want to achieve an output voltage "Vout" of 10 V, how do I define the desiredresult in that case? It would be great if you have any example with an RLC circuit. I apologize if my questions are not up to the mark but I really need to figure this out. Thanks.

Answer 2

[Zinea]

Hi Syed Abid Sahdman,

To optimize the parameters of a nonlinear transmission line using ’Gradient Descent’, an integration of MATLAB for numerical optimization with LTSpice for circuit simulation can be used. Here are the steps that may be followed:

1.A MATLAB function to calculate the performance metric that needs to be optimized (e.g., minimizing signal distortion) is created as follows:

function cost = objectiveFunction(params) 
% Simulate the circuit with given parameters 
% params = [R, L, C, ...]; % Example parameters to optimize 
% Use LTspice to simulate 
% Extract the performance metric from the simulation results 
% Example: cost = calculateSignalDistortion(results); 
cost = ... % Define your cost calculation based on simulation results 
    end 

2. The ‘Gradient Descent’ algorithm is set up to adjust the parameters iteratively as follows:

    function optimizedParams = gradientDescent(initialParams, learningRate, numIterations) 
        params = initialParams; 
        
        for i = 1:numIterations 
            % Calculate the gradient (partial derivatives) 
            grad = computeGradient(@objectiveFunction, params); 
            
            % Update parameters based on gradient 
            params = params - learningRate * grad; 
            
            % Optionally, display progress 
            fprintf('Iteration %d: Cost = %.4f\n', i, objectiveFunction(params)); 
        end 
        
        optimizedParams = params; 
    end 

    function grad = computeGradient(func, params) 
        % Numerical approximation of the gradient 
        epsilon = 1e-6; 
        grad = zeros(size(params)); 
        
        for j = 1:length(params) 
            paramsPlus = params; 
            paramsPlus(j) = paramsPlus(j) + epsilon; 
            grad(j) = (func(paramsPlus) - func(params)) / epsilon; 
        end 
    end 

3. LTSpice is used to simulate the circuit with given parameters. The following links may be referred:

• Sample MATLAB code to simulate in LTSpice for an R-L circuit: https://www.mathworks.com/matlabcentral/fileexchange/75713-link-matlab-to-ltspice
• Generate a netlist, simulate in LTSpice: https://www.mathworks.com/matlabcentral/fileexchange/75713-link-matlab-to-ltspice

4. The parameters are initialized, and the ‘Gradient Descent’ function is run to optimize the parameters:

initialParams = [1, 1e-3, 1e-9]; % Example initial values for R, L, C 
learningRate = 0.01; 
numIterations = 100; 

optimizedParams = gradientDescent(initialParams, learningRate, numIterations); 

[Syed Abid Sahdman]

@Zinea Could you please tell me how the cost function would look like if I want to reach a certain output voltage by optimizing the value of parameters? If you have any example of an RLC circuit that would be very helpful. Thanks.