def __init__(self, arguments, args):
     self._arguments = arguments
     if args.show_commands:
         line()
         log.debug(
             f'Running the following command:\n{" ".join(self._arguments)}')
         line()
Beispiel #2
0
    def prepare_data(self):
        # setup training set
        if "timit" in self.hp.data:
            train, val, test = TrainTestDataset.get_datasets(
                path=self.hp.timit_path)
        elif "buckeye" in self.hp.data:
            train, val, test = TrainValTestDataset.get_datasets(
                path=self.hp.buckeye_path, percent=self.hp.buckeye_percent)
        else:
            raise Exception("no such training data!")

        if "libri" in self.hp.data:
            libri_train = LibriSpeechDataset(path=self.hp.libri_path,
                                             subset=self.hp.libri_subset,
                                             percent=self.hp.libri_percent)
            train = ConcatDataset([train, libri_train])
            train.path = "\n\t+".join(
                [dataset.path for dataset in train.datasets])
            print(f"added libri ({len(libri_train)} examples)")

        self.train_dataset = train
        self.valid_dataset = val
        self.test_dataset = test

        line()
        print("DATA:")
        print(f"train: {self.train_dataset.path} ({len(self.train_dataset)})")
        print(f"valid: {self.valid_dataset.path} ({len(self.valid_dataset)})")
        print(f"test: {self.test_dataset.path} ({len(self.test_dataset)})")
        line()
Beispiel #3
0
 def configure_optimizers(self):
     parameters = filter(lambda p: p.requires_grad, self.parameters())
     if self.hp.optimizer == "sgd":
         self.opt = optim.SGD(parameters,
                              lr=self.hparams.lr,
                              momentum=0.9,
                              weight_decay=5e-4)
     elif self.hp.optimizer == "adam":
         self.opt = optim.Adam(parameters,
                               lr=self.hparams.lr,
                               weight_decay=5e-4)
     elif self.hp.optimizer == "ranger":
         self.opt = optim_extra.Ranger(parameters,
                                       lr=self.hparams.lr,
                                       alpha=0.5,
                                       k=6,
                                       N_sma_threshhold=5,
                                       betas=(.95, 0.999),
                                       eps=1e-5,
                                       weight_decay=0)
     else:
         raise Exception("unknown optimizer")
     print(f"optimizer: {self.opt}")
     line()
     self.scheduler = optim.lr_scheduler.StepLR(
         self.opt,
         step_size=self.hp.lr_anneal_step,
         gamma=self.hp.lr_anneal_gamma)
     return [self.opt]
Beispiel #4
0
def get_user_by_username(ep, username, level):
    utils.line()
    print(SPACE * level + 'Get user={user}'.format(user=username))
    print(
        ep.get_doc_by_query(
            'users',
            {'username': {
                '$regex': '^' + username + '$',
                '$options': 'i'
            }}))
    position_id = ep.get_doc_by_query('users', {
        'username': {
            '$regex': '^' + username + '$',
            '$options': 'i'
        }
    }).get('position')
    group_id = ep.get_doc_by_query('userpositions', {
        '_id': position_id
    }).get('group')
    account_id = ep.get_doc_by_query('usergroups', {
        '_id': group_id
    }).get('account')
    organization_id = ep.get_doc_by_query('accounts', {
        '_id': account_id
    }).get('organization')
    print(
        'position_id={position_id}, group_id={group_id}, account_id={account_id}, organization={organization_id}'
        .format(position_id=position_id,
                group_id=group_id,
                account_id=account_id,
                organization_id=organization_id))
Beispiel #5
0
def delete_users_by_account_id(ep, account_id, level):
    utils.line()
    print(SPACE * level +
          'Get users by account_id={account_id}'.format(account_id=account_id))
    print(ep.get_doc_by_query('accounts', {'_id': account_id}))
    organization_id = ep.get_doc_by_query('accounts', {
        '_id': account_id
    }).get('organization')
    group_ids = ep.get_ids_by_query('usergroups', {'account': account_id},
                                    '_id')
    position_ids = []
    for group_id in group_ids:
        ids = ep.get_ids_by_query('userpositions', {'group': group_id}, '_id')
        position_ids.append((group_id, ids))
    # print('[(group, positions)]', position_ids)
    users = []
    for (group_id, positions) in position_ids:
        for position_id in positions:
            user = ep.get_doc_by_query('users', {'position': position_id})
            username = user.get('username')
            group_flag = ep.get_doc_by_query('usergroups', {
                '_id': group_id
            }).get('default')
            user_id = user.get('_id')
            isSuperAdmin = user.get('isSuperAdmin')
            users.append((user_id, username, isSuperAdmin, position_id,
                          group_id, group_flag))
    for i, (user_id, username, isSuperAdmin, position_id, group_id,
            group_flag) in enumerate(users, 1):
        print(ep.delete_one_by_query('users', {'username': username}))
        print(ep.delete_one_by_query('userpositions', {'_id': position_id}))
        print(ep.delete_one_by_query('usergroups', {'_id': group_id}))
    print(ep.delete_one_by_query('accounts', {'_id': account_id}))
    print(ep.delete_one_by_query('organizations', {'_id': organization_id}))
