prompt stringlengths 19 1.03M | completion stringlengths 4 2.12k | api stringlengths 8 90 |
|---|---|---|
# ----------------------------------------------------------------------------
# Copyright (c) 2013--, scikit-bio development team.
#
# Distributed under the terms of the Modified BSD License.
#
# The full license is in the file COPYING.txt, distributed with this software.
# --------------------------------------------... | pd.RangeIndex(2) | pandas.RangeIndex |
# Functions for OCR block identification script
#
import io, json, sys, os, psycopg2, logging, subprocess, swifter, re, dateparser
from glob import glob
from pathlib import Path
from psycopg2.extras import RealDictCursor
from time import localtime, strftime
from fuzzywuzzy import fuzz
import pandas as pd
from datetime... | pd.DataFrame(counties_list) | pandas.DataFrame |
import re
import numpy as np
import pandas as pd
from sklearn.pipeline import Pipeline, make_pipeline
from sklearn.preprocessing import (
FunctionTransformer,
LabelBinarizer,
LabelEncoder,
OneHotEncoder,
OrdinalEncoder,
StandardScaler,
)
def transfrom_array_to_df_onehot(pl,nparray,oneh... | pd.DataFrame(nparray, columns=col_list) | pandas.DataFrame |
import datetime as dt
import sqlite3
from os import listdir
import numpy as np
import pandas as pd
import math
"""
ISSUES 12-15
NCATS_DEMOGRAPHICS and visit details - not even there
X Diagnoses ok
ACT Labs doesn't show up after "full list"
ACT Laboratory Tests no show at all
ACT Meds can't drill into
X Procedures ok
... | pd.read_csv(bigfullnamefile,index_col='c_fullname',delimiter=',',dtype='str',encoding='cp1252') | pandas.read_csv |
import pytest
import os
import pandas as pd
from lkmltools.bq_writer import BqWriter
from google.cloud.storage.blob import Blob
from google.cloud.bigquery.job import WriteDisposition
from google.cloud.bigquery.job import LoadJobConfig
def test_write_to_csv():
writer = BqWriter()
df = pd.DataFrame({"col1": [1,... | pd.DataFrame({"col1": [1, 2], "col2": [3, 4]}) | pandas.DataFrame |
# multivariate multihead multistep
from keras.layers import Flatten
from keras.layers import ConvLSTM2D
from keras.layers.merge import concatenate
from numpy import array
from numpy import hstack
from keras.models import Model
from keras.layers import Input
from keras.layers import Dense
from keras.layers import Reshap... | pd.read_csv(path+file) | pandas.read_csv |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Mar 5 10:15:25 2021
@author: lenakilian
"""
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import geopandas as gpd
from scipy.stats import pearsonr
ghg_year = 2015 # 2017
dict_cat = 'category_8' # replac... | pd.read_excel(wd + '/data/processed/LCFS/Meta/lcfs_desc_anne&john.xlsx') | pandas.read_excel |
# -*- coding: utf-8 -*-
"""
This library contains all functions needed to produce the spatial files
of a LARSIM raster model (tgb.dat, utgb.dat, profile.dat).
It uses functions from the TATOO core library.
Author: <NAME>
Chair for Hydrology and River Basin Management
Technical University of Munich
Req... | pd.Series(df_tgb_in.shape[0]*'', index=df_tgb_in.index, name=f_nrflv) | pandas.Series |
import os
from unittest.mock import patch
from itertools import product
import numpy as np
import pandas as pd
from pandas.testing import assert_frame_equal
from mavedbconvert import validators, enrich2, constants
from tests import ProgramTestCase
class TestEnrich2ParseInput(ProgramTestCase):
def setUp(self):
... | pd.HDFStore(self.path, mode="r") | pandas.HDFStore |
# Copyright 2021 AI Singapore. 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... | pd.DataFrame([[0.1, 2.5, 3.6], [0.5, 2.2, 6.6], [0.3, 2.3, 5.2]], columns=['x1', 'x2', 'x3']) | pandas.DataFrame |
# -*- coding: utf-8 -*-
import logging
logger = logging.getLogger('main_logger')
import pandas as pd
import dataset
import model
from torch.utils.data import DataLoader
import torch
import torch.nn as nn
from tqdm.auto import tqdm
def predict_effnet(conf):
device = torch.device('cuda:0' if torch.cuda.is_availa... | pd.read_csv(conf['dir_df_test']) | pandas.read_csv |
#!/usr/bin/env python
# coding: utf-8
# # Project 2 - GeoTweet
#
# @Author <NAME> (daddyjab)<br>
# @Date 3/25/19<br>
# @File ETL_for_GeoTweet
#
# # Dependencies
# In[1]:
# Dependencies
import tweepy
import json
import time
import os
import pandas as pd
from datetime import datetime
from dateutil import tz
impor... | pd.DataFrame.from_dict(trends_avail, orient='columns') | pandas.DataFrame.from_dict |
'''
Created on Feb. 25, 2020
@author: cefect
helper functions w/ Qgis api
'''
#==============================================================================
# imports------------
#==============================================================================
#python
import os, configparser, logging, inspect, copy, ... | pd.DataFrame.from_dict(fid_attvs, orient='index', columns=all_fnl) | pandas.DataFrame.from_dict |
import os
import pandas as pd
def get_data():
"""
Loads the data for the project.
"""
import os
import pandas as pd
pardir = os.path.abspath(os.path.join(os.getcwd(), os.pardir))
datadir = pardir + "\\Data"
datadir
offense = []
defense = []
offensel = []... | pd.concat(combined, ignore_index=True) | pandas.concat |
from collections import namedtuple
import dask.array as da
import dask.dataframe as dd
import numpy as np
import pandas as pd
import pandas.testing as tm
import pytest
from dask.array.utils import assert_eq as assert_eq_ar
from dask.dataframe.utils import assert_eq as assert_eq_df
from dask_ml.datasets import make_cl... | tm.assert_series_equal(result, expected) | pandas.testing.assert_series_equal |
import os
import tempfile
import pandas as pd
import pytest
from pandas.util import testing as pdt
from .. import simulation as sim
from ...utils.testing import assert_frames_equal
def setup_function(func):
sim.clear_sim()
sim.enable_cache()
def teardown_function(func):
sim.clear_sim()
sim.enable_... | pdt.assert_series_equal(table['b'], df['b']) | pandas.util.testing.assert_series_equal |
"""
Tests that work on both the Python and C engines but do not have a
specific classification into the other test modules.
"""
from datetime import datetime
from inspect import signature
from io import StringIO
import os
from pathlib import Path
import sys
import numpy as np
import pytest
from pandas.compat import P... | tm.ensure_clean(filename) | pandas._testing.ensure_clean |
"""
Created at EPFL 2020
@author: <NAME>meters
Placing detectors on edges
Input requirements:
- dataframe with edges, needed column names = 'N1', 'N2', 'length'
- Linestring column in x-y coordinates (needed for interpolate function) with name = 'geom'
Note: Linestring object can follow curves, not just straight line... | pd.concat([name, id_b], axis=1) | pandas.concat |
from dataclasses import replace
from tika import parser
import utils
import json
from datetime import datetime
import pandas as pd
pd.set_option('display.max_columns', None)
pd.set_option('display.width', None)
def get_meta_indices(alist):
for index, item in enumerate(alist):
if "AUSFAHRLISTE" in item:
... | pd.concat(dict_list) | pandas.concat |
import streamlit as st
import json
import requests
import pandas as pd
import numpy as np
import re
from datetime import datetime as dt
from datetime import time
import matplotlib.pyplot as plt
import seaborn as sns
import matplotlib
st.set_page_config(layout="centered",
page_title="Da... | pd.DataFrame(user_dict) | pandas.DataFrame |
"""Loads, standardizes and validates input data for the simulation.
Abstract the extract and transform pieces of the artifact ETL.
The intent here is to provide a uniform interface around this portion
of artifact creation. The value of this interface shows up when more
complicated data needs are part of the project. S... | pd.concat([world_bank_1, world_bank_2]) | pandas.concat |
## ÇOK DEĞİŞKENLİ REGRESYON İÇİN VERİ HAZIRLAMA
#------------------------------------------------------
## KÜTÜPHANELER
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
#---------------------------------
## VERİ YÜKLEME
veri = pd.read_csv("C:\\Users\\Computer\\Desktop\\python... | pd.concat([s,sonuc_2],axis=1) | pandas.concat |
# -*- coding:utf-8 -*-
# @Time : 2020/1/122:48
# @Author : liuqiuxi
# @Email : <EMAIL>
# @File : fundfeedsjqdata.py
# @Project : datafeeds
# @Software: PyCharm
# @Remark : This is class of option market
import pandas as pd
import datetime
import copy
from datafeeds.jqdatafeeds import BaseJqData
... | pd.DataFrame() | pandas.DataFrame |
from itertools import combinations
import pandas as pd
import pytest
mock_data = {
"block": [
1,
1,
2,
3,
2,
2,
2,
2,
1,
1,
1,
1,
1,
2,
3,
2,
3,
3,
3,
3,
... | pd.DataFrame(mock_data) | pandas.DataFrame |
"""
Authors: <NAME> and <NAME>
"""
from bloomberg import BBG
import pandas as pd
from sklearn import preprocessing
import numpy as np
import matplotlib.pyplot as plt
bbg = BBG()
min_max_scaler = preprocessing.MinMaxScaler()
# Pulling IBOVESPA and S&P indexes volatility, as well as general US and BR 10-year bonds
# ... | pd.DataFrame(data=df['GEBR10Y Index']) | pandas.DataFrame |
# -*- coding: utf-8 -*-
import pandas as pd
import os
DATASET_FOLDER = '../../datasets/'
def gen_worldbank_countries():
# Écrit un csv avec les pays et les codes associés des pays qui nous intéresses
df_des = dataframe_flood()
df = pd.DataFrame(df_des.groupby('Country')[['Country', 'ISO']].head(... | pd.read_excel(f'{DATASET_FOLDER}emdat_public_2020_09_12_query_uid-tAnKEX.xlsx', index_col=0) | pandas.read_excel |
# -*- coding: utf-8 -*-
import gc
import os
import pickle
import random
from argparse import ArgumentParser
import numpy as np
import pandas as pd
import torch
from transformers import GPT2Tokenizer
from experiment import Intervention, Model
from utils import convert_results_to_pd
np.random.seed(1)
torch.manual_see... | pd.concat([female_df, male_df]) | pandas.concat |
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import datetime
import os
import pandas as pd
deskPath = os.path.join(os.path.expanduser("~"), 'Desktop')
import csv
with open(deskPath+'\\ExportData.csv','r',encoding='UTF-8') as csvfile:
csv_reader = csv.reader(csvfile)
dates = []
cols = []
framedate = ... | pd.DataFrame(framedate, columns=cols, index=dates) | pandas.DataFrame |
"""
SIR 3S Logfile Utilities (short: Lx)
"""
__version__='192.168.3.11.dev1'
import os
import sys
import logging
logger = logging.getLogger(__name__)
import argparse
import unittest
import doctest
import nbformat
from nbconvert.preprocessors import ExecutePreprocessor
from nbconvert.preprocessor... | pd.DataFrame() | pandas.DataFrame |
### imports starts
import sys
from pathlib import Path
import pickle
import cv2
import pandas as pd
import numpy as np
import tensorflow as tf
from tensorflow.keras import Model
from tensorflow.keras.layers import Input
from tensorflow.keras.optimizers import Adam
util_dir = Path.cwd().parent.joinpath('Utility')
sy... | pd.read_csv(C.validation_bbox_reference_file, index_col=0) | pandas.read_csv |
from django.conf import settings
import pandas as pd
import os
info_path = os.path.join(settings.BASE_DIR, 'info.pkl')
fin_path = os.path.join(settings.BASE_DIR, 'fin.pkl')
mc_path = os.path.join(settings.BASE_DIR, 'mc.pkl')
info = pd.read_pickle(info_path)
fin = pd.read_pickle(fin_path)
mc = | pd.read_pickle(mc_path) | pandas.read_pickle |
import pandas as pd
def multiIDgnomad(CHR, position, ref, alt):
position_list = str(position).split(',')
chr_element = ['chr']*len(list(str(position).split(',')))
chr_list = [str(CHR)]*len(str(position).split(','))
chr_final = list(map("".join,list(zip(chr_element,chr_list))))
ref_list = str(ref).sp... | pd.read_csv('/path/to/gnomAD_info/gnomAD_rs_alleles_pop.info.csv',sep='\t') | pandas.read_csv |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import pandas as pd
log_data = open('./data/access.log', 'r')
fields = ['ts', 'elapsed', 'remhost', 'status', 'bytes',
'method', 'url', 'rfc931', 'peerstatus', 'type']
split_list = list()
for line in log_data:
ls = line.split()
l_type = ls[9]
l_ur... | pd.DataFrame(split_list, columns=['ts', 'remhost', 'url', 'file']) | pandas.DataFrame |
from __future__ import division
from datetime import timedelta
from functools import partial
import itertools
from nose.tools import assert_true
from parameterized import parameterized
import numpy as np
from numpy.testing import assert_array_equal, assert_almost_equal
import pandas as pd
from toolz import merge
fro... | pd.Timestamp('2015-01-12') | pandas.Timestamp |
from IPython import embed
import pandas as pd
import numpy as np
import os
import sys
sys.path.insert(0,'..')
from run_model import QuaLiKizDuoNN, QuaLiKizMultiNN, QuaLiKizNDNN, QuaLiKizComboNN
simple_nns = ['efe_GB',
'efi_GB',
]
# 'dfe_GB',
# 'dfi_GB',
# ... | pd.DataFrame() | pandas.DataFrame |
import json
import cv2
import pandas as pd
import numpy as np
from .process_steps import Analysis
from .parameters import SpotlobParameterSet
from .process_opencv import draw_contours, crop_to_contour
class CircleAnalysis(Analysis):
def __init__(self, calibration=None, extended_output=True):
self.calibr... | pd.DataFrame(res_dict) | pandas.DataFrame |
import forecaster as fc
import optimizer as opt
import trader as td
import datetime as dt
import utilities as util
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
def calc_start_date(end_date=dt.datetime(2017,1,1), data_size=12):
return end_date-dt.timedelta(weeks=int(data_size * 52/12))
de... | pd.concat([pv_current, pv_target, pv_new], keys=['Current', 'Target', 'New'], axis=1) | pandas.concat |
# Copyright (c) Facebook, Inc. and its affiliates.
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
# This file contains dummy data for the model unit tests
import numpy as np
import pandas as pd
AIR_FCST_LINEAR_95 = pd.DataFrame(
{
... | pd.Timestamp("2012-06-04 00:00:00") | pandas.Timestamp |
# Copyright 2017-2021 QuantRocket LLC - 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 applicabl... | pd.MultiIndex.from_product([fields, dt_idx], names=["Field", "Date"]) | pandas.MultiIndex.from_product |
__all__ = ["plot_centroids",
"plot_histogram",
"plot_scatter"]
try:
# noinspection PyUnresolvedReferences
from matplotlib import use
use('Agg')
# noinspection PyUnresolvedReferences
import matplotlib.pyplot as plt
# noinspection PyUnresolvedReferences
import matplotli... | pd.DataFrame(data) | pandas.DataFrame |
# -*- coding: utf-8 -*-
import numpy as np
import pytest
from numpy.random import RandomState
from numpy import nan
from datetime import datetime
from itertools import permutations
from pandas import (Series, Categorical, CategoricalIndex,
Timestamp, DatetimeIndex, Index, IntervalIndex)
import pan... | tm.assert_numpy_array_equal(result, expected) | pandas.util.testing.assert_numpy_array_equal |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Jan 3 10:14:40 2019
Adapted from code created as part of Udemy course: Deep
Learning A-Z™: Hands-On Artificial Neural Networks
(https://www.udemy.com/deep-learning-a-z/)
"""
# # Deep Learning: Stacked LSTM Recurrent Neural Network (RNN) Model in Pytho... | pd.DataFrame(data_test.iloc[:, 0:1].values) | pandas.DataFrame |
"""
Attempt to read and manipulate data using pandas, then plot some of it.
I've attempted to read in the ICP-OES file 'Whorley_C2016major_Grn.csv' and I'll try
to find the average and standard deviation of each analyte, 5 replicates per analyte.
"""
# Imports
import numpy as np
import matplotlib.pyplot as plt
import ... | pd.read_csv(in_fn) | pandas.read_csv |
"""Dynamic file checks."""
from dataclasses import dataclass
from datetime import date, timedelta
from typing import Dict, Set
import re
import pandas as pd
import numpy as np
from .errors import ValidationFailure, APIDataFetchError
from .datafetcher import get_geo_signal_combos, threaded_api_calls
from .utils import r... | pd.concat([api_frames, source_df]) | pandas.concat |
#!/usr/bin/env python
"""
Evaluation of conformal predictors.
"""
# Authors: <NAME>
# TODO: cross_val_score/run_experiment should possibly allow multiple to be evaluated on identical folding
from __future__ import division
from cqr.nonconformist_base import RegressorMixin, ClassifierMixin
import sys
import numpy ... | pd.DataFrame(scores) | pandas.DataFrame |
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# Created by <NAME>
import unittest
import pandas as pd
import pandas.testing as pdtest
from allfreqs import AlleleFreqs
from allfreqs.classes import Reference, MultiAlignment
from allfreqs.tests.constants import (
REAL_ALG_X_FASTA, REAL_ALG_X_NOREF_FASTA, REAL_RSRS_F... | pdtest.assert_frame_equal(self.af.frequencies, exp_freqs) | pandas.testing.assert_frame_equal |
"""Unit tests for compaction."""
from io import StringIO
import numpy as np # type: ignore
import pandas # type: ignore
from pytest import approx, mark, raises # type: ignore
from compaction import compact
from compaction.cli import load_config, run_compaction
def test_to_analytical() -> None:
c = 3.68e-8
... | pandas.DataFrame.from_dict({"dz": dz_0, "porosity": phi_0}) | pandas.DataFrame.from_dict |
# import start
import ast
import asyncio
import calendar
import platform
import subprocess as sp
import time
import traceback
import xml.etree.ElementTree as Et
from collections import defaultdict
from datetime import datetime
import math
import numpy as np
import pandas as pd
from Utility.CDPConfigValues import CDPC... | pd.DataFrame(exp, columns=["COMMIT_ID", "COMMITTER_TIMESTAMP", "EXP"]) | pandas.DataFrame |
from datetime import datetime
from decimal import Decimal
import numpy as np
import pytest
import pytz
from pandas.compat import is_platform_little_endian
from pandas import CategoricalIndex, DataFrame, Index, Interval, RangeIndex, Series
import pandas._testing as tm
class TestFromRecords:
def test_from_record... | DataFrame(data, columns=columns_names) | pandas.DataFrame |
'''
Implementation of SimpleImputer that returns Pandas DataFrame
'''
from pandas import DataFrame
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.impute import SimpleImputer
class DataFrameSimpleImputer(BaseEstimator, TransformerMixin):
def __init__(self, fit_params):
self.simple_im... | DataFrame(data, columns=X.columns.values) | pandas.DataFrame |
import pandas as pd
import random
import numpy as np
from multiprocessing import Pool
import time
import math
import itertools
from scipy.stats import binom as binom_stat, rankdata
from scipy.special import binom
from src.core.regression.accuracy_scores import \
hazard_ratio, \
dynamic_auc, \
logrank
fro... | pd.concat(all_result_dfs, axis=0) | pandas.concat |
# -*- coding: utf-8 -*-
"""
This module holds functions for processing the geometry for setting up
the geometry of a ThermalNetwork based on a street geometry and a table of
buildings.
This file is part of project dhnx (). It's copyrighted
by the contributors recorded in the version control history of the file,
avail... | pd.concat([lines, lines_consumers, lines_producers], sort=False) | pandas.concat |
import multiprocessing as mp
import os
import string
import warnings
import numpy as np
import pandas as pd
import uncertainties as un
from nptdms import TdmsFile
from numpy import NaN, sqrt
from scipy.stats import t
from tables import NoSuchNodeError
from uncertainties import unumpy as unp
from . import diodes
from ... | pd.HDFStore(loc_processed_h5, "a") | pandas.HDFStore |
import textwrap
import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from .utils import maybe_save_fig, shifted_color_map
def product_heatmap(*a, **kws):
return feature_loading_heatmap(
*a, original_features_axis_label='product name', **kws)
def feature_loadi... | pd.DataFrame(pca.components_[:n_components].T) | pandas.DataFrame |
import importlib
import inspect
import os
import warnings
from unittest.mock import patch
import cloudpickle
import numpy as np
import pandas as pd
import pytest
from skopt.space import Categorical
from evalml.exceptions import (
ComponentNotYetFittedError,
EnsembleMissingPipelinesError,
MethodPropertyNot... | pd.testing.assert_index_equal(X.index, X_original_index) | pandas.testing.assert_index_equal |
"""
The static functions for various calculations and required parameters
"""
# external packages
from astrodbkit2.astrodb import Database, REFERENCE_TABLES # used for pulling out database and querying
from astropy.coordinates import SkyCoord
from flask_wtf import FlaskForm # web forms
from markdown2 import markdown ... | pd.Series(thisnewphot.columns) | pandas.Series |
"""
5. Running Bycycle on 3D Arrays
===============================
Compute bycycle features for 3D organizations of timeseries.
Bycycle supports computing the features of 3D signals using :func:`~.compute_features_3d`.
Signals may be organized in a different ways, including (n_participants, n_channels, n_timepoints)... | pd.DataFrame() | pandas.DataFrame |
import calendar
from datetime import date, datetime, time
import locale
import unicodedata
import numpy as np
import pytest
import pytz
from pandas._libs.tslibs.timezones import maybe_get_tz
from pandas.core.dtypes.common import is_integer_dtype, is_list_like
import pandas as pd
from pandas import (
DataFrame, ... | date_range('20130101', periods=5) | pandas.date_range |
#
# Copyright (C) 2019 Databricks, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to i... | pd.Series([True, False, False, True, True, False, np.nan, np.nan, np.nan]) | pandas.Series |
from clean2 import*
import pandas as pd
import matplotlib.pyplot as plt
import math
import datetime
import time
def main():
loop_set=[3,5]
set3=[] #labels scaled at different window sizes
set4=[] #labels without scaling
for i in range(0,len(loop_set)):
set3.extend(['totalmovavg_predictclose... | pd.DataFrame() | pandas.DataFrame |
import datetime
import pandas as pd
singleton = None
def convert_receipt(receipt, contract_balance, block_info):
dict_receipt = dict(receipt)
new_dict = {"contract_balance" : str(contract_balance)}
receipt_include = ["transactionHash", "from", "to", "gasUsed"]
block_include = ["timestamp"] ## convert ... | pd.DataFrame.from_dict(block_chain) | pandas.DataFrame.from_dict |
import numpy as np
import pandas as pd
from domain.rastrigin.rastrigin_Categorize import rastrigin_Categorize
from domain.cube.cube_Categorize import cube_Categorize
from domain.wheelcase.wheelcase_Categorize import wheelcase_Categorize
# param: maximize indicates whether to search for max. fitness or not (min search)... | pd.DataFrame(data=df_bin.iloc[bestIndex,:]) | pandas.DataFrame |
import sys
import numpy as np
import pandas as pd
import json
import os
from joblib import Parallel, delayed
from gtad_lib import opts
thumos_class = {
7 : 'BaseballPitch',
9 : 'BasketballDunk',
12: 'Billiards',
21: 'CleanAndJerk',
22: 'CliffDiving',
23: 'CricketBowling',
24: 'CricketShot'... | pd.DataFrame() | pandas.DataFrame |
import pandas as pd
import dash
from dash.dependencies import Input, Output, State, MATCH, ALL
import dash_core_components as dcc
import dash_html_components as html
from dash.exceptions import PreventUpdate
import dash_bootstrap_components as dbc
import dash_table
import plotly.graph_objs as go
from threading impor... | pd.DataFrame(hdr_data) | pandas.DataFrame |
import pandas as pd
import numpy as np
import h5py as h5
from typing import Optional, Union
import datetime as dt
from audata.file import File as AuFile
"""
Wrapper for the audata File class
"""
class File (AuFile):
def __init__ (self,
file: h5.File,
time_reference: Optional[dt.... | pd.DataFrame(self['Mapping'].hdf[:]) | pandas.DataFrame |
import calendar
import datetime
import warnings
import numpy as np
import pandas as pd
from pandas.util.testing import assert_frame_equal, assert_series_equal
from numpy.testing import assert_allclose
import pytest
from pvlib._deprecation import pvlibDeprecationWarning
from pvlib.location import Location
from pvlib ... | assert_frame_equal(expected_solpos, ephem_data[expected_solpos.columns]) | pandas.util.testing.assert_frame_equal |
import os
import pandas as pd
from base import BaseFeature
from encoding_func import target_encoding
from google.cloud import storage, bigquery
from google.cloud import bigquery_storage_v1beta1
class CountEncodingPresentDomains(BaseFeature):
def import_columns(self):
return [
"tweet_id",
... | pd.merge(df_train_input, count_present_domains, on="tweet_id", how="left") | pandas.merge |
import json
import csv
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
from scipy import stats
from calibration import *
import pandas as pd
from eval_metrics import *
from tqdm import tqdm
from scipy.stats import norm
from scipy.stats import pearsonr
import argparse
import itertools
from os import... | pd.read_csv(da_dir) | pandas.read_csv |
"""Handle the raw data input/output and interface with external formats."""
from obspy.core import read
from obspy.core.utcdatetime import UTCDateTime
import pandas as pd
import datetime as dt
def load_stream(path):
"""Loads a Stream object from the file at path.
Args:
path: path to the input file, ... | pd.Series([t.timestamp for t in events]) | pandas.Series |
import numpy as np
import seaborn as sns
import matplotlib.pylab as plt
import math
import os
import pandas as pd
import re
def search_year(year, years):
for idx, _year in enumerate(years):
if idx == len(years) -1:
continue
if year >= _year and year < years[idx + 1]:
return ... | pd.DataFrame(topic_year[[i for i,cnt in result[ind*30:(ind+1)*30]]]) | pandas.DataFrame |
# @author <NAME>
#to merge the 3 different year ED visit files to single file
import pandas as pd
import os
import glob
import numpy as np
def seriesToTypes(series):
try:
series=series.astype("Int64")
except (TypeError,ValueError):
try:
series=pd.to_numeric(series,downcast='unsigne... | pd.concat([ip_df,df]) | pandas.concat |
__author__ = '<NAME>'
__email__ = '<EMAIL>'
__status__ = 'Development'
import numpy as np
import pandas as pd
import random
import math
from scipy.spatial.distance import cdist
from sklearn import metrics
from sklearn.cluster import KMeans
from sklearn.cluster import DBSCAN
from progress.bar import Bar
# read hillsl... | pd.DataFrame() | pandas.DataFrame |
import quandl
mydata = quandl.get("YAHOO/INDEX_DJI", start_date="2005-12-01", end_date="2005-12-05")
import pandas as pd
authtoken = '<PASSWORD>'
def get_data_quandl(symbol, start_date, end_date):
data = quandl.get(symbol, start_date=start_date, end_date=end_date, authtoken=authtoken)
return data
def... | pd.rolling_std(df['Volume'], window=5) | pandas.rolling_std |
import numpy as np
import pandas as pd
from six import string_types
from triage.component.catwalk.exceptions import BaselineFeatureNotInMatrix
OPERATOR_METHODS = {">": "gt", ">=": "ge", "<": "lt", "<=": "le", "==": "eq"}
REQUIRED_KEYS = frozenset(["feature_name", "operator", "threshold"])
def get_operator_method(op... | pd.concat(rule_evaluations_list, axis=1) | pandas.concat |
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from hash import *
class simulation:
def __init__(self, length=12096, mu=0, sigma=0.001117728,
b_target=10, block_reward=12.5, hash_ubd=55,
hash_slope=3, hash_center=1.5, prev_data=pd.DataFrame(),
... | pd.DataFrame() | pandas.DataFrame |
import os
import pandas as pd
import torch
from detectron2.data import MetadataCatalog
from detectron2.evaluation.evaluator import DatasetEvaluator
from pycocotools.coco import COCO
from dataset_utils import register_polyp_datasets, dataset_annots
class GianaEvaulator(DatasetEvaluator):
def __init__(self, datas... | pd.DataFrame(columns=["threshold", "TP", "FP", "TN", "FN", "RT"]) | pandas.DataFrame |
import csv
import typer
import os.path
import pandas as pd
from datetime import datetime
#from core import configmod as cfm
#from core import loggermod as lgm
file_svr = 'saved_report.csv'
def init(pbpath,dtcnt):
filepath = pbpath + "/" + file_svr
if not(os.path.exists(filepath)):
clm = {'date': [], '... | pd.DataFrame(clm) | pandas.DataFrame |
import os
import pickle
import warnings
from pathlib import Path
import numpy as np
import pandas as pd
import torch
from torch.utils.data import Dataset, DataLoader
from sklearn.preprocessing import StandardScaler, RobustScaler
from utils.preprocessing import preprocess
from utils.timefeatures import time_features
... | pd.to_datetime(df_stamp['date'].values) | pandas.to_datetime |
import sys
import logging
import arrow
import pandas as pd
from fintrist import Study
from fintrist_lib import ANALYSIS_CATALOG, SCRAPERS_CATALOG
from .settings import Config
from . import util
logger = logging.getLogger(__name__)
def backtest(model, strategy, period='1y', end=None):
"""Run the model Study on p... | pd.DataFrame(simulated, columns=['date', 'signals']) | pandas.DataFrame |
import datetime
import logging
import os.path
import random
import sys
from os import path
from typing import List
import pandas as pd
from tqdm import tqdm
from query_formulation.search import ElasticSearch, SibilsElastic
random.seed(0)
# Gets or creates a logger
def get_logger(filename: str, name: str):
logg... | pd.DataFrame() | pandas.DataFrame |
from config import *
import gensim
import pandas as pd
import os
import re
import string as st
import numpy as np
from textblob import TextBlob
class DataProcessor:
def __init__(self, nrows=None):
self.df = None
self.w2v_model = None
self.label_col = "retweet_count"
self.label_max ... | pd.to_datetime(self.df["timestamp"]) | pandas.to_datetime |
#!/usr/bin/env python
import argparse
import json
import logging
import os
import re
from datetime import datetime
from math import sqrt
from pathlib import Path
from typing import List, Optional
import lightgbm as lgb
import numpy as np
import pandas as pd
from fastcore.utils import store_attr
from mlforecast.core i... | pd.to_datetime(df_temporal['ds']) | pandas.to_datetime |
# -*- coding: utf-8 -*-
import numpy as np
import pandas as pd
from math import sqrt
from dramkit.gentools import power
from dramkit.gentools import isnull
from dramkit.gentools import cal_pct
from dramkit.gentools import x_div_y
from dramkit.gentools import check_l_allin_l0
from dramkit.gentools import get_update_kw... | pd.DataFrame(price_series) | pandas.DataFrame |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Oct 1 22:13:05 2018
@author: tauro
"""
import numpy as np
import pandas as pd
import warnings
warnings.filterwarnings('ignore')
from sklearn.preprocessing import StandardScaler, PowerTransformer, MinMaxScaler, LabelEncoder
from sklearn.metrics impor... | pd.Series(xgb_pred) | pandas.Series |
import pandas as pd
from inci_db.db_utils import DatabaseConnector
class Abbreviation(DatabaseConnector):
def __init__(self, name):
self.name = name
@classmethod
def create_table(cls, filepath):
"""
Create a table in the database from csv file
with abbreviations of cosmet... | pd.read_csv(filepath, encoding="utf-8") | pandas.read_csv |
"""Wrapped xgboost for tabular datasets."""
from time import perf_counter
import logging
from copy import copy
from copy import deepcopy
from typing import Optional
from typing import Callable
from typing import Tuple
from typing import Dict
import xgboost as xgb
from xgboost import dask as dxgb
import numpy as np
... | pd.Series(imp, index=self.features) | pandas.Series |
#!/usr/bin/env python
# coding: utf-8
# # MOJO Scoring: Two Approaches
#
# Now we will use the model we built on the Lending Club data to score the test cases we pickled. To mimick the scoring performance we would experience if the model were implemented in a real-time environment, we will score the records one at a ... | pd.DataFrame(results) | pandas.DataFrame |
import pandas as pd
import glob
import matplotlib.pyplot as plt
import seaborn as sns
plt.rcParams["figure.dpi"] = 150
# MP2.5
df_mp25 = pd.DataFrame()
for i, file_name in enumerate(sorted(list(glob.glob('../data/*_mp25.csv')), reverse=True)):
temp = pd.read_csv(file_name, usecols=['date', 'name', 'val'])
tem... | pd.to_datetime(temp.index) | pandas.to_datetime |
"""
Tests for Timestamp timezone-related methods
"""
from datetime import (
date,
datetime,
timedelta,
)
import dateutil
from dateutil.tz import (
gettz,
tzoffset,
)
import pytest
import pytz
from pytz.exceptions import (
AmbiguousTimeError,
NonExistentTimeError,
)
fro... | Timestamp.max.tz_localize("US/Pacific") | pandas.Timestamp.max.tz_localize |
#importing required modules
import pandas as pd
import numpy as np
#function to create or check required files
def create_file():
try:
exp = pd.read_csv('dom_expense.csv')
except FileNotFoundError:
exp = pd.DataFrame({'Housing': np.NaN,'Electricity': np.NaN,'Telecom': np.NaN,'Groceries': np.NaN... | pd.read_csv('dom_income.csv') | pandas.read_csv |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Apr 25 21:16:23 2021
@author: earnestt1234
"""
from collections.abc import Iterable
from copy import deepcopy
from difflib import SequenceMatcher
import os
import numpy as np
import pandas as pd
fixed_cols = ['Device_Number',
'Battery_V... | pd.Series(dtype=object) | pandas.Series |
"""
Analysis of the PSID for PS 1 in Gianluca Violante's quantitative
macro course
@author : <NAME> <<EMAIL>>
@date : 2015-02-04 16:57:38
"""
import numpy as np
import pandas as pd
import statsmodels.formula.api as sm
| pd.set_option("use_inf_as_null", True, "display.width", 180) | pandas.set_option |
import argparse
import os
from os import listdir
import pandas as pd
import numpy as np
import torch
import torch.nn as nn
import yaml
from constants.dataset_tables import ModelsTableHeader, DatasetTableHeader
from file_actions.readers.tomograms import load_tomogram
from file_actions.writers.csv import build_tom_moti... | pd.read_csv(models_table, dtype=ModelsHeader.dtype_dict) | pandas.read_csv |
#%%
import os
from pyteomics import mzid, mzml
import pandas as pd
import numpy as np
import glob
"""
Files are downloaded and manually randomly divided into different folders
the following code is repeated but has the same effect, it is applied to various folders to
generate pandas data frames and to store all the d... | pd.merge(mzid_df,spectra_df,how='left',on=['file','id']) | pandas.merge |
import pandas as pd
import numpy as np
import datetime
import sys
import time
import xgboost as xgb
from add_feture import *
FEATURE_EXTRACTION_SLOT = 10
LabelDay = datetime.datetime(2014,12,18,0,0,0)
Data = pd.read_csv("../../../../data/fresh_comp_offline/drop1112_sub_item.csv")
Data['daystime'] = Data['days'].map(lam... | pd.crosstab([beforefiveday.user_id,beforefiveday.item_id],beforefiveday.behavior_type) | pandas.crosstab |
import pandas as pd
series = pd.Series([21, 23, 56, 54])
print(series)
print(series.index)
print(series.values)
print(series.dtype)
brands = ['BMW', 'Jaguar', 'Ford', 'Kia']
quantities = [20, 10, 50, 75]
series2 = | pd.Series(quantities, index=brands) | pandas.Series |
from albumentations.augmentations.transforms import Normalize
import torch.nn as nn
import torchvision.models as models
from torch.utils.data import Dataset
import torch
import albumentations as A
from albumentations.pytorch import ToTensorV2
from pathlib import Path
import numpy as np
import re
import umap
import pand... | pd.concat([T_data, N_data], ignore_index=True) | pandas.concat |
import contextlib
from dateutil.tz import tzlocal
import numpy as np
import os
import pandas as pd
import sys
import warnings
from datetime import date, datetime
from scipy import stats
def date_range(df, begin, end):
"""Extract out a certain date range from a DataFrame.
Extract out a certain data range fro... | pd.to_datetime(value, unit='s', utc=True) | pandas.to_datetime |
""" test the scalar Timedelta """
import numpy as np
from datetime import timedelta
import pandas as pd
import pandas.util.testing as tm
from pandas.tseries.timedeltas import _coerce_scalar_to_timedelta_type as ct
from pandas import (Timedelta, TimedeltaIndex, timedelta_range, Series,
to_timedelta,... | Timedelta(days=10, seconds=10) | pandas.Timedelta |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Oct 23 19:46:26 2021
@author: KristinaSig
"""
import unittest
import pandas as pd
from code.feature_extraction.mentions_count import MentionsCountFeature
from code.util import COLUMN_MENTIONS
class HashtagFeatureTest(unittest.TestCase):
def s... | pd.DataFrame() | pandas.DataFrame |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.