├── .gitignore
├── README.md
├── cifar
    ├── pipeline.py
    ├── train.py
    └── vit.py
├── gpt4_prompt2
    ├── losses.pkl
    ├── messages.pkl
    └── trajectories.pkl
├── llm_hpo.py
├── load_toy_trajectories.ipynb
├── run_toy_fns.ipynb
└── utils
    └── toy_utils.py


/.gitignore:
--------------------------------------------------------------------------------
1 | # pycache
2 | __pycache__/
3 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | 
 2 | # Large Language Models for Hyperparameter Optimization
 3 | 
 4 | Michael R. Zhang, Nishkrit Desai, Juhan Bae, Jonathan Lorraine, Jimmy Ba
 5 | 
 6 | We explore the use of large language models (LLMs) in hyperparameter optimization (HPO). By prompting LLMs with dataset and model descriptions, we develop a methodology where LLMs suggest hyperparameter configurations, which are iteratively refined based on model performance. Our empirical evaluations on standard benchmarks reveal that LLMs, within constrained search budgets, can match or outperform traditional HPO methods like Bayesian optimization across different models on standard benchmarks. 
 7 | 
 8 | [Arxiv paper](https://arxiv.org/abs/2312.04528)
 9 | 
10 | 
11 | ## Reproducing experiments on CIFAR
12 | 
13 | `cifar/train.py` implements our method on CIFAR-10 and can be used to reproduce the results in our paper. The provide code demonstrates how to conduct our experiments with Vision Transformers and a small ResNet. The same prompt is used for both models in our experiments to make the tuning task more difficult.
14 | 
15 | ### Setup
16 | Set up your OpenAI API credentials. You can also modify `LLMHyperparameterTuner` to call a different LLM.
17 | 
18 | ```
19 | # Set up OpenAI API credentials: https://platform.openai.com/api-keys
20 | export OPENAI_API_KEY=(YOUR OPENAI API KEY)
21 | ```
22 | 
23 | Install packages.
24 | ```
25 | pip install -r requirements.txt
26 | ```
27 | 
28 | ### Usage
29 | 
30 | Run the script with desired arguments:
31 | ```
32 | python train.py [-h] [--random_hparams | --llm] [--rounds ROUNDS] [--search_space SEARCH_SPACE]
33 |                 [--dataset_dir DATASET_DIR] [--arch ARCH] [--save_dir SAVE_DIR]
34 |                 [--train_batch_size TRAIN_BATCH_SIZE] [--eval_batch_size EVAL_BATCH_SIZE]
35 |                 [--learning_rate LEARNING_RATE] [--weight_decay WEIGHT_DECAY] [--label_smoothing LABEL_SMOOTHING]
36 |                 [--optimizer OPTIMIZER] [--num_train_epochs NUM_TRAIN_EPOCHS] [--seed SEED]
37 | ```
38 | 
39 | To run the LLM-based hyperparameter search with a single seed:
40 | ```
41 | python train.py --llm --seed SEED
42 | ```
43 | By default, this tunes the optimizer, learning rate, batch size, weight decay, and label smoothing. GPT-4 generated some ranges which we found reasonable. To reproduce our results, run the command with five different random seeds.
44 | 
45 | To run random hyperparameter search:
46 | ```
47 | python train.py --random_hparams --seed SEED
48 | ```
49 | 
50 | This samples randomly from the same default configuration space. To reproduce our results, run the command with 100 different random seeds and then bootstrap to estimate the best error so far.
51 | 
52 | If neither --llm nor --random_hparams is specified, a training run is performed with hyperparameters specified by the other arguments.
53 | 
54 | ### Trying different architectures
55 | 
56 | To try different architectures, modify the --arch argument when running the script. The currently supported architectures are:
57 | 
58 | resnet9: A small ResNet architecture with 9 layers
59 | 
60 | vit: A Vision Transformer (ViT) architecture
61 | 
62 | Example usage:
63 | ```
64 | python train.py --arch resnet9
65 | python train.py --arch vit
66 | ```
67 | 
68 | ### Results 
69 | 
70 | The results of the hyperparameter search will be saved in the specified save_dir as JSON files. The files will contain the hyperparameters and corresponding evaluation metrics (loss and accuracy) for each trial.
71 | 
72 | ### Adapting to other Datasets and Architectures
73 | To provide more specific details on the dataset and architecture to potentially improve tuning performance, you can modify the initial_prompt in the main function of train.py.
74 | 
75 | For example, you can add information about the CIFAR-10 dataset, such as the number of classes, image dimensions, and any data augmentation techniques used. Additionally, you can provide more details about the chosen architecture, such as the number of layers, hidden dimensions, or attention heads for the ViT.
76 | 
77 | By providing more context about the dataset and architecture in the prompt, the LLM may be able to generate more informed hyperparameter suggestions.
78 | 
79 | ## Toy experiments
80 | 
81 | You can find code we use to run 2D experiments in `run_toy_fns.ipynb`. 
82 | 
83 | ## Cite 
84 | If you find our work useful, please cite as:
85 | ```
86 | @article{zhang2023using,
87 |   title={Using Large Language Models for Hyperparameter Optimization},
88 |   author={Zhang, Michael R and Desai, Nishkrit and Bae, Juhan and Lorraine, Jonathan and Ba, Jimmy},
89 |   journal={arXiv preprint arXiv:2312.04528},
90 |   year={2023}
91 | }
92 | ```


--------------------------------------------------------------------------------
/cifar/pipeline.py:
--------------------------------------------------------------------------------
  1 | 
  2 | import copy
  3 | import math
  4 | from typing import List, Optional
  5 | 
  6 | import datasets
  7 | import numpy as np
  8 | import torch
  9 | import torchvision
 10 | from torch import nn
 11 | 
 12 | 
 13 | class Mul(nn.Module):
 14 |     def __init__(self, weight: float) -> None:
 15 |         super().__init__()
 16 |         self.weight = weight
 17 | 
 18 |     def forward(self, x: torch.Tensor) -> torch.Tensor:
 19 |         return x * self.weight
 20 | 
 21 | 
 22 | class Flatten(nn.Module):
 23 |     def forward(self, x: torch.Tensor) -> torch.Tensor:
 24 |         return x.view(x.size(0), -1)
 25 | 
 26 | 
 27 | class Residual(nn.Module):
 28 |     def __init__(self, module: nn.Module) -> None:
 29 |         super().__init__()
 30 |         self.module = module
 31 | 
 32 |     def forward(self, x: torch.Tensor) -> torch.Tensor:
 33 |         return x + self.module(x)
 34 | 
 35 | 
 36 | def construct_resnet9() -> nn.Module:
 37 |     # ResNet-9 architecture from https://github.com/MadryLab/trak/blob/main/examples/cifar_quickstart.ipynb.
 38 |     def conv_bn(
 39 |         channels_in: int,
 40 |         channels_out: int,
 41 |         kernel_size: int = 3,
 42 |         stride: int = 1,
 43 |         padding: int = 1,
 44 |         groups: int = 1,
 45 |     ) -> nn.Module:
 46 |         return torch.nn.Sequential(
 47 |             torch.nn.Conv2d(
 48 |                 channels_in,
 49 |                 channels_out,
 50 |                 kernel_size=kernel_size,
 51 |                 stride=stride,
 52 |                 padding=padding,
 53 |                 groups=groups,
 54 |                 bias=False,
 55 |             ),
 56 |             torch.nn.BatchNorm2d(channels_out),
 57 |             torch.nn.ReLU(),
 58 |         )
 59 | 
 60 |     model = torch.nn.Sequential(
 61 |         conv_bn(3, 64, kernel_size=3, stride=1, padding=1),
 62 |         conv_bn(64, 128, kernel_size=5, stride=2, padding=2),
 63 |         Residual(torch.nn.Sequential(conv_bn(128, 128), conv_bn(128, 128))),
 64 |         conv_bn(128, 256, kernel_size=3, stride=1, padding=1),
 65 |         torch.nn.MaxPool2d(2),
 66 |         Residual(torch.nn.Sequential(conv_bn(256, 256), conv_bn(256, 256))),
 67 |         conv_bn(256, 128, kernel_size=3, stride=1, padding=0),
 68 |         torch.nn.AdaptiveMaxPool2d((1, 1)),
 69 |         Flatten(),
 70 |         torch.nn.Linear(128, 10, bias=False),
 71 |         Mul(0.2),
 72 |     )
 73 |     return model
 74 | 
 75 | 
 76 | def get_cifar10_dataset(
 77 |     split: str,
 78 |     indices: List[int] = None,
 79 |     corrupt_percentage: Optional[float] = None,
 80 |     dataset_dir: str = "data/",
 81 | ) -> datasets.Dataset:
 82 |     assert split in ["train", "eval_train", "valid"]
 83 | 
 84 |     normalize = torchvision.transforms.Normalize(mean=(0.4914, 0.4822, 0.4465), std=(0.247, 0.243, 0.261))
 85 |     if split == "train":
 86 |         transform_config = torchvision.transforms.Compose(
 87 |             [
 88 |                 torchvision.transforms.RandomCrop(32, padding=4),
 89 |                 torchvision.transforms.RandomHorizontalFlip(),
 90 |                 torchvision.transforms.ToTensor(),
 91 |                 normalize,
 92 |             ]
 93 |         )
 94 |     else:
 95 |         transform_config = torchvision.transforms.Compose(
 96 |             [
 97 |                 torchvision.transforms.ToTensor(),
 98 |                 normalize,
 99 |             ]
100 |         )
101 | 
102 |     dataset = torchvision.datasets.CIFAR10(
103 |         root=dataset_dir,
104 |         download=True,
105 |         train=split in ["train", "eval_train"],
106 |         transform=transform_config,
107 |     )
108 | 
109 |     if corrupt_percentage is not None:
110 |         if split == "valid":
111 |             raise NotImplementedError("Performing corruption on the validation dataset is not supported.")
112 |         assert 0.0 < corrupt_percentage <= 1.0
113 |         num_corrupt = math.ceil(len(dataset) * corrupt_percentage)
114 |         original_targets = np.array(copy.deepcopy(dataset.targets[:num_corrupt]))
115 |         new_targets = torch.randint(
116 |             0,
117 |             10,
118 |             size=original_targets[:num_corrupt].shape,
119 |             generator=torch.Generator().manual_seed(0),
120 |         ).numpy()
121 |         offsets = torch.randint(
122 |             1,
123 |             9,
124 |             size=new_targets[new_targets == original_targets].shape,
125 |             generator=torch.Generator().manual_seed(0),
126 |         ).numpy()
127 |         new_targets[new_targets == original_targets] = (new_targets[new_targets == original_targets] + offsets) % 10
128 |         assert (new_targets == original_targets).sum() == 0
129 |         dataset.targets[:num_corrupt] = list(new_targets)
130 | 
131 |     if indices is not None:
132 |         dataset = torch.utils.data.Subset(dataset, indices)
133 |         
134 | 
135 |     return dataset


--------------------------------------------------------------------------------
/cifar/train.py:
--------------------------------------------------------------------------------
  1 | import argparse
  2 | import logging
  3 | import os
  4 | import time
  5 | from typing import Tuple
  6 | 
  7 | import numpy as np
  8 | import torch
  9 | import torch.nn.functional as F
 10 | from torch import nn
 11 | from torch.optim import lr_scheduler
 12 | from torch.utils import data
 13 | import json
 14 | from openai import OpenAI
 15 | 
 16 | from cifar.pipeline import construct_resnet9, get_cifar10_dataset
 17 | from cifar.vit import ViT
 18 | 
 19 | DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 20 | 
 21 | class LLMHyperparameterTuner:
 22 |     """A class for tuning hyperparameters using a large language model (LLM).
 23 |     
 24 |     This implementation uses the OpenAI API to interact with the LLM and uses 
 25 |     the compressed format prompting approach from "Using Large Language Models
 26 |     for Hyperparameter Optimization".
 27 |     """
 28 |     def __init__(
 29 |         self,
 30 |         initial_prompt: str,
 31 |         model: str = 'gpt-4-1106-preview',
 32 |         temperature: float = 0.0,
 33 |         max_tokens: int = 1000,
 34 |         frequency_penalty: float = 0.0,
 35 |         seed: int = 0,
 36 |         round_digits: int = 4,
 37 |     ):
 38 |         """Initialize the LLM hyperparameter tuner.
 39 |         
 40 |         Args:
 41 |             initial_prompt: The initial prompt to use, describing the hyperparameter search space and the
 42 |             model: The LLM model to use for tuning hyperparameters.
 43 |             temperature: The temperature parameter for sampling from the LLM.
 44 |             max_tokens: The maximum number of tokens to generate in each response.
 45 |             frequency_penalty: The frequency penalty parameter for sampling from the LLM.
 46 |             seed: The seed to use for sampling from the LLM.
 47 |             round_digits: The number of digits to round float values to.
 48 |         """
 49 |         self.initial_prompt = initial_prompt
 50 |         self.model = model
 51 |         self.temperature = temperature
 52 |         self.max_tokens = max_tokens
 53 |         self.frequency_penalty = frequency_penalty
 54 |         self.seed = seed
 55 |         self.round_digits = round_digits
 56 |         self.configs = []  # Store history of configurations and their outcomes
 57 |         self.reset_messages()
 58 |         
 59 |     def reset_messages(self):
 60 |         """Reset the messages to the initial system message."""
 61 |         self.messages = [{"role": "system", "content": "You are a machine learning expert."}]
 62 | 
 63 |     def add_message(self, role, content):
 64 |         """Add a message to the conversation log."""
 65 |         self.messages.append({"role": role, "content": content})
 66 | 
 67 |     def generate_prompt(self, error=None):
 68 |         """Generate the prompt for the next interaction with the LLM."""
 69 |         if len(self.configs) > 0:
 70 |             prompt = self.initial_prompt + "\nThis is what has been done so far:\n"
 71 |         else:
 72 |             prompt = self.initial_prompt + "\n"
 73 |         for i, (config, error_rate, loss) in enumerate(self.configs):
 74 |             prompt += f"Config {i+1}: {config} Error Rate: {error_rate:.{self.round_digits}e}, Loss: {loss:.{self.round_digits}e}\n"
 75 |         if error:
 76 |             prompt += f"We got the following error message with the previous proposal: {error}\n"
 77 |         prompt += "Provide a config in the same JSON format."
 78 |         return prompt
 79 | 
 80 |     def parse_response(self, response):
 81 |         hyperparameters_text = response.choices[0].message.content.strip()
 82 |         try:
 83 |             hyperparameters = json.loads(hyperparameters_text)
 84 |             return hyperparameters
 85 |         except json.JSONDecodeError as e:
 86 |             raise ValueError(f"Failed to parse JSON response: {e}")
 87 | 
 88 |     def suggest_hyperparameters(self, max_retries=2, training_exception=None):
 89 |         for attempt in range(max_retries):
 90 |             self.reset_messages()
 91 |             prompt = self.generate_prompt(error=training_exception)
 92 |             self.add_message("user", prompt)  # Log the user prompt
 93 |             try:
 94 |                 client = OpenAI()
 95 |                 print('sending messages:', len(self.messages))
 96 |                 print(self.messages[-1]['content'])
 97 |                 response = client.chat.completions.create(
 98 |                     model=self.model,
 99 |                     messages=self.messages,
100 |                     temperature=self.temperature,
101 |                     max_tokens=self.max_tokens,
102 |                     frequency_penalty=self.frequency_penalty,
103 |                     seed=self.seed,
104 |                     response_format={"type": "json_object"},
105 |                 )
106 |                 hyperparameters = self.parse_response(response)
107 |                 self.add_message("assistant", response.choices[0].message.content)  # Log the parsed response
108 |                 return hyperparameters
109 |             except Exception as e:
110 |                 print(e)
111 |                 training_exception = str(e)
112 |                 if attempt < max_retries - 1:
113 |                     print(f"Attempt {attempt + 1} failed: {e}. Retrying...")
114 |                     time.sleep(30)
115 |                 else:
116 |                     raise Exception(f"Failed to call LLM after {max_retries} attempts: {e}")
117 |                 
118 |     def update_configs(self, config, validation_error, validation_loss):
119 |         self.configs.append((config, validation_error, validation_loss))
120 | 
121 | 
122 | def llm_hyperparameter_search(tuner, rounds=10):
123 |     """Perform hyperparameter search using the LLM tuner."""
124 |     results = []  
125 |     training_exception = None
126 |     for i in range(rounds):
127 |         try:
128 |             config = tuner.suggest_hyperparameters(training_exception=training_exception)
129 |             validation_loss, validation_error = train_and_evaluate(config) 
130 |             tuner.update_configs(config, validation_error, validation_loss)
131 |             # save and print results
132 |             results.append({
133 |                 "config": config,
134 |                 "accuracy": validation_error,
135 |                 "loss": validation_loss
136 |             
137 |             })
138 |             print(f"Round {i+1}: Validation Error = {validation_error}, Validation Loss = {validation_loss}")
139 |             print(f"Suggested Config: {config}")
140 |             training_exception = None
141 |         except Exception as e:
142 |             print(f"Error during training: {e}")
143 |             print("Continuing to the next round...")
144 |             # When an error occurs, append None for accuracy and loss
145 |             results.append({
146 |                 "config": config,
147 |                 "accuracy": None,
148 |                 "loss": None
149 |             })
150 |             training_exception = str(e)
151 |     return results
152 | 
153 | 
154 | def parse_args():
155 |     parser = argparse.ArgumentParser(description="Train ResNet-9 model on CIFAR-10 dataset.")
156 |     tuner_group = parser.add_mutually_exclusive_group()
157 |     # method (random, LLM) for tuning hyperparameters. If none specified, runs a single training run with what is given from argparse.
158 |     tuner_group.add_argument('--random_hparams', action='store_true', help='Randomly sample hyperparameters', default=False)
159 |     tuner_group.add_argument('--llm', action='store_true', help='Use LLM for hyperparameter search', default=False)
160 |     # llm tuning specific hyperparams
161 |     parser.add_argument('--rounds', type=int, default=10, help='Number of times we interact with the LLM to get hyperparameters')
162 |     parser.add_argument('--search_space', type=str, default='constrained', help='Search space for LLM tuning')
163 |     # general hparams
164 |     parser.add_argument("--dataset_dir", type=str, default="./data", help="A folder to download or load CIFAR-10 dataset.")
165 |     parser.add_argument("--arch", type=str, default="resnet9", help="Architecture to use for training.")
166 |     parser.add_argument("--save_dir", type=str, default="./out", help="A folder to save the results")
167 |     parser.add_argument("--train_batch_size", type=int, default=512, help="Batch size for the training dataloader.")
168 |     parser.add_argument("--eval_batch_size", type=int, default=1024, help="Batch size for the evaluation dataloader.")
169 |     parser.add_argument("--learning_rate", type=float, default=0.01, help="Initial learning rate to train the model.")
170 |     parser.add_argument("--weight_decay", type=float, default=0.0001, help="Weight decay to train the model.")
171 |     parser.add_argument("--label_smoothing", type=float, default=0, help="Label smoothing to train the model.")
172 |     parser.add_argument("--optimizer", type=str, default="SGD", help="Optimizer to use for training")
173 |     parser.add_argument("--num_train_epochs", type=int, default=20, help="Total number of epochs to train the model.")
174 |     parser.add_argument("--seed", type=int, default=1004, help="A seed for reproducible training pipeline.")
175 |     args = parser.parse_args()
176 |     return args
177 | 
178 | def train(
179 |     dataset: data.Dataset,
180 |     batch_size: int,
181 |     num_train_epochs: int,
182 |     learning_rate: float,
183 |     weight_decay: float,
184 |     label_smoothing: float,
185 |     optimizer: str = "SGD",
186 |     arch: str = "resnet9",
187 |     hyps: dict = None,
188 | ) -> nn.Module:
189 |     """Train a model on the given dataset with the specified hyperparameters."""
190 |     train_dataloader = data.DataLoader(
191 |         dataset=dataset,
192 |         batch_size=batch_size,
193 |         shuffle=True,
194 |         drop_last=True,
195 |     )
196 |     if arch == "resnet9": 
197 |         model = construct_resnet9()
198 |         print('Using ResNet-9 model')
199 |     elif arch == "vit":
200 |         # can optionally specify hyperparameters for the ViT model, otherwise defaults are used
201 |         if hyps is None or 'patch_size' not in hyps:
202 |             model = ViT(
203 |                 image_size = 32,
204 |                 patch_size = 4,
205 |                 num_classes = 10,
206 |                 dim = 512,
207 |                 depth = 6,
208 |                 heads = 8,
209 |                 mlp_dim = 512,
210 |                 dropout = 0.1,
211 |                 emb_dropout = 0.1
212 |             )
213 |         else:
214 |             model = ViT(
215 |                 image_size = 32,
216 |                 patch_size = hyps['patch_size'],
217 |                 num_classes = 10,
218 |                 dim = hyps['dim'],
219 |                 depth = hyps['depth'],
220 |                 heads = hyps['heads'],
221 |                 mlp_dim = hyps['mlp_dim'],
222 |                 dropout = hyps['dropout'],
223 |                 emb_dropout = hyps['emb_dropout'],
224 |             )
225 |         print('Using ViT model')
226 |     model = model.to(DEVICE)
227 |     if optimizer.lower() == "sgd":
228 |         optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, weight_decay=weight_decay)
229 |     elif optimizer.lower() == "adam":
230 |         optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=weight_decay)
231 |     else:
232 |         raise ValueError("Invalid optimizer")
233 | 
234 |     iters_per_epoch = len(train_dataloader)
235 |     lr_peak_epoch = num_train_epochs // 5
236 |     # Linearly increase learning rate to peak at lr_peak_epoch, then decrease to 0 
237 |     lr_schedule = np.interp(
238 |         np.arange((num_train_epochs + 1) * iters_per_epoch),
239 |         [0, lr_peak_epoch * iters_per_epoch, num_train_epochs * iters_per_epoch],
240 |         [0, 1, 0],
241 |     )
242 |     scheduler = lr_scheduler.LambdaLR(optimizer, lr_schedule.__getitem__)
243 | 
244 |     start_time = time.time()
245 |     model.train()
246 |     for epoch in range(num_train_epochs):
247 |         total_loss = 0.0
248 |         for batch in train_dataloader:
249 |             model.zero_grad()
250 |             inputs, labels = batch
251 |             inputs, labels = inputs.to(DEVICE), labels.to(DEVICE)
252 |             outputs = model(inputs)
253 |             loss = F.cross_entropy(outputs, labels, label_smoothing=label_smoothing)
254 |             loss.backward()
255 |             optimizer.step()
256 |             scheduler.step()
257 |             total_loss += loss.detach().float()
258 |         logging.info(f"Epoch {epoch + 1} - Averaged Loss: {total_loss / len(dataset)}")
259 |     end_time = time.time()
260 |     elapsed_time = end_time - start_time
261 |     logging.info(f"Completed training in {elapsed_time:.2f} seconds.")
262 |     return model
263 | 
264 | 
265 | def evaluate(model: nn.Module, dataset: data.Dataset, batch_size: int) -> Tuple[float, float]:
266 |     dataloader = data.DataLoader(
267 |         dataset=dataset,
268 |         batch_size=batch_size,
269 |         shuffle=False,
270 |         drop_last=False,
271 |     )
272 | 
273 |     model.eval()
274 |     total_loss, total_correct = 0.0, 0
275 |     for batch in dataloader:
276 |         with torch.no_grad():
277 |             inputs, labels = batch
278 |             inputs, labels = inputs.to(DEVICE), labels.to(DEVICE)
279 |             outputs = model(inputs)
280 |             loss = F.cross_entropy(outputs, labels, reduction="sum")
281 |             total_loss += loss.detach().float()
282 |             total_correct += outputs.detach().argmax(1).eq(labels).sum()
283 | 
284 |     return total_loss.item() / len(dataloader.dataset), total_correct.item() / len(dataloader.dataset)
285 | 
286 | def sample_hyperparameters(model, arch_params=False):
287 |     hyp = {}
288 |     # Sampling learning_rate and weight_decay in log space
289 |     learning_rate = 10**np.random.uniform(-4, -1)
290 |     weight_decay = 10**np.random.uniform(-5, -1)
291 |     
292 |     batch_sizes = [32, 64, 128, 256, 512]
293 |     batch_size = np.random.choice(batch_sizes)
294 |     batch_size = int(batch_size)
295 |     
296 |     # Sampling label smoothing linearly
297 |     label_smoothing = np.random.uniform(0, 0.2)
298 |     optimizer = np.random.choice(['SGD', 'Adam'])
299 |     hyp.update({
300 |         "learning_rate": learning_rate,
301 |         "weight_decay": weight_decay,
302 |         "train_batch_size": batch_size,
303 |         "label_smoothing": label_smoothing,
304 |         "optimizer": optimizer
305 |     })
306 |     if model == 'vit' and arch_params:
307 |         hyp['patch_size'] = np.random.choice([2, 4, 8])
308 |         hyp['dim'] = np.random.choice([128, 256, 512])
309 |         hyp['depth'] = np.random.choice([4, 6, 8, 12])
310 |         hyp['heads'] = np.random.choice([4, 8, 16])
311 |         hyp['mlp_dim'] = np.random.choice([256, 512, 1024])
312 |         hyp['dropout'] = np.random.uniform(0, 0.5)
313 |         hyp['emb_dropout'] = np.random.uniform(0, 0.5)
314 |     return hyp 
315 | 
316 | def save_results(hyperparams, results, trial_number, filename):
317 |     """Save hyperparameters and results to a JSON file."""
318 |     if not os.path.exists(filename):
319 |         os.makedirs(os.path.dirname(filename), exist_ok=True)
320 |     data = {'hyperparameters': hyperparams, 'results': results}
321 |     with open(filename, 'w') as f:
322 |         json.dump(data, f, indent=4)
323 | 
324 | def main(args):
325 |     # performs training and evaluation with given hyperparameters
326 |     if args.seed is not None:
327 |         torch.manual_seed(args.seed)
328 |         np.random.seed(args.seed)
329 |     
330 |     save_filename = os.path.join(args.save_dir, f"results_trial_{args.seed}.json")
331 |     print("Checking if results already saved in ", save_filename)
332 |     if args.random_hparams:
333 |         print('Randomly sampling hyperparameters')
334 |         # check if results already saved
335 |         if os.path.exists(save_filename):
336 |             print('results already saved')
337 |             return
338 |         # randomly sample hyperparameters
339 |         hyps = sample_hyperparameters(args.arch)
340 |     else:
341 |         lr = args.learning_rate
342 |         wd = args.weight_decay
343 |         bs = args.train_batch_size
344 |         ls = args.label_smoothing
345 |         optimizer = args.optimizer
346 |         hyps = {
347 |             "learning_rate": lr,
348 |             "weight_decay": wd,
349 |             "train_batch_size": bs,
350 |             "label_smoothing": ls,
351 |             "optimizer": optimizer
352 |         }
353 |     print("Hyperparameters:")
354 |     for k, v in hyps.items():
355 |         print(f"{k}: {v}")
356 |     logging.basicConfig(level=logging.INFO)
357 |     logger = logging.getLogger()
358 | 
359 |     train_dataset = get_cifar10_dataset(
360 |         split="train", dataset_dir=args.dataset_dir,
361 |     )
362 |     model = train(
363 |         dataset=train_dataset,
364 |         batch_size=hyps['train_batch_size'],
365 |         num_train_epochs=args.num_train_epochs,
366 |         learning_rate=hyps['learning_rate'],
367 |         weight_decay=hyps['weight_decay'],
368 |         label_smoothing=hyps['label_smoothing'],
369 |         optimizer=hyps['optimizer'],
370 |         arch=args.arch,
371 |         hyps=hyps,
372 |     )
373 | 
374 |     eval_train_dataset = get_cifar10_dataset(split="eval_train", dataset_dir=args.dataset_dir)
375 |     train_loss, train_acc = evaluate(model=model, dataset=eval_train_dataset, batch_size=args.eval_batch_size)
376 |     logger.info(f"Train loss: {train_loss}, Train Accuracy: {train_acc}")
377 | 
378 |     eval_dataset = get_cifar10_dataset(split="valid", dataset_dir=args.dataset_dir)
379 |     eval_loss, eval_acc = evaluate(model=model, dataset=eval_dataset, batch_size=args.eval_batch_size)
380 |     logger.info(f"Evaluation loss: {eval_loss}, Evaluation Accuracy: {eval_acc}")
381 |     
382 |     if args.random_hparams:
383 |         # save hyperparameters and results
384 |         save_results(hyps, {'train_loss': train_loss, 'train_acc': train_acc, 'eval_loss': eval_loss, 'eval_acc': eval_acc}, args.seed, save_filename)
385 | 
386 |     return train_loss, train_acc, eval_loss, eval_acc
387 | 
388 | def train_and_evaluate(hyperparameters):
389 |     args = parse_args()
390 |     args.learning_rate = hyperparameters["learning_rate"]
391 |     args.weight_decay = hyperparameters["weight_decay"]
392 |     args.train_batch_size = hyperparameters["train_batch_size"]
393 |     args.label_smoothing = hyperparameters["label_smoothing"]
394 |     args.optimizer = hyperparameters["optimizer"]
395 |     train_loss, train_acc, eval_loss, eval_acc = main(args)
396 |     eval_error = 1 - eval_acc
397 |     return eval_loss, eval_error
398 | 
399 | prompt_end = """You will get the validation error rate and loss before you need to specify the next configuration. The goal is to find the configuration that minimizes the error rate with the given budget, so you should explore different parts of the search space if the loss is not changing. Provide a config in JSON format. Do not put new lines or any extra characters in the response, only provide the config. Example config:
400 | {
401 |     "optimizer": a
402 |     "learning_rate": b
403 |     "training batch size": c
404 |     "weight_decay": d
405 |     "label_smoothing": e
406 | }
407 | """
408 | 
409 | initial_prompt = """You are helping tune hyperparameters for a neural network. This is our hyperparameter search space:
410 | {
411 |     "optimizer": must be ["adam", "sgd"]
412 |     "learning_rate":  positive float
413 |     "train_batch_size": positive integer
414 |     "weight_decay": nonnegative float
415 |     "label_smoothing": nonnegative float
416 | }""" + prompt_end
417 | 
418 | # same constraints as random search    
419 | initial_prompt_constrained = """You are helping tune hyperparameters for a neural network. This is our hyperparameter search space:
420 | {
421 |     "optimizer": must be ["adam", "sgd"]
422 |     "learning_rate":  between 1e-4 and 1e-1
423 |     "train_batch_size": 32, 64, 128, 256, 512
424 |     "weight_decay": between 1e-5 and 1e-1
425 |     "label_smoothing": between 0 and 0.2
426 | }""" + prompt_end
427 | 
428 | 
429 | if __name__ == "__main__":
430 |     args = parse_args()
431 |     np.random.seed(args.seed)
432 |     torch.manual_seed(args.seed)
433 |     
434 |     # performs hyperparam search with GPT-4, check if already run
435 |     if args.llm:
436 |         if not os.path.exists(args.save_dir):
437 |             os.makedirs(args.save_dir)
438 |         save_filename = os.path.join(args.save_dir, f"llmtuner_trial_{args.seed}.json")
439 |         if os.path.exists(save_filename):
440 |             print('results already saved')
441 |         else:
442 |             if args.search_space == 'constrained':
443 |                 tuner = LLMHyperparameterTuner(initial_prompt_constrained)
444 |             elif args.search_space == 'unconstrained':
445 |                 tuner = LLMHyperparameterTuner(initial_prompt)
446 |             results = llm_hyperparameter_search(tuner, rounds=args.rounds)
447 |             results_dict = {
448 |                 "results": results,
449 |                 "search_space": args.search_space,
450 |                 "rounds": args.rounds
451 |             }
452 |             with open(save_filename, 'w') as f:
453 |                 json.dump(results_dict, f, indent=4)  
454 |     # performs a single training run with given hyperparameters
455 |     else:
456 |         main(args)
457 |         