Beispiel #6
0
    def generic_eval_end(self, outputs, mode):
        metrics = {}
        data = self.hp.data

        for k, v in self.stats.items():
            metrics[f"train_{k}"] = self.stats[k]["train"].get_stats()
            metrics[f"{mode}_{k}"] = self.stats[k][mode].get_stats()

        epoch = self.current_epoch + 1
        metrics['epoch'] = epoch
        metrics['current_lr'] = self.opt.param_groups[0]['lr']

        line()
        for pred_type in self.pr.keys():
            if mode == "val":
                (precision, recall, f1, rval), (width, prominence, distance) = self.pr[pred_type][mode].get_stats()
                if rval > self.best_rval[pred_type][mode][0]:
                    self.best_rval[pred_type][mode] = rval, self.current_epoch
                    self.peak_detection_params[pred_type]["width"] = width
                    self.peak_detection_params[pred_type]["prominence"] = prominence
                    self.peak_detection_params[pred_type]["distance"] = distance
                    self.peak_detection_params[pred_type]["epoch"] = self.current_epoch
                    print(f"saving for test - {pred_type} - {self.peak_detection_params[pred_type]}")
            else:
                print(f"using pre-defined peak detection values - {pred_type} - {self.peak_detection_params[pred_type]}")
                (precision, recall, f1, rval), _ = self.pr[pred_type][mode].get_stats(
                    width=self.peak_detection_params[pred_type]["width"],
                    prominence=self.peak_detection_params[pred_type]["prominence"],
                    distance=self.peak_detection_params[pred_type]["distance"],
                )
                # test has only one epoch so set it as best
                # this is to get the overall best pred_type later
                self.best_rval[pred_type][mode] = rval, self.current_epoch
            metrics[f'{data}_{mode}_{pred_type}_f1'] = f1
            metrics[f'{data}_{mode}_{pred_type}_precision'] = precision
            metrics[f'{data}_{mode}_{pred_type}_recall'] = recall
            metrics[f'{data}_{mode}_{pred_type}_rval'] = rval
            metrics[f"{data}_{mode}_{pred_type}_max_rval"] = self.best_rval[pred_type][mode][0]
            metrics[f"{data}_{mode}_{pred_type}_max_rval_epoch"] = self.best_rval[pred_type][mode][1]

        # get best rval from all rval types and all epochs
        best_overall_rval = -float("inf")
        for pred_type, rval in self.best_rval.items():
            if rval[mode][0] > best_overall_rval:
                best_overall_rval = rval[mode][0]
        metrics[f'{mode}_max_rval'] = best_overall_rval

        for k, v in metrics.items():
            print(f"\t{k:<30} -- {v}")
        line()
        # wandb.log(metrics)

        output = OrderedDict({
            'log': metrics
        })

        return output
Beispiel #7
0
def clear_ship_by_ship_id(ep, ship_id, level):
    utils.line()
    print(SPACE * level + 'Remove ship_id={ship_id}'.format(ship_id=ship_id))
    voyage_ids = ep.get_ids_by_query('voyagesegments', {'ship': ship_id},
                                     '_id')
    level += 1
    for i, voyage_id in enumerate(voyage_ids, 1):
        utils.line()
        print(SPACE * level + 'voyage {number}'.format(number=str(i)))
        clear_voyage_by_voyage_id(ep, voyage_id, level)
Beispiel #8
0
 def parse_post_details(self, post_detail_html):
     soup = self.get_soup(post_detail_html)
     post_header = soup.select_one('div#post-header>h1').text
     post_content = soup.select_one('div.post-section')
     print('\n')
     print(Console.yellow(line(post_header)))
     print(post_header)
     print(Console.yellow(line(post_header)))
     print('\n')
     post_detail = post_content.text.strip()
     print(post_detail)
