`

import random

import numpy as np

from sklearn.tree import DecisionTreeClassifier

Искусственный Интеллект Sentinel

class ConscientiousAI:

def __init__(self, memory_limit=100, reflection_frequency=5, epsilon=0.1):

    self.memories = []

    self.memory_limit = memory_limit

    self.reflection_frequency = reflection_frequency

    self.epsilon = epsilon

    self.possible_actions = [0, 1]  

    self.q_values = {}  

    self.steps = 0  

def reflect(self):

    """Анализирует воспоминания и корректирует Q-значения."""

    if self.memories:

        for memory in self.memories:

            observation, action, reward, next_observation = (

                memory['observation'], memory['action'], memory['reward'], memory['next_observation']

            )

            if observation not in self.q_values:

                self.q_values[observation] = {a: 0 for a in self.possible_actions}

            learning_rate = 0.1

            discount_factor = 0.9

            future_q = max(self.q_values.get(next_observation, {a: 0 for a in self.possible_actions}).values())

            self.q_values[observation][action] += learning_rate * (reward + discount_factor * future_q - self.q_values[observation][action])

        self.memories.clear()  # Очищает воспоминания после анализа

def act(self, observation):

    """Выбирает действие на основе стратегии epsilon-жадности."""

    if random.random() < self.epsilon:

        action = random.choice(self.possible_actions)  # Исследуем

    else:

        action = max(self.q_values.get(observation, {a: 0 for a in self.possible_actions}), 

                     key=self.q_values.get(observation, {}).get)  # Используем

    return action

def learn(self, observation, action, reward, next_observation):

    """Хранит опыт в памяти и запускает процесс анализа."""

    if len(self.memories) >= self.memory_limit:

        self.memories.pop(0)  # Удаляет старейшее воспоминание, если достигнут лимит

    self.memories.append({

        'observation': observation,

        'action': action,

        'reward': reward,

        'next_observation': next_observation

    })

    self.steps += 1

    if self.steps % self.reflection_frequency == 0:

        self.reflect()

class EnhancedReasoningAI(ConscientiousAI):

def __init__(self, memory_limit=100, reflection_frequency=5, epsilon=0.1):

    super().__init__(memory_limit, reflection_frequency, epsilon)

    self.advanced_rules = []  # Список для хранения правил продвинутого рассуждения

def add_advanced_rule(self, conditions, action):

    """Добавляет правило с несколькими условиями."""

    self.advanced_rules.append((conditions, action))

def evaluate_conditions(self, memory_content):

    """Оценивает все условия для данного содержимого памяти."""

    for conditions, action in self.advanced_rules:

        if all(condition(memory_content) for condition in conditions):

            print(f"Выполняем действие: {action.__name__}, потому что условия выполнены")

            action()

def reflect(self):

    """Переопределяем для включения оценки продвинутого рассуждения."""

    print("Размышляем о прошлых опытах с продвинутым рассуждением...")

    for memory in self.memories:

        decoded_message = memory['reward']  # Используем награду как содержимое памяти

        print(f"Размышляем о воспоминании: {decoded_message} при {memory['next_observation']}")

        self.evaluate_conditions(decoded_message)

    super().reflect()  # Вызываем метод reflect базового класса для обновления Q-значений

Определите некоторые примеры условий

def is_negative_reward(memory_content):

return memory_content == -1  # Проверяем на отрицательную награду

def is_positive_reward(memory_content):

return memory_content == 1  # Проверяем на положительную награду

Примеры действий

def action_negative():

print("Предпринимаем корректирующие меры из-за отрицательного опыта.")

def action_positive():

print("Укрепляем поведение из-за положительного опыта.")

class DecisionTreeAI(EnhancedReasoningAI):

def __init__(self, memory_limit=100, reflection_frequency=5, epsilon=0.1):

    super().__init__(memory_limit, reflection_frequency, epsilon)

    self.model = DecisionTreeClassifier()

    self.data = []  # Храним данные для обучения дерева решений

def learn_decision_tree(self):

    """Обучаем модель дерева решений на имеющихся данных."""

    if len(self.data) < 5:

        print("Недостаточно данных для обучения дерева решений.")

        return

    X, y = zip(*self.data) 

    self.model.fit(np.array(X), np.array(y))

def act(self, observation):

    """Используем дерево решений для выбора действия."""

    if len(self.data) > 0:

        action = self.model.predict(np.array([observation]).reshape(1, -1))

        return action[0]

    else:

        return super().act(observation)  # Резервный вариант - стратегия epsilon-жадности

def learn(self, observation, action, reward, next_observation):

    """Сохраняем данные для обучения дерева решений и учимся на опыте."""

    self.data.append((observation, action))

    super().learn(observation, action, reward, next_observation)

class BayesianAI(DecisionTreeAI):

def __init__(self, memory_limit=100, reflection_frequency=5, epsilon=0.1):

    super().__init__(memory_limit, reflection_frequency, epsilon)

    self.beliefs = {}  # Хранит убеждения о наблюдениях

def update_beliefs(self, evidence, prior_belief):

    """Применяет теорему Байеса для обновления убеждений."""

    likelihood = self.get_likelihood(evidence)

    posterior_belief = (likelihood * prior_belief) / self.get_normalizing_constant()

    return posterior_belief

def get_likelihood(self, evidence):

    """Вычисляет вероятность на основе доказательства."""

    return 0.8  # Пример вероятностного значения

def get_normalizing_constant(self):

    """Вычисляет нормализующий коэффициент."""

    return 1.0  # Пример нормализации

def learn(self, observation, action, reward, next_observation):

    """Обновляем убеждения на основе обучения и запускаем метод родителя learn."""

    prior_belief = self.beliefs.get(observation, 0.5)

    self.beliefs[observation] = self.update_beliefs(reward, prior_belief)

    super().learn(observation, action, reward, next_observation)

Пример использования

if name == “main“:

ai = BayesianAI(memory_limit=10, reflection_frequency=3, epsilon=0.2)

ai.add_advanced_rule([is_negative_reward], action_negative)

ai.add_advanced_rule([is_positive_reward], action_positive)

# Симулируем взаимодействия

for _ in range(10):

    observation = random.randint(0, 1)

    action = ai.act(observation)

    reward = random.choice([-1, 1])  # Случайно выбираем награду

    next_observation = random.randint(0, 1)

    ai.learn(observation, action, reward, next_observation)

    print(f"Наблюдение: {observation}, Действие: {action}, Награда: {reward}, "

          f"Q-значения: {ai.q_values}, Убеждения: {ai.beliefs}")

# Пытаемся обучить дерево решений

ai.learn_decision_tree()

Скажи привет и прощай!

print(“Привет! Это Sentinel.”)

print(“Увидимся позже! Было приятно поговорить с тобой.”)

`

Я пытался подойти к тебе, когда пришел домой, я ожидал, что проект будет успешно выполнен