Hide navigation sidebar
Hide table of contents sidebar
Back to top
Toggle table of contents sidebar

# Tune Examples

This section includes source code for all of the Gurobi tune examples. The same source code can be found in the `examples` directory of the Gurobi distribution.

    /* Copyright 2025, Gurobi Optimization, LLC */

    /* This example reads a model from a file and tunes it.
       It then writes the best parameter settings to a file
       and solves the model using these parameters. */

    #include <assert.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <math.h>
    #include "gurobi_c.h"

    int
    main(int   argc,
         char *argv[])
    {
      GRBenv   *env      = NULL;
      GRBenv   *modelenv = NULL;
      GRBmodel *model    = NULL;

      int tuneresultcount;
      int error = 0;

      if (argc < 2) {
        fprintf(stderr, "Usage: tune_c filename\n");
        exit(1);
      }

      /* Create environment */

      error = GRBloadenv(&env, "tune_c.log");
      if (error) goto QUIT;

      /* Read model from file */

      error = GRBreadmodel(env, argv[1], &model);
      if (error) goto QUIT;

      /* Retrieve model env to set some parameters */

      modelenv = GRBgetenv(model);
      assert(modelenv != NULL);

      /* Set a time limit for the model */

      error = GRBsetdblparam(modelenv, GRB_DBL_PAR_TIMELIMIT, 5);
      if (error) goto QUIT;

      /* Set a time limit for the whole tuning run
       * Note that both time limits are chosen to have a quick demonstration.
       * In general, a total tune time limit should be set such that the
       * tuning tool can test several hundreds of parameter settings.
       */

      error = GRBsetdblparam(modelenv, GRB_DBL_PAR_TUNETIMELIMIT, 60);
      if (error) goto QUIT;

      /* Set the TuneResults parameter to 2
       *
       * The first parameter setting is the result for the first solved
       * setting. The second entry the parameter setting of the best parameter
       * setting.
       */
      error = GRBsetintparam(modelenv, GRB_INT_PAR_TUNERESULTS, 2);
      if (error) goto QUIT;

      /* Tune the model */

      error = GRBtunemodel(model);
      if (error) goto QUIT;

      /* Get the number of tuning results */

      error = GRBgetintattr(model, GRB_INT_ATTR_TUNE_RESULTCOUNT, &tuneresultcount);
      if (error) goto QUIT;

      if (tuneresultcount >= 2) {

        /* Load the best tuned parameters into the model's environment
         *
         * Note, the first parameter setting is associated to the first solved
         * setting and the second parameter setting to best tune result.
         */
        error = GRBgettuneresult(model, 1);
        if (error) goto QUIT;

        /* Write tuned parameters to a file */

        error = GRBwrite(model, "tune.prm");
        if (error) goto QUIT;

        /* Solve the model using the tuned parameters */

        error = GRBoptimize(model);
        if (error) goto QUIT;
      }

    QUIT:

      /* Error reporting */

      if (error) {
        printf("ERROR: %s\n", GRBgeterrormsg(env));
        exit(1);
      }

      /* Free model */

      GRBfreemodel(model);

      /* Free environment */

      GRBfreeenv(env);

      return 0;
    }

    /* Copyright 2025, Gurobi Optimization, LLC */

    /* This example reads a model from a file and tunes it.
       It then writes the best parameter settings to a file
       and solves the model using these parameters. */

    #include "gurobi_c++.h"
    #include <cmath>
    using namespace std;

    int
    main(int   argc,
         char *argv[])
    {
      if (argc < 2) {
        cout << "Usage: tune_c++ filename" << endl;
        return 1;
      }

      GRBEnv *env = 0;
      try {
        env = new GRBEnv();

        // Read model from file

        GRBModel model = GRBModel(*env, argv[1]);

        // Set a time limit for the model

        model.set(GRB_DoubleParam_TimeLimit, 5);

        // Set a time limit for the whole tuning run
        // Note that both time limits are chosen to have a quick demonstration.
        // In general, a total tune time limit should be set such that the
        // tuning tool can test several hundreds of parameter setting

        model.set(GRB_DoubleParam_TuneTimeLimit, 60);

        // Set the TuneResults parameter to 2
        //
        // The first parameter setting is the result for the first solved
        // setting. The second entry the parameter setting of the best
        // parameter setting.

        model.set(GRB_IntParam_TuneResults, 2);

        // Tune the model

        model.tune();

        // Get the number of tuning results

        int resultcount = model.get(GRB_IntAttr_TuneResultCount);

        if (resultcount >= 2) {

          // Load the tuned parameters into the model's environment
          //
          // Note, the first parameter setting is associated to the first solved
          // setting and the second parameter setting to best tune result.

          model.getTuneResult(1);

          // Write tuned parameters to a file

          model.write("tune.prm");

          // Solve the model using the tuned parameters

          model.optimize();
        }
      } catch(GRBException e) {
        cout << "Error code = " << e.getErrorCode() << endl;
        cout << e.getMessage() << endl;
      } catch (...) {
        cout << "Error during tuning" << endl;
      }

      delete env;
      return 0;
    }

    /* Copyright 2025, Gurobi Optimization, LLC */

    /* This example reads a model from a file and tunes it.
       It then writes the best parameter settings to a file
       and solves the model using these parameters. */

    using System;
    using Gurobi;

    class tune_cs
    {
      static void Main(string[] args)
      {
        if (args.Length < 1) {
          Console.Out.WriteLine("Usage: tune_cs filename");
          return;
        }

        try {
          GRBEnv env = new GRBEnv();

          // Read model from file
          GRBModel model = new GRBModel(env, args[0]);

          // Set a time limit for the model
          model.Parameters.TimeLimit = 5;

          // Set a time limit for the whol tuning run
          // Note that both time limits are chosen to have a quick demonstration.
          // In general, a total tune time limit should be set such that the
          // tuning tool can test several hundreds of parameter setting
          model.Parameters.TuneTimeLimit = 60;

          // Set the TuneResults parameter to 2
          //
          // The first parameter setting is the result for the first solved
          // setting. The second entry the parameter setting of the best
          // parameter setting.
          model.Parameters.TuneResults = 2;

          // Tune the model
          model.Tune();

          // Get the number of tuning results
          int resultcount = model.TuneResultCount;

          if (resultcount >= 2) {

            // Load the tuned parameters into the model's environment
            //
            // Note, the first parameter setting is associated to the first
            // solved setting and the second parameter setting to best tune
            // result.
            model.GetTuneResult(1);

            // Write the tuned parameters to a file
            model.Write("tune.prm");

            // Solve the model using the tuned parameters
            model.Optimize();
          }

          // Dispose of model and environment
          model.Dispose();
          env.Dispose();

        } catch (GRBException e) {
          Console.WriteLine("Error code: " + e.ErrorCode + ". " + e.Message);
        }
      }
    }

    /* Copyright 2025, Gurobi Optimization, LLC */

    /* This example reads a model from a file and tunes it.
       It then writes the best parameter settings to a file
       and solves the model using these parameters. */

    import com.gurobi.gurobi.*;

    public class Tune {
      public static void main(String[] args) {

        if (args.length < 1) {
          System.out.println("Usage: java Tune filename");
          System.exit(1);
        }

        try {
          GRBEnv env = new GRBEnv();

          // Read model from file
          GRBModel model = new GRBModel(env, args[0]);

          // Set a time limit for the model
          model.set(GRB.DoubleParam.TimeLimit, 5);

          // Set a time limit for the whole tuning run
          // Note that both time limits are chosen to have a quick demonstration.
          // In general, a total tune time limit should be set such that the
          // tuning tool can test several hundreds of parameter setting
          model.set(GRB.DoubleParam.TuneTimeLimit, 60);

          // Set the TuneResults parameter to 2
          //
          // The first parameter setting is the result for the first solved
          // setting. The second entry the parameter setting of the best
          // parameter setting.
          model.set(GRB.IntParam.TuneResults, 2);

          // Tune the model
          model.tune();

          // Get the number of tuning results
          int resultcount = model.get(GRB.IntAttr.TuneResultCount);

          if (resultcount >= 2) {

            // Load the tuned parameters into the model's environment
            //
            // Note, the first parameter setting is associated to the first
            // solved setting and the second parameter setting to best tune
            // result.
            model.getTuneResult(1);

            // Write the tuned parameters to a file
            model.write("tune.prm");

            // Solve the model using the tuned parameters
            model.optimize();
          }

          // Dispose of model and environment
          model.dispose();
          env.dispose();

        } catch (GRBException e) {
          System.out.println("Error code: " + e.getErrorCode() + ". "
              + e.getMessage());
        }
      }
    }

    #!/usr/bin/env python3

    # Copyright 2025, Gurobi Optimization, LLC

    #  This example reads a model from a file and tunes it.
    #  It then writes the best parameter settings to a file
    #  and solves the model using these parameters.

    import sys
    import gurobipy as gp

    if len(sys.argv) < 2:
        print("Usage: tune.py filename")
        sys.exit(0)

    # Read the model
    model = gp.read(sys.argv[1])

    # Set a time limit for the model
    model.Params.TimeLimit = 5

    # Set a time limit for the whole tuning run
    # Note that both time limits are chosen to have a quick demonstration.
    # In general, a total tune time limit should be set such that the
    # tuning tool can test several hundreds of parameter setting
    model.Params.TuneTimeLimit = 60

    # Set the TuneResults parameter to 2
    #
    # The first parameter setting is the result for the first solved
    # setting. The second entry the parameter setting of the best parameter
    # setting.
    model.Params.TuneResults = 2

    # Tune the model
    model.tune()

    if model.TuneResultCount >= 2:
        # Load the best tuned parameters into the model
        #
        # Note, the first parameter setting is associated to the first solved
        # setting and the second parameter setting to best tune result.
        model.getTuneResult(1)

        # Write tuned parameters to a file
        model.write("tune.prm")

        # Solve the model using the tuned parameters
        model.optimize()

    ' Copyright 2025, Gurobi Optimization, LLC */
    '
    ' This example reads a model from a file and tunes it.
    ' It then writes the best parameter settings to a file
    ' and solves the model using these parameters.

    Imports System
    Imports Gurobi

    Class tune_vb
        Shared Sub Main(ByVal args As String())

            If args.Length < 1 Then
                Console.Out.WriteLine("Usage: tune_vb filename")
                Return
            End If

            Try
                Dim env As New GRBEnv()

                ' Read model from file
                Dim model As New GRBModel(env, args(0))

                ' Set a time limit for the model
                model.Parameters.TimeLimit = 5

                ' Set a time limit for the whole tuning run
                ' Note that both time limits are chosen to have a quick demonstration.
                ' In general, a total tune time limit should be set such that the
                ' tuning tool can test several hundreds of parameter setting
                model.Parameters.TuneTimeLimit = 60

                ' Set the TuneResults parameter to 2
                '
                ' The first parameter setting is the result for the first solved
                ' setting. The second entry the parameter setting of the best
                ' parameter setting.
                model.Parameters.TuneResults = 2

                ' Tune the model
                model.Tune()

                ' Get the number of tuning results
                Dim resultcount As Integer = model.TuneResultCount

                If resultcount >= 2 Then

                    ' Load the tuned parameters into the model's environment
                    '
                    ' Note, the first parameter setting is associated to the first
                    ' solved setting and the second parameter setting to best tune
                    ' result.
                    model.GetTuneResult(1)

                    ' Write the tuned parameters to a file
                    model.Write("tune.prm")

                    ' Solve the model using the tuned parameters
                    model.Optimize()
                End If

                ' Dispose of model and environment
                model.Dispose()
                env.Dispose()

            Catch e As GRBException
                Console.WriteLine("Error code: " & e.ErrorCode & ". " & e.Message)
            End Try
        End Sub
    End Class

Help and Feedback

Press `/` or click to search this documentation | Gurobi website | Gurobi community forum
Go to other Gurobi documentation | Gurobi download | Contact support