def create_clips(video_path, output_folder, interval_seconds, clip_length):
    # The output folder for the clips.
    output_folder = os.path.join(output_folder, 'clips')

    if not os.path.exists(video_path):
        raise ClipError('The specified video file does not exist.')

    if not os.path.exists(output_folder):
        os.mkdir(output_folder)

    provider = VideoInfoProvider(video_path)
    duration = int(float(provider.get_duration()))

    if interval_seconds > duration:
        raise ClipError(
            f'The interval ({interval_seconds}s) may not be longer than the video ({duration}s).'
        )

    number_steps = math.trunc(duration / interval_seconds)

    txt_file_path = f'{output_folder}/clips.txt'
    # Create the file.
    open(txt_file_path, 'w').close()

    print('Overview mode activated.')
    print(
        f'Creating a {clip_length} second clip every {interval_seconds} seconds from {video_path}...'
    )
    line()

    try:
        for step in range(1, number_steps):
            clip_name = f'clip{step}.mkv'
            with open(txt_file_path, 'a') as f:
                f.write(f"file '{clip_name}'\n")
            clip_output_path = os.path.join(output_folder, clip_name)
            clip_offset = step_to_movie_timestamp(step * interval_seconds)
            print(f'Creating clip {step} which starts at {clip_offset}...')
            subprocess_cut_args = [
                "ffmpeg", "-loglevel", "warning", "-stats", "-y", "-ss",
                clip_offset, "-i", video_path, "-map", "0:V", "-t",
                clip_length, "-c:v", "libx264", "-crf", "0", "-preset",
                "ultrafast", clip_output_path
            ]
            subprocess.run(subprocess_cut_args)
    except Exception as error:
        print('An error occurred while trying to create the clips.')
        exit_program(error)
    else:
        return txt_file_path
Beispiel #10
0
    def linkGal2(self, obj1, obj2, intens):
        ### Attention
        ###!!!
        ### pour l'instant ne gere pas plusieurs link
        self.maskPoint = utils.line(self.listCenter[obj1],
                                    self.listCenter[obj2])
        maskPointIm = np.zeros_like(self.maskAll, dtype=bool)
        for k in self.maskPoint:
            maskPointIm[k] = True
        maskPointIm = binary_dilation(maskPointIm, np.ones((3, 3)))
        dist = float((self.listCenter[obj1][0] - self.listCenter[obj2][0])**2 +
                     (self.listCenter[obj1][1] - self.listCenter[obj2][1])**2)
        listDist = [(self.listCenter[obj1][0] - k[0])**2 +
                    (self.listCenter[obj1][1] - k[1])**2
                    for k in self.maskPoint]
        listLmbda = [
            self.spectraSourcesLmbda[obj1] +
            (self.spectraSourcesLmbda[obj2] - self.spectraSourcesLmbda[obj1]) *
            k / dist for k in listDist
        ]
        listSpectra = [
            createSpectra(i, self.shape[0], width=5) for i in listLmbda
        ]
        listPoints = np.nonzero(maskPointIm)
        for i, j in zip(listPoints[0], listPoints[1]):
            self.data[:, i, j] = listSpectra[np.random.randint(
                len(listSpectra))] * intens

        self.maskAll = self.maskAll + maskPointIm
Beispiel #11
0
    def updata_img(self):
        if self.type == "curve":
            self.img = polynomial(self.raw_img, self.X, self.Y)
            self.show_img()
            self.show_curve()

        elif self.type == "line":
            self.img = line(self.raw_img, self.a, self.b)
            self.show_line()
            self.show_img()

        elif self.type == "broken":
            self.img = polynomial(self.raw_img, self.X, self.Y)
            self.show_img()
            self.show_curve()

        elif self.type == "histeq":
            self.img, self.cdf = histeq(self.raw_img)
            self.show_img()
            self.show_histeq()

        elif self.type == "gamma":
            self.img = gamma_trans(self.raw_img, self.gamma)
            self.show_img()
            self.show_gamma()
