Add application file

TwoDimEnv.py

@@ -0,0 +1,94 @@
+import gymnasium as gym
+from params import *
+
+
+class TwoDimEnv(gym.Env):
+    """
+  Custom 2D-Environment that follows gym interface.
+  This is a simple 2D-env where the agent must go to the 0,0 point,
+  it can go right or straight in a continuous action space, but cannot change speed
+  """
+    def __init__(self):
+        super(TwoDimEnv, self).__init__()
+
+        # agent cannot be further away from target than space_limits
+        self.space_limits = SPACE_LIMITS
+
+        # Initialize the agent position
+        rho_init = np.random.random() * SPACE_LIMITS
+        theta_init = np.random.random() * 2 * PI - PI
+        self.rho_init, self.theta_init, self.z_init = rho_init, theta_init, Z_INIT
+        self.agent_pos = rho_init * np.exp(1j * theta_init)
+        self.agent_z = Z_INIT
+
+        # agent abs speed is constant, may change of direction on the plane, but doesnt change in the z-axis
+        self.agent_speed = SPEED_RHO * np.exp(1j*SPEED_ANGLE)
+        self.agent_speed_z = SPEED_Z
+        self.agent_max_angle = MAX_ANGLE
+
+        #
+        self.agent_previous_pos = self.agent_pos
+
+
+    def reset(self, training=True, rho_init=RHO_INIT, theta_init=THETA_INIT, z_init=Z_INIT):
+        """
+    :input: TwoDimEnv
+    :return: TwoDimEnv
+    """
+        # Initialize the agent position and speed
+        self.agent_pos = rho_init * np.exp(1j * theta_init)
+        self.agent_speed = SPEED_RHO * np.exp(1j * SPEED_ANGLE)
+        self.agent_z = z_init
+
+        # init step index
+        self.step_index = 0
+
+        return self.get_obs()
+
+    def step(self, action):
+        '''
+        the Gym step
+        :param action:
+        :return:
+        '''
+
+        self.step_index += 1
+
+        # Agent changes of direction according to its action: action[0] in [-1; 1]
+        self.agent_speed *= np.exp(1j * self.agent_max_angle * action[0], dtype=complex)
+        self.agent_previous_pos = self.agent_pos
+        self.agent_pos += self.agent_speed
+        self.agent_z -= self.agent_speed_z
+
+        # Are we done?
+        done = bool(self.agent_z <= 0)
+
+        # get normalized obs
+        obs = self.get_obs()
+
+        return obs, 0., done, {}
+
+    def render(self, **kwargs):
+        pass
+
+    def close(self):
+        pass
+
+    # calculates normalized obs
+    def get_obs(self):
+        '''
+        normalises the observation
+        :return: normalised observation
+        '''
+        agent_dist = np.abs(self.agent_pos) / self.space_limits
+        agent_angle = np.angle(self.agent_pos) / (2 * PI)
+        if agent_angle < 0:
+            agent_angle += 1
+        agent_speed = np.angle(self.agent_speed) / (2 * PI)
+        if agent_speed < 0:
+            agent_speed += 1
+        agent_z = (Z_INIT-self.agent_z) / Z_INIT
+        obs = np.array([agent_dist, agent_angle, agent_speed, agent_z]).astype(np.float32)
+        return obs
+
+

app.py

