bsmart.scans.MLScanner.MLS_SVR_RBF

! MLScanner SVR_RBF method ————————

MLScanner method MLS_SVR_RBF based on code from

• https://github.com/AHamamd150/MLscanner

• https://arxiv.org/abs/2207.09959

This scan implements an active learning strategy using a Support Vector Regressor (SVR) with a Radial Basis Function (RBF) kernel to efficiently find “good” points in a parameter space. A point is considered “good” if its Negative Log Likelihood (NLL) is below a specified threshold.

The process is as follows:

1. Initialization: The scan begins by evaluating a small set of randomly generated points (Bootstrap_Points). It can also load an initial dataset from a CSV file (InitCSV).

2. Initial Training: An SVR model (RBF kernel) is trained on this initial dataset to predict the Negative Log Likelihood (NLL) from the input parameters.

3. Active Learning Loop: The scan enters a loop to iteratively discover new good points until a Target_Points count is reached. In each iteration:

   1. A large number of Candidate_Points are randomly generated.

   2. The trained SVR model predicts the NLL for these candidates.

   3. candidates with the lowest predicted NLL (best quality), plus a small Random_Fraction, are selected for evaluation by the physics code.

   4. Retraining: The SVR is retrained with the newly discovered points, becoming progressively better at identifying promising regions (low NLL).

4. Data Collection: All discovered good points (NLL < Threshold) are returned.

This method is particularly effective for high-dimensional parameter spaces where exhaustive scanning is computationally prohibitive. !

Information

BSMArt Name: MLS_SVR_RBF

Requires:

• sklearn

• pandas

• numpy

Settings:

Networks

• Iterations: Number of active learning iterations (default: 10).

• Candidate_Points: Number of candidate points to generate and score in each iteration (default: 500).

• Bootstrap_Points: Number of initial random points to evaluate (default: 100).

• Points_Per_Iteration: Number of candidate points to evaluate in each iteration (default: 300).

• Threshold_Value: The threshold for the NLL to classify a point as ‘good’ (default: 1).

• Random_Fraction: Fraction of points per iteration to be selected randomly, for exploration (default: 0.2).

• C: Regularization parameter (default: 100).

• Gamma: Kernel coefficient (default: 0.1).

• Epsilon: Epsilon-tube within which no penalty is associated in the training loss function (default: 0.1).

• Verbose: Verbosity level (default: 0).

Setup

• InitCSV: Path to an optional CSV file with initial points to seed the scan.

• Points: Number of points to generate in total before stopping (default: 1000)

class bsmart.scans.MLScanner.MLS_SVR_RBF.NewScan(inputs, log)

Bases: Scan

extract_from_valid_points(valid_points)

get_losses(observables)

Returns a list of losses.

initialise()

Need to make sure we override certain settings

postprocess(Point, observables, data_point, temp_dir, log, lock=None)

return the likelihood; we won’t get this far if the point failed to be generated

run()

smooth_cap_loss(x)

Caps the loss by applying a sigmoid. This is useful for losses that are unbounded.

bsmart.scans.MLScanner.MLS_SVR_RBF.generate_param_points(inputs, num_points)