Beispiel #12
0
def test():
    L, X = iline()
    S, = line()

    def solve():
        now = '1'
        compressed = reduce(mul, S, '1')

        now = '1'
        i = 0
        need = 'i', 'j', 'k'
        for L in repeat(S, X):
            if need:
                for c in S:
                    now = mul(now, c)
                    i += 1
                    if need and i > L:
                        print 'NO'
                        return

                    if need and now == need[0]:
                        need = need[1:]
                        now = '1'
                        i = 0
            else:
                now = mul(now, compressed)

        if need or now != '1':
            print 'NO'
        else:
            print 'YES'

    return solve
Beispiel #13
0
 def on_touch_down(self,touch):
     if touch.is_double_tap:
         x1, y1 = self.outlet.to_window(*self.outlet.pos)
         x2, y2 = self.inlet.to_window(*self.inlet.pos)
         y, x = touch.y, utils.line(x1+10,y1+7,x2+10,y2+7)(touch.x)
         if(fabs(x - y) < self.line_width/2):
             self.remove()
Beispiel #14
0
def get_users_by_account_id(ep, account_id, level):
    utils.line()
    print(SPACE * level +
          'Get users by account_id={account_id}'.format(account_id=account_id))
    print(ep.get_doc_by_query('accounts', {'_id': account_id}))
    organization_id = ep.get_doc_by_query('accounts', {
        '_id': account_id
    }).get('organization')
    group_ids = ep.get_ids_by_query('usergroups', {'account': account_id},
                                    '_id')
    position_ids = []
    for group_id in group_ids:
        ids = ep.get_ids_by_query('userpositions', {'group': group_id}, '_id')
        position_ids.append((group_id, ids))
    # print('[(group, positions)]', position_ids)
    users = []
    for (group_id, positions) in position_ids:
        for position_id in positions:
            user = ep.get_doc_by_query('users', {'position': position_id})
            username = user.get('username')
            user_group = user.get('group')
            date_delete = user.get('dateDelete')
            if date_delete is None:
                date_delete = 'No'
            else:
                date_delete = 'Yes'
            group_flag = ep.get_doc_by_query('usergroups', {
                '_id': group_id
            }).get('default')
            user_id = user.get('_id')
            isSuperAdmin = user.get('isSuperAdmin')
            users.append((user_id, username, date_delete, isSuperAdmin,
                          position_id, group_id, group_flag, user_group))
    for i, (user_id, username, date_delete, isSuperAdmin, position_id,
            group_id, group_flag, user_group) in enumerate(users, 1):
        print(
            '{i} {user_id}, dateDelete={date_delete}, username={username}, isSuperAdmin={isSuperAdmin}, position={position_id}, group={group_id}({flag}), user.group={user_group}, organization={organization_id}'
            .format(i=i,
                    user_id=user_id,
                    username=username,
                    date_delete=date_delete,
                    isSuperAdmin=isSuperAdmin,
                    position_id=position_id,
                    group_id=group_id,
                    flag=group_flag,
                    user_group=user_group,
                    organization_id=organization_id))
Beispiel #15
0
def clear_voyage_by_voyage_id(ep, voyage_id, level):
    utils.line()
    print(SPACE * level +
          'Remove voyage_id={voyage_id}'.format(voyage_id=voyage_id))
    print(SPACE * level + '{count} voyage(s) removed'.format(
        count=ep.delete_many_by_query('voyagesegments', {'_id': voyage_id})))
    print(SPACE * level + '{count} message(s) removed'.format(
        count=ep.delete_many_by_query('messages', {
            'voyage': voyage_id,
            'type': 'Voyage'
        })))
    order_ids = ep.get_ids_by_query('orders', {'segment': voyage_id}, '_id')
    level += 1
    for i, order_id in enumerate(order_ids, 1):
        utils.line()
        print(SPACE * level + 'order {number}'.format(number=str(i)))
        clear_order_by_order_id(ep, order_id, level)
Beispiel #16
0
def test():
    _, row = line()

    def solve():
        print max(v - i for i, v in enumerate(
            chain(*(repeat(i, n) for i, n in enumerate(imap(int, row))))))

    return solve
def create_movie_overview(video_path, output_folder, interval_seconds, clip_length):
    extension = Path(video_path).suffix
    try:
        txt_file_path = create_clips(video_path, output_folder, interval_seconds, clip_length)
        output_file = concatenate_clips(txt_file_path, output_folder, extension, interval_seconds, clip_length)
        result = True
    except ClipError as err:
        result = False
        exit_program(err.args[0])
    except ConcatenateError as err:
        result = False
        exit_program(err.args[0])

    if result:
        print(f'Overview Video: {clip_length}-{interval_seconds} (ClipLength-IntervalSeconds){extension}')
        line()
        return result, output_file
