code stringlengths 31 1.05M | apis list | extract_api stringlengths 97 1.91M |
|---|---|---|
import gym
import numpy as np
import matplotlib.pyplot as plt
def sarsa(env, alpha=0.1, gamma=0.9, epsilon=0.1, num_ep=int(1e4)):
# Initalize Q arbitrarily, but make terminal states = 0
Q = np.random.random((env.observation_space.n, env.action_space.n))
env_t_states = ((env.desc == b'H') | (env.desc == b'... | [
"matplotlib.pyplot.show",
"gym.make",
"numpy.power",
"numpy.zeros",
"numpy.random.random",
"numpy.arange",
"numpy.random.randint"
] | [((2506, 2547), 'gym.make', 'gym.make', (['"""FrozenLake-v0"""'], {'map_name': '"""8x8"""'}), "('FrozenLake-v0', map_name='8x8')\n", (2514, 2547), False, 'import gym\n'), ((2599, 2624), 'numpy.arange', 'np.arange', (['(0.01)', '(0.9)', '(0.1)'], {}), '(0.01, 0.9, 0.1)\n', (2608, 2624), True, 'import numpy as np\n'), ((... |
from PIL import Image
import numpy as np
import physics
def render(size=3, resolution=(800,800)):
'''
size is -xmin, xmax, ymin, ymax
resolution is (width, height)
'''
imgWidth, imgHeight = resolution
xmin = -size
xmax = size
ymin = -size
ymax = size
if imgWidth > imgHeight:
... | [
"PIL.Image.fromarray",
"physics.World",
"numpy.array",
"numpy.linspace"
] | [((473, 506), 'numpy.linspace', 'np.linspace', (['xmin', 'xmax', 'imgWidth'], {}), '(xmin, xmax, imgWidth)\n', (484, 506), True, 'import numpy as np\n'), ((515, 549), 'numpy.linspace', 'np.linspace', (['ymin', 'ymax', 'imgHeight'], {}), '(ymin, ymax, imgHeight)\n', (526, 549), True, 'import numpy as np\n'), ((563, 579)... |
from __future__ import print_function
__author__ = "<NAME>, <NAME> and <NAME>"
__maintainer__ = "<NAME>"
__email__ = "<EMAIL>"
import yaml
import numpy as np
class IntrinsicCalibration:
"""
Intrinsic calibration
Attributes:
fx(float): Focal length in x
fy(float): Focal length y
... | [
"yaml.load",
"numpy.reshape"
] | [((6060, 6077), 'yaml.load', 'yaml.load', (['infile'], {}), '(infile)\n', (6069, 6077), False, 'import yaml\n'), ((6099, 6153), 'numpy.reshape', 'np.reshape', (["data['data']", "(data['rows'], data['cols'])"], {}), "(data['data'], (data['rows'], data['cols']))\n", (6109, 6153), True, 'import numpy as np\n')] |
import numpy as np
class Solution:
def isValid(self, s: str) -> bool:
flag=True
x=np.empty(0)
count={'(':0, ')':0, '{':0, '}':0, '[':0, ']':0}
brack={'(':[], ')':[], '{':[], '}':[], '[':[], ']':[]}
for i in range(len(s)):
count[s[i]]=count.get(s[i])+1
... | [
"numpy.empty"
] | [((102, 113), 'numpy.empty', 'np.empty', (['(0)'], {}), '(0)\n', (110, 113), True, 'import numpy as np\n')] |
import torch
from torchvision import models
import cv2
from matplotlib import pyplot as plt
import numpy as np
import json
# 恢复保存点
checkpoint_path = 'checkpoint.pth'
checkpoint = torch.load(checkpoint_path)
# 查看gpu状态
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
model = models.resnet152()
n... | [
"matplotlib.pyplot.show",
"cv2.cvtColor",
"matplotlib.pyplot.imshow",
"torch.load",
"numpy.transpose",
"cv2.imread",
"torch.nn.Softmax",
"numpy.array",
"torch.cuda.is_available",
"torch.nn.Linear",
"torch.max",
"torch.tensor",
"torchvision.models.resnet152",
"cv2.resize"
] | [((180, 207), 'torch.load', 'torch.load', (['checkpoint_path'], {}), '(checkpoint_path)\n', (190, 207), False, 'import torch\n'), ((300, 318), 'torchvision.models.resnet152', 'models.resnet152', ([], {}), '()\n', (316, 318), False, 'from torchvision import models\n'), ((400, 438), 'torch.nn.Linear', 'torch.nn.Linear', ... |
import numpy as np
# tests:
file_sizes = np.array([100, 500, 1000, 10000])
learning_rates = np.array([ 2 ** i for i in range(-4,6) ])
relaxation = np.array([ 0.05, 0.1, 0.2, 0.4, 0.8 ])
number_of_hidden_layers = np.array([ 0, 1, 2, 3, 4 ])
number_of_neurons_in_layer = np.array([ 0, 1, 2, 3, 4 ])
activation_functions = ... | [
"numpy.array"
] | [((41, 74), 'numpy.array', 'np.array', (['[100, 500, 1000, 10000]'], {}), '([100, 500, 1000, 10000])\n', (49, 74), True, 'import numpy as np\n'), ((147, 183), 'numpy.array', 'np.array', (['[0.05, 0.1, 0.2, 0.4, 0.8]'], {}), '([0.05, 0.1, 0.2, 0.4, 0.8])\n', (155, 183), True, 'import numpy as np\n'), ((212, 237), 'numpy... |
import numpy as np
from engine.gl import VAOMesh, GL_TRIANGLE_STRIP
from engine.gui.adaptive import ResizeModes, AlignModes
from engine.gui.base import BaseElement
from engine.gui.typedefs import vec_type, nullable_vec_type, cvec
class RoundedRect(BaseElement):
def __init__(self, parent: 'BaseElement', pos: vec_... | [
"engine.gl.VAOMesh",
"numpy.dtype",
"numpy.zeros",
"numpy.sin",
"numpy.cos",
"engine.gui.typedefs.cvec"
] | [((327, 333), 'engine.gui.typedefs.cvec', 'cvec', ([], {}), '()\n', (331, 333), False, 'from engine.gui.typedefs import vec_type, nullable_vec_type, cvec\n'), ((673, 787), 'engine.gl.VAOMesh', 'VAOMesh', (['[0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1]', '[0, 1, 2, 2, 3, 0]', '(2, 2)'], {'mode': 'GL_TRIANGLE_STRIP'}... |
import os
def calculate_non_empty_dir_num(type='train'):
dirs = next(os.walk('data/' + type))[1]
empty_dirs = [x for x in dirs if not os.listdir('data/' + type + "/" + x)]
empty_dirs = set(empty_dirs)
# print(empty_dirs)
# print(len(empty_dirs) / len(dirs))
# print(len(dirs) - len(empty_dir... | [
"os.remove",
"numpy.random.seed",
"pandas.read_csv",
"os.walk",
"numpy.random.choice",
"collections.Counter",
"os.listdir"
] | [((1639, 1670), 'pandas.read_csv', 'pd.read_csv', (['"""splits/train.csv"""'], {}), "('splits/train.csv')\n", (1650, 1670), True, 'import pandas as pd\n'), ((1684, 1714), 'pandas.read_csv', 'pd.read_csv', (['"""splits/test.csv"""'], {}), "('splits/test.csv')\n", (1695, 1714), True, 'import pandas as pd\n'), ((1727, 175... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Jul 3 17:14:53 2019
@author: liuhongbing
"""
import pandas as pd
import numpy as np
from scipy import stats
from sklearn.metrics import precision_score, recall_score, f1_score, confusion_matrix, roc_curve, auc
import tensorflow as tf
from sklearn.mode... | [
"numpy.argmax",
"pandas.read_csv",
"numpy.empty",
"sklearn.model_selection.train_test_split",
"tensorflow.reshape",
"tensorflow.matmul",
"sklearn.metrics.f1_score",
"numpy.mean",
"tensorflow.Variable",
"tensorflow.truncated_normal",
"numpy.unique",
"numpy.std",
"tensorflow.placeholder",
"t... | [((6684, 6781), 'tensorflow.placeholder', 'tf.placeholder', (['tf.float32'], {'shape': '[None, ccc.input_height, ccc.input_width, ccc.num_channels]'}), '(tf.float32, shape=[None, ccc.input_height, ccc.input_width,\n ccc.num_channels])\n', (6698, 6781), True, 'import tensorflow as tf\n'), ((6780, 6836), 'tensorflow.p... |
from dataclasses import dataclass
from typing import Sequence, Union
import numpy as np
Floats = Union[Sequence[float], np.ndarray]
@dataclass
class RegressionData:
targets: np.ndarray
predictions: np.ndarray
def __init__(
self, targets: Floats, predictions: Floats,
):
self.targets ... | [
"numpy.asarray"
] | [((322, 341), 'numpy.asarray', 'np.asarray', (['targets'], {}), '(targets)\n', (332, 341), True, 'import numpy as np\n'), ((369, 392), 'numpy.asarray', 'np.asarray', (['predictions'], {}), '(predictions)\n', (379, 392), True, 'import numpy as np\n')] |
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
# Copyright © 2017 <NAME> <<EMAIL>>
#
# Distributed under terms of the MIT license.
from __future__ import unicode_literals
from datetime import datetime
import numpy as np
import logging
import os
import json
import tensorflow as tf
class SimpleSeq2... | [
"json.dump",
"tensorflow.contrib.rnn.GRUCell",
"os.path.join",
"tensorflow.train.Saver",
"tensorflow.global_variables_initializer",
"tensorflow.reset_default_graph",
"tensorflow.train.RMSPropOptimizer",
"tensorflow.Session",
"numpy.ones",
"tensorflow.placeholder",
"tensorflow.contrib.rnn.BasicLS... | [((770, 794), 'tensorflow.reset_default_graph', 'tf.reset_default_graph', ([], {}), '()\n', (792, 794), True, 'import tensorflow as tf\n'), ((2299, 2322), 'tensorflow.placeholder', 'tf.placeholder', (['tf.bool'], {}), '(tf.bool)\n', (2313, 2322), True, 'import tensorflow as tf\n'), ((4129, 4145), 'tensorflow.train.Save... |
#
# demo_statistics.py
#
import numpy
import random
import statistics
import matplotlib.pyplot as plt
'''
Calculate the mean, mode, median, standard deviation and variance.
'''
data = numpy.random.normal(1, 0.5, 10000)
mean = statistics.mean(data)
mode = statistics.mode(data)
median = statistics.median(data)
std = ... | [
"statistics.median",
"matplotlib.pyplot.show",
"matplotlib.pyplot.hist",
"random.uniform",
"statistics.covariance",
"statistics.correlation",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.ylabel",
"statistics.standard_deviation",
"statistics.mean",
"numpy.random.normal",
"statistics.variance... | [((187, 221), 'numpy.random.normal', 'numpy.random.normal', (['(1)', '(0.5)', '(10000)'], {}), '(1, 0.5, 10000)\n', (206, 221), False, 'import numpy\n'), ((230, 251), 'statistics.mean', 'statistics.mean', (['data'], {}), '(data)\n', (245, 251), False, 'import statistics\n'), ((259, 280), 'statistics.mode', 'statistics.... |
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import os
import random
# War, Action, Horror, Children, Film-Noir, Drama, Crime, Adventure, Sci-Fi, Thriller, Mystery, Comedy,
# Western, Fantasy, Animation, Documentary, Romance, IMAX, (no genres listed), Musical
tags = ['War',
... | [
"pandas.DataFrame",
"numpy.zeros_like",
"pandas.read_csv",
"random.shuffle",
"numpy.random.randint",
"numpy.array"
] | [((2692, 2714), 'numpy.zeros_like', 'np.zeros_like', (['centers'], {}), '(centers)\n', (2705, 2714), True, 'import numpy as np\n'), ((2764, 2786), 'numpy.zeros_like', 'np.zeros_like', (['centers'], {}), '(centers)\n', (2777, 2786), True, 'import numpy as np\n'), ((4080, 4110), 'pandas.read_csv', 'pd.read_csv', (['"""da... |
from distutils.core import setup, Extension
from Cython.Build import cythonize
import numpy as np
setup(ext_modules=cythonize(Extension(
'utils.rank_cylib.rank_cy',
sources=['utils/rank_cylib/rank_cy.pyx'],
language='c',
include_dirs=[np.get_include()],
library_dirs=[],
libraries=[],
extra_... | [
"numpy.get_include"
] | [((252, 268), 'numpy.get_include', 'np.get_include', ([], {}), '()\n', (266, 268), True, 'import numpy as np\n')] |
#!/usr/bin/python
# coding=utf-8
import cv2, os
import numpy as np
# 获取数据集
# 参数: datadirs:数据目录, labels:数据目录对应的标签, descriptor:特征描述器, size:图片归一化尺寸(通常是2的n次方, 比如(64,64)), kwargs:描述器计算特征的附加参数
# 返回值, descs:特征数据, labels:标签数据
def getDataset(datadirs, labels, descriptor, size, **kwargs):
# 获取训练数据
# 参数: path:图片目录, l... | [
"cv2.resize",
"numpy.count_nonzero",
"os.walk",
"cv2.ml.SVM_load",
"numpy.hstack",
"cv2.imread",
"numpy.array",
"cv2.HOGDescriptor",
"os.path.join",
"numpy.vstack"
] | [((1832, 1877), 'os.path.join', 'join', (['base_train_dir', '"""tgse-20191114-two.dat"""'], {}), "(base_train_dir, 'tgse-20191114-two.dat')\n", (1836, 1877), False, 'from os.path import join\n'), ((2080, 2191), 'cv2.HOGDescriptor', 'cv2.HOGDescriptor', ([], {'_winSize': '(64, 64)', '_blockSize': '(16, 16)', '_blockStri... |
# The Clear BSD License
#
# Copyright (c) 2021 <NAME> and the NuSpaceSim Team
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted (subject to the limitations in the disclaimer
# below) provided that the following conditions are met:
#
# * Redi... | [
"h5py.File",
"astropy.io.registry.register_writer",
"astropy.table.Table",
"astropy.io.registry.register_identifier",
"numpy.count_nonzero",
"astropy.io.registry.read",
"astropy.io.registry.write",
"astropy.io.registry.UnifiedReadWriteMethod",
"astropy.io.registry.register_reader",
"astropy.io.fit... | [((11384, 11446), 'astropy.io.registry.register_reader', 'registry.register_reader', (['"""fits"""', 'NssGrid', 'fits_nssgrid_reader'], {}), "('fits', NssGrid, fits_nssgrid_reader)\n", (11408, 11446), False, 'from astropy.io import fits, registry\n'), ((11447, 11509), 'astropy.io.registry.register_writer', 'registry.re... |
import importlib
import gc
import os
import platform as platformModule
import sys
import time
import re
import traceback
from functools import partial
import numpy as np
from .GameBackend import GameBackNames, Keyboard, Event, InputMode
from PyEngine3D.Common import logger, log_level, COMMAND, VIDEO_RESIZE_TIME
from ... | [
"PyEngine3D.Render.RenderTargetManager.instance",
"PyEngine3D.Common.logger.info",
"PyEngine3D.Render.Renderer.instance",
"gc.collect",
"PyEngine3D.ResourceManager.ResourceManager.instance",
"PyEngine3D.Render.Renderer_Basic.instance",
"PyEngine3D.Render.RenderOptionManager.instance",
"PyEngine3D.UI.V... | [((2938, 2969), 'PyEngine3D.Utilities.Config', 'Config', (['"""config.ini"""', 'log_level'], {}), "('config.ini', log_level)\n", (2944, 2969), False, 'from PyEngine3D.Utilities import Singleton, GetClassName, Config, Profiler\n'), ((3718, 3744), 'PyEngine3D.UI.ViewportManager.instance', 'ViewportManager.instance', ([],... |
# -*- coding: utf-8 -*-
## @package inversetoon.core.transform
#
# Transform functions.
# @author tody
# @date 2015/07/30
import numpy as np
epsilon = 1e-10
def rotateVector(a, x, cos_t, sin_t):
p = np.dot(a, x) * a
q = x - p
r = np.cross(x, a)
x_new = p + cos_t * q + sin_t * r
... | [
"numpy.dot",
"numpy.linalg.norm",
"numpy.cross",
"numpy.array"
] | [((263, 277), 'numpy.cross', 'np.cross', (['x', 'a'], {}), '(x, a)\n', (271, 277), True, 'import numpy as np\n'), ((382, 404), 'numpy.cross', 'np.cross', (['v_to', 'v_from'], {}), '(v_to, v_from)\n', (390, 404), True, 'import numpy as np\n'), ((417, 434), 'numpy.linalg.norm', 'np.linalg.norm', (['a'], {}), '(a)\n', (43... |
####################################################################################
# Author:- <NAME>
# Task:- Face recognition
# DIP project
####################################################################################
# Import the various libraries
import numpy as np
import cv2
import os
def faceDetectio... | [
"cv2.face.LBPHFaceRecognizer_create",
"cv2.putText",
"os.path.basename",
"cv2.cvtColor",
"os.walk",
"cv2.imread",
"numpy.array",
"cv2.rectangle",
"cv2.CascadeClassifier",
"os.path.join"
] | [((397, 439), 'cv2.cvtColor', 'cv2.cvtColor', (['test_img', 'cv2.COLOR_BGR2GRAY'], {}), '(test_img, cv2.COLOR_BGR2GRAY)\n', (409, 439), False, 'import cv2\n'), ((520, 644), 'cv2.CascadeClassifier', 'cv2.CascadeClassifier', (['"""/home/manas/Documents/ImageProcessing/project/faceRec/haarcascade_frontalface_default.xml""... |
# Copyright 2017 <NAME>. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agree... | [
"speecht.evaluation.EvalStatistics",
"curses.wrapper",
"tensorflow.Session",
"random.choice",
"numpy.random.normal",
"bisect.insort"
] | [((2043, 2077), 'numpy.random.normal', 'np.random.normal', ([], {'loc': '(0)', 'scale': 'std'}), '(loc=0, scale=std)\n', (2059, 2077), True, 'import numpy as np\n'), ((2938, 2954), 'speecht.evaluation.EvalStatistics', 'EvalStatistics', ([], {}), '()\n', (2952, 2954), False, 'from speecht.evaluation import Evaluation, E... |
"""
fully connected layer
"""
import numpy as np
from . import layer
class FcLayer(layer.Layer):
layer_name = "fc"
layer_type = "hidden"
def __init__(self, num_neurons):
super().__init__()
self.num_neurons = num_neurons
self.parameters = ["weights", "bias"]
def forward_c... | [
"numpy.sum",
"numpy.random.randn",
"numpy.square",
"numpy.transpose",
"numpy.zeros",
"numpy.dot"
] | [((1165, 1196), 'numpy.zeros', 'np.zeros', (['(self.num_neurons, 1)'], {}), '((self.num_neurons, 1))\n', (1173, 1196), True, 'import numpy as np\n'), ((1220, 1248), 'numpy.zeros', 'np.zeros', (['self.weights.shape'], {}), '(self.weights.shape)\n', (1228, 1248), True, 'import numpy as np\n'), ((1270, 1295), 'numpy.zeros... |
from func_get_image_matrix import *
from func_save_edf_image import *
from func_generate_mask import *
import numpy as np
import sys
### This routine appy three function:
### 1) get_image_matrix: gets the matrix of the calibration image from h5 file
### 2) save_edf_image: saves the calibration
### 3) mask: ge... | [
"numpy.shape"
] | [((1075, 1097), 'numpy.shape', 'np.shape', (['image_matrix'], {}), '(image_matrix)\n', (1083, 1097), True, 'import numpy as np\n')] |
# coding: utf-8
# In[1]:
import time
from matplotlib import pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
import ase.dft.kpoints as kpt
timestart = time.time()
# In[2]:
def dij(i, j):
if i == j:
return 1
else:
return 0
# In[3]:
#initialize variables
a = 10.26
... | [
"numpy.conj",
"numpy.size",
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"numpy.asarray",
"numpy.allclose",
"matplotlib.pyplot.axis",
"time.time",
"numpy.linalg.eigh",
"ase.dft.kpoints.get_bandpath",
"numpy.array",
"numpy.dot",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",... | [((177, 188), 'time.time', 'time.time', ([], {}), '()\n', (186, 188), False, 'import time\n'), ((598, 614), 'numpy.asarray', 'np.asarray', (['rlv1'], {}), '(rlv1)\n', (608, 614), True, 'import numpy as np\n'), ((622, 638), 'numpy.asarray', 'np.asarray', (['rlv2'], {}), '(rlv2)\n', (632, 638), True, 'import numpy as np\... |
# coding: utf-8
import numpy
# 一维矩阵
vector = numpy.array([5, 10, 15, 20])
equal_to_ten_and_five = (vector == 10) & (vector == 5)
print(equal_to_ten_and_five) # [False False False False]
equal_to_ten_and_five = (vector == 10) | (vector == 5)
print(equal_to_ten_and_five) # [ True True False False]
equal_to_ten_and_f... | [
"numpy.array"
] | [((47, 75), 'numpy.array', 'numpy.array', (['[5, 10, 15, 20]'], {}), '([5, 10, 15, 20])\n', (58, 75), False, 'import numpy\n'), ((432, 486), 'numpy.array', 'numpy.array', (['[[5, 10, 15], [20, 25, 30], [35, 40, 45]]'], {}), '([[5, 10, 15], [20, 25, 30], [35, 40, 45]])\n', (443, 486), False, 'import numpy\n')] |
import numpy as np
import pandas as pd
import pytest
import warnings
from sklearn.datasets import fetch_20newsgroups
from pytorch_widedeep.preprocessing import TextPreprocessor
texts = np.random.choice(fetch_20newsgroups().data, 10)
df = pd.DataFrame({'texts':texts})
processor = TextPreprocessor(min_freq=0)
X_text = ... | [
"pandas.DataFrame",
"sklearn.datasets.fetch_20newsgroups",
"numpy.arange",
"pytorch_widedeep.preprocessing.TextPreprocessor"
] | [((240, 270), 'pandas.DataFrame', 'pd.DataFrame', (["{'texts': texts}"], {}), "({'texts': texts})\n", (252, 270), True, 'import pandas as pd\n'), ((282, 310), 'pytorch_widedeep.preprocessing.TextPreprocessor', 'TextPreprocessor', ([], {'min_freq': '(0)'}), '(min_freq=0)\n', (298, 310), False, 'from pytorch_widedeep.pre... |
import numpy as np
import scipy.sparse as sp
import gcn.utils as gut
class BasicWeighting:
def __init__(self, w_id):
self.description = "All edges are weighted as 1"
self.id = w_id
self.weights = []
def weights_for(self, idx1, idx2, args):
self.weights.append(1)
def post_... | [
"numpy.sum",
"numpy.log2",
"numpy.asarray",
"scipy.sparse.coo_matrix",
"numpy.array",
"numpy.exp"
] | [((369, 411), 'numpy.asarray', 'np.asarray', (['self.weights'], {'dtype': 'np.float32'}), '(self.weights, dtype=np.float32)\n', (379, 411), True, 'import numpy as np\n'), ((463, 570), 'scipy.sparse.coo_matrix', 'sp.coo_matrix', (["(self.weights, (args['edges'][:, 0], args['edges'][:, 1]))"], {'shape': '(num_nodes, num_... |
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
def get_activation(name, inplace=True):
if name == 'relu': return nn.ReLU(inplace=inplace)
if name == 'lrelu': return nn.LeakyReLU(0.1, inplace=inplace)
if name == 'tanh': return nn.Tanh()
if name == 'sigmoid': retur... | [
"torch.nn.AdaptiveAvgPool2d",
"torch.nn.ReLU",
"torch.nn.ConvTranspose2d",
"torch.nn.Sequential",
"torch.nn.Tanh",
"torch.nn.Conv2d",
"torch.nn.InstanceNorm2d",
"torch.nn.BatchNorm2d",
"torch.nn.Linear",
"torch.nn.MaxPool2d",
"torch.nn.LeakyReLU",
"numpy.sqrt",
"torch.nn.Sigmoid"
] | [((845, 871), 'torch.nn.Linear', 'nn.Linear', (['*args'], {}), '(*args, **kwargs)\n', (854, 871), True, 'import torch.nn as nn\n'), ((1015, 1041), 'torch.nn.Conv2d', 'nn.Conv2d', (['*args'], {}), '(*args, **kwargs)\n', (1024, 1041), True, 'import torch.nn as nn\n'), ((1194, 1229), 'torch.nn.ConvTranspose2d', 'nn.ConvTr... |
"""An example to run of the minitaur gym environment with virtual-constraints-based gaits.
The bezierdata_legspace file has all the gait coefficients data.
To run a single gait, use the HZDPolicy() function. (set --env==0 from cmd line)
To run multiple gaits succesively, use GaitLibraryPolicy() function. (set --en... | [
"csv.reader",
"argparse.ArgumentParser",
"scipy.special.comb",
"pybullet_envs.minitaur.envs.env_randomizers.minitaur_env_randomizer.MinitaurEnvRandomizer",
"matplotlib.pyplot.figure",
"os.sys.path.insert",
"os.path.join",
"numpy.multiply",
"os.path.dirname",
"numpy.cumsum",
"numpy.loadtxt",
"p... | [((749, 781), 'os.sys.path.insert', 'os.sys.path.insert', (['(0)', 'parentdir'], {}), '(0, parentdir)\n', (767, 781), False, 'import os\n'), ((1963, 1983), 'numpy.zeros', 'np.zeros', (['NUM_MOTORS'], {}), '(NUM_MOTORS)\n', (1971, 1983), True, 'import numpy as np\n'), ((2272, 2292), 'numpy.zeros', 'np.zeros', (['NUM_MOT... |
#!/usr/local/bin/python
import numpy as np
from scipy.stats import truncnorm
def getRandomDist(distName, para):
mean = para[0]
if distName.startswith("bst"):
distName = distName[3:6]
new = float('inf')
if distName == "exp":
new = np.random.exponential(mean)
elif distName == "cst":
... | [
"numpy.random.rand",
"numpy.random.weibull",
"numpy.random.exponential"
] | [((264, 291), 'numpy.random.exponential', 'np.random.exponential', (['mean'], {}), '(mean)\n', (285, 291), True, 'import numpy as np\n'), ((418, 441), 'numpy.random.weibull', 'np.random.weibull', (['(0.25)'], {}), '(0.25)\n', (435, 441), True, 'import numpy as np\n'), ((495, 511), 'numpy.random.rand', 'np.random.rand',... |
import numpy as np
import torch
from torch.utils.data import DataLoader
from util.loaders import *
import pickle
def buildlibrary(jpgklass, jpg2words, Network, model, enc, savepath, path = "nv_txt/", elements = 2):
complete_dataset = Triplet_loaderbh_Textvlad(jpgklass, jpg2words, elements, path,
... | [
"pickle.dump",
"numpy.array",
"numpy.concatenate",
"torch.utils.data.DataLoader"
] | [((471, 529), 'torch.utils.data.DataLoader', 'DataLoader', (['complete_dataset'], {'batch_size': '(32)', 'shuffle': '(False)'}), '(complete_dataset, batch_size=32, shuffle=False)\n', (481, 529), False, 'from torch.utils.data import DataLoader\n'), ((566, 578), 'numpy.array', 'np.array', (['[]'], {}), '([])\n', (574, 57... |
import numpy as np
import matplotlib.pyplot as plt
import rff
import tensorflow as tf
samplesize = np.arange(1000,60001,5000)
orfsvm = np.zeros((10,len(samplesize)))
urfsvm = np.zeros((10,len(samplesize)))
for idx in range(1,11,1):
orfsvm[idx-1,:] = np.loadtxt('result/ORFSVM'+str(idx))
urfsvm[idx-1,:] = np.loa... | [
"matplotlib.pyplot.title",
"matplotlib.pyplot.savefig",
"numpy.std",
"numpy.mean",
"numpy.arange",
"matplotlib.pyplot.xticks",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.errorbar"
] | [((100, 128), 'numpy.arange', 'np.arange', (['(1000)', '(60001)', '(5000)'], {}), '(1000, 60001, 5000)\n', (109, 128), True, 'import numpy as np\n'), ((362, 385), 'numpy.mean', 'np.mean', (['orfsvm'], {'axis': '(0)'}), '(orfsvm, axis=0)\n', (369, 385), True, 'import numpy as np\n'), ((395, 418), 'numpy.mean', 'np.mean'... |
# Copyright 2019 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... | [
"tensorflow.keras.layers.Dense",
"pytest.mark.with_device",
"tensorflow.Variable",
"tensorflow_addons.optimizers.weight_decay_optimizers.extend_with_decoupled_weight_decay",
"pytest.mark.parametrize",
"tensorflow.keras.losses.SparseCategoricalCrossentropy",
"tensorflow.optimizers.schedules.PiecewiseCons... | [((6940, 7027), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""dtype"""', '[(tf.half, 0), (tf.float32, 1), (tf.float64, 2)]'], {}), "('dtype', [(tf.half, 0), (tf.float32, 1), (tf.\n float64, 2)])\n", (6963, 7027), False, 'import pytest\n'), ((7309, 7376), 'pytest.mark.parametrize', 'pytest.mark.parametr... |
import argparse
parser = argparse.ArgumentParser(description='Modify the training script',add_help=True)
# root_dir = !pwd
# s3bucket_path = root_dir[0] + '/../s3bucket_goofys/' # remote S3 via goofys
parser.add_argument("--gpuid", default=1, type=int, help="GPU to use (0-3)")
parser.add_argument("--datadir", default... | [
"argparse.ArgumentParser",
"time.strftime",
"tensorflow.ConfigProto",
"numpy.rot90",
"numpy.append",
"numpy.swapaxes",
"numpy.random.shuffle",
"h5py.File",
"keras.callbacks.ModelCheckpoint",
"os.path.getsize",
"keras.backend.set_session",
"tensorflow.Session",
"keras.callbacks.TensorBoard",
... | [((26, 111), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Modify the training script"""', 'add_help': '(True)'}), "(description='Modify the training script', add_help=True\n )\n", (49, 111), False, 'import argparse\n'), ((1084, 1100), 'tensorflow.ConfigProto', 'tf.ConfigProto', ([],... |
# coding: utf-8
import cv2
import numpy as np
import pprint
class ScaleSpace(object):
def __init__(self, K = 3, O = 8, sigma_0 = 0.8, delta_0 = 0.5):
"""
This class is model of Gaussian Scale space
:param K: number of scales per octave
:param O: number of octaves
:param sig... | [
"cv2.imwrite",
"numpy.array",
"numpy.exp",
"pprint.pprint",
"cv2.resize"
] | [((870, 922), 'cv2.imwrite', 'cv2.imwrite', (['"""./data/lena_std_org.tif"""', 'self.image_0'], {}), "('./data/lena_std_org.tif', self.image_0)\n", (881, 922), False, 'import cv2\n'), ((1905, 1962), 'cv2.resize', 'cv2.resize', (['image', '(h, w)'], {'interpolation': 'cv2.INTER_LINEAR'}), '(image, (h, w), interpolation=... |
# 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... | [
"tensorflow.python.ops.array_ops.shape",
"tensorflow.python.ops.array_ops.squeeze",
"tensorflow.python.ops.math_ops.reduce_sum",
"tensorflow.python.ops.math_ops.reduce_mean",
"tensorflow.python.ops.math_ops.to_int32",
"tensorflow.python.ops.array_ops.slice",
"tensorflow.contrib.metrics.python.ops.metric... | [((1770, 1838), 'tensorflow.contrib.metrics.python.ops.metric_ops.streaming_accuracy', 'metric_ops.streaming_accuracy', (['predictions', 'targets'], {'weights': 'weights'}), '(predictions, targets, weights=weights)\n', (1799, 1838), False, 'from tensorflow.contrib.metrics.python.ops import metric_ops\n'), ((1904, 1930)... |
import numpy as np
import gym
import pyllab
from gym import wrappers
from nes_py.wrappers import JoypadSpace
import gym_tetris
from gym_tetris.actions import MOVEMENT
env = gym.make('TetrisA-v0')
env = JoypadSpace(env, MOVEMENT)
state_size = env.observation_space.shape[0]*env.observation_space.shape[1]
action_size = en... | [
"pyllab.get_randomness",
"gym.make",
"nes_py.wrappers.JoypadSpace",
"numpy.array",
"pyllab.Neat"
] | [((173, 195), 'gym.make', 'gym.make', (['"""TetrisA-v0"""'], {}), "('TetrisA-v0')\n", (181, 195), False, 'import gym\n'), ((202, 228), 'nes_py.wrappers.JoypadSpace', 'JoypadSpace', (['env', 'MOVEMENT'], {}), '(env, MOVEMENT)\n', (213, 228), False, 'from nes_py.wrappers import JoypadSpace\n'), ((337, 360), 'pyllab.get_r... |
"""
Qpath (Ndiv k1_x k1_y k1_z k2_x k2_y k2_z ...)
@description: Generate path between the k-vectors given in the input with
approximately Ndiv points. It garantes a number of points between path sections
proportional to the considered k-displacement in comparison with the full path.
@author: <NAME>
"""
im... | [
"numpy.linspace"
] | [((1870, 1943), 'numpy.linspace', 'np.linspace', (['Inkpts[ii][0]', 'Inkpts[ii + 1][0]', 'subdiv[ii]'], {'endpoint': 'cflag'}), '(Inkpts[ii][0], Inkpts[ii + 1][0], subdiv[ii], endpoint=cflag)\n', (1881, 1943), True, 'import numpy as np\n'), ((1948, 2021), 'numpy.linspace', 'np.linspace', (['Inkpts[ii][1]', 'Inkpts[ii +... |
# --------------
# Importing header files
import numpy as np
#New record
new_record=[[50, 9, 4, 1, 0, 0, 40, 0]]
#Code starts here
#Loading data file and saving it into a new numpy array
data = np.genfromtxt(path, delimiter=",", skip_header=1)
print(data.shape)
#Concatenating the new record to ... | [
"numpy.genfromtxt",
"numpy.concatenate"
] | [((213, 262), 'numpy.genfromtxt', 'np.genfromtxt', (['path'], {'delimiter': '""","""', 'skip_header': '(1)'}), "(path, delimiter=',', skip_header=1)\n", (226, 262), True, 'import numpy as np\n'), ((353, 395), 'numpy.concatenate', 'np.concatenate', (['(data, new_record)'], {'axis': '(0)'}), '((data, new_record), axis=0)... |
import warnings
from quantum_systems import (
BasisSet,
SpatialOrbitalSystem,
GeneralOrbitalSystem,
QuantumSystem,
)
def construct_pyscf_system_ao(
molecule,
basis="cc-pvdz",
add_spin=True,
anti_symmetrize=True,
np=None,
**kwargs,
):
"""Convenience function setting up an a... | [
"pyscf.scf.hf.get_hcore",
"pyscf.gto.Mole",
"quantum_systems.SpatialOrbitalSystem",
"numpy.asarray",
"numpy.einsum",
"numpy.allclose",
"quantum_systems.BasisSet",
"pyscf.scf.RHF",
"warnings.warn"
] | [((1848, 1864), 'pyscf.gto.Mole', 'pyscf.gto.Mole', ([], {}), '()\n', (1862, 1864), False, 'import pyscf\n'), ((2136, 2163), 'pyscf.scf.hf.get_hcore', 'pyscf.scf.hf.get_hcore', (['mol'], {}), '(mol)\n', (2158, 2163), False, 'import pyscf\n'), ((2338, 2363), 'quantum_systems.BasisSet', 'BasisSet', (['l'], {'dim': '(3)',... |
import inspect
import signal
import random
import time
import traceback
import sys
import os
import subprocess
import math
import pickle as pickle
from itertools import chain
import heapq
import hashlib
def computeMD5hash(my_string):
# {{{
# https://stackoverflow.com/questions/13259691/convert-string-to-md5
... | [
"pickle.dump",
"math.isinf",
"getpass.getuser",
"heapq.heappush",
"psutil.virtual_memory",
"random.shuffle",
"torch.cat",
"json.dumps",
"pickle.load",
"os.close",
"sys.stdout.flush",
"multiprocessing.cpu_count",
"numpy.pad",
"os.path.dirname",
"dill.load",
"pylab.imshow",
"socket.get... | [((328, 341), 'hashlib.md5', 'hashlib.md5', ([], {}), '()\n', (339, 341), False, 'import hashlib\n'), ((6633, 6660), 'random.shuffle', 'random.shuffle', (['permutation'], {}), '(permutation)\n', (6647, 6660), False, 'import random\n'), ((6864, 6917), 'multiprocessing.Pool', 'Pool', (['numberOfCPUs'], {'maxtasksperchild... |
from __future__ import print_function, division
from typing import Optional
import cv2
import math
import numpy as np
from .augmentor import DataAugment
class MisAlignment(DataAugment):
r"""Mis-alignment data augmentation of image stacks. This augmentation is
applied to both images and masks.
Args:
... | [
"math.asin",
"math.ceil",
"numpy.zeros",
"numpy.random.RandomState",
"cv2.warpAffine",
"cv2.getRotationMatrix2D"
] | [((1590, 1622), 'numpy.zeros', 'np.zeros', (['out_shape', 'input.dtype'], {}), '(out_shape, input.dtype)\n', (1598, 1622), True, 'import numpy as np\n'), ((4747, 4811), 'cv2.getRotationMatrix2D', 'cv2.getRotationMatrix2D', (['(height / 2, height / 2)', 'rand_angle', '(1)'], {}), '((height / 2, height / 2), rand_angle, ... |
# coding: utf8
# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserve.
#
# 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 requ... | [
"PIL.Image.new",
"utils.config.cfg.update_from_file",
"pprint.pformat",
"argparse.ArgumentParser",
"os.makedirs",
"numpy.resize",
"tools.gray2pseudo_color.get_color_map_list",
"sklearn.metrics.log_loss",
"utils.config.cfg.check_and_infer",
"os.path.exists",
"numpy.ones",
"numpy.array",
"os.p... | [((887, 905), 'os.chdir', 'os.chdir', (['"""../../"""'], {}), "('../../')\n", (895, 905), False, 'import os\n'), ((1319, 1386), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""PaddeSeg visualization tools"""'}), "(description='PaddeSeg visualization tools')\n", (1342, 1386), False, 'impor... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
import argparse
from PIL import Image
import time
import io
import tflite_runtime.interpreter as tflite
def load_labels(filename):
with open(filename, 'r') as f:
return [line.str... | [
"argparse.ArgumentParser",
"PIL.Image.open",
"time.time",
"numpy.argpartition",
"tflite_runtime.interpreter.Interpreter"
] | [((1110, 1141), 'numpy.argpartition', 'np.argpartition', (['(-output)', 'top_k'], {}), '(-output, top_k)\n', (1125, 1141), True, 'import numpy as np\n'), ((1221, 1300), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'formatter_class': 'argparse.ArgumentDefaultsHelpFormatter'}), '(formatter_class=argparse.A... |
# coding=utf-8
# Copyright © 2018 Computational Molecular Biology Group,
# Freie Universität Berlin (GER)
#
# Redistribution and use in source and binary forms, with or
# without modification, are permitted provided that the
# following conditions are met:
# 1. Redistributions of source code must ret... | [
"readdy._internal.readdybinding.api.KernelProvider.get",
"readdy.Trajectory",
"readdy._internal.readdybinding.api.Simulation",
"numpy.arange",
"shutil.rmtree",
"numpy.ndarray",
"os.path.join",
"unittest.main",
"readdy._internal.readdybinding.common.Vec",
"numpy.testing.assert_almost_equal",
"tem... | [((21977, 21992), 'unittest.main', 'unittest.main', ([], {}), '()\n', (21990, 21992), False, 'import unittest\n'), ((2391, 2411), 'readdy._internal.readdybinding.api.KernelProvider.get', 'KernelProvider.get', ([], {}), '()\n', (2409, 2411), False, 'from readdy._internal.readdybinding.api import KernelProvider\n'), ((25... |
'''
Created on May 30, 2019
@author: mohammedmostafa
'''
import numpy as np
from tensorflow.keras.layers import Dense
from tensorflow.keras.models import Sequential
import matplotlib.pyplot as plt
xs = np.random.choice(np.arange(-3,3,.01),500)
ys = xs**2
x_test=np.linspace(-3,3,1000)
y_test=x_test**2
model = Sequen... | [
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"tensorflow.keras.layers.Dense",
"numpy.arange",
"tensorflow.keras.models.Sequential",
"numpy.linspace"
] | [((265, 289), 'numpy.linspace', 'np.linspace', (['(-3)', '(3)', '(1000)'], {}), '(-3, 3, 1000)\n', (276, 289), True, 'import numpy as np\n'), ((314, 326), 'tensorflow.keras.models.Sequential', 'Sequential', ([], {}), '()\n', (324, 326), False, 'from tensorflow.keras.models import Sequential\n'), ((531, 563), 'matplotli... |
from __future__ import print_function
from __future__ import absolute_import
from past.builtins import basestring
import numpy as np
import moby2.libactpol as libactpol
from moby2.util import encode_c, get_user_config
from . import quaternions as quat
def get_coords(ctime, az, alt,
fields=None,
... | [
"moby2.util.get_user_config",
"numpy.asarray",
"numpy.zeros",
"moby2.util.encode_c",
"numpy.loadtxt"
] | [((1557, 1588), 'numpy.asarray', 'np.asarray', (['_t'], {'dtype': '"""float64"""'}), "(_t, dtype='float64')\n", (1567, 1588), True, 'import numpy as np\n'), ((1737, 1758), 'moby2.util.encode_c', 'encode_c', (['focal_plane'], {}), '(focal_plane)\n', (1745, 1758), False, 'from moby2.util import encode_c, get_user_config\... |
# Copyright (c) OpenMMLab. All rights reserved.
import copy
import numpy as np
import pycocotools.mask as maskUtils
import pytest
from mmcv.utils import build_from_cfg
from mmdet.core.mask import BitmapMasks, PolygonMasks
from mmdet.datasets.builder import PIPELINES
def _check_keys(results, results_translated):
... | [
"numpy.random.uniform",
"copy.deepcopy",
"pycocotools.mask.decode",
"mmcv.utils.build_from_cfg",
"numpy.ones",
"numpy.clip",
"numpy.equal",
"pytest.raises",
"numpy.array",
"mmdet.core.mask.PolygonMasks",
"pycocotools.mask.frPyObjects",
"pycocotools.mask.merge",
"numpy.concatenate"
] | [((1243, 1373), 'numpy.array', 'np.array', (['[[222.62, 217.82, 241.81, 238.93], [50.5, 329.7, 130.23, 384.96], [175.47, \n 331.97, 254.8, 389.26]]'], {'dtype': 'np.float32'}), '([[222.62, 217.82, 241.81, 238.93], [50.5, 329.7, 130.23, 384.96],\n [175.47, 331.97, 254.8, 389.26]], dtype=np.float32)\n', (1251, 1373... |
#!/usr/bin/env python3
"""
Tabulate pixels in a Cartesian grid that lie on lines through the origin.
Copyright (c) Facebook, Inc. and its affiliates.
This provides a way to sample on a Cartesian grid the points which lie on lines
passing through the origin, choosing the angles of the lines at random.
Functions
----... | [
"numpy.random.seed",
"math.sin",
"pylab.savefig",
"pylab.subplot",
"matplotlib.use",
"pylab.figure",
"math.cos",
"numpy.ndarray"
] | [((574, 595), 'matplotlib.use', 'matplotlib.use', (['"""agg"""'], {}), "('agg')\n", (588, 595), False, 'import matplotlib\n'), ((2472, 2503), 'numpy.ndarray', 'np.ndarray', (['(m * n)'], {'dtype': '"""bool"""'}), "(m * n, dtype='bool')\n", (2482, 2503), True, 'import numpy as np\n'), ((2670, 2695), 'numpy.random.seed',... |
import os
from subprocess import PIPE, Popen
import numpy as np
import pytest
import vtk
import vtki
from vtki import examples as ex
from vtki.plotting import system_supports_plotting
def test_multi_block_init_vtk():
multi = vtk.vtkMultiBlockDataSet()
multi.SetBlock(0, vtk.vtkRectilinearGrid())
multi.Se... | [
"vtk.vtkUnstructuredGrid",
"vtki.examples.load_airplane",
"vtki.MultiBlock",
"vtk.vtkMultiBlockDataSet",
"vtki.examples.load_uniform",
"numpy.random.rand",
"numpy.save",
"vtki.examples.load_sphere",
"vtk.vtkRectilinearGrid",
"vtk.vtkTable",
"vtki.examples.load_globe",
"vtki.examples.load_recti... | [((5171, 5219), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""binary"""', '[True, False]'], {}), "('binary', [True, False])\n", (5194, 5219), False, 'import pytest\n'), ((5221, 5274), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""extension"""', "['vtm', 'vtmb']"], {}), "('extension', ['vtm',... |
# Copyright (c) 2018 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 app... | [
"numpy.load",
"numpy.zeros",
"numpy.random.randint",
"numpy.array",
"parl.utils.logger.warn",
"numpy.savez"
] | [((892, 938), 'numpy.zeros', 'np.zeros', (['(max_size, obs_dim)'], {'dtype': '"""float32"""'}), "((max_size, obs_dim), dtype='float32')\n", (900, 938), True, 'import numpy as np\n'), ((961, 1007), 'numpy.zeros', 'np.zeros', (['(max_size, act_dim)'], {'dtype': '"""float32"""'}), "((max_size, act_dim), dtype='float32')\n... |
import os
from typing import Dict, Optional, Tuple, List, Union
import numpy as np
from jina.executors.decorators import batching_multi_input
from jina.executors.rankers import Match2DocRanker
from jina.excepts import PretrainedModelFileDoesNotExist
if False:
import lightgbm
class LightGBMRanker(Match2DocRanke... | [
"lightgbm.Dataset",
"os.path.exists",
"lightgbm.Booster",
"numpy.array",
"jina.excepts.PretrainedModelFileDoesNotExist",
"jina.executors.decorators.batching_multi_input",
"numpy.vstack"
] | [((4995, 5027), 'jina.executors.decorators.batching_multi_input', 'batching_multi_input', ([], {'num_data': '(3)'}), '(num_data=3)\n', (5015, 5027), False, 'from jina.executors.decorators import batching_multi_input\n'), ((4254, 4275), 'numpy.vstack', 'np.vstack', (['q_features'], {}), '(q_features)\n', (4263, 4275), T... |
# Copyright (C) 2020-2021 Intel Corporation
# SPDX-License-Identifier: Apache-2.0
import os
import numpy as np
from addict import Dict
from cv2 import imread, resize as cv2_resize
from openvino.tools.pot.api import Metric, DataLoader
from openvino.tools.pot.graph import load_model, save_model
from openvino.tools.pot.... | [
"os.path.join",
"openvino.tools.pot.utils.logger.init_logger",
"numpy.ravel",
"numpy.ceil",
"openvino.tools.pot.engines.ie_engine.IEEngine",
"numpy.argsort",
"openvino.tools.pot.graph.model_utils.compress_model_weights",
"numpy.array",
"os.path.splitext",
"openvino.tools.pot.pipeline.initializer.c... | [((711, 736), 'openvino.tools.pot.utils.logger.init_logger', 'init_logger', ([], {'level': '"""INFO"""'}), "(level='INFO')\n", (722, 736), False, 'from openvino.tools.pot.utils.logger import init_logger\n'), ((4775, 4799), 'cv2.resize', 'cv2_resize', (['image', 'shape'], {}), '(image, shape)\n', (4785, 4799), True, 'fr... |
from __future__ import print_function
import numpy as np
from random import randrange
def eval_numerical_gradient(f, x, verbose=True, h=0.00001):
"""
a naive implementation of numerical gradient of f at x
- f should be a function that takes a single argument
- x is the point (numpy array) to evaluate the gr... | [
"numpy.zeros_like",
"numpy.sum",
"numpy.copy",
"numpy.nditer",
"random.randrange"
] | [((403, 419), 'numpy.zeros_like', 'np.zeros_like', (['x'], {}), '(x)\n', (416, 419), True, 'import numpy as np\n'), ((461, 520), 'numpy.nditer', 'np.nditer', (['x'], {'flags': "['multi_index']", 'op_flags': "['readwrite']"}), "(x, flags=['multi_index'], op_flags=['readwrite'])\n", (470, 520), True, 'import numpy as np\... |
#!/usr/bin/env python
# ============================================================================
# AUTHOR: <NAME>
# EMAIL: <<EMAIL>>
# DATE: 2018-09-15 12:40:43
# BRIEF:
# ============================================================================
import os
import numpy as np
import tensorflow as ... | [
"gans.networks.cifar10.network.gen",
"argparse.ArgumentParser",
"tensorflow.trainable_variables",
"tensorflow.get_variable_scope",
"tensorflow.zeros_like",
"numpy.mean",
"tensorflow.split",
"numpy.std",
"gans.networks.cifar10.network.disc",
"tensorflow.name_scope",
"datetime.datetime.now",
"te... | [((5331, 5347), 'gans.config.Config', 'Config', ([], {}), '(**params)\n', (5337, 5347), False, 'from gans.config import Config\n'), ((5457, 5487), 'argparse.ArgumentParser', 'ArgumentParser', ([], {'description': '""""""'}), "(description='')\n", (5471, 5487), False, 'from argparse import ArgumentParser\n'), ((686, 696... |
'''
Simulation of car following user with 5 sensors used for the reward
3 sensors used to detect the user and determine whether or not he is
in front of the car.
State contains the 5 sonars and 3 BLE sensors information
<NAME>
'''
import sys
#sys.path.append('/usr/local/lib/python3.5/dist-packages')
import os
im... | [
"pygame.display.update",
"sys.stdout.flush",
"pymunk.Body",
"pymunk.Space",
"threading.Thread.__init__",
"random.randint",
"pygame.display.set_mode",
"pymunk.Segment",
"matplotlib.mlab.normpdf",
"math.cos",
"math.sqrt",
"pymunk.pygame_util.draw",
"pymunk.vec2d.Vec2d",
"pymunk.Vec2d",
"py... | [((672, 685), 'pygame.init', 'pygame.init', ([], {}), '()\n', (683, 685), True, 'import pygame as pygame\n'), ((695, 735), 'pygame.display.set_mode', 'pygame.display.set_mode', (['(width, height)'], {}), '((width, height))\n', (718, 735), True, 'import pygame as pygame\n'), ((744, 763), 'pygame.time.Clock', 'pygame.tim... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import argparse
import os
import os.path as osp
import sys
import json
import time
import numpy as np
import h5py
import pprint
from scipy.misc import imread, imresize
import cv2
from tqdm import trange, tqdm
... | [
"h5py.File",
"argparse.ArgumentParser",
"loaders.loader.Loader",
"mrcn.inference_no_imdb.Inference",
"numpy.hstack",
"numpy.array",
"os.path.join",
"sys.exit",
"torch.from_numpy"
] | [((602, 663), 'numpy.hstack', 'np.hstack', (['(boxes[:, 0:2], boxes[:, 0:2] + boxes[:, 2:4] - 1)'], {}), '((boxes[:, 0:2], boxes[:, 0:2] + boxes[:, 2:4] - 1))\n', (611, 663), True, 'import numpy as np\n'), ((766, 827), 'numpy.hstack', 'np.hstack', (['(boxes[:, 0:2], boxes[:, 2:4] - boxes[:, 0:2] + 1)'], {}), '((boxes[:... |
# 사용 패키지 임포트
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
from environments.gridworld import GridWorld
plt.rcParams["font.family"] = 'AppleGothic'
plt.rcParams["font.size"] = 12
mpl.rcParams['axes.unicode_minus'] = False
STEP_N_MAX = 9
# 행동-가치 함수 생성
def state_action_value(env):
q... | [
"environments.gridworld.GridWorld",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.ylim",
"numpy.argmax",
"matplotlib.pyplot.close",
"matplotlib.pyplot.legend",
"numpy.arange",
"numpy.random.normal",
"numpy.random.choice",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplo... | [((3499, 3532), 'environments.gridworld.GridWorld', 'GridWorld', ([], {'transition_reward': '(-0.1)'}), '(transition_reward=-0.1)\n', (3508, 3532), False, 'from environments.gridworld import GridWorld\n'), ((3589, 3613), 'numpy.arange', 'np.arange', (['(0.1)', '(1.1)', '(0.1)'], {}), '(0.1, 1.1, 0.1)\n', (3598, 3613), ... |
# camera-ready
from datasets import DatasetFrustumPointNetAugmentation, EvalDatasetFrustumPointNet, getBinCenters, wrapToPi # (this needs to be imported before torch, because cv2 needs to be imported before torch for some reason)
from frustum_pointnet import FrustumPointNet
import torch
import torch.utils.data
import... | [
"matplotlib.pyplot.title",
"pickle.dump",
"torch.bmm",
"numpy.argmax",
"torch.cos",
"matplotlib.pyplot.figure",
"numpy.mean",
"torch.no_grad",
"matplotlib.pyplot.xlabel",
"torch.utils.data.DataLoader",
"datasets.DatasetFrustumPointNetAugmentation",
"matplotlib.pyplot.close",
"torch.nn.functi... | [((484, 505), 'matplotlib.use', 'matplotlib.use', (['"""Agg"""'], {}), "('Agg')\n", (498, 505), False, 'import matplotlib\n'), ((720, 778), 'frustum_pointnet.FrustumPointNet', 'FrustumPointNet', (['model_id'], {'project_dir': '"""/root/3DOD_thesis"""'}), "(model_id, project_dir='/root/3DOD_thesis')\n", (735, 778), Fals... |
import copy
import unittest
import numpy
import pytest
import cupy
from cupy import core
from cupy import cuda
from cupy import get_array_module
from cupy import testing
class TestGetSize(unittest.TestCase):
def test_none(self):
assert core.get_size(None) == ()
def check_collection(self, a):
... | [
"cupy.testing.shaped_arange",
"cupy.testing.assert_array_equal",
"cupy.testing.numpy_cupy_equal",
"cupy.testing.parameterize",
"cupy.testing.product",
"numpy.ndarray",
"cupy.testing.for_all_dtypes",
"cupy.ndarray",
"cupy.testing.multi_gpu",
"pytest.raises",
"cupy.get_array_module",
"copy.deepc... | [((9606, 9724), 'cupy.testing.parameterize', 'testing.parameterize', (["{'shape': (3, 4, 5), 'indices': (2,), 'axis': 3}", "{'shape': (), 'indices': (0,), 'axis': 2}"], {}), "({'shape': (3, 4, 5), 'indices': (2,), 'axis': 3}, {\n 'shape': (), 'indices': (0,), 'axis': 2})\n", (9626, 9724), False, 'from cupy import te... |
import numpy as np
from .reglayers400M import AnyNet, WrappedModel
import torch
from .build import BACKBONE_REGISTRY
from .backbone import Backbone
from detectron2.modeling import ShapeSpec
regnet_200M_config = {'WA': 36.44, 'W0': 24, 'WM': 2.49, 'DEPTH': 13, 'GROUP_W': 8, 'BOT_MUL': 1}
regnet_400M_config = {'... | [
"numpy.divide",
"numpy.log",
"numpy.power",
"torch.load",
"torchsummary.summary",
"numpy.arange",
"numpy.unique"
] | [((6828, 6855), 'torchsummary.summary', 'summary', (['net', '(3, 224, 224)'], {}), '(net, (3, 224, 224))\n', (6835, 6855), False, 'from torchsummary import summary\n'), ((2861, 2878), 'numpy.power', 'np.power', (['w_m', 'ks'], {}), '(w_m, ks)\n', (2869, 2878), True, 'import numpy as np\n'), ((4543, 4581), 'torch.load',... |
import numpy as np
from hand import Hand
# hyperparameters
iterations_per = 500
epsilon = 10**-8 # offset to prevent division from blowing up
# R, B, U
lambd_colors = (1., 17./21, 13./21)
# Summit, Catacombs
lambd_checks = (0.4, 0.4)
# value of drawing Field of Ruin
lambd_field = 0.035
# penalty for drawing tapped lan... | [
"numpy.array",
"hand.Hand"
] | [((451, 479), 'hand.Hand', 'Hand', (['"""decklists/grixis.txt"""'], {}), "('decklists/grixis.txt')\n", (455, 479), False, 'from hand import Hand\n'), ((4374, 4413), 'numpy.array', 'np.array', (['results[utility]'], {'dtype': 'float'}), '(results[utility], dtype=float)\n', (4382, 4413), True, 'import numpy as np\n')] |
#!/usr/bin/env python3
"""Perform sample size Script to run RVM on bootstrap datasets of UK BIOBANK Scanner1. """
import argparse
import random
import warnings
from math import sqrt
from pathlib import Path
import numpy as np
import pandas as pd
from scipy import stats
from sklearn.metrics import mean_absolute_error, ... | [
"numpy.random.seed",
"argparse.ArgumentParser",
"numpy.abs",
"warnings.filterwarnings",
"pandas.read_csv",
"sklearn.metrics.r2_score",
"sklearn.metrics.mean_absolute_error",
"utils.load_demographic_data",
"random.seed",
"numpy.array",
"pathlib.Path.cwd",
"sklearn.metrics.mean_squared_error",
... | [((436, 446), 'pathlib.Path.cwd', 'Path.cwd', ([], {}), '()\n', (444, 446), False, 'from pathlib import Path\n'), ((448, 481), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (471, 481), False, 'import warnings\n'), ((492, 517), 'argparse.ArgumentParser', 'argparse.Argument... |
import covid.util as util
import pandas as pd
import matplotlib.pyplot as plt
import sys
start = sys.argv[1]
forecast_start = sys.argv[2]
samples_directory = sys.argv[3]
import numpy as np
from epiweeks import Week, Year
num_weeks = 8
data = util.load_state_data()
places = sorted(list(data.keys()))
#places = ['AK... | [
"pandas.DataFrame",
"pandas.date_range",
"pandas.read_csv",
"numpy.transpose",
"covid.util.load_samples",
"epiweeks.Week.fromdate",
"numpy.percentile",
"covid.util.load_state_data",
"pandas.to_datetime",
"numpy.arange",
"pandas.Timedelta"
] | [((248, 270), 'covid.util.load_state_data', 'util.load_state_data', ([], {}), '()\n', (268, 270), True, 'import covid.util as util\n'), ((427, 457), 'pandas.to_datetime', 'pd.to_datetime', (['forecast_start'], {}), '(forecast_start)\n', (441, 457), True, 'import pandas as pd\n'), ((475, 503), 'epiweeks.Week.fromdate', ... |
import datetime
import dateutil.tz
import dateutil.rrule
import functools
import numpy as np
import pytest
from matplotlib import rc_context, style
import matplotlib.dates as mdates
import matplotlib.pyplot as plt
from matplotlib.testing.decorators import image_comparison
import matplotlib.ticker as mtick... | [
"matplotlib.style.use",
"matplotlib.dates.epoch2num",
"matplotlib.testing.jpl_units.register",
"matplotlib.testing.decorators.image_comparison",
"numpy.isnan",
"matplotlib.pyplot.figure",
"numpy.arange",
"matplotlib.dates.date2num",
"pytest.mark.parametrize",
"matplotlib.dates.drange",
"matplotl... | [((1603, 1712), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""dtype"""', "['datetime64[s]', 'datetime64[us]', 'datetime64[ms]', 'datetime64[ns]']"], {}), "('dtype', ['datetime64[s]', 'datetime64[us]',\n 'datetime64[ms]', 'datetime64[ns]'])\n", (1626, 1712), False, 'import pytest\n'), ((2012, 2121), 'py... |
# Copyright 2020 The SQLFlow 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 o... | [
"functools.partial",
"tensorflow.strings.split",
"tensorflow.strings.to_number",
"copy.copy",
"runtime.db.selected_cols",
"runtime.db.connect_with_data_source",
"tensorflow.shape",
"numpy.array",
"runtime.db.db_generator",
"tensorflow.SparseTensor",
"runtime.db.read_features_from_row",
"tensor... | [((6556, 6587), 'copy.copy', 'copy.copy', (['feature_column_names'], {}), '(feature_column_names)\n', (6565, 6587), False, 'import copy\n'), ((3394, 3425), 'runtime.db.pai_selected_cols', 'db.pai_selected_cols', (['pai_table'], {}), '(pai_table)\n', (3414, 3425), False, 'from runtime import db\n'), ((3451, 3490), 'runt... |
#!/usr/bin/env python
import numpy as np
import pytest
from larndsim import consts
consts.load_pixel_geometry("larndsim/pixel_layouts/layout-2.5.0.yaml")
from larndsim import detsim
from larndsim import drifting, quenching, pixels_from_track
from math import ceil
class TestTrackCurrent:
tracks = np.zeros((10,... | [
"numpy.full",
"numpy.random.uniform",
"numpy.sum",
"numpy.copy",
"math.ceil",
"numpy.zeros",
"larndsim.consts.load_pixel_geometry",
"numpy.sqrt"
] | [((86, 156), 'larndsim.consts.load_pixel_geometry', 'consts.load_pixel_geometry', (['"""larndsim/pixel_layouts/layout-2.5.0.yaml"""'], {}), "('larndsim/pixel_layouts/layout-2.5.0.yaml')\n", (112, 156), False, 'from larndsim import consts\n'), ((307, 325), 'numpy.zeros', 'np.zeros', (['(10, 29)'], {}), '((10, 29))\n', (... |
import numpy as np
from sklearn import metrics as skl_metrics
from imblearn import metrics as imb_metrics
def contrast_ratio(target, background):
"""
This method calculates contrast ration between target and background image regions
:param target: target image region
:param background: back... | [
"imblearn.metrics.specificity_score",
"numpy.std",
"numpy.power",
"sklearn.metrics.accuracy_score",
"imblearn.metrics.sensitivity_score",
"sklearn.metrics.roc_auc_score",
"numpy.max",
"numpy.mean",
"sklearn.metrics.f1_score",
"numpy.where",
"numpy.linspace",
"sklearn.metrics.precision_score",
... | [((400, 415), 'numpy.mean', 'np.mean', (['target'], {}), '(target)\n', (407, 415), True, 'import numpy as np\n'), ((439, 458), 'numpy.mean', 'np.mean', (['background'], {}), '(background)\n', (446, 458), True, 'import numpy as np\n'), ((855, 870), 'numpy.mean', 'np.mean', (['target'], {}), '(target)\n', (862, 870), Tru... |
import numpy as np
from libs.functional import Polynomial, regression_sgd
class TestPolynomial:
def test_io(self):
f = Polynomial(a=[1., 2., 3.]) # 1 + 2x + 3x^2
assert f(4.).value == 57.
assert f(5.).value == 86.
def test_io_array(self):
f = Polynomial(a=[1., 2., 3.]) # 1... | [
"numpy.random.uniform",
"numpy.isclose",
"numpy.array",
"libs.functional.Polynomial",
"numpy.random.normal",
"libs.functional.regression_sgd"
] | [((711, 750), 'numpy.random.uniform', 'np.random.uniform', (['(-10)', '(10)', 'num_samples'], {}), '(-10, 10, num_samples)\n', (728, 750), True, 'import numpy as np\n'), ((763, 798), 'numpy.random.normal', 'np.random.normal', (['(0)', '(1)', 'num_samples'], {}), '(0, 1, num_samples)\n', (779, 798), True, 'import numpy ... |
"""
Utility functions for working with dataframes
"""
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from scipy.stats import t, ttest_1samp, ttest_ind
class ColumnCompare:
"""
Class for comparing columns in two dataframes {x1} and {x2}.
Initialize... | [
"numpy.std",
"sklearn.model_selection.train_test_split",
"scipy.stats.ttest_ind",
"numpy.isnan",
"numpy.mean",
"numpy.array",
"scipy.stats.t.interval",
"scipy.stats.t.ppf",
"numpy.sqrt"
] | [((1270, 1313), 'sklearn.model_selection.train_test_split', 'train_test_split', (['df'], {'train_size': 'train_size'}), '(df, train_size=train_size)\n', (1286, 1313), False, 'from sklearn.model_selection import train_test_split\n'), ((1330, 1372), 'sklearn.model_selection.train_test_split', 'train_test_split', (['val_t... |
import numpy as np
import matplotlib.pyplot as plt
def circle(x, inverse=False):
m = np.max(x)
c = (m + np.min(x)) / 2
r = m - c
s = np.sqrt(r*r-(x-c)*(x-c))
return -s if inverse else s
def recaman(n_iterations=10, n_middle_vals=10, **kwargs):
step = 1
pos = 0
occupied = set()
while step <= n_iter... | [
"matplotlib.pyplot.axis",
"numpy.max",
"numpy.min",
"matplotlib.pyplot.savefig",
"numpy.sqrt"
] | [((89, 98), 'numpy.max', 'np.max', (['x'], {}), '(x)\n', (95, 98), True, 'import numpy as np\n'), ((143, 177), 'numpy.sqrt', 'np.sqrt', (['(r * r - (x - c) * (x - c))'], {}), '(r * r - (x - c) * (x - c))\n', (150, 177), True, 'import numpy as np\n'), ((599, 614), 'matplotlib.pyplot.axis', 'plt.axis', (['"""off"""'], {}... |
# --------------------------------------------------------
# Fast R-CNN
# Copyright (c) 2015 Microsoft
# Licensed under The MIT License [see LICENSE for details]
# Written by <NAME>
# --------------------------------------------------------
from lib.utils.nms.cpu_nms import cpu_nms
from lib.utils.nms.gpu_nms import gp... | [
"lib.utils.nms.cpu_nms.cpu_nms",
"lib.utils.nms.gpu_nms.gpu_nms",
"numpy.hstack"
] | [((874, 895), 'lib.utils.nms.gpu_nms.gpu_nms', 'gpu_nms', (['dets', 'thresh'], {}), '(dets, thresh)\n', (881, 895), False, 'from lib.utils.nms.gpu_nms import gpu_nms\n'), ((841, 862), 'lib.utils.nms.cpu_nms.cpu_nms', 'cpu_nms', (['dets', 'thresh'], {}), '(dets, thresh)\n', (848, 862), False, 'from lib.utils.nms.cpu_nms... |
"""
Auxiliary functions for parsing and managing input data.
"""
import pandas as pd
import numpy as np
from os.path import join, isdir
def check_cleaned(path):
"""Check if the folder given is the parentfolder of a cleaned structure
for the module
"""
bool_1 = isdir(join(path, 'Main'))
bool_2 = ... | [
"pandas.DataFrame",
"pandas.ExcelFile",
"numpy.array",
"os.path.join",
"pandas.concat"
] | [((486, 501), 'pandas.ExcelFile', 'pd.ExcelFile', (['f'], {}), '(f)\n', (498, 501), True, 'import pandas as pd\n'), ((1369, 1385), 'os.path.join', 'join', (['path', 'name'], {}), '(path, name)\n', (1373, 1385), False, 'from os.path import join, isdir\n'), ((1604, 1620), 'os.path.join', 'join', (['path', 'name'], {}), '... |
# -*- coding: utf-8 -*-
"""
Created on Mon Mar 9 14:59:45 2020
@author: wonwoo
"""
from sklearn.pipeline import Pipeline
from sklearn.svm import LinearSVR
from sklearn.linear_model import LinearRegression, LogisticRegression
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.model_sele... | [
"matplotlib.pyplot.title",
"sklearn.model_selection.GridSearchCV",
"sklearn.metrics.confusion_matrix",
"sklearn.preprocessing.StandardScaler",
"numpy.argmax",
"pandas.read_csv",
"keras.backend.epsilon",
"tensorflow.zeros_like",
"sklearn.metrics.classification_report",
"gc.collect",
"keras.backen... | [((1391, 1407), 'sklearn.preprocessing.StandardScaler', 'StandardScaler', ([], {}), '()\n', (1405, 1407), False, 'from sklearn.preprocessing import StandardScaler\n'), ((3074, 3092), 'pandas.concat', 'pd.concat', (['df_list'], {}), '(df_list)\n', (3083, 3092), True, 'import pandas as pd\n'), ((3170, 3201), 'pandas.Data... |
import random
import numpy as np
import torch
import torch.utils.data
import commons
from utils import load_wav_to_torch, load_filepaths_and_text
from text_jp.tokenizer import Tokenizer
class TextMelLoader(torch.utils.data.Dataset):
"""
1) loads audio,text pairs
2) normalizes text and converts th... | [
"text_jp.tokenizer.Tokenizer",
"numpy.load",
"utils.load_wav_to_torch",
"utils.load_filepaths_and_text",
"random.shuffle",
"torch.squeeze",
"torch.rand_like",
"random.seed",
"torch.IntTensor",
"commons.TacotronSTFT"
] | [((508, 552), 'utils.load_filepaths_and_text', 'load_filepaths_and_text', (['audiopaths_and_text'], {}), '(audiopaths_and_text)\n', (531, 552), False, 'from utils import load_wav_to_torch, load_filepaths_and_text\n'), ((915, 926), 'text_jp.tokenizer.Tokenizer', 'Tokenizer', ([], {}), '()\n', (924, 926), False, 'from te... |
import os
import yaml
import lasagne
import pandas as pd
import numpy as np
from network import Network
import architectures as arches
L = lasagne.layers
# loads data with names according to autoload_data.py
from autoload_data import *
# load specs for all networks
with open('arch_specs.yaml') as archfile:
arch... | [
"os.listdir",
"yaml.load",
"numpy.log",
"numpy.log2",
"network.Network",
"numpy.arange",
"pandas.Series",
"os.path.join",
"pandas.concat"
] | [((328, 347), 'yaml.load', 'yaml.load', (['archfile'], {}), '(archfile)\n', (337, 347), False, 'import yaml\n'), ((2751, 2786), 'pandas.concat', 'pd.concat', (['pretrain_results'], {'axis': '(1)'}), '(pretrain_results, axis=1)\n', (2760, 2786), True, 'import pandas as pd\n'), ((6237, 6260), 'pandas.Series', 'pd.Series'... |
import torch
from torch.utils import data
import pickle
import numpy as np
from skimage.transform import rescale
from os import listdir
from os.path import join
class ToySampledTripletTestDataset(data.Dataset):
def __init__(self, width, height, depth):
self.width = width
self.heigh... | [
"numpy.zeros",
"numpy.expand_dims",
"skimage.transform.rescale"
] | [((648, 670), 'numpy.zeros', 'np.zeros', (['(64, 64, 64)'], {}), '((64, 64, 64))\n', (656, 670), True, 'import numpy as np\n'), ((2186, 2236), 'skimage.transform.rescale', 'rescale', (['original_tomogram', '(2)'], {'anti_aliasing': '(False)'}), '(original_tomogram, 2, anti_aliasing=False)\n', (2193, 2236), False, 'from... |
"""
This module is for functions which perform measurements.
"""
import numpy as np
def calculate_distance(rA, rB):
"""
Calculate the distance between two points.
Optional extended summary.
Parameters
----------
rA : np.ndarray
The coordinates of each point.
rB
Returns
-... | [
"numpy.dot",
"numpy.linalg.norm",
"numpy.degrees"
] | [((650, 667), 'numpy.linalg.norm', 'np.linalg.norm', (['d'], {}), '(d)\n', (664, 667), True, 'import numpy as np\n'), ((1027, 1044), 'numpy.degrees', 'np.degrees', (['theta'], {}), '(theta)\n', (1037, 1044), True, 'import numpy as np\n'), ((935, 949), 'numpy.dot', 'np.dot', (['AB', 'BC'], {}), '(AB, BC)\n', (941, 949),... |
import logging
from typing import Tuple, Union
import anndata
import numba
import numpy as np
import pandas as pd
import scipy.sparse as sp_sparse
logger = logging.getLogger(__name__)
def _compute_library_size(
data: Union[sp_sparse.spmatrix, np.ndarray]
) -> Tuple[np.ndarray, np.ndarray]:
sum_counts = data... | [
"numba.njit",
"numpy.zeros",
"numpy.unique",
"numpy.ma.log",
"pandas.Index",
"numpy.mean",
"numpy.squeeze",
"numpy.ma.is_masked",
"numpy.var",
"logging.getLogger"
] | [((158, 185), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (175, 185), False, 'import logging\n'), ((3142, 3164), 'numba.njit', 'numba.njit', ([], {'cache': '(True)'}), '(cache=True)\n', (3152, 3164), False, 'import numba\n'), ((354, 375), 'numpy.ma.log', 'np.ma.log', (['sum_counts'], {... |
import multi_agent_ale_py
from pathlib import Path
from pettingzoo import AECEnv
import gym
from gym.utils import seeding, EzPickle
from pettingzoo.utils import agent_selector, wrappers
from gym import spaces
import numpy as np
from pettingzoo.utils._parallel_env import _parallel_env_wrapper
from pettingzoo.utils.to_pa... | [
"pygame.quit",
"pettingzoo.utils.wrappers.AssertOutOfBoundsWrapper",
"pettingzoo.utils.wrappers.OrderEnforcingWrapper",
"gym.utils.seeding.create_seed",
"pygame.display.set_mode",
"numpy.zeros",
"gym.spaces.Discrete",
"pygame.init",
"pygame.display.flip",
"multi_agent_ale_py.ALEInterface",
"pyga... | [((513, 551), 'pettingzoo.utils.wrappers.AssertOutOfBoundsWrapper', 'wrappers.AssertOutOfBoundsWrapper', (['env'], {}), '(env)\n', (546, 551), False, 'from pettingzoo.utils import agent_selector, wrappers\n'), ((566, 601), 'pettingzoo.utils.wrappers.OrderEnforcingWrapper', 'wrappers.OrderEnforcingWrapper', (['env'], {}... |
"""
Imshow elaborate
=================
An example demoing imshow and styling the figure.
"""
import numpy as np
import matplotlib.pyplot as plt
def f(x, y):
return (1 - x / 2 + x ** 5 + y ** 3 ) * np.exp(-x ** 2 - y ** 2)
n = 10
x = np.linspace(-3, 3, int(round(3.5 * n)))
y = np.linspace(-3, 3, int(round(3.0 * ... | [
"numpy.meshgrid",
"matplotlib.pyplot.show",
"matplotlib.pyplot.axes",
"matplotlib.pyplot.imshow",
"matplotlib.pyplot.yticks",
"matplotlib.pyplot.colorbar",
"numpy.exp",
"matplotlib.pyplot.xticks"
] | [((332, 349), 'numpy.meshgrid', 'np.meshgrid', (['x', 'y'], {}), '(x, y)\n', (343, 349), True, 'import numpy as np\n'), ((363, 399), 'matplotlib.pyplot.axes', 'plt.axes', (['[0.025, 0.025, 0.95, 0.95]'], {}), '([0.025, 0.025, 0.95, 0.95])\n', (371, 399), True, 'import matplotlib.pyplot as plt\n'), ((400, 467), 'matplot... |
"""Columnar storage for DGLGraph."""
from __future__ import absolute_import
from collections import namedtuple
from collections.abc import MutableMapping
import numpy as np
from . import backend as F
from .base import DGLError, dgl_warning
from .init import zero_initializer
from . import utils
class Scheme(namedtup... | [
"numpy.delete",
"collections.namedtuple"
] | [((312, 352), 'collections.namedtuple', 'namedtuple', (['"""Scheme"""', "['shape', 'dtype']"], {}), "('Scheme', ['shape', 'dtype'])\n", (322, 352), False, 'from collections import namedtuple\n'), ((27901, 27924), 'numpy.delete', 'np.delete', (['index', 'query'], {}), '(index, query)\n', (27910, 27924), True, 'import nu... |
# 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... | [
"numpy.abs",
"numpy.sum",
"tvm.te.all",
"tvm.nd.empty",
"tvm.tir.stmt_functor.substitute",
"pytest.mark.parametrize",
"numpy.prod",
"tvm._ffi._init_api",
"numpy.zeros_like",
"logging.warning",
"numpy.isfinite",
"tvm.te.create_schedule",
"numpy.testing.assert_allclose",
"tvm.runtime.enabled... | [((22522, 22561), 'tvm._ffi._init_api', 'tvm._ffi._init_api', (['"""testing"""', '__name__'], {}), "('testing', __name__)\n", (22540, 22561), False, 'import tvm\n'), ((3122, 3201), 'numpy.testing.assert_allclose', 'np.testing.assert_allclose', (['actual', 'desired'], {'rtol': 'rtol', 'atol': 'atol', 'verbose': '(True)'... |
import json
import logging
import numpy as np
import os
import torch
from abc import ABC
from abc import abstractmethod
from ..utils.various import create_missing_folders
from ..utils.various import load_and_check
logger = logging.getLogger(__name__)
class Estimator(ABC):
"""
Abstract class for any ML est... | [
"json.dump",
"numpy.load",
"numpy.save",
"numpy.sum",
"json.load",
"numpy.std",
"torch.load",
"os.path.dirname",
"numpy.zeros",
"numpy.ones",
"numpy.einsum",
"torch.save",
"numpy.mean",
"numpy.array",
"torch.tensor",
"logging.getLogger"
] | [((227, 254), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (244, 254), False, 'import logging\n'), ((10821, 10836), 'numpy.sum', 'np.sum', (['weights'], {}), '(weights)\n', (10827, 10836), True, 'import numpy as np\n'), ((11232, 11255), 'numpy.mean', 'np.mean', (['t_hats'], {'axis': '(0... |
"""Inception_ResNet 1D models in Tensorflow-Keras.
Reference - [Rethinking the Inception Architecture for Computer Vision](http://arxiv.org/abs/1512.00567)
Inception_ResNet Review: https://towardsdatascience.com/review-inception-v4-evolved-from-googlenet-merged-with-resnet-idea-image-classification-5e8c339d18bc
"""
im... | [
"tensorflow.keras.layers.BatchNormalization",
"tensorflow.keras.layers.Reshape",
"tensorflow.keras.layers.Dense",
"tensorflow.keras.layers.Conv1D",
"tensorflow.keras.metrics.MeanSquaredError",
"tensorflow.keras.Input",
"tensorflow.keras.layers.MaxPooling1D",
"tensorflow.keras.layers.Dropout",
"tenso... | [((2256, 2330), 'tensorflow.keras.layers.concatenate', 'tf.keras.layers.concatenate', (['[branch1x1, branch3x3, branch3x3dbl]'], {'axis': '(-1)'}), '([branch1x1, branch3x3, branch3x3dbl], axis=-1)\n', (2283, 2330), True, 'import tensorflow as tf\n'), ((3074, 3134), 'tensorflow.keras.layers.concatenate', 'tf.keras.layer... |
from sklearn import metrics
import itertools
from scipy import io
import torch as th
from ogb.nodeproppred import DglNodePropPredDataset, Evaluator
show_plots = False
# %% Load dataset
dataset = DglNodePropPredDataset(name = 'ogbn-arxiv')
#Get training, validation and test set indicies
split_idx = dataset.get_idx_s... | [
"matplotlib.pyplot.title",
"matplotlib.pyplot.tight_layout",
"sklearn.metrics.confusion_matrix",
"torch.flatten",
"matplotlib.pyplot.show",
"numpy.count_nonzero",
"scipy.io.savemat",
"ogb.nodeproppred.DglNodePropPredDataset",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.colorbar",
"numpy.all... | [((198, 239), 'ogb.nodeproppred.DglNodePropPredDataset', 'DglNodePropPredDataset', ([], {'name': '"""ogbn-arxiv"""'}), "(name='ogbn-arxiv')\n", (220, 239), False, 'from ogb.nodeproppred import DglNodePropPredDataset, Evaluator\n'), ((1793, 1821), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(15, 12)'}), ... |
"""
This tutorial shows how to generate adversarial examples
using JSMA in white-box setting.
The original paper can be found at:
https://arxiv.org/abs/1511.07528
"""
# pylint: disable=missing-docstring
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __f... | [
"numpy.sum",
"numpy.argmax",
"cleverhans.utils.AccuracyReport",
"cleverhans.compat.flags.DEFINE_integer",
"cleverhans.attacks.SaliencyMapMethod",
"cleverhans.compat.flags.DEFINE_float",
"tensorflow.compat.v1.app.run",
"cleverhans.train.train",
"tensorflow.compat.v1.global_variables_initializer",
"... | [((2036, 2052), 'cleverhans.utils.AccuracyReport', 'AccuracyReport', ([], {}), '()\n', (2050, 2052), False, 'from cleverhans.utils import pair_visual, grid_visual, AccuracyReport\n'), ((2106, 2140), 'tensorflow.compat.v1.set_random_seed', 'tf.compat.v1.set_random_seed', (['(1234)'], {}), '(1234)\n', (2134, 2140), True,... |
'''Example script showing how to use stateful RNNs
to model long sequences efficiently.
'''
from __future__ import print_function
import numpy as np
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Dense, LSTM
# since we are using stateful rnn tsteps can be set to 1
tsteps ... | [
"matplotlib.pyplot.title",
"matplotlib.pyplot.subplot",
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"keras.layers.LSTM",
"numpy.zeros",
"numpy.mean",
"keras.layers.Dense",
"numpy.exp",
"numpy.cos",
"keras.models.Sequential"
] | [((1423, 1435), 'keras.models.Sequential', 'Sequential', ([], {}), '()\n', (1433, 1435), False, 'from keras.models import Sequential\n'), ((2135, 2155), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(2)', '(1)', '(1)'], {}), '(2, 1, 1)\n', (2146, 2155), True, 'import matplotlib.pyplot as plt\n'), ((2156, 2181), 'matpl... |
from os.path import dirname, join
import numpy as np
import pandas.io.sql as psql
import sqlite3 as sql
from bokeh.plotting import figure
from bokeh.layouts import layout, widgetbox
from bokeh.models import ColumnDataSource, ColumnData, HoverTool, Div
from bokeh.models.widgets import Slider, Select, TextInput, DataTa... | [
"pandas.io.sql.read_sql",
"bokeh.models.ColumnDataSource",
"bokeh.models.widgets.TextInput",
"bokeh.plotting.figure",
"bokeh.layouts.widgetbox",
"os.path.dirname",
"bokeh.models.widgets.DataTable",
"bokeh.layouts.layout",
"bokeh.io.curdoc",
"numpy.where",
"sqlite3.connect",
"bokeh.models.Hover... | [((470, 493), 'sqlite3.connect', 'sql.connect', (['movie_path'], {}), '(movie_path)\n', (481, 493), True, 'import sqlite3 as sql\n'), ((561, 587), 'pandas.io.sql.read_sql', 'psql.read_sql', (['query', 'conn'], {}), '(query, conn)\n', (574, 587), True, 'import pandas.io.sql as psql\n'), ((607, 655), 'numpy.where', 'np.w... |
import numpy as np
from unittest.mock import patch, ANY
from .base_test_class import DartsBaseTestClass
from ..utils import timeseries_generation as tg
from ..metrics import mape
from ..logging import get_logger
from ..dataprocessing.transformers import Scaler
from ..datasets import AirPassengersDataset
from darts.mod... | [
"numpy.random.seed",
"torch.manual_seed",
"darts.utils.likelihood_models.GaussianLikelihood",
"darts.utils.timeseries_generation.linear_timeseries",
"unittest.mock.patch"
] | [((1769, 1787), 'numpy.random.seed', 'np.random.seed', (['(42)'], {}), '(42)\n', (1783, 1787), True, 'import numpy as np\n'), ((1796, 1817), 'torch.manual_seed', 'torch.manual_seed', (['(42)'], {}), '(42)\n', (1813, 1817), False, 'import torch\n'), ((12592, 12660), 'unittest.mock.patch', 'patch', (['"""darts.models.for... |
import matplotlib
matplotlib.use('Agg')
#from plotnine import *
#from pandas.api.types import CategoricalDtype
from .config import REF_LABELCOUNTS, REF_DISEASECODES
import glob
import re
import pandas as pd
import numpy as np
import os, sys
#### Get class sizes
labelsize_df = pd.read_csv(REF_LABELCOUNTS, delimiter="\... | [
"sys.stdout.write",
"pandas.DataFrame",
"re.split",
"pandas.read_csv",
"pandas.merge",
"matplotlib.use",
"numpy.array"
] | [((18, 39), 'matplotlib.use', 'matplotlib.use', (['"""Agg"""'], {}), "('Agg')\n", (32, 39), False, 'import matplotlib\n'), ((279, 336), 'pandas.read_csv', 'pd.read_csv', (['REF_LABELCOUNTS'], {'delimiter': '"""\t"""', 'header': 'None'}), "(REF_LABELCOUNTS, delimiter='\\t', header=None)\n", (290, 336), True, 'import pan... |
# import the necessary packages
from imutils.video import VideoStream
import numpy as np
import imutils
import time
import cv2
import tensorflow as tf
from keras.preprocessing import image
#use this latter for bounding box
resMap = {
1 : 'Mask On',
0 : 'Kindly Wear Mask'
}
colorMap = {
1 :... | [
"tensorflow.keras.models.load_model",
"cv2.putText",
"cv2.waitKey",
"cv2.imshow",
"time.sleep",
"cv2.rectangle",
"numpy.array",
"cv2.dnn.readNetFromCaffe",
"imutils.resize",
"cv2.destroyAllWindows",
"numpy.round",
"cv2.resize"
] | [((782, 819), 'tensorflow.keras.models.load_model', 'tf.keras.models.load_model', (['mask_path'], {}), '(mask_path)\n', (808, 819), True, 'import tensorflow as tf\n'), ((925, 978), 'cv2.dnn.readNetFromCaffe', 'cv2.dnn.readNetFromCaffe', (['prototext_path', 'caffe_model'], {}), '(prototext_path, caffe_model)\n', (949, 9... |
#!/usr/bin/env python3
'''
This process finds calibration values. More info on what these calibration values
are can be found here https://github.com/commaai/openpilot/tree/master/common/transformations
While the roll calibration is a real value that can be estimated, here we assume it's zero,
and the image input into ... | [
"cereal.log.Event.from_bytes",
"gc.disable",
"numpy.abs",
"numpy.arctan2",
"common.transformations.camera.get_view_frame_from_road_frame",
"numpy.isnan",
"numpy.clip",
"numpy.mean",
"common.transformations.orientation.rot_from_euler",
"numpy.tile",
"common.realtime.set_realtime_priority",
"sel... | [((1020, 1036), 'numpy.radians', 'np.radians', (['(0.25)'], {}), '(0.25)\n', (1030, 1036), True, 'import numpy as np\n'), ((1059, 1072), 'numpy.radians', 'np.radians', (['(2)'], {}), '(2)\n', (1069, 1072), True, 'import numpy as np\n'), ((1347, 1360), 'numpy.radians', 'np.radians', (['(2)'], {}), '(2)\n', (1357, 1360),... |
import math
import argparse
import codecs
from collections import defaultdict
import random
import numpy as np
"""
This file is part of the computer assignments for the course DD1418/DD2418 Language engineering at KTH.
Created 2018 by <NAME> and <NAME>.
"""
class Generator(object) :
"""
This class generates w... | [
"collections.defaultdict",
"codecs.open",
"math.pow",
"numpy.random.choice"
] | [((675, 692), 'collections.defaultdict', 'defaultdict', (['dict'], {}), '(dict)\n', (686, 692), False, 'from collections import defaultdict\n'), ((1993, 2028), 'codecs.open', 'codecs.open', (['filename', '"""r"""', '"""utf-8"""'], {}), "(filename, 'r', 'utf-8')\n", (2004, 2028), False, 'import codecs\n'), ((3967, 4017)... |
import warnings
warnings.filterwarnings('ignore')
import random
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
plt.style.use("seaborn-darkgrid")
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
from torchvision.m... | [
"matplotlib.pyplot.show",
"torch.nn.BCELoss",
"matplotlib.pyplot.plot",
"warnings.filterwarnings",
"matplotlib.pyplot.legend",
"numpy.nonzero",
"matplotlib.pyplot.style.use",
"matplotlib.pyplot.figure",
"numpy.arange",
"torch.cuda.is_available",
"torch.optim.lr_scheduler.step",
"torch.device",... | [((16, 49), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (39, 49), False, 'import warnings\n'), ((151, 184), 'matplotlib.pyplot.style.use', 'plt.style.use', (['"""seaborn-darkgrid"""'], {}), "('seaborn-darkgrid')\n", (164, 184), True, 'import matplotlib.pyplot as plt\n')... |
from chaotic_neural_networks import utils, networkA
import matplotlib.pyplot as plt
import numpy as np
t_max = 2400
# Target function: Triangle-wave
#network = networkA.NetworkA()
# Target function: Sum of sinusoids
#network = networkA.NetworkA(f=utils.periodic)
# Target functions: sum of sinusoids AND triangle-wav... | [
"matplotlib.pyplot.show",
"numpy.arange",
"chaotic_neural_networks.networkA.NetworkA"
] | [((459, 511), 'chaotic_neural_networks.networkA.NetworkA', 'networkA.NetworkA', ([], {'nb_outputs': '(3)', 'f': 'utils.per_tri_cos'}), '(nb_outputs=3, f=utils.per_tri_cos)\n', (476, 511), False, 'from chaotic_neural_networks import utils, networkA\n'), ((522, 553), 'numpy.arange', 'np.arange', (['(0)', 't_max', 'networ... |
'Tests for the subspace models.'
# pylint: disable=C0413
# Not all the modules can be placed at the top of the files as we need
# first to change the PYTHONPATH before to import the modules.
import sys
sys.path.insert(0, './')
sys.path.insert(0, './tests')
import glob
import yaml
import math
import unittest
import nu... | [
"yaml.load",
"numpy.trace",
"numpy.sum",
"numpy.log",
"beer.PPCA.sufficient_statistics",
"beer.create_model",
"numpy.eye",
"torch.eye",
"torch.randint",
"sys.path.insert",
"torch.randn",
"numpy.identity",
"numpy.linalg.slogdet",
"beer.models.ppca.kl_div_std_norm",
"math.log"
] | [((203, 227), 'sys.path.insert', 'sys.path.insert', (['(0)', '"""./"""'], {}), "(0, './')\n", (218, 227), False, 'import sys\n'), ((228, 257), 'sys.path.insert', 'sys.path.insert', (['(0)', '"""./tests"""'], {}), "(0, './tests')\n", (243, 257), False, 'import sys\n'), ((830, 884), 'beer.models.ppca.kl_div_std_norm', 'b... |
"""The :mod:`population` module defines an evolutionary population of Individuals."""
from collections.abc import Sequence
from bisect import insort_left
import numpy as np
import pickle
from multiprocessing import Pool
from functools import partial
from pyshgp.gp.individual import Individual
from pyshgp.gp.evaluation... | [
"bisect.insort_left",
"functools.partial",
"numpy.array",
"pickle.dumps"
] | [((1864, 1907), 'functools.partial', 'partial', (['_eval_indiv'], {'evalr': 'evaluator_proxy'}), '(_eval_indiv, evalr=evaluator_proxy)\n', (1871, 1907), False, 'from functools import partial\n'), ((2488, 2538), 'numpy.array', 'np.array', (['[i.error_vector for i in self.evaluated]'], {}), '([i.error_vector for i in sel... |
"""
$Revision: 1.7 $ $Date: 2010-06-14 12:53:12 $
Author: <NAME>
Affiliation: Space Telescope - European Coordinating Facility
"""
from __future__ import absolute_import, print_function
__author__ = "<NAME> <<EMAIL>>"
__date__ = "$Date: 2011-04-25 13:46:00 $"
__version__ = "$Revision: 1.8 $"
__credits__ = """This soft... | [
"numpy.absolute",
"numpy.maximum",
"os.unlink",
"astropy.io.fits.PrimaryHDU",
"numpy.greater",
"numpy.ones",
"os.path.isfile",
"astropy.io.fits.HDUList",
"pyraf.iraf.drizzle",
"multidrizzle.quickDeriv.qderiv",
"pyraf.iraf.blot",
"numpy.fabs",
"numpy.less",
"os.access",
"stsci.image.numco... | [((1360, 1383), 'pyraf.iraf.unlearn', 'iraf.unlearn', (['"""drizzle"""'], {}), "('drizzle')\n", (1372, 1383), False, 'from pyraf import iraf\n'), ((2142, 2465), 'pyraf.iraf.drizzle', 'iraf.drizzle', ([], {'data': 'data', 'outdata': 'outdata', 'outweig': 'outweig', 'in_mask': 'in_mask', 'wt_scl': 'wt_scl', 'coeffs': 'co... |
#!/usr/bin/env python3
"""
Copyright (c) Facebook, Inc. and its affiliates.
All rights reserved.
This source code is licensed under the license found in the LICENSE file in the
root directory of this source tree.
Util functions for evaluating the DST model predictions.
The script includes a main function which t... | [
"json.dump",
"copy.deepcopy",
"argparse.ArgumentParser",
"numpy.sqrt"
] | [((10227, 10243), 'copy.deepcopy', 'copy.deepcopy', (['c'], {}), '(c)\n', (10240, 10243), False, 'import copy\n'), ((10309, 10334), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (10332, 10334), False, 'import argparse\n'), ((9601, 9617), 'numpy.sqrt', 'np.sqrt', (['n_total'], {}), '(n_total)\n... |
#!/usr/bin/env python
import numpy as np
import mirheo as mir
ranks = (1, 1, 1)
domain = (16, 16, 8)
u = mir.Mirheo(ranks, domain, dt=0, debug_level=3, log_filename='log', no_splash=True)
center=(domain[0]*0.5, domain[1]*0.5)
wall = mir.Walls.Cylinder("cylinder", center=center, radius=domain[1]*0.4, axis="z", insi... | [
"mirheo.Walls.Cylinder",
"mirheo.Mirheo",
"numpy.savetxt"
] | [((109, 195), 'mirheo.Mirheo', 'mir.Mirheo', (['ranks', 'domain'], {'dt': '(0)', 'debug_level': '(3)', 'log_filename': '"""log"""', 'no_splash': '(True)'}), "(ranks, domain, dt=0, debug_level=3, log_filename='log',\n no_splash=True)\n", (119, 195), True, 'import mirheo as mir\n'), ((238, 335), 'mirheo.Walls.Cylinder... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.