tensortrade 1.0.0b0__py3-none-any.whl → 1.0.4__py3-none-any.whl

tensortrade/env/generic/components/reward_scheme.py

@@ -1,44 +1,44 @@
-# Copyright 2020 The TensorTrade Authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License
-
-from abc import abstractmethod
-
-from tensortrade.core.component import Component
-from tensortrade.core.base import TimeIndexed
-
-
-class RewardScheme(Component, TimeIndexed):
-    """A component to compute the reward at each step of an episode."""
-
-    registered_name = "rewards"
-
-    @abstractmethod
-    def reward(self, env: 'TradingEnv') -> float:
-        """Computes the reward for the current step of an episode.
-
-        Parameters
-        ----------
-        env : `TradingEnv`
-            The trading environment
-
-        Returns
-        -------
-        float
-            The computed reward.
-        """
-        raise NotImplementedError()
-
-    def reset(self) -> None:
-        """Resets the reward scheme."""
-        pass
+# Copyright 2020 The TensorTrade Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License
+
+from abc import abstractmethod
+
+from tensortrade.core.component import Component
+from tensortrade.core.base import TimeIndexed
+
+
+class RewardScheme(Component, TimeIndexed):
+    """A component to compute the reward at each step of an episode."""
+
+    registered_name = "rewards"
+
+    @abstractmethod
+    def reward(self, env: 'TradingEnv') -> float:
+        """Computes the reward for the current step of an episode.
+
+        Parameters
+        ----------
+        env : `TradingEnv`
+            The trading environment
+
+        Returns
+        -------
+        float
+            The computed reward.
+        """
+        raise NotImplementedError()
+
+    def reset(self) -> None:
+        """Resets the reward scheme."""
+        pass

tensortrade/env/generic/components/stopper.py

@@ -1,46 +1,46 @@
-# Copyright 2020 The TensorTrade Authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License
-
-from abc import abstractmethod
-
-from tensortrade.core.component import Component
-from tensortrade.core.base import TimeIndexed
-
-
-class Stopper(Component, TimeIndexed):
-    """A component for determining if the environment satisfies a defined
-    stopping criteria.
-    """
-
-    registered_name = "stopper"
-
-    @abstractmethod
-    def stop(self, env: 'TradingEnv') -> bool:
-        """Computes if the environment satisfies the defined stopping criteria.
-
-        Parameters
-        ----------
-        env : `TradingEnv`
-            The trading environment.
-
-        Returns
-        -------
-        bool
-            If the environment should stop or continue.
-        """
-        raise NotImplementedError()
-
-    def reset(self) -> None:
-        """Resets the stopper."""
-        pass
+# Copyright 2020 The TensorTrade Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License
+
+from abc import abstractmethod
+
+from tensortrade.core.component import Component
+from tensortrade.core.base import TimeIndexed
+
+
+class Stopper(Component, TimeIndexed):
+    """A component for determining if the environment satisfies a defined
+    stopping criteria.
+    """
+
+    registered_name = "stopper"
+
+    @abstractmethod
+    def stop(self, env: 'TradingEnv') -> bool:
+        """Computes if the environment satisfies the defined stopping criteria.
+
+        Parameters
+        ----------
+        env : `TradingEnv`
+            The trading environment.
+
+        Returns
+        -------
+        bool
+            If the environment should stop or continue.
+        """
+        raise NotImplementedError()
+
+    def reset(self) -> None:
+        """Resets the stopper."""
+        pass

tensortrade/env/generic/environment.py

