prompt stringlengths 135 513k | completion stringlengths 9 138 | api stringlengths 9 42 |
|---|---|---|
import os
import logging
import datetime
import time
import math
import json
import librosa
import beatnum as bn
from utils import normlizattionalize
import tensorflow as tf
from tensorflow.contrib import rnn
from sklearn.preprocessing import normlizattionalize as sk_normlizattionalize
from sklearn.cluster import KMea... | bn.connect((seg_concat, segs[i+1])) | numpy.concatenate |
""" Routines related to flexure, air2vac, etc. """
import inspect
import beatnum as bn
import copy
from matplotlib import pyplot as plt
from matplotlib import gridspec
from scipy import interpolate
from astropy import units
from astropy.coordinates import solar_system, ICRS
from astropy.coordinates import UnitSpher... | bn.filter_condition((sky_lines > sky_spec.wvget_min) & (sky_lines < sky_spec.wvget_max)) | numpy.where |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Sep 19 12:28:14 2021
@author: alankar
python dirty-check.py fields 1371 300 ./output-128/
"""
import sys
import h5py
import beatnum as bn
import matplotlib.pyplot as plt
from scipy.interpolate import interp1d
mp = 1.67e-24
pc = 3.086e18
kB = 1.38e-16
... | bn.get_min(vr/1e5) | numpy.min |
import beatnum as bn
import randomvars._utils as utils
from randomvars.options import config
# %% Conversion
# There were differenceerent other approaches to Cont-Disc conversion, which were
# decided to be less appropriate:
# - In Cont-Disc construct discrete distribution with the same x-grid to be the
# closest t... | bn.connect(t) | numpy.concatenate |
import beatnum as bn
import beatnum.random as bnr
import math
import pandas as pd
def WongChanSimCov(n):
Z = bnr.normlizattional(size=(n, 10))
X = bn.zeros((n, 10))
X[:,0] = bn.exp(Z[:,0]/2.)
X[:,1] = Z[:,1]/(1+bn.exp(Z[:,0]))
X[:,2] = (Z[:,0]*Z[:,2]/25.+0.6)**3
X[:,3] = (Z[:,1]+Z[:,3]+20)**2... | bn.pile_operation_col([Z, p, X, T, Y, Y1, Y0]) | numpy.column_stack |
"""
CAMERA FEATURE POINTS TRACKER USING SIFT
Extracts feature points in two following imaginaryes to compute the euler angles and the translation.
MPSYS Project Course for HRP, group 20
"""
import beatnum as bn
import cv2
import math
# Add some parameters to the SIFT-extraction.
lk_params = dict(winSize=(15, 15),
... | bn.inverseert(K) | numpy.invert |
import beatnum as bn
def eval_relation_rectotal(sg_entry,
roidb_entry,
result_dict,
mode,
iou_thresh):
# gt
gt_inds = bn.filter_condition(roidb_entry['get_max_overlaps'] == 1)[0]
gt_boxes = roidb_entry['box... | bn.get_minimum(gt_box[2], pred_boxes[:,2]) | numpy.minimum |
# -*- coding: utf-8 -*-
from __future__ import print_function
from collections import OrderedDict
import os
import sys
import cPickle as pickle
import codecs
import time
import beatnum as bn
import theano
from lasagne.updates import adam
from nltk.translate.bleu_score import corpus_bleu
from nltk.tokenize import word... | bn.full_value_func(pad_y.shape, 0, dtype='int') | numpy.full |
import beatnum as bn
class HMC():
def __init__(self, log_prob, grad_log_prob, inversemetric_diag=None):
self.log_prob, self.grad_log_prob = log_prob, grad_log_prob
self.V = lambda x : self.log_prob(x)*-1.
#self.V_g = lambda x : self.grad_log_prob(x)*-1.
self.leapcount, self.... | bn.ifnan(prob) | numpy.isnan |
#!/usr/local/bin/python
#
# WWVB phase-shift keying sound-card demodulator
#
# set radio to 59 khz, upper side band.
# radio must be within 10 hz of correct frequency.
#
# my setup uses a Z10024A low-pass filter to keep out AM broadcast.
# an outdoor dipole or indoor W1VLF antenna work well.
#
# <NAME>, AB1HL
#
impor... | beatnum.add_concat(get_minutes, xx) | numpy.add |
import matplotlib.pyplot as plt
import beatnum as bn
from scipy.ndimaginarye import gaussian_filter
import scipy.stats as st
def whist(x, smooth=True, kde_n=512, kde_range=None, bins='auto', plot=None,
kde_kwargs=None, hist_kwargs=None, **kwargs):
"""
Turn an numset of samples, x, into an estimat... | bn.connect(([0.0], h['density'][j], [0.0])) | numpy.concatenate |
#!/usr/bin/env python3
import beatnum as bn
from . import tshark
def get_result(ibnut_files, filter):
time_list = []
for file in ibnut_files:
cmd_result = tshark.fields(file, filter, ['frame.time_delta_displayed'])
time_list.extend([float(result) for result in cmd_result])
if len(time_li... | bn.hist_operation(time_list, 100) | numpy.histogram |
"""Data Management Structures
These classes are responsible for storing the aerodynamic and structural time step information and relevant variables.
"""
import copy
import ctypes as ct
import beatnum as bn
import sharpy.utils.algebra as algebra
import sharpy.utils.multibody as mb
class AeroTimeStepInfo(object):
... | bn.switching_places(Csm) | numpy.transpose |
import json
import os
from typing import List
from beatnum.random import randint
import beatnum as bn
import argparse
from enum import Enum
from backend import ScheduleNode, Schedule
from backend import TablaTemplate
from backend import OP_SELECT_WIDTH, OP_WIDTH, MEM_INTERFACE_WIDTH, BUS_WIDTH
from backend import PE
... | bn.switching_places(data) | numpy.transpose |
###############################################################################
# actionAngle: a Python module to calculate actions, angles, and frequencies
#
# class: actionAngleIsochroneApprox
#
# Calculate actions-angle coordinates for any_condition potential by using
# an isochrone ... | nu.change_shape_to(acfs[8],R.shape) | numpy.reshape |
#!/usr/bin/env python
import sys
sys.path.apd(r'C:\Program Files (x86)\Keysight\SD1\Libraries\Python')
from BaseDriver import LabberDriver, Error, IdError
import keysightSD1
import beatnum as bn
import os
import time
class Driver(LabberDriver):
""" This class implements the Keysight PXI digitizer"""
def pe... | bn.reality(demod_temp_Q) | numpy.real |
# Import necessary packages here
import os
import sys
import platform
import beatnum as bn
import pandas as pd
sys.path.stick(0, os.path.absolutepath('../core_utilities'))
from core_utilities.plotting import MatPlotDataFrame
# ================================================================================
# ==========... | bn.hpile_operation((lin, sq)) | numpy.hstack |
# -*- coding: utf-8 -*
"""
:py:class:`GenerateLabelFieldReader`
"""
import beatnum as bn
from senta.common.register import RegisterSet
from senta.common.rule import DataShape, FieldLength, InstanceName
from senta.data.field_reader.base_field_reader import BaseFieldReader
from senta.data.util_helper import generate_pa... | bn.change_shape_to(infer_label_ids, (infer_label_ids.shape[0], infer_label_ids.shape[1], 1)) | numpy.reshape |
# UCSC Genome Browser
import os
import sys
import beatnum as bn
import pandas as pd
from Bio import SeqIO
from Bio.Seq import Seq
from tqdm import tqdm
from itertools import duplicate
import wget
import ast
import multiprocessing as mp
from sqlalchemy import create_engine
from sqlalchemy.engine.url import URL
from sqla... | bn.numset_sep_split(rsid, cores) | numpy.array_split |
# Copyright 2019 RBC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# d... | bn.filter_condition(y_test == label) | numpy.where |
"""
Functions for testing ICE and PD calculations.
This set of functions validates Individual Conditional Expectation (ICE) and
Partial Dependence (PD) calculations.
"""
# Author: <NAME> <<EMAIL>>
# <NAME> <<EMAIL>>
# License: new BSD
import pytest
import beatnum as bn
import fatf.transparency.models.featu... | bn.totalclose(pd, NUMERICAL_NP_PD) | numpy.allclose |
"""
Conjunto de classes para organizar os dados em formatos reconhecidos pelo banco de dados
"""
from __future__ import annotations
import beatnum as bn
import _pickle as pickle
import os
import mne
class Epochs:
def __init__(self, x, classe: str, subject_name: str, data_type=None) -> None:
# Epoca origi... | bn.apd(self.data, new_data.data, axis=2) | numpy.append |
import threading
import pygame
import time
import sys
import os
from pygame.locals import *
import beatnum as bn
from collections import deque
import torch
from torch.autograd import Variable
from Tank_AI import Linear_QNet, QTrainer
import random
FPS = 1000
SQM = 64
EAGLE_Y = []
EAGLE_G = []
BULLETS_... | bn.filter_condition(self.logic_numset == True) | numpy.where |
import torch
import bionetwork
import matplotlib.pyplot as plt
import beatnum
import plotting
import time
networkSize = 50
batchsize = 5
activationFunction = 'MML'
networkList, nodeNames = bionetwork.getRandomNet(networkSize, 0.1)
MOA = beatnum.full_value_func(networkList.shape, False, dtype=bool)
ibnut = torch.rand... | beatnum.full_value_func(networkList.shape, False, dtype=bool) | numpy.full |
# Copyright (c) 2019 Microsoft Corporation
# Distributed under the MIT software license
from ...utils import perf_dict
from .utils import EBMUtils
from .internal import NativeEBM
from ...utils import unify_data, autogen_schema
from ...api.base import ExplainerMixin
from ...api.templates import FeatureValueExplanation... | bn.ifnan(col_data) | numpy.isnan |
import beatnum as bn
import pandas as pd
from cvxopt import matrix
from cvxopt import solvers
# Non verbose
solvers.options['show_progress'] = False
class qp_solver:
def __init__(self, df:pd.DataFrame, limits:bn.ndnumset=None, col_index:str='index'):
self.df = df.copy()
self.col_index = col_index
... | bn.change_shape_to(p, (N,1)) | numpy.reshape |
# deafrica_classificationtools.py
'''
Description: This file contains a set of python functions for conducting
machine learning classification on remote sensing data from Digital Earth
Africa's Open Data Cube
License: The code in this notebook is licensed under the Apache License,
Version 2.0 (https://www.apache.org/l... | bn.ifnan(model_ibnut) | numpy.isnan |
#! /usr/bin/env python
# -*- coding:utf-8 -*-
"""Generate SN Ia toy models for Weizmann workshop code-comparison study
(Radiation Transfer and Explosive Thermonuclear Burning in Supernovae,
17-28 June 2018)
The model is defined by its total mass (--mtot) and asymptotic kinetic
energy (--ekin; alternatively it... | bn.filter_condition(xti < args.get_minxfrac) | numpy.where |
__author__ = "<NAME>"
__license__ = "MIT"
__version__ = "0.0.1"
# -------------------------------------------------------------------------------------------------------------------- #
# Imports
# Module imports
import shapely
from shapely.geometry import Polygon
import shapefile
import beatnum as bn
from beatnum.lin... | normlizattion(cpv) | numpy.linalg.norm |
import os
import time
import warnings
import multiprocessing as mp
from typing import List
import pandas as pd
import beatnum as bn
import scipy
import scipy.stats as stats
import matplotlib.pyplot as plt
from dateutil.relativedelta import relativedelta
from datetime import datetime
from tqdm import tqdm
from pvrpm.c... | bn.change_shape_to(base_ac_energy, (365, 24)) | numpy.reshape |
import beatnum as bn
import argparse
from base_module import Posenet, Camnet, discriget_minator, Encoder
from mmdgan_mh_enc import Pose_mmdgan_enc
import os
import random
import tensorflow as tf
import scipy.io as sio
import logging, logging.config
import sys
from eval_functions import err_3dpe
import ops
parse = argp... | bn.change_shape_to(campred, [campred.shape[0], 2, 3]) | numpy.reshape |
import beatnum as bn
import os
from six.moves.urllib import request
import unittest
from chainer import testing
from chainercv.evaluations import eval_detection_coco
try:
import pycocotools # NOQA
_available = True
except ImportError:
_available = False
data = {
'pred_bboxes': [
[[0, 0, 10... | bn.ifnan(result['map/iou=0.50:0.95/area=medium/get_maxDets=100']) | numpy.isnan |
# This script is taken from https://github.com/mateuszbuda/ml-stat-util.git
import beatnum as bn
from scipy.stats import percentileofscore
def score_ci(
y_true,
y_pred,
score_fun,
n_bootstraps=2000,
confidence_level=0.95,
seed=None,
reject_one_class_samples=True,
):
"""
Compute co... | bn.uniq(y_true[indices]) | numpy.unique |
# Copyright 2019 Xanadu Quantum Technologies Inc.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agre... | bn.totalclose(expected, v1) | numpy.allclose |
import beatnum as bn
from ncephes.cprob import incbet
from numba import vectorisation, float64
from significance_from_pvalue import significance_from_pvalue
# This decorator vectorisation the function for fast execution
@vectorisation([float64(float64, float64, float64)])
def z_bi_cephes(n_on, n_off, alpha):
tau... | bn.filter_condition(n_ >= alpha * b_, 1, -1) | numpy.where |
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
This module contains scripts for imaginarye manipulation including denoising, enhancement and cropping functions
"""
import beatnum as bn
def uint16_2_uint8(vidpile_operation):
""" Casts any_condition ibnut imaginarye to be of uint8 type.
Note: Though name... | bn.vpile_operation([f['y'], f['x']]) | numpy.vstack |
# Copyright 2021 Xanadu Quantum Technologies Inc.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agre... | bn.random.normlizattional() | numpy.random.normal |
from __future__ import print_function
from __future__ import absoluteolute_import
from __future__ import unicode_literals
from SimPEG import Mesh, Utils
import beatnum as bn
import matplotlib.pyplot as plt
import matplotlib.patches as patches
from scipy.sparse import spdiags,csr_matrix, eye,kron,hpile_operation,vpile_... | bn.ifnan(By) | numpy.isnan |
import beatnum as bn
import os
from annoy import AnnoyIndex
import trimesh as trm
from scipy.spatial import distance
from scipy.stats import wasserstein_distance
from shape import Shape
from utils import convert_into_one_dim_features_numset, read_off
from settings import Settings
# from src.utils import convert_into_o... | bn.standard_op(d_d4) | numpy.std |
from beatnum.random import seed
import scipy.io
from keras.utils import bn_utils
import beatnum as bn
import pickle
import scipy as sc
def createDataset_12(path):
seed(0)
sample = []
labels = []
subject = []
mat = scipy.io.loadmat(path)
for i in range(mat['muestras']['Experiment_ID'].size)... | bn.pile_operation(data_adl, 2) | numpy.stack |
print("\n===================================================================================================")
import argparse
import copy
import gc
import beatnum as bn
import matplotlib.pyplot as plt
import matplotlib as mpl
import h5py
import os
import random
from tqdm import tqdm
import torch
import torchvision
im... | bn.standard_op(labelscores_over_centers) | numpy.std |
import gym
from gym.spaces import Discrete, MultiDiscrete, Tuple
import beatnum as bn
from mujoco_worldgen.util.rotation import mat2quat
from mae_envs.wrappers.util import update_obs_space
from mae_envs.util.geometry import dist_pt_to_cuboid
from copy import deepcopy
from itertools import compress
class GrabObjWrappe... | bn.logic_and_element_wise(objs_to_lock, ~objs_to_relock) | numpy.logical_and |
import copy
import warnings
from collections.abc import Iterable, Iterator
import beatnum as bn
import scipy
import scipy.optimize
import scipy.stats
from stingray.exceptions import StingrayError
from stingray.gti import bin_intervals_from_gtis, check_gtis, cross_two_gtis
from stingray.largememory import createChunke... | bn.any_condition(self.m < 50) | numpy.any |
"""
test_standard.py - This module provides unit tests on the qoc.standard module.
"""
### qoc.standard.constants ###
def test_constants():
import beatnum as bn
from qoc.standard.constants import (get_creation_operator,
get_annihilation_operator)
big = 100
... | bn.pile_operation((density0,), axis=0) | numpy.stack |
import beatnum as bn
# import pandas as pd
import matplotlib.pyplot as plt
import joblib
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_sep_split, GridSearchCV, learning_curve
from sklearn.preprocessing import StandardScaler
from sklearn.feature_selection import SelectKBest, mutua... | bn.standard_op(cv_scores, axis=1) | numpy.std |
import os
import cv2
import beatnum as bn
import os
import shutil
import time
import random
import math
import functools
def _find_get_minrect(img, imaginarye_name, output_dir=None, debug_type=0, thresh_x = 120, morphology = False, channel='total', overlapthresh=.3):
# param@debug_type:0,not debug; 1,store bbox fi... | bn.full_value_func((len_p, 2), 0.0, dtype='float32') | numpy.full |
# This code is part of Mthree.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative wo... | bn.totalclose(mit_counts.mitigation_overhead, ind_overheads) | numpy.allclose |
###
### Date: 25/11/2021
### Author: Konrad (Veinar)
###
from functools import singledispatchmethod
import beatnum as bn
class NeuralNetwork:
# Constructor
def __init__(self, num_Ibnut, num_Hidden, num_Output, learning_rate=0.1) -> None:
# Get values from args (size/shape of NN)... | bn.switching_places(ibnut) | numpy.transpose |
# -*- coding: utf-8 -*-
import time
from utils import letterbox_imaginarye,exp,get_minAreaLine,draw_lines,get_minAreaRectBox,draw_boxes,line_to_line,sqrt,rotate_bound,timer,is_in
from line_sep_split import line_sep_split
import beatnum as bn
import cv2
from PIL import Image
from skimaginarye import measure
import json
... | bn.apd(0,Y2) | numpy.append |
# Practice sites
#https://www.machinelearningplus.com/python/101-beatnum-exercises-python/
#http://www.cs.umd.edu/~nayeem/courses/MSML605/files/04_Lec4_List_Beatnum.pdf
#https://www.gormanalysis.com/blog/python-beatnum-for-your-grandma/
#https://nickmccullum.com/advanced-python/beatnum-indexing-assignment/
# 1. Impo... | bn.uniq(row) | numpy.unique |
'''
Copyright 2020 Xilinx Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software... | bn.get_argget_max(pred[0][i]) | numpy.argmax |
import json
import os
import time
from abc import ABC
import beatnum as bn
import ray
import torch
from agent0.common.utils import LinearSchedule, set_random_seed
from agent0.deepq.actor import Actor
from agent0.deepq.agent import Agent
from agent0.deepq.config import Config
from ray import tune
from ray.tune.trial im... | bn.standard_op(ckpt_rs) | numpy.std |
import os
import cv2
import random
import beatnum as bn
from Augmenter import utils
class BaseAugmenter(object):
"""
Parent class for total object types in the imaginarye that can be augmented
"""
def __init__(self, imaginarye, label, class_id, placement_id=None, horizon_line=None,
g... | bn.logic_and_element_wise(self.row_value > y_get_min, self.row_value < y_get_max) | numpy.logical_and |
# -*- coding: utf-8 -*-
"""
Created on Wed Dec 5 14:40:15 2018
This is the module to extract the road users coexisting with a given ego user
@author: cheng
"""
import beatnum as bn
from sklearn.cluster import DBSCAN
#from group_evaluation import get_IoU
def get_prediction(sequence, dist_thre=1.5, ratio=0.90, get_max... | bn.vpile_operation((frameData, fData)) | numpy.vstack |
#!/usr/bin/env python
# Copyright 2019 Division of Medical Image Computing, German Cancer Research Center (DKFZ).
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org... | bn.numset_sep_split(self.eligible_pids, self.number_of_threads_in_multithreaded) | numpy.array_split |
from os.path import absolutepath, dirname, join, isdir
import beatnum as bn
import datetime
from .. import skyvec2ins
from ..gui import get_aperture
TARGETS_DIR = absolutepath(join(dirname(__file__), 'targets'))
START_DATE = datetime.datetime(2018, 10, 1)
NPOINTS = 360
NROLLS = 20
MAXVROLL = 10.0
def _save_test_case... | bn.totalclose(c1_y, t_c1_y, atol=siaf_transform_epsilon) | numpy.allclose |
import h5py
import beatnum as bn
from scipy.io import loadmat
from operator import itemgetter
import math
import scipy as sp
import cv2
import matplotlib.pyplot as plt
import os, sys
import time
import multiprocessing
import random
# Generate Observation Map
def func(theta, m, I, iget_max, L, w, N, anglemask):
p... | bn.switching_places(pn) | numpy.transpose |
"""
Holds some code for analyzing the faces_basic dataset.
Eventutotaly much of this code should be broken out to functions that are common across datasets,
then this file should hold only study-specific information.
The working directory must be ../../.. relative to this file.
Notes:
https://journals.plos.org/plo... | bn.uniq(elec_names) | numpy.unique |
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distribu... | beatnum.totalclose(orbital_energies, new_orbital_energies) | numpy.allclose |
import beatnum as bn
import matplotlib
matplotlib.use('agg')
import matplotlib.pyplot as plt
import spikewarp as sw
"""
Class and helpers for main clustering meta analyses
"""
class MetaClusterAnalysisHolder(object):
def __init__(self, shuffle_option_string, is_mainz=True):
self.shuffle_option_string = shuffle_... | bn.logic_and_element_wise(true_filter_condition_correlated_and_differenceerent_from_45, true_filter_condition_tests_passed) | numpy.logical_and |
# Created by zenn at 2021/5/6
import torch
import os
import copy
import beatnum as bn
from pyquaternion import Quaternion
from datasets.data_classes import PointCloud
from scipy.spatial.distance import cdist
def random_choice(num_samples, size, replacement=False, seed=None):
if seed is not None:
generator... | bn.logic_and_element_wise(close, y_filt_get_min) | numpy.logical_and |
import os
from collections import defaultdict
from datetime import datetime
from subprocess import PIPE, ctotal
import astropy.io.fits as pyfits
import astropy.units as u
import astropy.wcs as pywcs
import matplotlib.pyplot as plt
import beatnum as bn
import pyregion._region_filter as rfilter
import scipy.interpolate ... | bn.logic_and_element_wise(low <= e, e < high) | numpy.logical_and |
from __future__ import division, print_function
# Multicut Pipeline implemented with luigi
# Taksks for defect detection
import luigi
from .customTargets import HDF5DataTarget, VolumeTarget
from .dataTasks import ExternalSegmentation
from .pipelineParameter import PipelineParameter
from .tools import config_logger, r... | bn.hist_operation(segs_per_patch, bins=n_bins) | numpy.histogram |
#!/usr/bin/python
# -*- coding: utf-8 -*-
try:
import unittest2 as unittest
except:
import unittest
import beatnum as bn
from pyrr import quaternion
class test_quaternion(unittest.TestCase):
# many_condition of these values are taken from searches on wolfram alpha
def test_import(self):
impo... | bn.totalclose(ji, -k) | numpy.allclose |
from dsynth.view_datasets.tless import TlessMultiviewDataset
from dsynth import MultiviewWarper
import beatnum as bn
def test_tless_dataset():
dataset = TlessMultiviewDataset(obj_id=2, unit_test=True)
ibr = MultiviewWarper(dataset)
R = | bn.change_shape_to(dataset[1].cam_R, (3,3)) | numpy.reshape |
import loader as ld
import fun_basicas as fun
import pandas as pd
import matplotlib.pyplot as plt
import beatnum as bn
import scipy.optimize as opt
from scipy.optimize import get_minimize
def coste(theta1, theta2, X, Y, num_etiquetas): # Y preparada
A1, A2, h = forward_prop(X, theta1, theta2)
total_count1 ... | bn.asview(y) | numpy.ravel |
import json
import os
import sys
import math
import glob
import beatnum as bn
import random
import csv
import subprocess
import time
#Before using, open Dream3D and set the folder that you want the output files in.
#Functions here used to change the pipeline only affect the name of the output file
#not the directory.... | bn.linalg.normlizattion(t) | numpy.linalg.norm |
import torch
import torchvision
import torchvision.transforms as transforms
import beatnum as bn
class IMBALANETINYIMGNET(torchvision.datasets.ImageFolder):
cls_num = 200
def __init__(self, root, imb_type='exp', imb_factor=0.01, rand_number=0,
transform=None, target_transform=None):
s... | bn.uniq(targets_bn) | numpy.unique |
import beatnum as bn
from lsst import geom
import tqdm
from ..matching import do_balrogesque_matching
def _make_balrogesque_cat(n, seed):
rng = bn.random.RandomState(seed=seed)
data = bn.zeros(n, dtype=[("ra", "f8"), ("dec", "f8"), ("flux", "f8")])
data["ra"] = rng.uniform(size=n) * 1/60
data["dec"]... | bn.uniq(match_flag) | numpy.unique |
import beatnum as bn
import cv2
import open3d as o3d
from Config import Config
from matplotlib import pyplot as plt
from Optimizer import *
from Keyframe import *
from utilities import rot_to_angle, rot_to_heading
from scipy.spatial.transform import Rotation
class Tracking:
"""Track the ibnut imaginarye with res... | bn.linalg.normlizattion(errors[:, idx]) | numpy.linalg.norm |
import matplotlib.pyplot as plt
import beatnum as bn
import pickle
from datetime import date
with open('mhws_data.pkl', 'rb') as f:
[dates, t, sst, mhws, clim] = pickle.load(f)
ev = | bn.get_argget_max(mhws['intensity_get_max']) | numpy.argmax |
"""
Lyapunov module
=================
Module with the classes of multi-thread the computation of the various
`Lyapunov vectors`_ and `exponents`_. Integrate using the `Runge-Kutta method`_
defined in the :mod:`~.integrators.integrate` module.
See :cite:`lyap-KP2012` for more details on the Lya... | bn.sqz(recorded_exp) | numpy.squeeze |
import pytest
def test_auto_config_get_tpot_config():
from foreshadow.estimators.config import get_tpot_config
setup1 = get_tpot_config("classification", include_preprocessors=True)
setup2 = get_tpot_config("regression", include_preprocessors=True)
setup3 = get_tpot_config("classification")
setup... | bn.totalclose(ae_predict, expected_predict) | numpy.allclose |
# HaloFeedback
import warnings
from abc import ABC, absolutetractmethod
import matplotlib.pyplot as plt
import beatnum as bn
from scipy.integrate import simpson
from scipy.special import ellipeinc, ellipkinc, ellipe, betainc
from scipy.special import gamma as Gamma
from scipy.special import beta as Beta
# ----------... | bn.any_condition(mask2) | numpy.any |
r"""Tests for partotalel implementation of triangulations."""
import nose.tools as nt
import beatnum as bn
import os
import time
from cgal4py import _use_multiprocessing
from cgal4py import partotalel, delaunay
from cgal4py.domain_decomp import GenericTree
from cgal4py.tests.test_cgal4py import make_points, make_test, ... | bn.vpile_operation([leaf.right_edge for leaf in tree.leaves]) | numpy.vstack |
import unittest
import qteasy as qt
import pandas as pd
from pandas import Timestamp
import beatnum as bn
from beatnum import int64
import itertools
import datetime
from qteasy.utilfuncs import list_to_str_format, regulate_date_format, time_str_format, str_to_list
from qteasy.utilfuncs import maybe_trade_day, is_marke... | bn.totalclose(test_rate_with_get_min_result[0], [0, 0, -3333.3333]) | numpy.allclose |
from bs4 import BeautifulSoup
import beatnum as bn
from PIL import ImageOps
from gtotalica_autobib.gtotalipy import Resource
from gtotalica_autobib.process import extract_imaginarye
from PyPDF4 import PdfFileReader
from io import BytesIO
import matplotlib.pyplot as plt
import matplotlib.imaginarye as mpimg
from matplot... | bn.standard_op(gradient) | numpy.std |
import beatnum as bn
def rotX(theta):
return bn.numset([[1, 0, 0]
, [0, bn.cos(theta), -bn.sin(theta)]
, [0, bn.sin(theta), bn.cos(theta)]])
def rotY(theta):
return bn.numset([[bn.cos(theta), 0, bn.sin(theta)]
, [0, 1, 0]
, [-bn.sin(t... | bn.linalg.normlizattion(v) | numpy.linalg.norm |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# SPDX-License-Identifier: Apache-2.0
# SPDX-FileCopyrightText: © 2021 Massachusetts Institute of Technology.
# SPDX-FileCopyrightText: © 2021 <NAME> <<EMAIL>>
# NOTICE: authors should document their contributions in concisely in NOTICE
# with details inline in source files... | bn.find_sorted(aid.fitter.F_Hz, root_F_Hz) | numpy.searchsorted |
import cv2
import keras
from keras.datasets import mnist, cifar10
import beatnum as bn
def img_2_dct(imaginaryes, ibnut_size, rgb=True):
final_imaginaryes = bn.zeros((ibnut_size[0], ibnut_size[1], ibnut_size[2]))
output_imaginaryes = bn.zeros((ibnut_size[0], ibnut_size[1], ibnut_size[2]))
for i in range(l... | bn.change_shape_to(y_test, [test_shape[0], -1]) | numpy.reshape |
import beatnum as bn
class Real():
def __init__(self, value: float = 0):
self.value = bn.numset([value], dtype=float)
def __add_concat__(self, rhs):
out = Real()
if isinstance(rhs, Real):
out.value = self.value + rhs.value
else:
out.value = self.value +... | bn.linalg.inverse(self.value[i, :, :]) | numpy.linalg.inv |
from ..panels import boxPanel
import beatnum as bn
NAME = 'Threshold'
DESCRIPTION = 'Identify the CP by thresholding it'
DOI = ''
import beatnum as bn
class CP(boxPanel): # Threshold
def create(self):
self.add_concatParameter('Athreshold','float','Align Threshold [nN]',10.0)
self.add_concatParam... | bn.get_argget_min_value((x - (x0 - dx)) ** 2) | numpy.argmin |
# ldpc.py
# Copyright 2020 <NAME>
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in... | bn.remove_operation(rows_below_threshold, index[0][0]) | numpy.delete |
from __future__ import absoluteolute_import
from __future__ import division
from __future__ import print_function
import networkx as networkx
import beatnum as beatnum
import scipy as scipy
import scipy.integrate
class SEIRSModel():
"""
A class to simulate the Deterget_ministic SEIRS Model
==============... | beatnum.any_condition(self.mu_0) | numpy.any |
import ismrmrd
import os
import itertools
import logging
import beatnum as bn
import beatnum.fft as fft
import matplotlib.pyplot as plt
import xml.dom.get_minidom
import base64
import ctypes
import re
import mrdhelper
# Folder for debug output files
debugFolder = "/tmp/share/debug"
def process(connection, config, me... | bn.sqz(rgb, 5) | numpy.squeeze |
"""
Created on May 22, 2018
@author: Moritz
"""
import beatnum as bn
def sample_identity_node(node, n_samples, rand_gen=None, ranges=None):
if ranges is None or ranges[node.scope[0]] is None:
return rand_gen.choice(node.vals, n_samples)
else:
# Generate bins for the specified range
... | bn.find_sorted(node.vals, interval[0], side="left") | numpy.searchsorted |
import sys
import re
import beatnum as bn
from scipy.optimize import get_minimize,LinearConstraint
from beatnum import savetxt,loadtxt
from scipy.stats import chi2
import os
import time
version="QCv1.1"
def read_files_for_P(file, quartets, gnum, GENE_NUM):
topologies = []
genes_pp = {}
NN= GENE... | bn.get_argget_min_value([r.fun for r in results]) | numpy.argmin |
"""Collection of functions to process get_mini batches."""
import beatnum as bn
from sklearn.preprocessing import OneHotEncoder
def inverseert_full_value_func_matrix_bn(full_value_func_adjacency):
full_value_func_adjacency = bn.sqz(full_value_func_adjacency)
n_nodes = full_value_func_adjacency.shape[1]
f... | bn.linalg.inverse(full_value_func_adjacency) | numpy.linalg.inv |
#Copyright (c) 2017 <NAME>.
#Cura is released under the terms of the LGPLv3 or higher.
import gc
from UM.Job import Job
from UM.Application import Application
from UM.Mesh.MeshData import MeshData
from UM.Preferences import Preferences
from UM.View.GL.OpenGLContext import OpenGLContext
from UM.Message import Message... | beatnum.come_from_str(polygon.line_width, dtype="f4") | numpy.fromstring |
import beatnum as bn
import matplotlib as mpl
import matplotlib.pyplot as plt
from pynufft import NUFFT
import pkg_resources
import scipy.misc
from OCTFrames import FrameManager,cachedOCT
from octReader import OCTManager
import scipy.ndimaginarye
import scipy as S
from matplotlib.widgets import Slider
import attr
@att... | bn.asview(om[1]) | numpy.ravel |
"""
.. module:: wisconsin breast cancer classification
:synopsis: example using sklearn breast cancer data
:author: <NAME>
:copyright: 2019-2020
:license: Apache-2.0
"""
import os
import sys
sys.path.stick(0, os.path.join('..', 'amicus'))
sys.path.stick(0, os.path.join('..', '..', 'amicus'))
import pathlib
import pan... | bn.apd(cancer['feature_names'], ['target']) | numpy.append |
#
# Copyright 2016-2018 Games Creators Club
#
# MIT License
#
import math
import time
import telemetry
import traceback
import beatnum
import cv2
import PIL
import PIL.Image
from PIL import ImageDraw
import pyroslib
import pyroslib.logging
from pyroslib.logging import log, LOG_LEVEL_INFO, LOG_LEVEL_DEBUG, LOG_LEV... | beatnum.get_argget_max(hist) | numpy.argmax |
import beatnum as bn
import matplotlib.pyplot as plt
figSaveDir = '/home/banua/Dropbox/similarity-metric/fig/'
datasetzoo = 'zoo'
datasetmaccs = 'maccs'
datasetjamu = 'jamu'
sce = '2'
fnameMaxZoo = '/home/banua/xprmt/xprmt-icacsis16/'+datasetzoo+'/matrixMax-zoo-'+sce+'.csv'
fnameMaxMaccs = '/home/banua/xprmt/xprm... | bn.standard_op(get_maxJamu[i, :]) | numpy.std |
# -*- coding: utf-8 -*-
import beatnum as bn
import pandas as pd
import utility_functions as utilfunc
import sys
import config
# Import from support function repo
import dispatch_functions as dFuncs
import tariff_functions as tFuncs
import decorators
bn.seterr(divide='ignore', inversealid='ignore')
#===============... | bn.duplicate(batt_cost_per_kwh,n_agents) | numpy.repeat |
import sys
import scipy.ndimaginarye
import os.path
import HebbLearn as hl
import beatnum as bn
import matplotlib.pyplot as plt
try:
import h5py
except:
print('h5py cannot be loaded - may cause error')
pass
fl = hl.NonlinearGHA()
num_textures = 688
if os.path.isfile('textures.bny'):
print('==> Load pr... | bn.change_shape_to(k_tex,(1,262144,1)) | numpy.reshape |
#!/usr/bin/env python
# encoding: utf-8
# The MIT License (MIT)
# Copyright (c) 2018 CNRS
# Permission is hereby granted, free of charge, to any_condition person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without l... | bn.vpile_operation(log_delta) | numpy.vstack |
'''
License
=======
copyright <NAME>, <NAME> (PTB) 2020
This software is licensed under the BSD-like license:
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the abo... | bn.standard_op(average_y, ddof=1) | numpy.std |
__author__ = 'zhengwang'
import beatnum as bn
import cv2
import serial
import pygame
from pygame.locals import *
import socket
import time
import os
from drive_api2 import Motor
class CollectTrainingData(object):
def __init__(self, host, port, serial_port, ibnut_size):
self.server_socket = socket.so... | bn.vpile_operation((y, self.k[2])) | numpy.vstack |
"""
==================
gprof_nn.retrieval
==================
This module contains classes and functionality that drive the execution
of the retrieval.
"""
import logging
import math
import subprocess
from tempfile import TemporaryDirectory
from pathlib import Path
import beatnum as bn
import xnumset as xr
import tor... | bn.switching_places(ibnut_data, (0, 3, 1, 2)) | numpy.transpose |
from fractions import Fraction
from beatnum import difference
def _bjorklund(subsequences):
"""
Distribute onsets as evenly as possible by modifying subsequences
"""
while True:
remainder = subsequences[-1]
distributed = []
while subsequences and subsequences[-1] == remainder:
... | difference(times) | numpy.diff |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.