Improve readme, fix broken link, make slimmer

README.md

@@ -7,59 +7,60 @@
 
 Welcome to NePS, a powerful and flexible Python library for hyperparameter optimization (HPO) and neural architecture search (NAS) with its primary goal: enable HPO and NAS for deep learners!
 
-NePS houses recently published and well-established algorithms that can all be run massively parallel on distributed setups, with tools to analyze runs, restart runs, etc., all tailored to the needs of deep learning experts.
+NePS houses recently published and also well-established algorithms that can all be run massively parallel on distributed setups, with tools to analyze runs, restart runs, etc., all tailored to the needs of deep learning experts.
 
 Take a look at our [documentation](https://automl.github.io/neps/latest/) for all the details on how to use NePS!
 
-
 ## Key Features
 
-In addition to the common features offered by traditional HPO and NAS libraries, NePS stands out with:
+In addition to the features offered by traditional HPO and NAS libraries, NePS, e.g., stands out with:
 
 1. [**Hyperparameter Optimization (HPO) With Prior Knowledge:**](neps_examples/template/priorband_template.py)
-    - NePS excels in efficiently tuning hyperparameters using algorithms that enable users to make use of their prior knowledge within the search space. This is leveraged by the insights presented in:
-        - [PriorBand: Practical Hyperparameter Optimization in the Age of Deep Learning](https://arxiv.org/abs/2306.12370)
-        - [πBO: Augmenting Acquisition Functions with User Beliefs for Bayesian Optimization](https://arxiv.org/abs/2204.11051)
 
-2. [**Neural Architecture Search (NAS) With Context-free Grammar Search Spaces:**](neps_examples/basic_usage/architecture.py)
-    - NePS is equipped to handle context-free grammar search spaces, providing advanced capabilities for designing and optimizing architectures. this is leveraged by the insights presented in:
-        - [Construction of Hierarchical Neural Architecture Search Spaces based on Context-free Grammars](https://arxiv.org/abs/2211.01842)
+   - NePS excels in efficiently tuning hyperparameters using algorithms that enable users to make use of their prior knowledge within the search space. This is leveraged by the insights presented in:
+     - [PriorBand: Practical Hyperparameter Optimization in the Age of Deep Learning](https://arxiv.org/abs/2306.12370)
+     - [πBO: Augmenting Acquisition Functions with User Beliefs for Bayesian Optimization](https://arxiv.org/abs/2204.11051)
+
+1. [**Neural Architecture Search (NAS) With Context-free Grammar Search Spaces:**](neps_examples/basic_usage/architecture.py)
+
+   - NePS is equipped to handle context-free grammar search spaces, providing advanced capabilities for designing and optimizing architectures. this is leveraged by the insights presented in:
+     - [Construction of Hierarchical Neural Architecture Search Spaces based on Context-free Grammars](https://arxiv.org/abs/2211.01842)
+
+1. [**Easy Parallelization and Resumption of Runs:**](https://automl.github.io/neps/latest/examples/efficiency/)
 
-3. [**Easy Parallelization and Resumption of Runs:**](docs/parallelization.md)
-      - NePS simplifies the process of parallelizing optimization tasks both on individual computers and in distributed
-   computing environments. It also allows users to conveniently resume these optimization tasks after completion to
-   ensure a seamless and efficient workflow for long-running experiments.
+   - NePS simplifies the process of parallelizing optimization tasks both on individual computers and in distributed
+     computing environments. It also allows users to conveniently resume these optimization tasks after completion to
+     ensure a seamless and efficient workflow for long-running experiments.
 
-4. [**Seamless User Code Integration:**](neps_examples/template/)
-    - NePS's modular design ensures flexibility and extensibility. Integrate NePS effortlessly into existing machine learning workflows.
+1. [**Seamless User Code Integration:**](neps_examples/template/)
 
-## Getting Started
+   - NePS's modular design ensures flexibility and extensibility. Integrate NePS effortlessly into existing machine learning workflows.
 
-### 1. Installation
-NePS requires Python 3.8 or higher. You can install it via pip or from source.
+## Installation
+
+To install the latest release from PyPI run
 
-Using pip:
 ```bash
 pip install neural-pipeline-search
 ```
 
-> Note: As indicated with the `v0.x.x` version number, NePS is early stage code and APIs might change in the future.
+To get the latest version from github run
 
-You can install from source by cloning the repository and running:
 ```bash
-git clone [email protected]:automl/neps.git
-cd neps
-poetry install
+pip install git+https://github.com/automl/neps.git
 ```
 
-### 2. Basic Usage
+> Note: As indicated with the `v0.x.x` version number APIs will change in the future.
+
+
+## Basic Usage
 
 Using `neps` always follows the same pattern:
 
 1. Define a `run_pipeline` function capable of evaluating different architectural and/or hyperparameter configurations
    for your problem.
-2. Define a search space named `pipeline_space` of those Parameters e.g. via a dictionary
-3. Call `neps.run` to optimize `run_pipeline` over `pipeline_space`
+1. Define a search space named `pipeline_space` of those Parameters e.g. via a dictionary
+1. Call `neps.run` to optimize `run_pipeline` over `pipeline_space`
 
 In code, the usage pattern can look like this:
 
@@ -112,15 +113,16 @@ neps.run(
 ## Examples
 
 Discover how NePS works through these practical examples:
-* **[Hyperparameter Optimization (HPO)](neps_examples/basic_usage/hyperparameters.py)**: Learn the essentials of hyperparameter optimization with NePS.
 
-* **[Architecture Search with Primitives](neps_examples/basic_usage/architecture.py)**: Dive into architecture search using primitives in NePS.
+- **[Hyperparameter Optimization (HPO)](neps_examples/basic_usage/hyperparameters.py)**: Learn the essentials of hyperparameter optimization with NePS.
+
+- **[Architecture Search with Primitives](neps_examples/basic_usage/architecture.py)**: Dive into architecture search using primitives in NePS.
 
-* **[Multi-Fidelity Optimization](neps_examples/efficiency/multi_fidelity.py)**: Understand how to leverage multi-fidelity optimization for efficient model tuning.
+- **[Multi-Fidelity Optimization](neps_examples/efficiency/multi_fidelity.py)**: Understand how to leverage multi-fidelity optimization for efficient model tuning.
 
-* **[Utilizing Expert Priors for Hyperparameters](neps_examples/efficiency/expert_priors_for_hyperparameters.py)**: Learn how to incorporate expert priors for more efficient hyperparameter selection.
+- **[Utilizing Expert Priors for Hyperparameters](neps_examples/efficiency/expert_priors_for_hyperparameters.py)**: Learn how to incorporate expert priors for more efficient hyperparameter selection.
 
-* **[Additional NePS Examples](neps_examples/)**: Explore more examples, including various use cases and advanced configurations in NePS.
+- **[Additional NePS Examples](neps_examples/)**: Explore more examples, including various use cases and advanced configurations in NePS.
 
 ## Contributing