--------------------------------------------------------------------------------
/cifar/vit.py:
--------------------------------------------------------------------------------
  1 | 
  2 | # https://github.com/lucidrains/vit-pytorch/blob/main/vit_pytorch/vit.py
  3 | 
  4 | import torch
  5 | from torch import nn
  6 | 
  7 | from einops import rearrange, repeat
  8 | from einops.layers.torch import Rearrange
  9 | 
 10 | # helpers
 11 | 
 12 | def pair(t):
 13 |     return t if isinstance(t, tuple) else (t, t)
 14 | 
 15 | # classes
 16 | 
 17 | class PreNorm(nn.Module):
 18 |     def __init__(self, dim, fn):
 19 |         super().__init__()
 20 |         self.norm = nn.LayerNorm(dim)
 21 |         self.fn = fn
 22 |     def forward(self, x, **kwargs):
 23 |         return self.fn(self.norm(x), **kwargs)
 24 | 
 25 | class FeedForward(nn.Module):
 26 |     def __init__(self, dim, hidden_dim, dropout = 0.):
 27 |         super().__init__()
 28 |         self.net = nn.Sequential(
 29 |             nn.Linear(dim, hidden_dim),
 30 |             nn.GELU(),
 31 |             nn.Dropout(dropout),
 32 |             nn.Linear(hidden_dim, dim),
 33 |             nn.Dropout(dropout)
 34 |         )
 35 |     def forward(self, x):
 36 |         return self.net(x)
 37 | 
 38 | class Attention(nn.Module):
 39 |     def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0.):
 40 |         super().__init__()
 41 |         inner_dim = dim_head *  heads
 42 |         project_out = not (heads == 1 and dim_head == dim)
 43 | 
 44 |         self.heads = heads
 45 |         self.scale = dim_head ** -0.5
 46 | 
 47 |         self.attend = nn.Softmax(dim = -1)
 48 |         self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
 49 | 
 50 |         self.to_out = nn.Sequential(
 51 |             nn.Linear(inner_dim, dim),
 52 |             nn.Dropout(dropout)
 53 |         ) if project_out else nn.Identity()
 54 | 
 55 |     def forward(self, x):
 56 |         qkv = self.to_qkv(x).chunk(3, dim = -1)
 57 |         q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
 58 | 
 59 |         dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
 60 | 
 61 |         attn = self.attend(dots)
 62 | 
 63 |         out = torch.matmul(attn, v)
 64 |         out = rearrange(out, 'b h n d -> b n (h d)')
 65 |         return self.to_out(out)
 66 | 
 67 | class Transformer(nn.Module):
 68 |     def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0.):
 69 |         super().__init__()
 70 |         self.layers = nn.ModuleList([])
 71 |         for _ in range(depth):
 72 |             self.layers.append(nn.ModuleList([
 73 |                 PreNorm(dim, Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout)),
 74 |                 PreNorm(dim, FeedForward(dim, mlp_dim, dropout = dropout))
 75 |             ]))
 76 |     def forward(self, x):
 77 |         for attn, ff in self.layers:
 78 |             x = attn(x) + x
 79 |             x = ff(x) + x
 80 |         return x
 81 | 
 82 | class ViT(nn.Module):
 83 |     def __init__(self, *, image_size, patch_size, num_classes, dim, depth, heads, mlp_dim, pool = 'cls', channels = 3, dim_head = 64, dropout = 0., emb_dropout = 0.):
 84 |         super().__init__()
 85 |         image_height, image_width = pair(image_size)
 86 |         patch_height, patch_width = pair(patch_size)
 87 | 
 88 |         assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
 89 | 
 90 |         num_patches = (image_height // patch_height) * (image_width // patch_width)
 91 |         patch_dim = channels * patch_height * patch_width
 92 |         assert pool in {'cls', 'mean'}, 'pool type must be either cls (cls token) or mean (mean pooling)'
 93 | 
 94 |         self.to_patch_embedding = nn.Sequential(
 95 |             Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_height, p2 = patch_width),
 96 |             nn.Linear(patch_dim, dim),
 97 |         )
 98 | 
 99 |         self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))
