diff --git a/scratch/johannes/evaluation.py b/scratch/johannes/evaluation.py
new file mode 100644
index 0000000..67fec87
--- /dev/null
+++ b/scratch/johannes/evaluation.py
@@ -0,0 +1,90 @@
+
+def evaluate_policy_simple(
+    model,
+    env: gym.Env,
+    n_eval_episodes: int = 10,
+    deterministic: bool = True,
+    render: bool = False,
+    callback = None,
+    reward_threshold = None,
+    return_episode_rewards: bool = False,
+    warn: bool = True,
+):
+    """
+    Runs policy for ``n_eval_episodes`` episodes and returns average reward.
+    If a vector env is passed in, this divides the episodes to evaluate onto the
+    different elements of the vector env. This static division of work is done to
+    remove bias. See https://github.com/DLR-RM/stable-baselines3/issues/402 for more
+    details and discussion.
+
+    .. note::
+        If environment has not been wrapped with ``Monitor`` wrapper, reward and
+        episode lengths are counted as it appears with ``env.step`` calls. If
+        the environment contains wrappers that modify rewards or episode lengths
+        (e.g. reward scaling, early episode reset), these will affect the evaluation
+        results as well. You can avoid this by wrapping environment with ``Monitor``
+        wrapper before anything else.
+
+    :param model: The RL agent you want to evaluate.
+    :param env: The gym environment or ``VecEnv`` environment.
+    :param n_eval_episodes: Number of episode to evaluate the agent
+    :param deterministic: Whether to use deterministic or stochastic actions
+    :param render: Whether to render the environment or not
+    :param callback: callback function to do additional checks,
+        called after each step. Gets locals() and globals() passed as parameters.
+    :param reward_threshold: Minimum expected reward per episode,
+        this will raise an error if the performance is not met
+    :param return_episode_rewards: If True, a list of rewards and episode lengths
+        per episode will be returned instead of the mean.
+    :param warn: If True (default), warns user about lack of a Monitor wrapper in the
+        evaluation environment.
+    :return: Mean reward per episode, std of reward per episode.
+        Returns ([float], [int]) when ``return_episode_rewards`` is True, first
+        list containing per-episode rewards and second containing per-episode lengths
+        (in number of steps).
+    """
+    episode_rewards = []
+    episode_lengths = []
+
+    episode_counts = 0
+
+    current_rewards = 0
+    current_lengths = 0
+    observations = env.reset()
+    states = None
+    while (episode_counts < n_eval_episodes):
+        actions, states = model.predict(observations, state=states, deterministic=deterministic)
+        observations, rewards, dones, infos = env.step(actions)
+        print(env._env.t)
+        current_rewards += rewards
+        current_lengths += 1
+
+        # unpack values so that the callback can access the local variables
+        reward = rewards
+        done = dones
+        info = infos
+        if info['collision']:
+            print("COLLISION")
+
+        if callback is not None:
+            callback(locals(), globals())
+
+        if dones:
+            episode_rewards.append(current_rewards)
+            episode_lengths.append(current_lengths)
+            episode_counts += 1
+            current_rewards = 0
+            current_lengths = 0
+            if states is not None:
+                states *= 0
+
+        if render:
+            env.render()
+
+    mean_reward = np.mean(episode_rewards)
+    std_reward = np.std(episode_rewards)
+    if reward_threshold is not None:
+        assert mean_reward > reward_threshold, "Mean reward below threshold: " f"{mean_reward:.2f} < {reward_threshold:.2f}"
+    if return_episode_rewards:
+        return episode_rewards, episode_lengths
+    return mean_reward, std_reward
diff --git a/scratch/johannes/raytune_simple.py b/scratch/johannes/raytune_simple.py
new file mode 100644
index 0000000..5979c11
--- /dev/null
+++ b/scratch/johannes/raytune_simple.py
@@ -0,0 +1,69 @@
+"""This example demonstrates basic Ray Tune random search and grid search."""
+import time
+
+import ray
+from ray import tune
+
+
+def evaluation_fn(step, width, height):
+    time.sleep(0.1)
+    return (0.1 + width * step / 100)**(-1) + height * 0.1
+
+def easy_objective(config):
+    # Hyperparameters
+    width, height = config["width"], config["height"]
+
+    mydata = ray.get(ray_data)
+    print(mydata)
+
+    for step in range(config["steps"]):
+        # Iterative training function - can be any arbitrary training procedure
+        intermediate_score = evaluation_fn(step, width, height)
+        # Feed the score back back to Tune.
+        tune.report(iterations=step, mean_loss=intermediate_score)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--smoke-test", action="store_true", help="Finish quickly for testing")
+    parser.add_argument(
+        "--server-address",
+        type=str,
+        default=None,
+        required=False,
+        help="The address of server to connect to if using "
+        "Ray Client.")
+    args, _ = parser.parse_known_args()
+    if args.server_address is not None:
+        ray.init(f"ray://{args.server_address}")
+    else:
+        ray.init(configure_logging=False)
+
+    # This will do a grid search over the `activation` parameter. This means
+    # that each of the two values (`relu` and `tanh`) will be sampled once
+    # for each sample (`num_samples`). We end up with 2 * 50 = 100 samples.
+    # The `width` and `height` parameters are sampled randomly.
+    # `steps` is a constant parameter.
+
+    import numpy as np
+    N = 3
+    data = np.random.rand(N,N,N)
+    ray_data = ray.put(data)
+
+
+    analysis = tune.run(
+        easy_objective,
+        metric="mean_loss",
+        mode="min",
+        num_samples=5 if args.smoke_test else 50,
+        config={
+            "steps": 5 if args.smoke_test else 100,
+            "width": tune.uniform(0, 20),
+            "height": tune.uniform(-100, 100),
+            "activation": tune.grid_search(["relu", "tanh"])
+        })
+
+    print("Best hyperparameters found were: ", analysis.best_config)
\ No newline at end of file