@@ -0,0 +1,181 @@
+import time
+import streamlit as st
+from params import *
+from stable_baselines3 import SAC
+import pandas as pd
+import pydeck as pdk
+from TwoDimEnv import TwoDimEnv
+
+import gymnasium as gym
+
+def run_episode(env, model, lat_tg, lon_tg, rho_init=RHO_INIT, theta_init=THETA_INIT, zed=Z_INIT):
+    '''
+    runs the episode given an observation init ... and an env and a model
+    :param env: TwoDimEnv
+    :param model:
+    :param lat_tg:  lattitude de la target (0,0)
+    :param lon_tg: longitude de la target (0,0)
+    :param rho_init:
+    :param theta_init:
+    :param zed:
+    :return:
+    '''
+    obs = env.reset(training=False, rho_init=rho_init, theta_init=theta_init, z_init=zed)
+    step = 0
+    lat, lon = rhotheta_to_latlon(MOVE_TO_METERS * rho_init, theta_init, lat_tg, lon_tg)
+    path = [[lon, lat, MOVE_TO_METERS * zed]]
+    traj = [lat, lon, MOVE_TO_METERS * zed]
+    while step < zed:
+        step += 1
+        action, _ = model.predict(obs, deterministic=True)
+        obs, _, _, _ = env.step(action)
+        rho = obs[0] * env.space_limits
+        theta = obs[1] * 2 * PI
+        lat, lon = rhotheta_to_latlon(MOVE_TO_METERS*rho, theta, lat_tg, lon_tg)
+        traj = np.vstack((traj, [lat, lon, MOVE_TO_METERS*(zed - step)]))
+        path.append([lon, lat, MOVE_TO_METERS*(zed - step)])
+    df_col = pd.DataFrame(traj, columns=['lat', 'lon', 'zed'])
+    df_path = pd.DataFrame([{
+        'color': [0, 0, 200, 120],
+        'path': path
+    }])
+    return df_path, df_col
+
+def rhotheta_to_latlon(rho, theta, lat_tg, lon_tg):
+    '''
+    transforms polar coordinates into lat, lon
+    :param rho:
+    :param theta:
+    :param lat_tg: latitude de la target (0,0)
+    :param lon_tg: longitude de la target (0,0)
+    :return:
+    '''
+    z = rho * np.exp(1j * theta)
+    lat = np.imag(z)*360/(40075*1000) + lat_tg
+    lon = np.real(z)*360/(40075*1000*np.cos(PI/180*lat)) + lon_tg
+    return lat, lon
+
+
+def get_layers(df, df_past, df_target, df_path, df_col):
+    '''
+    renders the layers to be displayed with df in different formats as entries
+    :param df:
+    :param df_past:
+    :param df_target:
+    :param df_path:
+    :param df_col:
+    :return:
+    '''
+    return [
+        pdk.Layer(
+            'ScatterplotLayer',
+            data=df,
+            get_position='[lon, lat]',
+            get_color='[200, 30, 0, 160, 40]',
+            get_radius=10,
+        ),
+        pdk.Layer(
+            'ScatterplotLayer',
+            data=df_target,
+            get_position='[lon, lat]',
+            get_color='[200, 30, 0]',
+            get_radius=65,
+        ),
+        pdk.Layer(
+            'ScatterplotLayer',
+            data=df_target,
+            get_position='[lon, lat]',
+            get_color='[255, 255, 255]',
+            get_radius=45,
+        ),
+        pdk.Layer(
+            'ScatterplotLayer',
+            data=df_target,
+            get_position='[lon, lat]',
+            get_color='[0, 0, 200]',
+            get_radius=25,
+        ),
+        pdk.Layer(
+            'ScatterplotLayer',
+            data=df_past,
+            get_position='[lon, lat]',
+            get_color='[200, 30, 0, 40]',
+            get_radius=10,
+        ),
+        pdk.Layer(
+            type="PathLayer",
+            data=df_path,
+            pickable=True,
+            get_color="color",
+            width_scale=20,
+            width_min_pixels=1,
+            get_path="path",
+            get_width=1,
+        ),
+        pdk.Layer(
+            type="ColumnLayer",
+            data=df_col,
+            get_position=['lon', 'lat'],
+            get_elevation="zed",
+            elevation_scale=1,
+            radius=10,
+            get_fill_color=[160, 20, 0, 10],
+            pickable=True,
+            auto_highlight=True
+        ),
+    ]
+
+
+def show():
+    '''
+    shows the i-PADS in Streamlit
+    :return:
+    '''
+    env = TwoDimEnv()
+    model = SAC.load("longModel")
+    st.title('Intelligent PADS by hexamind')
+    st.write('This is a quick demo of an autonomous Parachute (Precision Air Delivery System) controlled by Reinforcement learning. ')
+    st.text('<- Set the starting point')
+
+    st.sidebar.write("Where do you want the parachute to start from?")
+    rho = st.sidebar.slider('What distance? (in m)', 0, 3000, 1500) / MOVE_TO_METERS
+    theta = 2*PI/360 * st.sidebar.slider('What angle?', 0, 360, 90)
+    zed = int(st.sidebar.slider('What elevation? (in m)', 0, 1200, 600) / MOVE_TO_METERS)
+
+    location = st.sidebar.radio("Location", ['San Francisco', 'Paris', 'Puilaurens'])
+    lat_tg = LOC[location]['lat']
+    lon_tg = LOC[location]['lon']
+    df_path, df_col = run_episode(env, model, lat_tg, lon_tg, rho_init=rho, theta_init=theta, zed=zed)
+    st.sidebar.write(
+        'If you like to play, you will probably find some starting points where the parachute is out of control :) '
+        'No worries, we have plenty more efficient models at www.hexamind.com ')
+
+    df_target = pd.DataFrame({'lat': [lat_tg], 'lon': [lon_tg]})
+    deck_map = st.empty()
+    pitch = st.slider('pitch', 0, 100, 50)
+    initial_view_state = pdk.ViewState(
+            latitude=lat_tg,
+            longitude=lon_tg,
+            zoom=12,
+            pitch=pitch
+    )
+    deck_map.pydeck_chart(pdk.Deck(
+        map_style='mapbox://styles/mapbox/light-v9',
+        initial_view_state=initial_view_state
+    ))
+    df_pathi = df_path.copy()
+    for i in range(zed):
+        df_pathi['path'][0] = df_path['path'][0][0:i+1]
+        layers = get_layers(df_col[i:i+1], df_col[0:i], df_target, df_pathi, df_col[0:i+1])
+        deck_map.pydeck_chart(pdk.Deck(
+            map_style='mapbox://styles/mapbox/light-v9',
+            initial_view_state=initial_view_state,
+            layers=layers
+        ))
+        time.sleep(TIMESLEEP)
+
+
+show()
+
+# to uncomment for debug
+#show_print()

