def simple_query(self, query, params, condition=''): """ Simple database query Input parameters: query - query number (one from QUERY_... constants) params - parameter tuple when only one parameter is required specify as (parameter,) Return value: success: - First row of query result failure: - raise error """ if self.__cnx is None: raise DbException.CONNECTION_FAILED try: complete_query = query.__add__(condition) self.__cursor.execute(complete_query, params) result = self.__cursor.fetchone() self.__cnx.commit() if result is None: raise DbException.QUERY_NO_RESULT except mysql.connector.Error: LOG.error("Query: '%s', parameters (%s)" % (complete_query, str(params))) raise DbException.MYSQL_CONNECTOR return result
def load_label(self, index): labels = [] try: with open(self.label_files[index], 'r') as f: for l in f.readlines(): target = l.split(' ') labels.append([self.class_to_idx(target[0]), int(target[1]), int(target[2]), int(target[3]), int(target[4])]) except: LOG.error('annotation file {} non-existent'.format(self.label_files[index])) return labels
def log(self, ip, msg, resultcode, cid, stage): """ Logs CLIENT connection to the database using inform parameters """ try: # Always [try to] log to the log table self.__cursor.execute(Queries.INSERT_CLIENTLOG, (cid, resultcode, ip, msg)) self.__cursor.fetchone() self.__cnx.commit() except mysql.connector.Error as err: LOG.error("Database: Error during LOG, %s" % err.msg)
def disconnect(self): """ Disconnect from database Input parameter: cnx = connection """ if self.__cnx is None: LOG.error("Error: disconnecting when not connected") return try: # Try to clean up database cursor object. If that fails the garbage # collector will automatically deal with it after connection has # been closed. self.__cursor.close() except mysql.connector.Error as err: LOG.error("Error closing cursor: %s" % err.msg) finally: # Closing the connection with the database server may lead to # exceptions but they are handled in such a way that they never lead # to an error disturbing normal operation. Closing the connection # can thus safely be done here. self.__cnx.close()
def connect(self): """ Connect to the database and create a cursor No input parameters """ config = { 'user': MYSQL_USER, 'password': MYSQL_PASSWORD, 'database': MYSQL_DATABASE, 'unix_socket': '/run/mysqld/mysqld.sock', 'raise_on_warnings': False, 'charset': 'latin1', 'collation': 'latin1_general_ci', 'buffered': False, } try: self.__cnx = mysql.connector.connect(**config) except mysql.connector.Error as err: if err.errno == errorcode.ER_ACCESS_DENIED_ERROR: LOG.error("Cannot connect to database: No access") elif err.errno == errorcode.ER_BAD_DB_ERROR: LOG.error("Cannot connect to database: Unknown database") else: LOG.error("Cannot connect to database: Unknown error") raise DbException.CONNECTION_FAILED self.__cursor = self.__cnx.cursor(prepared=True)
def load_mosaic(self, index): # mosaic增强 labels4 = [] s = self.img_size # mosaic增强四部分图片的相交点 yc, xc = [int(random.uniform(-x, 2 * s + x)) for x in self.mosaic_border] # 随机出其他三张图片 indices = [index] + [random.randint(0, len(self.img_files) - 1) for _ in range(3)] for i, index in enumerate(indices): # Load image img = cv2.imread(self.img_files[index]) assert img is not None, LOG.error('Image not found' + self.img_files[index]) h, w = img.shape[:2] # place img in img4 if i == 0: # top left img4 = np.full((s * 2, s * 2, img.shape[2]), 114, dtype=np.uint8) # base image with 4 tiles x1a, y1a, x2a, y2a = max(xc - w, 0), max(yc - h, 0), xc, yc # xmin, ymin, xmax, ymax (large image) x1b, y1b, x2b, y2b = w - (x2a - x1a), h - (y2a - y1a), w, h # xmin, ymin, xmax, ymax (small image) elif i == 1: # top right x1a, y1a, x2a, y2a = xc, max(yc - h, 0), min(xc + w, s * 2), yc x1b, y1b, x2b, y2b = 0, h - (y2a - y1a), min(w, x2a - x1a), h elif i == 2: # bottom left x1a, y1a, x2a, y2a = max(xc - w, 0), yc, xc, min(s * 2, yc + h) x1b, y1b, x2b, y2b = w - (x2a - x1a), 0, max(xc, w), min(y2a - y1a, h) elif i == 3: # bottom right x1a, y1a, x2a, y2a = xc, yc, min(xc + w, s * 2), min(s * 2, yc + h) x1b, y1b, x2b, y2b = 0, 0, min(w, x2a - x1a), min(y2a - y1a, h) img4[y1a:y2a, x1a:x2a] = img[y1b:y2b, x1b:x2b] # img4[ymin:ymax, xmin:xmax] padw = x1a - x1b padh = y1a - y1b # Labels x = load_label(index) labels = x.copy() if x.size > 0: # xyxy format labels[:, 1] = x[:, 1] + padw labels[:, 2] = x[:, 2] + padh labels[:, 3] = x[:, 3] + padw labels[:, 4] = x[:, 4] + padh labels4.append(labels) # Concat/clip labels if len(labels4): labels4 = np.concatenate(labels4, 0) np.clip(labels4[:, 1:], 0, 2 * s, out=labels4[:, 1:]) return img4, labels4
def __init__(self, path, class_names, hyp, img_size = 640, transform=None): super(FreeDataset, self).__init__() self.transform = transform if transform else FreeDatasetAugment(hyp) self.img_size = img_size # mosaic增强图片 self.mosaic_border = [-img_size // 2, -img_size // 2] self.root = str(Path(path)) + os.sep assert (os.path.isdir(self.root)), LOG.error("dataset path is not dir.") # 获取所有文件,并过滤不支持的格式 files = glob.glob(self.root + 'imgs' + os.sep + '*.*') self.img_files = [x for x in files if os.path.splitext[-1].lower() in img_formats] label_path = self.root + 'labels' + os.sep self.label_files = [label_path + x.split(os.sep)[-1].replace(os.path.splitext(x)[-1], '.txt') for x in self.img_files] assert (len(self.img_files) == len(self.label_files)), LOG.error("image annotation lose.") # 类别和idx对应 self.classes = [] self.classes.append('__background__') self.classes += [i.strip() for i in class_names.split(',')] self.class_to_idx = dict(zip(self.classes, range(len(self.classes)))) LOG.info("class to idx: {}".format(self.class_to_idx))
def session_handler(reader, writer): """ This is a call back routine for an SSL session Read messages from the device, handle them and write the responses """ # initialize defaults session = { 'queue': [], 'rpc': { 'id': 0 }, 'cpe': {}, 'dm': {}, 'rtwan_layer3_keep': False, 'voice_layer3_keep': False } # start authentication of client state = RPCS.Authenticating state = state.prepare_session(writer, session) try: LOG.debug("Open connection with: %s", session['cpe']['ip']) # RPC SERVER while state in RPCS.RPC_SERVER_STATES: response = None request = yield from asyncio.wait_for(reader.readline(), timeout=RPCSD_TIMEOUT) if reader.at_eof(): # Received disconnect signal from CPE update_northbound_handler(session) session['log'] = { 'rc': 'error', 'msg': 'Connection terminated by client' } LOG.debug("CPE closed connection with RPC Server") break session['rpc']['message'] = parse_message(request, 'request') # Respond with error to invalid requests, when possible if 'error' in session['rpc']['message']: if session['rpc']['message']['error'] is not None: response = session['rpc']['message'] # Handle message and move between states else: state, response = state.run(session) # Prepare and send response if not (response is None): LOG.debug("Message to cpe: " + str(response)) send_rpc(response, writer) # RPC CLIENT while state in RPCS.RPC_CLIENT_STATES: request = None rpc = None # Only listen for messages during 'ExpectResponse' state if state == RPCS.ExpectResponse: request = yield from asyncio.wait_for(reader.readline(), timeout=RPCSD_TIMEOUT) if reader.at_eof(): # Received disconnect signal from CPE update_northbound_handler(session) session['log'] = { 'rc': 'error', 'msg': 'Connection terminated by client' } LOG.debug("CPE closed connection with RPC Server") break session['rpc']['message'] = parse_message(request, 'response') # Either check if there are RPCs in queue to send, or handle CPE # response state, rpc = state.run(session) if rpc is not None: LOG.debug("Message to cpe: " + str(rpc)) send_rpc(rpc, writer) except asyncio.TimeoutError: LOG.debug("CPE connection timed out") # Write an error to the database session['log'] = {'rc': 'error', 'msg': 'Connection timeout'} reader.feed_eof() except ConnectionResetError: LOG.debug("CPE closed the connection with RPC Server") session['log'] = {'rc': 'error', 'msg': 'Connection reset by peer'} reader.feed_eof() except Exception: # Catch everything else, prevents daemon from crashing err = sys.exc_info()[0] traceback.print_exc() LOG.error("Internal server error: %s", err) reader.feed_eof() finally: # Make sure session is always closed tidily even if an error occurs if 'db' in session: log_to_database(session) session['db'].disconnect() writer.close() # Get any response left and throw away while not (reader.at_eof()): yield from reader.read() LOG.debug("Close connection with: %s", session['cpe']['ip']) # Running a forceful full garbage collection collected = gc.collect() LOG.debug("Unreachable objects after forceful garbage collection: %d", collected)
LOG.info(s + '%10.4g' * 4 % results) # 模型保存 if (epoch + 1) % 10 == 0 or (epoch + 1) == args.epochs: epoch_model = Path(args.save_path) / 'yolov5_ep%g.pth' % (epoch+1) torch.save(ema.ema, epoch_model) fi = fitness(np.array(results).reshape(1, -1)) # fitness_i = weighted combination of [P, R, mAP, F1] if fi > best_fitness: best_fitness = fi torch.save(ema.ema, best) if args.local_rank in [-1, 0]: LOG.info('%g epochs completed in %.3f hours = %i.\n' % (epoch - start_epoch + 1, (time.time() - t0) / 3600)) dist.destroy_process_group() if args.local_rank not in [-1, 0] else None torch.cuda.empty_cache() if __name__ == '__main__': config.log_setting(config.logger["file"], config.logger["level"], config.logger["format"], config.logger["backupCount"], config.logger["interval"]) LOG.info("*******************train start.*******************") LOG.info(args) LOG.info(config.hyp) LOG.info(config.dataset) LOG.info(config.logger) if args.labels is None: LOG.error("labels is none.") LOG.info("***************training***************") train() LOG.info("*******************exited.*******************")