def __init__(self, game_id, obs_size, skip_frame=4, mode='train'):
self.game_id = game_id
env = gym_super_mario_bros.make(game_id)
temp_obs = env.reset()
height, width, _ = temp_obs.shape
self.env = BinarySpaceToDiscreteSpaceEnv(env, COMPLEX_MOVEMENT)
self.obs_last2max = np.zeros((2, obs_size, obs_size, 1), np.uint8)
self.obstack = np.zeros((obs_size, obs_size, 4))
self.rewards = []
self.lives = 3
self.skip = skip_frame
self.mode = mode
if self.mode == 'play':
self.monitor = Monitor(width=width, height=height)
async def scan_computers(queue: asyncio.Queue):
monitor = Monitor(NETWORK)
loop = asyncio.get_running_loop()
while True:
with ThreadPoolExecutor(MAX_WORKERS) as pool:
aws = [
loop.run_in_executor(pool, Monitor.scan_host, monitor, host)
for host in monitor.get_hosts(NUM_OF_HOSTS)
]
for coro in asyncio.as_completed(aws):
try:
computer = await coro
except HostNotFound:
pass
else:
queue.put_nowait(computer)
print(f"Sleeping for {SLEEP_INTERVAL / 60} minutes...")
await asyncio.sleep(SLEEP_INTERVAL)
def main():
try:
Utilities._create_dir("/var/log/vims_cluster")
parser = argparse.ArgumentParser(
description='vIMS Cluster monitoring service')
parser.add_argument("-c",
"--config",
help='Service parmeters configuration file',
required=True)
parser.add_argument("-l",
"--logging",
help='Service logging configuration file',
required=True)
args, ignore = parser.parse_known_args()
logging.config.fileConfig(args.logging, disable_existing_loggers=False)
threads = []
monitor = Monitor(args.config)
logger = logging.getLogger()
cluster = threading.Thread(target=monitor.update_cluster)
bono = threading.Thread(target=monitor.monitor_bono)
sprout = threading.Thread(target=monitor.monitor_sprout)
dime = threading.Thread(target=monitor.monitor_dime)
vellum = threading.Thread(target=monitor.monitor_vellum)
homer = threading.Thread(target=monitor.monitor_homer)
cluster.daemon = True
bono.daemon = True
sprout.daemon = True
dime.daemon = True
vellum.daemon = True
homer.daemon = True
logger.info("Starting the cluster monitoring thread.")
cluster.start()
logger.info("Starting the Bono cluster monitoring thread.")
bono.start()
logger.info("Starting the Sprout cluster monitoring thread.")
sprout.start()
logger.info("Starting the Dime cluster monitoring thread.")
dime.start()
logger.info("Starting the Vellum cluster monitoring thread.")
vellum.start()
logger.info("Starting the Homer cluster monitoring thread.")
homer.start()
threads.append(cluster)
threads.append(bono)
threads.append(sprout)
threads.append(dime)
threads.append(vellum)
threads.append(homer)
while True:
time.sleep(2)
except KeyboardInterrupt:
logger.info("Keyboard interrupt.")
logger.info("Exiting...")
sys.exit()
def __init__(self):
super(MainWindow, self).__init__()
self.setupUi(self)
self.setWindowTitle('[ITBA] Formula SAE')
self.setStyleSheet("background-color: rgb(153, 153, 153);")
# Private members/attributes
self.session = UserSession()
# TODO! Here we are setting a manual service for testing purpose, please remember to REMOVE THIS LINE!
from src.manualservice import ManualService
self.manual_service = ManualService()
self.session.set_data_service(self.manual_service)
self.manual_service.show()
# Setting up the Router class with the StackedWidget to be used
self.declare_router(
'index', self.router_widget, {
'index': Index(self.session, self),
'monitor': Monitor(self.session, self)
})
# 2018 International Student Car Competition: Autonomous Car SKKU Team. HEVEN
# 2018 국제대학생창작자동차대회 자율주행차 부문 성균관대학교 HEVEN 팀
# interpreted by python 3.6
# please read README.md
# =================Module===================
import cv2
from src.car_control import Control
from src.monitor import Monitor
from src.motion_planner import MotionPlanner
from src.communication import PlatformSerial
# =================instance=================
planner = MotionPlanner()
controller = Control()
platform = PlatformSerial('COM4') # check your serial port
monitor = Monitor()
# ==========================================
while True:
# perception - planning - control loop
controller.read(*platform.read())
planner.plan_motion(controller.get_status())
print("mission num: ", planner.mission_num)
print("sign mission num: ", planner.sign_cam.mission_number)
print("key mission num: ", planner.key_cam.mission_num)
print()
controller.mission(*planner.get_motion_parameter())
platform.write(*controller.write())
# show monitor
frames = planner.get_frame()
"""
Find a gpu device
"""
if len(DEVICE_ID_LIST) < 1:
gpu_id = None
device_str = "cpu"
else:
gpu_id = DEVICE_ID_LIST[0]
# os.environ["CUDA_VISIBLE_DEVICES"] = "0,1,2"
device_str = "cuda:" + str(DEVICE_ID_LIST[0])
"""
monitoring resources of this application
"""
monitor = Monitor(1, gpu_id, os.getpid())
data_loader = DataLoader(
Tensor(train_Triples), batch_size=BATCH_SIZE, shuffle=True, drop_last=True
)
"""
init model
"""
print("init model ", MODEL)
vbcr = VBCAR(
data_loader,
data,
model_save_dir,
n_users,
n_items,
class Game:
def __init__(self, game_id, obs_size, skip_frame=4, mode='train'):
self.game_id = game_id
env = gym_super_mario_bros.make(game_id)
temp_obs = env.reset()
height, width, _ = temp_obs.shape
self.env = BinarySpaceToDiscreteSpaceEnv(env, COMPLEX_MOVEMENT)
self.obs_last2max = np.zeros((2, obs_size, obs_size, 1), np.uint8)
self.obstack = np.zeros((obs_size, obs_size, 4))
self.rewards = []
self.lives = 3
self.skip = skip_frame
self.mode = mode
if self.mode == 'play':
self.monitor = Monitor(width=width, height=height)
def step(self, action, monitor=False):
reward = 0.0
done = False
for i in range(self.skip):
obs, r, done, info = self.env.step(action)
if self.mode == 'play':
self.monitor.record(obs)
if i >= 2:
self.obs_last2max[i % 2] = self._process_obs(obs)
# super mario's reward is cliped in [-15.0, 15.0]
reward += r / 15.0
lives = info['life']
if lives < self.lives:
done = True
self.lives = lives
if done:
break
self.rewards.append(reward)
if done:
episode_info = {
"reward": sum(self.rewards),
"length": len(self.rewards)
}
self.reset()
else:
episode_info = None
obs = self.obs_last2max.max(axis=0)
self.obstack = np.roll(self.obstack, shift=-1, axis=-1)
self.obstack[..., -1:] = obs
return self.obstack, reward, done, episode_info
def reset(self):
obs = self.env.reset()
obs = self._process_obs(obs)
self.obstack[..., 0:] = obs
self.obstack[..., 1:] = obs
self.obstack[..., 2:] = obs
self.obstack[..., 3:] = obs
self.rewards = []
self.lives = 3
return self.obstack
@staticmethod
def _process_obs(obs):
obs = cv2.cvtColor(obs, cv2.COLOR_RGB2GRAY)
obs = cv2.resize(obs, (84, 84), interpolation=cv2.INTER_AREA)
return obs[:, :, None]
except:
pass
if self.parking_count == 5:
self.parkingline_info = (x, 200 - y, middle,
max(theta1, theta2))
self.parking_count = 0
else:
self.parkingline_info = None
# parking_frame을 모니터에 넘겨줘야 함.
self.parkingline_frame.write(parking_frame)
def stop(self):
self.video_left.release()
self.video_right.release()
if __name__ == "__main__":
from src.monitor import Monitor
monitor = Monitor()
lane_cam = LaneCam()
while True:
lane_cam.default_loop(0)
monitor.show('1', *lane_cam.getFrame())
if cv2.waitKey(1) & 0xFF == ord('q'): break
lane_cam.stop()
def __init__(self):
self.a = Monitor("a")
self.b = Monitor("b")
self.c = Monitor("c")
def monitor(self):
self.monitor_args = self.monitorParser()
self.config = yaml.load(open(self.monitor_args.config, 'r'),
Loader=Loader)
self.monitor = Monitor(self.config, self.monitor_args)