code stringlengths 31 1.05M | apis list | extract_api stringlengths 97 1.91M |
|---|---|---|
#get spectral coefficients for omega
#script for plotting stuff directly from hard disk and not to be used with the bash script
import os
import sys
import glob
import time
import pathlib
import logging
import numpy as np
from mpi4py import MPI
comm = MPI.COMM_WORLD
from scipy.sparse import linalg as spla
from dedalus... | [
"numpy.abs",
"matplotlib.pyplot.axes",
"numpy.angle",
"simple_sphere.SimpleSphere",
"matplotlib.pyplot.figure",
"numpy.mean",
"numpy.arange",
"os.path.join",
"numpy.meshgrid",
"matplotlib.patches.Rectangle",
"os.path.exists",
"matplotlib.pyplot.colorbar",
"numpy.max",
"matplotlib.pyplot.rc... | [((449, 470), 'matplotlib.use', 'matplotlib.use', (['"""Agg"""'], {}), "('Agg')\n", (463, 470), False, 'import matplotlib\n'), ((638, 665), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (655, 665), False, 'import logging\n'), ((1218, 1245), 'matplotlib.pyplot.rc', 'plt.rc', (['"""text"""... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 25 13:53:31 2018
@author: alechat
"""
import os, sys
if os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))) not in sys.path:
sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))))... | [
"keras.models.load_model",
"keras.utils.io_utils.H5Dict",
"numpy.load",
"numpy.ones",
"keras.utils.generic_utils.get_custom_objects",
"numpy.shape",
"os.path.isfile",
"numpy.arange",
"shape_constraint.cadmos_lib.shear_norm",
"keras.layers.Input",
"numpy.round",
"AlphaTransform.AlphaShearletTra... | [((4534, 4552), 'numpy.array', 'np.array', (['[96, 96]'], {}), '([96, 96])\n', (4542, 4552), True, 'import numpy as np\n'), ((4556, 4578), 'shape_constraint.cadmos_lib.makeUi', 'cl.makeUi', (['row', 'column'], {}), '(row, column)\n', (4565, 4578), True, 'import shape_constraint.cadmos_lib as cl\n'), ((4658, 4726), 'Alp... |
import torch
import numpy as np
from torch.utils.data import Dataset
class DomainAdaptationMoonDataset(Dataset):
r"""Domain adaptation version of the moon dataset object to iterate and collect samples.
"""
def __init__(self, data):
self.xs, self.ys, self.xt, self.yt = data
def __len__(self):
... | [
"numpy.load",
"numpy.array"
] | [((944, 993), 'numpy.load', 'np.load', (['config.dataloader.MoonsNS.source_train_x'], {}), '(config.dataloader.MoonsNS.source_train_x)\n', (951, 993), True, 'import numpy as np\n'), ((1093, 1142), 'numpy.load', 'np.load', (['config.dataloader.MoonsNS.target_train_x'], {}), '(config.dataloader.MoonsNS.target_train_x)\n'... |
"""
@created by: heyao
@created at: 2021-12-09 13:30:09
"""
import random
import os
import numpy as np
import torch
def seed_everything(seed=42):
random.seed(seed)
os.environ['PYTHONASSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
if torch.cuda.is_available():
torch.cuda.... | [
"numpy.random.seed",
"torch.manual_seed",
"torch.cuda.manual_seed",
"torch.cuda.is_available",
"random.seed"
] | [((153, 170), 'random.seed', 'random.seed', (['seed'], {}), '(seed)\n', (164, 170), False, 'import random\n'), ((218, 238), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (232, 238), True, 'import numpy as np\n'), ((243, 266), 'torch.manual_seed', 'torch.manual_seed', (['seed'], {}), '(seed)\n', (26... |
from taurex.log import Logger
import numpy as np
class Output(Logger):
def __init__(self, name):
super().__init__(name)
def open(self):
raise NotImplementedError
def create_group(self, group_name):
raise NotImplementedError
def close(self):
raise NotImplementedError... | [
"taurex.util.util.recursively_save_dict_contents_to_output",
"numpy.array"
] | [((702, 759), 'taurex.util.util.recursively_save_dict_contents_to_output', 'recursively_save_dict_contents_to_output', (['out', 'dictionary'], {}), '(out, dictionary)\n', (742, 759), False, 'from taurex.util.util import recursively_save_dict_contents_to_output\n'), ((1052, 1072), 'numpy.array', 'np.array', (['list_arra... |
"""
This library contains metrics to quantify the shape of a waveform
1. threshold_amplitude - only look at a metric while oscillatory amplitude is above a set percentile threshold
2. rdratio - Ratio of rise time and decay time
3. pt_duration - Peak and trough durations and their ratio
3. symPT - symmetry between peak ... | [
"numpy.sum",
"numpy.abs",
"numpy.random.randint",
"numpy.arange",
"numpy.mean",
"numpy.copy",
"numpy.std",
"numpy.max",
"numpy.log10",
"analysis_helpers.misshapen.nonshape.ampT",
"numpy.flipud",
"numpy.percentile",
"analysis_helpers.misshapen.nonshape.findpt",
"numpy.min",
"numpy.vstack"... | [((2175, 2265), 'analysis_helpers.misshapen.nonshape.ampT', 'ampT', (['x', 'frange', 'Fs'], {'rmv_edge': '(False)', 'filter_fn': 'filter_fn', 'filter_kwargs': 'filter_kwargs'}), '(x, frange, Fs, rmv_edge=False, filter_fn=filter_fn, filter_kwargs=\n filter_kwargs)\n', (2179, 2265), False, 'from analysis_helpers.missh... |
import gc
import os
from glob import glob
import numpy as np
from PIL import Image
import pickle
from tqdm import tqdm_notebook, tqdm
from models.network import U_Net, R2U_Net, AttU_Net, R2AttU_Net
from models.linknet import LinkNet34
from models.deeplabv3.deeplabv3plus import DeepLabV3Plus
from backboned_unet import U... | [
"matplotlib.pyplot.title",
"numpy.sum",
"matplotlib.pyplot.suptitle",
"pickle.load",
"torchvision.transforms.Normalize",
"torch.no_grad",
"segmentation_models_pytorch.Unet",
"matplotlib.pyplot.imshow",
"torch.load",
"models.deeplabv3.deeplabv3plus.DeepLabV3Plus",
"models.Transpose_unet.unet.mode... | [((12300, 12357), 'sklearn.model_selection.StratifiedKFold', 'StratifiedKFold', ([], {'n_splits': '(5)', 'shuffle': '(True)', 'random_state': '(1)'}), '(n_splits=5, shuffle=True, random_state=1)\n', (12315, 12357), False, 'from sklearn.model_selection import KFold, StratifiedKFold\n'), ((6888, 6922), 'torchvision.trans... |
from dataclasses import dataclass
import functions as fx
import glow.gwas.log_reg as lr
import glow.gwas.approx_firth as af
import pandas as pd
from nptyping import Float, NDArray
import numpy as np
import pytest
from typing import Any
@dataclass
class TestData:
phenotypes: NDArray[(Any, ), Float]
covariates:... | [
"numpy.allclose",
"numpy.zeros",
"numpy.isnan",
"functions.compare_to_regenie",
"glow.gwas.approx_firth._fit_firth",
"pandas.read_table",
"glow.gwas.log_reg.logistic_regression",
"pytest.mark.min_spark",
"functions.get_input_dfs"
] | [((4970, 4996), 'pytest.mark.min_spark', 'pytest.mark.min_spark', (['"""3"""'], {}), "('3')\n", (4991, 4996), False, 'import pytest\n'), ((5345, 5371), 'pytest.mark.min_spark', 'pytest.mark.min_spark', (['"""3"""'], {}), "('3')\n", (5366, 5371), False, 'import pytest\n'), ((5725, 5751), 'pytest.mark.min_spark', 'pytest... |
import cv2
import numpy as np
import os
def load_image(path: str) -> np.ndarray:
"""Загрузка ихображения
:param path: путь к файлу с изображением
:return: загруженное изображение
"""
if type(path) != str:
raise TypeError(f'Тип переменной path {type(path)} не является строкой')
if not... | [
"cv2.Canny",
"numpy.int0",
"cv2.cvtColor",
"os.path.exists",
"cv2.rectangle",
"cv2.imread",
"cv2.boxPoints",
"numpy.array",
"cv2.minAreaRect",
"cv2.inRange"
] | [((420, 436), 'cv2.imread', 'cv2.imread', (['path'], {}), '(path)\n', (430, 436), False, 'import cv2\n'), ((772, 795), 'numpy.array', 'np.array', (['[110, 50, 50]'], {}), '([110, 50, 50])\n', (780, 795), True, 'import numpy as np\n'), ((814, 839), 'numpy.array', 'np.array', (['[130, 255, 255]'], {}), '([130, 255, 255])... |
import numpy as np
import random
import pickle
class Loader:
@staticmethod
def load_train_set_and_test_set(path):
# loading training set features
with open(path + "/new/train_set_features.pkl", "rb") as f:
train_set_features2 = pickle.load(f)
# reducing feature vector len... | [
"numpy.std",
"random.shuffle",
"pickle.load",
"numpy.array"
] | [((348, 385), 'numpy.std', 'np.std', ([], {'a': 'train_set_features2', 'axis': '(0)'}), '(a=train_set_features2, axis=0)\n', (354, 385), True, 'import numpy as np\n'), ((991, 1027), 'numpy.std', 'np.std', ([], {'a': 'test_set_features2', 'axis': '(0)'}), '(a=test_set_features2, axis=0)\n', (997, 1027), True, 'import nu... |
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
class DataAugmentor:
"""
A class used for data augmentation (partially taken from : https://www.wouterbulten.nl/blog/tech/data-augmentation-using-tensorflow-data-dataset/)
Attributes
----------
batch : tf.Tensor, opti... | [
"tensorflow.random.set_seed",
"tensorflow.keras.backend.min",
"tensorflow.keras.preprocessing.image.ImageDataGenerator",
"numpy.random.seed",
"numpy.random.random_sample",
"tensorflow.clip_by_value",
"tensorflow.random.uniform",
"tensorflow.image.random_contrast",
"tensorflow.keras.backend.mean",
... | [((1028, 1057), 'tensorflow.random.set_seed', 'tf.random.set_seed', (['self.seed'], {}), '(self.seed)\n', (1046, 1057), True, 'import tensorflow as tf\n'), ((1066, 1091), 'numpy.random.seed', 'np.random.seed', (['self.seed'], {}), '(self.seed)\n', (1080, 1091), True, 'import numpy as np\n'), ((1318, 1368), 'tensorflow.... |
#!/usr/bin/env python
# coding: utf-8
# In[1]:
import os
project_name = "reco-tut-asr"; branch = "main"; account = "sparsh-ai"
project_path = os.path.join('/content', project_name)
if not os.path.exists(project_path):
get_ipython().system(u'cp /content/drive/MyDrive/mykeys.py /content')
import mykeys
ge... | [
"pandas.DataFrame",
"sys.path.append",
"numpy.isin",
"numpy.average",
"sklearn.tree.DecisionTreeRegressor",
"matplotlib.pyplot.hist",
"numpy.count_nonzero",
"pandas.read_csv",
"numpy.std",
"os.path.exists",
"numpy.isnan",
"sklearn.linear_model.LinearRegression",
"numpy.array",
"matplotlib.... | [((145, 183), 'os.path.join', 'os.path.join', (['"""/content"""', 'project_name'], {}), "('/content', project_name)\n", (157, 183), False, 'import os\n'), ((1218, 1256), 'pandas.read_csv', 'pd.read_csv', (['"""./data/silver/items.csv"""'], {}), "('./data/silver/items.csv')\n", (1229, 1256), True, 'import pandas as pd\n... |
"""Main module that contains SimulationOptimization class definition
.. module:: sim_opt.py
:synopsis: DWSIM simulation optimization class
.. moduleauthor:: <NAME> <<EMAIL>>
:Module: sim_opt.py
:Author: <NAME> <<EMAIL>>
"""
import numpy as np
import time
class SimulationOptimization():
"""Class that defines... | [
"numpy.asarray",
"numpy.zeros",
"time.sleep",
"pythoncom.CoInitialize",
"numpy.append",
"clr.AddReference",
"numpy.array",
"numpy.linalg.norm"
] | [((1505, 1531), 'numpy.array', 'np.array', (['[]'], {'dtype': 'object'}), '([], dtype=object)\n', (1513, 1531), True, 'import numpy as np\n'), ((1882, 1894), 'numpy.array', 'np.array', (['[]'], {}), '([])\n', (1890, 1894), True, 'import numpy as np\n'), ((1916, 1928), 'numpy.array', 'np.array', (['[]'], {}), '([])\n', ... |
#
# Copyright 2016 The BigDL Authors.
#
# 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 ... | [
"copy.deepcopy",
"pandas.read_csv",
"numpy.savetxt",
"numpy.zeros",
"numpy.array"
] | [((1669, 1757), 'pandas.read_csv', 'pd.read_csv', (['train_file_name'], {'names': 'COLUMNS', 'skipinitialspace': '(True)', 'engine': '"""python"""'}), "(train_file_name, names=COLUMNS, skipinitialspace=True, engine=\n 'python')\n", (1680, 1757), True, 'import pandas as pd\n'), ((1849, 1948), 'pandas.read_csv', 'pd.r... |
import tensorflow as tf
import tensorflow_addons as tfa
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
from sklearn import metrics
from sklearn import preprocessing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
i... | [
"argparse.ArgumentParser",
"tensorflow.keras.layers.Dropout",
"tensorflow.keras.layers.Dense",
"pandas.read_csv",
"sklearn.model_selection.train_test_split",
"protobuf.api_pb2.ModelResults",
"sklearn.preprocessing.MinMaxScaler",
"grpc.insecure_channel",
"protobuf.api_pb2.Empty",
"time.sleep",
"s... | [((588, 613), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (611, 613), False, 'import argparse\n'), ((917, 929), 'tensorflow.keras.models.Sequential', 'Sequential', ([], {}), '()\n', (927, 929), False, 'from tensorflow.keras.models import Sequential\n'), ((1942, 2100), 'pandas.read_csv', 'pd.... |
import pytest
import os
import numpy as np
import pyscal.core as pc
import pyscal.crystal_structures as pcs
def test_q_4():
atoms, boxdims = pcs.make_crystal('bcc', repetitions = [4, 4, 4])
sys = pc.System()
sys.atoms = atoms
sys.box = boxdims
#sys.get_neighbors(method = 'voronoi')
... | [
"pyscal.crystal_structures.make_crystal",
"numpy.array",
"pyscal.core.System"
] | [((153, 199), 'pyscal.crystal_structures.make_crystal', 'pcs.make_crystal', (['"""bcc"""'], {'repetitions': '[4, 4, 4]'}), "('bcc', repetitions=[4, 4, 4])\n", (169, 199), True, 'import pyscal.crystal_structures as pcs\n'), ((213, 224), 'pyscal.core.System', 'pc.System', ([], {}), '()\n', (222, 224), True, 'import pysca... |
# -*- coding: utf-8 -*-
"""
Created on Sun May 15 22:37:00 2016
@author: <NAME>
"""
import random
import time
import numpy
from solution import solution
def PSO(objf, lb, ub, dim, popSize, iters):
# PSO parameters
vMax = 6
wMax = 0.9
wMin = 0.2
c1 = 2
c2 = 2
s = solution()
if... | [
"numpy.random.uniform",
"solution.solution",
"numpy.zeros",
"time.strftime",
"numpy.clip",
"time.time",
"random.random"
] | [((303, 313), 'solution.solution', 'solution', ([], {}), '()\n', (311, 313), False, 'from solution import solution\n'), ((485, 512), 'numpy.zeros', 'numpy.zeros', (['(popSize, dim)'], {}), '((popSize, dim))\n', (496, 512), False, 'import numpy\n'), ((531, 551), 'numpy.zeros', 'numpy.zeros', (['popSize'], {}), '(popSize... |
from trame import get_app_instance
from trame.html import AbstractElement, Template
try:
import numpy as np
from numbers import Number
except:
# dataframe_to_grid won't work
pass
# Make sure used module is available
_app = get_app_instance()
if "vuetify" not in _app.vue_use:
_app.vue_use += ["vuet... | [
"trame.get_app_instance",
"trame.html.Template.slot_names.update",
"numpy.isinf",
"numpy.isnan"
] | [((241, 259), 'trame.get_app_instance', 'get_app_instance', ([], {}), '()\n', (257, 259), False, 'from trame import get_app_instance\n'), ((3125, 3163), 'trame.html.Template.slot_names.update', 'Template.slot_names.update', (['slot_names'], {}), '(slot_names)\n', (3151, 3163), False, 'from trame.html import AbstractEle... |
# probability.py
import scipy
import numpy as np
################################################################################
# Functions:
# Phi
# T
# SkewNorm
# SampleSkewNorm
################################################################################
def Phi(x, m, s, a):
return 0.5 * (1. + scipy.speci... | [
"numpy.random.rand",
"scipy.optimize.newton",
"scipy.integrate.quad"
] | [((962, 978), 'numpy.random.rand', 'np.random.rand', ([], {}), '()\n', (976, 978), True, 'import numpy as np\n'), ((1134, 1164), 'scipy.optimize.newton', 'scipy.optimize.newton', (['func', '(0)'], {}), '(func, 0)\n', (1155, 1164), False, 'import scipy\n'), ((459, 488), 'scipy.integrate.quad', 'scipy.integrate.quad', ([... |
"""
desispec.fiberbitmasking
==============
Functions to properly take FIBERSTATUS into account in the variances for data reduction
"""
from __future__ import absolute_import, division
import numpy as np
from astropy.table import Table
from desiutil.log import get_logger
from desispec.maskbits import fibermask as fm... | [
"desiutil.log.get_logger",
"astropy.table.Table",
"numpy.int32"
] | [((2333, 2354), 'astropy.table.Table', 'Table', (['frame.fibermap'], {}), '(frame.fibermap)\n', (2338, 2354), False, 'from astropy.table import Table\n'), ((2401, 2413), 'desiutil.log.get_logger', 'get_logger', ([], {}), '()\n', (2411, 2413), False, 'from desiutil.log import get_logger\n'), ((2780, 2797), 'numpy.int32'... |
import math
import torch
import gpytorch
import numpy as np
import random
from matplotlib import pyplot as plt
from pssgp.kernels import MyMaternKernel
from unittest import TestCase
# We will use the simplest form of GP model, exact inference
class ExactGPModel(gpytorch.models.ExactGP):
def __init__(self, train_x... | [
"numpy.random.seed",
"gpytorch.distributions.MultivariateNormal",
"gpytorch.mlls.ExactMarginalLogLikelihood",
"math.sqrt",
"torch.manual_seed",
"gpytorch.settings.fast_pred_var",
"pssgp.kernels.MyMaternKernel",
"gpytorch.kernels.MaternKernel",
"random.seed",
"gpytorch.likelihoods.GaussianLikelihoo... | [((1210, 1269), 'gpytorch.mlls.ExactMarginalLogLikelihood', 'gpytorch.mlls.ExactMarginalLogLikelihood', (['likelihood', 'model'], {}), '(likelihood, model)\n', (1250, 1269), False, 'import gpytorch\n'), ((453, 482), 'gpytorch.means.ConstantMean', 'gpytorch.means.ConstantMean', ([], {}), '()\n', (480, 482), False, 'impo... |
import matplotlib as mpl
import numpy as np
import pandas
import sys
from matplotlib import pyplot as pp
from pprint import pprint
from prep_data import get_raw_xy
from prep_data import get_vpo
sizes = [[15, 8, 10], [20, 10, 20]]
sidx = 1
def setup_plot(sidx=sidx, yfrom=1973, yto=2020, step=4, xls=sizes[sidx][2]):
... | [
"matplotlib.pyplot.title",
"matplotlib.rc",
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"prep_data.get_raw_xy",
"pandas.read_csv",
"matplotlib.pyplot.style.use",
"prep_data.get_vpo",
"numpy.array",
"matplotlib.pyplot.gca",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matp... | [((376, 406), 'matplotlib.rc', 'mpl.rc', (['"""xtick"""'], {'labelsize': 'xls'}), "('xtick', labelsize=xls)\n", (382, 406), True, 'import matplotlib as mpl\n'), ((411, 452), 'matplotlib.rc', 'mpl.rc', (['"""ytick"""'], {'labelsize': 'sizes[sidx][2]'}), "('ytick', labelsize=sizes[sidx][2])\n", (417, 452), True, 'import ... |
# this code performes a dimension reduction on the dataset,
# using a DenseNet121 pretrained model.
import tensorflow as tf
from scipy.io import loadmat, savemat
import numpy as np
FV = loadmat('images.mat')
data = FV['data']
labels = FV['labels']
print(data.shape)
labels = labels.transpose()
labels = labels.ravel()... | [
"scipy.io.loadmat",
"tensorflow.keras.Input",
"scipy.io.savemat",
"tensorflow.keras.models.Model",
"numpy.array",
"tensorflow.keras.layers.GlobalAveragePooling2D",
"tensorflow.keras.applications.DenseNet121"
] | [((189, 210), 'scipy.io.loadmat', 'loadmat', (['"""images.mat"""'], {}), "('images.mat')\n", (196, 210), False, 'from scipy.io import loadmat, savemat\n'), ((350, 385), 'tensorflow.keras.Input', 'tf.keras.Input', ([], {'shape': '(224, 224, 3)'}), '(shape=(224, 224, 3))\n', (364, 385), True, 'import tensorflow as tf\n')... |
import numpy as np
from matplotlib import pyplot as plt
from ..Xfit.basic import fitline, fitline0, fitconstant
from ..Xfit.MCMC_straight_line import mcmc_sl
from ..Xfit.fit_basic import fit_basic
from ..Xplot.niceplot import niceplot
from matplotlib.offsetbox import AnchoredText
from matplotlib import ticker
def plo... | [
"matplotlib.offsetbox.AnchoredText",
"numpy.zeros",
"numpy.isfinite",
"numpy.hstack",
"numpy.min",
"numpy.max",
"numpy.array",
"numpy.arange",
"numpy.linspace",
"numpy.ma.masked_array",
"numpy.mean",
"matplotlib.pyplot.subplots",
"numpy.delete",
"numpy.sqrt"
] | [((2329, 2347), 'numpy.arange', 'np.arange', (['qv.size'], {}), '(qv.size)\n', (2338, 2347), True, 'import numpy as np\n'), ((1386, 1413), 'numpy.arange', 'np.arange', (['(modes - 1)', 'modes'], {}), '(modes - 1, modes)\n', (1395, 1413), True, 'import numpy as np\n'), ((1438, 1453), 'numpy.array', 'np.array', (['modes'... |
import numpy as np
import os
import shutil
import tempfile
import unittest
import yt
from yt.utilities.exceptions import \
YTProfileDataShape
from yt.data_objects.particle_filters import add_particle_filter
from yt.data_objects.profiles import Profile1D, Profile2D, Profile3D,\
create_profile
from yt.testing im... | [
"numpy.nan_to_num",
"yt.YTQuantity",
"yt.data_objects.profiles.Profile2D",
"numpy.ones",
"numpy.isnan",
"numpy.random.normal",
"shutil.rmtree",
"os.chdir",
"yt.data_objects.profiles.create_profile",
"yt.testing.assert_equal",
"yt.load_particles",
"yt.testing.fake_random_ds",
"tempfile.mkdtem... | [((15715, 15741), 'yt.testing.requires_module', 'requires_module', (['"""astropy"""'], {}), "('astropy')\n", (15730, 15741), False, 'from yt.testing import assert_equal, assert_raises, assert_rel_equal, fake_random_ds, requires_module\n'), ((16912, 16937), 'yt.testing.requires_module', 'requires_module', (['"""pandas""... |
import logging
import os
import cv2
import numpy as np
import inferencing_pb2
import media_pb2
import extension_pb2
import extension_pb2_grpc
# import timeit as t
from enum import Enum
from shared_memory import SharedMemoryManager
from exception_handler import PrintGetExceptionDetails
from model_wrapper import Yolo... | [
"cv2.imwrite",
"numpy.frombuffer",
"shared_memory.SharedMemoryManager",
"extension_pb2.MediaStreamMessage",
"media_pb2.MediaDescriptor",
"model_wrapper.YoloV4Model",
"logging.info",
"inferencing_pb2.Tag",
"numpy.array",
"inferencing_pb2.Rectangle",
"os.getenv",
"exception_handler.PrintGetExcep... | [((489, 507), 'os.getenv', 'os.getenv', (['"""DEBUG"""'], {}), "('DEBUG')\n", (498, 507), False, 'import os\n'), ((2192, 2205), 'model_wrapper.YoloV4Model', 'YoloV4Model', ([], {}), '()\n', (2203, 2205), False, 'from model_wrapper import YoloV4Model\n'), ((3403, 3439), 'cv2.imwrite', 'cv2.imwrite', (['outputFileName', ... |
import numpy as np
import os
# lib from Qiskit Aqua
# from qiskit.aqua import Operator, QuantumInstance
# from qiskit.aqua.algorithms import VQE, ExactEigensolver
# from qiskit.aqua.components.optimizers import COBYLA
from qiskit.aqua.operators import Z2Symmetries
from qiskit.circuit.instruction import Instruction
# li... | [
"qiskit.chemistry.components.variational_forms.UCCSD",
"qiskit.chemistry.FermionicOperator",
"qiskit.chemistry.components.initial_states.HartreeFock",
"torchquantum.plugins.qiskit2tq",
"qiskit.chemistry.drivers.PySCFDriver",
"pdb.set_trace",
"numpy.random.rand",
"qiskit.aqua.operators.Z2Symmetries.two... | [((710, 1004), 'torchquantum.plugins.qiskit_processor.QiskitProcessor', 'QiskitProcessor', ([], {'use_real_qc': '(False)', 'backend_name': 'None', 'noise_model_name': 'None', 'coupling_map_name': 'None', 'basis_gates_name': 'None', 'n_shots': '(8192)', 'initial_layout': 'None', 'seed_transpiler': '(42)', 'seed_simulato... |
# -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# Copyright (c) 2014, <NAME>. All rights reserved.
# Distributed under the terms of the new BSD License.
# -----------------------------------------------------------------------------
"""
An ArrayList is a strongly ... | [
"numpy.resize",
"numpy.log2",
"numpy.zeros",
"numpy.ones",
"numpy.array"
] | [((2573, 2599), 'numpy.array', 'np.array', (['data'], {'copy': '(False)'}), '(data, copy=False)\n', (2581, 2599), True, 'import numpy as np\n'), ((3563, 3594), 'numpy.zeros', 'np.zeros', (['(self._count, 2)', 'int'], {}), '((self._count, 2), int)\n', (3571, 3594), True, 'import numpy as np\n'), ((3747, 3771), 'numpy.ze... |
import lightgbm as lgb
import numpy as np
import pandas as pd
from attrdict import AttrDict
from sklearn.externals import joblib
from steppy.base import BaseTransformer
from .utils import NeptuneContext, get_logger
neptune_ctx = NeptuneContext()
logger = get_logger()
class LightGBM(BaseTransformer):
def __init_... | [
"sklearn.externals.joblib.dump",
"lightgbm.train",
"lightgbm.Dataset",
"numpy.array",
"sklearn.externals.joblib.load"
] | [((1858, 1970), 'lightgbm.Dataset', 'lgb.Dataset', ([], {'data': 'X', 'label': 'y', 'feature_name': 'feature_names', 'categorical_feature': 'categorical_features'}), '(data=X, label=y, feature_name=feature_names,\n categorical_feature=categorical_features, **kwargs)\n', (1869, 1970), True, 'import lightgbm as lgb\n'... |
# -*- coding: utf-8 -*-
# Copyright 2018 <NAME> & <NAME>. All Rights Reserved.
#
# 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
#
#... | [
"numpy.zeros_like",
"numpy.maximum",
"numpy.tanh",
"numpy.ones_like",
"numpy.square",
"numpy.sin",
"numpy.array",
"numpy.exp",
"numpy.arctan"
] | [((725, 736), 'numpy.array', 'np.array', (['x'], {}), '(x)\n', (733, 736), True, 'import numpy as np\n'), ((749, 765), 'numpy.maximum', 'np.maximum', (['(0)', 'x'], {}), '(0, x)\n', (759, 765), True, 'import numpy as np\n'), ((805, 816), 'numpy.array', 'np.array', (['x'], {}), '(x)\n', (813, 816), True, 'import numpy a... |
import numpy as np
import pytest
from numpy import linalg
import numpy.testing as npt
import itertools
from utils import get_rstate, get_printing
import dynesty # noqa
from dynesty import utils as dyfunc # noqa
"""
Run a series of basic tests to check whether anything huge is broken.
"""
nlive = 500
printing = get... | [
"numpy.abs",
"dynesty.utils.mean_and_cov",
"dynesty.DynamicNestedSampler",
"dynesty.utils.jitter_run",
"numpy.exp",
"utils.get_printing",
"dynesty.utils.unravel_run",
"numpy.std",
"numpy.identity",
"numpy.linspace",
"dynesty.utils.simulate_run",
"itertools.product",
"numpy.linalg.det",
"nu... | [((317, 331), 'utils.get_printing', 'get_printing', ([], {}), '()\n', (329, 331), False, 'from utils import get_rstate, get_printing\n'), ((520, 560), 'numpy.exp', 'np.exp', (['(results.logwt - results.logz[-1])'], {}), '(results.logwt - results.logz[-1])\n', (526, 560), True, 'import numpy as np\n'), ((1451, 1491), 'n... |
# Copyright (c) 2019-2021, <NAME>, <NAME>, <NAME>, and <NAME>.
#
# Distributed under the 3-clause BSD license, see accompanying file LICENSE
# or https://github.com/scikit-hep/vector for details.
import numpy
from vector.compute.planar import x, y
from vector.compute.spatial import z
from vector.methods import (
... | [
"vector.methods._ltype",
"vector.methods._aztype",
"numpy.errstate"
] | [((3109, 3137), 'numpy.errstate', 'numpy.errstate', ([], {'all': '"""ignore"""'}), "(all='ignore')\n", (3123, 3137), False, 'import numpy\n'), ((3044, 3056), 'vector.methods._aztype', '_aztype', (['vec'], {}), '(vec)\n', (3051, 3056), False, 'from vector.methods import AzimuthalRhoPhi, AzimuthalXY, LongitudinalEta, Lon... |
import os
import pytest
import tempfile
import pickle
import numpy as np
from ogindia.utils import comp_array, comp_scalar, dict_compare
from ogindia.get_micro_data import get_calculator
from ogindia import SS, TPI, utils
from ogindia.parameters import Specifications
from taxcalc import GrowFactors
TOL = 1e-5
CUR_PAT... | [
"tempfile.NamedTemporaryFile",
"os.remove",
"ogindia.TPI.run_TPI",
"ogindia.execute.runner",
"os.makedirs",
"taxcalc.GrowFactors",
"os.path.dirname",
"numpy.allclose",
"ogindia.utils.pickle_file_compare",
"ogindia.utils.dict_compare",
"ogindia.parameters.Specifications",
"ogindia.SS.run_SS",
... | [((1635, 1705), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""time_path"""', '[False, True]'], {'ids': "['SS', 'TPI']"}), "('time_path', [False, True], ids=['SS', 'TPI'])\n", (1658, 1705), False, 'import pytest\n'), ((340, 365), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (35... |
import multiprocessing
import sys
import torch.optim as optim
import numpy as np
from functools import partial
from src.base_model import BaseModel
from src.networks import Destilation_student_matchingInstance
from src.utils import save_images
from src.utils import bland_altman_loss, dice_soft_loss, ss_loss, generate_a... | [
"functools.partial",
"src.networks.Destilation_student_matchingInstance",
"numpy.copy",
"src.utils.apply_transform",
"src.utils.generate_affine",
"multiprocessing.Pool",
"torch.optim.lr_scheduler.MultiStepLR"
] | [((797, 871), 'src.networks.Destilation_student_matchingInstance', 'Destilation_student_matchingInstance', (['(self.cf.labels - 1)', 'self.cf.channels'], {}), '(self.cf.labels - 1, self.cf.channels)\n', (833, 871), False, 'from src.networks import Destilation_student_matchingInstance\n'), ((1152, 1246), 'torch.optim.lr... |
import inspect
import logging
import os
from itertools import product
from multiprocessing import JoinableQueue, Process
from queue import Empty
import numpy as np
import torch
import torch.nn.functional as F
from pandas import DataFrame
from fonduer.learning.models.marginal import Marginal
logger = logging.getLogge... | [
"numpy.concatenate",
"numpy.ravel",
"numpy.argmax",
"torch.nn.functional.cross_entropy",
"logging.getLogger",
"numpy.random.RandomState",
"multiprocessing.Process.__init__",
"numpy.where",
"numpy.array",
"inspect.getargspec",
"pandas.DataFrame.from_records",
"itertools.product",
"numpy.vstac... | [((304, 331), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (321, 331), False, 'import logging\n'), ((1080, 1107), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1097, 1107), False, 'import logging\n'), ((1986, 2013), 'fonduer.learning.models.marginal.Marg... |
from argparse import ArgumentParser
import numpy as np
import requests
from mmcls.apis import inference_model, init_model, show_result_pyplot
def parse_args():
parser = ArgumentParser()
parser.add_argument('img', help='Image file')
parser.add_argument('config', help='Config file')
parser.add_argumen... | [
"argparse.ArgumentParser",
"numpy.allclose",
"mmcls.apis.inference_model",
"mmcls.apis.show_result_pyplot",
"requests.post",
"mmcls.apis.init_model"
] | [((177, 193), 'argparse.ArgumentParser', 'ArgumentParser', ([], {}), '()\n', (191, 193), False, 'from argparse import ArgumentParser\n'), ((798, 858), 'mmcls.apis.init_model', 'init_model', (['args.config', 'args.checkpoint'], {'device': 'args.device'}), '(args.config, args.checkpoint, device=args.device)\n', (808, 858... |
## @package teetool
# This module contains the GaussianProcess class
#
# See GaussianProcess class for more details
import teetool as tt
import numpy as np
from numpy.linalg import det, inv, pinv, cond
## GaussianProcess class evaluates an ensemble of trajectories as a Gaussian process
#
# Such a Gaussian process... | [
"teetool.helpers.nearest_spd",
"numpy.abs",
"numpy.diagflat",
"numpy.empty",
"numpy.ones",
"numpy.linalg.cond",
"numpy.interp",
"numpy.mat",
"numpy.linalg.pinv",
"teetool.helpers.get_cluster_data_norm",
"numpy.zeros_like",
"numpy.multiply",
"numpy.isfinite",
"numpy.reshape",
"numpy.linsp... | [((850, 899), 'teetool.helpers.get_cluster_data_outline', 'tt.helpers.get_cluster_data_outline', (['cluster_data'], {}), '(cluster_data)\n', (885, 899), True, 'import teetool as tt\n'), ((928, 983), 'teetool.helpers.get_cluster_data_norm', 'tt.helpers.get_cluster_data_norm', (['cluster_data', 'outline'], {}), '(cluster... |
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import cv2
import tensorflow as tf
from PIL import Image
import os
from sklearn.model_selection import train_test_split
from keras.utils import to_categorical
from keras.models import Sequential, load_model
from keras.layers import Conv2D, MaxPool... | [
"matplotlib.pyplot.title",
"pandas.read_csv",
"sklearn.model_selection.train_test_split",
"sklearn.metrics.accuracy_score",
"keras.layers.MaxPool2D",
"matplotlib.pyplot.figure",
"keras.layers.Flatten",
"keras.utils.to_categorical",
"matplotlib.pyplot.show",
"keras.layers.Dropout",
"matplotlib.py... | [((395, 406), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (404, 406), False, 'import os\n'), ((916, 930), 'numpy.array', 'np.array', (['data'], {}), '(data)\n', (924, 930), True, 'import numpy as np\n'), ((940, 956), 'numpy.array', 'np.array', (['labels'], {}), '(labels)\n', (948, 956), True, 'import numpy as np\n'), (... |
import io
import numpy as np
import pytest
from typing import List, Tuple
from mlagents_envs.communicator_objects.agent_info_pb2 import AgentInfoProto
from mlagents_envs.communicator_objects.observation_pb2 import (
ObservationProto,
NONE,
PNG,
)
from mlagents_envs.communicator_objects.brain_parameters_pb2... | [
"numpy.sum",
"mlagents_envs.communicator_objects.observation_pb2.ObservationProto",
"mlagents_envs.rpc_utils.behavior_spec_from_proto",
"numpy.allclose",
"mlagents_envs.communicator_objects.brain_parameters_pb2.BrainParametersProto",
"numpy.mean",
"mlagents_envs.base_env.ActionSpec.create_continuous",
... | [((2964, 2982), 'mlagents_envs.communicator_objects.observation_pb2.ObservationProto', 'ObservationProto', ([], {}), '()\n', (2980, 2982), False, 'from mlagents_envs.communicator_objects.observation_pb2 import ObservationProto, NONE, PNG\n'), ((3569, 3587), 'mlagents_envs.communicator_objects.observation_pb2.Observatio... |
#!/usr/bin/env python3 -u
# -*- coding: utf-8 -*-
# copyright: sktime developers, BSD-3-Clause License (see LICENSE file)
from logging import warning
import numpy as np
import pandas as pd
from sklearn.utils import check_array, check_consistent_length
from sktime.datatypes import check_is_scitype, convert
from sktime... | [
"pandas.DataFrame",
"sktime.datatypes.check_is_scitype",
"numpy.isin",
"numpy.average",
"sklearn.utils.check_array",
"logging.warning",
"numpy.asarray",
"sktime.datatypes.convert",
"pandas.MultiIndex.from_product",
"pandas.Series",
"numpy.tile",
"sklearn.utils.check_consistent_length",
"nump... | [((10207, 10236), 'pandas.Series', 'pd.Series', ([], {'index': 'y_pred.index'}), '(index=y_pred.index)\n', (10216, 10236), True, 'import pandas as pd\n'), ((10848, 10887), 'sklearn.utils.check_consistent_length', 'check_consistent_length', (['y_true', 'y_pred'], {}), '(y_true, y_pred)\n', (10871, 10887), False, 'from s... |
import time
import numpy as np
import torch
from onpolicy.runner.shared.base_runner import Runner
import wandb
import imageio
def _t2n(x):
return x.detach().cpu().numpy()
class MPERunner(Runner):
"""Runner class to perform training, evaluation. and data collection for the MPEs. See parent class for details.""... | [
"numpy.zeros",
"numpy.ones",
"numpy.expand_dims",
"time.time",
"time.sleep",
"numpy.mean",
"numpy.array",
"numpy.eye",
"torch.no_grad",
"numpy.concatenate"
] | [((3685, 3700), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (3698, 3700), False, 'import torch\n'), ((6358, 6373), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (6371, 6373), False, 'import torch\n'), ((8961, 8976), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (8974, 8976), False, 'import torch\n')... |
##############################################################################
# Institute for the Design of Advanced Energy Systems Process Systems
# Engineering Framework (IDAES PSE Framework) Copyright (c) 2018-2019, by the
# software owners: The Regents of the University of California, through
# Lawrence Berkeley N... | [
"idaes.surrogate.ripe.ems",
"idaes.surrogate.ripe.ripemodel",
"numpy.random.seed",
"numpy.zeros",
"numpy.array"
] | [((907, 925), 'numpy.random.seed', 'np.random.seed', (['(20)'], {}), '(20)\n', (921, 925), True, 'import numpy as np\n'), ((1634, 1768), 'idaes.surrogate.ripe.ripemodel', 'ripe.ripemodel', (['cdata'], {'stoich': 'stoich', 'mechanisms': 'mechs', 'x0': 'cdata0', 'hide_output': '(False)', 'sigma': 'sigma', 'deltaterm': '(... |
import matplotlib
matplotlib.use('WXAgg')
from matplotlib import cm
import matplotlib.pyplot as plt
import numpy as np
import CoolProp
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure(figsize = (2,2))
ax = fig.add_subplot(111, projection='3d')
NT = 1000
NR = 1000
rho,t = np.logspace(np.log10(2e-3), np.log10(1... | [
"numpy.meshgrid",
"numpy.log",
"matplotlib.pyplot.close",
"CoolProp.CoolProp.PropsSI",
"matplotlib.pyplot.figure",
"matplotlib.use",
"numpy.linspace",
"numpy.log10",
"matplotlib.pyplot.tight_layout",
"matplotlib.pyplot.savefig"
] | [((18, 41), 'matplotlib.use', 'matplotlib.use', (['"""WXAgg"""'], {}), "('WXAgg')\n", (32, 41), False, 'import matplotlib\n'), ((182, 208), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(2, 2)'}), '(figsize=(2, 2))\n', (192, 208), True, 'import matplotlib.pyplot as plt\n'), ((365, 384), 'numpy.meshgrid', ... |
from __future__ import division
import sys
import pytest
import numpy as np
from datashader.glyphs import Glyph
from datashader.glyphs.line import _build_draw_segment, \
_build_map_onto_pixel_for_line
from datashader.utils import ngjit
py2_skip = pytest.mark.skipif(sys.version_info.major < 3, reason="py2 not s... | [
"datashader.glyphs.Glyph._expand_aggs_and_cols",
"numpy.zeros",
"pytest.mark.benchmark",
"pytest.mark.skipif",
"datashader.utils.ngjit",
"datashader.glyphs.line._build_map_onto_pixel_for_line",
"datashader.glyphs.line._build_draw_segment"
] | [((256, 330), 'pytest.mark.skipif', 'pytest.mark.skipif', (['(sys.version_info.major < 3)'], {'reason': '"""py2 not supported"""'}), "(sys.version_info.major < 3, reason='py2 not supported')\n", (274, 330), False, 'import pytest\n'), ((342, 360), 'datashader.utils.ngjit', 'ngjit', (['(lambda x: x)'], {}), '(lambda x: x... |
import time
import numpy as np
from pyembree import rtcore_scene as rtcs
from pyembree.mesh_construction import TriangleMesh
N = 4
def xplane(x):
return [[[x, -1.0, -1.0],
[x, +1.0, -1.0],
[x, -1.0, +1.0]],
[[x, +1.0, -1.0],
[x, +1.0, +1.0],
[x, -1... | [
"pyembree.rtcore_scene.EmbreeScene",
"numpy.zeros",
"time.time",
"numpy.array",
"pyembree.mesh_construction.TriangleMesh",
"numpy.vstack"
] | [((370, 400), 'numpy.array', 'np.array', (['triangles', '"""float32"""'], {}), "(triangles, 'float32')\n", (378, 400), True, 'import numpy as np\n'), ((410, 428), 'pyembree.rtcore_scene.EmbreeScene', 'rtcs.EmbreeScene', ([], {}), '()\n', (426, 428), True, 'from pyembree import rtcore_scene as rtcs\n'), ((436, 466), 'py... |
import numpy as np
import pandas as pd
import read_data as rd
import argparse
import os
import time
import sklearn
from sklearn.externals import joblib
from sklearn.metrics import precision_recall_curve
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
def prepare_data(df=N... | [
"sklearn.externals.joblib.dump",
"numpy.abs",
"argparse.ArgumentParser",
"pandas.read_csv",
"sklearn.ensemble.GradientBoostingRegressor",
"time.strftime",
"numpy.exp",
"read_data.read_data",
"pandas.DataFrame",
"read_data.date_lookup",
"os.path.exists",
"sklearn.preprocessing.LabelEncoder",
... | [((10726, 10750), 'numpy.linspace', 'np.linspace', (['cut', '(50)', '(10)'], {}), '(cut, 50, 10)\n', (10737, 10750), True, 'import numpy as np\n'), ((11068, 11098), 'numpy.linspace', 'np.linspace', (['cut', '(cut / 2)', '(100)'], {}), '(cut, cut / 2, 100)\n', (11079, 11098), True, 'import numpy as np\n'), ((12418, 1247... |
# This function is copied from https://github.com/Rubikplayer/flame-fitting
'''
Copyright 2015 <NAME>, <NAME> and the Max Planck Gesellschaft. All rights reserved.
This software is provided for research purposes only.
By using this software you agree to the terms of the SMPL Model license here http://smpl.is.tue... | [
"chumpy.eye",
"cv2.Rodrigues",
"numpy.array",
"numpy.eye"
] | [((832, 856), 'cv2.Rodrigues', 'cv2.Rodrigues', (['self.rt.r'], {}), '(self.rt.r)\n', (845, 856), False, 'import cv2\n'), ((946, 970), 'cv2.Rodrigues', 'cv2.Rodrigues', (['self.rt.r'], {}), '(self.rt.r)\n', (959, 970), False, 'import cv2\n'), ((1329, 1338), 'chumpy.eye', 'ch.eye', (['(3)'], {}), '(3)\n', (1335, 1338), ... |
import os
from pathlib import Path
import pandas as pd
import numpy as np
import math
from parsing import split_tmp, split_wnd, split_ceil, split_vis, split_liquid_precip, split_snow
def see_maps_location(lat, lon):
print(f'https://www.google.com.au/maps/search/{lat},{lon}')
def get_complete_station_years(path... | [
"pandas.DataFrame",
"os.listdir",
"parsing.split_wnd",
"math.sqrt",
"pandas.read_csv",
"math.radians",
"pandas.merge",
"parsing.split_vis",
"parsing.split_tmp",
"parsing.split_liquid_precip",
"math.sin",
"parsing.split_ceil",
"pathlib.Path",
"parsing.split_snow",
"pandas.concat",
"nump... | [((414, 428), 'pandas.DataFrame', 'pd.DataFrame', ([], {}), '()\n', (426, 428), True, 'import pandas as pd\n'), ((441, 465), 'os.listdir', 'os.listdir', (["(path / 'raw')"], {}), "(path / 'raw')\n", (451, 465), False, 'import os\n'), ((1817, 1840), 'parsing.split_liquid_precip', 'split_liquid_precip', (['df'], {}), '(d... |
import torch
import numpy as np
import pandas as pd
import os
from RBM import RBM
from load_dataset import MNIST
import cv2
from PIL import Image
from matplotlib import pyplot as plt
def image_beautifier(names, final_name):
image_names = sorted(names)
images = [Image.open(x) for x in names]
widths, heights = zip(*... | [
"matplotlib.pyplot.title",
"PIL.Image.new",
"matplotlib.pyplot.savefig",
"load_dataset.MNIST",
"RBM.RBM",
"cv2.imwrite",
"matplotlib.pyplot.imshow",
"PIL.Image.open",
"cv2.imread",
"numpy.mean",
"numpy.array",
"numpy.reshape",
"matplotlib.pyplot.cla",
"numpy.where",
"cv2.resize"
] | [((410, 453), 'PIL.Image.new', 'Image.new', (['"""RGB"""', '(total_width, max_height)'], {}), "('RGB', (total_width, max_height))\n", (419, 453), False, 'from PIL import Image\n'), ((579, 601), 'cv2.imread', 'cv2.imread', (['final_name'], {}), '(final_name)\n', (589, 601), False, 'import cv2\n'), ((609, 664), 'cv2.resi... |
from setuptools import setup, find_packages
from setuptools.extension import Extension
from Cython.Build import cythonize
import numpy.distutils.misc_util
import argparse
import sys, os
import numpy as np
print(sys.argv)
parser = argparse.ArgumentParser(description='Build Cython Extension for CPU')
parser.add_argument... | [
"setuptools.setup",
"argparse.ArgumentParser",
"os.path.isdir",
"setuptools.extension.Extension",
"os.path.isfile",
"numpy.get_include",
"os.path.join",
"os.listdir",
"sys.exit"
] | [((231, 300), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Build Cython Extension for CPU"""'}), "(description='Build Cython Extension for CPU')\n", (254, 300), False, 'import argparse\n'), ((2139, 2328), 'setuptools.setup', 'setup', ([], {'name': '"""kokkos_cpu"""', 'packages': "['kok... |
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 16 11:52:12 2019
@author: z5095790
"""
import numpy as np
import copy
import pickle
import os
from keras.models import load_model
class Node:
"""Binary tree with Ture and False Branches"""
def __init__(self, col=-1, value = None, parentID = None, ... | [
"keras.models.load_model",
"copy.deepcopy",
"numpy.zeros",
"pickle.load",
"numpy.matmul",
"os.listdir",
"numpy.vstack"
] | [((852, 868), 'keras.models.load_model', 'load_model', (['path'], {}), '(path)\n', (862, 868), False, 'from keras.models import load_model\n'), ((2177, 2198), 'copy.deepcopy', 'copy.deepcopy', (['weight'], {}), '(weight)\n', (2190, 2198), False, 'import copy\n'), ((2227, 2246), 'copy.deepcopy', 'copy.deepcopy', (['bias... |
import numpy as np
from finitewave.core.fibrosis import FibrosisPattern
class ScarGauss2DPattern(FibrosisPattern):
def __init__(self, mean, std, corr, size):
self.mean = mean
self.std = std
self.corr = corr
self.size = size
def generate(self, size, mesh=None):
if mesh... | [
"numpy.zeros",
"numpy.random.multivariate_normal"
] | [((349, 363), 'numpy.zeros', 'np.zeros', (['size'], {}), '(size)\n', (357, 363), True, 'import numpy as np\n'), ((517, 579), 'numpy.random.multivariate_normal', 'np.random.multivariate_normal', (['self.mean', 'self.covs', 'self.size'], {}), '(self.mean, self.covs, self.size)\n', (546, 579), True, 'import numpy as np\n'... |
"""
@Time: 2020/8/17 18:08
@Author: Zhirui(<NAME>
@E-mail: <EMAIL>
@Program:
"""
import os
import random
import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer
import tensorflow as tf
from tensorflow.keras import layers, optimizers
from tensorflow.keras.models import Sequential
from tenso... | [
"data_process.get_treat_info",
"numpy.abs",
"tensorflow.keras.layers.Dense",
"random.shuffle",
"tensorflow.keras.callbacks.ModelCheckpoint",
"tensorflow.keras.models.Sequential",
"os.path.join",
"tensorflow.keras.callbacks.EarlyStopping",
"pandas.DataFrame",
"sklearn.impute.SimpleImputer",
"pand... | [((356, 418), 'tensorflow.compat.v1.logging.set_verbosity', 'tf.compat.v1.logging.set_verbosity', (['tf.compat.v1.logging.ERROR'], {}), '(tf.compat.v1.logging.ERROR)\n', (390, 418), True, 'import tensorflow as tf\n'), ((703, 719), 'pandas.DataFrame', 'pd.DataFrame', (['{}'], {}), '({})\n', (715, 719), True, 'import pan... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Aug 13 12:10:41 2019
@author: reiters
"""
import numpy as np
#t1=np.load('/gpfs/laur/sepia_tools/PSGAN_textures/usedTextures/noiseBig_epoch_501_fc1.0_ngf80_ndf80_dep5-5.npy',None,'allow_pickle',True)
#t2=np.load('/gpfs/laur/sepia_tools/PSGAN_textures/... | [
"numpy.load",
"numpy.save",
"numpy.linspace"
] | [((689, 867), 'numpy.load', 'np.load', (['"""/gpfs/laur/sepia_tools/PSGAN_textures/best_paired_models/curtain_rocks1_evaluated/noiseBig_epoch_500_fc1.0_ngf80_ndf80_dep5-5.npy"""', 'None', '"""allow_pickle"""', '(True)'], {}), "(\n '/gpfs/laur/sepia_tools/PSGAN_textures/best_paired_models/curtain_rocks1_evaluated/noi... |
import abc
import csv
import uuid
import json
import os
import numpy as np
import requests
import joblib
import pandas
from scipy.sparse import csr_matrix
from tworaven_apps.solver_interfaces.models import SAVED_MODELS_PATH, R_SERVICE, get_metric, StatisticalModel
from tworaven_solver import Dataset
from collections... | [
"numpy.argmax",
"json.dumps",
"collections.defaultdict",
"tworaven_solver.model.BaseModelWrapper.load",
"h2o.import_file",
"requests.post",
"os.path.join",
"os.chdir",
"pandas.DataFrame",
"h2o.save_model",
"json.loads",
"h2o.init",
"os.path.exists",
"tworaven_apps.solver_interfaces.models.... | [((1390, 1431), 'os.path.join', 'os.path.join', (['SAVED_MODELS_PATH', 'model_id'], {}), '(SAVED_MODELS_PATH, model_id)\n', (1402, 1431), False, 'import os\n'), ((1456, 1504), 'os.path.join', 'os.path.join', (['model_folder_path', '"""metadata.json"""'], {}), "(model_folder_path, 'metadata.json')\n", (1468, 1504), Fals... |
# Copyright 2020 Huawei Technologies Co., Ltd
#
# 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... | [
"mindspore.ops.operations.SigmoidCrossEntropyWithLogits",
"mindspore.ops.operations.GatherNd",
"mindspore.Tensor",
"mindspore.ops.operations.Cast",
"mindspore.ops.operations.DType",
"mindspore.ops.operations.IOU",
"mindspore.nn.OneHot",
"mindspore.ops.operations.Fill",
"mindspore.ops.operations.Tran... | [((1055, 1071), 'mindspore.ops.operations.TupleToArray', 'P.TupleToArray', ([], {}), '()\n', (1069, 1071), True, 'from mindspore.ops import operations as P\n'), ((1419, 1426), 'mindspore.ops.operations.Sum', 'P.Sum', ([], {}), '()\n', (1424, 1426), True, 'from mindspore.ops import operations as P\n'), ((1447, 1475), 'm... |
# -*- coding: utf-8 -*-
"""
Basic and Monitor-Curve Exponent Transfer Functions
===================================================
Defines the exponent transfer functions:
- :func:`colour.models.exponent_function_basic`
- :func:`colour.models.exponent_function_monitor_curve`
References
----------
- :cite: `Th... | [
"colour.utilities.suppress_warnings",
"numpy.where",
"numpy.isnan",
"colour.utilities.as_float_array"
] | [((4646, 4663), 'colour.utilities.as_float_array', 'as_float_array', (['x'], {}), '(x)\n', (4660, 4663), False, 'from colour.utilities import as_float, as_float_array, suppress_warnings\n'), ((4679, 4703), 'colour.utilities.as_float_array', 'as_float_array', (['exponent'], {}), '(exponent)\n', (4693, 4703), False, 'fro... |
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# Last Change: Tue Jul 17 05:00 PM 2007 J
# The code and descriptive text is copyrighted and offered under the terms of
# the BSD License from the authors; see below. However, the actual dataset may
# have a different origin and intellectual property status. See the SOURC... | [
"os.path.dirname",
"numpy.array"
] | [((4312, 4331), 'numpy.array', 'np.array', (['nfeatures'], {}), '(nfeatures)\n', (4320, 4331), True, 'import numpy as np\n'), ((4432, 4475), 'numpy.array', 'np.array', (["[(lab == '+1') for lab in labels]"], {}), "([(lab == '+1') for lab in labels])\n", (4440, 4475), True, 'import numpy as np\n'), ((4094, 4111), 'os.pa... |
from __future__ import print_function, division
import abc
import numpy as np
class StreamProcessor(object):
"""Base class for stream processors"""
def __call__(self, items):
"""Processed the whole stream of items.
Args:
items (Iterable(object)) the stream of items to process.
... | [
"numpy.random.randint",
"numpy.random.random",
"numpy.random.seed"
] | [((917, 937), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (931, 937), True, 'import numpy as np\n'), ((1171, 1189), 'numpy.random.random', 'np.random.random', ([], {}), '()\n', (1187, 1189), True, 'import numpy as np\n'), ((1243, 1274), 'numpy.random.randint', 'np.random.randint', (['(0)', 'self.... |
import numpy as np
from config import FEEDRATE, X_STEP, Y_STEP, HEIGHT, WIDTH
# TO DO:
# * We assume that the head's nozzles extend along the Y direction.
# (This is apparently the case.)
def array_to_gcode(array):
"""Convert numpy array into a sequence of gcodes, saved to file."""
assert isinstanc... | [
"numpy.any",
"numpy.ceil",
"numpy.all"
] | [((1442, 1468), 'numpy.all', 'np.all', (['(firing_column == 0)'], {}), '(firing_column == 0)\n', (1448, 1468), True, 'import numpy as np\n'), ((477, 499), 'numpy.ceil', 'np.ceil', (['(height / 12.0)'], {}), '(height / 12.0)\n', (484, 499), True, 'import numpy as np\n'), ((1513, 1539), 'numpy.any', 'np.any', (['(firing_... |
import copy
from typing import List, Dict
import numpy as np
from prettytable import PrettyTable
from ase import Atoms
from dscribe.descriptors import SineMatrix
from dscribe.descriptors import CoulombMatrix
from dscribe.descriptors import ACSF
from dscribe.descriptors import SOAP
from matminer.featurizers.compositio... | [
"copy.deepcopy",
"pymatgen.io.ase.AseAtomsAdaptor",
"numpy.array",
"prettytable.PrettyTable",
"pymatgen.core.periodic_table.Element",
"numpy.concatenate"
] | [((2141, 2154), 'prettytable.PrettyTable', 'PrettyTable', ([], {}), '()\n', (2152, 2154), False, 'from prettytable import PrettyTable\n'), ((8201, 8213), 'numpy.array', 'np.array', (['[]'], {}), '([])\n', (8209, 8213), True, 'import numpy as np\n'), ((8007, 8024), 'pymatgen.io.ase.AseAtomsAdaptor', 'AseAtomsAdaptor', (... |
# coding=utf-8
# Copyright 2019 The Weak Disentangle Authors.
#
# 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 applica... | [
"tensorflow.random.uniform",
"tensorflow.random.normal",
"weak_disentangle.tensorsketch.utils.compute_fan",
"weak_disentangle.tensorsketch.utils.compute_out_dims",
"tensorflow.matmul",
"collections.OrderedDict",
"tensorflow.nn.bias_add",
"numpy.sqrt"
] | [((1612, 1625), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (1623, 1625), False, 'from collections import OrderedDict\n'), ((2172, 2200), 'weak_disentangle.tensorsketch.utils.compute_fan', 'tsu.compute_fan', (['self.kernel'], {}), '(self.kernel)\n', (2187, 2200), True, 'from weak_disentangle.tensorsketc... |
import streamlit as st
from collections import defaultdict
from kafka import KafkaConsumer
from json import loads
import time
import numpy as np
from datetime import datetime
import matplotlib.pyplot as plt
import plotly.graph_objects as go
import plotly.express as px
import pandas as pd
import PIL
from PIL import Imag... | [
"streamlit.balloons",
"streamlit.image",
"pandas.read_csv",
"plotly.express.scatter_mapbox",
"collections.defaultdict",
"numpy.around",
"pickle.load",
"numpy.arange",
"numpy.mean",
"pandas.DataFrame",
"datetime.datetime.fromisoformat",
"numpy.std",
"numpy.finfo",
"streamlit.beta_columns",
... | [((541, 908), 'streamlit.markdown', 'st.markdown', (['f"""\n<style>\n .reportview-container .main .block-container{{\n max-width: 100vw;\n padding-top: 1rem;\n padding-right: 1rem;\n padding-left: 1rem;\n padding-bottom: 1rem;\n }}\n .reportview-container .main {{\n co... |
from ..tools.velocity_embedding import velocity_embedding
from ..tools.utils import groups_to_bool
from .utils import default_basis, default_size, default_color, get_components, savefig_or_show, make_unique_list, get_basis
from .velocity_embedding_grid import compute_velocity_on_grid
from .scatter import scatter
from .... | [
"matplotlib.pyplot.subplot",
"matplotlib.pyplot.figure",
"numpy.isnan",
"matplotlib.pyplot.streamplot"
] | [((6200, 6302), 'matplotlib.pyplot.streamplot', 'pl.streamplot', (['X_grid[0]', 'X_grid[1]', 'V_grid[0]', 'V_grid[1]'], {'color': '"""grey"""', 'zorder': '(3)'}), "(X_grid[0], X_grid[1], V_grid[0], V_grid[1], color='grey',\n zorder=3, **stream_kwargs)\n", (6213, 6302), True, 'import matplotlib.pyplot as pl\n'), ((48... |
# Copyright (C) 2020 GreenWaves Technologies, SAS
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
# This prog... | [
"quantization.new_qrec.QRec.copy_ktype",
"utils.node_id.NodeId",
"copy.deepcopy",
"graph.types.NNEdge",
"importer.common.provisional_dim.ProvisionalDim",
"importer.common.provisional_dim.ProvisionalDim.from_tflite_shape",
"numpy.array",
"numpy.reshape",
"quantization.qtype.QType.from_min_max_sq",
... | [((1811, 1865), 'numpy.array', 'np.array', (['[elem for elem in shape if elem is not None]'], {}), '([elem for elem in shape if elem is not None])\n', (1819, 1865), True, 'import numpy as np\n'), ((8214, 8249), 'numpy.reshape', 'np.reshape', (['inp[0].value', 'new_shape'], {}), '(inp[0].value, new_shape)\n', (8224, 824... |
#!/usr/bin/env python
# coding: utf-8
# In[ ]:
# Data Science
import numpy as np
import pandas as pd
# Visualization
import seaborn as sns
import matplotlib.pyplot as plt
# Tricks
sns.set(style='ticks', context='talk', font_scale=1.15)
# In[ ]:
import os, sys
from skimage.io import imread as skIR
from PIL impor... | [
"sys.path.append",
"numpy.stack",
"os.path.abspath",
"PIL.Image.new",
"matplotlib.pyplot.imshow",
"os.path.exists",
"numpy.zeros",
"numpy.array",
"numpy.swapaxes",
"pandas.Series",
"seaborn.set",
"skimage.io.imread"
] | [((184, 239), 'seaborn.set', 'sns.set', ([], {'style': '"""ticks"""', 'context': '"""talk"""', 'font_scale': '(1.15)'}), "(style='ticks', context='talk', font_scale=1.15)\n", (191, 239), True, 'import seaborn as sns\n'), ((372, 403), 'os.path.abspath', 'os.path.abspath', (['Mask_RCNN_ROOT'], {}), '(Mask_RCNN_ROOT)\n', ... |
import matplotlib.pyplot as plt
import matplotlib.ticker as mtick
import numpy as np
import pandas as pd
import seaborn as sns
def __add_name_labels(ax, xs, ys):
last_y_pos = 9999
for i, name in enumerate(xs):
y_pos = ys[name] - 0.1
if np.abs(y_pos - last_y_pos) < 0.1:
... | [
"matplotlib.pyplot.xlim",
"pandas.NamedAgg",
"matplotlib.pyplot.show",
"numpy.abs",
"seaborn.scatterplot",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.close",
"matplotlib.pyplot.legend",
"seaborn.violinplot",
"sklearn.linear_model.LinearRegression",
"matplotlib.pyplot.figure",
"seaborn.boxplo... | [((921, 948), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': 'figsize'}), '(figsize=figsize)\n', (931, 948), True, 'import matplotlib.pyplot as plt\n'), ((1402, 1420), 'matplotlib.pyplot.tight_layout', 'plt.tight_layout', ([], {}), '()\n', (1418, 1420), True, 'import matplotlib.pyplot as plt\n'), ((1523, 15... |
import sys
sys.path.append('../')
sys.path.append('/opt/nvidia/deepstream/deepstream/lib')
from time import sleep
import time
import numpy as np
import gi
gi.require_version('Gst', '1.0')
gi.require_version('GstVideo', '1.0')
from gi.repository import GObject, Gst, GstVideo
from common.FPS import GETFPS
import pyds... | [
"sys.stdout.write",
"pyds.unset_callback_funcs",
"gstutils.get_np_dtype",
"pyds.get_string",
"my_utils.Segmentor",
"pyds.nvds_add_display_meta_to_frame",
"sys.path.append",
"gi.repository.Gst.Caps.from_string",
"gi.repository.GObject.MainLoop",
"gi.repository.GObject.threads_init",
"pyds.nvds_ac... | [((11, 33), 'sys.path.append', 'sys.path.append', (['"""../"""'], {}), "('../')\n", (26, 33), False, 'import sys\n'), ((34, 90), 'sys.path.append', 'sys.path.append', (['"""/opt/nvidia/deepstream/deepstream/lib"""'], {}), "('/opt/nvidia/deepstream/deepstream/lib')\n", (49, 90), False, 'import sys\n'), ((157, 189), 'gi.... |
"""
This module contains the functions necessary for the estimation process of transition
probabilities.
"""
import numba
import numpy as np
import pandas as pd
from estimagic.optimization.optimize import minimize
def estimate_transitions(df):
"""Estimating the transition proabilities.
The sub function for m... | [
"numpy.multiply",
"numpy.log",
"numpy.zeros",
"numpy.isnan",
"pandas.MultiIndex.from_product",
"numba.jit",
"estimagic.optimization.optimize.minimize",
"numpy.bincount"
] | [((3902, 3926), 'numba.jit', 'numba.jit', ([], {'nopython': '(True)'}), '(nopython=True)\n', (3911, 3926), False, 'import numba\n'), ((738, 756), 'numpy.bincount', 'np.bincount', (['usage'], {}), '(usage)\n', (749, 756), True, 'import numpy as np\n'), ((887, 955), 'pandas.MultiIndex.from_product', 'pd.MultiIndex.from_p... |
#
# Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
# Licensed under the Universal Permissive License v 1.0 as shown at http://oss.oracle.com/licenses/upl.
#
from __future__ import print_function
import tensorflow as tf
from numpy import genfromtxt
import numpy as np
import os
from os.path imp... | [
"numpy.random.seed",
"tensorflow.reshape",
"tensorflow.logging.set_verbosity",
"tensorflow.matmul",
"tensorflow.Variable",
"tensorflow.nn.conv2d",
"tensorflow.nn.relu",
"tensorflow.nn.softmax_cross_entropy_with_logits",
"numpy.genfromtxt",
"tensorflow.set_random_seed",
"tensorflow.placeholder",
... | [((399, 441), 'tensorflow.logging.set_verbosity', 'tf.logging.set_verbosity', (['tf.logging.ERROR'], {}), '(tf.logging.ERROR)\n', (423, 441), True, 'import tensorflow as tf\n'), ((974, 998), 'tensorflow.set_random_seed', 'tf.set_random_seed', (['seed'], {}), '(seed)\n', (992, 998), True, 'import tensorflow as tf\n'), (... |
#!/usr/bin/python
import numpy as np
import pyMolecular as mol
import pyMolecular.testing as moltest
import matplotlib.pyplot as plt
# ==================== Compare two point distributions (permutation inveriant)
'''
points_ref = np.array([
[1.0,0.0,0.0], [-1.0, 0.0, 0.0],
[0.0,1.0,0.0], [ 0.0,-1.0, 0.0],
[0... | [
"matplotlib.pyplot.axhline",
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"pyMolecular.testing.hash_saw",
"numpy.random.rand"
] | [((3075, 3097), 'numpy.random.rand', 'np.random.rand', (['natoms'], {}), '(natoms)\n', (3089, 3097), True, 'import numpy as np\n'), ((3208, 3235), 'pyMolecular.testing.hash_saw', 'moltest.hash_saw', (['xs_ref', 'k'], {}), '(xs_ref, k)\n', (3224, 3235), True, 'import pyMolecular.testing as moltest\n'), ((3518, 3539), 'm... |
"""This module evaluates the forecasted trajectories against the ground truth."""
import argparse
from typing import Dict, List, Union
from collections import OrderedDict
import numpy as np
import pandas as pd
import pickle as pkl
from argoverse.evaluation.eval_forecasting import compute_forecasting_metrics
from argo... | [
"matplotlib.pyplot.show",
"argoverse.map_representation.map_api.ArgoverseMap",
"matplotlib.pyplot.plot",
"argparse.ArgumentParser",
"numpy.sum",
"matplotlib.pyplot.yticks",
"matplotlib.pyplot.axis",
"numpy.expand_dims",
"argoverse.evaluation.eval_forecasting.compute_forecasting_metrics",
"numpy.ar... | [((1335, 1364), 'matplotlib.pyplot.figure', 'plt.figure', (['(0)'], {'figsize': '(8, 7)'}), '(0, figsize=(8, 7))\n', (1345, 1364), True, 'import matplotlib.pyplot as plt\n'), ((1375, 1389), 'argoverse.map_representation.map_api.ArgoverseMap', 'ArgoverseMap', ([], {}), '()\n', (1387, 1389), False, 'from argoverse.map_re... |
"""
Code modified from allen.
"""
import io
import logging
import itertools
from typing import Optional, Tuple, Iterator, Any
import numpy
import torch
from torch.nn.functional import embedding
from ..common import Vocabulary
from ..common.util import printf, get_file_extension
from ..modules import util
logger = l... | [
"torch.nn.Parameter",
"numpy.std",
"torch.nn.init.xavier_uniform_",
"numpy.asarray",
"torch.FloatTensor",
"torch.nn.functional.embedding",
"numpy.mean",
"itertools.chain",
"logging.getLogger"
] | [((319, 346), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (336, 346), False, 'import logging\n'), ((4593, 4779), 'torch.nn.functional.embedding', 'embedding', (['inputs', 'self.weight'], {'padding_idx': 'self.padding_index', 'max_norm': 'self.max_norm', 'norm_type': 'self.norm_type', '... |
# Lint as: python3
# 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
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by ap... | [
"reverb.item_selectors.Fifo",
"reverb.rate_limiters.MinSize",
"tensorflow.compat.v1.constant",
"numpy.zeros",
"numpy.ones",
"time.sleep",
"tensorflow.compat.v1.disable_eager_execution",
"tensorflow.compat.v1.test.main",
"numpy.array",
"reverb.client.Client",
"numpy.testing.assert_equal",
"conc... | [((9890, 9918), 'tensorflow.compat.v1.disable_eager_execution', 'tf.disable_eager_execution', ([], {}), '()\n', (9916, 9918), True, 'import tensorflow.compat.v1 as tf\n'), ((9921, 9935), 'tensorflow.compat.v1.test.main', 'tf.test.main', ([], {}), '()\n', (9933, 9935), True, 'import tensorflow.compat.v1 as tf\n'), ((141... |
from kernel_tuner import tune_kernel
import numpy
import argparse
import json
def generate_code(tuning_parameters):
code = \
"__global__ void fct_ale_c_horizontal(const int maxLevels, const int * __restrict__ nLevels, const int * __restrict__ nodesPerEdge, const int * __restrict__ elementsPerEdge, <%REAL_... | [
"json.dump",
"argparse.ArgumentParser",
"numpy.copy",
"numpy.random.randn",
"numpy.float32",
"numpy.dtype",
"numpy.zeros",
"numpy.random.random",
"numpy.random.randint",
"numpy.int32",
"numpy.float64"
] | [((4888, 4916), 'numpy.copy', 'numpy.copy', (['del_ttf_advhoriz'], {}), '(del_ttf_advhoriz)\n', (4898, 4916), False, 'import numpy\n'), ((5079, 5100), 'numpy.random.random', 'numpy.random.random', ([], {}), '()\n', (5098, 5100), False, 'import numpy\n'), ((6793, 6859), 'argparse.ArgumentParser', 'argparse.ArgumentParse... |
import numpy as np
import random
import matplotlib.pyplot as plt
n = 10
s = 0.5
S = 2
demand = []
replenish = []
x = [0]
y = [-s]
lambdas = np.array([1,2])
p = np.array([0.5,0.5])
for i in range(n):
demand.append(random.uniform(0,1))
if x[-1] < s:
y.append(S - s)
replenish.append(S - x[-1])
... | [
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"random.uniform",
"matplotlib.pyplot.legend",
"numpy.array"
] | [((141, 157), 'numpy.array', 'np.array', (['[1, 2]'], {}), '([1, 2])\n', (149, 157), True, 'import numpy as np\n'), ((161, 181), 'numpy.array', 'np.array', (['[0.5, 0.5]'], {}), '([0.5, 0.5])\n', (169, 181), True, 'import numpy as np\n'), ((467, 478), 'matplotlib.pyplot.plot', 'plt.plot', (['x'], {}), '(x)\n', (475, 47... |
# Licensed under a 3-clause BSD style license - see LICENSE.rst
from __future__ import absolute_import, division, print_function, unicode_literals
from numpy.testing import assert_allclose
import pytest
from astropy import units as u
from astropy.coordinates import SkyCoord
from astropy.tests.helper import assert_qu... | [
"astropy.tests.helper.assert_quantity_allclose",
"pytest.fixture",
"astropy.utils.data.get_pkg_data_filename",
"astropy.io.fits.getheader",
"astropy.wcs.WCS",
"pytest.mark.skipif",
"numpy.testing.assert_allclose",
"astropy.coordinates.SkyCoord"
] | [((694, 725), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""session"""'}), "(scope='session')\n", (708, 725), False, 'import pytest\n'), ((752, 801), 'astropy.utils.data.get_pkg_data_filename', 'get_pkg_data_filename', (['"""data/example_header.fits"""'], {}), "('data/example_header.fits')\n", (773, 801), Fals... |
from __future__ import division, absolute_import, print_function
import sys
import numpy as np
from numpy.testing import (
TestCase, run_module_suite, assert_, assert_raises,
assert_array_equal
)
class TestTake(TestCase):
def test_simple(self):
a = [[1, 2], [3, 4]]
a_str = [[b'1', b'2'],... | [
"numpy.testing.run_module_suite",
"numpy.testing.assert_raises",
"numpy.testing.assert_array_equal",
"numpy.empty",
"numpy.dtype",
"sys.getrefcount",
"numpy.testing.assert_",
"numpy.arange",
"numpy.array",
"numpy.issubdtype"
] | [((3676, 3694), 'numpy.testing.run_module_suite', 'run_module_suite', ([], {}), '()\n', (3692, 3694), False, 'from numpy.testing import TestCase, run_module_suite, assert_, assert_raises, assert_array_equal\n'), ((2943, 2956), 'numpy.arange', 'np.arange', (['(10)'], {}), '(10)\n', (2952, 2956), True, 'import numpy as n... |
import tensorflow as tf
import numpy as np, h5py
import scipy.io as sio
import sys
import random
import kNN
import re
import os
from numpy import *
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
def bias_variable(shape):
initial = tf.constant(0... | [
"numpy.random.shuffle",
"scipy.io.loadmat",
"tensorflow.global_variables_initializer",
"numpy.asarray",
"tensorflow.Session",
"tensorflow.constant",
"tensorflow.placeholder",
"tensorflow.cast",
"tensorflow.Variable",
"numpy.array",
"tensorflow.matmul",
"tensorflow.square",
"tensorflow.nn.l2_... | [((1074, 1119), 'scipy.io.loadmat', 'sio.loadmat', (['"""./data/CUB_data/train_attr.mat"""'], {}), "('./data/CUB_data/train_attr.mat')\n", (1085, 1119), True, 'import scipy.io as sio\n'), ((1124, 1149), 'numpy.array', 'np.array', (["f['train_attr']"], {}), "(f['train_attr'])\n", (1132, 1149), True, 'import numpy as np,... |
import os
import random
import numpy as np
from torch.utils.data import Dataset
from PIL import Image
from utils.cartoongan import smooth_image_edges
class CartoonDataset(Dataset):
def __init__(self, data_dir, src_style='real', tar_style='gongqijun', src_transform=None, tar_transform=None):
self.data_dir ... | [
"random.randint",
"numpy.asarray",
"PIL.Image.fromarray",
"os.path.join",
"numpy.random.shuffle"
] | [((1307, 1339), 'numpy.random.shuffle', 'np.random.shuffle', (['self.src_data'], {}), '(self.src_data)\n', (1324, 1339), True, 'import numpy as np\n'), ((1348, 1380), 'numpy.random.shuffle', 'np.random.shuffle', (['self.tar_data'], {}), '(self.tar_data)\n', (1365, 1380), True, 'import numpy as np\n'), ((3718, 3749), 'P... |
"""
Script calculates the mean January-April sea ice extent for the Bering Sea
over the 1850 to 2018 period and 1979-2018 period
Notes
-----
Author : <NAME>
Date : 24 March 2019
"""
### Import modules
import numpy as np
import matplotlib.pyplot as plt
import datetime
import scipy.stats as sts
### Define di... | [
"numpy.savetxt",
"numpy.genfromtxt",
"scipy.stats.pearsonr",
"numpy.isnan",
"numpy.arange",
"numpy.round",
"datetime.datetime.now"
] | [((441, 464), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (462, 464), False, 'import datetime\n'), ((749, 777), 'numpy.arange', 'np.arange', (['(1850)', '(2018 + 1)', '(1)'], {}), '(1850, 2018 + 1, 1)\n', (758, 777), True, 'import numpy as np\n'), ((784, 812), 'numpy.arange', 'np.arange', (['(19... |
import os
import time
import numpy as np
# from IPython import embed
print("perform experiments on amazoncat 13K (multilabel)")
leaf_example_multiplier = 2
lr = 1
bits = 30
alpha = 0.1 # 0.3
passes = 4
learn_at_leaf = True
use_oas = True
# num_queries = 1 #does not really use
dream_at_update = 1
# hal_version = 1 #... | [
"numpy.log",
"os.path.exists",
"os.system",
"time.time"
] | [((971, 982), 'time.time', 'time.time', ([], {}), '()\n', (980, 982), False, 'import time\n'), ((1471, 1494), 'os.system', 'os.system', (['command_line'], {}), '(command_line)\n', (1480, 1494), False, 'import os\n'), ((1560, 1571), 'time.time', 'time.time', ([], {}), '()\n', (1569, 1571), False, 'import time\n'), ((651... |
import random
import sys
import heapq
from typing import Callable, Iterator, List, Tuple, Any, Optional, TYPE_CHECKING
import numpy as np
if TYPE_CHECKING:
import pandas
import pyarrow
from ray.data.impl.sort import SortKeyT
from ray.data.aggregate import AggregateFn
from ray.data.block import (
Bloc... | [
"pandas.DataFrame",
"random.sample",
"random.shuffle",
"numpy.random.RandomState",
"ray.data.impl.size_estimator.SizeEstimator",
"numpy.array",
"sys.getsizeof",
"ray.data.block.BlockExecStats.builder"
] | [((667, 682), 'ray.data.impl.size_estimator.SizeEstimator', 'SizeEstimator', ([], {}), '()\n', (680, 682), False, 'from ray.data.impl.size_estimator import SizeEstimator\n'), ((1746, 1780), 'numpy.random.RandomState', 'np.random.RandomState', (['random_seed'], {}), '(random_seed)\n', (1767, 1780), True, 'import numpy a... |
# -*- coding:utf-8 -*-
from preprocessing import Tokenizer
import random
import csv
import json
import numpy as np
import sentencepiece as spm
from konlpy.tag import Okt
import torch
from torch.utils.data import Dataset, DataLoader
class BertLMDataset(Dataset):
def __init__(self, dataset, token... | [
"numpy.zeros_like",
"json.load",
"torch.utils.data.DataLoader",
"torch.LongTensor",
"random.shuffle",
"random.choice",
"numpy.array",
"torch.from_numpy"
] | [((4787, 4835), 'torch.utils.data.DataLoader', 'DataLoader', (['dataset'], {'batch_size': '(1)', 'shuffle': '(False)'}), '(dataset, batch_size=1, shuffle=False)\n', (4797, 4835), False, 'from torch.utils.data import Dataset, DataLoader\n'), ((974, 1005), 'torch.LongTensor', 'torch.LongTensor', (['masked_tokens'], {}), ... |
#!/usr/bin/env python
"""
setup the disperion database file structure and configuration file
"""
import os
import tempfile
import numpy as np
from dispersion import Material, Writer, Interpolation, Catalogue
from dispersion.config import default_config, write_config
def get_root_dir(conf):
"""
get the root dir... | [
"os.mkdir",
"tempfile.TemporaryDirectory",
"dispersion.Material",
"dispersion.Writer",
"os.path.isdir",
"dispersion.config.default_config",
"dispersion.config.write_config",
"dispersion.Interpolation",
"numpy.array",
"git.Repo.clone_from",
"dispersion.Catalogue",
"os.path.join"
] | [((3971, 4062), 'numpy.array', 'np.array', (['[[400.0, 1.7, 0.1], [500.0, 1.6, 0.05], [600.0, 1.5, 0.0], [700.0, 1.4, 0.0]]'], {}), '([[400.0, 1.7, 0.1], [500.0, 1.6, 0.05], [600.0, 1.5, 0.0], [700.0,\n 1.4, 0.0]])\n', (3979, 4062), True, 'import numpy as np\n'), ((4143, 4221), 'dispersion.Material', 'Material', ([]... |
import sys
sys.path.append("utils")
sys.path.append("models")
from file_io import *
from train_utils import *
import numpy as np
import pandas as pd
import matplotlib as mp
import matplotlib.pyplot as plt
import time
from test import init_test
from pathlib import Path
import torch
from torch.utils.data import Datase... | [
"sys.path.append",
"torch.no_grad",
"os.makedirs",
"numpy.zeros",
"torch.optim.lr_scheduler.ReduceLROnPlateau",
"time.time",
"dataloaders.get_double_scan_v1_loader",
"random_word.RandomWords",
"torch.utils.tensorboard.SummaryWriter",
"test.init_test",
"os.path.join",
"os.listdir",
"torch.ten... | [((11, 35), 'sys.path.append', 'sys.path.append', (['"""utils"""'], {}), "('utils')\n", (26, 35), False, 'import sys\n'), ((36, 61), 'sys.path.append', 'sys.path.append', (['"""models"""'], {}), "('models')\n", (51, 61), False, 'import sys\n'), ((1356, 1373), 'numpy.zeros', 'np.zeros', (['classes'], {}), '(classes)\n',... |
import argparse
from timeit import default_timer as timer
import numpy as np
import tensorflow as tf
import tbpf_tf
parser = argparse.ArgumentParser()
parser.add_argument("-d", "--degree", help="Degree of polynomial features", default=2, type=int)
parser.add_argument("-i", "--iterations", help="Number of iterations ... | [
"numpy.sum",
"argparse.ArgumentParser",
"tensorflow.random.normal",
"timeit.default_timer",
"numpy.savetxt",
"tensorflow.concat",
"tensorflow.config.experimental.set_memory_growth",
"numpy.min",
"numpy.mean",
"numpy.max",
"tbpf_tf.mask_matrix",
"tensorflow.config.experimental.list_logical_devi... | [((128, 153), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (151, 153), False, 'import argparse\n'), ((679, 730), 'tensorflow.config.experimental.list_physical_devices', 'tf.config.experimental.list_physical_devices', (['"""GPU"""'], {}), "('GPU')\n", (723, 730), True, 'import tensorflow as tf... |
import numpy as np
def pdist(source_mtx, target_mtx):
distance_matrix = -2 * source_mtx.dot(target_mtx.transpose()) \
+ (source_mtx ** 2).sum(axis=1).reshape(-1, 1) \
+ (target_mtx ** 2).sum(axis=1).reshape(1, -1)
return distance_matrix
def get_acc(query_emb, quer... | [
"numpy.sum",
"numpy.zeros",
"numpy.argsort",
"numpy.mean",
"numpy.where"
] | [((2160, 2180), 'numpy.mean', 'np.mean', (['self.values'], {}), '(self.values)\n', (2167, 2180), True, 'import numpy as np\n'), ((2409, 2466), 'numpy.zeros', 'np.zeros', (['(self.data_num, self.vec_dim)'], {'dtype': 'np.float16'}), '((self.data_num, self.vec_dim), dtype=np.float16)\n', (2417, 2466), True, 'import numpy... |
import logging
import numpy as np
from bokeh import plotting
from bokeh.layouts import gridplot
L = logging.getLogger(__name__)
def bokeh_plot(data, var_name, results, title, module, test_name):
plot = bokeh_plot_var(data, var_name, results, title, module, test_name)
return gridplot([[plot]], sizing_mode='f... | [
"bokeh.plotting.figure",
"numpy.ma.masked_where",
"logging.getLogger",
"bokeh.layouts.gridplot"
] | [((102, 129), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (119, 129), False, 'import logging\n'), ((287, 326), 'bokeh.layouts.gridplot', 'gridplot', (['[[plot]]'], {'sizing_mode': '"""fixed"""'}), "([[plot]], sizing_mode='fixed')\n", (295, 326), False, 'from bokeh.layouts import gridpl... |
#!/usr/bin/env python3
import h5py
import numpy
from numpy import sin, cos, pi, degrees
from ext import hdf5handler
from matplotlib import pyplot as plt
#MKS
G = 6.67384e-11 # m^3 kg^-1 s^-2
MSun = 1.9891e30 # kg^1
AU = 149597870700 # m^1
DAY = 3600*24 # s^1
YEAR = DAY*365.25 # s^1
def rk4... | [
"h5py.File",
"ext.hdf5handler.HDF5Handler",
"matplotlib.pyplot.figure",
"numpy.sin",
"numpy.array",
"numpy.arange",
"numpy.cos",
"matplotlib.pyplot.savefig"
] | [((881, 914), 'numpy.array', 'numpy.array', (['[da, de, df, dw, dM]'], {}), '([da, de, df, dw, dM])\n', (892, 914), False, 'import numpy\n'), ((1067, 1100), 'numpy.array', 'numpy.array', (['[a0, e0, f0, w0, M0]'], {}), '([a0, e0, f0, w0, M0])\n', (1078, 1100), False, 'import numpy\n'), ((1664, 1686), 'h5py.File', 'h5py... |
# -*- coding: utf-8 -*-
import numpy as np
eps = np.finfo(float).eps
def infnorm(x):
return np.linalg.norm(x, np.inf)
def scaled_tol(n):
tol = 5e1*eps if n < 20 else np.log(n)**2.5*eps
return tol
# bespoke test generators
def infNormLessThanTol(a, b, tol):
def asserter(self):
self.assertLes... | [
"numpy.log",
"numpy.finfo",
"numpy.sin",
"numpy.linalg.norm",
"numpy.exp",
"numpy.cos"
] | [((51, 66), 'numpy.finfo', 'np.finfo', (['float'], {}), '(float)\n', (59, 66), True, 'import numpy as np\n'), ((99, 124), 'numpy.linalg.norm', 'np.linalg.norm', (['x', 'np.inf'], {}), '(x, np.inf)\n', (113, 124), True, 'import numpy as np\n'), ((654, 663), 'numpy.exp', 'np.exp', (['x'], {}), '(x)\n', (660, 663), True, ... |
import pytest
import numpy as np
import pandas as pd
from pandas import Categorical, Series, CategoricalIndex
from pandas.core.dtypes.concat import union_categoricals
from pandas.util import testing as tm
class TestUnionCategoricals(object):
def test_union_categorical(self):
# GH 13361
data = [
... | [
"pandas.core.dtypes.concat.union_categoricals",
"pandas.Timestamp",
"pandas.date_range",
"pandas.period_range",
"pandas.util.testing.assert_raises_regex",
"pytest.raises",
"numpy.array",
"pandas.Series",
"pandas.util.testing.assert_categorical_equal",
"pandas.Categorical",
"pandas.CategoricalInd... | [((1665, 1693), 'pandas.Categorical', 'Categorical', (["['x', 'y', 'z']"], {}), "(['x', 'y', 'z'])\n", (1676, 1693), False, 'from pandas import Categorical, Series, CategoricalIndex\n'), ((1707, 1735), 'pandas.Categorical', 'Categorical', (["['a', 'b', 'c']"], {}), "(['a', 'b', 'c'])\n", (1718, 1735), False, 'from pand... |
import numpy as np
import argparse
from maci.learners import MAVBAC, MASQL, ROMMEO
from maci.misc.sampler import MASampler
from maci.environments import PBeautyGame, MatrixGame, DifferentialGame
from maci.environments import make_particle_env
from maci.misc import logger
import gtimer as gt
import datetime
from copy i... | [
"argparse.ArgumentParser",
"tensorflow.ConfigProto",
"keras.backend.tensorflow_backend.set_session",
"maci.misc.logger.set_snapshot_dir",
"maci.misc.tf_utils.single_threaded_session",
"gtimer.set_def_unique",
"gtimer.rename_root",
"gtimer.stamp",
"gtimer.reset",
"datetime.datetime.now",
"maci.en... | [((544, 560), 'tensorflow.ConfigProto', 'tf.ConfigProto', ([], {}), '()\n', (558, 560), True, 'import tensorflow as tf\n'), ((654, 679), 'tensorflow.Session', 'tf.Session', ([], {'config': 'config'}), '(config=config)\n', (664, 679), True, 'import tensorflow as tf\n'), ((680, 697), 'keras.backend.tensorflow_backend.set... |
to_import = ['mlmodels.modelutils',
'mlmodels.search.bayesian',
'mlmodels.search.hparameters.lgbm_params']
import logging
logger = logging.getLogger()
from os.path import dirname, abspath, split
project_name = split(dirname(abspath(__file__)))[1]
logger.info(f'{__file__} module: project dire... | [
"pandas.DataFrame",
"os.path.abspath",
"lightgbm.LGBMClassifier",
"importlib.import_module",
"numpy.argmax",
"scipy.sparse.issparse",
"sklearn.metrics.accuracy_score",
"shap.TreeExplainer",
"numpy.mean",
"numpy.array",
"lightgbm.LGBMRegressor",
"shap.summary_plot",
"pandas.concat",
"loggin... | [((158, 177), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (175, 177), False, 'import logging\n'), ((455, 519), 'importlib.import_module', 'importlib.import_module', ([], {'name': 'f""".{module}"""', 'package': 'project_name'}), "(name=f'.{module}', package=project_name)\n", (478, 519), False, 'import im... |
# -*- coding: utf-8 -*-
"""
Created on Fri Apr 16 13:12:07 2021
@author: <NAME>
"""
import warnings
warnings.filterwarnings("ignore")
import time
import unittest
import numpy as np
from smoot.smoot import MOO
from smoot.zdt import ZDT
from smt.sampling_methods import LHS
from smt.problems import Branin
from smt.ut... | [
"unittest.main",
"warnings.filterwarnings",
"pymoo.factory.get_performance_indicator",
"smt.problems.Branin",
"numpy.allclose",
"smoot.zdt.ZDT",
"time.time",
"smt.sampling_methods.LHS",
"smoot.smoot.MOO"
] | [((102, 135), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (125, 135), False, 'import warnings\n'), ((2946, 2961), 'unittest.main', 'unittest.main', ([], {}), '()\n', (2959, 2961), False, 'import unittest\n'), ((498, 506), 'smt.problems.Branin', 'Branin', ([], {}), '()\n... |
import copy
import random
import smmp
import numpy as np
from math import *
from universe1 import *
from protein1 import *
from mergesort import *
from sklearn import preprocessing
phi = np.concatenate((np.random.uniform(-80,-50,10),np.random.uniform(-160,-120,10)))
psi = np.concatenate((np.random.uniform(-50,-20,10)... | [
"smmp.outpdb",
"numpy.random.uniform",
"copy.deepcopy",
"numpy.sum",
"numpy.zeros",
"numpy.searchsorted",
"random.random",
"numpy.random.randint",
"numpy.random.random",
"numpy.array",
"numpy.concatenate"
] | [((8489, 8516), 'smmp.outpdb', 'smmp.outpdb', (['(0)', '"""final.pdb"""'], {}), "(0, 'final.pdb')\n", (8500, 8516), False, 'import smmp\n'), ((204, 235), 'numpy.random.uniform', 'np.random.uniform', (['(-80)', '(-50)', '(10)'], {}), '(-80, -50, 10)\n', (221, 235), True, 'import numpy as np\n'), ((234, 267), 'numpy.rand... |
# Importing the Keras libraries and packages
import numpy as np
import keras
import tensorflow as tf
from keras.models import load_model
from IPython.display import display
from PIL import Image
from keras.preprocessing import image
from keras.preprocessing.image import ImageDataGenerator
from keras.models import Seque... | [
"keras.models.load_model",
"keras.preprocessing.image.ImageDataGenerator",
"numpy.expand_dims",
"keras.preprocessing.image.img_to_array",
"keras.preprocessing.image.load_img"
] | [((478, 574), 'keras.preprocessing.image.ImageDataGenerator', 'ImageDataGenerator', ([], {'rescale': '(1.0 / 255)', 'shear_range': '(0.2)', 'zoom_range': '(0.2)', 'horizontal_flip': '(True)'}), '(rescale=1.0 / 255, shear_range=0.2, zoom_range=0.2,\n horizontal_flip=True)\n', (496, 574), False, 'from keras.preprocess... |
import numpy as np
class congestionInference:
def __init__(self, latency_jumps, jitter_analysis):
self.latency_jumps = latency_jumps
self.jitter_analysis = jitter_analysis
self.congestion = False
def fit(self):
self.congestion_inferences = []
for i in rang... | [
"numpy.array"
] | [((899, 935), 'numpy.array', 'np.array', (['self.congestion_inferences'], {}), '(self.congestion_inferences)\n', (907, 935), True, 'import numpy as np\n')] |
"""
Recommender
"""
from __future__ import annotations
from pathlib import Path
from typing import Any, Callable, Optional, Tuple, Union, cast
import numpy as np
import torch
from sklearn.neighbors import NearestNeighbors
from torch.utils.data import DataLoader
from tqdm.auto import tqdm
from wav2rec._utils.va... | [
"wav2rec.core.similarity.similarity_calculator",
"torch.inference_mode",
"torch.utils.data.DataLoader",
"wav2rec.nn.lightening.Wav2RecNet.load_from_checkpoint",
"typing.cast",
"numpy.asarray",
"numpy.finfo",
"numpy.array",
"numpy.linalg.norm",
"torch.cuda.is_available",
"torch.as_tensor",
"num... | [((603, 657), 'numpy.linalg.norm', 'np.linalg.norm', (['array'], {'ord': '(2)', 'axis': 'axis', 'keepdims': '(True)'}), '(array, ord=2, axis=axis, keepdims=True)\n', (617, 657), True, 'import numpy as np\n'), ((847, 865), 'torch.as_tensor', 'torch.as_tensor', (['x'], {}), '(x)\n', (862, 865), False, 'import torch\n'), ... |
import os
import pandas
import uuid
import math
import plotly.graph_objects as go
from scipy.stats import sem, norm
import numpy
from plotly.subplots import make_subplots
import glob
from models import Gillespie, CellDivision, DeterministicCellDivision
n_A = 6.023E23 # Avogadro's Number
e_coli_vol = 6.5E-16 # Liters... | [
"pandas.DataFrame",
"plotly.graph_objects.Scatter",
"math.exp",
"uuid.uuid4",
"plotly.graph_objects.Histogram",
"math.sqrt",
"models.DeterministicCellDivision",
"models.CellDivision",
"pandas.read_csv",
"scipy.stats.norm.pdf",
"numpy.array",
"scipy.stats.sem",
"numpy.linspace",
"glob.glob"... | [((1001, 1027), 'os.path.join', 'os.path.join', (['sim', '"""*.csv"""'], {}), "(sim, '*.csv')\n", (1013, 1027), False, 'import os\n'), ((1045, 1060), 'glob.glob', 'glob.glob', (['path'], {}), '(path)\n', (1054, 1060), False, 'import glob\n'), ((2356, 2405), 'scipy.stats.norm.pdf', 'norm.pdf', (['gauss_divide_x', 'divid... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.