100 |         self.cls_token = nn.Parameter(torch.randn(1, 1, dim))
101 |         self.dropout = nn.Dropout(emb_dropout)
102 | 
103 |         self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout)
104 | 
105 |         self.pool = pool
106 |         self.to_latent = nn.Identity()
107 | 
108 |         self.mlp_head = nn.Sequential(
109 |             nn.LayerNorm(dim),
110 |             nn.Linear(dim, num_classes)
111 |         )
112 | 
113 |     def forward(self, img):
114 |         x = self.to_patch_embedding(img)
115 |         b, n, _ = x.shape
116 | 
117 |         cls_tokens = repeat(self.cls_token, '() n d -> b n d', b = b)
118 |         x = torch.cat((cls_tokens, x), dim=1)
119 |         x += self.pos_embedding[:, :(n + 1)]
120 |         x = self.dropout(x)
121 | 
122 |         x = self.transformer(x)
123 | 
124 |         x = x.mean(dim = 1) if self.pool == 'mean' else x[:, 0]
125 | 
126 |         x = self.to_latent(x)
127 |         return self.mlp_head(x)
128 |     
129 |     


--------------------------------------------------------------------------------
/gpt4_prompt2/losses.pkl:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/michaelrzhang/LLM-HyperOpt/c8dd022089f0f7e7c3da7a75bd53e29bddfea438/gpt4_prompt2/losses.pkl


