code stringlengths 31 1.05M | apis list | extract_api stringlengths 97 1.91M |
|---|---|---|
import numpy as np
from proseco.core import get_kwargs_from_starcheck_text
# Vanilla observation info
STD_INFO = dict(att=(0, 0, 0),
detector='ACIS-S',
sim_offset=0,
focus_offset=0,
date='2018:001',
n_guide=5,
n_fid=3,
... | [
"numpy.full",
"proseco.core.get_kwargs_from_starcheck_text"
] | [((546, 588), 'numpy.full', 'np.full', ([], {'shape': '(1024, 1024)', 'fill_value': '(40)'}), '(shape=(1024, 1024), fill_value=40)\n', (553, 588), True, 'import numpy as np\n'), ((2915, 2970), 'proseco.core.get_kwargs_from_starcheck_text', 'get_kwargs_from_starcheck_text', (['chunk'], {'include_cat': '(True)'}), '(chun... |
# -*- coding: utf-8 -*-
"""
A pure implementation of the Monte Carlo Tree Search (MCTS)
@author: <NAME>
"""
import numpy as np
import copy
from operator import itemgetter
def rollout_policy_fn(board):
"""rollout_policy_fn -- a coarse, fast version of policy_fn used in the rollout phase."""
# rollout randomly... | [
"operator.itemgetter",
"numpy.sqrt",
"copy.deepcopy"
] | [((6139, 6159), 'copy.deepcopy', 'copy.deepcopy', (['state'], {}), '(state)\n', (6152, 6159), False, 'import copy\n'), ((2966, 2997), 'numpy.sqrt', 'np.sqrt', (['self._parent._n_visits'], {}), '(self._parent._n_visits)\n', (2973, 2997), True, 'import numpy as np\n'), ((5499, 5512), 'operator.itemgetter', 'itemgetter', ... |
import click
import json
import numpy as np
import os
import tensorflow.compat.v1 as tf
import time
from luminoth.datasets import get_dataset
from luminoth.models import get_model
from luminoth.utils.bbox_overlap import bbox_overlap
from luminoth.utils.config import get_config
from luminoth.utils.image_vis import imag... | [
"tensorflow.compat.v1.gfile.GFile",
"tensorflow.compat.v1.shape",
"tensorflow.compat.v1.gfile.Exists",
"tensorflow.compat.v1.train.start_queue_runners",
"time.sleep",
"numpy.argsort",
"tensorflow.compat.v1.logging.error",
"tensorflow.compat.v1.set_random_seed",
"tensorflow.compat.v1.train.Coordinato... | [((339, 398), 'click.command', 'click.command', ([], {'help': '"""Evaluate trained (or training) models"""'}), "(help='Evaluate trained (or training) models')\n", (352, 398), False, 'import click\n'), ((400, 490), 'click.option', 'click.option', (['"""dataset_split"""', '"""--split"""'], {'default': '"""val"""', 'help'... |
import cv2
import numpy as np
import dlib
webcam = 1
cap = cv2.VideoCapture(0)
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor("shape_predictor_68_face_landmarks.dat")
def creatBox(img,points,scale =5,masked = False, cropped = True):
if masked:
mask = np.zeros_like(img)
... | [
"cv2.fillPoly",
"cv2.imread",
"numpy.zeros_like",
"dlib.shape_predictor",
"cv2.bitwise_and",
"cv2.putText",
"cv2.imshow",
"dlib.get_frontal_face_detector",
"numpy.array",
"cv2.addWeighted",
"cv2.VideoCapture",
"cv2.cvtColor",
"cv2.resize",
"cv2.waitKey",
"cv2.boundingRect"
] | [((60, 79), 'cv2.VideoCapture', 'cv2.VideoCapture', (['(0)'], {}), '(0)\n', (76, 79), False, 'import cv2\n'), ((93, 125), 'dlib.get_frontal_face_detector', 'dlib.get_frontal_face_detector', ([], {}), '()\n', (123, 125), False, 'import dlib\n'), ((138, 199), 'dlib.shape_predictor', 'dlib.shape_predictor', (['"""shape_pr... |
import numpy as np
from skimage.transform import resize
import skimage
import torchvision.utils as tvutils
import torch
import PIL
from PIL import Image
import torchvision
class UnNormalize(object):
def __init__(self, mean, std):
self.mean = torch.tensor(mean).unsqueeze(0).unsqueeze(2).unsqueeze(3)
... | [
"numpy.clip",
"PIL.Image.fromarray",
"skimage.img_as_float",
"numpy.array",
"torch.tensor",
"torch.chunk",
"torchvision.utils.make_grid",
"skimage.transform.resize",
"torch.zeros",
"torch.cat"
] | [((2026, 2051), 'torch.cat', 'torch.cat', (['stacked'], {'dim': '(1)'}), '(stacked, dim=1)\n', (2035, 2051), False, 'import torch\n'), ((3979, 4003), 'skimage.img_as_float', 'skimage.img_as_float', (['im'], {}), '(im)\n', (3999, 4003), False, 'import skimage\n'), ((5885, 5910), 'skimage.img_as_float', 'skimage.img_as_f... |
# Copyright (c) 2017-present, Facebook, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed... | [
"logging.getLogger",
"core.test.ct_detect_all",
"mitok.detect.bound3d.combine_bounds_3d_direct",
"os.path.exists",
"utils.ImageIO.windowing",
"utils.net.load_ckpt",
"numpy.where",
"utils.timer.Timer",
"numpy.max",
"utils.io.save_object",
"numpy.empty",
"cv2.merge",
"numpy.ones",
"yaml.dump... | [((1871, 1898), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1888, 1898), False, 'import logging\n'), ((6056, 6063), 'utils.timer.Timer', 'Timer', ([], {}), '()\n', (6061, 6063), False, 'from utils.timer import Timer\n'), ((6780, 6802), 'utils.env.get_runtime_dir', 'envu.get_runtime_di... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Bokeh Visualization Template
This template is a general outline for turning your data into a
visualization using Bokeh.
"""
from __future__ import (division, absolute_import, print_function,
unicode_literals)
import numpy as np
# Bokeh librari... | [
"bokeh.io.output_file",
"bokeh.plotting.show",
"bokeh.plotting.figure",
"numpy.linspace",
"numpy.cumsum"
] | [((428, 450), 'numpy.linspace', 'np.linspace', (['(1)', '(10)', '(10)'], {}), '(1, 10, 10)\n', (439, 450), True, 'import numpy as np\n'), ((535, 557), 'numpy.cumsum', 'np.cumsum', (['daily_words'], {}), '(daily_words)\n', (544, 557), True, 'import numpy as np\n'), ((611, 678), 'bokeh.io.output_file', 'output_file', (['... |
# Licensed to Elasticsearch B.V. under one or more contributor
# license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright
# ownership. Elasticsearch B.V. licenses this file to you under
# the Apache License, Version 2.0 (the "License"); you may
# not use ... | [
"numpy.issubdtype",
"numpy.dtype",
"io.StringIO"
] | [((1530, 1546), 'numpy.dtype', 'np.dtype', (['object'], {}), '(object)\n', (1538, 1546), True, 'import numpy as np\n'), ((3521, 3531), 'io.StringIO', 'StringIO', ([], {}), '()\n', (3529, 3531), False, 'from io import StringIO\n'), ((6243, 6280), 'numpy.issubdtype', 'np.issubdtype', (['right.dtype', 'np.number'], {}), '... |
# Copyright 2019 The FastEstimator 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 appl... | [
"numpy.array",
"tensorflow.cast",
"tensorflow.is_tensor",
"typing.TypeVar"
] | [((884, 938), 'typing.TypeVar', 'TypeVar', (['"""Tensor"""', 'tf.Tensor', 'torch.Tensor', 'np.ndarray'], {}), "('Tensor', tf.Tensor, torch.Tensor, np.ndarray)\n", (891, 938), False, 'from typing import Collection, TypeVar, Union\n'), ((3119, 3137), 'tensorflow.is_tensor', 'tf.is_tensor', (['data'], {}), '(data)\n', (31... |
# 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.train.model.Model",
"mindspore.context.set_context",
"mindspore.ops.operations._grad_ops.TanhGrad",
"numpy.random.randn",
"mindspore.Tensor"
] | [((871, 914), 'mindspore.context.set_context', 'context.set_context', ([], {'device_target': '"""Ascend"""'}), "(device_target='Ascend')\n", (890, 914), True, 'import mindspore.context as context\n'), ((1196, 1212), 'mindspore.Tensor', 'Tensor', (['input_np'], {}), '(input_np)\n', (1202, 1212), False, 'from mindspore i... |
# Copyright (c) 2021, NVIDIA CORPORATION. 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... | [
"sklearn.cluster._kmeans.k_means",
"torch.from_numpy",
"numpy.argsort",
"numpy.array",
"numpy.mean",
"numpy.repeat",
"sklearn.metrics.pairwise.cosine_similarity",
"numpy.where",
"numpy.sort",
"numpy.diag_indices",
"numpy.real",
"numpy.linspace",
"numpy.vstack",
"numpy.random.seed",
"nump... | [((2002, 2036), 'sklearn.preprocessing.MinMaxScaler', 'MinMaxScaler', ([], {'feature_range': '(0, 1)'}), '(feature_range=(0, 1))\n', (2014, 2036), False, 'from sklearn.preprocessing import MinMaxScaler\n'), ((3531, 3558), 'numpy.zeros_like', 'np.zeros_like', (['affinity_mat'], {}), '(affinity_mat)\n', (3544, 3558), Tru... |
# %%
from functools import reduce
import numpy as np
import pandas as pd
from pandas.tseries.offsets import DateOffset
pd.set_option("display.max_rows", None)
pd.set_option("display.max_columns", None)
# %%
def build_gvkeys(prc, fund):
gvkeys_fund = fund.gvkey.unique()
gvkeys_prc = prc[prc.close > 5].gvkey.un... | [
"numpy.intersect1d",
"pandas.read_csv",
"pandas.set_option",
"pandas.tseries.offsets.DateOffset",
"pandas.concat",
"pandas.to_datetime"
] | [((120, 159), 'pandas.set_option', 'pd.set_option', (['"""display.max_rows"""', 'None'], {}), "('display.max_rows', None)\n", (133, 159), True, 'import pandas as pd\n'), ((160, 202), 'pandas.set_option', 'pd.set_option', (['"""display.max_columns"""', 'None'], {}), "('display.max_columns', None)\n", (173, 202), True, '... |
# -*- coding: utf-8 -*-
"""
Orbital functions
-----------------
Functions used within multiple orbital classes in Stone Soup
"""
import numpy as np
from . import dotproduct
from ..types.array import StateVector
def stumpff_s(z):
r"""The Stumpff S function
.. math::
S(z) = \begin{cases}\frac{\sqrt... | [
"numpy.abs",
"numpy.sqrt",
"numpy.sinh",
"numpy.array",
"numpy.cos",
"numpy.concatenate",
"numpy.cosh",
"numpy.sin"
] | [((3063, 3086), 'numpy.sqrt', 'np.sqrt', (['grav_parameter'], {}), '(grav_parameter)\n', (3070, 3086), True, 'import numpy as np\n'), ((6021, 6044), 'numpy.sqrt', 'np.sqrt', (['grav_parameter'], {}), '(grav_parameter)\n', (6028, 6044), True, 'import numpy as np\n'), ((9816, 9836), 'numpy.cos', 'np.cos', (['true_anomaly... |
import numpy as np
class Player:
def __init__(self, strategy=0):
"""
:param strategy: defines the strategy to be played by the player as
0: always defect
1: always coorporate
2: random
3: tit for tat
4: tit for two tats
default: 0
"""
... | [
"numpy.random.rand"
] | [((2579, 2595), 'numpy.random.rand', 'np.random.rand', ([], {}), '()\n', (2593, 2595), True, 'import numpy as np\n')] |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import numpy
import sys
import subprocess
import platform
import shutil
import distutils.spawn
from setuptools import setup, Extension
from setuptools.command.sdist import sdist
from distutils.command.build_ext import build_ext
# some paranoia to start with
# ... | [
"os.path.exists",
"os.makedirs",
"distutils.command.build_ext.build_ext.run",
"os.path.join",
"setuptools.setup",
"setuptools.command.sdist.sdist.run",
"os.getcwd",
"setuptools.Extension",
"os.path.realpath",
"platform.system",
"os.chdir",
"shutil.copyfile",
"shutil.copytree",
"shutil.rmtr... | [((886, 937), 'os.path.join', 'os.path.join', (['DIR_PREFIX', '"""build"""', '"""release_notest"""'], {}), "(DIR_PREFIX, 'build', 'release_notest')\n", (898, 937), False, 'import os\n'), ((1077, 1119), 'os.path.join', 'os.path.join', (['DIR_PREFIX', '"""src"""', '"""include"""'], {}), "(DIR_PREFIX, 'src', 'include')\n"... |
# -*- encoding: utf-8 -*-
from nose.tools import *
from nose import SkipTest
import networkx as nx
from networkx.utils import *
def test_is_string_like():
assert_true(is_string_like("aaaa"))
assert_false(is_string_like(None))
assert_false(is_string_like(123))
def test_iterable():
assert_false(iterable... | [
"nose.SkipTest",
"networkx.complete_graph",
"numpy.array"
] | [((537, 558), 'networkx.complete_graph', 'nx.complete_graph', (['(10)'], {}), '(10)\n', (554, 558), True, 'import networkx as nx\n'), ((2434, 2453), 'numpy.array', 'numpy.array', (['[2, 1]'], {}), '([2, 1])\n', (2445, 2453), False, 'import numpy\n'), ((2908, 2939), 'numpy.array', 'numpy.array', (['[[20, 10], [2, 1]]'],... |
from sklearn.neighbors import KNeighborsClassifier as skl_knn
from sklearn.base import TransformerMixin, BaseEstimator
import numpy as np
from dtaidistance.dtw_ndim import distance_fast
class KNeighborsClassifier(skl_knn):
def __init__(self, n_neighbors=1, classes=None, useClasses=False, **kwargs):
self.... | [
"dtaidistance.dtw_ndim.distance_fast",
"numpy.zeros"
] | [((771, 830), 'numpy.zeros', 'np.zeros', (['(n_observations, n_observations)'], {'dtype': 'np.double'}), '((n_observations, n_observations), dtype=np.double)\n', (779, 830), True, 'import numpy as np\n'), ((1357, 1382), 'dtaidistance.dtw_ndim.distance_fast', 'distance_fast', (['arr1', 'arr2'], {}), '(arr1, arr2)\n', (1... |
# -*- coding:utf-8 -*-
import numpy as np
import GVal
def initializationProcess():
localprefix = '/home/'
serverprefix = '/home/labcompute/'
GVal.setPARA('prefix_PARA', serverprefix)
# GVal.setPARA('prefix_PARA', localprefix)
return GVal.getPARA('prefix_PARA')
def processCodeEnc... | [
"GVal.getPARA",
"GVal.setPARA",
"numpy.array",
"numpy.arange"
] | [((165, 206), 'GVal.setPARA', 'GVal.setPARA', (['"""prefix_PARA"""', 'serverprefix'], {}), "('prefix_PARA', serverprefix)\n", (177, 206), False, 'import GVal\n'), ((269, 296), 'GVal.getPARA', 'GVal.getPARA', (['"""prefix_PARA"""'], {}), "('prefix_PARA')\n", (281, 296), False, 'import GVal\n'), ((1675, 1737), 'GVal.setP... |
# ***************************************************************
# Copyright (c) 2022 Jittor. All Rights Reserved.
# Maintainers:
# <NAME> <<EMAIL>>
# <NAME> <<EMAIL>>.
#
# This file is subject to the terms and conditions defined in
# file 'LICENSE.txt', which is part of this source code package.
# *********... | [
"numpy.int32",
"numpy.stack",
"numpy.issubdtype",
"numpy.array",
"jittor.stack",
"time.time",
"numpy.float32"
] | [((859, 896), 'jittor.stack', 'jt.stack', (['[data for data in batch]', '(0)'], {}), '([data for data in batch], 0)\n', (867, 896), True, 'import jittor as jt\n'), ((974, 1011), 'numpy.stack', 'np.stack', (['[data for data in batch]', '(0)'], {}), '([data for data in batch], 0)\n', (982, 1011), True, 'import numpy as n... |
import os
import json
import numpy
import re
import torch
import torch_rl
import utils
class Vocabulary:
"""A mapping from tokens to ids with a capacity of `max_size` words.
It can be saved in a `vocab.json` file."""
def __init__(self, model_dir):
self.path = utils.get_vocab_path(model_dir)
... | [
"os.path.exists",
"utils.get_vocab_path",
"utils.create_folders_if_necessary",
"numpy.array",
"torch.tensor",
"torch_rl.DictList"
] | [((283, 314), 'utils.get_vocab_path', 'utils.get_vocab_path', (['model_dir'], {}), '(model_dir)\n', (303, 314), False, 'import utils\n'), ((378, 403), 'os.path.exists', 'os.path.exists', (['self.path'], {}), '(self.path)\n', (392, 403), False, 'import os\n'), ((771, 815), 'utils.create_folders_if_necessary', 'utils.cre... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Storage plugin for RDFlib
see license https://github.com/DerwenAI/kglab#license-and-copyright
"""
from dataclasses import dataclass
import inspect
import typing
from cryptography.hazmat.primitives import hashes # type: ignore # pylint: disable=E0401
from icecream ... | [
"icecream.ic",
"rdflib.term.Literal",
"numpy.where",
"inspect.currentframe",
"dataclasses.dataclass",
"numpy.append",
"numpy.empty"
] | [((625, 647), 'dataclasses.dataclass', 'dataclass', ([], {'frozen': '(True)'}), '(frozen=True)\n', (634, 647), False, 'from dataclasses import dataclass\n'), ((1447, 1483), 'numpy.empty', 'np.empty', ([], {'shape': '[0, 1]', 'dtype': 'object'}), '(shape=[0, 1], dtype=object)\n', (1455, 1483), True, 'import numpy as np\... |
# Enter your code here. Read input from STDIN. Print output to STDOUT
import numpy as np
from scipy import stats
i = 0
arr = []
n = int(input(''))
arr = list(map(int, input().split()))
arr.sort()
x = np.mean(arr)
y = np.median(arr)
z = stats.mode(arr)
print(round(x,1))
print(round(y,1))
print('%d' %(z[0])) | [
"scipy.stats.mode",
"numpy.mean",
"numpy.median"
] | [((200, 212), 'numpy.mean', 'np.mean', (['arr'], {}), '(arr)\n', (207, 212), True, 'import numpy as np\n'), ((217, 231), 'numpy.median', 'np.median', (['arr'], {}), '(arr)\n', (226, 231), True, 'import numpy as np\n'), ((236, 251), 'scipy.stats.mode', 'stats.mode', (['arr'], {}), '(arr)\n', (246, 251), False, 'from sci... |
# -*- coding: utf-8 -*-
"""
@author: <NAME>
"""
from itertools import product
import numpy as np
from scipy.linalg import eigh, fractional_matrix_power
from .exceptions import SolutionMatrixIsZeroCanNotComputePODError
# le2d is a LinearElasticity2dProblem, not imported due to circular import
# rb_data is ReducedOrd... | [
"scipy.linalg.eigh",
"numpy.mean",
"numpy.linalg.solve",
"numpy.sqrt",
"itertools.product",
"numpy.sum",
"numpy.zeros",
"numpy.linspace",
"numpy.argwhere",
"quadpy.c1.gauss_lobatto",
"numpy.cumsum",
"scipy.linalg.fractional_matrix_power"
] | [((1929, 1956), 'numpy.zeros', 'np.zeros', (['(le2d.n_free, ns)'], {}), '((le2d.n_free, ns))\n', (1937, 1956), True, 'import numpy as np\n'), ((2065, 2101), 'itertools.product', 'product', (['e_young_vec', 'nu_poisson_vec'], {}), '(e_young_vec, nu_poisson_vec)\n', (2072, 2101), False, 'from itertools import product\n')... |
#!/usr/bin/env python
import numpy as np
from time import time
import pyfftw
from numpy.fft import fft, ifft, fftshift, ifftshift, fft2, ifft2
from scipy.special import jv as besselj
import finufftpy
def translations_brute_force(Shathat, Mhat, cmul_trans):
# Shathat: (q, te, k)
# Mhat: (im, k × γ)
# ... | [
"numpy.sin",
"numpy.arange",
"numpy.multiply",
"numpy.repeat",
"numpy.fft.fft",
"finufftpy.nufft2d1",
"pyfftw.FFTW",
"finufftpy.nufft2d1many",
"numpy.exp",
"numpy.real",
"numpy.stack",
"numpy.empty",
"numpy.unravel_index",
"numpy.concatenate",
"numpy.matmul",
"numpy.meshgrid",
"numpy... | [((1078, 1156), 'pyfftw.empty_aligned', 'pyfftw.empty_aligned', (['(n_gamma, ngridr, n_images, n_trans)'], {'dtype': '"""complex128"""'}), "((n_gamma, ngridr, n_images, n_trans), dtype='complex128')\n", (1098, 1156), False, 'import pyfftw\n'), ((1211, 1325), 'pyfftw.FFTW', 'pyfftw.FFTW', (['Mhat_trans', 'Mhat_trans'], ... |
import numpy as np
import pytest
from ctrm.environment import Instance, ObstacleSphere
from ctrm.roadmap import (
get_timed_roadmaps_fully_random,
get_timed_roadmaps_random,
get_timed_roadmaps_random_common,
)
@pytest.fixture
def ins():
return Instance(
2,
[np.array([0, 0]), np.array(... | [
"numpy.array",
"ctrm.roadmap.get_timed_roadmaps_random",
"ctrm.roadmap.get_timed_roadmaps_random_common",
"ctrm.roadmap.get_timed_roadmaps_fully_random"
] | [((293, 309), 'numpy.array', 'np.array', (['[0, 0]'], {}), '([0, 0])\n', (301, 309), True, 'import numpy as np\n'), ((311, 327), 'numpy.array', 'np.array', (['[1, 0]'], {}), '([1, 0])\n', (319, 327), True, 'import numpy as np\n'), ((339, 355), 'numpy.array', 'np.array', (['[1, 1]'], {}), '([1, 1])\n', (347, 355), True,... |
"""Tool for handling rigs"""
import logging
import re
from collections import defaultdict
from itertools import combinations
import networkx as nx
import numpy as np
from opensfm import actions, pygeometry, pymap
from opensfm.dataset import DataSet, DataSetBase
logger = logging.getLogger(__name__)
def find_image_... | [
"logging.getLogger",
"opensfm.pygeometry.Pose",
"opensfm.pymap.RigModel",
"opensfm.actions.reconstruct.run_dataset",
"networkx.Graph",
"networkx.connected_components",
"itertools.combinations",
"numpy.exp",
"numpy.zeros",
"collections.defaultdict",
"opensfm.actions.detect_features.run_dataset",
... | [((275, 302), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (292, 302), False, 'import logging\n'), ((1227, 1244), 'collections.defaultdict', 'defaultdict', (['dict'], {}), '(dict)\n', (1238, 1244), False, 'from collections import defaultdict\n'), ((1622, 1639), 'collections.defaultdict'... |
# coding: utf-8
from __future__ import division
import numpy as np
import pdb
import math
from . import data_generators
import copy
import cv2
import random
import keras
class_num =200
part_map_num = {'head':0,'legs':1,'wings':2,'back':3,'belly':4,'breast':5,'tail':6}
part_map_name = {}
crop_image = lambda img, x0, y0... | [
"keras.utils.to_categorical",
"numpy.array",
"numpy.sin",
"cv2.LUT",
"numpy.round",
"cv2.warpAffine",
"random.shuffle",
"numpy.cos",
"cv2.cvtColor",
"cv2.getRotationMatrix2D",
"cv2.resize",
"numpy.transpose",
"cv2.imread",
"numpy.copy",
"numpy.tan",
"cv2.flip",
"numpy.power",
"nump... | [((14927, 14950), 'numpy.zeros', 'np.zeros', (['(class_num + 1)'], {}), '(class_num + 1)\n', (14935, 14950), True, 'import numpy as np\n'), ((2967, 3054), 'numpy.zeros', 'np.zeros', (['[batech_size, self.input_img_size_heigth, self.input_img_size_witdth, 3]'], {}), '([batech_size, self.input_img_size_heigth, self.\n ... |
# Copyright (c) Facebook, Inc. and its affiliates.
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import argparse
import pathlib
import random
import numpy as np
import torch
import uuid
import activemri.envs.loupe_envs as loupe_envs
from ac... | [
"torch.manual_seed",
"activemri.baselines.non_rl.NonRLTester",
"argparse.ArgumentParser",
"matplotlib.use",
"activemri.envs.loupe_envs.LoupeBrainEnv",
"random.seed",
"uuid.uuid4",
"numpy.random.seed",
"activemri.envs.loupe_envs.LOUPERealKspaceEnv",
"torch.device"
] | [((396, 417), 'matplotlib.use', 'matplotlib.use', (['"""Agg"""'], {}), "('Agg')\n", (410, 417), False, 'import matplotlib\n'), ((460, 525), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""MRI Reconstruction Example"""'}), "(description='MRI Reconstruction Example')\n", (483, 525), False, ... |
from __future__ import print_function
# Copyright (c) 2013, <NAME>
# All rights reserved.
"""
Example timeseries reduction
"""
from collections import OrderedDict
import os
import glob
import time
import numpy as np
from pyvttbl import DataFrame
from undaqTools import Daq
# dependent variables and indices that... | [
"numpy.mean",
"collections.OrderedDict",
"numpy.abs",
"numpy.std",
"numpy.linalg.norm",
"pyvttbl.DataFrame",
"numpy.max",
"os.chdir",
"numpy.min",
"undaqTools.Daq",
"time.time",
"glob.glob"
] | [((775, 793), 'os.chdir', 'os.chdir', (['data_dir'], {}), '(data_dir)\n', (783, 793), False, 'import os\n'), ((878, 889), 'pyvttbl.DataFrame', 'DataFrame', ([], {}), '()\n', (887, 889), False, 'from pyvttbl import DataFrame\n'), ((956, 967), 'time.time', 'time.time', ([], {}), '()\n', (965, 967), False, 'import time\n'... |
import numpy as np
from skimage.measure import label
import skimage.measure._ccomp as ccomp
from skimage._shared import testing
from skimage._shared.testing import assert_array_equal
BG = 0 # background value
class TestConnectedComponents:
def setup(self):
self.x = np.array([
[0, 0, 3, 2, ... | [
"numpy.ones_like",
"skimage._shared.testing.assert_array_equal",
"skimage.measure._ccomp.undo_reshape_array",
"numpy.ones",
"numpy.random.rand",
"numpy.random.random",
"numpy.array",
"numpy.zeros",
"skimage.measure._ccomp.reshape_array",
"skimage._shared.testing.raises",
"numpy.all",
"skimage.... | [((284, 378), 'numpy.array', 'np.array', (['[[0, 0, 3, 2, 1, 9], [0, 1, 1, 9, 2, 9], [0, 0, 1, 9, 9, 9], [3, 1, 1, 5, 3, 0]\n ]'], {}), '([[0, 0, 3, 2, 1, 9], [0, 1, 1, 9, 2, 9], [0, 0, 1, 9, 9, 9], [3, 1,\n 1, 5, 3, 0]])\n', (292, 378), True, 'import numpy as np\n'), ((447, 541), 'numpy.array', 'np.array', (['[[... |
import torch
import torch.nn as nn
from torch.optim import lr_scheduler
from torch import optim
import torch.nn.functional as F
import random
import numpy as np
# import matplotlib.pyplot as plt
# import seaborn as sns
import os
import json
from utils.measures import wer, moses_multi_bleu
from utils.masked_cross_entro... | [
"os.path.exists",
"torch.optim.lr_scheduler.ReduceLROnPlateau",
"numpy.ones",
"torch.nn.Softmax",
"os.makedirs",
"torch.Tensor",
"numpy.array",
"torch.nn.BCELoss",
"torch.save",
"json.load",
"random.random",
"numpy.transpose"
] | [((926, 943), 'torch.nn.Softmax', 'nn.Softmax', ([], {'dim': '(0)'}), '(dim=0)\n', (936, 943), True, 'import torch.nn as nn\n'), ((2954, 3078), 'torch.optim.lr_scheduler.ReduceLROnPlateau', 'lr_scheduler.ReduceLROnPlateau', (['self.decoder_optimizer'], {'mode': '"""max"""', 'factor': '(0.5)', 'patience': '(1)', 'min_lr... |
# Copyright 2020 The ElasticDL 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 applicable law... | [
"elasticdl.proto.elasticdl_pb2.Model",
"elasticdl.python.ps.embedding_table.get_slot_table_name",
"numpy.random.rand",
"elasticdl.proto.elasticdl_pb2.PullEmbeddingVectorRequest",
"elasticdl.python.ps.parameters.Parameters",
"numpy.array",
"elasticdl.python.common.save_utils.CheckpointSaver",
"elasticd... | [((1566, 1636), 'elasticdl.python.common.model_utils.get_module_file_path', 'get_module_file_path', (['_test_model_zoo_path', '"""test_module.custom_model"""'], {}), "(_test_model_zoo_path, 'test_module.custom_model')\n", (1586, 1636), False, 'from elasticdl.python.common.model_utils import get_module_file_path, load_m... |
import matplotlib.pyplot as plt
import numpy as np
import sys
from os import walk
import matplotlib.colors as mcolors
'''
Return: table of lists of intervals {[%f,%f]}
'''
def read_log_file(filename):
result = {}
f = open(filename, 'r')
lines = f.readlines()
for line in lines:
line = line.repla... | [
"matplotlib.pyplot.xticks",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"os.walk",
"numpy.max",
"matplotlib.pyplot.close",
"numpy.sum",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.bar",
"numpy.std",
"matplotlib.pyplot.title... | [((4717, 4760), 'numpy.sum', 'np.sum', (['[(gap[1] - gap[0]) for gap in gaps]'], {}), '([(gap[1] - gap[0]) for gap in gaps])\n', (4723, 4760), True, 'import numpy as np\n'), ((4803, 4846), 'numpy.std', 'np.std', (['[(gap[1] - gap[0]) for gap in gaps]'], {}), '([(gap[1] - gap[0]) for gap in gaps])\n', (4809, 4846), True... |
#!/usr/bin/env python3
import argparse
import os
import re
import glog as log
import numpy as np
import pandas as pd
import ray
from factorized_sampler_lib import data_utils
from factorized_sampler_lib import rustlib
import join_utils
NULL = -1
@ray.remote
def get_first_jct(join_name, table, base_count_table):
... | [
"os.path.exists",
"ray.get",
"pandas.Int64Dtype",
"join_utils.get_bottom_up_table_ordering",
"numpy.nanprod",
"os.path.join",
"numpy.isin",
"glog.info",
"factorized_sampler_lib.rustlib.prepare_indices",
"factorized_sampler_lib.data_utils.save_result",
"ray.init"
] | [((324, 411), 'factorized_sampler_lib.data_utils.save_result', 'data_utils.save_result', (['f"""{table}.jct"""', 'join_name', 'f"""join count table of `{table}`"""'], {}), "(f'{table}.jct', join_name,\n f'join count table of `{table}`')\n", (346, 411), False, 'from factorized_sampler_lib import data_utils\n'), ((789... |
import numpy as np
from matplotlib import pyplot as plt
import pickle
file = open('Data/Alpha0Bw7', 'rb')
Data = np.array(pickle.load(file))
Alpha0 = [0.01, 0.02, 0.05, 0.1, 0.2, 0.4, 0.6, 0.9]
Bw = np.linspace(0.4, 3.2, 15)
Names = ['alpha0', 'bw',
'IS est', 'IS a-var', 'n0/ESS', 'n0/RSS', 'kernel number',
... | [
"numpy.ones",
"numpy.log",
"pickle.load",
"numpy.linspace",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.show"
] | [((201, 226), 'numpy.linspace', 'np.linspace', (['(0.4)', '(3.2)', '(15)'], {}), '(0.4, 3.2, 15)\n', (212, 226), True, 'import numpy as np\n'), ((124, 141), 'pickle.load', 'pickle.load', (['file'], {}), '(file)\n', (135, 141), False, 'import pickle\n'), ((1121, 1157), 'matplotlib.pyplot.subplots', 'plt.subplots', (['(3... |
# Copyright 2016 The TensorFlow 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 applica... | [
"itertools.chain",
"numpy.prod",
"numpy.sqrt",
"tensorflow.python.ops.variables.global_variables_initializer",
"tensorflow.python.framework.random_seed.set_random_seed",
"tensorflow.python.ops.gradient_checker_v2.compute_gradient",
"six.moves.xrange",
"tensorflow.python.ops.variables.Variable",
"ten... | [((9072, 9145), 'tensorflow.python.framework.test_util.run_v1_only', 'test_util.run_v1_only', (['"""b/126596827 needs graph mode in multiple threads"""'], {}), "('b/126596827 needs graph mode in multiple threads')\n", (9093, 9145), False, 'from tensorflow.python.framework import test_util\n'), ((9779, 9790), 'tensorflo... |
# -*- coding: utf-8 -*-
"""
Created on Sat Jul 6 15:00:21 2019
@author: agarwal.270a
"""
# Import Libraries
import numpy as np
import matplotlib.pyplot as plt
from scipy import signal as sig
from scipy.signal import windows as win
import pandas as pd
from scipy import io
import pickle
from scipy.stats i... | [
"numpy.random.standard_normal",
"scipy.signal.detrend",
"matplotlib.pyplot.grid",
"scipy.io.savemat",
"numpy.nanpercentile",
"numpy.random.rand",
"scipy.signal.filtfilt",
"scipy.io.loadmat",
"numpy.array",
"numpy.linalg.norm",
"numpy.sin",
"numpy.arange",
"numpy.mean",
"matplotlib.pyplot.p... | [((776, 805), 'numpy.arange', 'np.arange', (['(250)', '(900)', 'len_in_s'], {}), '(250, 900, len_in_s)\n', (785, 805), True, 'import numpy as np\n'), ((1279, 1298), 'numpy.sum', 'np.sum', (['arr'], {'axis': '(0)'}), '(arr, axis=0)\n', (1285, 1298), True, 'import numpy as np\n'), ((1350, 1369), 'numpy.sum', 'np.sum', ([... |
import numpy as np
import pytest
from sklego.neighbors import BayesianKernelDensityClassifier
from sklego.common import flatten
from sklego.testing import check_shape_remains_same_classifier
from tests.conftest import nonmeta_checks, general_checks, estimator_checks
@pytest.fixture()
def simple_dataset():
# Two... | [
"numpy.random.normal",
"numpy.ones",
"sklego.common.flatten",
"numpy.zeros",
"pytest.fixture",
"sklego.neighbors.BayesianKernelDensityClassifier"
] | [((272, 288), 'pytest.fixture', 'pytest.fixture', ([], {}), '()\n', (286, 288), False, 'import pytest\n'), ((610, 1028), 'sklego.common.flatten', 'flatten', (['[nonmeta_checks, general_checks, estimator_checks.\n check_classifier_data_not_an_array, estimator_checks.\n check_classifiers_one_label, estimator_checks... |
from itertools import cycle
from toolz.itertoolz import concatv, take
import numpy as np
import pytest
from tensorforce.environments import Environment
from bad_seeds.simple.bad_seeds_01 import BadSeeds01, count_measurements
def test_initialization():
bad_seeds_01_env = Environment.create(
environment=B... | [
"bad_seeds.simple.bad_seeds_01.count_measurements",
"tensorforce.environments.Environment.create",
"itertools.cycle",
"numpy.array",
"pytest.raises",
"bad_seeds.simple.bad_seeds_01.BadSeeds01"
] | [((279, 382), 'tensorforce.environments.Environment.create', 'Environment.create', ([], {'environment': 'BadSeeds01', 'seed_count': '(10)', 'bad_seed_count': '(3)', 'max_episode_length': '(100)'}), '(environment=BadSeeds01, seed_count=10, bad_seed_count=3,\n max_episode_length=100)\n', (297, 382), False, 'from tenso... |
from pathlib import Path
import numpy as np
import torch
import subprocess
import argparse
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("source_file", help="Absolute path to the Pytorch weights file to convert")
args = parser.parse_args()
source_file = Path(args.so... | [
"numpy.savez",
"subprocess.run",
"argparse.ArgumentParser",
"pathlib.Path"
] | [((132, 157), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (155, 157), False, 'import argparse\n'), ((308, 330), 'pathlib.Path', 'Path', (['args.source_file'], {}), '(args.source_file)\n', (312, 330), False, 'from pathlib import Path\n'), ((606, 650), 'numpy.savez', 'np.savez', (["(target_fol... |
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not u... | [
"tvm.autotvm.ConfigEntity",
"tvm.target.override_native_generic_func",
"tvm.relay.tile",
"tvm.relay.backend.te_compiler.get",
"tvm.relay.Tuple",
"tvm.autotvm.apply_history_best",
"tvm.relay.subtract",
"tvm.autotvm.MeasureInput",
"tvm.relay.analysis.free_vars",
"tvm.testing.device_enabled",
"tvm.... | [((1064, 1110), 'tvm.autotvm.register_topi_compute', 'autotvm.register_topi_compute', (['"""test/conv2d_1"""'], {}), "('test/conv2d_1')\n", (1093, 1110), False, 'from tvm import autotvm\n'), ((1281, 1328), 'tvm.autotvm.register_topi_schedule', 'autotvm.register_topi_schedule', (['"""test/conv2d_1"""'], {}), "('test/con... |
from __future__ import print_function
import os
import cv2
import string
import random
import numpy as np
class dataLoader(object):
def __init__(self, directory, dataset_dir, dataset_name, max_steps,
image_width, image_height, image_patch_width, image_patch_height,
grd_attn=False,... | [
"numpy.ceil",
"random.shuffle",
"numpy.random.rand",
"os.path.join",
"numpy.floor",
"numpy.array",
"numpy.zeros",
"cv2.resize",
"cv2.imread"
] | [((874, 921), 'os.path.join', 'os.path.join', (['self.directory', 'self.dataset_name'], {}), '(self.directory, self.dataset_name)\n', (886, 921), False, 'import os\n'), ((2289, 2305), 'numpy.random.rand', 'np.random.rand', ([], {}), '()\n', (2303, 2305), True, 'import numpy as np\n'), ((2561, 2584), 'random.shuffle', '... |
import cv2
import numpy as np
import random
#########################################################
# FUNCTION TO FIND THE CONNECTED COMPONENTS
#########################################################
def drawComponents(image, adj, block_size):
#ret, labels = cv2.connectedComponents(image)
#pri... | [
"numpy.ones_like",
"cv2.merge",
"cv2.threshold",
"cv2.imshow",
"numpy.max",
"numpy.zeros",
"cv2.waitKey",
"cv2.destroyAllWindows",
"cv2.connectedComponents",
"cv2.cvtColor",
"cv2.imread",
"random.randint"
] | [((3501, 3533), 'cv2.imread', 'cv2.imread', (['"""../../Images/2.jpg"""'], {}), "('../../Images/2.jpg')\n", (3511, 3533), False, 'import cv2\n'), ((3535, 3567), 'cv2.imshow', 'cv2.imshow', (['"""Original"""', 'img_orig'], {}), "('Original', img_orig)\n", (3545, 3567), False, 'import cv2\n'), ((3657, 3699), 'cv2.cvtColo... |
"""
# Authors:
* <NAME> 2021
* <NAME> 2020
* <NAME> 2020
* <NAME> 2020
* <NAME> 2020
* <NAME> 2020
"""
import torch
import numpy as np
smallVal = np.finfo("float").eps # To avoid divide by zero
def si_snr_loss(y_pred_batch, y_true_batch, lens, reduction="mean"):
"""Compute the si_snr sco... | [
"torch.log10",
"torch.sum",
"torch.squeeze",
"numpy.finfo",
"torch.zeros"
] | [((167, 184), 'numpy.finfo', 'np.finfo', (['"""float"""'], {}), "('float')\n", (175, 184), True, 'import numpy as np\n'), ((858, 893), 'torch.squeeze', 'torch.squeeze', (['y_pred_batch'], {'dim': '(-1)'}), '(y_pred_batch, dim=-1)\n', (871, 893), False, 'import torch\n'), ((914, 949), 'torch.squeeze', 'torch.squeeze', (... |
#!/usr/bin/env python3
# Author: <NAME>
# Date: 2021/1/29
# Functions to generate csv summaries of data statistics and merge result statistics
import os
import argparse
import re
from typing import Tuple
import pandas as pd
import numpy as np
import consts as C
from processing.marsdataloader import MARSDataLoader
... | [
"os.listdir",
"argparse.ArgumentParser",
"pandas.read_csv",
"re.compile",
"os.path.join",
"numpy.sum",
"pandas.DataFrame"
] | [((523, 608), 'pandas.read_csv', 'pd.read_csv', (['C.ALL_RES_CSV_PATH'], {'dtype': '{exp_ID_name: int}', 'index_col': 'exp_ID_name'}), '(C.ALL_RES_CSV_PATH, dtype={exp_ID_name: int}, index_col=exp_ID_name\n )\n', (534, 608), True, 'import pandas as pd\n'), ((620, 694), 'pandas.read_csv', 'pd.read_csv', (['C.EXP_ID_L... |
"""7 compounds containing only carbon and hydrogen,
and having only two topological symmetry classes each
ethane
benzene
cyclopentane
ethylene
methane
cyclopropane
cyclohexane
"""
import numpy as np
from openeye.oechem import OEPerceiveSymmetry
from simtk import unit
from bayes_implicit_solvent.freesolv import cid_t... | [
"openeye.oechem.OEPerceiveSymmetry",
"pkg_resources.resource_filename",
"bayes_implicit_solvent.molecule.Molecule",
"numpy.load",
"glob.glob"
] | [((679, 765), 'pkg_resources.resource_filename', 'resource_filename', (['"""bayes_implicit_solvent"""', '"""vacuum_samples/vacuum_samples_*.npy"""'], {}), "('bayes_implicit_solvent',\n 'vacuum_samples/vacuum_samples_*.npy')\n", (696, 765), False, 'from pkg_resources import resource_filename\n'), ((824, 852), 'glob.g... |
from typing import List, Tuple, Union
import numpy as np
import torch
from allrank.click_models.base import ClickModel
from allrank.data.dataset_loading import PADDED_Y_VALUE
def click_on_slates(slates: Union[Tuple[np.ndarray, np.ndarray], Tuple[torch.Tensor, torch.Tensor]],
click_model: ClickMo... | [
"numpy.sum",
"numpy.zeros_like"
] | [((2179, 2195), 'numpy.zeros_like', 'np.zeros_like', (['y'], {}), '(y)\n', (2192, 2195), True, 'import numpy as np\n'), ((1200, 1224), 'numpy.sum', 'np.sum', (['(slate_clicks > 0)'], {}), '(slate_clicks > 0)\n', (1206, 1224), True, 'import numpy as np\n')] |
"""
nc2pd
~~~~~
A thin python-netCDF4 wrapper to turn netCDF files into pandas data
structures, with a focus on extracting time series from regularly
spatial gridded data (with the ability to interpolate spatially).
Copyright 2015 <NAME>
License: MIT (see LICENSE file)
"""
from __future__ import print_function
fro... | [
"pandas.Series",
"numpy.ones_like",
"numpy.abs",
"netCDF4.num2date",
"numpy.searchsorted",
"netCDF4.Dataset",
"numpy.argmax",
"pandas.Panel",
"pandas.datetools.parse_time_string",
"itertools.chain.from_iterable",
"pandas.DataFrame",
"pandas.concat",
"pandas.date_range"
] | [((17595, 17621), 'pandas.concat', 'pd.concat', (['results'], {'axis': '(1)'}), '(results, axis=1)\n', (17604, 17621), True, 'import pandas as pd\n'), ((637, 675), 'pandas.datetools.parse_time_string', 'pd.datetools.parse_time_string', (['string'], {}), '(string)\n', (667, 675), True, 'import pandas as pd\n'), ((858, 8... |
#===============================================================================
# Copyright 2020-2021 Intel Corporation
#
# 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.apa... | [
"os.environ.keys",
"bench.load_data",
"xgboost.DMatrix",
"daal4py.gbt_regression_prediction",
"argparse.ArgumentParser",
"xgboost.train",
"numpy.unique",
"bench.parse_args",
"daal4py.gbt_classification_prediction",
"bench.measure_function_time",
"os.path.abspath",
"utils.print_output"
] | [((978, 1076), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""xgboost gbt + model transform + daal predict benchmark"""'}), "(description=\n 'xgboost gbt + model transform + daal predict benchmark')\n", (1001, 1076), False, 'import argparse\n'), ((3999, 4023), 'bench.parse_args', 'ben... |
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
import numpy as np
print("GPU is", "available" if torch.cuda.is_available() else "NOT AVAILABLE")
print(torch.__version__)
# import images dataset
import os
from PIL import Image
#import c... | [
"random.sample",
"torchvision.models.vgg16",
"PIL.Image.open",
"random.shuffle",
"torch.gt",
"numpy.asarray",
"random.seed",
"json.load",
"torch.tensor",
"numpy.array",
"torch.cuda.is_available",
"importlib.reload",
"torch.utils.data.DataLoader",
"torch.nn.BCEWithLogitsLoss",
"torch.save... | [((1571, 1594), 'random.shuffle', 'random.shuffle', (['dataset'], {}), '(dataset)\n', (1585, 1594), False, 'import random\n'), ((1640, 1731), 'torch.utils.data.DataLoader', 'torch.utils.data.DataLoader', (['dataset[:train_size]'], {'shuffle': '(True)', 'batch_size': 'BATCH_SIZE'}), '(dataset[:train_size], shuffle=True,... |
#
# This file is part of CasADi.
#
# CasADi -- A symbolic framework for dynamic optimization.
# Copyright (C) 2010-2014 <NAME>, <NAME>, <NAME>,
# <NAME>. All rights reserved.
# Copyright (C) 2011-2014 <NAME>
#
# CasADi is free software; you can redistribute it and/or
# ... | [
"unittest.main",
"numpy.linspace"
] | [((3590, 3605), 'unittest.main', 'unittest.main', ([], {}), '()\n', (3603, 3605), False, 'import unittest\n'), ((2125, 2154), 'numpy.linspace', 'n.linspace', (['(0)', "num['tend']", 'N'], {}), "(0, num['tend'], N)\n", (2135, 2154), True, 'import numpy as n\n'), ((2974, 3007), 'numpy.linspace', 'n.linspace', (['(0.7)', ... |
"""
implement bayesian analysis of two diff pops, X1 and X2, called here x and y
"""
from math import sqrt, exp, log
import numpy as np
import matplotlib.pyplot as plt
from SciInf_utilities import *
import sys
#--------------------------------------
print("\n implement bayesian analysis of two diff population means")
... | [
"matplotlib.pyplot.boxplot",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.title",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"math.sqrt",
"math.log",
"numpy.exp",
"numpy.zeros",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.yticks",
"matplotlib.pyplot.... | [((894, 905), 'math.sqrt', 'sqrt', (['var_x'], {}), '(var_x)\n', (898, 905), False, 'from math import sqrt, exp, log\n'), ((913, 924), 'math.sqrt', 'sqrt', (['var_y'], {}), '(var_y)\n', (917, 924), False, 'from math import sqrt, exp, log\n'), ((980, 1005), 'math.sqrt', 'sqrt', (['(var_x / (n_x - 1.0))'], {}), '(var_x /... |
"""Sample script of word embedding model.
This code implements skip-gram model and continuous-bow model.
Use ../ptb/download.py to download 'ptb.train.txt'.
"""
import argparse
import collections
import numpy as np
import six
import chainer
from chainer import cuda
import chainer.functions as F
import chainer.initial... | [
"chainer.training.extensions.PrintReport",
"chainer.datasets.get_ptb_words",
"chainer.training.StandardUpdater",
"numpy.array",
"numpy.arange",
"argparse.ArgumentParser",
"chainer.training.Trainer",
"chainer.training.extensions.Evaluator",
"chainer.cuda.to_cpu",
"chainer.links.Linear",
"chainer.... | [((497, 522), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (520, 522), False, 'import argparse\n'), ((5708, 5740), 'chainer.datasets.get_ptb_words', 'chainer.datasets.get_ptb_words', ([], {}), '()\n', (5738, 5740), False, 'import chainer\n'), ((5750, 5776), 'collections.Counter', 'collections... |
import jittor as jt
import numpy as np
from advance import *
import matplotlib.pyplot as plt
import argparse
import matplotlib.pyplot as plt
from tqdm import trange
from utils import get_model, modelSet, dataset_choices
import argparse
plt.switch_backend('agg')
# CUDA_VISIBLE_DEVICES=0 log_silent=1 python3.7 run_ssl... | [
"utils.get_model",
"matplotlib.pyplot.savefig",
"argparse.ArgumentParser",
"matplotlib.pyplot.plot",
"numpy.savetxt",
"matplotlib.pyplot.switch_backend"
] | [((238, 263), 'matplotlib.pyplot.switch_backend', 'plt.switch_backend', (['"""agg"""'], {}), "('agg')\n", (256, 263), True, 'import matplotlib.pyplot as plt\n'), ((509, 534), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (532, 534), False, 'import argparse\n'), ((1618, 1633), 'utils.get_model'... |
import numpy as np
import sys
# # temp solution for directory.
sys.path.append("./src/")
import math
from undefined.UDFunction import UDFunction
from undefined.GraphGenerator import UDGraph
from undefined.Utils import UDPrimitive, check_division_by_zero, check_log, check_pow, check_arc
def cos(udobject):
"""calc... | [
"numpy.arccos",
"numpy.sqrt",
"math.acos",
"undefined.Utils.check_pow",
"math.sqrt",
"numpy.log",
"math.log",
"math.cos",
"numpy.sin",
"math.exp",
"sys.path.append",
"math.atan",
"undefined.UDFunction.UDFunction",
"math.tan",
"numpy.exp",
"numpy.arctan",
"undefined.Utils.check_arc",
... | [((63, 88), 'sys.path.append', 'sys.path.append', (['"""./src/"""'], {}), "('./src/')\n", (78, 88), False, 'import sys\n'), ((1320, 1348), 'undefined.UDFunction.UDFunction', 'UDFunction', (['new_val', 'new_der'], {}), '(new_val, new_der)\n', (1330, 1348), False, 'from undefined.UDFunction import UDFunction\n'), ((3091,... |
#! /bin/env python
import os
import sys
import numpy as np
from ...grids import RasterField
class BovError(Exception):
pass
class MissingRequiredKeyError(BovError):
def __init__(self, opt):
self.opt = opt
def __str__(self):
return "%s: Missing required key" % self.opt
class BadKeyVa... | [
"numpy.prod",
"numpy.fromfile",
"os.path.isabs",
"os.path.splitext",
"os.path.isfile",
"numpy.array",
"os.path.dirname"
] | [((4109, 4135), 'os.path.splitext', 'os.path.splitext', (['filename'], {}), '(filename)\n', (4125, 4135), False, 'import os\n'), ((4226, 4261), 'numpy.array', 'np.array', (['spacing'], {'dtype': 'np.float64'}), '(spacing, dtype=np.float64)\n', (4234, 4261), True, 'import numpy as np\n'), ((4275, 4309), 'numpy.array', '... |
from csv import DictReader
from functools import lru_cache
from itertools import groupby
from pathlib import Path
from typing import TextIO
import click
import h5py
from skelshop.corpus import index_corpus_desc
from skelshop.face.consts import DEFAULT_METRIC
from skelshop.iden.idsegs import ref_arg
from skelshop.util... | [
"skelshop.utils.click.PathPath",
"csv.DictReader",
"itertools.groupby",
"skelshop.face.io.SparseFaceReader",
"click.File",
"h5py.File",
"skelshop.corpus.index_corpus_desc",
"numpy.vstack",
"functools.lru_cache",
"click.command"
] | [((369, 391), 'functools.lru_cache', 'lru_cache', ([], {'maxsize': '(128)'}), '(maxsize=128)\n', (378, 391), False, 'from functools import lru_cache\n'), ((587, 602), 'click.command', 'click.command', ([], {}), '()\n', (600, 602), False, 'import click\n'), ((496, 516), 'h5py.File', 'h5py.File', (['face_path'], {}), '(f... |
from helper.shapenet.shapenetMapper import desc_to_id
from deformations.FFD import get_template_ffd
from deformations.meshDeformation import get_thresholded_template_mesh
from mayavi import mlab
import numpy as np
from graphicUtils.visualizer.mayaviVisualizer import visualize_mesh, visualize_point_cloud
ds = get_tem... | [
"numpy.array",
"numpy.matmul",
"helper.shapenet.shapenetMapper.desc_to_id",
"mayavi.mlab.show"
] | [((991, 1002), 'mayavi.mlab.show', 'mlab.show', ([], {}), '()\n', (1000, 1002), False, 'from mayavi import mlab\n'), ((1043, 1054), 'mayavi.mlab.show', 'mlab.show', ([], {}), '()\n', (1052, 1054), False, 'from mayavi import mlab\n'), ((404, 424), 'helper.shapenet.shapenetMapper.desc_to_id', 'desc_to_id', (['"""pistol""... |
import cv2
import selectivesearch
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import numpy as np
#step1
image2="images/test2.png"
#用cv2读取图片
img = cv2.imread(image2,cv2.IMREAD_UNCHANGED)
#白底黑字图 改为黑底白字图
img=255-img
img_lbl, regions =selectivesearch.selective_search(img, scale=500, sigma=0.9, ... | [
"matplotlib.pyplot.savefig",
"cv2.copyMakeBorder",
"numpy.zeros",
"cv2.cvtColor",
"selectivesearch.selective_search",
"cv2.resize",
"cv2.imread",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.show"
] | [((175, 215), 'cv2.imread', 'cv2.imread', (['image2', 'cv2.IMREAD_UNCHANGED'], {}), '(image2, cv2.IMREAD_UNCHANGED)\n', (185, 215), False, 'import cv2\n'), ((260, 332), 'selectivesearch.selective_search', 'selectivesearch.selective_search', (['img'], {'scale': '(500)', 'sigma': '(0.9)', 'min_size': '(20)'}), '(img, sca... |
import argparse
import logging
from os import path
import signal
import subprocess
import sys
import time
import cv2
import numpy as np
from picamera.array import PiRGBArray
from picamera import PiCamera
from socketIO_client import SocketIO, BaseNamespace
# enable safe shutdown with ctl+c
global running
running = Tru... | [
"logging.getLogger",
"cv2.meanStdDev",
"cv2.rectangle",
"time.sleep",
"cv2.imshow",
"socketIO_client.SocketIO",
"argparse.ArgumentParser",
"cv2.threshold",
"picamera.array.PiRGBArray",
"cv2.waitKey",
"picamera.PiCamera",
"os.path.dirname",
"cv2.cvtColor",
"cv2.GaussianBlur",
"time.time",... | [((398, 442), 'signal.signal', 'signal.signal', (['signal.SIGINT', 'signal_handler'], {}), '(signal.SIGINT, signal_handler)\n', (411, 442), False, 'import signal\n'), ((453, 513), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Do fancy OpenCV stuff"""'}), "(description='Do fancy OpenCV s... |
import tensorflow as tf
import os
import time
import numpy as np
import glob
import matplotlib.pyplot as plt
import PIL
import imageio
import argparse
import dataset as dt
INPUT_SHAPE = (32, 32, 1)
tf.random.set_seed(777)
NORM_LIST = ["interframe_minmax", "est_minmax", "zscore"]
class ConvVAE(tf.keras.Model):
... | [
"matplotlib.pyplot.ylabel",
"tensorflow.math.log",
"tensorflow.reduce_sum",
"tensorflow.keras.layers.BatchNormalization",
"tensorflow.GradientTape",
"numpy.array",
"dataset.Processor",
"tensorflow.keras.layers.Dense",
"tensorflow.reduce_mean",
"imageio.get_writer",
"os.remove",
"matplotlib.pyp... | [((201, 224), 'tensorflow.random.set_seed', 'tf.random.set_seed', (['(777)'], {}), '(777)\n', (219, 224), True, 'import tensorflow as tf\n'), ((2581, 2605), 'tensorflow.math.log', 'tf.math.log', (['(2.0 * np.pi)'], {}), '(2.0 * np.pi)\n', (2592, 2605), True, 'import tensorflow as tf\n'), ((2903, 2968), 'tensorflow.nn.s... |
import numpy
import six
from chainer.backends import cuda
from chainer.backends import intel64
from chainer import function_node
from chainer.utils import type_check
def _cu_conv_sum(y, x, n):
# Convolutional sum
# TODO(beam2d): Use scan computation
rdim = x.size // (x.shape[0] * x.shape[1])
cuda.ele... | [
"chainer.backends.intel64.ideep.localResponseNormalizationParam",
"six.moves.range",
"chainer.backends.cuda.cupy.square",
"chainer.backends.intel64.ideep.array",
"chainer.backends.cuda.cupy.empty_like",
"numpy.square",
"chainer.backends.cuda.elementwise",
"chainer.backends.intel64.inputs_all_ready",
... | [((312, 887), 'chainer.backends.cuda.elementwise', 'cuda.elementwise', (['"""raw T x, int32 rdim, int32 N, int32 n_"""', '"""raw T y"""', '"""\n int half_n = n_ / 2;\n int offset = i / rdim * N * rdim + i % rdim;\n\n float sum_part = 0;\n for (int j = 0; j < N + half_n; ++j) {\n ... |
# coding: utf-8
import numpy as np
import torch
import pysptk
import pyworld
import librosa
from sklearn.preprocessing import MinMaxScaler
from nnmnkwii.io import hts
from nnmnkwii.frontend import merlin as fe
from nnmnkwii.postfilters import merlin_post_filter
from nnmnkwii.preprocessing.f0 import interp1d
from nnsv... | [
"numpy.clip",
"librosa.midi_to_hz",
"pysptk.util.mcepalpha",
"numpy.log",
"pysptk.mc2sp",
"nnmnkwii.io.hts.HTSLabelFile",
"torch.from_numpy",
"numpy.array",
"numpy.asarray",
"nnmnkwii.preprocessing.f0.interp1d",
"numpy.maximum",
"nnmnkwii.frontend.merlin.linguistic_features",
"numpy.round",
... | [((950, 985), 'librosa.midi_to_hz', 'librosa.midi_to_hz', (['x[indices, idx]'], {}), '(x[indices, idx])\n', (968, 985), False, 'import librosa\n'), ((1622, 1646), 'nnsvs.io.hts.get_note_indices', 'get_note_indices', (['labels'], {}), '(labels)\n', (1638, 1646), False, 'from nnsvs.io.hts import get_note_indices\n'), ((3... |
import os
import time
import argparse
import math
from numpy import finfo
import numpy as np
import torch
from distributed import apply_gradient_allreduce
import torch.distributed as dist
from torch.utils.data.distributed import DistributedSampler
from torch.utils.data import DataLoader
from model import Tacotron2
fr... | [
"matplotlib.pylab.subplots",
"apex.amp.initialize",
"argparse.ArgumentParser",
"model.Tacotron2",
"torch.autograd.Variable",
"matplotlib.pylab.close",
"matplotlib.use",
"matplotlib.pylab.xlabel",
"distributed.apply_gradient_allreduce",
"os.path.isfile",
"data_utils.TextMelCollate",
"numpy.finf... | [((500, 521), 'matplotlib.use', 'matplotlib.use', (['"""Agg"""'], {}), "('Agg')\n", (514, 521), False, 'import matplotlib\n'), ((753, 782), 'matplotlib.pylab.subplots', 'plt.subplots', ([], {'figsize': '(12, 3)'}), '(figsize=(12, 3))\n', (765, 782), True, 'import matplotlib.pylab as plt\n'), ((891, 914), 'matplotlib.py... |
# Copyright (c) 2019 PaddlePaddle 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 applic... | [
"numpy.sqrt",
"box_utils.box_crop",
"PIL.ImageEnhance.Contrast",
"box_utils.box_iou_xywh",
"numpy.arange",
"numpy.asarray",
"PIL.ImageEnhance.Color",
"numpy.concatenate",
"random.randint",
"random.uniform",
"numpy.random.beta",
"random.randrange",
"PIL.ImageEnhance.Brightness",
"cv2.resize... | [((1398, 1420), 'numpy.random.shuffle', 'np.random.shuffle', (['ops'], {}), '(ops)\n', (1415, 1420), True, 'import numpy as np\n'), ((1432, 1452), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (1447, 1452), False, 'from PIL import Image, ImageEnhance\n'), ((1529, 1544), 'numpy.asarray', 'np.asarra... |
import matplotlib.pyplot as plt
from sklearn.utils.multiclass import unique_labels
import numpy as np
from sklearn import svm
from sklearn.metrics import confusion_matrix
from sklearn.metrics import roc_auc_score
from sklearn.metrics import roc_curve
from sklearn.metrics import auc
from sklearn.metrics import f1_score
... | [
"sklearn.svm.SVC",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylabel",
"numpy.arange",
"sklearn.metrics.auc",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"inspect.getfullargspec",
"sklearn.metrics.roc_auc_score",
"numpy.array",
"sklearn.metrics.roc_curve",
"matplotlib.pyplot.title"... | [((1361, 1430), 'sklearn.svm.SVC', 'svm.SVC', ([], {'kernel': 'kernel', 'C': 'C', 'degree': 'degree', 'class_weight': 'class_weight'}), '(kernel=kernel, C=C, degree=degree, class_weight=class_weight)\n', (1368, 1430), False, 'from sklearn import svm\n'), ((2286, 2303), 'numpy.array', 'np.array', (['classes'], {}), '(cl... |
import sklearn
import copy
import numpy as np
import scipy as sp
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
import seaborn as sns
# from viz import viz
from bokeh.plotting import figure, show, output_notebook, output_file, save
from functions import merge_data
from sklearn.mod... | [
"naive_autoreg_baselines.train_and_evaluate_model",
"naive_autoreg_baselines.make_predictions",
"exponential_modeling.get_exponential_forecasts",
"pmdl_weight.compute_pmdl_weight",
"numpy.array",
"exponential_modeling.linear_fit",
"exponential_modeling.leave_t_day_out",
"exponential_modeling.fit_and_p... | [((1423, 1436), 'numpy.array', 'np.array', (['[1]'], {}), '([1])\n', (1431, 1436), True, 'import numpy as np\n'), ((5002, 5015), 'numpy.array', 'np.array', (['[1]'], {}), '([1])\n', (5010, 5015), True, 'import numpy as np\n'), ((6580, 6653), 'pmdl_weight.compute_pmdl_weight', 'pmdl_weight.compute_pmdl_weight', (['use_d... |
"""Tests for the design module"""
import numpy as np
import turbigen.compflow as cf
from turbigen import design
# Set up test data
# Ranges of velocity triangle parameters covering the classic Smith chart
phi = np.linspace(0.4, 1.2, 5)
psi = np.linspace(0.8, 2.4, 5)
# "Reasonable" range of reaction (usually close to... | [
"numpy.radians",
"numpy.ptp",
"turbigen.design.nondim_stage_from_Lam",
"numpy.sqrt",
"turbigen.compflow.V_cpTo_from_Ma",
"numpy.log",
"turbigen.design.pitch_circulation",
"turbigen.design.pitch_Zweifel",
"numpy.array",
"numpy.isfinite",
"turbigen.compflow.Po_P_from_Ma",
"numpy.diff",
"numpy.... | [((213, 237), 'numpy.linspace', 'np.linspace', (['(0.4)', '(1.2)', '(5)'], {}), '(0.4, 1.2, 5)\n', (224, 237), True, 'import numpy as np\n'), ((244, 268), 'numpy.linspace', 'np.linspace', (['(0.8)', '(2.4)', '(5)'], {}), '(0.8, 2.4, 5)\n', (255, 268), True, 'import numpy as np\n'), ((425, 449), 'numpy.linspace', 'np.li... |
#!/usr/bin/env python
# coding: utf-8
# #<NAME>
# ## <b> Problem Description </b>
#
# ### This project aims to build a classification model to predict the sentiment of COVID-19 tweets.The tweets have been pulled from Twitter and manual tagging has been done then. Leveraging Natural Language Processing, sentiment ana... | [
"pandas.read_csv",
"matplotlib.pyplot.ylabel",
"nltk.download",
"sklearn.metrics.classification_report",
"pandas.to_datetime",
"matplotlib.pyplot.imshow",
"textblob.TextBlob",
"seaborn.set",
"nltk.corpus.stopwords.words",
"sklearn.feature_extraction.text.CountVectorizer",
"matplotlib.pyplot.xlab... | [((907, 949), 'pandas.set_option', 'pd.set_option', (['"""display.max_colwidth"""', '(200)'], {}), "('display.max_colwidth', 200)\n", (920, 949), True, 'import pandas as pd\n'), ((2075, 2188), 'pandas.read_csv', 'pd.read_csv', (['"""https://raw.githubusercontent.com/gabrielpreda/covid-19-tweets/master/covid19_tweets.cs... |
"""Code to embed a set of sequences in an embedding space using a trained protvec model and an embedding set of sequences. Creates a .csv file of the embedded sequences. Also returns file of sequences which could not be successfully embedded"""
import pickle
import numpy as np
from Bio import SeqIO
import pandas as ... | [
"numpy.mean",
"random.shuffle",
"pickle.load",
"numpy.array",
"Bio.SeqIO.index",
"numpy.std",
"pandas.DataFrame",
"numpy.all",
"warnings.filterwarnings",
"numpy.var"
] | [((414, 452), 'warnings.filterwarnings', 'warnings.filterwarnings', ([], {'action': '"""once"""'}), "(action='once')\n", (437, 452), False, 'import warnings\n'), ((4228, 4289), 'Bio.SeqIO.index', 'SeqIO.index', (['"""../sequences/bacillus_embeddingset.fa"""', '"""fasta"""'], {}), "('../sequences/bacillus_embeddingset.f... |
#!/usr/bin/env python
"""
Code to load an expert policy and generate roll-out data for behavioral cloning.
Example usage:
python dagger_pytorch.py experts/Humanoid-v1.pkl Humanoid-v2 --render \
--num_rollouts 20
Author of this script and included expert policies: <NAME> (<EMAIL>)
"""
import pickle
im... | [
"numpy.mean",
"numpy.reshape",
"random.shuffle",
"argparse.ArgumentParser",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"tensorflow.Session",
"load_policy.load_policy",
"tf_util.initialize",
"torch.FloatTensor",
"torch.max",
"torch.nn.MSELoss",
"matplo... | [((778, 821), 'load_policy.load_policy', 'load_policy.load_policy', (['expert_policy_file'], {}), '(expert_policy_file)\n', (801, 821), False, 'import load_policy\n'), ((2128, 2156), 'numpy.reshape', 'np.reshape', (['pair[0]', '(1, -1)'], {}), '(pair[0], (1, -1))\n', (2138, 2156), True, 'import numpy as np\n'), ((2168,... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#File afsk1200lib.py
#Author <NAME>/M0ZJO
#Date 05/10/2019
#Desc. This is a physical layer decoder for UOSAT-2 AFSK
__author__ = "Jonathan/M0ZJO"
__copyright__ = "Jonathan/M0ZJO 2019"
__credits__ = ["Surrey University"]
__license__ = "MIT"
__versi... | [
"matplotlib.pyplot.grid",
"matplotlib.pyplot.ylabel",
"numpy.array",
"numpy.sin",
"logging.info",
"numpy.arange",
"numpy.mean",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"numpy.max",
"numpy.exp",
"wavio.read",
"scipy.signal.firwin",
"numpy.cos",
"matplotlib.pyplot.title",
"... | [((562, 628), 'logging.basicConfig', 'logging.basicConfig', ([], {'filename': '"""PyAFSK1200.log"""', 'level': 'logging.INFO'}), "(filename='PyAFSK1200.log', level=logging.INFO)\n", (581, 628), False, 'import logging\n'), ((1544, 1564), 'wavio.read', 'wavio.read', (['filename'], {}), '(filename)\n', (1554, 1564), False... |
"""
Unit and regression test for the get_sequence_identity module of the molsysmt package on molsysmt MolSys molecular
systems.
"""
# Import package, test suite, and other packages as needed
import molsysmt as msm
import numpy as np
import math as math
# Distance between atoms in space and time
def test_get_sequence... | [
"math.isclose",
"molsysmt.topology.get_sequence_identity",
"numpy.array",
"numpy.all",
"molsysmt.convert"
] | [((364, 451), 'molsysmt.convert', 'msm.convert', (["msm.demo['T4 lysozyme L99A']['181l.msmpk']"], {'to_form': '"""molsysmt.MolSys"""'}), "(msm.demo['T4 lysozyme L99A']['181l.msmpk'], to_form=\n 'molsysmt.MolSys')\n", (375, 451), True, 'import molsysmt as msm\n'), ((462, 549), 'molsysmt.convert', 'msm.convert', (["ms... |
import copy
import logging
import os
import time
from collections import Counter
from statistics import mean
import numpy as np
import pandas as pd
from .fold_fitting_strategy import AbstractFoldFittingStrategy, SequentialLocalFoldFittingStrategy
from ..abstract.abstract_model import AbstractModel
from ...constants i... | [
"logging.getLogger",
"statistics.mean",
"numpy.where",
"collections.Counter",
"os.rmdir",
"numpy.zeros",
"copy.deepcopy",
"time.time",
"os.remove"
] | [((587, 614), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (604, 614), False, 'import logging\n'), ((4896, 4960), 'numpy.where', 'np.where', (['(oof_pred_model_repeats == 0)', '(1)', 'oof_pred_model_repeats'], {}), '(oof_pred_model_repeats == 0, 1, oof_pred_model_repeats)\n', (4904, 496... |
"""
<NAME>
University of Manitoba
July 30th, 2019
"""
import numpy as np
###############################################################################
def shuffle_arrays(arrays_list, rand_seed=0, return_seed=False):
"""Shuffle arrays to maintain inter-array ordering
Shuffles each array in t... | [
"numpy.ones_like",
"numpy.size",
"numpy.max",
"numpy.random.seed",
"numpy.shape",
"numpy.random.shuffle"
] | [((2407, 2425), 'numpy.ones_like', 'np.ones_like', (['data'], {}), '(data)\n', (2419, 2425), True, 'import numpy as np\n'), ((1164, 1189), 'numpy.random.seed', 'np.random.seed', (['rand_seed'], {}), '(rand_seed)\n', (1178, 1189), True, 'import numpy as np\n'), ((1558, 1589), 'numpy.random.shuffle', 'np.random.shuffle',... |
#================================================================
#
# File name : utils.py
# Author : PyLessons
# Created date: 2020-09-27
# Website : https://pylessons.com/
# GitHub : https://github.com/pythonlessons/TensorFlow-2.x-YOLOv3
# Description : additional yolov3 and yolov4 functio... | [
"cv2.rectangle",
"numpy.product",
"numpy.fromfile",
"tensorflow.shape",
"numpy.multiply.reduce",
"multiprocessing.Process",
"colorsys.hsv_to_rgb",
"cv2.imshow",
"numpy.array",
"cv2.destroyAllWindows",
"tensorflow.saved_model.load",
"cv2.VideoWriter",
"numpy.exp",
"tensorflow.concat",
"nu... | [((698, 730), 'tensorflow.keras.backend.clear_session', 'tf.keras.backend.clear_session', ([], {}), '()\n', (728, 730), True, 'import tensorflow as tf\n'), ((2930, 2981), 'tensorflow.config.experimental.list_physical_devices', 'tf.config.experimental.list_physical_devices', (['"""GPU"""'], {}), "('GPU')\n", (2974, 2981... |
# Copyright 2018 Amazon.com, Inc. or its affiliates. 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.
# A copy of the License is located at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# or in the "license... | [
"mxnet.nd.random.uniform",
"gluonts.mx.distribution.Binned",
"numpy.ones",
"mxnet.nd.ones",
"mxnet.random.uniform",
"itertools.product",
"pytest.mark.parametrize",
"mxnet.nd.arange",
"mxnet.nd.array",
"gluonts.mx.distribution.BinnedOutput"
] | [((2927, 2978), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""hybridize"""', '[True, False]'], {}), "('hybridize', [True, False])\n", (2950, 2978), False, 'import pytest\n'), ((993, 1038), 'mxnet.random.uniform', 'mx.random.uniform', ([], {'low': '(-6)', 'high': '(1)', 'shape': '(2,)'}), '(low=-6, high=1,... |
import sys, os, subprocess, importlib
import numpy as np
import ctypes
__all__ = ['Potential', 'TTM', 'MBPol']
class Potential:
"""Abstract base class for potential energy surfaces. A single function, evaluate(),
must be implemented which returns the energy and gradients.
Each child class needs... | [
"sys.path.insert",
"ctypes.c_int32",
"importlib.import_module",
"ctypes.POINTER",
"ctypes.cdll.LoadLibrary",
"numpy.reshape",
"numpy.asarray",
"os.getcwd",
"os.chdir",
"numpy.array",
"numpy.zeros",
"numpy.ctypeslib.ndpointer",
"numpy.ascontiguousarray",
"sys.exit",
"numpy.shape",
"nump... | [((1302, 1313), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (1311, 1313), False, 'import sys, os, subprocess, importlib\n'), ((5504, 5534), 'os.chdir', 'os.chdir', (['self.path_to_library'], {}), '(self.path_to_library)\n', (5512, 5534), False, 'import sys, os, subprocess, importlib\n'), ((5653, 5676), 'os.chdir', 'os.... |
#!/usr/bin/env python
import sys
from cvangysel import argparse_utils, logging_utils
import argparse
import logging
import matplotlib.cm as cm
import matplotlib.markers as markers
import matplotlib.pyplot as plt
import numpy as np
import os
import pylatex.utils
import pyndri
from sklearn.manifold import TSNE
import... | [
"numpy.copy",
"pyndri.Index",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.savefig",
"argparse.ArgumentParser",
"nvsm.load_meta",
"matplotlib.pyplot.gca",
"os.path.splitext",
"matplotlib.pyplot.style.use",
"sklearn.manifold.TSNE",
"cvangysel.logging_utils.configure_logging",
"os.path.basename"... | [((682, 707), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (705, 707), False, 'import argparse\n'), ((2335, 2355), 'matplotlib.pyplot.style.use', 'plt.style.use', (['"""bmh"""'], {}), "('bmh')\n", (2348, 2355), True, 'import matplotlib.pyplot as plt\n'), ((2361, 2391), 'logging.info', 'loggin... |
# coding: utf-8
# Copyright (c) Max-Planck-Institut für Eisenforschung GmbH - Computational Materials Design (CM) Department
# Distributed under the terms of "New BSD License", see the LICENSE file.
from __future__ import print_function
# import os
import sys
import copy
import numpy as np
from collections import Orde... | [
"numpy.copy",
"collections.OrderedDict",
"numpy.delete",
"numpy.equal",
"numpy.append",
"numpy.array"
] | [((3044, 3057), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (3055, 3057), False, 'from collections import OrderedDict, Sequence\n'), ((11675, 11713), 'numpy.delete', 'np.delete', (['self._lists[k]', 'key'], {'axis': '(0)'}), '(self._lists[k], key, axis=0)\n', (11684, 11713), True, 'import numpy as np\n'... |
# The Hazard Library
# Copyright (C) 2012-2018 GEM Foundation
#
# 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.
#... | [
"numpy.exp",
"numpy.dot"
] | [((5955, 5986), 'numpy.exp', 'numpy.exp', (['(-3.0 / b * distances)'], {}), '(-3.0 / b * distances)\n', (5964, 5986), False, 'import numpy\n'), ((3573, 3600), 'numpy.dot', 'numpy.dot', (['corma', 'residuals'], {}), '(corma, residuals)\n', (3582, 3600), False, 'import numpy\n')] |
import ray
import unittest
import numpy as np
from ray.rllib.agents.callbacks import DefaultCallbacks
from ray.rllib.env.multi_agent_env import MultiAgentEnv
from ray.rllib.evaluation.rollout_worker import RolloutWorker
from ray.rllib.examples.env.mock_env import MockEnv3
from ray.rllib.policy import Policy
from ray.rl... | [
"unittest.TestCase",
"ray.shutdown",
"numpy.where",
"pytest.main",
"ray.rllib.utils.override",
"ray.rllib.examples.env.mock_env.MockEnv3",
"ray.init"
] | [((2200, 2216), 'ray.rllib.utils.override', 'override', (['Policy'], {}), '(Policy)\n', (2208, 2216), False, 'from ray.rllib.utils import override\n'), ((512, 531), 'unittest.TestCase', 'unittest.TestCase', ([], {}), '()\n', (529, 531), False, 'import unittest\n'), ((3575, 3595), 'ray.init', 'ray.init', ([], {'num_cpus... |
import abc
import numpy as np
import copy
import csv
import os
from beluga.liepack import *
# The following math import statements appear to be unused, but they are required on import of the specific
# methods since an eval() is called
from math import sqrt
class Method(object):
"""
Class containing informati... | [
"os.path.abspath",
"numpy.array",
"copy.copy",
"csv.reader"
] | [((968, 1021), 'numpy.array', 'np.array', (["self.data[self.name]['a']"], {'dtype': 'np.float64'}), "(self.data[self.name]['a'], dtype=np.float64)\n", (976, 1021), True, 'import numpy as np\n'), ((1041, 1094), 'numpy.array', 'np.array', (["self.data[self.name]['b']"], {'dtype': 'np.float64'}), "(self.data[self.name]['b... |
"""
Vortex dynamics
Several initial states are provided: select one with 'vortex_config'
"""
import sys
try:
from param import Param
except:
print("[ERROR] unable to import the param module")
print("[INFO] you likely forgot to set $PYTHONPATH")
print("[INFO] depending on your shell")
print("> so... | [
"grid.Grid",
"numpy.shape",
"numpy.sqrt",
"ana_profiles.vortex",
"numpy.asarray",
"fluid2d.Fluid2d",
"numpy.exp",
"numpy.array",
"numpy.random.seed",
"numpy.cos",
"sys.exit",
"param.Param",
"numpy.round"
] | [((820, 840), 'param.Param', 'Param', (['"""default.xml"""'], {}), "('default.xml')\n", (825, 840), False, 'from param import Param\n'), ((1670, 1681), 'grid.Grid', 'Grid', (['param'], {}), '(param)\n', (1674, 1681), False, 'from grid import Grid\n'), ((2456, 2476), 'fluid2d.Fluid2d', 'Fluid2d', (['param', 'grid'], {})... |
"""import pywt
import numpy as np
import matplotlib.pyplot as plt
t = np.linspace(-1, 1, 200, endpoint=False)
sig = np.cos(2 * np.pi * 7 * t) + np.real(np.exp(-7*(t-0.4)**2)*np.exp(1j*2*np.pi*2*(t-0.4)))
plt.plot(t, sig)
plt.show()
widths = np.arange(1, 31)
cwtmatr, freqs = pywt.cwt(sig, widths, 'mexh')
print(cwtmatr)... | [
"pywt.wavelist",
"matplotlib.pyplot.plot",
"numpy.asarray",
"numpy.cos",
"pywt.wavedec",
"pywt.waverec",
"matplotlib.pyplot.show"
] | [((631, 644), 'numpy.asarray', 'np.asarray', (['t'], {}), '(t)\n', (641, 644), True, 'import numpy as np\n'), ((967, 1004), 'pywt.wavedec', 'pywt.wavedec', (['sig', '"""rbio6.8"""'], {'level': '(3)'}), "(sig, 'rbio6.8', level=3)\n", (979, 1004), False, 'import pywt\n'), ((1301, 1332), 'pywt.waverec', 'pywt.waverec', ([... |
import numpy as np
class user:
def __init__(self):
self.planned_channel = -1
self.transmission_success = False
print('user creation success')
def choose_channel(self, method, num_channels):
if method == 'uniform':
self.planned_channel = np.random.randint(0, num_chan... | [
"numpy.random.randint"
] | [((291, 325), 'numpy.random.randint', 'np.random.randint', (['(0)', 'num_channels'], {}), '(0, num_channels)\n', (308, 325), True, 'import numpy as np\n')] |
import random
import numpy as np
import pynmmso as nmmso
class Swarm:
"""
Represents a swarm in the NMMSO algorithm.
Arguments
---------
id : int
Id used to refer to the swarm
swarm_size : int
Maximum number of particles in the swarm
problem :
Instance of the prob... | [
"numpy.sqrt",
"numpy.isscalar",
"numpy.random.rand",
"random.randrange",
"pynmmso.Nmmso.uniform_sphere_points",
"numpy.asarray",
"numpy.min",
"numpy.argsort",
"numpy.sum",
"numpy.zeros",
"numpy.random.randint",
"numpy.concatenate",
"numpy.linalg.norm",
"numpy.full"
] | [((2052, 2100), 'numpy.zeros', 'np.zeros', (['(self.swarm_size, self.num_dimensions)'], {}), '((self.swarm_size, self.num_dimensions))\n', (2060, 2100), True, 'import numpy as np\n'), ((2165, 2198), 'numpy.full', 'np.full', (['self.swarm_size', '(-np.inf)'], {}), '(self.swarm_size, -np.inf)\n', (2172, 2198), True, 'imp... |
# Copyright (c) 2020, Apple Inc. All rights reserved.
#
# Use of this source code is governed by a BSD-3-clause license that can be
# found in the LICENSE.txt file or at https://opensource.org/licenses/BSD-3-Clause
from coremltools.converters.mil.mil import Builder as mb
from coremltools.converters.mil.testing_util... | [
"numpy.prod",
"coremltools.converters.mil.testing_utils.apply_pass_and_basic_check",
"coremltools.converters.mil.testing_utils.get_op_types_in_program",
"coremltools.converters.mil.mil.Builder.TensorSpec",
"coremltools.converters.mil.mil.Builder.tile",
"itertools.product",
"coremltools.converters.mil.mi... | [((1203, 1263), 'coremltools.converters.mil.testing_utils.apply_pass_and_basic_check', 'apply_pass_and_basic_check', (['prog', '"""common::noop_elimination"""'], {}), "(prog, 'common::noop_elimination')\n", (1229, 1263), False, 'from coremltools.converters.mil.testing_utils import assert_model_is_valid, get_op_types_in... |
from blaze.expr import symbol
import numpy as np
from datashape import dshape, isscalar
def test_array_dshape():
x = symbol('x', '5 * 3 * float32')
assert x.shape == (5, 3)
assert x.schema == dshape('float32')
assert len(x) == 5
assert x.ndim == 2
def test_element():
x = symbol('x', '5 * 3 *... | [
"numpy.array",
"datashape.isscalar",
"datashape.dshape",
"blaze.expr.symbol"
] | [((123, 153), 'blaze.expr.symbol', 'symbol', (['"""x"""', '"""5 * 3 * float32"""'], {}), "('x', '5 * 3 * float32')\n", (129, 153), False, 'from blaze.expr import symbol\n'), ((300, 330), 'blaze.expr.symbol', 'symbol', (['"""x"""', '"""5 * 3 * float32"""'], {}), "('x', '5 * 3 * float32')\n", (306, 330), False, 'from bla... |
# Copyright 2021 MosaicML. All Rights Reserved.
import os
from dataclasses import dataclass
from typing import List, Optional, Tuple
import numpy as np
import torch
import torch.utils.data
import yahp as hp
from PIL import Image
from torchvision import transforms
from torchvision.datasets import ImageFolder
from com... | [
"torchvision.transforms.CenterCrop",
"torchvision.transforms.RandomResizedCrop",
"yahp.required",
"numpy.asarray",
"numpy.rollaxis",
"torch.from_numpy",
"torchvision.transforms.RandomHorizontalFlip",
"yahp.optional",
"torch.tensor",
"numpy.resize",
"os.path.join",
"numpy.expand_dims",
"torch... | [((1348, 1412), 'torch.tensor', 'torch.tensor', (['[target[1] for target in batch]'], {'dtype': 'torch.int64'}), '([target[1] for target in batch], dtype=torch.int64)\n', (1360, 1412), False, 'import torch\n'), ((2680, 2706), 'yahp.required', 'hp.required', (['"""resize size"""'], {}), "('resize size')\n", (2691, 2706)... |
"""
Last edited: January 22 2020
@author: <NAME>
# here we provide unit tests of our main functions in robustPipelineSizing
"""
from FINE.expansionModules import robustPipelineSizing
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import networkx as nx
def test_robustPipelineDesign():
# wr... | [
"pandas.Series",
"FINE.expansionModules.robustPipelineSizing.computePressureEndnodeArc",
"FINE.expansionModules.robustPipelineSizing.networkRefinement",
"FINE.expansionModules.robustPipelineSizing.computeTimeStepFlows",
"pandas.DataFrame",
"numpy.round",
"FINE.expansionModules.robustPipelineSizing.deter... | [((8410, 8437), 'pandas.Series', 'pd.Series', (['data'], {'index': 'keys'}), '(data, index=keys)\n', (8419, 8437), True, 'import pandas as pd\n'), ((8461, 8495), 'pandas.Series', 'pd.Series', (['invalidData'], {'index': 'keys'}), '(invalidData, index=keys)\n', (8470, 8495), True, 'import pandas as pd\n'), ((9606, 9633)... |
from collections import OrderedDict
import numpy as np
import torch
import torch.optim as optim
from torch import nn as nn
import rlkit.torch.pytorch_util as ptu
from rlkit.core.eval_util import create_stats_ordered_dict
from rlkit.torch.torch_rl_algorithm import TorchTrainer
from rlkit.torch.networks import FlattenM... | [
"uncertainty_modeling.rl_uncertainty.model.RaPP",
"collections.OrderedDict",
"rlkit.torch.networks.FlattenMlp_Dropout",
"numpy.prod",
"torch.max",
"torch.from_numpy",
"torch.min",
"torch.tensor",
"torch.nn.MSELoss",
"rlkit.torch.pytorch_util.get_numpy",
"uncertainty_modeling.rl_uncertainty.model... | [((1308, 1417), 'uncertainty_modeling.rl_uncertainty.model.SWAG', 'SWAG', (['RegNetBase', '*args'], {'subspace_type': '"""pca"""', 'subspace_kwargs': "{'max_rank': 10, 'pca_rank': 10}"}), "(RegNetBase, *args, subspace_type='pca', **kwargs, subspace_kwargs={\n 'max_rank': 10, 'pca_rank': 10})\n", (1312, 1417), False,... |
"""
Generate samples for a corpus tag and for a submission.
"""
import json
import logging
import numpy as np
from . import db
from . import distribution
from .sample_util import sample_without_replacement
from .counter_utils import normalize
logger = logging.getLogger(__name__)
def sample_document_uniform(corpus_... | [
"logging.getLogger",
"json.dumps",
"numpy.random.seed"
] | [((256, 283), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (273, 283), False, 'import logging\n'), ((1031, 1049), 'numpy.random.seed', 'np.random.seed', (['(42)'], {}), '(42)\n', (1045, 1049), True, 'import numpy as np\n'), ((718, 776), 'json.dumps', 'json.dumps', (["{'type': 'uniform',... |
# Compute multivariate ESS using multi_ess function based on eeyore
# %% Load packages
import numpy as np
import torch
from eeyore.stats import multi_ess
# %% Read chains
chains = torch.as_tensor(np.genfromtxt('chain01.csv', delimiter=','))
# %% Compute multivariate ESS using INSE MC covariance estimation
ess_va... | [
"numpy.genfromtxt",
"eeyore.stats.multi_ess"
] | [((324, 341), 'eeyore.stats.multi_ess', 'multi_ess', (['chains'], {}), '(chains)\n', (333, 341), False, 'from eeyore.stats import multi_ess\n'), ((201, 244), 'numpy.genfromtxt', 'np.genfromtxt', (['"""chain01.csv"""'], {'delimiter': '""","""'}), "('chain01.csv', delimiter=',')\n", (214, 244), True, 'import numpy as np\... |
import numpy as np
import scipy as sp
import scipy.sparse
import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.path
import time
plt.ion()
import pybie2d
"""
Demonstrate how to use the pybie2d package to solve an interior Laplace problem
On a complicated domain using a global quadrature
This exam... | [
"numpy.abs",
"numpy.eye",
"numpy.ma.array",
"numpy.linalg.inv",
"matplotlib.pyplot.ion",
"scipy.sparse.csr_matrix",
"numpy.zeros_like",
"matplotlib.pyplot.subplots"
] | [((150, 159), 'matplotlib.pyplot.ion', 'plt.ion', ([], {}), '()\n', (157, 159), True, 'import matplotlib.pyplot as plt\n'), ((2983, 2999), 'numpy.linalg.inv', 'np.linalg.inv', (['A'], {}), '(A)\n', (2996, 2999), True, 'import numpy as np\n'), ((3298, 3321), 'numpy.zeros_like', 'np.zeros_like', (['gridp.xg'], {}), '(gri... |
import numpy
n = int(input())
matrix = []
for i in range(n):
matrix.append(list(map(float,input().split())))
print(round(numpy.linalg.det(matrix), 2))
| [
"numpy.linalg.det"
] | [((129, 153), 'numpy.linalg.det', 'numpy.linalg.det', (['matrix'], {}), '(matrix)\n', (145, 153), False, 'import numpy\n')] |
#
# Author: <NAME>
# Copyright 2015-present, NASA-JPL/Caltech
#
import os
import glob
import logging
import datetime
import numpy as np
import isceobj
import isceobj.Sensor.MultiMode as MultiMode
from isceobj.Planet.Planet import Planet
from isceobj.Alos2Proc.Alos2ProcPublic import runCmd
from isceobj.Alos2Proc.Alos2... | [
"logging.getLogger",
"os.makedirs",
"isceobj.Catalog.createCatalog",
"os.path.join",
"isceobj.Sensor.MultiMode.createSwath",
"os.chdir",
"numpy.array",
"numpy.argsort",
"isceobj.Sensor.MultiMode.createFrame",
"os.path.basename",
"os.path.abspath"
] | [((478, 530), 'logging.getLogger', 'logging.getLogger', (['"""isce.alos2insar.runPreprocessor"""'], {}), "('isce.alos2insar.runPreprocessor')\n", (495, 530), False, 'import logging\n'), ((604, 659), 'isceobj.Catalog.createCatalog', 'isceobj.Catalog.createCatalog', (['self._insar.procDoc.name'], {}), '(self._insar.procD... |
import sys
sys.path.extend(["./"])
import numpy as np
import torch
from clustorch.kmeans import KMeans
from src.threat.clustering.constrained_poisoning import ConstrainedAdvPoisoningGlobal
from experiments.utilities import ClusteringWrapper3Dto2D, set_seed
X = np.load("comparison/SEEDS/kme_X_org.npy")
Xadv_s = np.l... | [
"experiments.utilities.ClusteringWrapper3Dto2D",
"experiments.utilities.set_seed",
"torch.from_numpy",
"torch.nonzero",
"numpy.array",
"numpy.zeros",
"sys.path.extend",
"numpy.load",
"clustorch.kmeans.KMeans"
] | [((12, 35), 'sys.path.extend', 'sys.path.extend', (["['./']"], {}), "(['./'])\n", (27, 35), False, 'import sys\n'), ((265, 306), 'numpy.load', 'np.load', (['"""comparison/SEEDS/kme_X_org.npy"""'], {}), "('comparison/SEEDS/kme_X_org.npy')\n", (272, 306), True, 'import numpy as np\n'), ((316, 357), 'numpy.load', 'np.load... |
import tensorflow as tf
import numpy as np
from PIL import Image
import os
import glob
import platform
import argparse
from scipy.io import loadmat,savemat
from preprocess_img import align_img
from utils import *
from face_decoder import Face3D
from options import Option
is_windows = True
def parse_args():
des... | [
"numpy.clip",
"options.Option",
"networks.R_Net",
"os.path.exists",
"tensorflow.Graph",
"argparse.ArgumentParser",
"face_decoder.Face3D",
"tensorflow.placeholder",
"tensorflow.Session",
"tensorflow.trainable_variables",
"preprocess_img.align_img",
"glob.glob",
"tensorflow.device",
"tensorf... | [((364, 405), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': 'desc'}), '(description=desc)\n', (387, 405), False, 'import argparse\n'), ((676, 700), 'tensorflow.trainable_variables', 'tf.trainable_variables', ([], {}), '()\n', (698, 700), True, 'import tensorflow as tf\n'), ((711, 732), 'ten... |
import abc
from typing import Dict, List, Optional, TypeVar
import numpy as np
from pydantic import BaseModel
from ..constants import ZEROISH, Dtype
class DatasetMetadata(BaseModel):
id: Optional[int]
name: str = ""
dose_units: str = ""
response_units: str = ""
dose_name: str = ""
response_n... | [
"numpy.max",
"numpy.min",
"typing.TypeVar"
] | [((2869, 2910), 'typing.TypeVar', 'TypeVar', (['"""DatasetType"""'], {'bound': 'DatasetBase'}), "('DatasetType', bound=DatasetBase)\n", (2876, 2910), False, 'from typing import Dict, List, Optional, TypeVar\n'), ((1276, 1294), 'numpy.min', 'np.min', (['self.doses'], {}), '(self.doses)\n', (1282, 1294), True, 'import nu... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.