jijzepttools.blackbox_optimization

jijzepttools.blackbox_optimization#

Submodules#

Classes#

`BOCSWorkflow`
`FactorizationMachine`	Factorization Machine model
`FMTrainer`
`FMOWorkflow`
`SparseBayesianLinearRegression`
`BlackboxOptimizationWorkflow`

Package Contents#

class BOCSWorkflow(random_seed: int | None = None, coef_mean=True, flip_postprocess4uniq: bool = False)#

Bases: jijzepttools.blackbox_optimization.workflow.BlackboxOptimizationWorkflow

sbr#

coef_mean = True#

create_quadratic_terms(x: numpy.ndarray) → numpy.ndarray#

train(state)#

generate_instance(state) → tuple[dict, float]#

run(x: numpy.ndarray, y: numpy.ndarray, blackbox_func: Callable, solver: Callable, n_iter: int, draws: int = 1, tune: int = 1)#

class FactorizationMachine(n_features: int, latent_dim: int)#

Bases: torch.nn.Module

Factorization Machine model

`math f(x|w, v) = w0 + Σwi*xi + ΣΣ<vj, vk>xj*xk = w0 + Σwi*xi + 1/2*(Σ(vi*xi)^2 - Σ(vi^2*xi^2)) `

n_features#

latent_dim#

linear#

quad#

forward(x)#

property v#

property w#

property w0#

class FMTrainer(n_features: int, latent_dim: int, optimizer_params: dict | None = None)#

model#

fit(x_numpy: numpy.ndarray, y_numpy: numpy.ndarray, n_epochs: int)#

predict(x: torch.Tensor) → torch.Tensor#

property x#

property y#

get_qubo() → tuple[numpy.ndarray, float]#

class FMOWorkflow(n_features, latent_dim, optimizer_params: dict | None = None, flip_postprocess4uniq: bool = False)#

Bases: jijzepttools.blackbox_optimization.workflow.BlackboxOptimizationWorkflow

fm_trainer#

train(state)#

generate_instance(state) → tuple[numpy.ndarray, float]#

run(x: numpy.ndarray, y: numpy.ndarray, blackbox_func: Callable, solver: Callable, n_iter: int, n_epochs: int)#

class SparseBayesianLinearRegression(random_seed: int | None = None)#

rs#

trace: list[Trace] = []#

fit(x: numpy.ndarray, y: numpy.ndarray, draws: int = 10, tune: int = 100)#

class BlackboxOptimizationWorkflow(flip_postprocess4uniq: bool = False)#

workflow#

train(state: BlackboxState) → None#

generate_instance(state: BlackboxState)#

solve(instance)#

run_blackbox(state: BlackboxState, x)#

flip_postprocess4uniq(state: BlackboxState, new_x: numpy.ndarray)#

check_iter(state: BlackboxState)#

run(x: numpy.ndarray, y: numpy.ndarray, blackbox_func: Callable, solver: Callable, n_iter: int, **params)#