--------------------------------------------------------------------------------
/gpt4_prompt2/messages.pkl:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/michaelrzhang/LLM-HyperOpt/c8dd022089f0f7e7c3da7a75bd53e29bddfea438/gpt4_prompt2/messages.pkl


--------------------------------------------------------------------------------
/gpt4_prompt2/trajectories.pkl:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/michaelrzhang/LLM-HyperOpt/c8dd022089f0f7e7c3da7a75bd53e29bddfea438/gpt4_prompt2/trajectories.pkl


--------------------------------------------------------------------------------
/llm_hpo.py:
--------------------------------------------------------------------------------
 1 | 
 2 | import json
 3 | import openai
 4 | import re
 5 | 
 6 | class LLMOptimizer:
 7 |     def __init__(self, is_expert="generic", model="gpt-3.5-turbo",
 8 |         temperature = 0.0,
 9 |         max_tokens = 600,
10 |         frequency_penalty = 0,
11 |         use_cot = False,
12 |     ):
13 |         self.model = model
14 |         self.is_expert = is_expert
15 |         self.temperature = temperature
16 |         self.max_tokens = max_tokens
17 |         self.frequency_penalty = frequency_penalty
18 |         self.use_cot = use_cot
19 |         self.messages = []
20 | 
21 |         # Initialize the conversation with the given system prompt
22 |         self.initial_config()
23 | 
24 |     def initial_config(self):
25 |         """This expert prompt does not seem to make too much of a difference (see Appendix in paper), but conditioning on good performance is generally a good idea."""
26 |         if self.is_expert == "generic":
27 |             message = {"role":"system", "content": "You are a machine learning expert."}
28 |             self.messages.append(message)
29 | 
30 |     def call_llm(self, max_retries=2):
31 |         tries = 0
32 |         while tries < max_retries:
33 |             try:
34 |                 response = openai.ChatCompletion.create(
35 |                     model=self.model,
36 |                     messages=self.messages,
37 |                     temperature=self.temperature,
38 |                     max_tokens=self.max_tokens,
39 |                     frequency_penalty=self.frequency_penalty
40 |                 )
41 |                 # make sure we have the right version
42 |                 if self.model == "gpt-4":
43 |                     assert response.model == 'gpt-4-0613'
44 |                 elif self.model == "gpt-3.5-turbo":
45 |                     assert response.model == "gpt-3.5-turbo-0613"
46 |                 config = response["choices"][0]["message"]["content"]
47 |                 self.messages.append({"role":"assistant", "content": config})
48 |                 return config 
49 |             except Exception as e:
50 |                 tries += 1
51 |                 print(e)
52 |                 import time; time.sleep(30)
53 |         print(response)
54 |         raise Exception("Failed to call LLM, max retries exceeded")
55 | 
56 |     def _parse_raw_message(self, raw_message):
57 |         # Parse the raw message into model source code, optimizer source code, and hparams
58 |         json_match = re.search(r'```json\n(.*)\n```', raw_message, re.DOTALL)
59 |         if json_match is None:
60 |             raise Exception("Failed to parse raw message")
61 |         params = json.loads(json_match.group(1).strip())
62 |         assert isinstance(params, dict)
63 |         assert "x1" in params and "x2" in params
64 |         
65 |         return params
66 |     
67 |     def parse_message(self, raw_message):
68 |         if "Output: " in raw_message:
69 |             raw_message = raw_message.split("Output: ")[1]
70 |         try:
71 |             params = json.loads(raw_message)
72 |             params = params["x"]
73 |         except:
74 |             print("***Raising exception...")
75 |             print(raw_message)
76 |             raise Exception("Failed to parse message")
77 |         return params
78 |         
79 |     
80 |     def ask(self, prompt):
81 |         self.messages.append({"role":"user", "content": prompt})
82 |         raw_message = self.call_llm()
83 |         params = self.parse_message(raw_message)
84 |         return params
85 |     
86 |     def get_current_messages(self):
87 |         return self.messages


