#!/usr/bin/env python3
import sys
from pathlib import Path as _P
from ply.lex import TOKEN
import ply.lex as lex
import ply.yacc as yacc
INPUT_DEFAULT = _P(__file__).with_name('%s-input.txt' % _P(__file__).stem)
INPUT = sys.argv[1] if len(sys.argv) > 1 else INPUT_DEFAULT
### lex related stuff - start #####################################
# states
states = (
('garbagec', 'exclusive'),
('garbageb', 'exclusive'),
)
# tokens
tokens = (
'LGROUP',
'RGROUP',
'LGARBAGE',
'RGARBAGE',
'EXCLAMATION',
'COMMA',
'STRING',
'garbagec_STRING',
'garbageb_STRING',
)
# token regexes
from matplotlib.pylab import *
import cityflow
import pandas as pd
import os
import csv
import json
from pathlib import Path as _P
import numpy as np
from numpy import array as _A
from timeit import default_timer
GIT_ROOT = _P(os.path.abspath(__file__)).parents[1]
print("GIT_ROOT", GIT_ROOT)
config_path = GIT_ROOT / "data/esquare3/config_engine.json"
config = json.load(open(config_path, 'rt'))
DIR = _P(config['dir'])
#archive_dump = _P(config['dir']) / config['archive_dump']
num_sim_loops = config.get('num_sim_loops', 500)
verbose_counter = config.get('verbose_counter', 100)
output_dict_path = _P(config['dir']) / "summary.json"
roudnet_output = DIR / config['roadnetLogFile']
roadnetFilePath = DIR / config['roadnetFile']
roadnetFile = json.load(roadnetFilePath.open('rt'))
intersections = roadnetFile['intersections']
inters = [
intersection for intersection in intersections
if not intersection['virtual']
]
from numpy import array as _A
from timeit import default_timer
from ctypes import cdll, c_void_p, c_long, c_char_p
from matplotlib import pylab as plt
from pandas import DataFrame as _D
from pandas import json_normalize
import gym
import sys
import cv2
from keras.models import Sequential, Model
from keras.layers import Dense, Activation, Flatten, Convolution2D, Permute, Input
from keras.optimizers import Adam
PROJECT_ROOT = _P(os.path.abspath(__file__)).parents[1]
PY_ROOT = PROJECT_ROOT / "py"
print("PY_ROOT", PY_ROOT)
sys.path.append(str(PY_ROOT))
os.chdir(PROJECT_ROOT)
print(f"Chdir {PROJECT_ROOT}")
config_path = PROJECT_ROOT / "data/esquare3/config_engine.json"
class CityFlowAgent(gym.Env):
def __init__(self, config_path=config_path, mode='train'):
work_dir = _P(config_path).parents[0]
self.mode = mode
def __init__(self, config_path=config_path, mode='train'):
work_dir = _P(config_path).parents[0]
self.mode = mode
self.last_action = None
self.config = config = json.load(open(config_path, 'rt'))
self.thread_num = config.get("thread_num", 4)
roadnetFile = _P(config['dir']) / config['roadnetFile']
self.roadnet = roadnet = json.load(roadnetFile.open('rt'))
self.intersections = json_normalize(roadnet['intersections'])
self.roads = roads = json_normalize(roadnet['roads'])
self.intersections = self.intersections[~self.intersections['virtual']] # Filter out virtuals
self.lns = [len(row['trafficLight.lightphases']) for i, row in self.intersections.iterrows()]
l = list() # Read all points to get bounding box.
for i, (p1, p2) in roads.points.iteritems(): l.extend((p1, p2))
l = _D(l)
self.min_xy = _A(l['x'].min(), l['y'].min())
self.max_xy = _A(l['x'].max(), l['y'].max())
self.MAT_SIZE = (self.max_xy - self.min_xy).max()
self.range_1 = self.MAT_SIZE / (self.max_xy - self.min_xy)
self.image = np.zeros((self.MAT_SIZE, self.MAT_SIZE), dtype=np.uint8)
self.input_shape = (config['WINDOW_LENGTH'], self.MAT_SIZE, self.MAT_SIZE)
num_phases = self.lns[0]
self.action_space = gym.spaces.Discrete(num_phases)
self.observation_space = gym.spaces.Dict({
'phase':gym.spaces.Box(low=0, high=1, shape=(1,1), dtype=np.float32),
'vehicle':gym.spaces.Box(low=0, high=14, shape=(1, self.MAT_SIZE, self.MAT_SIZE), dtype=np.float32)})
#self.seed(seed, state)
# Store what the agent tried
self.curr_episode = -1
self.action_episode_memory = []
self.count_from_last_bump = 0
self.total_num_bumps = 0
self.curr_step = -1
DIR = _P(config['dir'])
#archive_dump = _P(config['dir']) / config['archive_dump']
self.num_sim_loops = config.get('num_sim_loops', 500)
self.output_dict_path = _P(config['dir']) / "summary.json"
roudnet_output = DIR/ config['roadnetLogFile']
replayLogFile = DIR/ config['replayLogFile']
weights_filename = f"dqn_{config['WINDOW_LENGTH']}_{self.MAT_SIZE},{self.MAT_SIZE}_{mode}_weights.h5f"
self.weights_filename = work_dir / weights_filename
self.checkpoint_weights_filename = work_dir / ('checkpoint_{step}_' + weights_filename)
if mode == 'train':
self.config['saveReplay'] = False
self.work_config_path = work_dir / "generated_train_config.json"
else:
self.work_config_path = work_dir / "generated_predict_config.json"
self.config['saveReplay'] = True
try:
os.remove(str(roudnet_output))
print("Removed previous log file %s" % roudnet_output)
except BaseException as e:
print(str(e), roudnet_output)
try:
os.remove(str(replayLogFile))
print("Removed previous log file %s" % replayLogFile)
except BaseException as e:
print(str(e), replayLogFile)
self.eng = cityflow.Engine(str(self.work_config_path), thread_num=self.thread_num)
json.dump(self.config, self.work_config_path.open('wt'))
from PIL import Image
import cv2
import tensorflow as tf
import requests
import json
from tensorflow.keras import backend as K
from libs.pconv_model import PConvUnet
# Change to root path
from pathlib import Path as _P
RESIZED = 512
ROOT = _P(os.path.abspath(__file__)).parents[1]
CONV_ROOT = _P(os.path.abspath(__file__)).parents[0]
MODAL_PATH = str(ROOT / "PConv-Keras/weights/pconv_imagenet.26-1.07.h5")
EXPORT_PATH = str(ROOT / "exported_models" / "pconv_imagenet" / "2")
def prepare_image(image_tensor, mask_tensor):
#image_contents = tf.read_file(image_str_tensor)
#image = tf.image.decode_jpeg(image_contents, channels=3)
#image = tf.image.resize_images(image, [224, 224])
image = tf.cast(image_tensor, tf.float32)
return image / 255.0
#return preprocess_input(image)
def serving_input_receiver_fn():
