def showResults(self):
#restore .m file from archive
fileName = self.outfile
self.restoreFromArchive(fileName)
Visualizer.yScatterPlot(self.ensemble, self.outputs[0], self.x,
self.cmd, fileName)
def main():
# parse arguments
args = cli()
# setup processor and visualizer
processor = Processor(model=args['model'])
visualizer = Visualizer()
# fetch input
print('image arg', args['image'])
# img = cv2.imread('inputs/{}'.format(args['image']))
input_image_paths = []
folder_path = 'imgs'
if os.path.isdir(folder_path):
ls = os.listdir(folder_path)
for file_name in sorted(ls, key=lambda x: str(x.split('.jpg')[0])):
input_image_paths.append(os.path.join(folder_path, file_name))
img_batch = []
for input_image_path in input_image_paths:
img_batch.append(input_image_path)
if len(img_batch) == args['batch_size']:
# inference
output, image_raw_batch = processor.detect(img_batch)
# final results
boxes, confs, classes = processor.post_process(
output,
conf_thres=0.5,
iou_thres=0.4,
image_raw_batch=image_raw_batch)
# print(boxes)
for i in range(len(img_batch)):
visualizer.draw_results_batch(i, image_raw_batch[i], boxes[i],
confs[i], classes[i])
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.scene = QGraphicsScene()
# Scene is the parent of the view in order to show the graphical items.
# the View must also be the parent of the scene in order to avoid
# bizarre segmentation faults with GTK
self.view = InteractiveView(self.scene)
self.scene.setParent(self.view)
self.setCentralWidget(self.view)
self.view.setSceneRect(INT_MIN/2, INT_MIN/2, INT_MAX, INT_MAX)
self.view.centerOn(0, 0)
self.visualizer = Visualizer(self.scene)
self.visualizer.update_processes_data()
# Set a dark background color
back_color = QColor(25, 20, 45)
self.view.setBackgroundBrush(QBrush(back_color))
def keyPressEvent(self, event):
super(MainWindow, self).keyPressEvent(event)
# Quit via escape key.
if event.key() == Qt.Key_Escape:
self.close()
if event.key() == Qt.Key_R:
self.visualizer.showRootTasks = not self.visualizer.showRootTasks
def main():
# parse arguments
args = cli()
# setup processor and visualizer
processor = Processor(model=args['model'])
visualizer = Visualizer()
# fetch input
print('image arg', args['image'])
# img = cv2.imread('inputs/{}'.format(args['image']))
input_image_paths = []
folder_path = args['image']
if os.path.isdir(folder_path):
ls = os.listdir(folder_path)
for file_name in sorted(ls, key=lambda x: str(x.split('.jpg')[0])):
input_image_paths.append(os.path.join(folder_path, file_name))
for input_image_path in input_image_paths:
img = cv2.imread(input_image_path)
# inference
output = processor.detect(img)
# final results
boxes, confs, classes = processor.post_process(output, conf_thres=0.3, iou_thres=0.4, origin_w=img.shape[1], origin_h=img.shape[0])
visualizer.draw_results(img, boxes, confs, classes)
def elasticDistort(picture, sigma, alpha):
dx, dy = generateDisplacementFields(sigma, alpha)
distortion = np.zeros(Constants.pic_shape)
Visualizer.plotNumber('dx', dx)
Visualizer.plotNumber('dy', dy)
# For each pixel use the displacement field to grab new pixel values
# Hopefully it will be elastically distorted! :D
# Bilinear interpolation
for i in range(Constants.pic_height):
for j in range(Constants.pic_width):
x = i + dx[i, j]
y = j + dy[i, j]
# If the new location we're trying to grab is outside the picture
# boundaries, then leave the pixel value as zero
if x < 0 or x > (Constants.pic_width - 1):
continue
if y < 0 or y > (Constants.pic_height - 1):
continue
distortion[i, j] = bilinearInterpolation(picture, x, y)
return distortion
def setUp(self):
self.autoseed = random.randint(0, 9999999999)
self.seed = self.RAND_SEED
if not self.seed:
self.seed = self.autoseed
self.myRandom = random.Random(self.seed)
self.peer_controller = None
self.peers = [
self.create_peer("P%d" % i, "127.0.0.1", 8500 + i)
for i in range(self.NO_OF_PEERS)
]
self.peer_controller = PeerController(self.peers,
self.WORLD_SIZE,
self.TOP_SPEED,
self.MAX_SPEED_CHANGE,
self.RADIO_RANGE,
rand_seed=self.seed)
#Start router
self.router = Router("127.0.0.1", 8300, self.peers,
self.peer_controller, self.USE_TICKS)
self.router.start()
self.ensure_peers_ready(self.peers)
self.router.activate_queue()
if self.VISUALIZE:
self.visualizer = Visualizer(self.peers, self.peer_controller)
self.visualizer.visualize()
def prepareLinkData(self, date='2009-02-13'):
"""
Reads and returns a tuple of (linkData, segmentData).
linkData is a dictionary with one record for each link, containing
the data necessary for plotting.
segmentData is a dictionary with one record for each shape segment
for use with the HoverTool.
Called once at the beginning to read in all the data.
date - string for the date's data to display
"""
# read the highway network
hwynet = HwyNetwork()
hwynet.readDTANetwork(INPUT_DYNAMEQ_NET_DIR, INPUT_DYNAMEQ_NET_PREFIX, logging_dir=LOGGING_DIR)
# get the data
v = Visualizer(hwynet, TAXI_OUTFILE)
df = v.getLinkData(date=date)
# convert to a dictionary.
# .to_dict() returns in a different structure that doesn't work.
linkData = {}
for c in df.columns:
linkData[c] = df[c]
# convert to segments
segmentData = v.getSegmentRectangleData(df)
return (linkData, segmentData)
def prepareLinkData(self, date='2009-02-13'):
"""
Reads and returns a tuple of (linkData, segmentData).
linkData is a dictionary with one record for each link, containing
the data necessary for plotting.
segmentData is a dictionary with one record for each shape segment
for use with the HoverTool.
Called once at the beginning to read in all the data.
date - string for the date's data to display
"""
# read the highway network
hwynet = HwyNetwork()
hwynet.readDTANetwork(INPUT_DYNAMEQ_NET_DIR,
INPUT_DYNAMEQ_NET_PREFIX,
logging_dir=LOGGING_DIR)
# get the data
v = Visualizer(hwynet, TAXI_OUTFILE)
df = v.getLinkData(date=date)
# convert to a dictionary.
# .to_dict() returns in a different structure that doesn't work.
linkData = {}
for c in df.columns:
linkData[c] = df[c]
# convert to segments
segmentData = v.getSegmentRectangleData(df)
return (linkData, segmentData)
def main():
# parse arguments
args = cli()
# setup processor and visualizer
processor = Processor(model=args['model'])
visualizer = Visualizer()
# fetch input
print('image arg', args['image'])
img = cv2.imread('inputs/{}'.format(args['image']))
# inference
output = processor.detect(img)
img = cv2.resize(img, (640, 640))
# object visualization
object_grids = processor.extract_object_grids(output)
visualizer.draw_object_grid(img, object_grids, 0.1)
# class visualization
class_grids = processor.extract_class_grids(output)
visualizer.draw_class_grid(img, class_grids, 0.01)
# bounding box visualization
boxes = processor.extract_boxes(output)
visualizer.draw_boxes(img, boxes)
# final results
boxes, confs, classes = processor.post_process(output)
visualizer.draw_results(img, boxes, confs, classes)
def RunDetection(TS_ID):
#Get Data
dfds = d.GetTimeSeries(TS_ID)
targets = dfds['target'].unique()
#Delete Output Data for TS_ID
d._deleteTimeSeriesOutput(TS_ID)
#Run detection
for target in targets:
try:
titleName = TS_ID + '_' + target
df = dfds[dfds['target'] == target]
print(target)
#Change Detection
detector = ADetector(df)
detector.Run()
dfResults = detector.GetResults()
dfResults['ts_id'] = TS_ID
dfResults['target'] = target
d.SaveResults(dfResults)
visuals = Visualizer(dfResults,
plt_ymin=min(df.y),
plt_ymax=max(df.y))
visuals.PlotChangePoints(Title=titleName, fileName=titleName)
except Exception as ex:
print("Error with {0}".format(TS_ID + " - " + target))
def test2(self):
useless = ['RegionID', 'resulttime', 'CellID', 'PRB_DL_Used_Rate']
analyzer.drop_unnecessary_columns(useless)
arguments = {"C": 0.3}
analyzer.create_model(ModelType.logregression, arguments,
analyzer.data,
analyzer.data['cnt_averload_cell'])
print("Cross variation score:\n" + str(analyzer.models[0].cv_score))
# print("Feature importances:\n" + str(analyzer.models[0].model.feature_importances_))
print(analyzer.models[0].feature_names)
Visualizer.draw_class_scatter(analyzer.models[0])
def plot_polygon(m, polygons, limit_x, limit_y, title):
for v in m.getVars():
if v.x == 1:
name = v.varName
name = name.split(" ")
i = int(name[0])
point = [int(name[1]), int(name[2])]
point[0] = point[0] - polygons[i][0][0]
point[1] = point[1] - polygons[i][0][1]
polygons[i] = Polygon.add_number_axis_x_y(polygons[i], point[0], point[1])
polygons = Polygon.create_polygons_to_plot(polygons)
visualiser = Visualizer(polygons, limit_x, limit_y, title)
visualiser.plot_polygons()
def specialTurnGateTest():
dic = DictionarySearcher(2)
id = AQP.generateSpecialTurn(a=-1, b=0, dic=dic)
Debug.debug(Visualizer.printPath(id, dic, deepEnd=False),
DebugLevel.Result)
Debug.debug(Visualizer.printCompress(id, dic), DebugLevel.Result)
Debug.debug("\n" + str(dic.getGate(id).getMatrix()) + "\n\n",
DebugLevel.Result)
id = AQP.generateSpecialTurn(a=(1 / (math.sqrt(2))),
b=(1 / (math.sqrt(2))),
dic=dic)
Debug.debug(Visualizer.printPath(id, dic, deepEnd=False),
DebugLevel.Result)
Debug.debug(Visualizer.printCompress(id, dic), DebugLevel.Result)
Debug.debug("\n" + str(dic.getGate(id).getMatrix()) + "\n\n",
DebugLevel.Result)
dic = DictionarySearcher(3)
id = AQP.generateSpecialTurn(a=1j, b=0, dic=dic)
Debug.debug(Visualizer.printPath(id, dic, deepEnd=False),
DebugLevel.Result)
Debug.debug(Visualizer.printCompress(id, dic), DebugLevel.Result)
Debug.debug(
Visualizer.printCompress(id,
dic,
deepEnd=True,
deep=1,
autoReference=True), DebugLevel.Result)
Debug.debug("\n" + str(dic.getGate(id).getMatrix()) + "\n\n",
DebugLevel.Result)
dic = DictionarySearcher(4)
id = AQP.generateSpecialTurn(a=(1 / (math.sqrt(2))),
b=(1j * (1 / (math.sqrt(2)))),
dic=dic)
Debug.debug(Visualizer.printPath(id, dic, deepEnd=False),
DebugLevel.Result)
Debug.debug(Visualizer.printCompress(id, dic), DebugLevel.Result)
Debug.debug(
Visualizer.printCompress(id,
dic,
deepEnd=True,
deep=1,
autoReference=True), DebugLevel.Result)
Debug.debug("\n" + str(dic.getGate(id).getMatrix()) + "\n\n",
DebugLevel.Result)
def basicTurnGateTest():
dic = DictionarySearcher(2)
id = AQP.generateBasicTurn(target=1,
angle=math.pi,
turnType=TurnType.Z,
dic=dic)
Debug.debug(Visualizer.printPath(id, dic), DebugLevel.Result)
Debug.debug(Visualizer.printCompress(id, dic), DebugLevel.Result)
Debug.debug("\n" + str(dic.getGate(id).getMatrix()) + "\n\n",
DebugLevel.Result)
id = AQP.generateBasicTurn(target=0,
angle=math.pi / 2,
turnType=TurnType.Z,
dic=dic)
Debug.debug(Visualizer.printPath(id, dic), DebugLevel.Result)
Debug.debug(Visualizer.printCompress(id, dic), DebugLevel.Result)
Debug.debug("\n" + str(dic.getGate(id).getMatrix()) + "\n\n",
DebugLevel.Result)
id = AQP.generateBasicTurn(target=1,
angle=math.pi / 4,
turnType=TurnType.X,
dic=dic)
Debug.debug(Visualizer.printPath(id, dic), DebugLevel.Result)
Debug.debug(Visualizer.printCompress(id, dic), DebugLevel.Result)
Debug.debug("\n" + str(dic.getGate(id).getMatrix()) + "\n\n",
DebugLevel.Result)
dic = DictionarySearcher(4)
id = AQP.generateBasicTurn(target=3,
angle=math.pi / 4,
turnType=TurnType.Z,
dic=dic)
Debug.debug(Visualizer.printPath(id, dic), DebugLevel.Result)
Debug.debug(Visualizer.printCompress(id, dic), DebugLevel.Result)
Debug.debug("\n" + str(dic.getGate(id).getMatrix()) + "\n\n",
DebugLevel.Result)
id = AQP.generateBasicTurn(target=1,
angle=math.pi / 4,
turnType=TurnType.Z,
dic=dic)
Debug.debug(Visualizer.printPath(id, dic), DebugLevel.Result)
Debug.debug(Visualizer.printCompress(id, dic), DebugLevel.Result)
Debug.debug("\n" + str(dic.getGate(id).getMatrix()) + "\n\n",
DebugLevel.Result)
def test3(self):
classifier = "DL_MCS_64QAM"
# TODO: redo it, so it doesn't delete the classifier from the dataset, what if you want to reuse it?
classifier_values = analyzer.data[classifier]
arguments = {"C": 0.8, "kernel": 'linear'}
useless = [
'RegionID', 'resulttime', 'CellID', 'cnt_averload_cell', classifier
]
analyzer.drop_unnecessary_columns(useless)
analyzer.create_model(ModelType.svc, arguments, analyzer.data,
classifier_values)
print("Cross variation score:\n" + str(analyzer.models[0].cv_score))
# print("Feature importances:\n" + str(analyzer.models[0].model.feature_importances_))
print(analyzer.models[0].feature_names)
Visualizer.draw_class_scatter(analyzer.models[0])
def __init__(self, train, test):
print("ObjectOrientedTitanic object created")
self.testPassengerID = test['PassengerId']
self.number_of_train = train.shape[0]
self.y_train = train['Survived']
self.train = train.drop('Survived', axis=1)
self.test = test
self.all_data = self._get_all_data()
# Create instance of objects
self._info = Information()
self.preprocessStrategy = PreprocessStrategy()
self.visualizer = Visualizer()
self.gridSearchHelper = GridSearchHelper()
def action(self):
def order_review():
#print('Passed')
return True
order_review()
#self.selected_data_engine = Selector(self.order.data_engine).task_submit()
self.data_profiling_result = Analyst(
self.order.df, self.order.df_name,
self.order.path_to_output).task_submit()
print(self.data_profiling_result)
self.data_auditing_result = Auditor(
self.data_profiling_result, self.order.auditing_config,
self.order.path_to_output).task_submit()
self.Visualizing_result = Visualizer(
self.data_profiling_result, self.data_auditing_result,
self.order.path_to_output, self.order.report_config,
self.order.auditing_config).task_submit()
result = {}
result['data_profile'] = self.data_profiling_result
result['data_auditing'] = self.data_auditing_result
result['data_viz'] = self.Visualizing_result
return result
def showResults(self):
cmd = 'rs%d' % len(self.inputs)
mfile = 'matlab' + cmd + '.m'
self.restoreFromArchive(mfile)
ngrid = 0
if len(self.inputs) == 2:
ngrid = 256 # select grid resolution (32-256)
elif len(self.inputs) == 3:
ngrid = 32 # select grid resolution (16-32)
inNames = self.ensemble.getInputNames()
x = [index + 1 for index in self.inputs]
Visualizer.showRSPlot(self.ensemble, self.outputs[0], x,
len(self.inputs), ngrid, self.responseSurface,
self.minVal, self.maxVal, mfile)
def write_frames_from_log(self, logfile):
stuff = np.load(logfile)
filename = str(stuff['name']) + '.mp4'
self.visualizer = Visualizer(int(stuff['ego_id']),
stuff['LengthWidth'][:, 0],
stuff['LengthWidth'][:, 1],
int(stuff['num_cars']), self.road)
metadata = dict(title=str(stuff['name']), artist='Pseudo', comment='')
writer = FFMpegWriter(fps=2 * int(1. / Vehicle.DEL_T),
codec='libx264',
metadata=metadata,
extra_args=['-pix_fmt', 'yuv420p'])
with writer.saving(self.visualizer.fig, filename,
self.visualizer.fig.dpi):
for state in stuff['State_record']:
self.visualizer.update(state[:, :3])
writer.grab_frame()
Scenario.flip_video(filename)
def grover4AATest():
dic = DictionarySearcher(4)
matrix = QuantumMath.getAmplitudAmplifier(4)
id = AQP.generateSpecial(matrix=matrix, name="grover4AA", dic=dic)
Debug.debug(Visualizer.printCompress(id, dic), DebugLevel.Result)
Debug.debug("\n" + str(dic.getGate(id).getMatrix()) + "\n\n",
DebugLevel.Result)
def main():
# parse arguments
args = cli()
# setup processor and visualizer
processor = Processor(model=args['model'])
visualizer = Visualizer()
# fetch input
print('image arg', args['image'])
#img = cv2.imread('inputs/{}'.format(args['image']))
img = cv2.imread("/home/jiqing/jq/bottle/33/3 (3).jpg")
cap = cv2.VideoCapture(0)
while 1:
ret, frame = cap.read()
#print(type(img))
# inference
#output = processor.detect(img)
#img = cv2.resize(img, (640, 640))
output = processor.detect(frame)
img = cv2.resize(frame, (640, 640))
# object visualization
object_grids = processor.extract_object_grids(output)
#visualizer.draw_object_grid(img, object_grids, 0.1)
# class visualization
class_grids = processor.extract_class_grids(output)
#visualizer.draw_class_grid(img, class_grids, 0.01)
# bounding box visualization
boxes = processor.extract_boxes(output)
#visualizer.draw_boxes(img, boxes)
# final results
boxes, confs, classes = processor.post_process(output)
#print(classes)
#label = f'{names[int(classes)]} {confs:.2f}'
visualizer.draw_results(img, boxes, confs, classes)
def show_current_policy_and_map(self):
"""
For visualization of the maze and policy when using the A* planner.
:return: None
"""
vis = Visualizer(self.maze_map.dim)
vis.draw_maze(Maze('known_maze.txt'))
vis.draw_policy(reversed(self.planner.policy), self.location, self.heading)
vis.show_window()
def __init__(self, parent):
self.ch_tracks = dict()
self.parent = parent
self.parsed = False
self.listWidget = self.parent.GetTracksList()
self.Visualizer = Visualizer.getInstance()
self.last_id = -1e3
self.np_tracks = np.zeros(0)
self.clothes = dict()
self.tracks_path = ""
self.clothes_path = ""
def memoryTest():
# inicializa un diccionario para 4 qubits
dic = DictionarySearcher(nQubits=4)
# genera una puerta de giro condicionado multiple y las subpuertas necesarias
gateId = AQP.generateMultipleTurn(sources=[0, 1, 2],
target=3,
angle=math.pi / 2,
turnType=TurnType.Z,
dic=dic)
# imprime por pantalla el path
print(
Visualizer.printCompress(gateId,
dic,
deepEnd=True,
deep=1,
autoReference=False))
# genera el fichero .qasm para crear esta puerta
WriterAsm.writeAsm(gateId, dic, "multiConditionalGate.qasm", reset=True)
Debug.debug(Visualizer.printCompress(
id,
dic,
), DebugLevel.Result)
Debug.debug(
Visualizer.printCompress(id,
dic,
deepEnd=True,
deep=1,
autoReference=True), DebugLevel.Result)
Debug.debug(
Visualizer.printCompress(id,
dic,
deepEnd=True,
deep=2,
autoReference=True), DebugLevel.Debug)
Debug.debug("\n" + str(dic.getGate(id).getMatrix()) + "\n\n",
DebugLevel.Result)
def calcScore(self):
i = 0
visualizer = Visualizer()
totalScore = 0
iterations = 200
if (self.visualization == 1):
iterations = 200
while(i < iterations): #frontierController.hasData()):
self.frontierController.tick(self.workingNN)
#print self.frontierController.agentLocations
totalScore += self.agents[self.workingNN].getScore()
self.globalScore += self.scorer.getGlobalScore()
if (self.visualization == 1):
visualizer.vis(self.frontierController.frontierData, self.frontierController.agentLocations)
# print self.frontierController.agentLocations
time.sleep(.03)
i = i + 1
return totalScore
def analyze(self):
Common.initFolder(Visualizer.dname)
data = self.ensemble
data = data.getValidSamples(
) # filter out samples that have no output results
fname = Common.getLocalFileName(Visualizer.dname,
data.getModelName().split()[0], '.dat')
index = ResponseSurfaces.getEnumValue(self.responseSurface)
fixedAsVariables = index == ResponseSurfaces.USER
data.writeToPsuade(fname, fixedAsVariables=fixedAsVariables)
rsdim = len(self.inputs)
inNames = data.getInputNames()
plotInNames = [inNames[i - 1] for i in self.inputs]
if self.legendreOrder is not None:
mfile = Visualizer.showRS(
fname,
self.outputs[0],
plotInNames,
rsdim,
self.responseSurface,
vmin=self.minVal,
vmax=self.maxVal,
rsOptions=self.rsOptions,
userRegressionFile=self.userRegressionFile)
else:
mfile = Visualizer.showRS(
fname,
self.outputs[0],
plotInNames,
rsdim,
self.responseSurface,
vmin=self.minVal,
vmax=self.maxVal,
userRegressionFile=self.userRegressionFile)
if mfile is not None:
self.archiveFile(mfile)
return mfile
def __init__(self):
self.run_mode = Runmode.BUILD
self.event_stream = []
self.fps = conf["simulation"]["fps"]
env_conf = conf["environment"]
tile_size = env_conf["tile_size"]
self.clock = pygame.time.Clock()
default_obstacles, default_robot = self.get_default_environment()
self.environment = RoomEnvironment(env_conf["width"],
env_conf["height"], tile_size,
default_obstacles, default_robot)
self.visualizer = Visualizer(self.environment, self.clock,
self.environment.initial_events)
self.algorithms = {
"random": RandomBounceWalkAlgorithm(),
"spiral": SpiralWalkAlgorithm(),
"swalk": SWalkAlgorithm()
}
self.algorithm = self.algorithms[self.get_algorithm_name()]
def RunBackpropagation(self,
minPeriods=30,
chartTitle="Trend",
metric='AlgoOutlierDetected'):
AS_OF_DATES = self.df['ds'].unique()
for i, toDate in enumerate(AS_OF_DATES):
print(toDate)
dfSource = self.df[self.df['ds'] <= toDate]
#need at least 10 records to run model
if dfSource.shape[0] > minPeriods:
detector = ADetector(dfSource)
detector.Run()
dfResults = detector.GetResults()
dfResults['AsOfDate'] = toDate
#Prepare for Visualization (including future dates with 0's)
xDates = self.df['ds'].values
y = list(dfResults['y'].values)
changepointChanges = list(dfResults[metric].values)
while len(y) < len(xDates):
y.append(0)
changepointChanges.append(0)
d = {'ds': xDates, 'y': y, metric: changepointChanges}
dfResultsCharting = pd.DataFrame(d)
#Save Image
visuals = Visualizer(dfResultsCharting,
plt_ymin=min(self.df.y),
plt_ymax=max(self.df.y))
visuals.PlotChangePoints(Title=chartTitle,
fileName=str(i),
folderName="seqimg",
metric=metric)
def __init__(self, path, queue_size=128):
self.stream = cv2.VideoCapture(path)
self.stopped = False
self.queue_size = queue_size
self.path = path
self.Q = Queue(maxsize=queue_size)
self.thread = threading.Thread(target=self.update, args=())
# self.thread.daemon = True
self.allreaded = False
self.pause_cond = threading.Condition(threading.Lock())
self.paused = False
self.Visualizer = Visualizer.getInstance()
self.Visualizer.setStream(self)
self.frame_id = 0
def basicGateTest():
dic = DictionarySearcher(2)
id = AQP.generateBasic(standarGate=StandarGate.X, targets=[0], dic=dic)
Debug.debug(Visualizer.printPath(id, dic), DebugLevel.Result)
Debug.debug(Visualizer.printCompress(id, dic), DebugLevel.Result)
Debug.debug("\n" + str(dic.getGate(id).getMatrix()) + "\n\n",
DebugLevel.Result)
id = AQP.generateBasic(standarGate=StandarGate.X, targets=[0, 1], dic=dic)
Debug.debug(Visualizer.printPath(id, dic), DebugLevel.Result)
Debug.debug(Visualizer.printCompress(id, dic), DebugLevel.Result)
Debug.debug("\n" + str(dic.getGate(id).getMatrix()) + "\n\n",
DebugLevel.Result)
id = AQP.generateBasic(standarGate=StandarGate.H, targets=[0, 1], dic=dic)
Debug.debug(Visualizer.printPath(id, dic), DebugLevel.Result)
Debug.debug(Visualizer.printCompress(id, dic), DebugLevel.Result)
Debug.debug("\n" + str(dic.getGate(id).getMatrix()) + "\n\n",
DebugLevel.Result)
dic = DictionarySearcher(4)
id = AQP.generateBasic(standarGate=StandarGate.X,
targets=[1, 2, 3],
dic=dic)
Debug.debug(Visualizer.printPath(id, dic), DebugLevel.Result)
Debug.debug(Visualizer.printCompress(id, dic), DebugLevel.Result)
Debug.debug("\n" + str(dic.getGate(id).getMatrix()) + "\n\n",
DebugLevel.Result)
id = AQP.generateBasic(standarGate=StandarGate.H, targets=[2], dic=dic)
Debug.debug(Visualizer.printPath(id, dic), DebugLevel.Result)
Debug.debug(Visualizer.printCompress(id, dic), DebugLevel.Result)
Debug.debug("\n" + str(dic.getGate(id).getMatrix()) + "\n\n",
DebugLevel.Result)
class ObjectOrientedTitanic():
def __init__(self, train, test):
print("ObjectOrientedTitanic object created")
self.testPassengerID = test['PassengerId']
self.number_of_train = train.shape[0]
self.y_train = train['Survived']
self.train = train.drop('Survived', axis=1)
self.test = test
self.all_data = self._get_all_data()
# Create instance of objects
self._info = Information()
self.preprocessStrategy = PreprocessStrategy()
self.visualizer = Visualizer()
self.gridSearchHelper = GridSearchHelper()
def _get_all_data(self):
return pd.concat([self.train, self.test])
def information(self):
self._info.info(self.all_data)
def preprocessing(self, strategy_type):
self.strategy_type = strategy_type
self.all_data = self.preprocessStrategy.strategy(
self._get_all_data(), strategy_type)
def visualize(self, visualizer_type, number_of_features=None):
self._get_train_and_test()
if visualizer_type == "RadViz":
self.visualizer.RandianViz(X=self.X_train,
y=self.y_train,
number_of_features=number_of_features)
def machine_learning(self):
self._get_train_and_test()
self.gridSearchHelper.fit_predict_save(self.X_train, self.X_test,
self.y_train,
self.testPassengerID,
self.strategy_type)
def _get_train_and_test(self):
self.X_train = self.all_data[:self.number_of_train]
self.X_test = self.all_data[self.number_of_train:]
def main():
from Visualizer import Visualizer
#data = np.genfromtxt('Data/train.csv', delimiter=',') # Why does numpy break? Nobody knows...
print 'Reading data'
data = pd.read_csv('Data/train.csv')
print 'Reshaping data'
row = 0
label = data.iloc[row, 0]
picture = np.reshape(data.iloc[row, 1:], Constants.pic_shape)
print 'Plotting number'
Visualizer.plotNumber(str(label), picture)
print 'Transforming'
sigma = 4
alpha = 8
elasticDistort(picture, sigma, alpha)
return
# distortion = elasticDistort(picture, sigma, alpha)
print distortion
print 'Plotting zoom'
Visualizer.plotNumber(str(label), distortion)
def analyze(self):
data = self.ensemble.getValidSamples()
Common.initFolder(Visualizer.dname)
fname = Common.getLocalFileName(Visualizer.dname,
data.getModelName().split()[0], '.dat')
data.writeToPsuade(fname)
#perform screening
mfile = Visualizer.yScatter(fname, self.outputs[0], self.x, self.cmd)
#archive file
if mfile is not None:
self.archiveFile(mfile)
return mfile
class SimRobotControl():
def __init__(self, callback, rate, errorPercent):
pyglet.clock.schedule_interval(callback, rate)
ob = ObstacleGenerator()
ob.generate()
self.vis = Visualizer(ob.cornerarray, errorPercent)
#A manual function for overriding the Model control
def setMotorSpeed(self, motorIndex, speed):
raise Exception("Not implemented")
#Sets all the speeds of all the motors
def setAllMotorSpeeds(self, motor0, motor1, motor2, motor3):
raise Exception("Not implemented")
#Gets the probable point
def getProbablePoint(self):
return [self.vis.robit.x, self.vis.robit.y]
#Gets the probable theta
def getProbableTheta(self):
return self.vis.robit.theta
#Moves the robot forward a distance at a certain speed
def move(self, meters, speed):
self.vis.moveForward(meters)
#Rotates the robot by degrees at speed
def rotate(self, degrees, speed):
self.vis.setΘReltive(degrees)
def getSensorData(self):
return self.vis.getSensorData()
def tick(self, function):
function(self)
def __init__(self, D: DataCI, embedding_size: int = 200, optimizer: str = 'Adam',
negative_ratio=1, nb_epochs: int = 10, batch_size: int = 1, classification: bool = False,
kfolds: int = 10, model_file: str = 'model.h5', load: bool = False, save: bool = False):
"""
NNEmbeddings Class initialization.
:param D:
:param model_file:
:param embedding_size:
:param optimizer:
:param save:
:param load:
"""
Model.__init__(self)
Metrics.__init__(self)
Visualizer.__init__(self)
self.Data = D
# Parameter Grid
self.param_grid = {'embedding_size': embedding_size,
'negative_ratio': negative_ratio,
'batch_size': batch_size,
'nb_epochs': nb_epochs,
'classification': classification,
'optimizer': optimizer
}
self.model_file = model_file
self.nr_revision = len(self.Data.pairs)
if load:
self.model = keras.models.load_model(self.model_file)
else:
self.model = self.build_model()
print(self.crossValidation(k_folds=kfolds))
if save:
self.model.save(self.model_file)
def finish_scene(self):
if (not self.write_log) and (not self.write_frames):
return
if self.join_index_and_run_in_log:
name = self.frame_prefix + '%06d' % (self.index + self.run)
else:
name = self.frame_prefix + '%03d_%03d' % (self.index, self.run)
# save log
if self.write_log:
filename = name + '.npz'
with open(filename, 'wb') as file:
np.savez_compressed(file,
State_record=np.asarray(self.State_record),
ego_id=self.ego_id,
LengthWidth=self.LengthWidth,
num_cars=self.num_cars,
index=self.index,
run=self.run,
name=name)
# make movie
if self.write_frames:
filename = name + '.mp4'
self.visualizer = Visualizer(self.ego_id, self.LengthWidth[:, 0],
self.LengthWidth[:, 1], self.num_cars,
self.road)
metadata = dict(title=name, artist='Pseudo', comment='')
writer = FFMpegWriter(fps=2 * int(1. / Vehicle.DEL_T),
codec='libx264',
metadata=metadata,
extra_args=['-pix_fmt', 'yuv420p'])
with writer.saving(self.visualizer.fig, filename,
self.visualizer.fig.dpi):
for state in self.State_record:
self.visualizer.update(state[:, :3])
writer.grab_frame()
Scenario.flip_video(filename)
def __init__(self):
super(MainWindow, self).__init__()
self.scene = QGraphicsScene()
# Scene is the parent of the view in order to show the graphical items.
# the View must also be the parent of the scene in order to avoid
# bizarre segmentation faults with GTK
self.view = InteractiveView(self.scene)
self.scene.setParent(self.view)
self.setCentralWidget(self.view)
self.view.setSceneRect(INT_MIN/2, INT_MIN/2, INT_MAX, INT_MAX)
self.view.centerOn(0, 0)
self.visualizer = Visualizer(self.scene)
self.visualizer.update_processes_data()
# Set a dark background color
back_color = QColor(25, 20, 45)
self.view.setBackgroundBrush(QBrush(back_color))
def setUp(self):
self.autoseed = random.randint(0, 9999999999)
self.seed = self.RAND_SEED
if not self.seed:
self.seed = self.autoseed
self.myRandom = random.Random(self.seed)
self.peer_controller = None
self.peers = [self.create_peer("P%d" % i, "127.0.0.1", 8500 + i) for i in range(self.NO_OF_PEERS)]
self.peer_controller = PeerController(
self.peers, self.WORLD_SIZE, self.TOP_SPEED, self.MAX_SPEED_CHANGE, self.RADIO_RANGE, rand_seed=self.seed
)
# Start router
self.router = Router("127.0.0.1", 8300, self.peers, self.peer_controller, self.USE_TICKS)
self.router.start()
self.ensure_peers_ready(self.peers)
self.router.activate_queue()
if self.VISUALIZE:
self.visualizer = Visualizer(self.peers, self.peer_controller)
self.visualizer.visualize()
class PeerController():
"""The purpose of the class is to emulate a physical space to test range and effect of wireless communication.
Average walking speed will be 1.4, which corresponds to 5 km/h. Maximal speed in this configuration is 7.12km/h"""
def __init__(self, peers, worldSize, topSpeed, maxSpeedChange, radioRange, rand_seed = None):
if not rand_seed:
rand_seed = random.randint(0,9999999999)
self.myRandom = random.Random(rand_seed)
self.peers = peers
self.peerLock = Lock()
self.worldSize = worldSize
self.TOP_SPEED, self.MAX_SPEED_CHANGE, self.RADIO_RANGE = topSpeed, maxSpeedChange, radioRange
self.visualizer = None
for peer in self.peers:
peer.setLocation(self.generateNewPeerLocation())
peer.setPeerController(self)
def addPeer(self, peer):
self.peers.append(peer)
self.revisualize()
def removePeer(self, peer):
self.peers.remove(peer)
if self.visualizer:
self.visualizer.removePeer(peer)
self.revisualize()
def endVisualize(self):
self.visualizer.close = True
def revisualize(self):
if self.visualizer:
self.visualizer.redraw = True
def visualize(self, block=True):
if block:
self._do_visualize()
else:
thread = threading.Thread(name="visualize", target=self._do_visualize, args=[])
thread.setDaemon(True)
thread.start()
def _do_visualize(self):
self.visualizer = Visualizer(self.peers, self)
self.visualizer.visualize()
def replacePeer(self, i, peer):
with self.peerLock:
oldPeer = self.peers[i]
self.peers[i] = peer
if self.visualizer:
self.visualizer.removePeer(oldPeer)
self.revisualize()
def generateNewPeerLocation(self):
x = self.myRandom.uniform(0, self.worldSize['width']) # x coord of peer spawn
y = self.myRandom.uniform(0, self.worldSize['height']) # y coord of peer spawn
vecX = self.myRandom.uniform(-self.TOP_SPEED, self.TOP_SPEED) # x coord of peer speed vector
vecY = self.myRandom.uniform(-self.TOP_SPEED, self.TOP_SPEED) # y coord of peer speed vector
return x, y, vecX, vecY
def movePeers(self):
with self.peerLock:
for peer in self.peers:
# Check the world bounds and flip the vector to avoid collision
if peer.x + peer.vecX > self.worldSize['width'] or peer.x + peer.vecX < 0:
peer.vecX = -peer.vecX
if peer.y + peer.vecY > self.worldSize['height'] or peer.y + peer.vecY < 0:
peer.vecY = -peer.vecY
# Move
peer.x += peer.vecX
peer.y += peer.vecY
# Change the vector to change speed and direction of peer
peer.vecX = self.myRandom.uniform(
-self.TOP_SPEED if peer.vecX < -self.TOP_SPEED + self.MAX_SPEED_CHANGE else peer.vecX - self.MAX_SPEED_CHANGE,
self.TOP_SPEED if peer.vecX > self.TOP_SPEED - self.MAX_SPEED_CHANGE else peer.vecX + self.MAX_SPEED_CHANGE)
peer.vecY = self.myRandom.uniform(
-self.TOP_SPEED if peer.vecY < -self.TOP_SPEED + self.MAX_SPEED_CHANGE else peer.vecY - self.MAX_SPEED_CHANGE,
self.TOP_SPEED if peer.vecY > self.TOP_SPEED - self.MAX_SPEED_CHANGE else peer.vecY + self.MAX_SPEED_CHANGE)
self.revisualize()
def findPeersInRange(self, peer):
with self.peerLock:
# print()
# if peer.color:
# print('Finding peers in range of ' + peer.name + '(' + peer.color + ')')
# else:
# print('Finding peers in range of ' + peer.name)
peersInRange = []
meX = peer.x
meY = peer.y
for opeer in self.peers:
if opeer:
if math.pow(meX - opeer.x, 2) + math.pow(meY - opeer.y, 2) < math.pow(self.RADIO_RANGE, 2):
#if opeer.color:
# print(opeer.name + '(' + opeer.color + ') is in range')
#else:
# print(opeer.name + ' is in range')
peersInRange.append(opeer)
return peersInRange
def findPeersInRangeOutputToTerm(self, peer):
with self.peerLock:
print()
if peer.color:
print('Finding peers in range of ' + peer.name + '(' + peer.color + ')')
else:
print('Finding peers in range of ' + peer.name)
peersInRange = []
meX = peer.x
meY = peer.y
for opeer in self.peers:
if opeer:
if math.pow(meX - opeer.x, 2) + math.pow(meY - opeer.y, 2) < math.pow(self.RADIO_RANGE, 2):
if opeer.color:
print(opeer.name + '(' + opeer.color + ') is in range')
else:
print(opeer.name + ' is in range')
peersInRange.append(opeer)
return peersInRange
def _do_visualize(self):
self.visualizer = Visualizer(self.peers, self)
self.visualizer.visualize()
from socket import *
from Visualizer import Visualizer
def socketHandler(client, addr, vis):
pass
if __name__ == '__main__':
HOST = 'localhost'
PORT = 1234
BUFSIZE = 1024
serversock = socket(AF_INET, SOCK_STREAM)
serversock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
serversock.bind((HOST, PORT))
serversock.listen(1)
print 'Waiting for client'
clientsock, addr = serversock.accept()
print 'Client connected from:', addr
vis = Visualizer(clientsock)
vis.start()
# does it ever get here
print 'Closing socket connection.'
serversock.shutdown(1)
serversock.close()
def train(network, minibatch_size=5000, data_size=50000, n_epochs=60, shapeInput=(7, 7), data_iterator=DataLoader.iterate_cifar, load_previous=False):
visualizer = Visualizer()
errors_train = []
errors_train_vector = []
errors_test = []
errors_test_vector = []
sparsity_train = []
sparsity_test = []
currenti = 0
if load_previous:
try:
state = pickle.load(open('network_state.pkl', 'rb'))
network.weights = state[0]
currenti = state[1] + 1
errors_train = state[2]
errors_train_vector = state[3]
sparsity_train = state[4]
errors_test = state[5]
errors_test_vector = state[6]
sparsity_test = state[7]
np.random.set_state(state[8])
network.learning_rate = state[9]
network.output_average = state[10]
network.norm_limit = state[11]
print('Reloading previous state')
except:
print('Starting from random weights')
queue_train, queue_test = data_loading(minibatch_size, data_iterator, shapeInput, n_epochs-currenti)
for i in range(currenti, n_epochs):
print("----Epoch %i----" % i)
total_error_train = 0
total_error_train_vector = np.zeros_like(network.get_reconstruction_error_vector())
total_sparsity_train = 0
total_error_test = 0
total_error_test_vector = np.zeros_like(network.get_reconstruction_error_vector())
total_sparsity_test = 0
t1 = time.time()
j = 0
for k in range(data_size/minibatch_size):
new_input = queue_train.get()
new_input_test = queue_test.get()
for m in range(new_input.shape[0]):
j += 1
# train, update network
network.update(new_input[m], train=True)
# update statistics train
total_error_train += network.get_reconstruction_error()
total_error_train_vector += network.get_reconstruction_error_vector()
total_sparsity_train += network.get_sparsity_error_term()
# test, not modify weights
network.update(new_input_test[m], train=False)
# update statistics test
total_error_test += network.get_reconstruction_error()
total_error_test_vector += network.get_reconstruction_error_vector()
total_sparsity_test += network.get_sparsity_error_term()
print(i, j, total_error_train / j, total_sparsity_train / float(j))
visualizer.saveNetworkPlots(network, i, calc_error_surface=False)
if i % 1 == 0: # measure only sometimes
errors_train += [total_error_train / j]
errors_train_vector += [total_error_train_vector / j]
sparsity_train += [total_sparsity_train / float(j)]
errors_test += [total_error_test / j]
errors_test_vector += [total_error_test_vector / j]
sparsity_test += [total_sparsity_test / float(j)]
print(i, total_error_train / j, total_sparsity_train / float(j))
print(time.time()-t1)
if i % 1 == 0:
pickle.dump((network.weights, i, errors_train, errors_train_vector, sparsity_train, errors_test,
errors_test_vector, sparsity_test, np.random.get_state(), network.learning_rate, network.output_average,
network.norm_limit), open('network_state.pkl', 'wb'))
visualizer.saveFinalPlots(errors_train, errors_test, sparsity_train, sparsity_test, errors_train_vector, errors_test_vector, epoch=i)
visualizer.saveNetworkPlots(network, i, calc_error_surface=True)
if i > 0: # update learning rate
previous_error = errors_train[i-1]
if not errors_train[i]*1.01 < previous_error:
network.learning_rate*=0.9
print('New learning rate: ', network.learning_rate)
print("Training END")
from MazeMap import MazeMap
from AStarPlanner import AStarPlanner
from Visualizer import Visualizer
from Position import Position
from Direction import Direction
from maze import Maze
import sys
from GoalHeuristic import GoalHeuristic
if __name__ == '__main__':
file_path = str(sys.argv[1])
maze_map = MazeMap(file_path=file_path)
maze = Maze(file_path)
planner = AStarPlanner(maze_map, GoalHeuristic(maze.dim))
vis = Visualizer(maze_map.dim)
start_pos = Position(0,0)
start_head = Direction(0)
planner.replan(start_pos, start_head)
vis.draw_maze(maze)
vis.draw_policy(reversed(planner.policy), start_pos, start_head)
print "Number of moves: ", len(planner.policy)
vis.show_window()
def run(self):
drawer = Visualizer()
while True:
for key in self.robots:
robot = self.robots[key]
if self.running:
print "update"
self.update_robot(robot, delta)
self.send_updated_position(robot)
drawer.draw_robot(robot)
if self.running:
self.update_ball()
drawer.draw_ball(self.ball)
drawer.plot_field()
drawer.draw()
time.sleep(0.1)
drawer.clear()
#Frontier simulator
from FrontierController import FrontierController
from TestAgent import TestAgent
from FarsiteProducer import FarsiteProducer
from TestScorer import TestScorer
from Visualizer import Visualizer
from HotspotFilter import HotspotFilter
from FovFilter import FovFilter
import time
agent1 = TestAgent()
agent2 = TestAgent()
frontierFilter = HotspotFilter()
agentFilter = FovFilter()
frontierProducer = FarsiteProducer()
scorer = TestScorer()
i = 0
frontierController = FrontierController(scorer,frontierProducer,[agent1, agent2], [frontierFilter, agentFilter])
visualizer = Visualizer()
while(i < 10000): #frontierController.hasData()):
frontierController.tick()
visualizer.vis(frontierController.frontierData, frontierController.agentLocations) # ,frontierController.fov, frontierController.AgentLoc)
i = i +1
try:
opts, args = getopt.getopt(sys.argv[1:], "hcsv", \
["help", "calculate", "simulate", "visualize"])
except getopt.GetoptError:
usage()
sys.exit(2)
if len(sys.argv) == 1:
usage()
sys.exit()
for opt, arg in opts:
if opt in ("-h", "--help"):
usage()
sys.exit()
elif opt in("-c", "--calculate"):
try:
call("pypy Simulation.py", shell = True)
except: #pypy not found I guess
Simulate().start_calculation()
elif opt in("-s", "--simulate"):
vis = Visualizer()
vis.show_real_time()
elif opt in("-v", "--visualize"):
vis = Visualizer()
vis.show_from_file()
else:
usage()
sys.exit()
taxiHelper.setDebugCabTripIds(TRAJ_DEBUG_SPECS)
taxiHelper.createTrajectories(hwynet, TAXI_OUTFILE, 'trip_points', 'trajectories')
taxiHelper.closeDebugFile()
print 'Finished creating taxi trajectories in ', (datetime.datetime.now() - startTime)
# calculate means and such
if 'timeAgg' in STEPS_TO_RUN:
startTime = datetime.datetime.now()
taxiHelper.aggregateLinkTravelTimes(TAXI_OUTFILE, 'trajectories', 'link_tt')
print 'Finished aggregating link travel times in ', (datetime.datetime.now() - startTime)
# create network vizualizations
if 'viz' in STEPS_TO_RUN:
startTime = datetime.datetime.now()
if (hwynet==None):
hwynet = HwyNetwork()
hwynet.readDTANetwork(INPUT_DYNAMEQ_NET_DIR, INPUT_DYNAMEQ_NET_PREFIX, logging_dir=LOGGING_DIR)
vizualizer = Visualizer(hwynet, TAXI_OUTFILE)
# network speed maps
vizualizer.createNetworkPlot(VIZ_OUTFILE, date=VIZ_DATE, hour=VIZ_HOUR)
# individual trajectory plots
vizualizer.plotTrajectories(TRAJ_VIZ_OUTFILE, trajSpecs=TRAJ_VIZ_SPECS)
print 'Finished vizualizing data in ', (datetime.datetime.now() - startTime)
print 'Run complete! Time for a pint!'
# Alex is doing something funny. Blame him when it breaks.
class P2PTestCase(unittest.TestCase):
NO_OF_PEERS = 1
VISUALIZE = False
# Simulation params
TOP_SPEED = 140
MAX_SPEED_CHANGE = 50
RADIO_RANGE = 500
WORLD_SIZE = {"width": 2000, "height": 2000} # in centimeters
USE_TICKS = False
CLOCK_SYNC = False
MANUAL_OVERRIDE = True
RAND_SEED = None
def setUp(self):
self.autoseed = random.randint(0, 9999999999)
self.seed = self.RAND_SEED
if not self.seed:
self.seed = self.autoseed
self.myRandom = random.Random(self.seed)
self.peer_controller = None
self.peers = [self.create_peer("P%d" % i, "127.0.0.1", 8500 + i) for i in range(self.NO_OF_PEERS)]
self.peer_controller = PeerController(
self.peers, self.WORLD_SIZE, self.TOP_SPEED, self.MAX_SPEED_CHANGE, self.RADIO_RANGE, rand_seed=self.seed
)
# Start router
self.router = Router("127.0.0.1", 8300, self.peers, self.peer_controller, self.USE_TICKS)
self.router.start()
self.ensure_peers_ready(self.peers)
self.router.activate_queue()
if self.VISUALIZE:
self.visualizer = Visualizer(self.peers, self.peer_controller)
self.visualizer.visualize()
def tearDown(self):
for peer in self.peers:
peer.kill()
self.router.shutdown()
# print("SEED: " + str(self.seed))
def tick(self, num_msgs=1):
self.router.tick(num_msgs)
def wait_nw_idle(self):
self.router.wait_queue_empty()
def assertContains(self, msg, msg_part):
try:
self.assertTrue(msg_part in msg)
except AssertionError:
raise AssertionError("Msg: %s does not contain %s" % (msg, msg_part))
def assertNotContains(self, msg, msg_part):
try:
self.assertFalse(msg_part in msg)
except AssertionError:
raise AssertionError("Msg: %s does contain %s" % (msg, msg_part))
def create_peer(self, name, host, port):
peer = PeerHandler(name, host, port, self.MANUAL_OVERRIDE, self.CLOCK_SYNC)
if self.peer_controller: # Not set on first setup
peer.setLocation(self.peer_controller.generateNewPeerLocation())
peer.setPeerController(self.peer_controller)
if peer.process.returncode is not None:
raise Exception("Peer " + peer.name + " quit immediately ")
return peer
def ensure_peers_ready(self, peers):
for peer in peers:
peer.expect_ready(20)
def has_song_with_votes_in_playlist(self, playlist, song):
for playlistitem in playlist:
if playlistitem["song_name"] == song:
if len(playlistitem["votes"]) > 0:
return True
return False
return False
def assert_song_in_playlist(self, playlist, song):
self.assertTrue(
self.has_song_with_votes_in_playlist(playlist, song), "Song " + song + " was expected in playlist"
)