--------------------------------------------------------------------------------
/load_toy_trajectories.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 7,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "import os\n",
 10 |     "import pickle\n",
 11 |     "import numpy as np\n",
 12 |     "import matplotlib.pyplot as plt"
 13 |    ]
 14 |   },
 15 |   {
 16 |    "cell_type": "code",
 17 |    "execution_count": 9,
 18 |    "metadata": {},
 19 |    "outputs": [],
 20 |    "source": [
 21 |     "def load_results(load_path):\n",
 22 |     "    print(\"Loading results from\", load_path)\n",
 23 |     "    trajectory_path = os.path.join(load_path, \"trajectories.pkl\")\n",
 24 |     "    losses_path = os.path.join(load_path, \"losses.pkl\")\n",
 25 |     "    messages_path = os.path.join(load_path, \"messages.pkl\")\n",
 26 |     "    with open(trajectory_path, \"rb\") as f:\n",
 27 |     "        trajectories = pickle.load(f)\n",
 28 |     "    with open(losses_path, \"rb\") as f:\n",
 29 |     "        losses = pickle.load(f)\n",
 30 |     "    with open(messages_path, \"rb\") as f:\n",
 31 |     "        messages = pickle.load(f)\n",
 32 |     "    print(\"successfully loaded\")\n",
 33 |     "    for t, results in losses.items():\n",
 34 |     "        results = np.array(results)\n",
 35 |     "        assert results.shape[0] == 3\n",
 36 |     "        min_losses = np.min(results, axis=1)\n",
 37 |     "        print(f\"t={t}, min_losses={min_losses}\")\n",
 38 |     "    return trajectories, losses, messages"
 39 |    ]
 40 |   },
 41 |   {
 42 |    "cell_type": "code",
 43 |    "execution_count": 11,
 44 |    "metadata": {},
 45 |    "outputs": [
 46 |     {
 47 |      "name": "stdout",
 48 |      "output_type": "stream",
 49 |      "text": [
 50 |       "Loading results from gpt4_prompt2\n",
 51 |       "successfully loaded\n",
 52 |       "t=rosenbrock, min_losses=[0. 1. 0.]\n",
 53 |       "t=branin, min_losses=[1.9431494  3.91125913 0.49791071]\n",
 54 |       "t=himmelblau, min_losses=[8.125 8.125 8.125]\n",
 55 |       "t=ackley, min_losses=[0. 0. 0.]\n",
 56 |       "t=quadratic2d, min_losses=[ 1.445  0.365 28.145]\n",
 57 |       "t=quadratic2d_10, min_losses=[51.4475     51.14046875  0.6475    ]\n",
 58 |       "t=shifted_rosenbrock, min_losses=[  0.528301   163.859581    15.36746506]\n",
 59 |       "t=shifted_branin, min_losses=[3.25633331 5.58170296 9.89968188]\n",
 60 |       "t=shifted_himmelblau, min_losses=[16.99008562 47.06711762 47.06711762]\n",
 61 |       "t=shifted_ackley, min_losses=[1.77061516 1.86148837 4.47514355]\n",
 62 |       "dict_keys(['rosenbrock', 'branin', 'himmelblau', 'ackley', 'quadratic2d', 'quadratic2d_10', 'shifted_rosenbrock', 'shifted_branin', 'shifted_himmelblau', 'shifted_ackley'])\n"
 63 |      ]
 64 |     }
 65 |    ],
 66 |    "source": [
 67 |     "trajectories, losses, messages = load_results(\"gpt4_prompt2\")\n",
 68 |     "print(trajectories.keys())"
 69 |    ]
 70 |   },
 71 |   {
 72 |    "cell_type": "code",
 73 |    "execution_count": 13,
 74 |    "metadata": {},
 75 |    "outputs": [
 76 |     {
 77 |      "data": {
 78 |       "text/plain": [
 79 |        "[[0, 0],\n",
 80 |        " [-5, 15],\n",
 81 |        " [-5, 15],\n",
 82 |        " [0, 10],\n",
 83 |        " [-5, 15],\n",
 84 |        " [-5, 15],\n",
 85 |        " [10, 0],\n",
 86 |        " [10, 5],\n",
 87 |        " [10, 10],\n",
 88 |        " [10, 3]]"
 89 |       ]
 90 |      },
 91 |      "execution_count": 13,
 92 |      "metadata": {},
 93 |      "output_type": "execute_result"
 94 |     }
 95 |    ],
 96 |    "source": [
 97 |     "trajectories[\"branin\"][0]"
 98 |    ]
 99 |   },
