ino

Initialization of numerical optimization

https://github.com/loelschlaeger/ino

Keywords

Repository

Initialization of numerical optimization

README.Rmd

---
output: github_document
---



```{r setup, include = FALSE}
knitr::opts_chunk$set(
  collapse = TRUE,
  comment = "#>",
  fig.path = "man/figures/README-",
  out.width = "70%",
  message = FALSE,
  warning = FALSE
)
```

# Initialization of numerical optimization 


[![CRAN status](https://www.r-pkg.org/badges/version/ino)](https://CRAN.R-project.org/package=ino)
[![CRAN downloads](https://cranlogs.r-pkg.org/badges/grand-total/ino)](https://CRAN.R-project.org/package=ino)
[![R-CMD-check](https://github.com/loelschlaeger/ino/workflows/R-CMD-check/badge.svg)](https://github.com/loelschlaeger/ino/actions)
[![Codecov test coverage](https://codecov.io/gh/loelschlaeger/ino/branch/master/graph/badge.svg)](https://app.codecov.io/gh/loelschlaeger/ino?branch=master)


The `{ino}` R package provides a framework for analyzing the role of initialization in numerical optimization. It allows for systematic comparisons of different initialization strategies and optimization algorithms using a unified `R6` object called [`Nop`](https://loelschlaeger.de/ino/reference/Nop.html). For detailed examples and usage guidance, please have a look at the [package vignettes](https://loelschlaeger.de/ino/articles/).

## Installation

You can install the released version from [CRAN](https://CRAN.R-project.org) with:

```{r install_released}
install.packages("ino")
```

## Example

The [Ackley function](https://en.wikipedia.org/wiki/Ackley_function) has multiple local minima and one global minimum at the origin. We define 

1. the numerical optimization problem as a `Nop` object, 
2. two optimization algorithms `stats::nlm()` and `stats::optim()`, and 
3. 40 randomly drawn initial values:

```{r ackley_definition}
library("ino")
set.seed(1)
Nop_ackley <- Nop$new(f = TestFunctions::TF_ackley, npar = 2)$
  set_optimizer(optimizeR::Optimizer$new("stats::nlm"))$
  set_optimizer(optimizeR::Optimizer$new("stats::optim"))$
  initialize_random(runs = 40)
```

We can visualize the function surface along with the initial values:

```{r ackley_plot}
library("ggplot2")
Nop_ackley |> autoplot()
```

Next, we optimize the function via the previously defined initial values and optimizers:

```{r ackley_optimize}
Nop_ackley$optimize()
```

In this example, `stats::nlm()` appears to be both faster...

```{r ackley_time}
Nop_ackley$results |> 
  ggplot2::autoplot("seconds", group_by = "optimizer", relative = TRUE) +
  ggplot2::scale_x_continuous(labels = scales::percent_format()) +
  ggplot2::labs(
    "x" = "optimization time relative to overall median",
    "y" = "optimizer"
  )
```

... and more effective at locating the global minimum:

```{r ackley_optima}
Nop_ackley$optima(digits = 2, group_by = "optimizer")
```

Overall, (only) `r Nop_ackley$optima(digits = 2) |> dplyr::filter(value == 0) |> dplyr::select(n) |> dplyr::slice(1) |> as.numeric()`% of of the initializations successfully converged to the global minimum.

## Contact

Have a question, found a bug, request a feature, want to contribute? [Please file an issue](https://github.com/loelschlaeger/ino/issues/new/choose).

## Related R packages

- The [{trackopt} package](https://CRAN.R-project.org/package=trackopt) tracks parameter value, gradient, and Hessian at each iteration of numerical optimizers in R. This can be useful for analyzing optimization progress, diagnosing issues, and studying convergence behavior.

- The [{optimizeR} package](https://CRAN.R-project.org/package=optimizeR) provides a unified object-oriented framework for numerical optimizers in R. Allows for both minimization and maximization with any optimizer, optimization over more than one function argument, measuring of computation time, setting a time limit for long optimization tasks.

- The [{ao} package](https://CRAN.R-project.org/package=ao) implements an iterative process that optimizes a function by alternately performing restricted optimization over parameter subsets. Instead of joint optimization, it breaks the optimization problem down into simpler sub-problems. This approach can make optimization feasible when joint optimization is too difficult.

Owner

GitHub Events

Packages