text string |
|---|
from cmath import exp
from msapy import msa, utils as ut
import pytest
# ------------------------------#
# A function that assigns 1 to the cause and 0 to others
def simple(complements):
contribution = {"score_1": 1, "score_2": 1}
if 'a' in complements:
contribution['score_1'] = 0
if 'b' in comple... |
<filename>src/model/normalization.py
import typing
import mesh_tensorflow as mtf
import numpy as np
import tensorflow as tf
from scipy.special import erfinv
from .backend import normal_var, SHAPE
from ..dataclass import BlockArgs
from ..mtf_wrapper import einsum, reduce_mean, rsqrt_eps, square
from ..utils_mtf import... |
from scipy.optimize import curve_fit
from scipy import signal
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from scipy.interpolate import interp1d
import os
from qutip import *
def lorentzian_func(f, A, f_r, Q, c):
return A*(f_r/Q)/((f_r/Q)**2 + 4*(f-f_r)**2)**0.5 + c
def lin_func(x, a,... |
<reponame>Wizard-collab/wizard_2
# coding: utf-8
# Author: <NAME>
# Contact: <EMAIL>
# Python modules
from PyQt5 import QtWidgets, QtCore, QtGui
from PyQt5.QtCore import pyqtSignal
import json
import statistics
# Wizard gui modules
from wizard.gui import gui_utils
from wizard.gui import gui_server
from wizard.gui imp... |
#!/usr/bin/env python
import argparse
import os, os.path
import math
import numpy as np
from scipy.stats import gamma
import matplotlib.pyplot as plt
def main():
parser = argparse.ArgumentParser()
parser.add_argument("outfile")
args = parser.parse_args()
ts = list(map(lambda x: x + 1, range(10)))
plt.clf()
... |
<reponame>RPGroup-PBoC/chann_cap
#%%
import os
import glob
import numpy as np
import scipy as sp
import pandas as pd
import re
import git
# Import libraries to parallelize processes
from joblib import Parallel, delayed
# Import matplotlib stuff for plotting
import matplotlib.pyplot as plt
import matplotlib.cm as cm
i... |
import torch
import torch.nn as nn
import torch.nn.functional as F
from libcity.model.abstract_traffic_state_model import AbstractTrafficStateModel
import torch
import torch.nn.functional as F
from torch.nn.modules.module import Module
from torch.nn.parameter import Parameter
import numpy as np
from libcity.model impor... |
import csv
import os,sys
# Add utils to the path
# sys.path.insert(0, os.getcwd() + '/utils/')
# import Parsers as parsers
import pickle
import numpy, scipy.io
from xml.etree.ElementTree import iterparse
from collections import defaultdict
class DrugBankParser(object):
"""
DrugBANK fast parser.
Modi... |
<filename>structure/abstract_note.py
"""
File: abstract_note.py
Purpose: AbstractNote, the root class behind all note constructs
"""
from abc import ABCMeta, abstractmethod
from timemodel.offset import Offset
from timemodel.position import Position
from fractions import Fraction
class AbstractNote(object):
"""... |
<gh_stars>0
"""
Special functions for DimeNet and SpookyNet.
Dimenet functions taken directly from
https://github.com/klicperajo/
dimenet/blob/master/dimenet/model/
layers/basis_utils.py.
"""
import numpy as np
from scipy.optimize import brentq
from scipy import special as sp
import sympy as sym
import copy
import to... |
import numpy as np
import matplotlib.pyplot as plt
from components.utilities.misc import print_orthogonal
from components.utilities.load_write import read_image, load
from components.utilities.VTKFunctions import render_volume
from components.processing.clustering import kmeans_scikit, segment_clusters
from joblib imp... |
<reponame>HaotianZhang96/FDS_2020_2021
# import packages: numpy, math (you might need pi for gaussian functions)
import numpy as np
import math
import matplotlib.pyplot as plt
from scipy.signal import convolve2d as conv2
"""
Gaussian function taking as argument the standard deviation sigma
The filter should be defin... |
# coding: utf-8
# In[30]:
from numpy import *
import pickle
# In[3]:
import sys
sys.path.append('../')
sys.path.append('../support/')
sys.path.append('../lung_segmentation/')
import os
from preprocessing import *
from ct_reader import *
from scipy.ndimage import morphology
from tqdm import tqdm
import time
from o... |
# TODO maybe handle conversions using scipy
# img_as_float
# Convert to 64-bit floating point.
# img_as_ubyte
# Convert to 8-bit uint.
# img_as_uint
# Convert to 16-bit uint.
# img_as_int
# Convert to 16-bit int.
# TODO allow add or remove ROIs --> create IJ compatible ROIs... --> in a way that is simpler than the cro... |
import numpy as np
from scipy import signal
# 1 sample delay: u[n] = x[n] + x[n-1]
# 1 sample delay: y[n] = u[n] + u[n-1]
# Final equation: y[n] = x[n] + x[n-1] + x[n-1] + x[n-2]
# y[n] = x[n] + 2*x[n-1] + x[n-2]
# Two series LPFs with the system gain normalized
b = [0.25,0.5,0.25]
# Single LPF diffe... |
# From: https://raw.githubusercontent.com/skollmann/PyFactorise/master/factorise.py
#!/usr/bin/python3 -O
from math import sqrt, log2, ceil, floor
import random
from fractions import gcd
import sys
from builtins import ValueError
"""This script factorises a natural number given as a command line
parameter into its p... |
#!/usr/bin/python
# -*- coding: utf-8 -*-
__author__ = 'ar'
import cv2
import time
import shutil
import os
import math
from scipy import ndimage
import matplotlib.pyplot as plt
import skimage.io as skio
import skimage.transform as sktf
import skimage.morphology as skmorph
import skimage.exposure as skexp
import numpy ... |
import os
import sys
import timeit
import pdb
import math
import numpy as np
import pickle
import pandas as pd
import scipy.sparse as ss
import argparse
dirs = os.environ['PETSC_DIR']
sys.path.insert(0, dirs+'/bin/')
try:
import PetscBinaryIO
except:
print('Failed to import Petsc, check PETSC_DIR environme... |
from sacred import Ingredient
import torch.multiprocessing as mp
import json
import torch
from .data.graph import eval_reconstruction
from .embed_save import load_model
from .logging_thread import write_tensorboard, write_log
from embedding_evaluation.process_benchmarks import process_benchmarks
from .graph_embeddi... |
#!/usr/bin/env python
#imports go here
import rospy
from geometry_msgs.msg import Twist
from utils import *
import tf
import tf.transformations as tfs
import numpy as np
import scipy as scp
import math
# import teleop_custom as tele
import dynamic_reconfigure.client as dyn
from geometry_msgs.msg import Twist
from se... |
<reponame>rcarson3/pyFEpX
import os
import numpy as np
import scipy as sci
import Misori as mis
import Rotations as rot
import Utility as utl
from scipy import optimize as sciop
'''
List of all functions available in this module
LoadQuadrature(qname)
calcVol(crd, con)
centroidTet(crd, con)
localConnectCrd(mesh, grNum)... |
# import external libraries so pyinstaller includes them
import cProfile
import timeit
import json
import logging
import pytweening
import statistics
import pygame
from pygame.locals import *
from scripts import __main__
__main__.main()
|
import numpy as np
import spikeextractors as se
from scipy.optimize import linear_sum_assignment
class SortingComparison():
def __init__(self, sorting1, sorting2, delta_tp=20):
self._sorting1 = sorting1
self._sorting2 = sorting2
self._delta_tp = delta_tp
self._do_comparison()
... |
import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import find_peaks
data = np.genfromtxt('slides.csv', delimiter=",", dtype=np.float, encoding='ascii', skip_header=0)
beginnings = np.where(data[:-1,1] != data[1:,1])[0]
data = np.vsplit(data,beginnings+1)
data = data[2:] #first run was with
sli... |
import sys; sys.path.append("../../")
import os
import datetime
import numpy as np
import scipy
import scipy.stats
import scipy.optimize
from ecpn_src.data_analysis import basic_stats, bootstrap, fetch_data_npz, get_file_dict, Binder_parameter
def main_postprocessing(f_name, t_eq=0):
# -- READ IN RAW DATA
N ... |
import numpy as np
import os
import scipy.io as sio
import plotly.graph_objects as go
import time
HW8_data_file_dir = os.path.join("Data-Part-B","Data-Problem-8")
Dataset_file = os.path.join(HW8_data_file_dir,"dataset.dat")
joint_file = os.path.join(HW8_data_file_dir,"joint.dat")
# assign numbers sequ
name_of_nodes ... |
<reponame>timothydmorton/fpp-old
from numpy import *
#from utils import *
from consts import *
import scipy
from scipy.interpolate import interp1d
import math
import scipy.stats as stats
import numpy.random as rand
import sys,re,os
#DATAFOLDER = os.environ['ASTROUTIL_DATADIR'] #'/Users/tdm/Dropbox/astroutil/data'
#ko... |
<filename>Ramachandran_plot_analysis.py
###############################################
##<NAME>, 2020##
##N-to-C-terminus assymetry in protein domain secondary structure elements composition##
#Pareses DSSP output generated for representative structures with Run_DSSP.py
#Makes Ramachandran plots for N- and C-termini ... |
<filename>wxprofilers/_hmrf.py
'''
Estimate measurement confidence using a hidden markov random field model
'''
from wxprofilers._segmentation import Segmentation
from wxprofilers._segmentation.segmentation import nonzero, log
import numpy as np
import xarray as xr
from scipy.ndimage import uniform_filter, median_filt... |
# Standard library
import os, abc
import numpy as np
from copy import deepcopy
# Third-party
from scipy.interpolate import interp1d
from astropy.table import Table
from astropy import units as u
# Project
from ..util import check_random_state, check_units, MIST_PATH
from ..log import logger
from ..filters import *
f... |
# coding: utf-8
from collections import OrderedDict
from sympy import symbols
from sympy import Tuple
from sympy import Matrix
from sympy import srepr
from sympde.core import Constant
from sympde.calculus import grad, dot, inner
from sympde.topology import Domain, element_of
from sympde.topology import get_index_der... |
# ------------------------------------------------------------------------------
# Copyright (c) Microsoft
# Licensed under the MIT License.
# The code is based on deep-high-resolution-net.pytorch.
# (https://github.com/leoxiaobin/deep-high-resolution-net.pytorch)
# Modified by <NAME> (<EMAIL>).
# ---------------------... |
<filename>assignment3/sixteen_exp.py<gh_stars>0
import matplotlib.pyplot as plt
from sklearn.decomposition import FastICA
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
import pandas as pd
import numpy as np
import scipy.stats as stats
from scipy.stats import norm, kurtosis
import seaborn as sns
f... |
<filename>source/transforms/transform_function.py
import numpy as np
from statsmodels.distributions.empirical_distribution import ECDF
from scipy.stats import norm
class TransformFunction():
def __init__(self, X, cont_indices, ord_indices):
self.X = X
self.ord_indices = ord_indices
self.con... |
<reponame>st3107/pdfstream
import typing as tp
from collections import namedtuple
from configparser import ConfigParser
from pathlib import Path
import matplotlib.pyplot as plt
import numpy as np
import scipy.optimize as opt
from bluesky.callbacks.stream import LiveDispatcher
from diffpy.pdfgetx import PDFGetter, PDFC... |
<reponame>samuelpucek/ep-stats
import pandas as pd
import numpy as np
import scipy.stats as st
from statsmodels.stats.multitest import multipletests
import warnings
class Statistics:
"""
Various methods needed to evaluate experiment.
"""
@classmethod
def ttest_evaluation(cls, stats: np.array, con... |
import psi4
import resp
import ele
import numpy as np
import yaml
import os
import shutil
from rdkit import Chem
from rdkit.Chem import AllChem
from pathlib import Path
from iteround import saferound
from rdkit.Geometry.rdGeometry import Point3D
from scipy.spatial.transform import Rotation
from .utils import canonic... |
<filename>postprocessing/kmeans_test.py
# Create 50 datapoints in two clusters a and b
import numpy as np
from scipy.cluster.vq import kmeans, whiten
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
pts = 50
rng = np.random.default_rng()
a = rng.multivariate_normal([0, 0], [[4, 1], [1, 4]... |
"""
Inferring a binomial proportion via exact mathematical analysis.
"""
import sys
import numpy as np
from scipy.stats import beta
from scipy.special import beta as beta_func
import matplotlib.pyplot as plt
import matplotlib.patches as patches
#from HDIofICDF import *
from scipy.optimize import fmin
#from scipy.stats ... |
<filename>challenge-03/peguerosdc/classical-solver.py
# Generate QUBO equation
def qubo(n):
import itertools
from sympy import symbols
# create variables for n qubits
q = symbols([f"q{i}" for i in range(n)])
a = symbols([f"a{i}" for i in range(n)])
b = symbols([f"b{i}{j}" for i,j in itertools.co... |
# a collection of function to help search and identify molecular and ion lines
# by <NAME>
# <EMAIL>
# History:
# 2021.07.18, release
from collections import OrderedDict
import numpy as np
import scipy as sp
import matplotlib.pyplot as plt
import astropy.units as u
import astropy.constants as const
def print_l... |
<gh_stars>1-10
from random import Random
import math
import timeit
from time import localtime, gmtime, strftime
from scipy.spatial import Voronoi, Delaunay
import numpy as np
from map_gen.objects.line import Line
from map_gen.objects.mountain import Mountain
from map_gen.objects.point import Point
from map_gen.objec... |
import numpy as np
import numpy.random as npr
import scipy.linalg as spl
from test.assertions import QuaternionTest
from .context import pq, esoq, wahba, qmethod
class TestWahbaQMethod(QuaternionTest):
def test_qmethod(self):
q_inrtl_to_body_list = [
pq.identity(),
pq... |
# AUTOGENERATED! DO NOT EDIT! File to edit: nbs/04_evaluation.core.ipynb (unless otherwise specified).
__all__ = ['get_mean_probs', 'find_parens', 'mean_dist_probs', 'token_taxonomy', 'non_wordy', 'get_error_rates',
'get_error_rates_df', 'get_last_token_error_df', 'get_mean_cross_entropy', 'get_mean_probs',... |
<gh_stars>1-10
import scipy as sp
import matplotlib.pyplot as plt
# A class that will regenerate a fractal set as we zoom in, so that you
# can actually see the increasing detail.
class JuliaDisplay(object):
def __init__(self, h=400, w=400, niter=20, power=2.0, c=0.4+0.124j):
self.height = h
self.w... |
<filename>sparsejac_test.py
"""Tests for `sparsejac`."""
import jax
import jax.experimental.sparse as jsparse
import jax.numpy as jnp
import networkx
import numpy as onp
import scipy.sparse as ssparse
import unittest
import sparsejac
_SIZE = 50
class JacrevTest(unittest.TestCase):
def test_sparsity_shape_valid... |
from typing import (
List,
Tuple,
Dict,
Optional,
Union
)
import os
import sys
from overrides import overrides
import logging
from enum import Enum
import torch
import numpy as np
import scipy
from scipy import sparse
logger = logging.getLogger(name=__name__)
TensorType = Union[
np.ndarray,
... |
<gh_stars>1-10
from numpy import zeros, transpose, asarray, sum, diag, dot, arccos
from numpy.linalg import norm
import numpy
from scipy.linalg import svd, inv
from pattern.web import Wikipedia
import re, random
from math import *
from operator import itemgetter
from pattern.web import URL, Document, plaintext
# stopw... |
import SVMClassification as SVMC
from os import system
import numpy as np
import scipy.optimize as op
import matplotlib.pyplot as plt
SVMC.clearScreen()
dataTraining= SVMC.loadData("dataTraining.txt")
X=dataTraining[:,0:2]
y=dataTraining[:,2:3]
degree=1
theta =SVMC.initTheta(X,degree)
#theta = SVMC.gradientDescent(... |
from sklearn.base import BaseEstimator, TransformerMixin
import cv2
import scipy.signal as signal
from .base import FunctionFilter
import numpy as np
class GaussianFilter(FunctionFilter):
def __init__(self, sigma, sz=0):
sz = sigma2sz(sigma) if sz <= 0 else sz
kernel = cv2.getGaussianKernel(sz, sig... |
<gh_stars>100-1000
import os
import numpy
import scipy
import chainer
from chainer_chemistry.dataset.graph_dataset.base_graph_data import PaddingGraphData # NOQA
def get_reddit_coo_data(dirpath):
"""Temporary function to obtain reddit coo data for GIN
(because it takes to much time to convert it to netwo... |
<reponame>chmcewan/Numnum<gh_stars>0
import numpy as np
import scipy as sp
import pandas as pd
import matplotlib.pyplot as mp
import Numnum
# NB: all unit testable functions need to be in this namespace
from kmeans import *
def iris(k=3):
data = pd.read_csv("test/iris.dat")
(means,clusts, err) ... |
<filename>code/pyseg/scripts/ga/render_sub_tomo_26s.py
"""
Renders template copies in a tomogram from a STAR file (GA 26s adaptation)
Input: - STAR file
- Reference tomogram
- Template pre-processing parameters
- Rigid transformations parameters
Output: - A set of VTK... |
import numpy as np
from PIL import Image
from scipy.signal import convolve2d
def matlab_style_gauss2D(shape=(3, 3), sigma=0.5):
"""
2D gaussian mask - should give the same result as MATLAB's
fspecial('gaussian',[shape],[sigma])
"""
m, n = [(ss - 1.) / 2. for ss in shape]
y, x = np.ogrid[-m:m +... |
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""Process wind data for adjacent years and save processed data to a NetCDF file per subset. Settings, such as target file name,
are imported from config.py.
Example::
$ python process_data.py : process all latitudes (all subsets)
$ python proces... |
#NR ionization yield class
#see the link below for the reason for the filtrations
#https://stackoverflow.com/questions/40845304/runtimewarning-numpy-dtype-size-changed-may-indicate-binary-incompatibility
import warnings
warnings.filterwarnings("ignore", message="numpy.dtype size changed")
warnings.filterwarnings("ignor... |
"""
Work in progress: This module contains functions to perform feature grouping
between multiple ms-runs/specfiles and the class Fgi and FgiContainer to
represent and store such groups.
"""
# Copyright 2015-2017 <NAME>, <NAME>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use th... |
<filename>Investigate_a_Dataset.py<gh_stars>1-10
#!/usr/bin/env python
# coding: utf-8
#
# # Investigation of the Dataset: No-show Medical Appointments
#
# ## Table of Contents
# <ul>
# <li><a href="#intro">Introduction</a></li>
# <li><a href="#wrangling">Data Wrangling</a></li>
# <li><a href="#eda">Exploratory Dat... |
<filename>tasks.py
from invoke import task, Collection, Task
import sys
import os
from pathlib import Path
import subprocess
import shutil
from datetime import datetime, timedelta, date
from pprint import pprint
from enum import Enum, auto, unique, Flag
from time import time, sleep
import json
import re
from textwrap i... |
<gh_stars>1-10
from itertools import product
from objects.grtensors.riccitensor import RicciTensor
from sympy import simplify
class RicciScalar(RicciTensor):
def __init__(self, metric_tensor, coord_sys):
"""
Creating the ricci scalar object
Args:
metric_tensor [list]: The met... |
#!/usr/bin/env python3
import json
from collections import defaultdict
import dateutil.parser
import datetime
import numpy as np
import scipy.stats as stats
issue_data = "data/lz_issues_combined"
with open(issue_data) as f:
combined = json.load(f)
pulls = [issue for issue in combined if 'pull_request' in issu... |
<filename>QDTModel.py<gh_stars>1-10
from __future__ import division
from scipy import stats, std
import numpy
import warnings
from DecisionMaking.Configuration import ConfigurationError
from DecisionMaking.Constants import *
from DecisionMaking.QModel import QState
from pprint import pprint
"""
Class to represen... |
import numpy as np
from scipy.special import gamma
from copy import deepcopy
class arfima(object):
def __init__(self, Ap = [], Aq = [], d = 0, infit=100):
self.Ap = Ap
self.Aq = Aq
self.order = d
self.infit = infit
if not isinstance(Ap, list):
raise Type... |
<reponame>leonnnop/Locater
# -*- coding: utf-8 -*-
import os
import sys
sys.path.append('.')
import cv2
import json
import uuid
import tqdm
import torch
import numpy as np
import os.path as osp
import scipy.io as sio
import torch.utils.data as data
import h5py
import random
from transformers import AutoTokenizer, Au... |
<reponame>Maddonix/deepflash2
# AUTOGENERATED! DO NOT EDIT! File to edit: nbs/02_data.ipynb (unless otherwise specified).
__all__ = ['show', 'calculate_weights', 'DeformationField', 'BaseDataset', 'RandomTileDataset', 'TileDataset']
# Cell
import os
import numpy as np
import imageio
import shutil
from joblib import P... |
<filename>mafa_process.py<gh_stars>0
# -*- coding: utf-8 -*-
import glob as gb
import os
import xml.etree.ElementTree as ET
from scipy.io import loadmat
def create_list_file():
save_train_path = '/home/helinfei/PycharmProjects/FaceBoxes.Attention/data/MAFA_TRAIN/img_list.txt'
save_test_path = '/home/helinfei/... |
import numpy as np
from .colors import get_gyor_color_gradient
from PIL import Image
from scipy import interpolate
from scipy.ndimage import zoom
import geopy.distance
import matplotlib as mpl
from matplotlib import cm
def _resize_mat(mat, size):
"""
size: new size - (rows, cols)
"""
assert mat.ndim =... |
<filename>zobs/orecharge/Gauges/Taos_recession_DGK_23dec2015.py
# <NAME> 18 DEC 2015
# Find gauge recession at R. Pueblo de Taos
# <EMAIL>
from __future__ import division
import datetime
import string
from dateutil import rrule
from matplotlib import pyplot as plt
from scipy.ndimage import filters
from scipy.signal imp... |
<reponame>CSMMLab/neuralEntropyClosures<filename>callNeuralClosure.py<gh_stars>1-10
'''
This is the script that gets called from the C++ KiT-RT method MLOptimizer.cpp
It initializes and loads a neural Closure
The call method performs a prediction
Author: <NAME>
Version: 0.0
Date 29.10.2020
'''
### imports ###
# intern... |
import sys
from limix.core.type.observed import Observed
from hcache import Cached, cached
from limix.utils.preprocess import regressOut
from limix.core.utils import assert_finite_array
import scipy as sp
import numpy as np
import scipy.linalg as LA
import copy
class MeanBase(Cached, Observed):
"""
Basic mean... |
import tensorflow as tf
import math
from tqdm import tqdm
from hmc import hmc
from tensorflow.python.platform import flags
from torch.utils.data import DataLoader, Dataset
from models import DspritesNet
from utils import optimistic_restore, ReplayBuffer
import os.path as osp
import numpy as np
from rl_algs.logger impor... |
<filename>examples/dish_classification/deploy.py
#!/usr/bin/python
#coding=gbk
import json
import cv2
import os
import random
from scipy.misc import imread, imsave
import matplotlib.pyplot as plt
import caffe
import apollocaffe
import time
from utils import (image_jitter, image_to_h5, load_image_mean_from_binproto)... |
import numpy as np
import torch
from scipy.io.wavfile import read
from f0.yin import compute_yin
import matplotlib.pyplot as plt
def load_wav_to_torch(full_path):
sampling_rate, data = read(full_path)
return torch.FloatTensor(data.astype(np.float32)), sampling_rate
def get_f0(audio, sampling_rate=22050, frame... |
<filename>scripts/AtomicCliffords.py
"""
Created on Thu Feb 9 21:30:03 2012
Test script to play around with the single pulse single qubit Clifford gates achieved via phase-ramping.
"""
from __future__ import division
import numpy as np
from scipy.constants import pi
from scipy.linalg import expm
import matplotlib... |
<filename>sandbox/apps/python/multigrid/NAS-PB-MG-3.2/polymage_common.py
from __init__ import *
from fractions import Fraction
import sys
sys.path.insert(0, ROOT)
from compiler import *
from constructs import *
def set_zero_ghosts(r, ghosts):
for key in ghosts:
r.defn.append(Case(ghosts[key], 0.0))
... |
<reponame>Jianningli/autoimplant<filename>src/pred_2_org.py
import numpy as np
import nrrd
from glob import glob
import scipy
import scipy.ndimage
import random
from scipy.ndimage import zoom
def resizingbbox(data,z_dim):
a,b,c=data.shape
resized_data = zoom(data,(512/a,512/b,z_dim/c),order=2, mode... |
# -*- coding: utf-8 -*-
"""
Created on Fri Jan 19 00:04:22 2019
@author: keums
"""
import os
import click
import librosa
# os.environ['CUDA_DEVICE_ORDER']='PCI_BUS_ID'
# os.environ['CUDA_VISIBLE_DEVICES']=''
import numpy as np
from keras.utils import multi_gpu_model
import matplotlib.pyplot as plt
from scipy.signal ... |
# -*- coding: utf-8 -*-
"""
Created on Thu Feb 18 16:02:37 2021
@author: growolff
comportamiento del actuador para diferentes cargas en la salida
"""
import numpy as np
import scipy as sp
import scipy.signal
import matplotlib as mpl
from matplotlib import pyplot as plt
import numpy.polynomial.polynomial as poly
mpl.... |
import glob
import pickle
import random
import unittest
import matplotlib.pyplot as plt
import cv2
import numpy as np
import scipy.cluster.vq as vq
from src.Distance import NPCosineDistance
from src.Heuristic import CosineWordCountHeuristic
import time
import os
import ntpath
from os.path import basename
import re
im... |
from scipy.misc import comb
n = 1950
m = 1116
res = []
for k in xrange(m,n+1):
value = comb(n,k,exact=True)
res.append(value)
res = sum(res)%int(1e6)
print res
|
<filename>Scripts/control_temps_climatologies.py<gh_stars>1-10
"""
*Calculates average temperature per 100 years in CESM control*
"""
import numpy as np
from netCDF4 import Dataset
from scipy.stats import nanmean
years = '13000101-13991231'
### Import Tmax
def avetemps(years):
"""
Calculates average 2m maxT f... |
<gh_stars>0
import sys
import numpy as np
import scipy.spatial.distance as sp
import data
# computing covariance matrix for GP by means of SE kernel:
# depending on what Xs and Ys are, this can be K, K*, or K**.
# scipy.spatial.distance.pdist and .cdist are used to compute
# the matrix of squared Euclidian distance... |
# -*- encoding: utf-8 -*-
import numba
import numpy as np
import healpy as hp
from scipy.interpolate import griddata
from scipy.ndimage.interpolation import zoom
@numba.jit(nopython=True)
def binned_map(signal, pixidx, mappixels, hits, reset_map=True):
"""Project a TOD onto a map.
This function implements ... |
"""
Volume constants
Base unit: Litre
"""
from fractions import Fraction
# US liquid/fluid (volume in L) customary
# Note: US food labeling nutrition => oz = 30mL
FL_OZ = Fraction(0.0295735295625) # ounce
GILL = 4 * FL_OZ # gill, teacup
CUP = 8 * FL_OZ # cup
PT = 16 * FL_OZ ... |
import numpy as np
import pickle as pkl
import networkx as nx
import scipy.sparse as sp
from scipy.sparse.linalg.eigen.arpack import eigsh
import sys
from sklearn.neighbors import kneighbors_graph
from sklearn import svm
import time
import tensorflow as tf
def del_all_flags(FLAGS):
flags_dict = FLAGS._flags()
... |
# python version of falco_gen_dm_poke_cube.m
import sys
import os
import numpy as np
import scipy
import scipy.io as sio
from falco import utils # ceil_even, ceil_odd
sys.path.append('y:/src/Falco/falco-python/falco/')
def sind(tdeg):
return np.sin((np.pi / 180.) * tdeg)
def cosd(tdeg):
... |
# --------------------------------------------------------
# OIM
# Copyright (c) 2019 SenseTime Research
# Licensed under The MIT License [see LICENSE for details]
# Written by SenseTime Research (OICRLayer for reference)
# --------------------------------------------------------
"""The layer used during training for... |
import numpy as np
import scipy.optimize
def diffVector(angles, e11, e22, e33, e23, e13, e12):
phi = np.radians(angles[:, 0])
chi = np.radians(angles[:, 1])
omega = np.radians(angles[:, 2])
theta = np.radians(angles[:, 3])
delta = np.radians(angles[:, 4])
q1 = (
(np.cos(theta) * np.cos... |
<filename>vgg16_class_AE.py
"""
cifar10vgg.py
geifmany/cifar-vgg
https://github.com/geifmany/cifar-vgg/blob/master/cifar10vgg.py
"""
import numpy as np
import matplotlib.pyplot as plt
from scipy.misc import toimage
import keras
from keras.datasets import cifar10
from keras.models import Model
from keras.utils impor... |
import csv
import json
from . import prf, glm, plotting
import lmfit
import matplotlib.colors as mcolors
import matplotlib.pyplot as plt
import nibabel as nb
import nideconv as nd
import numpy as np
import operator
import os
import pandas as pd
from PIL import ImageColor
from prfpy import stimulus
import random
from sc... |
<filename>bin/test.py
"""
Test stuff!
"""
import os
import sys
import argparse
import scipy
import scipy.cluster.hierarchy as sch
import dateutil.parser
d = 'Thu Feb 11 16:39:56 -0800 2016'
z = dateutil.parser.parse(d)
print(z)
sys.exit(0)
X = scipy.randn(100, 2) # 100 2-dimensional observations
print(X)
d ... |
from typing import Optional
import numpy as np
import pandas as pd
from pyspark.sql import DataFrame
from pyspark.sql import types as st
from scipy.sparse import csc_matrix
from sklearn.linear_model import ElasticNet
from replay.models.base_rec import NeighbourRec
from replay.session_handler import State
class SLIM... |
# this is the python library created for using BigGAN in evolution.
import sys
from os.path import join
sys.path.append("C:/Users/zhanq/OneDrive - Washington University in St. Louis/GitHub/pytorch-pretrained-BigGAN")
# sys.path.append("E:\Github_Projects\pytorch-pretrained-BigGAN")
from pytorch_pretrained_biggan import... |
# coding=UTF-8
from builtins import print
import numpy as np
from sympy import *
from scipy import constants
import Star
import Planet
import Orbit
# ploting
import matplotlib.pyplot as plt
class Engine:
"""
:version:
:author:
"""
def __str__(self):
return self.print_status()
de... |
<reponame>CallumJHays/mathpad<filename>mathpad/_vector_space.py
"Note: Unfinished module!"
from typing import (
Any,
OrderedDict,
Union,
)
from sympy.vector import CoordSys3D
from mathpad.val import (
OutputVal,
)
R3 = CoordSys3D("ℝ3")
class VectorSpace(OutputVal):
def __init__(self, ordered_un... |
import cartopy.crs as ccrs
import matplotlib.pyplot as plt
import matplotlib.colors as colors
from loaders.load_uta_gitm_201602_newrun import *
import utilities.datetime_utilities as du
import visualization.time_series as ts
from geospacelab.visualization.mpl.geomap.geopanels import PolarMapPanel as PolarMap
import ge... |
<reponame>niuxinzhe/Paid-q-a
"""
OLS.py mainly trains OLS model and completes the OLS tests.
def OLS_train gets the OLS result and you can use the .summary() to see it.
def Pearson calculates the Pearson coefficient.
def multicollinearity_test is for multicollinearity test based on VIF
def normality_test uses K-S test... |
<filename>gen_matfile.py<gh_stars>0
import scipy.io as spio
import os
import numpy as np
import glob
from helperFunctions import classes
import utils
def setup_renderforcnn():
src = 'data/renderforcnn_orig'
dst = 'data/renderforcnn'
classes_map = {
'02691156':'aeroplane',
'02834778':'bicyc... |
#!/usr/bin/env python3
"""Generate gene regulatory network and time series expression data.
Functions:
main: Generate biologically plausible data.
gen_planted_edge_data: Phi-network model.
gen_adj_mat: Generate adjacency matrix.
"""
import sys
import numpy as np
from scipy.integrate import odeint
from scip... |
import matplotlib.pyplot as plt
import networkx as nx
import numpy as np
import seaborn as sns
import scipy
from scipy.optimize import minimize
from autoins.common import common, io
class AdjacentMatrixComputer():
def __call__(self, label_demo, nb_subgoal):
## (1) Count frequency
node_frequency =... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.