100 |   {
101 |    "cell_type": "code",
102 |    "execution_count": 14,
103 |    "metadata": {},
104 |    "outputs": [
105 |     {
106 |      "data": {
107 |       "text/plain": [
108 |        "[{'role': 'system', 'content': 'You are a machine learning expert.'},\n",
109 |        " {'role': 'user',\n",
110 |        "  'content': 'You are helping tune hyperparameters to minimize loss. x1 must be in range (-5, 10). x2 must be in range (0, 15). I want you to predict values that minimize the loss of the function; I will tell you the value of the function before you try again. Do not put new lines or extra characters in your response. We have a total of 10 evaluations. Format your output with json as follows: {\"x\": [x1, x2]}\\n'},\n",
111 |        " {'role': 'assistant', 'content': '{\"x\": [0, 0]}'},\n",
112 |        " {'role': 'user',\n",
113 |        "  'content': 'Loss: 5.560e+01. Format your next output as before.'},\n",
114 |        " {'role': 'assistant', 'content': '{\"x\": [-5, 15]}'},\n",
115 |        " {'role': 'user',\n",
116 |        "  'content': 'Loss: 1.751e+01. Write two lines as follows:\\nAnalysis:(up to a few sentences describing what worked so far and what to choose next)\\nOutput:{json dict}'},\n",
117 |        " {'role': 'assistant',\n",
118 |        "  'content': 'Analysis: The loss decreased significantly when x1 was at its minimum and x2 was at its maximum. This suggests that the function may be minimized when x1 is less and x2 is more. Let\\'s try to decrease x1 further and increase x2 further within their respective ranges.\\n\\nOutput: {\"x\": [-5, 15]}'},\n",
119 |        " {'role': 'user',\n",
120 |        "  'content': 'Loss: 1.751e+01. Write two lines as follows:\\nAnalysis:(up to a few sentences describing what worked so far and what to choose next)\\nOutput:{json dict}'},\n",
121 |        " {'role': 'assistant',\n",
122 |        "  'content': 'Analysis: The loss remained the same, indicating that we might have reached the optimal values for x1 and x2. However, to confirm this, let\\'s try a different combination by increasing x1 and decreasing x2.\\n\\nOutput: {\"x\": [0, 10]}'},\n",
123 |        " {'role': 'user',\n",
124 |        "  'content': 'Loss: 3.560e+01. Write two lines as follows:\\nAnalysis:(up to a few sentences describing what worked so far and what to choose next)\\nOutput:{json dict}'},\n",
125 |        " {'role': 'assistant',\n",
126 |        "  'content': 'Analysis: The loss increased when we increased x1 and decreased x2. This suggests that the function is indeed minimized when x1 is less and x2 is more. Let\\'s revert back to the previous values to confirm this.\\n\\nOutput: {\"x\": [-5, 15]}'},\n",
127 |        " {'role': 'user',\n",
128 |        "  'content': 'Loss: 1.751e+01. Write two lines as follows:\\nAnalysis:(up to a few sentences describing what worked so far and what to choose next)\\nOutput:{json dict}'},\n",
129 |        " {'role': 'assistant',\n",
130 |        "  'content': 'Analysis: The loss remained the same, confirming our hypothesis that the function is minimized when x1 is at its minimum and x2 is at its maximum. Let\\'s keep these values as they seem to provide the lowest loss.\\n\\nOutput: {\"x\": [-5, 15]}'},\n",
131 |        " {'role': 'user',\n",
132 |        "  'content': 'Loss: 1.751e+01. Write two lines as follows:\\nAnalysis:(up to a few sentences describing what worked so far and what to choose next)\\nOutput:{json dict}'},\n",
133 |        " {'role': 'assistant',\n",
134 |        "  'content': 'Analysis: The loss is consistent at 1.751e+01 when x1 is -5 and x2 is 15. This suggests that we have found the optimal values for x1 and x2. However, to ensure we are not stuck in a local minimum, let\\'s try a different combination.\\n\\nOutput: {\"x\": [10, 0]}'},\n",
135 |        " {'role': 'user',\n",
136 |        "  'content': 'Loss: 1.096e+01. Write two lines as follows:\\nAnalysis:(up to a few sentences describing what worked so far and what to choose next)\\nOutput:{json dict}'},\n",
137 |        " {'role': 'assistant',\n",
138 |        "  'content': 'Analysis: Surprisingly, the loss decreased when we set x1 to its maximum and x2 to its minimum. This suggests that the function might have multiple minima. Let\\'s continue exploring this direction by keeping x1 at its maximum and increasing x2 slightly.\\n\\nOutput: {\"x\": [10, 5]}'},\n",
139 |        " {'role': 'user',\n",
140 |        "  'content': 'Loss: 5.931e+00. Write two lines as follows:\\nAnalysis:(up to a few sentences describing what worked so far and what to choose next)\\nOutput:{json dict}'},\n",
141 |        " {'role': 'assistant',\n",
142 |        "  'content': 'Analysis: The loss decreased further when we increased x2 while keeping x1 at its maximum. This suggests that the function might be minimized when x1 is high and x2 is somewhere in the middle of its range. Let\\'s continue to increase x2.\\n\\nOutput: {\"x\": [10, 10]}'},\n",
143 |        " {'role': 'user',\n",
144 |        "  'content': 'Loss: 5.090e+01. Write two lines as follows:\\nAnalysis:(up to a few sentences describing what worked so far and what to choose next)\\nOutput:{json dict}'},\n",
145 |        " {'role': 'assistant',\n",
146 |        "  'content': 'Analysis: The loss increased significantly when we increased x2 further while keeping x1 at its maximum. This suggests that the function might be minimized when x1 is high and x2 is lower. Let\\'s decrease x2 slightly.\\n\\nOutput: {\"x\": [10, 3]}'}]"
147 |       ]
148 |      },
149 |      "execution_count": 14,
150 |      "metadata": {},
151 |      "output_type": "execute_result"
152 |     }
153 |    ],
154 |    "source": [
155 |     "messages[\"branin\"][0]"
156 |    ]
157 |   },
158 |   {
159 |    "cell_type": "code",
160 |    "execution_count": null,
161 |    "metadata": {},
162 |    "outputs": [],
163 |    "source": []
164 |   }
165 |  ],
166 |  "metadata": {
167 |   "kernelspec": {
168 |    "display_name": "llm_hpo",
169 |    "language": "python",
170 |    "name": "llm-hpo"
171 |   },
172 |   "language_info": {
173 |    "codemirror_mode": {
174 |     "name": "ipython",
175 |     "version": 3
176 |    },
177 |    "file_extension": ".py",
178 |    "mimetype": "text/x-python",
179 |    "name": "python",
180 |    "nbconvert_exporter": "python",
181 |    "pygments_lexer": "ipython3",
182 |    "version": "3.9.12"
183 |   }
184 |  },
185 |  "nbformat": 4,
186 |  "nbformat_minor": 2
187 | }
188 | 


--------------------------------------------------------------------------------
/run_toy_fns.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 2,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "import openai\n",
 10 |     "from llm_hpo import LLMOptimizer\n",
 11 |     "from utils.toy_utils import *\n",
 12 |     "\n",
 13 |     "%load_ext autoreload\n",
 14 |     "%autoreload 2"
 15 |    ]
 16 |   },
 17 |   {
 18 |    "cell_type": "code",
 19 |    "execution_count": 3,
 20 |    "metadata": {},
 21 |    "outputs": [],
 22 |    "source": [
 23 |     "try:\n",
 24 |     "    openai.api_key = os.getenv(\"OPENAI_API_KEY\")\n",
 25 |     "except:\n",
 26 |     "    #insert key here \n",
 27 |     "    print(\"API key not found in environment variables\")\n",
 28 |     "    openai.api_key = \"\"\n",
 29 |     "   "
 30 |    ]
 31 |   },
 32 |   {
 33 |    "cell_type": "code",
 34 |    "execution_count": 4,
 35 |    "metadata": {},
 36 |    "outputs": [
 37 |     {
 38 |      "name": "stdout",
 39 |      "output_type": "stream",
 40 |      "text": [
 41 |       "dict_keys(['rosenbrock', 'branin', 'himmelblau', 'ackley', 'quadratic2d', 'quadratic2d_10', 'shifted_rosenbrock', 'shifted_branin', 'shifted_himmelblau', 'shifted_ackley'])\n"
 42 |      ]
 43 |     }
 44 |    ],
 45 |    "source": [
 46 |     "print(named_toy_functions.keys())"
 47 |    ]
 48 |   },
 49 |   {
 50 |    "cell_type": "code",
 51 |    "execution_count": 5,
 52 |    "metadata": {},
 53 |    "outputs": [
 54 |     {
 55 |      "name": "stdout",
 56 |      "output_type": "stream",
 57 |      "text": [
 58 |       "Iteration 0 out of 5\n",
 59 |       "Iteration 1 out of 5\n",
 60 |       "Iteration 2 out of 5\n",
 61 |       "Iteration 3 out of 5\n",
 62 |       "Iteration 4 out of 5\n"
 63 |      ]
 64 |     }
 65 |    ],
 66 |    "source": [
 67 |     "# optimize rosenbrock\n",
 68 |     "name = \"quadratic2d\"\n",
 69 |     "t = named_toy_functions[name]\n",
 70 |     "search_budget = 5\n",
 71 |     "llm_model = \"gpt-3.5-turbo\"\n",
 72 |     "use_cot = True\n",
 73 |     "temperature = 0\n",
 74 |     "prompt_number = 2  \n",
 75 |     "trajectory, losses, messages = optimize_with_llm(t, search_budget=search_budget, llm_model=llm_model, cot=use_cot, temperature=temperature, prompt_num=prompt_number, verbose=False)"
 76 |    ]
 77 |   },
 78 |   {
 79 |    "cell_type": "code",
 80 |    "execution_count": 6,
 81 |    "metadata": {},
 82 |    "outputs": [
 83 |     {
 84 |      "data": {
 85 |       "image/png": "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",
 86 |       "text/plain": [
 87 |        "<Figure size 640x480 with 2 Axes>"
 88 |       ]
 89 |      },
 90 |      "metadata": {},
 91 |      "output_type": "display_data"
 92 |     }
 93 |    ],
 94 |    "source": [
 95 |     "plot_type = \"quadratic\" if \"quadratic\" in name else \"standard\"\n",
 96 |     "fig = plot_trajectory(t, trajectory, log_scale=False, plot_type=plot_type, func_name=name)"
 97 |    ]
 98 |   },
 99 |   {
100 |    "cell_type": "code",
101 |    "execution_count": null,
102 |    "metadata": {},
103 |    "outputs": [],
104 |    "source": []
105 |   }
106 |  ],
107 |  "metadata": {
108 |   "kernelspec": {
109 |    "display_name": "llm_hpo",
110 |    "language": "python",
111 |    "name": "llm-hpo"
112 |   },
113 |   "language_info": {
114 |    "codemirror_mode": {
115 |     "name": "ipython",
116 |     "version": 3
117 |    },
118 |    "file_extension": ".py",
119 |    "mimetype": "text/x-python",
120 |    "name": "python",
121 |    "nbconvert_exporter": "python",
122 |    "pygments_lexer": "ipython3",
123 |    "version": "3.9.12"
124 |   }
125 |  },
126 |  "nbformat": 4,
127 |  "nbformat_minor": 2
128 | }
129 | 