@@ -1,163 +1,211 @@
-# Copyright 2020 The TensorTrade Authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License
-
-import uuid
-import logging
-
-from typing import Dict, Any, Tuple
-
-import gym
-import numpy as np
-
-from tensortrade.core import TimeIndexed, Clock, Component
-from tensortrade.env.generic import (
-    ActionScheme,
-    RewardScheme,
-    Observer,
-    Stopper,
-    Informer,
-    Renderer
-)
-
-
-class TradingEnv(gym.Env, TimeIndexed):
-    """A trading environment made for use with Gym-compatible reinforcement
-    learning algorithms.
-
-    Parameters
-    ----------
-    action_scheme : `ActionScheme`
-        A component for generating an action to perform at each step of the
-        environment.
-    reward_scheme : `RewardScheme`
-        A component for computing reward after each step of the environment.
-    observer : `Observer`
-        A component for generating observations after each step of the
-        environment.
-    informer : `Informer`
-        A component for providing information after each step of the
-        environment.
-    renderer : `Renderer`
-        A component for rendering the environment.
-    kwargs : keyword arguments
-        Additional keyword arguments needed to create the environment.
-    """
-
-    agent_id: str = None
-    episode_id: str = None
-
-    def __init__(self,
-                 action_scheme: ActionScheme,
-                 reward_scheme: RewardScheme,
-                 observer: Observer,
-                 stopper: Stopper,
-                 informer: Informer,
-                 renderer: Renderer,
-                 **kwargs) -> None:
-        super().__init__()
-        self.clock = Clock()
-
-        self.action_scheme = action_scheme
-        self.reward_scheme = reward_scheme
-        self.observer = observer
-        self.stopper = stopper
-        self.informer = informer
-        self.renderer = renderer
-
-        for c in self.components.values():
-            c.clock = self.clock
-
-        self.action_space = action_scheme.action_space
-        self.observation_space = observer.observation_space
-
-        self._enable_logger = kwargs.get('enable_logger', False)
-        if self._enable_logger:
-            self.logger = logging.getLogger(kwargs.get('logger_name', __name__))
-            self.logger.setLevel(kwargs.get('log_level', logging.DEBUG))
-
-    @property
-    def components(self) -> 'Dict[str, Component]':
-        """The components of the environment. (`Dict[str,Component]`, read-only)"""
-        return {
-            "action_scheme": self.action_scheme,
-            "reward_scheme": self.reward_scheme,
-            "observer": self.observer,
-            "stopper": self.stopper,
-            "informer": self.informer,
-            "renderer": self.renderer
-        }
-
-    def step(self, action: Any) -> 'Tuple[np.array, float, bool, dict]':
-        """Makes on step through the environment.
-
-        Parameters
-        ----------
-        action : Any
-            An action to perform on the environment.
-
-        Returns
-        -------
-        `np.array`
-            The observation of the environment after the action being
-            performed.
-        float
-            The computed reward for performing the action.
-        bool
-            Whether or not the episode is complete.
-        dict
-            The information gathered after completing the step.
-        """
-        self.action_scheme.perform(self, action)
-
-        obs = self.observer.observe(self)
-        reward = self.reward_scheme.reward(self)
-        done = self.stopper.stop(self)
-        info = self.informer.info(self)
-
-        self.clock.increment()
-
-        return obs, reward, done, info
-
-    def reset(self) -> 'np.array':
-        """Resets the environment.
-
-        Returns
-        -------
-        obs : `np.array`
-            The first observation of the environment.
-        """
-        self.episode_id = str(uuid.uuid4())
-        self.clock.reset()
-
-        for c in self.components.values():
-            if hasattr(c, "reset"):
-                c.reset()
-
-        obs = self.observer.observe(self)
-
-        self.clock.increment()
-
-        return obs
-
-    def render(self, **kwargs) -> None:
-        """Renders the environment."""
-        self.renderer.render(self, **kwargs)
-
-    def save(self) -> None:
-        """Saves the rendered view of the environment."""
-        self.renderer.save()
-
-    def close(self) -> None:
-        """Closes the environment."""
-        self.renderer.close()
+# Copyright 2020 The TensorTrade Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License
+
+import uuid
+import logging
+
+from typing import Dict, Any, Tuple, Optional
+from random import randint
+
+import gymnasium
+import numpy as np
+
+from tensortrade.core import TimeIndexed, Clock, Component
+from tensortrade.env.generic import (
+    ActionScheme,
+    RewardScheme,
+    Observer,
+    Stopper,
+    Informer,
+    Renderer
+)
+
+
+class TradingEnv(gymnasium.Env, TimeIndexed):
+    """A trading environment made for use with Gym-compatible reinforcement
+    learning algorithms.
+
+    Parameters
+    ----------
+    action_scheme : `ActionScheme`
+        A component for generating an action to perform at each step of the
+        environment.
+    reward_scheme : `RewardScheme`
+        A component for computing reward after each step of the environment.
+    observer : `Observer`
+        A component for generating observations after each step of the
+        environment.
+    informer : `Informer`
+        A component for providing information after each step of the
+        environment.
+    renderer : `Renderer`
+        A component for rendering the environment.
+    kwargs : keyword arguments
+        Additional keyword arguments needed to create the environment.
+    """
+
+    agent_id: str = None
+    episode_id: str = None
+
+    def __init__(self,
+                 action_scheme: ActionScheme,
+                 reward_scheme: RewardScheme,
+                 observer: Observer,
+                 stopper: Stopper,
+                 informer: Informer,
+                 renderer: Renderer,
+                 min_periods: int = None,
+                 max_episode_steps: int = None,
+                 random_start_pct: float = 0.00,
+                 device: Optional[str] = None,
+                 **kwargs) -> None:
+        super().__init__()
+        self.clock = Clock()
+
+        self.action_scheme = action_scheme
+        self.reward_scheme = reward_scheme
+        self.observer = observer
+        self.stopper = stopper
+        self.informer = informer
+        self.renderer = renderer
+        self.min_periods = min_periods
+        self.max_episode_steps = max_episode_steps
+        self.random_start_pct = random_start_pct
+        self.device = device
+
+        for c in self.components.values():
+            c.clock = self.clock
+
+        self.action_space = action_scheme.action_space
+        self.observation_space = observer.observation_space
+
+        self._enable_logger = kwargs.get('enable_logger', False)
+        if self._enable_logger:
+            self.logger = logging.getLogger(kwargs.get('logger_name', __name__))
+            self.logger.setLevel(kwargs.get('log_level', logging.DEBUG))
+
+    def _ensure_numpy(self, obs: Any) -> np.ndarray:
+        """Ensure observation is returned as numpy array for GPU compatibility.
+        
+        Parameters
+        ----------
+        obs : Any
+            The observation to convert
+            
+        Returns
+        -------
+        np.ndarray
+            The observation as a numpy array
+        """
+        if hasattr(obs, 'cpu'):  # PyTorch tensor
+            return obs.cpu().numpy()
+        elif hasattr(obs, 'numpy'):  # TensorFlow tensor
+            return obs.numpy()
+        elif isinstance(obs, np.ndarray):
+            return obs
+        else:
+            return np.array(obs)
+
+    @property
+    def components(self) -> 'Dict[str, Component]':
+        """The components of the environment. (`Dict[str,Component]`, read-only)"""
+        return {
+            "action_scheme": self.action_scheme,
+            "reward_scheme": self.reward_scheme,
+            "observer": self.observer,
+            "stopper": self.stopper,
+            "informer": self.informer,
+            "renderer": self.renderer
+        }
+
+    def step(self, action: Any) -> 'Tuple[np.array, float, bool, dict]':
+        """Makes one step through the environment.
+
+        Parameters
+        ----------
+        action : Any
+            An action to perform on the environment.
+
+        Returns
+        -------
+        `np.array`
+            The observation of the environment after the action being
+            performed.
+        float
+            The computed reward for performing the action.
+        bool
+            Whether or not the episode is complete.
+        dict
+            The information gathered after completing the step.
+        """
+        self.action_scheme.perform(self, action)
+
+        obs = self.observer.observe(self)
+        # Ensure observation is numpy array for GPU compatibility
+        obs = self._ensure_numpy(obs)
+        reward = self.reward_scheme.reward(self)
+        terminated = self.stopper.stop(self)
+        # Check if episode should be truncated due to max steps
+        truncated = (self.max_episode_steps is not None and
+                     self.clock.step >= self.max_episode_steps)
+        info = self.informer.info(self)
+
+        self.clock.increment()
+
+        return obs, reward, terminated, truncated, info
+
+    def reset(self,seed = None, options = None) -> tuple["np.array", dict[str, Any]]:
+        """Resets the environment.
+
+        Returns
+        -------
+        obs : `np.array`
+            The first observation of the environment.
+        """
+        if self.random_start_pct > 0.00:
+            size = len(self.observer.feed.process[-1].inputs[0].iterable)
+            random_start = randint(0, int(size * self.random_start_pct))
+        else:
+            random_start = 0
+
+        self.episode_id = str(uuid.uuid4())
+        self.clock.reset()
+
+        for c in self.components.values():
+            if hasattr(c, "reset"):
+                if isinstance(c, Observer):
+                    c.reset(random_start=random_start)
+                else:
+                    c.reset()
+
+        obs = self.observer.observe(self)
+        # Ensure observation is numpy array for GPU compatibility
+        obs = self._ensure_numpy(obs)
+        info = self.informer.info(self)
+
+        self.clock.increment()
+
+        return obs, info
+
+    def render(self, **kwargs) -> None:
+        """Renders the environment."""
+        self.renderer.render(self, **kwargs)
+
+    def save(self) -> None:
+        """Saves the rendered view of the environment."""
+        self.renderer.save()
+
+    def close(self) -> None:
+        """Closes the environment."""
+        self.renderer.close()

tensortrade/feed/__init__.py

@@ -1,5 +1,5 @@
-
-from . import api
-from . import core
-
-from .core import Stream, NameSpace, DataFeed
+
+from . import api
+from . import core
+
+from .core import Stream, NameSpace, DataFeed

tensortrade/feed/api/__init__.py

@@ -1,5 +1,5 @@
-
-from . import generic    
-from . import float
-from . import boolean
-from . import string
+
+from . import generic    
+from . import float
+from . import boolean
+from . import string