def main(): parser = argparse.ArgumentParser() # parser.add_argument('--position', default="tail_conv", type=str, # choices=["tail", "tail_tsp", "tail_conv", "tail_tsp_self", # "tail_conv_deep", "tail_conv_deep_fc"]) # parser.add_argument('--csize', default=64, type=int) # parser.add_argument('-fc', '--focal_loss', action='store_true', help='use focal loss') parser.add_argument('--weights', default="hg_yolo-110000", type=str) parser.add_argument('--weight_dir', default='../../log512/512stc4md2_bboxwhsm32hm1_hghm3/', type=str) # parser.add_argument('--data_dir', default="data", type=str) parser.add_argument('--gpu', type=str) parser.add_argument('-c', '--cpu', action='store_true', help='use cpu') args = parser.parse_args() if args.gpu: os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu if args.cpu: os.environ['CUDA_VISIBLE_DEVICES'] = '' get_config(args.weight_dir) # cfg.CELL_SIZE = args.csize yolo = HOURGLASSYOLONet('visual') detector = Detector(yolo, os.path.join(args.weight_dir, args.weights)) # detect from camera cap = cv2.VideoCapture(-1) detector.camera_detector(cap)
def main(generate_accuracy_csv=False, order=None): """ run evaluation for a specific model and generate chart """ # Load configuration for evaluation # config = get_config('eval/resnet152') # config = get_config('eval/affact') config = get_config('eval/resnet51_s') # Init environment, use GPU if available, set random seed device = init_environment(config) # Create an evaluation instance with the loaded configuration on the loaded device eval_instance = EvalModel(config, device) # Check if flag is set to generate file that contains accuracies of the model of different test sets # Further check if such a file exists. If not, generate file regardless of the state of the flag. if generate_accuracy_csv or not os.path.isfile( '{}/evaluation_result.csv'.format(config.experiments_dir)): # Run the evaluation (Calculate prediction accuracies of model on different test sets) df = eval_instance.evaluate() # Save csv df.to_csv('{}/evaluation_result.csv'.format(config.experiments_dir)) # execute quantitative analysis if config.evaluation.quantitative.enabled: eval_instance.quantitative_analysis(order) # execute qualitative analysis if config.evaluation.qualitative.enabled: eval_instance.qualitative_analysis()
def __init__(self): self.conf = config_utils.get_config("FVExtractionCnn") self.img = None self.frontal_face_detector = models_utils.get_frontal_face_detector() self.shape_predictor = models_utils.get_shape_predictor() self.face_rec_model = models_utils.get_face_recog_model() self.upsample_times = self.conf["upsampleTimes"] self.num_jitters = self.conf["numJitters"]
def __init__(self): self.conf = config_utils.get_config("preprocessing") self.img_path = None self.img = None self.upsample_times = self.conf["upsampleTimes"] self.img_square_size = self.conf["imgSquareSize"] self.anti_aliasing = bool(self.conf["antiAliasing"]) self.resize_mode = self.conf["resizeMode"] self.frontal_face_detector = models_utils.get_frontal_face_detector() self.shape_predictor = models_utils.get_shape_predictor()
def __init__(self): self.conf = config_utils.get_config("FVExtractionLbph") self.img = None self.neighbours = self.conf["neighbours"] self.radius = self.conf["radius"] self.grid_size = self.conf["gridSize"] self.img_size = self.conf["imgSize"] self.n_rows = self.conf["nRows"] self.n_cols = self.conf["nCols"] self.nbp_method_name = self.conf["lbpMethodName"] self.nbp_method_colors = self.conf["lbpMethodColors"]
def main(): """ Run training for a specific model """ # Load configuration for training config = get_config() # Init environment, use GPU if available, set random seed device = init_environment(config) # Create result directory create_result_directory(config) # Create a training instance with the loaded configuration on the loaded device training_instance = TrainModel(config, device) # Run the training training_instance.train()
def main(): """ Creates the test datasets needed for evaluation """ config = get_config('dataset/testsetA_config') # Load dataframes for testing df_test_labels, df_test_landmarks, df_test_bounding_boxes = generate_test_dataset( config) # Define transformations for dataset A (aligned) # Consists of images aligned according to the hand-labled landmarks print('Creating testset A (aligned)') data_transforms_A = transforms.Compose([AffactTransformer(config)]) _create_test_images(config, df_test_labels, df_test_landmarks, df_test_bounding_boxes, data_transforms_A) # Define transformations for dataset D (detected bounding boxes) # Consists of images aligned according to the face detector print('Creating testset D (detected bounding boxes)') config = get_config('dataset/testsetD_config') data_transforms_D = transforms.Compose([AffactTransformer(config)]) _create_test_images(config, df_test_labels, df_test_landmarks, df_test_bounding_boxes, data_transforms_D) # face detector -> grösser bbx -> 10crop config = get_config('dataset/testsetC_config') print('Creating testset C (10 crop)') data_transforms_C = transforms.Compose([AffactTransformer(config)]) _create_test_images(config, df_test_labels, df_test_landmarks, df_test_bounding_boxes, data_transforms_C) # face detector -> bigger bbx -> AFFACT Transformations config = get_config('dataset/testsetT_config') print('Creating testset T (AFFACT transformations)') data_transforms_T = transforms.Compose([AffactTransformer(config)]) _create_test_images(config, df_test_labels, df_test_landmarks, df_test_bounding_boxes, data_transforms_T)
def create_and_run_model(config_name, eval_path=None, infer=False): if eval_path is not None and infer: raise Exception("Both infer_path and eval_path are set. But cannot infer and evaluate at the same time.") mappings = {'CNN_RNN_CTC': CNN_RNN_CTC, 'RNN_CTC': RNN_CTC, 'Encoder_Decoder': Encoder_Decoder} config = get_config(config_name) TRAIN = eval_path is None and not infer # indicates whether we are in training mode or not if not infer: _setup_logging(config, config.restore_previous_model or not TRAIN) if TRAIN: if config.restore_previous_model: logging.info("-"*70 + "\n" + " "*20 + "Continuing with previous model\n" + "-"*70) else: logging.info("-"*70 + "\n" + " "*25 + "Starting a new model\n" + "-"*70) logging.info("Logging model parameters:") try: attr = vars(config) except: attr = config._asdict() for k, v in attr.items(): if not k.startswith('__'): logging.info(str(k) + ": " + str(v)) elif eval_path is not None: logging.info("\n" + "-"*50 + "\nEvaluating ({})\n".format(config.decoder_type.replace("_", " ").capitalize()) + "-"*50) if TRAIN: logging.info("\n" + "-"*50 + "\nInitializing Model and Building Graph\n" + "-"*50) tic = time.time(); model = mappings[config.model](config, eval_path, infer); if TRAIN: toc = time.time() logging.info("Time to initialize model (including to load data): %f secs\n" % (toc-tic)) if TRAIN or eval_path is not None: model() return model, config
FastAPI Demo Create the initial user ''' from database.setup import session_local, engine from database import models from data_schemas import schemas from utils.config_utils import get_config from utils.user_utils import ( create_user, set_user_admin ) ############################################################################### CONFIG = get_config('initial_user.cfg') INITIAL_USER_CONFIG = CONFIG['initial_user'] INITIAL_USER = schemas.UserCreate( username=INITIAL_USER_CONFIG['username'], first_name=INITIAL_USER_CONFIG['first_name'], last_name=INITIAL_USER_CONFIG['last_name'], email=INITIAL_USER_CONFIG['email'], password=INITIAL_USER_CONFIG['password'] ) ############################################################################### def create_initial_user(): '''Create the initial user''' session = session_local() models.Base.metadata.create_all(bind=engine)
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm import jwt from sqlalchemy.orm import Session from starlette.requests import Request from starlette.status import (HTTP_400_BAD_REQUEST, HTTP_401_UNAUTHORIZED) # Local Imports from utils.config_utils import get_config from utils.main_utils import get_db from utils.token_utils import create_access_token from utils.user_utils import (authenticate_user, get_user) from data_schemas import schemas ############################################################################### CONFIG = get_config('security.cfg') SECURITY = CONFIG['security'] oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/token") #pylint: disable=invalid-name router = APIRouter() #pylint: disable=invalid-name ############################################################################### AUTHENTICATION_EXCEPTION = HTTPException( status_code=HTTP_401_UNAUTHORIZED, detail="Incorrect username or password", headers={"WWW-Authenticate": "Bearer"}, ) CREDENTIALS_EXCEPTION = HTTPException(status_code=HTTP_401_UNAUTHORIZED,
import dlib from utils import config_utils paths = config_utils.get_config("paths") def get_shape_predictor(): return dlib.shape_predictor(paths["shapePredictor"]) def get_frontal_face_detector(): return dlib.get_frontal_face_detector() def get_face_recog_model(): return dlib.face_recognition_model_v1(paths["faceRecog1"])
def load_img_skimage(img_path): from utils import config_utils size = config_utils.get_config("preprocessing")["imgSquareSize"] return resize(imageio.imread(img_path, pilmode='LA'), (size, size), anti_aliasing=True, mode="constant")
from fastapi import Depends, FastAPI from starlette.requests import Request from starlette.responses import Response from starlette.testclient import TestClient # Local Imports from database.setup import session_local from data_schemas import schemas from routers import (token, users) from utils.config_utils import get_config from utils.token_utils import create_access_token import utils.user_utils as user_utils ############################################################################### CONFIG = get_config('testing.cfg') TESTING = CONFIG['testing'] PASS_MSG = 'Parameters meant to pass the test produced negative result' ############################################################################### # Testing class ############################################################################### class TestFastAPI(unittest.TestCase): '''Template class for testing a PostgreSQL database''' def __init__(self, *args, **kwargs): super(TestFastAPI, self).__init__(*args, **kwargs) self.app = FastAPI() self.setup_fastapi_app() self.client = TestClient(self.app) self.session = session_local()
def main(): """ Run training for a specific model """ # Load configuration for training config = get_config('train/affact_hyperopt') # Init environment, use GPU if available, set random seed device = init_environment(config) # Create result directory create_result_directory(config) # Create a training instance with the loaded configuration on the loaded device # training_instance = TrainModel(config, device) # Run the training # training_instance.train() prefix = "/home/yves/Desktop/uzh/affact/PyAffact/" print(prefix + config.dataset.dataset_labels_filename) def train_hyperopt(config, data_dir=None): config.basic.result_directory = prefix + "results" config.dataset.dataset_labels_filename = prefix + config.dataset.dataset_labels_filename config.dataset.partition_filename = prefix + config.dataset.partition_filename config.dataset.dataset_image_folder = prefix + config.dataset.dataset_image_folder config.dataset.landmarks_filename = prefix + config.dataset.landmarks_filename config.dataset.bounding_boxes_filename = prefix + config.dataset.bounding_boxes_filename training_instance = TrainModel(config, device) # Run the training training_instance.train_resnet_51_hyperopt() data_dir = os.path.abspath("./data_dir") config.preprocessing.dataloader.batch_size = tune.choice([32, 64]) wandb.init(config=config) # config.training.epochs = tune.choice([1, 2]) scheduler = ASHAScheduler(metric="loss", mode="min", max_t=10, grace_period=1, reduction_factor=2) reporter = CLIReporter( # parameter_columns=["l1", "l2", "lr", "batch_size"], metric_columns=["loss", "accuracy", "training_iteration"]) print("starting") result = tune.run(partial(train_hyperopt), resources_per_trial={ "cpu": 2, "gpu": 1 }, config=config, num_samples=1, scheduler=scheduler, progress_reporter=reporter) best_trial = result.get_best_trial("loss", "min", "last") print("Best trial config: {}".format(best_trial.config)) print("Best trial final validation loss: {}".format( best_trial.last_result["loss"])) print("Best trial final validation accuracy: {}".format( best_trial.last_result["accuracy"])) # Create the sweep wandb.sweep(result)
def main(): parser = argparse.ArgumentParser() parser.add_argument('-ims', '--image_size', default=512, type=int) parser.add_argument('-g', '--gpu', type=str) parser.add_argument('-c', '--cpu', action='store_true', help='use cpu') parser.add_argument('-ds', '--data_source', default='all', type=str, choices=['coco', 'pascal', 'all']) parser.add_argument('-ef', '--eval_file', type=str, required=True) parser.add_argument('-lf', '--log_file', type=str) parser.add_argument('-al', '--auto_all', action='store_true') # when calculate single model parser.add_argument('--weights', default="hg_yolo-240000", type=str) parser.add_argument( '--weight_dir', default='../log_bbox_hm/0.8_0.08_0.03_conv_fc_l2_0.005_bhm5', type=str) args = parser.parse_args() if args.gpu: os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu if args.cpu: os.environ['CUDA_VISIBLE_DEVICES'] = '' if not args.auto_all: strings = get_config(args.weight_dir) net = HOURGLASSYOLONet('eval') detector = Detector(net, os.path.join(args.weight_dir, args.weights)) # data = COCO_VAL() data = PASCAL_VAL() evaluator = EVALUATOR(detector, data) ap = evaluator.eval() log = Logger(args.eval_file, level='debug') log.logger.info('\n calculate single ap from {} {}\n'.format( args.weight_dir, args.weights)) log.logger.info('Data sc:{} AP:{} Weights:{} {}'.format( data.__class__.__name__, ap, args.weights, strings)) else: data_source = ds_config(args) log = Logger(args.eval_file, level='debug') log.logger.info('\n calculate ap from {}\n'.format(args.eval_file)) model_start = 'hg_yolo' rootdir = '../' + args.log_file root_list = os.listdir(rootdir) # 列出文件夹下所有的目录与文件 root_list.sort() for path in root_list: model_dir = os.path.join(rootdir, path) models = os.listdir(model_dir) models = filter(lambda x: x.startswith(model_start), models) models = list(set(map(lambda x: x.split('.')[0], models))) models.sort(key=lambda x: int(x[8:])) for data in data_source: for model in models: strings = get_config(model_dir) tf.reset_default_graph() net = HOURGLASSYOLONet('eval') detector = Detector(net, os.path.join(model_dir, model)) evaluator = EVALUATOR(detector, data) ap = evaluator.eval() log.logger.info( 'Data sc:{} AP:{:<5.5f} Weights:{} {}'.format( data.__class__.__name__, ap, model, strings)) detector.sess.close() del net del detector del evaluator
""" Generate chart to compare relative performance of two models """ from evaluation.charts import generate_relative_improvement_chart from preprocessing.dataset_generator import generate_test_dataset from utils.config_utils import get_config import pandas as pd if __name__ == '__main__': config_l = get_config('eval/resnet51_s') config_r = get_config('eval/affact') left_name = 'ResNet-51' right_name = 'AFFACT' labels, _, _ = generate_test_dataset(config_l) labels = labels.columns.tolist() accuracy_df_l = pd.read_csv('{}/evaluation_result.csv'.format( config_l.experiments_dir), index_col=0) accuracy_df_r = pd.read_csv('{}/evaluation_result.csv'.format( config_r.experiments_dir), index_col=0) figures = generate_relative_improvement_chart(labels, accuracy_df_l, accuracy_df_r, left_name, right_name) for i, test_set in enumerate(accuracy_df_l.columns): figures[i].show() figures[i].write_image( '{}/eval_{}_{}_{}_relative_improvement.png'.format( config_l.experiments_dir, left_name, right_name, test_set),
FastAPI Demo Database setup ''' # Standard Imports # PyPi Imports from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import sessionmaker # Local Imports from utils.config_utils import get_config ############################################################################### CONFIG = get_config('database.cfg') DB_CONFIG = CONFIG['database'] DB_URL_MASK = 'postgresql+psycopg2://{user}:{pw}@{url}/{db}' DB_URL = DB_URL_MASK.format(user=DB_CONFIG['POSTGRES_USER'], pw=DB_CONFIG['POSTGRES_PW'], url=DB_CONFIG['POSTGRES_URL'], db=DB_CONFIG['POSTGRES_DB']) SQLALCHEMY_DATABASE_URL = DB_URL ############################################################################### engine = create_engine(SQLALCHEMY_DATABASE_URL) #pylint: disable=invalid-name session_local = sessionmaker(autocommit=False, autoflush=False, bind=engine) #pylint: disable=invalid-name Base = declarative_base() #pylint: disable=invalid-name
from sklearn import metrics from data_loader.gnn_data_generator import load_data from models.text_gnn import TextGNN from utils import csv_utils from utils.config_utils import get_config def evaluate_model(args): tf.set_random_seed(19) tf_config = tf.ConfigProto(allow_soft_placement=True) tf_config.gpu_options.allow_growth = True with tf.Session(config=tf_config) as sess: label_dict = csv_utils.read(args['dataset']['path'] + '/labels.csv') data_generator = load_data(args['dataset']['path'], args['dataset']['dataset_name']) model = TextGNN(sess=sess, data_generator=data_generator, **data_generator, **args['dataset'], **args['model'], **args) result, labels = model.test() print('评估') print(metrics.classification_report(labels, result, target_names=label_dict)) print('混淆矩阵') print(metrics.confusion_matrix(labels, result)) if __name__ == '__main__': # config = get_config('gnn/aclImdb') # config = get_config('gnn/cnews') config = get_config('gnn/cnews_voc') config['tag'] = 'base' evaluate_model(config)
# yaml_utils.write(args['model']['checkpoint_dir'] + '/' + args['dataset']['dataset_name'] + '/' + # args['model']['name'] + '/' + args['tag'] + '/' + 'best_result.yaml', result) print('评估') print( metrics.classification_report( labels, result, target_names=eval_data_generator.get_labels())) print('混淆矩阵') cm = metrics.confusion_matrix(labels, result) print(cm) if __name__ == '__main__': # config = get_config('adversarial/aclImdb_rnn') # config = get_config('adversarial/aclImdb_cnn') # config = get_config('adversarial/cnews_rnn') # config = get_config('adversarial/cnews_cnn') # config = get_config('adversarial/cnews_voc_cnn') # config = get_config('adversarial/cnews_voc_rnn') # config = get_config('cnn/aclImdb') # config = get_config('cnn/cnews') # config = get_config('cnn/cnews_voc') config = get_config('rnn/aclImdb') # config = get_config('rnn/cnews') # config = get_config('rnn/cnews_voc') # config['tag'] = 'base' # config['tag'] = 'embedding_untrainable' config['tag'] = 'lstm' config['model']['rnn_type'] = 'lstm' evaluate_model(config)
seq_length=args['dataset']['seq_length']) model_class = get_model_class_by_name(args['model']['name']) model = model_class(sess=sess, train_generator=train_data_generator, eval_generator=eval_data_generator, embedding=embedding, **dataset_info, **args['dataset'], **args['model'], **args) model.train() if __name__ == '__main__': os.environ['CUDA_VISIBLE_DEVICES'] = '2' config = get_config('adversarial/aclImdb_rnn') # config = get_config('adversarial/aclImdb_cnn') # config = get_config('adversarial/cnews_rnn') # config = get_config('adversarial/cnews_cnn') # config = get_config('adversarial/cnews_voc_cnn') # config = get_config('adversarial/cnews_voc_rnn') # config = get_config('cnn/aclImdb') # config = get_config('cnn/cnews') # config = get_config('cnn/cnews_voc') # config = get_config('rnn/aclImdb') # config = get_config('rnn/cnews') # config = get_config('rnn/cnews_voc') config['tag'] = 'lstm_clear_string' # config['tag'] = 'lstm_without_embedding' config['model']['rnn_type'] = 'lstm'
import tensorflow as tf from model import SkipGram from utils.config_utils import get_config def train(args): tf.set_random_seed(19) tf_config = tf.ConfigProto(allow_soft_placement=True) tf_config.gpu_options.allow_growth = True with tf.Session(config=tf_config) as sess: model = SkipGram(sess=sess, **args['dataset'], **args['model'], **args) model.train() if __name__ == '__main__': config = get_config('english') config['tag'] = 'base' train(config)