Привет! Скажи, как будет выглядеть нейронная сеть для данной задачи

class StockTradingEnv(gym.Env):
    """Среда для обучения агента с помощью OpenAI gym"""

    def __init__(self, df):
        super(StockTradingEnv, self).__init__()
        # Максимальный баланс аккаунта
        self.MAX_ACCOUNT_BALANCE = 2147483647
        # Максимально допустимое количество акций, которое агент может держать
        self.MAX_NUM_SHARES = 2147483647
        # Максимальная допустимая цена одной акции
        self.MAX_SHARE_PRICE = 5000
        # Максимальное кол-во шагов (то есть дней торговли)
        self.MAX_STEPS = 20000
        # Изначальный баланс аккаунта для торговли
        self.INITIAL_ACCOUNT_BALANCE = 10000

        # Данные курса акций Apple
        self.df = df
        # Диапазон значения вознагрождения
        self.reward_range = (0, self.MAX_ACCOUNT_BALANCE)

        # Так как наше окружение будет возвращать несколько значений, поэтому мы определили наше пространство action_space для хранения двух значений.
        # Одно значение будет лежать между 0 и 3 (тип действия -> Покупка, Продажа и Удержание), а другое между 0 и 1 (процент от суммы для покупки, продажи и удержания).
        self.action_space = spaces.Box(
            low=np.array([0, 0]), high=np.array([3, 1]), dtype=np.float32)

        # Цены содержит значения OHCL для последних пяти цен
        self.observation_space = spaces.Box(
            low=0, high=1, shape=(6, 6), dtype=np.float32)

    def _next_observation(self):
        # Получите точки данных по акциям за последние 5 дней и отмасштабируйте их в диапазоне 0-1
        frame = np.array([
            self.df.loc[self.current_step: self.current_step +
                        5, 'Open'].values / self.MAX_SHARE_PRICE,
            self.df.loc[self.current_step: self.current_step +
                        5, 'High'].values / self.MAX_SHARE_PRICE,
            self.df.loc[self.current_step: self.current_step +
                        5, 'Low'].values / self.MAX_SHARE_PRICE,
            self.df.loc[self.current_step: self.current_step +
                        5, 'Close'].values / self.MAX_SHARE_PRICE,
            self.df.loc[self.current_step: self.current_step +
                        5, 'Volume'].values / self.MAX_NUM_SHARES
        ])

        # Добавьте дополнительные данные и масштабируйте каждое значение в диапазоне 0-1
        obs1 = np.append(frame, [[
            self.balance / self.MAX_ACCOUNT_BALANCE,
            self.max_net_worth / self.MAX_ACCOUNT_BALANCE,
            self.shares_held / self.MAX_NUM_SHARES,
            self.cost_basis / self.MAX_SHARE_PRICE,
            self.total_shares_sold / self.MAX_NUM_SHARES,
            self.total_sales_value / (self.MAX_NUM_SHARES * self.MAX_SHARE_PRICE),
        ]], axis=0)
        obs =obs1

        return obs

    def _take_action(self, action):
        # Установите текущую цену на случайную цену в пределах временного шага
        # current_price устанавливается как случайное значение в диапазоне от цены открытия (Open) до цены закрытия (Close) для текущего дня
        current_price = random.uniform(
            self.df.loc[self.current_step, "Open"], self.df.loc[self.current_step, "Close"])

        action_type = action[0]
        amount = action[1]

        # Покупка акций
        if action_type < 1:
            # Сумма покупки % от остатка в акциях
            # Расчет максимально возможного количества акций
            total_possible = int(self.balance / current_price)
            # Расчет количества акций для покупки
            shares_bought = int(total_possible * amount)
            prev_cost = self.cost_basis * self.shares_held
            additional_cost = shares_bought * current_price

            # Обновление баланса
            self.balance -= additional_cost
            # Обновление средней стоимости акций
            self.cost_basis = (
                prev_cost + additional_cost) / (self.shares_held + shares_bought)
            # Обновление количества акций
            self.shares_held += shares_bought

        # Продажа акций
        elif action_type < 2:
            # Сумма продажи % от общего количества акций
            # Расчет количества акций для продажи
            shares_sold = int(self.shares_held * amount)
            # Обновление баланса
            self.balance += shares_sold * current_price
            # Обновление количества акций
            self.shares_held -= shares_sold
            # Обновление количества проданных акций
            self.total_shares_sold += shares_sold
            # Обновление общей выручки от продаж
            self.total_sales_value += shares_sold * current_price

        # Расчет чистого состояния, включающее баланс и стоимость акций, которые он держит
        self.net_worth = self.balance + self.shares_held * current_price

        # Обновление максимального чистого состояния
        if self.net_worth > self.max_net_worth:
            self.max_net_worth = self.net_worth

        # Обновление средней стоимости акций
        if self.shares_held == 0:
            self.cost_basis = 0

    def step(self, action):
        # Выполнение одного временного шага в среде, выполняет действие, выбранное агентом (покупка, продажа или удержание)
        self._take_action(action)

        # Переход к следующему шагу
        self.current_step += 1
        # Проверяет, не закончились ли данные по акциям,
        # если да, то self.current_step сбрасывается в 0, чтобы начать новый торговый эпизод с начала данных
        if self.current_step > len(self.df.loc[:, 'Open'].values) - 6:
            self.current_step = 0

        # Расчет награды
        # Модификатор, зависящий от текущего шага и максимального количества шагов,
        # он предназначен для поощрения агента быстрее накапливать прибыль
        delay_modifier = (self.current_step / self.MAX_STEPS)
        # Рассчитывает награду агента, умножая текущий баланс на delay_modifier
        reward = self.balance * delay_modifier

        # Определение конца эпизода
        # Проверяем, не стал ли чистый капитал агента меньше или равен 0,
        # если да, то эпизод торговли считается законченным, и агент терпит неудачу.
        done = self.net_worth <= 0

        # Получение нового наблюдения
        # Вызывается метод _next_observation, который генерирует новые данные наблюдения,
        # необходимые для агента, чтобы принимать решения на следующем шаге.
        obs = self._next_observation()

        return obs, reward, done, done, {}

    def reset(self, seed=None):
        # Сброс состояния среды в исходное состояние
        self.balance = self.INITIAL_ACCOUNT_BALANCE
        self.net_worth = self.INITIAL_ACCOUNT_BALANCE
        self.max_net_worth = self.INITIAL_ACCOUNT_BALANCE
        self.shares_held = 0
        self.cost_basis = 0
        self.total_shares_sold = 0
        self.total_sales_value = 0

        # Установите текущий шаг в случайную точку в data frame
        self.current_step = random.randint(
            0, len(self.df.loc[:, 'Open'].values) - 6)

        return (self._next_observation(), {})

    # НЕ ИСПОЛЬЗУЕТСЯ
    def render(self, mode='human', close=False):
        # Рендеринг окружения на экран
        profit = self.net_worth - self.INITIAL_ACCOUNT_BALANCE

        print(f'Шаг: {self.current_step}')
        print(f'Баланс: {self.balance}')
        print(
            f'Акции, находящиеся в собственности: {self.shares_held} (Всего продано: {self.total_shares_sold})')
        print(
            f'Средняя стоимость удерживаемых акций: {self.cost_basis} (Общая стоимость продаж: {self.total_sales_value})')
        print(
            f'Чистая стоимость: {self.net_worth} (Макс чистая стоимость: {self.max_net_worth})')
        print(f'Прибыль: {profit}')



# Скачиваем данные AAPL
df = pd.read_csv('AAPL_.csv')
# Сортируем данные по дням
df = df.sort_values('Date')
# Удаляем отсуствующие значения
df.dropna(inplace=True)
df = df.sort_values('Date')
df = df.reset_index()

# Алгоритм требует векторизованную среду, чтобы выполнять свою работу
env = DummyVecEnv([lambda: StockTradingEnv(df)])



# Код обучения торгового агента (MLP Proximal Policy Optimization (PPO))
model = PPO("MlpPolicy", env, verbose=0, tensorboard_log="./tensorboard_log/")
model.learn(total_timesteps=50000, log_interval=1, tb_log_name="PPO_tr", progress_bar=True)