code stringlengths 31 1.05M | apis list | extract_api stringlengths 97 1.91M |
|---|---|---|
from time import time
import matplotlib
#this will prevent the figure from popping up
matplotlib.use('Agg')
from matplotlib import pyplot as plt
import numpy as np
import pycuda.autoinit
from pycuda import gpuarray
from pycuda.elementwise import ElementwiseKernel
# first string: the input, pycuda::complex<float> is a ... | [
"pycuda.gpuarray.empty",
"matplotlib.pyplot.imshow",
"numpy.float32",
"pycuda.elementwise.ElementwiseKernel",
"time.time",
"matplotlib.pyplot.figure",
"matplotlib.use",
"numpy.linspace",
"pycuda.gpuarray.to_gpu",
"numpy.int32",
"matplotlib.pyplot.savefig"
] | [((86, 107), 'matplotlib.use', 'matplotlib.use', (['"""Agg"""'], {}), "('Agg')\n", (100, 107), False, 'import matplotlib\n'), ((358, 794), 'pycuda.elementwise.ElementwiseKernel', 'ElementwiseKernel', (['"""pycuda::complex<float> *lattice, float *mandelbrot_graph, int max_iters, float upper_bound"""', '"""\nmandelbrot_g... |
from os import path, system
import numpy as np
import matplotlib.pyplot as plt
from backbone.trajectory import TrajectoryProcess
class RMSFProcess(TrajectoryProcess):
def __init__(self, host, strand_id, big_traj_folder, backbone_data_folder):
super().__init__(host, strand_id, big_traj_folder, backbone_dat... | [
"os.path.join",
"numpy.genfromtxt",
"matplotlib.pyplot.subplots"
] | [((358, 416), 'os.path.join', 'path.join', (['self.strand_folder', 'f"""{self.strand_id}.res.xvg"""'], {}), "(self.strand_folder, f'{self.strand_id}.res.xvg')\n", (367, 416), False, 'from os import path, system\n'), ((444, 501), 'os.path.join', 'path.join', (['self.strand_folder', 'f"""{self.strand_id}.aa.xvg"""'], {})... |
from dynplt import phase_plane
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import ode
# Van der Poll oscilator
def vanderpoll(t, x, mu):
dx = np.zeros(2)
dx[0] = x[1]
dx[1] = mu*(1-x[0]**2)*x[1]-x[0]
return dx
# Define initial conditions and simulation times
initial_condi... | [
"dynplt.phase_plane",
"scipy.integrate.ode",
"matplotlib.pyplot.show",
"numpy.zeros",
"matplotlib.pyplot.subplots"
] | [((1088, 1102), 'matplotlib.pyplot.subplots', 'plt.subplots', ([], {}), '()\n', (1100, 1102), True, 'import matplotlib.pyplot as plt\n'), ((1132, 1221), 'dynplt.phase_plane', 'phase_plane', (['r', 'initial_conditions', '[-6, 6, -6, 6]'], {'solution_direction': '"""both"""', 'ax': 'ax'}), "(r, initial_conditions, [-6, 6... |
# -*- coding: utf-8 -*-
"""
Created on Fri May 04 11:08:56 2012
Author: <NAME>
"""
#Load the El Nino dataset. Consists of 60 years worth of Pacific Ocean sea
#surface temperature data.
import matplotlib.pyplot as plt
import numpy as np
import statsmodels.api as sm
data = sm.datasets.elnino.load()
#Create a rai... | [
"matplotlib.pyplot.figure",
"statsmodels.api.datasets.elnino.load",
"numpy.arange",
"statsmodels.api.graphics.rainbowplot"
] | [((280, 305), 'statsmodels.api.datasets.elnino.load', 'sm.datasets.elnino.load', ([], {}), '()\n', (303, 305), True, 'import statsmodels.api as sm\n'), ((338, 350), 'matplotlib.pyplot.figure', 'plt.figure', ([], {}), '()\n', (348, 350), True, 'import matplotlib.pyplot as plt\n'), ((383, 440), 'statsmodels.api.graphics.... |
import numpy as np
class Coppock(object):
def __init__(self, data, wma_pd=10, roc_long=14, roc_short=11):
self.wma_pd = wma_pd
self.long_pd = roc_long
self.short_pd = roc_short
self.past_data = None
self.values = self.calc_copp(data)
def calc_copp(self, da... | [
"numpy.add",
"numpy.load",
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot"
] | [((2982, 3004), 'matplotlib.pyplot.plot', 'plt.plot', (['test1[-100:]'], {}), '(test1[-100:])\n', (2990, 3004), True, 'import matplotlib.pyplot as plt\n'), ((3010, 3034), 'matplotlib.pyplot.plot', 'plt.plot', (['updated[-100:]'], {}), '(updated[-100:])\n', (3018, 3034), True, 'import matplotlib.pyplot as plt\n'), ((304... |
# -*- coding: utf-8 -*-
"""@package Methods.Machine.MagnetType14.build_geometry
MagnetType14 build_geometry method
@date Created on Wed Dec 17 16:09:15 2014
@copyright (C) 2014-2015 EOMYS ENGINEERING.
@author pierre_b
"""
from numpy import angle, exp
from pyleecan.Classes.Arc1 import Arc1
from pyleecan.Classes.Segmen... | [
"numpy.angle",
"pyleecan.Classes.Arc1.Arc1",
"pyleecan.Methods.ParentMissingError",
"pyleecan.Classes.Segment.Segment",
"numpy.exp",
"pyleecan.Classes.SurfLine.SurfLine"
] | [((1448, 1527), 'pyleecan.Methods.ParentMissingError', 'ParentMissingError', (["('Error: The magnet object is not inside a ' + 'slot object')"], {}), "('Error: The magnet object is not inside a ' + 'slot object')\n", (1466, 1527), False, 'from pyleecan.Methods import ParentMissingError\n'), ((2661, 2684), 'pyleecan.Cla... |
"""
The MIT License (MIT)
Copyright (c) 2021 NVIDIA
Permission is hereby granted, free of charge, to any 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, modify, merge, publi... | [
"tensorflow.keras.applications.VGG19",
"tensorflow.keras.layers.Reshape",
"tensorflow.keras.layers.Dense",
"pickle.load",
"tensorflow.get_logger",
"tensorflow.keras.preprocessing.text.Tokenizer",
"tensorflow.keras.layers.Concatenate",
"tensorflow.keras.preprocessing.image.load_img",
"tensorflow.kera... | [((5659, 5710), 'tensorflow.keras.preprocessing.sequence.pad_sequences', 'pad_sequences', (['dest_input_token_seq'], {'padding': '"""post"""'}), "(dest_input_token_seq, padding='post')\n", (5672, 5710), False, 'from tensorflow.keras.preprocessing.sequence import pad_sequences\n'), ((6033, 6059), 'tensorflow.keras.layer... |
import os
from prohmr.utils.geometry import batch_rodrigues
import cv2
import torch
import numpy as np
import pickle
from tqdm import tqdm
from prohmr.models import SMPL
from prohmr.configs import prohmr_config, dataset_config
def preprocess_3dpw(dataset_path: str, out_file: str):
'''
Generate 3DPW dataset fi... | [
"torch.ones",
"tqdm.tqdm",
"prohmr.configs.dataset_config",
"prohmr.configs.prohmr_config",
"numpy.zeros",
"prohmr.models.SMPL",
"cv2.Rodrigues",
"pickle.load",
"numpy.array",
"os.path.join",
"os.listdir",
"torch.tensor"
] | [((445, 460), 'prohmr.configs.prohmr_config', 'prohmr_config', ([], {}), '()\n', (458, 460), False, 'from prohmr.configs import prohmr_config, dataset_config\n'), ((569, 600), 'prohmr.models.SMPL', 'SMPL', ([], {'gender': '"""male"""'}), "(**smpl_cfg, gender='male')\n", (573, 600), False, 'from prohmr.models import SMP... |
import numpy as np
import keras.models
from keras.models import Model
import matplotlib.pyplot as plt
import keras.backend as K
class Gradient:
def __init__(self, model):
mask0=K.sqrt(K.sum(K.square(K.relu(K.squeeze(K.gradients(model.layers[-2].output[0,0],model.layers[1].input),0))),axis=2))
mas... | [
"keras.backend.stack",
"keras.backend.gradients",
"keras.backend.tf.diag",
"keras.backend.squeeze",
"keras.backend.expand_dims",
"keras.backend.function",
"keras.backend.sum",
"keras.models.Model",
"keras.backend.eval",
"keras.backend.mean",
"numpy.array",
"keras.backend.relu"
] | [((456, 475), 'keras.backend.squeeze', 'K.squeeze', (['mask0', '(0)'], {}), '(mask0, 0)\n', (465, 475), True, 'import keras.backend as K\n'), ((492, 511), 'keras.backend.squeeze', 'K.squeeze', (['mask1', '(0)'], {}), '(mask1, 0)\n', (501, 511), True, 'import keras.backend as K\n'), ((529, 603), 'keras.backend.function'... |
#from matplotlib.ticker import FormatStrFormatter
import math
import CCU_Concrete_Constants
import numpy as np
import pandas as pd
def f_get_input_array(i):
excel_file = CCU_Concrete_Constants.excel_file
df = pd.read_excel(excel_file, sheet_name=CCU_Concrete_Constants.sheet_name)
number_of_samples=CCU... | [
"numpy.random.uniform",
"math.sqrt",
"numpy.zeros",
"pandas.read_excel",
"math.log",
"numpy.random.lognormal"
] | [((223, 294), 'pandas.read_excel', 'pd.read_excel', (['excel_file'], {'sheet_name': 'CCU_Concrete_Constants.sheet_name'}), '(excel_file, sheet_name=CCU_Concrete_Constants.sheet_name)\n', (236, 294), True, 'import pandas as pd\n'), ((8039, 8086), 'numpy.random.lognormal', 'np.random.lognormal', (['m1', 'sd1', 'number_of... |
#########################################################################
#########################################################################
# Classes for handling genome-wide association input and output files, ##
# analysis and qc programs, and post-hoc analyses ##
########################... | [
"numpy.sum",
"numpy.nan_to_num",
"numpy.empty",
"numpy.isnan",
"numpy.mean",
"numpy.exp",
"pandas.read_table",
"numpy.float64",
"numpy.round",
"os.path.join",
"pandas.DataFrame",
"scipy.stats.norm",
"cgatcore.experiment.info",
"random.randint",
"numpy.std",
"pandas.merge",
"numpy.pla... | [((109501, 109597), 'pandas.merge', 'pd.merge', ([], {'left': 'coords', 'right': 'data', 'left_on': 'coord_id_col', 'right_on': 'coord_id_col', 'how': '"""inner"""'}), "(left=coords, right=data, left_on=coord_id_col, right_on=\n coord_id_col, how='inner')\n", (109509, 109597), True, 'import pandas as pd\n'), ((11067... |
import numpy as np
# a rigid triangle
def case_1():
points = np.array([[-1, 0], [1, 0], [0, 1.732]])
fixed_points_index = [0]
edges = [(0, 1), (1, 2), (2, 0)]
joints = []
return points, fixed_points_index, edges, joints
def case_1_1():
points = np.array([[-1, 0], [1, 0], [0, 0.2]])
fixed_p... | [
"numpy.array",
"numpy.sqrt"
] | [((66, 105), 'numpy.array', 'np.array', (['[[-1, 0], [1, 0], [0, 1.732]]'], {}), '([[-1, 0], [1, 0], [0, 1.732]])\n', (74, 105), True, 'import numpy as np\n'), ((271, 308), 'numpy.array', 'np.array', (['[[-1, 0], [1, 0], [0, 0.2]]'], {}), '([[-1, 0], [1, 0], [0, 0.2]])\n', (279, 308), True, 'import numpy as np\n'), ((4... |
# Copyright 2018 <NAME>
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
... | [
"ppg.DependenciesPPG",
"common.data_utterance_pb2.MetaData.Gender.Value",
"common.align.read_tg_from_str",
"logging.warning",
"common.feat.read_wav_kaldi_internal",
"common.align.write_tg_to_str",
"common.data_utterance_pb2.MetaData.Gender.Name",
"ppg.compute_monophone_ppg",
"textgrid.IntervalTier",... | [((1792, 1810), 'numpy.array', 'np.array', (['mat.data'], {}), '(mat.data)\n', (1800, 1810), True, 'import numpy as np\n'), ((3665, 3722), 'textgrid.IntervalTier', 'IntervalTier', ([], {'minTime': 'start_time[0]', 'maxTime': 'end_time[-1]'}), '(minTime=start_time[0], maxTime=end_time[-1])\n', (3677, 3722), False, 'from... |
################################################################################################################
# Author: <NAME>
# <EMAIL>
################################################################################################################
from dotmap import DotMap
import numpy as np
import scipy.io
impor... | [
"torch.nn.Dropout",
"torch.mean",
"numpy.stack",
"torch.from_numpy",
"numpy.sum",
"argparse.ArgumentParser",
"torch.nn.ReLU",
"torch.gather",
"torch.nn.LogSoftmax",
"torch.autograd.Variable",
"numpy.nonzero",
"torch.exp",
"numpy.mean",
"torch.nn.Linear",
"torch.sum",
"torch.cuda.LongTe... | [((559, 584), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (582, 584), False, 'import argparse\n'), ((5358, 5387), 'torch.sum', 'torch.sum', (['KLD_element'], {'dim': '(1)'}), '(KLD_element, dim=1)\n', (5367, 5387), False, 'import torch\n'), ((6045, 6074), 'numpy.sum', 'np.sum', (['batch_nn_d... |
import torch
import torch.nn as nn
import cv2
import numpy as np
from ..builder import DETECTORS, build_backbone, build_head, build_neck
from .base import BaseDetector
from mmdet.core.bbox.iou_calculators import build_iou_calculator
from mmdet.models.plugins import Heatmap
import os
import mmcv
class TwoStageDetector... | [
"torch.randn",
"cv2.rectangle",
"cv2.imshow",
"mmcv.imread",
"numpy.zeros_like",
"mmdet.core.bbox.iou_calculators.build_iou_calculator",
"cv2.resize",
"mmdet.models.plugins.Heatmap",
"numpy.uint8",
"cv2.waitKey",
"numpy.hstack",
"cv2.addWeighted",
"cv2.applyColorMap",
"numpy.vstack",
"cv... | [((2446, 2455), 'mmdet.models.plugins.Heatmap', 'Heatmap', ([], {}), '()\n', (2453, 2455), False, 'from mmdet.models.plugins import Heatmap\n'), ((12961, 12986), 'cv2.waitKey', 'cv2.waitKey', (['wait_time_ms'], {}), '(wait_time_ms)\n', (12972, 12986), False, 'import cv2\n'), ((9021, 9048), 'mmdet.utils.featuremap_to_he... |
# -*- coding: utf-8 -*-
# Copyright (c) 2020. Distributed under the terms of the MIT License.
from copy import deepcopy
import numpy as np
from pymatgen.io.vasp import Vasprun
from vise.analyzer.effective_mass import EffectiveMass
from pymatgen.electronic_structure.boltztrap import BoltztrapError
def make_effectiv... | [
"numpy.array",
"copy.deepcopy",
"pymatgen.electronic_structure.boltztrap2.BztInterpolator",
"pymatgen.electronic_structure.boltztrap2.VasprunBSLoader"
] | [((637, 654), 'copy.deepcopy', 'deepcopy', (['vasprun'], {}), '(vasprun)\n', (645, 654), False, 'from copy import deepcopy\n'), ((768, 792), 'pymatgen.electronic_structure.boltztrap2.VasprunBSLoader', 'VasprunBSLoader', (['vasprun'], {}), '(vasprun)\n', (783, 792), False, 'from pymatgen.electronic_structure.boltztrap2 ... |
import numpy as np
import pandas as pd
import os
def mask_step(x, step):
"""
Create a mask to only contain the step-th element starting from the first element. Used to downsample
"""
mask = np.zeros_like(x)
mask[::step] = 1
return mask.astype(bool)
def downsample(df, step):
"""
Downsample data by the given ... | [
"pandas.factorize",
"numpy.zeros_like",
"pandas.concat",
"numpy.where"
] | [((196, 212), 'numpy.zeros_like', 'np.zeros_like', (['x'], {}), '(x)\n', (209, 212), True, 'import numpy as np\n'), ((6109, 6143), 'pandas.concat', 'pd.concat', (['data'], {'ignore_index': '(True)'}), '(data, ignore_index=True)\n', (6118, 6143), True, 'import pandas as pd\n'), ((8394, 8453), 'numpy.where', 'np.where', ... |
import unittest
import pytest
import numpy as np
from s2and.data import ANDData
from s2and.featurizer import FeaturizationInfo, many_pairs_featurize
from s2and.consts import LARGE_INTEGER
class TestData(unittest.TestCase):
def setUp(self):
super().setUp()
self.dummy_dataset = ANDData(
... | [
"s2and.featurizer.FeaturizationInfo",
"numpy.isnan",
"s2and.data.ANDData",
"s2and.featurizer.many_pairs_featurize"
] | [((300, 445), 's2and.data.ANDData', 'ANDData', (['"""tests/dummy/signatures.json"""', '"""tests/dummy/papers.json"""'], {'clusters': '"""tests/dummy/clusters.json"""', 'name': '"""dummy"""', 'load_name_counts': '(True)'}), "('tests/dummy/signatures.json', 'tests/dummy/papers.json', clusters=\n 'tests/dummy/clusters.... |
import numpy as np, os, itertools
import pandas as pd
from rpy2 import robjects
import rpy2.robjects.numpy2ri
rpy2.robjects.numpy2ri.activate()
import rpy2.robjects.pandas2ri
from rpy2.robjects.packages import importr
from selection.adjusted_MLE.BH_MLE import (BHfilter,
cove... | [
"pandas.DataFrame",
"selection.adjusted_MLE.BH_MLE.test_marginal",
"numpy.asarray",
"os.path.dirname",
"numpy.zeros",
"numpy.ones",
"numpy.array",
"itertools.chain.from_iterable",
"numpy.sqrt"
] | [((485, 513), 'numpy.array', 'np.array', (['[1, 5, 10, 12, 15]'], {}), '([1, 5, 10, 12, 15])\n', (493, 513), True, 'import numpy as np, os, itertools\n'), ((581, 593), 'numpy.sqrt', 'np.sqrt', (['(1.0)'], {}), '(1.0)\n', (588, 593), True, 'import numpy as np, os, itertools\n'), ((683, 697), 'pandas.DataFrame', 'pd.Data... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright (c) <NAME>. All rights reserved.
# Licensed under the BSD license. See LICENSE file in the project root for full license information.
import numpy as np
class AbstractFeature(object):
def compute(self,X,y):
raise NotImplementedError("Every Abstra... | [
"numpy.matrix",
"numpy.power",
"numpy.asarray",
"numpy.floor",
"numpy.zeros",
"numpy.argsort",
"facerec.operators.ChainOperator",
"numpy.histogram",
"numpy.linalg.svd",
"numpy.array",
"numpy.linalg.inv",
"numpy.mean",
"numpy.where",
"numpy.dot",
"facerec.util.asColumnMatrix",
"numpy.un... | [((1545, 1562), 'facerec.util.asColumnMatrix', 'asColumnMatrix', (['X'], {}), '(X)\n', (1559, 1562), False, 'from facerec.util import asColumnMatrix\n'), ((1575, 1588), 'numpy.asarray', 'np.asarray', (['y'], {}), '(y)\n', (1585, 1588), True, 'import numpy as np\n'), ((2026, 2064), 'numpy.linalg.svd', 'np.linalg.svd', (... |
# Copyright (c) 2012-2014, GPy authors (see AUTHORS.txt).
# Licensed under the BSD 3-clause license (see LICENSE.txt)
from .. import likelihoods
from ..inference import optimization
from ..util.misc import opt_wrapper
from .parameterization import Parameterized
import multiprocessing as mp
import numpy as np
from num... | [
"numpy.random.uniform",
"numpy.abs",
"numpy.allclose",
"numpy.zeros",
"numpy.argmin",
"numpy.where",
"numpy.array",
"multiprocessing.Pool",
"numpy.dot",
"numpy.all"
] | [((4158, 4210), 'numpy.argmin', 'np.argmin', (['[o.f_opt for o in self.optimization_runs]'], {}), '([o.f_opt for o in self.optimization_runs])\n', (4167, 4210), True, 'import numpy as np\n'), ((13075, 13092), 'numpy.zeros', 'np.zeros', (['x.shape'], {}), '(x.shape)\n', (13083, 13092), True, 'import numpy as np\n'), ((1... |
import numpy as np
import pyuvdata
import copy
from collections import OrderedDict as odict
import astropy.units as u
import astropy.constants as c
from pyuvdata import UVData
import uvtools
from . import conversions, uvpspec, utils
def delay_spectrum(uvp, blpairs, spw, pol, average_blpairs=False,
... | [
"numpy.abs",
"numpy.floor",
"numpy.argsort",
"numpy.imag",
"numpy.rot90",
"numpy.meshgrid",
"numpy.unwrap",
"uvtools.plot.waterfall",
"numpy.real",
"numpy.log10",
"matplotlib.pyplot.subplots",
"copy.deepcopy",
"numpy.ceil",
"matplotlib.ticker.LogFormatterSciNotation",
"numpy.diff",
"nu... | [((4637, 4659), 'copy.deepcopy', 'copy.deepcopy', (['blpairs'], {}), '(blpairs)\n', (4650, 4659), False, 'import copy\n'), ((15464, 15486), 'copy.deepcopy', 'copy.deepcopy', (['blpairs'], {}), '(blpairs)\n', (15477, 15486), False, 'import copy\n'), ((16210, 16217), 'collections.OrderedDict', 'odict', ([], {}), '()\n', ... |
# Copyright 2018/2019 The RLgraph authors. 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
#
# Unless required by appli... | [
"numpy.random.seed",
"numpy.argmax",
"rlgraph.components.neural_networks.actor_component.ActorComponent",
"rlgraph.components.explorations.exploration.Exploration",
"rlgraph.tests.test_util.config_from_path",
"rlgraph.tests.test_util.recursive_assert_almost_equal",
"rlgraph.utils.numpy.softmax",
"rlgr... | [((2012, 2025), 'rlgraph.components.explorations.exploration.Exploration', 'Exploration', ([], {}), '()\n', (2023, 2025), False, 'from rlgraph.components.explorations.exploration import Exploration\n'), ((2070, 2119), 'rlgraph.components.neural_networks.actor_component.ActorComponent', 'ActorComponent', (['preprocessor... |
import astropy.units as u
from astropy.coordinates import SkyCoord
import pandas as pd
import numpy as np
import tqdm
from tde_catalogue import main_logger
from tde_catalogue.catalogue import Catalogue
logger = main_logger.getChild(__name__)
class Compiler:
"""
An instance of this class will take a list of... | [
"astropy.coordinates.SkyCoord",
"tde_catalogue.main_logger.getChild",
"pandas.concat",
"numpy.all"
] | [((214, 244), 'tde_catalogue.main_logger.getChild', 'main_logger.getChild', (['__name__'], {}), '(__name__)\n', (234, 244), False, 'from tde_catalogue import main_logger\n'), ((1309, 1323), 'pandas.concat', 'pd.concat', (['dfs'], {}), '(dfs)\n', (1318, 1323), True, 'import pandas as pd\n'), ((1141, 1190), 'numpy.all', ... |
"""
Utility functions adapted from: https://github.com/swshon/multi-speakerID.
Copyright 2018 <NAME>
Biometric Vox S.L.
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.o... | [
"numpy.absolute",
"sklearn.metrics.roc_curve",
"numpy.power",
"numpy.float",
"numpy.nonzero",
"numpy.array",
"numpy.loadtxt",
"numpy.unique"
] | [((790, 863), 'numpy.loadtxt', 'np.loadtxt', (['filename'], {'dtype': '"""str"""', 'delimiter': '""","""', 'skiprows': '(1)', 'usecols': '[0]'}), "(filename, dtype='str', delimiter=',', skiprows=1, usecols=[0])\n", (800, 863), True, 'import numpy as np\n'), ((1365, 1383), 'numpy.array', 'np.array', (['norm_mat'], {}), ... |
import numpy as np
import tensorflow as tf
import gym
import time
from collections import deque
class PPO:
""" Single agent implementation of Proximal Policy Optimization with a clipped surrogate objective function,
Generalized Advantage Estimation, and no shared parameters between the policy (actor) and valu... | [
"numpy.random.seed",
"tensorflow.clip_by_value",
"tensorflow.get_collection",
"numpy.clip",
"numpy.mean",
"collections.deque",
"numpy.zeros_like",
"tensorflow.variable_scope",
"tensorflow.set_random_seed",
"tensorflow.placeholder",
"numpy.random.choice",
"tensorflow.global_variables_initialize... | [((11136, 11147), 'time.time', 'time.time', ([], {}), '()\n', (11145, 11147), False, 'import time\n'), ((11200, 11218), 'gym.make', 'gym.make', (['env_name'], {}), '(env_name)\n', (11208, 11218), False, 'import gym\n'), ((11255, 11275), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (11269, 11275), ... |
import numpy as np
dataDir = 'ics_temporals.txt'
data = np.genfromtxt(dataDir, skip_header=1)
# collect data after 100 seconds
noffset = 8 * data.shape[0] // 10
# extract P_OVER_RHO_INTGRL_(1) and TAU_INTGRL_(1)
p_over_rho_intgrl_1 = data[noffset:, 4]
tau_intgrl_1 = data[noffset:, 6]
drag = np.mean(p_over_rho_intgrl_1... | [
"numpy.mean",
"numpy.genfromtxt"
] | [((57, 94), 'numpy.genfromtxt', 'np.genfromtxt', (['dataDir'], {'skip_header': '(1)'}), '(dataDir, skip_header=1)\n', (70, 94), True, 'import numpy as np\n'), ((293, 336), 'numpy.mean', 'np.mean', (['(p_over_rho_intgrl_1 - tau_intgrl_1)'], {}), '(p_over_rho_intgrl_1 - tau_intgrl_1)\n', (300, 336), True, 'import numpy a... |
# --------------------------------------------------------------- Imports ---------------------------------------------------------------- #
# System
import json
# Pip
import numpy
# Local
from pretty_talib import get_stats, ALL, FunctionName
# -----------------------------------------------------------------------... | [
"pandas.DataFrame",
"json.dump",
"pretty_talib.get_stats",
"numpy.random.random"
] | [((772, 842), 'pandas.DataFrame', 'pd.DataFrame', (['data'], {'columns': "['open', 'high', 'low', 'close', 'volume']"}), "(data, columns=['open', 'high', 'low', 'close', 'volume'])\n", (784, 842), True, 'import pandas as pd\n'), ((852, 914), 'pretty_talib.get_stats', 'get_stats', (['data'], {'timeperiod': 'timeperiod',... |
#!/usr/bin/env python
# coding: utf-8
import sys
import time
import sklearn.metrics
from masif.geometry.open3d_import import *
import numpy as np
import os
from masif.masif_ppi_search.alignment_utils_masif_search import compute_nn_score, rand_rotation_matrix, \
get_center_and_random_rotate, get_patch_geo, multi... | [
"numpy.sum",
"numpy.nan_to_num",
"numpy.argmax",
"masif.ppi_search.pdl1_benchmark.align_and_save",
"os.walk",
"masif.masif_ppi_search.alignment_utils_masif_search.subsample_patch_coords",
"numpy.argsort",
"os.path.isfile",
"numpy.mean",
"numpy.linalg.norm",
"scipy.spatial.cKDTree",
"os.path.jo... | [((5832, 5844), 'time.clock', 'time.clock', ([], {}), '()\n', (5842, 5844), False, 'import time\n'), ((5939, 5948), 'masif.masif_ppi_search.transformation_training_data.score_nn.ScoreNN', 'ScoreNN', ([], {}), '()\n', (5946, 5948), False, 'from masif.masif_ppi_search.transformation_training_data.score_nn import ScoreNN\... |
import cv2
import numpy as np
import quaternion # install numpy-quaternion
class Transformation:
def __init__(self, rotation=None, translation=None, transformation=None):
if transformation is not None:
rotation = transformation.rotate if rotation is None else rotation
translation ... | [
"quaternion.as_rotation_matrix",
"numpy.arctan2",
"numpy.copy",
"quaternion.from_rotation_matrix",
"numpy.zeros",
"quaternion.rotate_vectors",
"cv2.Rodrigues",
"numpy.array",
"quaternion.from_rotation_vector",
"numpy.sqrt"
] | [((658, 677), 'cv2.Rodrigues', 'cv2.Rodrigues', (['rvec'], {}), '(rvec)\n', (671, 677), False, 'import cv2\n'), ((690, 727), 'quaternion.from_rotation_matrix', 'quaternion.from_rotation_matrix', (['rmat'], {}), '(rmat)\n', (721, 727), False, 'import quaternion\n'), ((1567, 1613), 'quaternion.from_rotation_vector', 'qua... |
# -*- coding: utf-8 -*-
from datetime import datetime, timedelta
import re
import pkg_resources
import os
import logging
import struct
import json
try:
import hashlib
md5 = hashlib.md5
except ImportError:
# for Python << 2.5
import md5
md5 = md5.new
# import codecs
import numpy as np
from numpy i... | [
"pandas.DataFrame",
"struct.unpack_from",
"os.path.basename",
"numpy.ma.masked_all",
"re.finditer",
"numpy.ma.getmaskarray",
"struct.calcsize",
"datetime.datetime",
"numpy.ma.array",
"datetime.datetime.strptime",
"seabird.utils.load_rule",
"numpy.append",
"pkg_resources.resource_string",
"... | [((423, 455), 'logging.getLogger', 'logging.getLogger', (['"""seabird.cnv"""'], {}), "('seabird.cnv')\n", (440, 455), False, 'import logging\n'), ((1276, 1312), 're.sub', 're.sub', (['"""\n\\\\s*(?=\n)"""', '""""""', 'raw_text'], {}), "('\\n\\\\s*(?=\\n)', '', raw_text)\n", (1282, 1312), False, 'import re\n'), ((1417, ... |
import gc
import os
import numpy as np
from sklearn.neighbors import NearestNeighbors, DistanceMetric
from sklearn.preprocessing import MultiLabelBinarizer, LabelBinarizer
import tensorflow as tf
from tensorflow.keras import backend as K
from tensorflow.keras import constraints
from tensorflow.keras import losses
from ... | [
"tensorflow.random.set_seed",
"sklearn.preprocessing.LabelBinarizer",
"tensorflow.keras.backend.clear_session",
"tensorflow.keras.models.Model",
"tensorflow.keras.layers.Input",
"tensorflow.keras.initializers.Constant",
"tensorflow.keras.regularizers.l1_l2",
"tensorflow.keras.callbacks.EarlyStopping",... | [((1501, 1517), 'sklearn.preprocessing.LabelBinarizer', 'LabelBinarizer', ([], {}), '()\n', (1515, 1517), False, 'from sklearn.preprocessing import MultiLabelBinarizer, LabelBinarizer\n'), ((1576, 1598), 'tensorflow.random.set_seed', 'tf.random.set_seed', (['(42)'], {}), '(42)\n', (1594, 1598), True, 'import tensorflow... |
import os
import argparse
import torch
import torchvision
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import Subset
from PIL import Image
import numpy as np
from dataclasses import dataclass
import copy
from networ... | [
"torch.cat",
"torchvision.datasets.CIFAR10",
"numpy.random.randint",
"torch.device",
"torchvision.transforms.Normalize",
"os.path.join",
"torch.utils.data.DataLoader",
"networks.Encoder",
"torch.zeros",
"copy.deepcopy",
"torchvision.transforms.RandomHorizontalFlip",
"networks.ConvNet",
"torc... | [((870, 966), 'torchvision.datasets.CIFAR10', 'torchvision.datasets.CIFAR10', ([], {'root': '"""./data"""', 'train': 'train', 'download': '(True)', 'transform': 'transform'}), "(root='./data', train=train, download=True,\n transform=transform)\n", (898, 966), False, 'import torchvision\n'), ((1258, 1327), 'torch.uti... |
### testing image registration functions
import numpy as np
from urllib.parse import urlparse
from cellpose import utils, io,models
import matplotlib
import matplotlib.pyplot as plt
import time, os, sys
import pandas as pd
import glob
### Part 1 : Image Registration
from skimage import img_as_uint,io,registration,trans... | [
"skimage.segmentation.join_segmentations",
"numpy.load",
"pandas.read_csv",
"scipy.spatial.Voronoi",
"numpy.ones",
"matplotlib.pyplot.figure",
"numpy.linalg.norm",
"skimage.transform.rotate",
"numpy.round",
"numpy.prod",
"pandas.DataFrame",
"numpy.pad",
"scipy.ndimage.distance_transform_edt"... | [((672, 693), 'matplotlib.use', 'matplotlib.use', (['"""agg"""'], {}), "('agg')\n", (686, 693), False, 'import matplotlib\n'), ((1563, 1593), 'numpy.average', 'np.average', (['image0[image0 > 0]'], {}), '(image0[image0 > 0])\n', (1573, 1593), True, 'import numpy as np\n'), ((1603, 1633), 'numpy.average', 'np.average', ... |
from operator import itemgetter
import numpy as np
import torch
import random
import numpy as np
from global_var import MIDDLE, EVENLY, DYN_IMAGE, RGB_FRAME
class TubeCrop(object):
def __init__(self,
tube_len=16,
central_frame=True,
max_num_tubes=4,
... | [
"numpy.asarray",
"numpy.insert",
"numpy.array",
"numpy.linspace",
"operator.itemgetter",
"torch.from_numpy"
] | [((3443, 3469), 'numpy.array', 'np.array', (['tube_frames_idxs'], {}), '(tube_frames_idxs)\n', (3451, 3469), True, 'import numpy as np\n'), ((6292, 6326), 'numpy.insert', 'np.insert', (['central_box[0:4]', '(0)', 'id'], {}), '(central_box[0:4], 0, id)\n', (6301, 6326), True, 'import numpy as np\n'), ((6363, 6392), 'tor... |
import numpy as np
import matplotlib.pyplot as plt
try:
import plotly.graph_objects as go
from plotly.subplots import make_subplots
except ImportError:
pass
def __calc_plot_data(stvariogram, **kwargs):
# get the marginal experimental variograms
vx = stvariogram.XMarginal.experimental
vy = stv... | [
"plotly.graph_objects.Figure",
"matplotlib.pyplot.tight_layout",
"numpy.linspace"
] | [((429, 471), 'numpy.linspace', 'np.linspace', (['(0)', 'stvariogram.xbins[-1]', 'res'], {}), '(0, stvariogram.xbins[-1], res)\n', (440, 471), True, 'import numpy as np\n'), ((481, 523), 'numpy.linspace', 'np.linspace', (['(0)', 'stvariogram.tbins[-1]', 'res'], {}), '(0, stvariogram.tbins[-1], res)\n', (492, 523), True... |
# -*-coding:utf-8-*-
import logging
import math
import os
import shutil
import tensorflow as tf
from scipy.stats import ttest_ind
import numpy as np
import torch
import torchvision
import torchvision.transforms as transforms
class Cutout(object):
def __init__(self, n_holes, length):
self.n_holes = n_holes... | [
"tensorflow.gfile.Exists",
"tensorflow.logging.info",
"math.tanh",
"numpy.ones",
"numpy.clip",
"logging.Formatter",
"torchvision.datasets.CIFAR10",
"os.path.isfile",
"numpy.random.randint",
"numpy.mean",
"torchvision.transforms.Normalize",
"logging.FileHandler",
"torch.utils.data.DataLoader"... | [((2748, 2788), 'torch.save', 'torch.save', (['state', "(filename + '.pth.tar')"], {}), "(state, filename + '.pth.tar')\n", (2758, 2788), False, 'import torch\n'), ((2939, 2959), 'os.path.isfile', 'os.path.isfile', (['path'], {}), '(path)\n', (2953, 2959), False, 'import os\n'), ((4343, 4457), 'torch.utils.data.DataLoa... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
import cPickle as pickle
import numpy as np
import argparse
import time
import sys
import os
def normal(x, mu, sigma):
pi ... | [
"numpy.load",
"numpy.random.seed",
"tensorflow.trainable_variables",
"tensorflow.reset_default_graph",
"tensorflow.multiply",
"tensorflow.matmul",
"tensorflow.Variable",
"numpy.random.randint",
"tensorflow.nn.conv2d",
"os.path.join",
"tensorflow.truncated_normal",
"tensorflow.nn.relu",
"tens... | [((322, 340), 'tensorflow.constant', 'tf.constant', (['np.pi'], {}), '(np.pi)\n', (333, 340), True, 'import tensorflow as tf\n'), ((461, 479), 'tensorflow.constant', 'tf.constant', (['np.pi'], {}), '(np.pi)\n', (472, 479), True, 'import tensorflow as tf\n'), ((940, 996), 'tensorflow.nn.conv2d', 'tf.nn.conv2d', (['x', '... |
import math
import os
import numpy as np
import matplotlib.pyplot as plt
import torch
import argparse
from pathlib import Path
from models import DAVE2pytorch
from DatasetGenerator import DataSequence
from torch.utils.data import DataLoader
from torchvision.transforms import Compose, ToTensor
def parse_args():
p... | [
"os.mkdir",
"argparse.ArgumentParser",
"torch.utils.data.DataLoader",
"math.pow",
"numpy.random.get_state",
"torch.load",
"os.path.exists",
"torch.cuda.is_available",
"matplotlib.pyplot.savefig",
"torchvision.transforms.ToTensor"
] | [((679, 721), 'torch.load', 'torch.load', (['modelpath'], {'map_location': 'device'}), '(modelpath, map_location=device)\n', (689, 721), False, 'import torch\n'), ((1086, 1179), 'torch.utils.data.DataLoader', 'DataLoader', (['dataset'], {'batch_size': 'BATCH_SIZE', 'shuffle': '(False)', 'worker_init_fn': 'worker_init_f... |
'''
Created on Sep, 2017
@author: hugo
'''
import os
import re
import yaml
import gzip
import json
import string
import numpy as np
from nltk.tokenize import wordpunct_tokenize#, word_tokenize
# tokenize = lambda s: word_tokenize(re.sub(r'[%s]' % punc_wo_dot, ' ', re.sub(r'(?<!\d)[%s](?!\d)' % string.punctuation, '... | [
"json.dump",
"yaml.load",
"json.load",
"numpy.save",
"numpy.load",
"gzip.open",
"os.walk",
"re.escape",
"json.dumps",
"os.path.join",
"os.listdir"
] | [((529, 547), 'yaml.load', 'yaml.load', (['setting'], {}), '(setting)\n', (538, 547), False, 'import yaml\n'), ((1284, 1300), 'numpy.save', 'np.save', (['f', 'data'], {}), '(f, data)\n', (1291, 1300), True, 'import numpy as np\n'), ((1449, 1459), 'numpy.load', 'np.load', (['f'], {}), '(f)\n', (1456, 1459), True, 'impor... |
# -*- coding: utf-8 -*-
"""
@author: <NAME> <<EMAIL>>
"""
from ..data import TextModule
from ..data import ImageModule
from ..data import GraphModule
from ..data import MultimodalTrainSet
from ..data import MultimodalTestSet
from ..utils.common import validate_format
from ..metrics.rating import RatingMetric
from ..m... | [
"tqdm.tqdm",
"numpy.ones_like",
"numpy.asarray",
"numpy.zeros",
"time.time",
"collections.defaultdict",
"numpy.mean",
"numpy.arange",
"numpy.where",
"collections.OrderedDict"
] | [((1890, 1903), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (1901, 1903), False, 'from collections import OrderedDict, defaultdict\n'), ((1934, 1947), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (1945, 1947), False, 'from collections import OrderedDict, defaultdict\n'), ((8612, 8623), 't... |
# -*- coding: utf-8 -*-
"""SAC agent for continuous tasks in Genius Environment.
- Author: <NAME>
- Contact: <EMAIL>
- Paper: https://arxiv.org/pdf/1801.01290.pdf
https://arxiv.org/pdf/1812.05905.pdf
"""
from collections import deque
import os
import shutil
import time
from typing import Tuple
import numpy a... | [
"wandb.log",
"wandb.config.update",
"time.time",
"torch.cuda.is_available",
"os.path.join",
"numpy.vstack"
] | [((526, 551), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (549, 551), False, 'import torch\n'), ((2296, 2307), 'time.time', 'time.time', ([], {}), '()\n', (2305, 2307), False, 'import time\n'), ((4019, 4075), 'wandb.log', 'wandb.log', (["{'opp_utility': utility}"], {'step': 'self.i_episode'}... |
import numpy as np
from numpy.typing import ArrayLike
import puzzle_1
def load_input(file: str) -> ArrayLike:
"""Load the puzzle input and duplicate 5 times in each direction,
adding 1 to the array for each copy.
"""
input = puzzle_1.load_input(file)
input_1x5 = np.copy(input)
for _ in rang... | [
"numpy.copy",
"puzzle_1.find_lowest_risk_score",
"numpy.mod",
"puzzle_1.load_input",
"numpy.concatenate"
] | [((244, 269), 'puzzle_1.load_input', 'puzzle_1.load_input', (['file'], {}), '(file)\n', (263, 269), False, 'import puzzle_1\n'), ((287, 301), 'numpy.copy', 'np.copy', (['input'], {}), '(input)\n', (294, 301), True, 'import numpy as np\n'), ((476, 494), 'numpy.copy', 'np.copy', (['input_1x5'], {}), '(input_1x5)\n', (483... |
# do the necessary imports
import warnings
from joblib import dump, load
import flwr as fl
import numpy as np
import datahandler as dh
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import log_loss
from sklearn.utils import class_weight
from imblearn.over_sampling import SMOTE
from sklearn im... | [
"utils.partition",
"matplotlib.pyplot.show",
"warnings.simplefilter",
"utils.get_model_parameters",
"sklearn.metrics.accuracy_score",
"utils.set_initial_params",
"datahandler.data_processor",
"sklearn.linear_model.LogisticRegression",
"utils.set_model_params",
"mlxtend.plotting.plot_confusion_matr... | [((519, 538), 'datahandler.data_processor', 'dh.data_processor', ([], {}), '()\n', (536, 538), True, 'import datahandler as dh\n'), ((958, 978), 'numpy.random.choice', 'np.random.choice', (['(10)'], {}), '(10)\n', (974, 978), True, 'import numpy as np\n'), ((1623, 1684), 'sklearn.linear_model.LogisticRegression', 'Logi... |
import numpy as np
def times_for_clean_separation(n_events, MaxDelay):
"""
Function to generate evenly spaced event times.
Args:
n_events (int): Number of events
MaxDelay (float): Time difference between events. Should be large enough to
prevent event pile-up.
Returns:
... | [
"numpy.random.uniform",
"numpy.arange"
] | [((415, 441), 'numpy.arange', 'np.arange', (['(1)', '(n_events + 1)'], {}), '(1, n_events + 1)\n', (424, 441), True, 'import numpy as np\n'), ((1391, 1466), 'numpy.random.uniform', 'np.random.uniform', ([], {'low': 'offset', 'high': '(simulation_time + offset)', 'size': 'n_events'}), '(low=offset, high=simulation_time ... |
import numpy as np
import rospy
from collections import namedtuple
from pyrobot.core import Arm
class TM700Arm(Arm):
"""
This class has the functionality to control a tm700 manipulator
"""
def __init__( self,
configs,
moveit_planner='ESTkConfigDefault'):
... | [
"numpy.zeros"
] | [((560, 582), 'numpy.zeros', 'np.zeros', (['self.arm_dof'], {}), '(self.arm_dof)\n', (568, 582), True, 'import numpy as np\n')] |
"""Training routines that optimize neural networks and other ansatzs.
This module provides interface and implementations of Wavefunction optimizer.
It separates the process into connection of the necessary modules into the graph
and their execution in a specified order to perform a single epoch of training.
New optim... | [
"tensorflow.local_variables",
"tensorflow.assign",
"graph_builders.get_or_create_num_epochs",
"tensorflow.sqrt",
"tensorflow.train.ExponentialMovingAverage",
"scipy.special.binomi",
"tensorflow.concat",
"typing.NamedTuple",
"tensorflow.metrics.mean_tensor",
"tensorflow.train.piecewise_constant",
... | [((805, 1093), 'typing.NamedTuple', 'NamedTuple', (['"""TrainingOpsTraditional"""', "[('accumulate_gradients', tf.Tensor), ('apply_gradients', tf.Tensor), (\n 'reset_gradients', tf.Tensor), ('mc_step', tf.Tensor), ('acc_rate', tf.\n Tensor), ('metrics', tf.Tensor), ('epoch_increment', tf.Tensor), (\n 'update_w... |
import torch
import numpy as np
# 19-4-12 pytorch
# input: coeff with shape [1,257]
def Split_coeff(coeff):
id_coeff = coeff[:,:80] # identity(shape) coeff of dim 80
ex_coeff = coeff[:,80:144] # expression coeff of dim 64
tex_coeff = coeff[:,144:224] # texture(albedo) coeff of dim 80
angles = coeff[:,... | [
"torch.ones",
"torch.eye",
"torch.stack",
"torch.cat",
"torch.cos",
"torch.einsum",
"numpy.reshape",
"torch.reshape",
"torch.matmul",
"numpy.sqrt",
"torch.sin",
"numpy.concatenate",
"torch.from_numpy"
] | [((1167, 1198), 'numpy.reshape', 'np.reshape', (['p_matrix', '[1, 3, 3]'], {}), '(p_matrix, [1, 3, 3])\n', (1177, 1198), True, 'import numpy as np\n'), ((1214, 1240), 'torch.from_numpy', 'torch.from_numpy', (['p_matrix'], {}), '(p_matrix)\n', (1230, 1240), False, 'import torch\n'), ((3045, 3077), 'torch.cat', 'torch.ca... |
import pandas as pd
import networkx as nx
import logging
import math
import numpy as np
from statsmodels.stats.outliers_influence import variance_inflation_factor
def get_vif(df: pd.DataFrame, threshold: float = 5.0):
"""
Calculates the variance inflation factor (VIF) for each feature column. A VIF
value... | [
"pandas.DataFrame",
"numpy.nan_to_num",
"statsmodels.stats.outliers_influence.variance_inflation_factor",
"numpy.zeros",
"networkx.Graph",
"networkx.find_cliques"
] | [((546, 560), 'pandas.DataFrame', 'pd.DataFrame', ([], {}), '()\n', (558, 560), True, 'import pandas as pd\n'), ((2207, 2217), 'networkx.Graph', 'nx.Graph', ([], {}), '()\n', (2215, 2217), True, 'import networkx as nx\n'), ((686, 725), 'statsmodels.stats.outliers_influence.variance_inflation_factor', 'variance_inflatio... |
import numpy as np
import tensorflow as tf
mean_color = np.asarray([123, 117, 104])
def random_flip_horizontal(image, ground_truth_boxes, prob=0.5, normalized=True):
with tf.name_scope('random_flip_horizontal'):
if tf.random.uniform(shape=(), name='prob') > prob:
if normalized:
... | [
"tensorflow.split",
"tensorflow.image.flip_left_right",
"numpy.random.uniform",
"numpy.minimum",
"numpy.maximum",
"tensorflow.random.uniform",
"numpy.asarray",
"tensorflow.pad",
"tensorflow.concat",
"numpy.clip",
"tensorflow.constant",
"tensorflow.cast",
"tensorflow.shape",
"numpy.random.c... | [((58, 85), 'numpy.asarray', 'np.asarray', (['[123, 117, 104]'], {}), '([123, 117, 104])\n', (68, 85), True, 'import numpy as np\n'), ((5163, 5198), 'numpy.minimum', 'np.minimum', (['box_a[:, 2:]', 'box_b[2:]'], {}), '(box_a[:, 2:], box_b[2:])\n', (5173, 5198), True, 'import numpy as np\n'), ((5212, 5247), 'numpy.maxim... |
import numpy as np
from neuraxle.base import ExecutionContext
from neuraxle.data_container import DataContainer
from neuraxle.pipeline import Pipeline
from neuraxle.steps.misc import FitCallbackStep, TapeCallbackFunction
from neuraxle.steps.numpy import MultiplyByN
from neuraxle.steps.output_handlers import OutputTran... | [
"neuraxle.base.ExecutionContext",
"neuraxle.steps.misc.TapeCallbackFunction",
"neuraxle.steps.numpy.MultiplyByN",
"neuraxle.data_container.DataContainer",
"numpy.random.random",
"neuraxle.steps.misc.FitCallbackStep",
"numpy.array_equal"
] | [((451, 473), 'neuraxle.steps.misc.TapeCallbackFunction', 'TapeCallbackFunction', ([], {}), '()\n', (471, 473), False, 'from neuraxle.steps.misc import FitCallbackStep, TapeCallbackFunction\n'), ((650, 699), 'numpy.array_equal', 'np.array_equal', (['tape.data[0][0]', 'expected_outputs'], {}), '(tape.data[0][0], expecte... |
# Generated by Selenium IDE
import pytest
import time
import json
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.support import expected_conditions
from selenium.webdriver.support.wait import WebDriverWa... | [
"time.sleep",
"numpy.random.randint",
"selenium.webdriver.ChromeOptions",
"selenium.webdriver.Chrome",
"yagmail.SMTP"
] | [((1275, 1300), 'selenium.webdriver.ChromeOptions', 'webdriver.ChromeOptions', ([], {}), '()\n', (1298, 1300), False, 'from selenium import webdriver\n'), ((1424, 1493), 'selenium.webdriver.Chrome', 'webdriver.Chrome', ([], {'executable_path': 'CHROME_DRIVER_PATH', 'options': 'options'}), '(executable_path=CHROME_DRIVE... |
"""Test channel data"""
from datetime import datetime, timezone
import numpy as np
from nitdms.reader import TdmsFile
from nitdms import WaveformDT
# pylint: disable=missing-docstring
# pylint: disable=pointless-statement
# pylint: disable=no-member
def test_channeldata():
tf = TdmsFile("./tests/tdms_files/chann... | [
"numpy.asarray",
"nitdms.reader.TdmsFile",
"datetime.datetime"
] | [((286, 333), 'nitdms.reader.TdmsFile', 'TdmsFile', (['"""./tests/tdms_files/channeldata.tdms"""'], {}), "('./tests/tdms_files/channeldata.tdms')\n", (294, 333), False, 'from nitdms.reader import TdmsFile\n'), ((557, 611), 'nitdms.reader.TdmsFile', 'TdmsFile', (['"""./tests/tdms_files/channeldata_nodata.tdms"""'], {}),... |
import numpy as np
import click
@click.command()
@click.option('--fasta', type=click.Path(exists=True), required=True)
@click.option('--iterations', type=int, default=10)
@click.option('--holdout-fraction', type=float, default=0.2)
@click.option('--output-basename', type=str, required=True)
def random_subsets(fasta, ... | [
"numpy.random.uniform",
"click.Path",
"click.option",
"click.command"
] | [((35, 50), 'click.command', 'click.command', ([], {}), '()\n', (48, 50), False, 'import click\n'), ((122, 172), 'click.option', 'click.option', (['"""--iterations"""'], {'type': 'int', 'default': '(10)'}), "('--iterations', type=int, default=10)\n", (134, 172), False, 'import click\n'), ((174, 233), 'click.option', 'c... |
from pathlib import Path
from typing import Dict, Union, Optional
import numpy as np
import pandas
import torch
from torch.utils.data import Dataset
import torchaudio
import pandas as pd
from src.common.utils import (
BIRDCALLS_DIR,
SOUNDSCAPES_DIR,
BIRD2IDX,
get_spectrogram,
load_vocab,
PROJECT... | [
"src.common.utils.get_spectrogram",
"numpy.vectorize",
"torch.stack",
"src.common.utils.SOUNDSCAPES_DIR.glob",
"hydra.utils.instantiate",
"pandas.read_csv",
"torch.load",
"numpy.ones",
"torch.save",
"src.common.utils.load_vocab",
"torchaudio.load",
"torch.tensor"
] | [((7263, 7283), 'src.common.utils.load_vocab', 'load_vocab', (['BIRD2IDX'], {}), '(BIRD2IDX)\n', (7273, 7283), False, 'from src.common.utils import BIRDCALLS_DIR, SOUNDSCAPES_DIR, BIRD2IDX, get_spectrogram, load_vocab, PROJECT_ROOT\n'), ((16733, 16753), 'src.common.utils.load_vocab', 'load_vocab', (['BIRD2IDX'], {}), '... |
import numpy as np
import scipy.ndimage
from scipy import interpolate, stats
import matplotlib.pyplot as plt
import matplotlib as mpl
import pickle
import os
import array
import cv2
#readin Image
def readin_vanhateren_img(fname):
'''
Readin a single van hateren image
'''
with open(fname, 'rb') as hand... | [
"cv2.imread",
"numpy.mean",
"numpy.array",
"array.array"
] | [((359, 378), 'array.array', 'array.array', (['"""H"""', 's'], {}), "('H', s)\n", (370, 378), False, 'import array\n'), ((570, 587), 'cv2.imread', 'cv2.imread', (['fname'], {}), '(fname)\n', (580, 587), False, 'import cv2\n'), ((596, 615), 'numpy.mean', 'np.mean', (['s'], {'axis': '(-1)'}), '(s, axis=-1)\n', (603, 615)... |
import matplotlib.pyplot as plt
import numpy as np
from scipy.optimize import curve_fit
E_aa = 1.09 * 1.6* 10**(-19) #j activation Energy
k_0a = 2.4 *10**(13)*60 #1/min frequnecy factor
k_B = 1.38064852 * 10**(-23) #Boltzmann Konstante
N_C0 = 1.1*10**11 #stable Damage amplitude in 1/cm**3
E_y = 1.33... | [
"matplotlib.pyplot.clf",
"numpy.genfromtxt",
"matplotlib.pyplot.subplots",
"numpy.exp",
"matplotlib.pyplot.semilogx",
"matplotlib.pyplot.savefig"
] | [((875, 922), 'numpy.genfromtxt', 'np.genfromtxt', (['"""Daten/tdata_1.txt"""'], {'unpack': '(True)'}), "('Daten/tdata_1.txt', unpack=True)\n", (888, 922), True, 'import numpy as np\n'), ((2001, 2015), 'matplotlib.pyplot.subplots', 'plt.subplots', ([], {}), '()\n', (2013, 2015), True, 'import matplotlib.pyplot as plt\n... |
import os, json
import numpy as np
import pandas as pd
from PIL import Image
import matplotlib.pyplot as plt
import seaborn
import matplotlib.patheffects as path_effects
def mean(list):
"""计算平均值"""
if not len(list):
return 0
return sum(list) / len(list)
# 平滑函数的作用是将每一个点的值变为 上一个节点*0.8+当前节点*0.2
def... | [
"matplotlib.pyplot.title",
"matplotlib.pyplot.suptitle",
"pandas.read_csv",
"matplotlib.pyplot.figure",
"numpy.arange",
"matplotlib.pyplot.gca",
"os.path.join",
"matplotlib.pyplot.MultipleLocator",
"pandas.DataFrame",
"json.loads",
"matplotlib.pyplot.close",
"matplotlib.pyplot.imshow",
"matp... | [((599, 624), 'numpy.array', 'np.array', (['smoothed_points'], {}), '(smoothed_points)\n', (607, 624), True, 'import numpy as np\n'), ((802, 818), 'os.listdir', 'os.listdir', (['"""./"""'], {}), "('./')\n", (812, 818), False, 'import os, json\n'), ((1768, 1784), 'numpy.array', 'np.array', (['plot_x'], {}), '(plot_x)\n'... |
# Princeton University licenses this file to You 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 writin... | [
"copy.deepcopy",
"psyneulink.core.globals.sampleiterator.SampleIterator",
"psyneulink.core.llvm.helpers.get_param_ptr",
"psyneulink.core.llvm.helpers.unwrap_2d_array",
"copy.copy",
"psyneulink.core.globals.context.handle_external_context",
"psyneulink.core.components.ports.inputport._parse_shadow_inputs... | [((44524, 44549), 'psyneulink.core.globals.context.handle_external_context', 'handle_external_context', ([], {}), '()\n', (44547, 44549), False, 'from psyneulink.core.globals.context import handle_external_context\n'), ((74236, 74261), 'psyneulink.core.globals.context.handle_external_context', 'handle_external_context'... |
import numpy as np
from scipy.integrate import odeint
from scipy.special import legendre, chebyt
import sys
sys.path.append('../src')
from sindy_utils import library_size
from data_manage import DataStruct
import pdb
class Rossler:
def __init__(self,
option='delay',
coefficients=[0.2, 0.2... | [
"sys.path.append",
"numpy.random.randn",
"data_manage.DataStruct",
"scipy.integrate.odeint",
"sindy_utils.library_size",
"numpy.zeros",
"numpy.arange",
"numpy.array",
"numpy.random.rand",
"numpy.concatenate"
] | [((108, 133), 'sys.path.append', 'sys.path.append', (['"""../src"""'], {}), "('../src')\n", (123, 133), False, 'import sys\n'), ((1484, 1506), 'numpy.arange', 'np.arange', (['(0)', 'tend', 'dt'], {}), '(0, tend, dt)\n', (1493, 1506), True, 'import numpy as np\n'), ((1665, 1683), 'numpy.array', 'np.array', (['ic_means']... |
import numpy as np
import cv2
import os
import sys
vgg_mean = [123.68, 116.779, 103.939]
def train_feature_extract(arg, Comparator, train_data):
train_features = np.array([]).reshape(0,1,1,512)
total_train_num = len(train_data)
train_done = 0
while total_train_num > 0:
train_... | [
"sys.stdout.write",
"sys.stdout.flush",
"numpy.array",
"os.path.join",
"numpy.concatenate"
] | [((1339, 1390), 'numpy.concatenate', 'np.concatenate', (['[train_features, train_feature_tmp]'], {}), '([train_features, train_feature_tmp])\n', (1353, 1390), True, 'import numpy as np\n'), ((1489, 1511), 'sys.stdout.write', 'sys.stdout.write', (["'\\r'"], {}), "('\\r')\n", (1505, 1511), False, 'import sys\n'), ((1616,... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Defines unit tests for :mod:`colour.phenomenons.rayleigh` module.
"""
from __future__ import division, unicode_literals
import numpy as np
import sys
if sys.version_info[:2] <= (2, 6):
import unittest2 as unittest
else:
import unittest
from colour.phenomen... | [
"unittest.main",
"colour.phenomenons.rayleigh.gravity_list1968",
"colour.phenomenons.rayleigh.air_refraction_index_penndorf1957",
"colour.phenomenons.rayleigh_scattering_spd",
"colour.phenomenons.rayleigh.molecular_density",
"colour.phenomenons.rayleigh.air_refraction_index_peck1972",
"colour.phenomenon... | [((1782, 7738), 'numpy.array', 'np.array', (['[0.59910134, 0.59217069, 0.58534101, 0.57861051, 0.57197745, 0.56544013, \n 0.55899687, 0.55264605, 0.54638605, 0.54021531, 0.53413228, 0.52813547,\n 0.5222234, 0.51639461, 0.51064769, 0.50498125, 0.49939393, 0.4938844, \n 0.48845134, 0.48309347, 0.47780954, 0.4725... |
__all__ = ['EmceeFitting', 'values_to_print']
import emcee
import numpy as np
import warnings
from pylightcurve.errors import *
from pylightcurve.processes.counter import Counter
from pylightcurve.processes.files import save_dict
from pylightcurve.plots.plots_fitting import plot_mcmc_corner, plot_mcmc_traces, plot_m... | [
"numpy.sum",
"pylightcurve.plots.plots_fitting.plot_mcmc_traces",
"numpy.ones",
"numpy.isnan",
"numpy.mean",
"numpy.correlate",
"warnings.simplefilter",
"numpy.std",
"pylightcurve.processes.files.save_dict",
"numpy.max",
"warnings.catch_warnings",
"numpy.swapaxes",
"numpy.log10",
"numpy.me... | [((1194, 1212), 'numpy.array', 'np.array', (['initials'], {}), '(initials)\n', (1202, 1212), True, 'import numpy as np\n'), ((1237, 1254), 'numpy.array', 'np.array', (['limits1'], {}), '(limits1)\n', (1245, 1254), True, 'import numpy as np\n'), ((1279, 1296), 'numpy.array', 'np.array', (['limits2'], {}), '(limits2)\n',... |
# -*- coding: utf-8 -*-
import numpy as np
'''
lapa: 11 class
label class
0 background
1 skin
2 left eyebrow
3 right eyebrow
4 left eye
5 right eye
6 nose
7 upper lip
8 inner mouth
9 lower lip
10 hair
label color
0 [0, 0, 0]
1 [0, 153, 255]
2 [102, 255, 153]
3 [0, 204, 153]
4 [255, 255, 102]
5 [255, 255, 204]
6 [255,... | [
"numpy.array"
] | [((608, 626), 'numpy.array', 'np.array', (['lapa_map'], {}), '(lapa_map)\n', (616, 626), True, 'import numpy as np\n'), ((1610, 1632), 'numpy.array', 'np.array', (['voc_colormap'], {}), '(voc_colormap)\n', (1618, 1632), True, 'import numpy as np\n')] |
# encoding: latin2
"""
Objective functions
"""
from __future__ import absolute_import
from builtins import range
__author__ = "<NAME>"
__credits__ = "Copyright (c) 2009-11 <NAME>"
__license__ = "New BSD License"
__version__ = "1.0.0"
__maintainer__ = "RiSE Group"
__email__ = "<EMAIL>"
from .distanceFunctions import d... | [
"numpy.array",
"numpy.linalg.norm",
"numpy.zeros",
"builtins.range"
] | [((2962, 2984), 'numpy.zeros', 'np.zeros', (['(size, size)'], {}), '((size, size))\n', (2970, 2984), True, 'import numpy as np\n'), ((3005, 3016), 'builtins.range', 'range', (['size'], {}), '(size)\n', (3010, 3016), False, 'from builtins import range\n'), ((3071, 3111), 'numpy.array', 'np.array', (['regionMaker.areas[a... |
import numpy as np
import pandas as pd
'''
Decision Trees are greedy algorithms
that maximise the current Information Gain
without backtracking or going back up to the root.
Future splits are based on the current splits:
split(t+1) = f(split(t))
At every level, the impurity of the dataset
decreases. The entropy (ran... | [
"pandas.read_csv",
"numpy.log2",
"numpy.unique",
"numpy.array",
"numpy.concatenate"
] | [((4053, 4117), 'pandas.read_csv', 'pd.read_csv', (['"""./data/iris.csv"""'], {'skiprows': '(1)', 'header': '(0)', 'names': 'cols'}), "('./data/iris.csv', skiprows=1, header=0, names=cols)\n", (4064, 4117), True, 'import pandas as pd\n'), ((4467, 4478), 'numpy.array', 'np.array', (['X'], {}), '(X)\n', (4475, 4478), Tru... |
#!/usr/bin/env python
"""
ScoreBigwig: Calculate footprint tracks from cutsite bigwig
@author: <NAME>
@contact: mette.bentsen (at) mpi-bn.mpg.de
@license: MIT
"""
import os
import sys
import argparse
import numpy as np
import math
import textwrap
import logging
import pyBigWig
import multiproce... | [
"tobias.utils.logger.TobiasLogger",
"numpy.abs",
"argparse.ArgumentParser",
"numpy.nan_to_num",
"tobias.utils.regions.OneRegion",
"multiprocessing.Manager",
"pyBigWig.open",
"argparse.RawDescriptionHelpFormatter",
"multiprocessing.Pool",
"tobias.utils.regions.RegionList",
"sys.exit"
] | [((3966, 4010), 'tobias.utils.logger.TobiasLogger', 'TobiasLogger', (['""""""', 'args.verbosity', 'args.log_q'], {}), "('', args.verbosity, args.log_q)\n", (3978, 4010), False, 'from tobias.utils.logger import TobiasLogger\n'), ((4029, 4055), 'pyBigWig.open', 'pyBigWig.open', (['args.signal'], {}), '(args.signal)\n', (... |
import numpy as np
#Calculate the magnetic field vector
def BVector(coords):
B = np.zeros_like(coords)
#Center B-field at this point.
center = np.array([0.,0.,0.55])
coordsB = coords.copy()
coordsB[...] = coordsB[...] - center
d = 0.05 #Diameter of... | [
"numpy.zeros_like",
"numpy.array",
"numpy.sum"
] | [((90, 111), 'numpy.zeros_like', 'np.zeros_like', (['coords'], {}), '(coords)\n', (103, 111), True, 'import numpy as np\n'), ((168, 194), 'numpy.array', 'np.array', (['[0.0, 0.0, 0.55]'], {}), '([0.0, 0.0, 0.55])\n', (176, 194), True, 'import numpy as np\n'), ((1923, 1953), 'numpy.sum', 'np.sum', (['(k * B)'], {'axis':... |
from krikos.data.loader import Loader
import numpy as np
class RecurrentTestLoader(Loader):
def __init__(self, batch_size):
super(RecurrentTestLoader, self).__init__(batch_size)
train, validation, test = self.load_data()
self.train_set, self.train_labels = train
self.validation_set... | [
"numpy.random.randint",
"numpy.where"
] | [((463, 507), 'numpy.random.randint', 'np.random.randint', (['(1)', '(10)'], {'size': '(16000, 2, 1)'}), '(1, 10, size=(16000, 2, 1))\n', (480, 507), True, 'import numpy as np\n'), ((582, 604), 'numpy.where', 'np.where', (['(targets <= 0)'], {}), '(targets <= 0)\n', (590, 604), True, 'import numpy as np\n'), ((606, 627... |
from functools import total_ordering
import operator
from collections import Counter, defaultdict
from tqdm import tqdm
import networkx as nx
import numpy as np
@total_ordering
class ClusterHDBSCAN(object):
def __init__(self, weight: float, cl_size: int, clusters: list = None, nodes: list = None):
# init
... | [
"tqdm.tqdm",
"collections.defaultdict",
"networkx.Graph",
"numpy.sign",
"collections.Counter",
"operator.itemgetter",
"numpy.unique"
] | [((7734, 7760), 'tqdm.tqdm', 'tqdm', (['connected_components'], {}), '(connected_components)\n', (7738, 7760), False, 'from tqdm import tqdm\n'), ((371, 380), 'collections.Counter', 'Counter', ([], {}), '()\n', (378, 380), False, 'from collections import Counter, defaultdict\n'), ((406, 415), 'collections.Counter', 'Co... |
import numpy as np
import math
import matplotlib.pyplot as plt
from basic_units import radians
plt.style.use('seaborn-whitegrid')
def format_func(value, tick_number):
# find number of multiples of pi/2
N = int(np.round(2 * value / np.pi))
if N == 0:
return "0"
elif N == 1:
... | [
"matplotlib.pyplot.title",
"UIE.NPoints",
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"math.tan",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.legend",
"math.sin",
"matplotlib.pyplot.style.use",
"numpy.arange",
"matplotlib.pyplot.xticks",
"numpy.linspace",
"matplotlib.pyplot.ylabe... | [((101, 135), 'matplotlib.pyplot.style.use', 'plt.style.use', (['"""seaborn-whitegrid"""'], {}), "('seaborn-whitegrid')\n", (114, 135), True, 'import matplotlib.pyplot as plt\n'), ((771, 782), 'math.sin', 'math.sin', (['x'], {}), '(x)\n', (779, 782), False, 'import math\n'), ((833, 844), 'math.tan', 'math.tan', (['x'],... |
#!/usr/bin/env python
u"""
convert_shapefile_centerline_geom_mod.py
<NAME> (Last update 06/2020)
Read output predictions and convert to shapefile lines
This script uses the centerline module
"""
import os
import sys
import rasterio
import numpy as np
import skimage
import getopt
import shapefile
import scipy.ndimage ... | [
"os.path.expanduser",
"os.mkdir",
"rasterio.open",
"numpy.count_nonzero",
"getopt.getopt",
"os.path.exists",
"centerline.geometry.Centerline",
"numpy.nonzero",
"rasterio.transform.xy",
"shapefile.Writer",
"skimage.measure.find_contours",
"shapely.ops.linemerge",
"numpy.round",
"os.path.joi... | [((490, 542), 'os.path.expanduser', 'os.path.expanduser', (['"""~/GL_learning_data/geocoded_v1"""'], {}), "('~/GL_learning_data/geocoded_v1')\n", (508, 542), False, 'import os\n'), ((692, 742), 'getopt.getopt', 'getopt.getopt', (['sys.argv[1:]', '"""D:F:C"""', 'long_options'], {}), "(sys.argv[1:], 'D:F:C', long_options... |
# vim: fdm=indent
'''
author: <NAME>
date: 22/11/17
content: Merge scattering and antibody-based predictors.
'''
# Modules
import os
import sys
import argparse
import yaml
import numpy as np
import pandas as pd
from scipy.stats import spearmanr
from sklearn.externals import joblib
import json
import matpl... | [
"numpy.load",
"sklearn.externals.joblib.dump",
"numpy.abs",
"argparse.ArgumentParser",
"pandas.read_csv",
"matplotlib.pyplot.tight_layout",
"pandas.DataFrame",
"numpy.meshgrid",
"matplotlib.pyplot.cm.Paired",
"seaborn.swarmplot",
"numpy.linspace",
"tarfile.open",
"collections.Counter",
"nu... | [((1151, 1176), 'pandas.read_csv', 'pd.read_csv', (['fn'], {'sep': '"""\t"""'}), "(fn, sep='\\t')\n", (1162, 1176), True, 'import pandas as pd\n'), ((2373, 2398), 'matplotlib.pyplot.cm.Paired', 'plt.cm.Paired', (['[0.0, 1.0]'], {}), '([0.0, 1.0])\n', (2386, 2398), True, 'import matplotlib.pyplot as plt\n'), ((4043, 406... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import sys
import numpy as np
import scipy as scp
import logging
import matplotlib.pyplot as plt
import json
from pyvision.logger import Logger
from ast import literal_eval
import torch
import t... | [
"os.mkdir",
"numpy.savez_compressed",
"torch.no_grad",
"matplotlib.pyplot.tight_layout",
"os.path.join",
"logging.error",
"matplotlib.pyplot.close",
"numpy.savetxt",
"os.path.exists",
"pyvision.utils.MedianSmoother",
"localseg.data_generators.visualizer.LocalSegVisualizer",
"os.path.basename",... | [((688, 799), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""%(asctime)s %(levelname)s %(message)s"""', 'level': 'logging.INFO', 'stream': 'sys.stdout'}), "(format='%(asctime)s %(levelname)s %(message)s', level=\n logging.INFO, stream=sys.stdout)\n", (707, 799), False, 'import logging\n'), ((12765... |
import argparse
import json
import numpy as np
import torch
from torch import nn, optim
from torch.autograd import Variable
from torchvision import datasets, transforms, models
from PIL import Image
### python predict.py ./flowers/test/7/image_08099.jpg ./checkpoint.pth --topk 5 --category_names cat_to_name.json --gpu... | [
"json.load",
"argparse.ArgumentParser",
"torch.load",
"torchvision.transforms.Normalize",
"numpy.asarray",
"PIL.Image.open",
"torchvision.transforms.ToTensor",
"torch.exp",
"torch.cuda.is_available",
"torch.device",
"torchvision.transforms.CenterCrop",
"torchvision.models.vgg16",
"torch.no_g... | [((1411, 1436), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (1434, 1436), False, 'import argparse\n'), ((1817, 1849), 'torch.load', 'torch.load', (['args.checkpoint_path'], {}), '(args.checkpoint_path)\n', (1827, 1849), False, 'import torch\n'), ((1862, 1891), 'torchvision.models.vgg16', 'mo... |
import math
import os
import pickle
import time
import numpy as np
import open3d as o3d
import pybullet
import pybullet_data
import pybullet_utils.bullet_client as bc
import sys
sys.path.insert(1, "/home/harry/umpnet")
import umpnet.sim_utils as sim_utils
import umpnet.utils as utils
class PybulletSim():
def __i... | [
"numpy.abs",
"cv2.VideoWriter_fourcc",
"numpy.arctan2",
"numpy.sum",
"open3d.geometry.PointCloud",
"numpy.argmin",
"os.path.join",
"umpnet.utils.get_pointcloud",
"numpy.tan",
"numpy.ravel_multi_index",
"umpnet.sim_utils.fetch_mobility_object",
"numpy.arccos",
"numpy.uint8",
"pybullet_utils... | [((179, 219), 'sys.path.insert', 'sys.path.insert', (['(1)', '"""/home/harry/umpnet"""'], {}), "(1, '/home/harry/umpnet')\n", (194, 219), False, 'import sys\n'), ((23089, 23137), 'spherical_sampling.fibonacci', 'spherical_sampling.fibonacci', (['(64)'], {'co_ords': '"""cart"""'}), "(64, co_ords='cart')\n", (23117, 2313... |
from py2neo import Graph, ClientError
import pandas as pd
import numpy as np
import os
from core.storage import cd
from py2neo import *
import pathlib
from main import ROOT_DIR
# ROOT_DIR = os.path.dirname(os.path.abspath(__file__)) # This is your Project Root
from core import name
def check_for_results_folder(resul... | [
"pandas.DataFrame",
"os.mkdir",
"pandas.read_csv",
"core.storage.cd",
"os.path.exists",
"pathlib.Path",
"numpy.arange",
"py2neo.Graph",
"numpy.round"
] | [((9682, 9706), 'numpy.arange', 'np.arange', (['(0.75)', '(1)', '(0.01)'], {}), '(0.75, 1, 0.01)\n', (9691, 9706), True, 'import numpy as np\n'), ((9753, 9782), 'numpy.arange', 'np.arange', (['(0.001)', '(0.01)', '(0.001)'], {}), '(0.001, 0.01, 0.001)\n', (9762, 9782), True, 'import numpy as np\n'), ((9881, 9907), 'num... |
"""
Example of using a nonuniform grid for selectively resolving portions
of the computational domain
Distribute n grid points on the interval [0,1] so that the density of nodes
is higher at a set of m locations xi[0],...,xi[m-1]
Test the grid clustering method on the boundary value problem
-(p(x)... | [
"dolfin.FacetFunction",
"matplotlib.pyplot.show",
"dolfin.TrialFunction",
"dolfin.solve",
"dolfin.TestFunction",
"dolfin.Function",
"dolfin.Expression",
"dolfin.FunctionSpace",
"matplotlib.pyplot.figure",
"dolfin.Constant",
"numpy.array",
"numpy.reshape",
"numpy.linspace",
"dolfin.Interval... | [((1171, 1191), 'numpy.linspace', 'np.linspace', (['(0)', '(1)', 'n'], {}), '(0, 1, n)\n', (1182, 1191), True, 'import numpy as np\n'), ((1243, 1263), 'numpy.linspace', 'np.linspace', (['(0)', '(1)', 'n'], {}), '(0, 1, n)\n', (1254, 1263), True, 'import numpy as np\n'), ((1848, 1876), 'dolfin.IntervalMesh', 'df.Interva... |
import numpy as np
import colorsys
from PersonTracking.util import boundingBox2FaceImage
from FaceDetection.FaceDetection import FaceDetection
class TrackedPerson:
"""
Person object
parameters
face_detection_sequence: list of FaceDetections
frame_images (list of numpy images): video frames
... | [
"PersonTracking.util.boundingBox2FaceImage",
"colorsys.rgb_to_hsv",
"numpy.zeros",
"numpy.clip",
"numpy.array"
] | [((2856, 2961), 'numpy.zeros', 'np.zeros', (['(self.n_total_frames, self.small_face_size[0], self.small_face_size[1], 3)'], {'dtype': 'np.uint8'}), '((self.n_total_frames, self.small_face_size[0], self.\n small_face_size[1], 3), dtype=np.uint8)\n', (2864, 2961), True, 'import numpy as np\n'), ((2989, 3094), 'numpy.z... |
import pandas as pd
import matplotlib.pyplot as plt
df = pd.read_csv("/content/IIITH_Codemixed_new.txt",sep="\t",names = ["Speech", "Labels"]).dropna()
df1 = pd.read_csv("/content/train_new.txt",sep = "\t",names = ["Speech", "Labels"]).dropna()
df_new = pd.concat([df,df1], ignore_index=True)
df = df_new
df["Labels"] ... | [
"keras.backend.dot",
"pandas.read_csv",
"sklearn.model_selection.train_test_split",
"matplotlib.pyplot.bar",
"keras.backend.epsilon",
"keras.models.Model",
"numpy.arange",
"keras.layers.Input",
"sklearn.preprocessing.LabelEncoder",
"keras.preprocessing.text.Tokenizer",
"re.sub",
"pandas.concat... | [((256, 295), 'pandas.concat', 'pd.concat', (['[df, df1]'], {'ignore_index': '(True)'}), '([df, df1], ignore_index=True)\n', (265, 295), True, 'import pandas as pd\n'), ((517, 546), 'matplotlib.pyplot.bar', 'plt.bar', (['labels', 'label_counts'], {}), '(labels, label_counts)\n', (524, 546), True, 'import matplotlib.pyp... |
import numpy as np
import cv2
from PIL import Image
from os import path
#[17, 15, 100], [50, 56, 200]
#[170, 0, 0], [255, 120, 60]
lower_red = np.array([70, 70, 70], dtype = "uint8")
upper_red = np.array([255, 255, 255], dtype = "uint8")
lower_white = np.array([240, 240, 240])
upper_white = np.array([255, 255, 255])
... | [
"numpy.count_nonzero",
"cv2.bitwise_and",
"cv2.cvtColor",
"cv2.imwrite",
"cv2.waitKey",
"cv2.imshow",
"numpy.hstack",
"cv2.VideoCapture",
"cv2.imread",
"numpy.array",
"cv2.destroyAllWindows",
"cv2.inRange"
] | [((144, 181), 'numpy.array', 'np.array', (['[70, 70, 70]'], {'dtype': '"""uint8"""'}), "([70, 70, 70], dtype='uint8')\n", (152, 181), True, 'import numpy as np\n'), ((196, 236), 'numpy.array', 'np.array', (['[255, 255, 255]'], {'dtype': '"""uint8"""'}), "([255, 255, 255], dtype='uint8')\n", (204, 236), True, 'import nu... |
import json
import os
import sqlite3
import pyAesCrypt
import pandas
from os import stat
from datetime import datetime
import time
import numpy
# Global variables for use by this file
bufferSize = 64*1024
password = os.environ.get('ENCRYPTIONPASSWORD')
# py -c 'import databaseAccess; databaseAccess.reset()'
def reset... | [
"pandas.DataFrame",
"os.remove",
"os.stat",
"pyAesCrypt.encryptStream",
"os.path.exists",
"os.environ.get",
"datetime.datetime.strptime",
"numpy.where",
"sqlite3.connect",
"pandas.to_datetime",
"pandas.read_sql_query",
"pyAesCrypt.decryptStream"
] | [((217, 253), 'os.environ.get', 'os.environ.get', (['"""ENCRYPTIONPASSWORD"""'], {}), "('ENCRYPTIONPASSWORD')\n", (231, 253), False, 'import os\n'), ((487, 524), 'sqlite3.connect', 'sqlite3.connect', (['"""strava_temp.sqlite"""'], {}), "('strava_temp.sqlite')\n", (502, 524), False, 'import sqlite3\n'), ((808, 845), 'sq... |
"""
Experiments on various real datasets.
"""
__author__ = 'wittawat'
import fsic.data as data
import fsic.feature as fea
import fsic.indtest as it
import fsic.glo as glo
import fsic.util as util
import fsic.kernel as kernel
import exglobal as exglo
# need independent_jobs package
# https://github.com/karlnapf/in... | [
"fsic.glo.ex_file_exists",
"fsic.indtest.GaussNFSIC",
"numpy.empty",
"fsic.util.ContextTimer",
"fsic.feature.MarginalCDFMap",
"fsic.glo.ex_save_result",
"fsic.util.NumpySeedContext",
"fsic.util.subsample_rows",
"os.path.join",
"independent_jobs.engines.SlurmComputationEngine.SlurmComputationEngine... | [((2527, 2583), 'fsic.ex.ex4_real_data.job_nfsicJ10_stoopt', 'job_nfsicJ10_stoopt', (['paired_source', 'tr', 'te', 'r', 'n_permute'], {}), '(paired_source, tr, te, r, n_permute)\n', (2546, 2583), False, 'from fsic.ex.ex4_real_data import job_nfsicJ10_stoopt\n'), ((3655, 3718), 'fsic.ex.ex4_real_data.job_nfsicJ10_med', ... |
import matplotlib.pyplot as plt
from mpl_toolkits import mplot3d
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter
import numpy as np
def plot_convergence(path, convergence):
N = convergence.shape[0]
X = np.arange(N)
Y = convergence[:,0]
plt.figure()
plt.plo... | [
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.figure",
"numpy.arange",
"matplotlib.pyplot.autoscale",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.fill_between",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.savefi... | [((254, 266), 'numpy.arange', 'np.arange', (['N'], {}), '(N)\n', (263, 266), True, 'import numpy as np\n'), ((296, 308), 'matplotlib.pyplot.figure', 'plt.figure', ([], {}), '()\n', (306, 308), True, 'import matplotlib.pyplot as plt\n'), ((313, 327), 'matplotlib.pyplot.plot', 'plt.plot', (['X', 'Y'], {}), '(X, Y)\n', (3... |
import time
from shutil import copyfile
import pandas as pd
import tracemalloc
import numpy as np
import pickle
import os
class Experiment(object):
"""Optional instrumentation for running an experiment.
Runs a simulation between an arbitrary openAI Gym environment and an algorithm, saving a dataset of (reward... | [
"pandas.DataFrame",
"tracemalloc.start",
"pickle.dump",
"numpy.random.seed",
"os.makedirs",
"numpy.log",
"tracemalloc.get_traced_memory",
"tracemalloc.stop",
"numpy.zeros",
"os.path.exists",
"time.time",
"os.path.join"
] | [((2949, 2993), 'numpy.zeros', 'np.zeros', (["[dict['nEps'] * self.num_iters, 5]"], {}), "([dict['nEps'] * self.num_iters, 5])\n", (2957, 2993), True, 'import numpy as np\n'), ((3204, 3229), 'numpy.random.seed', 'np.random.seed', (['self.seed'], {}), '(self.seed)\n', (3218, 3229), True, 'import numpy as np\n'), ((7654,... |
"""
Panasonic V-Log Log Encoding
============================
Defines the *Panasonic V-Log* log encoding:
- :func:`colour.models.log_encoding_VLog`
- :func:`colour.models.log_decoding_VLog`
References
----------
- :cite:`Panasonic2014a` : Panasonic. (2014). VARICAM V-Log/V-Gamut (pp.
1-7).
http://pro-a... | [
"colour.models.rgb.transfer_functions.legal_to_full",
"colour.utilities.from_range_1",
"colour.utilities.Structure",
"colour.utilities.to_domain_1",
"colour.models.rgb.transfer_functions.full_to_legal",
"numpy.where",
"numpy.log10"
] | [((1078, 1145), 'colour.utilities.Structure', 'Structure', ([], {'cut1': '(0.01)', 'cut2': '(0.181)', 'b': '(0.00873)', 'c': '(0.241514)', 'd': '(0.598206)'}), '(cut1=0.01, cut2=0.181, b=0.00873, c=0.241514, d=0.598206)\n', (1087, 1145), False, 'from colour.utilities import Structure, as_float, from_range_1, to_domain_... |
import os
import yaml
import argparse
import numpy as np
from utils import get_file_basename
class Statistics:
def __init__(self, data_path, params_file, out_path):
"""A class wrapper for calculating the statistics of the prepared dataset.
The following statistics are calculated:
'
... | [
"argparse.ArgumentParser",
"numpy.std",
"yaml.full_load",
"utils.get_file_basename",
"numpy.mean",
"os.path.join",
"os.listdir"
] | [((2211, 2236), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (2234, 2236), False, 'import argparse\n'), ((1409, 1449), 'os.path.join', 'os.path.join', (['self.data_path', '"""data_csv"""'], {}), "(self.data_path, 'data_csv')\n", (1421, 1449), False, 'import os\n'), ((1474, 1495), 'os.listdir'... |
import argparse
from lisa.core.data_interface import DataInterface
import numpy as np
import pandas as pd
import os
def main(args):
cistrome_metadata = pd.read_csv(args.cistrome_metadata, sep = '\t').set_index('DCid')
cistrome_metadata.index = cistrome_metadata.index.astype(str)
data = DataInterface(arg... | [
"numpy.load",
"argparse.ArgumentParser",
"os.path.basename",
"pandas.read_csv",
"lisa.core.data_interface.DataInterface"
] | [((303, 427), 'lisa.core.data_interface.DataInterface', 'DataInterface', (['args.species'], {'window_size': 'args.window_size', 'download_if_not_exists': '(False)', 'make_new': '(False)', 'load_genes': '(True)'}), '(args.species, window_size=args.window_size,\n download_if_not_exists=False, make_new=False, load_gene... |
import numpy as np
import matplotlib.pyplot as plt
x1 = np.array([78, 82, 72, 77, 74, 69, 65, 70, 62, 82])
y1 = np.array([44.44, 46.32, 90.91, 83.33, 78.95, 74.44, 94.94, 84.51, 99.12, 42.55])
x2 = np.array([87, 88, 76, 81, 75, 80, 73, 80, 67, 84])
y2 = np.array([42.74, 56.28, 87.51, 71.09, 69.15, 84.59, 74.26, 60.22... | [
"matplotlib.pyplot.title",
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.legend",
"numpy.array",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel"
] | [((57, 107), 'numpy.array', 'np.array', (['[78, 82, 72, 77, 74, 69, 65, 70, 62, 82]'], {}), '([78, 82, 72, 77, 74, 69, 65, 70, 62, 82])\n', (65, 107), True, 'import numpy as np\n'), ((113, 198), 'numpy.array', 'np.array', (['[44.44, 46.32, 90.91, 83.33, 78.95, 74.44, 94.94, 84.51, 99.12, 42.55]'], {}), '([44.44, 46.32,... |
import unittest
import torch
from pyscf import gto
from torch.autograd import Variable, grad, gradcheck
import numpy as np
from qmctorch.scf import Molecule
from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import BackFlowTransformation
from qmctorch.wavefunction.orbitals.backflow.kernels import Bac... | [
"unittest.main",
"torch.ones",
"torch.ones_like",
"numpy.random.seed",
"torch.allclose",
"torch.autograd.grad",
"torch.manual_seed",
"torch.autograd.Variable",
"torch.set_default_tensor_type",
"qmctorch.scf.Molecule",
"torch.rand",
"torch.zeros",
"qmctorch.wavefunction.orbitals.backflow.back... | [((339, 388), 'torch.set_default_tensor_type', 'torch.set_default_tensor_type', (['torch.DoubleTensor'], {}), '(torch.DoubleTensor)\n', (368, 388), False, 'import torch\n'), ((390, 412), 'torch.manual_seed', 'torch.manual_seed', (['(101)'], {}), '(101)\n', (407, 412), False, 'import torch\n'), ((413, 432), 'numpy.rando... |
from __future__ import annotations
import dataclasses
from typing import Dict, List, Any, Tuple, Optional
from enum import Enum
import io
import numpy as np
@dataclasses.dataclass
class Source:
filepath: str
name: str
num_pages: int
pages: List[Section]
images: List[List[Any]]
page_images: Lis... | [
"io.BytesIO",
"numpy.savez_compressed",
"numpy.load"
] | [((1233, 1245), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (1243, 1245), False, 'import io\n'), ((1254, 1288), 'numpy.savez_compressed', 'np.savez_compressed', (['stream'], {}), '(stream, **ims)\n', (1273, 1288), True, 'import numpy as np\n'), ((1562, 1580), 'io.BytesIO', 'io.BytesIO', (['images'], {}), '(images)\n'... |
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import os, glob
import numpy as np
from astropy.io import fits
from scipy.interpolate import interp1d
def readFits(filename):
"""
read Lamost DR5 fits
"""
hdulist = fits.open(filename)
head = hdulist[0].header
scidata = hdulist[0].data
obsid = head[... | [
"scipy.interpolate.interp1d",
"numpy.array",
"astropy.io.fits.open",
"glob.glob"
] | [((224, 243), 'astropy.io.fits.open', 'fits.open', (['filename'], {}), '(filename)\n', (233, 243), False, 'from astropy.io import fits\n'), ((526, 560), 'scipy.interpolate.interp1d', 'interp1d', (['wave', 'flux'], {'kind': '"""cubic"""'}), "(wave, flux, kind='cubic')\n", (534, 560), False, 'from scipy.interpolate impor... |
"""
Preprocess images
@author: pgb13
"""
import numpy as np
from skimage import img_as_float
def subtract_channels(image, bright=None):
"""Subtracts every channel from each other in a multichannel image
Parameters
----------
image: np.array of any dtype
bright: brightfield channel to i... | [
"skimage.img_as_float",
"numpy.copy"
] | [((698, 717), 'skimage.img_as_float', 'img_as_float', (['image'], {}), '(image)\n', (710, 717), False, 'from skimage import img_as_float\n'), ((780, 794), 'numpy.copy', 'np.copy', (['image'], {}), '(image)\n', (787, 794), True, 'import numpy as np\n'), ((1970, 1989), 'skimage.img_as_float', 'img_as_float', (['image'], ... |
# -*- coding: utf-8 -*-
"""
COVID-19 Microsimulation Model
@author: <NAME> (<EMAIL>)
"""
import numpy as np
import json
from enums import *
def dict_to_array(d):
if type(d) is dict:
return [dict_to_array(v) for v in list(d.values())]
else:
return d
def normalized(a, axis=-1, order=2):
... | [
"numpy.outer",
"numpy.sum",
"json.loads",
"numpy.asarray",
"numpy.zeros",
"numpy.ones",
"numpy.expand_dims",
"numpy.any",
"numpy.linalg.norm"
] | [((339, 369), 'numpy.linalg.norm', 'np.linalg.norm', (['a', 'order', 'axis'], {}), '(a, order, axis)\n', (353, 369), True, 'import numpy as np\n'), ((406, 430), 'numpy.expand_dims', 'np.expand_dims', (['l2', 'axis'], {}), '(l2, axis)\n', (420, 430), True, 'import numpy as np\n'), ((13431, 13477), 'numpy.zeros', 'np.zer... |
import xlwings as xw
import math
# import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
# import sympy.physics.units as u
from pint import UnitRegistry
u = UnitRegistry()
# wb = xw.Book()
@xw.sub # only required if you want to import it or run it via UDF Server
def main():
wb = xw.Book.caller()
... | [
"xlwings.ret",
"xlwings.Book.caller",
"pint.UnitRegistry",
"numpy.where",
"numpy.diff",
"numpy.arange",
"numpy.concatenate"
] | [((175, 189), 'pint.UnitRegistry', 'UnitRegistry', ([], {}), '()\n', (187, 189), False, 'from pint import UnitRegistry\n'), ((2181, 2203), 'xlwings.ret', 'xw.ret', ([], {'expand': '"""table"""'}), "(expand='table')\n", (2187, 2203), True, 'import xlwings as xw\n'), ((303, 319), 'xlwings.Book.caller', 'xw.Book.caller', ... |
from PIL import Image
import numpy as np
import pandas as pd
import image_processing
def get_statistics(input_path):
image_paths = image_processing.get_images_paths(input_path)
non_background_pixels_counts = []
pixels_counts = []
image_widths = []
image_heights = []
image_background_p... | [
"pandas.DataFrame",
"PIL.Image.open",
"numpy.array",
"image_processing.get_images_paths"
] | [((141, 186), 'image_processing.get_images_paths', 'image_processing.get_images_paths', (['input_path'], {}), '(input_path)\n', (174, 186), False, 'import image_processing\n'), ((392, 414), 'PIL.Image.open', 'Image.open', (['image_path'], {}), '(image_path)\n', (402, 414), False, 'from PIL import Image\n'), ((429, 444)... |
#!/usr/bin/env python3
"""
Clustering Module
"""
import numpy as np
def maximization(X, g):
"""
Calculates the maximization step in the EM algorithm for a GMM:
X is a numpy.ndarray of shape (n, d) containing the data set
g is a numpy.ndarray of shape (k, n) containing the posterior
probabilities ... | [
"numpy.dot",
"numpy.ones",
"numpy.zeros",
"numpy.sum"
] | [((1171, 1185), 'numpy.zeros', 'np.zeros', (['(k,)'], {}), '((k,))\n', (1179, 1185), True, 'import numpy as np\n'), ((1187, 1203), 'numpy.zeros', 'np.zeros', (['(k, d)'], {}), '((k, d))\n', (1195, 1203), True, 'import numpy as np\n'), ((1205, 1224), 'numpy.zeros', 'np.zeros', (['(k, d, d)'], {}), '((k, d, d))\n', (1213... |
#!/usr/bin/python3
# Dependencies from the Scipy stack https://www.scipy.org/stackspec.html :
import numpy as np
class Oracle:
def __init__(self, budget):
assert budget > 0
self.budget = budget
self.total_cost = 0
self.round = 0
self.a_history = []
self.b_history = [... | [
"numpy.abs",
"numpy.angle",
"numpy.random.random",
"numpy.arange",
"numpy.exp",
"numpy.random.poisson",
"numpy.sqrt"
] | [((1228, 1275), 'numpy.arange', 'np.arange', (['(0)', '(2 * np.pi)', '(2 * np.pi / num_phases)'], {}), '(0, 2 * np.pi, 2 * np.pi / num_phases)\n', (1237, 1275), True, 'import numpy as np\n'), ((478, 497), 'numpy.random.random', 'np.random.random', (['(1)'], {}), '(1)\n', (494, 497), True, 'import numpy as np\n'), ((893... |
import numpy as np
import os
import sys
sys.path.append('/home/mehdi/github/LSSutils')
import fitsio as ft
from lssutils.utils import NNWeight
from astropy.table import Table
nside = 256
#region = sys.argv[2] #'NBMZLS'
#target = sys.argv[1] #'LRG'
#mversion = sys.argv[3] #'v0.1'
#root_dir = '/home/mehdi/data/dr9v0.5... | [
"sys.path.append",
"lssutils.utils.NNWeight",
"astropy.table.Table",
"os.makedirs",
"os.path.dirname",
"os.path.exists",
"numpy.isfinite",
"fitsio.read"
] | [((40, 86), 'sys.path.append', 'sys.path.append', (['"""/home/mehdi/github/LSSutils"""'], {}), "('/home/mehdi/github/LSSutils')\n", (55, 86), False, 'import sys\n'), ((782, 807), 'os.path.dirname', 'os.path.dirname', (['out_path'], {}), '(out_path)\n', (797, 807), False, 'import os\n'), ((995, 1035), 'fitsio.read', 'ft... |
# import the necessary packages
import os
import random
import cv2 as cv
import keras.backend as K
import numpy as np
from config import img_rows, img_cols, num_classes, test_folder, original_images_key, gray_values
from model import build_model
from utils import get_best_model, preprocess_input
if __name__ == '__ma... | [
"cv2.resize",
"os.makedirs",
"utils.preprocess_input",
"random.sample",
"model.build_model",
"numpy.empty",
"numpy.argmax",
"os.path.exists",
"cv2.imread",
"numpy.reshape",
"utils.get_best_model",
"os.path.join",
"os.listdir",
"keras.backend.clear_session"
] | [((339, 352), 'model.build_model', 'build_model', ([], {}), '()\n', (350, 352), False, 'from model import build_model\n'), ((438, 484), 'os.path.join', 'os.path.join', (['test_folder', 'original_images_key'], {}), '(test_folder, original_images_key)\n', (450, 484), False, 'import os\n'), ((500, 593), 'os.path.join', 'o... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.