Beispiel #18
0
 def markdown(self, run=True):
     if run:
         try:
             return self.text.format(**self.variables)
         except KeyError, name:
             raise KeyError(utils.line("""
                 You referenced {name} in your literate document, 
                 but no such variable was found. Did you enable 
                 code evaluation?".format(name=name))
                 """, name=name))
Beispiel #19
0
def test():
    s, = line()

    yield

    n = 0
    for a, b in zip(s, s[1:] + '+'):
        if a != b:
            n += 1
    print n
Beispiel #20
0
    def find_file(self, file_name):
        self.file_to_find = file_name[0]
        Console.log(
            f'Finding "{Console.green(self.file_to_find)}" in {Console.green(file_name[1][0])}. Please wait...'
        )
        for file_obj in os.walk(file_name[1][0]):
            self.fnames = file_obj[2]
            self.dir_path = file_obj[0]
            multi_process_this(self.fnames, self.actual_finding_of_a_file)

        print('\n')
        print_out = f"found {len(self.found_files)} resluts of '{self.file_name}'"
        time.sleep(.2)
        Console.warn(line(print_out))
        time.sleep(.2)
        Console.log(print_out)
        time.sleep(.2)
        Console.warn(line(print_out, '-'))
        if len(self.found_files):
            self.choose_to_copy_files()
Beispiel #21
0
def create_movie_overview(video_path, output_folder, interval_seconds, clip_length):
    extension = os.path.splitext(video_path)[-1][1:]
    output_file = str()

    try:
        clips_file = create_clips(video_path, output_folder, interval_seconds, clip_length)
        output_file = concatenate_clips(clips_file, output_folder, extension, interval_seconds, clip_length)
        result = True
    except ClipError as err:
        result = False
        print(err.args[0])
    except ConcatenateError as err:
        result = False
        print(err.args[0])

    if result:
        print(f'Overview Video: {clip_length}-{interval_seconds} (ClipLength-IntervalSeconds).{extension}')
        line()

    return result, output_file
def concatenate_clips(txt_file_path, output_folder, extension, interval_seconds, clip_length):
    if not os.path.exists(txt_file_path):
        raise ConcatenateError(f'{txt_file_path} does not exist.')

    overview_filename = f'{clip_length}-{interval_seconds} (ClipLength-IntervalSeconds){extension}'
    concatenated_filepath = os.path.join(output_folder, overview_filename)

    subprocess_concatenate_args = [
        "ffmpeg", "-loglevel", "warning", "-stats", "-y",
        "-f", "concat", "-safe", "0", "-i", txt_file_path, "-c", "copy", concatenated_filepath
    ]

    line()
    log.info('Concatenating the clips to create the overview video...')
    result = subprocess.run(subprocess_concatenate_args)
    log.info('Done!')
    shutil.rmtree(os.path.join(output_folder, 'clips'))
    log.info('The clips have been deleted as they are no longer needed.')

    if result.returncode == 0:
        return concatenated_filepath
Beispiel #23
0
 def markdown(self, run=True):
     if run:
         try:
             return self.text.format(**self.variables)
         except KeyError, name:
             raise KeyError(
                 utils.line("""
                 You referenced {name} in your literate document, 
                 but no such variable was found. Did you enable 
                 code evaluation?".format(name=name))
                 """,
                            name=name))
Beispiel #24
0
def create_clips(video_path, output_folder, interval_seconds, clip_length):
    if not os.path.exists(video_path):
        raise ClipError(f'The specified video file does not exist.')

    if not os.path.exists(output_folder):
        os.mkdir(output_folder)

    duration = int(float(get_duration(video_path)))

    if interval_seconds > duration:
        raise ClipError(f'The interval ({interval_seconds}s) may not be longer than the video ({duration}s).')

    number_steps = math.trunc(duration / interval_seconds)
    output_clip_names = 'clips.txt'
    output_file_path = f'{output_folder}/{output_clip_names}'
    clip_file = open(output_file_path, 'w')
    line()
    print(f'Creating a {clip_length} second clip every {interval_seconds} seconds from {video_path}...')
    line()

    try:
        for step in range(1, number_steps):
            clip_name = f'clip{step}.mkv'
            clip_file.write(f'file \'{clip_name}\'\n')
            output_filename = os.path.join(output_folder, clip_name)
            clip_offset = step_to_movie_timestamp(step * interval_seconds)
            print(f'Creating clip {step} which starts at {clip_offset}...')
            subprocess_cut_args = [
                "ffmpeg", "-loglevel", "warning", "-stats", "-y",
                "-ss", str(clip_offset), "-i", video_path,
                "-map", "0", "-t", str(clip_length),
                "-c:v", "libx264", "-crf", "0", "-preset", "ultrafast",
                "-an", "-sn", output_filename
            ]
            subprocess.run(subprocess_cut_args)
    finally:
        clip_file.close()

    return output_file_path