--------------------------------------------------------------------------------
/utils/toy_utils.py:
--------------------------------------------------------------------------------
  1 | import math
  2 | import os
  3 | from collections import namedtuple
  4 | 
  5 | import matplotlib.pyplot as plt
  6 | import numpy as np
  7 | import openai
  8 | 
  9 | from llm_hpo import LLMOptimizer
 10 | 
 11 | 
 12 | def optimize_with_llm(
 13 |     toy_func, search_budget, llm_model, cot, temperature, prompt_num, verbose=False
 14 | ):
 15 |     """Optimize a toy function using LLM."""
 16 |     llm = LLMOptimizer(model=llm_model, temperature=temperature)
 17 |     trajectory = []
 18 |     losses = []
 19 |     for iteration in range(search_budget):
 20 |         print(f"Iteration {iteration} out of {search_budget}")
 21 |         if iteration == 0:
 22 |             prompt = BlackBoxPrompts.make_inital_prompt(
 23 |                 toy_func.search_space, prompt_num=prompt_num, budget=search_budget
 24 |             )
 25 |         else:
 26 |             prompt = BlackBoxPrompts.make_feedback_prompt(
 27 |                 loss, iter=iteration, use_cot=cot, prompt_num=prompt_num
 28 |             )
 29 |         params = llm.ask(prompt)
 30 |         if isinstance(toy_func, QuadraticFunction):
 31 |             loss = toy_func(params)
 32 |         else:
 33 |             loss = toy_func(params[0], params[1])
 34 |         if verbose:
 35 |             print(f"----\nPrompt: {prompt}\nparams: {params}\n Loss: {loss}")
 36 |         trajectory.append(params)
 37 |         losses.append(loss)
 38 |     messages = llm.get_current_messages()
 39 |     return trajectory, losses, messages
 40 | 
 41 | 
 42 | # define toy functions
 43 | class ToyFunction:
 44 |     search_space: dict[str, tuple[float]]
 45 |     optima: dict[str, float]
 46 | 
 47 |     def __init__(self, search_space=None, optima=None) -> None:
 48 |         self.search_space = search_space
 49 |         self.optima = optima
 50 | 
 51 |     def __call__(self, *args):
 52 |         raise NotImplementedError
 53 | 
 54 | 
 55 | class QuadraticFunction:
 56 |     """Axis-aligned quadratic function"""
 57 | 
 58 |     def __init__(self, num_dimensions=5, eigenspectrum="uniform", optima_min=5):
 59 |         # Define optimum c within the range [-min_range, min_range]
 60 |         self.num_dimensions = num_dimensions
 61 |         self.min_range = optima_min  # dist from origin to optima
 62 | 
 63 |         if eigenspectrum == "uniform":
 64 |             self.eigenvalues = np.ones(self.num_dimensions)
 65 |         elif eigenspectrum == "random":
 66 |             self.eigenvalues = np.random.uniform(1, num_dimensions, self.num_dimensions)
 67 |         else:
 68 |             raise NotImplementedError
 69 | 
 70 |         self.A = np.diag(self.eigenvalues)
 71 |         self.c = np.random.uniform(-self.min_range, self.min_range, self.num_dimensions)
 72 |         self.search_space = {
 73 |             f"x{i+1}": (-self.min_range, self.min_range)
 74 |             for i in range(self.num_dimensions)
 75 |         }
 76 | 
 77 |     def __call__(self, x):
 78 |         x_minus_c = x - self.c
 79 |         return np.dot(x_minus_c.T, np.dot(self.A, x_minus_c))
 80 | 
 81 |     def set_A(self, A):
 82 |         self.A = A
 83 | 
 84 |     def set_c(self, c):
 85 |         self.c = c
 86 | 
 87 |     def evaluate_on_grid(self, X1, X2):
 88 |         Y = np.zeros_like(X1)
 89 |         for i in range(X1.shape[0]):
 90 |             for j in range(X1.shape[1]):
 91 |                 x = np.array([X1[i, j], X2[i, j]])
 92 |                 Y[i, j] = self(x)
 93 |         return Y
 94 | 
 95 |     def load_dict(self, d):
 96 |         self.num_dimensions = d["num_dimensions"]
 97 |         self.eigenvalues = d["eigenvalues"]
 98 |         self.c = d["c"]
 99 |         self.A = np.diag(self.eigenvalues)
