code stringlengths 31 1.05M | apis list | extract_api stringlengths 97 1.91M |
|---|---|---|
import math
import numbers
import numpy as np
from skimage.filters import gaussian
from skimage import img_as_float
from scipy import ndimage
from skimage import exposure
import torch
from torch import nn
from torch.nn import functional as F
import kornia
from loguru import logger
def simple_invert(data):
"""I... | [
"numpy.nan_to_num",
"skimage.exposure.adjust_gamma",
"numpy.min",
"scipy.ndimage.label",
"numpy.max"
] | [((553, 572), 'scipy.ndimage.label', 'ndimage.label', (['data'], {}), '(data)\n', (566, 572), False, 'from scipy import ndimage\n'), ((665, 683), 'numpy.nan_to_num', 'np.nan_to_num', (['img'], {}), '(img)\n', (678, 683), True, 'import numpy as np\n'), ((615, 626), 'numpy.min', 'np.min', (['img'], {}), '(img)\n', (621, ... |
#!/usr/bin/env python
# Copyright (c) 2021, <NAME>
# See LICENSE file for details: <https://github.com/moble/spherical/blob/master/LICENSE>
import math
import cmath
import numpy as np
import quaternionic
import spherical as sf
import pytest
from .conftest import requires_sympy
slow = pytest.mark.slow
precision_Wig... | [
"numpy.abs",
"numpy.sum",
"numpy.allclose",
"spherical.WignerDsize",
"numpy.sin",
"numpy.identity",
"math.cos",
"numpy.linspace",
"spherical.WignerDrange",
"time.perf_counter",
"math.sin",
"numpy.cos",
"cmath.exp",
"numpy.all",
"spherical.WignerDindex",
"spherical.Wigner",
"quaternio... | [((706, 724), 'spherical.Wigner', 'sf.Wigner', (['ell_max'], {}), '(ell_max)\n', (715, 724), True, 'import spherical as sf\n'), ((1295, 1314), 'time.perf_counter', 'time.perf_counter', ([], {}), '()\n', (1312, 1314), False, 'import time\n'), ((1527, 1550), 'spherical.Wigner', 'sf.Wigner', (['ell_max_slow'], {}), '(ell_... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Created by <NAME> | 27/09/2018 | https://y-research.github.io
"""Description
"""
import numpy as np
import torch
from org.archive.l2r_global import L2R_GLOBAL
from org.archive.ranking.run.l2r import point_run, grid_run
""" GPU acceleration if expected """
L2R_GLOBAL.... | [
"torch.manual_seed",
"org.archive.ranking.run.l2r.point_run",
"numpy.random.seed",
"org.archive.ranking.run.l2r.grid_run"
] | [((406, 446), 'numpy.random.seed', 'np.random.seed', ([], {'seed': 'L2R_GLOBAL.l2r_seed'}), '(seed=L2R_GLOBAL.l2r_seed)\n', (420, 446), True, 'import numpy as np\n'), ((447, 490), 'torch.manual_seed', 'torch.manual_seed', ([], {'seed': 'L2R_GLOBAL.l2r_seed'}), '(seed=L2R_GLOBAL.l2r_seed)\n', (464, 490), False, 'import ... |
"""
This module implements several Raman response functions. Numerical models of
the Raman response are important for the accurate theoretical description of
the propagation of optical pulses with short duration and high peak power
[MM1986]_ [G1986]_.
The following Raman response models are currently supported:
.. a... | [
"numpy.sum",
"numpy.asarray",
"numpy.zeros",
"numpy.min",
"numpy.where",
"numpy.sin",
"numpy.exp"
] | [((2694, 2704), 'numpy.sum', 'np.sum', (['hR'], {}), '(hR)\n', (2700, 2704), True, 'import numpy as np\n'), ((3698, 3743), 'numpy.where', 'np.where', (['(t > 0)', '((1.0 - fb) * ha + fb * hb)', '(0)'], {}), '(t > 0, (1.0 - fb) * ha + fb * hb, 0)\n', (3706, 3743), True, 'import numpy as np\n'), ((3754, 3764), 'numpy.sum... |
import numpy as np
import tensorflow as tf
from tensorflow import keras
import os
import dataprocess
import fluidmodels
import losses
#python version of jupyter notebook file, just for testing the packages.
# ### Manufacturing data for trainig
# In[2]:
np.random.seed(123)
pde_data_size = 2000
bc_data_size = 400
... | [
"fluidmodels.ForwardModel",
"numpy.random.seed",
"tensorflow.sin",
"dataprocess.DataPreprocess",
"dataprocess.imp_from_csv"
] | [((260, 279), 'numpy.random.seed', 'np.random.seed', (['(123)'], {}), '(123)\n', (274, 279), True, 'import numpy as np\n'), ((4353, 4426), 'dataprocess.imp_from_csv', 'dataprocess.imp_from_csv', (['"""data_manufactured/t_sin_x_plus_y.csv"""', '(True)', '(1)'], {}), "('data_manufactured/t_sin_x_plus_y.csv', True, 1)\n",... |
import pandas as pd
from itertools import combinations
import numpy as np
import datetime
import os
dataFrame = ""
columnsWithSameValue = []
fullEmptyColumns = []
def startAnalyze(csv_path):
global dataFrame, fullEmptyColumns
# print("Importing CSV File\n")
csv = pd.read_csv(csv_path, low_memory=False)
csv_no_he... | [
"pandas.DataFrame",
"os.mkdir",
"pandas.read_csv",
"os.path.exists",
"numpy.zeros",
"itertools.combinations",
"datetime.datetime.now"
] | [((270, 309), 'pandas.read_csv', 'pd.read_csv', (['csv_path'], {'low_memory': '(False)'}), '(csv_path, low_memory=False)\n', (281, 309), True, 'import pandas as pd\n'), ((325, 377), 'pandas.read_csv', 'pd.read_csv', (['csv_path'], {'header': 'None', 'low_memory': '(False)'}), '(csv_path, header=None, low_memory=False)\... |
"""
Various data import functions for training and validation of neural networks.
"""
import numpy as np
import random as rnd
from oap.__conf__ import OAP_FILE_EXTENSION, SLICE_SIZE
from oap.lib import normalize
from oap.utils import (
barycenter,
features,
adjust_y,
center_particle,
flip_x,
f... | [
"oap.utils.move_to_y",
"oap.lib.normalize",
"oap.utils.files.filepaths",
"oap.utils.barycenter",
"oap.utils.monochromatic",
"random.uniform",
"random.shuffle",
"oap.utils.move_to_x",
"oap.utils.flip_x",
"oap.utils.adjust_y",
"oap.utils.files.read_oap_file",
"numpy.array",
"random.getrandbits... | [((3363, 3381), 'random.shuffle', 'rnd.shuffle', (['files'], {}), '(files)\n', (3374, 3381), True, 'import random as rnd\n'), ((2779, 2887), 'oap.utils.files.filepaths', 'filepaths', (['directory'], {'exclude': 'exclude', 'include': 'include', 'file_extension': 'file_extension', 'p_types': 'positive'}), '(directory, ex... |
# -*- coding: utf-8 -*-
""" Simulating what echolocating bats as they fly in groups - AKA the
'cocktail party nightmare'
Created on Tue Dec 12 21:55:48 2017
Copyright <NAME>, 2019
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "... | [
"numpy.abs",
"numpy.sum",
"numpy.argmin",
"scipy.spatial.distance_matrix",
"numpy.around",
"numpy.sin",
"numpy.arange",
"numpy.tile",
"numpy.float64",
"numpy.random.random_integers",
"sys.path.append",
"pandas.DataFrame",
"scipy.spatial.distance.euclidean",
"numpy.cumsum",
"numpy.apply_a... | [((1366, 1396), 'sys.path.append', 'sys.path.append', (['"""../bridson/"""'], {}), "('../bridson/')\n", (1381, 1396), False, 'import sys\n'), ((1397, 1429), 'sys.path.append', 'sys.path.append', (['"""../acoustics/"""'], {}), "('../acoustics/')\n", (1412, 1429), False, 'import sys\n'), ((4165, 4222), 'scipy.spatial.dis... |
import numpy as np
import unyt as u
class APConstants:
"""Experimental data and other constants for Ammonium Perchlorate"""
def __init__(self):
assert (
self.expt_lattice_a.keys()
== self.expt_lattice_b.keys()
== self.expt_lattice_c.keys()
)
assert(
... | [
"numpy.asarray",
"numpy.array",
"numpy.vstack"
] | [((1257, 1317), 'numpy.asarray', 'np.asarray', (['[[3.5, 4.5], [0.5, 2.0], [2.5, 3.8], [2.5, 3.8]]'], {}), '([[3.5, 4.5], [0.5, 2.0], [2.5, 3.8], [2.5, 3.8]])\n', (1267, 1317), True, 'import numpy as np\n'), ((1466, 1529), 'numpy.asarray', 'np.asarray', (['[[0.1, 0.8], [0.0, 0.02], [0.01, 0.2], [0.02, 0.3]]'], {}), '([... |
from numpy import array
A = array([[1,2,3],[4,5,6],[7,8,9]])
print('A[:,0] =',A[:,0])
print('A[:,2] =',A[:,2])
| [
"numpy.array"
] | [((28, 68), 'numpy.array', 'array', (['[[1, 2, 3], [4, 5, 6], [7, 8, 9]]'], {}), '([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n', (33, 68), False, 'from numpy import array\n')] |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Time : 2020-12-30 10:28
# @Author : Xelawk
# @FileName: parser.py
import os
from io import BytesIO
import numpy as np
import trimesh
import open3d as o3d
import uuid
from wand import image
from PIL import Image
class MeshParser(object):
def __init__(self, **kwa... | [
"trimesh.Trimesh",
"os.remove",
"io.BytesIO",
"open3d.utility.Vector3iVector",
"PIL.Image.open",
"open3d.visualization.draw_geometries",
"wand.image.Image",
"uuid.uuid1",
"open3d.geometry.TriangleMesh",
"numpy.array",
"open3d.io.read_image",
"open3d.utility.Vector3dVector",
"open3d.utility.V... | [((3941, 3961), 'PIL.Image.open', 'Image.open', (['path_tmp'], {}), '(path_tmp)\n', (3951, 3961), False, 'from PIL import Image\n'), ((4182, 4200), 'numpy.array', 'np.array', (['self.uvs'], {}), '(self.uvs)\n', (4190, 4200), True, 'import numpy as np\n'), ((4622, 4640), 'numpy.array', 'np.array', (['self.uvs'], {}), '(... |
# -*- coding: utf-8 -*-
"""
Created on Sat Dec 5 23:46:02 2020
@author: sabbi
"""
#input file name to the function, data will be output into dataContainer object,
#which will have xml fopoter and wavelength calibration if applicable
#dataContainer.data will be a list of numpy arrays per ROI
import numpy ... | [
"xml.etree.ElementTree.fromstring",
"numpy.fromfile",
"numpy.dtype",
"numpy.int",
"numpy.reshape",
"numpy.fromstring",
"numpy.concatenate"
] | [((863, 903), 'numpy.fromfile', 'np.fromfile', (['f'], {'dtype': 'np.uint64', 'count': '(1)'}), '(f, dtype=np.uint64, count=1)\n', (874, 903), True, 'import numpy as np\n'), ((945, 986), 'numpy.fromfile', 'np.fromfile', (['f'], {'dtype': 'np.float32', 'count': '(1)'}), '(f, dtype=np.float32, count=1)\n', (956, 986), Tr... |
from astropy.tests.helper import pytest
import numpy as np
from .. import Model
from .test_helpers import random_id, get_test_dust
from ...grid import AMRGrid
@pytest.mark.parametrize(('direction'), ['x', 'y', 'z'])
def test_amr_differing_widths(tmpdir, direction):
# Widths of grids in same level are not the sa... | [
"astropy.tests.helper.pytest.mark.parametrize",
"astropy.tests.helper.pytest.raises",
"numpy.ones"
] | [((163, 216), 'astropy.tests.helper.pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""direction"""', "['x', 'y', 'z']"], {}), "('direction', ['x', 'y', 'z'])\n", (186, 216), False, 'from astropy.tests.helper import pytest\n'), ((1540, 1593), 'astropy.tests.helper.pytest.mark.parametrize', 'pytest.mark.parametr... |
import cv2
import base64
import logging
import argparse
import numpy as np
from flask import Flask, Response, request, jsonify
from functions import DataSet
logging.basicConfig(level=logging.INFO)
app = Flask(
__name__
)
@app.route("/", methods=["POST"])
def index():
data = request.get_json()
src = da... | [
"base64.standard_b64decode",
"logging.basicConfig",
"argparse.ArgumentParser",
"numpy.frombuffer",
"flask.Flask",
"cv2.imdecode",
"functions.DataSet",
"flask.jsonify",
"flask.Response",
"flask.request.get_json"
] | [((159, 198), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (178, 198), False, 'import logging\n'), ((206, 221), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (211, 221), False, 'from flask import Flask, Response, request, jsonify\n'), ((288, 306)... |
import json
from pathlib import Path
import numpy as np
import pandas as pd
from .utils import get_project_path, read_tsv
def _fetch_margulies_gradient():
"""Load Margulies gradients in Schaefer 100 space"""
path_dm_gradient = (
Path(get_project_path()) / "data/hcp/hcp_embed_1-10_Schaefer1000_7Netwo... | [
"numpy.corrcoef",
"pathlib.Path",
"json.load",
"pandas.concat"
] | [((1903, 1929), 'pandas.concat', 'pd.concat', (['collect'], {'axis': '(0)'}), '(collect, axis=0)\n', (1912, 1929), True, 'import pandas as pd\n'), ((812, 827), 'pathlib.Path', 'Path', (['data_path'], {}), '(data_path)\n', (816, 827), False, 'from pathlib import Path\n'), ((1035, 1055), 'json.load', 'json.load', (['json... |
import jax
import jax.numpy as jnp
import numpy as onp
import haiku as hk
from jax.experimental import optix
from nsec.datasets.two_moons import get_two_moons
from nsec.datasets.gaussian_mixture import get_gm
from nsec.datasets.swiss_roll import get_swiss_roll
from nsec.utils import display_score_two_moons
from nsec.mo... | [
"matplotlib.pyplot.title",
"pickle.dump",
"matplotlib.pyplot.quiver",
"jax.random.PRNGKey",
"matplotlib.pyplot.tight_layout",
"nsec.models.dae.ardae.ARDAE",
"jax.experimental.optix.adam",
"numpy.random.randn",
"matplotlib.pyplot.imshow",
"jax.numpy.linspace",
"matplotlib.pyplot.colorbar",
"jax... | [((1829, 1846), 'jax.experimental.optix.adam', 'optix.adam', (['(0.001)'], {}), '(0.001)\n', (1839, 1846), False, 'from jax.experimental import optix\n'), ((1856, 1875), 'haiku.PRNGSequence', 'hk.PRNGSequence', (['(42)'], {}), '(42)\n', (1871, 1875), True, 'import haiku as hk\n'), ((4205, 4222), 'jax.experimental.optix... |
from sklearn.datasets import make_classification, make_blobs, load_iris
from sklearn.model_selection import train_test_split
import json
import numpy as np
def iris_dataset():
iris = load_iris()
X = iris.data[:, [0, 2]]
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y,
... | [
"sklearn.datasets.load_iris",
"json.load",
"sklearn.model_selection.train_test_split",
"numpy.asarray",
"sklearn.datasets.make_classification",
"sklearn.datasets.make_blobs"
] | [((190, 201), 'sklearn.datasets.load_iris', 'load_iris', ([], {}), '()\n', (199, 201), False, 'from sklearn.datasets import make_classification, make_blobs, load_iris\n'), ((291, 346), 'sklearn.model_selection.train_test_split', 'train_test_split', (['X', 'y'], {'train_size': '(0.8)', 'random_state': '(42)'}), '(X, y, ... |
from gridworld import GridWorld
import random
from collections import defaultdict
import numpy as np
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
from plot_utils import heatmap, annotate_heatmap, plotArrow
import math
def get_random_start_pos(gridworld):
width, height = len(gridworld.g... | [
"matplotlib.pyplot.title",
"math.isnan",
"matplotlib.pyplot.show",
"random.randint",
"plot_utils.plotArrow",
"numpy.argmax",
"numpy.empty",
"plot_utils.annotate_heatmap",
"collections.defaultdict",
"random.random",
"numpy.max",
"matplotlib.use",
"numpy.arange",
"random.seed",
"matplotlib... | [((119, 142), 'matplotlib.use', 'matplotlib.use', (['"""TkAgg"""'], {}), "('TkAgg')\n", (133, 142), False, 'import matplotlib\n'), ((558, 573), 'random.random', 'random.random', ([], {}), '()\n', (571, 573), False, 'import random\n'), ((848, 873), 'numpy.empty', 'np.empty', (['(width, height)'], {}), '((width, height))... |
#!/usr/bin/python
# create QuantLib models from Python models
try:
import QuantLib as ql
except ModuleNotFoundError as e:
print('Error: Module QuantLibPayoffs requires a (custom) QuantLib installation.')
raise e
try:
from QuantLib import QuasiGaussianModel as qlQuasiGaussianModel
except ImportError a... | [
"sys.path.append",
"QuantLib.Actual365Fixed",
"QuantLib.Settings.instance",
"numpy.identity",
"numpy.array",
"QuantLib.QuasiGaussianModel"
] | [((627, 648), 'sys.path.append', 'sys.path.append', (['"""./"""'], {}), "('./')\n", (642, 648), False, 'import sys\n'), ((1384, 1423), 'numpy.array', 'np.array', (['[(0.0) for t in model._times]'], {}), '([(0.0) for t in model._times])\n', (1392, 1423), True, 'import numpy as np\n'), ((1498, 1523), 'numpy.identity', 'n... |
from util.Logger import Logger
from util.misc_util import *
import traceback
import sys
import numpy as np
import os
def _check_attr_is_None(attr):
def _check_attr_empty(f):
def wrapper(self, *args):
ret = f(self, *args)
if getattr(self, attr) is None:
... | [
"traceback.format_exception",
"os.makedirs",
"util.Logger.Logger",
"sys.exc_info",
"os.path.split",
"os.path.join",
"numpy.concatenate",
"numpy.repeat"
] | [((3317, 3366), 'util.Logger.Logger', 'Logger', (['self.__class__.__name__'], {'stdout_only': '(True)'}), '(self.__class__.__name__, stdout_only=True)\n', (3323, 3366), False, 'from util.Logger import Logger\n'), ((4100, 4117), 'os.makedirs', 'os.makedirs', (['path'], {}), '(path)\n', (4111, 4117), False, 'import os\n'... |
# -*- coding: utf-8 -*-
"""Implements the RippleNet model."""
import logging
import math
import multiprocessing as mp
import time
from collections import defaultdict
from typing import Dict, Optional, Sequence, Tuple, Union
import numpy as np
import torch
from jsonargparse import Namespace
from jsonargparse.typing i... | [
"numpy.isin",
"sklearn.model_selection.train_test_split",
"torch.nn.init.uniform_",
"torch.empty",
"collections.defaultdict",
"sklearn.metrics.f1_score",
"numpy.random.choice",
"torch.nn.Linear",
"multiprocessing.JoinableQueue",
"torch.zeros_like",
"torch.nn.init.xavier_uniform_",
"time.perf_c... | [((739, 766), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (756, 766), False, 'import logging\n'), ((3972, 4015), 'torch.nn.Linear', 'nn.Linear', (['embed_dim', 'embed_dim'], {'bias': '(False)'}), '(embed_dim, embed_dim, bias=False)\n', (3981, 4015), False, 'from torch import nn\n'), ((... |
"""Microscoper is a wrapper around bioformats using a forked
python-bioformats to extract the raw images from Olympus IX83
CellSense .vsi format, into a more commonly used TIFF format.
Images are bundled together according to their channels.
This code is used internally in SCB Lab, TCIS, TIFR-H.
You're free to modify... | [
"tqdm.tqdm",
"javabridge.static_call",
"javabridge.get_static_field",
"os.makedirs",
"javabridge.kill_vm",
"os.path.basename",
"bioformats.get_omexml_metadata",
"os.path.realpath",
"os.walk",
"os.path.exists",
"numpy.asarray",
"tifffile.TiffWriter",
"javabridge.start_vm",
"bioformats.Image... | [((984, 1002), 'os.walk', 'os.walk', (['directory'], {}), '(directory)\n', (991, 1002), False, 'import os\n'), ((1294, 1326), 'bioformats.get_omexml_metadata', 'bf.get_omexml_metadata', (['filename'], {}), '(filename)\n', (1316, 1326), True, 'import bioformats as bf\n'), ((1342, 1364), 'bioformats.omexml.OMEXML', 'bf.o... |
import argparse
import numpy as np
import glob
import torch
import torch.nn.functional as F
import os
from kaldi_io import read_mat_scp
import model as model_
import scipy.io as sio
from utils import *
def prep_feats(data_):
#data_ = ( data_ - data_.mean(0) ) / data_.std(0)
features = data_.T
if features.shape[... | [
"model.DenseNet",
"model.cnn_lstm",
"os.remove",
"model.TDNN",
"argparse.ArgumentParser",
"model.MobileNetV3_Small",
"os.path.isfile",
"numpy.tile",
"model.lcnn_9layers",
"torch.no_grad",
"model.lcnn_29layers_v2_pca",
"model.Linear",
"model.FTDNN",
"model.VGG",
"torch.load",
"model.TDN... | [((554, 607), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Compute scores"""'}), "(description='Compute scores')\n", (577, 607), False, 'import argparse\n'), ((4587, 4616), 'os.path.isfile', 'os.path.isfile', (['args.out_path'], {}), '(args.out_path)\n', (4601, 4616), False, 'import os... |
""" If this operator needs to be run with the faster NMS implementation,
follow these steps:
1. Clone google/automl and tensorflow/models from Github.
2. Run the following commands in automl/efficientdet:
a. grep -lIR "from object_detection" ./* | xargs sed -i "s/from object_detection/from object_det/g"... | [
"pylot.perception.detection.utils.load_coco_labels",
"tensorflow.reshape",
"inference.image_preprocess",
"tensorflow.compat.v1.disable_eager_execution",
"tensorflow.ConfigProto",
"numpy.isclose",
"tensorflow.GPUOptions",
"erdos.profile_method",
"erdos.utils.setup_csv_logging",
"pylot.perception.me... | [((8167, 8189), 'erdos.profile_method', 'erdos.profile_method', ([], {}), '()\n', (8187, 8189), False, 'import erdos\n'), ((2318, 2388), 'erdos.utils.setup_logging', 'erdos.utils.setup_logging', (['self.config.name', 'self.config.log_file_name'], {}), '(self.config.name, self.config.log_file_name)\n', (2343, 2388), Fal... |
from entente.equality import have_same_topology
from lacecore import shapes
import numpy as np
def test_have_same_topology():
cube_1 = shapes.cube(np.zeros(3), 1.0)
cube_2 = shapes.cube(np.zeros(3), 1.0)
assert have_same_topology(cube_1, cube_2) is True
cube_1 = shapes.cube(np.zeros(3), 1.0)
cub... | [
"numpy.roll",
"numpy.zeros",
"numpy.ones",
"numpy.array",
"entente.equality.have_same_topology"
] | [((511, 539), 'numpy.roll', 'np.roll', (['cube_2.f', '(1)'], {'axis': '(1)'}), '(cube_2.f, 1, axis=1)\n', (518, 539), True, 'import numpy as np\n'), ((697, 730), 'numpy.zeros', 'np.zeros', (['(0, 3)'], {'dtype': 'np.uint64'}), '((0, 3), dtype=np.uint64)\n', (705, 730), True, 'import numpy as np\n'), ((154, 165), 'numpy... |
import numpy as np
from gym_collision_avoidance.envs.config import Config
from gym_collision_avoidance.envs.util import wrap, find_nearest
from gym_collision_avoidance.envs.utils import end_conditions as ec
import operator
import math
class Agent(object):
def __init__(self, start_x, start_y, goal_x, goal_y, radius... | [
"numpy.arctan2",
"math.sqrt",
"numpy.roll",
"numpy.empty",
"numpy.zeros",
"numpy.ones",
"numpy.sin",
"numpy.array",
"numpy.linalg.norm",
"gym_collision_avoidance.envs.util.wrap",
"numpy.linalg.inv",
"numpy.cos",
"numpy.dot"
] | [((734, 779), 'numpy.array', 'np.array', (['[start_x, start_y]'], {'dtype': '"""float64"""'}), "([start_x, start_y], dtype='float64')\n", (742, 779), True, 'import numpy as np\n'), ((813, 856), 'numpy.array', 'np.array', (['[goal_x, goal_y]'], {'dtype': '"""float64"""'}), "([goal_x, goal_y], dtype='float64')\n", (821, ... |
#Based on https://www.kaggle.com/tezdhar/wordbatch-with-memory-test
import gc
import time
import numpy as np
import pandas as pd
from scipy.sparse import csr_matrix, hstack
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import t... | [
"sklearn.feature_extraction.text.CountVectorizer",
"wordbatch.WordBatch",
"pandas.read_csv",
"sklearn.feature_extraction.text.TfidfVectorizer",
"wordbatch.models.FM_FTRL",
"gc.collect",
"pickle.load",
"wordbatch.models.FTRL",
"pandas.DataFrame",
"re.findall",
"pandas.concat",
"numpy.log1p",
... | [((3793, 3821), 're.compile', 're.compile', (['u"""[^A-Za-z0-9]+"""'], {}), "(u'[^A-Za-z0-9]+')\n", (3803, 3821), False, 'import re\n'), ((4125, 4136), 'time.time', 'time.time', ([], {}), '()\n', (4134, 4136), False, 'import time\n'), ((4695, 4787), 'pandas.read_csv', 'pd.read_csv', (['"""../input/train.csv"""'], {'ind... |
import numpy as np
import sklearn.dummy
import sklearn.linear_model
def eta_string(time_points, remaining_works):
return format_timedelta(eta(time_points, remaining_works))
def eta(time_points, remaining_works, regression_points_used=200):
"""Estimate the time remaining until completion of a task based on s... | [
"numpy.interp",
"numpy.asarray",
"numpy.expand_dims",
"numpy.isnan"
] | [((991, 1014), 'numpy.asarray', 'np.asarray', (['time_points'], {}), '(time_points)\n', (1001, 1014), True, 'import numpy as np\n'), ((1037, 1064), 'numpy.asarray', 'np.asarray', (['remaining_works'], {}), '(remaining_works)\n', (1047, 1064), True, 'import numpy as np\n'), ((2097, 2125), 'numpy.interp', 'np.interp', ([... |
import batoid
import numpy as np
from test_helpers import timer
@timer
def test_rSplit():
for i in range(100):
R = np.random.normal(0.7, 0.8)
conic = np.random.uniform(-2.0, 1.0)
ncoef = np.random.randint(0, 4)
coefs = [np.random.normal(0, 1e-10) for i in range(ncoef)]
asph... | [
"numpy.random.uniform",
"batoid.SimpleCoating",
"batoid.Asphere",
"batoid.ConstMedium",
"batoid.Air",
"numpy.random.randint",
"numpy.random.normal"
] | [((129, 155), 'numpy.random.normal', 'np.random.normal', (['(0.7)', '(0.8)'], {}), '(0.7, 0.8)\n', (145, 155), True, 'import numpy as np\n'), ((172, 200), 'numpy.random.uniform', 'np.random.uniform', (['(-2.0)', '(1.0)'], {}), '(-2.0, 1.0)\n', (189, 200), True, 'import numpy as np\n'), ((217, 240), 'numpy.random.randin... |
from argparse import ArgumentParser
from copy import deepcopy
import json
import random
import spacy
from rouge import Rouge
from tqdm import tqdm
import numpy as np
from collections import defaultdict
import functools
import operator
from gensim.models import Word2Vec
import streamlit as st
import requests
import bs4
... | [
"streamlit.text_input",
"argparse.ArgumentParser",
"random.shuffle",
"streamlit.title",
"collections.defaultdict",
"numpy.mean",
"streamlit.subheader",
"rouge.Rouge",
"spacy.load",
"random.seed",
"requests.get",
"re.sub",
"copy.deepcopy",
"tqdm.tqdm",
"bs4.BeautifulSoup",
"re.compile",... | [((338, 403), 'spacy.load', 'spacy.load', (['"""en_core_web_lg"""'], {'disable': "['tagger', 'ner', 'parser']"}), "('en_core_web_lg', disable=['tagger', 'ner', 'parser'])\n", (348, 403), False, 'import spacy\n'), ((2851, 2890), 'rouge.Rouge', 'Rouge', ([], {'metrics': "['rouge-1']", 'stats': "['f']"}), "(metrics=['roug... |
import argparse
import os
import torch
import itertools
from game.Player import RandomPlayer
from ai.HeuristicPlayer import HeuristicPlayer1, HeuristicPlayer2
from ai.RLPlayer import RLPlayer
from ai.EAPlayer import EAPlayer
from game.Game import Game
import numpy as np
from tqdm import tqdm
def parse_args():
p... | [
"ai.EAPlayer.EAPlayer",
"os.mkdir",
"game.Player.RandomPlayer",
"ai.RLPlayer.RLPlayer",
"numpy.count_nonzero",
"argparse.ArgumentParser",
"game.Game.Game",
"numpy.savetxt",
"numpy.genfromtxt",
"itertools.combinations_with_replacement",
"ai.HeuristicPlayer.HeuristicPlayer2",
"torch.cuda.is_avai... | [((328, 353), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (351, 353), False, 'import argparse\n'), ((1301, 1341), 'game.Game.Game', 'Game', (['(2)', '(0)'], {'config_path': 'args.config_path'}), '(2, 0, config_path=args.config_path)\n', (1305, 1341), False, 'from game.Game import Game\n'), (... |
import numpy as np
from sgp4.api import Satrec
from astropy.io import ascii
def minmaxloc(num_list):
return np.argmin(num_list), np.argmax(num_list)
np.set_printoptions(precision=2)
with open('hipparcos-tle.txt', 'r') as f:
st = f.read().split('\n')
jds = np.genfromtxt("hipparcos_tle_jd.txt", dtype=None)
N... | [
"numpy.set_printoptions",
"numpy.argmax",
"sgp4.api.Satrec.twoline2rv",
"numpy.savetxt",
"numpy.zeros",
"numpy.genfromtxt",
"numpy.argmin",
"numpy.where",
"numpy.modf",
"numpy.concatenate"
] | [((156, 188), 'numpy.set_printoptions', 'np.set_printoptions', ([], {'precision': '(2)'}), '(precision=2)\n', (175, 188), True, 'import numpy as np\n'), ((269, 318), 'numpy.genfromtxt', 'np.genfromtxt', (['"""hipparcos_tle_jd.txt"""'], {'dtype': 'None'}), "('hipparcos_tle_jd.txt', dtype=None)\n", (282, 318), True, 'imp... |
'''
Theorem 1
this script is a brute-force verification that the scalar local Lipschitz
result is true
'''
import numpy as np
def relu(y):
return (y>0)*y
def lip(y0,y):
return np.abs(relu(y) - relu(y0))/np.abs(y-y0)
# setup
n_trials = 10**4
n_samps = 7
lip_anl = np.full(n_trials, np.nan)
lip_brute = np.full... | [
"numpy.full",
"numpy.random.uniform",
"numpy.abs",
"numpy.max",
"numpy.linalg.norm"
] | [((275, 300), 'numpy.full', 'np.full', (['n_trials', 'np.nan'], {}), '(n_trials, np.nan)\n', (282, 300), True, 'import numpy as np\n'), ((313, 338), 'numpy.full', 'np.full', (['n_trials', 'np.nan'], {}), '(n_trials, np.nan)\n', (320, 338), True, 'import numpy as np\n'), ((726, 750), 'numpy.linalg.norm', 'np.linalg.norm... |
"""
2016 Day 8
https://adventofcode.com/2016/day/8
"""
from typing import Callable, Sequence, Tuple
import re
import numpy as np
import aocd # type: ignore
def blank_screen() -> np.ndarray:
"""
Create an empty 50x6 array.
"""
return np.array([[0 for col in range(50)] for row in range(6)], int)
def... | [
"numpy.roll",
"numpy.rot90",
"aocd.get_data",
"re.compile"
] | [((935, 964), 'numpy.rot90', 'np.rot90', (['screen'], {'axes': '(1, 0)'}), '(screen, axes=(1, 0))\n', (943, 964), True, 'import numpy as np\n'), ((1032, 1061), 'numpy.rot90', 'np.rot90', (['rolled'], {'axes': '(0, 1)'}), '(rolled, axes=(0, 1))\n', (1040, 1061), True, 'import numpy as np\n'), ((2627, 2658), 'aocd.get_da... |
import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt
import numpy as np
import os
if __name__ == "__main__":
# Load trained model
model = keras.models.load_model("../paper_results/3d_optmock_6par/models/3D_21cmPIE_Net")
# Plot each of the 32 filters from the first convolutio... | [
"matplotlib.pyplot.tight_layout",
"tensorflow.keras.models.load_model",
"os.makedirs",
"matplotlib.pyplot.close",
"matplotlib.pyplot.yticks",
"numpy.mean",
"matplotlib.pyplot.xticks",
"matplotlib.pyplot.subplots"
] | [((179, 265), 'tensorflow.keras.models.load_model', 'keras.models.load_model', (['"""../paper_results/3d_optmock_6par/models/3D_21cmPIE_Net"""'], {}), "(\n '../paper_results/3d_optmock_6par/models/3D_21cmPIE_Net')\n", (202, 265), False, 'from tensorflow import keras\n'), ((532, 561), 'numpy.mean', 'np.mean', (['weig... |
# -*- coding: utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt
from timeit import timeit
from fft import direct_ft, recursive_ft, bitrev_ft
a = -np.pi
b = np.pi
N = 512
x = np.linspace(a, b, N)
def func(x, **kwds):
# note peaks for each mode
# return np.sum([np.sin(i*x) for i in (1., 2., 5., 10.... | [
"timeit.timeit",
"numpy.exp",
"fft.bitrev_ft",
"numpy.linspace",
"matplotlib.pyplot.subplots",
"numpy.sqrt"
] | [((187, 207), 'numpy.linspace', 'np.linspace', (['a', 'b', 'N'], {}), '(a, b, N)\n', (198, 207), True, 'import numpy as np\n'), ((789, 801), 'fft.bitrev_ft', 'bitrev_ft', (['f'], {}), '(f)\n', (798, 801), False, 'from fft import direct_ft, recursive_ft, bitrev_ft\n'), ((823, 838), 'matplotlib.pyplot.subplots', 'plt.sub... |
import numpy as np
'''
# sort
# Syantax: numpy.sort(a, axis, kind, order)
a = np.array([[3,7],[9,1]])
print("sort default: ", np.sort(a))
print("sort axis = 0: ", np.sort(a, axis = 0))
# VIP sorting based on custom data type
dt = np.dtype([('name', 'S10'),('age', int)])
a = np.array([("raju",21),("anil... | [
"numpy.where",
"numpy.array",
"numpy.arange",
"numpy.mod"
] | [((948, 997), 'numpy.array', 'np.array', (['[[30, 40, 0], [0, 20, 10], [50, 0, 60]]'], {}), '([[30, 40, 0], [0, 20, 10], [50, 0, 60]])\n', (956, 997), True, 'import numpy as np\n'), ((997, 1013), 'numpy.where', 'np.where', (['(a > 30)'], {}), '(a > 30)\n', (1005, 1013), True, 'import numpy as np\n'), ((1173, 1187), 'nu... |
import numpy as np
import torch as th
def train_ppo(model, optimizer,
obs, acs, advs, vtargs, old_ac_logps,
n_epochs=3, n_mbatch=1, loss='clip',
vfcoef=0.5, entcoef=0.01, kl_threshold=np.inf, **update_kwargs):
batch_size = obs.shape[0]
mbatch_size = int(batch_siz... | [
"numpy.random.permutation",
"torch.exp",
"torch.clamp",
"torch.max"
] | [((1868, 1899), 'torch.exp', 'th.exp', (['(ac_logps - old_ac_logps)'], {}), '(ac_logps - old_ac_logps)\n', (1874, 1899), True, 'import torch as th\n'), ((1927, 1977), 'torch.clamp', 'th.clamp', (['ac_logp_frac', '(1 - clip_eps)', '(1 + clip_eps)'], {}), '(ac_logp_frac, 1 - clip_eps, 1 + clip_eps)\n', (1935, 1977), True... |
import os
import time
from collections import Counter
import numpy as np
import tensorflow as tf
import tensorflow_hub as hub
from tensorflow import keras
from tensorflow.python.keras.callbacks import ModelCheckpoint, EarlyStopping, TensorBoard
from sklearn.metrics import f1_score, precision_score, recall_score, accur... | [
"numpy.load",
"numpy.save",
"utils_data_text.get_features_from_data",
"tensorflow_hub.Module",
"tensorflow.global_variables_initializer",
"sklearn.metrics.accuracy_score",
"numpy.zeros",
"sklearn.metrics.recall_score",
"tensorflow.placeholder",
"tensorflow.matmul",
"sklearn.metrics.f1_score",
... | [((2516, 2571), 'utils_data_text.get_features_from_data', 'get_features_from_data', (['train_data', 'val_data', 'test_data'], {}), '(train_data, val_data, test_data)\n', (2538, 2571), False, 'from utils_data_text import get_features_from_data, read_class_results\n'), ((2742, 2803), 'tensorflow.placeholder', 'tf.placeho... |
import numpy
#numpy.genfromtxt('arr.txt', dtype=bool)
test_input = """00100
11110
10110
10111
10101
01111
00111
11100
10000
11001
00010
01010"""
with open('input') as f:
input = f.read().rstrip()
def parse_data(input):
return numpy.array([[int(char) for char in list(line)] for line in input.splitlines()])
... | [
"numpy.shape",
"numpy.count_nonzero",
"numpy.sum",
"numpy.argwhere"
] | [((1028, 1058), 'numpy.shape', 'numpy.shape', (['diagnostic_report'], {}), '(diagnostic_report)\n', (1039, 1058), False, 'import numpy\n'), ((451, 492), 'numpy.count_nonzero', 'numpy.count_nonzero', (['diagnostic_report', '(0)'], {}), '(diagnostic_report, 0)\n', (470, 492), False, 'import numpy\n'), ((609, 650), 'numpy... |
import music21 as m21
m21.humdrum.spineParser.flavors['JRP'] = True
import pandas as pd
import numpy as np
import json
import argparse
from fractions import Fraction
from collections import defaultdict
from pathlib import Path
from itertools import zip_longest
from MTCFeatures.MTCFeatureLoader import MTCFeatureLoader... | [
"json.load",
"argparse.ArgumentParser",
"pandas.concat",
"MTCFeatures.MTCFeatureLoader.MTCFeatureLoader",
"json.dumps",
"collections.defaultdict",
"music21.interval.Interval",
"pathlib.Path",
"numpy.array",
"music21.converter.parse",
"fractions.Fraction",
"music21.note.Note"
] | [((739, 815), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Convert MTC .krn to feature sequences"""'}), "(description='Convert MTC .krn to feature sequences')\n", (762, 815), False, 'import argparse\n'), ((2781, 2818), 'pathlib.Path', 'Path', (['args.mtcroot', '"""MTC-FS-INST-2.0"""'],... |
"""parameter_search.py
Search for optimal parameters for RIDDLE and various ML classifiers.
Requires: Keras, NumPy, scikit-learn, RIDDLE (and their dependencies)
Author: <NAME>, Rzhetsky Lab
Copyright: 2018, all rights reserved
"""
from __future__ import print_function
import argparse
import os
import pickl... | [
"pickle.dump",
"numpy.random.seed",
"argparse.ArgumentParser",
"utils.subset_reencode_features",
"utils.get_param_path",
"utils.get_preprocessed_data",
"os.path.isfile",
"sklearn.svm.SVC",
"utils.vectorize_features",
"utils.recursive_mkdir",
"sklearn.model_selection.RandomizedSearchCV",
"riddl... | [((883, 987), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Perform parameter search for various classification methods."""'}), "(description=\n 'Perform parameter search for various classification methods.')\n", (906, 987), False, 'import argparse\n'), ((4397, 4483), 'riddle.emr.get... |
import numpy as np
from dialRL.utils import distance, float_equality
origin = np.array([1. , 1.])
target = np.array([10., 10.])
print('origin position: ', origin)
print('Traget position: ', target)
a = distance(origin, target)
b = np.random.uniform(0, 9)
# , b = np.random.uniform(0, 9)
# a, b = np.max([a, b]), np.... | [
"numpy.random.uniform",
"dialRL.utils.distance",
"numpy.array"
] | [((79, 99), 'numpy.array', 'np.array', (['[1.0, 1.0]'], {}), '([1.0, 1.0])\n', (87, 99), True, 'import numpy as np\n'), ((108, 130), 'numpy.array', 'np.array', (['[10.0, 10.0]'], {}), '([10.0, 10.0])\n', (116, 130), True, 'import numpy as np\n'), ((205, 229), 'dialRL.utils.distance', 'distance', (['origin', 'target'], ... |
# -----------------------------------------------------------------------------
# From Pytnon to Numpy
# Copyright (2017) <NAME> - BSD license
# More information at https://github.com/rougier/numpy-book
# -----------------------------------------------------------------------------
import numpy as np
import matplotlib.... | [
"numpy.arctan2",
"numpy.empty",
"numpy.einsum",
"numpy.ones",
"matplotlib.animation.FuncAnimation",
"matplotlib.pyplot.figure",
"numpy.sin",
"numpy.multiply",
"numpy.dstack",
"numpy.divide",
"matplotlib.pyplot.show",
"numpy.hypot",
"numpy.cos",
"numpy.dot",
"numpy.random.uniform",
"mat... | [((6821, 6885), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(10, 10 * height / width)', 'facecolor': '"""white"""'}), "(figsize=(10, 10 * height / width), facecolor='white')\n", (6831, 6885), True, 'import matplotlib.pyplot as plt\n'), ((7318, 7370), 'matplotlib.animation.FuncAnimation', 'FuncAnimation'... |
from __future__ import absolute_import, division, print_function
from mmtbx.validation.ramalyze import draw_ramachandran_plot
import math
from scipy import interpolate
import numpy as np
def calculate_indexes(x, y, xmin, x_step, ymin, y_step):
i = math.floor((x-xmin) / x_step)
j = math.floor((y-ymin) / y_step)
... | [
"math.floor",
"mmtbx.validation.ramalyze.draw_ramachandran_plot",
"scipy.interpolate.interp2d",
"numpy.array",
"numpy.swapaxes"
] | [((253, 284), 'math.floor', 'math.floor', (['((x - xmin) / x_step)'], {}), '((x - xmin) / x_step)\n', (263, 284), False, 'import math\n'), ((289, 320), 'math.floor', 'math.floor', (['((y - ymin) / y_step)'], {}), '((y - ymin) / y_step)\n', (299, 320), False, 'import math\n'), ((3135, 3179), 'scipy.interpolate.interp2d'... |
import numpy as np
from tictactoe import search
from tictactoe.search import Minimax, SearchAlgorithm
from tictactoe.board import Board, Winner
def app(algorithm: SearchAlgorithm, player: bool):
b = Board(np.full((3,3), None))
if not player:
print(str(b))
while b.winner == Winner.UNDETERMINED:
... | [
"numpy.full",
"tictactoe.search.Minimax"
] | [((211, 232), 'numpy.full', 'np.full', (['(3, 3)', 'None'], {}), '((3, 3), None)\n', (218, 232), True, 'import numpy as np\n'), ((864, 881), 'tictactoe.search.Minimax', 'Minimax', (['(False)', '(5)'], {}), '(False, 5)\n', (871, 881), False, 'from tictactoe.search import Minimax, SearchAlgorithm\n')] |
from copy import deepcopy
import numpy as np
from bridge_sim.bridges.bridge_705 import bridge_705
from bridge_sim.configs import opensees_default
from bridge_sim.vehicles import truck1
from bridge_sim.model import PointLoad
from bridge_sim.util import flatten
c = opensees_default(bridge_705(0.5))
entering_time = truc... | [
"bridge_sim.vehicles.truck1.to_wheel_track_xs",
"copy.deepcopy",
"bridge_sim.util.flatten",
"bridge_sim.vehicles.truck1.time_left_bridge",
"bridge_sim.bridges.bridge_705.bridge_705",
"bridge_sim.vehicles.truck1.to_point_load_pw",
"bridge_sim.vehicles.truck1.total_kn",
"bridge_sim.vehicles.truck1.time_... | [((316, 360), 'bridge_sim.vehicles.truck1.time_entering_bridge', 'truck1.time_entering_bridge', ([], {'bridge': 'c.bridge'}), '(bridge=c.bridge)\n', (343, 360), False, 'from bridge_sim.vehicles import truck1\n'), ((376, 419), 'bridge_sim.vehicles.truck1.time_entered_bridge', 'truck1.time_entered_bridge', ([], {'bridge'... |
import rospy
import numpy as np
import pcl
from tools import *
#Import error, but we don't really used this file anymore
#from scipy.linalg import lstsq
from std_msgs.msg import Header, Int64
from geometry_msgs.msg import Point
from pointcloud_operations import filtering
from sensor_msgs.msg import PointCloud2
from sen... | [
"std_msgs.msg.Int64",
"rospy.Subscriber",
"rospy.Time.now",
"gpd.msg.CloudIndexed",
"std_msgs.msg.Header",
"rospy.Publisher",
"rospy.sleep",
"numpy.ones",
"numpy.where",
"pointcloud_operations.filtering",
"geometry_msgs.msg.Point",
"sensor_msgs.point_cloud2.read_points",
"pcl.PointCloud"
] | [((449, 465), 'pcl.PointCloud', 'pcl.PointCloud', ([], {}), '()\n', (463, 465), False, 'import pcl\n'), ((621, 711), 'rospy.Subscriber', 'rospy.Subscriber', (['"""/camera/depth_registered/points"""', 'PointCloud2', 'self.cloud_callback'], {}), "('/camera/depth_registered/points', PointCloud2, self.\n cloud_callback)... |
import os, pickle, glob
from pandas.core.reshape.concat import concat
from common.tflogs2pandas import tflog2pandas
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
from common.gym_interface import template
if False:
def read_df(body):
dfs = []
for seed ... | [
"common.tflogs2pandas.tflog2pandas",
"numpy.arange",
"common.gym_interface.template",
"pandas.read_pickle",
"pandas.concat"
] | [((1324, 1371), 'pandas.read_pickle', 'pd.read_pickle', (['"""output_data/tmp/oracle_1xx_df"""'], {}), "('output_data/tmp/oracle_1xx_df')\n", (1338, 1371), True, 'import pandas as pd\n'), ((1115, 1145), 'numpy.arange', 'np.arange', ([], {'start': '(100)', 'stop': '(200)'}), '(start=100, stop=200)\n', (1124, 1145), True... |
# -*- coding: utf-8 -*-
# Max-Planck-Gesellschaft zur Förderung der Wissenschaften e.V. (MPG) is
# holder of all proprietary rights on this computer program.
# You can only use this computer program if you have closed
# a license agreement with MPG or you get the right to use the computer
# program from someone who is... | [
"pyrender.camera.IntrinsicsCamera",
"torch.cuda.synchronize",
"pickle.dump",
"mesh_intersection.bvh_search_tree.BVH",
"torch.cat",
"numpy.ones",
"pyrender.Mesh.from_trimesh",
"numpy.mean",
"numpy.arange",
"pickle.load",
"pyrender.Scene",
"temp_prox.optimizers.optim_factory.create_optimizer",
... | [((15875, 15913), 'numpy.concatenate', 'np.concatenate', (['contact_fric_verts_ids'], {}), '(contact_fric_verts_ids)\n', (15889, 15913), True, 'import numpy as np\n'), ((19531, 20794), 'temp_prox.fitting_temp_slide.create_loss', 'fitting.create_loss', ([], {'loss_type': 'loss_type', 'joint_weights': 'joint_weights', 'r... |
"""
Push Sum Gossip Gradient Descent class for parallel optimization using column stochastic mixing.
:author: <NAME>
:description: Distributed otpimization using column stochastic mixing and greedy gradient descent.
Based on the paper (nedich2015distributed)
"""
import time
import numpy as np
from .go... | [
"numpy.random.randn",
"numpy.random.seed",
"time.time"
] | [((5484, 5495), 'time.time', 'time.time', ([], {}), '()\n', (5493, 5495), False, 'import time\n'), ((7341, 7365), 'numpy.random.seed', 'np.random.seed', ([], {'seed': 'UID'}), '(seed=UID)\n', (7355, 7365), True, 'import numpy as np\n'), ((7384, 7416), 'numpy.random.randn', 'np.random.randn', (['num_features', '(1)'], {... |
from copy import copy
from collections import ChainMap
from collections.abc import Collection, Iterable
from functools import lru_cache
import logging
import os
from pathlib import Path, PurePosixPath
import re
from types import SimpleNamespace
from warnings import warn
import jpype
from jpype import JClass
import num... | [
"ixmp.utils.as_str_list",
"jpype.isJVMStarted",
"ixmp.utils.islistable",
"jpype.JClass",
"copy.copy",
"re.match",
"ixmp.utils.filtered",
"pathlib.Path",
"numpy.array",
"jpype.getDefaultJVMPath",
"ixmp.config.get_platform_info",
"collections.ChainMap",
"warnings.warn",
"functools.lru_cache"... | [((524, 551), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (541, 551), False, 'import logging\n'), ((851, 868), 'types.SimpleNamespace', 'SimpleNamespace', ([], {}), '()\n', (866, 868), False, 'from types import SimpleNamespace\n'), ((30057, 30069), 'functools.lru_cache', 'lru_cache', (... |
import logging
import os
from collections import defaultdict
from pathlib import Path
from multiprocessing import Pool, cpu_count
import librosa
import numpy as np
from python_speech_features import fbank
from tqdm import tqdm
from constants import SAMPLE_RATE, NUM_FBANKS
from utils import find_files, ensures_dir
log... | [
"numpy.abs",
"utils.find_files",
"collections.defaultdict",
"pathlib.Path",
"os.path.isfile",
"numpy.mean",
"utils.ensures_dir",
"os.path.join",
"multiprocessing.cpu_count",
"numpy.std",
"os.path.exists",
"librosa.core.frames_to_samples",
"librosa.feature.rms",
"numpy.save",
"numpy.perce... | [((326, 353), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (343, 353), False, 'import logging\n'), ((465, 478), 'numpy.abs', 'np.abs', (['audio'], {}), '(audio)\n', (471, 478), True, 'import numpy as np\n'), ((503, 528), 'numpy.percentile', 'np.percentile', (['energy', '(95)'], {}), '(e... |
import tkinter
import cv2
import PIL.Image, PIL.ImageTk
import time
import numpy as np
import RPi.GPIO as GPIO
import mpv
import sys
import os
import serial
from time import sleep
import picamera
import io
#Initialization
#webcam/blindspot
capleft = ""
capright = ""
all_Cam_Off = 1
left_Camera_On ... | [
"numpy.floor",
"cv2.imdecode",
"cv2.adaptiveThreshold",
"mpv.MPV",
"cv2.rectangle",
"serial.Serial",
"numpy.full",
"cv2.contourArea",
"RPi.GPIO.setup",
"cv2.cvtColor",
"cv2.ml.KNearest_create",
"tkinter.Button",
"numpy.append",
"numpy.loadtxt",
"os.fork",
"tkinter.Tk",
"cv2.resize",
... | [((402, 435), 'mpv.MPV', 'mpv.MPV', ([], {'start_event_thread': '(False)'}), '(start_event_thread=False)\n', (409, 435), False, 'import mpv\n'), ((477, 611), 'serial.Serial', 'serial.Serial', (['"""/dev/ttyAMA0"""', '(9600)'], {'timeout': '(4)', 'parity': 'serial.PARITY_NONE', 'stopbits': 'serial.STOPBITS_ONE', 'bytesi... |
import difflib
import os
import shutil
import subprocess
import sys
import time
import numpy as np
from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import *
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.figure import Figure
from threading import Thread
# slash = '/' ... | [
"os.listdir",
"os.mkdir",
"numpy.zeros_like",
"numpy.sum",
"shutil.rmtree",
"os.getcwd",
"os.path.isdir",
"subprocess.check_output",
"os.path.exists",
"numpy.zeros",
"time.time",
"numpy.append",
"os.path.isfile",
"matplotlib.figure.Figure",
"numpy.array",
"matplotlib.backends.backend_q... | [((24478, 24489), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (24487, 24489), False, 'import os\n'), ((483, 521), 'numpy.sum', 'np.sum', (['self.matrix_time[mask]'], {'axis': '(0)'}), '(self.matrix_time[mask], axis=0)\n', (489, 521), True, 'import numpy as np\n'), ((2571, 2583), 'numpy.array', 'np.array', (['[]'], {}),... |
"""
Preprocessing functions.
"""
import numpy as np
import scipy as sp
import nutsml.imageutil as ni
from nutsflow import *
from constants import C, H, W, H_TOP, H_BOTTOM
def flatten_layers(image, order=2, verbose=False):
"""
:param ndarray image: gray scale image.
:param int order: Order of polynom fit... | [
"numpy.pad",
"nutsml.imageutil.gray2rgb",
"numpy.multiply",
"numpy.polyfit",
"numpy.zeros",
"nutsml.imageutil.resize",
"scipy.ndimage.zoom",
"numpy.hstack",
"numpy.isnan",
"numpy.nonzero",
"numpy.mean",
"numpy.vstack"
] | [((802, 825), 'numpy.multiply', 'np.multiply', (['mask', 'idxs'], {}), '(mask, idxs)\n', (813, 825), True, 'import numpy as np\n'), ((1177, 1218), 'numpy.hstack', 'np.hstack', (['[xs[0:d], xs[ncols - d:ncols]]'], {}), '([xs[0:d], xs[ncols - d:ncols]])\n', (1186, 1218), True, 'import numpy as np\n'), ((1229, 1270), 'num... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import cv2
import numpy as np
# 找图 返回最近似的点
def search_img(img, template, threshold=0.9, debug=False, gray=0):
"""
在大图中找小图
:param img: 大图
:param template: 小图
:param threshold: 相似度 1为完美 -1为最差
:param debug: 是否显示图片匹配情况，True会框选出匹配项
:param gray: 是... | [
"cv2.cvtColor",
"cv2.waitKey",
"cv2.imread",
"numpy.where",
"cv2.rectangle",
"cv2.imshow",
"cv2.matchTemplate"
] | [((464, 493), 'cv2.cvtColor', 'cv2.cvtColor', (['img', 'color_mode'], {}), '(img, color_mode)\n', (476, 493), False, 'import cv2\n'), ((509, 543), 'cv2.cvtColor', 'cv2.cvtColor', (['template', 'color_mode'], {}), '(template, color_mode)\n', (521, 543), False, 'import cv2\n'), ((557, 611), 'cv2.matchTemplate', 'cv2.matc... |
import numpy as np
def get_sonic_specific_actions():
buttons = ["B", "A", "MODE", "START", "UP", "DOWN", "LEFT", "RIGHT", "C", "Y", "X", "Z"]
actions = [['LEFT'], ['RIGHT'], ['LEFT', 'DOWN'], ['RIGHT', 'DOWN'], ['DOWN'],
['DOWN', 'B'], ['B'], [], ['LEFT', 'B'], ['RIGHT', 'B']]
_actions = []... | [
"numpy.array"
] | [((362, 384), 'numpy.array', 'np.array', (['([False] * 12)'], {}), '([False] * 12)\n', (370, 384), True, 'import numpy as np\n')] |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
showcase paths
==============
This example shows how OMAS supports dynamic path crection using different syntaxes.
.. figure:: ../images/dynamic_path_testimonial.png
:align: center
:width: 100%
:alt: What people say about OMAS dynamic path creation
:target: ../... | [
"numpy.array"
] | [((2030, 2047), 'numpy.array', 'numpy.array', (['data'], {}), '(data)\n', (2041, 2047), False, 'import numpy\n'), ((2073, 2126), 'numpy.array', 'numpy.array', (['[1000.0, 2000.0, 3000.0, 4000.0, 5000.0]'], {}), '([1000.0, 2000.0, 3000.0, 4000.0, 5000.0])\n', (2084, 2126), False, 'import numpy\n'), ((2259, 2312), 'numpy... |
import random
import numpy as np
from PIL import Image
_plan_square = np.array([[0, 0], [1, 0], [0, 1], [1, 1]], dtype=np.float64)
_middle_point_coordinates = np.array([0.5, 0.5], dtype=np.float64)
def compute_perspective_params(plan_1, plan_2, width_, height_):
"""
Given the coordinates of the four corner... | [
"random.gauss",
"numpy.array"
] | [((74, 134), 'numpy.array', 'np.array', (['[[0, 0], [1, 0], [0, 1], [1, 1]]'], {'dtype': 'np.float64'}), '([[0, 0], [1, 0], [0, 1], [1, 1]], dtype=np.float64)\n', (82, 134), True, 'import numpy as np\n'), ((163, 201), 'numpy.array', 'np.array', (['[0.5, 0.5]'], {'dtype': 'np.float64'}), '([0.5, 0.5], dtype=np.float64)\... |
import numpy as np
import imageio
import argparse
import glob
import os
np.seterr(invalid='ignore')
def make_grayscale(depth: np.ndarray) -> np.ndarray:
"""Get depth for grayscale images."""
depth_not_nan = depth[np.logical_not(np.isnan(depth))]
min_v = np.min(depth_not_nan)
max_v = np.max(depth_not_... | [
"numpy.stack",
"os.path.abspath",
"argparse.ArgumentParser",
"numpy.seterr",
"numpy.power",
"numpy.square",
"numpy.isnan",
"numpy.min",
"numpy.max",
"numpy.array",
"numpy.arange",
"glob.glob",
"os.path.join",
"numpy.sqrt"
] | [((73, 100), 'numpy.seterr', 'np.seterr', ([], {'invalid': '"""ignore"""'}), "(invalid='ignore')\n", (82, 100), True, 'import numpy as np\n'), ((269, 290), 'numpy.min', 'np.min', (['depth_not_nan'], {}), '(depth_not_nan)\n', (275, 290), True, 'import numpy as np\n'), ((303, 324), 'numpy.max', 'np.max', (['depth_not_nan... |
import re
import numpy as np
from kabuki import kabuki_mask
# We want to use the output
# of kabuki kidpix to initialize
# a Game of Life grid.
#
# Here is the format that Life expects:
#
# initialState : '[{"39":[60]},{"40":[62]},{"41":[59,60,63,64,65]}]',
#
# '[
# { "<row-id>" : [<col-id>, <col-id>, <col-id... | [
"numpy.shape",
"kabuki.kabuki_mask",
"numpy.array",
"re.sub"
] | [((1463, 1565), 'kabuki.kabuki_mask', 'kabuki_mask', (['img_filename', "kwargs['final_size']", "kwargs['brightness_threshold']", "kwargs['invert']"], {}), "(img_filename, kwargs['final_size'], kwargs[\n 'brightness_threshold'], kwargs['invert'])\n", (1474, 1565), False, 'from kabuki import kabuki_mask\n'), ((1568, 1... |
#!/usr/bin/env python
r"""
The following parameters come from:
[1] <NAME>., <NAME>., <NAME>. & <NAME>.
Collisionless Isotropization of the Solar-Wind Protons By Compressive
Fluctuations and Plasma Instabilities. Astrophys. J. 831, 128 (2016).
for which the Bibtex entry is:
@article{Verscharen2016a,
... | [
"pandas.DataFrame",
"matplotlib.pyplot.FuncFormatter",
"pandas.MultiIndex.from_tuples",
"pandas.DataFrame.from_dict",
"matplotlib.colors.Normalize",
"matplotlib.patches.Rectangle",
"pandas.Index",
"collections.namedtuple",
"pandas.Series",
"matplotlib.cbook.normalize_kwargs",
"pandas.concat",
... | [((1184, 1240), 'pandas.Index', 'pd.Index', (["['AIC', 'FMW', 'MM', 'OFI']"], {'name': '"""Intability"""'}), "(['AIC', 'FMW', 'MM', 'OFI'], name='Intability')\n", (1192, 1240), True, 'import pandas as pd\n'), ((1254, 1301), 'pandas.Index', 'pd.Index', (["['a', 'b', 'c']"], {'name': '"""Fit Parameter"""'}), "(['a', 'b',... |
from abc import abstractmethod
import types
import numpy as np
import os
from multiprocessing import Pool
import schwimmbad
# from schwimmbad import SerialPool, MultiPool, MPIPool
from argparse import ArgumentParser
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import make_axes_locatable
from corner impo... | [
"utils.make_dir",
"argparse.ArgumentParser",
"numpy.abs",
"matplotlib.pyplot.suptitle",
"matplotlib.pyplot.subplot2grid",
"parameters.PARS_ORDER.items",
"matplotlib.pyplot.figure",
"numpy.mean",
"matplotlib.pyplot.tight_layout",
"os.path.join",
"zeus.EnsembleSampler",
"numpy.random.randn",
"... | [((528, 544), 'argparse.ArgumentParser', 'ArgumentParser', ([], {}), '()\n', (542, 544), False, 'from argparse import ArgumentParser\n'), ((20159, 20195), 'os.path.join', 'os.path.join', (['utils.TEST_DIR', '"""mcmc"""'], {}), "(utils.TEST_DIR, 'mcmc')\n", (20171, 20195), False, 'import os\n'), ((20200, 20222), 'utils.... |
"""
Aurora is using axelrod_aurora_test1 to reproduce Table 2 from the Axelrod paper.
"""
import sys
import dworp
import igraph
import logging
import numpy as np
import axelrod_aurora_test1
import pdb
import pickle as pkl
import time
# --- Constant Parameters ---
xdim = 10
ydim = 10
n_tsteps = 8000 # because we cycle... | [
"numpy.random.seed",
"axelrod_aurora_test1.AxelrodTerminator",
"logging.basicConfig",
"dworp.TwoStageSimulation",
"numpy.median",
"time.clock",
"axelrod_aurora_test1.AxelrodEnvironment",
"numpy.random.RandomState",
"numpy.random.randint",
"numpy.mean",
"pdb.set_trace",
"axelrod_aurora_test1.Ax... | [((516, 555), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.WARN'}), '(level=logging.WARN)\n', (535, 555), False, 'import logging\n'), ((793, 821), 'numpy.random.seed', 'np.random.seed', (['toplevelseed'], {}), '(toplevelseed)\n', (807, 821), True, 'import numpy as np\n'), ((1114, 1126), 'time.c... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import numpy as np
from scipy import integrate
import sympy as sp
sp.init_printing(use_unicode=True)
def stopFunCombined(t, s, lst, events, out=[]):
""" Universal event detection function that handles multiple events.
Intended for scipy.integrate.ode solo... | [
"numpy.asarray",
"sympy.init_printing",
"math.fabs",
"scipy.integrate.ode"
] | [((114, 148), 'sympy.init_printing', 'sp.init_printing', ([], {'use_unicode': '(True)'}), '(use_unicode=True)\n', (130, 148), True, 'import sympy as sp\n'), ((6746, 6775), 'scipy.integrate.ode', 'integrate.ode', (['model.equation'], {}), '(model.equation)\n', (6759, 6775), False, 'from scipy import integrate\n'), ((747... |
from __future__ import division, print_function
import sys, os, glob, time, warnings, gc
import numpy as np
# import matplotlib
# matplotlib.use("Agg")
# import matplotlib.pyplot as plt
from astropy.table import Table, vstack, hstack, join
import fitsio
# from astropy.io import fits
columns = ['SGA_ID', 'REF_CAT', 'G... | [
"fitsio.read",
"numpy.argsort"
] | [((361, 481), 'fitsio.read', 'fitsio.read', (['"""/global/cfs/cdirs/cosmo/data/legacysurvey/dr9/masking/SGA-ellipse-v3.0.kd.fits"""'], {'columns': 'columns'}), "(\n '/global/cfs/cdirs/cosmo/data/legacysurvey/dr9/masking/SGA-ellipse-v3.0.kd.fits'\n , columns=columns)\n", (372, 481), False, 'import fitsio\n'), ((48... |
from sklearn.metrics import classification_report, accuracy_score
from collections import OrderedDict
from privacy.analysis.rdp_accountant import compute_rdp
from privacy.analysis.rdp_accountant import get_privacy_spent
from privacy.optimizers import dp_optimizer
import tensorflow as tf
import numpy as np
import... | [
"argparse.ArgumentParser",
"tensorflow.reshape",
"privacy.optimizers.dp_optimizer.DPAdamGaussianOptimizer",
"tensorflow.estimator.Estimator",
"numpy.unique",
"tensorflow.keras.regularizers.l2",
"tensorflow.metrics.accuracy",
"privacy.analysis.rdp_accountant.get_privacy_spent",
"os.path.exists",
"n... | [((2559, 2622), 'tensorflow.keras.losses.sparse_categorical_crossentropy', 'tf.keras.losses.sparse_categorical_crossentropy', (['labels', 'logits'], {}), '(labels, logits)\n', (2606, 2622), True, 'import tensorflow as tf\n'), ((2642, 2669), 'tensorflow.reduce_mean', 'tf.reduce_mean', (['vector_loss'], {}), '(vector_los... |
import re
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from pandas.core.algorithms import mode
import pandas_datareader as web
import datetime as dt
from six import unichr
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras import models
from tensorflow.keras.layers import De... | [
"pandas_datareader.DataReader",
"matplotlib.pyplot.title",
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"tensorflow.keras.layers.Dropout",
"tensorflow.keras.layers.Dense",
"matplotlib.pyplot.legend",
"sklearn.preprocessing.MinMaxScaler",
"datetime.datetime",
"numpy.array",
"numpy.reshape"... | [((500, 523), 'datetime.datetime', 'dt.datetime', (['(2016)', '(1)', '(1)'], {}), '(2016, 1, 1)\n', (511, 523), True, 'import datetime as dt\n'), ((528, 545), 'datetime.datetime.now', 'dt.datetime.now', ([], {}), '()\n', (543, 545), True, 'import datetime as dt\n'), ((554, 611), 'pandas_datareader.DataReader', 'web.Dat... |
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from pathlib import Path
from seabreeze.spectrometers import Spectrometer
class OceanMea():
def __init__(self,intgtime=1000,ave=10):
self.intgtime = intgtime
self.ave = ave
self.spec = Spectrometer.from_first... | [
"pandas.DataFrame",
"numpy.zeros_like",
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"pandas.read_csv",
"time.sleep",
"pathlib.Path",
"seabreeze.spectrometers.Spectrometer.from_first_available"
] | [((5316, 5329), 'time.sleep', 'time.sleep', (['(5)'], {}), '(5)\n', (5326, 5329), False, 'import time\n'), ((5362, 5375), 'time.sleep', 'time.sleep', (['(3)'], {}), '(3)\n', (5372, 5375), False, 'import time\n'), ((297, 332), 'seabreeze.spectrometers.Spectrometer.from_first_available', 'Spectrometer.from_first_availabl... |
#-*-coding:utf-8-*-
import tensorflow as tf
import Data_helper
from utils.data_util import from_project_root
from tensorflow.contrib import learn
import numpy as np
from sklearn.metrics import f1_score
from sklearn.metrics import accuracy_score
from tqdm import tqdm
import pickle as pk
# ============================... | [
"tensorflow.contrib.learn.preprocessing.VocabularyProcessor.restore",
"tensorflow.train.import_meta_graph",
"sklearn.metrics.accuracy_score",
"tensorflow.Session",
"utils.data_util.from_project_root",
"tensorflow.ConfigProto",
"sklearn.metrics.f1_score",
"numpy.array",
"tensorflow.Graph",
"tensorf... | [((390, 485), 'tensorflow.flags.DEFINE_boolean', 'tf.flags.DEFINE_boolean', (['"""allow_soft_placement"""', '(True)', '"""Allow device soft device placement"""'], {}), "('allow_soft_placement', True,\n 'Allow device soft device placement')\n", (413, 485), True, 'import tensorflow as tf\n'), ((482, 575), 'tensorflow.... |
# Copyright (c) 2018-present, Facebook, Inc.
# All rights reserved.
#
# This source code is licensed under the license found in the
# LICENSE file in the root directory of this source tree.
#
import numpy as np
import pandas as pd
import copy
from common.quaternion import expmap_to_quaternion, qfix, qmul_np
from commo... | [
"copy.deepcopy",
"numpy.load",
"common.skeleton.Skeleton",
"common.quaternion.qmul_np",
"numpy.array",
"numpy.ascontiguousarray",
"numpy.concatenate"
] | [((439, 1497), 'common.skeleton.Skeleton', 'Skeleton', ([], {'offsets': '[[0.0, 0.0, 0.0], [-132.948591, 0.0, 0.0], [0.0, -442.894612, 0.0], [0.0, -\n 454.206447, 0.0], [0.0, 0.0, 162.767078], [0.0, 0.0, 74.999437], [\n 132.948826, 0.0, 0.0], [0.0, -442.894413, 0.0], [0.0, -454.20659, 0.0],\n [0.0, 0.0, 162.76... |
from typing import List
import numpy as np
import torch
from searl.neuroevolution.components.utils import Transition
from searl.rl_algorithms.components.wrappers import make_atari, wrap_deepmind, wrap_pytorch
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("train CUDA", device == torch.de... | [
"torch.LongTensor",
"torch.FloatTensor",
"searl.rl_algorithms.components.wrappers.wrap_pytorch",
"numpy.random.RandomState",
"numpy.var",
"searl.rl_algorithms.components.wrappers.wrap_deepmind",
"numpy.mean",
"torch.cuda.is_available",
"numpy.array",
"torch.device",
"searl.rl_algorithms.componen... | [((244, 269), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (267, 269), False, 'import torch\n'), ((312, 332), 'torch.device', 'torch.device', (['"""cuda"""'], {}), "('cuda')\n", (324, 332), False, 'import torch\n'), ((446, 491), 'numpy.random.RandomState', 'np.random.RandomState', (['config.s... |
# --------------------------------------------------------------------------------------------------
# Copyright (c) 2018 Microsoft Corporation
#
# 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 Softw... | [
"os.path.dirname",
"collections.deque",
"json.dumps",
"numpy.isclose",
"logging.getLogger",
"csv.DictWriter"
] | [((6846, 6871), 'collections.deque', 'deque', ([], {'maxlen': 'num_targets'}), '(maxlen=num_targets)\n', (6851, 6871), False, 'from collections import deque\n'), ((7992, 8019), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (8009, 8019), False, 'import logging\n'), ((8827, 8862), 'csv.Dic... |
import cv2
import numpy as np
class Color_Detection(object):
def __init__(self):
self.ColorStandard = np.array([[255, 0, 0], # red
[0, 0, 255], # blue
[0, 255, 0], # green
[0... | [
"cv2.cvtColor",
"numpy.zeros",
"numpy.array"
] | [((116, 180), 'numpy.array', 'np.array', (['[[255, 0, 0], [0, 0, 255], [0, 255, 0], [0, 255, 255]]'], {}), '([[255, 0, 0], [0, 0, 255], [0, 255, 0], [0, 255, 255]])\n', (124, 180), True, 'import numpy as np\n'), ((558, 652), 'numpy.array', 'np.array', (['[[120, 130, 160, 180], [15, 25, 85, 105], [30, 40, 200, 220], [80... |
import os
from scipy.io import loadmat, matlab
from scipy.signal import spectrogram, find_peaks, medfilt
import pandas as pd
import numpy as np
from joblib import Parallel, delayed
# remove these exercises from targets since there are no data samples
ignore_exercises = ['<Initial Activity>', 'Arm straight up', 'Invali... | [
"numpy.pad",
"numpy.maximum",
"numpy.abs",
"numpy.log",
"scipy.io.loadmat",
"pandas.read_csv",
"numpy.log2",
"scipy.signal.medfilt",
"numpy.hstack",
"numpy.diff",
"numpy.array",
"numpy.exp",
"scipy.signal.spectrogram",
"numpy.tile",
"numpy.arange"
] | [((483, 550), 'pandas.read_csv', 'pd.read_csv', (['"""codes/exercises.txt"""'], {'header': 'None', 'names': "['exercise']"}), "('codes/exercises.txt', header=None, names=['exercise'])\n", (494, 550), True, 'import pandas as pd\n'), ((3151, 3209), 'scipy.io.loadmat', 'loadmat', (['filename'], {'struct_as_record': '(Fals... |
# Conversion of Washington DC Taxi Trips (2017): https://www.kaggle.com/bvc5283/dc-taxi-trips
import argparse
import pandas as pd
import numpy as np
def convertData(inFile, outFile, startDate, endDate):
df = pd.read_csv(inFile)
df_out = df[['StartDateTime',
'OriginLatitude', 'OriginLongitude'... | [
"numpy.sum",
"argparse.ArgumentParser",
"pandas.read_csv",
"pandas.to_datetime",
"numpy.prod"
] | [((214, 233), 'pandas.read_csv', 'pd.read_csv', (['inFile'], {}), '(inFile)\n', (225, 233), True, 'import pandas as pd\n'), ((692, 780), 'pandas.to_datetime', 'pd.to_datetime', (["df_out['request time']"], {'format': '"""%Y-%m-%d %H:%M:%S"""', 'errors': '"""coerce"""'}), "(df_out['request time'], format='%Y-%m-%d %H:%M... |
import numpy as np
from sklearn import linear_model
reg = linear_model.LinearRegression(fit_intercept=True)
def get_doubling_time_via_regression(in_array):
''' Use a linear regression to approximate the doubling rate'''
y = np.array(in_array)
X = np.arange(-1,2).reshape(-1, 1)
assert len(in_... | [
"sklearn.linear_model.LinearRegression",
"numpy.array",
"numpy.arange"
] | [((59, 108), 'sklearn.linear_model.LinearRegression', 'linear_model.LinearRegression', ([], {'fit_intercept': '(True)'}), '(fit_intercept=True)\n', (88, 108), False, 'from sklearn import linear_model\n'), ((239, 257), 'numpy.array', 'np.array', (['in_array'], {}), '(in_array)\n', (247, 257), True, 'import numpy as np\n... |
"""Script filename: example_optFrog.py
Exemplary calculation of an optFrog trace for data obtained from
the numerical propagation of a short and intense few-cycle optical
pulse in presence of the refractive index profile of an endlessly single
mode photonic crystal fiber.
"""
import sys
import numpy as np
import nump... | [
"numpy.load",
"optfrog.optFrog",
"numpy.exp",
"figure.spectrogramFigure",
"numpy.sqrt"
] | [((851, 941), 'optfrog.optFrog', 'optFrog', (['t', 'Et', 'windowFuncGauss'], {'alpha': 'a0', 'tLim': '(tMin, tMax, 10)', 'wLim': '(wMin, wMax, 3)'}), '(t, Et, windowFuncGauss, alpha=a0, tLim=(tMin, tMax, 10), wLim=(wMin,\n wMax, 3))\n', (858, 941), False, 'from optfrog import optFrog\n'), ((934, 978), 'figure.spectr... |
import cv2
import numpy as np
import os
aaa = cv2.imread('seed0075.png')
aaa2 = cv2.imread('seed00752.png')
ddd = np.mean((aaa2 - aaa)**2)
print('ddd=%.6f' % ddd)
print()
| [
"cv2.imread",
"numpy.mean"
] | [((51, 77), 'cv2.imread', 'cv2.imread', (['"""seed0075.png"""'], {}), "('seed0075.png')\n", (61, 77), False, 'import cv2\n'), ((85, 112), 'cv2.imread', 'cv2.imread', (['"""seed00752.png"""'], {}), "('seed00752.png')\n", (95, 112), False, 'import cv2\n'), ((120, 146), 'numpy.mean', 'np.mean', (['((aaa2 - aaa) ** 2)'], {... |
import unittest
import numpy as np
from chainer0 import Variable, Chain
from chainer0.links import EmbedID, Linear
from chainer0.functions import sigmoid, tanh, mean_squared_error
from chainer0.optimizers import SGD
class TestEmbedModel(unittest.TestCase):
def test_train(self):
x = Variable(np.array([1, ... | [
"chainer0.functions.mean_squared_error",
"numpy.random.seed",
"chainer0.functions.tanh",
"chainer0.functions.sigmoid",
"numpy.array",
"chainer0.optimizers.SGD",
"numpy.random.rand",
"chainer0.links.EmbedID",
"chainer0.links.Linear"
] | [((670, 681), 'chainer0.optimizers.SGD', 'SGD', ([], {'lr': '(0.5)'}), '(lr=0.5)\n', (673, 681), False, 'from chainer0.optimizers import SGD\n'), ((722, 739), 'numpy.random.seed', 'np.random.seed', (['(0)'], {}), '(0)\n', (736, 739), True, 'import numpy as np\n'), ((769, 789), 'numpy.random.rand', 'np.random.rand', (['... |
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
class LICACritic(nn.Module):
def __init__(self, scheme, args):
super(LICACritic, self).__init__()
self.args = args
self.n_actions = args.n_actions
self.n_agents = args.n_agents
self.outp... | [
"torch.nn.ReLU",
"torch.bmm",
"numpy.prod",
"torch.nn.Linear"
] | [((1544, 1583), 'torch.nn.Linear', 'nn.Linear', (['self.state_dim', 'self.hid_dim'], {}), '(self.state_dim, self.hid_dim)\n', (1553, 1583), True, 'import torch.nn as nn\n'), ((2313, 2334), 'torch.bmm', 'torch.bmm', (['h', 'w_final'], {}), '(h, w_final)\n', (2322, 2334), False, 'import torch\n'), ((396, 421), 'numpy.pro... |
'''
Created with love by Sigmoid
@Author - <NAME> - <EMAIL>
'''
# Importing all libraries
import numpy as np
import pandas as pd
from scipy.stats import norm
import sys
from .erorrs import NotBinaryData, NoSuchColumn
def warn(*args, **kwargs):
pass
import warnings
warnings.warn = warn
class MT... | [
"pandas.DataFrame",
"numpy.random.uniform",
"numpy.random.seed",
"scipy.stats.norm.cdf",
"numpy.array",
"pandas.concat"
] | [((923, 948), 'numpy.random.seed', 'np.random.seed', (['self.seed'], {}), '(self.seed)\n', (937, 948), True, 'import numpy as np\n'), ((5630, 5687), 'pandas.DataFrame', 'pd.DataFrame', (['self.synthetic_data'], {'columns': 'self.X_columns'}), '(self.synthetic_data, columns=self.X_columns)\n', (5642, 5687), True, 'impor... |
#!/usr/bin/env python2
#coding: utf-8
# 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
#
# Unles... | [
"argparse.ArgumentParser",
"core.config.merge_cfg_from_file",
"cv2.VideoWriter_fourcc",
"collections.defaultdict",
"datasets.dummy_datasets.get_coco_dataset",
"cv2.rectangle",
"cv2.VideoWriter",
"cv2.imshow",
"sys.path.append",
"cv2.cvtColor",
"core.config.assert_and_infer_cfg",
"sys.setdefaul... | [((1268, 1316), 'sys.path.append', 'sys.path.append', (['"""/home/vpa/github/caffe2/build"""'], {}), "('/home/vpa/github/caffe2/build')\n", (1283, 1316), False, 'import sys\n'), ((1671, 1702), 'utils.c2.import_detectron_ops', 'c2_utils.import_detectron_ops', ([], {}), '()\n', (1700, 1702), True, 'import utils.c2 as c2_... |
"""Integration Test for local_implicit_grid + PDELayer."""
# pylint: disable=import-error, no-member, too-many-arguments, no-self-use
import unittest
import numpy as np
import torch
from parameterized import parameterized
from local_implicit_grid import query_local_implicit_grid
from implicit_net import ImNet
from pd... | [
"unittest.main",
"pde.PDELayer",
"implicit_net.ImNet",
"local_implicit_grid.query_local_implicit_grid",
"torch.rand",
"numpy.testing.assert_allclose"
] | [((3752, 3767), 'unittest.main', 'unittest.main', ([], {}), '()\n', (3765, 3767), False, 'import unittest\n'), ((2812, 2868), 'torch.rand', 'torch.rand', (['batch_size', 'grid_res', 'grid_res', 'grid_res', 'nc'], {}), '(batch_size, grid_res, grid_res, grid_res, nc)\n', (2822, 2868), False, 'import torch\n'), ((2889, 29... |
import os
import sys
import tensorflow as tf
import numpy as np
from model256 import LungSystem
from os.path import join as pjoin
import random
import logging
starting=False
logging.basicConfig(level=logging.INFO)
tf.app.flags.DEFINE_float("best_val_loss", float('inf'), "best val loss so far")
tf.app.flags.DEFINE... | [
"tensorflow.app.flags.DEFINE_float",
"tensorflow.gfile.Exists",
"numpy.load",
"numpy.save",
"logging.basicConfig",
"tensorflow.Session",
"logging.info",
"tensorflow.app.flags.DEFINE_string",
"sys.exit",
"tensorflow.app.flags.DEFINE_integer",
"tensorflow.app.run",
"os.listdir",
"tensorflow.tr... | [((178, 217), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (197, 217), False, 'import logging\n'), ((301, 400), 'tensorflow.app.flags.DEFINE_string', 'tf.app.flags.DEFINE_string', (['"""model"""', '"""unet"""', '"""Type of model to use: linear or cnn or simple... |
#!/usr/bin/env python
# encoding: utf-8
# Attention-Based Aspect-Based Sentiment Extraction 2 (ABABSE2).
#
# https://github.com/LucaZampierin/ABABSE
#
# Adapted from Trusca, Wassenberg, Frasincar and Dekker (2020). Changes have been made to adapt the methods
# to the current project and to adapt the scripts to... | [
"nn_layer.reduce_mean_with_len",
"nn_layer.softmax_layer",
"tensorflow.compat.v1.disable_eager_execution",
"tensorflow.matmul",
"tensorflow.ConfigProto",
"tensorflow.Variable",
"sklearn.metrics.f1_score",
"nn_layer.bi_dynamic_rnn_abse",
"utils.load_inputs_twitter",
"tensorflow.placeholder",
"ten... | [((1088, 1126), 'tensorflow.compat.v1.disable_eager_execution', 'tf.compat.v1.disable_eager_execution', ([], {}), '()\n', (1124, 1126), True, 'import tensorflow as tf\n'), ((1074, 1085), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (1083, 1085), False, 'import os, sys\n'), ((1790, 1827), 'tensorflow.nn.dropout', 'tf.nn.... |
import numpy as np
def function_for_pos(mass, mom):
return mom / mass
def function_for_mom(mass1, mass2, diff, dist):
return - mass1 * mass2 / dist ** 3 * diff
def compute_k(mass, pos, mom):
pos_k = [0] * len(pos)
mom_k = [0] * len(pos)
tmp_index = np.arange(len(pos))
index_j, index_i = np.... | [
"numpy.array",
"numpy.meshgrid",
"numpy.linalg.norm"
] | [((317, 350), 'numpy.meshgrid', 'np.meshgrid', (['tmp_index', 'tmp_index'], {}), '(tmp_index, tmp_index)\n', (328, 350), True, 'import numpy as np\n'), ((443, 494), 'numpy.linalg.norm', 'np.linalg.norm', (['(pos[index_i] - pos[index_j])'], {'axis': '(2)'}), '(pos[index_i] - pos[index_j], axis=2)\n', (457, 494), True, '... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Mar 18 20:55:39 2017
@author: <NAME>
"""
import NetBuilder as nb
import numpy as np
import sys
from sklearn.preprocessing import normalize as norm
def extract_data(filename):
with open(filename) as f:
data = np.loadtxt(f,delimiter=',',skipr... | [
"numpy.vectorize",
"NetBuilder.Network",
"sklearn.preprocessing.normalize",
"numpy.loadtxt",
"numpy.random.shuffle"
] | [((1696, 1722), 'numpy.vectorize', 'np.vectorize', (['change_zeros'], {}), '(change_zeros)\n', (1708, 1722), True, 'import numpy as np\n'), ((2671, 2719), 'NetBuilder.Network', 'nb.Network', ([], {'topology': 'topology', 'learningRate': '(0.01)'}), '(topology=topology, learningRate=0.01)\n', (2681, 2719), True, 'import... |
# coding=utf-8
# @Author : zhzhx2008
# @Date : 2019/12/29
# from:
# https://arxiv.org/abs/1611.01747，《A COMPARE-AGGREGATE MODEL FOR MATCHING TEXT SEQUENCES》
import warnings
import jieba
import numpy as np
from keras import Model, regularizers, constraints, initializers
from keras.callbacks import EarlyStopping... | [
"keras.backend.dot",
"numpy.random.seed",
"keras.preprocessing.sequence.pad_sequences",
"sklearn.model_selection.train_test_split",
"keras.regularizers.get",
"keras.backend.batch_dot",
"keras.backend.abs",
"keras.backend.relu",
"keras.backend.concatenate",
"keras.preprocessing.text.Tokenizer",
"... | [((538, 571), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (561, 571), False, 'import warnings\n'), ((585, 605), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (599, 605), True, 'import numpy as np\n'), ((7694, 7718), 'numpy.random.shuffle', 'np.rando... |
# %%
import rasterio
import pandas as pds
import numpy as np
import numpy.ma as ma
from sklearn.pipeline import Pipeline
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt
import seaborn
# %%
HI_RES = '30s'
LOW_RES... | [
"pandas.DataFrame",
"rasterio.open",
"sklearn.preprocessing.StandardScaler",
"numpy.corrcoef",
"sklearn.cluster.KMeans",
"sklearn.decomposition.PCA",
"seaborn.jointplot",
"numpy.ma.vstack",
"numpy.cov",
"numpy.ma.compress_rows"
] | [((1169, 1195), 'numpy.ma.compress_rows', 'ma.compress_rows', (['raw_rows'], {}), '(raw_rows)\n', (1185, 1195), True, 'import numpy.ma as ma\n'), ((1204, 1241), 'numpy.corrcoef', 'np.corrcoef', (['compressed'], {'rowvar': '(False)'}), '(compressed, rowvar=False)\n', (1215, 1241), True, 'import numpy as np\n'), ((1248, ... |
"""
.. module:: get_data_hlsp_everest
:synopsis: Returns EVEREST lightcurve data as a JSON string.
.. moduleauthor:: <NAME> <<EMAIL>>
"""
import collections
import numpy
from astropy.io import fits
from data_series import DataSeries
from parse_obsid_hlsp_everest import parse_obsid_hlsp_everest
#-----------------... | [
"numpy.isfinite",
"astropy.io.fits.open",
"collections.namedtuple",
"parse_obsid_hlsp_everest.parse_obsid_hlsp_everest",
"data_series.DataSeries"
] | [((1081, 1128), 'collections.namedtuple', 'collections.namedtuple', (['"""DataPoint"""', "['x', 'y']"], {}), "('DataPoint', ['x', 'y'])\n", (1103, 1128), False, 'import collections\n'), ((1449, 1480), 'parse_obsid_hlsp_everest.parse_obsid_hlsp_everest', 'parse_obsid_hlsp_everest', (['obsid'], {}), '(obsid)\n', (1473, 1... |
import numpy as np
from qcodes import Parameter, ArrayParameter
from .RemoteProcessWrapper import RPGWrappedBase, ensure_ndarray, get_remote
from .ExtendedDataItem import ExtendedDataItem
from .ColorMap import ColorMap
class HistogramLUTItem(RPGWrappedBase):
_base = "HistogramLUTItem"
def __init__(self, *arg... | [
"numpy.min",
"numpy.max"
] | [((4953, 4965), 'numpy.min', 'np.min', (['data'], {}), '(data)\n', (4959, 4965), True, 'import numpy as np\n'), ((4967, 4979), 'numpy.max', 'np.max', (['data'], {}), '(data)\n', (4973, 4979), True, 'import numpy as np\n')] |
import numpy as np
import time
import argparse
from rlkit.envs.wrappers import NormalizedBoxEnv
parser = argparse.ArgumentParser()
parser.add_argument('--exp_name', type=str, default='Ant')
parser.add_argument('--ml', type=int, default=1000)
args = parser.parse_args()
import gym
env = NormalizedBoxEnv(gym.make(args.e... | [
"gym.make",
"argparse.ArgumentParser",
"numpy.argmax",
"time.sleep",
"numpy.max",
"numpy.mean"
] | [((106, 131), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (129, 131), False, 'import argparse\n'), ((305, 336), 'gym.make', 'gym.make', (["(args.exp_name + '-v2')"], {}), "(args.exp_name + '-v2')\n", (313, 336), False, 'import gym\n'), ((756, 771), 'time.sleep', 'time.sleep', (['(0.1)'], {})... |
#!/usr/bin/env python
import rospy
import math
import numpy as np
import tf
import tf2_ros
import geometry_msgs.msg
from geometry_msgs.msg import Point
import geometry_msgs.msg
#import transformation_py.transformation as transformation
class FieldMapPublisher(object):
def __init__(self):
rospy.init_node('... | [
"tf2_ros.StaticTransformBroadcaster",
"rospy.Time.now",
"numpy.asarray",
"rospy.Rate",
"rospy.get_param",
"rospy.is_shutdown",
"rospy.init_node",
"rospy.get_name",
"tf.transformations.quaternion_from_matrix",
"tf.TransformListener"
] | [((303, 333), 'rospy.init_node', 'rospy.init_node', (['"""GPS_tf_node"""'], {}), "('GPS_tf_node')\n", (318, 333), False, 'import rospy\n'), ((489, 504), 'rospy.Rate', 'rospy.Rate', (['(1.0)'], {}), '(1.0)\n', (499, 504), False, 'import rospy\n'), ((573, 683), 'rospy.get_param', 'rospy.get_param', (['"""map_file"""'], {... |
"""Configure common variables and data locations."""
from pathlib import Path
import numpy as np
# Path definitions
# -----------------------------------------------------------------------------
# if several external hard drives are used, pick the correct one by changing the index
external_name = {0: "LinuxDataApp... | [
"pathlib.Path",
"numpy.arange"
] | [((705, 748), 'pathlib.Path', 'Path', (['"""/home/stefanappelhoff/Desktop/eComp"""'], {}), "('/home/stefanappelhoff/Desktop/eComp')\n", (709, 748), False, 'from pathlib import Path\n'), ((769, 844), 'pathlib.Path', 'Path', (['f"""/media/stefanappelhoff/{external_name}/eeg_compression/ecomp_data/"""'], {}), "(f'/media/s... |
import numpy as np
from collections import Counter
from scipy.stats.stats import ttest_1samp, ttest_ind, pearsonr
from numpy.random.mtrand import permutation
from sklearn.metrics import mean_squared_error
from mvpa_itab.utils import progress
def cross_validate(ds, clf, partitioner, permuted_labels):
partition... | [
"mvpa_itab.utils.progress",
"numpy.sum",
"numpy.abs",
"scipy.stats.stats.ttest_ind",
"scipy.stats.stats.ttest_1samp",
"scipy.stats.stats.pearsonr",
"numpy.ix_",
"numpy.float",
"numpy.isnan",
"numpy.random.mtrand.permutation",
"numpy.mean",
"numpy.array",
"numpy.random.permutation",
"collec... | [((1132, 1152), 'numpy.array', 'np.array', (['accuracies'], {}), '(accuracies)\n', (1140, 1152), True, 'import numpy as np\n'), ((1467, 1487), 'numpy.unique', 'np.unique', (['ds.chunks'], {}), '(ds.chunks)\n', (1476, 1487), True, 'import numpy as np\n'), ((11742, 11761), 'numpy.array', 'np.array', (['null_dist'], {}), ... |
from scipy.integrate import solve_ivp, quad
from sidmpy.Profiles.halo_density_profiles import TNFWprofile
from scipy.interpolate import interp1d
import numpy as np
from scipy.optimize import fsolve
def compute_r1(rhos, rs, vdispersion_halo, cross_section_class, halo_age):
"""
:param rhos: density normalizati... | [
"numpy.roots",
"numpy.absolute",
"numpy.isreal",
"numpy.ones_like",
"numpy.log",
"scipy.integrate.quad",
"sidmpy.Profiles.halo_density_profiles.TNFWprofile",
"scipy.integrate.solve_ivp",
"scipy.optimize.fsolve",
"numpy.exp",
"numpy.linspace",
"scipy.interpolate.interp1d",
"numpy.log10",
"n... | [((1106, 1129), 'numpy.roots', 'np.roots', (['[1, 2, 1, -k]'], {}), '([1, 2, 1, -k])\n', (1114, 1129), True, 'import numpy as np\n'), ((1736, 1760), 'scipy.optimize.fsolve', 'fsolve', (['_func_to_min', 'rs'], {}), '(_func_to_min, rs)\n', (1742, 1760), False, 'from scipy.optimize import fsolve\n'), ((2323, 2370), 'numpy... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue May 14 14:03:56 2019
@author: bmoseley
"""
# This code is my own python implementation of the SEISMIC_CPML library here: https://github.com/geodynamics/seismic_cpml/blob/master/seismic_CPML_2D_pressure_second_order.f90
import matplotlib.pyplot as plt
... | [
"matplotlib.pyplot.subplot",
"matplotlib.pyplot.show",
"numpy.log",
"matplotlib.pyplot.plot",
"numpy.abs",
"matplotlib.pyplot.suptitle",
"numpy.zeros",
"numpy.ones",
"numpy.max",
"matplotlib.pyplot.figure",
"numpy.exp"
] | [((798, 814), 'numpy.max', 'np.max', (['velocity'], {}), '(velocity)\n', (804, 814), True, 'import numpy as np\n'), ((4386, 4413), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': 'figsize'}), '(figsize=figsize)\n', (4396, 4413), True, 'import matplotlib.pyplot as plt\n'), ((4418, 4435), 'matplotlib.pyplot.su... |
import numpy as np
import wave
from scipy.io.wavfile import read, write
import struct
from numpy.fft import fft, fftshift, ifft
def spectrum_shifting( x, shift, fs ):
X = fft( x )
N = fs
N_half = int( fs / 2 )
Y = np.zeros( N, dtype = 'complex' )
for i in range( N_half ):
if i + shift >= 0 and i + shift <= N_ha... | [
"numpy.fft.ifft",
"wave.open",
"numpy.fft.fft",
"numpy.zeros",
"scipy.io.wavfile.read"
] | [((173, 179), 'numpy.fft.fft', 'fft', (['x'], {}), '(x)\n', (176, 179), False, 'from numpy.fft import fft, fftshift, ifft\n'), ((219, 247), 'numpy.zeros', 'np.zeros', (['N'], {'dtype': '"""complex"""'}), "(N, dtype='complex')\n", (227, 247), True, 'import numpy as np\n'), ((458, 465), 'numpy.fft.ifft', 'ifft', (['Y'], ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.