From 8601da7e97889de881606061ae83094ab9888663 Mon Sep 17 00:00:00 2001
From: Deadsg <144394753+Deadsg@users.noreply.github.com>
Date: Sat, 18 Nov 2023 19:04:05 -0500
Subject: [PATCH] Add files via upload

---
 DQNAgent/DQNAgent.py                          | 101 ++++
 DQNAgent/QLAgent.py                           | 376 +++++++++++++
 DQNAgent/QNetwork.py                          |  87 +++
 DQNAgent/__pycache__/QLAgent.cpython-312.pyc  | Bin 0 -> 16984 bytes
 DQNAgent/__pycache__/QLAgent.cpython-38.pyc   | Bin 0 -> 9735 bytes
 DQNAgent/__pycache__/QLAgent.cpython-39.pyc   | Bin 0 -> 9738 bytes
 DQNAgent/__pycache__/QNetwork.cpython-38.pyc  | Bin 0 -> 3074 bytes
 .../integrationmodule.cpython-38.pyc          | Bin 0 -> 675 bytes
 .../__pycache__/learningmodule.cpython-38.pyc | Bin 0 -> 13058 bytes
 DQNAgent/__pycache__/lpmodule.cpython-38.pyc  | Bin 0 -> 562 bytes
 .../perceptionmodule.cpython-38.pyc           | Bin 0 -> 1954 bytes
 .../reasoningmodule.cpython-38.pyc            | Bin 0 -> 590 bytes
 DQNAgent/__pycache__/rlmodule.cpython-38.pyc  | Bin 0 -> 2324 bytes
 DQNAgent/decisionmakingmodule.py              |   8 +
 DQNAgent/integrationmodule.py                 |  19 +
 DQNAgent/learningmodule.py                    | 527 ++++++++++++++++++
 DQNAgent/lpmodule.py                          |  13 +
 DQNAgent/perceptionmodule.py                  |  85 +++
 DQNAgent/reasoningmodule.py                   |  13 +
 DQNAgent/rlmodule.py                          |  66 +++
 20 files changed, 1295 insertions(+)
 create mode 100644 DQNAgent/DQNAgent.py
 create mode 100644 DQNAgent/QLAgent.py
 create mode 100644 DQNAgent/QNetwork.py
 create mode 100644 DQNAgent/__pycache__/QLAgent.cpython-312.pyc
 create mode 100644 DQNAgent/__pycache__/QLAgent.cpython-38.pyc
 create mode 100644 DQNAgent/__pycache__/QLAgent.cpython-39.pyc
 create mode 100644 DQNAgent/__pycache__/QNetwork.cpython-38.pyc
 create mode 100644 DQNAgent/__pycache__/integrationmodule.cpython-38.pyc
 create mode 100644 DQNAgent/__pycache__/learningmodule.cpython-38.pyc
 create mode 100644 DQNAgent/__pycache__/lpmodule.cpython-38.pyc
 create mode 100644 DQNAgent/__pycache__/perceptionmodule.cpython-38.pyc
 create mode 100644 DQNAgent/__pycache__/reasoningmodule.cpython-38.pyc
 create mode 100644 DQNAgent/__pycache__/rlmodule.cpython-38.pyc
 create mode 100644 DQNAgent/decisionmakingmodule.py
 create mode 100644 DQNAgent/integrationmodule.py
 create mode 100644 DQNAgent/learningmodule.py
 create mode 100644 DQNAgent/lpmodule.py
 create mode 100644 DQNAgent/perceptionmodule.py
 create mode 100644 DQNAgent/reasoningmodule.py
 create mode 100644 DQNAgent/rlmodule.py