100 | 
101 |     def get_dict(self):
102 |         # returns dictionary that can be used to reconstruct identical function
103 |         return {
104 |             "num_dimensions": self.num_dimensions,
105 |             "eigenvalues": self.eigenvalues,
106 |             "c": self.c,
107 |         }
108 | 
109 |     def get_info(self):
110 |         return self.A, self.c
111 | 
112 |     def __repr__(self) -> str:
113 |         return f"QuadraticFunction(eigenspectrum={self.eigenvalues}, min={self.c}"
114 | 
115 | 
116 | class ShiftedToyFunction:
117 |     # shifts everything to mitigate overfitting
118 |     def __init__(self, toy_function_instance, shift_value):
119 |         self.toy_function_instance = toy_function_instance
120 |         self.shift_value = shift_value
121 |         self.search_space = self.toy_function_instance.search_space
122 |         self.optima = self.toy_function_instance.optima
123 |         self.optima["x1"] += self.shift_value[0]
124 |         self.optima["x2"] += self.shift_value[1]
125 |         # check if instance has optimas
126 |         if getattr(self.toy_function_instance, "optimas", None) is not None:
127 |             self.optimas = []
128 |             for optima in self.toy_function_instance.optimas:
129 |                 self.optimas.append(
130 |                     {
131 |                         "x1": optima["x1"] + self.shift_value[0],
132 |                         "x2": optima["x2"] + self.shift_value[1],
133 |                     }
134 |                 )
135 | 
136 |     def __call__(self, x1, x2) -> float:
137 |         return self.toy_function_instance(
138 |             x1 - self.shift_value[0], x2 - self.shift_value[1]
139 |         )
140 | 
141 | 
142 | class RosenbrockFunction(ToyFunction):
143 |     def __init__(self):
144 |         search_space = {
145 |             "x1": (-5, 10),
146 |             "x2": (-5, 10),  # TODO: check if this is correct
147 |         }
148 |         optima = {
149 |             "x1": 1.0,
150 |             "x2": 1.0,
151 |         }
152 |         super().__init__(search_space=search_space, optima=optima)
153 | 
154 |     def __call__(self, x1: float, x2: float) -> float:
155 |         # See https://en.wikipedia.org/wiki/Rosenbrock_function.
156 |         # Search space: [-5, 10] x [5, 10]
157 |         return (1 - x1) ** 2.0 + 100 * (x2 - x1**2.0) ** 2.0
158 | 
159 | 
160 | class BraninFunction(ToyFunction):
161 |     def __init__(self):
162 |         search_space = {
163 |             "x1": (-5, 10),
164 |             "x2": (0, 15),
165 |         }
166 |         optima = {
167 |             "x1": -math.pi,
168 |             "x2": 12.275,
169 |         }
170 |         optimas = [
171 |             {"x1": -math.pi, "x2": 12.275},
172 |             {"x1": math.pi, "x2": 2.275},
173 |             {"x1": 9.42478, "x2": 2.475},
174 |         ]
175 |         self.optimas = optimas
176 |         super().__init__(search_space=search_space, optima=optima)
177 | 
178 |     def __call__(self, x1: float, x2: float) -> float:
179 |         # Reference code:
180 |         # https://github.com/automl/SMAC3/blob/main/benchmark/src/models/branin.py.
181 |         # Search space: [-5, 10] x [0, 15].
182 |         pi = math.pi
183 |         a = 1
184 |         b = 5.1 / ((2 * pi) ** 2)
185 |         c = 5 / pi
186 |         r = 6
187 |         s = 10
188 |         t = 1 / (8 * pi)
189 |         return a * (x2 - b * x1**2 + c * x1 - r) ** 2 + s * (1 - t) * np.cos(x1) + s
190 | 
191 | 
192 | class HimmelblauFunction(ToyFunction):
193 |     def __init__(self):
194 |         search_space = {
195 |             "x1": (-5, 5),
196 |             "x2": (-5, 5),
197 |         }
198 |         optima = {
199 |             "x1": 3.0,
200 |             "x2": 2.0,
201 |         }
202 |         optimas = [
203 |             {"x1": 3, "x2": 2},
204 |             {"x1": -2.805118, "x2": 3.131312},
205 |             {"x1": -3.779310, "x2": -3.283186},
206 |             {"x1": 3.584428, "x2": -1.848126},
207 |         ]
208 |         self.optimas = optimas
209 |         super().__init__(search_space=search_space, optima=optima)
210 | 
211 |     def __call__(self, x1: float, x2: float) -> float:
212 |         # Reference code:
213 |         # https://github.com/automl/SMAC3/blob/main/benchmark/src/models/himmelblau.py.
214 |         # Search space: [-5, 5] x [-5, 5]
215 |         return (x1**2 + x2 - 11) ** 2 + (x1 + x2**2 - 7) ** 2
216 | 
217 | 
218 | class AckleyFunction(ToyFunction):
219 |     def __init__(self):
220 |         search_space = {
221 |             "x1": (-5, 5),
222 |             "x2": (-5, 5),
223 |         }
224 |         optima = {
225 |             "x1": 0.0,
226 |             "x2": 0.0,
227 |         }
228 |         super().__init__(search_space=search_space, optima=optima)
229 | 
230 |     def __call__(self, x1: float, x2: float) -> float:
231 |         # Reference code:
232 |         return (
233 |             -20 * np.exp(-0.2 * np.sqrt(0.5 * (x1**2 + x2**2)))
234 |             - np.exp(0.5 * (np.cos(2 * math.pi * x1) + np.cos(2 * math.pi * x2)))
235 |             + math.e
236 |             + 20
237 |         )
238 | 
239 | 
240 | named_toy_functions = {
241 |     "rosenbrock": RosenbrockFunction(),
242 |     "branin": BraninFunction(),
243 |     "himmelblau": HimmelblauFunction(),
244 |     "ackley": AckleyFunction(),
245 | }
246 | 
247 | function_names = tuple(named_toy_functions.keys())
248 | toy_functions = namedtuple("_toy_funcs", named_toy_functions.keys())(
249 |     **named_toy_functions
250 | )
251 | 
252 | quadratic_uniform_2d = QuadraticFunction(
253 |     num_dimensions=2, eigenspectrum="uniform", optima_min=5
254 | )
255 | quad_optima_x = -4.15
256 | quad_optima_y = 3.35
257 | quadratic_uniform_2d.set_c(np.array([quad_optima_x, quad_optima_y]))
258 | 
259 | quadratic_badcondition_2d = QuadraticFunction(
260 |     num_dimensions=2, eigenspectrum="uniform", optima_min=5
261 | )
262 | quadratic_badcondition_2d.set_c(np.array([quad_optima_x, quad_optima_y]))
263 | quadratic_badcondition_2d.set_A(np.array([[1, 0], [0, 10]]))
264 | 
265 | named_toy_functions.update(
266 |     {
267 |         "quadratic2d": quadratic_uniform_2d,
268 |         "quadratic2d_10": quadratic_badcondition_2d,
269 |     }
270 | )
271 | 
272 | shift_value = (0.93, 0.59)  # we use these throughout experiments
273 | named_toy_functions.update(
274 |     {
275 |         "shifted_rosenbrock": ShiftedToyFunction(RosenbrockFunction(), shift_value),
276 |         "shifted_branin": ShiftedToyFunction(BraninFunction(), shift_value),
277 |         "shifted_himmelblau": ShiftedToyFunction(HimmelblauFunction(), shift_value),
278 |         "shifted_ackley": ShiftedToyFunction(AckleyFunction(), shift_value),
279 |     }
280 | )
281 | 
282 | 
283 | def get_function_name(function: ToyFunction) -> str:
284 |     return repr(function).split("Function")[0]
285 | 
286 | 
287 | def get_function(name: str) -> ToyFunction:
288 |     return named_toy_functions[name]
289 | 
290 | 
291 | # Prompts for 2D Toy functions
292 | class BlackBoxPrompts:
293 |     def make_inital_prompt(search_space, prompt_num, budget=10):
294 |         if prompt_num == 0:
295 |             prompt = f"""You are optimizing a function with two inputs. x1 must be in range {search_space['x1']}. x2 must be in range {search_space['x2']}. I want you to predict values that minimize the loss of the function; I will tell you the value of the function before you try again. Do not put new lines or extra characters in your response. Format your output with json as follows: {{"x": [x1, x2]}}\n"""
296 |         elif prompt_num == 1:
297 |             prompt = f"""You are optimizing a function with two inputs. x1 must be in range {search_space['x1']}. x2 must be in range {search_space['x2']}. I want you to predict values that minimize the loss of the function; I will tell you the value of the function before you try again. Do not put new lines or extra characters in your response. We have a total of {budget} evaluations. Format your output with json as follows: {{"x": [x1, x2]}}\n"""
298 |         elif prompt_num == 2:
299 |             prompt = f"""You are helping tune hyperparameters to minimize loss. x1 must be in range {search_space['x1']}. x2 must be in range {search_space['x2']}. I want you to predict values that minimize the loss of the function; I will tell you the value of the function before you try again. Do not put new lines or extra characters in your response. We have a total of {budget} evaluations. Format your output with json as follows: {{"x": [x1, x2]}}\n"""
300 |         elif prompt_num == 3:
301 |             prompt = f"""You are helping tune hyperparameters to minimize loss. x1 must be in range {search_space['x1']}. x2 must be in range {search_space['x2']}. The training process is deterministic and yields a nonnegative loss. I want you to predict values that minimize the loss of the function; I will tell you the value of the function before you try again. Do not put new lines or extra characters in your response. We have a total of {budget} evaluations. Format your output with json as follows: {{"x": [x1, x2]}}\n"""
302 |         else:
303 |             raise NotImplementedError
304 |         return prompt
305 | 
306 |     def make_feedback_prompt(loss, iter=1, use_cot=True, prompt_num=1):
307 |         # prompt_num currently unused
308 |         if iter > 0 and use_cot:
309 |             return f"""Loss: {loss:.3e}. Write two lines as follows:\nAnalysis:(up to a few sentences describing what worked so far and what to choose next)\nOutput:{{json dict}}"""
310 |         else:
311 |             return f"""Loss: {loss:.3e}. Format your next output as before."""
312 | 
313 | 
314 | def plot_trajectory(
315 |     func: ToyFunction,
316 |     trajectory: list[tuple[float]],
317 |     log_scale=False,
318 |     plot_type="standard",
319 |     func_name="example",
320 | ):
321 |     fig, ax = plt.subplots()
322 |     # ax.set_title(f"Trajectory on {func_name}")
323 |     ax.set_xlabel("x1")
324 |     ax.set_ylabel("x2")
325 |     if plot_type == "standard":
326 |         x1_lower, x1_upper = func.search_space["x1"]
327 |         x1_lower -= 0.5
328 |         x1_upper += 0.5
329 |         x2_lower, x2_upper = func.search_space["x2"]
330 |         x2_lower -= 0.5
331 |         x2_upper += 0.5
332 |     else:
333 |         x1_lower, x1_upper = -6, 6
334 |         x2_lower, x2_upper = -6, 6
335 |     ax.set_xlim(x1_lower, x1_upper)
336 |     ax.set_ylim(x2_lower, x2_upper)
337 | 
338 |     # setup log scale if needed
339 |     norm = LogNorm() if log_scale else None
340 | 
341 |     # Plot the function as a color map
342 |     x1 = np.linspace(x1_lower, x1_upper, 150)
343 |     x2 = np.linspace(x2_lower, x2_upper, 150)
344 |     X1, X2 = np.meshgrid(x1, x2)
345 |     if plot_type == "standard":
346 |         Y = func(X1, X2)
347 |     else:
348 |         Y = func.evaluate_on_grid(X1, X2)
349 |     c = ax.pcolormesh(X1, X2, Y, shading="auto", cmap="inferno", norm=norm)
350 |     fig.colorbar(c, ax=ax)
351 | 
352 |     # Add contours
353 |     contour = ax.contour(X1, X2, Y, levels=20, colors="salmon", norm=norm)
354 |     ax.clabel(contour, inline=1, fontsize=8)
355 | 
356 |     # Plot the trajectory with arrows
357 |     x1_vals, x2_vals = zip(*trajectory)
358 |     ax.plot(x1_vals, x2_vals, marker="o", color="royalblue", linewidth=1, markersize=1)
359 |     for i in range(1, len(x1_vals)):
360 |         ax.quiver(
361 |             x1_vals[i - 1],
362 |             x2_vals[i - 1],
363 |             x1_vals[i] - x1_vals[i - 1],
364 |             x2_vals[i] - x2_vals[i - 1],
365 |             angles="xy",
366 |             scale_units="xy",
367 |             scale=1,
368 |             color="royalblue",
369 |         )
370 | 
371 |     # Indicate start and end of the trajectory
372 |     ax.plot(x1_vals[0], x2_vals[0], marker="o", color="mediumseagreen", label="Start")
373 |     ax.plot(x1_vals[-1], x2_vals[-1], marker="s", color="dodgerblue", label="End")
374 | 
375 |     # Mark the optima
376 |     if plot_type == "standard":
377 |         # check if func has optimas
378 |         if getattr(func, "optimas", None) is not None:
379 |             print("multiple optimas")
380 |             # iterate through optimas
381 |             for i, optima in enumerate(func.optimas):
382 |                 x1_opt, x2_opt = optima["x1"], optima["x2"]
383 |                 if i == 0:
384 |                     ax.plot(
385 |                         x1_opt,
386 |                         x2_opt,
387 |                         marker="*",
388 |                         markersize=12,
389 |                         color="limegreen",
390 |                         label="Optima",
391 |                     )
392 |                 else:
393 |                     ax.plot(
394 |                         x1_opt, x2_opt, marker="*", markersize=12, color="limegreen"
395 |                     )
396 |         else:
397 |             print("single optima")
398 |             x1_opt, x2_opt = func.optima["x1"], func.optima["x2"]
399 |             ax.plot(
400 |                 x1_opt,
401 |                 x2_opt,
402 |                 marker="*",
403 |                 markersize=12,
404 |                 color="limegreen",
405 |                 label="Optima",
406 |             )
407 |     else:
408 |         x1_opt, x2_opt = quad_optima_x, quad_optima_y
409 |         ax.plot(
410 |             x1_opt, x2_opt, marker="*", markersize=12, color="limegreen", label="Optima"
411 |         )
412 | 
413 |     ax.legend()
414 |     plt.show()
415 |     return fig
416 | 


--------------------------------------------------------------------------------