revert README changes, keep example and docs only

Author: Abhishek

README.md

@@ -114,8 +114,8 @@ pip install hyperactive[all_extras]           # Everything including Optuna
       <sub>GFO algorithms, Optuna samplers, and sklearn search methods through one unified API.</sub>
     </td>
     <td width="33%">
-      <a href="https://hyperactive.readthedocs.io/en/latest/examples.html"><b>Problems & Experiments</b></a><br>
-      <sub>Toy optimization problems as well as AI/ML benchmarking experiments for evaluation and testing.</sub>
+      <a href="https://hyperactive.readthedocs.io/en/latest/api_reference.html"><b>Stable & Tested</b></a><br>
+      <sub>5+ years of development, comprehensive test coverage, and active maintenance since 2019.</sub>
     </td>
   </tr>
 </table>

examples/integrations/README.md

@@ -1,7 +1,7 @@
 # Integrations with AI framework toolboxes
 
 This directory contains examples for estimator level integration with
-common AI toolbox libraries such as `scikit-learn`, `sktime`, or `torch`.
+common AI toolbox libraries such as `scikit-learn` or `sktime`.
 
 ## Quick Start
 
@@ -12,10 +12,9 @@ You can also run any example directly:
 python sklearn_classif_example.py
 python sktime_forecasting_example.py
 python sktime_tsc_example.py
-python torch_experiment_example.py
 ```
 
-Requires `scikit-learn` resp `sktime` resp `torch` and `lightning` installed.
+Requires `scikit-learn` resp `sktime` installed.
 
 ## Available Integrations
 
@@ -24,7 +23,6 @@ Requires `scikit-learn` resp `sktime` resp `torch` and `lightning` installed.
 | `sklearn` classifier or regressor tuner | [OptCV](sklearn_classif_example.py) |
 | `sktime` forecasting tuner | [ForecastingOptCV](sktime_forecasting_example.py) |
 | `sktime` time series classifier tuner | [TSCOptCV](sktime_tsc_example.py) |
-| `torch` experiment tuner | [TorchExperiment](torch_experiment_example.py) |
 
 ## Integration with sklearn
 
@@ -145,100 +143,3 @@ y_pred = tuned_naive.predict(X_test)
 best_params = tuned_naive.best_params_
 best_classifier = tuned_naive.best_estimator_
 ```
-
-## Integration with torch
-
-Any available tuning engine from hyperactive can be used, for example:
-
-* hill climbing - ``from hyperactive.opt import HillClimbing``
-* bayesian optimization - ``from hyperactive.opt.gfo import BayesianOptimizer``
-* optuna parzen-tree search - ``from hyperactive.opt.optuna import TPEOptimizer``
-
-For illustration, we use hill climbing, this can be replaced by any other optimizer.
-
-```python
-# 1. defining the experiment:
-import numpy as np
-import lightning as L
-import torch
-from torch import nn
-from torch.utils.data import DataLoader
-
-from hyperactive.experiment.integrations import TorchExperiment
-from hyperactive.opt.gfo import HillClimbing
-
-class SimpleLightningModule(L.LightningModule):
-    def __init__(self, input_dim=10, hidden_dim=16, lr=1e-3):
-        super().__init__()
-        self.save_hyperparameters()
-        self.model = nn.Sequential(
-            nn.Linear(input_dim, hidden_dim), nn.ReLU(),
-            nn.Linear(hidden_dim, 2),
-        )
-        self.lr = lr
-
-    def forward(self, x):
-        return self.model(x)
-
-    def training_step(self, batch, batch_idx):
-        x, y = batch
-        loss = nn.functional.cross_entropy(self(x), y)
-        self.log("train_loss", loss)
-        return loss
-
-    def validation_step(self, batch, batch_idx):
-        x, y = batch
-        val_loss = nn.functional.cross_entropy(self(x), y)
-        self.log("val_loss", val_loss, on_epoch=True)
-        return val_loss
-
-    def configure_optimizers(self):
-        return torch.optim.Adam(self.parameters(), lr=self.lr)
-
-class RandomDataModule(L.LightningDataModule):
-    def __init__(self, batch_size=32):
-        super().__init__()
-        self.batch_size = batch_size
-
-    def setup(self, stage=None):
-        dataset = torch.utils.data.TensorDataset(
-            torch.randn(200, 10), torch.randint(0, 2, (200,)),
-        )
-        self.train, self.val = torch.utils.data.random_split(
-            dataset, [160, 40]
-        )
-
-    def train_dataloader(self):
-        return DataLoader(self.train, batch_size=self.batch_size)
-
-    def val_dataloader(self):
-        return DataLoader(self.val, batch_size=self.batch_size)
-
-# 2. creating the experiment:
-datamodule = RandomDataModule(batch_size=16)
-datamodule.setup()
-
-experiment = TorchExperiment(
-    datamodule=datamodule,
-    lightning_module=SimpleLightningModule,
-    trainer_kwargs={"max_epochs": 3},
-    objective_metric="val_loss",
-)
-
-# 3. defining search space and running optimization:
-search_space = {
-    "hidden_dim": [16, 32, 64, 128],
-    "lr": np.logspace(-4, -1, 10).tolist(),
-}
-
-optimizer = HillClimbing(
-    search_space=search_space,
-    n_iter=5,
-    experiment=experiment,
-)
-best_params = optimizer.solve()
-
-# 4. obtaining best parameters
-print(f"Best params: {best_params}")
-```
-