longModel.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70dc33275fa1df891ec4b106e71b63c2b8ad3f9ebd7728352d7ddfff1e0e895d
+size 3018346

params.py

@@ -0,0 +1,33 @@
+import numpy as np
+
+PI = np.float32(np.pi)
+
+EPISODE_LENGTH = 100  # number of steps per episode
+
+SPACE_LIMITS = 250  # playground limits for the PADS
+LANDING_LIMITS = 10  # error tolerated for landing
+LANDING_TARGET = 50  # error tolerated for the target when landing
+
+RHO_INIT = 10  # default para's 2D position
+THETA_INIT = PI / 2
+Z_INIT = 100  #
+
+SPEED_RHO = 5  # units forward per step
+SPEED_ANGLE = 0
+SPEED_Z = 1  # units down per step
+
+MOVE_TO_METERS = 8  # how many meters (down or horizontally) per unit in a step
+
+MAX_ANGLE = PI / 3
+
+LOC = {'Paris':
+           {'lat': 48.865879, 'lon': 2.319827},
+       'Fonsorbes':
+           {'lat': 43.54, 'lon': 1.25},
+       'San Francisco':
+           {'lat': 37.7737283, 'lon': -122.4342383},
+       'Puilaurens':
+           {'lat': 42.8119596, 'lon': 2.2590985},
+       }
+
+TIMESLEEP = 0.2

requirements.txt

@@ -0,0 +1,60 @@
+altair==4.2.2
+attrs==23.1.0
+blinker==1.6.2
+cachetools==5.3.1
+certifi==2023.5.7
+charset-normalizer==3.1.0
+click==8.1.3
+cloudpickle==2.2.1
+contourpy==1.0.6
+cycler==0.11.0
+decorator==5.1.1
+entrypoints==0.4
+fonttools==4.38.0
+gitdb==4.0.10
+GitPython==3.1.31
+gym==0.21.0
+gymnasium==0.28.1
+gym-notices==0.0.8
+idna==3.4
+importlib-metadata==4.13.0
+Jinja2==3.1.2
+jsonschema==4.17.3
+kiwisolver==1.4.4
+markdown-it-py==2.1.0
+MarkupSafe==2.1.2
+matplotlib==3.5.3
+mdurl==0.1.2
+numpy==1.21.6
+packaging==23.0
+pandas==1.3.5
+Pillow==9.5.0
+protobuf==3.20.3
+pyarrow==12.0.0
+pydeck==0.8.1b0
+Pygments==2.15.1
+Pympler==1.0.1
+pyparsing==3.0.9
+pyrsistent==0.19.3
+python-dateutil==2.8.2
+pytz==2022.7.1
+pytz-deprecation-shim==0.1.0.post0
+requests==2.28.2
+rich==13.2.0
+semver==2.13.0
+six==1.16.0
+smmap==5.0.0
+setuptools==66.0.0
+stable-baselines3==1.7.0
+streamlit==1.22.0
+tenacity==8.2.2
+toml==0.10.2
+toolz==0.12.0
+torch==1.13.1
+tornado==6.2
+typing_extensions==4.4.0
+tzdata==2022.7
+tzlocal==4.2
+urllib3==1.26.16
+validators==0.20.0
+zipp==3.11.0