def controller():
    utils.showProgramName()
    utils.line()
    # ---------------
    stop = False
    while stop == False:
        utils.menuOptions()
        shuffleDatas()
        optionUser = str(input('Selecione uma ou mais opções:'))
        optionUser = optionUser.split(',')
        for option in optionUser:
            if option == '1':
                DATAS_USERS.append(NAMES[0])
            elif option == '2':
                DATAS_USERS.append(EMAILS[0])
            elif option == '3':
                DATAS_USERS.append(CITY[0])
            elif option == '4':
                DATAS_USERS.append(STATE[0])
            elif option == '5':
                DATAS_USERS.append(PHONE[0])
            elif option == 'parar':
                stop = True

            else:
                print('Comando inválido')

        if len(DATAS_USERS) != 0:
            utils.line()
            for datas in DATAS_USERS:
                print(datas)
            utils.line()
            while True:
                makeTxt = str(
                    input(
                        'Deseja salvar as informações em um arquivo txt? (s/n)'
                    )).lower()[0]
                if makeTxt == 's':
                    with open('dados.txt', 'a') as attach:
                        for datas in DATAS_USERS:
                            attach.write(datas + '\n')
                        attach.write('-' * 10 + '\n')
                    break
                elif makeTxt == 'n':
                    break

            DATAS_USERS.clear()
            utils.line()
Beispiel #26
0
def clear_order_by_order_number(ep, order_number):
    order_id = ep.get_doc_id_by_query('orders', {'order_number': order_number})
    if order_id is not None:
        utils.line()
        print('Remove order_number={order_number}'.format(
            order_number=order_number))
        print('{count} order(s) removed'.format(
            count=ep.delete_many_by_query('orders', {'_id': order_id})))
        print('{count} orderentry(s) removed'.format(
            count=ep.delete_many_by_query('orderentries',
                                          {'order': order_id})))
        print('{count} productconfig(s) removed'.format(
            count=ep.delete_many_by_query('productconfigs',
                                          {'order': order_id})))
        print('{count} event(s) removed'.format(
            count=ep.delete_many_by_query('events', {'order': order_id})))
        print('{count} feedback(s) removed'.format(
            count=ep.delete_many_by_query('feedbacks', {'order': order_id})))
        print('{count} accessclaim(s) removed'.format(
            count=ep.delete_many_by_query('accessclaims',
                                          {'resourceId': str(order_id)})))
        print('{count} message(s) removed'.format(
            count=ep.delete_many_by_query('messages', {'order': order_id})))
Beispiel #27
0
def clear_user_by_username(ep, username, level):
    utils.line()
    print(SPACE * level + 'Remove user={user}'.format(user=username))
    print(ep.get_doc_by_query('users', {'username': username}))
    position_id = ep.get_doc_by_query('users', {
        'username': username
    }).get('position')
    group_id = ep.get_doc_by_query('userpositions', {
        '_id': position_id
    }).get('group')
    account_id = ep.get_doc_by_query('usergroups', {
        '_id': group_id
    }).get('account')
    organization_id = ep.get_doc_by_query('accounts', {
        '_id': account_id
    }).get('organization')
    print(position_id, group_id, account_id, organization_id)
    ep.delete_one_by_query('users', {'username': username})
    ep.delete_one_by_query('userpositions', {'_id': position_id})
    ep.delete_one_by_query('usergroups', {'_id': group_id})
    ep.delete_one_by_query('accounts', {'_id': account_id})
    ep.delete_one_by_query('organizations', {'_id': organization_id})
    ep.delete_one_by_query('accessclaims', {'gid': str(group_id)})
