import sys
import time
import json
import random
import errno
import math
import malmoutils
import numpy as np
import agentMC
malmoutils.fix_print()
agent_host = MalmoPython.AgentHost()
malmoutils.parse_command_line(agent_host)
recordingsDirectory = malmoutils.get_recordings_directory(agent_host)
video_requirements = '<VideoProducer><Width>860</Width><Height>480</Height></VideoProducer>' if agent_host.receivedArgument(
"record_video") else ''
# Task parameters:
MAX_DISTANCE = 40
MAX_ZOMBIES = 16
####### SPEED OF GAME #######
SPEED = 8
ARENA_WIDTH = MAX_DISTANCE
ARENA_BREADTH = MAX_DISTANCE
def getCorner(index, top, left, expand=0, y=0):
''' Return part of the XML string that defines the requested corner'''
x = str(-(expand + old_div(ARENA_WIDTH, 2))) if left else str(
print("Frames received: " + str(numFrames))
print("Average fps: " + "{0:.2f}".format(averagefps))
print("Frame data transferred: " + "{0:.2f}".format(dataShifted) + "MB")
print("Data transfer rate: " + "{0:.2f}".format(datarate) + "MB/s")
print("===============================================================================================")
print()
if iRepeat % 2:
fps_offscreen.append(averagefps)
datarate_offscreen.append(datarate)
else:
fps_onscreen.append(averagefps)
datarate_onscreen.append(datarate)
time.sleep(0.5) # Give mod a little time to get back to dormant state.
if SHOW_PLOT:
# Now plot some graphs:
plot_fpsoff = pylab.plot(num_pixels, fps_offscreen, 'r', label='render speed (no onscreen updates)')
plot_fpson = pylab.plot(num_pixels, fps_onscreen, 'g', label='render speed (with onscreen updates)')
plot_dataoff = pylab.plot(num_pixels, datarate_offscreen, 'b', label='data transfer speed (no onscreen updates)')
plot_dataon = pylab.plot(num_pixels, datarate_onscreen, 'y', label='data transfer speed (with onscreen updates)')
pylab.xlabel("Frame size (pixels)")
pylab.ylabel("MB/s or frames/s")
pylab.legend()
pylab.title("Plot of render and data-transfer speeds for varying frame sizes, with and without onscreen rendering")
if TESTING:
pylab.savefig(malmoutils.get_recordings_directory(agent_host) + "//render_test_results.png")
else:
pylab.show()
import os import random import sys import time import json import copy import errno import xml.etree.ElementTree from collections import deque import malmoutils malmoutils.fix_print() agent_host = MalmoPython.AgentHost() malmoutils.parse_command_line(agent_host) recordingsDirectory = malmoutils.get_recordings_directory(agent_host) # Set up some pallettes: colourful=["stained_glass", "diamond_block", "lapis_block", "gold_block", "redstone_block", "obsidian"] fiery=["stained_glass WHITE", "stained_glass PINK", "stained_glass ORANGE", "stained_glass RED", "wool BLACK", "glowstone"] oresome=["gold_ore", "lapis_ore", "iron_ore", "emerald_ore", "redstone_ore", "quartz_ore"] frilly=["skull", "stained_glass WHITE", "wool PINK", "wool WHITE", "stained_hardened_clay PINK", "stained_hardened_clay WHITE"] icepalace=["ice", "stained_glass", "stained_glass", "stained_glass", "stained_glass", "snow"] volatile=["tnt", "stained_glass", "stained_glass", "redstone_block", "stained_glass", "stained_glass"] oak=["planks", "planks", "planks", "planks", "lapis_block", "lapis_block"] sponge=["sponge", "glass", "sponge", "glass", "sponge", "glass"] palletes = [colourful, fiery, oresome, frilly, icepalace, volatile, oak, sponge] # dimensions of the test structure: SIZE_X = 21 SIZE_Y = 31
import malmoutils
agentHost = MalmoPython.AgentHost()
# See if we can parse our extended command line.
malmoutils.parse_command_line(agentHost)
# As we are not recording our video xml should be an empty string.
assert malmoutils.get_video_xml(agentHost) == ''
# Test that we can get a default recording spec.
assert type(malmoutils.get_default_recording_object(
agentHost, "test")) == MalmoPython.MissionRecordSpec
# Default recordings directory is ''.
assert malmoutils.get_recordings_directory(agentHost) == ''
def clientInfos(cp):
return [(c.ip_address, c.control_port, c.command_port) for c in cp.clients]
# Test adding some client infos to a client pool.
clientPool = MalmoPython.ClientPool()
assert len(clientPool.clients) == 0
c1 = ("localhost", 10000, 0)
client1 = MalmoPython.ClientInfo(*c1)
clientPool.add(client1)
assert clientInfos(clientPool) == [c1]
c2 = ("127.0.0.1", 10001, 20001)
client2 = MalmoPython.ClientInfo(*c2)
def main(agent_host):
device = torch.device("cpu")
if VISION_ENABLED:
eyes = Eyes()
if GET_VISION_DATA:
clear_images()
malmoutils.fix_print()
malmoutils.parse_command_line(agent_host)
recordingsDirectory = malmoutils.get_recordings_directory(agent_host)
q_network = QNetwork((2, Hyperparameters.OBS_SIZE, Hyperparameters.OBS_SIZE), len(Hyperparameters.ACTION_DICT))
target_network = QNetwork((2, Hyperparameters.OBS_SIZE, Hyperparameters.OBS_SIZE), len(Hyperparameters.ACTION_DICT))
target_network.load_state_dict(q_network.state_dict())
optim = torch.optim.Adam(q_network.parameters(), lr= Hyperparameters.LEARNING_RATE)
replay_buffer = deque(maxlen=Hyperparameters.REPLAY_BUFFER_SIZE)
global_step = 0
num_episode = 0
epsilon = 1
start_time = time.time()
returns = []
steps = []
loss_array = []
loop = tqdm(total=Hyperparameters.MAX_GLOBAL_STEPS, position=0, leave=False)
result_dataset = []
print("Global Step", Hyperparameters.MAX_GLOBAL_STEPS)
while global_step < Hyperparameters.MAX_GLOBAL_STEPS:
episode_step = 0
episode_return = 0
episode_loss = 0
done = False
#Initialize
agent_host = init_malmo(agent_host,recordingsDirectory, video_width,video_height)
world_state = agent_host.getWorldState()
while not world_state.has_mission_begun:
time.sleep(0.1)
world_state = agent_host.getWorldState()
#for error in world_state.errors:
#print("\nError:",error.text)
obs = get_observation(world_state, agent_host)
#Testing
agent_host.sendCommand( "move 1" )
while world_state.is_mission_running:
#Depth Implementation
while world_state.number_of_video_frames_since_last_state < 1 and world_state.is_mission_running:
time.sleep(0.05)
world_state = agent_host.getWorldState()
if world_state.is_mission_running:
frame = world_state.video_frames[0].pixels
processFrame(frame)
if GET_VISION_DATA:
try:
result_dataset.append(view_surrounding(video_height, video_width, frame, global_step))
except:
print("Error in getting image for training data.")
elif VISION_ENABLED:
input_img_temp = get_img(world_state,frame,agent_host,eyes,device,video_width,video_height)
print("Yaw Delta ", current_yaw_delta_from_depth)
if current_yaw_delta_from_depth > 0:
agent_host.sendCommand(Hyperparameters.ACTION_DICT[1])
else:
agent_host.sendCommand(Hyperparameters.ACTION_DICT[2])
action_idx = get_action(obs, q_network, epsilon)
command = Hyperparameters.ACTION_DICT[action_idx]
agent_host.sendCommand(command)
#agent_host.sendCommand( "turn " + str(current_yaw_delta_from_depth) )
#time.sleep(.3)
episode_step += 1
if episode_step >= Hyperparameters.MAX_EPISODE_STEPS or \
(obs[0, int(Hyperparameters.OBS_SIZE/2)+1, int(Hyperparameters.OBS_SIZE/2)] == -1 and \
command == 'movesouth 1'):
done = True
time.sleep(2)
world_state = agent_host.getWorldState()
for error in world_state.errors:
print("Error:", error.text)
next_obs = get_observation(world_state, agent_host)
reward = 0
for r in world_state.rewards:
reward += r.getValue()
episode_return += reward
replay_buffer.append((obs, action_idx, next_obs, reward, done))
obs = next_obs
global_step += 1
#print(global_step)
if global_step == Hyperparameters.MAX_GLOBAL_STEPS:
break
if global_step > Hyperparameters.START_TRAINING and global_step % Hyperparameters.LEARN_FREQUENCY == 0:
batch = prepare_batch(replay_buffer)
loss = learn(batch, optim, q_network, target_network)
episode_loss += loss
if epsilon > Hyperparameters.MIN_EPSILON:
epsilon *= Hyperparameters.EPSILON_DECAY
if global_step % Hyperparameters.TARGET_UPDATE == 0:
target_network.load_state_dict(q_network.state_dict())
num_episode += 1
returns.append(episode_return)
loss_array.append(episode_loss)
steps.append(global_step)
avg_return = sum(returns[-min(len(returns), 10):]) / min(len(returns), 10)
loop.update(episode_step)
loop.set_description('Episode: {} Steps: {} Time: {:.2f} Loss: {:.2f} Last Return: {:.2f} Avg Return: {:.2f}'.format(
num_episode, global_step, (time.time() - start_time) / 60, episode_loss, episode_return, avg_return))
if num_episode > 0 and num_episode % 10 == 0:
log_returns(steps, loss_array)
#print()
#print(len(result_dataset))
np.save("images/image_labels",np.array(result_dataset))
import MalmoPython
import malmoutils
agentHost = MalmoPython.AgentHost()
# See if we can parse our extended command line.
malmoutils.parse_command_line(agentHost)
# As we are not recording our video xml should be an empty string.
assert malmoutils.get_video_xml(agentHost) == ''
# Test that we can get a default recording spec.
assert type(malmoutils.get_default_recording_object(agentHost, "test")) == MalmoPython.MissionRecordSpec
# Default recordings directory is ''.
assert malmoutils.get_recordings_directory(agentHost) == ''
def clientInfos(cp):
return [(c.ip_address, c.control_port, c.command_port) for c in cp.clients]
# Test adding some client infos to a client pool.
clientPool = MalmoPython.ClientPool()
assert len(clientPool.clients) == 0
c1 = ("localhost", 10000, 0)
client1 = MalmoPython.ClientInfo(*c1)
clientPool.add(client1)
assert clientInfos(clientPool) == [c1]
c2 = ("127.0.0.1", 10001, 20001)
client2 = MalmoPython.ClientInfo(*c2)
clientPool.add(client2)
assert clientInfos(clientPool) == [c1, c2]
"damping_factor":dampen_factor
}
if SWEEP_DAMPENING_FACTOR:
print(run)
run_data.append(run)
time.sleep(0.5) # Give mod a little time to get back to dormant state.
if SWEEP_DAMPENING_FACTOR:
import matplotlib
import numpy
import pylab
damp_vals = [x["damping_factor"] for x in run_data]
reversals = [x["reversals"] for x in run_data]
total_yaw = [x["total_abs_yaw_deltas"] for x in run_data]
commands = [x["commands_sent"] for x in run_data]
plot_reversals = pylab.plot(damp_vals, reversals, 'r-', label='Reversals')
plot_yaw = pylab.plot(damp_vals, total_yaw, 'g-', label='Total abs yaw delta')
plot_commands = pylab.plot(damp_vals, commands, 'b-', label='Commands sent')
pylab.xlabel('Damping factor')
pylab.legend()
pylab.title("Sweep of dampening factor.")
if TESTING:
pylab.savefig(malmoutils.get_recordings_directory(agent_host) + "//dampening_factor_sweep.png")
else:
pylab.show()
if TESTING and successful_runs == 0:
print("No successful runs!")
exit(1)
def main():
sight = {'x': (-30, 30), 'z': (-30, 30), 'y': (-1, 1)}
range_x = abs(sight['x'][1] - sight['x'][0]) + 1
range_y = abs(sight['y'][1] - sight['y'][0]) + 1
range_z = abs(sight['z'][1] - sight['z'][0]) + 1
malmoutils.fix_print()
agent_host = MalmoPython.AgentHost()
malmoutils.parse_command_line(agent_host)
recordingsDirectory = malmoutils.get_recordings_directory(agent_host)
recordingsDirectory = "../human_trajectories"
if (not os.path.exists(recordingsDirectory)):
os.mkdir(recordingsDirectory)
logging.basicConfig(level=logging.INFO)
# pdb.set_trace()
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG) # set to INFO if you want fewer messages
video_width = 640
video_height = 480
sys.argv
mission_xml_path = "../custom_xmls/usar.xml"
validate = True
# my_mission = MalmoPython.MissionSpec(missionXML, validate)
my_mission = MalmoPython.MissionSpec(getMissionXML(mission_xml_path),
validate)
# ObservationFromGrid
my_mission.observeGrid(sight['x'][0], sight['y'][0], sight['z'][0],
sight['x'][1], sight['y'][1], sight['z'][1],
'relative_view')
# agent_host.setObservationsPolicy(MalmoPython.ObservationsPolicy.LATEST_OBSERVATION_ONLY)
agent_host.setVideoPolicy(MalmoPython.VideoPolicy.LATEST_FRAME_ONLY)
if agent_host.receivedArgument("test"):
num_reps = 1
else:
num_reps = 30000
my_mission_record = MalmoPython.MissionRecordSpec()
if recordingsDirectory:
my_mission_record.recordRewards()
my_mission_record.recordObservations()
my_mission_record.recordCommands()
# if agent_host.receivedArgument("record_video"): # my_mission_record.recordMP4(24,2000000)
my_mission_record.recordMP4(24, 2000000)
recording_name = datetime.now().strftime("%Y-%m-%d_%I-%M-%S_%p")
for iRepeat in range(1):
my_mission_record.setDestination(
os.path.join(recordingsDirectory, recording_name + ".tgz"))
max_retries = 3
for retry in range(max_retries):
try:
agent_host.startMission(my_mission, my_mission_record)
break
except RuntimeError as e:
if retry == max_retries - 1:
logger.error("Error starting mission: %s" % e)
exit(1)
else:
time.sleep(2)
logger.info('Mission %s', iRepeat)
logger.info("Waiting for the mission to start")
world_state = agent_host.getWorldState()
while not world_state.has_mission_begun:
print(".", end="")
time.sleep(0.1)
world_state = agent_host.getWorldState()
print()
img_counter = 0
# print('observations', world_state.observations)
while world_state.is_mission_running:
world_state = agent_host.getWorldState()
# Observations
# msg = observe(agent_host)
# if msg is not None:
# print('timestamp: ', msg['timestamp'])
# NOTE : Nothing recorded in world state. Uncomment to test it out.
# if world_state.number_of_observations_since_last_state > 0:
# timestamp = world_state.observations[-1].timestamp
# msg = world_state.observations[-1].text
# obs = json.loads(msg)
# print("{'timestamp': timestamp, 'observations': obs}")
# Video Frames
while world_state.number_of_video_frames_since_last_state < 1 and world_state.is_mission_running:
logger.info("Waiting for frames...")
time.sleep(0.05)
world_state = agent_host.getWorldState()
logger.info("Got frame!")
# import ipdb; ipdb.set_trace
# print('observations', world_state.observations)
# world_state.observations
if world_state.is_mission_running:
# timestamp = world_state.observations[-1].timestamp
# msg = world_state.observations[-1].text
# print(timestamp)
# print(msg)
frame = world_state.video_frames[-1]
img = Image.frombytes('RGB', (640, 480), bytes(frame.pixels))
# imageio.imsave("./tmp_imgs/{}.png".format(img_counter), img)
img_counter += 1
logger.info("Mission has stopped.")
time.sleep(1) # let the Mod recover
