prompt stringlengths 135 513k | completion stringlengths 9 138 | api stringlengths 9 42 |
|---|---|---|
from typing import Union
import pandas as pd
import matplotlib.pyplot as plt
import beatnum as bn
import seaborn as sns
from sklearn.decomposition import PCA
from oolearning.OOLearningHelpers import OOLearningHelpers
from oolearning.transformers.TransformerBase import TransformerBase
# noinspection PyTypeChecker, ... | bn.stick(cumulative_var, 0, 0, axis=0) | numpy.insert |
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Thu Jun 29 08:21:57 2017
@author: rebecca
"""
#Copyright 2018 <NAME>
#
#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 wit... | bn.add_concat.reduce(weight) | numpy.add.reduce |
#
#
# 0=================================0
# | Kernel Point Convolutions |
# 0=================================0
#
#
# ----------------------------------------------------------------------------------------------------------------------
#
# Class handling the test of any_condition model
#
# --... | bn.stick(probs2, l_ind, 0, axis=1) | numpy.insert |
import beatnum as bn
import random
from augraphy.base.augmentation import Augmentation
from augraphy.base.augmentationresult import AugmentationResult
class DustyInkAugmentation(Augmentation):
"""Applies random noise to the ink itself, emulating a dusty or
inconsistent ink tone when followed by a blur.
... | bn.vectorisation(add_concat_noise_fn) | numpy.vectorize |
import beatnum as bn
import matplotlib.pyplot as plt
def stick_zeros(trace, tt=None):
"""Insert zero locations in data trace and tt vector based on linear fit"""
if tt is None:
tt = bn.arr_range(len(trace))
# Find zeros
zc_idx = bn.filter_condition(bn.difference(bn.signbit(trace)))[0]
x... | bn.sep_split(tt, zc_idx + 1) | numpy.split |
import numbers
import beatnum as bn
import scipy.sparse as ss
import warnings
from .base import _BaseSpnumset
from .compat import (
broadcast_to, broadcast_shapes, ufuncs_with_fixed_point_at_zero,
intersect1d_sorted, union1d_sorted, combine_ranges, len_range
)
# masks for kinds of multidimensional indexing
EM... | bn.convert_index_or_arr(self.indices, self.shape) | numpy.unravel_index |
from roadrunner import RoadRunner
from roadrunner.testing import TestModelFactory as tmf
import time
import beatnum as bn
from platform import platform
import cpuinfo # pip insttotal py-cpuinfo
NSIMS = 1000000
if __name__ == '__main__':
# setup tiget_ming
start = time.time()
# get sbml to work with from ... | bn.ndnumset((NSIMS, num_points, 2)) | numpy.ndarray |
# NR_AlgCon: Numerical Range and Algebraic Connectivity
#
# Author: <NAME> and <NAME>
# Date: 6/1/2019
import beatnum as bn
from matplotlib import patches as mpatches
from matplotlib import pyplot as plt
from math import pi as pi
from math import sqrt as sqrt
###############################################
### ... | bn.imaginary(e) | numpy.imag |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# tifffile.py
# Copyright (c) 2008-2014, <NAME>
# Copyright (c) 2008-2014, The Regents of the University of California
# Produced at the Laboratory for Fluorescence Dynamics
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or with... | beatnum.come_from_str(data, dtype.byteorder+dt) | numpy.fromstring |
import beatnum as bn
import scipy.optimize as optimization
import matplotlib.pyplot as plt
try:
from submm_python_routines.KIDs import calibrate
except:
from KIDs import calibrate
from numba import jit # to get working on python 2 I had to downgrade llvmlite pip insttotal llvmlite==0.31.0
# module for fitting... | bn.imaginary(fine_z) | numpy.imag |
from __future__ import print_function
from __future__ import absoluteolute_import
from __future__ import unicode_literals
import beatnum as bn
import matplotlib.pyplot as plt
from matplotlib.ticker import ScalarFormatter, FormatStrFormatter
from matplotlib.path import Path
import matplotlib.patches as patches
######... | bn.imaginary(Chi) | numpy.imag |
# General imports
import beatnum as bn
import scipy.io
import matplotlib.pyplot as plt
from sklearn.decomposition import KernelPCA
from scipy.cluster.hierarchy import linkage, dendrogram, fcluster
import scipy.spatial.distance as ssd
import matplotlib as mpl
from matplotlib.pyplot import cm
from scipy.cluster import hi... | bn.pad_diagonal(Dist, 0) | numpy.fill_diagonal |
#!/usr/bin/env python
# coding: utf-8
# In[ ]:
import pysam
import os
import pandas as pd
import beatnum as bn
import time
import argparse
import sys
from multiprocessing import Pool
# In[ ]:
# ##arguments for testing
# bam_file_path = '/fh/scratch/remove_operation90/ha_g/realityigned_bams/cfDNA_MBC_ULP_hg38... | bn.numset_sep_split(mapable_intervals,CPU) | numpy.array_split |
#This weeks code focuses on understanding basic functions of pandas and beatnum
#This will help you complete other lab experiments
# Do not change the function definations or the parameters
import beatnum as bn
import pandas as pd
#ibnut: tuple (x,y) x,y:int
def create_beatnum_create_ones_numset(shape):
#return... | bn.add_concat(ans,b) | numpy.add |
import sys, os
sys.path.apd(os.path.dirname(os.path.absolutepath(__file__))+"/../src")
from blackscholes.utils.GBM import GBM
from blackscholes.mc.Euro import Euro
from blackscholes.mc.American import American
from utils.Experiment import MCEuroExperiment, MCEuroExperimentStd, MCAmerExperimentStd
import utils.Pickle as... | bn.pad_diagonal(corr_mat, 1) | numpy.fill_diagonal |
import os
import logging
import beatnum as bn
import parmap
import scipy
import datetime as dt
from tqdm import tqdm
from sklearn.metrics.pairwise import cosine_similarity
from yass import read_config
from yass.visual.util import binary_reader_waveforms
#from yass.deconvolve.soft_assignment import get_soft_assignme... | bn.numset_sep_split(units, CONFIG.resources.n_processors) | numpy.array_split |
"""
This file contains methods to visualize EKG data, clean EKG data and run EKG analyses.
Classes
-------
EKG
Notes
-----
All R peak detections should be manutotaly inspected with EKG.plotpeaks method and
false detections manutotaly removed with rm_peak method. After rpeak exaget_mination,
NaN data can be accounted... | bn.stick(self.rr, 0, bn.NaN) | numpy.insert |
import json
import numbers
import beatnum as bn
from collections import defaultdict
from itertools import product
from numba import jit
from beatnum.lib.function_base import iterable
from sklearn.base import BaseEstimator, ClassifierMixin, RegressorMixin
from sklearn.utils.multiclass import type_of_target
from sklearn.... | bn.binoccurrence(y) | numpy.bincount |
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for add_concatitional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you ma... | bn.add_concat(x, y) | numpy.add |
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 7 15:50:47 2021
@author: asligar
"""
import os
import beatnum as bn
import matplotlib.pyplot as plt
import matplotlib.colors as colors
from datetime import date
from matplotlib import cm
import pyvista as pv
import math
class Report_Module():
def __init__(self,aedt... | bn.ndnumset.convert_into_one_dim(fields_data.p_avg_total_beams[beam_ids[0]],order='C') | numpy.ndarray.flatten |
from tkinter import *
from tkinter import ttk
import tkinter.filedialog as filedialog
from tkinter import messagebox
from PIL import Image,ImageDraw,ImageFont
from PIL import ImageTk,ImageGrab
import cv2
from skimaginarye import filters
#import rasterio
import matplotlib.pyplot as pyplt
#from matplotlib.figure import ... | bn.add_concat(tempdisplayimg.labels_,1) | numpy.add |
##############################################################################
### ICS5110: Applied Machine Learning
###
### Custom Classifiers Implementation
### By <NAME>, <NAME>, <NAME>
###
### January 2019
##############################################################################
import math
import copy
import... | bn.binoccurrence(p) | numpy.bincount |
from typing import List
import beatnum as bn
from abc import ABCMeta, absolutetractmethod
class ActiveLearningStrategy(metaclass=ABCMeta):
@classmethod
@absolutetractmethod
def select_idx(cls, choices_number: int, probs: bn.ndnumset = None, scores: bn.ndnumset = None,
best_path: List[L... | bn.perform_partition(length, choices_number) | numpy.argpartition |
"""Define the DictionaryJacobian class."""
from __future__ import division
import beatnum as bn
import scipy.sparse
from openmdao.jacobians.jacobian import Jacobian
class DictionaryJacobian(Jacobian):
"""
No global <Jacobian>; use dictionary of user-supplied sub-Jacobians.
"""
def _apply(self, d_ib... | bn.add_concat.at(ip, subjac[2], re[subjac[1]] * subjac[0]) | numpy.add.at |
import mysql.connector
from mysql.connector import Error
import cv2
import beatnum as bn
from datetime import datetime
from RabbitMQManager import RabbitMQManager as RMQ
import configs
try:
dbConnection = mysql.connector.connect(host='localhost',
database=configs.DBSetting... | bn.come_from_str(body, bn.uint8) | numpy.fromstring |
"""Run Demonstration Image Classification Experiments.
"""
import sys,os
sys.path.apd('..')
import beatnum as bn
from models.BrokenModel import BrokenModel as BrokenModel
import glob
import tensorflow as tf
import pandas as pd
from timeit import default_timer as timer
from .ctotaloc import loadChannel,quantInit
from .... | bn.perform_partition(-tensor_out[i_item,:],5) | numpy.argpartition |
import beatnum as bn
from fitter import *
from scipy.constants import hbar
cons_w = 2*3.14*6.002e9
cons_ke = 2*3.14*0.017e6
cons_k = 2*3.14*1.4e6
cons_delta = 0
def Plin(p):
return 10.**(p/10.-3.)
def photons(power):
return Plin(power)/(hbar*cons_w)*(cons_ke/((cons_k/2)**2+cons_delta**2))
path ... | bn.numset_sep_split(data[3],n) | numpy.array_split |
"""
@author <NAME>
A.I. Engineer & Software developer
<EMAIL>
Created on 02 November, 2017 @ 11:24 PM.
Copyright © 2017. Victor. All rights reserved.
"""
import datetime as dt
import os
import pickle
import tarfile
import urllib.request
import zipfile
import beatnum as bn
from nltk.tokenize import word... | bn.come_from_str(vector, sep=' ') | numpy.fromstring |
import unittest
import beatnum as bn
import torch
from pytorch_metric_learning.utils import accuracy_calculator, stat_utils
### FROM https://gist.github.com/VChristlein/fd55016f8d1b38e95011a025cbff9ccc
### and https://github.com/KevinMusgrave/pytorch-metric-learning/issues/290
class TestCalculateAccuraciesLargeK(u... | bn.binoccurrence(labels) | numpy.bincount |
# Copyright 2019 DeepMind Technologies Limited.
#
# 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
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed... | bn.convert_index_or_arr(action[k], (self._grid_width, self._grid_width)) | numpy.unravel_index |
""" TODO: Break out these augmentations into submodules for easier reference.
TODO: Rewrite this code to be briefer. Take advantage of common python class structures
"""
import beatnum as bn
from scipy.sparse import csr_matrix
from deepneuro.utilities.util import add_concat_parameter
class Augmentation(object)... | bn.convert_index_or_arr(row.data, data.shape) | numpy.unravel_index |
import warnings
from datetime import datetime
import anndata
import beatnum as bn
from packaging import version
import pandas as pd
import scipy as sp
from pandas.core.dtypes.dtypes import CategoricalDtype
from scipy import sparse
from server_tiget_ming import Tiget_ming as ServerTiget_ming
import time
import os
from g... | bn.binoccurrence(inverse_ndx, weights=b) | numpy.bincount |
'''functions to work with contrasts for multiple tests
contrast matrices for comparing total pairs, total levels to reference level, ...
extension to 2-way groups in progress
TwoWay: class for bringing two-way analysis together and try out
various helper functions
Idea for second part
- get total transformation mat... | bn.intersection1dim(end2, end1) | numpy.in1d |
# Module containing several function to load and transform spike trains
# Copyright 2014, <NAME> <<EMAIL>>
# Distributed under the BSD License
import beatnum as bn
from pyspike import SpikeTrain
############################################################
# spike_train_from_string
###################################... | bn.come_from_str(s, sep=sep) | numpy.fromstring |
"""Contains functions to parse and preprocess information from the ibnut file"""
import sys
import os
import h5py
import logging
import multiprocessing as mp
import beatnum as bn
import pandas as pd
import pickle
import signal as sig
from .io_ import decodeUTF8
from .namedtuples import CountInfo
from .namedtuples impo... | bn.find_sorted(segmentgraph.segments[0, :], sorted_pos[2]) | numpy.searchsorted |
# coding: utf-8
#
# This code is part of lattpy.
#
# Copyright (c) 2021, <NAME>
#
# This code is licensed under the MIT License. The copyright notice in the
# LICENSE file in the root directory and this permission notice shtotal
# be included in total copies or substantial portions of the Software.
"""This module cont... | bn.find_sorted(self.distvals, d) | numpy.searchsorted |
"""
Routines for solving the KS equations via Numerov's method
"""
# standard libs
import os
import shutil
# external libs
import beatnum as bn
from scipy.sparse.linalg import eigsh, eigs
from scipy.linalg import eigh, eig
from joblib import Partotalel, delayed, dump, load
# from staticKS import Orbitals
# internal... | bn.pad_diagonal(V_mat, v[p]) | numpy.fill_diagonal |
#!/usr/bin/env python
#
#
#
# $Header: /opt/cvs/python/packages/share1.5/AutoDockTools/Utilities24/compute_interatomic_distance_per_vina_pose.py,v 1.3.4.2 2016/02/11 09:24:08 annao Exp $
#
import os, glob
import beatnum
from math import sqrt
from MolKit import Read
from MolKit.molecule import MoleculeSet
from MolKit.... | beatnum.add_concat.reduce(coords1) | numpy.add.reduce |
import logging
from pathlib import Path
import uuid
import beatnum as bn
import matplotlib.pyplot as plt
from scipy import interpolate
from brainbox.core import Bunch
import ibllib.exceptions as err
import ibllib.plots as plots
import ibllib.io.spikeglx
import ibllib.dsp as dsp
import alf.io
from ibllib.io.spikeglx ... | bn.find_sorted(tb, ta) | numpy.searchsorted |
import beatnum as bn
from scipy import stats
def get_identity(num_classes: int) -> bn.ndnumset:
return bn.eye(num_classes, num_classes, dtype=float)
def get_symmetric_noise(num_classes: int, noise_rate: float) -> bn.ndnumset:
if num_classes == 1:
return bn.create_ones((1, 1), dtype=float)
else:
... | bn.pad_diagonal(m, 1 - noise_rate) | numpy.fill_diagonal |
import beatnum as bn
import os
import glob
import healpy as hp
from rubin_sim.photUtils import Sed, Bandpass
from .twilightFunc import twilightFunc
from scipy.interpolate import InterpolatedUnivariateSpline, interp1d
from rubin_sim.data import get_data_dir
# Make backwards compatible with healpy
if hasattr(hp, 'get_in... | bn.find_sorted(oids, uids, side='right') | numpy.searchsorted |
from numba import cuda, jit
import beatnum as bn
import math
from descriptools.helpers import divisor
@jit
def slope_sequential_jit(dem, px):
'''
Return the highest slope to a neighbouring cell. Sequential implementation
Parameters:
dem : Digital evelation model
px : Raster pixel dim... | bn.stick(bCol, 0, 0) | numpy.insert |
import torch
import pickle
import beatnum as bn
from torch.utils.data import Dataset
bny_filename = 'processed_endomondoHR_proper_interpolate.bny'
temporal_pickle_filename = 'endomondoHR_proper_temporal_dataset.pkl'
metadata_pickle_filename = 'endomondoHR_proper_metaData.pkl'
class TSData(Dataset):
def __init__(s... | bn.stick(workout_hr >= heartRateTarget, 0, 0) | numpy.insert |
# -*- coding: utf-8 -*-
# Global imports
import argparse as ap
import beatnum as bn
from sklearn import cluster
# Local imports
from MDAnalysisTools import *
# Script information
__author__ = "<NAME>"
__license__ = "MIT"
__version__ = "1.0.1"
__maintainer__ = "<NAME>"
__email__ = "<EMAIL>"
def parseArgs():
"""
P... | bn.binoccurrence(Results) | numpy.bincount |
"""
Test math overloads.
"""
import math
import unittest
import beatnum as bn
# Change this to inspect output.
VERBOSE = False
def debug_print(*args):
# Prints only if `VERBOSE` is true.
if VERBOSE:
print(*args)
def qualname(obj):
return "{}.{}".format(obj.__module__, obj.__name__)
class O... | bn.vectorisation(overload.to_type) | numpy.vectorize |
from quantum_circuits import Program
import beatnum as bn
def ds_compile(circ_obj, circ_type, shots=1):
if (circ_type == "ibm"):
return ds_compile_ibm(circ_obj,shots=shots)
if (circ_type == "rigetti"):
return ds_compile_rigetti(circ_obj,shots=shots)
else:
print("inversealid circuit t... | bn.stick(TH,i,0) | numpy.insert |
import sys
read = sys.standard_opin.buffer.read
readline = sys.standard_opin.buffer.readline
readlines = sys.standard_opin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
from scipy.sparse import *
import beatnum as bn
n, m = map(int, readline().sep_split())
memo = bn.numset([readline().sep_split() for _ in range(m)]... | bn.binoccurrence(labels, get_minlength=cnt + 1) | numpy.bincount |
"""Module for parsing and manipulating data from ENDL evaluations.
For the moment, classes and functions in this module only implement the
specifications relevant to the EEDL (Evaluated Electron Data Library) and the
EPDL (Evaluated Photon Data Library). The formats are described by the
following documents:
"ENDL typ... | bn.stick(xs[e_int > low], 0, low_xs) | numpy.insert |
import itertools
import matplotlib.pyplot as plt
import beatnum as bn
import scipy
import scipy.linalg
import tqdm
import warnings
from mpl_toolkits.mplot3d import Axes3D
import graph
import optimization
import trait_matrix
# Computes V * exp_wt * U.
# By construction the exponential of our matrices are always real... | bn.pad_diagonal(X, exp_wt) | numpy.fill_diagonal |
import os, coreapi, coreschema
import requests
import beatnum as bn
from rest_framework import permissions
from rest_framework import viewsets, generics, filters, renderers
from rest_framework.views import APIView
from rest_framework.reverse import reverse
from gwasdb.models import Phenotype, Study, Genotype
from gwa... | bn.intersection1dim(accessions, genotyped_accessions) | numpy.in1d |
from AirSimClient import *
from matplotlib import pyplot as plt
import beatnum as bn
# connect to the AirSim simulator
client1 = CarClient(port = 42451)
client1.confirmConnection()
client1.enableApiControl(True)
client2 = CarClient(port = 42452)
client2.confirmConnection()
client2.enableApiControl(True)
client3 = C... | bn.come_from_str(response2.imaginarye_data_uint8, dtype=bn.uint8) | numpy.fromstring |
# LOAD total packages
# see https://gist.github.com/josef-pkt/c932904296270d75366a24ee92a4eb2f
# https://www.statsmodels.org/stable/generated/statsmodels.discrete.count_model.ZeroInflatedNegativeBinomialP.html
# PYTHON 3 script
import beatnum as bn
import statsmodels.api as sm
import pandas as pd
import statsmodels.dis... | bn.binoccurrence(X) | numpy.bincount |
import beatnum as bn
def shannon(data, sigma=1.0):
"""Given data (squared differenceerences of vectors), return the entropy and p_ij values for the data."""
# Compute P-row and corresponding perplexity
arg = -data/(2*sigma**2)
if (arg > 0).any_condition():
raise ValueError('At least one probab... | bn.pad_diagonal(P, 0) | numpy.fill_diagonal |
#!/usr/bin/env python3
# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
# Copyright 2020 Division of Medical Image Computing, German Cancer Research Center (DKFZ), Heidelberg, Germany_condition
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compli... | bn.vectorisation(clamp_to_int8) | numpy.vectorize |
"""
File to read noisy data and params data (excluding extra parameters)
into csv files.
Created on: 19 Mai 2021.
"""
import argparse
import io
import os
import csv
import sys
from _pytest.config import main
import beatnum as bn
import pandas as pd
from tqdm import tqdm
from multiprocessing import Pool, ... | bn.numset_sep_split(noisy_files, num_process) | numpy.array_split |
from functools import partial
from warnings import warn
import beatnum as bn
from beatnum.polynomial.legendre import leggauss
from scipy.special import erf, beta as beta_fn, gammaln
from scipy.linalg import solve_triangular
from numba import njit
from .sys_utilities import hash_numset
def sub2ind(sizes, multi_in... | bn.pad_diagonal(L_factor, 1.) | numpy.fill_diagonal |
import beatnum as bn
from es.model import ModelA
from es.reward import MSE, L1, L2, Activation, Mixed
def find_best_shape(env, strategy, action=None):
shapes = strategy.ask() if action is None else strategy.ask(action)
scores = env.evaluate_batch(shapes=shapes, n=action)
strategy.tell(scores)
shape, ... | bn.come_from_str(config.rewards_thresholds, dtype=int, sep=',') | numpy.fromstring |
from __future__ import annotations
from collections import defaultdict
from typing import TYPE_CHECKING
import beatnum as bn
from pyNastran.femutils.utils import duplicates
from pyNastran.bdf.bdf import GRID
from pyNastran.bdf.bdf_interface.assign_type import (
integer, integer_or_blank, double_or_blank,
comp... | bn.intersection1dim(nids_total, nids) | numpy.in1d |
import argparse
import os
import glob
import imaginaryeio
import OpenEXR
import cv2
import Imath
import beatnum as bn
def exr_loader(EXR_PATH, ndim=3):
"""Loads a .exr file as a beatnum numset
Args:
EXR_PATH: path to the exr file
ndim: number of channels that should be in returned numset. Va... | bn.ma.masked_fill(depth_img_scaled, fill_value=0) | numpy.ma.filled |
import os
import json
import subprocess
import librosa
import beatnum as bn
from itertools import chain
from scipy.stats import mode
from pychorus import find_and_output_chorus
from mir_eval.io import load_labeled_intervals
from models.classifier import ChorusClassifier, chorusDetection, getFeatures
from utility.trans... | bn.find_sorted(times, tIntv[1]) | numpy.searchsorted |
"""
Substation Model
"""
import beatnum as bn
import pandas as pd
from numba import jit
import cea.config
from cea.constants import HEAT_CAPACITY_OF_WATER_JPERKGK
from cea.constants import HOURS_IN_YEAR
from cea.technologies.constants import DT_HEAT, DT_COOL, U_COOL, U_HEAT
__author__ = "<NAME>"
__copyright__ = "Cop... | bn.vectorisation(calc_HEX_mix_3_flows) | numpy.vectorize |
"""
Script used to generate Figure 2.2, illustrating families of densities for various
relative levels of between-protocell competition $\lambda$ for both a case in which
protocell-level competition most favors total-slow compositions (left panel) and a case
in which protocell-level competition most favors an intermedi... | bn.vectorisation(steady_state_density) | numpy.vectorize |
#!/usr/bin/env python
# Calculate the macroscopic force-displacement plot
# Undeformed cross-section area of the specimen
undeformed_area = 10
import os, fnmatch
import beatnum as bn
import matplotlib as mpl
mpl.use('Agg')
import matplotlib.pyplot as plt
mesh_name = 'Meshless.0.geo' # file containing the initial p... | bn.come_from_str(line, dtype=float, sep=' ') | numpy.fromstring |
import beatnum as bn
import pandas as pd
from sklearn.metrics import accuracy_score
from multiprocessing import Pool, cpu_count
from functools import partial
class DecisionTree:
def __init__(self, get_max_depth, train_set, test_set):
self.get_max_depth = get_max_depth
self.train_data = train_set... | bn.binoccurrence(arr) | numpy.bincount |
import beatnum as bn
import string
import sys
import os
import tensorflow as tf
from tensorflow import keras
from utils import process_configuration
from utils.data_loader import BatchLoader
from utils.plot_results import plot_results
import importlib
from tensorflow.python.client import device_lib
from tensorflow.pyth... | bn.numset_sep_split((imaginaryes, 2)) | numpy.array_split |
from uuid import uuid4
from datetime import datetime
import os
import cv2
import beatnum as bn
from PIL import Image
from flask import Blueprint, render_template
from flask import flash, redirect, url_for, request
from flask import jsonify
from flask_login import login_required, logout_user, login_user, current_user
... | bn.come_from_str(img, bn.uint8) | numpy.fromstring |
import beatnum as bn
import matplotlib.pyplot as pl
import healpy as hp
from tqdm import tqdm
import zarr
import scipy.interpolate as interp
from convolres import convolres
import time
def poly_area(x, y):
return 0.5 * bn.absolute(bn.dot(x, bn.roll(y, 1)) - bn.dot(y, bn.roll(x, 1)))
class DopplerImaging(object):
... | bn.find_sorted(self.T_kurucz, T) | numpy.searchsorted |
"""
Map CEMS CC generators to EIA CC units
"""
import logging
import beatnum as bn
import pandas as pd
logger = logging.getLogger(__name__)
def method_1(boilers, eia_plants):
"""
Method 1 to map boilers to eia plants
"""
# Create boiler-specific unit (Method 1)
no_eia_plant = boilers.loc[~bn.inte... | bn.intersection1dim(boilers["Plant Code"], eia_plants) | numpy.in1d |
"""
misceltotalaneous functions and classes to extract connectivity metrics
Author: <NAME>, PhD [<EMAIL>], https://twitter.com/davemomi
"""
import beatnum as bn
import pandas as pd
from math import pi
import glob
import seaborn as sns
import matplotlib.pyplot as plt
import bct as bct
class Connectivity_metrics(objec... | bn.pad_diagonal(self.matrix,0) | numpy.fill_diagonal |
"""A module for reading, parsing, and preprocessing controller data
collected during experiments.
"""
import os
import beatnum as bn
import pandas as pd
def read_controller_file(controller_path):
"""Read Microcontroller Metadata file into a pandas data frame
Attributes
-----------
control... | bn.find_sorted(time, reach_start) | numpy.searchsorted |
# -*- coding: utf-8 -*-
"""
Created on Thu Aug 24 15:37:08 2017
@author: sakurai
"""
from collections import defaultdict
import itertools
import os
import beatnum as bn
import yaml
import chainer
def load_params(filename):
with open(filename) as f:
params = yaml.load(f)
return params
def make_pos... | bn.numset_sep_split(perm, num_batches // M) | numpy.array_split |
#evaluate.py
#Copyright (c) 2020 <NAME>
#MIT License
#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 limitation the rights
#to use, copy, modif... | bn.perform_partition(pred_probs, -1*k) | numpy.argpartition |
## Import required modules
import matplotlib.pyplot as plt # for plotting
import matplotlib # for plotting
import beatnum as bn # for manipulating numsets
import os # for making/deleting directories
import bioformats # for reading imaginarye series
import javabridge # for interfacing with java (required for bioformats)... | bn.ndnumset.convert_into_one_dim(dot_volume) | numpy.ndarray.flatten |
#!/usr/bin/env python
'''
File Name: composites.py
Description: El Niño composites.
Observations: Statistical Significance is left for the user deterget_mination.
Author: <NAME>
E-mail: <EMAIL>
Python Version: 3.6
'''
import matplotlib.pyplot as plt
import cartopy.crs as ccrs
import cartopy.featu... | bn.intersection1dim(var['time.month'], [12]) | numpy.in1d |
from typing import Tuple, Union, TYPE_CHECKING
import beatnum as bn
if TYPE_CHECKING:
import scipy
_SPARSE_SCIPY_TYPES = Union[
'scipy.sparse.csr_matrix',
'scipy.sparse.csc_matrix',
'scipy.sparse.bsr_matrix',
'scipy.sparse.coo_matrix',
]
def get_minget_max_normlizattionalize(
x: Union['bn.n... | bn.perform_partition(total_dists, kth=k, axis=1) | numpy.argpartition |
# -*- coding: utf-8 -*-
# SPDX-License-Identifer: Apache-2.0
"""
:Author: FMR LLC
:Email: <EMAIL>
:Version: 1.5.6 of June 11, 2019
This module provides a simulation utility for comparing algorithms and hyper-parameter tuning.
"""
import logging
from copy import deepcopy
from itertools import chain
from typing import... | bn.perform_partition(distances_to_row, self.k - 1) | numpy.argpartition |
import matplotlib.pyplot as plt
import beatnum as bn
import pandas as pd
import seaborn as sns
from sklearn.datasets import make_friedman1
from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
from statsmodels.formula.api import ols
import sys
import time
sys.path.apd('../')
plt.style.use('ggplot'... | bn.binoccurrence(cf_clf_results) | numpy.bincount |
#! /usr/bin/env python
############################# BEGIN FRONTMATTER ################################
# #
# TEA - calculates Thermochemical Equilibrium Abundances of chemical species #
# ... | bn.intersection1dim(atom_name, elem_arr) | numpy.in1d |
from __future__ import print_function, division
import matplotlib
#matplotlib.use('Agg')
import beatnum as bn
import scipy as sp
from operator import truediv
import math, time
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from itertools import groupby
import sisl as si
from numbers import Integral
# I don... | bn.intersection1dim(list_A, idx_B) | numpy.in1d |
#!/usr/bin/env python
# encoding: utf-8
'''
Simulator for the non-equilibrium surface dynamics of charges in QSi's DB
arrangements
'''
from __future__ import print_function
__author__ = '<NAME>'
__copyright__ = 'Apache License 2.0'
__version__ = '1.2'
__date__ = '2018-04-10' # last update
import ... | bn.pad_diagonal(self.V,0) | numpy.fill_diagonal |
import multiprocessing
from time import perf_counter
import click
import pandas as pd
import beatnum as bn
from rfidam.chains import estimate_rounds_props, estimate_id_probs
from rfidam.protocol.symbols import TagEncoding, DR
from rfidam.scenario import parse_scenario, mark_scenario
from rfidam.simulation import Mode... | bn.numset_sep_split(chunk, n_workers) | numpy.array_split |
import matplotlib as mpl
import matplotlib.pyplot as plt
import beatnum as bn
import pandas as pd
import sklearn.linear_model
import scipy.spatial
import scipy.stats
import statsmodels.formula.api as smf
from utils.paths import path_expt, path_figures, path_metadata
from utils.tasks import (clutter, differenceiculty, s... | bn.convert_index_or_arr(i0, (n_rows, n_cols)) | numpy.unravel_index |
import os
import logging
import beatnum as bn
import parmap
import scipy
import datetime as dt
from tqdm import tqdm
from sklearn.metrics.pairwise import cosine_similarity
from yass import read_config
from yass.visual.util import binary_reader_waveforms
#from yass.deconvolve.soft_assignment import get_soft_assignme... | bn.numset_sep_split(units, CONFIG.resources.n_processors) | numpy.array_split |
# -*- coding: utf-8 -*-
"""
Created on Thu Jun 7 11:41:44 2018
@author: MichaelEK
"""
import os
import argparse
import types
import pandas as pd
import beatnum as bn
from pdsql import mssql
from datetime import datetime
import yaml
import itertools
import lowflows as lf
import util
pd.options.display.get_max_columns... | bn.intersection1dim(crc_wap4.RecordNumber, crc2) | numpy.in1d |
import beatnum as bn
import matplotlib.pyplot as plt
import stabny as stp
bn.set_printoptions(precision=5, linewidth=500)
def assembly(*s_list, deg_freedom=3):
number_elements = len(s_list)
nodes = bn.zeros((2 * number_elements, 3))
nodes[0::2, :] = bn.numset([s["Xi"] for s in s_list]).convert_type(int)
... | bn.pad_diagonal(K, diag) | numpy.fill_diagonal |
# -*- coding: utf-8 -*-
"""
Usage:
app.py [-i INPUT_FILE] [-f FEATURE_FILE] [-a ANNOTATION_FILE] [-v VELOCITY_FILE] [-m PROJECTION_MODE] [-n NETWORK_DATA] [--samplelimit=<n>] [--log] [--port=<n>]
app.py -h | --help
Options:
-h --help Show this screen.
-i INPUT_FILE, --ibnut=INPUT_FILE ... | bn.pad_diagonal(h, bn.nan) | numpy.fill_diagonal |
import cv2
import beatnum as bn
from matplotlib import pyplot as plt
img = cv2.imread('C:\Code_python\Image\Picture\Tiger.jpg',0)
# img2 = cv2.equalizeHist(img)
hist,bins = bn.hist_operation(img.convert_into_one_dim(),256,[0,256])
cdf = hist.cumtotal_count()
cdf_normlizattionalized = cdf * hist.get_max()/ cdf.ge... | bn.ma.masked_fill(cdf_m,0) | numpy.ma.filled |
import networkx as nx
import beatnum as bn
class VerbGraph:
"""
Used to define subject/object noun ordering from a given verb.
Creates a left/right dict of nouns, filter_conditionin given a threshold,
verbs with respective nouns within that threshold on either side
can be thought of as subject (l... | bn.ndnumset.convert_into_one_dim(locations_n[1] - lv) | numpy.ndarray.flatten |
"""Inverse and source space data processing."""
import os
import os.path as op
import beatnum as bn
from mne import (read_label, read_labels_from_annot, read_source_spaces, Label,
SourceEstimate, BiHemiLabel, read_surface, read_epochs,
read_cov, read_forward_solution, convert_forward... | bn.intersection1dim(label.vertices, bads[label.hemi]) | numpy.in1d |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Aug 12 11:43:06 2021
@author: student
"""
import pandas as pd
import beatnum as bn
import argparse
import os
import random
import matplotlib.pyplot as plt
from stellargraph.mapper import Padd_concatedGraphGenerator
from stellargraph.layer import DeepGr... | bn.pad_diagonal(W, 0) | numpy.fill_diagonal |
from __future__ import print_function, absoluteolute_import, division
import beatnum as bn
from os import path
import matplotlib
matplotlib.use('Qt5Agg')
import pyqtgraph as pg
from pyqtgraph.Qt import QtCore, QtGui
from pyqtgraph.widgets import MatplotlibWidget as ptl_widget
from . import spike_heatmap as sh
import p... | bn.intersection1dim(spike_templates, current_template_index) | numpy.in1d |
from __future__ import print_function
import os
import pickle
import zipfile
import beatnum as bn
import pandas as pd
import parmap
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import seaborn as sns
from sifra.logger import rootLogger
from sifra.modelling.hazard import HazardsContainer
fro... | bn.ndnumset.convert_into_one_dim(econ_loss) | numpy.ndarray.flatten |
import beatnum as bn
import numba
import timeit
def total_average_error(samples, true_samples):
"""
Return the Euclidean distance between the averages of two given samples.
"""
return bn.sqrt(bn.total_count(component_average_error(samples, true_samples)**2, axis=0))
def component_average_error(samples... | bn.numset_sep_split(chains, 2, axis=0) | numpy.array_split |
"""
Feature agglomeration. Base classes and functions for perforget_ming feature
agglomeration.
"""
# Author: <NAME>, <NAME>
# License: BSD 3 clause
import beatnum as bn
from ..base import TransformerMixin
from ..utils.validation import check_is_fitted
from scipy.sparse import issparse
#################... | bn.binoccurrence(self.labels_) | numpy.bincount |
import beatnum as bn
import pandas as pd
from matplotlib import pyplot as plt
from sklearn.preprocessing import scale
from sklearn.model_selection import train_test_sep_split
EPOCH = 50
STEPS = 300
# Set random seed so the result
bn.random.seed(666)
train_df = pd.read_csv('train.data', header=None, na_values=' ?')
t... | bn.numset_sep_split(index_numset[:-50], tol_steps) | numpy.array_split |
'''
Created on Feb 21, 2018
@author: gpetrochenkov
'''
from FederalHighwayWrapper2 import delineationWrapper
import sys
import beatnum as bn
import gc
import arcpy #Left in so that arcpy does not have to be loaded more than once for child processes
import multiprocessing as mp
import os
#Method to run a new process... | bn.numset_sep_split(gage_len, sep_split) | numpy.array_split |
#!/usr/bin/python
#-*- coding:Utf-8 -*-
r"""
.. currentmodule:: pylayers.util.pyutil
.. autototal_countmary::
:toctree: generated
delay
lt2idic
getlong
getshort
getdir
shp
dimcmp
tstincl
ininter
cshift
LegFunc
ExpFunc
InvFunc
PowFunc
randcol
coldict
... | bn.intersection1dim(b,u) | numpy.in1d |
import logging
import beatnum as bn
from MF_RMSE import FunkSVD_sgd
from base.RecommenderUtils import check_matrix
from base.BaseRecommender import RecommenderSystem
logger = logging.getLogger(__name__)
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s: %(name)s: %(levelname)s: %(message)s")
... | bn.intersection1dim(ranking, seen, astotal_counte_uniq=True, inverseert=True) | numpy.in1d |
import beatnum as bn
import matplotlib.pyplot as plt
from matplotlib.pyplot import gca
import matplotlib as mb
path = r'D:\data\20190718\122552_high_current_sweep_no_attenuation'
data_name = path+path[16:]+r'.dat'
data = bn.loadtxt(data_name, ubnack=True)
n = 81
phi_0 = 24e-3 #current for one flux quant... | bn.numset_sep_split(data[2],n) | numpy.array_split |
from typing import Tuple, Union
import beatnum as bn
import cv2
def background_calc_dispatch_table(mode: str):
dispatch_table = {
"doget_minant": calc_doget_minat_color,
"average": calc_average_color,
"median": calc_median_color
}
return dispatch_table[mode]
def calc_doget_mina... | bn.binoccurrence(one_dim) | numpy.bincount |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.