def mail(self, name=0, **kwargs): name = str(name) cfg = Config.smtp Logger.debug("sending mail %s%s from %s to %s", name, str(kwargs), cfg['from'], cfg['to']) usr = cfg.get('user') pswd = cfg.get('password') msg = self.buildMsg(name, kwargs) dump = kwargs.get("dump") if dump: with open(dump, "w") as f: f.write(msg) Logger.info("Message %s saved to %s", name, dump) return cli = smtplib.SMTP(cfg['host']) if cfg.get('ssl') == True: cli.starttls() if usr and pswd: cli.ehlo() cli.login(usr, pswd) else: cli.helo() cli.sendmail(cfg['from'], kwargs.get('to') or cfg['to'], msg) cli.quit() Logger.info("Message %s sent", name)
class Client(object): TOP_K = 3 def __init__(self, config): if not os.path.exists(FLAGS.log_path): os.mkdir(FLAGS.log_path) self.logger = Logger(config.log_path, 'client') self.stub = service_grpc.RecognitionStub( grpc.insecure_channel('{}:{}'.format(FLAGS.ip, FLAGS.port))) def RecognizeTest(self, filepath): self.logger.log('--- Performing recognition ---') self.logger.info('--- Performing recognition ---') request = service_pb.Request() # Extract data from image file with open(filepath, 'rb') as file: request.image.data = file.read() # Define file extension request.image.format = os.path.basename(filepath).split('.')[-1] start_time = time.time() # Perform request responses = self.stub.Recognize(iter([request])) results = None for response in responses: if response.status.code == 0: print('Result = {} '.format(response.status.text)) return False if len(response.label) == 0: return False results = sorted(response.label, key=lambda l: -l.probability)[:self.TOP_K] end_time = (time.time() - start_time) self.logger.log("--- Recognition took %s seconds ---" % end_time) self.logger.info("--- Recognition took %s seconds ---" % end_time) print('Results:') for result in results: print("'{}' with probability {}%.".format( result.text, math.floor(result.probability * 100))) return True
def serve(): logger = Logger(FLAGS.log_path, 'server') server = grpc.server(futures.ThreadPoolExecutor(max_workers=1)) service = Server(FLAGS) service_grpc.add_RecognitionServicer_to_server(service, server) server.add_insecure_port('[::]:{}'.format(FLAGS.port)) logger.log("--- Server has been started... ---") logger.info("--- Server has been started... ---") server.start() try: while True: time.sleep(1) except KeyboardInterrupt: server.stop(0)
(options, args) = optParser.parse_args() return options # this is the main entry point of this script if __name__ == "__main__": options = get_options() if not options.scenario_folder: sys.exit("You must specify the Scenario Folder using the '--scenario' option") Logger.set_globals(options.scenario_folder,'desenv',logging.INFO, options.withpreemption) logger = Logger('Runner').get() logger.info(options) #scenario = options.scenario # this script has been called from the command line. It will start sumo as a # server, then connect and run if options.nogui: sumoBinary = checkBinary('sumo') else: sumoBinary = checkBinary('sumo-gui') # this is the normal way of using traci. sumo is started as a # subprocess and then the python script connects and runs #traci.start([sumoBinary, "-c", './' + scenario + '/osm.sumocfg', # "--tripinfo-output", './' + scenario + '/tripinfo.xml'])
class Classifier: def __init__(self, graph_path, labels_path, input_layer, output_layer, input_height=224, input_width=224, input_mean=0, input_std=255): self.logger = Logger() """ -------------------------------------- Original session -------------------------------------- """ start_time = time.time() # We load the protobuf file from the disk and parse it to retrieve the unserialized graph_def with tf.gfile.GFile(graph_path, "rb") as f: self.graph = tf.Graph() graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) # Then, we import the graph_def into a new Graph and returns it with self.graph.as_default(): # The name var will prefix every op/nodes in your graph # Since we load everything in a new graph, this is not needed tf.import_graph_def(graph_def) # Creating a session one time to reduce the time for serving a lot of images self.session = tf.Session(graph=self.graph) self.logger.log( "--- Deep Neural Network session initialization took %s seconds ---" % (time.time() - start_time)) self.logger.info( "--- Deep Neural Network session initialization took %s seconds ---" % (time.time() - start_time)) """ -------------------------------------- Input & output -------------------------------------- """ # Access input and output nodes self.input_operation = self.graph.get_tensor_by_name('import/' + input_layer) self.output_operation = self.graph.get_tensor_by_name('import/' + output_layer) """ --------------------------------- Image preprocessing session ---------------------------------- """ start_time = time.time() # Image processing graph self.image_graph = tf.Graph() with self.image_graph.as_default(): self.image_path = tf.placeholder(tf.string) file_reader = tf.read_file(self.image_path, "file_reader") # Define image extension ext = tf.string_split([self.image_path], '.').values[1] def read_jpg(fr): return tf.image.decode_jpeg(fr, channels=3, name="jpeg_reader") def read_png(fr): return tf.image.decode_png(fr, channels=3, name="png_reader") def read_bmp(fr): return tf.image.decode_bmp(fr, name="bmp_reader") def read_gif(fr): return tf.image.decode_gif(fr, name="gif_reader") # Load image bytes image = tf.case( { tf.equal(ext, tf.constant('jpg', dtype=tf.string)): lambda: read_jpg(file_reader), tf.equal(ext, tf.constant('png', dtype=tf.string)): lambda: read_png(file_reader), tf.equal(ext, tf.constant('bmp', dtype=tf.string)): lambda: read_bmp(file_reader), tf.equal(ext, tf.constant('gif', dtype=tf.string)): lambda: read_gif(file_reader) }, default=lambda: read_jpg(file_reader), exclusive=True) # Convert input image and transform to [0; 1) range if image.dtype != tf.float32: image = tf.image.convert_image_dtype(image, dtype=tf.float32) # Central crop does not work without that image.set_shape((None, None, None)) # Accidentally it increases overall accuracy image = tf.image.central_crop(image, central_fraction=0.875) # Resize the image to the specified height and width. if input_height and input_height: image = tf.expand_dims(image, 0) image = tf.image.resize_bilinear(image, [input_height, input_width], align_corners=False) # Transform to [-1; 1) range self.image_output = tf.multiply(tf.subtract(image, 0.5), 2.0) # float_caster = tf.cast(image, tf.float32) # dims_expander = tf.expand_dims(float_caster, 0) # resized = tf.image.resize_bilinear(dims_expander, [input_height, input_width]) # self.image_output = tf.divide(tf.subtract(resized, input_mean), input_std) self.image_sess = tf.Session(graph=self.image_graph) self.logger.log( "--- Image preprocessing session initialization took %s seconds ---" % (time.time() - start_time)) self.logger.info( "--- Image preprocessing session initialization took %s seconds ---" % (time.time() - start_time)) """ -------------------------------------- Labels loading -------------------------------------- """ # Loading captions of labels self.labels = [] self.load_labels(labels_path) # Launch image recognition session def recognize(self, image_path): start_time = time.time() data = self.read_tensor_from_image_file(image_path=image_path) self.logger.log("--- Image preprocessing took %s seconds ---" % (time.time() - start_time)) self.logger.info("--- Image preprocessing took %s seconds ---" % (time.time() - start_time)) start_time = time.time() probabilities = self.session.run( self.output_operation, feed_dict={self.input_operation: data}) self.logger.log("--- DNN inference took %s seconds ---" % (time.time() - start_time)) self.logger.info("--- DNN inference took %s seconds ---" % (time.time() - start_time)) probabilities = np.squeeze(probabilities) return [(self.labels[i], prob) for i, prob in enumerate(probabilities)] # Launch image preprocessing session def read_tensor_from_image_file(self, image_path): return self.image_sess.run(self.image_output, feed_dict={self.image_path: image_path}) # Load labels from file def load_labels(self, label_path): for l in open(label_path, 'r').readlines(): self.labels.append(l.split(':')[1][:-1]) return self.labels
instance_folder = os.path.join(options.scenario_folder, 'results') instance_folder = os.path.join(instance_folder, options.prefix) if not os.path.exists(instance_folder): os.makedirs(instance_folder, exist_ok=True) instance_opts = 'tripinfo_' + algorithm.instance_name() logfile = os.path.join(instance_folder, '{}.log'.format(instance_opts)) Logger.set_globals(logfile, logging.INFO) logger = Logger('Runner').get() logger.info(options) trip_file = instance_folder + '/' + instance_opts + '.xml' statistics_values = StatisticsValues(options.scenario_folder, instance_folder, trip_file, options.algorithm, options.ev) if not statistics_values.skip_because_json_file( options.override, options.skip, algorithm.instance_name()): traci.start([ sumoBinary, '-v', 'true', '-c', options.scenario_folder + '/osm-' + options.prefix + '.sumocfg', '--duration-log.statistics', '--tripinfo-output', trip_file, '--start', '--time-to-teleport', '300', '--seed', str(options.seedsumo), '--ignore-junction-blocker', '50'
FLAGS = parse_args() if __name__ == '__main__': if not os.path.exists(FLAGS.graph_path): raise FileNotFoundError('Graph file does not exist') if not os.path.exists(FLAGS.labels_path): raise FileNotFoundError('Labels file does not exist') if not os.path.exists(FLAGS.log_path): os.mkdir(FLAGS.log_path) logger = Logger(FLAGS.log_path, 'inference') start_time = time.time() classifier = Classifier(FLAGS.graph_path, FLAGS.labels_path, FLAGS.input_layer, FLAGS.output_layer, FLAGS.input_height, FLAGS.input_width, FLAGS.input_mean, FLAGS.input_std) logger.log("--- Initialization took %s seconds ---" % (time.time() - start_time)) logger.info("--- Initialization took %s seconds ---" % (time.time() - start_time)) start_time = time.time() result = classifier.recognize(FLAGS.image_path) logger.log("--- %s seconds ---" % (time.time() - start_time)) logger.info("--- %s seconds ---" % (time.time() - start_time))
class Server(service_grpc.RecognitionServicer): def __init__(self, config): super(Server, self).__init__() self.logger = Logger(config.log_path, 'server') self.logger.log("--- Initialization started ---") self.logger.info("--- Initialization started ---") start_time = time.time() self.classifier = Classifier(config.graph_path, config.labels_path, config.input_layer, config.output_layer, config.input_height, config.input_width, config.input_mean, config.input_std) self.logger.log("--- Total initialization took %s seconds ---" % (time.time() - start_time)) self.logger.info("--- Total initialization took %s seconds ---" % (time.time() - start_time)) def Recognize(self, request_iterator, context): try: # Extract image data from the message request = service_pb.Request() request.image.data = b'' for r in request_iterator: request.image.format = r.image.format if r.image.data: request.image.data += r.image.data self.logger.log("--- Message has been successfully received ---") self.logger.info("--- Message has been successfully received ---") if request.image.format not in [ 'jpg', 'jpeg', 'png', 'bmp', 'gif' ]: response = service_pb.Response() response.status.code = 0 response.status.text = 'Not supported image format' self.logger.log("--- Not supported image format received ---") self.logger.info("--- Not supported image format received ---") return iter([response]) filename = str(time.strftime("%Y-%m-%d %H:%M:%S")) filepath = os.path.join(DIR, 'images', filename + '.' + request.image.format) with open(filepath, 'wb') as file: file.write(request.image.data) file.close() self.logger.log("--- Recognition started ---") self.logger.info("--- Recognition started ---") start_time = time.time() output = self.classifier.recognize(filepath) self.logger.log("--- Recognition took %s seconds ---" % (time.time() - start_time)) self.logger.info("--- Recognition took %s seconds ---" % (time.time() - start_time)) # Create and send the response response = service_pb.Response() response.status.code = 1 response.status.text = 'Success' for l, p in output: label = response.label.add() label.code = 1 label.text = l label.probability = p self.logger.log("--- Recognition response sent ---") self.logger.info("--- Recognition response sent ---") os.remove(filepath) return iter([response]) except Exception as e: self.logger.log("--- Error: %s ---" % str(e)) self.logger.info("--- Error: %s ---" % str(e)) response = service_pb.Response() response.status.code = 0 response.status.text = 'Error: %s' % str(e) return iter([response])