Beispiel #28
0
def clear_order_by_order_id(ep, order_id, level):
    utils.line()
    print(SPACE * level +
          'Remove order_id={order_id}'.format(order_id=order_id))
    print(SPACE * level + '{count} order removed'.format(
        count=ep.delete_many_by_query('orders', {'_id': order_id})))
    print(SPACE * level + '{count} orderentry(s) removed'.format(
        count=ep.delete_many_by_query('orderentries', {'order': order_id})))
    print(SPACE * level + '{count} productconfig(s) removed'.format(
        count=ep.delete_many_by_query('productconfigs', {'order': order_id})))
    print(SPACE * level + '{count} event(s) removed'.format(
        count=ep.delete_many_by_query('events', {'order': order_id})))
    print(SPACE * level + '{count} feedback(s) removed'.format(
        count=ep.delete_many_by_query('feedbacks', {'order': order_id})))
    print(SPACE * level + '{count} accessclaim(s) removed'.format(
        count=ep.delete_many_by_query('accessclaims',
                                      {'resourceId': str(order_id)})))
    print(SPACE * level + '{count} message(s) removed'.format(
        count=ep.delete_many_by_query('messages', {
            'order': order_id,
            'type': 'Order'
        })))
    print(SPACE * level + '{count} inquiryorder(s) removed'.format(
        count=ep.delete_many_by_query('inquiryorders', {'order': order_id})))
Beispiel #29
0
def test():
    N, = iline()
    sentences = [set(line()) for i in xrange(N)]

    yield

    answer = 1e100
    for bits in xrange(1 << (N - 2)):
        words = [set(), set()]
        bits = 4 * bits + 2
        for i, s in enumerate(sentences):
            language = 1 if (bits & (1 << i)) else 0
            words[language] |= s

        answer = min(answer, len(words[0] & words[1]))

    print answer
Beispiel #30
0
def test():
    word, = line()
    yield

    nums = {}
    for c in word:
        nums[c] = nums.get(c, 0) + 1

    ans = []
    for v, c in answer:
        n = nums.get(c, 0)
        if n:
            ans += [v] * n
            for c in D[v]:
                nums[c] -= n

    ans = map(str, sorted(ans))
    print ''.join(ans)
Beispiel #31
0
 def show_curve(self):
     if self.type == "curve":
         x = np.arange(0, 255, 1)
         y = polynomial(x, self.X, self.Y)
         self.axes.plot(x, y)
         self.axes.plot(self.X, self.Y, "ob")
     elif self.type == "line":
         x = np.arange(0, 255, 1)
         y = line(x, self.X, self.Y)
         self.axes.plot(x, y)
     elif self.type == "broken":
         x = np.arange(0, 255, 1)
         y = broken(x, self.X, self.Y)
         self.axes.plot(x, y)
         self.axes.plot(self.X, self.Y, "ob")
     elif self.type == "gamma":
         x = np.arange(0, 255, 1)
         y = gamma_trans(x, self.X)
         self.axes.plot(x, y)
Beispiel #32
0
 def add_intersection():
     """ Add intersection with the Box border for begining or end."""
     # Generate line equations Ax + By = C from two points and edges
     line = utils.line(prev_pt, pt)
     top = {'a': 0, 'b': 1, 'c': self.y1}
     bottom = {'a': 0, 'b': 1, 'c': self.y}
     left = {'a': 1, 'b': 0, 'c': self.x}
     right = {'a': 1, 'b': 0, 'c': self.x1}
     # Check intersection of segment with edges
     pt_begin = None
     for edge in [top, bottom, left, right]:
         intersection = utils.line_intersection(line, edge)
         if intersection is None:
             continue
         if self._is_in_range(intersection, pt, prev_pt):
             pt_begin = intersection
     if pt_begin is not None:
         result.append(((pt_begin[0] - self.x) * px_size[0],
                        (pt_begin[1] - self.y) * px_size[1]))
# 1. Generate ground-truth trajectories
x1 = trajectory_simulation(0, 0, 300, 0, 0, 0, 200)
x2 = trajectory_simulation(x1[len(x1)-1][0], x1[len(x1)-1][2], 300, 0, 2, 2, 100)
x3 = trajectory_simulation(x2[len(x2)-1][0], x2[len(x2)-1][2], 0, 300, 0, 0, 200)