diff --git a/DQNAgent/DQNAgent.py b/DQNAgent/DQNAgent.py
new file mode 100644
index 0000000..091ef71
--- /dev/null
+++ b/DQNAgent/DQNAgent.py
@@ -0,0 +1,101 @@
+import QLAgent
+from perceptionmodule import image_recognition, text_processing 
+from learningmodule import supervised_learning, QLearningAgent, run_q_learning, reinforcement_learning
+from rlmodule import execute_action_and_get_reward
+from reasoningmodule import rule_based_reasoning, decision_making
+from lpmodule import simple_chatbot
+from integrationmodule import integrate_modules
+
+
+
+def image_recognition(image_data):
+    pass
+
+def text_processing(text_data):
+    pass
+
+# Example data
+image_data = "path_to_image.jpg"
+text_data = "This is a sample text."
+user_input = "How are you?"
+
+# Perception Module
+image_result = image_recognition(image_data)
+text_result = text_processing(text_data)
+
+# Learning Module
+supervised_result = supervised_learning(X_train, y_train)
+reinforcement_result = reinforcement_learning()
+
+# Reasoning Module
+rule_based_result = rule_based_reasoning(text_data)
+decision_making_result = decision_making(X_train, y_train)
+
+# Language Processing Module
+chatbot_response = simple_chatbot(user_input)
+
+# Integration Module
+final_output = integrate_modules(image_result, text_result, supervised_result,
+                                reinforcement_result, rule_based_result,
+                                decision_making_result, chatbot_response)
+def cagi_agent(states):
+    # Placeholder function, replace with actual state representation logic
+    return states[0]
+
+# RL Agent
+rl_agent = QLearningAgent(num_actions=3)  # Assuming 3 possible actions
+
+def execute_action_and_get_reward(action):
+    # Placeholder function, replace with actual action execution and reward logic
+    return 1.0  # Placeholder reward
+
+def integrate_modules(image_data, text_data, user_input):
+    perception_output = image_recognition(image_data)
+    learning_output = supervised_learning(text_data)
+    reasoning_output = rule_based_reasoning(user_input)
+    language_output = simple_chatbot(user_input)
+
+    # RL Module
+    current_state = cagi_agent(environment_states)
+    rl_action = rl_agent.select_action(current_state)
+    rl_reward = execute_action_and_get_reward(rl_action)
+    next_state = cagi_agent(environment_states)
+    rl_agent.update_q_table(current_state, rl_action, rl_reward, next_state)
+
+    final_output["rl_learning"] = {"action": rl_action, "reward": rl_reward}
+
+    return final_output
+
+    # Load a sample dataset for illustration (replace with your dataset)
+iris = load_iris()
+X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42)
+
+# Other imports and definitions from your script
+
+# Example usage
+image_data = "path_to_image.jpg"
+text_data = "This is a sample text."
+user_input = "How are you?"
+
+environment_states = ["State1", "State2", "State3"]
+
+output = integrate_modules(image_data, text_data, user_input)
+print("CAGI Agent Output:", output)
+
+env = gym.make('FrozenLake-v1')
+
+# Ensure that observation_space and action_space are valid gym.spaces objects
+observation_space = env.observation_space
+action_space = env.action_space
+
+# Initialize the QLearningAgent with q_table, observation_space, and action_space
+q_table = ...  # Define or load your q_table
+agent = QLearningAgent(q_table, observation_space, action_space)
+
+num_episodes = 100
+
+# Get the number of episodes
+num_episodes = get_num_episodes()
+
+# Call run_q_learning using the created agent
+run_q_learning(agent, env, num_episodes)
\ No newline at end of file
diff --git a/DQNAgent/QLAgent.py b/DQNAgent/QLAgent.py
new file mode 100644
index 0000000..3dc6ca0
--- /dev/null
+++ b/DQNAgent/QLAgent.py
@@ -0,0 +1,376 @@
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.model_selection import train_test_split
+import numpy as np
+import gym
+
+def run_q_learning(agent, env, _):
+    pass
+
+def initialize_q_table(num_states, num_actions):
+    return np.zeros((num_states, num_actions))
+
+# Example usage:
+num_states = 4  # Number of states
+num_actions = 2  # Number of actions
+Q = initialize_q_table(num_states, num_actions)
+
+def num_actions(env):
+    return env.action_space.n
+
+def update_q_table(self, state, action, reward, next_state):
+    pass
+
+def q_table(env):
+    # Assuming env is a Gym environment
+    if isinstance(env.observation_space, gym.spaces.Discrete) and isinstance(env.action_space, gym.spaces.Discrete):
+        return np.zeros((env.observation_space.n, env.action_space.n))
+    else:
+        raise ValueError("The environment's state and action space should be discrete for Q-table approach.")
+
+def q_learning(env, q_table, learning_rate=0.1, discount_factor=0.9, exploration_prob=0.1, episodes=1000):
+    for episode in range(episodes):
+        state = env.reset()
+        done = False
+        while not done:
+            # Selecting action using epsilon-greedy strategy
+            if np.random.uniform(0, 1) < exploration_prob:
+                action = env.action_space.sample()
+            else:
+                action = np.argmax(q_table[state, :])
+
+            # Taking action and observing next state and reward
+            next_state, reward, done, _ = env.step(action)
+
+            # Updating Q-value
+            best_next_action = np.argmax(q_table[next_state, :])
+            td_target = reward + discount_factor * q_table[next_state, best_next_action]
+            td_error = td_target - q_table[state, action]
+            q_table[state, action] += learning_rate * td_error
+
+            state = next_state
+    
+    return q_table
+
+def shape(space):
+    if isinstance(space, gym.spaces.Discrete):
+        return space.n
+    else:
+        return space.shape[0]
+
+def observation_space():
+    pass
+
+def action_space():
+    pass
+
+def QLearningAgent(self, q_table, observation_space, action_space, num_actions, learning_rate, discount_factor, exploration_prob, num_states, select_action):
+    
+
+    def run_q_learning(agent, env, _):
+
+
+        def learning_rate():
+            pass
+
+        def discount_factor():
+            pass
+
+        def exploration_prob():
+            pass
+
+        def num_states():
+            pass
+
+        def env(observation_space, action_space, n):
+            pass
+
+def update_q_value(Q, state, action, reward, next_state, learning_rate, discount_factor):
+    if state < Q.shape[0] and action < Q.shape[1] and next_state < Q.shape[0]:
+        Q[state, action] += learning_rate * (reward + discount_factor * (np.max(Q[next_state, :]) - Q[state, action]))
+    else:
+        raise IndexError("Index out of bounds for Q-table")
+    return Q
+
+def accuracy_score(y_true, y_pred):
+    # Check if the lengths of y_true and y_pred match
+    if len(y_true) != len(y_pred):
+        raise ValueError("The lengths of y_true and y_pred should match")
+
+    # Count the number of correct predictions
+    correct_predictions = sum(1 for true, pred in zip(y_true, y_pred) if true == pred)
+
+    # Calculate the accuracy
+    accuracy = correct_predictions / len(y_true)
+
+    return accuracy
+
+def select_action(q_table, state, exploration_rate, num_actions):
+    if np.random.rand() < exploration_rate:
+        return np.random.choice(1)  # Exploration
+    else:
+        return np.argmax(q_table[state])
+
+def train_test_split(X, y, test_size=0.2, random_state=None):
+    # Check if the length of X and y matches
+    if len(X) != len(y):
+        raise ValueError("The lengths of X and y should match")
+
+    # Combine the features and labels into a single dataset
+    dataset = np.column_stack([X, y])
+
+    # Set the random seed for reproducibility
+    if random_state is not None:
+        np.random.seed(random_state)
+
+    # Shuffle the dataset
+    np.random.shuffle(dataset)
+
+    # Calculate the split index
+    split_index = int(len(dataset) * (1 - test_size))
+
+    # Split the dataset into training and testing sets
+    X_train, y_train = dataset[:split_index, :-1], dataset[:split_index, -1]
+    X_test, y_test = dataset[split_index:, :-1], dataset[split_index:, -1]
+
+    return X_train, X_test, y_train, y_test
+
+def q_table(env):
+    # Assuming env is a Gym environment
+    if isinstance(env.observation_space, gym.spaces.Discrete) and isinstance(env.action_space, gym.spaces.Discrete):
+        return np.zeros((env.observation_space.n, env.action_space.n))
+    else:
+        raise ValueError("The environment's state and action space should be discrete for Q-table approach.")
+
+def q_learning(env, q_table, learning_rate=0.1, discount_factor=0.9, exploration_prob=0.1, episodes=1000):
+    for episode in range(episodes):
+        state = env.reset()
+        done = False
+        while not done:
+            # Selecting action using epsilon-greedy strategy
+            if np.random.uniform(0, 1) < exploration_prob:
+                action = env.action_space.sample()
+            else:
+                action = np.argmax(0)
+
+            # Taking action and observing next state and reward
+            next_state, reward, done, _, _ = env.step(action)
+
+            # Updating Q-value
+            best_next_action = np.argmax(q_table[next_state, :])
+            td_target = reward + discount_factor * q_table[next_state, best_next_action]
+            td_error = td_target - q_table[0]
+            q_table[0] += learning_rate * td_error
+
+            state = next_state
+    return q_table
+
+# Example usage:
+env = gym.make('FrozenLake-v1')
+table = q_table(env)
+Q_table = q_learning(env, table)
+
+# Using the Q-table for inference
+state = env.reset()
+done = False
+while not done:
+    action = np.argmax(0)
+    next_state, reward, done, _, _ = env.step(action)
+    state = next_state
+
+class QLearningAgent:
+    def __init__(self, num_states, num_actions, learning_rate=0.1, discount_factor=0.9, exploration_rate=0.1, exploration_prob=0.3, select_action=select_action):
+        self.num_states = num_states
+        self.num_actions = num_actions
+        self.learning_rate = learning_rate
+        self.discount_factor = discount_factor
+        self.exploration_rate = exploration_rate
+        self.q_table = np.zeros((4, 2))
+        self.q_table = q_table(env)
+        self.select_action = select_action
+
+    def select_action(self, state, num_actions):
+        return select_action(self.q_table, state, self.exploration_rate, self.num_actions)
+
+    def run_q_learning(agent, env, num_episodes):
+        for episode in range(num_episodes):
+            state_tuple = env.reset()
+            state = np.ravel_multi_index(state_tuple, env.observation_space.shape)
+            done = False
+
+class SupervisedLearningModel:
+    def __init__(self):
+        self.model = DecisionTreeClassifier()
+
+    def train(self, X_train, y_train):
+        self.model.fit(X_train, y_train)
+
+    def predict(self, X_test):
+        return self.model.predict(X_test)
+
+def supervised_learning(X, y):
+    # Split the data into training and testing sets
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+    # Create and train the model
+    model = SupervisedLearningModel()
+    model.train(X_train, y_train)
+
+    # Make predictions on the testing set
+    y_pred = model.predict(X_test)
+
+    # Calculate and print the accuracy
+    accuracy = accuracy_score(y_test, y_pred)
+    print(f"Accuracy: {accuracy}")
+
+    return model
+
+env = gym.make('FrozenLake-v1')
+
+# Ensure that observation_space and action_space are valid gym.spaces objects
+observation_space = env.observation_space
+action_space = env.action_space
+
+num_states = env.observation_space.n
+num_actions = env.action_space.n
+learning_rate = 0.1
+discount_factor = 0.9
+exploration_rate = 0.1
+agent = QLearningAgent(num_states, num_actions, learning_rate, discount_factor, exploration_rate)
+
+# Run Q-learning
+run_q_learning(agent, env, 1000)
+
+# After running Q-learning, we can use the learned Q-table to generate a dataset for supervised learning
+states = np.arange(env.observation_space.n)
+actions = np.argmax(agent.q_table, axis=1) 
+
+# The states are the inputs and the actions are the outputs
+X = states.reshape(-1, 1)
+y = actions
+
+# Train a supervised learning model on the Q-learning data
+supervised_model = supervised_learning(X, y)
+
+def q_learning(env, learning_rate=0.1, discount_factor=0.9, epsilon=0.9, episodes=1000):
+    # Initializing Q-table
+    Q = np.zeros((env.observation_space.n, env.action_space.n))
+
+    # Q-learning algorithm
+    for episode in range(10):
+        state = env.reset()
+        done = False
+        while not done:
+            # Selecting action using epsilon-greedy strategy
+            if np.random.uniform(0, 1) < epsilon:
+                action = env.action_space.sample()
+            else:
+                action = np.argmax(Q[0])
+
+            # Taking action and observing next state and reward
+            next_state, reward, done, _, _ = env.step(action)
+
+            # Updating Q-value
+            if len(Q[1].shape) > 1:
+                Q[1] = Q[1].flatten()
+
+# Use the first maximum value if there are multiple
+max_Q1 = np.max(Q[1])
+if isinstance(max_Q1, np.ndarray):
+    max_Q1 = max_Q1[0]
+
+# Update the Q-value
+Q[3, 1] += learning_rate * (reward + discount_factor * max_Q1 - Q[3, 1])
+
+state = next_state
+
+print (Q)
+
+# Initializing the environment
+env = gym.make('FrozenLake-v1')
+table = q_table(env)
+
+# Define num_actions and other parameters
+num_actions = env.action_space.n
+learning_rate = 0.1
+discount_factor = 0.9
+exploration_prob = 0.1
+num_states = env.observation_space.n
+
+# Initialize QLearningAgent with Q-table and parameters
+agent = QLearningAgent(table, learning_rate, discount_factor, exploration_prob, select_action)
+
+# Run Q-learning
+Q_table = q_learning(env, table, learning_rate, discount_factor, exploration_prob)
+
+# Use Q-table for inference
+state = env.reset()
+done = False
+while not done:
+    action = agent.select_action(state, exploration_rate, num_actions, _)
+    next_state, reward, done, _, _ = env.step(action)
+    state = next_state
+
+    def select_action(self, state):
+        if np.random.rand() < self.exploration_rate:
+            return np.random.choice(self.num_actions)  # Exploration
+        else:
+            return np.argmax(self.q_table[state])  # Exploitation
+
+    def update_q_table(self, state, action, reward, next_state):
+        best_next_action = np.argmax(self.q_table[next_state])
+        td_target = reward + self.discount_factor * self.q_table[next_state][best_next_action]
+        td_error = td_target - self.q_table[state][action]
+        self.q_table[state][action] += self.learning_rate * td_error 
+
+    def QLAgent():
+
+        def run_q_learning(agent, env, num_episodes):
+            for episode in range(num_episodes):
+                state_tuple = env.reset()  # Reset the environment to get the initial state
+                state = np.ravel_multi_index(state_tuple, env.observation_space.n)  # Convert the state to a single index using the observation space dimensions
+                done = False
+
+            while not done:
+                action = agent.select_action(state)
+                next_state, reward, done, _ = env.step(action)
+                agent.update_q_table(state, action, reward, next_state)
+                state = next_state
+
+            if (episode + 1) % 10 == 0:
+                print(f"Episode {episode + 1} completed")
+
+    print("Training finished")
+
+    def select_action(self, state):
+        if np.random.rand() < self.exploration_prob:
+            return np.random.choice(self.num_actions)  # Exploration
+        else:
+            return np.argmax(self.q_table[state])  # Exploitation
+
+    def update_q_table(self, state, action, reward, next_state):
+        best_next_action = np.argmax(self.q_table[next_state])
+        td_target = reward + self.discount_factor * self.q_table[next_state][best_next_action]
+        td_error = td_target - self.q_table[state][action]
+        self.q_table[state][action] += self.learning_rate * td_error
+
+if __name__ == "__main__":
+    # Create environment and Q-table
+    env = gym.make('FrozenLake-v1')
+    table = q_table(env)
+
+    # Define num_actions
+    num_actions = env.action_space.n
+
+    # Initialize QLearningAgent with Q-table and num_actions
+    agent = QLearningAgent(table, num_actions, learning_rate=0.1, discount_factor=0.9, exploration_prob=0.1)
+
+    # Run Q-learning
+    Q_table = q_learning(env, table, learning_rate=0.1, discount_factor=0.9, exploration_prob=0.1)
+
+    # Use Q-table for inference
+    state = env.reset()
+    done = False
+    while not done:
+        action = agent.select_action(state)
+        next_state, reward, done, _ = env.step(action)
+        state = next_state
\ No newline at end of file
diff --git a/DQNAgent/QNetwork.py b/DQNAgent/QNetwork.py
new file mode 100644
index 0000000..91f54ab
--- /dev/null
+++ b/DQNAgent/QNetwork.py
@@ -0,0 +1,87 @@
+import QLAgent
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.layers import Dense
+from tensorflow.keras import models
+import gym
+
+def QNetwork():
+    pass
+
+def dtype():
+    dtype(reshape, dtype=np.float32)
+    state = np.array(state, reshape, dtype=(object))
+
+def convert_dtype(reshape_func, state):
+    return np.array(reshape_func(state), dtype=np.float32)
+
+# Reshape function to flatten the input state
+reshape = lambda x: np.array(x).reshape(1, -1)
+
+class DQNAgent:
+    def __init__(self, observation_space, action_space):
+        self.observation_space = observation_space
+        self.action_space = action_space
+        self.q_network = self.build_q_network()
+        self.target_network = self.build_q_network()
+        self.update_target_network()
+
+    def build_q_network(self):
+        model = models.Sequential([
+            Dense(64, activation='relu', input_shape=self.observation_space.shape),
+            Dense(64, activation='relu'),
+            Dense(self.action_space.n, activation='linear')
+        ])
+        model.compile(optimizer='adam', loss='mse')
+        return model
+
+    def update_target_network(self):
+        self.target_network.set_weights(self.q_network.get_weights())
+
+    def act(self, state, epsilon=0.1):
+        if np.random.rand() < epsilon:
+            return np.random.choice(self.action_space.n)
+
+        state = convert_dtype(reshape, state)
+        q_values = self.q_network.predict(state)
+        return np.argmax(q_values)
+
+    def train(self, state, action, reward, next_state, done, gamma=0.99, batch_size=32):
+        state = convert_dtype(reshape, state)
+        next_state = convert_dtype(reshape, next_state)
+
+        target = self.q_network.predict(state)
+
+        if done:
+            target[0][action] = reward
+        else:
+            next_q_values = self.target_network.predict(next_state)
+            target[0][action] = reward + gamma * np.max(next_q_values)
+
+        self.q_network.fit(state, target, epochs=1, verbose=0, batch_size=batch_size)
+
+env = gym.make('CartPole-v1')
+observation_space = env.observation_space
+action_space = env.action_space
+agent = DQNAgent(observation_space, action_space)
+
+for episode in range(100):
+    state = env.reset()
+    total_reward = 0
+    done = False
+    while not done:
+        action = agent.act([0, 2, 3, 0], 0.1)
+        next_state, reward, done, _, _ = env.step(action)
+
+        agent.train([0.3, 0.3, 0.3, 0.3], action, reward, [0.3, 0.3, 0.3, 0.3], done)
+        total_reward += reward
+        state = next_state
+
+        # Print the values of state and next_state
+        print("State:", state)
+        print("Next State:", next_state)
+
+    print(f"Episode {episode + 1}, Total Reward: {total_reward}")
+    print(agent.q_network.summary())
+    for layer in agent.q_network.layers:
+        print(layer.get_weights())
\ No newline at end of file
diff --git a/DQNAgent/__pycache__/QLAgent.cpython-312.pyc b/DQNAgent/__pycache__/QLAgent.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1daa1f768705e3a7b9c3db9197ac70571a38ca78
GIT binary patch
literal 16984
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
YCxdaYerhAypXn)^{b4J`$R~LJ4fRoZw*UYD

literal 0
HcmV?d00001

diff --git a/DQNAgent/__pycache__/QLAgent.cpython-38.pyc b/DQNAgent/__pycache__/QLAgent.cpython-38.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6f69ff91996f2f870a31b63ff2462fda775468f3
GIT binary patch
literal 9735
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
NFK#u*x^s@1{{y41gC+m~

literal 0
HcmV?d00001

diff --git a/DQNAgent/__pycache__/QLAgent.cpython-39.pyc b/DQNAgent/__pycache__/QLAgent.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8c0e65b84fbcc239a123d3222c7f3f98bf31f1b9
GIT binary patch
literal 9738
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
S$18YvlVfq7Inn**g!mt^UWMNP

literal 0
HcmV?d00001

diff --git a/DQNAgent/__pycache__/QNetwork.cpython-38.pyc b/DQNAgent/__pycache__/QNetwork.cpython-38.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..997810cd0f3e2b797c9677b48fef882d114422da
GIT binary patch
literal 3074
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
a3(@4GB0J!g_>y&>I2$=`t>V^H=l=z7R>5`v

literal 0
HcmV?d00001

diff --git a/DQNAgent/__pycache__/integrationmodule.cpython-38.pyc b/DQNAgent/__pycache__/integrationmodule.cpython-38.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4204a1ae90dc38206665afa31b6e9a446e4fb669
GIT binary patch
literal 675
zcmZWny-ve05Vn)F4H4x>^Z{72Ffby7T8e}i=u&lwB1LX&f~CfZYzKi9CXjduUVvB1
z%3B}?&Ti9yIP3nt<bHhT#c&uPpoh0PD;$JAjq{rTLt|hy0znbQuP8#)p)P1ly*Ubd
zDSY`u7`!R4@<31o|KQmNk_PU?*LZpsFBFq1z9mnR#8*XH<xFT5Pp)s`OQLfkjwd(q
zlw>^SLbFT~%?ptiv|6!~@~Juehnf<~w2ZKHL8eBu<b%-zwym9lp;3)q@UyFNjX`_b
zsU6Tg?ONTh-P)^rb)VvQ?|D!U;3Cc}^rE0-GG(P{Ch}K|NWn!G?MOycVa&!~5s_6S
zW1$C4=3pd}r9~#ViD`~h1sNW=Vl-*Pn~{WDB}-z!F4Lakc?o!WPxP|Tq2C1Se3WR?
z>}d9=6Ke()j56V(taNnP^_LWtHqd@srv(nSHCkl9ZF&PVyLViW)yC@<C(V4j*|TK5
r5W8&qN|57Ydprl*^W7iFAq34r$8N<szY^MqVYB+@>tq+(Mf&a!68y8b

literal 0
HcmV?d00001

diff --git a/DQNAgent/__pycache__/learningmodule.cpython-38.pyc b/DQNAgent/__pycache__/learningmodule.cpython-38.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3ab4234b5ac4c94cc968fde4da1c61210200c973
GIT binary patch
literal 13058
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
G?D>BJC0*43

literal 0
HcmV?d00001

diff --git a/DQNAgent/__pycache__/lpmodule.cpython-38.pyc b/DQNAgent/__pycache__/lpmodule.cpython-38.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8b24635a763e997a49bf5df80fe886ab562ea04d
GIT binary patch
literal 562
zcmYjOO-sW-5Zz7M*cKH8JqR9F5F{YI3L<`0uszsIDMAU9HM_ROBpY@&NJG7O^XA!u
z9{o$Xdh#y_f-|YoPMAsNWq335roXn<AYd=gJ=vy&d}6X}4kTybW(R^Gf<|OOgd^N1
zGN7U&s_=FM?GfMmf(p_NF)kahk`}nBKoA5fY4?L@BwmE?!`4yIH&UD6nol(kE>)Pt
zGO;E&zv=`R+{Qd%=bfO%N0T5*V<oakHq&WQ`%hf#fvkjTY!zbTe?z<qUJg>OLU9RE
zd37J@jJ}Z>nNd;QChrce(#<zJ`!O3SB@UP!^W>gQRkoXNA<CJV#Azg1IOg_N*=D|n
zaH1?TnU-v<9+*{3OOvWZ;3qKHrtjvfZTQ8Z1jtVFjT?aX4JMi;JeH@$%B8&HS!6ZN
z>eIp<N$WdBBLiiIlO)Y-QJ?b~X%^~f+`U+zk2U-o%LB}m$8{VE&yVNnI?}p@r+Fe&
aT*_2pOH}1uO1|3hT;&rKvb<i+sky%pLVw@@

literal 0
HcmV?d00001

diff --git a/DQNAgent/__pycache__/perceptionmodule.cpython-38.pyc b/DQNAgent/__pycache__/perceptionmodule.cpython-38.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..37a7e282908e82c2c39d137dccc89d3b305aa8d0
GIT binary patch
literal 1954
zcmZuxOK%%D5GMDf-IZj?vg0J^OMOEvAhfwPD2fC&QWR*6v~k*k5FoHiT3LBtC8^Xl
zl#`3z{2!#FZ~Ytn3wtWilP~=NZ4aH<wJZndN;@3Ra)#vh&CIiQJ0$S@{_FShw<aNf
z;^gLI!{h<H`Y#ZI2$~Q^VYCvGTFjzovlBaYm{aKv=q__B-A%l-!5WlEI<=<$G+==Y
z7U7bNtdYf<tOc^oHe^$HuMycsX%VouMML<%5Y`ca2t{*Zv##vO?iq!sEzyQAn_@$B
zVC;!5+mb!Gbw=5?++N&T5?J$pwsoY&8DTqeXK`D0mz3REMV6aq;9JLn81yL_Y+k~h
z$^L+r?vYengW@IpL@Lz6r}C$n%uLJ^n00pZS!TYIk;zqjD%Au%$shTHh*nxH92gML
zU3m2)5Qa<<8hha^$xAw?3wKVIa81xW)LvRwD;f)bZo%9(fuIP43FdYM2!VrI`={Ga
zR31sKrRX2XW7FT`hTk8ArDYD41v{1PLdl|D6K9jsF|eu(4)P<J;elD}FgD{n8>3yb
zUNwwOKGxMWA#~}lRMsxIxbeX)RGgWCQ+iRZikW7CS%ocwm6K*&@DlQd;{{P0aJ0Wa
z+r2+}rUBN`V}7FeXfKauDL|`755N3swD-;a!wJkrg;bF&Oq^$FE@p`w7AIu~&pBS-
ztA)s-Al3#A?a=PpK2=?qpY9wyk98mZyszW5NMs*<ho^TAVCb(y^yM+f&%@J?_qmxV
zp7g)w*<{8ivVR3K0EmI$(o#unU^<L&&((vRV_8)^XQ0$9F6?S_rmmpE61H%Jd+yY>
zg(tivz0w=Y+QXUpPztv2&+9zEIVLj9CoW_InUiTCnphMQDmKn-EIY`D&i-W|b{$xk
zHVmo<qI8r@W*7G51GL;)nFm%G^2o$5IO1A1<E)sOv3|}A3Er4E>dwmHf~p<RFY#t&
zL+6Jk<;SJN1y9*qy5LI7am0<BKnX-V8AmFIe9Vl>fheCx5nvgeT-arh1B)qUUFjsS
zrfj6rfR7%8%ER5Ng!O=BnP`PYqwpTg+s(5V_x4!pF+YBi=Lz6`Z?9}TO1LpHE8RVr
zX<0U+JT2lxV%b(9swAsL2amoPr@-Y{$ta&>G2Z)aFl$7KSU%mREgI4;?f&BhJzISU
z)>n!c4;R2&k^3zu*W?1RbLbrB)HqYGCK!lA-9@smbPp&6ec}LtQ1Vmgbx0}@*hB*7
z*m+vebkuE#T{E?X+FcZzATBYzfPi?C=CM$(!;EeH7-w9ayn?xU13lgZG4R*8s&~+O
z4XSz<r|+S7A6HuSwjZDYi}NOK>jE6t75FJE&{$lA`hZyrfB$-Z&r%<u>o$nNT^0g4
zI#-8D{`2}6th=@jtL|EHTpbLu=_rw0Wy3>>6)4A0p^!UB)ewtTxe&SZ1@t&Ap<B6W
z7Hh+TB!|9)R@OKkgGZc|jgwko9$27OOAib%Ry{#sr>GdN4~&RIo4W2ZcukoA)Uz}N
zbXoY~y1|!i?3b`drVn$Kmh^`ka8<xnx#oXfBlQJxrauAU*D%qR6<XW0XZhXG_Cfj^
S4)tx{uA~*(9<(o?dh|beqVjM6

literal 0
HcmV?d00001

diff --git a/DQNAgent/__pycache__/reasoningmodule.cpython-38.pyc b/DQNAgent/__pycache__/reasoningmodule.cpython-38.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a18e95a854fbe791d0a52ab76969004db1c2e04c
GIT binary patch
literal 590
zcmah`y-ve05Vn)FjVekP29OxKW<i1xp^E-Ur~@5{x>S}TlQUJ+CaLUXXvN6HoAi0u
zy7CrG+_`ESx^U9{_<X+a{N1G0YBH3s&rn@)#=hxL6$cNGsOB0CFyJ3-%D@2^JqHhJ
z=pCqsENH}7@kg*98=x8w4X}`H_;|xKwLF@i?%-ZbjM7Ft%axX5n8#(Rvcibo(@6AX
zk;<&o8;OCOB|<A{@+`?_X%6K=-7Htz_DPOV4Ph{@3Hbl9G(9;^REb=?*tS8%iAnM-
zO644(sp%e|Mga7DFBB8F{dWfg;O}f+*Jt2_3|t#uf`@Sp6*&p&<7qR_Ge`=AxLx}%
z%9M+u)2n3f4%z<te5l?e73}KlumRsTlWbWQ5y(QG&VQkispwT21<`@4299Rz>bcK7
iQb$v69JrP>O+T}lN;|tb%ZdN6TR_*cO^o=i@BRW=9dnNW

literal 0
HcmV?d00001

diff --git a/DQNAgent/__pycache__/rlmodule.cpython-38.pyc b/DQNAgent/__pycache__/rlmodule.cpython-38.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5299d1f6064d45430686446456c1fe9cc8dd3991
GIT binary patch
literal 2324
zcmZWq&2QaA5a0FpbKY0dKpN4OstAO8=z#;3P(=wvRFxnSih8l0v~s+ghf{yNuI-XW
zj)c@+`v-tHG{^o4oVmh3uvZRMB@Uc{12b#;y(HbIH=fxY@6P<@x8sMSkxyX!`(jW0
zHX!6rG|mnaj4$9{{s@8-PE(T6kY+|`P_&KI%&gGL?9kS>nL3#px|tVx+P2a`=7+x4
z?Q|_1a)-OmNjSPsxW@<22_HN&LYw=14Q9u}=0iSuLBk0j^9jsM`IN82bDi6JB-nTZ
zQINn;>q!>P1(PB!=6O;jMXn~5II7q}7O^PHB%g!VrLtZK`6MX?XQ_x}4%2G<-8Y@O
zGZ%RUZkw`B1>29%O^T>2wBLk_I4NOgmPL<nKdQ!Mk}beB{ywVqi)uH<XwD7_#y$9#
z76?xE$Sb=0ib#ZbCH}d6@3Yy%Qpj@lZS+(|v#*M{&LEU>wsZf%?8~UiqWt>KgW0`k
zp3G#L6&&KbwRoz$-f-~@0|cRR2=c8!mSy`0Rs{(uC!ql#o7{R%LzCOw0Z=XOau1$1
z9{{*((gx?(KmUZ|*SoL(_#MYzcVnFH2kN-F&hjQG4Q&V`jRBH2CP<^PK$?~H(r)Mh
zJ;ikgv5>$o61ZwDuQL|KShP}&`noU~RYFa8QpQD{SL^^h3aO^zXpt7MhJ}FQ?kgi-
zDEnB*qEzl<Rz>@%2yA7QB0Z23I6+QPtfSaKu>yY$Oyx0_0Am<KtJLJDPWL<BI?s(;
zy>G0sh8J+4zJ%Zw7!^6BFO5^ukVEqkk=L{hAROAKbPrZvI-t9#uVC=xC3sUgGRk?8
zDGQ%EUge^i<dsfFIgy-a(UE)yyaPkNi!a$_1z257Yy=31xayF_)Jq2hp;J0Gj;~zE
z?40wt3M03$%DTc|g8~Ua4G)b|dSYXR5Akm__BPohTbQ)b7~AABIl(kRx5+lnT8*<w
zZUa(x&ZKSYwB>uStxl<}6ILv6b#n3w=#aIh2f!nKh$L5jj(1z9t)}~;teBqYyu6At
zA!Q*iLNcxw9FSriO)kUM9VSD1jUHdUfXR99-N2M1jB|_vwZK94<WVLVQ$Azu#RPrG
z*yB1%+ZDNm{#Q|afMUfzts(97MMFzR<5A!B96c9f1L+6q$TeLE50nPl?>1bdz}S_z
zsJDi;<Y-{ZGbd@L`!Vzn25mC0u7P*kFAVuH=x>m}0o4?H>&){_3|I^2&A}hW-*>w+
zCGL3fz^md&#5LgE)`bC&*<4i6Q?ZC2!W(@IH$jgvhJIiZTaxY*Fe=FQ89gy8+E92}
z6%Y%ac4g|P14OhMyKy-E#X4~t7oxOw11t2Q;m2Zu?IQI0-VzR0ZQV<wd|m@8aGP`z
z@55<oO{U8)MBqz=U1ATHc!eZ_uW?fwB7c&|BFA>!^0CCO+@jnT9dpx_4~EKbKT|-$
zNDcJ&NvnPh-5=V}qOQXARluyME1a72arYC`W%&Kfq|c(8P{V^HkJ8>6#kG{n5Y+%9
zY;P2*Z9U|53{-Pc3(c8zXgp$$t+-=%8Gu)L0|cR7`?CzHfB!kIWfI!`3}VPn!7JEM
z(^X3C6>0IrdaH4tTeqS?#>%V7GRba9Lyz4^dFi5?!%8R{J|K&yZ6`tE=+a2+#8QKg
kVVp^9m7RB|-R5(oc)1B;3f*x^htxAXbG+%<zTsK_0}3oHSO5S3

literal 0
HcmV?d00001

diff --git a/DQNAgent/decisionmakingmodule.py b/DQNAgent/decisionmakingmodule.py
new file mode 100644
index 0000000..cb2e0b9
--- /dev/null
+++ b/DQNAgent/decisionmakingmodule.py
@@ -0,0 +1,8 @@
+from sklearn.tree import DecisionTreeClassifier
+
+def decisionmakingmodule():
+	pass
+
+# Assuming you have a labeled dataset (X_train, y_train)
+model = DecisionTreeClassifier()
+model.fit(X_train, y_train)
\ No newline at end of file
diff --git a/DQNAgent/integrationmodule.py b/DQNAgent/integrationmodule.py
new file mode 100644
index 0000000..7c17b29
--- /dev/null
+++ b/DQNAgent/integrationmodule.py
@@ -0,0 +1,19 @@
+def integrationmodule():
+    pass
+
+def integrate_modules(image_data, text_data, user_input):
+    # Assuming you have the output from each module
+    perception_output = image_recognition(image_data)
+    learning_output = supervised_learning(text_data)
+    reasoning_output = rule_based_reasoning(user_input)
+    language_output = simple_chatbot(user_input)
+
+    # Combine or use the outputs as needed
+    final_output = {
+        "perception": perception_output,
+        "learning": learning_output,
+        "reasoning": reasoning_output,
+        "language": language_output
+    }
+
+    return final_output
\ No newline at end of file
diff --git a/DQNAgent/learningmodule.py b/DQNAgent/learningmodule.py
new file mode 100644
index 0000000..636b120
--- /dev/null
+++ b/DQNAgent/learningmodule.py
@@ -0,0 +1,527 @@
+import gym
+import numpy as np
+from collections import deque
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense
+import QNetwork
+import QLAgent
+from tensorflow.keras import models, layers
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score
+import random
+import copy
+
+def q_learning(env, learning_rate=0.1, discount_factor=0.9, epsilon=0.9, episodes=1000):
+    if isinstance(env.action_space, gym.spaces.Discrete):
+        num_actions = env.action_space.n
+    else:
+        num_actions = env.action_space.shape[0]
+
+    if len(env.observation_space.shape) == 1:
+        state_size = env.observation_space.shape[0]
+    else:
+        state_size = np.prod(env.observation_space.shape)
+
+    Q = np.zeros((state_size, num_actions))
+
+    for episode in range(episodes):
+        state = env.reset()
+        done = False
+        while not done:
+            if np.random.uniform(0, 1) < epsilon:
+                action = env.action_space.sample()
+            else:
+                action = np.argmax(Q[0, :])
+
+            next_state, reward, done, _, _ = env.step(action)
+
+            if len(env.observation_space.shape) == 1:
+                state_as_integer = int(0)
+            else:
+                state_as_integer = int(np.ravel_multi_index(state, env.observation_space.shape))
+
+            action = int(action)
+            action = np.clip(1, 0, num_actions - 1)
+            Q[0, 1] += learning_rate * (
+                    reward + discount_factor * np.max(Q[2, :]) - Q[2, 1])
+
+            state = next_state
+
+    return Q
+
+def DQNAgent(state_size, action_size):
+    dqn_agent = DQNAgent(state_size, action_size)
+
+def get_num_episodes():
+    return 100
+
+def shape(space):
+    if isinstance(space, gym.spaces.Discrete):
+        return space.n
+    else:
+        return space.shape[0]
+
+def observation_space():
+    pass
+
+def action_space():
+    
+
+    def QLearningAgent(_, self, num_actions, learning_rate, discount_factor, exploration_prob, num_states, action_space):
+        agent = QLearningAgent(q_table, env.observation_space, env.action_space)
+
+        def run_q_learning(agent, env, _):
+            pass
+
+        def num_actions():
+            pass
+
+        def learning_rate():
+            pass
+
+        def discount_factor():
+            pass
+
+        def exploration_prob():
+            pass
+
+        def num_states():
+            pass
+
+        def env(observation_space, action_space, n):
+            observation_space = (4,)
+            action_space = (2)
+
+class DQNAgent:
+    def __init__(self, state_size, action_size):
+        self.state_size = state_size
+        self.action_size = action_size
+        self.memory = deque(maxlen=2000)
+        self.gamma = 0.95
+        self.epsilon = 1.0
+        self.epsilon_min = 0.01
+        self.epsilon_decay = 0.995
+        self.learning_rate = 0.001
+        self.model = self._build_model(state_size)
+
+    def set_input_shape(self, observation_space):
+        input_shape = observation_space.shape[0]
+        self.model = self._build_model(input_shape)
+
+    def _build_model(self, input_shape):
+        model = Sequential()
+        model.add(Dense(24, input_dim=input_shape, activation='relu'))  # Use input_dim instead of input_shape
+        model.add(Dense(24, activation='relu'))
+        model.add(Dense(64, activation='relu'))
+        model.add(Dense(self.action_size, activation='linear'))
+        model.compile(loss='mse', optimizer='adam')
+        return model
+
+    def remember(self, state, action, reward, next_state, done):
+        self.memory.append((state, action, reward, next_state, done))
+
+    def act(self, state):
+        state = np.reshape(state, (1, -1))  # Reshape the state if needed
+        if np.random.rand() <= self.epsilon:
+            return np.random.choice(self.action_size)
+        act_values = self.model.predict(state)
+        return np.argmax(act_values[0])
+
+    def replay(self, batch_size):
+        minibatch = random.sample(self.memory, batch_size)
+        for state, action, reward, next_state, done in minibatch:
+            target = reward
+            if not done:
+                next_state = np.reshape(next_state, (1, -1))  # Reshape next_state
+                target = (reward + self.gamma * np.amax(self.model.predict(next_state)[0]))
+
+            state_array = np.array(state).reshape((1, -1))  # Reshape the state if needed
+            target_f = self.model.predict(state_array)
+            target_f[0][action] = target
+            self.model.fit(state, target_f, epochs=1, verbose=0)
+
+        if self.epsilon > self.epsilon_min:
+            self.epsilon *= self.epsilon_decay
+
+    def predict(self, state):
+        state = np.reshape(state, (1, -1))
+        return np.argmax(self.model.predict(state)[0])
+
+dtype = object
+env = gym.make('CartPole-v1')
+state_size = env.observation_space.shape[0]
+action_size = env.action_space.n
+agent = DQNAgent(state_size, action_size)
+agent.set_input_shape(env.observation_space)
+
+# Create an instance of the DQNAgent
+dqn_agent = DQNAgent(env.observation_space.shape[0], env.action_space.n)
+
+# Training the DQN
+state = env.reset()
+state = np.reshape(state, [-1, 1])
+for time in range(500):
+    action = dqn_agent.act(state)
+    next_state, reward, done, _, _ = env.step(action)
+    reward = reward if not done else -10
+    next_state = np.reshape(next_state, [-1, 1])
+    dqn_agent.remember(state, action, reward, next_state, done)
+    state = next_state
+    if done:
+        break
+    if len(dqn_agent.memory) > 32:
+        dqn_agent.replay(32)
+
+class QLearningAgent:
+    def __init__(self, q_table, observation_space, action_space, learning_rate=0.1, discount_factor=0.9, exploration_prob=0.1):
+        self.q_table = q_table
+        self.num_actions = action_space.n if hasattr(action_space, 'n') else action_space.shape[0]  # Use shape[0] for continuous action space
+        self.num_states = observation_space.shape[0]  # Use shape[0] for the number of dimensions
+        self.learning_rate = learning_rate
+        self.discount_factor = discount_factor
+        self.exploration_rate = exploration_prob
+
+        def __init__(self, q_table, observation_space, action_space, learning_rate=0.1, discount_factor=0.9, exploration_prob=0.1):
+            self.q_table = q_table
+            self.num_actions = action_space.n if hasattr(action_space, 'n') else action_space.shape[2]
+            self.num_states = observation_space.shape[0]
+
+        def q_learning(env, learning_rate=0.1, discount_factor=0.9, epsilon=0.9, episodes=1000):
+            if isinstance(env.action_space, gym.spaces.Discrete):
+                num_actions = env.action_space.n
+            else:
+                num_actions = env.action_space.shape[0]
+
+            Q = np.zeros((env.observation_space.n, num_actions))  # Corrected size of Q-table
+
+            for episode in range(episodes):
+                state = env.reset()
+                done = False
+                while not done:
+                    if np.random.uniform(0, 1) < epsilon:
+                        action = env.action_space.sample()
+                    else:
+                        action = np.argmax(Q[state, :])
+
+                    next_state, reward, done, _ = env.step(action)
+
+                    # Update Q-value
+                    Q[state, action] += learning_rate * (reward + discount_factor * np.max(Q[next_state, :]) - Q[state, action])
+
+                    state = next_state
+
+            return Q
+
+        # Main part of the code
+        env = gym.make('CartPole-v1')
+
+        # Q-learning parameters
+        learning_rate_q = 0.1
+        discount_factor_q = 0.9
+        exploration_prob_q = 0.1
+        num_episodes_q = 100
+
+        # Initialize Q-table for Q-learning
+        q_table = q_learning(env, learning_rate=learning_rate_q, discount_factor=discount_factor_q, epsilon=exploration_prob_q, episodes=num_episodes_q)
+
+        # Create Q-learning agent
+        q_agent = QLearningAgent(q_table, env.observation_space, env.action_space, learning_rate_q, discount_factor_q, exploration_prob_q)
+
+        # Run Q-learning
+        num_episodes_q = 100
+        run_q_learning(q_agent, env, num_episodes_q)
+
+        # Use Q-learning data to train a supervised learning model
+        states_q = np.arange(env.observation_space.n)
+        actions_q = np.argmax(q_agent.q_table, axis=1)
+        X_q = states_q.reshape(-1, 1)
+        y_q = actions_q
+
+        # Train supervised learning model
+        supervised_model = supervised_learning(X_q, y_q)
+
+        def select_action(self, state):
+            if np.random.rand() < self.exploration_rate:
+                return np.random.choice(self.num_actions)
+            else:
+                return np.argmax(self.q_table[state, :])
+
+        def update_q_table(self, state, action, reward, next_state):
+            best_next_action = np.argmax(self.q_table[next_state, :])
+            td_target = reward + self.discount_factor * self.q_table[next_state, best_next_action]
+            td_error = td_target - self.q_table[state, action]
+            self.q_table[state, action] += self.learning_rate * td_error
+
+        def q_learning(env, learning_rate, discount_factor, epsilon, episodes):
+            model = Sequential([
+                Dense(64, input_shape=(env.observation_space.shape[0],), activation='relu'),
+                Dense(env.action_space.n, activation='linear')
+            ])
+            model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate), loss='mse')
+
+            for episode in range(episodes):
+                state = env.reset()
+                state = np.reshape(state, [1, env.observation_space.shape[0]])
+
+                for time in range(500):  # Adjust the maximum time steps as needed
+                    # Choose action using epsilon-greedy policy or exploration strategy
+                    action = epsilon_greedy_policy(model, state, epsilon)
+
+                    # Take the chosen action and observe the next state and reward
+                    next_state, reward, done, _ = env.step(action)
+                    next_state = np.reshape(next_state, [1, env.observation_space.shape[0]])
+
+                    # Update Q-values using the Bellman equation and backpropagation
+                    target = reward + discount_factor * np.max(model.predict(next_state))
+                    target_f = model.predict(state)
+                    target_f[0][action] = target
+                    model.fit(state, target_f, epochs=1, verbose=0)
+
+                    state = next_state
+
+                    if done:
+                        break
+
+            return model
+        
+        def get_num_actions(self, action_space):
+            if isinstance(action_space, gym.spaces.Discrete):
+                return action_space.n
+            else:
+                return action_space.shape[2]
+
+        Q = np.zeros((env.observation_space.shape[4], env.action_space.shape[2]))
+        env = gym.make('CartPole-v1')
+        num_states = agent.num_states()
+        num_actions = agent.num_actions()
+        state_size = env.observation_space.shape[4]
+        action_size = env.action_space.n if hasattr(env.action_space, 'n') else env.action_space.shape[2]
+        q_table = np.zeros((env.observation_space.shape[4], action_size))  # Initialize q_table
+        agent = QLearningAgent(q_table, env.observation_space, env.action_space)
+        num_episodes = 100
+        run_q_learning(agent, env, num_episodes)
+
+class SupervisedLearningModel:
+    def __init__(self):
+        self.model = DecisionTreeClassifier()
+
+    def train(self, X_train, y_train):
+        self.model.fit(X_train, y_train)
+
+    def predict(self, X_test):
+        return self.model.predict(X_test)
+
+def supervised_learning(X, y):
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+    model = SupervisedLearningModel()
+    model.train(X_train, y_train)
+    y_pred = model.predict(X_test)
+    accuracy = accuracy_score(y_test, y_pred)
+    print(f"Accuracy: {accuracy}")
+    return model
+
+# Initializing the environment
+env = gym.make('CartPole-v1')
+state = env.reset()
+state = np.reshape(state, (-1, 1))
+
+# Running the Q-learning algorithm
+Q_table = q_learning(env)
+
+# Using the Q-table for inference
+state = env.reset()
+done = False
+while not done:
+    action = np.argmax(Q_table[0, :])
+    next_state, reward, done, _, _ = env.step(action)
+    state = next_state
+
+Q = np.zeros((env.observation_space.shape[0], env.action_space.n))
+
+# Instantiate QLearningAgent
+if isinstance(env.observation_space, gym.spaces.Discrete):
+    q_table = np.zeros((env.observation_space.n, env.action_space.n))
+else:
+    q_table = np.zeros((env.observation_space.shape[0], env.action_space.n))  # Initialize q_table
+agent = QLearningAgent(q_table, env.observation_space, env.action_space)
+
+# Call the run_q_learning function
+num_episodes = 100
+agent.run_q_learning(env, num_episodes)
+
+# After running Q-learning, we can use the learned Q-table to generate a dataset for supervised learning
+states = np.arange(env.observation_space.n)
+actions = np.argmax(agent.q_table, axis=1)
+
+# The states are the inputs and the actions are the outputs
+X = states.reshape(-1, 1)
+y = actions
+
+# Train a supervised learning model on the Q-learning data
+supervised_model = supervised_learning(X, y)
+
+# Training the DQN
+state = env.reset()
+state = np.reshape(state, [-1, 1])
+for time in range(500):
+    action = dqn_agent.act(state)
+    next_state, reward, done, _, _ = env.step(action)
+    reward = reward if not done else -10
+    next_state = np.reshape(next_state, [-1, 1])
+    dqn_agent.remember(state, action, reward, next_state, done)
+    state = next_state
+    if done:
+        break
+    if len(dqn_agent.memory) > 32:
+        dqn_agent.replay(32)
+
+# Instantiate QLearningAgent
+q_table = np.zeros([0])  # Initialize q_table
+agent = QLearningAgent(q_table, env.observation_space, env.action_space)
+
+# Call the run_q_learning function
+num_episodes = 100
+run_q_learning(agent, env, num_episodes)
+
+# Using the Q-learning data to train a supervised learning model
+states = np.arange(env.observation_space.n)
+actions = np.argmax(agent.q_table, axis=1)
+X = states.reshape(-1, 1)
+y = actions
+supervised_model = supervised_learning(X, y)
+
+env = gym.make('CartPole-v1')
+state = env.reset()
+state = np.reshape(state, (1, -1))  # Reshape the state
+observation_space = env.observation_space
+action_space = env.action_space
+
+dqn_agent = DQNAgent(state_size, env.action_space.n)  # Pass state.shape[1] as state_size
+agent.set_input_shape(env.observation_space)
+
+# Training the DQN
+state = env.reset()
+state = np.reshape(state, [-1, 1])
+for time in range(500):
+    action = agent.act(state)
+    next_state, reward, done, _, _ = env.step(action)
+    reward = reward if not done else -10
+    next_state = np.reshape(next_state, [-1, 1])
+    agent.remember(state, action, reward, next_state, done)
+    state = next_state
+    if done:
+        break
+    if len(agent.memory) > 32:
+        agent.replay(32)
+
+q_table = np.zeros((observation_space.n, action_space.n))  # Initialize q_table
+agent = QLearningAgent(q_table, observation_space, action_space)  # Instantiate QLearningAgent
+num_episodes = 100
+run_q_learning(agent, env, num_episodes)  # Call the run_q_learning function
+
+# After running Q-learning, we can use the learned Q-table to generate a dataset for supervised learning
+states = np.arange(env.observation_space.n)
+actions = np.argmax(agent.q_table, axis=1) 
+
+# The states are the inputs and the actions are the outputs
+X = states.reshape(-1, 1)
+y = actions
+
+# Train a supervised learning model on the Q-learning data
+supervised_model = supervised_learning(X, y)
+
+def q_learning(env, learning_rate=0.1, discount_factor=0.9, epsilon=0.9, episodes=1000):
+    # Initializing Q-table
+    Q = np.zeros((env.observation_space, env.action_space))
+
+    # Q-learning algorithm
+    for episode in range(episodes):
+        state = env.reset()
+        done = False
+        while not done:
+            # Selecting action using epsilon-greedy strategy
+            if np.random.uniform(0, 1) < epsilon:
+                action = env.action_space.sample()
+            else:
+                action = np.argmax(Q[state, :])
+
+            # Taking action and observing next state and reward
+            next_state, reward, done, _ = env.step(action)
+
+            # Updating Q-value
+            Q[state, action] += learning_rate * (reward + discount_factor * np.max(Q[next_state, :]) - Q[state, action])
+
+            state = next_state
+
+    return Q
+
+# Initializing the environment
+env = gym.make('CartPole-v1')
+state = env.reset()
+state = np.reshape(state, (-1, 1))
+# Running the Q-learning algorithm
+Q_table = q_learning(env)
+
+# Using the Q-table for inference
+state = env.reset()
+done = False
+while not done:
+    action = np.argmax(Q_table[state, :])
+    next_state, reward, done, _ = env.step(action)
+    state = next_state
+
+env = gym.make('FrozenLake-v1')
+agent = QLearningAgent(q_table, observation_space, action_space)
+run_q_learning(agent, env, 100)
+
+env = gym.make('CartPole-v1')
+state_size = env.observation_space.shape[0]
+action_size = env.action_space.n
+agent = DQNAgent(state_size, action_size)
+agent.set_input_shape(env.observation_space)
+
+if __name__ == "__main__":
+    # Example usage for Q-learning
+    env_q = gym.make('CartPole-v1')
+    q_table = q_learning(env_q)
+    q_agent = QLearningAgent(q_table, env_q.observation_space, env_q.action_space)
+    q_agent.run_q_learning(env_q, 100)
+
+    # Example usage for DQN
+    env_dqn = gym.make('CartPole-v1')
+    state_size_dqn = env_dqn.observation_space.shape[0]
+    action_size_dqn = env_dqn.action_space.n
+    agent_dqn = DQNAgent(state_size_dqn, action_size_dqn)
+    agent_dqn.set_input_shape(env_dqn.observation_space)
+
+    state_dqn = env_dqn.reset()
+    state_dqn = np.reshape(state_dqn, (1, -1))
+    for time in range(500):
+        action_dqn = agent_dqn.act(state_dqn)
+        next_state_dqn, reward_dqn, done_dqn, _, _ = env_dqn.step(action_dqn)
+        reward_dqn = reward_dqn if not done_dqn else -10
+        next_state_dqn = np.reshape(next_state_dqn, (1, -1))
+        agent_dqn.remember(state_dqn, action_dqn, reward_dqn, next_state_dqn, done_dqn)
+        state_dqn = next_state_dqn
+        if done_dqn:
+            break
+        if len(agent_dqn.memory) > 32:
+            agent_dqn.replay(32)
+
+    # Example usage for Q-learning with Supervised Learning
+    env_q_sl = gym.make('CartPole-v1')
+    q_table_sl = q_learning(env_q_sl)
+    q_agent_sl = QLearningAgent(q_table_sl, env_q_sl.observation_space, env_q_sl.action_space)
+    q_agent_sl.run_q_learning(env_q_sl, 100)
+
+    # Use Q-learning data to train a supervised learning model
+    states_q_sl = np.arange(env_q_sl.observation_space.n)
+    actions_q_sl = np.argmax(q_agent_sl.q_table, axis=1)
+    X_q_sl = states_q_sl.reshape(-1, 1)
+    y_q_sl = actions_q_sl
+
+    # Train supervised learning model
+    supervised_model_sl = supervised_learning(X_q_sl, y_q_sl)
+
+print(f"State: {state}, Action: {action}, Next State: {next_state}")
\ No newline at end of file
diff --git a/DQNAgent/lpmodule.py b/DQNAgent/lpmodule.py
new file mode 100644
index 0000000..6478291
--- /dev/null
+++ b/DQNAgent/lpmodule.py
@@ -0,0 +1,13 @@
+import random
+
+def lpmodule():
+    pass
+
+def simple_chatbot(user_input):
+    responses = {
+        "How are you?": "I'm good, thank you!",
+        "What's your name?": "I'm a simple chatbot.",
+        "Default": "I'm not sure how to respond to that."
+    }
+
+    return responses.get(user_input, responses["Default"])
\ No newline at end of file
diff --git a/DQNAgent/perceptionmodule.py b/DQNAgent/perceptionmodule.py
new file mode 100644
index 0000000..ea952df
--- /dev/null
+++ b/DQNAgent/perceptionmodule.py
@@ -0,0 +1,85 @@
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers
+from tensorflow.keras import Sequential
+from sklearn.feature_extraction.text import CountVectorizer
+
+mnist = tf.keras.datasets.mnist
+
+(x_train, y_train), (x_test, y_test) = mnist.load_data()
+x_train, x_test = x_train / 255.0, x_test / 255.0
+
+def text_processing(corpus):
+    # Tokenize the text data
+    tokenizer = tf.keras.preprocessing.text.Tokenizer()
+    tokenizer.fit_on_texts(corpus)
+
+    # Convert text to sequences of integers
+    sequences = tokenizer.texts_to_sequences(corpus)
+
+    # Pad sequences to have consistent length
+    padded_sequences = tf.keras.preprocessing.sequence.pad_sequences(sequences)
+
+    # Print the processed data
+    print("Processed Text Data:")
+    print(padded_sequences)
+
+# Sample text data
+corpus = ["This is a simple text.", "Text processing example.", "Natural Language Processing is interesting."]
+
+# Call the text_processing function
+text_processing(corpus)
+
+def image_recognition():
+    # Build a simple CNN model for image recognition
+    model = tf.keras.models.Sequential([
+        tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(64, 64, 3)),
+        tf.keras.layers.MaxPooling2D((2, 2)),
+        tf.keras.layers.Flatten(),
+        tf.keras.layers.Dense(64, activation='relu'),
+        tf.keras.layers.Dense(10, activation='softmax')
+    ])
+
+    # Compile the model
+    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
+
+    # Your image recognition logic goes here
+    pass
+
+def perception_module(input_shape):
+    model = tf.keras.models.Sequential([
+        layers.Flatten(input_shape=input_shape),  # Flatten the input
+        layers.Dense(64, activation='relu'),       # Dense layer with ReLU activation
+        layers.Dense(32, activation='relu'),       # Additional Dense layer
+        layers.Dense(1, activation='sigmoid')      # Output layer with Sigmoid activation for binary classification
+    ])
+
+    # Compile the model
+    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
+
+    return model
+
+# Example usage:
+input_shape = (64, 64, 3)  # Adjust the input shape based on your data
+perception_model = perception_module(input_shape)
+
+# Display the model summary
+perception_model.summary()
+
+# Example usage:
+input_shape = (64, 64, 3)  # Adjust the input shape based on your data
+perception_model = perception_module(input_shape)
+
+# Display the model summary
+perception_model.summary()
+# Sample text data
+corpus = ["This is a simple text.", "Text processing example.", "Natural Language Processing is interesting."]
+
+# Create a bag-of-words model using CountVectorizer
+vectorizer = CountVectorizer()
+X = vectorizer.fit_transform(corpus)
+
+# Call the respective functions based on your workflow
+text_processing(corpus)
+image_recognition()
+perception_module(input_shape)
\ No newline at end of file
diff --git a/DQNAgent/reasoningmodule.py b/DQNAgent/reasoningmodule.py
new file mode 100644
index 0000000..5521dac
--- /dev/null
+++ b/DQNAgent/reasoningmodule.py
@@ -0,0 +1,13 @@
+def reasoningmodule():
+    pass
+
+def decision_making():
+    pass
+
+def rule_based_reasoning(input_data):
+    if "condition1" in input_data:
+        return "Result A"
+    elif "condition2" in input_data:
+        return "Result B"
+    else:
+        return "Default Result"
\ No newline at end of file
diff --git a/DQNAgent/rlmodule.py b/DQNAgent/rlmodule.py
new file mode 100644
index 0000000..42618b4
--- /dev/null
+++ b/DQNAgent/rlmodule.py
@@ -0,0 +1,66 @@
+from perceptionmodule import image_recognition, text_processing
+from learningmodule import supervised_learning, QLearningAgent
+from reasoningmodule import rule_based_reasoning, decision_making
+from lpmodule import simple_chatbot
+import numpy as np
+
+def rlmodule():
+    pass
+
+class QLearningAgent:
+    def __init__(self, num_actions, learning_rate=0.1, discount_factor=0.9, exploration_prob=0.1):
+        self.num_actions = num_actions
+        self.learning_rate = learning_rate
+        self.discount_factor = discount_factor
+        self.exploration_prob = exploration_prob
+        self.q_table = np.zeros((num_actions,))
+
+    def select_action(self, state):
+        if np.random.rand() < self.exploration_prob:
+            return np.random.randint(self.num_actions)  # Exploration
+        else:
+            return np.argmax(self.q_table)  # Exploitation
+
+    def update_q_table(self, state, action, reward, next_state):
+        best_next_action = np.argmax(self.q_table)
+        td_error = reward + self.discount_factor * self.q_table[best_next_action] - self.q_table[action]
+        self.q_table[action] += self.learning_rate * td_error
+
+
+def cagi_agent(states):
+    # Placeholder function, replace with actual state representation logic
+    return states[0]
+
+# RL Agent
+rl_agent = QLearningAgent(num_actions=3)  # Assuming 3 possible actions
+
+def execute_action_and_get_reward(action):
+    # Placeholder function, replace with actual action execution and reward logic
+    return 1.0  # Placeholder reward
+
+def integrate_modules(image_data, text_data, user_input):
+    perception_output = image_recognition(image_data)
+    learning_output = supervised_learning(text_data)
+    reasoning_output = rule_based_reasoning(user_input)
+    language_output = simple_chatbot(user_input)
+
+    # Combine or use the outputs as needed
+    final_output = {
+        "perception": perception_output,
+        "learning": learning_output,
+        "reasoning": reasoning_output,
+        "language": language_output
+    }
+
+    return final_output
+
+    # RL Module
+    current_state = cagi_agent(environment_states)
+    rl_action = rl_agent.select_action(current_state)
+    rl_reward = execute_action_and_get_reward(rl_action)
+    next_state = cagi_agent(environment_states)
+    rl_agent.update_q_table(current_state, rl_action, rl_reward, next_state)
+
+    final_output["rl_learning"] = {"action": rl_action, "reward": rl_reward}
+
+    return final_output
\ No newline at end of file