text
stringlengths
2.42k
4.01k
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '*', '^', '*', '*', '*', '*', '*', '^', '*', '^', '^'], ['^', '^', '*', '*', '*', '*', '^', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '*', '^', '*', '*', '*', '*', '^', '^', '^', '*', '*', '^'], ['^', '^', '^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '^', '*', '*', '^', '*', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '^', '*', '*', '^', '*', '*', '^', '*', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '^', '^', '*', '*', '*', '^', '*', '*', '*', '^', '^'], ['^', '*', '^', '^', '*', '*', '*', '*', '*', '*', '^', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '^', '*', '*', '*', '^', '^', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^', '^', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] ``` Information about the problem: 1. "S": agent 2. "H": goal 3. "^": wall 4. "*": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "H": 1 [/INST] import numpy as np maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '*', '^', '*', '*', '*', '*', '*', '^', '*', '^', '^'], ['^', '^', '*', '*', '*', '*', '^', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '*', '^', '*', '*', '*', '*', '^', '^', '^', '*', '*', '^'], ['^', '^', '^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '^', '*', '*', '^', '*', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '^', '*', '*', '^', '*', '*', '^', '*', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '^', '^', '*', '*', '*', '^', '*', '*', '*', '^', '^'], ['^', '*', '^', '^', '*', '*', '*', '*', '*', '*', '^', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '^', '*', '*', '*', '^', '^', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^', '^', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'H': V[i][j] = 3 continue if maze[i][j] == '^': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', '*', '*', ' ', '*', '*', ' ', '*'], ['*', ' ', ' ', '*', '*', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', '*', '*', '*', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', '*', '*', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', '*', '*', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] ``` Information about the problem: 1. "E": agent 2. "T": goal 3. "*": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "T": 1 [/INST] import numpy as np maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', '*', '*', ' ', '*', '*', ' ', '*'], ['*', ' ', ' ', '*', '*', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', '*', '*', '*', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', '*', '*', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', '*', '*', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'T': V[i][j] = 5 continue if maze[i][j] == '*': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', 'O', '.', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', 'O', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', '.', 'O'], ['O', 'O', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O', 'O'], ['O', 'O', '.', '.', '.', '.', '.', 'O', '.', 'O', '.', 'O', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', 'O', '.', 'O', '.', 'O', '.', '.', 'O'], ['O', '.', '.', 'O', 'O', '.', '.', 'O', 'O', '.', 'O', '.', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "R": agent 2. "P": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "P": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', 'O', '.', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', 'O', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', '.', 'O'], ['O', 'O', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O', 'O'], ['O', 'O', '.', '.', '.', '.', '.', 'O', '.', 'O', '.', 'O', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', 'O', '.', 'O', '.', 'O', '.', '.', 'O'], ['O', '.', '.', 'O', 'O', '.', '.', 'O', 'O', '.', 'O', '.', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'P': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', '*'], ['*', ' ', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', '*', '*'], ['*', ' ', '*', '*', ' ', '*', ' ', ' ', ' ', ' ', '*', '*'], ['*', ' ', '*', ' ', ' ', '*', '*', ' ', ' ', ' ', '*', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', '*', '*', ' ', '*', ' ', ' ', ' ', ' ', '*', '*'], ['*', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] ``` Information about the problem: 1. "E": agent 2. "T": goal 3. "*": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "T": 1 [/INST] import numpy as np maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', '*'], ['*', ' ', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', '*', '*'], ['*', ' ', '*', '*', ' ', '*', ' ', ' ', ' ', ' ', '*', '*'], ['*', ' ', '*', ' ', ' ', '*', '*', ' ', ' ', ' ', '*', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', '*', '*', ' ', '*', ' ', ' ', ' ', ' ', '*', '*'], ['*', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'T': V[i][j] = 5 continue if maze[i][j] == '*': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '.', '@', '@', '.', '.', '.', '@', '.', '@', '.', '.', '.', '@'], ['@', '.', '.', '.', '@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '@', '.', '.', '.', '.', '@', '.', '@', '.', '.', '@', '.', '.', '@'], ['@', '@', '.', '.', '.', '@', '.', '.', '.', '@', '@', '.', '.', '.', '@'], ['@', '.', '@', '.', '@', '@', '.', '@', '@', '.', '.', '.', '.', '.', '@'], ['@', '@', '@', '.', '.', '@', '.', '.', '.', '.', '.', '.', '.', '@', '@'], ['@', '@', '.', '.', '.', '@', '.', '.', '@', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '@', '.', '@', '.', '.', '.', '.', '@'], ['@', '.', '.', '@', '.', '@', '.', '.', '@', '.', '.', '@', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '@', '.', '.', '.', '.', '.', '.', '@', '.', '.', '.', '.', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] ``` Information about the problem: 1. "T": agent 2. "O": goal 3. "@": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "O": 1 [/INST] import numpy as np maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '.', '@', '@', '.', '.', '.', '@', '.', '@', '.', '.', '.', '@'], ['@', '.', '.', '.', '@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '@', '.', '.', '.', '.', '@', '.', '@', '.', '.', '@', '.', '.', '@'], ['@', '@', '.', '.', '.', '@', '.', '.', '.', '@', '@', '.', '.', '.', '@'], ['@', '.', '@', '.', '@', '@', '.', '@', '@', '.', '.', '.', '.', '.', '@'], ['@', '@', '@', '.', '.', '@', '.', '.', '.', '.', '.', '.', '.', '@', '@'], ['@', '@', '.', '.', '.', '@', '.', '.', '@', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '@', '.', '@', '.', '.', '.', '.', '@'], ['@', '.', '.', '@', '.', '@', '.', '.', '@', '.', '.', '@', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '@', '.', '.', '.', '.', '.', '.', '@', '.', '.', '.', '.', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '@' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'O': V[i][j] = 2 continue if maze[i][j] == '@': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', 'O', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', 'O', '.', '.', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', 'O', 'O', '.', 'O', 'O', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', 'O', 'O', '.', '.', '.', 'O', '.', '.', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', 'O', 'O', '.', 'O', '.', '.', '.', 'O', 'O', 'O'], ['O', '.', 'O', 'O', '.', 'O', 'O', '.', '.', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "R": agent 2. "P": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "P": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', 'O', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', 'O', '.', '.', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', 'O', 'O', '.', 'O', 'O', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', 'O', 'O', '.', '.', '.', 'O', '.', '.', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', 'O', 'O', '.', 'O', '.', '.', '.', 'O', 'O', 'O'], ['O', '.', 'O', 'O', '.', 'O', 'O', '.', '.', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'P': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'D', '-', '-', '-', '-', '-', '-', '~'], ['~', '-', '-', '~', '-', '~', '~', '~', '~'], ['~', '-', '-', '-', '-', '~', '~', '-', '~'], ['~', '-', '-', '~', '-', '-', '-', '-', '~'], ['~', '-', '-', '~', '-', '-', '-', '-', '~'], ['~', '-', '~', '-', '-', '-', '-', '~', '~'], ['~', '-', '~', '~', '-', '-', '~', '-', '~'], ['~', '-', '-', '-', '~', '-', '~', 'C', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~'], ] ``` Information about the problem: 1. "D": agent 2. "C": goal 3. "~": wall 4. "-": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "C": 1 [/INST] import numpy as np maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'D', '-', '-', '-', '-', '-', '-', '~'], ['~', '-', '-', '~', '-', '~', '~', '~', '~'], ['~', '-', '-', '-', '-', '~', '~', '-', '~'], ['~', '-', '-', '~', '-', '-', '-', '-', '~'], ['~', '-', '-', '~', '-', '-', '-', '-', '~'], ['~', '-', '~', '-', '-', '-', '-', '~', '~'], ['~', '-', '~', '~', '-', '-', '~', '-', '~'], ['~', '-', '-', '-', '~', '-', '~', 'C', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'C': V[i][j] = 2 continue if maze[i][j] == '~': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', '~', ' ', '~', ' ', ' ', '~', ' ', '~', '~'], ['~', '~', '~', ' ', '~', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~'], ['~', ' ', '~', '~', ' ', '~', ' ', ' ', '~', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', '~', '~', ' ', ' ', '~', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] ``` Information about the problem: 1. "P": agent 2. "X": goal 3. "~": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "X": 1 [/INST] import numpy as np maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', '~', ' ', '~', ' ', ' ', '~', ' ', '~', '~'], ['~', '~', '~', ' ', '~', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~'], ['~', ' ', '~', '~', ' ', '~', ' ', ' ', '~', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', '~', '~', ' ', ' ', '~', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'X': V[i][j] = 5 continue if maze[i][j] == '~': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', '.', 'O', '.', '.', 'O', '.', '.', '.', 'O', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', 'O', 'O', 'O', '.', '.', 'O'], ['O', '.', '.', 'O', 'O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', 'O', 'O'], ['O', 'O', 'O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', 'O', '.', '.', '.', '.', '.', 'O', '.', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "R": agent 2. "P": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "P": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', '.', 'O', '.', '.', 'O', '.', '.', '.', 'O', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', 'O', 'O', 'O', '.', '.', 'O'], ['O', '.', '.', 'O', 'O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', 'O', 'O'], ['O', 'O', 'O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', 'O', '.', '.', '.', '.', '.', 'O', '.', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'P': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', '*', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', '*'], ['*', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*'], ['*', '*', ' ', ' ', '*', '*', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', '*', '*', '*', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] ``` Information about the problem: 1. "E": agent 2. "T": goal 3. "*": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "T": 1 [/INST] import numpy as np maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', '*', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', '*'], ['*', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*'], ['*', '*', ' ', ' ', '*', '*', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', '*', '*', '*', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'T': V[i][j] = 5 continue if maze[i][j] == '*': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '^', '^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '^', '*', '*', '^', '^', '*', '*', '*', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '*', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '^', '^', '*', '*', '^', '*', '^', '*', '*', '^', '*', '^'], ['^', '^', '*', '*', '*', '^', '^', '*', '^', '*', '*', '*', '*', '^', '^'], ['^', '*', '^', '*', '*', '*', '*', '*', '*', '*', '^', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '^', '*', '*', '^', '*', '^', '*', '*', '^', '^'], ['^', '*', '^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] ``` Information about the problem: 1. "S": agent 2. "H": goal 3. "^": wall 4. "*": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "H": 1 [/INST] import numpy as np maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '^', '^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '^', '*', '*', '^', '^', '*', '*', '*', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '*', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '^', '^', '*', '*', '^', '*', '^', '*', '*', '^', '*', '^'], ['^', '^', '*', '*', '*', '^', '^', '*', '^', '*', '*', '*', '*', '^', '^'], ['^', '*', '^', '*', '*', '*', '*', '*', '*', '*', '^', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '^', '*', '*', '^', '*', '^', '*', '*', '^', '^'], ['^', '*', '^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'H': V[i][j] = 3 continue if maze[i][j] == '^': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', '*'], ['*', ' ', '*', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*', ' ', '*', '*', '*', ' ', '*'], ['*', ' ', ' ', '*', '*', '*', ' ', ' ', '*', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', '*', '*', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] ``` Information about the problem: 1. "E": agent 2. "T": goal 3. "*": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "T": 1 [/INST] import numpy as np maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', '*'], ['*', ' ', '*', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*', ' ', '*', '*', '*', ' ', '*'], ['*', ' ', ' ', '*', '*', '*', ' ', ' ', '*', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', '*', '*', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'T': V[i][j] = 5 continue if maze[i][j] == '*': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '@', '.', '@', '@', '@', '.', '@', '.', '@'], ['@', '@', '.', '.', '.', '@', '.', '.', '.', '.', '@'], ['@', '.', '@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '@', '.', '@', '@', '@'], ['@', '.', '@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '@', '.', '.', '@', '.', '@', '.', '.', '@', '@'], ['@', '.', '@', '.', '.', '@', '.', '.', '.', '.', '@'], ['@', '@', '.', '.', '.', '.', '.', '.', '.', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] ``` Information about the problem: 1. "T": agent 2. "O": goal 3. "@": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "O": 1 [/INST] import numpy as np maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '@', '.', '@', '@', '@', '.', '@', '.', '@'], ['@', '@', '.', '.', '.', '@', '.', '.', '.', '.', '@'], ['@', '.', '@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '@', '.', '@', '@', '@'], ['@', '.', '@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '@', '.', '.', '@', '.', '@', '.', '.', '@', '@'], ['@', '.', '@', '.', '.', '@', '.', '.', '.', '.', '@'], ['@', '@', '.', '.', '.', '.', '.', '.', '.', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '@' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'O': V[i][j] = 2 continue if maze[i][j] == '@': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', '~', ' ', '~', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', '~', '~', '~', ' ', ' ', ' ', '~'], ['~', ' ', '~', ' ', '~', ' ', '~', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', '~', ' ', '~', ' ', ' ', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] ``` Information about the problem: 1. "P": agent 2. "X": goal 3. "~": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "X": 1 [/INST] import numpy as np maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', '~', ' ', '~', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', '~', '~', '~', ' ', ' ', ' ', '~'], ['~', ' ', '~', ' ', '~', ' ', '~', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', '~', ' ', '~', ' ', ' ', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'X': V[i][j] = 5 continue if maze[i][j] == '~': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '.', '.', '.', '@', '.', '.', '.', '@'], ['@', '.', '.', '@', '@', '@', '.', '.', '@', '@'], ['@', '@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '@', '@', '@', '.', '.', '.', '@'], ['@', '.', '.', '@', '.', '.', '.', '@', '.', '@'], ['@', '.', '@', '@', '.', '@', '.', '@', '.', '@'], ['@', '.', '.', '.', '@', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '@', '@', '.', '@', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '@', '.', '.', '@'], ['@', '@', '.', '@', '.', '.', '@', '.', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] ``` Information about the problem: 1. "T": agent 2. "O": goal 3. "@": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "O": 1 [/INST] import numpy as np maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '.', '.', '.', '@', '.', '.', '.', '@'], ['@', '.', '.', '@', '@', '@', '.', '.', '@', '@'], ['@', '@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '@', '@', '@', '.', '.', '.', '@'], ['@', '.', '.', '@', '.', '.', '.', '@', '.', '@'], ['@', '.', '@', '@', '.', '@', '.', '@', '.', '@'], ['@', '.', '.', '.', '@', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '@', '@', '.', '@', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '@', '.', '.', '@'], ['@', '@', '.', '@', '.', '.', '@', '.', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '@' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'O': V[i][j] = 2 continue if maze[i][j] == '@': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', ' ', ' ', '*', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', '*', '*', ' ', ' ', '*'], ['*', '*', '*', '*', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', '*', '*', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*'], ['*', ' ', ' ', ' ', '*', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', ' ', ' ', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*'], ] ``` Information about the problem: 1. "E": agent 2. "T": goal 3. "*": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "T": 1 [/INST] import numpy as np maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', ' ', ' ', '*', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', '*', '*', ' ', ' ', '*'], ['*', '*', '*', '*', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', '*', '*', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*'], ['*', ' ', ' ', ' ', '*', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', ' ', ' ', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'T': V[i][j] = 5 continue if maze[i][j] == '*': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'D', '~', '-', '~', '-', '-', '-', '-', '-', '-', '-', '~', '~', '~'], ['~', '-', '-', '-', '-', '~', '-', '~', '-', '~', '-', '-', '-', '-', '~'], ['~', '~', '-', '-', '-', '-', '~', '-', '-', '-', '-', '-', '-', '~', '~'], ['~', '-', '~', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '~'], ['~', '-', '-', '-', '-', '-', '-', '~', '-', '~', '-', '-', '-', '-', '~'], ['~', '-', '-', '-', '~', '-', '-', '-', '~', '-', '-', '-', '-', '~', '~'], ['~', '~', '~', '-', '-', '-', '-', '-', '-', '-', '-', '~', '-', '-', '~'], ['~', '-', '-', '-', '-', '~', '-', '-', '-', '-', '~', '~', '-', '~', '~'], ['~', '-', '~', '-', '-', '~', '~', '-', '-', '-', '-', '~', '-', 'C', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] ``` Information about the problem: 1. "D": agent 2. "C": goal 3. "~": wall 4. "-": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "C": 1 [/INST] import numpy as np maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'D', '~', '-', '~', '-', '-', '-', '-', '-', '-', '-', '~', '~', '~'], ['~', '-', '-', '-', '-', '~', '-', '~', '-', '~', '-', '-', '-', '-', '~'], ['~', '~', '-', '-', '-', '-', '~', '-', '-', '-', '-', '-', '-', '~', '~'], ['~', '-', '~', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '~'], ['~', '-', '-', '-', '-', '-', '-', '~', '-', '~', '-', '-', '-', '-', '~'], ['~', '-', '-', '-', '~', '-', '-', '-', '~', '-', '-', '-', '-', '~', '~'], ['~', '~', '~', '-', '-', '-', '-', '-', '-', '-', '-', '~', '-', '-', '~'], ['~', '-', '-', '-', '-', '~', '-', '-', '-', '-', '~', '~', '-', '~', '~'], ['~', '-', '~', '-', '-', '~', '~', '-', '-', '-', '-', '~', '-', 'C', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'C': V[i][j] = 2 continue if maze[i][j] == '~': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', 'O', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O', 'O', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', 'O', '.', 'O'], ['O', 'O', '.', '.', '.', 'O', '.', '.', 'O', 'O', '.', '.', 'O'], ['O', '.', '.', 'O', '.', 'O', '.', '.', '.', '.', 'O', '.', 'O'], ['O', 'O', 'O', '.', '.', 'O', '.', '.', 'O', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', 'O', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', 'O', 'O', 'O', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', 'O', 'O', '.', '.', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "R": agent 2. "P": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "P": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', 'O', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O', 'O', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', 'O', '.', 'O'], ['O', 'O', '.', '.', '.', 'O', '.', '.', 'O', 'O', '.', '.', 'O'], ['O', '.', '.', 'O', '.', 'O', '.', '.', '.', '.', 'O', '.', 'O'], ['O', 'O', 'O', '.', '.', 'O', '.', '.', 'O', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', 'O', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', 'O', 'O', 'O', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', 'O', 'O', '.', '.', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'P': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'L', '.', '.', 'O', '.', 'O', '.', '.', 'O'], ['O', '.', '.', 'O', '.', 'O', 'O', '.', 'O', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', 'O', 'O', 'O', 'O'], ['O', '.', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', 'B', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "L": agent 2. "B": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "B": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'L', '.', '.', 'O', '.', 'O', '.', '.', 'O'], ['O', '.', '.', 'O', '.', 'O', 'O', '.', 'O', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', 'O', 'O', 'O', 'O'], ['O', '.', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', 'B', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'B': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'L', 'O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O', '.', '.', '.', 'O'], ['O', 'O', 'O', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', 'O', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O', 'O', '.', 'O'], ['O', 'O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O'], ['O', 'O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', 'O', '.', '.', '.', '.', 'O'], ['O', '.', '.', 'O', '.', '.', 'O', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', 'O', '.', 'O', '.', '.', 'B', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "L": agent 2. "B": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "B": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'L', 'O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O', '.', '.', '.', 'O'], ['O', 'O', 'O', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', 'O', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O', 'O', '.', 'O'], ['O', 'O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O'], ['O', 'O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', 'O', '.', '.', '.', '.', 'O'], ['O', '.', '.', 'O', '.', '.', 'O', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', 'O', '.', 'O', '.', '.', 'B', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'B': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~', '~'], ['~', ' ', '~', '~', ' ', '~', '~', '~', ' ', ' ', '~'], ['~', ' ', ' ', ' ', '~', '~', ' ', ' ', ' ', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] ``` Information about the problem: 1. "P": agent 2. "X": goal 3. "~": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "X": 1 [/INST] import numpy as np maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~', '~'], ['~', ' ', '~', '~', ' ', '~', '~', '~', ' ', ' ', '~'], ['~', ' ', ' ', ' ', '~', '~', ' ', ' ', ' ', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'X': V[i][j] = 5 continue if maze[i][j] == '~': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', '.', '.', 'O', '.', '.', 'O', '.', 'O', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', 'O', 'O', 'O', '.', 'O'], ['O', '.', '.', 'O', '.', 'O', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', '.', 'O'], ['O', '.', 'O', 'O', '.', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "R": agent 2. "P": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "P": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', '.', '.', 'O', '.', '.', 'O', '.', 'O', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', 'O', 'O', 'O', '.', 'O'], ['O', '.', '.', 'O', '.', 'O', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', '.', 'O'], ['O', '.', 'O', 'O', '.', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'P': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '@', '.', '@', '.', '@', '.', '@'], ['@', '@', '@', '.', '@', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '@', '@'], ['@', '.', '@', '.', '.', '.', '.', '.', '@'], ['@', '.', '@', '@', '.', '.', '.', '.', '@'], ['@', '.', '@', '.', '@', '.', '.', '.', '@'], ['@', '.', '.', '.', '@', '@', '.', '@', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '@', '.', '@'], ['@', '@', '@', '.', '.', '.', '.', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@'], ] ``` Information about the problem: 1. "T": agent 2. "O": goal 3. "@": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "O": 1 [/INST] import numpy as np maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '@', '.', '@', '.', '@', '.', '@'], ['@', '@', '@', '.', '@', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '@', '@'], ['@', '.', '@', '.', '.', '.', '.', '.', '@'], ['@', '.', '@', '@', '.', '.', '.', '.', '@'], ['@', '.', '@', '.', '@', '.', '.', '.', '@'], ['@', '.', '.', '.', '@', '@', '.', '@', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '@', '.', '@'], ['@', '@', '@', '.', '.', '.', '.', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '@' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'O': V[i][j] = 2 continue if maze[i][j] == '@': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'D', '-', '-', '~', '-', '~', '~', '-', '~'], ['~', '-', '-', '-', '-', '-', '~', '~', '-', '~'], ['~', '-', '-', '-', '-', '-', '-', '-', '-', '~'], ['~', '-', '-', '-', '-', '-', '-', '-', '~', '~'], ['~', '-', '~', '-', '-', '-', '-', '-', '-', '~'], ['~', '-', '-', '-', '~', '-', '-', '-', '-', '~'], ['~', '-', '-', '~', '-', '-', '-', '-', '-', '~'], ['~', '~', '-', '-', '-', '-', '-', '-', '~', '~'], ['~', '~', '~', '-', '-', '-', '~', '~', '~', '~'], ['~', '~', '-', '-', '~', '~', '-', '-', 'C', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] ``` Information about the problem: 1. "D": agent 2. "C": goal 3. "~": wall 4. "-": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "C": 1 [/INST] import numpy as np maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'D', '-', '-', '~', '-', '~', '~', '-', '~'], ['~', '-', '-', '-', '-', '-', '~', '~', '-', '~'], ['~', '-', '-', '-', '-', '-', '-', '-', '-', '~'], ['~', '-', '-', '-', '-', '-', '-', '-', '~', '~'], ['~', '-', '~', '-', '-', '-', '-', '-', '-', '~'], ['~', '-', '-', '-', '~', '-', '-', '-', '-', '~'], ['~', '-', '-', '~', '-', '-', '-', '-', '-', '~'], ['~', '~', '-', '-', '-', '-', '-', '-', '~', '~'], ['~', '~', '~', '-', '-', '-', '~', '~', '~', '~'], ['~', '~', '-', '-', '~', '~', '-', '-', 'C', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'C': V[i][j] = 2 continue if maze[i][j] == '~': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', 'O', '.', '.', 'O'], ['O', 'O', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', '.', '.', 'O', 'O', 'O', 'O', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', 'O', '.', 'O'], ['O', '.', 'O', '.', 'O', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', 'O', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "R": agent 2. "P": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "P": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', 'O', '.', '.', 'O'], ['O', 'O', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', '.', '.', 'O', 'O', 'O', 'O', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', 'O', '.', 'O'], ['O', '.', 'O', '.', 'O', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', 'O', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'P': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ['|', 'N', '_', '|', '|', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '|', '|', '_', '|'], ['|', '|', '|', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '|', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '|', '|', '|', '_', '_', '_', '|'], ['|', '|', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '|', '|', '|', '_', '_', '_', '_', '|'], ['|', '_', '_', '|', '_', '_', '_', '|', '_', '|'], ['|', '_', '|', '_', '_', '|', '_', '_', '_', '|'], ['|', '_', '|', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '|', '_', '_', '|', '_', '_', '|'], ['|', '_', '|', '_', '_', '_', '_', '_', 'S', '|'], ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ] ``` Information about the problem: 1. "N": agent 2. "S": goal 3. "|": wall 4. "_": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "S": 1 [/INST] import numpy as np maze=[ ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ['|', 'N', '_', '|', '|', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '|', '|', '_', '|'], ['|', '|', '|', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '|', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '|', '|', '|', '_', '_', '_', '|'], ['|', '|', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '|', '|', '|', '_', '_', '_', '_', '|'], ['|', '_', '_', '|', '_', '_', '_', '|', '_', '|'], ['|', '_', '|', '_', '_', '|', '_', '_', '_', '|'], ['|', '_', '|', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '|', '_', '_', '|', '_', '_', '|'], ['|', '_', '|', '_', '_', '_', '_', '_', 'S', '|'], ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '|' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'S': V[i][j] = 2 continue if maze[i][j] == '|': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', ' ', '*', ' ', '*', '*', ' ', '*', ' ', '*', '*'], ['*', ' ', '*', ' ', ' ', '*', ' ', ' ', '*', ' ', '*', '*'], ['*', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', '*', '*', '*'], ['*', ' ', ' ', '*', '*', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] ``` Information about the problem: 1. "E": agent 2. "T": goal 3. "*": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "T": 1 [/INST] import numpy as np maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', ' ', '*', ' ', '*', '*', ' ', '*', ' ', '*', '*'], ['*', ' ', '*', ' ', ' ', '*', ' ', ' ', '*', ' ', '*', '*'], ['*', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', '*', '*', '*'], ['*', ' ', ' ', '*', '*', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'T': V[i][j] = 5 continue if maze[i][j] == '*': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'L', 'O', '.', '.', '.', 'O', 'O', 'O', 'O'], ['O', 'O', 'O', 'O', 'O', '.', '.', '.', 'O', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', '.', 'O', '.', '.', 'O', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', 'O', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', 'O', 'B', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "L": agent 2. "B": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "B": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'L', 'O', '.', '.', '.', 'O', 'O', 'O', 'O'], ['O', 'O', 'O', 'O', 'O', '.', '.', '.', 'O', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', '.', 'O', '.', '.', 'O', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', 'O', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', 'O', 'B', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'B': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'L', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', 'O', '.', 'O'], ['O', '.', 'O', 'O', '.', 'O', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', 'O', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O', 'O', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', '.', 'O'], ['O', '.', 'O', '.', 'O', '.', '.', '.', '.', 'O', '.', 'B', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "L": agent 2. "B": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "B": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'L', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', 'O', '.', 'O'], ['O', '.', 'O', 'O', '.', 'O', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', 'O', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O', 'O', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', '.', 'O'], ['O', '.', 'O', '.', 'O', '.', '.', '.', '.', 'O', '.', 'B', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'B': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~'], ['~', ' ', ' ', '~', ' ', ' ', ' ', ' ', '~', '~', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~', '~', ' ', '~'], ['~', ' ', ' ', '~', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', '~', ' ', ' ', '~'], ['~', ' ', '~', ' ', ' ', ' ', ' ', '~', ' ', '~', ' ', ' ', '~'], ['~', ' ', '~', '~', ' ', ' ', '~', '~', ' ', '~', ' ', ' ', '~'], ['~', ' ', ' ', ' ', '~', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] ``` Information about the problem: 1. "P": agent 2. "X": goal 3. "~": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "X": 1 [/INST] import numpy as np maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~'], ['~', ' ', ' ', '~', ' ', ' ', ' ', ' ', '~', '~', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~', '~', ' ', '~'], ['~', ' ', ' ', '~', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', '~', ' ', ' ', '~'], ['~', ' ', '~', ' ', ' ', ' ', ' ', '~', ' ', '~', ' ', ' ', '~'], ['~', ' ', '~', '~', ' ', ' ', '~', '~', ' ', '~', ' ', ' ', '~'], ['~', ' ', ' ', ' ', '~', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'X': V[i][j] = 5 continue if maze[i][j] == '~': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '*', '^', '*', '*', '^', '*', '*', '*', '^'], ['^', '^', '^', '*', '*', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '*', '^', '*', '^', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '^', '^', '^', '*', '*', '*', '*', '^', '^', '*', '^', '^'], ['^', '*', '*', '*', '^', '^', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '*', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '*', '^', '^', '*', '*', '*', '^', '^'], ['^', '^', '*', '*', '*', '^', '*', '*', '^', '*', '*', '^', '^'], ['^', '*', '^', '*', '*', '*', '*', '*', '*', '*', '^', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] ``` Information about the problem: 1. "S": agent 2. "H": goal 3. "^": wall 4. "*": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "H": 1 [/INST] import numpy as np maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '*', '^', '*', '*', '^', '*', '*', '*', '^'], ['^', '^', '^', '*', '*', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '*', '^', '*', '^', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '^', '^', '^', '*', '*', '*', '*', '^', '^', '*', '^', '^'], ['^', '*', '*', '*', '^', '^', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '*', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '*', '^', '^', '*', '*', '*', '^', '^'], ['^', '^', '*', '*', '*', '^', '*', '*', '^', '*', '*', '^', '^'], ['^', '*', '^', '*', '*', '*', '*', '*', '*', '*', '^', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'H': V[i][j] = 3 continue if maze[i][j] == '^': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', ' ', ' ', '~', '~', '~', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~', ' ', '~'], ['~', ' ', '~', ' ', '~', '~', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', '~'], ['~', '~', ' ', '~', '~', ' ', ' ', ' ', '~', ' ', '~', '~'], ['~', ' ', '~', '~', '~', ' ', '~', '~', ' ', ' ', '~', '~'], ['~', ' ', ' ', '~', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', '~', '~', ' ', '~', ' ', ' ', '~', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] ``` Information about the problem: 1. "P": agent 2. "X": goal 3. "~": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "X": 1 [/INST] import numpy as np maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', ' ', ' ', '~', '~', '~', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~', ' ', '~'], ['~', ' ', '~', ' ', '~', '~', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', '~'], ['~', '~', ' ', '~', '~', ' ', ' ', ' ', '~', ' ', '~', '~'], ['~', ' ', '~', '~', '~', ' ', '~', '~', ' ', ' ', '~', '~'], ['~', ' ', ' ', '~', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', '~', '~', ' ', '~', ' ', ' ', '~', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'X': V[i][j] = 5 continue if maze[i][j] == '~': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', '.', 'O', '.', 'O', '.', 'O', 'O', 'O'], ['O', '.', '.', 'O', '.', '.', '.', 'O', 'O', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', '.', 'O', '.', '.', 'O', 'O', 'O', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "R": agent 2. "P": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "P": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', '.', 'O', '.', 'O', '.', 'O', 'O', 'O'], ['O', '.', '.', 'O', '.', '.', '.', 'O', 'O', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', '.', 'O', '.', '.', 'O', 'O', 'O', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'P': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '^', '*', '*', '*', '^', '^', '^', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '^', '^', '^', '*', '^', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '*', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '*', '^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '^', '*', '^', '^', '*', '^', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '^', '^', '*', '*', '*', '^', '*', '^', '*', '^'], ['^', '*', '*', '^', '*', '*', '*', '*', '^', '*', '*', '^', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] ``` Information about the problem: 1. "S": agent 2. "H": goal 3. "^": wall 4. "*": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "H": 1 [/INST] import numpy as np maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '^', '*', '*', '*', '^', '^', '^', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '^', '^', '^', '*', '^', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '*', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '*', '^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '^', '*', '^', '^', '*', '^', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '^', '^', '*', '*', '*', '^', '*', '^', '*', '^'], ['^', '*', '*', '^', '*', '*', '*', '*', '^', '*', '*', '^', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'H': V[i][j] = 3 continue if maze[i][j] == '^': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', ' ', ' ', '~', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', '~', ' ', ' ', '~', ' ', ' ', ' ', ' ', '~'], ['~', '~', '~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', '~', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~', ' ', '~', ' ', '~'], ['~', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~', ' ', ' ', '~', '~'], ['~', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~', '~', '~', '~', ' ', '~'], ['~', '~', ' ', ' ', ' ', '~', '~', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', '~', ' ', ' ', '~', '~', '~', ' ', ' ', ' ', ' ', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] ``` Information about the problem: 1. "P": agent 2. "X": goal 3. "~": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "X": 1 [/INST] import numpy as np maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', ' ', ' ', '~', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', '~', ' ', ' ', '~', ' ', ' ', ' ', ' ', '~'], ['~', '~', '~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', '~', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~', ' ', '~', ' ', '~'], ['~', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~', ' ', ' ', '~', '~'], ['~', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~', '~', '~', '~', ' ', '~'], ['~', '~', ' ', ' ', ' ', '~', '~', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', '~', ' ', ' ', '~', '~', '~', ' ', ' ', ' ', ' ', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'X': V[i][j] = 5 continue if maze[i][j] == '~': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '^', '*', '*', '^', '*', '*', '*', '^', '^'], ['^', '*', '*', '^', '*', '*', '*', '*', '^', '*', '^'], ['^', '^', '^', '^', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '^', '*', '^', '*', '^', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^', '^', '^'], ['^', '^', '*', '*', '^', '*', '*', '*', '*', '^', '^'], ['^', '^', '*', '*', '*', '^', '*', '*', '^', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] ``` Information about the problem: 1. "S": agent 2. "H": goal 3. "^": wall 4. "*": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "H": 1 [/INST] import numpy as np maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '^', '*', '*', '^', '*', '*', '*', '^', '^'], ['^', '*', '*', '^', '*', '*', '*', '*', '^', '*', '^'], ['^', '^', '^', '^', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '^', '*', '^', '*', '^', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^', '^', '^'], ['^', '^', '*', '*', '^', '*', '*', '*', '*', '^', '^'], ['^', '^', '*', '*', '*', '^', '*', '*', '^', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'H': V[i][j] = 3 continue if maze[i][j] == '^': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~', '~', '~', '~', ' ', '~'], ['~', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', '~', ' ', ' ', '~', '~', '~', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', '~', '~', ' ', ' ', ' ', ' ', ' ', '~', ' ', '~'], ['~', ' ', ' ', '~', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~'], ['~', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~', ' ', '~', ' ', '~'], ['~', '~', ' ', ' ', '~', ' ', ' ', '~', ' ', ' ', '~', ' ', ' ', ' ', '~'], ['~', ' ', '~', ' ', ' ', ' ', '~', ' ', '~', ' ', ' ', '~', ' ', '~', '~'], ['~', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] ``` Information about the problem: 1. "P": agent 2. "X": goal 3. "~": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "X": 1 [/INST] import numpy as np maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~', '~', '~', '~', ' ', '~'], ['~', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', '~', ' ', ' ', '~', '~', '~', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', '~', '~', ' ', ' ', ' ', ' ', ' ', '~', ' ', '~'], ['~', ' ', ' ', '~', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~'], ['~', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~', ' ', '~', ' ', '~'], ['~', '~', ' ', ' ', '~', ' ', ' ', '~', ' ', ' ', '~', ' ', ' ', ' ', '~'], ['~', ' ', '~', ' ', ' ', ' ', '~', ' ', '~', ' ', ' ', '~', ' ', '~', '~'], ['~', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'X': V[i][j] = 5 continue if maze[i][j] == '~': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O', 'O'], ['O', 'O', '.', 'O', 'O', 'O', '.', 'O', 'O', 'O', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', '.', 'O', 'O', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "R": agent 2. "P": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "P": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O', 'O'], ['O', 'O', '.', 'O', 'O', 'O', '.', 'O', 'O', 'O', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', '.', 'O', 'O', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'P': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', '*', ' ', '*', '*', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', '*', '*', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', '*', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', '*'], ['*', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', '*', '*', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] ``` Information about the problem: 1. "E": agent 2. "T": goal 3. "*": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "T": 1 [/INST] import numpy as np maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', '*', ' ', '*', '*', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', '*', '*', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', '*', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', '*'], ['*', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', '*', '*', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'T': V[i][j] = 5 continue if maze[i][j] == '*': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '.', '.', '.', '.', '@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '@', '.', '@', '.', '.', '@', '.', '@'], ['@', '.', '.', '.', '@', '.', '@', '@', '.', '.', '.', '.', '.', '@', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@', '.', '.', '.', '@'], ['@', '.', '.', '.', '@', '@', '.', '@', '.', '.', '.', '@', '.', '@', '@'], ['@', '@', '@', '.', '.', '.', '.', '.', '.', '.', '.', '@', '.', '.', '@'], ['@', '.', '@', '.', '@', '@', '.', '.', '.', '.', '.', '@', '.', '.', '@'], ['@', '.', '.', '@', '.', '@', '@', '.', '.', '.', '.', '@', '@', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] ``` Information about the problem: 1. "T": agent 2. "O": goal 3. "@": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "O": 1 [/INST] import numpy as np maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '.', '.', '.', '.', '@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '@', '.', '@', '.', '.', '@', '.', '@'], ['@', '.', '.', '.', '@', '.', '@', '@', '.', '.', '.', '.', '.', '@', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@', '.', '.', '.', '@'], ['@', '.', '.', '.', '@', '@', '.', '@', '.', '.', '.', '@', '.', '@', '@'], ['@', '@', '@', '.', '.', '.', '.', '.', '.', '.', '.', '@', '.', '.', '@'], ['@', '.', '@', '.', '@', '@', '.', '.', '.', '.', '.', '@', '.', '.', '@'], ['@', '.', '.', '@', '.', '@', '@', '.', '.', '.', '.', '@', '@', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '@' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'O': V[i][j] = 2 continue if maze[i][j] == '@': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', '*', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*', '*', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', '*', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] ``` Information about the problem: 1. "E": agent 2. "T": goal 3. "*": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "T": 1 [/INST] import numpy as np maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', '*', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*', '*', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', '*', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'T': V[i][j] = 5 continue if maze[i][j] == '*': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '*', '^', '*', '^', '*', '*', '*', '^', '*', '^'], ['^', '^', '*', '*', '^', '*', '^', '^', '*', '*', '^', '*', '*', '^'], ['^', '*', '*', '*', '^', '^', '*', '^', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '^', '^', '^', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '^', '*', '^', '*', '*', '*', '^', '^'], ['^', '^', '*', '*', '^', '*', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '^', '^', '*', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '^', '*', '*', '^', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '^', '*', '*', '^', '*', '^', '^', '*', '*', '*', '*', '*', '^'], ['^', '^', '^', '^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] ``` Information about the problem: 1. "S": agent 2. "H": goal 3. "^": wall 4. "*": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "H": 1 [/INST] import numpy as np maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '*', '^', '*', '^', '*', '*', '*', '^', '*', '^'], ['^', '^', '*', '*', '^', '*', '^', '^', '*', '*', '^', '*', '*', '^'], ['^', '*', '*', '*', '^', '^', '*', '^', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '^', '^', '^', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '^', '*', '^', '*', '*', '*', '^', '^'], ['^', '^', '*', '*', '^', '*', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '^', '^', '*', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '^', '*', '*', '^', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '^', '*', '*', '^', '*', '^', '^', '*', '*', '*', '*', '*', '^'], ['^', '^', '^', '^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'H': V[i][j] = 3 continue if maze[i][j] == '^': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ['|', 'N', '|', '_', '_', '_', '|', '|', '|', '_', '_', '_', '_', '_', '|'], ['|', '|', '_', '_', '|', '|', '_', '_', '|', '_', '_', '|', '_', '_', '|'], ['|', '_', '|', '_', '_', '_', '_', '_', '_', '_', '|', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '|', '_', '_', '|', '_', '|', '_', '|'], ['|', '_', '_', '_', '_', '_', '|', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '|', '_', '|', '_', '|', '_', '_', '_', '|'], ['|', '|', '_', '|', '|', '_', '|', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '|', '_', '_', '_', '|', '_', '_', '_', '_', '_', '_', '|', '|'], ['|', '_', '_', '|', '|', '_', '_', '_', '|', '_', '_', '|', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '|', '|', '|', '_', '|', '_', 'S', '|'], ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ] ``` Information about the problem: 1. "N": agent 2. "S": goal 3. "|": wall 4. "_": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "S": 1 [/INST] import numpy as np maze=[ ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ['|', 'N', '|', '_', '_', '_', '|', '|', '|', '_', '_', '_', '_', '_', '|'], ['|', '|', '_', '_', '|', '|', '_', '_', '|', '_', '_', '|', '_', '_', '|'], ['|', '_', '|', '_', '_', '_', '_', '_', '_', '_', '|', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '|', '_', '_', '|', '_', '|', '_', '|'], ['|', '_', '_', '_', '_', '_', '|', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '|', '_', '|', '_', '|', '_', '_', '_', '|'], ['|', '|', '_', '|', '|', '_', '|', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '|', '_', '_', '_', '|', '_', '_', '_', '_', '_', '_', '|', '|'], ['|', '_', '_', '|', '|', '_', '_', '_', '|', '_', '_', '|', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '|', '|', '|', '_', '|', '_', 'S', '|'], ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '|' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'S': V[i][j] = 2 continue if maze[i][j] == '|': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', '*', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', '*', '*', '*', '*', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', '*', ' ', ' ', '*', '*', ' ', '*', ' ', ' ', '*', '*', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] ``` Information about the problem: 1. "E": agent 2. "T": goal 3. "*": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "T": 1 [/INST] import numpy as np maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', '*', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', '*', '*', '*', '*', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', '*', ' ', ' ', '*', '*', ' ', '*', ' ', ' ', '*', '*', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'T': V[i][j] = 5 continue if maze[i][j] == '*': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '*', '*', '^', '^', '*', '^'], ['^', '^', '*', '*', '^', '*', '*', '*', '*', '^'], ['^', '*', '*', '^', '*', '^', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '^', '^'], ['^', '*', '*', '^', '*', '^', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] ``` Information about the problem: 1. "S": agent 2. "H": goal 3. "^": wall 4. "*": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "H": 1 [/INST] import numpy as np maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '*', '*', '^', '^', '*', '^'], ['^', '^', '*', '*', '^', '*', '*', '*', '*', '^'], ['^', '*', '*', '^', '*', '^', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '^', '^'], ['^', '*', '*', '^', '*', '^', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'H': V[i][j] = 3 continue if maze[i][j] == '^': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '@', '@', '.', '@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@', '@'], ['@', '@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '@', '.', '.', '.', '.', '.', '.', '.', '@', '@', '.', '@'], ['@', '@', '.', '.', '.', '.', '.', '@', '@', '.', '.', '.', '@', '@'], ['@', '.', '@', '.', '.', '@', '.', '.', '.', '.', '@', '.', '.', '@'], ['@', '@', '.', '@', '.', '.', '.', '.', '@', '@', '@', '.', '.', '@'], ['@', '.', '.', '.', '.', '@', '.', '@', '.', '.', '@', '.', '.', '@'], ['@', '.', '.', '.', '@', '.', '.', '.', '@', '.', '.', '.', '@', '@'], ['@', '.', '.', '.', '@', '@', '.', '.', '@', '.', '.', '.', '.', '@'], ['@', '@', '@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@', '@'], ['@', '.', '.', '.', '.', '@', '.', '.', '.', '.', '@', '.', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] ``` Information about the problem: 1. "T": agent 2. "O": goal 3. "@": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "O": 1 [/INST] import numpy as np maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '@', '@', '.', '@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@', '@'], ['@', '@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '@', '.', '.', '.', '.', '.', '.', '.', '@', '@', '.', '@'], ['@', '@', '.', '.', '.', '.', '.', '@', '@', '.', '.', '.', '@', '@'], ['@', '.', '@', '.', '.', '@', '.', '.', '.', '.', '@', '.', '.', '@'], ['@', '@', '.', '@', '.', '.', '.', '.', '@', '@', '@', '.', '.', '@'], ['@', '.', '.', '.', '.', '@', '.', '@', '.', '.', '@', '.', '.', '@'], ['@', '.', '.', '.', '@', '.', '.', '.', '@', '.', '.', '.', '@', '@'], ['@', '.', '.', '.', '@', '@', '.', '.', '@', '.', '.', '.', '.', '@'], ['@', '@', '@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@', '@'], ['@', '.', '.', '.', '.', '@', '.', '.', '.', '.', '@', '.', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '@' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'O': V[i][j] = 2 continue if maze[i][j] == '@': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', '*', ' ', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', '*', '*', ' ', ' ', '*', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', ' ', '*', '*', '*', '*'], ['*', '*', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', '*', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*'], ] ``` Information about the problem: 1. "E": agent 2. "T": goal 3. "*": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "T": 1 [/INST] import numpy as np maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', '*', ' ', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', '*', '*', ' ', ' ', '*', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', ' ', '*', '*', '*', '*'], ['*', '*', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', '*', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'T': V[i][j] = 5 continue if maze[i][j] == '*': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', ' ', ' ', '~', '~', '~', '~'], ['~', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', '~', ' ', ' ', '~', '~'], ['~', '~', '~', '~', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~'], ['~', '~', ' ', '~', ' ', ' ', ' ', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~'], ] ``` Information about the problem: 1. "P": agent 2. "X": goal 3. "~": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "X": 1 [/INST] import numpy as np maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', ' ', ' ', '~', '~', '~', '~'], ['~', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', '~', ' ', ' ', '~', '~'], ['~', '~', '~', '~', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~'], ['~', '~', ' ', '~', ' ', ' ', ' ', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'X': V[i][j] = 5 continue if maze[i][j] == '~': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', '~', ' ', ' ', ' ', ' ', ' ', '~', '~', ' ', '~', '~'], ['~', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', '~', '~', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~'], ['~', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', '~'], ['~', ' ', ' ', '~', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', '~', ' ', '~'], ['~', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] ``` Information about the problem: 1. "P": agent 2. "X": goal 3. "~": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "X": 1 [/INST] import numpy as np maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', '~', ' ', ' ', ' ', ' ', ' ', '~', '~', ' ', '~', '~'], ['~', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', '~', '~', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~'], ['~', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', '~'], ['~', ' ', ' ', '~', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', '~', ' ', '~'], ['~', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'X': V[i][j] = 5 continue if maze[i][j] == '~': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ['|', 'N', '|', '|', '_', '_', '_', '_', '_', '_', '_', '_', '|', '|'], ['|', '_', '_', '_', '_', '_', '_', '|', '|', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '|', '_', '_', '|', '|', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '_', '|', '_', '_', '|', '|'], ['|', '|', '_', '|', '_', '|', '_', '_', '_', '_', '|', '|', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '|', '_', '_', '|', '_', '|'], ['|', '|', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', 'S', '|'], ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ] ``` Information about the problem: 1. "N": agent 2. "S": goal 3. "|": wall 4. "_": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "S": 1 [/INST] import numpy as np maze=[ ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ['|', 'N', '|', '|', '_', '_', '_', '_', '_', '_', '_', '_', '|', '|'], ['|', '_', '_', '_', '_', '_', '_', '|', '|', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '|', '_', '_', '|', '|', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '_', '|', '_', '_', '|', '|'], ['|', '|', '_', '|', '_', '|', '_', '_', '_', '_', '|', '|', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '|', '_', '_', '|', '_', '|'], ['|', '|', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', 'S', '|'], ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '|' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'S': V[i][j] = 2 continue if maze[i][j] == '|': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'D', '-', '~', '-', '~', '-', '~', '-', '-', '-', '-', '~'], ['~', '-', '-', '~', '-', '~', '-', '~', '-', '-', '-', '-', '~'], ['~', '~', '-', '~', '~', '~', '-', '-', '-', '-', '-', '-', '~'], ['~', '-', '-', '-', '-', '-', '-', '~', '-', '-', '-', '-', '~'], ['~', '~', '-', '-', '~', '-', '-', '-', '~', '~', '-', '-', '~'], ['~', '-', '-', '-', '-', '-', '-', '-', '~', '-', '-', '-', '~'], ['~', '-', '-', '-', '-', '-', '-', '~', '~', '~', '-', 'C', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] ``` Information about the problem: 1. "D": agent 2. "C": goal 3. "~": wall 4. "-": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "C": 1 [/INST] import numpy as np maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'D', '-', '~', '-', '~', '-', '~', '-', '-', '-', '-', '~'], ['~', '-', '-', '~', '-', '~', '-', '~', '-', '-', '-', '-', '~'], ['~', '~', '-', '~', '~', '~', '-', '-', '-', '-', '-', '-', '~'], ['~', '-', '-', '-', '-', '-', '-', '~', '-', '-', '-', '-', '~'], ['~', '~', '-', '-', '~', '-', '-', '-', '~', '~', '-', '-', '~'], ['~', '-', '-', '-', '-', '-', '-', '-', '~', '-', '-', '-', '~'], ['~', '-', '-', '-', '-', '-', '-', '~', '~', '~', '-', 'C', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'C': V[i][j] = 2 continue if maze[i][j] == '~': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '^', '*', '*', '^', '*', '^'], ['^', '*', '*', '^', '*', '^', '^', '*', '^'], ['^', '*', '^', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '^'], ['^', '*', '^', '^', '*', '*', '^', '*', '^'], ['^', '^', '*', '*', '^', '^', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '^', '*', '^', '*', '*', '*', '*', '^'], ['^', '*', '*', '^', '*', '^', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^'], ] ``` Information about the problem: 1. "S": agent 2. "H": goal 3. "^": wall 4. "*": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "H": 1 [/INST] import numpy as np maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '^', '*', '*', '^', '*', '^'], ['^', '*', '*', '^', '*', '^', '^', '*', '^'], ['^', '*', '^', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '^'], ['^', '*', '^', '^', '*', '*', '^', '*', '^'], ['^', '^', '*', '*', '^', '^', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '^', '*', '^', '*', '*', '*', '*', '^'], ['^', '*', '*', '^', '*', '^', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'H': V[i][j] = 3 continue if maze[i][j] == '^': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ['|', 'N', '_', '_', '_', '_', '_', '_', '|', '|'], ['|', '_', '|', '_', '|', '_', '_', '|', '_', '|'], ['|', '|', '_', '|', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '|', '|', '|'], ['|', '_', '_', '_', '_', '|', '_', '|', '_', '|'], ['|', '_', '|', '|', '_', '|', '|', '_', '_', '|'], ['|', '|', '_', '|', '_', '|', '|', '_', '_', '|'], ['|', '_', '_', '|', '_', '_', '_', '_', 'S', '|'], ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ] ``` Information about the problem: 1. "N": agent 2. "S": goal 3. "|": wall 4. "_": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "S": 1 [/INST] import numpy as np maze=[ ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ['|', 'N', '_', '_', '_', '_', '_', '_', '|', '|'], ['|', '_', '|', '_', '|', '_', '_', '|', '_', '|'], ['|', '|', '_', '|', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '|', '|', '|'], ['|', '_', '_', '_', '_', '|', '_', '|', '_', '|'], ['|', '_', '|', '|', '_', '|', '|', '_', '_', '|'], ['|', '|', '_', '|', '_', '|', '|', '_', '_', '|'], ['|', '_', '_', '|', '_', '_', '_', '_', 'S', '|'], ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '|' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'S': V[i][j] = 2 continue if maze[i][j] == '|': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ['|', 'N', '_', '|', '|', '_', '_', '_', '_', '_', '_', '_', '_', '|', '|'], ['|', '_', '|', '|', '_', '|', '_', '_', '_', '_', '_', '_', '|', '_', '|'], ['|', '|', '_', '|', '_', '|', '|', '|', '|', '_', '_', '_', '_', '_', '|'], ['|', '|', '_', '_', '_', '_', '_', '|', '_', '_', '_', '_', '_', '_', '|'], ['|', '|', '_', '|', '_', '_', '_', '_', '_', '_', '_', '_', '|', '_', '|'], ['|', '_', '_', '|', '_', '_', '_', '_', '_', '|', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '|', '|', '|', '_', '_', '_', '|'], ['|', '_', '_', '|', '_', '_', '|', '_', '|', '_', '_', '_', '_', '_', '|'], ['|', '|', '_', '_', '|', '_', '_', '|', '|', '_', '_', '_', '|', 'S', '|'], ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ] ``` Information about the problem: 1. "N": agent 2. "S": goal 3. "|": wall 4. "_": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "S": 1 [/INST] import numpy as np maze=[ ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ['|', 'N', '_', '|', '|', '_', '_', '_', '_', '_', '_', '_', '_', '|', '|'], ['|', '_', '|', '|', '_', '|', '_', '_', '_', '_', '_', '_', '|', '_', '|'], ['|', '|', '_', '|', '_', '|', '|', '|', '|', '_', '_', '_', '_', '_', '|'], ['|', '|', '_', '_', '_', '_', '_', '|', '_', '_', '_', '_', '_', '_', '|'], ['|', '|', '_', '|', '_', '_', '_', '_', '_', '_', '_', '_', '|', '_', '|'], ['|', '_', '_', '|', '_', '_', '_', '_', '_', '|', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '|', '|', '|', '_', '_', '_', '|'], ['|', '_', '_', '|', '_', '_', '|', '_', '|', '_', '_', '_', '_', '_', '|'], ['|', '|', '_', '_', '|', '_', '_', '|', '|', '_', '_', '_', '|', 'S', '|'], ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '|' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'S': V[i][j] = 2 continue if maze[i][j] == '|': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', '.', '.', 'O', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', 'O', '.', '.', 'O', 'O'], ['O', 'O', '.', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', 'O', '.', 'O', '.', 'O', '.', '.', '.', 'O', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', 'O', 'O'], ['O', 'O', '.', '.', '.', 'O', '.', '.', 'O', '.', 'O'], ['O', '.', '.', 'O', '.', 'O', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', 'O', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', 'O', 'O', 'O', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "R": agent 2. "P": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "P": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', '.', '.', 'O', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', 'O', '.', '.', 'O', 'O'], ['O', 'O', '.', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', 'O', '.', 'O', '.', 'O', '.', '.', '.', 'O', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', 'O', 'O'], ['O', 'O', '.', '.', '.', 'O', '.', '.', 'O', '.', 'O'], ['O', '.', '.', 'O', '.', 'O', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', 'O', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', 'O', 'O', 'O', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'P': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '*', '*', '*', '*', '*', '^', '^', '*', '*', '^'], ['^', '*', '^', '*', '^', '^', '*', '*', '^', '^', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '^', '*', '*', '*', '*', '^', '^', '^'], ['^', '^', '^', '*', '^', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '*', '*', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '*', '^', '*', '*', '^', '*', '*', '^', '^'], ['^', '^', '*', '*', '*', '^', '*', '^', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '^', '*', '*', '^', '*', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] ``` Information about the problem: 1. "S": agent 2. "H": goal 3. "^": wall 4. "*": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "H": 1 [/INST] import numpy as np maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '*', '*', '*', '*', '*', '^', '^', '*', '*', '^'], ['^', '*', '^', '*', '^', '^', '*', '*', '^', '^', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '^', '*', '*', '*', '*', '^', '^', '^'], ['^', '^', '^', '*', '^', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '*', '*', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '*', '^', '*', '*', '^', '*', '*', '^', '^'], ['^', '^', '*', '*', '*', '^', '*', '^', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '^', '*', '*', '^', '*', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'H': V[i][j] = 3 continue if maze[i][j] == '^': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'L', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', 'O', 'O', 'O'], ['O', 'O', '.', '.', 'O', '.', '.', 'O', 'O', '.', 'O'], ['O', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'O'], ['O', 'O', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', 'O', '.', 'O', '.', '.', 'O', '.', 'O'], ['O', '.', '.', 'O', 'O', '.', 'O', '.', '.', '.', 'O'], ['O', '.', 'O', 'O', '.', '.', 'O', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', 'O', '.', '.', 'B', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "L": agent 2. "B": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "B": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'L', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', 'O', 'O', 'O'], ['O', 'O', '.', '.', 'O', '.', '.', 'O', 'O', '.', 'O'], ['O', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'O'], ['O', 'O', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', 'O', '.', 'O', '.', '.', 'O', '.', 'O'], ['O', '.', '.', 'O', 'O', '.', 'O', '.', '.', '.', 'O'], ['O', '.', 'O', 'O', '.', '.', 'O', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', 'O', '.', '.', 'B', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'B': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', '*', '*', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', ' ', '*', '*', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', '*', '*', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] ``` Information about the problem: 1. "E": agent 2. "T": goal 3. "*": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "T": 1 [/INST] import numpy as np maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', '*', '*', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', ' ', '*', '*', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', '*', '*', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'T': V[i][j] = 5 continue if maze[i][j] == '*': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '^', '*', '*', '^', '*', '*', '^'], ['^', '^', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '^', '^', '^', '^'], ['^', '^', '*', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '^', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '*', '^', '*', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^'], ] ``` Information about the problem: 1. "S": agent 2. "H": goal 3. "^": wall 4. "*": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "H": 1 [/INST] import numpy as np maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '^', '*', '*', '^', '*', '*', '^'], ['^', '^', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '^', '^', '^', '^'], ['^', '^', '*', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '^', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '*', '^', '*', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'H': V[i][j] = 3 continue if maze[i][j] == '^': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', ' ', ' ', ' ', '~', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', '~', '~', '~'], ['~', ' ', ' ', ' ', '~', '~', ' ', ' ', '~'], ['~', ' ', '~', '~', ' ', ' ', ' ', '~', '~'], ['~', '~', '~', '~', '~', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', '~', '~', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', '~', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~'], ] ``` Information about the problem: 1. "P": agent 2. "X": goal 3. "~": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "X": 1 [/INST] import numpy as np maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', ' ', ' ', ' ', '~', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', '~', '~', '~'], ['~', ' ', ' ', ' ', '~', '~', ' ', ' ', '~'], ['~', ' ', '~', '~', ' ', ' ', ' ', '~', '~'], ['~', '~', '~', '~', '~', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', '~', '~', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', '~', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'X': V[i][j] = 5 continue if maze[i][j] == '~': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', '*', '*'], ['*', '*', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*', '*'], ['*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] ``` Information about the problem: 1. "E": agent 2. "T": goal 3. "*": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "T": 1 [/INST] import numpy as np maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', '*', '*'], ['*', '*', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*', '*'], ['*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'T': V[i][j] = 5 continue if maze[i][j] == '*': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', '.', 'O', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', 'O', 'O', 'O', '.', '.', '.', 'O'], ['O', 'O', '.', '.', 'O', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', 'O', '.', '.', 'O'], ['O', '.', '.', '.', 'O', 'O', '.', '.', 'O'], ['O', '.', '.', '.', 'O', 'O', '.', '.', 'O'], ['O', '.', '.', 'O', '.', '.', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "R": agent 2. "P": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "P": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', '.', 'O', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', 'O', 'O', 'O', '.', '.', '.', 'O'], ['O', 'O', '.', '.', 'O', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', 'O', '.', '.', 'O'], ['O', '.', '.', '.', 'O', 'O', '.', '.', 'O'], ['O', '.', '.', '.', 'O', 'O', '.', '.', 'O'], ['O', '.', '.', 'O', '.', '.', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'P': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', 'O', '.', 'O', '.', '.', 'O', 'O'], ['O', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', 'O', 'O', '.', '.', '.', 'O', '.', 'O'], ['O', '.', 'O', '.', '.', 'O', '.', '.', 'O', 'O', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', 'O', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', '.', 'O', '.', '.', 'O', 'O'], ['O', 'O', '.', '.', 'O', '.', '.', '.', '.', 'O', 'O'], ['O', 'O', 'O', '.', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', 'O', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "R": agent 2. "P": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "P": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', 'O', '.', 'O', '.', '.', 'O', 'O'], ['O', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', 'O', 'O', '.', '.', '.', 'O', '.', 'O'], ['O', '.', 'O', '.', '.', 'O', '.', '.', 'O', 'O', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', 'O', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', '.', 'O', '.', '.', 'O', 'O'], ['O', 'O', '.', '.', 'O', '.', '.', '.', '.', 'O', 'O'], ['O', 'O', 'O', '.', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', 'O', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'P': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '.', '.', '.', '.', '@', '@', '@', '.', '@'], ['@', '@', '@', '.', '.', '.', '.', '@', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@', '.', '@'], ['@', '.', '.', '.', '.', '.', '@', '@', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '@', '@', '.', '.', '@'], ['@', '.', '@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '@', '@', '.', '@', '.', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] ``` Information about the problem: 1. "T": agent 2. "O": goal 3. "@": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "O": 1 [/INST] import numpy as np maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '.', '.', '.', '.', '@', '@', '@', '.', '@'], ['@', '@', '@', '.', '.', '.', '.', '@', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@', '.', '@'], ['@', '.', '.', '.', '.', '.', '@', '@', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '@', '@', '.', '.', '@'], ['@', '.', '@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '@', '@', '.', '@', '.', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '@' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'O': V[i][j] = 2 continue if maze[i][j] == '@': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '^', '^', '*', '*', '*', '^', '^'], ['^', '*', '^', '*', '*', '^', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '^', '^', '^', '*', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '^', '*', '*', '*', '*', '^'], ['^', '^', '*', '^', '*', '^', '*', '*', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] ``` Information about the problem: 1. "S": agent 2. "H": goal 3. "^": wall 4. "*": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "H": 1 [/INST] import numpy as np maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '^', '^', '*', '*', '*', '^', '^'], ['^', '*', '^', '*', '*', '^', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '^', '^', '^', '*', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '^', '*', '*', '*', '*', '^'], ['^', '^', '*', '^', '*', '^', '*', '*', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'H': V[i][j] = 3 continue if maze[i][j] == '^': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '^', '*', '^', '^', '*', '*', '^', '^', '*', '^'], ['^', '^', '^', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '^', '*', '^', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '*', '^', '*', '^'], ['^', '*', '^', '*', '*', '^', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '^', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '^', '^', '*', '*', '*', '*', '^', '*', '^', '^'], ['^', '*', '*', '^', '^', '*', '^', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^', '^', '^', '^'], ['^', '*', '^', '*', '*', '*', '*', '^', '^', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] ``` Information about the problem: 1. "S": agent 2. "H": goal 3. "^": wall 4. "*": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "H": 1 [/INST] import numpy as np maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '^', '*', '^', '^', '*', '*', '^', '^', '*', '^'], ['^', '^', '^', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '^', '*', '^', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '*', '^', '*', '^'], ['^', '*', '^', '*', '*', '^', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '^', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '^', '^', '*', '*', '*', '*', '^', '*', '^', '^'], ['^', '*', '*', '^', '^', '*', '^', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^', '^', '^', '^'], ['^', '*', '^', '*', '*', '*', '*', '^', '^', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'H': V[i][j] = 3 continue if maze[i][j] == '^': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '.', '.', '.', '.', '.', '.', '.', '@', '@'], ['@', '.', '.', '.', '.', '@', '@', '.', '@', '@', '@'], ['@', '.', '.', '.', '@', '.', '.', '@', '.', '@', '@'], ['@', '.', '.', '.', '.', '.', '@', '.', '.', '.', '@'], ['@', '.', '@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '.', '@', '@'], ['@', '@', '.', '@', '@', '.', '.', '.', '.', '@', '@'], ['@', '.', '.', '.', '@', '.', '.', '@', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@', '.', '@'], ['@', '.', '.', '.', '@', '.', '.', '@', '.', '.', '@'], ['@', '.', '@', '.', '@', '.', '.', '@', '.', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] ``` Information about the problem: 1. "T": agent 2. "O": goal 3. "@": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "O": 1 [/INST] import numpy as np maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '.', '.', '.', '.', '.', '.', '.', '@', '@'], ['@', '.', '.', '.', '.', '@', '@', '.', '@', '@', '@'], ['@', '.', '.', '.', '@', '.', '.', '@', '.', '@', '@'], ['@', '.', '.', '.', '.', '.', '@', '.', '.', '.', '@'], ['@', '.', '@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '.', '@', '@'], ['@', '@', '.', '@', '@', '.', '.', '.', '.', '@', '@'], ['@', '.', '.', '.', '@', '.', '.', '@', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@', '.', '@'], ['@', '.', '.', '.', '@', '.', '.', '@', '.', '.', '@'], ['@', '.', '@', '.', '@', '.', '.', '@', '.', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '@' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'O': V[i][j] = 2 continue if maze[i][j] == '@': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ['|', 'N', '_', '_', '_', '|', '_', '_', '|', '|', '_', '_', '|', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '_', '_', '|', '_', '_', '|'], ['|', '_', '_', '_', '_', '|', '_', '_', '_', '_', '|', '_', '_', '|'], ['|', '_', '_', '_', '|', '_', '|', '_', '_', '_', '_', '|', '_', '|'], ['|', '_', '_', '_', '|', '|', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '_', '|', '_', '_', '_', '|'], ['|', '|', '|', '|', '|', '|', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '|', '_', '_', '_', '_', '_', '|', '_', '_', '|'], ['|', '_', '|', '|', '_', '_', '_', '|', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '|', '_', '|', '_', '|', '_', '|', 'S', '|'], ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ] ``` Information about the problem: 1. "N": agent 2. "S": goal 3. "|": wall 4. "_": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "S": 1 [/INST] import numpy as np maze=[ ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ['|', 'N', '_', '_', '_', '|', '_', '_', '|', '|', '_', '_', '|', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '_', '_', '|', '_', '_', '|'], ['|', '_', '_', '_', '_', '|', '_', '_', '_', '_', '|', '_', '_', '|'], ['|', '_', '_', '_', '|', '_', '|', '_', '_', '_', '_', '|', '_', '|'], ['|', '_', '_', '_', '|', '|', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '_', '|', '_', '_', '_', '|'], ['|', '|', '|', '|', '|', '|', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '|', '_', '_', '_', '_', '_', '|', '_', '_', '|'], ['|', '_', '|', '|', '_', '_', '_', '|', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '|', '_', '|', '_', '|', '_', '|', 'S', '|'], ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '|' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'S': V[i][j] = 2 continue if maze[i][j] == '|': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', '*'], ['*', '*', ' ', '*', ' ', ' ', '*', ' ', '*', '*', ' ', ' ', '*'], ['*', ' ', '*', '*', ' ', ' ', '*', '*', ' ', ' ', ' ', '*', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', '*', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] ``` Information about the problem: 1. "E": agent 2. "T": goal 3. "*": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "T": 1 [/INST] import numpy as np maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', '*'], ['*', '*', ' ', '*', ' ', ' ', '*', ' ', '*', '*', ' ', ' ', '*'], ['*', ' ', '*', '*', ' ', ' ', '*', '*', ' ', ' ', ' ', '*', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', '*', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'T': V[i][j] = 5 continue if maze[i][j] == '*': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '.', '.', '.', '.', '.', '@', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '@', '@', '.', '.', '.', '.', '@'], ['@', '@', '@', '.', '.', '@', '.', '@', '@'], ['@', '@', '.', '.', '.', '.', '.', '@', '@'], ['@', '.', '@', '@', '.', '.', '.', '.', '@'], ['@', '@', '.', '@', '.', '.', '.', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@'], ] ``` Information about the problem: 1. "T": agent 2. "O": goal 3. "@": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "O": 1 [/INST] import numpy as np maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '.', '.', '.', '.', '.', '@', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '@', '@', '.', '.', '.', '.', '@'], ['@', '@', '@', '.', '.', '@', '.', '@', '@'], ['@', '@', '.', '.', '.', '.', '.', '@', '@'], ['@', '.', '@', '@', '.', '.', '.', '.', '@'], ['@', '@', '.', '@', '.', '.', '.', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '@' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'O': V[i][j] = 2 continue if maze[i][j] == '@': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '.', '.', '@', '.', '.', '@', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '@', '.', '.', '.', '.', '.', '.', '@', '.', '@'], ['@', '.', '@', '.', '.', '.', '@', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '@', '.', '.', '.', '.', '@', '@', '.', '.', '.', '@', '@'], ['@', '.', '.', '@', '.', '@', '.', '@', '.', '.', '.', '.', '.', '@'], ['@', '.', '@', '@', '.', '.', '.', '@', '.', '.', '.', '@', '@', '@'], ['@', '@', '.', '@', '.', '@', '.', '@', '.', '.', '.', '.', '.', '@'], ['@', '@', '@', '.', '.', '.', '@', '.', '@', '@', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] ``` Information about the problem: 1. "T": agent 2. "O": goal 3. "@": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "O": 1 [/INST] import numpy as np maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '.', '.', '@', '.', '.', '@', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '@', '.', '.', '.', '.', '.', '.', '@', '.', '@'], ['@', '.', '@', '.', '.', '.', '@', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '@', '.', '.', '.', '.', '@', '@', '.', '.', '.', '@', '@'], ['@', '.', '.', '@', '.', '@', '.', '@', '.', '.', '.', '.', '.', '@'], ['@', '.', '@', '@', '.', '.', '.', '@', '.', '.', '.', '@', '@', '@'], ['@', '@', '.', '@', '.', '@', '.', '@', '.', '.', '.', '.', '.', '@'], ['@', '@', '@', '.', '.', '.', '@', '.', '@', '@', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '@' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'O': V[i][j] = 2 continue if maze[i][j] == '@': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '*', '*', '^', '*', '^'], ['^', '^', '^', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '^', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '^', '^', '*', '*', '^', '^'], ['^', '^', '*', '^', '^', '*', '*', '^', '^'], ['^', '*', '^', '^', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^'], ] ``` Information about the problem: 1. "S": agent 2. "H": goal 3. "^": wall 4. "*": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "H": 1 [/INST] import numpy as np maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '*', '*', '^', '*', '^'], ['^', '^', '^', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '^', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '^', '^', '*', '*', '^', '^'], ['^', '^', '*', '^', '^', '*', '*', '^', '^'], ['^', '*', '^', '^', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'H': V[i][j] = 3 continue if maze[i][j] == '^': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', 'O', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', 'O'], ['O', 'O', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', 'O', '.', '.', 'O', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', 'O', 'O', '.', '.', 'O', 'O'], ['O', '.', '.', 'O', '.', 'O', '.', '.', 'O'], ['O', 'O', '.', '.', 'O', '.', '.', '.', 'O'], ['O', '.', '.', 'O', '.', '.', '.', '.', 'O'], ['O', 'O', '.', 'O', '.', 'O', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "R": agent 2. "P": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "P": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', 'O', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', 'O'], ['O', 'O', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', 'O', '.', '.', 'O', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', 'O', 'O', '.', '.', 'O', 'O'], ['O', '.', '.', 'O', '.', 'O', '.', '.', 'O'], ['O', 'O', '.', '.', 'O', '.', '.', '.', 'O'], ['O', '.', '.', 'O', '.', '.', '.', '.', 'O'], ['O', 'O', '.', 'O', '.', 'O', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'P': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', 'O'], ['O', '.', '.', 'O', 'O', '.', '.', 'O', '.', '.', 'O', 'O', '.', 'O'], ['O', 'O', '.', '.', '.', '.', 'O', '.', 'O', '.', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', '.', 'O', '.', 'O', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', 'O', '.', 'O', 'O'], ['O', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "R": agent 2. "P": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "P": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', 'O'], ['O', '.', '.', 'O', 'O', '.', '.', 'O', '.', '.', 'O', 'O', '.', 'O'], ['O', 'O', '.', '.', '.', '.', 'O', '.', 'O', '.', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', '.', 'O', '.', 'O', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', 'O', '.', 'O', 'O'], ['O', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'P': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', '~', '~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~', ' ', '~', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', '~', ' ', '~', ' ', ' ', '~', ' ', ' ', ' ', '~'], ['~', '~', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', '~', '~', '~', ' ', '~', ' ', ' ', ' ', ' ', '~', ' ', '~'], ['~', '~', '~', ' ', '~', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', '~', ' ', ' ', ' ', '~', '~', '~', ' ', ' ', ' ', ' ', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] ``` Information about the problem: 1. "P": agent 2. "X": goal 3. "~": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "X": 1 [/INST] import numpy as np maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', '~', '~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~', ' ', '~', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', '~', ' ', '~', ' ', ' ', '~', ' ', ' ', ' ', '~'], ['~', '~', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', '~', '~', '~', ' ', '~', ' ', ' ', ' ', ' ', '~', ' ', '~'], ['~', '~', '~', ' ', '~', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', '~', ' ', ' ', ' ', '~', '~', '~', ' ', ' ', ' ', ' ', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'X': V[i][j] = 5 continue if maze[i][j] == '~': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ['|', 'N', '|', '_', '_', '|', '|', '_', '_', '|', '_', '|'], ['|', '_', '|', '_', '|', '_', '_', '|', '|', '_', '|', '|'], ['|', '|', '_', '_', '_', '_', '|', '_', '|', '_', '_', '|'], ['|', '_', '|', '_', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '_', '|', '_', '|'], ['|', '_', '_', '|', '|', '_', '_', '|', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '|', '|', '|', '_', '|', '_', '_', '|', '_', '_', '|'], ['|', '_', '_', '_', '_', '|', '_', '_', '_', '|', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '_', '|', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '|', '|', 'S', '|'], ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ] ``` Information about the problem: 1. "N": agent 2. "S": goal 3. "|": wall 4. "_": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "S": 1 [/INST] import numpy as np maze=[ ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ['|', 'N', '|', '_', '_', '|', '|', '_', '_', '|', '_', '|'], ['|', '_', '|', '_', '|', '_', '_', '|', '|', '_', '|', '|'], ['|', '|', '_', '_', '_', '_', '|', '_', '|', '_', '_', '|'], ['|', '_', '|', '_', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '_', '|', '_', '|'], ['|', '_', '_', '|', '|', '_', '_', '|', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '|', '|', '|', '_', '|', '_', '_', '|', '_', '_', '|'], ['|', '_', '_', '_', '_', '|', '_', '_', '_', '|', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '_', '|', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '|', '|', 'S', '|'], ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '|' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'S': V[i][j] = 2 continue if maze[i][j] == '|': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', 'O', '.', '.', 'O', '.', '.', 'O', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', '.', 'O'], ['O', 'O', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', 'O', '.', 'O', '.', 'O', '.', 'O', 'O'], ['O', 'O', 'O', '.', 'O', '.', 'O', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', 'O', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "R": agent 2. "P": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "P": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', 'O', '.', '.', 'O', '.', '.', 'O', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', '.', 'O'], ['O', 'O', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', 'O', '.', 'O', '.', 'O', '.', 'O', 'O'], ['O', 'O', 'O', '.', 'O', '.', 'O', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', 'O', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'P': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ['|', 'N', '_', '|', '_', '|', '_', '_', '|', '_', '_', '_', '|'], ['|', '_', '_', '|', '|', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '|', '|', '_', '_', '_', '|'], ['|', '|', '_', '_', '|', '_', '|', '|', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '|', '|', '_', '_', '_', '_', '|', '|'], ['|', '_', '|', '_', '|', '_', '|', '_', '_', '|', '_', '|', '|'], ['|', '_', '|', '_', '_', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '|', '_', '_', '|', '|', '_', '_', '_', '_', '|', '|'], ['|', '|', '_', '|', '_', '_', '|', '_', '|', '_', '_', '|', '|'], ['|', '_', '_', '|', '_', '_', '_', '_', '_', '_', '|', '_', '|'], ['|', '_', '_', '_', '_', '|', '_', '_', '_', '_', '|', '_', '|'], ['|', '_', '_', '|', '|', '_', '_', '_', '_', '_', '|', 'S', '|'], ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ] ``` Information about the problem: 1. "N": agent 2. "S": goal 3. "|": wall 4. "_": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "S": 1 [/INST] import numpy as np maze=[ ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ['|', 'N', '_', '|', '_', '|', '_', '_', '|', '_', '_', '_', '|'], ['|', '_', '_', '|', '|', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '_', '_', '|', '|', '_', '_', '_', '|'], ['|', '|', '_', '_', '|', '_', '|', '|', '_', '_', '_', '_', '|'], ['|', '_', '_', '_', '_', '|', '|', '_', '_', '_', '_', '|', '|'], ['|', '_', '|', '_', '|', '_', '|', '_', '_', '|', '_', '|', '|'], ['|', '_', '|', '_', '_', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '_', '|', '_', '_', '|', '|', '_', '_', '_', '_', '|', '|'], ['|', '|', '_', '|', '_', '_', '|', '_', '|', '_', '_', '|', '|'], ['|', '_', '_', '|', '_', '_', '_', '_', '_', '_', '|', '_', '|'], ['|', '_', '_', '_', '_', '|', '_', '_', '_', '_', '|', '_', '|'], ['|', '_', '_', '|', '|', '_', '_', '_', '_', '_', '|', 'S', '|'], ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '|' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'S': V[i][j] = 2 continue if maze[i][j] == '|': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '@', '.', '@', '.', '@', '.', '.', '.', '@', '@', '.', '.', '@'], ['@', '.', '.', '@', '.', '@', '.', '.', '@', '.', '@', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '@', '@', '.', '@', '.', '@', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@', '.', '.', '.', '.', '@', '@'], ['@', '.', '.', '.', '.', '.', '.', '@', '.', '.', '.', '@', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '.', '@', '.', '.', '@', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '@', '.', '.', '@', '@', '.', '@', '.', '.', '.', '@', '.', '@', '@'], ['@', '@', '@', '@', '@', '@', '.', '.', '.', '.', '.', '.', '@', '@', '@'], ['@', '.', '.', '@', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] ``` Information about the problem: 1. "T": agent 2. "O": goal 3. "@": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "O": 1 [/INST] import numpy as np maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '@', '.', '@', '.', '@', '.', '.', '.', '@', '@', '.', '.', '@'], ['@', '.', '.', '@', '.', '@', '.', '.', '@', '.', '@', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '@', '@', '.', '@', '.', '@', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@', '.', '.', '.', '.', '@', '@'], ['@', '.', '.', '.', '.', '.', '.', '@', '.', '.', '.', '@', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '.', '@', '.', '.', '@', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '@', '.', '.', '@', '@', '.', '@', '.', '.', '.', '@', '.', '@', '@'], ['@', '@', '@', '@', '@', '@', '.', '.', '.', '.', '.', '.', '@', '@', '@'], ['@', '.', '.', '@', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '@' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'O': V[i][j] = 2 continue if maze[i][j] == '@': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '.', '@', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '@', '@'], ['@', '.', '.', '.', '.', '@', '@', '@', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '@', '.', '@', '@', '@', '.', '@'], ['@', '@', '.', '@', '.', '@', '@', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '@', '@', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '@', '.', '.', '@', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@'], ] ``` Information about the problem: 1. "T": agent 2. "O": goal 3. "@": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "O": 1 [/INST] import numpy as np maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '.', '@', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '@', '@'], ['@', '.', '.', '.', '.', '@', '@', '@', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '@', '.', '@', '@', '@', '.', '@'], ['@', '@', '.', '@', '.', '@', '@', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '.', '@', '@', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '.', '@', '.', '.', '@', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '@' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'O': V[i][j] = 2 continue if maze[i][j] == '@': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', '*', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', '*', '*', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', '*', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', '*', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', ' ', '*', ' ', '*', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', '*', '*', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*'], ] ``` Information about the problem: 1. "E": agent 2. "T": goal 3. "*": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "T": 1 [/INST] import numpy as np maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', '*', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', '*', ' ', ' ', ' ', '*', '*', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', '*', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', '*', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', ' ', '*', ' ', '*', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', '*', '*', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'T': V[i][j] = 5 continue if maze[i][j] == '*': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', '*', '*', ' ', '*'], ['*', ' ', '*', '*', ' ', '*', ' ', ' ', ' ', '*', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*'], ['*', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', '*', '*'], ['*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', '*', '*'], ['*', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] ``` Information about the problem: 1. "E": agent 2. "T": goal 3. "*": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "T": 1 [/INST] import numpy as np maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', '*', '*', ' ', '*'], ['*', ' ', '*', '*', ' ', '*', ' ', ' ', ' ', '*', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*'], ['*', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', '*', '*'], ['*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', '*', '*'], ['*', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'T': V[i][j] = 5 continue if maze[i][j] == '*': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', ' ', ' ', '*', ' ', ' ', '*', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*'], ['*', ' ', '*', ' ', ' ', '*', ' ', '*', '*', ' ', '*'], ['*', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] ``` Information about the problem: 1. "E": agent 2. "T": goal 3. "*": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "T": 1 [/INST] import numpy as np maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', '*', ' ', ' ', '*', ' ', ' ', '*', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'], ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*'], ['*', ' ', '*', ' ', ' ', '*', ' ', '*', '*', ' ', '*'], ['*', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'T': V[i][j] = 5 continue if maze[i][j] == '*': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '^', '^', '^', '*', '^'], ['^', '*', '*', '*', '^', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '^', '^'], ['^', '^', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '^', '^', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '^', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^'], ] ``` Information about the problem: 1. "S": agent 2. "H": goal 3. "^": wall 4. "*": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "H": 1 [/INST] import numpy as np maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '^', '^', '^', '*', '^'], ['^', '*', '*', '*', '^', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '^', '^'], ['^', '^', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '^', '^', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '^', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'H': V[i][j] = 3 continue if maze[i][j] == '^': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', 'O', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', 'O', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', 'O', '.', '.', 'O', '.', 'O', '.', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', 'O', '.', 'O', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', 'O', '.', 'O', '.', 'O', '.', 'O'], ['O', '.', 'O', 'O', '.', '.', 'O', 'O', '.', '.', '.', 'O'], ['O', 'O', '.', '.', '.', '.', 'O', '.', '.', '.', 'O', 'O'], ['O', '.', '.', '.', 'O', '.', 'O', '.', '.', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "R": agent 2. "P": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "P": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', 'O', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', '.', '.', '.', 'O', '.', 'O', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', 'O', '.', '.', 'O', '.', 'O', '.', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', 'O', '.', 'O', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', 'O', '.', 'O', '.', 'O', '.', 'O'], ['O', '.', 'O', 'O', '.', '.', 'O', 'O', '.', '.', '.', 'O'], ['O', 'O', '.', '.', '.', '.', 'O', '.', '.', '.', 'O', 'O'], ['O', '.', '.', '.', 'O', '.', 'O', '.', '.', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'P': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '^', '*', '*', '^', '*', '*', '^', '^', '*', '^', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '^', '*', '*', '*', '^', '*', '^', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '^', '^', '*', '*', '*', '^', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^', '^', '^'], ['^', '*', '^', '*', '*', '*', '^', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '^', '^', '^', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '^', '^', '^', '*', '*', '*', '*', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '*', '*', '*', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] ``` Information about the problem: 1. "S": agent 2. "H": goal 3. "^": wall 4. "*": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "H": 1 [/INST] import numpy as np maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '^', '*', '*', '^', '*', '*', '^', '^', '*', '^', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '^', '*', '*', '*', '^', '*', '^', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '^', '^', '*', '*', '*', '^', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^', '^', '^'], ['^', '*', '^', '*', '*', '*', '^', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '^', '^', '^', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '*', '^', '^', '^', '*', '*', '*', '*', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '*', '*', '*', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'H': V[i][j] = 3 continue if maze[i][j] == '^': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '^', '*', '*', '^', '*', '*', '^', '^', '*', '*', '^', '^'], ['^', '*', '*', '*', '^', '^', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '^', '*', '*', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '^', '*', '^', '*', '*', '*', '^', '*', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '*', '^', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '^', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '^', '^', '^', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '*', '^', '*', '^', '^', '*', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] ``` Information about the problem: 1. "S": agent 2. "H": goal 3. "^": wall 4. "*": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "H": 1 [/INST] import numpy as np maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '^', '*', '*', '^', '*', '*', '^', '^', '*', '*', '^', '^'], ['^', '*', '*', '*', '^', '^', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '^', '*', '*', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '*', '^', '*', '^', '*', '*', '*', '^', '*', '*', '*', '^', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '*', '^', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '^', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '^', '^', '^', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '*', '^', '*', '^', '^', '*', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'H': V[i][j] = 3 continue if maze[i][j] == '^': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'D', '-', '-', '-', '-', '~', '-', '~'], ['~', '-', '~', '-', '-', '-', '~', '-', '~'], ['~', '-', '~', '-', '-', '-', '-', '-', '~'], ['~', '-', '-', '~', '-', '-', '~', '~', '~'], ['~', '-', '~', '-', '-', '-', '-', '-', '~'], ['~', '-', '-', '-', '~', '~', '~', '-', '~'], ['~', '-', '~', '-', '~', '~', '-', '-', '~'], ['~', '-', '-', '-', '-', '-', '-', 'C', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~'], ] ``` Information about the problem: 1. "D": agent 2. "C": goal 3. "~": wall 4. "-": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "C": 1 [/INST] import numpy as np maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'D', '-', '-', '-', '-', '~', '-', '~'], ['~', '-', '~', '-', '-', '-', '~', '-', '~'], ['~', '-', '~', '-', '-', '-', '-', '-', '~'], ['~', '-', '-', '~', '-', '-', '~', '~', '~'], ['~', '-', '~', '-', '-', '-', '-', '-', '~'], ['~', '-', '-', '-', '~', '~', '~', '-', '~'], ['~', '-', '~', '-', '~', '~', '-', '-', '~'], ['~', '-', '-', '-', '-', '-', '-', 'C', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'C': V[i][j] = 2 continue if maze[i][j] == '~': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', '*', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*'], ['*', '*', '*', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', '*', '*', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', ' ', '*', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', '*', '*'], ['*', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*', '*', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] ``` Information about the problem: 1. "E": agent 2. "T": goal 3. "*": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "T": 1 [/INST] import numpy as np maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', '*', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*'], ['*', '*', '*', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', '*', '*', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', ' ', '*', '*'], ['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '*', '*', '*'], ['*', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*', '*', ' ', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'T': V[i][j] = 5 continue if maze[i][j] == '*': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', '~', ' ', ' ', ' ', '~', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', '~', '~', ' ', '~', '~', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', '~', '~', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', '~', '~', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', ' ', ' ', '~', '~', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] ``` Information about the problem: 1. "P": agent 2. "X": goal 3. "~": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "X": 1 [/INST] import numpy as np maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', '~', ' ', ' ', ' ', '~', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', '~', '~', ' ', '~', '~', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', '~', '~', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', '~', '~', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', ' ', ' ', '~', '~', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'X': V[i][j] = 5 continue if maze[i][j] == '~': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ['|', 'N', '_', '_', '_', '_', '_', '_', '|', '|'], ['|', '|', '_', '|', '_', '_', '|', '_', '|', '|'], ['|', '_', '_', '|', '_', '_', '_', '_', '|', '|'], ['|', '|', '_', '|', '|', '_', '_', '_', '|', '|'], ['|', '_', '_', '_', '_', '|', '_', '_', '_', '|'], ['|', '|', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '|', '_', '_', '_', '|', '_', '_', 'S', '|'], ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ] ``` Information about the problem: 1. "N": agent 2. "S": goal 3. "|": wall 4. "_": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "S": 1 [/INST] import numpy as np maze=[ ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ['|', 'N', '_', '_', '_', '_', '_', '_', '|', '|'], ['|', '|', '_', '|', '_', '_', '|', '_', '|', '|'], ['|', '_', '_', '|', '_', '_', '_', '_', '|', '|'], ['|', '|', '_', '|', '|', '_', '_', '_', '|', '|'], ['|', '_', '_', '_', '_', '|', '_', '_', '_', '|'], ['|', '|', '_', '_', '_', '_', '_', '_', '_', '|'], ['|', '|', '_', '_', '_', '|', '_', '_', 'S', '|'], ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '|' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'S': V[i][j] = 2 continue if maze[i][j] == '|': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '*', '*', '*', '*', '^', '^', '*', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^', '^', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '^', '^', '*', '^', '*', '^', '^'], ['^', '*', '^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '^', '*', '*', '*', '*', '*', '*', '^', '*', '*', '*', '^'], ['^', '^', '*', '*', '*', '^', '*', '*', '^', '*', '*', '*', '^', '^', '^'], ['^', '*', '^', '*', '*', '*', '*', '*', '^', '*', '^', '*', '^', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] ``` Information about the problem: 1. "S": agent 2. "H": goal 3. "^": wall 4. "*": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "H": 1 [/INST] import numpy as np maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '*', '*', '*', '*', '^', '^', '*', '^', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^', '^', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '^', '*', '*', '^', '^', '*', '^', '*', '^', '^'], ['^', '*', '^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '^', '*', '*', '*', '*', '*', '*', '^', '*', '*', '*', '^'], ['^', '^', '*', '*', '*', '^', '*', '*', '^', '*', '*', '*', '^', '^', '^'], ['^', '*', '^', '*', '*', '*', '*', '*', '^', '*', '^', '*', '^', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'H': V[i][j] = 3 continue if maze[i][j] == '^': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '^', '*', '*', '^', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '^', '*', '^', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '^', '*', '^', '^', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '*', '*', '^'], ['^', '^', '^', '*', '^', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '^', '^', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '^', '^', '*', '*', '^'], ['^', '^', '*', '^', '^', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '^', '*', '^', '*', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] ``` Information about the problem: 1. "S": agent 2. "H": goal 3. "^": wall 4. "*": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] ``` The rewards are: 1. "H": 1 [/INST] import numpy as np maze=[ ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ['^', 'S', '*', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '^', '*', '*', '^', '*', '^', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '^', '*', '^'], ['^', '*', '*', '*', '^', '*', '^', '*', '*', '*', '^'], ['^', '*', '^', '*', '*', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '*', '*', '^', '^'], ['^', '^', '*', '^', '^', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '*', '^', '*', '*', '^'], ['^', '^', '^', '*', '^', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '^', '^', '*', '*', '*', '*', '*', '^'], ['^', '*', '*', '*', '*', '*', '^', '^', '*', '*', '^'], ['^', '^', '*', '^', '^', '*', '^', '*', '*', '*', '^'], ['^', '*', '*', '*', '^', '*', '^', '*', '*', 'H', '^'], ['^', '^', '^', '^', '^', '^', '^', '^', '^', '^', '^'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'H': V[i][j] = 3 continue if maze[i][j] == '^': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'L', '.', '.', '.', 'O', 'O', '.', 'O', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', 'O', '.', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', 'O', '.', '.', '.', '.', 'O', 'O', 'O', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', 'O', 'O', 'O', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', 'O', '.', 'O', 'O', 'O'], ['O', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', 'O'], ['O', '.', '.', 'O', '.', '.', '.', 'O', '.', '.', 'O', 'B', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "L": agent 2. "B": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "B": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'L', '.', '.', '.', 'O', 'O', '.', 'O', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', 'O', '.', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', 'O', '.', '.', '.', '.', 'O', 'O', 'O', '.', 'O', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', 'O', 'O', 'O', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', 'O', '.', 'O', 'O', 'O'], ['O', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', 'O'], ['O', '.', '.', 'O', '.', '.', '.', 'O', '.', '.', 'O', 'B', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'B': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*', '*'], ['*', ' ', ' ', '*', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', '*', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', '*', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', '*', '*', ' ', ' ', '*', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] ``` Information about the problem: 1. "E": agent 2. "T": goal 3. "*": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "T": 1 [/INST] import numpy as np maze=[ ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ['*', 'E', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*', '*'], ['*', ' ', ' ', '*', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', '*', '*', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'], ['*', '*', '*', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*'], ['*', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', '*'], ['*', ' ', ' ', ' ', ' ', ' ', '*', '*', '*', ' ', ' ', '*', 'T', '*'], ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'T': V[i][j] = 5 continue if maze[i][j] == '*': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', 'O', '.', 'O', '.', '.', 'O', 'O', '.', 'O', 'O'], ['O', '.', 'O', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', 'O', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', '.', 'O', 'O', 'O'], ['O', '.', 'O', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', 'O', 'O', 'O', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', 'O', '.', 'O', '.', '.', '.', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "R": agent 2. "P": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "P": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'R', 'O', '.', 'O', '.', '.', 'O', 'O', '.', 'O', 'O'], ['O', '.', 'O', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', 'O', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', '.', 'O', 'O', 'O'], ['O', '.', 'O', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', 'O', '.', '.', 'O'], ['O', '.', 'O', 'O', 'O', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'], ['O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', 'O', '.', 'O', '.', '.', '.', '.', 'P', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'P': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '@', '@', '.', '.', '.', '.', '.', '@', '.', '@'], ['@', '@', '.', '.', '.', '.', '.', '@', '.', '.', '.', '@'], ['@', '@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '@', '.', '.', '.', '.', '.', '.', '@', '.', '@'], ['@', '.', '.', '.', '@', '.', '.', '.', '.', '.', '.', '@'], ['@', '@', '.', '@', '@', '.', '.', '.', '@', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@', '.', '@', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@', '.', '.', '@'], ['@', '@', '.', '.', '.', '.', '.', '.', '.', '@', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] ``` Information about the problem: 1. "T": agent 2. "O": goal 3. "@": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "O": 1 [/INST] import numpy as np maze=[ ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ['@', 'T', '@', '@', '.', '.', '.', '.', '.', '@', '.', '@'], ['@', '@', '.', '.', '.', '.', '.', '@', '.', '.', '.', '@'], ['@', '@', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@'], ['@', '.', '@', '.', '.', '.', '.', '.', '.', '@', '.', '@'], ['@', '.', '.', '.', '@', '.', '.', '.', '.', '.', '.', '@'], ['@', '@', '.', '@', '@', '.', '.', '.', '@', '.', '.', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@', '.', '@', '@'], ['@', '.', '.', '.', '.', '.', '.', '.', '@', '.', '.', '@'], ['@', '@', '.', '.', '.', '.', '.', '.', '.', '@', 'O', '@'], ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '@' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'O': V[i][j] = 2 continue if maze[i][j] == '@': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'L', 'O', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'], ['O', '.', 'O', '.', 'O', '.', 'O', '.', 'O', '.', '.', 'O'], ['O', '.', '.', 'O', 'O', 'O', '.', 'O', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', 'O', '.', 'O', 'O', '.', 'O'], ['O', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', 'O', '.', 'O', '.', '.', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'B', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] ``` Information about the problem: 1. "L": agent 2. "B": goal 3. "O": wall 4. ".": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0)] ``` The rewards are: 1. "B": 1 [/INST] import numpy as np maze=[ ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ['O', 'L', 'O', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'], ['O', '.', 'O', '.', 'O', '.', 'O', '.', 'O', '.', '.', 'O'], ['O', '.', '.', 'O', 'O', 'O', '.', 'O', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', '.', 'O', '.', 'O', 'O', '.', 'O'], ['O', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', 'O', 'O'], ['O', '.', '.', '.', '.', '.', 'O', '.', 'O', '.', '.', 'O'], ['O', 'O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'], ['O', '.', 'O', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'], ['O', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'B', 'O'], ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'B': V[i][j] = 3 continue if maze[i][j] == 'O': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'D', '-', '~', '-', '~', '-', '~', '-', '~', '~', '-', '~'], ['~', '-', '-', '-', '-', '-', '-', '-', '~', '-', '~', '-', '~'], ['~', '-', '~', '-', '-', '-', '-', '-', '-', '-', '-', '~', '~'], ['~', '~', '~', '~', '~', '-', '-', '-', '-', '-', '-', '-', '~'], ['~', '~', '-', '-', '-', '-', '-', '-', '-', '-', '~', '-', '~'], ['~', '~', '-', '-', '~', '-', '~', '~', '-', '-', '-', '-', '~'], ['~', '-', '~', '-', '-', '-', '-', '-', '~', '-', '-', '~', '~'], ['~', '-', '-', '-', '-', '-', '~', '-', '-', '-', '-', '-', '~'], ['~', '-', '~', '-', '-', '-', '-', '-', '-', '-', '~', '~', '~'], ['~', '-', '~', '-', '-', '-', '-', '-', '-', '-', '-', '-', '~'], ['~', '-', '-', '-', '~', '-', '-', '-', '-', '-', '~', '~', '~'], ['~', '-', '-', '-', '-', '~', '-', '-', '-', '-', '-', 'C', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] ``` Information about the problem: 1. "D": agent 2. "C": goal 3. "~": wall 4. "-": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "C": 1 [/INST] import numpy as np maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'D', '-', '~', '-', '~', '-', '~', '-', '~', '~', '-', '~'], ['~', '-', '-', '-', '-', '-', '-', '-', '~', '-', '~', '-', '~'], ['~', '-', '~', '-', '-', '-', '-', '-', '-', '-', '-', '~', '~'], ['~', '~', '~', '~', '~', '-', '-', '-', '-', '-', '-', '-', '~'], ['~', '~', '-', '-', '-', '-', '-', '-', '-', '-', '~', '-', '~'], ['~', '~', '-', '-', '~', '-', '~', '~', '-', '-', '-', '-', '~'], ['~', '-', '~', '-', '-', '-', '-', '-', '~', '-', '-', '~', '~'], ['~', '-', '-', '-', '-', '-', '~', '-', '-', '-', '-', '-', '~'], ['~', '-', '~', '-', '-', '-', '-', '-', '-', '-', '~', '~', '~'], ['~', '-', '~', '-', '-', '-', '-', '-', '-', '-', '-', '-', '~'], ['~', '-', '-', '-', '~', '-', '-', '-', '-', '-', '~', '~', '~'], ['~', '-', '-', '-', '-', '~', '-', '-', '-', '-', '-', 'C', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'C': V[i][j] = 2 continue if maze[i][j] == '~': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>
<s>[INST] <<SYS>>\n\n<</SYS>>\n\n This is a maze problem that I want you to solve. ``` maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', '~', '~', ' ', ' ', '~', ' ', ' ', '~', ' ', '~', ' ', '~'], ['~', ' ', '~', ' ', ' ', ' ', '~', ' ', '~', '~', ' ', ' ', '~', ' ', '~'], ['~', ' ', '~', ' ', '~', '~', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', '~', ' ', '~', ' ', '~', '~', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', '~', '~', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', '~', ' ', ' ', '~', ' ', ' ', '~', ' ', '~', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', '~', '~', '~', ' ', ' ', ' ', ' ', '~', '~', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] ``` Information about the problem: 1. "P": agent 2. "X": goal 3. "~": wall 4. " ": empty space These are the set of actions that an agent can perform: ``` actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] ``` The rewards are: 1. "X": 1 [/INST] import numpy as np maze=[ ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ['~', 'P', ' ', '~', '~', ' ', ' ', '~', ' ', ' ', '~', ' ', '~', ' ', '~'], ['~', ' ', '~', ' ', ' ', ' ', '~', ' ', '~', '~', ' ', ' ', '~', ' ', '~'], ['~', ' ', '~', ' ', '~', '~', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', '~', ' ', '~', ' ', '~', '~', ' ', ' ', '~'], ['~', '~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', '~', '~', ' ', ' ', ' ', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'], ['~', ' ', '~', ' ', ' ', '~', ' ', ' ', '~', ' ', '~', ' ', ' ', '~', '~'], ['~', ' ', ' ', ' ', '~', '~', '~', ' ', ' ', ' ', ' ', '~', '~', 'X', '~'], ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'], ] def value_iteration(maze, gamma=0.9): rows = len(maze) cols = len(maze[0]) # Initialize the value function V = np.zeros((rows, cols)) # Define actions: actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)] # Helper function to check if a cell is valid to move into def is_valid_move(x, y): return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~' # Perform value iteration for i in range(1000): for i in range(rows): for j in range(cols): if maze[i][j] == 'X': V[i][j] = 5 continue if maze[i][j] == '~': continue # Walls or obstacles have no value max_value = float('-inf') for action in actions: new_i, new_j = i + action[0], j + action[1] if is_valid_move(new_i, new_j): max_value = max(max_value, V[new_i][new_j]) V[i][j] = gamma * max_value return V np.set_printoptions(precision=2) print(value_iteration(maze)) </s>