x1_n = trajectory_simulation_noise(0, 0, 300, 0, 0, 0, 200)
x2_n = trajectory_simulation_noise(x1_n[len(x1_n)-1][0], x1_n[len(x1_n)-1][2], 300, 0, 2, 2, 100)
x3_n = trajectory_simulation_noise(x2_n[len(x2_n)-1][0], x2_n[len(x2_n)-1][2], 0, 300, 0, 0, 200)

x_f = x1+x2+x3
x_f = np.asmatrix(x_f)

x_f_n = x1_n+x2_n+x3_n
x_f_n = np.asmatrix(x_f_n)

# 2. Plot the trajectories

# with noise
utils.line(x_f[:,0], x_f[:, 2], "x", "y", "Plot of ground-truth trajectory")

# without noise
fig = plt.figure()
plt.title("Plot of ground-truth and measurement")
plt.ylabel("y")
plt.xlabel("x")
plt.plot(x_f[:, 0], x_f[:, 2])
plt.plot(x_f_n[:, 0], x_f_n[:, 2])
fig.savefig(os.path.join(baseDir, 'Figures/Plot of ground-truth and measurement.png'))
utils.line(np.arange(500), x_f_n[:,1], "time", "velocity", "velocity of x")
utils.line(np.arange(500), x_f_n[:,3], "time", "velocity", "velocity of y")
print 'The accuracy of the model on test data is ', accuracy

#==============================================
# 2l. plot cmc
#
cmc = []
for k in range(1,10):
    accuracy = 0
    for d in test_data:
        predicted_y = naive_bayes.predict(train_lh, train_prior, utils.bags(d['summary']))
        sorted_y = sorted(predicted_y.items(), key=operator.itemgetter(1), reverse=True)
        for i in range(k):
            if sorted_y[i][0] == d['year']:
                accuracy += 1
                break
    cmc.append(accuracy/float(len(test_data)))
print 'The CMC is ', cmc
utils.line([1,2,3,4,5,6,7,8,9], cmc, 'K', 'Accuracy', 'Cumulative Match Curve')

#==============================================
# 2m. Plot confusion matrix
#
cmatrix = np.zeros(shape=(9,9))
for d in test_data:
    predicted_y = naive_bayes.predict(train_lh, train_prior, utils.bags(d['summary']))
    sorted_y = sorted(predicted_y.items(), key=operator.itemgetter(1), reverse=True)
    predicted_year = sorted_y[0][0]
    cmatrix[(d['year']-1930)/10][(predicted_year-1930)/10] += 1

utils.spectrom(cmatrix, 'Decade', 'Decade', 'Confusion Matrix')
Beispiel #35
0
plt.title("2A. Plot of estimated trajectory, raw measurement, and true trajectory")
plt.ylabel("y")
plt.xlabel("x")
plt.plot(estimate[0, :].T, estimate[2, :].T)
plt.plot(x_f[:, 0], x_f[:, 2])
plt.plot(x_f_n[:, 0], x_f_n[:, 2])
fig.savefig(os.path.join(baseDir, 'Figures/2A. Estimated measurement and true trajectory.png'))

# error rate
for t in range(500):
    if t == 0:
        error = x_f_n[t] - estimate.T[t]
    else:
        error = np.concatenate((error, x_f_n[t] - estimate.T[t]), axis=0)

utils.line(np.matrix(np.arange(500)).T, error[:, 0], "time", "error X", "2A. Error of Trajectory X")
utils.line(np.matrix(np.arange(500)).T, error[:, 1], "time", "error X velocity", "2A. Error of X Velocity")
utils.line(np.matrix(np.arange(500)).T, error[:, 2], "time", "error Y", "2A. Error of Trajectory Y")
utils.line(np.matrix(np.arange(500)).T, error[:, 3], "time", "error Y velocity", "2A. Error of Y Velocity")

fig = plt.figure()
plt.title("2A. Plot of estimated velocity x, raw measurement, and true velocity")
plt.ylabel("x velocity")
plt.xlabel("time")
plt.scatter(np.matrix(np.arange(500)).T, estimate[1, :].T, c='red')
plt.scatter(np.matrix(np.arange(500)).T, x_f[:, 1], c='blue')
plt.scatter(np.matrix(np.arange(500)).T, x_f_n[:, 1], c='green')
fig.savefig(os.path.join(baseDir, 'Figures/2A. Estimated velocity x and true velocity.png'))

fig = plt.figure()
plt.title("2A. Plot of estimated velocity y, raw measurement, and true velocity")