def __init__(self, config, session=None):
self.config = config
self.save = config.bool("save", True)
self.task = config.string("task", "train")
self.dataset = config.string("dataset").lower()
self.num_epochs = config.int("num_epochs", 1000)
self.session = self._create_session(session)
self.global_step = tf.Variable(0, name='global_step', trainable=False)
self.iou_threshold = config.float("iou_threshold", 0.85)
self.avg_clicks = {}
# TODO
need_train = True
if need_train:
self.train_data = load_eval_dataset(config, "train")
freeze_batchnorm = config.bool("freeze_batchnorm", False)
print("creating trainnet...", file=log.v1)
self.train_network = Network(self.config,
self.train_data,
is_trainnet=True,
freeze_batchnorm=freeze_batchnorm,
name="trainnet")
else:
self.train_data = None
self.train_network = None
need_val = self.task != "train_no_val"
if need_val:
self.valid_data = load_eval_dataset(config, "valid")
print("creating testnet...", file=log.v1)
self.test_network = Network(config,
self.valid_data,
is_trainnet=False,
freeze_batchnorm=True,
name="testnet")
else:
self.valid_data = None
self.test_network = None
self.trainer = Trainer(config, self.train_network, self.test_network,
self.global_step, self.session)
self.saver = Saver(config, self.session)
tf.global_variables_initializer().run()
tf.local_variables_initializer().run()
self.start_epoch = self.saver.try_load_weights()
self.session.graph.finalize()
self.recursive_rounds = config.int("recursive_rounds", 20)
self.avg_clicks = {}
self.locality = config.bool("locality", False)
self.locality_threshold = config.int("locality_threshold", 100)
self.monotonicity = config.bool("monotonicity", False)
if self.locality:
print("Using locality postprocessing...", log.v1)
if self.monotonicity:
print("Using monotonicity postprocessing...", log.v1)
def __init__(self, config, session=None):
self.config = config
self.save = config.bool("save", True)
self.task = config.string("task", "train")
self.dataset = config.string("dataset").lower()
self.num_epochs = config.int("num_epochs", 1000)
self.session = self._create_session(session)
self.global_step = tf.Variable(0, name='global_step', trainable=False)
need_train = True # TODO should be self.task != "eval", but right now testnet needs to reuse variables from train
if need_train:
self.train_data = load_dataset(config, "train", self.session,
self.dataset)
freeze_batchnorm = config.bool("freeze_batchnorm", False)
print("creating trainnet...", file=log.v1)
self.train_network = Network(self.config,
self.train_data,
is_trainnet=True,
freeze_batchnorm=freeze_batchnorm,
name="trainnet")
else:
self.train_data = None
self.train_network = None
need_val = self.task != "train_no_val"
if need_val:
self.valid_data = load_dataset(config, "val", self.session,
self.dataset)
print("creating testnet...", file=log.v1)
reuse_variables = None if need_train else False
self.test_network = Network(config,
self.valid_data,
is_trainnet=False,
freeze_batchnorm=True,
name="testnet",
reuse_variables=reuse_variables)
else:
self.valid_data = None
self.test_network = None
self.trainer = Trainer(config, self.train_network, self.test_network,
self.global_step, self.session)
self.saver = Saver(config, self.session)
tf.global_variables_initializer().run()
tf.local_variables_initializer().run()
self.start_epoch = self.saver.try_load_weights()
self.session.graph.finalize()
class Environment:
network = Network()
action_space = 2
observation_space = 64
info = ""
def __init__(self, behavior=Behavior.ONLY_SAFE):
self.done = False
self.behavior = behavior
def reset(self):
self.done = False
def step(self, action):
if (action != 0) & (action != 1):
print("Wrong action")
return -1, -1, False, ""
note = self.network.step()
if (action == 1) & (note.kind == Kind.DANGER):
reward = 1
elif (action == 1) & (note.kind == Kind.SAFE):
reward = -1
else:
reward = 0
observation = note.message
done = self.done
info = note
return observation, reward, done, info
def main():
parser = argparse.ArgumentParser(description="arguments of Neuron Network Optimizer")
parser.add_argument('-n', '--network', default="data/ResNet-50-deploy.prototxt")
parser.add_argument('-m', '--model', default='data/ResNet-50-model.caffemodel')
args = parser.parse_args()
network_file = args.network
json_file = ProtoReader.read_proto(network_file)
model_file = args.model
model = parse_caffemodel(model_file)
network = Network()
network.construct_from_json(json_file)
network.init_caffe_model(model)
in_data = network.input
in_data.set_content(np.zeros(in_data.get_shape()))
for layer in network.layers:
print 'start execute layer %s' % layer.name
layer.execute()
layer.print_info()
print ""
idx = len(network.layers) - 1
print "output:"
print network.layers[idx].top[0].get_content()
def test_single_layer_network(self):
network = Network()
network.add_layer(Normalize())
indata = np.array([2, 7, 3])
outdata = network.compute(indata)
self.assertTrue(np.allclose(outdata, [-0.4, 0.6, -0.2]))
def __init__(self, mode=Mode.DEMO, behavior=Behavior.ONLY_SAFE):
self.done = False
self.behavior = behavior
self.network = Network(mode)
self.mode = mode
if self.mode == Mode.DEMO:
self.observation_space = 8
else:
self.observation_space = 68
def test_multi_layer_network(self):
network = Network()
network.add_layer(Convolve([[0.1, 0], [0, 0.1]], keepdims=False))
network.add_layer(Relu())
network.add_layer(Flatten())
network.add_layer(Softmax())
indata = np.array([[5, 2, 7, 10], [1, 8, 3, 4]])
outdata = network.compute(indata)
self.assertTrue(np.allclose(outdata, [0.440905, 0.19811, 0.36098]))
def __init__(self):
# Call Screen constructor
Screen.__init__(self)
# Make connection to the server
self.n = Network()
self.n.connect()
# Retrieve list of games from server
self.buttonListSubset = []
self.buttonList = []
self.buttonListSlice = [0, 4]
self.updateGameList()
# Page navigator to go to next or previous page of active games
self.pageNavigator = PageNavigator()
if __name__ == "__main__":
# AVD Checking...
dev = Device()
while not dev.check_device():
print "waiting for device connection..."
sleep(3)
print "AVD Connected Successfully..."
print
# System Utility Initialization...
proc_service = Procs()
mem_service = MemInfo()
log_service = Meow()
network_service = Network()
log_service.thread_up()
with open(record_path, "r") as handle:
for line in handle:
if line.strip() == "":
continue
p, r = line.strip().split(", ")
pre_status[p] = True if r == "T" else False
f = Formatter()
# Set Up Apk
pp = pprint.PrettyPrinter(indent=4)
samples_info = {}
def __init__(self, config, session=None):
self.config = config
self.save = config.bool("save", True)
self.task = config.string("task", "train")
self.dataset = config.string("dataset").lower()
self.dataset_val = config.string("dataset_val", "").lower()
if self.dataset_val == "":
self.dataset_val = self.dataset
self.num_epochs = config.int("num_epochs", 1000)
self.session = self._create_session(session)
self.global_step = tf.Variable(0, name='global_step', trainable=False)
self.build_networks = config.bool("build_networks", True)
need_train = self.task not in ("eval", "forward_detections_recurrent",
"forward_tracking",
"forward_clustering",
"forward_refine_bboxes",
"forward_crop_detection",
"forward_mot_detection_rescore",
"forward_mots_detection_rescore",
"forward_mot_detection_linking",
"forward_refine_detection_bboxes")
if need_train:
self.train_data = load_dataset(config, "train", self.session,
self.dataset)
freeze_batchnorm = config.bool("freeze_batchnorm", False)
print("creating trainnet...", file=log.v1)
if self.build_networks:
self.train_network = Network(self.config,
self.train_data,
is_trainnet=True,
freeze_batchnorm=freeze_batchnorm,
name="trainnet")
else:
self.train_network = None
else:
self.train_data = None
self.train_network = None
need_val = self.task != "train_no_val"
if need_val:
self.valid_data = load_dataset(config, "val", self.session,
self.dataset_val)
print("creating testnet...", file=log.v1)
reuse_variables = None if need_train else False
if self.build_networks:
self.test_network = Network(config,
self.valid_data,
is_trainnet=False,
freeze_batchnorm=True,
name="testnet",
reuse_variables=reuse_variables)
else:
self.test_network = None
else:
self.valid_data = None
self.test_network = None
self.trainer = Trainer(config, self.train_network, self.test_network,
self.global_step, self.session)
self.saver = Saver(config, self.session)
tf.global_variables_initializer().run()
tf.local_variables_initializer().run()
self.start_epoch = self.saver.try_load_weights()
self.session.graph.finalize()
def __init__(
self,
username,
isHost,
gameName=None,
gameKey=None,
maxPlayers=None,
gameMode=None,
winningScore=None,
):
Screen.__init__(self)
# Set up connection to server
self.n = Network()
self.n.connect()
# Tell the server to create/join the game and return player id
if isHost:
self.player = self.n.getPlayer(
f"host/{gameName}/{maxPlayers}/{gameMode}/{winningScore}")
else:
self.player = self.n.getPlayer(f"join/{gameKey}")
# Get the game from the server
self.game = self.n.send("get")
# Check if the game could be received from the server
connectionAttempts = 0
MAX_ATTMEPTS = 10000
while self.game is None and connectionAttempts < MAX_ATTMEPTS:
self.game = self.n.send("get")
connectionAttempts += 1
# Only initialize game screen objects if server connectino was succesful
if self.game is not None:
# Set player username
self.game.players[self.player].username = username
self.n.send("username: "******"S"
self.scoreButton = Button(
SCORE_BUTTON_WIDTH,
SCORE_BUTTON_HEIGHT,
SCORE_BUTTON_X,
SCORE_BUTTON_Y,
SCORE_BUTTON_COLOR,
SCORE_BUTTON_TEXT_COLOR,
SCORE_BUTTON_TEXT,
)
# Ten and Under Button
TEN_AND_UNDER_BUTTON_WIDTH = 100
TEN_AND_UNDER_BUTTON_HEIGHT = 100
TEN_AND_UNDER_BUTTON_PADDING = 10
TEN_AND_UNDER_BUTTON_X = (self.screen.get_width() /
2) - (TEN_AND_UNDER_BUTTON_WIDTH / 2)
TEN_AND_UNDER_BUTTON_Y = (
(self.screen.get_height() / 2) -
(TEN_AND_UNDER_BUTTON_HEIGHT / 2)) - (
TEN_AND_UNDER_BUTTON_HEIGHT + TEN_AND_UNDER_BUTTON_PADDING)
TEN_AND_UNDER_BUTTON_COLOR = (255, 0, 0)
TEN_AND_UNDER_BUTTON_TEXT_COLOR = (0, 0, 0)
TEN_AND_UNDER_BUTTON_TEXT = "TEN\nAND\nUNDER"
self.tenAndUnderButton = Button(
TEN_AND_UNDER_BUTTON_WIDTH,
TEN_AND_UNDER_BUTTON_HEIGHT,
TEN_AND_UNDER_BUTTON_X,
TEN_AND_UNDER_BUTTON_Y,
TEN_AND_UNDER_BUTTON_COLOR,
TEN_AND_UNDER_BUTTON_TEXT_COLOR,
TEN_AND_UNDER_BUTTON_TEXT,
)
# List of all the buttons
self.buttonList.append(self.scoreButton)
self.buttonList.append(self.tenAndUnderButton)
# Score screen
self.scoreScreen = ScoreScreen()
# Win Screen
self.winScreen = WinScreen()
self.showGameScreen = False
self.showScoreScreen = False
self.showWinScreen = False
self.gameReady = False
class NetworkController(object):
data = None
distancesInLocation = None
distancesBetweenLocation = None
locationsCount = None
trainData = None
trainPoints = None
generateLocationsArray = None
generateParametersArray = None
firstPoints = None
mostPopularStartLocations = None
lastLocations = None
lastLocationsWindow = None
histCount = None
Network = Network()
window = None
def getWindowSize(self):
return self.window
def __init__(self):
self.data = None
self.locationsCount = None
self.mostPopularStartLocations = None
self.levyCoeff = 4
def maxTimeCalc(self, data):
max = data[0][0].time
min = data[0][0].time
for arr in data:
for a in arr:
if a.time > max:
max = a.time
if a.time < min:
min = a.time
return max, min
def maxPauseTimeCalc(self, data):
max = data[0][0].pauseTime
min = data[0][0].pauseTime
for arr in data:
for a in arr:
if a.pauseTime > max:
max = a.pauseTime
if a.pauseTime < min:
min = a.pauseTime
return max, min
def setTrainData(self, data, locations, window):
self.trainPoints = data
self.locationsCount = len(locations)
self.distancesInLocation = []
self.distancesBetweenLocation = []
self.firstPoints = []
self.trainStartTimes = []
self.lastLocations = []
self.lastLocationsWindow = window
self.window = window
self.mostPopularStartLocations = []
d = []
num = 0
for i in data:
countMostPopular = 0
locs = [0] * self.locationsCount
d1 = []
a = [0] * self.locationsCount
self.distancesInLocation.append(a.copy())
self.distancesBetweenLocation.append(a.copy())
self.firstPoints.append([])
if not len(self.firstPoints[num]) == self.window:
self.firstPoints[num].append(i[0].departurePoint)
for j in i:
dep = Location.FindLocation(j.departurePoint, locations)
dest = Location.FindLocation(j.destination, locations)
d1.append(LocationJump(dep, dest, j.time, j.pauseTime))
if not len(self.firstPoints[num]) == self.window:
self.firstPoints[num].append(j.destination)
if dep.Number == dest.Number:
self.distancesInLocation[len(
self.distancesInLocation
) - 1][dep.Number] = self.distancesInLocation[len(
self.distancesInLocation
) - 1][
dep.
Number] + PathPoint.distanceInMetersBetweenEarthCoordinates(
j.departurePoint.latitude,
j.departurePoint.longitude, j.destination.latitude,
j.destination.longitude)
else:
pass
d.append(d1)
num = num + 1
self.data = d
self.maxTime, self.minTime = self.maxTimeCalc(data)
self.maxPauseTime, self.minPauseTime = self.maxPauseTimeCalc(data)
self.trainData = []
self.generateLocationsArray = []
self.generateParametersArray = []
num = 0
for arr in self.data:
if (len(arr) == 0):
continue
self.generateLocationsArray.append([])
self.generateParametersArray.append([])
x = []
a = [0] * self.locationsCount
a[arr[0].departure.Number] = 1
x.append(a)
if not len(self.generateLocationsArray[num]) == self.window:
self.generateLocationsArray[num].append(a)
t = []
for i in range(len(arr)):
a = [0] * self.locationsCount
a[arr[i].destination.Number] = 1
x.append(a)
if not len(self.generateLocationsArray[num]) == self.window:
self.generateLocationsArray[num].append(a)
a = [
Levy.levyCalculate(arr[i].time, self.minTime,
self.maxTime / self.levyCoeff),
Levy.levyCalculate(arr[i].pauseTime, self.minPauseTime,
self.maxPauseTime / self.levyCoeff)
]
t.append(a)
if not len(
self.generateParametersArray[num]) == self.window - 1:
self.generateParametersArray[num].append(a)
self.trainData.append([x, t])
num = num + 1
Plotter.setTrainIntervals(self.trainData, self.distancesInLocation,
self.trainPoints, self.locationsCount,
self.minTime, self.maxTime,
self.minPauseTime, self.maxPauseTime,
self.levyCoeff)
self.histCount = len(
Plotter.trainIntervals.tracesLength) + 1 - 1 + len(
Plotter.trainIntervals.pauseTimes) - 1
def plotTrain(self):
Plotter.plotTrained(self.trainData, self.distancesInLocation,
self.trainPoints, self.locationsCount,
self.minTime, self.maxTime, self.minPauseTime,
self.maxPauseTime, self.levyCoeff)
def plotCharacteristics(self, data):
Plotter.plot(data, self.locationsCount, self.minTime, self.maxTime,
self.minPauseTime, self.maxPauseTime, self.levyCoeff)
def getTrainData(self):
return self.data
def getLocationsCount(self):
return self.locationsCount
def getFeaturesCount(self):
return 4
#TODO
def generate(self, locations, parameters):
count = [0] * len(self.trainData)
for i in range(len(self.trainData)):
count[i] = len(self.trainData[i]
[0]) - self.window ###############################
result = self.Network.generate(locations, parameters, count,
self.firstPoints, self.minPauseTime,
self.maxPauseTime, self.levyCoeff)
self.plotCharacteristics(result)
