prompt
stringlengths
19
1.03M
completion
stringlengths
4
2.12k
api
stringlengths
8
90
from urllib.request import urlopen from http.cookiejar import CookieJar from io import StringIO from app.extensions import cache from app.api.constants import PERMIT_HOLDER_CACHE, DORMANT_WELLS_CACHE, LIABILITY_PER_WELL_CACHE, TIMEOUT_15_MINUTES, TIMEOUT_60_MINUTES, TIMEOUT_12_HOURS, TIMEOUT_1_YEAR from flask import Flask, current_app from threading import Thread import requests import urllib import pandas as pd import pyarrow as pa import time from .ogc_data_constants import PERMIT_HOLDER_CSV_DATA, DORMANT_WELLS_CSV_DATA, LIABILITY_PER_WELL_CSV_DATA # TODO: Stick into environment variables PERMIT_HOLDER_CSV = 'http://reports.bcogc.ca/ogc/f?p=200:201:14073940726161:CSV::::' DORMANT_WELLS_CSV = 'https://reports.bcogc.ca/ogc/f?p=200:81:9680316354055:CSV::::' LIABILITY_PER_WELL_CSV = 'https://reports.bcogc.ca/ogc/f?p=200:10:10256707131131:CSV::::' session = requests.session() def refreshOGCdata(app, cache_key, csv_url, process): with app.app_context(): serializer = pa.default_serialization_context() data = cache.get(cache_key) expiry_token = cache.get(cache_key + '_EXPIRY_TOKEN') if not expiry_token: current_app.logger.debug(f'OGC DATA SERVICE - {cache_key} - Cached data not found.') # set 15 minute token to mitigate multiple threads requesting data at the same time cache.set(cache_key + '_EXPIRY_TOKEN', True, timeout=TIMEOUT_15_MINUTES) else: current_app.logger.debug(f'OGC DATA SERVICE - {cache_key} - Cached data up to date.') return try: cookieProcessor = urllib.request.HTTPCookieProcessor() opener = urllib.request.build_opener(cookieProcessor) response = session.get(csv_url) df = pd.read_table(StringIO(response.text), sep=",") df = process(df) updated_from_web = True current_app.logger.debug( f'OGC DATA SERVICE - {cache_key} - Successful get from OGC reporting.') df = process(df) except: # on error, if we don't have data in the cache initialize it from static content if not data: current_app.logger.debug( f'OGC DATA SERVICE - {cache_key} - Falling back to static content.') if cache_key is PERMIT_HOLDER_CACHE: df = pd.read_table(StringIO(PERMIT_HOLDER_CSV_DATA), sep=",") if cache_key is DORMANT_WELLS_CACHE: df = pd.read_table(StringIO(DORMANT_WELLS_CSV_DATA), sep=",") if cache_key is LIABILITY_PER_WELL_CACHE: df = pd.read_table(StringIO(LIABILITY_PER_WELL_CSV_DATA), sep=",") df = process(df) row_count = df.shape[0] # only update cache if there is a good dataset if row_count > 1: current_app.logger.debug(f'OGC DATA SERVICE - {cache_key} - Updating cached data.') cache.set( cache_key, serializer.serialize(df).to_buffer().to_pybytes(), timeout=TIMEOUT_1_YEAR) if updated_from_web: cache.set(cache_key + '_EXPIRY_TOKEN', True, timeout=TIMEOUT_60_MINUTES) else: current_app.logger.warning( f'OGC DATA SERVICE - {cache_key} - FAILED TO RETRIEVE UPDATED DATA') class OGCDataService(): @classmethod def refreshAllData(cls): cls.getPermitHoldersDataFrame() cls.getDormantWellsDataFrame() cls.getLiabilityPerWellDataFrame() @classmethod def getOGCdataframe(cls, cache_key, csv_url, process): serializer = pa.default_serialization_context() data = cache.get(cache_key) app = current_app._get_current_object() #if empty dataset refresh data synchronously, otherwise refresh in the background and continue if not data: df = refreshOGCdata(app, cache_key, csv_url, process) else: thread = Thread( target=refreshOGCdata, args=( app, cache_key, csv_url, process, )) thread.daemon = True thread.start() #update data and return data = cache.get(cache_key) if data: df = serializer.deserialize(data) return df @classmethod def getPermitHoldersDataFrame(cls): def process(df): df.columns = [ 'operator_id', 'organization_name', 'phone_num', 'address_line_1', 'address_line_2', 'city', 'province', 'postal_code', 'country' ] return df return cls.getOGCdataframe(PERMIT_HOLDER_CACHE, PERMIT_HOLDER_CSV, process) @classmethod def getDormantWellsDataFrame(cls): def process(df): df.columns = [ 'operator_name', 'operator_id', 'well_auth_number', 'well_name', 'dormant_status', 'current_status', 'well_dormancy_date', 'site_dormancy_date', 'site_dormancy_type', 'site_dormant_status', 'surface_location', 'field', 'abandonment_date', 'last_spud_date', 'last_rig_rels_date', 'last_completion_date', 'last_active_production_year', 'last_active_inj_display_year', 'wellsite_dormancy_declaration_date', 'multi_well' ] df['well_dormancy_date'] = pd.to_datetime( df['well_dormancy_date'], errors='coerce').apply(lambda x: x.strftime('%Y-%m-%d') if pd.notnull(x) else None) df['site_dormancy_date'] = pd.to_datetime( df['site_dormancy_date'], errors='coerce').apply(lambda x: x.strftime('%Y-%m-%d') if pd.notnull(x) else None) df['abandonment_date'] = pd.to_datetime( df['abandonment_date'], errors='coerce').apply(lambda x: x.strftime('%Y-%m-%d') if pd.notnull(x) else None) df['last_spud_date'] = pd.to_datetime( df['last_spud_date'], errors='coerce').apply(lambda x: x.strftime('%Y-%m-%d') if pd.notnull(x) else None) df['last_rig_rels_date'] = pd.to_datetime( df['last_rig_rels_date'], errors='coerce').apply(lambda x: x.strftime('%Y-%m-%d') if pd.notnull(x) else None) df['last_completion_date'] = pd.to_datetime( df['last_completion_date'], errors='coerce').apply(lambda x: x.strftime('%Y-%m-%d') if pd.notnull(x) else None) df['last_active_production_year'] = pd.to_datetime( df['last_active_production_year'], errors='coerce').apply(lambda x: x.strftime('%Y-%m-%d') if pd.notnull(x) else None) df['last_active_inj_display_year'] = pd.to_datetime( df['last_active_inj_display_year'], errors='coerce').apply(lambda x: x.strftime('%Y-%m-%d') if
pd.notnull(x)
pandas.notnull
#!/usr/bin/env python # coding: utf-8 # # N-BEATS # # ### Uses nbeats model as prediction of future. # In[1]: import os, sys from tqdm import tqdm from subseasonal_toolkit.utils.notebook_util import isnotebook if isnotebook(): # Autoreload packages that are modified get_ipython().run_line_magic('load_ext', 'autoreload') get_ipython().run_line_magic('autoreload', '2') else: from argparse import ArgumentParser import pandas as pd import numpy as np from scipy.spatial.distance import cdist, euclidean from datetime import datetime, timedelta from ttictoc import tic, toc from subseasonal_data.utils import get_measurement_variable from subseasonal_toolkit.utils.general_util import printf from subseasonal_toolkit.utils.experiments_util import get_id_name, get_th_name, get_first_year, get_start_delta from subseasonal_toolkit.utils.models_util import (get_submodel_name, start_logger, log_params, get_forecast_filename, save_forecasts) from subseasonal_toolkit.utils.eval_util import get_target_dates, mean_rmse_to_score, save_metric from sklearn.linear_model import * from subseasonal_data import data_loaders # In[ ]: # # Specify model parameters # if not isnotebook(): # If notebook run as a script, parse command-line arguments parser = ArgumentParser() parser.add_argument("pos_vars",nargs="*") # gt_id and horizon parser.add_argument('--target_dates', '-t', default="std_test") args, opt = parser.parse_known_args() # Assign variables gt_id = get_id_name(args.pos_vars[0]) # "contest_precip" or "contest_tmp2m" horizon = get_th_name(args.pos_vars[1]) # "12w", "34w", or "56w" target_dates = args.target_dates else: # Otherwise, specify arguments interactively gt_id = "contest_tmp2m" horizon = "34w" target_dates = "std_contest" # # Process model parameters # # One can subtract this number from a target date to find the last viable training date. start_delta = timedelta(days=get_start_delta(horizon, gt_id)) # Record model and submodel name model_name = "nbeats" submodel_name = get_submodel_name(model_name) FIRST_SAVE_YEAR = 2007 # Don't save forecasts from years prior to FIRST_SAVE_YEAR if not isnotebook(): # Save output to log file logger = start_logger(model=model_name,submodel=submodel_name,gt_id=gt_id, horizon=horizon,target_dates=target_dates) # Store parameter values in log params_names = ['gt_id', 'horizon', 'target_dates'] params_values = [eval(param) for param in params_names] log_params(params_names, params_values) # In[ ]: printf('Loading target variable and dropping extraneous columns') tic() var = get_measurement_variable(gt_id) gt = data_loaders.get_ground_truth(gt_id).loc[:,["start_date","lat","lon",var]] toc() # In[ ]: printf('Pivoting dataframe to have one column per lat-lon pair and one row per start_date') tic() gt = gt.set_index(['lat','lon','start_date']).squeeze().unstack(['lat','lon']) toc() # In[ ]: # # Make predictions for each target date # from fbprophet import Prophet from pandas.tseries.offsets import DateOffset def get_first_fourth_month(date): targets = {(1, 31), (3,31), (5, 31), (7, 31), (9, 30), (11,30)} while (date.month, date.day) not in targets: date = date - DateOffset(days=1) return date from dateutil.relativedelta import relativedelta def get_predictions(date): # take the first (12/31, 8/31, 4/30) right before the date. true_date = get_first_fourth_month(date) if horizon == "34w": prediction_lag = 28 if horizon == "56w": prediction_lag = 42 shifts = np.flip(np.arange(0, 13)) * 4 cmd_prefix = "python main.py --features " cmd_features = "" for shift in shifts: cmd_features = cmd_features + f"{gt_id}_shift{shift} " a = len(cmd_features) cmd_features += f'\\' b = len(cmd_features) epochs = 20 cnt = 0 target_date = (true_date - timedelta(days=prediction_lag) - relativedelta(years=1)).strftime("%Y-%m-%d") val_begin_date = (true_date - timedelta(days=prediction_lag) - relativedelta(years=1) + timedelta(days=1)).strftime("%Y-%m-%d") val_end_date = (true_date - timedelta(days=prediction_lag)).strftime("%Y-%m-%d") test_begin_date = true_date.strftime("%Y-%m-%d") test_end_date = (true_date + relativedelta(months=2) -timedelta(days=1)).strftime("%Y-%m-%d") log_params(["target_date"], [target_date]) converted_date = date.strftime('%Y_%m_%d') cmd_suffix = f"--task '{gt_id}_{horizon}' --train --evaluate --path-to-feather-file 'data/gt-{gt_id}-14d.h5' --begin-date 1979-01-01 \ --target-date {target_date} \ --val-begin-date {val_begin_date} \ --val-end-date {val_end_date} \ --test-begin-date {test_begin_date} --test-end-date {test_end_date} \ --batch-size 512 --max_epochs {epochs} --grid-count -1 --gpus 1 --gpu-idx {cnt} --full \ --default_root_dir {gt_id}_{horizon}_exp_{converted_date} " cmd = cmd_prefix + cmd_features + cmd_suffix log_params(["cmd"], [cmd]) print(cmd) os.system(cmd) # comment to not run the actual program. # open the file where this is outputted. date_string = date.strftime("%Y%m%d") filename = f"nbeats-predictions/{gt_id}_{horizon}-{date_string}.h5" # return the answer. return pd.read_hdf(filename).values tic() target_date_objs = pd.Series(get_target_dates(date_str=target_dates,horizon=horizon)) rmses =
pd.Series(index=target_date_objs, dtype=np.float64)
pandas.Series
from datetime import datetime import numpy as np import pytest import pandas.util._test_decorators as td from pandas import DataFrame, DatetimeIndex, Index, MultiIndex, Series import pandas._testing as tm from pandas.core.window.common import flex_binary_moment def _rolling_consistency_cases(): for window in [1, 2, 3, 10, 20]: for min_periods in {0, 1, 2, 3, 4, window}: if min_periods and (min_periods > window): continue for center in [False, True]: yield window, min_periods, center # binary moments def test_rolling_cov(series): A = series B = A + np.random.randn(len(A)) result = A.rolling(window=50, min_periods=25).cov(B) tm.assert_almost_equal(result[-1], np.cov(A[-50:], B[-50:])[0, 1]) def test_rolling_corr(series): A = series B = A + np.random.randn(len(A)) result = A.rolling(window=50, min_periods=25).corr(B) tm.assert_almost_equal(result[-1], np.corrcoef(A[-50:], B[-50:])[0, 1]) # test for correct bias correction a = tm.makeTimeSeries() b = tm.makeTimeSeries() a[:5] = np.nan b[:10] = np.nan result = a.rolling(window=len(a), min_periods=1).corr(b) tm.assert_almost_equal(result[-1], a.corr(b)) @pytest.mark.parametrize("func", ["cov", "corr"]) def test_rolling_pairwise_cov_corr(func, frame): result = getattr(frame.rolling(window=10, min_periods=5), func)() result = result.loc[(slice(None), 1), 5] result.index = result.index.droplevel(1) expected = getattr(frame[1].rolling(window=10, min_periods=5), func)(frame[5]) tm.assert_series_equal(result, expected, check_names=False) @pytest.mark.parametrize("method", ["corr", "cov"]) def test_flex_binary_frame(method, frame): series = frame[1] res = getattr(series.rolling(window=10), method)(frame) res2 = getattr(frame.rolling(window=10), method)(series) exp = frame.apply(lambda x: getattr(series.rolling(window=10), method)(x)) tm.assert_frame_equal(res, exp) tm.assert_frame_equal(res2, exp) frame2 = frame.copy() frame2.values[:] = np.random.randn(*frame2.shape) res3 = getattr(frame.rolling(window=10), method)(frame2) exp = DataFrame( {k: getattr(frame[k].rolling(window=10), method)(frame2[k]) for k in frame} ) tm.assert_frame_equal(res3, exp) @pytest.mark.parametrize( "window,min_periods,center", list(_rolling_consistency_cases()) ) @pytest.mark.parametrize("f", [lambda v: Series(v).sum(), np.nansum]) def test_rolling_apply_consistency_sum_nans( consistency_data, window, min_periods, center, f ): x, is_constant, no_nans = consistency_data if f is np.nansum and min_periods == 0: pass else: rolling_f_result = x.rolling( window=window, min_periods=min_periods, center=center ).sum() rolling_apply_f_result = x.rolling( window=window, min_periods=min_periods, center=center ).apply(func=f, raw=True) tm.assert_equal(rolling_f_result, rolling_apply_f_result) @pytest.mark.parametrize( "window,min_periods,center", list(_rolling_consistency_cases()) ) @pytest.mark.parametrize("f", [lambda v: Series(v).sum(), np.nansum, np.sum]) def test_rolling_apply_consistency_sum_no_nans( consistency_data, window, min_periods, center, f ): x, is_constant, no_nans = consistency_data if no_nans: if f is np.nansum and min_periods == 0: pass else: rolling_f_result = x.rolling( window=window, min_periods=min_periods, center=center ).sum() rolling_apply_f_result = x.rolling( window=window, min_periods=min_periods, center=center ).apply(func=f, raw=True) tm.assert_equal(rolling_f_result, rolling_apply_f_result) @pytest.mark.parametrize("window", range(7)) def test_rolling_corr_with_zero_variance(window): # GH 18430 s = Series(np.zeros(20)) other = Series(np.arange(20)) assert s.rolling(window=window).corr(other=other).isna().all() def test_flex_binary_moment(): # GH3155 # don't blow the stack msg = "arguments to moment function must be of type np.ndarray/Series/DataFrame" with pytest.raises(TypeError, match=msg): flex_binary_moment(5, 6, None) def test_corr_sanity(): # GH 3155 df = DataFrame( np.array( [ [0.87024726, 0.18505595], [0.64355431, 0.3091617], [0.92372966, 0.50552513], [0.00203756, 0.04520709], [0.84780328, 0.33394331], [0.78369152, 0.63919667], ] ) ) res = df[0].rolling(5, center=True).corr(df[1]) assert all(np.abs(np.nan_to_num(x)) <= 1 for x in res) df = DataFrame(np.random.rand(30, 2)) res = df[0].rolling(5, center=True).corr(df[1]) assert all(np.abs(np.nan_to_num(x)) <= 1 for x in res) def test_rolling_cov_diff_length(): # GH 7512 s1 = Series([1, 2, 3], index=[0, 1, 2]) s2 = Series([1, 3], index=[0, 2]) result = s1.rolling(window=3, min_periods=2).cov(s2) expected = Series([None, None, 2.0]) tm.assert_series_equal(result, expected) s2a = Series([1, None, 3], index=[0, 1, 2]) result = s1.rolling(window=3, min_periods=2).cov(s2a) tm.assert_series_equal(result, expected) def test_rolling_corr_diff_length(): # GH 7512 s1 = Series([1, 2, 3], index=[0, 1, 2]) s2 = Series([1, 3], index=[0, 2]) result = s1.rolling(window=3, min_periods=2).corr(s2) expected = Series([None, None, 1.0]) tm.assert_series_equal(result, expected) s2a = Series([1, None, 3], index=[0, 1, 2]) result = s1.rolling(window=3, min_periods=2).corr(s2a) tm.assert_series_equal(result, expected) @pytest.mark.parametrize( "f", [ lambda x: x.rolling(window=10, min_periods=5).cov(x, pairwise=False), lambda x: x.rolling(window=10, min_periods=5).corr(x, pairwise=False), lambda x: x.rolling(window=10, min_periods=5).max(), lambda x: x.rolling(window=10, min_periods=5).min(), lambda x: x.rolling(window=10, min_periods=5).sum(), lambda x: x.rolling(window=10, min_periods=5).mean(), lambda x: x.rolling(window=10, min_periods=5).std(), lambda x: x.rolling(window=10, min_periods=5).var(), lambda x: x.rolling(window=10, min_periods=5).skew(), lambda x: x.rolling(window=10, min_periods=5).kurt(), lambda x: x.rolling(window=10, min_periods=5).quantile(quantile=0.5), lambda x: x.rolling(window=10, min_periods=5).median(), lambda x: x.rolling(window=10, min_periods=5).apply(sum, raw=False), lambda x: x.rolling(window=10, min_periods=5).apply(sum, raw=True), pytest.param( lambda x: x.rolling(win_type="boxcar", window=10, min_periods=5).mean(), marks=td.skip_if_no_scipy, ), ], ) def test_rolling_functions_window_non_shrinkage(f): # GH 7764 s = Series(range(4)) s_expected = Series(np.nan, index=s.index) df = DataFrame([[1, 5], [3, 2], [3, 9], [-1, 0]], columns=["A", "B"]) df_expected =
DataFrame(np.nan, index=df.index, columns=df.columns)
pandas.DataFrame
## SETUP ## ## dependencies import pandas as pd ## logging sys.stdout = open(snakemake.log[0], 'w') sys.stderr = open(snakemake.log[0], 'w') ## input files input_dict = { 'taxlist' : snakemake.input['taxlist'], 'slvmap' : snakemake.input['slvmap'], 'dups' : snakemake.input['dups'], } ## output files output_dict = { 'kraknames_S' : snakemake.output['kraknames_S'], 'kraknodes_S' : snakemake.output['kraknodes_S'], 'krakseq2tax_S' : snakemake.output['krakseq2tax_S'], 'kraknames_G' : snakemake.output['kraknames_G'], 'kraknodes_G' : snakemake.output['kraknodes_G'], 'krakseq2tax_G' : snakemake.output['krakseq2tax_G'], 'kronataxtab_S' : snakemake.output['kronataxtab_S'], 'kronataxlist_S' : snakemake.output['kronataxlist_S'], 'kronaseq2tax_S' : snakemake.output['kronaseq2tax_S'], 'kronataxtab_G' : snakemake.output['kronataxtab_G'], 'kronataxlist_G' : snakemake.output['kronataxlist_G'], 'kronaseq2tax_G' : snakemake.output['kronaseq2tax_G'], 'qiimetax_S' : snakemake.output['qiimetax_S'], 'qiimetax_G' : snakemake.output['qiimetax_G'] } # input_dict = { # 'slvmap' : "METADATA/Reference_Sequences/silva/slvmap.txt", # 'taxlist' : "METADATA/Reference_Sequences/silva/taxlist.txt", # 'dups' : "METADATA/Reference_Sequences/silva/reference.dups" # } # output_dict = { # 'kraknames_S' : "METADATA/Reference_Sequences/silva/kraken2/species/taxonomy/names.dmp", # 'kraknodes_S' : "METADATA/Reference_Sequences/silva/kraken2/species/taxonomy/nodes.dmp", # 'krakseq2tax_S' : "METADATA/Reference_Sequences/silva/kraken2/species/seqid2taxid.map", # 'kraknames_G' : "METADATA/Reference_Sequences/silva/kraken2/genus/taxonomy/names.dmp", # 'kraknodes_G' : "METADATA/Reference_Sequences/silva/kraken2/genus/taxonomy/nodes.dmp", # 'krakseq2tax_G' : "METADATA/Reference_Sequences/silva/kraken2/genus/seqid2taxid.map", # 'kronataxtab_S' : "METADATA/Reference_Sequences/silva/krona/species/taxonomy.tab", # 'kronataxtab_G' : "METADATA/Reference_Sequences/silva/krona/genus/taxonomy.tab", # 'kronataxlist_S' : "METADATA/Reference_Sequences/silva/krona/species/taxlist.txt", # 'kronataxlist_G' : "METADATA/Reference_Sequences/silva/krona/genus/taxlist.txt", # 'kronaseq2tax_S' : "METADATA/Reference_Sequences/silva/krona/species/seqid2taxid.map", # 'qiimetax_G' : "METADATA/Reference_Sequences/silva/qiime/genus/taxonomy.tsv", # 'qiimetax_S' : "METADATA/Reference_Sequences/silva/qiime/species/taxonomy.tsv" # } # import os # krak_dir_S = "/".join(output_dict['krakseq2tax_S'].split("/")[:-1]) # krak_dir_G = "/".join(output_dict['krakseq2tax_G'].split("/")[:-1]) # krona_dir_S = "/".join(output_dict['kronataxtab_S'].split("/")[:-1]) # krona_dir_G = "/".join(output_dict['kronataxtab_G'].split("/")[:-1]) # qiime_dir_S = "/".join(output_dict['qiimetax_S'].split("/")[:-1]) # qiime_dir_G = "/".join(output_dict['qiimetax_G'].split("/")[:-1]) # os.makedirs( krak_dir_S + "/taxonomy" ) # os.makedirs( krak_dir_G + "/taxonomy" ) # os.makedirs( krona_dir_S ) # os.makedirs( krona_dir_G ) # os.makedirs( qiime_dir_S ) # os.makedirs( qiime_dir_G ) ## LOAD DATA ## ## load taxID list df_taxlist = pd.read_csv(input_dict['taxlist'], sep='\t', names=['pathname','taxID','rank','remark','release'], usecols=['pathname','taxID','rank']) ## load SILVA taxIDs w/o species classification df_accmap = pd.read_csv(input_dict['slvmap'], sep='\t', skiprows=1, names=['accID','start','end','path','name','taxID'], usecols=['accID','start','end','name','taxID']) ## PER ACCID ## ## the concept of this paragraph was adapted from <NAME>, Little Rock, AR, <EMAIL> ## add path to accmap df_accmap =
pd.merge(df_accmap, df_taxlist.loc[:,['pathname','taxID']], how='left', on='taxID')
pandas.merge
# -*- encoding: utf8 -*- from ..benchmark import * from .partition_shape_experiment import * from ..cluster import * from ..util import * import lue # from ..plot.scale.square_root import SquareRootScale import dateutil.relativedelta import dateutil.parser import matplotlib # matplotlib.use("PDF") matplotlib.use("Agg") import matplotlib.pyplot as plt import matplotlib.scale as mscale import matplotlib.ticker as ticker import numpy as np import pandas as pd import seaborn as sns # import tzlocal import json import math import tempfile # mscale.register_scale(SquareRootScale) def benchmark_meta_to_lue_json( benchmark_pathname, lue_pathname, cluster, benchmark, experiment): # Read benchmark JSON benchmark_json = json.loads(open(benchmark_pathname).read()) environment_json = benchmark_json["environment"] nr_workers = [environment_json["nr_workers"]] lue_json = { "dataset": { "phenomena": [ { "name": "benchmark", "collection_property_sets": [ { "name": "meta_information", "properties": [ { "name": "name", "shape_per_object": "same_shape", "value_variability": "constant", "datatype": "string", "value": [experiment.program_name] }, { "name": "system_name", "shape_per_object": "same_shape", "value_variability": "constant", "datatype": "string", "value": [cluster.name] }, { "name": "command", "shape_per_object": "same_shape", "value_variability": "constant", "datatype": "string", "value": [experiment.command_pathname] }, { "name": "kind", "shape_per_object": "same_shape", "value_variability": "constant", "datatype": "string", "value": [experiment.name] }, { "name": "scenario_name", "shape_per_object": "same_shape", "value_variability": "constant", "datatype": "string", "value": [benchmark.scenario_name] }, { "name": "description", "shape_per_object": "same_shape", "value_variability": "constant", "datatype": "string", "value": [experiment.description] }, { "name": "nr_workers", "shape_per_object": "same_shape", "value_variability": "constant", "datatype": "uint64", "value": nr_workers }, ] } ] } ] } } # Write results open(lue_pathname, "w").write( json.dumps(lue_json, sort_keys=False, indent=4)) def benchmark_to_lue_json( benchmark_pathname, lue_json_pathname, epoch): # Read benchmark JSON benchmark_json = json.loads(open(benchmark_pathname).read()) time_units = benchmark_json["unit"] benchmark_epoch = dateutil.parser.isoparse(benchmark_json["start"]) # We assume here that benchmarks are located at different time points # in seconds from each other. If this is not the case, use time_units # to figure out what units to use instead. epoch_offset = int((benchmark_epoch - epoch).total_seconds()) if epoch_offset < 0: raise RuntimeError( "epoch passed in is later than epoch from benchmark: " "{} > {}".format(epoch, benchmark_epoch)) # Calculate number of seconds sinds the epoch time_points = [ dateutil.parser.isoparse(timing["start"]) for timing in benchmark_json["timings"]] time_points = [ epoch_offset + int((time_point - benchmark_epoch).total_seconds()) for time_point in time_points] time_points = [time_points[0]] property_description = "Amount of time a measurement took" durations = [timing["duration"] for timing in benchmark_json["timings"]] # Object tracking: a benchmark contains property values (durations) # for a single object (piece of software being benchmarked). The ID of # this object is some value, like 5. # The active set indices are 0, 1, 2, 3, ... nr_active_sets = len(time_points) active_set_idx = list(range(nr_active_sets)) active_object_id = nr_active_sets * [5] array_shape = list(benchmark_json["task"]["array_shape"]) partition_shape = list(benchmark_json["task"]["partition_shape"]) lue_json = { "dataset": { "phenomena": [ { "name": "benchmark", "property_sets": [ { "name": "measurement", "description": "Information per benchmark measurement", "object_tracker": { "active_set_index": active_set_idx, "active_object_id": active_object_id }, "time_domain": { "clock": { "epoch": { "kind": "common_era", "origin": epoch.isoformat(), "calendar": "gregorian" }, "unit": time_units, "tick_period_count": 1 }, "time_point": time_points }, "properties": [ { "name": "duration", "description": property_description, "shape_per_object": "same_shape", "value_variability": "variable", "shape_variability": "constant_shape", "datatype": "uint64", "shape": [len(durations)], "value": durations }, { "name": "array_shape", "shape_per_object": "same_shape", "value_variability": "variable", "shape_variability": "constant_shape", "datatype": "uint64", "shape": [len(array_shape)], "value": array_shape }, { "name": "partition_shape", "shape_per_object": "same_shape", "value_variability": "variable", "shape_variability": "constant_shape", "datatype": "uint64", "shape": [len(partition_shape)], "value": partition_shape }, ] } ] } ] } } # Write results open(lue_json_pathname, "w").write( json.dumps(lue_json, sort_keys=False, indent=4)) def determine_epoch( cluster, benchmark, experiment): array_shapes = experiment.array.shapes partition_shapes = experiment.partition.shapes epoch = None for array_shape in array_shapes: for partition_shape in partition_shapes: benchmark_pathname = experiment.benchmark_result_pathname( cluster.name, benchmark.scenario_name, array_shape, "x".join([str(extent) for extent in partition_shape]), "json") assert os.path.exists(benchmark_pathname), benchmark_pathname benchmark_json = json.loads(open(benchmark_pathname).read()) benchmark_start = dateutil.parser.isoparse(benchmark_json["start"]) if epoch is None: epoch = benchmark_start else: epoch = epoch if epoch < benchmark_start else benchmark_start return epoch def import_raw_results( cluster, benchmark, experiment): """ Import all raw benchmark results into a new LUE file This is a two step process: 1. Translate each raw benchmark result into a LUE JSON file 2. Import all LUE JSON files into a single LUE file """ # Each benchmark containing timings has a start location in time and # an overall duration. The location in time can be used to position # the benchmark in time. Most likely, all benchmarks are started at # different locations in time. The duration is not that relevant. # The timings are represented by a location in time and a # duration. The location in time is not that relevant. Duration is. # To position all benchmarks in time, we need a single starting time # point to use as the clock's epoch and calculate the distance of # each benchmark's start time point from this epoch. epoch = determine_epoch(cluster, benchmark, experiment) lue_dataset_pathname = experiment.result_pathname( cluster.name, benchmark.scenario_name, "data", "lue") if os.path.exists(lue_dataset_pathname): os.remove(lue_dataset_pathname) array_shapes = list(experiment.array.shapes) partition_shapes = list(experiment.partition.shapes) metadata_written = False for array_shape in array_shapes: for partition_shape in partition_shapes: result_pathname = experiment.benchmark_result_pathname( cluster.name, benchmark.scenario_name, array_shape, "x".join([str(extent) for extent in partition_shape]), "json") assert os.path.exists(result_pathname), result_pathname if not metadata_written: with tempfile.NamedTemporaryFile(suffix=".json") as lue_json_file: benchmark_meta_to_lue_json( result_pathname, lue_json_file.name, cluster, benchmark, experiment) import_lue_json(lue_json_file.name, lue_dataset_pathname) metadata_written = True with tempfile.NamedTemporaryFile(suffix=".json") as lue_json_file: benchmark_to_lue_json(result_pathname, lue_json_file.name, epoch) import_lue_json(lue_json_file.name, lue_dataset_pathname) lue.assert_is_valid(lue_dataset_pathname) return lue_dataset_pathname def meta_information_dataframe( lue_meta_information): # TODO: BUG: double delete # lue_meta_information.properties["kind"].value[0:0] assert \ lue_meta_information.properties["kind"].value[:] == ["partition_shape"] name = lue_meta_information.properties["name"].value[:] system_name = lue_meta_information.properties["system_name"].value[:] scenario_name = lue_meta_information.properties["scenario_name"].value[:] # # Pandas does not support nD array elements. Convert (each) shape # # to string. # assert array_shape.dtype == np.uint64 # array_shape = [str(shape) for shape in array_shape] meta_information = pd.DataFrame({ "name": name, "system_name": system_name, "scenario_name": scenario_name, }) return meta_information def measurement_dataframe( lue_measurement): array_shape = lue_measurement.properties["array_shape"].value[:] partition_shape = lue_measurement.properties["partition_shape"].value[:] duration = lue_measurement.properties["duration"].value[:] assert len(duration) == len(partition_shape) == len(array_shape) # count durations per benchmark duration = pd.DataFrame(duration) # array shape per benchmark array_shape = pd.DataFrame(array_shape) # partition shape per benchmark partition_shape = pd.DataFrame(partition_shape) assert (duration.index == partition_shape.index).all() assert (duration.index == array_shape.index).all() measurement =
pd.concat([array_shape, partition_shape, duration], axis=1)
pandas.concat
#!/usr/bin/env python2 # -*- coding: utf-8 -*- """ Created on Wed Jun 6 18:36:11 2018 @author: <NAME> """ from env import env from rl_brain import agent_manager import matplotlib.pyplot as plt from tqdm import tqdm import datetime import pandas as pd import numpy as np import os class trainer(): def __init__(self, num_stations, action_space, episode, threshold, collaboration): # Performance Metrics self.success_ratios = {} self.team_cumulative_rewards = {} self.timestamp = self.get_timestamp(True) self.result_dir = "./performance_log/" + self.timestamp + "/graphs/" if not os.path.exists(self.result_dir): os.makedirs(self.result_dir) # Env, Agent, and Key Attributes self.env = env(num_stations, 50, threshold) self.init_stocks = [] self.current_stocks = self.init_stocks self.num_stations = num_stations self.action_space = action_space self.q_tables = [] self.merged_table = 0 self.mode = "learn" self.collaboration = collaboration self.threshold = threshold for idx in range(num_stations): self.init_stocks.append(50) self.agent_manager = agent_manager(self.num_stations, self.action_space, self.init_stocks, self.collaboration) if type(episode) == int: self.eps = [episode] def run(self, mode): ''' This function runs the agent-station training and testing procedures using multithreading. ''' print("==========================") print("start {}ing sessions of {} stations ...".format(mode, self.num_stations)) self.mode = mode self.success_ratios[mode] = [] self.team_cumulative_rewards[mode] = [] if self.mode == "test": # Create new env and agents; run test workflow self.env.eps_reset() self.agent_manager.batch_reset(self.merged_table) for num_eps in self.eps: for eps in tqdm(range(num_eps)): upload_flag = False if num_eps % 500 == 0 and self.collaboration: upload_flag = True for hour in range(0, 24): # Agent-Station Interaction with multi-threading actions = self.agent_manager.batch_choose_action(self.current_stocks) current_hour, old_stocks, new_stocks, rewards, day_end = self.env.ping(actions) self.agent_manager.batch_learn(old_stocks, actions, rewards, new_stocks, day_end, upload = upload_flag) self.current_stocks = new_stocks self.success_ratios[self.mode].append(self.env.cal_success_ratio()) self.team_cumulative_rewards[self.mode].append(self.agent_manager.get_team_rewards()) self.env.eps_reset() self.agent_manager.eps_reset() print("-------------------------") self.agent_manager.save_q_tables(self.timestamp) if self.mode == "learn": self.q_tables, self.merged_table = self.agent_manager.get_q_tables() def graph_performance(self, num_eps): window = num_eps / 200 # Rolling Average of Group Success Ratio fig = plt.figure(figsize = (10, 8)) learn_rolling_average = pd.Series(self.success_ratios["learn"]).rolling(window).mean() test_rolling_average =
pd.Series(self.success_ratios["test"])
pandas.Series
import datetime import lightgbm as lgb import numpy as np import pandas as pd from sklearn.model_selection import KFold from models.tools import f1_score, f1_score_lgbm, load_data # path path_to_data = "data/" path_to_submissions = "submissions/" path_to_stacking = "stacking/" path_to_plots = "models/plots/" # tuned hyper-parameters parameters = { 'task': 'train', 'boosting_type': 'gbdt', 'objective': 'binary', # 'metric': {}, 'num_leaves': 200, 'learning_rate': 0.1, 'feature_fraction': 0.5, 'bagging_fraction': 0.6, 'bagging_freq': 5, 'verbose': 0, "min_data_in_leaf": 3, "max_depth": 150 } # used features my_features_string = [ "date_diff", "overlap_title", "common_author", # "score_1_2", # "score_2_1", "cosine_distance", "journal_similarity", # "overlapping_words_abstract", # "jaccard", # "adar", "preferential_attachment", # "resource_allocation_index", "out_neighbors", "in_neighbors", "common_neighbors", "shortest_path", "popularity", "common_successors", "common_predecessors", "paths_of_length_one", "authors_citation", "coauthor_score" # "katz" # "katz_2" ] my_features_acronym = ["_".join(list(map(lambda x: x[0], string.split('_')))) for string in my_features_string] # load data (X_train, X_test, Y_train, my_features_index, my_features_dic) = load_data(my_features_string) # print user info now = datetime.datetime.now() print("date: " + str(now)) print("features: " + str(my_features_string)) print("model: LGBM") print("parameters:") print(parameters) print("cross validation:") # instantiate Kfold and predictions placeholder k = 5 kf = KFold(k) predictions = np.zeros((X_test.shape[0], k)) predictions_train = np.zeros(X_train.shape[0]) i = 0 # for each fold store predictions on test set and print validation results results = [] print('Start training...') for train_index, test_index in kf.split(X_train): lgb_train = lgb.Dataset(X_train[train_index], Y_train[train_index]) lgb_eval = lgb.Dataset(X_train[test_index], Y_train[test_index], reference=lgb_train) gbm = lgb.train(parameters, train_set=lgb_train, num_boost_round=100, valid_sets=lgb_eval, verbose_eval=40, feval=f1_score_lgbm ) res = gbm.predict(X_test) Y_pred = gbm.predict(X_train[test_index]) Y_pred_train = gbm.predict(X_train[train_index]) predictions[:, i] = res predictions_train[test_index] = Y_pred print("train: " + str(f1_score(Y_train[train_index], Y_pred_train.round()))) print("test: " + str(f1_score(Y_train[test_index], Y_pred.round()))) i += 1 # save submission file Y_test = (np.sum(predictions, axis=1) > 2.5).astype(int) submission =
pd.DataFrame(Y_test)
pandas.DataFrame
#!/usr/bin/env python """ Parses SPINS' EA log files into BIDS tsvs. Usage: dm_parse_ea.py [options] <study> Arguments: <study> A datman study to parse task data for. Options: --experiment <experiment> Single datman session to generate TSVs for --timings <timing_path> The full path to the EA timings file. Defaults to the 'EA-timing.csv' file in the assets folder. --lengths <lengths_path> The full path to the file containing the EA vid lengths. Defaults to the 'EA-vid-lengths.csv' in the assets folder. --regex <regex> The regex to use to find the log files to parse. [default: *UCLAEmpAcc*] --debug Set log level to debug """ import re import os import glob import logging import pandas as pd import numpy as np from docopt import docopt import datman.config import datman.scanid logging.basicConfig( level=logging.WARN, format="[%(name)s] %(levelname)s: %(message)s" ) logger = logging.getLogger(os.path.basename(__file__)) # reads in log file and subtracts the initial TRs/MRI startup time def read_in_logfile(path): log_file = pd.read_csv(path, sep="\t", skiprows=3) time_to_subtract = int(log_file.Duration[log_file.Code == "MRI_start"]) log_file.Time = log_file.Time - time_to_subtract return log_file # Remove the rating when there is a scanner response during the task instead of just at the start def clean_logfile(log_file): scan_response = ["101", "104"] # 1st list of indexes to remove scan responses and ratings in the dataframe indexes_to_drop = [] # Remove the rating that come after the scan response when there is a 102/103 response right before or after # Also remove the rating that come after scan response and carry over to the next video # The rating is always registered two indexes after the scan response for index, row in log_file.iterrows(): if ("rating" in log_file["Code"][index]) and any( resp in log_file["Code"][index - 2] for resp in scan_response ): # index to select the rating to drop indexes_to_drop.append(index) # index - 2 to select the scan response to drop indexes_to_drop.append(index - 2) if len(indexes_to_drop) == 0: log_file_cleaned = log_file else: log_file_cleaned = log_file.drop(log_file.index[indexes_to_drop]) log_file_cleaned = log_file_cleaned.reset_index(drop=True) logger.warning( f"Removed {len(indexes_to_drop)/2} registered rating occurred before or after actual rating" ) # 2nd list of indexes to drop the remaining scan responses and ratings indexes_to_drop_1 = [] # Remove the remaining rating response come right after scan response # The rating is registered one index after the scan response for index, row in log_file_cleaned.iterrows(): if ("rating" in log_file_cleaned["Code"][index]) and any( resp in log_file_cleaned["Code"][index - 1] for resp in scan_response ): # index to select the remaining rating to drop indexes_to_drop_1.append(index) # index - 1 select the remaing scan response to drop indexes_to_drop_1.append(index - 1) if len(indexes_to_drop_1) == 0: final_log_file = log_file_cleaned else: final_log_file = log_file_cleaned.drop( log_file_cleaned.index[indexes_to_drop_1] ) final_log_file = final_log_file.reset_index(drop=True) logger.warning( f"Removed {len(indexes_to_drop_1)/2} rating registered followed scanner responses" ) return final_log_file # Grabs the starts of blocks and returns rows for them def get_blocks(log, vid_info): # identifies the video trial types (as opposed to button press events etc) mask = ["vid" in log["Code"][i] for i in range(0, log.shape[0])] df = pd.DataFrame( { "onset": log.loc[mask]["Time"], "trial_type": log.loc[mask]["Event Type"], "movie_name": log.loc[mask]["Code"], } ) df["trial_type"] = df["movie_name"].apply( lambda x: "circle_block" if "cvid" in x else "EA_block" ) df["duration"] = df["movie_name"].apply( lambda x: int(vid_info[x]["duration"]) * 10000 if x in vid_info else pd.NA ) df["stim_file"] = df["movie_name"].apply( lambda x: vid_info[x]["stim_file"] if x in vid_info else pd.NA ) df["end"] = df["onset"] + df["duration"] return df def format_vid_info(vid): vid.columns = [c.lower() for c in vid.columns] vid = vid.rename(index={0: "stim_file", 1: "duration"}) vid = vid.to_dict() return vid def read_in_standard(timing_path): df = pd.read_csv(timing_path).astype(str) df.columns = [c.lower() for c in df.columns] df_dict = df.drop([0, 0]).reset_index(drop=True).to_dict(orient="list") return df_dict def get_series_standard(gold_standard, block_name): return [float(x) for x in gold_standard[block_name] if x != "nan"] def get_ratings(log): rating_mask = ["rating" in log["Code"][i] for i in range(0, log.shape[0])] df = pd.DataFrame( { "onset": log["Time"].loc[rating_mask].values, "participant_value": log.loc[rating_mask]["Code"].values, "event_type": "button_press", "duration": 0, } ) # Pull rating value from formatted string df["participant_value"] = df["participant_value"].str.strip().str[-1] return df def combine_dfs(blocks, ratings): # combines the block rows with the ratings rows and sorts them combo = blocks.append(ratings).sort_values("onset").reset_index(drop=True) mask = pd.notnull(combo["trial_type"]) combo["space_b4_prev"] = combo["onset"].diff(periods=1) combo["first_button_press"] = combo["duration"].shift() > 0 combo2 = combo.drop( combo[ (combo["space_b4_prev"] < 1000) & (combo["first_button_press"] == True) ].index ).reset_index(drop=True) mask = pd.notnull(combo2["trial_type"]) block_start_locs = combo2[mask].index.values last_block = combo2.iloc[block_start_locs[len(block_start_locs) - 1]] end_row = { "onset": last_block.end, "rating_duration": 0, "event_type": "last_row", "duration": 0, "participant_value": last_block.participant_value, } combo2 = combo2.append(end_row, ignore_index=True).reset_index(drop=True) mask = pd.notnull(combo2["trial_type"]) block_start_locs = combo2[mask].index.values combo2["rating_duration"] = combo2["onset"].shift(-1) - combo2[ "onset" ].where( mask == False ) # noqa: E712 for i in range(len(block_start_locs)): if block_start_locs[i] != 0: combo2.rating_duration[block_start_locs[i - 1]] = ( combo2.end[block_start_locs[i - 1]] - combo2.onset[block_start_locs[i - 1]] ) for i in block_start_locs: new_row = { "onset": combo2.onset[i], "rating_duration": combo2.onset[i + 1] - combo2.onset[i], "event_type": "default_rating", "duration": 0, "participant_value": 5, } combo2 = combo2.append(new_row, ignore_index=True) combo2 = combo2.sort_values( by=["onset", "event_type"], na_position="first" ).reset_index(drop=True) return combo2 def block_scores(ratings_dict, combo): """ Compute Pearson correlation between gold standard ratings and participant ratings """ list_of_rows = [] summary_vals = {} mask = pd.notnull(combo["trial_type"]) block_start_locs = combo[mask].index.values block_start_locs = np.append( block_start_locs, combo.tail(1).index.values, axis=None ) for idx in range(1, len(block_start_locs)): block_start = combo.onset[block_start_locs[idx - 1]] block_end = combo.end[block_start_locs[idx - 1]] block = combo.iloc[block_start_locs[idx - 1] : block_start_locs[idx]][ pd.notnull(combo.event_type) ] block_name = ( combo.movie_name.iloc[ block_start_locs[idx - 1] : block_start_locs[idx] ][pd.notnull(combo.movie_name)] .reset_index(drop=True) .astype(str) .get(0) ) gold = get_series_standard(ratings_dict, block_name) if "cvid" in block_name: interval = np.arange( combo.onset[block_start_locs[idx - 1]], combo.end[block_start_locs[idx - 1]], step=40000, ) else: interval = np.arange( combo.onset[block_start_locs[idx - 1]], combo.end[block_start_locs[idx - 1]], step=20000, ) if len(gold) < len(interval): interval = interval[: len(gold)] logger.warning( "gold standard is shorter than the number of pt " f"ratings. pt ratings truncated, block: {block_name}", ) if len(interval) < len(gold): gold = gold[: len(interval)] logger.warning( "number of pt ratings is shorter than the number " f"of gold std, gold std truncated, block: {block_name}", ) # this is to append for the remaining fraction of a second (so that # the loop goes to the end i guess...)- maybe i dont need to do this interval = np.append(interval, block_end) two_s_avg = [] for x in range(len(interval) - 1): start = interval[x] end = interval[x + 1] sub_block = block[ block["onset"].between(start, end) | block["onset"].between(start, end).shift(-1) ] block_length = end - start if len(sub_block) != 0: ratings = [] for index, row in sub_block.iterrows(): if row.onset < start: numerator = (row.onset + row.rating_duration) - start else: if (row.onset + row.rating_duration) <= end: numerator = row.rating_duration elif (row.onset + row.rating_duration) > end: numerator = end - row.onset else: numerator = 999999 # add error here if row.event_type != "last_row": ratings.append( { "start": start, "end": end, "row_time": row.rating_duration, "row_start": row.onset, "block_length": block_length, "rating": row.participant_value, "time_held": numerator, } ) nums = [float(d["rating"]) for d in ratings] times = [ float(d["time_held"]) / block_length for d in ratings ] avg = np.sum(np.multiply(nums, times)) last_row = row.participant_value else: avg = last_row two_s_avg.append(float(avg)) list_of_rows.append( { "event_type": "running_avg", "participant_value": float(avg), "onset": start, "duration": end - start, "gold_std": gold[x], } ) n_button_press = len(block[block.event_type == "button_press"].index) block_score = np.corrcoef(gold, two_s_avg)[1][0] key = str(block_name) summary_vals.update( { key: { "n_button_press": int(n_button_press), "block_score": block_score, "onset": block_start, "duration": block_end - block_start, } } ) return list_of_rows, summary_vals def outputs_exist(log_file, output_path): if not os.path.exists(output_path): return False if os.path.getmtime(output_path) < os.path.getmtime(log_file): logger.error( "Output file is less recently modified than its task file" f" {log_file}. Output will be deleted and regenerated." ) try: os.remove(output_path) except Exception as e: logger.error( f"Failed to remove output file {output_path}, cannot " f"regenerate. Reason - {e}" ) return True return False return True def get_output_path(ident, log_file, dest_dir): try: os.makedirs(dest_dir) except FileExistsError: pass part = re.findall(r"((?:part|RUN)\d).log", log_file) if not part: logger.error( f"Can't detect which part task file {log_file} " "corresponds to. Ignoring file." ) return else: part = part[0] return os.path.join(dest_dir, f"{ident}_EAtask_{part}.tsv") def parse_task(ident, log_file, dest_dir, length_file, timing_file): output_path = get_output_path(ident, log_file, dest_dir) if outputs_exist(log_file, output_path): return # Reads in and clean the log, skipping the first three preamble lines try: log = read_in_logfile(log_file) log_cleaned = clean_logfile(log) except Exception as e: logger.error( f"Cannot parse {log_file}! File maybe corrupted! Skipping" ) return vid_in =
pd.read_csv(length_file)
pandas.read_csv
# 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 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.html # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Testing hwm_allocation() with bookings in natural order. import unittest from imscommon.es.ims_esclient import ESClient from pyspark.sql import HiveContext from pyspark import SparkContext, SparkConf import optimizer.util import pandas from pandas.testing import assert_frame_equal import optimizer.algo.hwm import os import json import warnings class Unittest_HWM_Allocations_2(unittest.TestCase): def setUp(self): warnings.simplefilter("ignore", ResourceWarning) fpath = os.path.abspath(os.path.join(os.path.dirname(__file__),"..")) with open(fpath + '/data_source/bookings_fully_overlapped.json') as bookings_source: self.bookings = json.load(bookings_source) with open(fpath + '/data_source/cfg.json') as cfg_source: self.cfg = json.load(cfg_source) today = '20180402' self.days = optimizer.util.get_days_from_bookings(today, self.bookings) self.sc = SparkContext.getOrCreate() self.hive_context = HiveContext(self.sc) self.schema = optimizer.util.get_common_pyspark_schema() def compare_two_dfs(self, pandas_df_expected, df_to_test_rows): df = self.hive_context.createDataFrame(df_to_test_rows, self.schema) df_allocated = optimizer.algo.hwm.hwm_allocation(df, self.bookings, self.days) pandas_df_allocated = df_allocated.select("*").toPandas() print(pandas_df_expected) print(pandas_df_allocated) return self.assertTrue(assert_frame_equal(pandas_df_expected, pandas_df_allocated, check_dtype=False) == None) def test_hwm_allocation_case1(self): pandas_df_expected = pandas.DataFrame(columns=['day', 'ands', 'minus', 'amount', 'allocated']) pandas_df_expected.loc[0] = ['20180402', ['b1', 'b3', 'b2'], [], 733, {'b1': 500, 'b3': 233}] df_to_test_rows = [(['20180402', ['b1', 'b3', 'b2'], [], {}, 733])] return self.compare_two_dfs(pandas_df_expected, df_to_test_rows) def test_hwm_allocation_case2(self): pandas_df_expected =
pandas.DataFrame(columns=['day', 'ands', 'minus', 'amount', 'allocated'])
pandas.DataFrame
import re import json import operator import sys import dateutil.parser as dp import pandas as pd from typing import List, Tuple, Set from rltk import similarity from tl.exceptions import TLException import numpy as np ccm_columns = ['type', 'score', 'property', 'row', 'col1', 'col1_item', 'col1_string', 'col2', 'col2_string', 'col2_item'] valid_property_types = {'i', 'd', 'q', 'e'} class CellContextMatches: """ Contains the context matches for a single cell to all other cells in the same row. This class contains all the triples for all candidates for a cell. """ def __init__(self, row: str, col: str, ): """ Create an empty CellContextMatches for a specific cell. """ self.row = row self.col = col # self.ccm = pd.DataFrame(columns=ccm_columns) self.ccm = dict() self.col1_items = set() def add_triple(self, row: str, col1: str, col1_item: str, col1_string: str, type: str, score: float, property: str, col2: str, col2_string: str, best_match: str, col2_item: str = None): """ Add a single triple to CellContextMatches. """ triple = { 'type': type, 'score': score, 'property': property, 'row': row, 'col1': col1, 'col1_item': col1_item, 'col1_string': col1_string, 'col2': col2, 'col2_string': col2_string, 'col2_item': col2_item, 'best_match': best_match } if col2 not in self.ccm: self.ccm[col2] = list() self.ccm[col2].append(triple) self.col1_items.add(col1_item) def has_candidate(self, col1_item: str): """ Returns true of the CellContextMatches contains information for a given q_node. """ return col1_item in self.col1_items def get_triples(self): """ Return a list of all the triples """ out = [] for k in self.ccm: triples = self.ccm[k] out.extend(triples) return out def get_triples_to_column(self, col2: str): """ Return the triples to another column. """ if self.col == col2: raise Exception(f'Cannot find context for a column with itself. col1: {self.col}, col2: {col2}') return self.ccm.get(col2, []) def get_properties(self, col2: str, q_node: str = None) -> List[Tuple[str, str, float, int]]: """ list of tuples (property, type, best score, count_appears) -> [("P175", "i", 0.95, 4), ...] current_col for col in range(0, max_columns): for row in range (0, max_rows): cc = tcm.get_cell_context(row, col) props = cc.get_properties(3) """ if self.col == col2: raise Exception(f'Cannot find context for a column with itself. col1: {self.col}, col2: {col2}') result = [] col2_records = self.ccm.get(col2, []) if q_node: col2_records = [s for s in col2_records if s.get('col1_item') == q_node] prop_count = {} for record in col2_records: property = record['property'] score = record['score'] if property not in prop_count: prop_count[property] = { 'count': 0, 'max_score': -1.0, 'type': record['type'], 'sum': 0 } prop_count[property]['count'] += 1 prop_count[property]['sum'] += score if score > prop_count[property]['max_score']: prop_count[property]['max_score'] = score for property in prop_count: number_of_occurences = prop_count[property]['count'] avg_score = prop_count[property]['sum'] / number_of_occurences max_score = prop_count[property]['max_score'] result.append((property, prop_count[property]['type'], max_score, avg_score, number_of_occurences)) return result class TableContextMatches: """ Contains all context matches for a table, for every cell that we have to link to all other cells in the same row. """ def __init__(self, context_path: str = None, context_dict: dict = None, input_df: pd.DataFrame = None, input_path: str = None, context_matches_path=None, label_column: str = 'label_clean', ignore_column: str = None, relevant_properties_file: str = None, use_relevant_properties: bool = False, save_relevant_properties: bool = False, string_similarity_threshold: float = 0.7, quantity_similarity_threshold: float = 0.3, output_column_name: str = "context_score" ): """ Maybe better to have a set of columns Create a ContextMatches datastructure to store the context matches between columns in a row. Each entry in the ContextMatches array is a list of dicts, where each dict contains row, col1, col2, property, score, col1_item, col2_string and col2_item. The internal datastructure must return the matches between two columns in a rows in constant time, so the backing store must be NumPy array. """ self.ignore_column = ignore_column if self.ignore_column: self.prefix_column_name = "ignore_" else: self.prefix_column_name = "" self.row_col_label_dict = {} if context_path is not None: context_dict = self.read_context_file(context_path) self.output_column_name = output_column_name self.ccm_dict = {} self.string_similarity_threshold = string_similarity_threshold self.quantity_similarity_threshold = quantity_similarity_threshold self.input_df = None if input_path is not None: input_df = pd.read_csv(input_path) self.relevant_properties_file = relevant_properties_file self.use_relevant_properties = use_relevant_properties self.save_relevant_properties = save_relevant_properties self.relevant_properties = {} if use_relevant_properties: self.relevant_properties = self.read_relevant_properties() input_df['row'] = input_df['row'].astype('str') input_df['column'] = input_df['column'].astype('str') self.main_entity_column = self.find_main_entity_column(input_df, label_column) self.initialize(input_df, context_dict, label_column) if context_matches_path is not None: self.load_from_disk(context_matches_path) def read_relevant_properties(self) -> dict: # or whatever datastructure makes sense if self.relevant_properties_file is None: raise TLException('Please specify a valid path for relevant properties.') relevant_properties_df = pd.read_csv(self.relevant_properties_file) relevant_properties_group = relevant_properties_df.groupby(['column', 'col2']) relevant_properties_dict = {} for cell, group in relevant_properties_group: column_column_pair = f"{cell[0]}_{cell[1]}" all_properties = set(group['property_'].unique()) relevant_properties_dict[column_column_pair] = all_properties return relevant_properties_dict def write_relevant_properties(self, relevant_properties_df: pd.DataFrame): if self.relevant_properties_file is None: raise TLException('Please specify a valid path for relevant properties.') relevant_properties_df.to_csv(self.relevant_properties_file, index=False) def is_relevant_property(self, col1: str, col2: str, property: str) -> bool: column_column_pair = f"{col1}_{col2}" # Lookup the dictionary if column_column_pair in self.relevant_properties: column_relevant_properties = self.relevant_properties[column_column_pair] if property in column_relevant_properties: return True return False def find_main_entity_column(self, input_df, label_column) -> str: col_labels_dict = {} for col, gdf in input_df.groupby(by=['column']): col_labels_dict[col] = len(gdf[label_column].unique()) max_cols = [key for (key, value) in col_labels_dict.items() if value == max(col_labels_dict.values())] if len(max_cols) == 1: return max_cols[0] return '0' def initialize(self, raw_input_df, context_dict, label_column): raw_input_df['kg_labels'].fillna("", inplace=True) raw_input_df['kg_aliases'].fillna("", inplace=True) if self.ignore_column is not None: _input_df = raw_input_df[(raw_input_df[self.ignore_column].astype(float) == 0) & (raw_input_df['column'] == self.main_entity_column)] not_ignored_rows = set(_input_df['row'].unique()) _input_df_2 = raw_input_df[ (raw_input_df['row'].isin(not_ignored_rows)) & (raw_input_df["column"] != self.main_entity_column)] self.input_df = pd.concat([_input_df, _input_df_2]) not_ignored_indices = self.input_df.index self.other_input_df = raw_input_df[~raw_input_df.index.isin(not_ignored_indices)] assert (len(self.input_df) + len(self.other_input_df)) == len(raw_input_df) else: self.input_df = raw_input_df self.other_input_df = None rows = set(self.input_df['row'].unique()) columns = set(self.input_df['column'].unique()) row_column_pairs = set() for row, col, label in zip(self.input_df['row'], self.input_df['column'], self.input_df[label_column]): key = f"{row}_{col}" row_column_pairs.add(key) # row_column_label_dict stores only the row_column pairs that need to be matched for row, col, context in zip(self.input_df['row'], self.input_df['column'], self.input_df['context']): if col == '0': context_vals = context.split('|') for i, context_val in enumerate(context_vals): context_column = i + 1 row_col_dict_key = f"{row}_{context_column}" if row_col_dict_key not in self.row_col_label_dict: try: date = dp.parse(context_val) context_val = str(date.year) except: pass self.row_col_label_dict[row_col_dict_key] = context_val columns.add(str(context_column)) for row, col, kg_id, kg_id_label_str, kg_id_alias_str in zip(self.input_df['row'], self.input_df['column'], self.input_df['kg_id'], self.input_df['kg_labels'], self.input_df['kg_aliases']): kg_id_context = context_dict.get(kg_id, None) kg_labels = [] if kg_id_label_str and kg_id_label_str.strip() != "": kg_labels.append(kg_id_label_str.strip()) if kg_id_alias_str and kg_id_alias_str.strip() != "": kg_labels.append(kg_id_alias_str.strip()) kg_label_str = "|".join(kg_labels) ccm_key = f"{row}_{col}" if ccm_key not in self.ccm_dict: self.ccm_dict[ccm_key] = CellContextMatches(row, col) if kg_id_context is not None: for col2 in columns: if (col != col2) and (col == self.main_entity_column or col2 == self.main_entity_column): ccm_key_2 = f"{row}_{col2}" if ccm_key_2 not in self.ccm_dict: self.ccm_dict[ccm_key_2] = CellContextMatches(row, col2) context_results = self.compute_context_similarity(kg_id_context, col, col2, self.row_col_label_dict.get(f"{row}_{col2}", None)) for context_result in context_results: self.add_match(row=row, col1=col, col1_item=kg_id, col1_string=kg_label_str, col2=col2, col2_item=context_result['col2_item'], col2_string=context_result['col2_string'], type=context_result['type'], property=context_result['property'], score=context_result['score'], best_match=context_result['best_match'] ) self.input_df = self.process(row_column_pairs, columns) def process(self, row_column_pairs: set, n_context_columns: set): context_scores, properties, similarities = self.compute_context_scores(n_context_columns, row_column_pairs) self.input_df[self.output_column_name] = context_scores self.input_df[self.prefix_column_name + 'context_properties'] = properties self.input_df[self.prefix_column_name + 'context_similarity'] = similarities out = [self.input_df] if self.other_input_df is not None: out.append(self.other_input_df) return pd.concat(out).fillna(0.0) def correctness_of_candidate(self): # Number of matches are the number it matched correctly pass def compute_context_scores(self, n_context_columns: set, row_column_pairs: set) -> ( List[int], List[str], List[int]): self.compute_property_scores(row_column_pairs, n_context_columns) context_score_list = [] context_property_list = [] context_similarity_list = [] for row, col, q_node in zip(self.input_df['row'], self.input_df['column'], self.input_df['kg_id']): # Handle equal similarity for different properties by looping over and getting # the one with highest similarity. property_matched = [] similarity_matched = [] sum_of_properties = 0 r_c = f"{row}_{col}" for col2 in n_context_columns: if col2 != col and (col == self.main_entity_column or col2 == self.main_entity_column): returned_properties = self.ccm_dict[r_c].get_properties(col2, q_node=q_node) if not returned_properties: continue best_score = 0 property_ = None for properties in returned_properties: if properties[2] > best_score: property_ = properties[0] best_score = properties[2] # if property_ not in current_relevant_properties: pass property_matched.append(property_ + "(" + str(best_score) + ")") similarity_matched.append(best_score) sum_of_properties = sum_of_properties + best_score if sum_of_properties == 0: context_score = 0 else: context_score = (1 - 1 / pow(2, sum_of_properties)) context_score_list.append(context_score) context_similarity_list.append(similarity_matched) context_property_list.append(property_matched) return context_score_list, context_property_list, context_similarity_list def compute_property_scores(self, row_column_pairs: set, n_context_columns: set): properties_df_list = [] for r_c in row_column_pairs: row_col = r_c.split("_") row = row_col[0] col = row_col[1] for col2 in n_context_columns: if (col2 != col) and (col2 == self.main_entity_column or col == self.main_entity_column): m = self.ccm_dict[r_c].get_properties(col2) int_prop = pd.DataFrame(m, columns=["property_", "type", "best_score", "avg_score", "n_occurences"]) int_prop['row'] = row int_prop['column'] = col int_prop['col2'] = col2 properties_df_list.append(int_prop) properties_df = pd.concat(properties_df_list) property_value_list = [] grouped_obj = properties_df.groupby(['column', 'col2', 'property_']) for cell, group in grouped_obj: property_score = (group['avg_score'].sum(axis=0)) property_value_list.append([cell[2], cell[0], cell[1], property_score]) property_value_df =
pd.DataFrame(property_value_list, columns=['property_', 'column', 'col2', 'property_score'])
pandas.DataFrame
# -*- coding: utf-8 -*- # Arithmetc tests for DataFrame/Series/Index/Array classes that should # behave identically. from datetime import timedelta import operator import pytest import numpy as np import pandas as pd import pandas.util.testing as tm from pandas.compat import long from pandas.core import ops from pandas.errors import NullFrequencyError, PerformanceWarning from pandas._libs.tslibs import IncompatibleFrequency from pandas import ( timedelta_range, Timedelta, Timestamp, NaT, Series, TimedeltaIndex, DatetimeIndex) # ------------------------------------------------------------------ # Fixtures @pytest.fixture def tdser(): """ Return a Series with dtype='timedelta64[ns]', including a NaT. """ return Series(['59 Days', '59 Days', 'NaT'], dtype='timedelta64[ns]') @pytest.fixture(params=[pd.offsets.Hour(2), timedelta(hours=2), np.timedelta64(2, 'h'), Timedelta(hours=2)], ids=lambda x: type(x).__name__) def delta(request): """ Several ways of representing two hours """ return request.param @pytest.fixture(params=[timedelta(minutes=5, seconds=4), Timedelta('5m4s'), Timedelta('5m4s').to_timedelta64()], ids=lambda x: type(x).__name__) def scalar_td(request): """ Several variants of Timedelta scalars representing 5 minutes and 4 seconds """ return request.param @pytest.fixture(params=[pd.Index, Series, pd.DataFrame], ids=lambda x: x.__name__) def box(request): """ Several array-like containers that should have effectively identical behavior with respect to arithmetic operations. """ return request.param @pytest.fixture(params=[pd.Index, Series, pytest.param(pd.DataFrame, marks=pytest.mark.xfail(strict=True))], ids=lambda x: x.__name__) def box_df_fail(request): """ Fixture equivalent to `box` fixture but xfailing the DataFrame case. """ return request.param # ------------------------------------------------------------------ # Numeric dtypes Arithmetic with Timedelta Scalar class TestNumericArraylikeArithmeticWithTimedeltaScalar(object): @pytest.mark.parametrize('box', [ pd.Index, Series, pytest.param(pd.DataFrame, marks=pytest.mark.xfail(reason="block.eval incorrect", strict=True)) ]) @pytest.mark.parametrize('index', [ pd.Int64Index(range(1, 11)), pd.UInt64Index(range(1, 11)), pd.Float64Index(range(1, 11)), pd.RangeIndex(1, 11)], ids=lambda x: type(x).__name__) @pytest.mark.parametrize('scalar_td', [ Timedelta(days=1), Timedelta(days=1).to_timedelta64(), Timedelta(days=1).to_pytimedelta()], ids=lambda x: type(x).__name__) def test_numeric_arr_mul_tdscalar(self, scalar_td, index, box): # GH#19333 if (box is Series and type(scalar_td) is timedelta and index.dtype == 'f8'): raise pytest.xfail(reason="Cannot multiply timedelta by float") expected = timedelta_range('1 days', '10 days') index = tm.box_expected(index, box) expected = tm.box_expected(expected, box) result = index * scalar_td tm.assert_equal(result, expected) commute = scalar_td * index tm.assert_equal(commute, expected) @pytest.mark.parametrize('index', [ pd.Int64Index(range(1, 3)), pd.UInt64Index(range(1, 3)), pd.Float64Index(range(1, 3)), pd.RangeIndex(1, 3)], ids=lambda x: type(x).__name__) @pytest.mark.parametrize('scalar_td', [ Timedelta(days=1), Timedelta(days=1).to_timedelta64(), Timedelta(days=1).to_pytimedelta()], ids=lambda x: type(x).__name__) def test_numeric_arr_rdiv_tdscalar(self, scalar_td, index, box): if box is Series and type(scalar_td) is timedelta: raise pytest.xfail(reason="TODO: Figure out why this case fails") if box is pd.DataFrame and isinstance(scalar_td, timedelta): raise pytest.xfail(reason="TODO: Figure out why this case fails") expected = TimedeltaIndex(['1 Day', '12 Hours']) index = tm.box_expected(index, box) expected = tm.box_expected(expected, box) result = scalar_td / index tm.assert_equal(result, expected) with pytest.raises(TypeError): index / scalar_td # ------------------------------------------------------------------ # Timedelta64[ns] dtype Arithmetic Operations class TestTimedeltaArraylikeAddSubOps(object): # Tests for timedelta64[ns] __add__, __sub__, __radd__, __rsub__ # ------------------------------------------------------------- # Invalid Operations def test_td64arr_add_str_invalid(self, box): # GH#13624 tdi = TimedeltaIndex(['1 day', '2 days']) tdi = tm.box_expected(tdi, box) with pytest.raises(TypeError): tdi + 'a' with pytest.raises(TypeError): 'a' + tdi @pytest.mark.parametrize('other', [3.14, np.array([2.0, 3.0])]) @pytest.mark.parametrize('op', [operator.add, ops.radd, operator.sub, ops.rsub], ids=lambda x: x.__name__) def test_td64arr_add_sub_float(self, box, op, other): tdi = TimedeltaIndex(['-1 days', '-1 days']) tdi = tm.box_expected(tdi, box) if box is pd.DataFrame and op in [operator.add, operator.sub]: pytest.xfail(reason="Tries to align incorrectly, " "raises ValueError") with pytest.raises(TypeError): op(tdi, other) @pytest.mark.parametrize('box', [ pd.Index, Series, pytest.param(pd.DataFrame, marks=pytest.mark.xfail(reason="Tries to cast df to " "Period", strict=True, raises=IncompatibleFrequency)) ], ids=lambda x: x.__name__) @pytest.mark.parametrize('freq', [None, 'H']) def test_td64arr_sub_period(self, box, freq): # GH#13078 # not supported, check TypeError p = pd.Period('2011-01-01', freq='D') idx = TimedeltaIndex(['1 hours', '2 hours'], freq=freq) idx = tm.box_expected(idx, box) with pytest.raises(TypeError): idx - p with pytest.raises(TypeError): p - idx @pytest.mark.parametrize('box', [ pd.Index, Series, pytest.param(pd.DataFrame, marks=pytest.mark.xfail(reason="broadcasts along " "wrong axis", raises=ValueError, strict=True)) ], ids=lambda x: x.__name__) @pytest.mark.parametrize('pi_freq', ['D', 'W', 'Q', 'H']) @pytest.mark.parametrize('tdi_freq', [None, 'H']) def test_td64arr_sub_pi(self, box, tdi_freq, pi_freq): # GH#20049 subtracting PeriodIndex should raise TypeError tdi = TimedeltaIndex(['1 hours', '2 hours'], freq=tdi_freq) dti = Timestamp('2018-03-07 17:16:40') + tdi pi = dti.to_period(pi_freq) # TODO: parametrize over box for pi? tdi = tm.box_expected(tdi, box) with pytest.raises(TypeError): tdi - pi # ------------------------------------------------------------- # Binary operations td64 arraylike and datetime-like def test_td64arr_sub_timestamp_raises(self, box): idx = TimedeltaIndex(['1 day', '2 day']) idx = tm.box_expected(idx, box) msg = "cannot subtract a datelike from|Could not operate" with tm.assert_raises_regex(TypeError, msg): idx - Timestamp('2011-01-01') @pytest.mark.parametrize('box', [ pd.Index, Series, pytest.param(pd.DataFrame, marks=pytest.mark.xfail(reason="Returns object dtype", strict=True)) ], ids=lambda x: x.__name__) def test_td64arr_add_timestamp(self, box): idx = TimedeltaIndex(['1 day', '2 day']) expected = DatetimeIndex(['2011-01-02', '2011-01-03']) idx = tm.box_expected(idx, box) expected = tm.box_expected(expected, box) result = idx + Timestamp('2011-01-01') tm.assert_equal(result, expected) @pytest.mark.parametrize('box', [ pd.Index, Series, pytest.param(pd.DataFrame, marks=pytest.mark.xfail(reason="Returns object dtype", strict=True)) ], ids=lambda x: x.__name__) def test_td64_radd_timestamp(self, box): idx = TimedeltaIndex(['1 day', '2 day']) expected = DatetimeIndex(['2011-01-02', '2011-01-03']) idx = tm.box_expected(idx, box) expected = tm.box_expected(expected, box) # TODO: parametrize over scalar datetime types? result = Timestamp('2011-01-01') + idx tm.assert_equal(result, expected) @pytest.mark.parametrize('box', [ pd.Index, Series, pytest.param(pd.DataFrame, marks=pytest.mark.xfail(reason="Returns object dtype " "instead of " "datetime64[ns]", strict=True)) ], ids=lambda x: x.__name__) def test_td64arr_add_sub_timestamp(self, box): # GH#11925 ts = Timestamp('2012-01-01') # TODO: parametrize over types of datetime scalar? tdser = Series(timedelta_range('1 day', periods=3)) expected = Series(pd.date_range('2012-01-02', periods=3)) tdser = tm.box_expected(tdser, box) expected = tm.box_expected(expected, box) tm.assert_equal(ts + tdser, expected) tm.assert_equal(tdser + ts, expected) expected2 = Series(pd.date_range('2011-12-31', periods=3, freq='-1D')) expected2 = tm.box_expected(expected2, box) tm.assert_equal(ts - tdser, expected2) tm.assert_equal(ts + (-tdser), expected2) with pytest.raises(TypeError): tdser - ts def test_tdi_sub_dt64_array(self, box_df_fail): box = box_df_fail # DataFrame tries to broadcast incorrectly dti = pd.date_range('2016-01-01', periods=3) tdi = dti - dti.shift(1) dtarr = dti.values expected = pd.DatetimeIndex(dtarr) - tdi tdi = tm.box_expected(tdi, box) expected = tm.box_expected(expected, box) with pytest.raises(TypeError): tdi - dtarr # TimedeltaIndex.__rsub__ result = dtarr - tdi tm.assert_equal(result, expected) def test_tdi_add_dt64_array(self, box_df_fail): box = box_df_fail # DataFrame tries to broadcast incorrectly dti = pd.date_range('2016-01-01', periods=3) tdi = dti - dti.shift(1) dtarr = dti.values expected = pd.DatetimeIndex(dtarr) + tdi tdi = tm.box_expected(tdi, box) expected = tm.box_expected(expected, box) result = tdi + dtarr tm.assert_equal(result, expected) result = dtarr + tdi tm.assert_equal(result, expected) # ------------------------------------------------------------------ # Operations with int-like others @pytest.mark.parametrize('box', [ pd.Index, Series, pytest.param(pd.DataFrame, marks=pytest.mark.xfail(reason="Attempts to broadcast " "incorrectly", strict=True, raises=ValueError)) ], ids=lambda x: x.__name__) def test_td64arr_add_int_series_invalid(self, box, tdser): tdser = tm.box_expected(tdser, box) err = TypeError if box is not pd.Index else NullFrequencyError with pytest.raises(err): tdser + Series([2, 3, 4]) @pytest.mark.parametrize('box', [ pd.Index, pytest.param(Series, marks=pytest.mark.xfail(reason="GH#19123 integer " "interpreted as " "nanoseconds", strict=True)), pytest.param(pd.DataFrame, marks=pytest.mark.xfail(reason="Attempts to broadcast " "incorrectly", strict=True, raises=ValueError)) ], ids=lambda x: x.__name__) def test_td64arr_radd_int_series_invalid(self, box, tdser): tdser = tm.box_expected(tdser, box) err = TypeError if box is not pd.Index else NullFrequencyError with pytest.raises(err): Series([2, 3, 4]) + tdser @pytest.mark.parametrize('box', [ pd.Index, Series, pytest.param(pd.DataFrame, marks=pytest.mark.xfail(reason="Attempts to broadcast " "incorrectly", strict=True, raises=ValueError)) ], ids=lambda x: x.__name__) def test_td64arr_sub_int_series_invalid(self, box, tdser): tdser = tm.box_expected(tdser, box) err = TypeError if box is not pd.Index else NullFrequencyError with pytest.raises(err): tdser - Series([2, 3, 4]) @pytest.mark.xfail(reason='GH#19123 integer interpreted as nanoseconds', strict=True) def test_td64arr_rsub_int_series_invalid(self, box, tdser): tdser = tm.box_expected(tdser, box) with pytest.raises(TypeError): Series([2, 3, 4]) - tdser @pytest.mark.parametrize('box', [ pd.Index, Series, pytest.param(pd.DataFrame, marks=pytest.mark.xfail(reason="Attempts to broadcast " "incorrectly", strict=True, raises=ValueError)) ], ids=lambda x: x.__name__) def test_td64arr_add_intlike(self, box): # GH#19123 tdi = TimedeltaIndex(['59 days', '59 days', 'NaT']) ser = tm.box_expected(tdi, box) err = TypeError if box is not pd.Index else NullFrequencyError other = Series([20, 30, 40], dtype='uint8') # TODO: separate/parametrize with pytest.raises(err): ser + 1 with pytest.raises(err): ser - 1 with pytest.raises(err): ser + other with pytest.raises(err): ser - other with pytest.raises(err): ser + np.array(other) with pytest.raises(err): ser - np.array(other) with pytest.raises(err): ser + pd.Index(other) with pytest.raises(err): ser - pd.Index(other) @pytest.mark.parametrize('scalar', [1, 1.5, np.array(2)]) def test_td64arr_add_sub_numeric_scalar_invalid(self, box, scalar, tdser): if box is pd.DataFrame and isinstance(scalar, np.ndarray): # raises ValueError pytest.xfail(reason="DataFrame to broadcast incorrectly") tdser = tm.box_expected(tdser, box) err = TypeError if box is pd.Index and not isinstance(scalar, float): err = NullFrequencyError with pytest.raises(err): tdser + scalar with pytest.raises(err): scalar + tdser with pytest.raises(err): tdser - scalar with pytest.raises(err): scalar - tdser @pytest.mark.parametrize('box', [ pd.Index, Series, pytest.param(pd.DataFrame, marks=pytest.mark.xfail(reason="Tries to broadcast " "incorrectly", strict=True, raises=ValueError)) ], ids=lambda x: x.__name__) @pytest.mark.parametrize('dtype', ['int64', 'int32', 'int16', 'uint64', 'uint32', 'uint16', 'uint8', 'float64', 'float32', 'float16']) @pytest.mark.parametrize('vec', [ np.array([1, 2, 3]), pd.Index([1, 2, 3]), Series([1, 2, 3]) # TODO: Add DataFrame in here? ], ids=lambda x: type(x).__name__) def test_td64arr_add_sub_numeric_arr_invalid(self, box, vec, dtype, tdser): if type(vec) is Series and not dtype.startswith('float'): pytest.xfail(reason='GH#19123 integer interpreted as nanos') tdser = tm.box_expected(tdser, box) err = TypeError if box is pd.Index and not dtype.startswith('float'): err = NullFrequencyError vector = vec.astype(dtype) # TODO: parametrize over these four ops? with pytest.raises(err): tdser + vector with pytest.raises(err): vector + tdser with pytest.raises(err): tdser - vector with pytest.raises(err): vector - tdser # ------------------------------------------------------------------ # Operations with timedelta-like others def test_td64arr_add_td64_array(self, box_df_fail): box = box_df_fail # DataFrame tries to broadcast incorrectly dti = pd.date_range('2016-01-01', periods=3) tdi = dti - dti.shift(1) tdarr = tdi.values expected = 2 * tdi tdi = tm.box_expected(tdi, box) expected = tm.box_expected(expected, box) result = tdi + tdarr tm.assert_equal(result, expected) result = tdarr + tdi tm.assert_equal(result, expected) def test_td64arr_sub_td64_array(self, box_df_fail): box = box_df_fail # DataFrame tries to broadcast incorrectly dti = pd.date_range('2016-01-01', periods=3) tdi = dti - dti.shift(1) tdarr = tdi.values expected = 0 * tdi tdi = tm.box_expected(tdi, box) expected = tm.box_expected(expected, box) result = tdi - tdarr tm.assert_equal(result, expected) result = tdarr - tdi tm.assert_equal(result, expected) # TODO: parametrize over [add, sub, radd, rsub]? @pytest.mark.parametrize('box', [ pd.Index, Series, pytest.param(pd.DataFrame, marks=pytest.mark.xfail(reason="Tries to broadcast " "incorrectly leading " "to alignment error", strict=True, raises=ValueError)) ], ids=lambda x: x.__name__) @pytest.mark.parametrize('names', [(None, None, None), ('Egon', 'Venkman', None), ('NCC1701D', 'NCC1701D', 'NCC1701D')]) def test_td64arr_add_sub_tdi(self, box, names): # GH#17250 make sure result dtype is correct # GH#19043 make sure names are propagated correctly tdi = TimedeltaIndex(['0 days', '1 day'], name=names[0]) ser = Series([Timedelta(hours=3), Timedelta(hours=4)], name=names[1]) expected = Series([Timedelta(hours=3), Timedelta(days=1, hours=4)], name=names[2]) ser = tm.box_expected(ser, box) expected = tm.box_expected(expected, box) result = tdi + ser tm.assert_equal(result, expected) if box is not pd.DataFrame: assert result.dtype == 'timedelta64[ns]' else: assert result.dtypes[0] == 'timedelta64[ns]' result = ser + tdi tm.assert_equal(result, expected) if box is not pd.DataFrame: assert result.dtype == 'timedelta64[ns]' else: assert result.dtypes[0] == 'timedelta64[ns]' expected = Series([Timedelta(hours=-3), Timedelta(days=1, hours=-4)], name=names[2]) expected = tm.box_expected(expected, box) result = tdi - ser tm.assert_equal(result, expected) if box is not pd.DataFrame: assert result.dtype == 'timedelta64[ns]' else: assert result.dtypes[0] == 'timedelta64[ns]' result = ser - tdi tm.assert_equal(result, -expected) if box is not pd.DataFrame: assert result.dtype == 'timedelta64[ns]' else: assert result.dtypes[0] == 'timedelta64[ns]' def test_td64arr_sub_NaT(self, box): # GH#18808 ser = Series([NaT, Timedelta('1s')]) expected = Series([NaT, NaT], dtype='timedelta64[ns]') ser = tm.box_expected(ser, box) expected = tm.box_expected(expected, box) res = ser - pd.NaT tm.assert_equal(res, expected) def test_td64arr_add_timedeltalike(self, delta, box): # only test adding/sub offsets as + is now numeric if box is pd.DataFrame and isinstance(delta, pd.DateOffset): pytest.xfail(reason="Returns object dtype instead of m8[ns]") rng = timedelta_range('1 days', '10 days') expected = timedelta_range('1 days 02:00:00', '10 days 02:00:00', freq='D') rng = tm.box_expected(rng, box) expected = tm.box_expected(expected, box) result = rng + delta tm.assert_equal(result, expected) def test_td64arr_sub_timedeltalike(self, delta, box): # only test adding/sub offsets as - is now numeric if box is pd.DataFrame and isinstance(delta, pd.DateOffset): pytest.xfail(reason="Returns object dtype instead of m8[ns]") rng = timedelta_range('1 days', '10 days') expected = timedelta_range('0 days 22:00:00', '9 days 22:00:00') rng = tm.box_expected(rng, box) expected = tm.box_expected(expected, box) result = rng - delta tm.assert_equal(result, expected) # ------------------------------------------------------------------ # __add__/__sub__ with DateOffsets and arrays of DateOffsets @pytest.mark.parametrize('box', [ pd.Index, pytest.param(Series, marks=pytest.mark.xfail(reason="Index fails to return " "NotImplemented on " "reverse op", strict=True)), pytest.param(pd.DataFrame, marks=pytest.mark.xfail(reason="Tries to broadcast " "incorrectly", strict=True, raises=ValueError)) ], ids=lambda x: x.__name__) @pytest.mark.parametrize('names', [(None, None, None), ('foo', 'bar', None), ('foo', 'foo', 'foo')]) def test_td64arr_add_offset_index(self, names, box): # GH#18849, GH#19744 tdi = TimedeltaIndex(['1 days 00:00:00', '3 days 04:00:00'], name=names[0]) other = pd.Index([pd.offsets.Hour(n=1), pd.offsets.Minute(n=-2)], name=names[1]) expected = TimedeltaIndex([tdi[n] + other[n] for n in range(len(tdi))], freq='infer', name=names[2]) tdi = tm.box_expected(tdi, box) expected = tm.box_expected(expected, box) with tm.assert_produces_warning(PerformanceWarning): res = tdi + other tm.assert_equal(res, expected) with tm.assert_produces_warning(PerformanceWarning): res2 = other + tdi tm.assert_equal(res2, expected) # TODO: combine with test_td64arr_add_offset_index by parametrizing # over second box? def test_td64arr_add_offset_array(self, box_df_fail): # GH#18849 box = box_df_fail # tries to broadcast incorrectly tdi = TimedeltaIndex(['1 days 00:00:00', '3 days 04:00:00']) other = np.array([pd.offsets.Hour(n=1), pd.offsets.Minute(n=-2)]) expected = TimedeltaIndex([tdi[n] + other[n] for n in range(len(tdi))], freq='infer') tdi = tm.box_expected(tdi, box) expected = tm.box_expected(expected, box) with tm.assert_produces_warning(PerformanceWarning): res = tdi + other tm.assert_equal(res, expected) with tm.assert_produces_warning(PerformanceWarning): res2 = other + tdi tm.assert_equal(res2, expected) @pytest.mark.parametrize('names', [(None, None, None), ('foo', 'bar', None), ('foo', 'foo', 'foo')]) def test_td64arr_sub_offset_index(self, names, box_df_fail): # GH#18824, GH#19744 box = box_df_fail # tries to broadcast incorrectly tdi = TimedeltaIndex(['1 days 00:00:00', '3 days 04:00:00'], name=names[0]) other = pd.Index([pd.offsets.Hour(n=1), pd.offsets.Minute(n=-2)], name=names[1]) expected = TimedeltaIndex([tdi[n] - other[n] for n in range(len(tdi))], freq='infer', name=names[2]) tdi = tm.box_expected(tdi, box) expected = tm.box_expected(expected, box) with tm.assert_produces_warning(PerformanceWarning): res = tdi - other tm.assert_equal(res, expected) def test_td64arr_sub_offset_array(self, box_df_fail): # GH#18824 box = box_df_fail # tries to broadcast incorrectly tdi = TimedeltaIndex(['1 days 00:00:00', '3 days 04:00:00']) other = np.array([pd.offsets.Hour(n=1), pd.offsets.Minute(n=-2)]) expected = TimedeltaIndex([tdi[n] - other[n] for n in range(len(tdi))], freq='infer') tdi = tm.box_expected(tdi, box) expected = tm.box_expected(expected, box) with tm.assert_produces_warning(PerformanceWarning): res = tdi - other tm.assert_equal(res, expected) @pytest.mark.parametrize('box', [ pd.Index, pytest.param(Series, marks=pytest.mark.xfail(reason="object dtype Series " "fails to return " "NotImplemented", strict=True, raises=TypeError)), pytest.param(pd.DataFrame, marks=pytest.mark.xfail(reason="tries to broadcast " "incorrectly", strict=True, raises=ValueError)) ], ids=lambda x: x.__name__) @pytest.mark.parametrize('names', [(None, None, None), ('foo', 'bar', None), ('foo', 'foo', 'foo')]) def test_td64arr_with_offset_series(self, names, box): # GH#18849 box2 = Series if box is pd.Index else box tdi = TimedeltaIndex(['1 days 00:00:00', '3 days 04:00:00'], name=names[0]) other = Series([pd.offsets.Hour(n=1), pd.offsets.Minute(n=-2)], name=names[1]) expected_add = Series([tdi[n] + other[n] for n in range(len(tdi))], name=names[2]) tdi = tm.box_expected(tdi, box) expected_add = tm.box_expected(expected_add, box2) with tm.assert_produces_warning(PerformanceWarning): res = tdi + other tm.assert_equal(res, expected_add) with tm.assert_produces_warning(PerformanceWarning): res2 = other + tdi tm.assert_equal(res2, expected_add) # TODO: separate/parametrize add/sub test? expected_sub = Series([tdi[n] - other[n] for n in range(len(tdi))], name=names[2]) expected_sub = tm.box_expected(expected_sub, box2) with tm.assert_produces_warning(PerformanceWarning): res3 = tdi - other tm.assert_equal(res3, expected_sub) @pytest.mark.parametrize('obox', [np.array, pd.Index, pd.Series]) def test_td64arr_addsub_anchored_offset_arraylike(self, obox, box_df_fail): # GH#18824 box = box_df_fail # DataFrame tries to broadcast incorrectly tdi = TimedeltaIndex(['1 days 00:00:00', '3 days 04:00:00']) tdi = tm.box_expected(tdi, box) anchored = obox([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)]) # addition/subtraction ops with anchored offsets should issue # a PerformanceWarning and _then_ raise a TypeError. with pytest.raises(TypeError): with tm.assert_produces_warning(PerformanceWarning): tdi + anchored with pytest.raises(TypeError): with tm.assert_produces_warning(PerformanceWarning): anchored + tdi with pytest.raises(TypeError): with tm.assert_produces_warning(PerformanceWarning): tdi - anchored with pytest.raises(TypeError): with tm.assert_produces_warning(PerformanceWarning): anchored - tdi class TestTimedeltaArraylikeMulDivOps(object): # Tests for timedelta64[ns] # __mul__, __rmul__, __div__, __rdiv__, __floordiv__, __rfloordiv__ # ------------------------------------------------------------------ # Multiplication # organized with scalar others first, then array-like def test_td64arr_mul_int(self, box_df_fail): box = box_df_fail # DataFrame op returns object instead of m8[ns] idx = TimedeltaIndex(np.arange(5, dtype='int64')) idx = tm.box_expected(idx, box) result = idx * 1 tm.assert_equal(result, idx) result = 1 * idx tm.assert_equal(result, idx) def test_td64arr_mul_tdlike_scalar_raises(self, delta, box): if box is pd.DataFrame and not isinstance(delta, pd.DateOffset): pytest.xfail(reason="returns m8[ns] instead of raising") rng = timedelta_range('1 days', '10 days', name='foo') rng = tm.box_expected(rng, box) with pytest.raises(TypeError): rng * delta def test_tdi_mul_int_array_zerodim(self, box_df_fail): box = box_df_fail # DataFrame op returns object dtype rng5 = np.arange(5, dtype='int64') idx = TimedeltaIndex(rng5) expected = TimedeltaIndex(rng5 * 5) idx = tm.box_expected(idx, box) expected = tm.box_expected(expected, box) result = idx * np.array(5, dtype='int64') tm.assert_equal(result, expected) def test_tdi_mul_int_array(self, box_df_fail): box = box_df_fail # DataFrame tries to broadcast incorrectly rng5 = np.arange(5, dtype='int64') idx = TimedeltaIndex(rng5) expected = TimedeltaIndex(rng5 ** 2) idx = tm.box_expected(idx, box) expected = tm.box_expected(expected, box) result = idx * rng5 tm.assert_equal(result, expected) def test_tdi_mul_int_series(self, box_df_fail): box = box_df_fail # DataFrame tries to broadcast incorrectly idx = TimedeltaIndex(np.arange(5, dtype='int64')) expected = TimedeltaIndex(np.arange(5, dtype='int64') ** 2) idx = tm.box_expected(idx, box) box2 = pd.Series if box is pd.Index else box expected = tm.box_expected(expected, box2) result = idx * pd.Series(np.arange(5, dtype='int64')) tm.assert_equal(result, expected) def test_tdi_mul_float_series(self, box_df_fail): box = box_df_fail # DataFrame tries to broadcast incorrectly idx = TimedeltaIndex(np.arange(5, dtype='int64')) idx = tm.box_expected(idx, box) rng5f = np.arange(5, dtype='float64') expected = TimedeltaIndex(rng5f * (rng5f + 0.1)) box2 = pd.Series if box is pd.Index else box expected = tm.box_expected(expected, box2) result = idx * Series(rng5f + 0.1) tm.assert_equal(result, expected) # TODO: Put Series/DataFrame in others? @pytest.mark.parametrize('other', [ np.arange(1, 11), pd.Int64Index(range(1, 11)), pd.UInt64Index(range(1, 11)), pd.Float64Index(range(1, 11)), pd.RangeIndex(1, 11) ], ids=lambda x: type(x).__name__) def test_tdi_rmul_arraylike(self, other, box_df_fail): # RangeIndex fails to return NotImplemented, for others # DataFrame tries to broadcast incorrectly box = box_df_fail tdi = TimedeltaIndex(['1 Day'] * 10) expected = timedelta_range('1 days', '10 days') tdi = tm.box_expected(tdi, box) expected = tm.box_expected(expected, box) result = other * tdi tm.assert_equal(result, expected) commute = tdi * other tm.assert_equal(commute, expected) # ------------------------------------------------------------------ # __div__ def test_td64arr_div_nat_invalid(self, box_df_fail): # don't allow division by NaT (maybe could in the future) box = box_df_fail # DataFrame returns all-NaT instead of raising rng = timedelta_range('1 days', '10 days', name='foo') rng = tm.box_expected(rng, box) with pytest.raises(TypeError): rng / pd.NaT def test_td64arr_div_int(self, box_df_fail): box = box_df_fail # DataFrame returns object dtype instead of m8[ns] idx = TimedeltaIndex(np.arange(5, dtype='int64')) idx = tm.box_expected(idx, box) result = idx / 1 tm.assert_equal(result, idx) def test_tdi_div_tdlike_scalar(self, delta, box_df_fail): box = box_df_fail # DataFrame op returns m8[ns] instead of float64 rng = timedelta_range('1 days', '10 days', name='foo') expected = pd.Float64Index((np.arange(10) + 1) * 12, name='foo') rng = tm.box_expected(rng, box) expected = tm.box_expected(expected, box) result = rng / delta tm.assert_equal(result, expected) def test_tdi_div_tdlike_scalar_with_nat(self, delta, box_df_fail): box = box_df_fail # DataFrame op returns m8[ns] instead of float64 rng = TimedeltaIndex(['1 days', pd.NaT, '2 days'], name='foo') expected = pd.Float64Index([12, np.nan, 24], name='foo') rng = tm.box_expected(rng, box) expected = tm.box_expected(expected, box) result = rng / delta tm.assert_equal(result, expected) # ------------------------------------------------------------------ # __floordiv__, __rfloordiv__ @pytest.mark.parametrize('box', [ pd.Index, Series, pytest.param(pd.DataFrame, marks=pytest.mark.xfail(reason="Incorrectly returns " "m8[ns] instead of f8", strict=True)) ], ids=lambda x: x.__name__) def test_td64arr_floordiv_tdscalar(self, box, scalar_td): # GH#18831 td1 = Series([timedelta(minutes=5, seconds=3)] * 3) td1.iloc[2] = np.nan expected = Series([0, 0, np.nan]) td1 = tm.box_expected(td1, box) expected = tm.box_expected(expected, box) result = td1 // scalar_td tm.assert_equal(result, expected) @pytest.mark.parametrize('box', [ pd.Index, Series, pytest.param(pd.DataFrame, marks=pytest.mark.xfail(reason="Incorrectly casts to f8", strict=True)) ], ids=lambda x: x.__name__) def test_td64arr_rfloordiv_tdscalar(self, box, scalar_td): # GH#18831 td1 = Series([timedelta(minutes=5, seconds=3)] * 3) td1.iloc[2] = np.nan expected = Series([1, 1, np.nan]) td1 = tm.box_expected(td1, box) expected = tm.box_expected(expected, box) result = scalar_td // td1 tm.assert_equal(result, expected) @pytest.mark.parametrize('box', [ pd.Index, Series, pytest.param(pd.DataFrame, marks=pytest.mark.xfail(reason="Returns m8[ns] dtype " "instead of f8", strict=True)) ], ids=lambda x: x.__name__) def test_td64arr_rfloordiv_tdscalar_explicit(self, box, scalar_td): # GH#18831 td1 = Series([timedelta(minutes=5, seconds=3)] * 3) td1.iloc[2] = np.nan expected = Series([1, 1, np.nan]) td1 = tm.box_expected(td1, box) expected = tm.box_expected(expected, box) # We can test __rfloordiv__ using this syntax, # see `test_timedelta_rfloordiv` result = td1.__rfloordiv__(scalar_td) tm.assert_equal(result, expected) def test_td64arr_floordiv_int(self, box_df_fail): box = box_df_fail # DataFrame returns object dtype idx = TimedeltaIndex(np.arange(5, dtype='int64')) idx = tm.box_expected(idx, box) result = idx // 1
tm.assert_equal(result, idx)
pandas.util.testing.assert_equal
# Author: <NAME> <<EMAIL>> # # License: Apache Software License 2.0 """Tests concerning :class:`nannyml.metadata.regression.RegressionMetadata`.""" from typing import Tuple import pandas as pd import pytest from nannyml.datasets import load_synthetic_binary_classification_dataset from nannyml.metadata import FeatureType, ModelType, RegressionMetadata, extract_metadata from nannyml.metadata.base import ( NML_METADATA_PARTITION_COLUMN_NAME, NML_METADATA_TARGET_COLUMN_NAME, NML_METADATA_TIMESTAMP_COLUMN_NAME, ) from nannyml.metadata.regression import NML_METADATA_PREDICTION_COLUMN_NAME, _guess_predictions @pytest.fixture def data() -> Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]: # noqa: D103 ref_df, ana_df, tgt_df = load_synthetic_binary_classification_dataset() # TODO create new regression sample data return ref_df, ana_df, tgt_df @pytest.fixture def metadata(data) -> RegressionMetadata: # noqa: D103 md = extract_metadata(data[0], model_type='regression') md.target_column_name = 'work_home_actual' return md def test_model_metadata_creation_with_defaults_has_correct_properties(): # noqa: D103 sut = RegressionMetadata() assert sut.name is None assert sut.model_type == ModelType.REGRESSION assert sut.features is not None assert len(sut.features) == 0 assert sut.prediction_column_name is None assert sut.target_column_name == 'target' assert sut.partition_column_name == 'partition' assert sut.timestamp_column_name == 'date' def test_model_metadata_creation_sets_correct_values_for_special_attributes(): # noqa: D103 sut = RegressionMetadata(prediction_column_name='pred') assert sut.prediction_column_name == 'pred' def test_to_dict_contains_all_properties(metadata): # noqa: D103 sut = metadata.to_dict() assert sut['prediction_column_name'] == 'y_pred' def test_to_pd_contains_all_properties(metadata): # noqa: D103 sut = metadata.to_df() assert sut.loc[sut['label'] == 'prediction_column_name', 'column_name'].iloc[0] == 'y_pred' @pytest.mark.parametrize( 'col,expected', [ ('p', True), ('y_pred', True), ('pred', True), ('prediction', True), ('out', True), ('output', True), ('nope', False), ], ) def test_guess_predictions_yields_correct_results(col, expected): # noqa: D103 sut = _guess_predictions(data=
pd.DataFrame(columns=[col])
pandas.DataFrame
"""General utility functions that are used in a variety of contexts. The functions in this module are used in various stages of the ETL and post-etl processes. They are usually not dataset specific, but not always. If a function is designed to be used as a general purpose tool, applicable in multiple scenarios, it should probably live here. There are lost of transform type functions in here that help with cleaning and restructing dataframes. """ import itertools import logging import pathlib import re import shutil from collections import defaultdict from functools import partial from importlib import resources from io import BytesIO from typing import Any, DefaultDict, Dict, List, Optional, Set, Union import addfips import numpy as np import pandas as pd import requests import sqlalchemy as sa from pudl.metadata.classes import DataSource, Package from pudl.metadata.fields import apply_pudl_dtypes, get_pudl_dtypes logger = logging.getLogger(__name__) sum_na = partial(pd.Series.sum, skipna=False) """A sum function that returns NA if the Series includes any NA values. In many of our aggregations we need to override the default behavior of treating NA values as if they were zero. E.g. when calculating the heat rates of generation units, if there are some months where fuel consumption is reported as NA, but electricity generation is reported normally, then the fuel consumption for the year needs to be NA, otherwise we'll get unrealistic heat rates. """ def label_map( df: pd.DataFrame, from_col: str = "code", to_col: str = "label", null_value: Union[str, type(pd.NA)] = pd.NA, ) -> DefaultDict[str, Union[str, type(pd.NA)]]: """Build a mapping dictionary from two columns of a labeling / coding dataframe. These dataframes document the meanings of the codes that show up in much of the originally reported data. They're defined in :mod:`pudl.metadata.codes`. This function is mostly used to build maps that can translate the hard to understand short codes into longer human-readable codes. Args: df: The coding / labeling dataframe. Must contain columns ``from_col`` and ``to_col``. from_col: Label of column containing the existing codes to be replaced. to_col: Label of column containing the new codes to be swapped in. null_value: Defualt (Null) value to map to when a value which doesn't appear in ``from_col`` is encountered. Returns: A mapping dictionary suitable for use with :meth:`pandas.Series.map`. """ return defaultdict( lambda: null_value, df.loc[:, [from_col, to_col]] .drop_duplicates(subset=[from_col]) .to_records(index=False), ) def find_new_ferc1_strings( table: str, field: str, strdict: Dict[str, List[str]], ferc1_engine: sa.engine.Engine, ) -> Set[str]: """Identify as-of-yet uncategorized freeform strings in FERC Form 1. Args: table: Name of the FERC Form 1 DB to search. field: Name of the column in that table to search. strdict: A string cleaning dictionary. See e.g. `pudl.transform.ferc1.FUEL_UNIT_STRINGS` ferc1_engine: SQL Alchemy DB connection engine for the FERC Form 1 DB. Returns: Any string found in the searched table + field that was not part of any of categories enumerated in strdict. """ all_strings = set( pd.read_sql(f"SELECT {field} FROM {table};", ferc1_engine).pipe( # nosec simplify_strings, columns=[field] )[field] ) old_strings = set.union(*[set(strings) for strings in strdict.values()]) return all_strings.difference(old_strings) def find_foreign_key_errors(dfs: Dict[str, pd.DataFrame]) -> List[Dict[str, Any]]: """Report foreign key violations from a dictionary of dataframes. The database schema to check against is generated based on the names of the dataframes (keys of the dictionary) and the PUDL metadata structures. Args: dfs: Keys are table names, and values are dataframes ready for loading into the SQLite database. Returns: A list of dictionaries, each one pertains to a single database table in which a foreign key constraint violation was found, and it includes the table name, foreign key definition, and the elements of the dataframe that violated the foreign key constraint. """ package = Package.from_resource_ids(resource_ids=tuple(sorted(dfs))) errors = [] for resource in package.resources: for foreign_key in resource.schema.foreign_keys: x = dfs[resource.name][foreign_key.fields] y = dfs[foreign_key.reference.resource][foreign_key.reference.fields] ncols = x.shape[1] idx = range(ncols) xx, yy = x.set_axis(idx, axis=1), y.set_axis(idx, axis=1) if ncols == 1: # Faster check for single-field foreign key invalid = ~(xx[0].isin(yy[0]) | xx[0].isna()) else: invalid = ~( pd.concat([yy, xx]).duplicated().iloc[len(yy) :] | xx.isna().any(axis=1) ) if invalid.any(): errors.append( { "resource": resource.name, "foreign_key": foreign_key, "invalid": x[invalid], } ) return errors def download_zip_url(url, save_path, chunk_size=128): """Download and save a Zipfile locally. Useful for acquiring and storing non-PUDL data locally. Args: url (str): The URL from which to download the Zipfile save_path (pathlib.Path): The location to save the file. chunk_size (int): Data chunk in bytes to use while downloading. Returns: None """ # This is a temporary hack to avoid being filtered as a bot: headers = { "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:77.0) Gecko/20100101 Firefox/77.0", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8", "Accept-Language": "en-US,en;q=0.5", "DNT": "1", "Connection": "keep-alive", "Upgrade-Insecure-Requests": "1", } r = requests.get(url, stream=True, headers=headers) with save_path.open(mode="wb") as fd: for chunk in r.iter_content(chunk_size=chunk_size): fd.write(chunk) def add_fips_ids(df, state_col="state", county_col="county", vintage=2015): """Add State and County FIPS IDs to a dataframe. To just add State FIPS IDs, make county_col = None. """ # force the columns to be the nullable string types so we have a consistent # null value to filter out before feeding to addfips df = df.astype({state_col: pd.StringDtype()}) if county_col: df = df.astype({county_col: pd.StringDtype()}) af = addfips.AddFIPS(vintage=vintage) # Lookup the state and county FIPS IDs and add them to the dataframe: df["state_id_fips"] = df.apply( lambda x: ( af.get_state_fips(state=x[state_col]) if pd.notnull(x[state_col]) else pd.NA ), axis=1, ) # force the code columns to be nullable strings - the leading zeros are # important df = df.astype({"state_id_fips": pd.StringDtype()}) logger.info( f"Assigned state FIPS codes for " f"{len(df[df.state_id_fips.notnull()])/len(df):.2%} of records." ) if county_col: df["county_id_fips"] = df.apply( lambda x: ( af.get_county_fips(state=x[state_col], county=x[county_col]) if pd.notnull(x[county_col]) and pd.notnull(x[state_col]) else pd.NA ), axis=1, ) # force the code columns to be nullable strings - the leading zeros are # important df = df.astype({"county_id_fips": pd.StringDtype()}) logger.info( f"Assigned county FIPS codes for " f"{len(df[df.county_id_fips.notnull()])/len(df):.2%} of records." ) return df def clean_eia_counties(df, fixes, state_col="state", county_col="county"): """Replace non-standard county names with county nmes from US Census.""" df = df.copy() df[county_col] = ( df[county_col] .str.strip() # Condense multiple whitespace chars. .str.replace(r"\s+", " ", regex=True) .str.replace(r"^St ", "St. ", regex=True) # Standardize abbreviation. # Standardize abbreviation. .str.replace(r"^Ste ", "Ste. ", regex=True) .str.replace("Kent & New Castle", "Kent, New Castle") # Two counties # Fix ordering, remove comma .str.replace("Borough, Kodiak Island", "Kodiak Island Borough") # Turn comma-separated counties into lists .str.replace(r",$", "", regex=True) .str.split(",") ) # Create new records for each county in a multi-valued record df = df.explode(county_col) df[county_col] = df[county_col].str.strip() # Yellowstone county is in MT, not WY df.loc[ (df[state_col] == "WY") & (df[county_col] == "Yellowstone"), state_col ] = "MT" # Replace individual bad county names with identified correct names in fixes: for fix in fixes.itertuples(): state_mask = df[state_col] == fix.state county_mask = df[county_col] == fix.eia_county df.loc[state_mask & county_mask, county_col] = fix.fips_county return df def oob_to_nan(df, cols, lb=None, ub=None): """Set non-numeric values and those outside of a given rage to NaN. Args: df (pandas.DataFrame): The dataframe containing values to be altered. cols (iterable): Labels of the columns whose values are to be changed. lb: (number): Lower bound, below which values are set to NaN. If None, don't use a lower bound. ub: (number): Upper bound, below which values are set to NaN. If None, don't use an upper bound. Returns: pandas.DataFrame: The altered DataFrame. """ out_df = df.copy() for col in cols: # Force column to be numeric if possible, NaN otherwise: out_df.loc[:, col] = pd.to_numeric(out_df[col], errors="coerce") if lb is not None: out_df.loc[out_df[col] < lb, col] = np.nan if ub is not None: out_df.loc[out_df[col] > ub, col] = np.nan return out_df def prep_dir(dir_path, clobber=False): """Create (or delete and recreate) a directory. Args: dir_path (path-like): path to the directory that you are trying to clean and prepare. clobber (bool): If True and dir_path exists, it will be removed and replaced with a new, empty directory. Raises: FileExistsError: if a file or directory already exists at dir_path. Returns: pathlib.Path: Path to the created directory. """ dir_path = pathlib.Path(dir_path) if dir_path.exists(): if clobber: shutil.rmtree(dir_path) else: raise FileExistsError(f"{dir_path} exists and clobber is {clobber}") dir_path.mkdir(parents=True) return dir_path def is_doi(doi): """Determine if a string is a valid digital object identifier (DOI). Function simply checks whether the offered string matches a regular expresssion -- it doesn't check whether the DOI is actually registered with the relevant authority. Args: doi (str): String to validate. Returns: bool: True if doi matches the regex for valid DOIs, False otherwise. """ doi_regex = re.compile( r"(doi:\s*|(?:https?://)?(?:dx\.)?doi\.org/)?(10\.\d+(.\d+)*/.+)$", re.IGNORECASE | re.UNICODE, ) return bool(re.match(doi_regex, doi)) def clean_merge_asof( left: pd.DataFrame, right: pd.DataFrame, left_on: str = "report_date", right_on: str = "report_date", by: List[str] = [], ) -> pd.DataFrame: """Merge two dataframes having different ``report_date`` frequencies. We often need to bring together data which is reported on a monthly basis, and entity attributes that are reported on an annual basis. The :func:`pandas.merge_asof` is designed to do this, but requires that dataframes are sorted by the merge keys (``left_on``, ``right_on``, and ``by`` here). We also need to make sure that all merge keys have identical data types in the two dataframes (e.g. ``plant_id_eia`` needs to be a nullable integer in both dataframes, not a python int in one, and a nullable :func:`pandas.Int64Dtype` in the other). Note that :func:`pandas.merge_asof` performs a left merge, so the higher frequency dataframe **must** be the left dataframe. We also force both ``left_on`` and ``right_on`` to be a Datetime using :func:`pandas.to_datetime` to allow merging dataframes having integer years with those having datetime columns. Because :func:`pandas.merge_asof` searches backwards for the first matching date, this function only works if the less granular dataframe uses the convention of reporting the first date in the time period for which it reports. E.g. annual dataframes need to have January 1st as the date. This is what happens by defualt if only a year or year-month are provided to :func:`pandas.to_datetime` as strings. Args: left: The higher frequency "data" dataframe. Typically monthly in our use cases. E.g. ``generation_eia923``. Must contain ``report_date`` and any columns specified in the ``by`` argument. right: The lower frequency "attribute" dataframe. Typically annual in our uses cases. E.g. ``generators_eia860``. Must contain ``report_date`` and any columns specified in the ``by`` argument. left_on: Column in ``left`` to merge on using merge_asof. Default is ``report_date``. Must be convertible to a Datetime using :func:`pandas.to_datetime` right_on: Column in ``right`` to merge on using :func:`pd.merge_asof`. Default is ``report_date``. Must be convertible to a Datetime using :func:`pandas.to_datetime` by: Columns to merge on in addition to ``report_date``. Typically ID columns like ``plant_id_eia``, ``generator_id`` or ``boiler_id``. Returns: Merged contents of left and right input dataframes. Will be sorted by ``left_on`` and any columns specified in ``by``. See documentation for :func:`pandas.merge_asof` to understand how this kind of merge works. Raises: ValueError: if ``left_on`` or ``right_on`` columns are missing from their respective input dataframes. ValueError: if any of the labels referenced in ``by`` are missing from either the left or right dataframes. """ # Make sure we've got all the required inputs... if left_on not in left.columns: raise ValueError(f"Left dataframe has no column {left_on}.") if right_on not in right.columns: raise ValueError(f"Right dataframe has no {right_on}.") missing_left_cols = [col for col in by if col not in left.columns] if missing_left_cols: raise ValueError(f"Left dataframe is missing {missing_left_cols}.") missing_right_cols = [col for col in by if col not in right.columns] if missing_right_cols: raise ValueError(f"Left dataframe is missing {missing_right_cols}.") def cleanup(df, on, by): df = apply_pudl_dtypes(df) df.loc[:, on] = pd.to_datetime(df[on]) df = df.sort_values([on] + by) return df return pd.merge_asof( cleanup(df=left, on=left_on, by=by), cleanup(df=right, on=right_on, by=by), left_on=left_on, right_on=right_on, by=by, tolerance=pd.Timedelta("365 days"), # Should never match across years. ) def organize_cols(df, cols): """Organize columns into key ID & name fields & alphabetical data columns. For readability, it's nice to group a few key columns at the beginning of the dataframe (e.g. report_year or report_date, plant_id...) and then put all the rest of the data columns in alphabetical order. Args: df: The DataFrame to be re-organized. cols: The columns to put first, in their desired output ordering. Returns: pandas.DataFrame: A dataframe with the same columns as the input DataFrame df, but with cols first, in the same order as they were passed in, and the remaining columns sorted alphabetically. """ # Generate a list of all the columns in the dataframe that are not # included in cols data_cols = sorted([c for c in df.columns.tolist() if c not in cols]) organized_cols = cols + data_cols return df[organized_cols] def simplify_strings(df, columns): """Simplify the strings contained in a set of dataframe columns. Performs several operations to simplify strings for comparison and parsing purposes. These include removing Unicode control characters, stripping leading and trailing whitespace, using lowercase characters, and compacting all internal whitespace to a single space. Leaves null values unaltered. Casts other values with astype(str). Args: df (pandas.DataFrame): DataFrame whose columns are being cleaned up. columns (iterable): The labels of the string columns to be simplified. Returns: pandas.DataFrame: The whole DataFrame that was passed in, with the string columns cleaned up. """ out_df = df.copy() for col in columns: if col in out_df.columns: out_df.loc[out_df[col].notnull(), col] = ( out_df.loc[out_df[col].notnull(), col] .astype(str) .str.replace(r"[\x00-\x1f\x7f-\x9f]", "", regex=True) .str.strip() .str.lower() .str.replace(r"\s+", " ", regex=True) ) return out_df def cleanstrings_series(col, str_map, unmapped=None, simplify=True): """Clean up the strings in a single column/Series. Args: col (pandas.Series): A pandas Series, typically a single column of a dataframe, containing the freeform strings that are to be cleaned. str_map (dict): A dictionary of lists of strings, in which the keys are the simplified canonical strings, witch which each string found in the corresponding list will be replaced. unmapped (str): A value with which to replace any string found in col that is not found in one of the lists of strings in map. Typically the null string ''. If None, these strings will not be replaced. simplify (bool): If True, strip and compact whitespace, and lowercase all strings in both the list of values to be replaced, and the values found in col. This can reduce the number of strings that need to be kept track of. Returns: pandas.Series: The cleaned up Series / column, suitable for replacing the original messy column in a :class:`pandas.DataFrame`. """ if simplify: col = ( col.astype(str).str.strip().str.lower().str.replace(r"\s+", " ", regex=True) ) for k in str_map: str_map[k] = [re.sub(r"\s+", " ", s.lower().strip()) for s in str_map[k]] for k in str_map: if str_map[k]: col = col.replace(str_map[k], k) if unmapped is not None: badstrings = np.setdiff1d(col.unique(), list(str_map.keys())) # This call to replace can only work if there are actually some # leftover strings to fix -- otherwise it runs forever because we # are replacing nothing with nothing. if len(badstrings) > 0: col = col.replace(badstrings, unmapped) return col def cleanstrings(df, columns, stringmaps, unmapped=None, simplify=True): """Consolidate freeform strings in several dataframe columns. This function will consolidate freeform strings found in `columns` into simplified categories, as defined by `stringmaps`. This is useful when a field contains many different strings that are really meant to represent a finite number of categories, e.g. a type of fuel. It can also be used to create simplified categories that apply to similar attributes that are reported in various data sources from different agencies that use their own taxonomies. The function takes and returns a pandas.DataFrame, making it suitable for use with the :func:`pandas.DataFrame.pipe` method in a chain. Args: df (pandas.DataFrame): the DataFrame containing the string columns to be cleaned up. columns (list): a list of string column labels found in the column index of df. These are the columns that will be cleaned. stringmaps (list): a list of dictionaries. The keys of these dictionaries are strings, and the values are lists of strings. Each dictionary in the list corresponds to a column in columns. The keys of the dictionaries are the values with which every string in the list of values will be replaced. unmapped (str, None): the value with which strings not found in the stringmap dictionary will be replaced. Typically the null string ''. If None, then strings found in the columns but not in the stringmap will be left unchanged. simplify (bool): If true, strip whitespace, remove duplicate whitespace, and force lower-case on both the string map and the values found in the columns to be cleaned. This can reduce the overall number of string values that need to be tracked. Returns: pandas.DataFrame: The function returns a new DataFrame containing the cleaned strings. """ out_df = df.copy() for col, str_map in zip(columns, stringmaps): out_df[col] = cleanstrings_series( out_df[col], str_map, unmapped=unmapped, simplify=simplify ) return out_df def fix_int_na(df, columns, float_na=np.nan, int_na=-1, str_na=""): """Convert NA containing integer columns from float to string. Numpy doesn't have a real NA value for integers. When pandas stores integer data which has NA values, it thus upcasts integers to floating point values, using np.nan values for NA. However, in order to dump some of our dataframes to CSV files for use in data packages, we need to write out integer formatted numbers, with empty strings as the NA value. This function replaces np.nan values with a sentinel value, converts the column to integers, and then to strings, finally replacing the sentinel value with the desired NA string. This is an interim solution -- now that pandas extension arrays have been implemented, we need to go back through and convert all of these integer columns that contain NA values to Nullable Integer types like Int64. Args: df (pandas.DataFrame): The dataframe to be fixed. This argument allows method chaining with the pipe() method. columns (iterable of strings): A list of DataFrame column labels indicating which columns need to be reformatted for output. float_na (float): The floating point value to be interpreted as NA and replaced in col. int_na (int): Sentinel value to substitute for float_na prior to conversion of the column to integers. str_na (str): sa.String value to substitute for int_na after the column has been converted to strings. Returns: df (pandas.DataFrame): a new DataFrame, with the selected columns converted to strings that look like integers, compatible with the postgresql COPY FROM command. """ return ( df.replace({c: float_na for c in columns}, int_na) .astype({c: int for c in columns}) .astype({c: str for c in columns}) .replace({c: str(int_na) for c in columns}, str_na) ) def month_year_to_date(df): """Convert all pairs of year/month fields in a dataframe into Date fields. This function finds all column names within a dataframe that match the regular expression '_month$' and '_year$', and looks for pairs that have identical prefixes before the underscore. These fields are assumed to describe a date, accurate to the month. The two fields are used to construct a new _date column (having the same prefix) and the month/year columns are then dropped. Todo: This function needs to be combined with convert_to_date, and improved: * find and use a _day$ column as well * allow specification of default month & day values, if none are found. * allow specification of lists of year, month, and day columns to be combined, rather than automataically finding all the matching ones. * Do the Right Thing when invalid or NA values are encountered. Args: df (pandas.DataFrame): The DataFrame in which to convert year/months fields to Date fields. Returns: pandas.DataFrame: A DataFrame in which the year/month fields have been converted into Date fields. """ df = df.copy() month_regex = "_month$" year_regex = "_year$" # Columns that match our month or year patterns. month_cols = list(df.filter(regex=month_regex).columns) year_cols = list(df.filter(regex=year_regex).columns) # Base column names that don't include the month or year pattern months_base = [re.sub(month_regex, "", m) for m in month_cols] years_base = [re.sub(year_regex, "", y) for y in year_cols] # We only want to retain columns that have BOTH month and year # matches -- otherwise there's no point in creating a Date. date_base = [base for base in months_base if base in years_base] # For each base column that DOES have both a month and year, # We need to grab the real column names corresponding to each, # so we can access the values in the data frame, and use them # to create a corresponding Date column named [BASE]_date month_year_date = [] for base in date_base: base_month_regex = f"^{base}{month_regex}" month_col = list(df.filter(regex=base_month_regex).columns) if not len(month_col) == 1: raise AssertionError() month_col = month_col[0] base_year_regex = f"^{base}{year_regex}" year_col = list(df.filter(regex=base_year_regex).columns) if not len(year_col) == 1: raise AssertionError() year_col = year_col[0] date_col = f"{base}_date" month_year_date.append((month_col, year_col, date_col)) for month_col, year_col, date_col in month_year_date: df = fix_int_na(df, columns=[year_col, month_col]) date_mask = (df[year_col] != "") & (df[month_col] != "") years = df.loc[date_mask, year_col] months = df.loc[date_mask, month_col] df.loc[date_mask, date_col] = pd.to_datetime( {"year": years, "month": months, "day": 1}, errors="coerce" ) # Now that we've replaced these fields with a date, we drop them. df = df.drop([month_col, year_col], axis=1) return df def fix_leading_zero_gen_ids(df): """Remove leading zeros from EIA generator IDs which are numeric strings. If the DataFrame contains a column named ``generator_id`` then that column will be cast to a string, and any all numeric value with leading zeroes will have the leading zeroes removed. This is necessary because in some but not all years of data, some of the generator IDs are treated as integers in the Excel spreadsheets published by EIA, so the same generator may show up with the ID "0001" and "1" in different years. Alphanumeric generator IDs with leadings zeroes are not affected, as we found no instances in which an alphanumeric generator ID appeared both with and without leading zeroes. Args: df (pandas.DataFrame): DataFrame, presumably containing a column named generator_id (otherwise no action will be taken.) Returns: pandas.DataFrame """ if "generator_id" in df.columns: fixed_generator_id = ( df["generator_id"] .astype(str) .apply(lambda x: re.sub(r"^0+(\d+$)", r"\1", x)) ) num_fixes = len(df.loc[df["generator_id"].astype(str) != fixed_generator_id]) logger.debug("Fixed %s EIA generator IDs with leading zeros.", num_fixes) df = df.drop("generator_id", axis="columns").assign( generator_id=fixed_generator_id ) return df def convert_to_date( df, date_col="report_date", year_col="report_year", month_col="report_month", day_col="report_day", month_value=1, day_value=1, ): """Convert specified year, month or day columns into a datetime object. If the input ``date_col`` already exists in the input dataframe, then no conversion is applied, and the original dataframe is returned unchanged. Otherwise the constructed date is placed in that column, and the columns which were used to create the date are dropped. Args: df (pandas.DataFrame): dataframe to convert date_col (str): the name of the column you want in the output. year_col (str): the name of the year column in the original table. month_col (str): the name of the month column in the original table. day_col: the name of the day column in the original table. month_value (int): generated month if no month exists. day_value (int): generated day if no month exists. Returns: pandas.DataFrame: A DataFrame in which the year, month, day columns values have been converted into datetime objects. Todo: Update docstring. """ df = df.copy() if date_col in df.columns: return df year = df[year_col] if month_col not in df.columns: month = month_value else: month = df[month_col] if day_col not in df.columns: day = day_value else: day = df[day_col] df[date_col] = pd.to_datetime({"year": year, "month": month, "day": day}) cols_to_drop = [x for x in [day_col, year_col, month_col] if x in df.columns] df.drop(cols_to_drop, axis="columns", inplace=True) return df def fix_eia_na(df): """Replace common ill-posed EIA NA spreadsheet values with np.nan. Currently replaces empty string, single decimal points with no numbers, and any single whitespace character with np.nan. Args: df (pandas.DataFrame): The DataFrame to clean. Returns: pandas.DataFrame: The cleaned DataFrame. """ return df.replace( to_replace=[ r"^\.$", # Nothing but a decimal point r"^\s*$", # The empty string and entirely whitespace strings ], value=np.nan, regex=True, ) def simplify_columns(df): """Simplify column labels for use as snake_case database fields. All columns will be re-labeled by: * Replacing all non-alphanumeric characters with spaces. * Forcing all letters to be lower case. * Compacting internal whitespace to a single " ". * Stripping leading and trailing whitespace. * Replacing all remaining whitespace with underscores. Args: df (pandas.DataFrame): The DataFrame to clean. Returns: pandas.DataFrame: The cleaned DataFrame. Todo: Update docstring. """ df.columns = ( df.columns.str.replace(r"[^0-9a-zA-Z]+", " ", regex=True) .str.strip() .str.lower() .str.replace(r"\s+", " ", regex=True) .str.replace(" ", "_") ) return df def drop_tables(engine, clobber=False): """Drops all tables from a SQLite database. Creates an sa.schema.MetaData object reflecting the structure of the database that the passed in ``engine`` refers to, and uses that schema to drop all existing tables. Todo: Treat DB connection as a context manager (with/as). Args: engine (sa.engine.Engine): An SQL Alchemy SQLite database Engine pointing at an exising SQLite database to be deleted. Returns: None """ md = sa.MetaData() md.reflect(engine) insp = sa.inspect(engine) if len(insp.get_table_names()) > 0 and not clobber: raise AssertionError( f"You are attempting to drop your database without setting clobber to {clobber}" ) md.drop_all(engine) conn = engine.connect() conn.exec_driver_sql("VACUUM") conn.close() def merge_dicts(list_of_dicts): """Merge multipe dictionaries together. Given any number of dicts, shallow copy and merge into a new dict, precedence goes to key value pairs in latter dicts. Args: dict_args (list): a list of dictionaries. Returns: dict """ merge_dict = {} for dictionary in list_of_dicts: merge_dict.update(dictionary) return merge_dict def convert_cols_dtypes( df: pd.DataFrame, data_source: Optional[str] = None, name: Optional[str] = None ) -> pd.DataFrame: """Convert a PUDL dataframe's columns to the correct data type. Boolean type conversions created a special problem, because null values in boolean columns get converted to True (which is bonkers!)... we generally want to preserve the null values and definitely don't want them to be True, so we are keeping those columns as objects and preforming a simple mask for the boolean columns. The other exception in here is with the `utility_id_eia` column. It is often an object column of strings. All of the strings are numbers, so it should be possible to convert to :func:`pandas.Int32Dtype` directly, but it is requiring us to convert to int first. There will probably be other columns that have this problem... and hopefully pandas just enables this direct conversion. Args: df: dataframe with columns that appear in the PUDL tables. data_source: the name of the datasource (eia, ferc1, etc.) name: name of the table (for logging only!) Returns: Input dataframe, but with column types as specified by :py:const:`pudl.metadata.fields.FIELD_METADATA` """ # get me all of the columns for the table in the constants dtype dict dtypes = { col: dtype for col, dtype in get_pudl_dtypes(group=data_source).items() if col in df.columns } # grab only the boolean columns (we only need their names) bool_cols = [col for col in dtypes if dtypes[col] == "boolean"] # grab all of the non boolean columns non_bool_cols = {col: dtypes[col] for col in dtypes if col not in bool_cols} # Grab only the string columns... string_cols = [col for col in dtypes if dtypes[col] == "string"] for col in bool_cols: # Bc the og bool values were sometimes coming across as actual bools or # strings, for some reason we need to map both types (I'm not sure # why!). We use na_action to preserve the og NaN's. I've also added in # the string version of a null value bc I am sure it will exist. df[col] = df[col].map( { "False": False, "True": True, False: False, True: True, "nan": pd.NA, } ) if name: logger.debug(f"Converting the dtypes of: {name}") # unfortunately, the pd.Int32Dtype() doesn't allow a conversion from object # columns to this nullable int type column. `utility_id_eia` shows up as a # column of strings (!) of numbers so it is an object column, and therefor # needs to be converted beforehand. if "utility_id_eia" in df.columns: # we want to be able to use this dtype cleaning at many stages, and # sometimes this column has been converted to a float and therefor # we need to skip this conversion if df.utility_id_eia.dtypes is np.dtype("object"): df = df.astype({"utility_id_eia": "float"}) df = ( df.astype(non_bool_cols) .astype({col: "boolean" for col in bool_cols}) .replace(to_replace="nan", value={col: pd.NA for col in string_cols}) .replace(to_replace="<NA>", value={col: pd.NA for col in string_cols}) ) # Zip codes are highly correlated with datatype. If they datatype gets # converted at any point it may mess up the accuracy of the data. For # example: 08401.0 or 8401 are both incorrect versions of 08401 that a # simple datatype conversion cannot fix. For this reason, we use the # zero_pad_numeric_string function. if any("zip_code" for col in df.columns): zip_cols = [col for col in df.columns if "zip_code" in col] for col in zip_cols: if "4" in col: df.loc[:, col] = zero_pad_numeric_string(df[col], n_digits=4) else: df.loc[:, col] = zero_pad_numeric_string(df[col], n_digits=5) return df def generate_rolling_avg(df, group_cols, data_col, window, **kwargs): """Generate a rolling average. For a given dataframe with a ``report_date`` column, generate a monthly rolling average and use this rolling average to impute missing values. Args: df (pandas.DataFrame): Original dataframe. Must have group_cols column, a data_col column and a ``report_date`` column. group_cols (iterable): a list of columns to groupby. data_col (str): the name of the data column. window (int): window from :func:`pandas.Series.rolling`. kwargs : Additional arguments to pass to :func:`pandas.Series.rolling`. Returns: pandas.DataFrame """ df = df.astype({"report_date": "datetime64[ns]"}) # create a full date range for this df date_range = pd.DataFrame( pd.date_range( start=min(df["report_date"]), end=max(df["report_date"]), freq="MS", name="report_date", ) ).assign( tmp=1 ) # assiging a temp column to merge on groups = ( df[group_cols + ["report_date"]] .drop_duplicates() .assign(tmp=1) # assiging a temp column to merge on ) # merge the date range and the groups together # to get the backbone/complete date range/groups bones = ( date_range.merge(groups) .drop("tmp", axis=1) # drop the temp column .merge(df, on=group_cols + ["report_date"]) .set_index(group_cols + ["report_date"]) .groupby(by=group_cols + ["report_date"]) .mean() ) # with the aggregated data, get a rolling average roll = bones.rolling(window=window, center=True, **kwargs).agg({data_col: "mean"}) # return the merged return bones.merge( roll, on=group_cols + ["report_date"], suffixes=("", "_rolling") ).reset_index() def fillna_w_rolling_avg(df_og, group_cols, data_col, window=12, **kwargs): """Filling NaNs with a rolling average. Imputes null values from a dataframe on a rolling monthly average. To note, this was designed to work with the PudlTabl object's tables. Args: df_og (pandas.DataFrame): Original dataframe. Must have group_cols column, a data_col column and a 'report_date' column. group_cols (iterable): a list of columns to groupby. data_col (str): the name of the data column. window (int): window from pandas.Series.rolling kwargs : Additional arguments to pass to :class:`pandas.Series.rolling`. Returns: pandas.DataFrame: dataframe with nulls filled in. """ df_og = df_og.astype({"report_date": "datetime64[ns]"}) df_roll = generate_rolling_avg(df_og, group_cols, data_col, window, **kwargs) df_roll[data_col] = df_roll[data_col].fillna(df_roll[f"{data_col}_rolling"]) df_new = df_og.merge( df_roll, how="left", on=group_cols + ["report_date"], suffixes=("", "_rollfilled"), ) df_new[data_col] = df_new[data_col].fillna(df_new[f"{data_col}_rollfilled"]) return df_new.drop(columns=[f"{data_col}_rollfilled", f"{data_col}_rolling"]) def count_records(df, cols, new_count_col_name): """Count the number of unique records in group in a dataframe. Args: df (panda.DataFrame) : dataframe you would like to groupby and count. cols (iterable) : list of columns to group and count by. new_count_col_name (string) : the name that will be assigned to the column that will contain the count. Returns: pandas.DataFrame: dataframe containing only ``cols`` and ``new_count_col_name``. """ return ( df.assign(count_me=1) .groupby(cols, observed=True) .count_me.count() .reset_index() .rename(columns={"count_me": new_count_col_name}) ) def cleanstrings_snake(df, cols): """Clean the strings in a columns in a dataframe with snake case. Args: df (panda.DataFrame) : original dataframe. cols (list): list of columns in `df` to apply snake case to. """ for col in cols: df.loc[:, col] = ( df[col] .astype(str) .str.strip() .str.lower() .str.replace(r"\s+", "_", regex=True) ) return df def zero_pad_numeric_string( col: pd.Series, n_digits: int, ) -> pd.Series: """Clean up fixed-width leading zero padded numeric (e.g. ZIP, FIPS) codes. Often values like ZIP and FIPS codes are stored as integers, or get converted to floating point numbers because there are NA values in the column. Sometimes other non-digit strings are included like Canadian postal codes mixed in with ZIP codes, or IMP (imported) instead of a FIPS county code. This function attempts to manage these irregularities and produce either fixed-width leading zero padded strings of digits having a specified length (n_digits) or NA. * Convert the Series to a nullable string. * Remove any decimal point and all digits following it. * Remove any non-digit characters. * Replace any empty strings with NA. * Replace any strings longer than n_digits with NA. * Pad remaining digit-only strings to n_digits length. * Replace (invalid) all-zero codes with NA. Args: col: The Series to clean. May be numeric, string, object, etc. n_digits: the desired length of the output strings. Returns: A Series of nullable strings, containing only all-numeric strings having length n_digits, padded with leading zeroes if necessary. """ out_col = ( col.astype("string") # Remove decimal points and any digits following them. # This turns floating point strings into integer strings .replace(r"[\.]+\d*", "", regex=True) # Remove any whitespace .replace(r"\s+", "", regex=True) # Replace anything that's not entirely digits with NA .replace(r"[^\d]+", pd.NA, regex=True) # Set any string longer than n_digits to NA .replace(f"[\\d]{{{n_digits+1},}}", pd.NA, regex=True) # Pad the numeric string with leading zeroes to n_digits length .str.zfill(n_digits) # All-zero ZIP & FIPS codes are invalid. # Also catches empty strings that were zero padded. .replace({n_digits * "0": pd.NA}) ) if not out_col.str.match(f"^[\\d]{{{n_digits}}}$").all(): raise ValueError( f"Failed to generate zero-padded numeric strings of length {n_digits}." ) return out_col def iterate_multivalue_dict(**kwargs): """Make dicts from dict with main dict key and one value of main dict.""" single_valued = { k: v for k, v in kwargs.items() if not (isinstance(v, list) or isinstance(v, tuple)) } # Transform multi-valued {k: vlist} into {k1: [{k1: v1}, {k1: v2}, ...], k2: [...], ...} multi_valued = { k: [{k: v} for v in vlist] for k, vlist in kwargs.items() if (isinstance(vlist, list) or isinstance(vlist, tuple)) } for value_assignments in itertools.product(*multi_valued.values()): result = dict(single_valued) for k_v in value_assignments: result.update(k_v) yield result def get_working_eia_dates(): """Get all working EIA dates as a DatetimeIndex.""" dates = pd.DatetimeIndex([]) for data_source in DataSource.from_field_namespace("eia"): working_partitions = data_source.working_partitions if "years" in working_partitions: dates = dates.append( pd.to_datetime(working_partitions["years"], format="%Y") ) if "year_month" in working_partitions: dates = dates.append( pd.DatetimeIndex([pd.to_datetime(working_partitions["year_month"])]) ) return dates def dedupe_on_category(dedup_df, base_cols, category_name, sorter): """Deduplicate a df using a sorted category to retain prefered values. Use a sorted category column to retain your prefered values when a dataframe is deduplicated. Args: dedup_df (pandas.DataFrame): the dataframe with the record base_cols (list) : list of columns to use when dropping duplicates category_name (string) : name of categorical column sorter (list): sorted list of category options """ dedup_df.loc[:, category_name] = dedup_df.loc[:, category_name].astype( pd.CategoricalDtype(categories=sorter, ordered=True) ) return dedup_df.drop_duplicates(subset=base_cols, keep="first") def calc_capacity_factor(df, freq, min_cap_fact=None, max_cap_fact=None): """Calculate capacity factor. Capacity factor is calcuated from the capcity, the net generation over a time period and the hours in that same time period. The dates from that dataframe are pulled out to determine the hours in each period based on the frequency. The number of hours is used in calculating the capacity factor. Then records with capacity factors outside the range specified by `min_cap_fact` and `max_cap_fact` are dropped. Args: df (pandas.DataFrame): table with components of capacity factor ( `report_date`, `net_generation_mwh` and `capacity_mw`) min_cap_fact (float): Lower bound, below which values are set to NaN. If None, don't use a lower bound. Default is None. max_cap_fact (float): Upper bound, below which values are set to NaN. If None, don't use an upper bound. Default is None. freq (str): String describing time frequency at which to aggregate the reported data, such as 'MS' (month start) or 'AS' (annual start). Returns: pandas.DataFrame: modified version of input `df` with one additional column (`capacity_factor`). """ # get a unique set of dates to generate the number of hours dates = df["report_date"].drop_duplicates() dates_to_hours = pd.DataFrame( data={ "report_date": dates, "hours": dates.apply( lambda d: (
pd.date_range(d, periods=2, freq=freq)
pandas.date_range
#!/home/centos/anaconda3/bin/python3.6 #-*- coding: utf-8 -*- import os os.chdir('/home/ec2-user/utils/inven_data_real/') os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' import warnings warnings.filterwarnings("ignore", category=DeprecationWarning) import time from datetime import datetime,timedelta from pandas import read_csv import pandas as pd import numpy as np import matplotlib.pyplot as plt from sklearn import preprocessing # model from keras.models import Sequential from keras.layers import LSTM, Dense from keras.callbacks import EarlyStopping from keras.layers import Dropout, Activation from keras.models import Sequential from keras.models import save_model, load_model ## Evaluate Model from math import sqrt from numpy import concatenate from sklearn.metrics import mean_squared_error # Time Measure start_time = time.time() # argument import argparse parser = argparse.ArgumentParser() parser.add_argument('--index',dest='index',type=str,help="what is the parameters?") args = parser.parse_args() params = args.index #program_id = params import sys sys.path.append('/home/centos/anaconda3/lib/python3.6/site-packages') sys.path.append('/home/centos/anaconda3/lib/python3.6/site-packages/pandas') sys.path.append('/home/centos/anaconda3/lib/python3.6/site-packages/numpy') # function def mean_absolute_percentage_error(y_true, y_pred): return np.mean(np.abs((y_true - y_pred) / y_true)) * 100 def series_to_supervised(data, n_in=1, n_out=1, dropnan=True): n_vars = 1 if type(data) is list else data.shape[1] df = pd.DataFrame(data, index=dataset.index) cols, names = list(), list() # input sequence (t-n, ... t-1) for i in range(n_in, 0, -1): cols.append(df.shift(i)) names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)] # forecast sequence (t, t+1, ... t+n) for i in range(0, n_out): cols.append(df.shift(-i)) if i == 0: names += [('var%d(t)' % (j+1)) for j in range(n_vars)] else: names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)] # put it all together agg = pd.concat(cols, axis=1) agg.columns = names # drop rows with NaN values if dropnan: agg.dropna(inplace=True) return agg program_id = params # Import Parameter paramdata = pd.read_csv('DA_INVEN_PROG_TRG3.csv') paramselect = paramdata[paramdata['PROGRAM_ID'] == params] window_size = int(paramselect['WINDOW_SIZE']) model_neuron = int(paramselect['MODEL_NEURON']) model_ep = int(paramselect['MODEL_EP']) model_batchsize = int(paramselect['MODEL_BATCH']) model_dropout = float(paramselect['MODEL_DROPOUT']) #model_dropout = 0.4 model_activation =paramselect['MODEL_ACT'] model_loss = paramselect['MODEL_LOSS'] model_optimizer = paramselect['MODEL_OPT'] model_ym = paramselect['YM'] i = window_size j = 1488 # Start Time start_time = time.time() # Import Train data dataset = pd.read_csv(params+'.csv') dataset['DATE'] = pd.to_datetime(dataset['DATE_TIME'],format="%Y-%m-%d %H:%M") dataset.sort_values(by=['DATE'], axis=0, ascending=True,inplace=True) dataset= dataset.set_index('DATE') dataset = dataset[['INVEN']] dataset.index.name = 'date' dataset_inven = dataset[['INVEN']] # ensure all data is float values = dataset.values values = values.astype('float32') # normalize features scaler = preprocessing.MinMaxScaler(feature_range=(0, 1)) scaled = scaler.fit_transform(values) # frame as supervised learning raw_reframed = series_to_supervised(scaled, i+j, 1) # WINDOW var_xx = raw_reframed.loc[:,:'var1(t-'+str(j)+')'] # Label var_yy = raw_reframed['var1(t)'] # MERGE raw_reframed = pd.concat([var_xx,var_yy], axis=1) # print(raw_reframed.head()) reframed = raw_reframed # print(reframed.head(5)) # DateTime from datetime import datetime,timedelta current_time = datetime.utcnow() + timedelta(hours=9) train_date_str = (current_time-timedelta(hours=2)).strftime("%Y%m%d%H") #train_date_str = '2019052908' s_traindate = datetime.strptime(train_date_str, '%Y%m%d%H') # string to datetime train = reframed[s_traindate:s_traindate].values # split into input and outputs train_X, train_y = train[:, :-1], train[:, -1] # reshape input to be 3D [samples, timesteps, features] train_X = train_X.reshape((train_X.shape[0], 1, train_X.shape[1])) #print(train_X.shape, train_y.shape, test_X.shape, test_y.shape) # load_model #model = load_model model = load_model('/home/ec2-user/utils/MODEL_REAL/'+program_id+'.h5') model.fit(train_X, train_y, epochs=model_ep, batch_size=model_batchsize, verbose=2, shuffle=False) early_stop = EarlyStopping(monitor='loss', patience=1, verbose=1) #history = model.fit(train_X, train_y, epochs=model_ep, batch_size=model_batchsize, verbose=2, shuffle=False) model.save('/home/ec2-user/utils/MODEL_REAL/'+program_id+'.h5') #model.save('/home/ec2-user/utils/model_hist/'+program_id+'_'+train_date_str+'.h5') print("Finished Online Training") train_time = time.time()-start_time print("Start! Predict Inventory") predict_date = (datetime.utcnow() + timedelta(hours=9)).strftime("%Y%m%d%H") print("Making Testing Data") #test data from datetime import datetime,timedelta current_time = datetime.utcnow() + timedelta(hours=9) test_date_str = (current_time).strftime("%Y%m%d") test_date = test_date_str + '00' s_test_date = datetime.strptime(test_date, '%Y%m%d%H') test_tdate_str = (current_time+timedelta(hours=1488)).strftime("%Y%m%d") test_tdate = test_tdate_str + '23' t_test_date = datetime.strptime(test_tdate,'%Y%m%d%H') test = reframed.loc[s_test_date:t_test_date].values # split into input and outputs test_X, test_y = test[:, :-1], test[:, -1] # reshape input to be 3D [samples, timesteps, features] test_X = test_X.reshape((test_X.shape[0], 1, test_X.shape[1])) #print(train_X.shape, train_y.shape, test_X.shape, test_y.shape) model = load_model('/home/ec2-user/utils/MODEL_REAL/'+program_id+'.h5') # make a prediction yhat = model.predict(test_X) test_X = test_X.reshape((test_X.shape[0], test_X.shape[2])) # invert scaling for forecast inv_yhat = concatenate((yhat, test_X[:, 1:]), axis=1) inv_yhat = scaler.inverse_transform(inv_yhat) inv_yhat = inv_yhat[:,0] dataset_actual = dataset.loc[s_test_date:t_test_date]["INVEN"] Aarray_actual = np.array(dataset_actual) Aarray_predicted = np.array(inv_yhat) # calculate RMSE rmse = sqrt(mean_squared_error(Aarray_actual, Aarray_predicted)) print('Test RMSE: %.3f' % rmse) mape = mean_absolute_percentage_error(Aarray_actual,Aarray_predicted) print('Test MAPE: %.3f' % mape) MEAN = np.mean(Aarray_predicted) print('MEAN: %.3f' %MEAN) STD = np.std(Aarray_predicted) print('STD: %.3f' %STD) result = np.stack((Aarray_actual,Aarray_predicted), axis=1) result_pd =
pd.DataFrame(result, index=dataset_actual.index, columns=['actual', 'predict'])
pandas.DataFrame
import pandas as pd import numpy as np import math import pickle from scipy import stats import scipy.io from scipy.spatial.distance import pdist from scipy.linalg import cholesky from scipy.io import loadmat from sklearn.linear_model import LogisticRegression from sklearn.metrics import classification_report from sklearn.naive_bayes import GaussianNB from sklearn.svm import SVC from sklearn.metrics import classification_report,roc_auc_score,recall_score,precision_score from sklearn.model_selection import train_test_split from sklearn.preprocessing import MinMaxScaler from sklearn.ensemble import RandomForestClassifier from sklearn.decomposition import PCA from sklearn.experimental import enable_iterative_imputer from sklearn.impute import IterativeImputer import SMOTE import CFS import metrices_V2 as metrices import platform from os import listdir from os.path import isfile, join from glob import glob from pathlib import Path from os import path import sys import os import copy import traceback from pathlib import Path # Venn diag from matplotlib_venn import venn2, venn2_circles, venn2_unweighted from matplotlib_venn import venn3, venn3_circles from matplotlib import pyplot as plt import matplotlib.pyplot as plt import seaborn as sns import warnings warnings.filterwarnings("ignore") def load_both_data(project,metric): understand_path = 'data/understand_files_all/' + project + '_understand.csv' understand_df = pd.read_csv(understand_path) understand_df = understand_df.dropna(axis = 1,how='all') cols_list = understand_df.columns.values.tolist() for item in ['Kind', 'Name','commit_hash', 'Bugs']: if item in cols_list: cols_list.remove(item) cols_list.insert(0,item) understand_df = understand_df[cols_list] cols = understand_df.columns.tolist() understand_df = understand_df.drop_duplicates(cols[4:len(cols)]) understand_df['Name'] = understand_df.Name.str.rsplit('.',1).str[1] commit_guru_file_level_path = 'data/commit_guru_file/' + project + '.csv' commit_guru_file_level_df = pd.read_csv(commit_guru_file_level_path) commit_guru_file_level_df['commit_hash'] = commit_guru_file_level_df.commit_hash.str.strip('"') commit_guru_file_level_df = commit_guru_file_level_df[commit_guru_file_level_df['file_name'].str.contains('.java')] commit_guru_file_level_df['Name'] = commit_guru_file_level_df.file_name.str.rsplit('/',1).str[1].str.split('.').str[0].str.replace('/','.') commit_guru_file_level_df = commit_guru_file_level_df.drop('file_name',axis = 1) df = understand_df.merge(commit_guru_file_level_df,how='left',on=['commit_hash','Name']) cols = df.columns.tolist() cols.remove('Bugs') cols.append('Bugs') df = df[cols] file_names = df.Name for item in ['Kind', 'Name','commit_hash']: if item in cols: df = df.drop(labels = [item],axis=1) # df.dropna(inplace=True) df = df.drop_duplicates() df.reset_index(drop=True, inplace=True) y = df.Bugs X = df.drop('Bugs',axis = 1) cols = X.columns scaler = MinMaxScaler() X = scaler.fit_transform(X) X = pd.DataFrame(X,columns = cols) imp_mean = IterativeImputer(random_state=0) X = imp_mean.fit_transform(X) X = pd.DataFrame(X,columns = cols) if metric == 'process': X = X[['file_la', 'file_ld', 'file_lt', 'file_age', 'file_ddev', 'file_nuc', 'own', 'minor', 'file_ndev', 'file_ncomm', 'file_adev', 'file_nadev', 'file_avg_nddev', 'file_avg_nadev', 'file_avg_ncomm', 'file_ns', 'file_exp', 'file_sexp', 'file_rexp', 'file_nd', 'file_sctr']] elif metric == 'product': X = X.drop(['file_la', 'file_ld', 'file_lt', 'file_age', 'file_ddev', 'file_nuc', 'own', 'minor', 'file_ndev', 'file_ncomm', 'file_adev', 'file_nadev', 'file_avg_nddev', 'file_avg_nadev', 'file_avg_ncomm', 'file_ns', 'file_exp', 'file_sexp', 'file_rexp', 'file_nd', 'file_sctr'],axis = 1) else: X = X X['Name'] = file_names X['Bugs'] = y return X def load_data_release_level(project,metric): understand_path = 'data/understand_files_all/' + project + '_understand.csv' understand_df = pd.read_csv(understand_path) understand_df = understand_df.dropna(axis = 1,how='all') cols_list = understand_df.columns.values.tolist() for item in ['Kind', 'Name','commit_hash', 'Bugs']: if item in cols_list: cols_list.remove(item) cols_list.insert(0,item) understand_df = understand_df[cols_list] cols = understand_df.columns.tolist() understand_df = understand_df.drop_duplicates(cols[4:len(cols)]) understand_df['Name'] = understand_df.Name.str.rsplit('.',1).str[1] commit_guru_file_level_path = 'data/commit_guru_file/' + project + '.csv' commit_guru_file_level_df = pd.read_csv(commit_guru_file_level_path) commit_guru_file_level_df['commit_hash'] = commit_guru_file_level_df.commit_hash.str.strip('"') commit_guru_file_level_df = commit_guru_file_level_df[commit_guru_file_level_df['file_name'].str.contains('.java')] commit_guru_file_level_df['Name'] = commit_guru_file_level_df.file_name.str.rsplit('/',1).str[1].str.split('.').str[0].str.replace('/','.') commit_guru_file_level_df = commit_guru_file_level_df.drop('file_name',axis = 1) release_df = pd.read_pickle('data/release/' + project + '_release.pkl') release_df = release_df.sort_values('created_at',ascending=False) release_df = release_df.reset_index(drop=True) release_df['created_at'] = pd.to_datetime(release_df.created_at) release_df['created_at'] = release_df.created_at.dt.date commit_guru_path = 'data/commit_guru/' + project + '.csv' commit_guru_df = pd.read_csv(commit_guru_path) cols = understand_df.columns.tolist() commit_guru_df['created_at'] = pd.to_datetime(commit_guru_df.author_date_unix_timestamp,unit='s') commit_guru_df['created_at'] = commit_guru_df.created_at.dt.date commit_guru_df = commit_guru_df[['commit_hash','created_at']] df = understand_df.merge(commit_guru_file_level_df,how='left',on=['commit_hash','Name']) df = df.merge(commit_guru_df,how='left',on=['commit_hash']) cols = df.columns.tolist() cols.remove('Bugs') cols.append('Bugs') df = df[cols] file_names = df.Name commit_hash = df.commit_hash for item in ['Kind', 'Name','commit_hash']: if item in cols: df = df.drop(labels = [item],axis=1) df = df.drop_duplicates() df.reset_index(drop=True, inplace=True) created_at = df.created_at df = df.drop('created_at',axis = 1) y = df.Bugs X = df.drop('Bugs',axis = 1) cols = X.columns scaler = MinMaxScaler() X = scaler.fit_transform(X) X = pd.DataFrame(X,columns = cols) imp_mean = IterativeImputer(random_state=0) X = imp_mean.fit_transform(X) X = pd.DataFrame(X,columns = cols) X['created_at'] = created_at if metric == 'process': X = X[['file_la', 'file_ld', 'file_lt', 'file_age', 'file_ddev', 'file_nuc', 'own', 'minor', 'file_ndev', 'file_ncomm', 'file_adev', 'file_nadev', 'file_avg_nddev', 'file_avg_nadev', 'file_avg_ncomm', 'file_ns', 'file_exp', 'file_sexp', 'file_rexp', 'file_nd', 'file_sctr','created_at']] elif metric == 'product': X = X.drop(['file_la', 'file_ld', 'file_lt', 'file_age', 'file_ddev', 'file_nuc', 'own', 'minor', 'file_ndev', 'file_ncomm', 'file_adev', 'file_nadev', 'file_avg_nddev', 'file_avg_nadev', 'file_avg_ncomm', 'file_ns', 'file_exp', 'file_sexp', 'file_rexp', 'file_nd', 'file_sctr'],axis = 1) else: X = X df = X df['Name'] = file_names df['Bugs'] = y accepted_commit_dates = [] all_data =
pd.DataFrame()
pandas.DataFrame
import warnings from collections import defaultdict import h5py import numpy as np from scipy.interpolate import InterpolatedUnivariateSpline as iu_spline #from pipeline import PipelineException import matplotlib import pandas as pd matplotlib.use('agg') import matplotlib.pyplot as plt import numpy as np try: import cv2 except ImportError: print("Could not find cv2. You won't be able to use the pupil tracker.") ANALOG_PACKET_LEN = 2000 def read_video_hdf5(hdf_path): """ Reads hdf5 file for eye tracking :param hdf_path: path of the file. Needs a %d where multiple files differ. :return: dictionary with the data """ data = {} with h5py.File(hdf_path, 'r+', driver='family', memb_size=0) as fid: data['version'] = fid.attrs['Version'] if float(fid.attrs['Version']) == 2.: data['ball'] = np.asarray(fid['Wheel']).T wf = np.asarray(np.asarray(fid['Analog Signals'])).T data['framenum_ts'] = np.asarray(fid['framenum_ts']).squeeze() data['trialnum_ts'] = np.asarray(fid['trialnum_ts']).squeeze() data['eyecam_ts'] = np.asarray(fid['videotimestamps']).squeeze() data['syncPd'] = wf[:, 0] # flip photo diode data['scanImage'] = wf[:, 1] data['ts'] = wf[:, 2] data['analogPacketLen'] = float(fid.attrs['AS_samples_per_channel']) elif float(fid.attrs['Version']) == 1.: data['ball'] = np.asarray(fid['ball']).T wf = np.asarray(np.asarray(fid['waveform'])).T data['cam1ts'] = np.asarray(fid['behaviorvideotimestamp']).squeeze() data['cam2ts'] = np.asarray(fid['eyetrackingvideotimestamp']).squeeze() data['syncPd'] = wf[:, 2] # flip photo diode data['scanImage'] = wf[:, 9] data['ts'] = wf[:, 10] data['analogPacketLen'] = ANALOG_PACKET_LEN else: print('File version not known') return data def ts2sec(ts, packet_length=0, samplingrate=1e7): """ Convert 10MHz timestamps from Saumil's patching program (ts) to seconds (s) :param ts: timestamps :param packet_length: length of timestamped packets :returns: timestamps converted to seconds system time (in seconds) of t=0 bad camera indices from 2^31:2^32 in camera timestamps prior to 4/10/13 """ ts = ts.astype(float) # find bad indices in camera timestamps and replace with linear est bad_idx = ts == 2 ** 31 - 1 if bad_idx.sum() > 10: raise PipelineException('Bad camera ts...') x = np.where(~bad_idx)[0] x_bad = np.where(bad_idx)[0] f = iu_spline(x, ts[~bad_idx], k=1) ts[bad_idx] = f(x_bad) # remove wraparound wrap_idx = np.where(np.diff(ts) < 0)[0] while not len(wrap_idx) == 0: ts[wrap_idx[0] + 1:] += 2 ** 32 wrap_idx = np.where(np.diff(ts) < 0)[0] s = ts / samplingrate # Remove offset, and if not monotonically increasing (i.e. for packeted ts), interpolate if np.any(np.diff(s) <= 0): # Check to make sure it's packets diffs = np.where(np.diff(s) > 0)[0] assert packet_length == diffs[0] + 1 # Interpolate not_zero = np.hstack((0, diffs + 1)) f = iu_spline(not_zero, s[not_zero], k=1) s = f(np.arange(len(s))) return s, bad_idx class CVROIGrabber: start = None end = None roi = None def __init__(self, img): self.img = img self.exit = False def grab(self): print('Contrast (std)', np.std(self.img)) img = np.asarray(self.img / self.img.max(), dtype=float) cv2.namedWindow('real image') cv2.setMouseCallback('real image', self, 0) while not self.exit: cv2.imshow('real image', img) if (cv2.waitKey(0) & 0xFF) == ord('q'): cv2.waitKey(1) cv2.destroyAllWindows() break cv2.waitKey(2) def __call__(self, event, x, y, flags, params): img = self.img if event == cv2.EVENT_LBUTTONDOWN: print('Start Mouse Position: ' + str(x) + ', ' + str(y)) self.start = np.asarray([x, y]) elif event == cv2.EVENT_LBUTTONUP: self.end = np.asarray([x, y]) x = np.vstack((self.start, self.end)) tmp = np.hstack((x.min(axis=0), x.max(axis=0))) roi = np.asarray([[tmp[1], tmp[3]], [tmp[0], tmp[2]]], dtype=int) + 1 print(roi) crop = img[roi[0, 0]:roi[0, 1], roi[1, 0]:roi[1, 1]] crop = np.asarray(crop / crop.max(), dtype=float) self.roi = roi cv2.imshow('crop', crop) if (cv2.waitKey(0) & 0xFF) == ord('q'): cv2.destroyAllWindows() self.exit = True class ROIGrabber: """ Interactive matplotlib figure to grab an ROI from an image. Usage: rg = ROIGrabber(img) # select roi print(rg.roi) # get ROI """ def __init__(self, img): plt.switch_backend('GTK3Agg') self.img = img self.start = None self.current = None self.end = None self.pressed = False self.fig, self.ax = plt.subplots(facecolor='w') self.fig.canvas.mpl_connect('button_press_event', self.on_press) self.fig.canvas.mpl_connect('button_release_event', self.on_release) self.fig.canvas.mpl_connect('motion_notify_event', self.on_move) self.replot() plt.show(block=True) def draw_rect(self, fr, to, color='dodgerblue'): x = np.vstack((fr, to)) fr = x.min(axis=0) to = x.max(axis=0) self.ax.plot(fr[0] * np.ones(2), [fr[1], to[1]], color=color, lw=2) self.ax.plot(to[0] * np.ones(2), [fr[1], to[1]], color=color, lw=2) self.ax.plot([fr[0], to[0]], fr[1] * np.ones(2), color=color, lw=2) self.ax.plot([fr[0], to[0]], to[1] * np.ones(2), color=color, lw=2) self.ax.plot(fr[0], fr[1], 'ok', mfc='gold') self.ax.plot(to[0], to[1], 'ok', mfc='deeppink') def replot(self): self.ax.clear() self.ax.imshow(self.img, cmap=plt.cm.gray) if self.pressed: self.draw_rect(self.start, self.current, color='lime') elif self.start is not None and self.end is not None: self.draw_rect(self.start, self.current) self.ax.axis('tight') self.ax.set_aspect(1) self.ax.set_title('Close window when done', fontsize=16, fontweight='bold') plt.draw() @property def roi(self): x = np.vstack((self.start, self.end)) tmp = np.hstack((x.min(axis=0), x.max(axis=0))) return np.asarray([[tmp[1], tmp[3]], [tmp[0], tmp[2]]], dtype=int) + 1 def on_press(self, event): if event.xdata is not None and event.ydata is not None: self.pressed = True self.start = np.asarray([event.xdata, event.ydata]) def on_release(self, event): if event.xdata is not None and event.ydata is not None: self.end = np.asarray([event.xdata, event.ydata]) else: self.end = self.current self.pressed = False self.replot() def on_move(self, event): if event.xdata is not None and event.ydata is not None: self.current = np.asarray([event.xdata, event.ydata]) if self.pressed: self.replot() class PupilTracker: """ Parameters: perc_high : float # upper percentile for bright pixels perc_low : float # lower percentile for dark pixels perc_weight : float # threshold will be perc_weight*perc_low + (1- perc_weight)*perc_high relative_area_threshold : float # enclosing rotating rectangle has to have at least that amount of area ratio_threshold : float # ratio of major and minor radius cannot be larger than this error_threshold : float # threshold on the RMSE of the ellipse fit min_contour_len : int # minimal required contour length (must be at least 5) margin : float # relative margin the pupil center should not be in contrast_threshold : float # contrast below that threshold are considered dark speed_threshold : float # eye center can at most move that fraction of the roi between frames dr_threshold : float # maximally allow relative change in radius """ def __init__(self, param): self._params = param self._center = None self._radius = None self._last_detection = 1 @staticmethod def goodness_of_fit(contour, ellipse): center, size, angle = ellipse angle *= np.pi / 180 err = 0 for coord in contour.squeeze().astype(np.float): posx = (coord[0] - center[0]) * np.cos(-angle) - (coord[1] - center[1]) * np.sin(-angle) posy = (coord[0] - center[0]) * np.sin(-angle) + (coord[1] - center[1]) * np.cos(-angle) err += ((posx / size[0]) ** 2 + (posy / size[1]) ** 2 - 0.25) ** 2 return np.sqrt(err / len(contour)) @staticmethod def restrict_to_long_axis(contour, ellipse, corridor): center, size, angle = ellipse angle *= np.pi / 180 R = np.asarray([[np.cos(-angle), - np.sin(-angle)], [np.sin(-angle), np.cos(-angle)]]) contour = np.dot(contour.squeeze() - center, R.T) contour = contour[np.abs(contour[:, 0]) < corridor * ellipse[1][1] / 2] return (np.dot(contour, R) + center).astype(np.int32) def get_pupil_from_contours(self, contours, small_gray, show_matching=5): ratio_thres = self._params['ratio_threshold'] area_threshold = self._params['relative_area_threshold'] error_threshold = self._params['error_threshold'] min_contour = self._params['min_contour_len'] margin = self._params['margin'] speed_thres = self._params['speed_threshold'] dr_thres = self._params['dr_threshold'] err = np.inf best_ellipse = None best_contour = None results, cond = defaultdict(list), defaultdict(list) for j, cnt in enumerate(contours): if len(contours[j]) < min_contour: # otherwise fitEllipse won't work continue ellipse = cv2.fitEllipse(contours[j]) ((x, y), axes, angle) = ellipse if min(axes) == 0: # otherwise ratio won't work continue ratio = max(axes) / min(axes) area = np.prod(ellipse[1]) / np.prod(small_gray.shape) curr_err = self.goodness_of_fit(cnt, ellipse) results['ratio'].append(ratio) results['area'].append(area) results['rmse'].append(curr_err) results['x coord'].append(x / small_gray.shape[1]) results['y coord'].append(y / small_gray.shape[0]) center = np.array([x / small_gray.shape[1], y / small_gray.shape[0]]) r = max(axes) dr = 0 if self._radius is None else np.abs(r - self._radius) / self._radius dx = 0 if self._center is None else np.sqrt(np.sum((center - self._center) ** 2)) results['dx'].append(dx) results['dr/r'].append(dr) matching_conditions = 1 * (ratio <= ratio_thres) + 1 * (area >= area_threshold) \ + 1 * (curr_err < error_threshold) \ + 1 * (margin < center[0] < 1 - margin) \ + 1 * (margin < center[1] < 1 - margin) \ + 1 * (dx < speed_thres * self._last_detection) \ + 1 * (dr < dr_thres * self._last_detection) cond['ratio'].append(ratio <= ratio_thres) cond['area'].append(area >= area_threshold) cond['rmse'].append(curr_err < error_threshold) cond['x coord'].append(margin < center[0] < 1 - margin) cond['y coord'].append(margin < center[1] < 1 - margin) cond['dx'].append(dx < speed_thres * self._last_detection) cond['dr/r'].append(dr < dr_thres * self._last_detection) results['conditions'] = matching_conditions cond['conditions'].append(True) if curr_err < err and matching_conditions == 7: best_ellipse = ellipse best_contour = cnt err = curr_err cv2.ellipse(small_gray, ellipse, (0, 0, 255), 2) elif matching_conditions >= show_matching: cv2.ellipse(small_gray, ellipse, (255, 0, 0), 2) if best_ellipse is None: df = pd.DataFrame(results) df2 =
pd.DataFrame(cond)
pandas.DataFrame
# coding: utf-8 # # Explore simulated relationship (part 2) # # This notebook is using simulated data generated from [main_Pa_sim_enhance_AtoB](1_main_Pa_sim_enhance_AtoB.ipynb). This notebook input raw Pseudomonas gene expression data from the Pseudomonas compendium referenced in [ADAGE](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5069748/) paper and added a strong nonlinear signal. This signal assigned a set of genes to group A and a set of genes to group B. If the expression of genes in group A exceeded some threshold then the genes in group B were upregulated. # # This notebook is extending from the exploration performed in [explore_relationship_AandB_pt1](explore_relationship_AandB_pt1.ipynb). In this notebook we determined that the modeled/predicted gene expression data between A and B (i.e. after applying a linear transformation in the latent space and decoding) is a mostly linear relationship. We assume that this means that the *decoder* is learning this linear relationship. So now we want to determine what the *encoder* is learning. # In[1]: get_ipython().run_line_magic('load_ext', 'autoreload') get_ipython().run_line_magic('autoreload', '2') import os import pandas as pd import numpy as np import random import glob import pickle import seaborn as sns from keras.models import model_from_json, load_model from functions import utils import matplotlib.pyplot as plt from matplotlib_venn import venn2 from numpy.random import seed randomState = 123 seed(randomState) # In[2]: # Run notebook to generate simulated data #%run ./main_Pa_sim_enhance_AtoB.ipynb # In[3]: # Load base_dir = os.path.dirname(os.getcwd()) analysis_name = 'sim_balancedAB_100_2latent' sim_data_file = os.path.join( base_dir, "data", analysis_name, "train_model_input.txt.xz" ) A_file = os.path.join( base_dir, "data", analysis_name, "geneSetA.txt" ) B_file = os.path.join( base_dir, "data", analysis_name, "geneSetB.txt" ) offset_vae_file = os.path.join( os.path.dirname(os.getcwd()), "encoded", analysis_name, "offset_latent_space_vae.txt" ) weight_file = os.path.join( os.path.dirname(os.getcwd()), "data", analysis_name, "VAE_weight_matrix.txt" ) model_encoder_file = glob.glob(os.path.join( base_dir, "models", analysis_name, "*_encoder_model.h5"))[0] weights_encoder_file = glob.glob( os.path.join( base_dir, "models", analysis_name, "*_encoder_weights.h5" ) )[0] model_decoder_file = glob.glob( os.path.join( base_dir, "models", analysis_name, "*_decoder_model.h5" ) )[0] weights_decoder_file = glob.glob( os.path.join( base_dir, "models", analysis_name, "*_decoder_weights.h5" ) )[0] # In[4]: # Output image files positive_trend_file = os.path.join( base_dir, "viz", analysis_name, "input_A_B.png" ) model_trend_file = os.path.join( base_dir, "viz", analysis_name, "model_A_transformB.png" ) # In[5]: # Read data sim_data = pd.read_table(sim_data_file, index_col=0, header=0, compression='xz') geneSetA = pd.read_table(A_file, header=0, index_col=0) geneSetB = pd.read_table(B_file, header=0, index_col=0) print(sim_data.shape) sim_data.head() # In[6]: # Select samples that have expression of gene A around the threshold # Since threshold is 0.5 then select samples with expression in range(0.4, 0.6) # Since our simulation set all genes in set A to be the same value for a give sample # we can consider a single gene in set A to query by rep_gene_A = geneSetA.iloc[0][0] # Query for samples whose representative gene A expression is in range (0.4, 0.6) #test_samples = sim_data.query('0.4 < @rep_gene_A < 0.6') -- why didn't this work? test_samples = sim_data[(sim_data[rep_gene_A]>0.4) & (sim_data[rep_gene_A]<0.6)] test_samples_sorted = test_samples.sort_values(by=[rep_gene_A]) print(test_samples_sorted.shape) test_samples_sorted.head() # ## 1. Trend of gene B with respect to A (input) # # How is B changing with respect to A in our simulated dataset (before the data goes into the autoencoder)? # # Plot gene expression of A vs mean(gene B expression). This plot will serve as a reference against later plots that will show the relationship between A and B after transforming the data (i.e. after the data has been fed through the autoencoder) # In[7]: # Get the means of B genes # Convert dataframe with gene ids to list geneSetB_ls = geneSetB['gene id'].values.tolist() geneSetB_exp = test_samples[geneSetB_ls] # Get the mean for each sample geneSetB_mean = geneSetB_exp.mean(axis=1) geneSetB_mean.head() # In[8]: # Join original expression of A and mean(transformed expression of B) original_A_exp = test_samples[rep_gene_A] original_B_mean_exp = geneSetB_mean A_and_B_before_df = pd.merge(original_A_exp.to_frame('gene A untransformed'), original_B_mean_exp.to_frame('mean gene B untransformed'), left_index=True, right_index=True) A_and_B_before_df.head() # **Plot** # The plot below shows the signal that was added to the dataset. This signal assigned a set of genes to group A and a set of genes to group B. If the expression of genes in group A exceeded some threshold then the genes in group B were upregulated. # # So we see a step function relationship between the expression of genes in group A and the expression of genes in group B. With a threshold of 0.5 we can see that the expression of genes in B are upregulated. # In[9]: # Plot positive_signal = sns.regplot(x='gene A untransformed', y='mean gene B untransformed', data = A_and_B_before_df) fig = positive_signal.get_figure() fig.savefig(positive_trend_file, dpi=300) # ## 2. Trend of gene B with respect to A (decoder) # # How is B changing with respect to A after applying our latent space transformation? # # Here we are only changing samples **after** they have been encoded into the latent space and we apply our latent space transformation. Therefore, any trends that we observe we conclude that this relationship is what the decoder is learning. # In[10]: # Define function to apply latent space transformation and output reconstructed data def interpolate_in_vae_latent_space_AB(all_data, sample_data, model_encoder_file, model_decoder_file, weights_encoder_file, weights_decoder_file, encoded_dir, gene_id, percent_low, percent_high, out_dir): """ interpolate_in_vae_latent_space(all_data: dataframe, sample_data: dataframe, model_encoder_file: string, model_decoder_file: string, weights_encoder_file: string, weights_decoder_file: string, encoded_dir: string, gene_id: string, percent_low: integer, percent_high: integer, out_dir: string): input: all_data: Dataframe with gene expression data from all samples sample_data: Dataframe with gene expression data from subset of samples (around the treshold) model_encoder_file: file containing the learned vae encoder model model_decoder_file: file containing the learned vae decoder model weights_encoder_file: file containing the learned weights associated with the vae encoder model weights_decoder_file: file containing the learned weights associated with the vae decoder model encoded_dir: directory to use to output offset vector to gene_id: gene you are using as the "phenotype" to sort samples by This gene is referred to as "target_gene" in comments below percent_low: integer between 0 and 1 percent_high: integer between 0 and 1 out_dir: directory to output predicted gene expression to computation: 1. Sort samples based on the expression level of the target gene defined by the user 2. Sample_data are encoded into VAE latent space 3. We predict the expression profile of the OTHER genes at a given level of target gene expression by adding a scale factor of offset vector to the sample The scale factor depends on the distance along the target gene expression gradient the sample is. For example the range along the target gene expression is from 0 to 1. If the sample of interest has a target gene expression of 0.3 then our prediction for the gene expression of all other genes is equal to the gene expression corresponding to the target gene expression=0 + 0.3*offset latent vector 3. Prediction is decoded back into gene space 4. This computation is repeated for all samples output: 1. encoded predicted expression profile per sample 2. predicted expression profile per sample """ # Load arguments offset_file = os.path.join(encoded_dir, "offset_latent_space_vae.txt") # Output file predict_file = os.path.join(out_dir, "predicted_gene_exp.txt") predict_encoded_file = os.path.join(out_dir, "predicted_encoded_gene_exp.txt") # Read in data target_gene_data = all_data[gene_id] offset_encoded = pd.read_table(offset_file, header=0, index_col=0) # read in saved VAE models loaded_model = load_model(model_encoder_file) loaded_decoder_model = load_model(model_decoder_file) # load weights into models loaded_model.load_weights(weights_encoder_file) loaded_decoder_model.load_weights(weights_decoder_file) # Sort target gene data by expression (lowest --> highest) target_gene_sorted = target_gene_data.sort_values() lowest_file = os.path.join(encoded_dir, "lowest_encoded_vae.txt") low_exp_encoded = pd.read_table(lowest_file, header=0, index_col=0) # Average gene expression across samples in each extreme group lowest_mean_encoded = low_exp_encoded.mean(axis=0) # Format and rename as "baseline" baseline_encoded = pd.DataFrame( lowest_mean_encoded, index=offset_encoded.columns).T # Initialize dataframe for predicted expression of sampled data predicted_sample_data = pd.DataFrame(columns=sample_data.columns) predicted_encoded_sample_data = pd.DataFrame() sample_ids = sample_data.index for sample_id in sample_ids: intermediate_target_gene_exp = target_gene_sorted[sample_id] print('gene A exp is {}'.format(intermediate_target_gene_exp)) alpha = get_scale_factor( target_gene_sorted, intermediate_target_gene_exp, percent_low, percent_high) print('scale factor is {}'.format(alpha)) predict = baseline_encoded + alpha * offset_encoded predict_encoded_df = pd.DataFrame(predict) predicted_encoded_sample_data = ( predicted_encoded_sample_data .append(predict_encoded_df, ignore_index=True) ) # Decode prediction predict_decoded = loaded_decoder_model.predict_on_batch(predict) predict_df = pd.DataFrame( predict_decoded, columns=sample_data.columns) predicted_sample_data = ( predicted_sample_data .append(predict_df, ignore_index=True) ) predicted_sample_data.set_index(sample_data.index, inplace=True) predicted_encoded_sample_data.set_index(sample_data.index, inplace=True) # Output estimated gene experession values predicted_sample_data.to_csv(predict_file, sep='\t') predicted_encoded_sample_data.to_csv(predict_encoded_file, sep='\t') def get_scale_factor(target_gene_sorted, expression_profile, percent_low, percent_high): """ get_scale_factor(target_gene_sorted: dataframe, expression_profile: dataframe, percent_low: integer, percent_high: integer,): input: target_gene_sorted: dataframe of sorted target gene expression expression_profile: dataframe of gene expression for selected sample percent_low: integer between 0 and 1 percent_high: integer between 0 and 1 computation: Determine how much to scale offset based on distance along the target gene expression gradient Output: scale factor = intermediate gene expression/ (average high target gene expression - avgerage low target gene expression) """ # Collect the extreme gene expressions # Get sample IDs with the lowest 5% of reference gene expression threshold_low = np.percentile(target_gene_sorted, percent_low) lowest = target_gene_sorted[target_gene_sorted <= threshold_low] # Get sample IDs with the highest 5% of reference gene expression threshold_high = np.percentile(target_gene_sorted, percent_high) highest = target_gene_sorted[target_gene_sorted >= threshold_high] # Average gene expression across samples in each extreme group lowest_mean = (lowest.values).mean() highest_mean = (highest.values).mean() # Different in extremes denom = highest_mean - lowest_mean # scale_factor is the proportion along the gene expression gradient scale_factor = expression_profile / denom return scale_factor # In[11]: # Apply function out_dir = os.path.join(base_dir, "output", analysis_name) encoded_dir = os.path.join(base_dir, "encoded", analysis_name) percent_low = 5 percent_high = 95 interpolate_in_vae_latent_space_AB(sim_data, test_samples_sorted, model_encoder_file, model_decoder_file, weights_encoder_file, weights_decoder_file, encoded_dir, rep_gene_A, percent_low, percent_high, out_dir) # **Plot** # Plot transformed gene expression A vs mean transformed expression of genes in set B # # Q: What is the relationship between genes in set A and B? As the expression of A varies how does the expression of B vary? # In[12]: # Read dataframe with gene expression transformed predict_file = os.path.join(base_dir, "output", analysis_name, "predicted_gene_exp.txt") predict_gene_exp = pd.read_table(predict_file, header=0, index_col=0) print(predict_gene_exp.shape) predict_gene_exp.head() # In[13]: # Get the means of B genes # Convert dataframe with gene ids to list geneSetB_ls = geneSetB['gene id'].values.tolist() geneSetB_exp = predict_gene_exp[geneSetB_ls] # Get the mean for each sample geneSetB_mean = geneSetB_exp.mean(axis=1) geneSetB_mean.head() # In[14]: # Join original expression of transformed A and mean(transformed expression of B) predict_A_exp = predict_gene_exp[rep_gene_A] predict_B_mean_exp = geneSetB_mean A_and_B_predict_df = pd.merge(original_A_exp.to_frame('gene A untransformed'), predict_B_mean_exp.to_frame('mean gene B transformed'), left_index=True, right_index=True) A_and_B_predict_df.head() # In[15]: # Plot sns.regplot(x='gene A untransformed', y='mean gene B transformed', data = A_and_B_predict_df) # ## 3. Trend of gene B with respect to A (encoder) # # How is B changing with respect to A after shifting input expression and then applying our latent space transformation? # # Here we are only changing samples **before** they have been encoded into the latent space and then we apply our latent space transformation. If we compare these trends with those from #2 module, which show what the decoder is supposedly learning, then we can conclude what the encoder is learning. # # In order to test this we manually shift A genes from being below the activation threshold to being above it and see how the gene expression data is reconstructed # In[16]: # Artificially shift gene A expression # Get single sample test_sample = test_samples_sorted.index[0] print(test_sample) # Sample with original value of gene A A_exp_sample = test_samples_sorted.loc[test_sample] A_exp_sample_modified_df = pd.DataFrame() A_exp_sample_modified_df.append(A_exp_sample, ignore_index=True) # Convert dataframe with gene ids to list geneSetA_ls = geneSetA['gene id'].values.tolist() # Artificially shift genes in set A new_A_exp = np.linspace(0.41, 0.60, num=100) for i in new_A_exp: test_samples_sorted.loc[test_sample,geneSetA_ls] = i A_exp_sample = test_samples_sorted.loc[test_sample] A_exp_sample_modified_df = A_exp_sample_modified_df.append(A_exp_sample, ignore_index=True) A_exp_sample_modified_df.head() # In[17]: # Define function to apply latent space transformation to SHIFTED data and output reconstructed data def interpolate_in_vae_latent_space_shiftA(all_data, sample_data, model_encoder_file, model_decoder_file, weights_encoder_file, weights_decoder_file, encoded_dir, gene_id, percent_low, percent_high, out_dir): """ interpolate_in_vae_latent_space(all_data: dataframe, sample_data: dataframe, model_encoder_file: string, model_decoder_file: string, weights_encoder_file: string, weights_decoder_file: string, encoded_dir: string, gene_id: string, percent_low: integer, percent_high: integer, out_dir: string): input: all_data: Dataframe with gene expression data from all samples sample_data: Dataframe with gene expression data from subset of samples (around the treshold) model_encoder_file: file containing the learned vae encoder model model_decoder_file: file containing the learned vae decoder model weights_encoder_file: file containing the learned weights associated with the vae encoder model weights_decoder_file: file containing the learned weights associated with the vae decoder model encoded_dir: directory to use to output offset vector to gene_id: gene you are using as the "phenotype" to sort samples by This gene is referred to as "target_gene" in comments below percent_low: integer between 0 and 1 percent_high: integer between 0 and 1 out_dir: directory to output predicted gene expression to computation: 1. Sort samples based on the expression level of the target gene defined by the user 2. Sample_data are encoded into VAE latent space 3. We predict the expression profile of the OTHER genes at a given level of target gene expression by adding a scale factor of offset vector to the sample The scale factor depends on the distance along the target gene expression gradient the sample is. For example the range along the target gene expression is from 0 to 1. If the sample of interest has a target gene expression of 0.3 then our prediction for the gene expression of all other genes is equal to the gene expression corresponding to the target gene expression=0 + 0.3*offset latent vector 3. Prediction is decoded back into gene space 4. This computation is repeated for all samples output: 1. encoded predicted expression profile per sample 2. predicted expression profile per sample """ # Load arguments offset_file = os.path.join(encoded_dir, "offset_latent_space_vae.txt") # Output file predict_file = os.path.join(out_dir, "shifted_predicted_gene_exp.txt") predict_encoded_file = os.path.join(out_dir, "shifted_predicted_encoded_gene_exp.txt") # Read in data target_gene_data = all_data[gene_id] offset_encoded = pd.read_table(offset_file, header=0, index_col=0) # read in saved VAE models loaded_model = load_model(model_encoder_file) loaded_decoder_model = load_model(model_decoder_file) # load weights into models loaded_model.load_weights(weights_encoder_file) loaded_decoder_model.load_weights(weights_decoder_file) # Initialize dataframe for predicted expression of sampled data predicted_sample_data = pd.DataFrame(columns=sample_data.columns) predicted_encoded_sample_data = pd.DataFrame() sample_ids = sample_data.index for sample_id in sample_ids: sample_exp = sample_data.loc[sample_id].to_frame().T # Use trained model to encode expression data into SAME latent space predict = loaded_model.predict_on_batch(sample_exp) predict_encoded_df = pd.DataFrame(predict) predicted_encoded_sample_data = ( predicted_encoded_sample_data .append(predict_encoded_df, ignore_index=True) ) # Decode prediction predict_decoded = loaded_decoder_model.predict_on_batch(predict_encoded_df) predict_df = pd.DataFrame( predict_decoded, columns=sample_data.columns) predicted_sample_data = ( predicted_sample_data .append(predict_df, ignore_index=True) ) predicted_sample_data.set_index(sample_data.index, inplace=True) predicted_encoded_sample_data.set_index(sample_data.index, inplace=True) # Output estimated gene experession values predicted_sample_data.to_csv(predict_file, sep='\t') predicted_encoded_sample_data.to_csv(predict_encoded_file, sep='\t') # In[18]: # Define function to apply latent space transformation to SHIFTED data and output reconstructed data def interpolate_in_pca_latent_space_shiftA(all_data, sample_data, model_dir, encoded_dir, gene_id, percent_low, percent_high, out_dir): """ interpolate_in_pca_latent_space(data_dir: string, model_dir: string, encoded_dir: string, gene_id: string, out_dir: string, percent_low: integer, percent_high: integer): input: data_dir: directory containing the raw gene expression data and the offset vector model_dir: directory containing the learned vae models encoded_dir: directory to use to output offset vector to gene_id: gene you are using as the "phenotype" to sort samples by This gene is referred to as "target_gene" in comments below out_dir: directory to output predicted gene expression to percent_low: integer between 0 and 1 percent_high: integer between 0 and 1 computation: 1. Sort samples based on the expression level of the target gene defined by the user 2. Samples are encoded into PCA latent space 3. We predict the expression profile of the OTHER genes at a given level of target gene expression by adding a scale factor of offset vector to the sample The scale factor depends on the distance along the target gene expression gradient the sample is. For example the range along the target gene expression is from 0 to 1. If the sample of interest has a target gene expression of 0.3 then our prediction for the gene expression of all other genes is equal to the gene expression corresponding to the target gene expression=0 + 0.3*offset latent vector 3. Prediction is decoded back into gene space 4. This computation is repeated for all samples output: 1. predicted expression profile per sample (intermediate samples x 2 statistical scores --> correlation and pvalue) 2. target gene expression sorted by expression level for reference when plotting """ # Load arguments #offset_file = os.path.join(encoded_dir, "offset_latent_space_vae.txt") model_file = os.path.join(model_dir, "pca_model.pkl") # Output file predict_file = os.path.join(out_dir, "shifted_predicted_gene_exp.txt") predict_encoded_file = os.path.join(out_dir, "shifted_predicted_encoded_gene_exp.txt") # Read in data target_gene_data = all_data[gene_id] #offset_encoded = pd.read_table(offset_file, header=0, index_col=0) # load pca model infile = open(model_file, 'rb') pca = pickle.load(infile) infile.close() # Initialize dataframe for predicted expression of sampled data predicted_sample_data = pd.DataFrame(columns=sample_data.columns) predicted_encoded_sample_data =
pd.DataFrame()
pandas.DataFrame
""" algo for test input None output detail open_time, open_price, direction, expect_price, dump_price, dump_time None """ import json import pickle import datetime import time import os import numpy as np import pandas as pd import board_push from util.util import haunter LOG = haunter() cache_jqd = "./cache_jqd/" cache_ticker = "./cache_ticker/" cache_matrix = "./cache_matrix/" cache_runtime = "./cache_runtime/" EARLY = 4 SETUP = 7 INTER = 2 def end_nine(sub_df, ealier = 4, setup = 9, inter = 2): """ 0 1 2 3 4 - 12 return 1 => put down return -1 => wake up """ arr = np.array(sub_df["close"]) if len(arr) != ealier+setup: # 4+9 return None direction = None for index, item in enumerate(arr): if index < ealier: continue elif index == ealier: direction = np.sign(item-arr[index-ealier]) elif direction == np.sign(item-arr[index-ealier]): continue else: return None if direction == None: raise return direction def algo_DeMark_lite(sub_df, ealier = 4, setup = 7, inter = 2): """ DeMark Indicators are designed to anticipate turning points in the market. <NAME> created a strategy called a sequential that finds an overextended price move, one that is likely to change direction and takes a countertrend position. To get a buy signal, the following three steps are applied to daily data: 1) Setup. There must be a decline of at least nine or more consequtive closes that are lower than the corresponding closes four days ealier. If today’s close is equal to or greater than the close four days before, the setup must begin again. 2) Intersection. To assure prices are declinging in an orderly fashion rather than plunging, the high of any day on or after the eighth day of the set up must be greater than the low of any day three or more days earlier. 3) Countdown. Once setup and intersection have been satifiedm we count the number of days in which we close lower than the close two days ago (doesn’t need to be continuous). When the countdown reaches 13, we get a buy signal unless one of the following occurs: a. There is a close that exceeds the highest intraday high that occured during the setup stage. b. A sell setup occurs (nine consequtive closes above the corresponding closes four days earlier). c. Another buy setup occurs before the buy countdown is completed. Traders should expect that the development of the entire formation take no less than 21 days, but more typically 24-39 days. Luckily there are many systems avaliable which do the counts for us. Bloomberg is one such example. """ # lite version is only 1 & 2, not apply step 3 arr = np.array(sub_df["close"]) if len(arr) != ealier+setup+inter: # 4+9 return None direction = None for index, item in enumerate(arr): if index < ealier: continue elif index == ealier: direction = np.sign(item-arr[index-ealier]) elif direction == 0: return None elif direction == np.sign(item-arr[index-ealier]): continue else: return None ## check 8 & 9 if direction == -1: # up decling = sub_df["low"][sub_df["high"][-2]>sub_df["low"]].count() if decling < 3: decling = sub_df["low"][sub_df["high"][-1]>sub_df["low"]].count() if decling < 3: return None elif direction == 1: # down decling = sub_df["high"][sub_df["low"][-2]>sub_df["high"]].count() if decling < 3: decling = sub_df["high"][sub_df["low"][-1]>sub_df["high"]].count() if decling < 3: return None else: raise return direction def launch(): action = None # detail_dict # detail = { "ticker":None, # "open_price":None, # "open_time":None, # "direction":None, # "expect_price":None, # "dump_price":None, # "dump_time":None, # } # detail DataFrame detail_df = pd.DataFrame(columns=[ "ticker", "open_time", "open_price", "direction", "expect_price", "dump_price", "dump_time"]) # init ticker_list = ["000001.XSHG"] ticker = ticker_list[0] # baseline baseline = "000001.XSHG" with open(cache_runtime + baseline, 'rb') as f: baseline_df = pickle.load(f) baseline_now = baseline_df.index[-1] # load data with open(cache_runtime + ticker, 'rb') as f: df = pickle.load(f) # open # LOG.debug(int(df["close"][2]*100) % 10) # LOG.info(int(df["close"][2]*100) % 10) # LOG.warning(int(df["close"][2]*100) % 10) # Algo sub_df = df[-(EARLY+SETUP+INTER):] # action = end_nine(sub_df) action = algo_DeMark_lite(sub_df) if action == None: return None elif action == -1: # up detail_dict = {} detail_dict["ticker"] = ticker detail_dict["open_price"] = sub_df["close"][-3:].mean() #tmp detail_dict["open_time"] = baseline_now detail_dict["direction"] = True detail_dict["expect_price"] = sub_df["close"][-7:-1].mean() #tmp detail_dict["dump_price"] = sub_df["close"][-1]-(sub_df["close"][-2]-sub_df["close"][-1]) detail_dict["dump_time"] = baseline_now + datetime.timedelta(minutes=5) elif action == 1: detail_dict = {} detail_dict["ticker"] = ticker detail_dict["open_price"] = sub_df["close"][-3:].mean() #tmp detail_dict["open_time"] = baseline_now detail_dict["direction"] = False detail_dict["expect_price"] = sub_df["close"][-7:-1].mean() #tmp detail_dict["dump_price"] = sub_df["close"][-1]-(sub_df["close"][-2]-sub_df["close"][-1]) detail_dict["dump_time"] = baseline_now + datetime.timedelta(minutes=5) else: raise return None # miss more series, so here is the only one detail_ss =
pd.Series(detail_dict,name=detail_dict["ticker"])
pandas.Series
from typing import Optional, List, overload, Union from matplotlib.axes import Axes from mpl_format.axes.axis_utils import new_axes from networkx import DiGraph, draw_networkx_nodes, \ draw_networkx_edges, all_simple_paths, \ descendants_at_distance, draw_networkx_labels from pandas import DataFrame from probability.models.decision_tree.nodes import \ DecisionNode, ChanceNode, AmountNode from probability.models.utils import distribute_about_center class DecisionTree(object): """ A Probabilistic Decision Tree. There are 3 types of nodes: DecisionNodes, ChanceNodes and AmountNodes. * Each DecisionNode represents a Decision that needs to be made, consisting of any number of different choices. * Each ChanceNode represents a potential choice of a Decision, each with a given probability of success. * Each AmountNode represents either a Cost or a Reward if a choice is successful. """ def __init__(self): """ Create a new Probabilistic Decision Tree. """ self._graph = DiGraph() self._root_node: Optional[DecisionNode] = None self._solved: bool = False @property def graph(self) -> DiGraph: """ Return the wrapped networkx DiGraph object. """ return self._graph @property def max_depth(self) -> int: """ Return the maximum depth of any DecisionNode in the Tree, """ decision_nodes = self.decision_nodes() if len(decision_nodes): return max([node.depth for node in decision_nodes]) else: return 0 def _get_layout(self) -> dict: """ Generate a layout for the Tree. """ x_add = { DecisionNode: 0, ChanceNode: 1 / 3, AmountNode: 2 / 3 } y_add = { DecisionNode: 0, ChanceNode: 1 / 3, AmountNode: 2 / 3 } max_depth = self.max_depth nodes = {} for depth in range(1, max_depth + 1): nodes[(DecisionNode, depth)] = self.decision_nodes(depth) nodes[(ChanceNode, depth)] = self.chance_nodes(depth) nodes[(AmountNode, depth)] = self.amount_nodes(depth) max_width = max(len(value) for value in nodes.values()) layout = {} for node in self._graph.nodes(): node_type = type(node) node_list = nodes[(node_type, node.depth)] x = (node.depth + x_add[node_type]) / (max_depth * 3) y = distribute_about_center( index=node_list.index(node), size=len(node_list), max_loc=max_width - 1, max_size=max_width ) + y_add[node_type] layout[node] = [x, y] return layout def decision_nodes(self, depth: Optional[int] = None) -> List[DecisionNode]: """ Return a list of all DecisionNodes in the DecisionTree. """ nodes = [node for node in self._graph.nodes() if isinstance(node, DecisionNode)] if depth is not None: nodes = [node for node in nodes if node.depth == depth] return nodes def decision_node( self, name: str, depth: Optional[int] = None ) -> DecisionNode: decision_nodes = self.decision_nodes(depth=depth) return [node for node in decision_nodes if node.name == name][0] def chance_nodes(self, depth: Optional[int] = None) -> List[ChanceNode]: """ Return a list of all ChanceNodes in the DecisionTree. """ nodes = [node for node in self._graph.nodes() if isinstance(node, ChanceNode)] if depth is not None: nodes = [node for node in nodes if node.depth == depth] return nodes def chance_node( self, name: str, depth: Optional[int] = None ) -> ChanceNode: chance_nodes = self.chance_nodes(depth=depth) return [node for node in chance_nodes if node.name == name][0] def amount_nodes(self, depth: Optional[int] = None) -> List[AmountNode]: """ Return a list of all AmountNodes in the DecisionTree. """ nodes = [node for node in self._graph.nodes() if isinstance(node, AmountNode)] if depth is not None: nodes = [node for node in nodes if node.depth == depth] return nodes def amount_node( self, name: str, depth: Optional[int] = None ) -> AmountNode: amount_nodes = self.amount_nodes(depth=depth) return [node for node in amount_nodes if node.name == name][0] def node(self, name: str, depth: Optional[int] = None): """ Return the node with the given name. :param name: The name of the node. :param depth: Optional depth filter in case node names are only unique by depth. """ nodes = list([node for node in self._graph.nodes() if node.name == name]) if depth is not None: nodes = [node for node in nodes if node.depth == depth] if len(nodes) == 1: return nodes[0] else: if depth is None: raise ValueError(f'{len(nodes)} matching nodes named {name}') else: raise ValueError( f'{len(nodes)} matching nodes named {name} at depth {depth}' ) def node_amounts_dict(self) -> dict: """ Return a dict mapping Nodes to their amounts. """ return { node: node.str_amount for node in self._graph.nodes() } def node_names_dict(self) -> dict: """ Return a dict mapping Nodes to their names. """ return { node: node.name for node in self._graph.nodes() } def node_names(self) -> List[str]: """ Return a list of all the Node names in the Tree. """ return [node.name for node in self._graph.nodes()] @overload def parent(self, node: AmountNode) -> ChanceNode: pass @overload def parent(self, node: ChanceNode) -> DecisionNode: pass @overload def parent(self, node: DecisionNode) -> Optional[ChanceNode]: pass def parent(self, node): return list(self._graph.predecessors(node))[0] @overload def children(self, node: DecisionNode) -> List[ChanceNode]: pass @overload def children( self, node: ChanceNode ) -> List[Union[DecisionNode, AmountNode]]: pass def children(self, node): return list(descendants_at_distance(self._graph, node, 1)) def add_decision_node( self, decision_node: DecisionNode, parent: Optional[ChanceNode] = None ) -> DecisionNode: """ Add a new DecisionNode to the Tree. :param decision_node: The DecisionNode to add. :param parent: The parent ChanceNode that triggers the DecisionNode on failure. Leave as None if this is the first Decision. """ if parent is None and self._root_node is not None: raise ValueError('Must give parent if tree already has a root node') if decision_node.depth is None: raise ValueError('DecisionNode must have depth assigned.') if parent is not None and parent not in self._graph.nodes(): raise ValueError(f'ChanceNode {parent} is not in the Tree.') self._graph.add_node(decision_node) if parent is not None: self._graph.add_edge(parent, decision_node) else: self._root_node = decision_node self._solved = False return decision_node def add_decision(self, name: str, parent_name: Optional[str] = None): """ Add a new Decision to the Tree. :param name: The name of the Decision. :param parent_name: The parent ChanceNode that triggers the DecisionNode on failure. Leave as None if this is the first Decision. """ if name in self.node_names(): raise ValueError(f'{name} already exists in Tree') parent: Optional[ChanceNode] = ( self.chance_node(parent_name) if parent_name is not None else None ) decision_node = DecisionNode( name=name, depth=(1 if parent_name is None else parent.depth + 1) ) self.add_decision_node(decision_node=decision_node, parent=parent) def add_chance_node( self, chance_node: ChanceNode, parent: DecisionNode ) -> ChanceNode: """ Add a new ChanceNode to the Tree. The ChanceNode represents the probability of :param chance_node: The ChanceNode to add. :param parent: The DecisionNode that this ChanceNode belongs to. """ if chance_node.depth is None: raise ValueError('ChanceNode must have depth assigned.') if parent not in self._graph.nodes(): raise ValueError(f'DecisionNode {parent} is not in the Tree.') self._graph.add_node(chance_node) self._graph.add_edge(parent, chance_node) self._solved = False return chance_node def add_option( self, name: str, p_success: float, amount: float, parent_name: str, final: bool = False ): """ Add a new option to a Decision with associated ChanceNode, success and optional failure AmountNodes. :param name: The name of the Chance. :param p_success: The probability of the Chance succeeding. :param amount: The cost of choosing the option. :param parent_name: The parent DecisionNode that the option belongs to. :param final: Set to True to add a failure as well as a success AmountNode. """ node_names = self.node_names() if name in node_names: raise ValueError(f'{name} already exists in Tree') if parent_name not in node_names: raise ValueError( f'DecisionNode named {parent_name} is not in the Tree.' ) decision_node = self.decision_node(name=parent_name) chance_node = self.add_chance_node( chance_node=ChanceNode( name=name, p_success=p_success, amount=amount, depth=decision_node.depth ), parent=decision_node ) self.add_amount_node( amount_node=AmountNode( name=f'{name}.success', probability=p_success, depth=decision_node.depth ), parent=chance_node ) if final: self.add_amount_node( amount_node=AmountNode( name=f'{name}.failure', probability=1 - p_success, depth=decision_node.depth ), parent=chance_node ) def add_amount_node( self, amount_node: AmountNode, parent: ChanceNode ) -> AmountNode: """ Add a new AmountNode to the Tree. :param amount_node: The AmountNode to add. :param parent: The ChanceNode associated with this AmountNode, if successful. """ if amount_node.depth is None: raise ValueError('AmountNode must have depth assigned.') if parent not in self._graph.nodes(): raise ValueError(f'ChanceNode {parent} is not in the Tree.') self._graph.add_node(amount_node) self._graph.add_edge(parent, amount_node) self._solved = False return amount_node def solve(self, minimize: bool = True): """ Solve the Decision Tree. :param minimize: True to minimize amounts, i.e. amounts are costs, or False to maximize amounts, i.e. amounts are rewards. """ if minimize: opt_func = min else: opt_func = max # 1) at each end point of the tree write down the net total cost # incurred if that end point is reached for amount_node in self.amount_nodes(): path_to_node = list(all_simple_paths( self._graph, self._root_node, amount_node ))[0] # path from first decision node to amount node total_amount = 0 for node in path_to_node: if isinstance(node, ChanceNode): total_amount += node.amount amount_node: AmountNode = path_to_node[-1] amount_node.total_amount = total_amount # 2) work backwards computing the expected cost at all nodes and # choosing action at choice nodes where expected cost is lowest for depth in range(self.max_depth, 0, -1): for amount_node in self.amount_nodes(depth): # propagate expected payoff to parent chance node parent = self.parent(amount_node) parent.expected_amount += ( amount_node.probability * amount_node.total_amount ) for decision_node in self.decision_nodes(depth): # select minimum cost from child chance nodes children = self.children(decision_node) decision_node.expected_amount = opt_func([ child.expected_amount for child in children ]) if depth > 1: parent = self.parent(decision_node) parent.expected_amount += ( parent.p_failure * decision_node.expected_amount ) self._solved = True def amounts(self, require_success: bool = False) -> DataFrame: """ Return the amounts in the solved DecisionTree. :param require_success: Set to True to only calculate amounts where success is guaranteed. """ if not self._solved: raise PermissionError( "Can't calculate amounts for an unsolved tree." ) results = [] for amount_node in self.amount_nodes(): path_to_node = list(all_simple_paths( self._graph, self._root_node, amount_node ))[0] chance_nodes = [c for c in path_to_node if isinstance(c, ChanceNode)] if chance_nodes[-1].p_success != 1 and require_success: continue result = {} for c, node in enumerate(chance_nodes): result[f'choice_{c + 1}'] = str(node.name) result[f'amount_{c + 1}'] = node.amount result[f'expected_amount_{c + 1}'] = node.expected_amount results.append(result) return
DataFrame(results)
pandas.DataFrame
from __future__ import absolute_import from __future__ import division from __future__ import print_function import pandas from pandas.api.types import is_scalar from pandas.compat import to_str, string_types, numpy as numpy_compat, cPickle as pkl import pandas.core.common as com from pandas.core.dtypes.common import ( _get_dtype_from_object, is_list_like, is_numeric_dtype, is_datetime_or_timedelta_dtype, is_dtype_equal, is_object_dtype, is_integer_dtype, ) from pandas.core.index import _ensure_index_from_sequences from pandas.core.indexing import check_bool_indexer, convert_to_index_sliceable from pandas.util._validators import validate_bool_kwarg import itertools import functools import numpy as np import re import sys import warnings from modin.error_message import ErrorMessage from .utils import from_pandas, to_pandas, _inherit_docstrings from .iterator import PartitionIterator from .series import SeriesView @_inherit_docstrings( pandas.DataFrame, excluded=[pandas.DataFrame, pandas.DataFrame.__init__] ) class DataFrame(object): def __init__( self, data=None, index=None, columns=None, dtype=None, copy=False, query_compiler=None, ): """Distributed DataFrame object backed by Pandas dataframes. Args: data (numpy ndarray (structured or homogeneous) or dict): Dict can contain Series, arrays, constants, or list-like objects. index (pandas.Index, list, ObjectID): The row index for this DataFrame. columns (pandas.Index): The column names for this DataFrame, in pandas Index object. dtype: Data type to force. Only a single dtype is allowed. If None, infer copy (boolean): Copy data from inputs. Only affects DataFrame / 2d ndarray input. query_compiler: A query compiler object to manage distributed computation. """ if isinstance(data, DataFrame): self._query_compiler = data._query_compiler return # Check type of data and use appropriate constructor if data is not None or query_compiler is None: pandas_df = pandas.DataFrame( data=data, index=index, columns=columns, dtype=dtype, copy=copy ) self._query_compiler = from_pandas(pandas_df)._query_compiler else: self._query_compiler = query_compiler def __str__(self): return repr(self) def _build_repr_df(self, num_rows, num_cols): # Add one here so that pandas automatically adds the dots # It turns out to be faster to extract 2 extra rows and columns than to # build the dots ourselves. num_rows_for_head = num_rows // 2 + 1 num_cols_for_front = num_cols // 2 + 1 if len(self.index) <= num_rows: head = self._query_compiler tail = None else: head = self._query_compiler.head(num_rows_for_head) tail = self._query_compiler.tail(num_rows_for_head) if len(self.columns) <= num_cols: head_front = head.to_pandas() # Creating these empty to make the concat logic simpler head_back = pandas.DataFrame() tail_back = pandas.DataFrame() if tail is not None: tail_front = tail.to_pandas() else: tail_front = pandas.DataFrame() else: head_front = head.front(num_cols_for_front).to_pandas() head_back = head.back(num_cols_for_front).to_pandas() if tail is not None: tail_front = tail.front(num_cols_for_front).to_pandas() tail_back = tail.back(num_cols_for_front).to_pandas() else: tail_front = tail_back = pandas.DataFrame() head_for_repr = pandas.concat([head_front, head_back], axis=1) tail_for_repr = pandas.concat([tail_front, tail_back], axis=1) return pandas.concat([head_for_repr, tail_for_repr]) def __repr__(self): # In the future, we can have this be configurable, just like Pandas. num_rows = 60 num_cols = 30 result = repr(self._build_repr_df(num_rows, num_cols)) if len(self.index) > num_rows or len(self.columns) > num_cols: # The split here is so that we don't repr pandas row lengths. return result.rsplit("\n\n", 1)[0] + "\n\n[{0} rows x {1} columns]".format( len(self.index), len(self.columns) ) else: return result def _repr_html_(self): """repr function for rendering in Jupyter Notebooks like Pandas Dataframes. Returns: The HTML representation of a Dataframe. """ # In the future, we can have this be configurable, just like Pandas. num_rows = 60 num_cols = 20 # We use pandas _repr_html_ to get a string of the HTML representation # of the dataframe. result = self._build_repr_df(num_rows, num_cols)._repr_html_() if len(self.index) > num_rows or len(self.columns) > num_cols: # We split so that we insert our correct dataframe dimensions. return result.split("<p>")[ 0 ] + "<p>{0} rows x {1} columns</p>\n</div>".format( len(self.index), len(self.columns) ) else: return result def _get_index(self): """Get the index for this DataFrame. Returns: The union of all indexes across the partitions. """ return self._query_compiler.index def _get_columns(self): """Get the columns for this DataFrame. Returns: The union of all indexes across the partitions. """ return self._query_compiler.columns def _set_index(self, new_index): """Set the index for this DataFrame. Args: new_index: The new index to set this """ self._query_compiler.index = new_index def _set_columns(self, new_columns): """Set the columns for this DataFrame. Args: new_index: The new index to set this """ self._query_compiler.columns = new_columns index = property(_get_index, _set_index) columns = property(_get_columns, _set_columns) def _validate_eval_query(self, expr, **kwargs): """Helper function to check the arguments to eval() and query() Args: expr: The expression to evaluate. This string cannot contain any Python statements, only Python expressions. """ if isinstance(expr, str) and expr is "": raise ValueError("expr cannot be an empty string") if isinstance(expr, str) and "@" in expr: ErrorMessage.not_implemented("Local variables not yet supported in eval.") if isinstance(expr, str) and "not" in expr: if "parser" in kwargs and kwargs["parser"] == "python": ErrorMessage.not_implemented("'Not' nodes are not implemented.") @property def size(self): """Get the number of elements in the DataFrame. Returns: The number of elements in the DataFrame. """ return len(self.index) * len(self.columns) @property def ndim(self): """Get the number of dimensions for this DataFrame. Returns: The number of dimensions for this DataFrame. """ # DataFrames have an invariant that requires they be 2 dimensions. return 2 @property def ftypes(self): """Get the ftypes for this DataFrame. Returns: The ftypes for this DataFrame. """ # The ftypes are common across all partitions. # The first partition will be enough. dtypes = self.dtypes.copy() ftypes = ["{0}:dense".format(str(dtype)) for dtype in dtypes.values] result = pandas.Series(ftypes, index=self.columns) return result @property def dtypes(self): """Get the dtypes for this DataFrame. Returns: The dtypes for this DataFrame. """ return self._query_compiler.dtypes @property def empty(self): """Determines if the DataFrame is empty. Returns: True if the DataFrame is empty. False otherwise. """ return len(self.columns) == 0 or len(self.index) == 0 @property def values(self): """Create a numpy array with the values from this DataFrame. Returns: The numpy representation of this DataFrame. """ return to_pandas(self).values @property def axes(self): """Get the axes for the DataFrame. Returns: The axes for the DataFrame. """ return [self.index, self.columns] @property def shape(self): """Get the size of each of the dimensions in the DataFrame. Returns: A tuple with the size of each dimension as they appear in axes(). """ return len(self.index), len(self.columns) def _update_inplace(self, new_query_compiler): """Updates the current DataFrame inplace. Args: new_query_compiler: The new QueryCompiler to use to manage the data """ old_query_compiler = self._query_compiler self._query_compiler = new_query_compiler old_query_compiler.free() def add_prefix(self, prefix): """Add a prefix to each of the column names. Returns: A new DataFrame containing the new column names. """ return DataFrame(query_compiler=self._query_compiler.add_prefix(prefix)) def add_suffix(self, suffix): """Add a suffix to each of the column names. Returns: A new DataFrame containing the new column names. """ return DataFrame(query_compiler=self._query_compiler.add_suffix(suffix)) def applymap(self, func): """Apply a function to a DataFrame elementwise. Args: func (callable): The function to apply. """ if not callable(func): raise ValueError("'{0}' object is not callable".format(type(func))) ErrorMessage.non_verified_udf() return DataFrame(query_compiler=self._query_compiler.applymap(func)) def copy(self, deep=True): """Creates a shallow copy of the DataFrame. Returns: A new DataFrame pointing to the same partitions as this one. """ return DataFrame(query_compiler=self._query_compiler.copy()) def groupby( self, by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, **kwargs ): """Apply a groupby to this DataFrame. See _groupby() remote task. Args: by: The value to groupby. axis: The axis to groupby. level: The level of the groupby. as_index: Whether or not to store result as index. sort: Whether or not to sort the result by the index. group_keys: Whether or not to group the keys. squeeze: Whether or not to squeeze. Returns: A new DataFrame resulting from the groupby. """ axis = pandas.DataFrame()._get_axis_number(axis) idx_name = "" if callable(by): by = by(self.index) elif isinstance(by, string_types): idx_name = by by = self.__getitem__(by).values.tolist() elif is_list_like(by): if isinstance(by, pandas.Series): by = by.values.tolist() mismatch = ( len(by) != len(self) if axis == 0 else len(by) != len(self.columns) ) if all(obj in self for obj in by) and mismatch: # In the future, we will need to add logic to handle this, but for now # we default to pandas in this case. pass elif mismatch: raise KeyError(next(x for x in by if x not in self)) from .groupby import DataFrameGroupBy return DataFrameGroupBy( self, by, axis, level, as_index, sort, group_keys, squeeze, idx_name, **kwargs ) def sum( self, axis=None, skipna=True, level=None, numeric_only=None, min_count=0, **kwargs ): """Perform a sum across the DataFrame. Args: axis (int): The axis to sum on. skipna (bool): True to skip NA values, false otherwise. Returns: The sum of the DataFrame. """ axis = pandas.DataFrame()._get_axis_number(axis) if axis is not None else 0 self._validate_dtypes_sum_prod_mean(axis, numeric_only, ignore_axis=False) return self._query_compiler.sum( axis=axis, skipna=skipna, level=level, numeric_only=numeric_only, min_count=min_count, **kwargs ) def abs(self): """Apply an absolute value function to all numeric columns. Returns: A new DataFrame with the applied absolute value. """ self._validate_dtypes(numeric_only=True) return DataFrame(query_compiler=self._query_compiler.abs()) def isin(self, values): """Fill a DataFrame with booleans for cells contained in values. Args: values (iterable, DataFrame, Series, or dict): The values to find. Returns: A new DataFrame with booleans representing whether or not a cell is in values. True: cell is contained in values. False: otherwise """ return DataFrame(query_compiler=self._query_compiler.isin(values=values)) def isna(self): """Fill a DataFrame with booleans for cells containing NA. Returns: A new DataFrame with booleans representing whether or not a cell is NA. True: cell contains NA. False: otherwise. """ return DataFrame(query_compiler=self._query_compiler.isna()) def isnull(self): """Fill a DataFrame with booleans for cells containing a null value. Returns: A new DataFrame with booleans representing whether or not a cell is null. True: cell contains null. False: otherwise. """ return DataFrame(query_compiler=self._query_compiler.isnull()) def keys(self): """Get the info axis for the DataFrame. Returns: A pandas Index for this DataFrame. """ return self.columns def transpose(self, *args, **kwargs): """Transpose columns and rows for the DataFrame. Returns: A new DataFrame transposed from this DataFrame. """ return DataFrame(query_compiler=self._query_compiler.transpose(*args, **kwargs)) T = property(transpose) def dropna(self, axis=0, how="any", thresh=None, subset=None, inplace=False): """Create a new DataFrame from the removed NA values from this one. Args: axis (int, tuple, or list): The axis to apply the drop. how (str): How to drop the NA values. 'all': drop the label if all values are NA. 'any': drop the label if any values are NA. thresh (int): The minimum number of NAs to require. subset ([label]): Labels to consider from other axis. inplace (bool): Change this DataFrame or return a new DataFrame. True: Modify the data for this DataFrame, return None. False: Create a new DataFrame and return it. Returns: If inplace is set to True, returns None, otherwise returns a new DataFrame with the dropna applied. """ inplace = validate_bool_kwarg(inplace, "inplace") if is_list_like(axis): axis = [pandas.DataFrame()._get_axis_number(ax) for ax in axis] result = self for ax in axis: result = result.dropna(axis=ax, how=how, thresh=thresh, subset=subset) return self._create_dataframe_from_compiler(result._query_compiler, inplace) axis = pandas.DataFrame()._get_axis_number(axis) if how is not None and how not in ["any", "all"]: raise ValueError("invalid how option: %s" % how) if how is None and thresh is None: raise TypeError("must specify how or thresh") if subset is not None: if axis == 1: indices = self.index.get_indexer_for(subset) check = indices == -1 if check.any(): raise KeyError(list(np.compress(check, subset))) else: indices = self.columns.get_indexer_for(subset) check = indices == -1 if check.any(): raise KeyError(list(np.compress(check, subset))) new_query_compiler = self._query_compiler.dropna( axis=axis, how=how, thresh=thresh, subset=subset ) return self._create_dataframe_from_compiler(new_query_compiler, inplace) def add(self, other, axis="columns", level=None, fill_value=None): """Add this DataFrame to another or a scalar/list. Args: other: What to add this this DataFrame. axis: The axis to apply addition over. Only applicaable to Series or list 'other'. level: A level in the multilevel axis to add over. fill_value: The value to fill NaN. Returns: A new DataFrame with the applied addition. """ axis = pandas.DataFrame()._get_axis_number(axis) if level is not None: if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.add, other, axis=axis, level=level, fill_value=fill_value, ) other = self._validate_other(other, axis, numeric_or_object_only=True) new_query_compiler = self._query_compiler.add( other=other, axis=axis, level=level, fill_value=fill_value ) return self._create_dataframe_from_compiler(new_query_compiler) def agg(self, func, axis=0, *args, **kwargs): return self.aggregate(func, axis, *args, **kwargs) def aggregate(self, func, axis=0, *args, **kwargs): axis = pandas.DataFrame()._get_axis_number(axis) result = None if axis == 0: try: result = self._aggregate(func, axis=axis, *args, **kwargs) except TypeError: pass if result is None: kwargs.pop("is_transform", None) return self.apply(func, axis=axis, args=args, **kwargs) return result def _aggregate(self, arg, *args, **kwargs): _axis = kwargs.pop("_axis", None) if _axis is None: _axis = getattr(self, "axis", 0) kwargs.pop("_level", None) if isinstance(arg, string_types): return self._string_function(arg, *args, **kwargs) # Dictionaries have complex behavior because they can be renamed here. elif isinstance(arg, dict): return self._default_to_pandas(pandas.DataFrame.agg, arg, *args, **kwargs) elif is_list_like(arg) or callable(arg): return self.apply(arg, axis=_axis, args=args, **kwargs) else: # TODO Make pandas error raise ValueError("type {} is not callable".format(type(arg))) def _string_function(self, func, *args, **kwargs): assert isinstance(func, string_types) f = getattr(self, func, None) if f is not None: if callable(f): return f(*args, **kwargs) assert len(args) == 0 assert ( len([kwarg for kwarg in kwargs if kwarg not in ["axis", "_level"]]) == 0 ) return f f = getattr(np, func, None) if f is not None: return self._default_to_pandas(pandas.DataFrame.agg, func, *args, **kwargs) raise ValueError("{} is an unknown string function".format(func)) def align( self, other, join="outer", axis=None, level=None, copy=True, fill_value=None, method=None, limit=None, fill_axis=0, broadcast_axis=None, ): if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.align, other, join=join, axis=axis, level=level, copy=copy, fill_value=fill_value, method=method, limit=limit, fill_axis=fill_axis, broadcast_axis=broadcast_axis, ) def all(self, axis=0, bool_only=None, skipna=None, level=None, **kwargs): """Return whether all elements are True over requested axis Note: If axis=None or axis=0, this call applies df.all(axis=1) to the transpose of df. """ if axis is not None: axis = pandas.DataFrame()._get_axis_number(axis) else: if bool_only: raise ValueError("Axis must be 0 or 1 (got {})".format(axis)) return self._query_compiler.all( axis=axis, bool_only=bool_only, skipna=skipna, level=level, **kwargs ) def any(self, axis=0, bool_only=None, skipna=None, level=None, **kwargs): """Return whether any elements are True over requested axis Note: If axis=None or axis=0, this call applies on the column partitions, otherwise operates on row partitions """ if axis is not None: axis = pandas.DataFrame()._get_axis_number(axis) else: if bool_only: raise ValueError("Axis must be 0 or 1 (got {})".format(axis)) return self._query_compiler.any( axis=axis, bool_only=bool_only, skipna=skipna, level=level, **kwargs ) def append(self, other, ignore_index=False, verify_integrity=False, sort=None): """Append another DataFrame/list/Series to this one. Args: other: The object to append to this. ignore_index: Ignore the index on appending. verify_integrity: Verify the integrity of the index on completion. Returns: A new DataFrame containing the concatenated values. """ if isinstance(other, (pandas.Series, dict)): if isinstance(other, dict): other = pandas.Series(other) if other.name is None and not ignore_index: raise TypeError( "Can only append a Series if ignore_index=True" " or if the Series has a name" ) if other.name is None: index = None else: # other must have the same index name as self, otherwise # index name will be reset index = pandas.Index([other.name], name=self.index.name) # Create a Modin DataFrame from this Series for ease of development other = DataFrame(pandas.DataFrame(other).T, index=index)._query_compiler elif isinstance(other, list): if not isinstance(other[0], DataFrame): other = pandas.DataFrame(other) if (self.columns.get_indexer(other.columns) >= 0).all(): other = DataFrame(other.loc[:, self.columns])._query_compiler else: other = DataFrame(other)._query_compiler else: other = [obj._query_compiler for obj in other] else: other = other._query_compiler # If ignore_index is False, by definition the Index will be correct. # We also do this first to ensure that we don't waste compute/memory. if verify_integrity and not ignore_index: appended_index = self.index.append(other.index) is_valid = next((False for idx in appended_index.duplicated() if idx), True) if not is_valid: raise ValueError( "Indexes have overlapping values: {}".format( appended_index[appended_index.duplicated()] ) ) query_compiler = self._query_compiler.concat( 0, other, ignore_index=ignore_index, sort=sort ) return DataFrame(query_compiler=query_compiler) def apply( self, func, axis=0, broadcast=False, raw=False, reduce=None, args=(), **kwds ): """Apply a function along input axis of DataFrame. Args: func: The function to apply axis: The axis over which to apply the func. broadcast: Whether or not to broadcast. raw: Whether or not to convert to a Series. reduce: Whether or not to try to apply reduction procedures. Returns: Series or DataFrame, depending on func. """ axis = pandas.DataFrame()._get_axis_number(axis) ErrorMessage.non_verified_udf() if isinstance(func, string_types): if axis == 1: kwds["axis"] = axis return getattr(self, func)(*args, **kwds) elif isinstance(func, dict): if axis == 1: raise TypeError( "(\"'dict' object is not callable\", " "'occurred at index {0}'".format(self.index[0]) ) if len(self.columns) != len(set(self.columns)): warnings.warn( "duplicate column names not supported with apply().", FutureWarning, stacklevel=2, ) elif is_list_like(func): if axis == 1: raise TypeError( "(\"'list' object is not callable\", " "'occurred at index {0}'".format(self.index[0]) ) elif not callable(func): return query_compiler = self._query_compiler.apply(func, axis, *args, **kwds) if isinstance(query_compiler, pandas.Series): return query_compiler return DataFrame(query_compiler=query_compiler) def as_blocks(self, copy=True): return self._default_to_pandas(pandas.DataFrame.as_blocks, copy=copy) def as_matrix(self, columns=None): """Convert the frame to its Numpy-array representation. Args: columns: If None, return all columns, otherwise, returns specified columns. Returns: values: ndarray """ # TODO this is very inefficient, also see __array__ return to_pandas(self).as_matrix(columns) def asfreq(self, freq, method=None, how=None, normalize=False, fill_value=None): return self._default_to_pandas( pandas.DataFrame.asfreq, freq, method=method, how=how, normalize=normalize, fill_value=fill_value, ) def asof(self, where, subset=None): return self._default_to_pandas(pandas.DataFrame.asof, where, subset=subset) def assign(self, **kwargs): return self._default_to_pandas(pandas.DataFrame.assign, **kwargs) def astype(self, dtype, copy=True, errors="raise", **kwargs): col_dtypes = {} if isinstance(dtype, dict): if not set(dtype.keys()).issubset(set(self.columns)) and errors == "raise": raise KeyError( "Only a column name can be used for the key in" "a dtype mappings argument." ) col_dtypes = dtype else: for column in self.columns: col_dtypes[column] = dtype new_query_compiler = self._query_compiler.astype(col_dtypes, **kwargs) return self._create_dataframe_from_compiler(new_query_compiler, not copy) def at_time(self, time, asof=False): return self._default_to_pandas(pandas.DataFrame.at_time, time, asof=asof) def between_time(self, start_time, end_time, include_start=True, include_end=True): return self._default_to_pandas( pandas.DataFrame.between_time, start_time, end_time, include_start=include_start, include_end=include_end, ) def bfill(self, axis=None, inplace=False, limit=None, downcast=None): """Synonym for DataFrame.fillna(method='bfill')""" new_df = self.fillna( method="bfill", axis=axis, limit=limit, downcast=downcast, inplace=inplace ) if not inplace: return new_df def bool(self): """Return the bool of a single element PandasObject. This must be a boolean scalar value, either True or False. Raise a ValueError if the PandasObject does not have exactly 1 element, or that element is not boolean """ shape = self.shape if shape != (1,) and shape != (1, 1): raise ValueError( """The PandasObject does not have exactly 1 element. Return the bool of a single element PandasObject. The truth value is ambiguous. Use a.empty, a.item(), a.any() or a.all().""" ) else: return to_pandas(self).bool() def boxplot( self, column=None, by=None, ax=None, fontsize=None, rot=0, grid=True, figsize=None, layout=None, return_type=None, **kwargs ): return to_pandas(self).boxplot( column=column, by=by, ax=ax, fontsize=fontsize, rot=rot, grid=grid, figsize=figsize, layout=layout, return_type=return_type, **kwargs ) def clip(self, lower=None, upper=None, axis=None, inplace=False, *args, **kwargs): # validate inputs if axis is not None: axis = pandas.DataFrame()._get_axis_number(axis) self._validate_dtypes(numeric_only=True) if is_list_like(lower) or is_list_like(upper): if axis is None: raise ValueError("Must specify axis = 0 or 1") self._validate_other(lower, axis) self._validate_other(upper, axis) inplace = validate_bool_kwarg(inplace, "inplace") axis = numpy_compat.function.validate_clip_with_axis(axis, args, kwargs) # any np.nan bounds are treated as None if lower is not None and np.any(np.isnan(lower)): lower = None if upper is not None and np.any(np.isnan(upper)): upper = None new_query_compiler = self._query_compiler.clip( lower=lower, upper=upper, axis=axis, inplace=inplace, *args, **kwargs ) return self._create_dataframe_from_compiler(new_query_compiler, inplace) def clip_lower(self, threshold, axis=None, inplace=False): return self.clip(lower=threshold, axis=axis, inplace=inplace) def clip_upper(self, threshold, axis=None, inplace=False): return self.clip(upper=threshold, axis=axis, inplace=inplace) def combine(self, other, func, fill_value=None, overwrite=True): if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.combine, other, func, fill_value=fill_value, overwrite=overwrite, ) def combine_first(self, other): if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas(pandas.DataFrame.combine_first, other=other) def compound(self, axis=None, skipna=None, level=None): return self._default_to_pandas( pandas.DataFrame.compound, axis=axis, skipna=skipna, level=level ) def consolidate(self, inplace=False): return self._default_to_pandas(pandas.DataFrame.consolidate, inplace=inplace) def convert_objects( self, convert_dates=True, convert_numeric=False, convert_timedeltas=True, copy=True, ): return self._default_to_pandas( pandas.DataFrame.convert_objects, convert_dates=convert_dates, convert_numeric=convert_numeric, convert_timedeltas=convert_timedeltas, copy=copy, ) def corr(self, method="pearson", min_periods=1): return self._default_to_pandas( pandas.DataFrame.corr, method=method, min_periods=min_periods ) def corrwith(self, other, axis=0, drop=False): if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.corrwith, other, axis=axis, drop=drop ) def count(self, axis=0, level=None, numeric_only=False): """Get the count of non-null objects in the DataFrame. Arguments: axis: 0 or 'index' for row-wise, 1 or 'columns' for column-wise. level: If the axis is a MultiIndex (hierarchical), count along a particular level, collapsing into a DataFrame. numeric_only: Include only float, int, boolean data Returns: The count, in a Series (or DataFrame if level is specified). """ axis = pandas.DataFrame()._get_axis_number(axis) if axis is not None else 0 return self._query_compiler.count( axis=axis, level=level, numeric_only=numeric_only ) def cov(self, min_periods=None): return self._default_to_pandas(pandas.DataFrame.cov, min_periods=min_periods) def cummax(self, axis=None, skipna=True, *args, **kwargs): """Perform a cumulative maximum across the DataFrame. Args: axis (int): The axis to take maximum on. skipna (bool): True to skip NA values, false otherwise. Returns: The cumulative maximum of the DataFrame. """ axis = pandas.DataFrame()._get_axis_number(axis) if axis is not None else 0 if axis: self._validate_dtypes() return DataFrame( query_compiler=self._query_compiler.cummax( axis=axis, skipna=skipna, **kwargs ) ) def cummin(self, axis=None, skipna=True, *args, **kwargs): """Perform a cumulative minimum across the DataFrame. Args: axis (int): The axis to cummin on. skipna (bool): True to skip NA values, false otherwise. Returns: The cumulative minimum of the DataFrame. """ axis = pandas.DataFrame()._get_axis_number(axis) if axis is not None else 0 if axis: self._validate_dtypes() return DataFrame( query_compiler=self._query_compiler.cummin( axis=axis, skipna=skipna, **kwargs ) ) def cumprod(self, axis=None, skipna=True, *args, **kwargs): """Perform a cumulative product across the DataFrame. Args: axis (int): The axis to take product on. skipna (bool): True to skip NA values, false otherwise. Returns: The cumulative product of the DataFrame. """ axis = pandas.DataFrame()._get_axis_number(axis) if axis is not None else 0 self._validate_dtypes(numeric_only=True) return DataFrame( query_compiler=self._query_compiler.cumprod( axis=axis, skipna=skipna, **kwargs ) ) def cumsum(self, axis=None, skipna=True, *args, **kwargs): """Perform a cumulative sum across the DataFrame. Args: axis (int): The axis to take sum on. skipna (bool): True to skip NA values, false otherwise. Returns: The cumulative sum of the DataFrame. """ axis = pandas.DataFrame()._get_axis_number(axis) if axis is not None else 0 self._validate_dtypes(numeric_only=True) return DataFrame( query_compiler=self._query_compiler.cumsum( axis=axis, skipna=skipna, **kwargs ) ) def describe(self, percentiles=None, include=None, exclude=None): """ Generates descriptive statistics that summarize the central tendency, dispersion and shape of a dataset's distribution, excluding NaN values. Args: percentiles (list-like of numbers, optional): The percentiles to include in the output. include: White-list of data types to include in results exclude: Black-list of data types to exclude in results Returns: Series/DataFrame of summary statistics """ if include is not None: if not is_list_like(include): include = [include] include = [np.dtype(i) for i in include] if exclude is not None: if not is_list_like(include): exclude = [exclude] exclude = [np.dtype(e) for e in exclude] if percentiles is not None: pandas.DataFrame()._check_percentile(percentiles) return DataFrame( query_compiler=self._query_compiler.describe( percentiles=percentiles, include=include, exclude=exclude ) ) def diff(self, periods=1, axis=0): """Finds the difference between elements on the axis requested Args: periods: Periods to shift for forming difference axis: Take difference over rows or columns Returns: DataFrame with the diff applied """ axis = pandas.DataFrame()._get_axis_number(axis) return DataFrame( query_compiler=self._query_compiler.diff(periods=periods, axis=axis) ) def div(self, other, axis="columns", level=None, fill_value=None): """Divides this DataFrame against another DataFrame/Series/scalar. Args: other: The object to use to apply the divide against this. axis: The axis to divide over. level: The Multilevel index level to apply divide over. fill_value: The value to fill NaNs with. Returns: A new DataFrame with the Divide applied. """ if level is not None: if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.div, other, axis=axis, level=level, fill_value=fill_value, ) other = self._validate_other(other, axis, numeric_only=True) new_query_compiler = self._query_compiler.div( other=other, axis=axis, level=level, fill_value=fill_value ) return self._create_dataframe_from_compiler(new_query_compiler) def divide(self, other, axis="columns", level=None, fill_value=None): """Synonym for div. Args: other: The object to use to apply the divide against this. axis: The axis to divide over. level: The Multilevel index level to apply divide over. fill_value: The value to fill NaNs with. Returns: A new DataFrame with the Divide applied. """ return self.div(other, axis, level, fill_value) def dot(self, other): if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas(pandas.DataFrame.dot, other) def drop( self, labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors="raise", ): """Return new object with labels in requested axis removed. Args: labels: Index or column labels to drop. axis: Whether to drop labels from the index (0 / 'index') or columns (1 / 'columns'). index, columns: Alternative to specifying axis (labels, axis=1 is equivalent to columns=labels). level: For MultiIndex inplace: If True, do operation inplace and return None. errors: If 'ignore', suppress error and existing labels are dropped. Returns: dropped : type of caller """ # TODO implement level if level is not None: return self._default_to_pandas( pandas.DataFrame.drop, labels=labels, axis=axis, index=index, columns=columns, level=level, inplace=inplace, errors=errors, ) inplace = validate_bool_kwarg(inplace, "inplace") if labels is not None: if index is not None or columns is not None: raise ValueError("Cannot specify both 'labels' and 'index'/'columns'") axis = pandas.DataFrame()._get_axis_name(axis) axes = {axis: labels} elif index is not None or columns is not None: axes, _ = pandas.DataFrame()._construct_axes_from_arguments( (index, columns), {} ) else: raise ValueError( "Need to specify at least one of 'labels', 'index' or 'columns'" ) # TODO Clean up this error checking if "index" not in axes: axes["index"] = None elif axes["index"] is not None: if not is_list_like(axes["index"]): axes["index"] = [axes["index"]] if errors == "raise": non_existant = [obj for obj in axes["index"] if obj not in self.index] if len(non_existant): raise ValueError( "labels {} not contained in axis".format(non_existant) ) else: axes["index"] = [obj for obj in axes["index"] if obj in self.index] # If the length is zero, we will just do nothing if not len(axes["index"]): axes["index"] = None if "columns" not in axes: axes["columns"] = None elif axes["columns"] is not None: if not is_list_like(axes["columns"]): axes["columns"] = [axes["columns"]] if errors == "raise": non_existant = [ obj for obj in axes["columns"] if obj not in self.columns ] if len(non_existant): raise ValueError( "labels {} not contained in axis".format(non_existant) ) else: axes["columns"] = [ obj for obj in axes["columns"] if obj in self.columns ] # If the length is zero, we will just do nothing if not len(axes["columns"]): axes["columns"] = None new_query_compiler = self._query_compiler.drop( index=axes["index"], columns=axes["columns"] ) return self._create_dataframe_from_compiler(new_query_compiler, inplace) def drop_duplicates(self, subset=None, keep="first", inplace=False): return self._default_to_pandas( pandas.DataFrame.drop_duplicates, subset=subset, keep=keep, inplace=inplace ) def duplicated(self, subset=None, keep="first"): return self._default_to_pandas( pandas.DataFrame.duplicated, subset=subset, keep=keep ) def eq(self, other, axis="columns", level=None): """Checks element-wise that this is equal to other. Args: other: A DataFrame or Series or scalar to compare to. axis: The axis to perform the eq over. level: The Multilevel index level to apply eq over. Returns: A new DataFrame filled with Booleans. """ if level is not None: if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.eq, other, axis=axis, level=level ) other = self._validate_other(other, axis) new_query_compiler = self._query_compiler.eq( other=other, axis=axis, level=level ) return self._create_dataframe_from_compiler(new_query_compiler) def equals(self, other): """ Checks if other DataFrame is elementwise equal to the current one Returns: Boolean: True if equal, otherwise False """ if isinstance(other, pandas.DataFrame): # Copy into a Ray DataFrame to simplify logic below other = DataFrame(other) if not self.index.equals(other.index) or not self.columns.equals(other.columns): return False return all(self.eq(other).all()) def eval(self, expr, inplace=False, **kwargs): """Evaluate a Python expression as a string using various backends. Args: expr: The expression to evaluate. This string cannot contain any Python statements, only Python expressions. parser: The parser to use to construct the syntax tree from the expression. The default of 'pandas' parses code slightly different than standard Python. Alternatively, you can parse an expression using the 'python' parser to retain strict Python semantics. See the enhancing performance documentation for more details. engine: The engine used to evaluate the expression. truediv: Whether to use true division, like in Python >= 3 local_dict: A dictionary of local variables, taken from locals() by default. global_dict: A dictionary of global variables, taken from globals() by default. resolvers: A list of objects implementing the __getitem__ special method that you can use to inject an additional collection of namespaces to use for variable lookup. For example, this is used in the query() method to inject the index and columns variables that refer to their respective DataFrame instance attributes. level: The number of prior stack frames to traverse and add to the current scope. Most users will not need to change this parameter. target: This is the target object for assignment. It is used when there is variable assignment in the expression. If so, then target must support item assignment with string keys, and if a copy is being returned, it must also support .copy(). inplace: If target is provided, and the expression mutates target, whether to modify target inplace. Otherwise, return a copy of target with the mutation. Returns: ndarray, numeric scalar, DataFrame, Series """ self._validate_eval_query(expr, **kwargs) inplace = validate_bool_kwarg(inplace, "inplace") new_query_compiler = self._query_compiler.eval(expr, **kwargs) if isinstance(new_query_compiler, pandas.Series): return new_query_compiler else: return self._create_dataframe_from_compiler(new_query_compiler, inplace) def ewm( self, com=None, span=None, halflife=None, alpha=None, min_periods=0, freq=None, adjust=True, ignore_na=False, axis=0, ): return self._default_to_pandas( pandas.DataFrame.ewm, com=com, span=span, halflife=halflife, alpha=alpha, min_periods=min_periods, freq=freq, adjust=adjust, ignore_na=ignore_na, axis=axis, ) def expanding(self, min_periods=1, freq=None, center=False, axis=0): return self._default_to_pandas( pandas.DataFrame.expanding, min_periods=min_periods, freq=freq, center=center, axis=axis, ) def ffill(self, axis=None, inplace=False, limit=None, downcast=None): """Synonym for DataFrame.fillna(method='ffill') """ new_df = self.fillna( method="ffill", axis=axis, limit=limit, downcast=downcast, inplace=inplace ) if not inplace: return new_df def fillna( self, value=None, method=None, axis=None, inplace=False, limit=None, downcast=None, **kwargs ): """Fill NA/NaN values using the specified method. Args: value: Value to use to fill holes. This value cannot be a list. method: Method to use for filling holes in reindexed Series pad. ffill: propagate last valid observation forward to next valid backfill. bfill: use NEXT valid observation to fill gap. axis: 0 or 'index', 1 or 'columns'. inplace: If True, fill in place. Note: this will modify any other views on this object. limit: If method is specified, this is the maximum number of consecutive NaN values to forward/backward fill. In other words, if there is a gap with more than this number of consecutive NaNs, it will only be partially filled. If method is not specified, this is the maximum number of entries along the entire axis where NaNs will be filled. Must be greater than 0 if not None. downcast: A dict of item->dtype of what to downcast if possible, or the string 'infer' which will try to downcast to an appropriate equal type. Returns: filled: DataFrame """ # TODO implement value passed as DataFrame if isinstance(value, pandas.DataFrame) or isinstance(value, pandas.Series): new_query_compiler = self._default_to_pandas( pandas.DataFrame.fillna, value=value, method=method, axis=axis, inplace=False, limit=limit, downcast=downcast, **kwargs )._query_compiler return self._create_dataframe_from_compiler(new_query_compiler, inplace) inplace = validate_bool_kwarg(inplace, "inplace") axis = pandas.DataFrame()._get_axis_number(axis) if axis is not None else 0 if isinstance(value, (list, tuple)): raise TypeError( '"value" parameter must be a scalar or dict, but ' 'you passed a "{0}"'.format(type(value).__name__) ) if value is None and method is None: raise ValueError("must specify a fill method or value") if value is not None and method is not None: raise ValueError("cannot specify both a fill method and value") if method is not None and method not in ["backfill", "bfill", "pad", "ffill"]: expecting = "pad (ffill) or backfill (bfill)" msg = "Invalid fill method. Expecting {expecting}. Got {method}".format( expecting=expecting, method=method ) raise ValueError(msg) new_query_compiler = self._query_compiler.fillna( value=value, method=method, axis=axis, inplace=False, limit=limit, downcast=downcast, **kwargs ) return self._create_dataframe_from_compiler(new_query_compiler, inplace) def filter(self, items=None, like=None, regex=None, axis=None): """Subset rows or columns based on their labels Args: items (list): list of labels to subset like (string): retain labels where `arg in label == True` regex (string): retain labels matching regex input axis: axis to filter on Returns: A new DataFrame with the filter applied. """ nkw = com._count_not_none(items, like, regex) if nkw > 1: raise TypeError( "Keyword arguments `items`, `like`, or `regex` " "are mutually exclusive" ) if nkw == 0: raise TypeError("Must pass either `items`, `like`, or `regex`") if axis is None: axis = "columns" # This is the default info axis for dataframes axis = pandas.DataFrame()._get_axis_number(axis) labels = self.columns if axis else self.index if items is not None: bool_arr = labels.isin(items) elif like is not None: def f(x): return like in to_str(x) bool_arr = labels.map(f).tolist() else: def f(x): return matcher.search(to_str(x)) is not None matcher = re.compile(regex) bool_arr = labels.map(f).tolist() if not axis: return self[bool_arr] return self[self.columns[bool_arr]] def first(self, offset): return self._default_to_pandas(pandas.DataFrame.first, offset) def first_valid_index(self): """Return index for first non-NA/null value. Returns: scalar: type of index """ return self._query_compiler.first_valid_index() def floordiv(self, other, axis="columns", level=None, fill_value=None): """Divides this DataFrame against another DataFrame/Series/scalar. Args: other: The object to use to apply the divide against this. axis: The axis to divide over. level: The Multilevel index level to apply divide over. fill_value: The value to fill NaNs with. Returns: A new DataFrame with the Divide applied. """ if level is not None: if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.floordiv, other, axis=axis, level=level, fill_value=fill_value, ) other = self._validate_other(other, axis, numeric_only=True) new_query_compiler = self._query_compiler.floordiv( other=other, axis=axis, level=level, fill_value=fill_value ) return self._create_dataframe_from_compiler(new_query_compiler) @classmethod def from_csv( cls, path, header=0, sep=", ", index_col=0, parse_dates=True, encoding=None, tupleize_cols=None, infer_datetime_format=False, ): from .io import read_csv return read_csv( path, header=header, sep=sep, index_col=index_col, parse_dates=parse_dates, encoding=encoding, tupleize_cols=tupleize_cols, infer_datetime_format=infer_datetime_format, ) @classmethod def from_dict(cls, data, orient="columns", dtype=None): ErrorMessage.default_to_pandas() return from_pandas(pandas.DataFrame.from_dict(data, orient=orient, dtype=dtype)) @classmethod def from_items(cls, items, columns=None, orient="columns"): ErrorMessage.default_to_pandas() return from_pandas( pandas.DataFrame.from_items(items, columns=columns, orient=orient) ) @classmethod def from_records( cls, data, index=None, exclude=None, columns=None, coerce_float=False, nrows=None, ): ErrorMessage.default_to_pandas() return from_pandas( pandas.DataFrame.from_records( data, index=index, exclude=exclude, columns=columns, coerce_float=coerce_float, nrows=nrows, ) ) def ge(self, other, axis="columns", level=None): """Checks element-wise that this is greater than or equal to other. Args: other: A DataFrame or Series or scalar to compare to. axis: The axis to perform the gt over. level: The Multilevel index level to apply gt over. Returns: A new DataFrame filled with Booleans. """ if level is not None: if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.ge, other, axis=axis, level=level ) other = self._validate_other(other, axis, comparison_dtypes_only=True) new_query_compiler = self._query_compiler.ge( other=other, axis=axis, level=level ) return self._create_dataframe_from_compiler(new_query_compiler) def get(self, key, default=None): """Get item from object for given key (DataFrame column, Panel slice, etc.). Returns default value if not found. Args: key (DataFrame column, Panel slice) : the key for which value to get Returns: value (type of items contained in object) : A value that is stored at the key """ try: return self[key] except (KeyError, ValueError, IndexError): return default def get_dtype_counts(self): """Get the counts of dtypes in this object. Returns: The counts of dtypes in this object. """ result = self.dtypes.value_counts() result.index = result.index.map(lambda x: str(x)) return result def get_ftype_counts(self): """Get the counts of ftypes in this object. Returns: The counts of ftypes in this object. """ return self.ftypes.value_counts().sort_index() def get_value(self, index, col, takeable=False): return self._default_to_pandas( pandas.DataFrame.get_value, index, col, takeable=takeable ) def get_values(self): return self._default_to_pandas(pandas.DataFrame.get_values) def gt(self, other, axis="columns", level=None): """Checks element-wise that this is greater than other. Args: other: A DataFrame or Series or scalar to compare to. axis: The axis to perform the gt over. level: The Multilevel index level to apply gt over. Returns: A new DataFrame filled with Booleans. """ if level is not None: if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.gt, other, axis=axis, level=level ) other = self._validate_other(other, axis, comparison_dtypes_only=True) new_query_compiler = self._query_compiler.gt( other=other, axis=axis, level=level ) return self._create_dataframe_from_compiler(new_query_compiler) def head(self, n=5): """Get the first n rows of the DataFrame. Args: n (int): The number of rows to return. Returns: A new DataFrame with the first n rows of the DataFrame. """ if n >= len(self.index): return self.copy() return DataFrame(query_compiler=self._query_compiler.head(n)) def hist( self, column=None, by=None, grid=True, xlabelsize=None, xrot=None, ylabelsize=None, yrot=None, ax=None, sharex=False, sharey=False, figsize=None, layout=None, bins=10, **kwargs ): return self._default_to_pandas( pandas.DataFrame.hist, column=column, by=by, grid=grid, xlabelsize=xlabelsize, xrot=xrot, ylabelsize=ylabelsize, yrot=yrot, ax=ax, sharex=sharex, sharey=sharey, figsize=figsize, layout=layout, bins=bins, **kwargs ) def idxmax(self, axis=0, skipna=True): """Get the index of the first occurrence of the max value of the axis. Args: axis (int): Identify the max over the rows (1) or columns (0). skipna (bool): Whether or not to skip NA values. Returns: A Series with the index for each maximum value for the axis specified. """ if not all(d != np.dtype("O") for d in self.dtypes): raise TypeError("reduction operation 'argmax' not allowed for this dtype") return self._query_compiler.idxmax(axis=axis, skipna=skipna) def idxmin(self, axis=0, skipna=True): """Get the index of the first occurrence of the min value of the axis. Args: axis (int): Identify the min over the rows (1) or columns (0). skipna (bool): Whether or not to skip NA values. Returns: A Series with the index for each minimum value for the axis specified. """ if not all(d != np.dtype("O") for d in self.dtypes): raise TypeError("reduction operation 'argmax' not allowed for this dtype") return self._query_compiler.idxmin(axis=axis, skipna=skipna) def infer_objects(self): return self._default_to_pandas(pandas.DataFrame.infer_objects) def info( self, verbose=None, buf=None, max_cols=None, memory_usage=None, null_counts=None ): """Print a concise summary of a DataFrame, which includes the index dtype and column dtypes, non-null values and memory usage. Args: verbose (bool, optional): Whether to print the full summary. Defaults to true buf (writable buffer): Where to send output. Defaults to sys.stdout max_cols (int, optional): When to switch from verbose to truncated output. By defualt, this is 100. memory_usage (bool, str, optional): Specifies whether the total memory usage of the DataFrame elements (including index) should be displayed. True always show memory usage. False never shows memory usage. A value of 'deep' is equivalent to "True with deep introspection". Memory usage is shown in human-readable units (base-2 representation). Without deep introspection a memory estimation is made based in column dtype and number of rows assuming values consume the same memory amount for corresponding dtypes. With deep memory introspection, a real memory usage calculation is performed at the cost of computational resources. Defaults to True. null_counts (bool, optional): Whetehr to show the non-null counts. By default, this is shown only when the frame is smaller than 100 columns and 1690785 rows. A value of True always shows the counts and False never shows the counts. Returns: Prints the summary of a DataFrame and returns None. """ # We will default to pandas because it will be faster than doing two passes # over the data buf = sys.stdout if not buf else buf import io with io.StringIO() as tmp_buf: self._default_to_pandas( pandas.DataFrame.info, verbose=verbose, buf=tmp_buf, max_cols=max_cols, memory_usage=memory_usage, null_counts=null_counts, ) result = tmp_buf.getvalue() result = result.replace( "pandas.core.frame.DataFrame", "modin.pandas.dataframe.DataFrame" ) buf.write(result) return None index = self.index columns = self.columns dtypes = self.dtypes # Set up default values verbose = True if verbose is None else verbose buf = sys.stdout if not buf else buf max_cols = 100 if not max_cols else max_cols memory_usage = True if memory_usage is None else memory_usage if not null_counts: if len(columns) < 100 and len(index) < 1690785: null_counts = True else: null_counts = False # Determine if actually verbose actually_verbose = True if verbose and max_cols > len(columns) else False if type(memory_usage) == str and memory_usage == "deep": memory_usage_deep = True else: memory_usage_deep = False # Start putting together output # Class denoted in info() output class_string = "<class 'modin.pandas.dataframe.DataFrame'>\n" # Create the Index info() string by parsing self.index index_string = index.summary() + "\n" if null_counts: counts = self._query_compiler.count() if memory_usage: memory_usage_data = self._query_compiler.memory_usage( deep=memory_usage_deep, index=True ) if actually_verbose: # Create string for verbose output col_string = "Data columns (total {0} columns):\n".format(len(columns)) for col, dtype in zip(columns, dtypes): col_string += "{0}\t".format(col) if null_counts: col_string += "{0} not-null ".format(counts[col]) col_string += "{0}\n".format(dtype) else: # Create string for not verbose output col_string = "Columns: {0} entries, {1} to {2}\n".format( len(columns), columns[0], columns[-1] ) # A summary of the dtypes in the dataframe dtypes_string = "dtypes: " for dtype, count in dtypes.value_counts().iteritems(): dtypes_string += "{0}({1}),".format(dtype, count) dtypes_string = dtypes_string[:-1] + "\n" # Create memory usage string memory_string = "" if memory_usage: if memory_usage_deep: memory_string = "memory usage: {0} bytes".format(memory_usage_data) else: memory_string = "memory usage: {0}+ bytes".format(memory_usage_data) # Combine all the components of the info() output result = "".join( [class_string, index_string, col_string, dtypes_string, memory_string] ) # Write to specified output buffer buf.write(result) def insert(self, loc, column, value, allow_duplicates=False): """Insert column into DataFrame at specified location. Args: loc (int): Insertion index. Must verify 0 <= loc <= len(columns). column (hashable object): Label of the inserted column. value (int, Series, or array-like): The values to insert. allow_duplicates (bool): Whether to allow duplicate column names. """ if isinstance(value, (DataFrame, pandas.DataFrame)): if len(value.columns) != 1: raise ValueError("Wrong number of items passed 2, placement implies 1") value = value.iloc[:, 0] if len(self.index) == 0: try: value = pandas.Series(value) except (TypeError, ValueError, IndexError): raise ValueError( "Cannot insert into a DataFrame with no defined index " "and a value that cannot be converted to a " "Series" ) new_index = value.index.copy() new_columns = self.columns.insert(loc, column) new_query_compiler = DataFrame( value, index=new_index, columns=new_columns )._query_compiler else: if not is_list_like(value): value = np.full(len(self.index), value) if not isinstance(value, pandas.Series) and len(value) != len(self.index): raise ValueError("Length of values does not match length of index") if not allow_duplicates and column in self.columns: raise ValueError("cannot insert {0}, already exists".format(column)) if loc > len(self.columns): raise IndexError( "index {0} is out of bounds for axis 0 with size {1}".format( loc, len(self.columns) ) ) if loc < 0: raise ValueError("unbounded slice") new_query_compiler = self._query_compiler.insert(loc, column, value) self._update_inplace(new_query_compiler=new_query_compiler) def interpolate( self, method="linear", axis=0, limit=None, inplace=False, limit_direction="forward", downcast=None, **kwargs ): return self._default_to_pandas( pandas.DataFrame.interpolate, method=method, axis=axis, limit=limit, inplace=inplace, limit_direction=limit_direction, downcast=downcast, **kwargs ) def iterrows(self): """Iterate over DataFrame rows as (index, Series) pairs. Note: Generators can't be pickled so from the remote function we expand the generator into a list before getting it. This is not that ideal. Returns: A generator that iterates over the rows of the frame. """ index_iter = iter(self.index) def iterrow_builder(df): df.columns = self.columns df.index = [next(index_iter)] return df.iterrows() partition_iterator = PartitionIterator(self._query_compiler, 0, iterrow_builder) for v in partition_iterator: yield v def items(self): """Iterator over (column name, Series) pairs. Note: Generators can't be pickled so from the remote function we expand the generator into a list before getting it. This is not that ideal. Returns: A generator that iterates over the columns of the frame. """ col_iter = iter(self.columns) def items_builder(df): df.columns = [next(col_iter)] df.index = self.index return df.items() partition_iterator = PartitionIterator(self._query_compiler, 1, items_builder) for v in partition_iterator: yield v def iteritems(self): """Iterator over (column name, Series) pairs. Note: Returns the same thing as .items() Returns: A generator that iterates over the columns of the frame. """ return self.items() def itertuples(self, index=True, name="Pandas"): """Iterate over DataFrame rows as namedtuples. Args: index (boolean, default True): If True, return the index as the first element of the tuple. name (string, default "Pandas"): The name of the returned namedtuples or None to return regular tuples. Note: Generators can't be pickled so from the remote function we expand the generator into a list before getting it. This is not that ideal. Returns: A tuple representing row data. See args for varying tuples. """ index_iter = iter(self.index) def itertuples_builder(df): df.columns = self.columns df.index = [next(index_iter)] return df.itertuples(index=index, name=name) partition_iterator = PartitionIterator( self._query_compiler, 0, itertuples_builder ) for v in partition_iterator: yield v def join(self, other, on=None, how="left", lsuffix="", rsuffix="", sort=False): """Join two or more DataFrames, or a DataFrame with a collection. Args: other: What to join this DataFrame with. on: A column name to use from the left for the join. how: What type of join to conduct. lsuffix: The suffix to add to column names that match on left. rsuffix: The suffix to add to column names that match on right. sort: Whether or not to sort. Returns: The joined DataFrame. """ if on is not None: if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.join, other, on=on, how=how, lsuffix=lsuffix, rsuffix=rsuffix, sort=sort, ) if isinstance(other, pandas.Series): if other.name is None: raise ValueError("Other Series must have a name") other = DataFrame({other.name: other}) if isinstance(other, DataFrame): # Joining the empty DataFrames with either index or columns is # fast. It gives us proper error checking for the edge cases that # would otherwise require a lot more logic. pandas.DataFrame(columns=self.columns).join( pandas.DataFrame(columns=other.columns), lsuffix=lsuffix, rsuffix=rsuffix, ).columns return DataFrame( query_compiler=self._query_compiler.join( other._query_compiler, how=how, lsuffix=lsuffix, rsuffix=rsuffix, sort=sort, ) ) else: # This constraint carried over from Pandas. if on is not None: raise ValueError( "Joining multiple DataFrames only supported for joining on index" ) # See note above about error checking with an empty join. pandas.DataFrame(columns=self.columns).join( [pandas.DataFrame(columns=obj.columns) for obj in other], lsuffix=lsuffix, rsuffix=rsuffix, ).columns return DataFrame( query_compiler=self._query_compiler.join( [obj._query_compiler for obj in other], how=how, lsuffix=lsuffix, rsuffix=rsuffix, sort=sort, ) ) def kurt(self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs): return self._default_to_pandas( pandas.DataFrame.kurt, axis=axis, skipna=skipna, level=level, numeric_only=numeric_only, **kwargs ) def kurtosis(self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs): return self._default_to_pandas( pandas.DataFrame.kurtosis, axis=axis, skipna=skipna, level=level, numeric_only=numeric_only, **kwargs ) def last(self, offset): return self._default_to_pandas(pandas.DataFrame.last, offset) def last_valid_index(self): """Return index for last non-NA/null value. Returns: scalar: type of index """ return self._query_compiler.last_valid_index() def le(self, other, axis="columns", level=None): """Checks element-wise that this is less than or equal to other. Args: other: A DataFrame or Series or scalar to compare to. axis: The axis to perform the le over. level: The Multilevel index level to apply le over. Returns: A new DataFrame filled with Booleans. """ if level is not None: if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.le, other, axis=axis, level=level ) other = self._validate_other(other, axis, comparison_dtypes_only=True) new_query_compiler = self._query_compiler.le( other=other, axis=axis, level=level ) return self._create_dataframe_from_compiler(new_query_compiler) def lookup(self, row_labels, col_labels): return self._default_to_pandas(pandas.DataFrame.lookup, row_labels, col_labels) def lt(self, other, axis="columns", level=None): """Checks element-wise that this is less than other. Args: other: A DataFrame or Series or scalar to compare to. axis: The axis to perform the lt over. level: The Multilevel index level to apply lt over. Returns: A new DataFrame filled with Booleans. """ if level is not None: if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.lt, other, axis=axis, level=level ) other = self._validate_other(other, axis, comparison_dtypes_only=True) new_query_compiler = self._query_compiler.lt( other=other, axis=axis, level=level ) return self._create_dataframe_from_compiler(new_query_compiler) def mad(self, axis=None, skipna=None, level=None): return self._default_to_pandas( pandas.DataFrame.mad, axis=axis, skipna=skipna, level=level ) def mask( self, cond, other=np.nan, inplace=False, axis=None, level=None, errors="raise", try_cast=False, raise_on_error=None, ): if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.mask, cond, other=other, inplace=inplace, axis=axis, level=level, errors=errors, try_cast=try_cast, raise_on_error=raise_on_error, ) def max(self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs): """Perform max across the DataFrame. Args: axis (int): The axis to take the max on. skipna (bool): True to skip NA values, false otherwise. Returns: The max of the DataFrame. """ axis = pandas.DataFrame()._get_axis_number(axis) if axis is not None else 0 self._validate_dtypes_min_max(axis, numeric_only) return self._query_compiler.max( axis=axis, skipna=skipna, level=level, numeric_only=numeric_only, **kwargs ) def mean(self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs): """Computes mean across the DataFrame. Args: axis (int): The axis to take the mean on. skipna (bool): True to skip NA values, false otherwise. Returns: The mean of the DataFrame. (Pandas series) """ axis = pandas.DataFrame()._get_axis_number(axis) if axis is not None else 0 self._validate_dtypes_sum_prod_mean(axis, numeric_only, ignore_axis=False) return self._query_compiler.mean( axis=axis, skipna=skipna, level=level, numeric_only=numeric_only, **kwargs ) def median(self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs): """Computes median across the DataFrame. Args: axis (int): The axis to take the median on. skipna (bool): True to skip NA values, false otherwise. Returns: The median of the DataFrame. (Pandas series) """ axis = pandas.DataFrame()._get_axis_number(axis) if axis is not None else 0 if numeric_only is not None and not numeric_only: self._validate_dtypes(numeric_only=True) return self._query_compiler.median( axis=axis, skipna=skipna, level=level, numeric_only=numeric_only, **kwargs ) def melt( self, id_vars=None, value_vars=None, var_name=None, value_name="value", col_level=None, ): return self._default_to_pandas( pandas.DataFrame.melt, id_vars=id_vars, value_vars=value_vars, var_name=var_name, value_name=value_name, col_level=col_level, ) def memory_usage(self, index=True, deep=False): """Returns the memory usage of each column in bytes Args: index (bool): Whether to include the memory usage of the DataFrame's index in returned Series. Defaults to True deep (bool): If True, introspect the data deeply by interrogating objects dtypes for system-level memory consumption. Defaults to False Returns: A Series where the index are the column names and the values are the memory usage of each of the columns in bytes. If `index=true`, then the first value of the Series will be 'Index' with its memory usage. """ result = self._query_compiler.memory_usage(index=index, deep=deep) result.index = self.columns if index: index_value = self.index.memory_usage(deep=deep) return pandas.Series(index_value, index=["Index"]).append(result) return result def merge( self, right, how="inner", on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=("_x", "_y"), copy=True, indicator=False, validate=None, ): """Database style join, where common columns in "on" are merged. Args: right: The DataFrame to merge against. how: What type of join to use. on: The common column name(s) to join on. If None, and left_on and right_on are also None, will default to all commonly named columns. left_on: The column(s) on the left to use for the join. right_on: The column(s) on the right to use for the join. left_index: Use the index from the left as the join keys. right_index: Use the index from the right as the join keys. sort: Sort the join keys lexicographically in the result. suffixes: Add this suffix to the common names not in the "on". copy: Does nothing in our implementation indicator: Adds a column named _merge to the DataFrame with metadata from the merge about each row. validate: Checks if merge is a specific type. Returns: A merged Dataframe """ if not isinstance(right, DataFrame): raise ValueError( "can not merge DataFrame with instance of type " "{}".format(type(right)) ) if left_index is False or right_index is False: if isinstance(right, DataFrame): right = right._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.merge, right, how=how, on=on, left_on=left_on, right_on=right_on, left_index=left_index, right_index=right_index, sort=sort, suffixes=suffixes, copy=copy, indicator=indicator, validate=validate, ) if left_index and right_index: return self.join( right, how=how, lsuffix=suffixes[0], rsuffix=suffixes[1], sort=sort ) def min(self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs): """Perform min across the DataFrame. Args: axis (int): The axis to take the min on. skipna (bool): True to skip NA values, false otherwise. Returns: The min of the DataFrame. """ axis = pandas.DataFrame()._get_axis_number(axis) if axis is not None else 0 self._validate_dtypes_min_max(axis, numeric_only) return self._query_compiler.min( axis=axis, skipna=skipna, level=level, numeric_only=numeric_only, **kwargs ) def mod(self, other, axis="columns", level=None, fill_value=None): """Mods this DataFrame against another DataFrame/Series/scalar. Args: other: The object to use to apply the mod against this. axis: The axis to mod over. level: The Multilevel index level to apply mod over. fill_value: The value to fill NaNs with. Returns: A new DataFrame with the Mod applied. """ if level is not None: if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.mod, other, axis=axis, level=level, fill_value=fill_value, ) other = self._validate_other(other, axis, numeric_only=True) new_query_compiler = self._query_compiler.mod( other=other, axis=axis, level=level, fill_value=fill_value ) return self._create_dataframe_from_compiler(new_query_compiler) def mode(self, axis=0, numeric_only=False): """Perform mode across the DataFrame. Args: axis (int): The axis to take the mode on. numeric_only (bool): if True, only apply to numeric columns. Returns: DataFrame: The mode of the DataFrame. """ axis = pandas.DataFrame()._get_axis_number(axis) return DataFrame( query_compiler=self._query_compiler.mode( axis=axis, numeric_only=numeric_only ) ) def mul(self, other, axis="columns", level=None, fill_value=None): """Multiplies this DataFrame against another DataFrame/Series/scalar. Args: other: The object to use to apply the multiply against this. axis: The axis to multiply over. level: The Multilevel index level to apply multiply over. fill_value: The value to fill NaNs with. Returns: A new DataFrame with the Multiply applied. """ if level is not None: if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.mul, other, axis=axis, level=level, fill_value=fill_value, ) other = self._validate_other(other, axis, numeric_only=True) new_query_compiler = self._query_compiler.mul( other=other, axis=axis, level=level, fill_value=fill_value ) return self._create_dataframe_from_compiler(new_query_compiler) def multiply(self, other, axis="columns", level=None, fill_value=None): """Synonym for mul. Args: other: The object to use to apply the multiply against this. axis: The axis to multiply over. level: The Multilevel index level to apply multiply over. fill_value: The value to fill NaNs with. Returns: A new DataFrame with the Multiply applied. """ return self.mul(other, axis, level, fill_value) def ne(self, other, axis="columns", level=None): """Checks element-wise that this is not equal to other. Args: other: A DataFrame or Series or scalar to compare to. axis: The axis to perform the ne over. level: The Multilevel index level to apply ne over. Returns: A new DataFrame filled with Booleans. """ if level is not None: if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.ne, other, axis=axis, level=level ) other = self._validate_other(other, axis) new_query_compiler = self._query_compiler.ne( other=other, axis=axis, level=level ) return self._create_dataframe_from_compiler(new_query_compiler) def nlargest(self, n, columns, keep="first"): return self._default_to_pandas(pandas.DataFrame.nlargest, n, columns, keep=keep) def notna(self): """Perform notna across the DataFrame. Returns: Boolean DataFrame where value is False if corresponding value is NaN, True otherwise """ return DataFrame(query_compiler=self._query_compiler.notna()) def notnull(self): """Perform notnull across the DataFrame. Returns: Boolean DataFrame where value is False if corresponding value is NaN, True otherwise """ return DataFrame(query_compiler=self._query_compiler.notnull()) def nsmallest(self, n, columns, keep="first"): return self._default_to_pandas( pandas.DataFrame.nsmallest, n, columns, keep=keep ) def nunique(self, axis=0, dropna=True): """Return Series with number of distinct observations over requested axis. Args: axis : {0 or 'index', 1 or 'columns'}, default 0 dropna : boolean, default True Returns: nunique : Series """ axis = pandas.DataFrame()._get_axis_number(axis) if axis is not None else 0 return self._query_compiler.nunique(axis=axis, dropna=dropna) def pct_change(self, periods=1, fill_method="pad", limit=None, freq=None, **kwargs): return self._default_to_pandas( pandas.DataFrame.pct_change, periods=periods, fill_method=fill_method, limit=limit, freq=freq, **kwargs ) def pipe(self, func, *args, **kwargs): """Apply func(self, *args, **kwargs) Args: func: function to apply to the df. args: positional arguments passed into ``func``. kwargs: a dictionary of keyword arguments passed into ``func``. Returns: object: the return type of ``func``. """ return com._pipe(self, func, *args, **kwargs) def pivot(self, index=None, columns=None, values=None): return self._default_to_pandas( pandas.DataFrame.pivot, index=index, columns=columns, values=values ) def pivot_table( self, values=None, index=None, columns=None, aggfunc="mean", fill_value=None, margins=False, dropna=True, margins_name="All", ): return self._default_to_pandas( pandas.DataFrame.pivot_table, values=values, index=index, columns=columns, aggfunc=aggfunc, fill_value=fill_value, margins=margins, dropna=dropna, margins_name=margins_name, ) @property def plot( self, x=None, y=None, kind="line", ax=None, subplots=False, sharex=None, sharey=False, layout=None, figsize=None, use_index=True, title=None, grid=None, legend=True, style=None, logx=False, logy=False, loglog=False, xticks=None, yticks=None, xlim=None, ylim=None, rot=None, fontsize=None, colormap=None, table=False, yerr=None, xerr=None, secondary_y=False, sort_columns=False, **kwargs ): return to_pandas(self).plot def pop(self, item): """Pops an item from this DataFrame and returns it. Args: item (str): Column label to be popped Returns: A Series containing the popped values. Also modifies this DataFrame. """ result = self[item] del self[item] return result def pow(self, other, axis="columns", level=None, fill_value=None): """Pow this DataFrame against another DataFrame/Series/scalar. Args: other: The object to use to apply the pow against this. axis: The axis to pow over. level: The Multilevel index level to apply pow over. fill_value: The value to fill NaNs with. Returns: A new DataFrame with the Pow applied. """ if level is not None: if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.pow, other, axis=axis, level=level, fill_value=fill_value, ) other = self._validate_other(other, axis, numeric_only=True) new_query_compiler = self._query_compiler.pow( other=other, axis=axis, level=level, fill_value=fill_value ) return self._create_dataframe_from_compiler(new_query_compiler) def prod( self, axis=None, skipna=None, level=None, numeric_only=None, min_count=1, **kwargs ): """Return the product of the values for the requested axis Args: axis : {index (0), columns (1)} skipna : boolean, default True level : int or level name, default None numeric_only : boolean, default None min_count : int, default 1 Returns: prod : Series or DataFrame (if level specified) """ axis = pandas.DataFrame()._get_axis_number(axis) if axis is not None else 0 self._validate_dtypes_sum_prod_mean(axis, numeric_only, ignore_axis=True) return self._query_compiler.prod( axis=axis, skipna=skipna, level=level, numeric_only=numeric_only, min_count=min_count, **kwargs ) def product( self, axis=None, skipna=None, level=None, numeric_only=None, min_count=1, **kwargs ): """Return the product of the values for the requested axis Args: axis : {index (0), columns (1)} skipna : boolean, default True level : int or level name, default None numeric_only : boolean, default None min_count : int, default 1 Returns: product : Series or DataFrame (if level specified) """ return self.prod( axis=axis, skipna=skipna, level=level, numeric_only=numeric_only, min_count=min_count, **kwargs ) def quantile(self, q=0.5, axis=0, numeric_only=True, interpolation="linear"): """Return values at the given quantile over requested axis, a la numpy.percentile. Args: q (float): 0 <= q <= 1, the quantile(s) to compute axis (int): 0 or 'index' for row-wise, 1 or 'columns' for column-wise interpolation: {'linear', 'lower', 'higher', 'midpoint', 'nearest'} Specifies which interpolation method to use Returns: quantiles : Series or DataFrame If q is an array, a DataFrame will be returned where the index is q, the columns are the columns of self, and the values are the quantiles. If q is a float, a Series will be returned where the index is the columns of self and the values are the quantiles. """ axis = pandas.DataFrame()._get_axis_number(axis) if axis is not None else 0 def check_dtype(t): return is_numeric_dtype(t) or is_datetime_or_timedelta_dtype(t) if not numeric_only: # If not numeric_only and columns, then check all columns are either # numeric, timestamp, or timedelta if not axis and not all(check_dtype(t) for t in self.dtypes): raise TypeError("can't multiply sequence by non-int of type 'float'") # If over rows, then make sure that all dtypes are equal for not # numeric_only elif axis: for i in range(1, len(self.dtypes)): pre_dtype = self.dtypes[i - 1] curr_dtype = self.dtypes[i] if not is_dtype_equal(pre_dtype, curr_dtype): raise TypeError( "Cannot compare type '{0}' with type '{1}'".format( pre_dtype, curr_dtype ) ) else: # Normally pandas returns this near the end of the quantile, but we # can't afford the overhead of running the entire operation before # we error. if not any(is_numeric_dtype(t) for t in self.dtypes): raise ValueError("need at least one array to concatenate") # check that all qs are between 0 and 1 pandas.DataFrame()._check_percentile(q) axis = pandas.DataFrame()._get_axis_number(axis) if isinstance(q, (pandas.Series, np.ndarray, pandas.Index, list)): return DataFrame( query_compiler=self._query_compiler.quantile_for_list_of_values( q=q, axis=axis, numeric_only=numeric_only, interpolation=interpolation, ) ) else: return self._query_compiler.quantile_for_single_value( q=q, axis=axis, numeric_only=numeric_only, interpolation=interpolation ) def query(self, expr, inplace=False, **kwargs): """Queries the Dataframe with a boolean expression Returns: A new DataFrame if inplace=False """ ErrorMessage.non_verified_udf() self._validate_eval_query(expr, **kwargs) inplace = validate_bool_kwarg(inplace, "inplace") new_query_compiler = self._query_compiler.query(expr, **kwargs) return self._create_dataframe_from_compiler(new_query_compiler, inplace) def radd(self, other, axis="columns", level=None, fill_value=None): return self.add(other, axis, level, fill_value) def rank( self, axis=0, method="average", numeric_only=None, na_option="keep", ascending=True, pct=False, ): """ Compute numerical data ranks (1 through n) along axis. Equal values are assigned a rank that is the [method] of the ranks of those values. Args: axis (int): 0 or 'index' for row-wise, 1 or 'columns' for column-wise method: {'average', 'min', 'max', 'first', 'dense'} Specifies which method to use for equal vals numeric_only (boolean) Include only float, int, boolean data. na_option: {'keep', 'top', 'bottom'} Specifies how to handle NA options ascending (boolean): Decedes ranking order pct (boolean): Computes percentage ranking of data Returns: A new DataFrame """ axis = pandas.DataFrame()._get_axis_number(axis) return DataFrame( query_compiler=self._query_compiler.rank( axis=axis, method=method, numeric_only=numeric_only, na_option=na_option, ascending=ascending, pct=pct, ) ) def rdiv(self, other, axis="columns", level=None, fill_value=None): """Div this DataFrame against another DataFrame/Series/scalar. Args: other: The object to use to apply the div against this. axis: The axis to div over. level: The Multilevel index level to apply div over. fill_value: The value to fill NaNs with. Returns: A new DataFrame with the rdiv applied. """ if level is not None: if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.rdiv, other, axis=axis, level=level, fill_value=fill_value, ) other = self._validate_other(other, axis, numeric_only=True) new_query_compiler = self._query_compiler.rdiv( other=other, axis=axis, level=level, fill_value=fill_value ) return self._create_dataframe_from_compiler(new_query_compiler) def reindex( self, labels=None, index=None, columns=None, axis=None, method=None, copy=True, level=None, fill_value=np.nan, limit=None, tolerance=None, ): if level is not None: return self._default_to_pandas( pandas.DataFrame.reindex, labels=labels, index=index, columns=columns, axis=axis, method=method, copy=copy, level=level, fill_value=fill_value, limit=limit, tolerance=tolerance, ) axis = pandas.DataFrame()._get_axis_number(axis) if axis is not None else 0 if axis == 0 and labels is not None: index = labels elif labels is not None: columns = labels if index is not None: new_query_compiler = self._query_compiler.reindex( 0, index, method=method, fill_value=fill_value, limit=limit, tolerance=tolerance, ) else: new_query_compiler = self._query_compiler if columns is not None: final_query_compiler = new_query_compiler.reindex( 1, columns, method=method, fill_value=fill_value, limit=limit, tolerance=tolerance, ) else: final_query_compiler = new_query_compiler return self._create_dataframe_from_compiler(final_query_compiler, not copy) def reindex_axis( self, labels, axis=0, method=None, level=None, copy=True, limit=None, fill_value=np.nan, ): return self._default_to_pandas( pandas.DataFrame.reindex_axis, labels, axis=axis, method=method, level=level, copy=copy, limit=limit, fill_value=fill_value, ) def reindex_like(self, other, method=None, copy=True, limit=None, tolerance=None): if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.reindex_like, other, method=method, copy=copy, limit=limit, tolerance=tolerance, ) def rename( self, mapper=None, index=None, columns=None, axis=None, copy=True, inplace=False, level=None, ): """Alters axes labels. Args: mapper, index, columns: Transformations to apply to the axis's values. axis: Axis to target with mapper. copy: Also copy underlying data. inplace: Whether to return a new DataFrame. level: Only rename a specific level of a MultiIndex. Returns: If inplace is False, a new DataFrame with the updated axes. """ inplace = validate_bool_kwarg(inplace, "inplace") # We have to do this with the args because of how rename handles # kwargs. It doesn't ignore None values passed in, so we have to filter # them ourselves. args = locals() kwargs = {k: v for k, v in args.items() if v is not None and k != "self"} # inplace should always be true because this is just a copy, and we # will use the results after. kwargs["inplace"] = True df_to_rename = pandas.DataFrame(index=self.index, columns=self.columns) df_to_rename.rename(**kwargs) if inplace: obj = self else: obj = self.copy() obj.index = df_to_rename.index obj.columns = df_to_rename.columns if not inplace: return obj def rename_axis(self, mapper, axis=0, copy=True, inplace=False): axes_is_columns = axis == 1 or axis == "columns" renamed = self if inplace else self.copy() if axes_is_columns: renamed.columns.name = mapper else: renamed.index.name = mapper if not inplace: return renamed def _set_axis_name(self, name, axis=0, inplace=False): """Alter the name or names of the axis. Args: name: Name for the Index, or list of names for the MultiIndex axis: 0 or 'index' for the index; 1 or 'columns' for the columns inplace: Whether to modify `self` directly or return a copy Returns: Type of caller or None if inplace=True. """ axes_is_columns = axis == 1 or axis == "columns" renamed = self if inplace else self.copy() if axes_is_columns: renamed.columns.set_names(name) else: renamed.index.set_names(name) if not inplace: return renamed def reorder_levels(self, order, axis=0): return self._default_to_pandas( pandas.DataFrame.reorder_levels, order, axis=axis ) def replace( self, to_replace=None, value=None, inplace=False, limit=None, regex=False, method="pad", ): return self._default_to_pandas( pandas.DataFrame.replace, to_replace=to_replace, value=value, inplace=inplace, limit=limit, regex=regex, method=method, ) def resample( self, rule, how=None, axis=0, fill_method=None, closed=None, label=None, convention="start", kind=None, loffset=None, limit=None, base=0, on=None, level=None, ): return self._default_to_pandas( pandas.DataFrame.resample, rule, how=how, axis=axis, fill_method=fill_method, closed=closed, label=label, convention=convention, kind=kind, loffset=loffset, limit=limit, base=base, on=on, level=level, ) def reset_index( self, level=None, drop=False, inplace=False, col_level=0, col_fill="" ): """Reset this index to default and create column from current index. Args: level: Only remove the given levels from the index. Removes all levels by default drop: Do not try to insert index into DataFrame columns. This resets the index to the default integer index. inplace: Modify the DataFrame in place (do not create a new object) col_level : If the columns have multiple levels, determines which level the labels are inserted into. By default it is inserted into the first level. col_fill: If the columns have multiple levels, determines how the other levels are named. If None then the index name is repeated. Returns: A new DataFrame if inplace is False, None otherwise. """ inplace = validate_bool_kwarg(inplace, "inplace") # TODO Implement level if level is not None: new_query_compiler = self._default_to_pandas( pandas.DataFrame.reset_index, level=level, drop=drop, inplace=inplace, col_level=col_level, col_fill=col_fill, ) return self._create_dataframe_from_compiler(new_query_compiler, inplace) # Error checking for matching Pandas. Pandas does not allow you to # insert a dropped index into a DataFrame if these columns already # exist. if ( not drop and not isinstance(self.index, pandas.MultiIndex) and all(n in self.columns for n in ["level_0", "index"]) ): raise ValueError("cannot insert level_0, already exists") new_query_compiler = self._query_compiler.reset_index(drop=drop, level=level) return self._create_dataframe_from_compiler(new_query_compiler, inplace) def rfloordiv(self, other, axis="columns", level=None, fill_value=None): if level is not None: if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.rfloordiv, other, axis=axis, level=level, fill_value=fill_value, ) other = self._validate_other(other, axis, numeric_only=True) new_query_compiler = self._query_compiler.rfloordiv( other=other, axis=axis, level=level, fill_value=fill_value ) return self._create_dataframe_from_compiler(new_query_compiler) def rmod(self, other, axis="columns", level=None, fill_value=None): """Mod this DataFrame against another DataFrame/Series/scalar. Args: other: The object to use to apply the div against this. axis: The axis to div over. level: The Multilevel index level to apply div over. fill_value: The value to fill NaNs with. Returns: A new DataFrame with the rdiv applied. """ if level is not None: if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.rmod, other, axis=axis, level=level, fill_value=fill_value, ) other = self._validate_other(other, axis, numeric_only=True) new_query_compiler = self._query_compiler.rmod( other=other, axis=axis, level=level, fill_value=fill_value ) return self._create_dataframe_from_compiler(new_query_compiler) def rmul(self, other, axis="columns", level=None, fill_value=None): return self.mul(other, axis, level, fill_value) def rolling( self, window, min_periods=None, freq=None, center=False, win_type=None, on=None, axis=0, closed=None, ): return self._default_to_pandas( pandas.DataFrame.rolling, window, min_periods=min_periods, freq=freq, center=center, win_type=win_type, on=on, axis=axis, closed=closed, ) def round(self, decimals=0, *args, **kwargs): """Round each element in the DataFrame. Args: decimals: The number of decimals to round to. Returns: A new DataFrame. """ return DataFrame( query_compiler=self._query_compiler.round(decimals=decimals, **kwargs) ) def rpow(self, other, axis="columns", level=None, fill_value=None): """Pow this DataFrame against another DataFrame/Series/scalar. Args: other: The object to use to apply the pow against this. axis: The axis to pow over. level: The Multilevel index level to apply pow over. fill_value: The value to fill NaNs with. Returns: A new DataFrame with the Pow applied. """ if level is not None: if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.rpow, other, axis=axis, level=level, fill_value=fill_value, ) other = self._validate_other(other, axis, numeric_only=True) # Check to make sure integers are not raised to negative integer powers if ( is_integer_dtype(type(other)) and other < 0 and all(is_integer_dtype(t) for t in self.dtypes) ): raise ValueError("Integers to negative integer powers are not allowed.") new_query_compiler = self._query_compiler.rpow( other=other, axis=axis, level=level, fill_value=fill_value ) return self._create_dataframe_from_compiler(new_query_compiler) def rsub(self, other, axis="columns", level=None, fill_value=None): """Subtract a DataFrame/Series/scalar from this DataFrame. Args: other: The object to use to apply the subtraction to this. axis: The axis to apply the subtraction over. level: Mutlilevel index level to subtract over. fill_value: The value to fill NaNs with. Returns: A new DataFrame with the subtraciont applied. """ axis = pandas.DataFrame()._get_axis_number(axis) if level is not None: if isinstance(other, DataFrame): other = other._query_compiler.to_pandas() return self._default_to_pandas( pandas.DataFrame.rsub, other, axis=axis, level=level, fill_value=fill_value, ) other = self._validate_other(other, axis, numeric_or_time_only=True) new_query_compiler = self._query_compiler.rsub( other=other, axis=axis, level=level, fill_value=fill_value ) return self._create_dataframe_from_compiler(new_query_compiler) def rtruediv(self, other, axis="columns", level=None, fill_value=None): return self.truediv(other, axis, level, fill_value) def sample( self, n=None, frac=None, replace=False, weights=None, random_state=None, axis=None, ): """Returns a random sample of items from an axis of object. Args: n: Number of items from axis to return. Cannot be used with frac. Default = 1 if frac = None. frac: Fraction of axis items to return. Cannot be used with n. replace: Sample with or without replacement. Default = False. weights: Default 'None' results in equal probability weighting. If passed a Series, will align with target object on index. Index values in weights not found in sampled object will be ignored and index values in sampled object not in weights will be assigned weights of zero. If called on a DataFrame, will accept the name of a column when axis = 0. Unless weights are a Series, weights must be same length as axis being sampled. If weights do not sum to 1, they will be normalized to sum to 1. Missing values in the weights column will be treated as zero. inf and -inf values not allowed. random_state: Seed for the random number generator (if int), or numpy RandomState object. axis: Axis to sample. Accepts axis number or name. Returns: A new Dataframe """ axis = pandas.DataFrame()._get_axis_number(axis) if axis is not None else 0 if axis: axis_labels = self.columns axis_length = len(axis_labels) else: # Getting rows requires indices instead of labels. RangeIndex provides this. axis_labels = pandas.RangeIndex(len(self.index)) axis_length = len(axis_labels) if weights is not None: # Index of the weights Series should correspond to the index of the # Dataframe in order to sample if isinstance(weights, pandas.Series): weights = weights.reindex(self.axes[axis]) # If weights arg is a string, the weights used for sampling will # the be values in the column corresponding to that string if isinstance(weights, string_types): if axis == 0: try: weights = self[weights] except KeyError: raise KeyError("String passed to weights not a valid column") else: raise ValueError( "Strings can only be passed to " "weights when sampling from rows on " "a DataFrame" ) weights =
pandas.Series(weights, dtype="float64")
pandas.Series
import pytest import numpy as np import pandas as pd from endaq.calc import rotation @pytest.mark.parametrize( 'quat, euler', [ ((0., 0., 0., 1.), (0., 0., 0.)), ((0., 0., 0., -1.), (0., 0., 0.)), ((1., 0., 0., 0.), (np.pi, 0., 0.)), ((0., 1., 0., 0.), (np.pi, 0., np.pi)), ((0., 0., 1., 0.), (0., 0., np.pi)), ] ) def test_quat_to_euler_data(quat, euler): df = pd.DataFrame([quat], index=[0], columns=['X', 'Y', 'Z', 'W']) target =
pd.DataFrame([euler], index=[0], columns=['x', 'y', 'z'])
pandas.DataFrame
# data_functions.py #!/usr/bin/env ml # coding: utf-8 # Import libraries import logging import pandas as pd import numpy as np from pathlib import Path import argparse import gc from scipy import stats # REDUCE MEMORY USAGE def reduce_mem_usage(df, verbose=False): start_mem = df.memory_usage().sum() / 1024 ** 2 int_columns = df.select_dtypes(include=["int"]).columns float_columns = df.select_dtypes(include=["float"]).columns for col in int_columns: df[col] = pd.to_numeric(df[col], downcast="integer") for col in float_columns: df[col] = pd.to_numeric(df[col], downcast="float") end_mem = df.memory_usage().sum() / 1024 ** 2 if verbose: print( "Mem. usage decreased to {:5.2f} Mb ({:.1f}% reduction)".format( end_mem, 100 * (start_mem - end_mem) / start_mem ) ) return df # LOAD DATASET def load_data(file_path, kind='csv'): data =
pd.DataFrame([])
pandas.DataFrame
from collections import OrderedDict import pandas as pd import torch from torch import nn from torch.autograd import Variable def get_names_dict(model): """ Recursive walk over modules to get names including path. """ names = {} def _get_names(module, parent_name=''): for key, module in module.named_children(): name = parent_name + '.' + key if parent_name else key names[name] = module if isinstance(module, torch.nn.Module): _get_names(module, parent_name=name) _get_names(model) return names def summarize_model(model, input_size, return_meta=False): """Summarizes torch model by showing trainable parameters and weights. Parameters: ---------- model : {nn.Module} The model to summarize. input_size : {tuple} The dimensions of the model input not including batch size. return_meta : {bool}, optional Whether or not to return some additional meta data of the model compute from the summary (the default is False). Returns ------- pd.DataFrame The model summary as a Pandas data frame. --------- Example: import torchvision.models as models model = models.alexnet() df = summarize_model(model=model, input_size=(3, 224, 224)) print(df) name class_name input_shape output_shape n_parameters 1 features=>0 Conv2d (-1, 3, 224, 224) (-1, 64, 55, 55) 23296 2 features=>1 ReLU (-1, 64, 55, 55) (-1, 64, 55, 55) 0 ... """ def get_settings(m): c = m.__class__ s = {} # Linear layers if c is [nn.Linear, nn.Bilinear]: s = '-' # Convolutional layers if c in [nn.Conv1d, nn.Conv2d, nn.Conv3d]: s = {'stride': m.stride, 'padding': m.padding} if c in [nn.ConvTranspose1d, nn.ConvTranspose2d, nn.ConvTranspose3d]: s = {'stride': m.stride, 'padding': m.padding, 'output_padding': m.output_padding} # Pooling layers if c in [nn.MaxPool1d, nn.MaxPool2d, nn.MaxPool3d]: s = {'kernel_size': m.kernel_size, 'stride': m.stride, 'padding': m.padding, 'dilation': m.dilation} #, 'ceil_mode'=False} if c in [nn.MaxUnpool1d, nn.MaxUnpool2d, nn.MaxUnpool3d]: s = {'kernel_size': m.kernel_size, 'stride': m.stride, 'padding': m.padding} if c in [nn.AvgPool1d, nn.AvgPool2d, nn.AvgPool3d]: s = {'kernel_size': m.kernel_size, 'stride': m.stride, 'padding': m.padding, 'count_include_pad': m.count_include_pad} # Padding layers if c in [nn.ReflectionPad1d, nn.ReflectionPad2d, nn.ReplicationPad1d, nn.ReplicationPad2d, nn.ReplicationPad3d, nn.ZeroPad2d, nn.ConstantPad1d, nn.ConstantPad2d, nn.ConstantPad3d]: s = {'padding': m.padding} if c in [nn.ConstantPad1d, nn.ConstantPad2d, nn.ConstantPad3d]: s['value'] = m.value # Recurrent layers if c in [nn.RNN, nn.LSTM, nn.GRU, nn.RNNCell, nn.LSTMCell, nn.GRUCell]: s = {'input_size': m.input_size, 'hidden_size': m.hidden_size, 'num_layers': m.num_layers, 'nonlinearity': m.nonlinearity, 'dropout': m.dropout, 'bidirectional': m.bidirectional, 'batch_first': m.batch_first} # Dropout layers if c in [nn.Dropout, nn.Dropout2d, nn.Dropout3d]: s = {'p': m.p} # Normalization layers if c in [nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d]: s = {'momentum': m.momentum, 'affine': m.affine} # Activation functions if c in [nn.ELU]: s = {'alpha': c.alpha} if c in [nn.Softplus]: s = {'beta': c.beta, 'threshold': c.threshold} # Embedding layers s = s if len(s) > 0 else '-' return s def register_hook(module): # Define hook def hook(module, input, output): name = '' for key, item in names.items(): if item == module: name = key # Get class name and set module index class_name = str(module.__class__).split('.')[-1].split("'")[0] module_idx = len(summary) m_key = module_idx + 1 # Prepare summary entry for this module summary[m_key] = OrderedDict() summary[m_key]['name'] = name summary[m_key]['class_name'] = class_name # Input and output shape summary[m_key]['input_shape'] = (-1, ) + tuple(input[0].size())[1:] summary[m_key]['output_shape'] = (-1, ) + tuple(output.size())[1:] # Weight dimensions summary[m_key]['weight_shapes'] = list([tuple(p.size()) for p in module.parameters()]) # Number of parameters in layers summary[m_key]['n_parameters'] = sum([torch.LongTensor(list(p.size())).prod().item() for p in module.parameters()]) summary[m_key]['n_trainable'] = sum([torch.LongTensor(list(p.size())).prod().item() for p in module.parameters() if p.requires_grad]) # Get special settings for layers summary[m_key]['settings'] = get_settings(module) # Append if not isinstance(module, nn.Sequential) and not isinstance(module, nn.ModuleList) and not (module == model): hooks.append(module.register_forward_hook(hook)) # Put model in evaluation mode (required for some modules {BN, DO, etc.}) was_training = model.training if model.training: model.eval() # Names are stored in parent and path+name is unique not the name names = get_names_dict(model) # Check if there are multiple inputs to the network if isinstance(input_size[0], (list, tuple)): x = [Variable(torch.rand(1, *in_size)) for in_size in input_size] else: x = Variable(torch.rand(1, *input_size)) # Move parameters to CUDA if relevant if next(model.parameters()).is_cuda: x = x.cuda() # Create properties summary = OrderedDict() hooks = [] # Register hook on all modules of model model.apply(register_hook) # Make a forward pass to evaluate registered hook functions # and build summary model(x) # Remove all the registered hooks from the model again and # return it in the state it was given. for h in hooks: h.remove() # If the model was in training mode, put it back into training mode if was_training: model.train() # Make dataframe df_summary = pd.DataFrame.from_dict(summary, orient='index') # Create additional info if return_meta: meta = {'total_parameters': df_summary.n_parameters.sum(), 'total_trainable': df_summary.n_trainable.sum(), 'layers': df_summary.shape[0], 'trainable_layers': (df_summary.n_trainable != 0).sum()} df_meta = pd.DataFrame.from_dict(meta, orient='index') return df_summary, df_meta else: return df_summary if __name__ == '__main__': import torchvision.models as models
pd.set_option('display.max_colwidth', -1)
pandas.set_option
import numpy as np import pandas as pd import uuid METHODS = [ 'add', 'sub', 'mul', 'floordiv', 'div', 'truediv', 'mod', 'divmod', 'pow', 'lshift', 'rshift', 'and', 'or', 'xor' ] _df =
pd.DataFrame()
pandas.DataFrame
from __future__ import unicode_literals import es_core_news_sm import tweepy import numpy import argparse import collections import datetime import re import json import sys import os import spacy import nltk import glob import operator import time import itertools import numpy as np import pandas as pd from nltk.corpus import stopwords from transformers import pipeline from ascii_graph import Pyasciigraph from ascii_graph.colors import Gre, Yel, Red from ascii_graph.colordata import hcolor from spacy.lang.es.examples import sentences from multiprocessing import Process from tqdm import tqdm from functools import partial #from watson_developer_cloud import VisualRecognitionV3 from subject_classification_spanish import subject_classifier from spellchecker import SpellChecker cats_classifier = subject_classifier.SubjectClassifier() #visual_recognition = VisualRecognitionV3( # '2018-03-19', # iam_apikey='-') nlp_ = es_core_news_sm.load() stopwords_ = set(stopwords.words('spanish')) repl = partial(re.sub, '( |\n|\t)+', ' ') leet_alph = {'0':'o', '1':'i', '3':'e', '5':'s', '4':'a', '7':'t', '8': 'b'} regex = "/*[a-zA-ZñÑ$]*[0134578$][a-zA-ZñÑ]*" regex2 = "https://t.co/\w*" regex3 = "@[a-zA-Z0-9]*" regex4 = "#[a-zA-Z0-9]*" spell = SpellChecker(language='es') #prog_ = re.compile("(@[A-Za-z0-9]+)|([^0-9A-Za-z' \t])|(\w+:\/\/\S+)") #prog2_ = re.compile(" +") #hashtags_ = re.compile("#(\w+)") #regex_mentions_ = re.compile("@(\w+)") #urls_ = re.compile("http(s)?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+") regex_bad_words_ = re.compile("(" + "|".join(pd.concat([
pd.read_csv(f)
pandas.read_csv
#https://bit.ly/2NyxdAG from bs4 import BeautifulSoup import requests import pandas as pd url = 'https://www.imdb.com/search/title/?title_type=feature&primary_language=te&sort=num_votes,desc&view=advanced&start=%s' movies = [] start = 1 index = 1 def add_movies_from_url(url): global movies, start, index response = requests.get(url) soup = BeautifulSoup(response.text, 'lxml') movies_list = soup.find("div", class_="lister-list") movies_list = movies_list.find_all("div", class_="lister-item-content") for movie in movies_list: name, director, actors, popularity, year, rating = None, None, [], None, None, None try: popularity = index try: year = movie.find_all('span')[1].text[1:-1] except: pass try: rating = movie.find('strong').text except: pass try: name = movie.find('a').text except: pass try: people = movie.find_all('p')[2].find_all('a') except: pass try: director = people[0].text except: pass actors = [person.text for person in people[1:]] if len(people)>1 else [] except Exception as e: print('Failed for - ', index, name) movies.append([popularity, year, rating, name, director, actors]) index+=1 print('Done for the url - ', url) for i in range(100): add_movies_from_url(url%start) start+=50 columns = ["popularity", "year", "rating", "name", "director", "actors"] df =
pd.DataFrame(movies, columns=columns)
pandas.DataFrame
from datetime import datetime, timedelta, date import pandas as pd import time import matplotlib.pyplot as plt import numpy as np from scipy.stats import linregress import os.path from tiingo import TiingoClient import sys import urllib.request as request import csv #from urllib.parse import urlencode #%matplotlib inline #plt.rcParams["figure.figsize"] = (10, 6) # (w, h) #plt.ioff() #import pandas_datareader.data as web #from pandas_datareader import data, wb #import pandas.io.data as web1 # Package and modules for importing data; this code may change depending on pandas version #import requests #from bs4 import BeautifulSoup #import json #import re def tiingo_data(ticker, start, end): config = {} # To reuse the same HTTP Session across API calls (and have better performance), include a session key. config['session'] = True # Obtain Tiingo API Key myFile = open("/Users/brittanythomas/PycharmProjects/SystemTraderV2/tiingoAPIkey.txt", "r") myAPIkey = myFile.readline() myFile.close() config['api_key'] = myAPIkey # Initialize client = TiingoClient(config) try: print('Trying to pull Tiingo data for '+ticker) df = client.get_dataframe(ticker, startDate=start, endDate=end, frequency='daily') except: print("Unexpected error:", sys.exc_info()[0]) time.sleep(1) try: print('AGAIN - Trying to pull Tiingo data for ' + ticker) df = client.get_dataframe(ticker, startDate=start, endDate=end, frequency='daily') except: print('Could not pull Tiingo data for ' + ticker) print("Unexpected error:", sys.exc_info()[0]) return None return df def momentum(closes): returns = np.log(closes) x = np.arange(len(returns)) slope, _, rvalue, _, _ = linregress(x, returns) return ((1 + slope) ** 252) * (rvalue ** 2) # annualize slope and multiply by R^2 def main(): #Define system file path for where you have stored the constituents.csv and WIKI_PRICES.csv sysFiles1 = '/Users/brittanythomas/PycharmProjects/SystemTraderV2/' #Define system file path where momentum results should be stored sysFiles2='/Users/brittanythomas/Library/Application Support/JetBrains/PyCharmCE2020.1/scratches/datas/' #Open a txt file to save troubleshooting data as necessary troubleshootFile1 = open(sysFiles1+'troubleshooting.txt','w+') troubleshootFile1.write('test'+'\n') skiped =[] mydateparser = lambda x: datetime.strptime(x, "%Y-%m-%d") constituents = pd.read_csv(sysFiles1 + 'constituents.csv', header=0, names=['date_column', 'tickers'], parse_dates=['date_column'], date_parser=mydateparser) #create a list of constituents from constituent.csv dataframe conList = set([a for b in constituents.tickers.str.strip('[]').str.split(',') for a in b]) conList = [s.replace("'",'') for s in conList] #remove quotes from strings in list conList = [s.strip() for s in conList] conList = list(dict.fromkeys(conList)) #remove duplicates by converting conList into a dictionary and then back again conList = sorted(conList) #sort conList alphabetically start = "2015-10-01" end = "2020-09-01" momentums = pd.DataFrame(columns=['ticker','momentum']) i=0 for ticker in conList: if os.path.isfile(sysFiles2 + ticker + '.csv'): try: print(ticker + ' momentum exists - Adding to dictionary') df =
pd.read_csv(sysFiles2+ticker+'.csv',header='infer', sep=' ')
pandas.read_csv
import numpy as np import pytest from pandas.compat import range, u, zip import pandas as pd from pandas import DataFrame, Index, MultiIndex, Series import pandas.core.common as com from pandas.core.indexing import IndexingError from pandas.util import testing as tm @pytest.fixture def frame_random_data_integer_multi_index(): levels = [[0, 1], [0, 1, 2]] codes = [[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]] index = MultiIndex(levels=levels, codes=codes) return DataFrame(np.random.randn(6, 2), index=index) @pytest.fixture def dataframe_with_duplicate_index(): """Fixture for DataFrame used in tests for gh-4145 and gh-4146""" data = [['a', 'd', 'e', 'c', 'f', 'b'], [1, 4, 5, 3, 6, 2], [1, 4, 5, 3, 6, 2]] index = ['h1', 'h3', 'h5'] columns = MultiIndex( levels=[['A', 'B'], ['A1', 'A2', 'B1', 'B2']], codes=[[0, 0, 0, 1, 1, 1], [0, 3, 3, 0, 1, 2]], names=['main', 'sub']) return DataFrame(data, index=index, columns=columns) @pytest.mark.parametrize('access_method', [lambda s, x: s[:, x], lambda s, x: s.loc[:, x], lambda s, x: s.xs(x, level=1)]) @pytest.mark.parametrize('level1_value, expected', [ (0, Series([1], index=[0])), (1, Series([2, 3], index=[1, 2])) ]) def test_series_getitem_multiindex(access_method, level1_value, expected): # GH 6018 # series regression getitem with a multi-index s = Series([1, 2, 3]) s.index = MultiIndex.from_tuples([(0, 0), (1, 1), (2, 1)]) result = access_method(s, level1_value) tm.assert_series_equal(result, expected) @pytest.mark.parametrize('level0_value', ['D', 'A']) def test_getitem_duplicates_multiindex(level0_value): # GH 5725 the 'A' happens to be a valid Timestamp so the doesn't raise # the appropriate error, only in PY3 of course! index = MultiIndex(levels=[[level0_value, 'B', 'C'], [0, 26, 27, 37, 57, 67, 75, 82]], codes=[[0, 0, 0, 1, 2, 2, 2, 2, 2, 2], [1, 3, 4, 6, 0, 2, 2, 3, 5, 7]], names=['tag', 'day']) arr = np.random.randn(len(index), 1) df = DataFrame(arr, index=index, columns=['val']) # confirm indexing on missing value raises KeyError if level0_value != 'A': msg = "'A'" with pytest.raises(KeyError, match=msg): df.val['A'] msg = "'X'" with pytest.raises(KeyError, match=msg): df.val['X'] result = df.val[level0_value] expected = Series(arr.ravel()[0:3], name='val', index=Index( [26, 37, 57], name='day')) tm.assert_series_equal(result, expected) @pytest.mark.parametrize('indexer, is_level1, expected_error', [ ([], False, None), # empty ok (['A'], False, None), (['A', 'D'], False, None), (['D'], False, r"\['D'\] not in index"), # not any values found (pd.IndexSlice[:, ['foo']], True, None), (pd.IndexSlice[:, ['foo', 'bah']], True, None) ]) def test_getitem_duplicates_multiindex_missing_indexers(indexer, is_level1, expected_error): # GH 7866 # multi-index slicing with missing indexers idx = MultiIndex.from_product([['A', 'B', 'C'], ['foo', 'bar', 'baz']], names=['one', 'two']) s = Series(np.arange(9, dtype='int64'), index=idx).sort_index() if indexer == []: expected = s.iloc[[]] elif is_level1: expected = Series([0, 3, 6], index=MultiIndex.from_product( [['A', 'B', 'C'], ['foo']], names=['one', 'two'])).sort_index() else: exp_idx = MultiIndex.from_product([['A'], ['foo', 'bar', 'baz']], names=['one', 'two']) expected = Series(np.arange(3, dtype='int64'), index=exp_idx).sort_index() if expected_error is not None: with pytest.raises(KeyError, match=expected_error): s.loc[indexer] else: result = s.loc[indexer] tm.assert_series_equal(result, expected) @pytest.mark.parametrize('columns_indexer', [ ([], slice(None)), (['foo'], []) ]) def test_getitem_duplicates_multiindex_empty_indexer(columns_indexer): # GH 8737 # empty indexer multi_index = MultiIndex.from_product((['foo', 'bar', 'baz'], ['alpha', 'beta'])) df = DataFrame(np.random.randn(5, 6), index=range(5), columns=multi_index) df = df.sort_index(level=0, axis=1) expected = DataFrame(index=range(5), columns=multi_index.reindex([])[0]) result = df.loc[:, columns_indexer] tm.assert_frame_equal(result, expected) def test_getitem_duplicates_multiindex_non_scalar_type_object(): # regression from < 0.14.0 # GH 7914 df = DataFrame([[np.mean, np.median], ['mean', 'median']], columns=MultiIndex.from_tuples([('functs', 'mean'), ('functs', 'median')]), index=['function', 'name']) result = df.loc['function', ('functs', 'mean')] expected = np.mean assert result == expected def test_getitem_simple(multiindex_dataframe_random_data): df = multiindex_dataframe_random_data.T expected = df.values[:, 0] result = df['foo', 'one'].values tm.assert_almost_equal(result, expected) @pytest.mark.parametrize('indexer,msg', [ (lambda df: df[('foo', 'four')], r"\('foo', 'four'\)"), (lambda df: df['foobar'], "'foobar'") ]) def test_getitem_simple_key_error( multiindex_dataframe_random_data, indexer, msg): df = multiindex_dataframe_random_data.T with pytest.raises(KeyError, match=msg): indexer(df) @pytest.mark.parametrize('indexer', [ lambda s: s[2000, 3], lambda s: s.loc[2000, 3] ]) def test_series_getitem( multiindex_year_month_day_dataframe_random_data, indexer): s = multiindex_year_month_day_dataframe_random_data['A'] expected = s.reindex(s.index[42:65]) expected.index = expected.index.droplevel(0).droplevel(0) result = indexer(s) tm.assert_series_equal(result, expected) @pytest.mark.parametrize('indexer', [ lambda s: s[2000, 3, 10], lambda s: s.loc[2000, 3, 10] ]) def test_series_getitem_returns_scalar( multiindex_year_month_day_dataframe_random_data, indexer): s = multiindex_year_month_day_dataframe_random_data['A'] expected = s.iloc[49] result = indexer(s) assert result == expected @pytest.mark.filterwarnings("ignore:\\n.ix:DeprecationWarning") @pytest.mark.parametrize('indexer', [ lambda s: s.loc[[(2000, 3, 10), (2000, 3, 13)]], lambda s: s.ix[[(2000, 3, 10), (2000, 3, 13)]] ]) def test_series_getitem_fancy( multiindex_year_month_day_dataframe_random_data, indexer): s = multiindex_year_month_day_dataframe_random_data['A'] expected = s.reindex(s.index[49:51]) result = indexer(s) tm.assert_series_equal(result, expected) @pytest.mark.parametrize('indexer,error,msg', [ (lambda s: s.__getitem__((2000, 3, 4)), KeyError, '356'), (lambda s: s[(2000, 3, 4)], KeyError, '356'), (lambda s: s.loc[(2000, 3, 4)], IndexingError, 'Too many indexers'), (lambda s: s.__getitem__(len(s)), IndexError, 'index out of bounds'), (lambda s: s[len(s)], IndexError, 'index out of bounds'), (lambda s: s.iloc[len(s)], IndexError, 'single positional indexer is out-of-bounds') ]) def test_series_getitem_indexing_errors( multiindex_year_month_day_dataframe_random_data, indexer, error, msg): s = multiindex_year_month_day_dataframe_random_data['A'] with pytest.raises(error, match=msg): indexer(s) def test_series_getitem_corner_generator( multiindex_year_month_day_dataframe_random_data): s = multiindex_year_month_day_dataframe_random_data['A'] result = s[(x > 0 for x in s)] expected = s[s > 0] tm.assert_series_equal(result, expected) def test_frame_getitem_multicolumn_empty_level(): df = DataFrame({'a': ['1', '2', '3'], 'b': ['2', '3', '4']}) df.columns = [['level1 item1', 'level1 item2'], ['', 'level2 item2'], ['level3 item1', 'level3 item2']] result = df['level1 item1'] expected = DataFrame([['1'], ['2'], ['3']], index=df.index, columns=['level3 item1']) tm.assert_frame_equal(result, expected) def test_getitem_tuple_plus_slice(): # GH 671 df = DataFrame({'a': np.arange(10), 'b': np.arange(10), 'c': np.random.randn(10), 'd': np.random.randn(10)} ).set_index(['a', 'b']) expected = df.loc[0, 0] result = df.loc[(0, 0), :] tm.assert_series_equal(result, expected) @pytest.mark.parametrize('indexer,expected_slice', [ (lambda df: df['foo'], slice(3)), (lambda df: df['bar'], slice(3, 5)), (lambda df: df.loc[:, 'bar'], slice(3, 5)) ]) def test_getitem_toplevel( multiindex_dataframe_random_data, indexer, expected_slice): df = multiindex_dataframe_random_data.T expected = df.reindex(columns=df.columns[expected_slice]) expected.columns = expected.columns.droplevel(0) result = indexer(df) tm.assert_frame_equal(result, expected) def test_getitem_int(frame_random_data_integer_multi_index): df = frame_random_data_integer_multi_index result = df.loc[1] expected = df[-3:] expected.index = expected.index.droplevel(0) tm.assert_frame_equal(result, expected) def test_getitem_int_raises_exception(frame_random_data_integer_multi_index): df = frame_random_data_integer_multi_index msg = "3" with pytest.raises(KeyError, match=msg): df.loc.__getitem__(3) def test_getitem_iloc(multiindex_dataframe_random_data): df = multiindex_dataframe_random_data result = df.iloc[2] expected = df.xs(df.index[2]) tm.assert_series_equal(result, expected) def test_frame_setitem_view_direct(multiindex_dataframe_random_data): # this works because we are modifying the underlying array # really a no-no df = multiindex_dataframe_random_data.T df['foo'].values[:] = 0 assert (df['foo'].values == 0).all() def test_frame_setitem_copy_raises(multiindex_dataframe_random_data): # will raise/warn as its chained assignment df = multiindex_dataframe_random_data.T msg = "A value is trying to be set on a copy of a slice from a DataFrame" with pytest.raises(com.SettingWithCopyError, match=msg): df['foo']['one'] = 2 def test_frame_setitem_copy_no_write(multiindex_dataframe_random_data): frame = multiindex_dataframe_random_data.T expected = frame df = frame.copy() msg = "A value is trying to be set on a copy of a slice from a DataFrame" with pytest.raises(com.SettingWithCopyError, match=msg): df['foo']['one'] = 2 result = df tm.assert_frame_equal(result, expected) def test_getitem_lowerdim_corner(multiindex_dataframe_random_data): df = multiindex_dataframe_random_data # test setup - check key not in dataframe with pytest.raises(KeyError, match="11"): df.loc[('bar', 'three'), 'B'] # in theory should be inserting in a sorted space???? df.loc[('bar', 'three'), 'B'] = 0 expected = 0 result = df.sort_index().loc[('bar', 'three'), 'B'] assert result == expected @pytest.mark.parametrize('unicode_strings', [True, False]) def test_mixed_depth_get(unicode_strings): # If unicode_strings is True, the column labels in dataframe # construction will use unicode strings in Python 2 (pull request # #17099). arrays = [['a', 'top', 'top', 'routine1', 'routine1', 'routine2'], ['', 'OD', 'OD', 'result1', 'result2', 'result1'], ['', 'wx', 'wy', '', '', '']] if unicode_strings: arrays = [[u(s) for s in arr] for arr in arrays] tuples = sorted(zip(*arrays)) index = MultiIndex.from_tuples(tuples) df = DataFrame(np.random.randn(4, 6), columns=index) result = df['a'] expected = df['a', '', ''].rename('a') tm.assert_series_equal(result, expected) result = df['routine1', 'result1'] expected = df['routine1', 'result1', ''] expected = expected.rename(('routine1', 'result1')) tm.assert_series_equal(result, expected) @pytest.mark.parametrize('indexer', [ lambda df: df.loc[:, ('A', 'A1')], lambda df: df[('A', 'A1')] ]) def test_mi_access(dataframe_with_duplicate_index, indexer): # GH 4145 df = dataframe_with_duplicate_index index = Index(['h1', 'h3', 'h5']) columns = MultiIndex.from_tuples([('A', 'A1')], names=['main', 'sub']) expected = DataFrame([['a', 1, 1]], index=columns, columns=index).T result = indexer(df) tm.assert_frame_equal(result, expected) def test_mi_access_returns_series(dataframe_with_duplicate_index): # GH 4146, not returning a block manager when selecting a unique index # from a duplicate index # as of 4879, this returns a Series (which is similar to what happens # with a non-unique) df = dataframe_with_duplicate_index expected = Series(['a', 1, 1], index=['h1', 'h3', 'h5'], name='A1') result = df['A']['A1'] tm.assert_series_equal(result, expected) def test_mi_access_returns_frame(dataframe_with_duplicate_index): # selecting a non_unique from the 2nd level df = dataframe_with_duplicate_index expected = DataFrame([['d', 4, 4], ['e', 5, 5]], index=Index(['B2', 'B2'], name='sub'), columns=['h1', 'h3', 'h5'], ).T result = df['A']['B2']
tm.assert_frame_equal(result, expected)
pandas.util.testing.assert_frame_equal
""" ADE20K Dataset, old version with scene subdirs STEP 1 in a database preprocessing: making a list of all input image and annotation files and saving it as .csv file """ import os import scipy.io import numpy as np import pandas as pd rootdir = "/media/sveta/DATASTORE/AI_ML_DL/Datasets/4_ADE20K/ADE20K_2016_07_26/" out_anno_subdir = "anno_meta" out_anno_csv = "anno_filelist.csv" img_sets = {"images/training": "train", "images/validation": "val"} seg_suffix = "_seg.png" columns = ['set', 'subdirs', 'filename_img', 'filename_seg', 'train'] data_list = [] L_iss = len(img_sets) for i_iss, img_set_subdir in enumerate(img_sets): set_subdir = os.path.join(rootdir, img_set_subdir) file_groups = list(os.walk(set_subdir)) L_fg = len(file_groups) for i_fg, file_group in enumerate(file_groups): print("{}/{} \t {}/{} \t processing.. ".format(i_iss+1, L_iss, i_fg+1, L_fg), end='') if len(file_group[1]) > 0: print('skipped') continue subdir = os.path.relpath(file_group[0], set_subdir) for f in file_group[2]: img_name, img_ext = os.path.splitext(f) if img_ext != '.jpg': continue f_seg = img_name + seg_suffix if f_seg in file_group[2]: data_list.append([img_set_subdir, subdir, f, f_seg, img_sets[img_set_subdir]=="train"]) print('done') data_list =
pd.DataFrame(data_list, columns=columns)
pandas.DataFrame
import pandas as pd import numpy as np import sys import csv from time import * from datetime import * from io import StringIO import bootstrapping import BS import dataSetConstruction def rmse(a,b): return np.sqrt(np.nanmean(np.square(a-b))) def selectIndex(df, indexToKeep): return df.loc[indexToKeep][ ~df.loc[indexToKeep].index.duplicated(keep='first') ] def removeDuplicateIndex(df): return selectIndex(df, df.index) ################################################################################ Parsing dat files def parseDatFile(fileName): s = open(fileName).read() defPos=s.find("[option]") finPos=s.find("[dividend]") df = pd.read_csv(StringIO(s[defPos:finPos].replace("\n\n",";").replace("\n",",").replace(";",";\n")),decimal=".", sep=",", header=None) matC = pd.to_numeric(df[1].str.split(pat="= ", expand=True)[1]).round(3) strikeC = pd.to_numeric(df[3].str.split(pat="= ", expand=True)[1]).round() priceC = pd.to_numeric(df[4].str.replace(";","").str.split(pat="= ", expand=True)[1]) typeC = pd.to_numeric(df[2].str.split(pat="= ", expand=True)[1]) formattedDat = pd.DataFrame([matC, strikeC, priceC, typeC], index = ["Maturity", "Strike", "Price", "Type"]).transpose().astype({"Type":"int32"}) filteredDat = formattedDat[formattedDat["Type"]==2] return filteredDat def parseModelParamDatFile(fileName): s = open(fileName).read() parts = s.split("\n\n") number1 = parts[0] repo = parts[1] dates = parts[2] interestRates = parts[3] dividendRates = parts[4] number2 = parts[5] number3 = parts[6] n = parts[7] sigmaRef = parts[8] h = parts[9] sigmaMax = parts[10] sigmaMin = parts[11] number4 = parts[12] underlying = parts[13] def splitRow(row): return np.array(row.split("\t")).astype(np.float) tree = ("\n".join(parts[14:])).split("\n") tree.remove("") formattedTree = np.reshape(np.array(list(map(splitRow, tree))), (-1,3)) return pd.DataFrame(formattedTree, columns = ["date", "stock(%)", "vol"]) def parseImpliedVolDatFile(fileName): s = open(fileName).read() parts = s.split("\n\n") def splitRow(row): return np.array(row.split("\t")).astype(np.float) testGrid = ("\n".join(parts)).split("\n") testGrid.remove("") formattedTestGrid = np.reshape(np.array(list(map(splitRow, testGrid))), (-1,4)) return pd.DataFrame(formattedTestGrid, columns=["Strike","Maturity","Implied vol.","Option price"]) def parseCalibrOutDatFile(fileName): s = open(fileName).read() parts = s.split("\n") def splitRow(row): return np.array(row.split("\t")) def filterRow(row): return len(row)==10 def formatRow(row): return row.astype(np.float) #tree = ("\n".join(parts)).split("\n") #tree.remove("") filteredTrainingData = list(filter(filterRow , list(map(splitRow, parts)))) formattedTrainingData = np.array(list(map(formatRow, filteredTrainingData))) colNames = ["Active", "Option\ntype", "Maturity", "Strike", "Moneyness", "Option\nprice", "Implied\nvol.", "Calibrated\nvol.","Market vol. -\nCalibrated vol.","MarketPrice"] dfTrainingData = pd.DataFrame(formattedTrainingData, columns = colNames) dfTrainingData["Active"] = dfTrainingData["Active"].astype(np.int) dfTrainingData["Option\ntype"] = dfTrainingData["Option\ntype"].astype(np.int) return dfTrainingData def parseDatFiles(fileName): s = open(fileName).read() posUnderlying = s.find("[underlying]") posZeroCoupon = s.find("[zero_coupon]") posOption = s.find("[option]") posDividend = s.find("[dividend]") underlyingString = s[posUnderlying:posZeroCoupon] zeroCouponString = s[posZeroCoupon:posOption] optionString = s[posOption:posDividend] dividendString = s[posDividend:-2] def extractData(subStr, tag): parts = subStr.replace(tag + "\n", "").split("\n\n") try : parts.remove("") except ValueError: #Not found, we continue pass def parseRow(row): return (int(row.split(" = ")[1]) if (row.split(" = ")[0] == "type") else float(row.split(" = ")[1])) def splitRow(row): table = np.array(row.split("\n")) parseTable = np.array(list(map(parseRow, table))) return np.reshape(parseTable, (-1)) return np.array(list(map(splitRow, parts))) underlying = pd.DataFrame(extractData(underlyingString, "[underlying]"), columns=["S","Repo"]) zeroCoupon = pd.DataFrame(extractData(zeroCouponString, "[zero_coupon] "), columns=["Maturity","Price"]) option = pd.DataFrame(extractData(optionString, "[option] "), columns=["Maturity","Type", "Price", "Strike"]) option["Type"] = option["Type"].astype(np.int) dividend = pd.DataFrame(extractData(dividendString, "[dividend] "), columns=["Maturity","Amount"]) return underlying, zeroCoupon, dividend, option ###################################################################### data processing def cleanData(zeroCouponCurve, dividendCurve, trainingData, testingData, underlyingNative, localVolatilityNative): dividendDf = dividendCurve.set_index('Maturity').sort_index() dividendDf.loc[1.0] = 0.0 dividendDf.sort_index(inplace=True) # Format zero coupon curve as a Pandas series rateCurveDf = zeroCouponCurve.set_index('Maturity').sort_index() # keep only rates expriring before 1 year rateCurveDf = rateCurveDf.loc[rateCurveDf.index <= 1.01] localVolatility = localVolatilityNative.dropna() strikeCol = np.multiply(localVolatility["stock(%)"], underlyingNative).copy() localVolatility.insert(0, "Strike", strikeCol) roundedDate = localVolatility["date"].round(decimals=3) localVolatility = localVolatility.copy() localVolatility.loc[:, "date"] = roundedDate renameDict = {"date": "Maturity", "vol": "LocalVolatility", "stock(%)": "StrikePercentage"} localVolatility = localVolatility.rename(columns=renameDict).set_index(["Strike", "Maturity"]) # Treatment for training data filteredTestingData = testingData[(testingData["Implied vol."] > 0) & (testingData["Option price"] > 0)] filteredTestingData = filteredTestingData.copy() filteredTestingData.loc[:, "Maturity"] = filteredTestingData["Maturity"].round(decimals=3) filteredTestingData.insert(0, "OptionType", np.ones_like(filteredTestingData["Maturity"])) renameDict = {"Implied vol.": "ImpliedVol", "Option price": "Price", "Implied delta": "ImpliedDelta", "Implied gamma": "ImpliedGamma", "Implied theta": "ImpliedTheta", "Local delta": "LocalDelta", "Local gamma": "LocalGamma"} formattedTestingData = filteredTestingData.rename(columns=renameDict).set_index(["Strike", "Maturity"])[ "ImpliedVol"] # Treatment for testing data filteredTrainingData = trainingData[(trainingData["Calibrated\nvol."] > 0) & (trainingData["Option\nprice"] > 0) & ( trainingData["Option\ntype"] == 2)] roundedMat = filteredTrainingData["Maturity"].round(decimals=3) filteredTrainingData = filteredTrainingData.copy() filteredTrainingData.loc[:, "Maturity"] = roundedMat renameDict = {"Option\ntype": "OptionType", "Option\nprice": "Price", "Calibrated\nvol.": "ImpliedVol", # "LocalImpliedVol", "Implied\nvol.": "LocalImpliedVol"} # "ImpliedVol"} formattedTrainingData = filteredTrainingData.drop(["Active", "Market vol. -\nCalibrated vol."], axis=1).rename( columns=renameDict).set_index(["Strike", "Maturity"]) return dividendDf, rateCurveDf, localVolatility, removeDuplicateIndex(formattedTestingData), removeDuplicateIndex(formattedTrainingData) def selectTrainingSet(rawData): maturities = np.sort(np.unique(rawData.index.get_level_values("Maturity").values)) maxTrainingMaturities = maturities[-1] #maturities[-3] filteredData = rawData[rawData.index.get_level_values("Maturity") <= maxTrainingMaturities] trainingPercentage = 0.5 nbTrainingObs = int(rawData.shape[0] * trainingPercentage) sampledPercentage = nbTrainingObs / filteredData.shape[0] selectedTrainingRow = [] for maturityDf in filteredData.groupby(level="Maturity") : if maturityDf[1].shape[0] > 1 : nbPointsToDraw = max(int(maturityDf[1].shape[0] * sampledPercentage), 2) selectedTrainingRow.append(maturityDf[1].sample(n=nbPointsToDraw, axis=0)) elif (maturityDf[0] == filteredData["Maturity"].min()) or (maturityDf[0] == filteredData["Maturity"].max()): #Keep all data selectedTrainingRow.append(smile[1]) #trainingSet = filteredData.sample(n=nbTrainingObs, axis=0) trainingSet = filteredData.loc[pd.concat(selectedTrainingRow).index] testingSet = rawData.drop(trainingSet.index) return trainingSet.sort_index(), testingSet.sort_index() ###################################################################### Main functions def loadDataFromCSV(pathFolder, datFile): zeroCouponCurve = pd.read_csv(pathFolder + "discount.csv",decimal=".").apply(pd.to_numeric) dividendCurve = pd.read_csv(pathFolder + "dividend.csv",decimal=".").apply(pd.to_numeric) trainingData = pd.read_csv(pathFolder + "dataTrain.csv",decimal=".").apply(pd.to_numeric) testingData = pd.read_csv(pathFolder + "dataTest.csv",decimal=".").apply(pd.to_numeric) underlyingNative = pd.read_csv(pathFolder + "underlying.csv",decimal=".").apply(pd.to_numeric) localVolatilityNative = pd.read_csv(pathFolder + "locvol.csv",decimal=".").apply(pd.to_numeric) filteredDat = parseDatFile(pathFolder + datFile + ".dat") #return zeroCouponCurve, dividendCurve, trainingData, testingData, underlyingNative["S"].values[0], localVolatilityNative, filteredDat S0 = underlyingNative["S"].values[0] dividendDf, rateCurveDf, localVolatility, formattedTestingData, formattedTrainingData = cleanData(zeroCouponCurve, dividendCurve, trainingData, testingData, S0, localVolatilityNative) bootstrap = bootstrapping.bootstrapping(rateCurveDf, dividendDf, S0) #return dividendDf, rateCurveDf, localVolatility, formattedTestingData, formattedTrainingData, S0, bootstrap testingDataSet = dataSetConstruction.generateData(formattedTestingData, S0, bootstrap, localVolatility) #trainingDataSet = dataSetConstruction.generateData(formattedTrainingData["ImpliedVol"], # S0, # bootstrap, # localVolatility, # priceDf=filteredDat) trainingDataSet = dataSetConstruction.generateData(formattedTrainingData["ImpliedVol"], S0, bootstrap, localVolatility, priceDf=formattedTrainingData.reset_index()) return trainingDataSet, testingDataSet, bootstrap, S0 def loadDataFromDat(pathFolder, datFileName): localVolatilityNative = parseModelParamDatFile(pathFolder + datFileName + ".dat.modelparam.dat") testingData = parseImpliedVolDatFile(pathFolder + datFileName + ".dat.impliedvol.dat") trainingData = parseCalibrOutDatFile(pathFolder + datFileName + ".dat.calibr.out.dat") underlyingNative, zeroCouponCurve, dividendCurve, filteredDat = parseDatFiles(pathFolder + datFileName + ".dat") repricingError = rmse(trainingData["Option\nprice"], trainingData["MarketPrice"]) print("Tikhonov PDE repricing error on training set : ", repricingError) #return zeroCouponCurve, dividendCurve, trainingData, testingData, underlyingNative["S"].values[0], localVolatilityNative, filteredDat S0 = underlyingNative["S"].values[0] dividendDf, rateCurveDf, localVolatility, formattedTestingData, formattedTrainingData = cleanData(zeroCouponCurve, dividendCurve, trainingData, testingData, S0, localVolatilityNative) bootstrap = bootstrapping.bootstrapping(rateCurveDf, dividendDf, S0) #return dividendDf, rateCurveDf, localVolatility, formattedTestingData, formattedTrainingData, S0, bootstrap testingDataSet = dataSetConstruction.generateData(formattedTestingData, S0, bootstrap, localVolatility) #trainingDataSet = dataSetConstruction.generateData(formattedTrainingData["ImpliedVol"], # S0, # bootstrap, # localVolatility, # priceDf=filteredDat) trainingDataSet = dataSetConstruction.generateData(formattedTrainingData["ImpliedVol"], S0, bootstrap, localVolatility, priceDf=formattedTrainingData.reset_index()) return trainingDataSet, testingDataSet, bootstrap, S0 def loadCBOTData(pathFolder, fileName, asOfDate): sheetName = "quotedata" aDf = pd.read_excel(pathFolder + fileName, header=None, sheet_name = sheetName) S0 = float(aDf.iloc[0, 1]) aDf = pd.read_excel(pathFolder + fileName, header=2, sheet_name = sheetName) # aDf = aDf[aDf["Converted Expiration Date"] >= asOfDate] def formatDate(date): if isinstance(date, str): return pd.to_datetime(date, format='%m/%d/%Y') return pd.Timestamp(date.year, date.day, date.month) aDf["Converted Expiration Date"] = aDf["Expiration Date"].map(lambda x: formatDate(x)) aDf = aDf[(aDf["Vol"] > 0.1) & (aDf["Last Sale"] > 0.01) & (aDf["Last Sale.1"] > 0.01) & (aDf["IV.1"] > 0.001) & (aDf["IV"] > 0.001)] closeDate = aDf["Converted Expiration Date"] strike = aDf["Strike"].round(decimals=3) maturity = (aDf["Converted Expiration Date"] - pd.Timestamp(asOfDate)).map(lambda x: x.days / 365.25).round(decimals=3) closeCall = (aDf["Bid"] + aDf["Ask"]) / 2 # aDf["Last Sale"] bidCall = aDf["Bid"] askCall = aDf["Ask"] impliedVolCall = aDf["IV"] deltaCall = aDf["Delta"] gammaCall = aDf["Gamma"] impliedVolPut = aDf["IV.1"] closePut = (aDf["Bid.1"] + aDf["Ask.1"]) / 2 # aDf["Last Sale.1"] bidPut = aDf["Bid.1"] askPut = aDf["Ask.1"] deltaPut = aDf["Delta.1"] gammaPut = aDf["Gamma.1"] callDf = pd.DataFrame(np.vstack( [strike, maturity, closeCall, bidCall, askCall, impliedVolCall, deltaCall, gammaCall, np.ones_like(deltaCall, dtype=np.int32)]).T, columns=["Strike", "Maturity", "Price", "Bid", "Ask", "ImpliedVol", "Delta", "Gamma", "OptionType"]).set_index(["Strike", "Maturity"]) PutDf = pd.DataFrame(np.vstack([strike, maturity, closePut, bidPut, askPut, impliedVolPut, deltaPut, gammaPut, 2 * np.ones_like(deltaCall, dtype=np.int32)]).T, columns=["Strike", "Maturity", "Price", "Bid", "Ask", "ImpliedVol", "Delta", "Gamma", "OptionType"]).set_index(["Strike", "Maturity"]) bootstrap = bootstrapping.bootstrappingAveraged(pathFolder + "yieldCurve.dat", S0, strike, asOfDate, closeCall, closePut, maturity) rawData = pd.concat([callDf, PutDf]) rawData = rawData[rawData["OptionType"]==2] #impvol = BS.vectorizedImpliedVolatilityCalibration(S0, # bootstrap, # rawData.index.get_level_values("Maturity"), # rawData.index.get_level_values("Strike"), # rawData["OptionType"], # rawData["Price"]) #rawData["ImpliedVol"] = impvol filteredData = removeDataViolatingStaticArbitrage(rawData.reset_index()) rawData = removeDuplicateIndex(filteredData.set_index(["Strike", "Maturity"])) trainingSet, testingSet = selectTrainingSet(rawData) trainingDataSet = dataSetConstruction.generateData(trainingSet["ImpliedVol"], S0, bootstrap, localVolatilityRef = None, priceDf=trainingSet.reset_index(), spotValue = False) testingDataSet = dataSetConstruction.generateData(testingSet["ImpliedVol"], S0, bootstrap, localVolatilityRef = None, priceDf=testingSet.reset_index(), spotValue = False) return trainingDataSet, testingDataSet, bootstrap, S0 def loadESXData(pathFolder, fileName, asOfDate): #Stock S0 = pd.read_excel(pathFolder + fileName, header=0, sheet_name="Underlying_spot")["S0"].values[0] #Raw data rawData = pd.read_excel(pathFolder + fileName, header=0, sheet_name="Put_Call_ask_price_all") rawData["Strike"] = rawData["K"].astype(np.float).round(decimals=3) rawData["Maturity"] = rawData["T"].round(decimals=3) #Bootstrapping bootstrap = bootstrapping.bootstrappingAveragedExcel(pathFolder + fileName, S0, rawData["Strike"], asOfDate, rawData["Call_price"], rawData["Put_price"], rawData["Maturity"]) callDf = pd.DataFrame(np.vstack([rawData["Call_price"].values, np.ones_like(rawData["Call_price"].values), rawData["Strike"].values, rawData["Maturity"].values]).T, index = rawData.index, columns = ["Price", "OptionType", "Strike", "Maturity"]) putDf = pd.DataFrame(np.vstack([rawData["Put_price"].values, 2 * np.ones_like(rawData["Put_price"].values), rawData["Strike"].values, rawData["Maturity"].values]).T, index=rawData.index, columns=["Price", "OptionType", "Strike", "Maturity"]) rawData = pd.concat([callDf, putDf]) impvol = BS.vectorizedImpliedVolatilityCalibration(S0, bootstrap, rawData["Maturity"], rawData["Strike"], rawData["OptionType"], rawData["Price"]) rawData["ImpliedVol"] = impvol rawData = removeDuplicateIndex(rawData.set_index(["Strike","Maturity"])) trainingSet, testingSet = selectTrainingSet(rawData) trainingDataSet = dataSetConstruction.generateData(trainingSet["ImpliedVol"], S0, bootstrap, localVolatilityRef = None, priceDf=trainingSet.reset_index(), spotValue = False) testingDataSet = dataSetConstruction.generateData(testingSet["ImpliedVol"], S0, bootstrap, localVolatilityRef = None, priceDf=testingSet.reset_index(), spotValue = False) return trainingDataSet, testingDataSet, bootstrap, S0 def loadGPLocVol(pathFolder, GPKernel, bootstrap, S0): pathGP = pathFolder + ("local_vol_gaussian.csv" if GPKernel == "Gaussian" else "local_vol_matern_5_2.csv") print("Loading local volatility from : ", pathGP) locVolAresky = pd.read_csv(pathGP, decimal=".").apply(pd.to_numeric).dropna() #locVolAresky["Strike"] = locVolAresky["K"].values locVolAresky.insert(0, "Strike", locVolAresky["K"].values) #locVolAresky["Maturity"] = locVolAresky["T"].round(decimals=3) locVolAresky.insert(0, "Maturity", locVolAresky["T"].round(decimals=3)) renameDict = {"loc_vol": "LocalVolatility"} locVolAreskyFormatted = locVolAresky.rename(columns=renameDict).set_index(["Strike", "Maturity"]) changedVarAresky = bootstrap.changeOfVariable(locVolAreskyFormatted["K"], locVolAreskyFormatted["T"]) #locVolAreskyFormatted["Maturity"] = locVolAreskyFormatted["T"] locVolAreskyFormatted.insert(0, "Maturity", locVolAreskyFormatted["T"].round(decimals=3)) #locVolAreskyFormatted["Strike"] = locVolAreskyFormatted["K"] locVolAreskyFormatted.insert(0, "Strike", locVolAreskyFormatted["K"].round(decimals=3)) #locVolAreskyFormatted["ChangedStrike"] = pd.Series(changedVarAresky[0], # index=locVolAreskyFormatted.index) locVolAreskyFormatted.insert(0, "ChangedStrike", pd.Series(changedVarAresky[0], index=locVolAreskyFormatted.index)) #locVolAreskyFormatted["logMoneyness"] = np.log(locVolAreskyFormatted["ChangedStrike"] / S0) locVolAreskyFormatted.insert(0, "logMoneyness", np.log(locVolAreskyFormatted["ChangedStrike"] / S0)) locVolAreskyFormatted.insert(0, "OptionType", -np.ones_like(locVolAreskyFormatted["ChangedStrike"])) return locVolAreskyFormatted[~locVolAreskyFormatted.index.duplicated(keep='first')] def loadGPLocVol(workingFolder, filename, bootstrap, S0): #pathGP = pathFolder + ("local_vol_gaussian.csv" if GPKernel == "Gaussian" else "local_vol_matern_5_2.csv") pathGP = workingFolder + filename print("Loading local volatility from : ", pathGP) locVolAresky = pd.read_excel(pathGP, header=0, sheet_name="Sheet1") #locVolAresky["Strike"] = locVolAresky["K"].values locVolAresky.insert(0, "Strike", locVolAresky["K"].round(decimals=3).values) #locVolAresky["Maturity"] = locVolAresky["T"].round(decimals=3) locVolAresky.insert(0, "Maturity", locVolAresky["T"].round(decimals=3)) renameDict = {"loc_vol": "LocalVolatility"} locVolAreskyFormatted = locVolAresky.rename(columns=renameDict).set_index(["Strike", "Maturity"]) changedVarAresky = bootstrap.changeOfVariable(locVolAreskyFormatted["K"], locVolAreskyFormatted["T"]) #locVolAreskyFormatted["Maturity"] = locVolAreskyFormatted["T"] locVolAreskyFormatted.insert(0, "Maturity", locVolAreskyFormatted["T"].round(decimals=3)) #locVolAreskyFormatted["Strike"] = locVolAreskyFormatted["K"] locVolAreskyFormatted.insert(0, "Strike", locVolAreskyFormatted["K"].round(decimals=3)) #locVolAreskyFormatted["ChangedStrike"] = pd.Series(changedVarAresky[0], # index=locVolAreskyFormatted.index) locVolAreskyFormatted.insert(0, "ChangedStrike", pd.Series(changedVarAresky[0], index=locVolAreskyFormatted.index)) #locVolAreskyFormatted["logMoneyness"] = np.log(locVolAreskyFormatted["ChangedStrike"] / S0) locVolAreskyFormatted.insert(0, "logMoneyness", np.log(locVolAreskyFormatted["ChangedStrike"] / S0)) locVolAreskyFormatted.insert(0, "OptionType", -np.ones_like(locVolAreskyFormatted["ChangedStrike"])) return locVolAreskyFormatted[~locVolAreskyFormatted.index.duplicated(keep='first')] def removeDataViolatingStaticArbitrageStep(df): arbitrableRows = [] for strike in df.rename({"Strike": "StrikeColumn"}, axis=1).groupby("StrikeColumn"): impliedTotVariance = np.square(strike[1]["ImpliedVol"]) * strike[1]["Maturity"] sortedStrike = pd.Series(impliedTotVariance.values, index=strike[1]["Maturity"].values).sort_index().diff().dropna() thetaViolation = sortedStrike.diff().dropna() if (thetaViolation < 0).sum() > 0: arbitrableMaturities = thetaViolation[(thetaViolation < 0)].index arbitrableRows.append(strike[1][ strike[1]["Maturity"].isin(arbitrableMaturities) ]) #plt.plot(strike[1]["Maturity"].values, impliedTotVariance.values, label=str(strike[0])) #print("Strike : ", strike[0], " NbViolations : ", (thetaViolation < 0).sum()) #print((thetaViolation < 0)) #print(sortedStrike) return df.drop(pd.concat(arbitrableRows).index) if (len(arbitrableRows) > 0) else df def removeDataViolatingStaticArbitrage(df): formerDf = df condition = True maxNbLoop = 500 iterNb = 0 while condition and (iterNb < maxNbLoop) : dfStep = removeDataViolatingStaticArbitrageStep(formerDf) condition = (dfStep.shape[0] < formerDf.shape[0]) and (dfStep.shape[0] > 0) formerDf = dfStep iterNb = iterNb + 1 return dfStep def loadFormattedData(pathFolder): S0 = 2859.53 #Hard coded value trainingPath = pathFolder + "trainingDataSet.csv" trainingDataset = pd.read_csv(trainingPath).set_index(["Strike", "Maturity"]).rename({"Strike.1": "Strike", "Maturity.1": "Maturity"}, axis=1).sort_index() testingPath = pathFolder + "testingDataSet.csv" testingDataset = pd.read_csv(testingPath).set_index(["Strike", "Maturity"]).rename({"Strike.1": "Strike", "Maturity.1": "Maturity"}, axis=1).sort_index() bootstrappingPath = pathFolder + "dfCurve.csv" dfCurve =
pd.read_csv(bootstrappingPath)
pandas.read_csv
import numpy as np import pytest import pandas.util._test_decorators as td from pandas.core.dtypes.generic import ABCIndexClass import pandas as pd import pandas._testing as tm from pandas.api.types import is_float, is_float_dtype, is_integer, is_scalar from pandas.core.arrays import IntegerArray, integer_array from pandas.core.arrays.integer import ( Int8Dtype, Int16Dtype, Int32Dtype, Int64Dtype, UInt8Dtype, UInt16Dtype, UInt32Dtype, UInt64Dtype, ) from pandas.tests.extension.base import BaseOpsUtil def make_data(): return list(range(8)) + [np.nan] + list(range(10, 98)) + [np.nan] + [99, 100] @pytest.fixture( params=[ Int8Dtype, Int16Dtype, Int32Dtype, Int64Dtype, UInt8Dtype, UInt16Dtype, UInt32Dtype, UInt64Dtype, ] ) def dtype(request): return request.param() @pytest.fixture def data(dtype): return integer_array(make_data(), dtype=dtype) @pytest.fixture def data_missing(dtype): return integer_array([np.nan, 1], dtype=dtype) @pytest.fixture(params=["data", "data_missing"]) def all_data(request, data, data_missing): """Parametrized fixture giving 'data' and 'data_missing'""" if request.param == "data": return data elif request.param == "data_missing": return data_missing def test_dtypes(dtype): # smoke tests on auto dtype construction if dtype.is_signed_integer: assert np.dtype(dtype.type).kind == "i" else: assert np.dtype(dtype.type).kind == "u" assert dtype.name is not None @pytest.mark.parametrize( "dtype, expected", [ (Int8Dtype(), "Int8Dtype()"), (Int16Dtype(), "Int16Dtype()"), (Int32Dtype(), "Int32Dtype()"), (Int64Dtype(), "Int64Dtype()"), (UInt8Dtype(), "UInt8Dtype()"), (UInt16Dtype(), "UInt16Dtype()"), (UInt32Dtype(), "UInt32Dtype()"), (UInt64Dtype(), "UInt64Dtype()"), ], ) def test_repr_dtype(dtype, expected): assert repr(dtype) == expected def test_repr_array(): result = repr(integer_array([1, None, 3])) expected = "<IntegerArray>\n[1, <NA>, 3]\nLength: 3, dtype: Int64" assert result == expected def test_repr_array_long(): data = integer_array([1, 2, None] * 1000) expected = ( "<IntegerArray>\n" "[ 1, 2, <NA>, 1, 2, <NA>, 1, 2, <NA>, 1,\n" " ...\n" " <NA>, 1, 2, <NA>, 1, 2, <NA>, 1, 2, <NA>]\n" "Length: 3000, dtype: Int64" ) result = repr(data) assert result == expected class TestConstructors: def test_uses_pandas_na(self): a = pd.array([1, None], dtype=pd.Int64Dtype()) assert a[1] is pd.NA def test_from_dtype_from_float(self, data): # construct from our dtype & string dtype dtype = data.dtype # from float expected = pd.Series(data) result = pd.Series( data.to_numpy(na_value=np.nan, dtype="float"), dtype=str(dtype) ) tm.assert_series_equal(result, expected) # from int / list expected = pd.Series(data) result = pd.Series(np.array(data).tolist(), dtype=str(dtype)) tm.assert_series_equal(result, expected) # from int / array expected = pd.Series(data).dropna().reset_index(drop=True) dropped = np.array(data.dropna()).astype(np.dtype((dtype.type))) result = pd.Series(dropped, dtype=str(dtype)) tm.assert_series_equal(result, expected) class TestArithmeticOps(BaseOpsUtil): def _check_divmod_op(self, s, op, other, exc=None): super()._check_divmod_op(s, op, other, None) def _check_op(self, s, op_name, other, exc=None): op = self.get_op_from_name(op_name) result = op(s, other) # compute expected mask = s.isna() # if s is a DataFrame, squeeze to a Series # for comparison if isinstance(s, pd.DataFrame): result = result.squeeze() s = s.squeeze() mask = mask.squeeze() # other array is an Integer if isinstance(other, IntegerArray): omask = getattr(other, "mask", None) mask = getattr(other, "data", other) if omask is not None: mask |= omask # 1 ** na is na, so need to unmask those if op_name == "__pow__": mask = np.where(~s.isna() & (s == 1), False, mask) elif op_name == "__rpow__": other_is_one = other == 1 if isinstance(other_is_one, pd.Series): other_is_one = other_is_one.fillna(False) mask = np.where(other_is_one, False, mask) # float result type or float op if ( is_float_dtype(other) or is_float(other) or op_name in ["__rtruediv__", "__truediv__", "__rdiv__", "__div__"] ): rs = s.astype("float") expected = op(rs, other) self._check_op_float(result, expected, mask, s, op_name, other) # integer result type else: rs = pd.Series(s.values._data, name=s.name) expected = op(rs, other) self._check_op_integer(result, expected, mask, s, op_name, other) def _check_op_float(self, result, expected, mask, s, op_name, other): # check comparisons that are resulting in float dtypes expected[mask] = np.nan if "floordiv" in op_name: # Series op sets 1//0 to np.inf, which IntegerArray does not do (yet) mask2 = np.isinf(expected) & np.isnan(result) expected[mask2] = np.nan tm.assert_series_equal(result, expected) def _check_op_integer(self, result, expected, mask, s, op_name, other): # check comparisons that are resulting in integer dtypes # to compare properly, we convert the expected # to float, mask to nans and convert infs # if we have uints then we process as uints # then convert to float # and we ultimately want to create a IntArray # for comparisons fill_value = 0 # mod/rmod turn floating 0 into NaN while # integer works as expected (no nan) if op_name in ["__mod__", "__rmod__"]: if is_scalar(other): if other == 0: expected[s.values == 0] = 0 else: expected = expected.fillna(0) else: expected[ (s.values == 0).fillna(False) & ((expected == 0).fillna(False) | expected.isna()) ] = 0 try: expected[ ((expected == np.inf) | (expected == -np.inf)).fillna(False) ] = fill_value original = expected expected = expected.astype(s.dtype) except ValueError: expected = expected.astype(float) expected[ ((expected == np.inf) | (expected == -np.inf)).fillna(False) ] = fill_value original = expected expected = expected.astype(s.dtype) expected[mask] = pd.NA # assert that the expected astype is ok # (skip for unsigned as they have wrap around) if not s.dtype.is_unsigned_integer: original = pd.Series(original) # we need to fill with 0's to emulate what an astype('int') does # (truncation) for certain ops if op_name in ["__rtruediv__", "__rdiv__"]: mask |= original.isna() original = original.fillna(0).astype("int") original = original.astype("float") original[mask] = np.nan tm.assert_series_equal(original, expected.astype("float")) # assert our expected result tm.assert_series_equal(result, expected) def test_arith_integer_array(self, data, all_arithmetic_operators): # we operate with a rhs of an integer array op = all_arithmetic_operators s = pd.Series(data) rhs = pd.Series([1] * len(data), dtype=data.dtype) rhs.iloc[-1] = np.nan self._check_op(s, op, rhs) def test_arith_series_with_scalar(self, data, all_arithmetic_operators): # scalar op = all_arithmetic_operators s = pd.Series(data) self._check_op(s, op, 1, exc=TypeError) def test_arith_frame_with_scalar(self, data, all_arithmetic_operators): # frame & scalar op = all_arithmetic_operators df = pd.DataFrame({"A": data}) self._check_op(df, op, 1, exc=TypeError) def test_arith_series_with_array(self, data, all_arithmetic_operators): # ndarray & other series op = all_arithmetic_operators s = pd.Series(data) other = np.ones(len(s), dtype=s.dtype.type) self._check_op(s, op, other, exc=TypeError) def test_arith_coerce_scalar(self, data, all_arithmetic_operators): op = all_arithmetic_operators s = pd.Series(data) other = 0.01 self._check_op(s, op, other) @pytest.mark.parametrize("other", [1.0, np.array(1.0)]) def test_arithmetic_conversion(self, all_arithmetic_operators, other): # if we have a float operand we should have a float result # if that is equal to an integer op = self.get_op_from_name(all_arithmetic_operators) s = pd.Series([1, 2, 3], dtype="Int64") result = op(s, other) assert result.dtype is np.dtype("float") def test_arith_len_mismatch(self, all_arithmetic_operators): # operating with a list-like with non-matching length raises op = self.get_op_from_name(all_arithmetic_operators) other = np.array([1.0]) s = pd.Series([1, 2, 3], dtype="Int64") with pytest.raises(ValueError, match="Lengths must match"): op(s, other) @pytest.mark.parametrize("other", [0, 0.5]) def test_arith_zero_dim_ndarray(self, other): arr = integer_array([1, None, 2]) result = arr + np.array(other) expected = arr + other tm.assert_equal(result, expected) def test_error(self, data, all_arithmetic_operators): # invalid ops op = all_arithmetic_operators s = pd.Series(data) ops = getattr(s, op) opa = getattr(data, op) # invalid scalars msg = ( r"(:?can only perform ops with numeric values)" r"|(:?IntegerArray cannot perform the operation mod)" ) with pytest.raises(TypeError, match=msg): ops("foo") with pytest.raises(TypeError, match=msg): ops(pd.Timestamp("20180101")) # invalid array-likes with pytest.raises(TypeError, match=msg): ops(pd.Series("foo", index=s.index)) if op != "__rpow__": # TODO(extension) # rpow with a datetimelike coerces the integer array incorrectly msg = ( "can only perform ops with numeric values|" "cannot perform .* with this index type: DatetimeArray|" "Addition/subtraction of integers and integer-arrays " "with DatetimeArray is no longer supported. *" ) with pytest.raises(TypeError, match=msg): ops(pd.Series(pd.date_range("20180101", periods=len(s)))) # 2d result = opa(pd.DataFrame({"A": s})) assert result is NotImplemented msg = r"can only perform ops with 1-d structures" with pytest.raises(NotImplementedError, match=msg): opa(np.arange(len(s)).reshape(-1, len(s))) @pytest.mark.parametrize("zero, negative", [(0, False), (0.0, False), (-0.0, True)]) def test_divide_by_zero(self, zero, negative): # https://github.com/pandas-dev/pandas/issues/27398 a = pd.array([0, 1, -1, None], dtype="Int64") result = a / zero expected = np.array([np.nan, np.inf, -np.inf, np.nan]) if negative: expected *= -1 tm.assert_numpy_array_equal(result, expected) def test_pow_scalar(self): a = pd.array([-1, 0, 1, None, 2], dtype="Int64") result = a ** 0 expected = pd.array([1, 1, 1, 1, 1], dtype="Int64") tm.assert_extension_array_equal(result, expected) result = a ** 1 expected = pd.array([-1, 0, 1, None, 2], dtype="Int64") tm.assert_extension_array_equal(result, expected) result = a ** pd.NA expected = pd.array([None, None, 1, None, None], dtype="Int64") tm.assert_extension_array_equal(result, expected) result = a ** np.nan expected = np.array([np.nan, np.nan, 1, np.nan, np.nan], dtype="float64") tm.assert_numpy_array_equal(result, expected) # reversed a = a[1:] # Can't raise integers to negative powers. result = 0 ** a expected = pd.array([1, 0, None, 0], dtype="Int64") tm.assert_extension_array_equal(result, expected) result = 1 ** a expected = pd.array([1, 1, 1, 1], dtype="Int64") tm.assert_extension_array_equal(result, expected) result = pd.NA ** a expected = pd.array([1, None, None, None], dtype="Int64") tm.assert_extension_array_equal(result, expected) result = np.nan ** a expected = np.array([1, np.nan, np.nan, np.nan], dtype="float64") tm.assert_numpy_array_equal(result, expected) def test_pow_array(self): a = integer_array([0, 0, 0, 1, 1, 1, None, None, None]) b = integer_array([0, 1, None, 0, 1, None, 0, 1, None]) result = a ** b expected = integer_array([1, 0, None, 1, 1, 1, 1, None, None]) tm.assert_extension_array_equal(result, expected) def test_rpow_one_to_na(self): # https://github.com/pandas-dev/pandas/issues/22022 # https://github.com/pandas-dev/pandas/issues/29997 arr = integer_array([np.nan, np.nan]) result = np.array([1.0, 2.0]) ** arr expected = np.array([1.0, np.nan]) tm.assert_numpy_array_equal(result, expected) class TestComparisonOps(BaseOpsUtil): def _compare_other(self, data, op_name, other): op = self.get_op_from_name(op_name) # array result = pd.Series(op(data, other)) expected = pd.Series(op(data._data, other), dtype="boolean") # fill the nan locations expected[data._mask] = pd.NA tm.assert_series_equal(result, expected) # series s = pd.Series(data) result = op(s, other) expected = op(pd.Series(data._data), other) # fill the nan locations expected[data._mask] = pd.NA expected = expected.astype("boolean") tm.assert_series_equal(result, expected) @pytest.mark.parametrize("other", [True, False, pd.NA, -1, 0, 1]) def test_scalar(self, other, all_compare_operators): op = self.get_op_from_name(all_compare_operators) a = pd.array([1, 0, None], dtype="Int64") result = op(a, other) if other is pd.NA: expected = pd.array([None, None, None], dtype="boolean") else: values = op(a._data, other) expected = pd.arrays.BooleanArray(values, a._mask, copy=True) tm.assert_extension_array_equal(result, expected) # ensure we haven't mutated anything inplace result[0] = pd.NA tm.assert_extension_array_equal(a, pd.array([1, 0, None], dtype="Int64")) def test_array(self, all_compare_operators): op = self.get_op_from_name(all_compare_operators) a = pd.array([0, 1, 2, None, None, None], dtype="Int64") b = pd.array([0, 1, None, 0, 1, None], dtype="Int64") result = op(a, b) values = op(a._data, b._data) mask = a._mask | b._mask expected = pd.arrays.BooleanArray(values, mask) tm.assert_extension_array_equal(result, expected) # ensure we haven't mutated anything inplace result[0] = pd.NA tm.assert_extension_array_equal( a, pd.array([0, 1, 2, None, None, None], dtype="Int64") ) tm.assert_extension_array_equal( b, pd.array([0, 1, None, 0, 1, None], dtype="Int64") ) def test_compare_with_booleanarray(self, all_compare_operators): op = self.get_op_from_name(all_compare_operators) a = pd.array([True, False, None] * 3, dtype="boolean") b = pd.array([0] * 3 + [1] * 3 + [None] * 3, dtype="Int64") other = pd.array([False] * 3 + [True] * 3 + [None] * 3, dtype="boolean") expected = op(a, other) result = op(a, b) tm.assert_extension_array_equal(result, expected) def test_no_shared_mask(self, data): result = data + 1 assert np.shares_memory(result._mask, data._mask) is False def test_compare_to_string(self, any_nullable_int_dtype): # GH 28930 s = pd.Series([1, None], dtype=any_nullable_int_dtype) result = s == "a" expected = pd.Series([False, pd.NA], dtype="boolean") self.assert_series_equal(result, expected) def test_compare_to_int(self, any_nullable_int_dtype, all_compare_operators): # GH 28930 s1 = pd.Series([1, None, 3], dtype=any_nullable_int_dtype) s2 = pd.Series([1, None, 3], dtype="float") method = getattr(s1, all_compare_operators) result = method(2) method = getattr(s2, all_compare_operators) expected = method(2).astype("boolean") expected[s2.isna()] = pd.NA self.assert_series_equal(result, expected) class TestCasting: @pytest.mark.parametrize("dropna", [True, False]) def test_construct_index(self, all_data, dropna): # ensure that we do not coerce to Float64Index, rather # keep as Index all_data = all_data[:10] if dropna: other = np.array(all_data[~all_data.isna()]) else: other = all_data result = pd.Index(integer_array(other, dtype=all_data.dtype)) expected = pd.Index(other, dtype=object) tm.assert_index_equal(result, expected) @pytest.mark.parametrize("dropna", [True, False]) def test_astype_index(self, all_data, dropna): # as an int/uint index to Index all_data = all_data[:10] if dropna: other = all_data[~all_data.isna()] else: other = all_data dtype = all_data.dtype idx = pd.Index(np.array(other)) assert isinstance(idx, ABCIndexClass) result = idx.astype(dtype) expected = idx.astype(object).astype(dtype) tm.assert_index_equal(result, expected) def test_astype(self, all_data): all_data = all_data[:10] ints = all_data[~all_data.isna()] mixed = all_data dtype = Int8Dtype() # coerce to same type - ints s = pd.Series(ints) result = s.astype(all_data.dtype) expected = pd.Series(ints) tm.assert_series_equal(result, expected) # coerce to same other - ints s = pd.Series(ints) result = s.astype(dtype) expected = pd.Series(ints, dtype=dtype) tm.assert_series_equal(result, expected) # coerce to same numpy_dtype - ints s = pd.Series(ints) result = s.astype(all_data.dtype.numpy_dtype) expected = pd.Series(ints._data.astype(all_data.dtype.numpy_dtype)) tm.assert_series_equal(result, expected) # coerce to same type - mixed s = pd.Series(mixed) result = s.astype(all_data.dtype) expected = pd.Series(mixed) tm.assert_series_equal(result, expected) # coerce to same other - mixed s = pd.Series(mixed) result = s.astype(dtype) expected = pd.Series(mixed, dtype=dtype) tm.assert_series_equal(result, expected) # coerce to same numpy_dtype - mixed s = pd.Series(mixed) msg = r"cannot convert to .*-dtype NumPy array with missing values.*" with pytest.raises(ValueError, match=msg): s.astype(all_data.dtype.numpy_dtype) # coerce to object s = pd.Series(mixed) result = s.astype("object") expected = pd.Series(np.asarray(mixed)) tm.assert_series_equal(result, expected) def test_astype_to_larger_numpy(self): a = pd.array([1, 2], dtype="Int32") result = a.astype("int64") expected = np.array([1, 2], dtype="int64") tm.assert_numpy_array_equal(result, expected) a = pd.array([1, 2], dtype="UInt32") result = a.astype("uint64") expected = np.array([1, 2], dtype="uint64") tm.assert_numpy_array_equal(result, expected) @pytest.mark.parametrize("dtype", [Int8Dtype(), "Int8", UInt32Dtype(), "UInt32"]) def test_astype_specific_casting(self, dtype): s = pd.Series([1, 2, 3], dtype="Int64") result = s.astype(dtype) expected = pd.Series([1, 2, 3], dtype=dtype) tm.assert_series_equal(result, expected) s = pd.Series([1, 2, 3, None], dtype="Int64") result = s.astype(dtype) expected = pd.Series([1, 2, 3, None], dtype=dtype) tm.assert_series_equal(result, expected) def test_construct_cast_invalid(self, dtype): msg = "cannot safely" arr = [1.2, 2.3, 3.7] with pytest.raises(TypeError, match=msg): integer_array(arr, dtype=dtype) with pytest.raises(TypeError, match=msg): pd.Series(arr).astype(dtype) arr = [1.2, 2.3, 3.7, np.nan] with pytest.raises(TypeError, match=msg): integer_array(arr, dtype=dtype) with pytest.raises(TypeError, match=msg): pd.Series(arr).astype(dtype) @pytest.mark.parametrize("in_series", [True, False]) def test_to_numpy_na_nan(self, in_series): a = pd.array([0, 1, None], dtype="Int64") if in_series: a = pd.Series(a) result = a.to_numpy(dtype="float64", na_value=np.nan) expected = np.array([0.0, 1.0, np.nan], dtype="float64") tm.assert_numpy_array_equal(result, expected) result = a.to_numpy(dtype="int64", na_value=-1) expected = np.array([0, 1, -1], dtype="int64") tm.assert_numpy_array_equal(result, expected) result = a.to_numpy(dtype="bool", na_value=False) expected = np.array([False, True, False], dtype="bool") tm.assert_numpy_array_equal(result, expected) @pytest.mark.parametrize("in_series", [True, False]) @pytest.mark.parametrize("dtype", ["int32", "int64", "bool"]) def test_to_numpy_dtype(self, dtype, in_series): a = pd.array([0, 1], dtype="Int64") if in_series: a = pd.Series(a) result = a.to_numpy(dtype=dtype) expected = np.array([0, 1], dtype=dtype) tm.assert_numpy_array_equal(result, expected) @pytest.mark.parametrize("dtype", ["float64", "int64", "bool"]) def test_to_numpy_na_raises(self, dtype): a = pd.array([0, 1, None], dtype="Int64") with pytest.raises(ValueError, match=dtype): a.to_numpy(dtype=dtype) def test_astype_str(self): a = pd.array([1, 2, None], dtype="Int64") expected = np.array(["1", "2", "<NA>"], dtype=object) tm.assert_numpy_array_equal(a.astype(str), expected) tm.assert_numpy_array_equal(a.astype("str"), expected) def test_astype_boolean(self): # https://github.com/pandas-dev/pandas/issues/31102 a = pd.array([1, 0, -1, 2, None], dtype="Int64") result = a.astype("boolean") expected = pd.array([True, False, True, True, None], dtype="boolean") tm.assert_extension_array_equal(result, expected) def test_frame_repr(data_missing): df = pd.DataFrame({"A": data_missing}) result = repr(df) expected = " A\n0 <NA>\n1 1" assert result == expected def test_conversions(data_missing): # astype to object series df = pd.DataFrame({"A": data_missing}) result = df["A"].astype("object") expected = pd.Series(np.array([np.nan, 1], dtype=object), name="A") tm.assert_series_equal(result, expected) # convert to object ndarray # we assert that we are exactly equal # including type conversions of scalars result = df["A"].astype("object").values expected = np.array([pd.NA, 1], dtype=object) tm.assert_numpy_array_equal(result, expected) for r, e in zip(result, expected): if pd.isnull(r): assert pd.isnull(e) elif is_integer(r): assert r == e assert is_integer(e) else: assert r == e assert type(r) == type(e) def test_integer_array_constructor(): values = np.array([1, 2, 3, 4], dtype="int64") mask = np.array([False, False, False, True], dtype="bool") result = IntegerArray(values, mask) expected = integer_array([1, 2, 3, np.nan], dtype="int64") tm.assert_extension_array_equal(result, expected) msg = r".* should be .* numpy array. Use the 'integer_array' function instead" with pytest.raises(TypeError, match=msg): IntegerArray(values.tolist(), mask) with pytest.raises(TypeError, match=msg): IntegerArray(values, mask.tolist()) with pytest.raises(TypeError, match=msg): IntegerArray(values.astype(float), mask) msg = r"__init__\(\) missing 1 required positional argument: 'mask'" with pytest.raises(TypeError, match=msg): IntegerArray(values) @pytest.mark.parametrize( "a, b", [ ([1, None], [1, np.nan]), ([None], [np.nan]), ([None, np.nan], [np.nan, np.nan]), ([np.nan, np.nan], [np.nan, np.nan]), ], ) def test_integer_array_constructor_none_is_nan(a, b): result = integer_array(a) expected = integer_array(b) tm.assert_extension_array_equal(result, expected) def test_integer_array_constructor_copy(): values = np.array([1, 2, 3, 4], dtype="int64") mask = np.array([False, False, False, True], dtype="bool") result = IntegerArray(values, mask) assert result._data is values assert result._mask is mask result = IntegerArray(values, mask, copy=True) assert result._data is not values assert result._mask is not mask @pytest.mark.parametrize( "values", [ ["foo", "bar"], ["1", "2"], "foo", 1, 1.0, pd.date_range("20130101", periods=2), np.array(["foo"]), [[1, 2], [3, 4]], [np.nan, {"a": 1}], ], ) def test_to_integer_array_error(values): # error in converting existing arrays to IntegerArrays msg = ( r"(:?.* cannot be converted to an IntegerDtype)" r"|(:?values must be a 1D list-like)" ) with pytest.raises(TypeError, match=msg): integer_array(values) def test_to_integer_array_inferred_dtype(): # if values has dtype -> respect it result = integer_array(np.array([1, 2], dtype="int8")) assert result.dtype == Int8Dtype() result = integer_array(np.array([1, 2], dtype="int32")) assert result.dtype == Int32Dtype() # if values have no dtype -> always int64 result = integer_array([1, 2]) assert result.dtype == Int64Dtype() def test_to_integer_array_dtype_keyword(): result = integer_array([1, 2], dtype="int8") assert result.dtype == Int8Dtype() # if values has dtype -> override it result = integer_array(np.array([1, 2], dtype="int8"), dtype="int32") assert result.dtype == Int32Dtype() def test_to_integer_array_float(): result = integer_array([1.0, 2.0]) expected = integer_array([1, 2]) tm.assert_extension_array_equal(result, expected) with pytest.raises(TypeError, match="cannot safely cast non-equivalent"): integer_array([1.5, 2.0]) # for float dtypes, the itemsize is not preserved result = integer_array(np.array([1.0, 2.0], dtype="float32")) assert result.dtype == Int64Dtype() @pytest.mark.parametrize( "bool_values, int_values, target_dtype, expected_dtype", [ ([False, True], [0, 1], Int64Dtype(), Int64Dtype()), ([False, True], [0, 1], "Int64", Int64Dtype()), ([False, True, np.nan], [0, 1, np.nan], Int64Dtype(), Int64Dtype()), ], ) def test_to_integer_array_bool(bool_values, int_values, target_dtype, expected_dtype): result = integer_array(bool_values, dtype=target_dtype) assert result.dtype == expected_dtype expected = integer_array(int_values, dtype=target_dtype) tm.assert_extension_array_equal(result, expected) @pytest.mark.parametrize( "values, to_dtype, result_dtype", [ (np.array([1], dtype="int64"), None, Int64Dtype), (np.array([1, np.nan]), None, Int64Dtype), (np.array([1, np.nan]), "int8", Int8Dtype), ], ) def test_to_integer_array(values, to_dtype, result_dtype): # convert existing arrays to IntegerArrays result = integer_array(values, dtype=to_dtype) assert result.dtype == result_dtype() expected = integer_array(values, dtype=result_dtype()) tm.assert_extension_array_equal(result, expected) def test_cross_type_arithmetic(): df = pd.DataFrame( { "A": pd.Series([1, 2, np.nan], dtype="Int64"), "B": pd.Series([1, np.nan, 3], dtype="UInt8"), "C": [1, 2, 3], } ) result = df.A + df.C expected = pd.Series([2, 4, np.nan], dtype="Int64") tm.assert_series_equal(result, expected) result = (df.A + df.C) * 3 == 12 expected = pd.Series([False, True, None], dtype="boolean") tm.assert_series_equal(result, expected) result = df.A + df.B expected = pd.Series([2, np.nan, np.nan], dtype="Int64") tm.assert_series_equal(result, expected) @pytest.mark.parametrize("op", ["sum", "min", "max", "prod"]) def test_preserve_dtypes(op): # TODO(#22346): preserve Int64 dtype # for ops that enable (mean would actually work here # but generally it is a float return value) df = pd.DataFrame( { "A": ["a", "b", "b"], "B": [1, None, 3], "C": integer_array([1, None, 3], dtype="Int64"), } ) # op result = getattr(df.C, op)() assert isinstance(result, int) # groupby result = getattr(df.groupby("A"), op)() expected = pd.DataFrame( {"B": np.array([1.0, 3.0]), "C": integer_array([1, 3], dtype="Int64")}, index=pd.Index(["a", "b"], name="A"), ) tm.assert_frame_equal(result, expected) @pytest.mark.parametrize("op", ["mean"]) def test_reduce_to_float(op): # some reduce ops always return float, even if the result # is a rounded number df = pd.DataFrame( { "A": ["a", "b", "b"], "B": [1, None, 3], "C": integer_array([1, None, 3], dtype="Int64"), } ) # op result = getattr(df.C, op)() assert isinstance(result, float) # groupby result = getattr(df.groupby("A"), op)() expected = pd.DataFrame( {"B": np.array([1.0, 3.0]), "C": integer_array([1, 3], dtype="Int64")}, index=pd.Index(["a", "b"], name="A"), ) tm.assert_frame_equal(result, expected) def test_astype_nansafe(): # see gh-22343 arr = integer_array([np.nan, 1, 2], dtype="Int8") msg = "cannot convert to 'uint32'-dtype NumPy array with missing values." with pytest.raises(ValueError, match=msg): arr.astype("uint32") @pytest.mark.parametrize("ufunc", [np.abs, np.sign]) # np.sign emits a warning with nans, <https://github.com/numpy/numpy/issues/15127> @pytest.mark.filterwarnings("ignore:invalid value encountered in sign") def test_ufuncs_single_int(ufunc): a = integer_array([1, 2, -3, np.nan]) result = ufunc(a) expected = integer_array(ufunc(a.astype(float))) tm.assert_extension_array_equal(result, expected) s = pd.Series(a) result = ufunc(s) expected = pd.Series(integer_array(ufunc(a.astype(float)))) tm.assert_series_equal(result, expected) @pytest.mark.parametrize("ufunc", [np.log, np.exp, np.sin, np.cos, np.sqrt]) def test_ufuncs_single_float(ufunc): a = integer_array([1, 2, -3, np.nan]) with np.errstate(invalid="ignore"): result = ufunc(a) expected = ufunc(a.astype(float)) tm.assert_numpy_array_equal(result, expected) s = pd.Series(a) with np.errstate(invalid="ignore"): result = ufunc(s) expected = ufunc(s.astype(float)) tm.assert_series_equal(result, expected) @pytest.mark.parametrize("ufunc", [np.add, np.subtract]) def test_ufuncs_binary_int(ufunc): # two IntegerArrays a = integer_array([1, 2, -3, np.nan]) result = ufunc(a, a) expected = integer_array(ufunc(a.astype(float), a.astype(float))) tm.assert_extension_array_equal(result, expected) # IntegerArray with numpy array arr = np.array([1, 2, 3, 4]) result = ufunc(a, arr) expected = integer_array(ufunc(a.astype(float), arr)) tm.assert_extension_array_equal(result, expected) result = ufunc(arr, a) expected = integer_array(ufunc(arr, a.astype(float))) tm.assert_extension_array_equal(result, expected) # IntegerArray with scalar result = ufunc(a, 1) expected = integer_array(ufunc(a.astype(float), 1)) tm.assert_extension_array_equal(result, expected) result = ufunc(1, a) expected = integer_array(ufunc(1, a.astype(float))) tm.assert_extension_array_equal(result, expected) @pytest.mark.parametrize("values", [[0, 1], [0, None]]) def test_ufunc_reduce_raises(values): a = integer_array(values) msg = r"The 'reduce' method is not supported." with pytest.raises(NotImplementedError, match=msg): np.add.reduce(a) @td.skip_if_no("pyarrow", min_version="0.15.0") def test_arrow_array(data): # protocol added in 0.15.0 import pyarrow as pa arr = pa.array(data) expected = np.array(data, dtype=object) expected[data.isna()] = None expected = pa.array(expected, type=data.dtype.name.lower(), from_pandas=True) assert arr.equals(expected) @td.skip_if_no("pyarrow", min_version="0.16.0") def test_arrow_roundtrip(data): # roundtrip possible from arrow 0.16.0 import pyarrow as pa df = pd.DataFrame({"a": data}) table = pa.table(df) assert table.field("a").type == str(data.dtype.numpy_dtype) result = table.to_pandas() tm.assert_frame_equal(result, df) @td.skip_if_no("pyarrow", min_version="0.16.0") def test_arrow_from_arrow_uint(): # https://github.com/pandas-dev/pandas/issues/31896 # possible mismatch in types import pyarrow as pa dtype = pd.UInt32Dtype() result = dtype.__from_arrow__(pa.array([1, 2, 3, 4, None], type="int64")) expected = pd.array([1, 2, 3, 4, None], dtype="UInt32") tm.assert_extension_array_equal(result, expected) @pytest.mark.parametrize( "pandasmethname, kwargs", [ ("var", {"ddof": 0}), ("var", {"ddof": 1}), ("kurtosis", {}), ("skew", {}), ("sem", {}), ], ) def test_stat_method(pandasmethname, kwargs): s = pd.Series(data=[1, 2, 3, 4, 5, 6, np.nan, np.nan], dtype="Int64") pandasmeth = getattr(s, pandasmethname) result = pandasmeth(**kwargs) s2 = pd.Series(data=[1, 2, 3, 4, 5, 6], dtype="Int64") pandasmeth = getattr(s2, pandasmethname) expected = pandasmeth(**kwargs) assert expected == result def test_value_counts_na(): arr = pd.array([1, 2, 1, pd.NA], dtype="Int64") result = arr.value_counts(dropna=False) expected = pd.Series([2, 1, 1], index=[1, 2, pd.NA], dtype="Int64")
tm.assert_series_equal(result, expected)
pandas._testing.assert_series_equal
import warnings warnings.filterwarnings('ignore',category=FutureWarning) warnings.filterwarnings('ignore',category=DeprecationWarning) from configparser import ConfigParser, MissingSectionHeaderError, NoSectionError,NoOptionError import os, glob import pandas as pd from dtreeviz.trees import * from sklearn.ensemble import RandomForestClassifier from sklearn.ensemble import GradientBoostingClassifier from sklearn.model_selection import train_test_split from yellowbrick.classifier import ClassificationReport from xgboost.sklearn import XGBClassifier from imblearn.combine import SMOTEENN from imblearn.over_sampling import SMOTE from sklearn.tree import export_graphviz from subprocess import call import shap import pickle import csv import warnings import numpy as np import eli5 from eli5.sklearn import PermutationImportance import matplotlib.pyplot as plt from sklearn.model_selection import learning_curve from sklearn.model_selection import ShuffleSplit from sklearn.metrics import precision_recall_curve import graphviz import graphviz.backend from dtreeviz.shadow import * from sklearn import tree from simba.drop_bp_cords import drop_bp_cords, GenerateMetaDataFileHeaders from sklearn.metrics import make_scorer, accuracy_score, precision_score, recall_score, f1_score from sklearn.model_selection import cross_val_score, cross_validate from simba.rw_dfs import * from sklearn.feature_selection import RFECV from simba.shap_calcs import shap_summary_calculations import time # import timeit def trainmodel2(inifile): configFile = str(inifile) config = ConfigParser() try: config.read(configFile) except MissingSectionHeaderError: print('ERROR: Not a valid project_config file. Please check the project_config.ini path.') modelDir = config.get('SML settings', 'model_dir') modelDir_out = os.path.join(modelDir, 'generated_models') projectPath = config.get('General settings', 'project_path') csv_dir_in, csv_dir_out = os.path.join(projectPath, 'csv', 'targets_inserted'), os.path.join(projectPath,'csv', 'machine_results') try: wfileType = config.get('General settings', 'workflow_file_type') except NoOptionError: wfileType = 'csv' if not os.path.exists(modelDir_out): os.makedirs(modelDir_out) tree_evaluations_out = os.path.join(modelDir_out, 'model_evaluations') if not os.path.exists(tree_evaluations_out): os.makedirs(tree_evaluations_out) try: model_nos = config.getint('SML settings', 'No_targets') data_folder = config.get('create ensemble settings', 'data_folder') model_to_run = config.get('create ensemble settings', 'model_to_run') classifierName = config.get('create ensemble settings', 'classifier') train_test_size = config.getfloat('create ensemble settings', 'train_test_size') except ValueError: print('ERROR: Project_config.ini contains errors in the [create ensemble settings] or [SML settings] sections. Please check the project_config.ini file.') features = pd.DataFrame() def generateClassificationReport(clf, class_names): try: visualizer = ClassificationReport(clf, classes=class_names, support=True) visualizer.score(data_test, target_test) visualizerPath = os.path.join(tree_evaluations_out, str(classifierName) + '_classificationReport.png') g = visualizer.poof(outpath=visualizerPath, clear_figure=True) except KeyError: print(('Warning, not enough data for classification report: ') + str(classifierName)) def generateFeatureImportanceLog(importances): feature_importances = [(feature, round(importance, 2)) for feature, importance in zip(feature_list, importances)] feature_importances = sorted(feature_importances, key=lambda x: x[1], reverse=True) feature_importance_list = [('Variable: {:20} Importance: {}'.format(*pair)) for pair in feature_importances] feature_importance_list_varNm = [i.split(':' " ", 3)[1] for i in feature_importance_list] feature_importance_list_importance = [i.split(':' " ", 3)[2] for i in feature_importance_list] log_df = pd.DataFrame() log_df['Feature_name'] = feature_importance_list_varNm log_df['Feature_importance'] = feature_importance_list_importance savePath = os.path.join(tree_evaluations_out, str(classifierName) + '_feature_importance_log.csv') log_df.to_csv(savePath) return log_df def generateShapLog(trainingSet, target_train, feature_list, classifierName, shap_target_present_no,shap_target_absent_no, inifile): print('Calculating SHAP scores for ' + str(len(trainingSet)) +' observations...') trainingSet[classifierName] = target_train targetTrainSet = trainingSet.loc[trainingSet[classifierName] == 1] nonTargetTrain = trainingSet.loc[trainingSet[classifierName] == 0] try: targetsForShap = targetTrainSet.sample(shap_target_present_no, replace=False) except ValueError: print('Could not find ' + str(shap_target_present_no) + ' in dataset. Taking the maximum instead (' + str(len(targetTrainSet)) + ')') targetsForShap = targetTrainSet.sample(len(targetTrainSet), replace=False) nontargetsForShap = nonTargetTrain.sample(shap_target_absent_no, replace=False) shapTrainingSet = pd.concat([targetsForShap, nontargetsForShap]) targetValFrame = shapTrainingSet.pop(classifierName).values explainer = shap.TreeExplainer(clf, data=None, model_output='raw', feature_perturbation='tree_path_dependent') expected_value = explainer.expected_value[1] outputDfRaw = pd.DataFrame(columns=feature_list) shapHeaders = feature_list.copy() shapHeaders.extend(('Expected_value', 'Sum', 'Prediction_probability', str(classifierName))) outputDfShap = pd.DataFrame(columns=shapHeaders) counter = 0 for frame in range(len(shapTrainingSet)): currInstance = shapTrainingSet.iloc[[frame]] shap_values = explainer.shap_values(currInstance, check_additivity=False) shapList = list(shap_values[0][0]) shapList = [x * -1 for x in shapList] shapList.append(expected_value) shapList.append(sum(shapList)) probability = clf.predict_proba(currInstance) shapList.append(probability[0][1]) shapList.append(targetValFrame[frame]) currRaw = list(shapTrainingSet.iloc[frame]) outputDfRaw.loc[len(outputDfRaw)] = currRaw outputDfShap.loc[len(outputDfShap)] = shapList counter += 1 print('SHAP calculated for: ' + str(counter) + '/' + str(len(shapTrainingSet)) + ' frames') outputDfShap.to_csv(os.path.join(tree_evaluations_out, 'SHAP_values_' + str(classifierName) + '.csv')) print('Creating SHAP summary statistics...') shap_summary_calculations(inifile, outputDfShap, classifierName, expected_value, tree_evaluations_out) outputDfRaw.to_csv(os.path.join(tree_evaluations_out, 'RAW_SHAP_feature_values_' + str(classifierName) + '.csv')) print('All SHAP data saved in project_folder/models/evaluations directory') def perf_RFCVE(projectPath, RFCVE_CVs, RFCVE_step_size, clf, data_train, target_train, feature_list): selector = RFECV(estimator=clf, step=RFCVE_step_size, cv=RFCVE_CVs, scoring='f1', verbose=1) selector = selector.fit(data_train, target_train) selectorSupport = selector.support_.tolist() trueIndex = np.where(selectorSupport) trueIndex = list(trueIndex[0]) selectedFeatures = [feature_list[i] for i in trueIndex] selectedFeaturesDf = pd.DataFrame(selectedFeatures, columns=['Selected_features']) savePath = os.path.join(tree_evaluations_out, 'RFECV_selected_features_' + str(classifierName) + '.csv') selectedFeaturesDf.to_csv(savePath) print('Recursive feature elimination results stored in ' + str(savePath)) def generateFeatureImportanceBarGraph(log_df, N_feature_importance_bars): log_df['Feature_importance'] = log_df['Feature_importance'].apply(pd.to_numeric) log_df['Feature_name'] = log_df['Feature_name'].map(lambda x: x.lstrip('+-').rstrip('Importance')) log_df = log_df.head(N_feature_importance_bars) ax = log_df.plot.bar(x='Feature_name', y='Feature_importance', legend=False, rot=90, fontsize=6) figName = str(classifierName) + '_feature_bars.png' figSavePath = os.path.join(tree_evaluations_out, figName) plt.ylabel('Feature_importance (mean decrease impurity)') plt.tight_layout() plt.savefig(figSavePath, dpi=600) plt.close('all') def generateExampleDecisionTree(estimator): dot_name = os.path.join(tree_evaluations_out, str(classifierName) + '_tree.dot') file_name = os.path.join(tree_evaluations_out, str(classifierName) + '_tree.pdf') export_graphviz(estimator, out_file=dot_name, filled=True, rounded=True, special_characters=False, impurity=False, class_names=class_names, feature_names=data_train.columns) commandStr = ('dot ' + str(dot_name) + ' -T pdf -o ' + str(file_name) + ' -Gdpi=600') call(commandStr, shell=True) def generateMetaData(metaDataList): metaDataFn = str(classifierName) + '_meta.csv' metaDataPath = os.path.join(modelDir_out, metaDataFn) metaDataHeaders = GenerateMetaDataFileHeaders() with open(metaDataPath, 'w', newline='') as f: out_writer = csv.writer(f) out_writer.writerow(metaDataHeaders) out_writer.writerow(metaDataList) def computePermutationImportance(data_test, target_test, clf): perm = PermutationImportance(clf, random_state=1).fit(data_test, target_test) permString = (eli5.format_as_text(eli5.explain_weights(perm, feature_names=data_test.columns.tolist()))) permString = permString.split('\n', 9)[-1] all_rows = permString.split("\n") all_cols = [row.split(' ') for row in all_rows] all_cols.pop(0) fimp = [row[0] for row in all_cols] errot = [row[2] for row in all_cols] name = [row[4] for row in all_cols] dfvals = pd.DataFrame(list(zip(fimp, errot, name)), columns=['A', 'B', 'C']) fname = os.path.join(tree_evaluations_out, str(classifierName) + '_permutations_importances.csv') dfvals.to_csv(fname, index=False) def LearningCurve(features, targetFrame, shuffle_splits, dataset_splits): newDataTargets = np.concatenate((target_train, target_test), axis=0) newDataFeatures = np.concatenate((data_train, data_test), axis=0) cv = ShuffleSplit(n_splits=shuffle_splits, test_size=train_test_size, random_state=0) model = RandomForestClassifier(n_estimators=RF_n_estimators, max_features=RF_max_features, n_jobs=-1, criterion=RF_criterion, min_samples_leaf=RF_min_sample_leaf, bootstrap=True, verbose=0) train_sizes, train_scores, test_scores = learning_curve(model, newDataFeatures, newDataTargets, cv=cv, scoring='f1', shuffle=True, n_jobs=-1, verbose=1, train_sizes=np.linspace(0.01, 1.0, dataset_splits)) train_sizes = np.linspace(0.01, 1.0, dataset_splits) train_mean = np.mean(train_scores, axis=1) test_mean = np.mean(test_scores, axis=1) train_std = np.std(train_scores, axis=1) test_std = np.std(test_scores, axis=1) learningCurve_df = pd.DataFrame() learningCurve_df['Fraction Train Size'] = train_sizes learningCurve_df['Train_mean_f1'] = train_mean learningCurve_df['Test_mean_f1'] = test_mean learningCurve_df['Train_std_f1'] = train_std learningCurve_df['Test_std_f1'] = test_std fname = os.path.join(tree_evaluations_out, str(classifierName) + '_learning_curve.csv') learningCurve_df.to_csv(fname, index=False) def dviz_classification_visualization(data_train, target_train, classifierName): clf = tree.DecisionTreeClassifier(max_depth=5, random_state=666) clf.fit(data_train, target_train) svg_tree = dtreeviz(clf, data_train, target_train, target_name=classifierName, feature_names=data_train.columns, orientation="TD", class_names=[classifierName, 'not_' + classifierName], fancy=True, histtype='strip', X=None, label_fontsize=12, ticks_fontsize=8, fontname="Arial") fname = os.path.join(tree_evaluations_out, str(classifierName) + 'fancy_decision_tree_example.svg') svg_tree.save(fname) # READ IN DATA FOLDER AND REMOVE ALL NON-FEATURE VARIABLES (POP DLC COORDINATE DATA AND TARGET DATA) print('Reading in ' + str(len(glob.glob(data_folder + '/*.' + wfileType))) + ' annotated files...') filesFound = glob.glob(csv_dir_in + '/*.' + wfileType) for file in filesFound: df = read_df(file, wfileType) df = df.dropna(axis=0, how='all') df = df.dropna() # jj inserted this, delete if needed features = features.append(df, ignore_index=True) try: features = features.set_index('scorer') except KeyError: pass features = features.loc[:, ~features.columns.str.contains('^Unnamed')] totalTargetframes = features[classifierName].sum() try: targetFrame = features.pop(classifierName).values except KeyError: print('Error: the dataframe does not contain any target annotations. Please check the csv files in the project_folder/csv/target_inserted folder') features = features.fillna(0) try: features = drop_bp_cords(features, inifile) except KeyError: print('Could not drop bodypart coordinates, bodypart coordinates missing in dataframe') target_names = [] loop = 1 for i in range(model_nos): currentModelNames = 'target_name_' + str(loop) currentModelNames = config.get('SML settings', currentModelNames) if currentModelNames != classifierName: target_names.append(currentModelNames) loop += 1 print('# of models to be created: 1') for i in range(len(target_names)): currentModelName = target_names[i] features.pop(currentModelName).values class_names = class_names = ['Not_' + classifierName, classifierName] feature_list = list(features) print('# of features in dataset: ' + str(len(feature_list))) # IF SET BY USER - PERFORM UNDERSAMPLING AND OVERSAMPLING IF SET BY USER data_train, data_test, target_train, target_test = train_test_split(features, targetFrame, test_size=train_test_size) under_sample_setting = config.get('create ensemble settings', 'under_sample_setting') over_sample_setting = config.get('create ensemble settings', 'over_sample_setting') trainDf = data_train trainDf[classifierName] = target_train targetFrameRows = trainDf.loc[trainDf[classifierName] == 1] print('# of ' + str(classifierName) + ' frames in dataset: ' + str(totalTargetframes)) if under_sample_setting == 'Random undersample': try: print('Performing undersampling...') under_sample_ratio = config.getfloat('create ensemble settings', 'under_sample_ratio') nonTargetFrameRows = trainDf.loc[trainDf[classifierName] == 0] nontargetFrameRowsSize = int(len(targetFrameRows) * under_sample_ratio) nonTargetFrameRows = nonTargetFrameRows.sample(nontargetFrameRowsSize, replace=False) trainDf =
pd.concat([targetFrameRows, nonTargetFrameRows])
pandas.concat
############################################################################## # # An example of positioning dataframes in a worksheet using Pandas and # XlsxWriter. # # Copyright 2013-2017, <NAME>, <EMAIL> # from builtins import str import pandas as pd from openpyxl import load_workbook import numpy as np # Create some Pandas dataframes from some data. df1 = pd.DataFrame({'Data': [11, 12, 13, 14,18]}) df2 = pd.DataFrame({'Data': [21, 22, 23, 24]}) df3 = pd.DataFrame({'Data': [31, 32, 33, 34]}) df4 = pd.DataFrame({'Data': [41, 42, 43, 44]}) # Create a Pandas Excel writer using XlsxWriter as the engine. writer = pd.ExcelWriter('pandas_positioning.xlsx', engine='xlsxwriter') # Position the dataframes in the worksheet. df1.to_excel(writer, sheet_name='Sheet1') # Default position, cell A1. df2.to_excel(writer, sheet_name='Sheet1', startcol=3) df3.to_excel(writer, sheet_name='Sheet1', startrow=6) # It is also possible to write the dataframe without the header and index. df4.to_excel(writer, sheet_name='Sheet1', startrow=7, startcol=4, index_label='test', header=False, index=True) # Close the Pandas Excel writer and output the Excel file. worksheet = writer.sheets['Sheet1'] #number_of_rows = worksheet.nrows worksheet.set_column(1,1000, 30) writer.save() # col: measure row: file book = load_workbook('pandas_positioning.xlsx') writer = pd.ExcelWriter('pandas_positioning.xlsx',engine='openpyxl') writer.book = book writer.sheets = dict((ws.title, ws) for ws in book.worksheets) labels =['a','b','c','d','e'] measures=['iou','precision','recall','dice'] names = ['file1', 'file2', 'file3'] #data = {'measures':[measure*len(label) for measure in measures]} res = np.random.randn(3,5) data = {'iou':res,'precision':res,'recall':res,'dice':res} row_index = np.asarray(names) column_index = [measure+'_' + str(label) for measure in measures for label in labels ] formated_data = {measure+'_' + str(label): data[measure][:,j] for measure in measures for j, label in enumerate(labels) } df = pd.DataFrame.from_dict(formated_data) df.index = pd.Index(row_index) df = df[column_index] df.to_excel(writer, sheet_name ='sheet2') writer.save() df.to_excel(writer, sheet_name ='sheet3') writer.save() # col: file row: measure book = load_workbook('pandas_positioning.xlsx') writer = pd.ExcelWriter('pandas_positioning.xlsx',engine='openpyxl') writer.book = book writer.sheets = dict((ws.title, ws) for ws in book.worksheets) labels =['a','b','c','d','e'] measures=['iou','precision','recall','dice'] names = ['file1', 'file2', 'file3'] #data = {'measures':[measure*len(label) for measure in measures]} data = {'iou':res,'precision':res,'recall':res,'dice':res} column_index = np.asarray(names) row_index = [measure+'_' + str(label) for measure in measures for label in labels ] formated_data = {name: np.concatenate([data[measure][id] for measure in measures]).tolist() for id, name in enumerate(names) } df =
pd.DataFrame.from_dict(formated_data)
pandas.DataFrame.from_dict
"""This module contains PlainFrame and PlainColumn tests. """ import collections import datetime import pytest import numpy as np import pandas as pd from numpy.testing import assert_equal as np_assert_equal from pywrangler.util.testing.plainframe import ( NULL, ConverterFromPandas, NaN, PlainColumn, PlainFrame ) @pytest.fixture def plainframe_standard(): cols = ["int", "float", "bool", "str", "datetime"] data = [[1, 1.1, True, "string", "2019-01-01 10:00:00"], [2, 2, False, "string2", "2019-02-01 10:00:00"]] return PlainFrame.from_plain(data=data, dtypes=cols, columns=cols) @pytest.fixture def plainframe_missings(): cols = ["int", "float", "bool", "str", "datetime"] data = [[1, 1.1, True, "string", "2019-01-01 10:00:00"], [2, NaN, False, "string2", "2019-02-01 10:00:00"], [NULL, NULL, NULL, NULL, NULL]] return PlainFrame.from_plain(data=data, dtypes=cols, columns=cols) @pytest.fixture def df_from_pandas(): df = pd.DataFrame( {"int": [1, 2], "int_na": [1, np.NaN], "bool": [True, False], "bool_na": [True, np.NaN], "float": [1.2, 1.3], "float_na": [1.2, np.NaN], "str": ["foo", "bar"], "str_na": ["foo", np.NaN], "datetime": [pd.Timestamp("2019-01-01"), pd.Timestamp("2019-01-02")], "datetime_na": [pd.Timestamp("2019-01-01"), pd.NaT]}) return df @pytest.fixture def df_from_spark(spark): from pyspark.sql import types values = collections.OrderedDict( {"int": [1, 2, None], "smallint": [1, 2, None], "bigint": [1, 2, None], "bool": [True, False, None], "single": [1.0, NaN, None], "double": [1.0, NaN, None], "str": ["foo", "bar", None], "datetime": [datetime.datetime(2019, 1, 1), datetime.datetime(2019, 1, 2), None], "date": [datetime.date(2019, 1, 1), datetime.date(2019, 1, 2), None], "map": [{"foo": "bar"}, {"bar": "foo"}, None], "array": [[1, 2, 3], [3, 4, 5], None]} ) data = list(zip(*values.values())) c = types.StructField columns = [c("int", types.IntegerType()), c("smallint", types.ShortType()), c("bigint", types.LongType()), c("bool", types.BooleanType()), c("single", types.FloatType()), c("double", types.DoubleType()), c("str", types.StringType()), c("datetime", types.TimestampType()), c("date", types.DateType()), c("map", types.MapType(types.StringType(), types.StringType())), c("array", types.ArrayType(types.IntegerType()))] schema = types.StructType(columns) return spark.createDataFrame(data, schema=schema) def create_plain_frame(cols, rows, reverse_cols=False, reverse_rows=False): """Helper function to automatically create instances of PlainFrame. `cols` contains typed column annotations like "col1:int". """ if reverse_cols: cols = cols[::-1] columns, dtypes = zip(*[col.split(":") for col in cols]) values = list(range(1, rows + 1)) mapping = {"str": list(map(str, values)), "int": values, "float": list(map(float, values)), "bool": list([x % 2 == 0 for x in values]), "datetime": ["2019-01-{:02} 10:00:00".format(x) for x in values]} data = [mapping[dtype] for dtype in dtypes] data = list(zip(*data)) if reverse_rows: data = data[::-1] return PlainFrame.from_plain(data=data, dtypes=dtypes, columns=columns) def create_plainframe_single(values, dtype): """Create some special scenarios more easily. Always assumes a single column with identical name. Only values and dtype varies. """ data = [[x] for x in values] dtypes = [dtype] columns = ["name"] return PlainFrame.from_plain(data=data, dtypes=dtypes, columns=columns) def test_plainframe(): # incorrect instantiation with non tuples with non factory method plain_column = PlainColumn.from_plain(name="int", dtype="int", values=[1, 2, 3]) # correct instantiation PlainFrame(plaincolumns=(plain_column,)) with pytest.raises(ValueError): PlainFrame(plaincolumns=[plain_column]) with pytest.raises(ValueError): PlainFrame(plaincolumns=[1]) def test_plainframe_from_plain_pandas_empty(): # tests GH#29 df = PlainFrame.from_plain(data=[], columns=["col1:int", "col2:str"]) col_values = lambda x: df.get_column(x).values assert df.n_rows == 0 assert df.columns == ["col1", "col2"] assert df.dtypes == ["int", "str"] assert col_values("col1") == tuple() assert col_values("col2") == tuple() dfp = pd.DataFrame(columns=["col1", "col2"], dtype=int) df = PlainFrame.from_pandas(dfp) col_values = lambda x: df.get_column(x).values assert df.n_rows == 0 assert df.columns == ["col1", "col2"] assert df.dtypes == ["int", "int"] assert col_values("col1") == tuple() assert col_values("col2") == tuple() def test_plainframe_attributes(plainframe_missings): df = plainframe_missings col_values = lambda x: df.get_column(x).values assert df.columns == ["int", "float", "bool", "str", "datetime"] assert df.dtypes == ["int", "float", "bool", "str", "datetime"] assert col_values("int") == (1, 2, NULL) assert col_values("str") == ("string", "string2", NULL) assert col_values("datetime")[0] == datetime.datetime(2019, 1, 1, 10) def test_plainframe_modify(): # change single value df_origin = create_plainframe_single([1, 2], "int") df_target = create_plainframe_single([1, 1], "int") assert df_origin.modify({"name": {1: 1}}) == df_target # change multiple values df_origin = create_plainframe_single([1, 2], "int") df_target = create_plainframe_single([3, 3], "int") assert df_origin.modify({"name": {0: 3, 1: 3}}) == df_target # change multiple columns df_origin = PlainFrame.from_plain(data=[[1, 2], ["a", "b"]], dtypes=["int", "str"], columns=["int", "str"], row_wise=False) df_target = PlainFrame.from_plain(data=[[1, 1], ["a", "a"]], dtypes=["int", "str"], columns=["int", "str"], row_wise=False) assert df_origin.modify({"int": {1: 1}, "str": {1: "a"}}) == df_target def test_plainframe_modify_assertions(): # check incorrect type conversion df = create_plainframe_single([1, 2], "int") with pytest.raises(TypeError): df.modify({"name": {0: "asd"}}) def test_plainframe_getitem_subset(): df = create_plain_frame(["col1:str", "col2:int", "col3:int"], 2) df_sub = create_plain_frame(["col1:str", "col2:int"], 2) cmp_kwargs = dict(assert_column_order=True, assert_row_order=True) # test list of strings, slice and string df["col1", "col2"].assert_equal(df_sub, **cmp_kwargs) df["col1":"col2"].assert_equal(df_sub, **cmp_kwargs) df["col1"].assert_equal(df_sub["col1"], **cmp_kwargs) # test incorrect type with pytest.raises(ValueError): df[{"col1"}] # test invalid column name with pytest.raises(ValueError): df["non_existant"] def test_plainframe_get_column(): df = create_plain_frame(["col1:str", "col2:int"], 2) assert df.get_column("col1") is df.plaincolumns[0] # check value error for non existent column with pytest.raises(ValueError): df.get_column("does_not_exist") def test_plainframe_parse_typed_columns(): parse = PlainFrame._parse_typed_columns # invalid splits cols = ["col1:int", "col2"] with pytest.raises(ValueError): parse(cols) # invalid types cols = ["col1:asd"] with pytest.raises(ValueError): parse(cols) # invalid abbreviations cols = ["col1:a"] with pytest.raises(ValueError): parse(cols) # correct types and columns cols = ["col1:str", "col2:s", "col3:int", "col4:i", "col5:float", "col6:f", "col7:bool", "col8:b", "col9:datetime", "col10:d"] names = ["col{}".format(x) for x in range(1, 11)] dtypes = ["str", "str", "int", "int", "float", "float", "bool", "bool", "datetime", "datetime"] result = (names, dtypes) np_assert_equal(parse(cols), result) def test_plainframe_from_plain(): # unequal elements per row with pytest.raises(ValueError): PlainFrame.from_plain(data=[[1, 2], [1]], columns=["a", "b"], dtypes=["int", "int"]) # mismatch between number of columns and entries per row with pytest.raises(ValueError): PlainFrame.from_plain(data=[[1, 2], [1, 2]], columns=["a"], dtypes=["int", "int"]) # mismatch between number of dtypes and entries per row with pytest.raises(ValueError): PlainFrame.from_plain(data=[[1, 2], [1, 2]], columns=["a", "b"], dtypes=["int"]) # incorrect dtypes with pytest.raises(ValueError): PlainFrame.from_plain(data=[[1, 2], [1, 2]], columns=["a", "b"], dtypes=["int", "bad_type"]) # type errors conversion with pytest.raises(TypeError): PlainFrame.from_plain(data=[[1, 2], [1, 2]], columns=["a", "b"], dtypes=["int", "str"]) with pytest.raises(TypeError): PlainFrame.from_plain(data=[[1, 2], [1, 2]], columns=["a", "b"], dtypes=["int", "bool"]) with pytest.raises(TypeError): PlainFrame.from_plain(data=[["1", 2], ["1", 2]], columns=["a", "b"], dtypes=["float", "int"]) with pytest.raises(TypeError): PlainFrame.from_plain(data=[["1", 2], ["1", 2]], columns=["a", "b"], dtypes=["str", "str"]) with pytest.raises(TypeError): PlainFrame.from_plain(data=[[True, 2], [False, 2]], columns=["a", "b"], dtypes=["datetime", "int"]) # correct implementation should not raise PlainFrame.from_plain(data=[[1, 2], [1, 2]], columns=["a", "b"], dtypes=["int", "int"]) def test_plainframe_to_plain(): columns = dtypes = ["int", "float", "bool", "str"] data = [[1, 1.1, True, "string"], [2, 2, False, "string2"]] pf = PlainFrame.from_plain(data=data, columns=columns, dtypes=dtypes) expected = (data, columns, dtypes) assert pf.to_plain() == expected def test_plainframe_from_dict(): data = collections.OrderedDict( [("col1:int", [1, 2, 3]), ("col2:s", ["a", "b", "c"])] ) df = PlainFrame.from_dict(data) # check correct column order and dtypes np_assert_equal(df.columns, ("col1", "col2")) np_assert_equal(df.dtypes, ["int", "str"]) # check correct values np_assert_equal(df.get_column("col1").values, (1, 2, 3)) np_assert_equal(df.get_column("col2").values, ("a", "b", "c")) def test_plainframe_to_dict(): df = create_plain_frame(["col2:str", "col1:int"], 2) to_dict = df.to_dict() keys = list(to_dict.keys()) values = list(to_dict.values()) # check column order and dtypes np_assert_equal(keys, ["col2:str", "col1:int"]) # check values np_assert_equal(values[0], ["1", "2"]) np_assert_equal(values[1], [1, 2]) def test_plainframe_from_pandas(df_from_pandas): df = df_from_pandas df_conv = PlainFrame.from_pandas(df) # check int to int assert df_conv.get_column("int").dtype == "int" assert df_conv.get_column("int").values == (1, 2) # check bool to bool assert df_conv.get_column("bool").dtype == "bool" assert df_conv.get_column("bool").values == (True, False) # check bool (object) to bool with nan assert df_conv.get_column("bool_na").dtype == "bool" assert df_conv.get_column("bool_na").values == (True, NULL) # check float to float assert df_conv.get_column("float").dtype == "float" assert df_conv.get_column("float").values == (1.2, 1.3) # check float to float with nan assert df_conv.get_column("float_na").dtype == "float" np_assert_equal(df_conv.get_column("float_na").values, (1.2, NaN)) # check str to str assert df_conv.get_column("str").dtype == "str" assert df_conv.get_column("str").values == ("foo", "bar") # check str to str with nan assert df_conv.get_column("str_na").dtype == "str" assert df_conv.get_column("str_na").values == ("foo", NULL) # check datetime to datetime assert df_conv.get_column("datetime").dtype == "datetime" assert df_conv.get_column("datetime").values == \ (datetime.datetime(2019, 1, 1), datetime.datetime(2019, 1, 2)) # check datetime to datetime with nan assert df_conv.get_column("datetime_na").dtype == "datetime" assert df_conv.get_column("datetime_na").values == ( datetime.datetime(2019, 1, 1), NULL) def test_plainframe_from_pandas_assertions_missings_cast(): # check mixed dtype raise df = pd.DataFrame({"mixed": [1, "foo bar"]}) with pytest.raises(TypeError): PlainFrame.from_pandas(df) # check assertion for incorrect forces # too many types provided with pytest.raises(ValueError): PlainFrame.from_pandas(df, dtypes=["int", "str"]) with pytest.raises(ValueError): PlainFrame.from_pandas(df, dtypes={"mixed": "str", "dummy": "int"}) # invalid dtypes provided with pytest.raises(ValueError): PlainFrame.from_pandas(df, dtypes=["not existant type"]) with pytest.raises(ValueError): PlainFrame.from_pandas(df, dtypes={"mixed": "not existant type"}) # invalid column names provided with pytest.raises(ValueError): PlainFrame.from_pandas(df, dtypes={"dummy": "str"}) # check int to forced int with nan df = pd.DataFrame({"int": [1, np.NaN]}) df_conv = PlainFrame.from_pandas(df, dtypes=["int"]) assert df_conv.get_column("int").dtype == "int" assert df_conv.get_column("int").values == (1, NULL) # check force int to float df = pd.DataFrame({"int": [1, 2]}) df_conv = PlainFrame.from_pandas(df, dtypes=["float"]) assert df_conv.get_column("int").dtype == "float" assert df_conv.get_column("int").values == (1.0, 2.0) # check force float to int df = pd.DataFrame({"float": [1.0, 2.0]}) df_conv = PlainFrame.from_pandas(df, dtypes=["int"]) assert df_conv.get_column("float").dtype == "int" assert df_conv.get_column("float").values == (1, 2) # check force str to datetime df = pd.DataFrame({"datetime": ["2019-01-01", "2019-01-02"]}) df_conv = PlainFrame.from_pandas(df, dtypes=["datetime"]) assert df_conv.get_column("datetime").dtype == "datetime" assert df_conv.get_column("datetime").values == \ (datetime.datetime(2019, 1, 1), datetime.datetime(2019, 1, 2)) # dtype object with strings and nan should pass correctly df = pd.DataFrame({"str": ["foo", "bar", NaN]}, dtype=object) df_conv = PlainFrame.from_pandas(df) assert df_conv.get_column("str").dtype == "str" assert df_conv.get_column("str").values == ("foo", "bar", NULL) def test_plainframe_from_pandas_inspect_dtype(): inspect = ConverterFromPandas.inspect_dtype # raise if incorrect type ser = pd.Series("asd", dtype=object) with pytest.raises(TypeError): inspect(ser) def test_plainframe_from_pandas_inspect_dtype_object(): inspect = ConverterFromPandas.inspect_dtype_object # ensure string with missings df = pd.DataFrame({"dummy": ["asd", NaN]}) conv = ConverterFromPandas(df) assert conv.inspect_dtype_object("dummy") == "str" # check incorrect dtype df = pd.DataFrame({"dummy": ["asd", tuple([1, 2])]}) conv = ConverterFromPandas(df) with pytest.raises(TypeError): conv.inspect_dtype_object("dummy") def test_plainframe_to_pandas(plainframe_standard): from pandas.api import types df = plainframe_standard.to_pandas() assert types.is_integer_dtype(df["int"]) assert df["int"][0] == 1 assert df["int"].isnull().sum() == 0 assert types.is_float_dtype(df["float"]) assert df["float"].isnull().sum() == 0 assert df["float"][1] == 2.0 assert types.is_bool_dtype(df["bool"]) np_assert_equal(df["bool"][0], True) assert df["bool"].isnull().sum() == 0 assert
types.is_object_dtype(df["str"])
pandas.api.types.is_object_dtype
# -*- coding: utf-8 -*- """ Created on Wed Aug 5 13:24:18 2020 @author: earne """ from collections import defaultdict import matplotlib.pyplot as plt import numpy as np import pandas as pd from scipy import stats import seaborn as sns from sipperplots import ( get_any_idi, get_side_idi, get_content_idi, get_chronogram_vals, preproc_averaging ) def format_avg_output(output, averaging): if averaging == 'datetime': output.index.name = 'Date' elif averaging == 'time': first = output.index[0] output.index = [i - first for i in output.index] output.index = (output.index.total_seconds()/3600).astype(int) output.index.name = 'Hours Since {}:00'.format(str(first.hour)) elif averaging == 'elapsed': output.index = output.index.astype(int) output.index.name = 'Elapsed Hours' return output def drinkcount_cumulative(sipper, show_left=True, show_right=True, show_content=[], **kwargs): output = pd.DataFrame() df = sipper.data if 'date_filter' in kwargs: s, e = kwargs['date_filter'] df = df[(df.index >= s) & (df.index <= e)].copy() if show_left: l = pd.DataFrame({'LeftCount' : df['LeftCount']}, index=df.index) output = output.join(l, how='outer') if show_right: r = pd.DataFrame({'RightCount' : df['RightCount']}, index=df.index) output = output.join(r, how='outer') if show_content: for c in show_content: count = sipper.get_content_values(c, out='Count', df=df) if not count.empty: temp = pd.DataFrame({c +'Count' : count}, index=count.index) output = output.join(temp, how='outer') return output def drinkcount_binned(sipper, binsize='1H', show_left=True, show_right=True, show_content=[], **kwargs): output = pd.DataFrame() df = sipper.data if 'date_filter' in kwargs: s, e = kwargs['date_filter'] df = df[(df.index >= s) & (df.index <= e)].copy() base = df.index[0].hour if show_left: binned = df['LeftCount'].diff().resample(binsize, base=base).sum() l = pd.DataFrame({'LeftCount' : binned}, index=binned.index) output = output.join(l, how='outer') if show_right: binned = df['RightCount'].diff().resample(binsize, base=base).sum() r = pd.DataFrame({'RightCount' : binned}, index=binned.index) output = output.join(r, how='outer') if show_content: for c in show_content: count = sipper.get_content_values(c, out='Count', df=df) binned = count.diff().resample(binsize, base=base).sum() if not count.empty: temp = pd.DataFrame({c+'Count' : binned}, index=binned.index) output = output.join(temp, how='outer') return output def drinkduration_cumulative(sipper, show_left=True, show_right=True, show_content=[], **kwargs): output = pd.DataFrame() df = sipper.data if 'date_filter' in kwargs: s, e = kwargs['date_filter'] df = df[(df.index >= s) & (df.index <= e)].copy() if show_left: l = pd.DataFrame({'LeftDuration' : df['LeftDuration']}, index=df.index) output = output.join(l, how='outer') if show_right: r = pd.DataFrame({'RightDuration' : df['RightDuration']}, index=df.index) output = output.join(r, how='outer') if show_content: for c in show_content: count = sipper.get_content_values(c, out='Count', df=df) if not count.empty: temp = pd.DataFrame({c+'Duration' : count}, index=count.index) output = output.join(temp, how='outer') return output def drinkduration_binned(sipper, binsize='1H', show_left=True, show_right=True, show_content=[], **kwargs): output = pd.DataFrame() df = sipper.data if 'date_filter' in kwargs: s, e = kwargs['date_filter'] df = df[(df.index >= s) & (df.index <= e)].copy() base = df.index[0].hour if show_left: binned = df['LeftDuration'].diff().resample(binsize, base=base).sum() l = pd.DataFrame({'LeftDuration' : binned}, index=binned.index) output = output.join(l, how='outer') if show_right: binned = df['RightDuration'].diff().resample(binsize, base=base).sum() r = pd.DataFrame({'RightDuration' : binned}, index=binned.index) output = output.join(r, how='outer') if show_content: for c in show_content: count = sipper.get_content_values(c, out='Count', df=df) binned = count.diff().resample(binsize, base=base).sum() if not count.empty: temp = pd.DataFrame({c+'Duration' : binned}, index=binned.index) output = output.join(temp, how='outer') return output def interdrink_intervals(sippers, kde=True, logx=True, combine=False, **kwargs): if combine: output = idi_onecurve(sippers, kde, logx, **kwargs) else: output = idi_multicurve(sippers, kde, logx, **kwargs) return output def idi_onecurve(sippers, kde, logx, **kwargs): bar_df = pd.DataFrame() kde_df = pd.DataFrame() combined = [] for sipper in sippers: fig = plt.figure() plt.clf() df = sipper.data.copy() if 'date_filter' in kwargs: s, e = kwargs['date_filter'] df = df[(df.index >= s) & (df.index <= e)].copy() y = get_any_idi(sipper) if logx: y = [np.log10(val) for val in y if not pd.isna(val) if val != 0] bins = np.round(np.arange(-2, 5, .1), 2) else: bins = np.linspace(0, 900, 50) combined += list(y) plot = sns.distplot(combined, bins=bins, norm_hist=False, kde=kde) if kde: if plot.get_lines(): line = plot.get_lines()[0] x, y = line.get_data() kde_df = kde_df.reindex(x) kde_df['Values'] = y bar_x = [v.get_x() for v in plot.patches] bar_h = [v.get_height() for v in plot.patches] bar_df = bar_df.reindex(bar_x) bar_df['Values'] = bar_h bar_df.index.name = 'log10(minutes)' if logx else 'minutes' kde_df.index.name = 'log10(minutes)' if logx else 'minutes' plt.close() return bar_df, kde_df def idi_multicurve(sippers, kde, logx, **kwargs): bar_df = pd.DataFrame() kde_df = pd.DataFrame() for sipper in sippers: fig = plt.figure() plt.clf() df = sipper.data.copy() if 'date_filter' in kwargs: s, e = kwargs['date_filter'] df = df[(df.index >= s) & (df.index <= e)].copy() y = get_any_idi(sipper) if logx: y = [np.log10(val) for val in y if not pd.isna(val) if val != 0] bins = np.round(np.arange(-2, 5, .1), 2) else: bins = np.linspace(0, 900, 50) plot = sns.distplot(y, bins=bins, norm_hist=False, kde=kde) bar_x = [v.get_x() for v in plot.patches] bar_h = [v.get_height() for v in plot.patches] btemp = pd.DataFrame({sipper.filename : bar_h}, index=bar_x) bar_df = bar_df.join(btemp, how='outer') if kde: if plot.get_lines(): line = plot.get_lines()[0] x, y = line.get_data() ktemp = pd.DataFrame({sipper.filename : y}, index=x) kde_df = kde_df.join(ktemp, how='outer') plt.close() bar_df.index.name = 'log10(minutes)' if logx else 'minutes' kde_df.index.name = 'log10(minutes)' if logx else 'minutes' return bar_df, kde_df def interdrink_intervals_byside(sippers, kde=True, logx=True, **kwargs): bar_df = pd.DataFrame() kde_df = pd.DataFrame() for side in ['Left', 'Right']: combined = [] fig = plt.figure() plt.clf() for sipper in sippers: df = sipper.data.copy() if 'date_filter' in kwargs: s, e = kwargs['date_filter'] df = df[(df.index >= s) & (df.index <= e)].copy() y = get_side_idi(sipper, side) if logx: y = [np.log10(val) for val in y if not pd.isna(val) if val != 0] bins = np.round(np.arange(-2, 5, .1), 2) else: bins = np.linspace(0, 900, 50) combined += list(y) plot = sns.distplot(combined, bins=bins, norm_hist=False, kde=kde) if kde: if plot.get_lines(): line = plot.get_lines()[0] x, y = line.get_data() ktemp = pd.DataFrame({side:y}, index=x) kde_df = kde_df.join(ktemp, how='outer') bar_x = [v.get_x() for v in plot.patches] bar_h = [v.get_height() for v in plot.patches] btemp = pd.DataFrame({side:bar_h}, index=bar_x) bar_df = bar_df.join(btemp, how='outer') plt.close() bar_df.index.name = 'log10(minutes)' if logx else 'minutes' kde_df.index.name = 'log10(minutes)' if logx else 'minutes' return bar_df, kde_df def interdrink_intervals_bycontent(sippers, idi_content, kde=True, logx=True, **kwargs): bar_df = pd.DataFrame() kde_df = pd.DataFrame() for c in idi_content: combined = [] fig = plt.figure() plt.clf() for sipper in sippers: df = sipper.data.copy() if 'date_filter' in kwargs: s, e = kwargs['date_filter'] df = df[(df.index >= s) & (df.index <= e)].copy() y = get_content_idi(sipper, c, df=df) if logx: y = [np.log10(val) for val in y if not pd.isna(val) if val != 0] bins = np.round(np.arange(-2, 5, .1), 2) else: bins = np.linspace(0, 900, 50) combined += list(y) plot = sns.distplot(combined, bins=bins, norm_hist=False, kde=kde) if kde: if plot.get_lines(): line = plot.get_lines()[0] x, y = line.get_data() ktemp = pd.DataFrame({c:y}, index=x) kde_df = kde_df.join(ktemp, how='outer') bar_x = [v.get_x() for v in plot.patches] bar_h = [v.get_height() for v in plot.patches] btemp = pd.DataFrame({c:bar_h}, index=bar_x) bar_df = bar_df.join(btemp, how='outer') plt.close() bar_df.index.name = 'log10(minutes)' if logx else 'minutes' kde_df.index.name = 'log10(minutes)' if logx else 'minutes' return bar_df, kde_df def drinkcount_chronogram(sipper, circ_left=True, circ_right=True, circ_content=None, lights_on=7, lights_off=19, **kwargs): output = pd.DataFrame() df = sipper.data if 'date_filter' in kwargs: s, e = kwargs['date_filter'] df = df[(df.index >= s) & (df.index <= e)].copy() to_plot = [] labels = [] if circ_left: to_plot.append(df['LeftCount']) labels.append('Left') if circ_right: to_plot.append(df['RightCount']) labels.append('Right') if circ_content: for c in circ_content: vals = sipper.get_content_values(c, 'Count', df=df) if not vals.empty: to_plot.append() labels.append(c) for i, series in enumerate(to_plot): reindexed = get_chronogram_vals(series, lights_on, lights_off) if reindexed.empty: continue label = labels[i] temp = pd.DataFrame({label:reindexed}, index=reindexed.index) output = output.join(temp, how='outer') output.index.name = 'Hours Into Light Cycle' return output def drinkcount_chronogram_grouped(sippers, groups, circ_left=True, circ_right=True, circ_content=None, circ_var='SEM', lights_on=7, lights_off=19, **kwargs): output = pd.DataFrame(index=range(0,24)) output.index.name = 'Hours Into Light Cycle' to_plot = defaultdict(list) for group in groups: for sipper in sippers: if group in sipper.groups: df = sipper.data if 'date_filter' in kwargs: s, e = kwargs['date_filter'] df = df[(df.index >= s) & (df.index <= e)].copy() if circ_left: key = group + ' - Left' vals = get_chronogram_vals(df['LeftCount'], lights_on, lights_off) vals.name = sipper.basename to_plot[key].append(vals) if circ_right: key = group + ' - Right' vals = get_chronogram_vals(df['RightCount'], lights_on, lights_off) vals.name = sipper.basename to_plot[key].append(vals) if circ_content: for c in circ_content: key = group + ' - ' + c content_vals = sipper.get_content_values(c, 'Count', df) if not content_vals.empty: vals = get_chronogram_vals(content_vals, lights_on, lights_off) vals.name = sipper.basename to_plot[key].append(vals) for i, (label, data) in enumerate(to_plot.items()): y = np.nanmean(data, axis=0) for d in data: output[label + ' - ' + d.name] = d output[label + ' MEAN'] = y if circ_var == 'SEM': sem = stats.sem(data, axis=0, nan_policy='omit') output[label + ' SEM'] = sem elif circ_var == 'STD': std = np.nanstd(data, axis=0) output[label + ' STD'] = std return output def drinkduration_chronogram(sipper, circ_left=True, circ_right=True, circ_content=None, lights_on=7, lights_off=19, **kwargs): output = pd.DataFrame() df = sipper.data if 'date_filter' in kwargs: s, e = kwargs['date_filter'] df = df[(df.index >= s) & (df.index <= e)].copy() to_plot = [] labels = [] if circ_left: to_plot.append(df['LeftDuration']) labels.append('Left') if circ_right: to_plot.append(df['RightDuration']) labels.append('Right') if circ_content: for c in circ_content: vals = sipper.get_content_values(c, 'Duration', df=df) if not vals.empty: to_plot.append() labels.append(c) for i, series in enumerate(to_plot): reindexed = get_chronogram_vals(series, lights_on, lights_off) if reindexed.empty: continue label = labels[i] temp = pd.DataFrame({label:reindexed}, index=reindexed.index) output = output.join(temp, how='outer') output.index.name = 'Hours Into Light Cycle' return output def drinkduration_chronogram_grouped(sippers, groups, circ_left=True, circ_right=True, circ_content=None, circ_var='SEM', lights_on=7, lights_off=19, **kwargs): output = pd.DataFrame(index=range(0,24)) output.index.name = 'Hours Into Light Cycle' to_plot = defaultdict(list) for group in groups: for sipper in sippers: if group in sipper.groups: df = sipper.data if 'date_filter' in kwargs: s, e = kwargs['date_filter'] df = df[(df.index >= s) & (df.index <= e)].copy() if circ_left: key = group + ' - Left' vals = get_chronogram_vals(df['LeftDuration'], lights_on, lights_off) vals.name = sipper.basename to_plot[key].append(vals) if circ_right: key = group + ' - Right' vals = get_chronogram_vals(df['RightDuration'], lights_on, lights_off) vals.name = sipper.basename to_plot[key].append(vals) if circ_content: for c in circ_content: key = group + ' - ' + c content_vals = sipper.get_content_values(c, 'Duration', df) if not content_vals.empty: vals = get_chronogram_vals(content_vals, lights_on, lights_off) vals.name = sipper.basename to_plot[key].append(vals) for i, (label, data) in enumerate(to_plot.items()): y = np.nanmean(data, axis=0) for d in data: output[label + ' - ' + d.name] = d output[label + ' MEAN'] = y if circ_var == 'SEM': sem = stats.sem(data, axis=0, nan_policy='omit') output[label + ' SEM'] = sem elif circ_var == 'STD': std = np.nanstd(data, axis=0) output[label + ' STD'] = std return output def side_preference(sipper, pref_side='Left', pref_metric='Count', pref_bins='1H', **kwargs): df = sipper.data if 'date_filter' in kwargs: s, e = kwargs['date_filter'] df = df[(df.index >= s) & (df.index <= e)].copy() base = df.index[0].hour lcol = 'Left' + pref_metric rcol = 'Right' + pref_metric l_data = df[lcol].diff().resample(pref_bins, base=base).sum() r_data = df[rcol].diff().resample(pref_bins, base=base).sum() total = l_data + r_data if pref_side == 'Left': preference = l_data/total else: preference = r_data/total preference *= 100 output = pd.DataFrame(preference) output.columns = ['{} Preference (% Drink {})'.format(pref_side, pref_metric)] return output def content_preference(sipper, pref_content=[], pref_metric='Count', pref_bins='1H', lights_on=7, lights_off=19, shade_dark=True, **kwargs): output = pd.DataFrame() df = sipper.data if 'date_filter' in kwargs: s, e = kwargs['date_filter'] df = df[(df.index >= s) & (df.index <= e)].copy() base = df.index[0].hour for i, c in enumerate(pref_content): target = sipper.get_content_values(c, out=pref_metric, df=df) if target.empty: continue target = target.diff().resample(pref_bins, base=base).sum() other = sipper.get_content_values(c, out=pref_metric, df=df, opposite=True) other = other.diff().resample(pref_bins, base=base).sum() if not target.empty and not other.empty: preference = target / (target + other) * 100 temp = pd.DataFrame({c : preference}, index=preference.index) output = output.join(temp, how='outer') return output def averaged_drinkcount(sippers, groups, averaging='datetime', avg_bins='1H', avg_var='SEM', show_left=True, show_right=True, show_content=[], **kwargs): output = pd.DataFrame() to_plot = defaultdict(list) for group in groups: for sipper in sippers: if group in sipper.groups: df = sipper.data if 'date_filter' in kwargs: s, e = kwargs['date_filter'] df = df[(df.index >= s) & (df.index <= e)].copy() if show_left: key = '{} - Left'.format(group) vals = df['LeftCount'].diff().rename(sipper.basename) to_plot[key].append(vals) if show_right: key = '{} - Right'.format(group) vals = df['RightCount'].diff().rename(sipper.basename) to_plot[key].append(vals) if show_content: for c in show_content: key = '{} - {}'.format(group, c) vals = sipper.get_content_values(c, out='Count', df=df).diff() if not vals.empty: to_plot[key].append(vals.rename(sipper.basename)) for i, (label, data) in enumerate(to_plot.items()): temp = pd.DataFrame() processed = preproc_averaging(data, averaging=averaging, avg_bins=avg_bins, agg='sum') x = processed['x'] ys = processed['ys'] mean = np.nanmean(ys, axis=0) temp = temp.reindex(x) for y in ys: temp['{} ({})'.format(y.name, label)] = y temp['{} MEAN'.format(label)] = mean if avg_var == 'SEM': temp['{} SEM'.format(label)] = stats.sem(ys, axis=0, nan_policy='omit') elif avg_var == 'STD': temp['{} STD'.format(label)] = np.nanstd(ys, axis=0) output = output.join(temp, how='outer') return format_avg_output(output, averaging) def cumulative_averaged_drinkcount(sippers, groups, avg_bins='1H', avg_var='SEM', show_left=True, show_right=True, show_content=[], **kwargs): averaging = 'elapsed' output = pd.DataFrame() to_plot = defaultdict(list) for group in groups: for sipper in sippers: if group in sipper.groups: df = sipper.data if 'date_filter' in kwargs: s, e = kwargs['date_filter'] df = df[(df.index >= s) & (df.index <= e)].copy() if show_left: key = '{} - Left'.format(group) vals = df['LeftCount'].rename(sipper.basename) to_plot[key].append(vals) if show_right: key = '{} - Right'.format(group) vals = df['RightCount'].rename(sipper.basename) to_plot[key].append(vals) if show_content: for c in show_content: key = '{} - {}'.format(group, c) vals = sipper.get_content_values(c, out='Count', df=df) if not vals.empty: to_plot[key].append(vals.rename(sipper.basename)) for i, (label, data) in enumerate(to_plot.items()): temp =
pd.DataFrame()
pandas.DataFrame
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """Retrieve bikeshare trips data.""" # pylint: disable=invalid-name import os import re from glob import glob from typing import Dict, List from zipfile import ZipFile import pandas as pd import pandera as pa import requests from src.utils import log_prefect trips_schema = pa.DataFrameSchema( columns={ "TRIP_ID": pa.Column(pa.Int), "TRIP__DURATION": pa.Column(pa.Int), "START_STATION_ID": pa.Column( pa.Int, nullable=True, ), "START_TIME": pa.Column( pa.Timestamp, checks=[pa.Check(lambda s: s.dt.year.isin([2021, 2022]))], ), "START_STATION_NAME": pa.Column(pd.StringDtype()), "END_STATION_ID": pa.Column( pa.Int, nullable=True, ), "END_TIME": pa.Column( pa.Timestamp, checks=[pa.Check(lambda s: s.dt.year.isin([2021, 2022]))], ), "END_STATION_NAME": pa.Column(pd.StringDtype()), "BIKE_ID": pa.Column(pa.Int, nullable=True), "USER_TYPE": pa.Column( pd.StringDtype(), checks=[ pa.Check( lambda s: s.isin(["Annual Member", "Casual Member"]), ) ], ), }, index=pa.Index(pa.Int), ) urls_schema = pa.DataFrameSchema( columns={ "url": pa.Column(pd.StringDtype()), "name": pa.Column(pd.StringDtype()), "format": pa.Column(pd.StringDtype()), "state": pa.Column(pd.StringDtype()), }, index=pa.Index(pa.Int), ) get_data_status_schema = pa.DataFrameSchema( columns={ "trips_file_name": pa.Column(pd.StringDtype()), "last_modified_opendata": pa.Column( pd.DatetimeTZDtype(tz="America/Toronto") ), "parquet_file_exists": pa.Column(
pd.BooleanDtype()
pandas.BooleanDtype
import os import pathlib from typing import Sequence, Union, List, Callable import matplotlib import matplotlib.cm import matplotlib.pyplot as plt from matplotlib.ticker import FuncFormatter import pandas as pd from pandas.tseries.offsets import MonthEnd from covid_data import get_ifr, scrape_and_combine from utils_pandas import cum2daily, cut_ages, decreasing, get_cycle, human_format, import_csv, increasing, normalise_to_total, \ rearrange, set_time_series_labels_2, topprov from utils_scraping import remove_prefix, remove_suffix from utils_thai import DISTRICT_RANGE, DISTRICT_RANGE_SIMPLE, AREA_LEGEND, AREA_LEGEND_SIMPLE, \ AREA_LEGEND_ORDERED, FIRST_AREAS, area_crosstab, get_provinces, join_provinces, thaipop def plot_area(df: pd.DataFrame, png_prefix: str, cols_subset: Union[str, Sequence[str]], title: str, footnote: str = None, legends: List[str] = None, legend_pos: str = None, legend_cols: int = 1, kind: str = 'line', stacked=False, percent_fig: bool = False, unknown_name: str = 'Unknown', unknown_total: str = None, unknown_percent=False, ma_days: int = None, cmap: str = 'tab20', periods_to_plot=None, actuals: List[str] = [], highlight: List[str] = [], box_cols: List[str] = [], reverse_cmap: bool = False, y_formatter: Callable[[float, int], str] = human_format, clean_end=True, between: List[str] = []) -> None: """Creates one .png file for several time periods, showing data in absolute numbers and percentage terms. :param df: data frame containing all available data :param png_prefix: file prefix (file suffix is '.png') :param cols_subset: specify columns from the pandas DataFrame based on either a column name prefix or based on a list of column names. :param title: plot title :param legends: legends to be used on the plots (line chart and percentage) :param kind: the type of plot (line chart or area chart) :param stacked: whether the line chart should use stacked lines :param percent_fig: whether the percentage chart should be included :param unknown_name: the column name containing data related to unknowns :param unknown_total: the column name (to be created) with unknown totals :param unknown_percent: to include unknowns in a percentage fig if enabled :param ma_days: number of days used when computing the moving average :param cmap: the matplotlib colormap to be used :param reverse_cmap: whether the colormap should be reversed :param highlight: cols to make thicker to highlight them :param y_formatter: function to format y axis numbers :param clean_end: remove days at end if there is no data (inc unknown) :param between: columns to display as dashed :param actuals: display non MA as dashed """ if type(cols_subset) is str: cols = [c for c in df.columns if str(c).startswith(cols_subset)] else: cols = cols_subset orig_cols = cols plt.rcParams.update({ "font.size": 24, "figure.titlesize": 30, "figure.titleweight": "bold", "axes.titlesize": 28, "legend.fontsize": 24, "axes.prop_cycle": get_cycle(cmap), }) if len(cols) > 6: plt.rcParams.update({"legend.fontsize": 18}) if actuals: # display the originals dashed along side MA if type(actuals) != list: actuals = cols else: actuals = [] if ma_days: ma_suffix = ' (MA)' for c in cols: df[f'{c}{ma_suffix}'] = df[c].rolling(ma_days, min_periods=int(ma_days / 2), center=True).mean() cols = [f'{c}{ma_suffix}' for c in cols] else: ma_suffix = '' # try to hone in on last day of "important" data. Assume first col last_update = df[orig_cols[:1]].dropna().last_valid_index() # date format chosen: '05 May 2021' # last_date_excl = df[cols].last_valid_index() # last date with some data (not inc unknown) is_dates = hasattr(last_update, 'date') if unknown_total: if ma_days: df[f'{unknown_total}{ma_suffix}'] = df[unknown_total].rolling(ma_days, min_periods=int(ma_days / 2), center=True).mean() total_col = f'{unknown_total}{ma_suffix}' unknown_col = f'{unknown_name}{ma_suffix}' other_cols = set(cols) - set([unknown_col]) # TODO: should not be 0 when no unknown_total df[unknown_col] = df[total_col].sub(df[other_cols].sum(axis=1), fill_value=None).clip(lower=0) if unknown_col not in cols: cols = cols + [unknown_col] if percent_fig: perccols = [ c for c in cols if (not unknown_total or unknown_percent or c != unknown_col) and c not in (between + actuals) ] for c in perccols: df[f'{c} (%)'] = df[f'{c}'] / df[perccols].sum(axis=1) * 100 if unknown_total and not unknown_percent: df[f'{unknown_name}{ma_suffix} (%)'] = 0 perccols = [f'{c} (%)' for c in perccols] title = f'{title}\n' if ma_days: title = title + f'({ma_days} day rolling average) ' if is_dates: title += f"Last Data: {last_update.date().strftime('%d %b %Y')}\n" else: title += f"Last Data: {last_update}\n" title += 'https://djay.github.io/covidthailand - (CC BY)' # if legends are not specified then use the columns names else use the data passed in the 'legends' argument if legends is None: legends = [remove_suffix(c, ma_suffix) for c in cols] if unknown_total and unknown_name not in legends: legends = legends + [unknown_name] # if unknown_total: # colormap = custom_cm(cmap, len(cols) + 1, 'lightgrey', flip=reverse_cmap) # else: # colormap = custom_cm(cmap, len(cols), flip=reverse_cmap) # colormap = cmap # drop any rows containing 'NA' if they are in the specified columns (=subset of all columns) # df_clean = clip_dataframe(df_all=df, cols=cols, n_rows=10) last_date_unknown = df[cols].last_valid_index() # last date with some data (inc unknown) if clean_end: df_clean = df.loc[:last_date_unknown] else: df_clean = df if is_dates: periods = { 'all': df_clean, '1': df_clean[:'2020-06-01'], '2': df_clean['2020-12-12':], '3': df_clean['2021-04-01':], '30d': df_clean.last('30d') } quick = os.environ.get('USE_CACHE_DATA', False) == 'True' # TODO: have its own switch if periods_to_plot: pass elif quick: periods_to_plot = ['all'] else: periods_to_plot = set(periods.keys()) periods = {key: periods[key] for key in periods_to_plot} else: periods = {'all': df_clean} for suffix, df_plot in periods.items(): if df_plot.empty: continue if percent_fig: f, (a0, a1) = plt.subplots(2, 1, gridspec_kw={'height_ratios': [4, 2]}, figsize=[20, 15]) else: f, a0 = plt.subplots(figsize=[20, 12]) # plt.rcParams["axes.prop_cycle"] = get_cycle(colormap) a0.set_prop_cycle(None) if y_formatter is not None: a0.yaxis.set_major_formatter(FuncFormatter(y_formatter)) areacols = [c for c in cols if c not in between] if kind != "line": df_plot.plot(ax=a0, y=areacols, kind=kind, stacked=stacked, legend='reverse') linecols = between + actuals else: linecols = cols + actuals # advance colour cycle so lines have correct next colour for _ in range(len(areacols)): next(a0._get_lines.prop_cycler) for c in linecols: style = "--" if c in [f"{b}{ma_suffix}" for b in between] + actuals else None width = 5 if c in [f"{h}{ma_suffix}" for h in highlight] else None df_plot.plot(ax=a0, y=c, use_index=True, linewidth=width, style=style, kind="line", zorder=4, legend=c not in actuals, x_compat=kind == 'bar' # Putting lines on bar plots doesn't work well ) if box_cols and type(box_cols[0]) != list: box_cols = [box_cols] elif not box_cols: box_cols = [] for dist in box_cols: mins, maxes, avg = df_plot[dist].min(axis=1), df_plot[dist].max(axis=1), df_plot[dist].mean(axis=1) a0.fill_between(df.index, mins, maxes, facecolor="orange", alpha=0.3, zorder=3, label=None, step=None) avg.plot(ax=a0, color="orange", style="--", zorder=5, x_compat=kind == 'bar', legend=False) # boxes = df_plot[box_cols].transpose() # boxes.boxplot(ax=a0) if kind == "bar" and is_dates: set_time_series_labels_2(df_plot, a0) a0.set_title(label=title) if footnote: plt.annotate(footnote, (0.99, 0), (0, -50), xycoords='axes fraction', textcoords='offset points', va='top', fontsize=15, horizontalalignment='right') handles, labels = a0.get_legend_handles_labels() # we are skipping pandas determining which legends to show so do it manually. box lines are 'None' # TODO: go back to pandas doing it. handles, labels = zip(*[(h, l) for h, l in zip(*a0.get_legend_handles_labels()) if l not in actuals + ['None']]) leg = a0.legend(handles=handles, labels=legends, loc=legend_pos, frameon=True, edgecolor="black", fancybox=True, framealpha=0.5, ncol=legend_cols) for line in leg.get_lines(): line.set_linewidth(4.0) if unknown_total: a0.set_ylabel(unknown_total) a0.xaxis.label.set_visible(False) if percent_fig: a1.set_prop_cycle(None) df_plot.plot(ax=a1, y=perccols, kind='area', legend=False) a1.set_ylabel('Percent') a1.xaxis.label.set_visible(False) plt.tight_layout() path = os.path.join("outputs", f'{png_prefix}_{suffix}.png') plt.savefig(path) print("Plot:", path) plt.close() return None def save_plots(df: pd.DataFrame) -> None: print('======== Generating Plots ==========') # matplotlib global settings matplotlib.use('AGG') plt.style.use('seaborn-whitegrid') # create directory if it does not exists pathlib.Path('./outputs').mkdir(parents=True, exist_ok=True) # Computed data # TODO: has a problem if we have local transmission but no proactive # TODO: put somewhere else walkins =
pd.DataFrame(df["Cases Local Transmission"] - df["Cases Proactive"], columns=['Cases Walkin'])
pandas.DataFrame
import numpy as np import pytest import pandas.util._test_decorators as td from pandas.core.dtypes.generic import ABCIndexClass import pandas as pd import pandas._testing as tm from pandas.api.types import is_float, is_float_dtype, is_integer, is_scalar from pandas.core.arrays import IntegerArray, integer_array from pandas.core.arrays.integer import ( Int8Dtype, Int16Dtype, Int32Dtype, Int64Dtype, UInt8Dtype, UInt16Dtype, UInt32Dtype, UInt64Dtype, ) from pandas.tests.extension.base import BaseOpsUtil def make_data(): return list(range(8)) + [np.nan] + list(range(10, 98)) + [np.nan] + [99, 100] @pytest.fixture( params=[ Int8Dtype, Int16Dtype, Int32Dtype, Int64Dtype, UInt8Dtype, UInt16Dtype, UInt32Dtype, UInt64Dtype, ] ) def dtype(request): return request.param() @pytest.fixture def data(dtype): return integer_array(make_data(), dtype=dtype) @pytest.fixture def data_missing(dtype): return integer_array([np.nan, 1], dtype=dtype) @pytest.fixture(params=["data", "data_missing"]) def all_data(request, data, data_missing): """Parametrized fixture giving 'data' and 'data_missing'""" if request.param == "data": return data elif request.param == "data_missing": return data_missing def test_dtypes(dtype): # smoke tests on auto dtype construction if dtype.is_signed_integer: assert np.dtype(dtype.type).kind == "i" else: assert np.dtype(dtype.type).kind == "u" assert dtype.name is not None @pytest.mark.parametrize( "dtype, expected", [ (Int8Dtype(), "Int8Dtype()"), (Int16Dtype(), "Int16Dtype()"), (Int32Dtype(), "Int32Dtype()"), (Int64Dtype(), "Int64Dtype()"), (UInt8Dtype(), "UInt8Dtype()"), (UInt16Dtype(), "UInt16Dtype()"), (UInt32Dtype(), "UInt32Dtype()"), (UInt64Dtype(), "UInt64Dtype()"), ], ) def test_repr_dtype(dtype, expected): assert repr(dtype) == expected def test_repr_array(): result = repr(integer_array([1, None, 3])) expected = "<IntegerArray>\n[1, <NA>, 3]\nLength: 3, dtype: Int64" assert result == expected def test_repr_array_long(): data = integer_array([1, 2, None] * 1000) expected = ( "<IntegerArray>\n" "[ 1, 2, <NA>, 1, 2, <NA>, 1, 2, <NA>, 1,\n" " ...\n" " <NA>, 1, 2, <NA>, 1, 2, <NA>, 1, 2, <NA>]\n" "Length: 3000, dtype: Int64" ) result = repr(data) assert result == expected class TestConstructors: def test_uses_pandas_na(self): a = pd.array([1, None], dtype=pd.Int64Dtype()) assert a[1] is pd.NA def test_from_dtype_from_float(self, data): # construct from our dtype & string dtype dtype = data.dtype # from float expected = pd.Series(data) result = pd.Series( data.to_numpy(na_value=np.nan, dtype="float"), dtype=str(dtype) ) tm.assert_series_equal(result, expected) # from int / list expected = pd.Series(data) result = pd.Series(np.array(data).tolist(), dtype=str(dtype)) tm.assert_series_equal(result, expected) # from int / array expected = pd.Series(data).dropna().reset_index(drop=True) dropped = np.array(data.dropna()).astype(np.dtype((dtype.type))) result = pd.Series(dropped, dtype=str(dtype)) tm.assert_series_equal(result, expected) class TestArithmeticOps(BaseOpsUtil): def _check_divmod_op(self, s, op, other, exc=None): super()._check_divmod_op(s, op, other, None) def _check_op(self, s, op_name, other, exc=None): op = self.get_op_from_name(op_name) result = op(s, other) # compute expected mask = s.isna() # if s is a DataFrame, squeeze to a Series # for comparison if isinstance(s, pd.DataFrame): result = result.squeeze() s = s.squeeze() mask = mask.squeeze() # other array is an Integer if isinstance(other, IntegerArray): omask = getattr(other, "mask", None) mask = getattr(other, "data", other) if omask is not None: mask |= omask # 1 ** na is na, so need to unmask those if op_name == "__pow__": mask = np.where(~s.isna() & (s == 1), False, mask) elif op_name == "__rpow__": other_is_one = other == 1 if isinstance(other_is_one, pd.Series): other_is_one = other_is_one.fillna(False) mask = np.where(other_is_one, False, mask) # float result type or float op if ( is_float_dtype(other) or is_float(other) or op_name in ["__rtruediv__", "__truediv__", "__rdiv__", "__div__"] ): rs = s.astype("float") expected = op(rs, other) self._check_op_float(result, expected, mask, s, op_name, other) # integer result type else: rs = pd.Series(s.values._data, name=s.name) expected = op(rs, other) self._check_op_integer(result, expected, mask, s, op_name, other) def _check_op_float(self, result, expected, mask, s, op_name, other): # check comparisons that are resulting in float dtypes expected[mask] = np.nan if "floordiv" in op_name: # Series op sets 1//0 to np.inf, which IntegerArray does not do (yet) mask2 = np.isinf(expected) & np.isnan(result) expected[mask2] = np.nan tm.assert_series_equal(result, expected) def _check_op_integer(self, result, expected, mask, s, op_name, other): # check comparisons that are resulting in integer dtypes # to compare properly, we convert the expected # to float, mask to nans and convert infs # if we have uints then we process as uints # then convert to float # and we ultimately want to create a IntArray # for comparisons fill_value = 0 # mod/rmod turn floating 0 into NaN while # integer works as expected (no nan) if op_name in ["__mod__", "__rmod__"]: if is_scalar(other): if other == 0: expected[s.values == 0] = 0 else: expected = expected.fillna(0) else: expected[ (s.values == 0).fillna(False) & ((expected == 0).fillna(False) | expected.isna()) ] = 0 try: expected[ ((expected == np.inf) | (expected == -np.inf)).fillna(False) ] = fill_value original = expected expected = expected.astype(s.dtype) except ValueError: expected = expected.astype(float) expected[ ((expected == np.inf) | (expected == -np.inf)).fillna(False) ] = fill_value original = expected expected = expected.astype(s.dtype) expected[mask] = pd.NA # assert that the expected astype is ok # (skip for unsigned as they have wrap around) if not s.dtype.is_unsigned_integer: original = pd.Series(original) # we need to fill with 0's to emulate what an astype('int') does # (truncation) for certain ops if op_name in ["__rtruediv__", "__rdiv__"]: mask |= original.isna() original = original.fillna(0).astype("int") original = original.astype("float") original[mask] = np.nan tm.assert_series_equal(original, expected.astype("float")) # assert our expected result tm.assert_series_equal(result, expected) def test_arith_integer_array(self, data, all_arithmetic_operators): # we operate with a rhs of an integer array op = all_arithmetic_operators s = pd.Series(data) rhs = pd.Series([1] * len(data), dtype=data.dtype) rhs.iloc[-1] = np.nan self._check_op(s, op, rhs) def test_arith_series_with_scalar(self, data, all_arithmetic_operators): # scalar op = all_arithmetic_operators s = pd.Series(data) self._check_op(s, op, 1, exc=TypeError) def test_arith_frame_with_scalar(self, data, all_arithmetic_operators): # frame & scalar op = all_arithmetic_operators df = pd.DataFrame({"A": data}) self._check_op(df, op, 1, exc=TypeError) def test_arith_series_with_array(self, data, all_arithmetic_operators): # ndarray & other series op = all_arithmetic_operators s = pd.Series(data) other = np.ones(len(s), dtype=s.dtype.type) self._check_op(s, op, other, exc=TypeError) def test_arith_coerce_scalar(self, data, all_arithmetic_operators): op = all_arithmetic_operators s = pd.Series(data) other = 0.01 self._check_op(s, op, other) @pytest.mark.parametrize("other", [1.0, np.array(1.0)]) def test_arithmetic_conversion(self, all_arithmetic_operators, other): # if we have a float operand we should have a float result # if that is equal to an integer op = self.get_op_from_name(all_arithmetic_operators) s = pd.Series([1, 2, 3], dtype="Int64") result = op(s, other) assert result.dtype is np.dtype("float") def test_arith_len_mismatch(self, all_arithmetic_operators): # operating with a list-like with non-matching length raises op = self.get_op_from_name(all_arithmetic_operators) other = np.array([1.0]) s = pd.Series([1, 2, 3], dtype="Int64") with pytest.raises(ValueError, match="Lengths must match"): op(s, other) @pytest.mark.parametrize("other", [0, 0.5]) def test_arith_zero_dim_ndarray(self, other): arr = integer_array([1, None, 2]) result = arr + np.array(other) expected = arr + other tm.assert_equal(result, expected) def test_error(self, data, all_arithmetic_operators): # invalid ops op = all_arithmetic_operators s = pd.Series(data) ops = getattr(s, op) opa = getattr(data, op) # invalid scalars msg = ( r"(:?can only perform ops with numeric values)" r"|(:?IntegerArray cannot perform the operation mod)" ) with pytest.raises(TypeError, match=msg): ops("foo") with pytest.raises(TypeError, match=msg): ops(pd.Timestamp("20180101")) # invalid array-likes with pytest.raises(TypeError, match=msg): ops(pd.Series("foo", index=s.index)) if op != "__rpow__": # TODO(extension) # rpow with a datetimelike coerces the integer array incorrectly msg = ( "can only perform ops with numeric values|" "cannot perform .* with this index type: DatetimeArray|" "Addition/subtraction of integers and integer-arrays " "with DatetimeArray is no longer supported. *" ) with pytest.raises(TypeError, match=msg): ops(pd.Series(pd.date_range("20180101", periods=len(s)))) # 2d result = opa(pd.DataFrame({"A": s})) assert result is NotImplemented msg = r"can only perform ops with 1-d structures" with pytest.raises(NotImplementedError, match=msg): opa(np.arange(len(s)).reshape(-1, len(s))) @pytest.mark.parametrize("zero, negative", [(0, False), (0.0, False), (-0.0, True)]) def test_divide_by_zero(self, zero, negative): # https://github.com/pandas-dev/pandas/issues/27398 a = pd.array([0, 1, -1, None], dtype="Int64") result = a / zero expected = np.array([np.nan, np.inf, -np.inf, np.nan]) if negative: expected *= -1 tm.assert_numpy_array_equal(result, expected) def test_pow_scalar(self): a = pd.array([-1, 0, 1, None, 2], dtype="Int64") result = a ** 0 expected = pd.array([1, 1, 1, 1, 1], dtype="Int64") tm.assert_extension_array_equal(result, expected) result = a ** 1 expected = pd.array([-1, 0, 1, None, 2], dtype="Int64") tm.assert_extension_array_equal(result, expected) result = a ** pd.NA expected = pd.array([None, None, 1, None, None], dtype="Int64") tm.assert_extension_array_equal(result, expected) result = a ** np.nan expected = np.array([np.nan, np.nan, 1, np.nan, np.nan], dtype="float64") tm.assert_numpy_array_equal(result, expected) # reversed a = a[1:] # Can't raise integers to negative powers. result = 0 ** a expected = pd.array([1, 0, None, 0], dtype="Int64") tm.assert_extension_array_equal(result, expected) result = 1 ** a expected = pd.array([1, 1, 1, 1], dtype="Int64") tm.assert_extension_array_equal(result, expected) result = pd.NA ** a expected = pd.array([1, None, None, None], dtype="Int64") tm.assert_extension_array_equal(result, expected) result = np.nan ** a expected = np.array([1, np.nan, np.nan, np.nan], dtype="float64") tm.assert_numpy_array_equal(result, expected) def test_pow_array(self): a = integer_array([0, 0, 0, 1, 1, 1, None, None, None]) b = integer_array([0, 1, None, 0, 1, None, 0, 1, None]) result = a ** b expected = integer_array([1, 0, None, 1, 1, 1, 1, None, None]) tm.assert_extension_array_equal(result, expected) def test_rpow_one_to_na(self): # https://github.com/pandas-dev/pandas/issues/22022 # https://github.com/pandas-dev/pandas/issues/29997 arr = integer_array([np.nan, np.nan]) result = np.array([1.0, 2.0]) ** arr expected = np.array([1.0, np.nan]) tm.assert_numpy_array_equal(result, expected) class TestComparisonOps(BaseOpsUtil): def _compare_other(self, data, op_name, other): op = self.get_op_from_name(op_name) # array result = pd.Series(op(data, other)) expected = pd.Series(op(data._data, other), dtype="boolean") # fill the nan locations expected[data._mask] = pd.NA tm.assert_series_equal(result, expected) # series s = pd.Series(data) result = op(s, other) expected = op(pd.Series(data._data), other) # fill the nan locations expected[data._mask] = pd.NA expected = expected.astype("boolean") tm.assert_series_equal(result, expected) @pytest.mark.parametrize("other", [True, False, pd.NA, -1, 0, 1]) def test_scalar(self, other, all_compare_operators): op = self.get_op_from_name(all_compare_operators) a = pd.array([1, 0, None], dtype="Int64") result = op(a, other) if other is pd.NA: expected = pd.array([None, None, None], dtype="boolean") else: values = op(a._data, other) expected = pd.arrays.BooleanArray(values, a._mask, copy=True) tm.assert_extension_array_equal(result, expected) # ensure we haven't mutated anything inplace result[0] = pd.NA tm.assert_extension_array_equal(a, pd.array([1, 0, None], dtype="Int64")) def test_array(self, all_compare_operators): op = self.get_op_from_name(all_compare_operators) a = pd.array([0, 1, 2, None, None, None], dtype="Int64") b = pd.array([0, 1, None, 0, 1, None], dtype="Int64") result = op(a, b) values = op(a._data, b._data) mask = a._mask | b._mask expected = pd.arrays.BooleanArray(values, mask) tm.assert_extension_array_equal(result, expected) # ensure we haven't mutated anything inplace result[0] = pd.NA tm.assert_extension_array_equal( a, pd.array([0, 1, 2, None, None, None], dtype="Int64") ) tm.assert_extension_array_equal( b, pd.array([0, 1, None, 0, 1, None], dtype="Int64") ) def test_compare_with_booleanarray(self, all_compare_operators): op = self.get_op_from_name(all_compare_operators) a = pd.array([True, False, None] * 3, dtype="boolean") b = pd.array([0] * 3 + [1] * 3 + [None] * 3, dtype="Int64") other =
pd.array([False] * 3 + [True] * 3 + [None] * 3, dtype="boolean")
pandas.array
# Arithmetic tests for DataFrame/Series/Index/Array classes that should # behave identically. # Specifically for datetime64 and datetime64tz dtypes from datetime import ( datetime, time, timedelta, ) from itertools import ( product, starmap, ) import operator import warnings import numpy as np import pytest import pytz from pandas._libs.tslibs.conversion import localize_pydatetime from pandas._libs.tslibs.offsets import shift_months from pandas.errors import PerformanceWarning import pandas as pd from pandas import ( DateOffset, DatetimeIndex, NaT, Period, Series, Timedelta, TimedeltaIndex, Timestamp, date_range, ) import pandas._testing as tm from pandas.core.arrays import ( DatetimeArray, TimedeltaArray, ) from pandas.core.ops import roperator from pandas.tests.arithmetic.common import ( assert_cannot_add, assert_invalid_addsub_type, assert_invalid_comparison, get_upcast_box, ) # ------------------------------------------------------------------ # Comparisons class TestDatetime64ArrayLikeComparisons: # Comparison tests for datetime64 vectors fully parametrized over # DataFrame/Series/DatetimeIndex/DatetimeArray. Ideally all comparison # tests will eventually end up here. def test_compare_zerodim(self, tz_naive_fixture, box_with_array): # Test comparison with zero-dimensional array is unboxed tz = tz_naive_fixture box = box_with_array dti = date_range("20130101", periods=3, tz=tz) other = np.array(dti.to_numpy()[0]) dtarr = tm.box_expected(dti, box) xbox = get_upcast_box(dtarr, other, True) result = dtarr <= other expected = np.array([True, False, False]) expected = tm.box_expected(expected, xbox) tm.assert_equal(result, expected) @pytest.mark.parametrize( "other", [ "foo", -1, 99, 4.0, object(), timedelta(days=2), # GH#19800, GH#19301 datetime.date comparison raises to # match DatetimeIndex/Timestamp. This also matches the behavior # of stdlib datetime.datetime datetime(2001, 1, 1).date(), # GH#19301 None and NaN are *not* cast to NaT for comparisons None, np.nan, ], ) def test_dt64arr_cmp_scalar_invalid(self, other, tz_naive_fixture, box_with_array): # GH#22074, GH#15966 tz = tz_naive_fixture rng = date_range("1/1/2000", periods=10, tz=tz) dtarr = tm.box_expected(rng, box_with_array) assert_invalid_comparison(dtarr, other, box_with_array) @pytest.mark.parametrize( "other", [ # GH#4968 invalid date/int comparisons list(range(10)), np.arange(10), np.arange(10).astype(np.float32), np.arange(10).astype(object), pd.timedelta_range("1ns", periods=10).array, np.array(pd.timedelta_range("1ns", periods=10)), list(pd.timedelta_range("1ns", periods=10)), pd.timedelta_range("1 Day", periods=10).astype(object), pd.period_range("1971-01-01", freq="D", periods=10).array, pd.period_range("1971-01-01", freq="D", periods=10).astype(object), ], ) def test_dt64arr_cmp_arraylike_invalid( self, other, tz_naive_fixture, box_with_array ): tz = tz_naive_fixture dta = date_range("1970-01-01", freq="ns", periods=10, tz=tz)._data obj = tm.box_expected(dta, box_with_array) assert_invalid_comparison(obj, other, box_with_array) def test_dt64arr_cmp_mixed_invalid(self, tz_naive_fixture): tz = tz_naive_fixture dta = date_range("1970-01-01", freq="h", periods=5, tz=tz)._data other = np.array([0, 1, 2, dta[3], Timedelta(days=1)]) result = dta == other expected = np.array([False, False, False, True, False]) tm.assert_numpy_array_equal(result, expected) result = dta != other tm.assert_numpy_array_equal(result, ~expected) msg = "Invalid comparison between|Cannot compare type|not supported between" with pytest.raises(TypeError, match=msg): dta < other with pytest.raises(TypeError, match=msg): dta > other with pytest.raises(TypeError, match=msg): dta <= other with pytest.raises(TypeError, match=msg): dta >= other def test_dt64arr_nat_comparison(self, tz_naive_fixture, box_with_array): # GH#22242, GH#22163 DataFrame considered NaT == ts incorrectly tz = tz_naive_fixture box = box_with_array ts = Timestamp("2021-01-01", tz=tz) ser = Series([ts, NaT]) obj = tm.box_expected(ser, box) xbox = get_upcast_box(obj, ts, True) expected = Series([True, False], dtype=np.bool_) expected = tm.box_expected(expected, xbox) result = obj == ts tm.assert_equal(result, expected) class TestDatetime64SeriesComparison: # TODO: moved from tests.series.test_operators; needs cleanup @pytest.mark.parametrize( "pair", [ ( [Timestamp("2011-01-01"), NaT, Timestamp("2011-01-03")], [NaT, NaT, Timestamp("2011-01-03")], ), ( [Timedelta("1 days"), NaT, Timedelta("3 days")], [NaT, NaT, Timedelta("3 days")], ), ( [Period("2011-01", freq="M"), NaT, Period("2011-03", freq="M")], [NaT, NaT, Period("2011-03", freq="M")], ), ], ) @pytest.mark.parametrize("reverse", [True, False]) @pytest.mark.parametrize("dtype", [None, object]) @pytest.mark.parametrize( "op, expected", [ (operator.eq, Series([False, False, True])), (operator.ne, Series([True, True, False])), (operator.lt, Series([False, False, False])), (operator.gt, Series([False, False, False])), (operator.ge, Series([False, False, True])), (operator.le, Series([False, False, True])), ], ) def test_nat_comparisons( self, dtype, index_or_series, reverse, pair, op, expected, ): box = index_or_series l, r = pair if reverse: # add lhs / rhs switched data l, r = r, l left = Series(l, dtype=dtype) right = box(r, dtype=dtype) result = op(left, right) tm.assert_series_equal(result, expected) @pytest.mark.parametrize( "data", [ [Timestamp("2011-01-01"), NaT, Timestamp("2011-01-03")], [Timedelta("1 days"), NaT, Timedelta("3 days")], [Period("2011-01", freq="M"), NaT, Period("2011-03", freq="M")], ], ) @pytest.mark.parametrize("dtype", [None, object]) def test_nat_comparisons_scalar(self, dtype, data, box_with_array): box = box_with_array left = Series(data, dtype=dtype) left = tm.box_expected(left, box) xbox = get_upcast_box(left, NaT, True) expected = [False, False, False] expected = tm.box_expected(expected, xbox) if box is pd.array and dtype is object: expected = pd.array(expected, dtype="bool") tm.assert_equal(left == NaT, expected) tm.assert_equal(NaT == left, expected) expected = [True, True, True] expected = tm.box_expected(expected, xbox) if box is pd.array and dtype is object: expected = pd.array(expected, dtype="bool") tm.assert_equal(left != NaT, expected) tm.assert_equal(NaT != left, expected) expected = [False, False, False] expected = tm.box_expected(expected, xbox) if box is pd.array and dtype is object: expected = pd.array(expected, dtype="bool") tm.assert_equal(left < NaT, expected) tm.assert_equal(NaT > left, expected) tm.assert_equal(left <= NaT, expected) tm.assert_equal(NaT >= left, expected) tm.assert_equal(left > NaT, expected) tm.assert_equal(NaT < left, expected) tm.assert_equal(left >= NaT, expected) tm.assert_equal(NaT <= left, expected) @pytest.mark.parametrize("val", [datetime(2000, 1, 4), datetime(2000, 1, 5)]) def test_series_comparison_scalars(self, val): series = Series(date_range("1/1/2000", periods=10)) result = series > val expected = Series([x > val for x in series]) tm.assert_series_equal(result, expected) @pytest.mark.parametrize( "left,right", [("lt", "gt"), ("le", "ge"), ("eq", "eq"), ("ne", "ne")] ) def test_timestamp_compare_series(self, left, right): # see gh-4982 # Make sure we can compare Timestamps on the right AND left hand side. ser = Series(date_range("20010101", periods=10), name="dates") s_nat = ser.copy(deep=True) ser[0] = Timestamp("nat") ser[3] = Timestamp("nat") left_f = getattr(operator, left) right_f = getattr(operator, right) # No NaT expected = left_f(ser, Timestamp("20010109")) result = right_f(Timestamp("20010109"), ser) tm.assert_series_equal(result, expected) # NaT expected = left_f(ser, Timestamp("nat")) result = right_f(Timestamp("nat"), ser) tm.assert_series_equal(result, expected) # Compare to Timestamp with series containing NaT expected = left_f(s_nat, Timestamp("20010109")) result = right_f(Timestamp("20010109"), s_nat) tm.assert_series_equal(result, expected) # Compare to NaT with series containing NaT expected = left_f(s_nat, NaT) result = right_f(NaT, s_nat) tm.assert_series_equal(result, expected) def test_dt64arr_timestamp_equality(self, box_with_array): # GH#11034 ser = Series([Timestamp("2000-01-29 01:59:00"), Timestamp("2000-01-30"), NaT]) ser = tm.box_expected(ser, box_with_array) xbox = get_upcast_box(ser, ser, True) result = ser != ser expected = tm.box_expected([False, False, True], xbox) tm.assert_equal(result, expected) warn = FutureWarning if box_with_array is pd.DataFrame else None with tm.assert_produces_warning(warn): # alignment for frame vs series comparisons deprecated result = ser != ser[0] expected = tm.box_expected([False, True, True], xbox) tm.assert_equal(result, expected) with tm.assert_produces_warning(warn): # alignment for frame vs series comparisons deprecated result = ser != ser[2] expected = tm.box_expected([True, True, True], xbox) tm.assert_equal(result, expected) result = ser == ser expected = tm.box_expected([True, True, False], xbox) tm.assert_equal(result, expected) with tm.assert_produces_warning(warn): # alignment for frame vs series comparisons deprecated result = ser == ser[0] expected = tm.box_expected([True, False, False], xbox) tm.assert_equal(result, expected) with tm.assert_produces_warning(warn): # alignment for frame vs series comparisons deprecated result = ser == ser[2] expected = tm.box_expected([False, False, False], xbox) tm.assert_equal(result, expected) @pytest.mark.parametrize( "datetimelike", [ Timestamp("20130101"), datetime(2013, 1, 1), np.datetime64("2013-01-01T00:00", "ns"), ], ) @pytest.mark.parametrize( "op,expected", [ (operator.lt, [True, False, False, False]), (operator.le, [True, True, False, False]), (operator.eq, [False, True, False, False]), (operator.gt, [False, False, False, True]), ], ) def test_dt64_compare_datetime_scalar(self, datetimelike, op, expected): # GH#17965, test for ability to compare datetime64[ns] columns # to datetimelike ser = Series( [ Timestamp("20120101"), Timestamp("20130101"), np.nan, Timestamp("20130103"), ], name="A", ) result = op(ser, datetimelike) expected = Series(expected, name="A") tm.assert_series_equal(result, expected) class TestDatetimeIndexComparisons: # TODO: moved from tests.indexes.test_base; parametrize and de-duplicate def test_comparators(self, comparison_op): index = tm.makeDateIndex(100) element = index[len(index) // 2] element = Timestamp(element).to_datetime64() arr = np.array(index) arr_result = comparison_op(arr, element) index_result = comparison_op(index, element) assert isinstance(index_result, np.ndarray) tm.assert_numpy_array_equal(arr_result, index_result) @pytest.mark.parametrize( "other", [datetime(2016, 1, 1), Timestamp("2016-01-01"), np.datetime64("2016-01-01")], ) def test_dti_cmp_datetimelike(self, other, tz_naive_fixture): tz = tz_naive_fixture dti = date_range("2016-01-01", periods=2, tz=tz) if tz is not None: if isinstance(other, np.datetime64): # no tzaware version available return other = localize_pydatetime(other, dti.tzinfo) result = dti == other expected = np.array([True, False]) tm.assert_numpy_array_equal(result, expected) result = dti > other expected = np.array([False, True]) tm.assert_numpy_array_equal(result, expected) result = dti >= other expected = np.array([True, True]) tm.assert_numpy_array_equal(result, expected) result = dti < other expected = np.array([False, False]) tm.assert_numpy_array_equal(result, expected) result = dti <= other expected = np.array([True, False]) tm.assert_numpy_array_equal(result, expected) @pytest.mark.parametrize("dtype", [None, object]) def test_dti_cmp_nat(self, dtype, box_with_array): left = DatetimeIndex([Timestamp("2011-01-01"), NaT, Timestamp("2011-01-03")]) right = DatetimeIndex([NaT, NaT, Timestamp("2011-01-03")]) left = tm.box_expected(left, box_with_array) right = tm.box_expected(right, box_with_array) xbox = get_upcast_box(left, right, True) lhs, rhs = left, right if dtype is object: lhs, rhs = left.astype(object), right.astype(object) result = rhs == lhs expected = np.array([False, False, True]) expected = tm.box_expected(expected, xbox) tm.assert_equal(result, expected) result = lhs != rhs expected = np.array([True, True, False]) expected = tm.box_expected(expected, xbox) tm.assert_equal(result, expected) expected = np.array([False, False, False]) expected = tm.box_expected(expected, xbox) tm.assert_equal(lhs == NaT, expected) tm.assert_equal(NaT == rhs, expected) expected = np.array([True, True, True]) expected = tm.box_expected(expected, xbox) tm.assert_equal(lhs != NaT, expected) tm.assert_equal(NaT != lhs, expected) expected = np.array([False, False, False]) expected = tm.box_expected(expected, xbox) tm.assert_equal(lhs < NaT, expected) tm.assert_equal(NaT > lhs, expected) def test_dti_cmp_nat_behaves_like_float_cmp_nan(self): fidx1 = pd.Index([1.0, np.nan, 3.0, np.nan, 5.0, 7.0]) fidx2 = pd.Index([2.0, 3.0, np.nan, np.nan, 6.0, 7.0]) didx1 = DatetimeIndex( ["2014-01-01", NaT, "2014-03-01", NaT, "2014-05-01", "2014-07-01"] ) didx2 = DatetimeIndex( ["2014-02-01", "2014-03-01", NaT, NaT, "2014-06-01", "2014-07-01"] ) darr = np.array( [ np.datetime64("2014-02-01 00:00"), np.datetime64("2014-03-01 00:00"), np.datetime64("nat"), np.datetime64("nat"), np.datetime64("2014-06-01 00:00"), np.datetime64("2014-07-01 00:00"), ] ) cases = [(fidx1, fidx2), (didx1, didx2), (didx1, darr)] # Check pd.NaT is handles as the same as np.nan with tm.assert_produces_warning(None): for idx1, idx2 in cases: result = idx1 < idx2 expected = np.array([True, False, False, False, True, False]) tm.assert_numpy_array_equal(result, expected) result = idx2 > idx1 expected = np.array([True, False, False, False, True, False]) tm.assert_numpy_array_equal(result, expected) result = idx1 <= idx2 expected = np.array([True, False, False, False, True, True]) tm.assert_numpy_array_equal(result, expected) result = idx2 >= idx1 expected = np.array([True, False, False, False, True, True]) tm.assert_numpy_array_equal(result, expected) result = idx1 == idx2 expected = np.array([False, False, False, False, False, True]) tm.assert_numpy_array_equal(result, expected) result = idx1 != idx2 expected = np.array([True, True, True, True, True, False]) tm.assert_numpy_array_equal(result, expected) with tm.assert_produces_warning(None): for idx1, val in [(fidx1, np.nan), (didx1, NaT)]: result = idx1 < val expected = np.array([False, False, False, False, False, False]) tm.assert_numpy_array_equal(result, expected) result = idx1 > val tm.assert_numpy_array_equal(result, expected) result = idx1 <= val tm.assert_numpy_array_equal(result, expected) result = idx1 >= val tm.assert_numpy_array_equal(result, expected) result = idx1 == val tm.assert_numpy_array_equal(result, expected) result = idx1 != val expected = np.array([True, True, True, True, True, True]) tm.assert_numpy_array_equal(result, expected) # Check pd.NaT is handles as the same as np.nan with tm.assert_produces_warning(None): for idx1, val in [(fidx1, 3), (didx1, datetime(2014, 3, 1))]: result = idx1 < val expected = np.array([True, False, False, False, False, False]) tm.assert_numpy_array_equal(result, expected) result = idx1 > val expected = np.array([False, False, False, False, True, True]) tm.assert_numpy_array_equal(result, expected) result = idx1 <= val expected = np.array([True, False, True, False, False, False]) tm.assert_numpy_array_equal(result, expected) result = idx1 >= val expected = np.array([False, False, True, False, True, True]) tm.assert_numpy_array_equal(result, expected) result = idx1 == val expected = np.array([False, False, True, False, False, False]) tm.assert_numpy_array_equal(result, expected) result = idx1 != val expected = np.array([True, True, False, True, True, True]) tm.assert_numpy_array_equal(result, expected) def test_comparison_tzawareness_compat(self, comparison_op, box_with_array): # GH#18162 op = comparison_op box = box_with_array dr = date_range("2016-01-01", periods=6) dz = dr.tz_localize("US/Pacific") dr = tm.box_expected(dr, box) dz = tm.box_expected(dz, box) if box is pd.DataFrame: tolist = lambda x: x.astype(object).values.tolist()[0] else: tolist = list if op not in [operator.eq, operator.ne]: msg = ( r"Invalid comparison between dtype=datetime64\[ns.*\] " "and (Timestamp|DatetimeArray|list|ndarray)" ) with pytest.raises(TypeError, match=msg): op(dr, dz) with pytest.raises(TypeError, match=msg): op(dr, tolist(dz)) with pytest.raises(TypeError, match=msg): op(dr, np.array(tolist(dz), dtype=object)) with pytest.raises(TypeError, match=msg): op(dz, dr) with pytest.raises(TypeError, match=msg): op(dz, tolist(dr)) with pytest.raises(TypeError, match=msg): op(dz, np.array(tolist(dr), dtype=object)) # The aware==aware and naive==naive comparisons should *not* raise assert np.all(dr == dr) assert np.all(dr == tolist(dr)) assert np.all(tolist(dr) == dr) assert np.all(np.array(tolist(dr), dtype=object) == dr) assert np.all(dr == np.array(tolist(dr), dtype=object)) assert np.all(dz == dz) assert np.all(dz == tolist(dz)) assert np.all(tolist(dz) == dz) assert np.all(np.array(tolist(dz), dtype=object) == dz) assert np.all(dz == np.array(tolist(dz), dtype=object)) def test_comparison_tzawareness_compat_scalars(self, comparison_op, box_with_array): # GH#18162 op = comparison_op dr = date_range("2016-01-01", periods=6) dz = dr.tz_localize("US/Pacific") dr = tm.box_expected(dr, box_with_array) dz = tm.box_expected(dz, box_with_array) # Check comparisons against scalar Timestamps ts = Timestamp("2000-03-14 01:59") ts_tz = Timestamp("2000-03-14 01:59", tz="Europe/Amsterdam") assert np.all(dr > ts) msg = r"Invalid comparison between dtype=datetime64\[ns.*\] and Timestamp" if op not in [operator.eq, operator.ne]: with pytest.raises(TypeError, match=msg): op(dr, ts_tz) assert np.all(dz > ts_tz) if op not in [operator.eq, operator.ne]: with pytest.raises(TypeError, match=msg): op(dz, ts) if op not in [operator.eq, operator.ne]: # GH#12601: Check comparison against Timestamps and DatetimeIndex with pytest.raises(TypeError, match=msg): op(ts, dz) @pytest.mark.parametrize( "other", [datetime(2016, 1, 1), Timestamp("2016-01-01"), np.datetime64("2016-01-01")], ) # Bug in NumPy? https://github.com/numpy/numpy/issues/13841 # Raising in __eq__ will fallback to NumPy, which warns, fails, # then re-raises the original exception. So we just need to ignore. @pytest.mark.filterwarnings("ignore:elementwise comp:DeprecationWarning") @pytest.mark.filterwarnings("ignore:Converting timezone-aware:FutureWarning") def test_scalar_comparison_tzawareness( self, comparison_op, other, tz_aware_fixture, box_with_array ): op = comparison_op tz = tz_aware_fixture dti = date_range("2016-01-01", periods=2, tz=tz) dtarr = tm.box_expected(dti, box_with_array) xbox = get_upcast_box(dtarr, other, True) if op in [operator.eq, operator.ne]: exbool = op is operator.ne expected = np.array([exbool, exbool], dtype=bool) expected = tm.box_expected(expected, xbox) result = op(dtarr, other) tm.assert_equal(result, expected) result = op(other, dtarr) tm.assert_equal(result, expected) else: msg = ( r"Invalid comparison between dtype=datetime64\[ns, .*\] " f"and {type(other).__name__}" ) with pytest.raises(TypeError, match=msg): op(dtarr, other) with pytest.raises(TypeError, match=msg): op(other, dtarr) def test_nat_comparison_tzawareness(self, comparison_op): # GH#19276 # tzaware DatetimeIndex should not raise when compared to NaT op = comparison_op dti = DatetimeIndex( ["2014-01-01", NaT, "2014-03-01", NaT, "2014-05-01", "2014-07-01"] ) expected = np.array([op == operator.ne] * len(dti)) result = op(dti, NaT) tm.assert_numpy_array_equal(result, expected) result = op(dti.tz_localize("US/Pacific"), NaT) tm.assert_numpy_array_equal(result, expected) def test_dti_cmp_str(self, tz_naive_fixture): # GH#22074 # regardless of tz, we expect these comparisons are valid tz = tz_naive_fixture rng = date_range("1/1/2000", periods=10, tz=tz) other = "1/1/2000" result = rng == other expected = np.array([True] + [False] * 9) tm.assert_numpy_array_equal(result, expected) result = rng != other expected = np.array([False] + [True] * 9) tm.assert_numpy_array_equal(result, expected) result = rng < other expected = np.array([False] * 10) tm.assert_numpy_array_equal(result, expected) result = rng <= other expected = np.array([True] + [False] * 9) tm.assert_numpy_array_equal(result, expected) result = rng > other expected = np.array([False] + [True] * 9) tm.assert_numpy_array_equal(result, expected) result = rng >= other expected = np.array([True] * 10) tm.assert_numpy_array_equal(result, expected) def test_dti_cmp_list(self): rng = date_range("1/1/2000", periods=10) result = rng == list(rng) expected = rng == rng tm.assert_numpy_array_equal(result, expected) @pytest.mark.parametrize( "other", [ pd.timedelta_range("1D", periods=10), pd.timedelta_range("1D", periods=10).to_series(), pd.timedelta_range("1D", periods=10).asi8.view("m8[ns]"), ], ids=lambda x: type(x).__name__, ) def test_dti_cmp_tdi_tzawareness(self, other): # GH#22074 # reversion test that we _don't_ call _assert_tzawareness_compat # when comparing against TimedeltaIndex dti = date_range("2000-01-01", periods=10, tz="Asia/Tokyo") result = dti == other expected = np.array([False] * 10) tm.assert_numpy_array_equal(result, expected) result = dti != other expected = np.array([True] * 10) tm.assert_numpy_array_equal(result, expected) msg = "Invalid comparison between" with pytest.raises(TypeError, match=msg): dti < other with pytest.raises(TypeError, match=msg): dti <= other with pytest.raises(TypeError, match=msg): dti > other with pytest.raises(TypeError, match=msg): dti >= other def test_dti_cmp_object_dtype(self): # GH#22074 dti = date_range("2000-01-01", periods=10, tz="Asia/Tokyo") other = dti.astype("O") result = dti == other expected = np.array([True] * 10) tm.assert_numpy_array_equal(result, expected) other = dti.tz_localize(None) result = dti != other tm.assert_numpy_array_equal(result, expected) other = np.array(list(dti[:5]) + [Timedelta(days=1)] * 5) result = dti == other expected = np.array([True] * 5 + [False] * 5) tm.assert_numpy_array_equal(result, expected) msg = ">=' not supported between instances of 'Timestamp' and 'Timedelta'" with pytest.raises(TypeError, match=msg): dti >= other # ------------------------------------------------------------------ # Arithmetic class TestDatetime64Arithmetic: # This class is intended for "finished" tests that are fully parametrized # over DataFrame/Series/Index/DatetimeArray # ------------------------------------------------------------- # Addition/Subtraction of timedelta-like @pytest.mark.arm_slow def test_dt64arr_add_timedeltalike_scalar( self, tz_naive_fixture, two_hours, box_with_array ): # GH#22005, GH#22163 check DataFrame doesn't raise TypeError tz = tz_naive_fixture rng = date_range("2000-01-01", "2000-02-01", tz=tz) expected = date_range("2000-01-01 02:00", "2000-02-01 02:00", tz=tz) rng = tm.box_expected(rng, box_with_array) expected = tm.box_expected(expected, box_with_array) result = rng + two_hours tm.assert_equal(result, expected) rng += two_hours tm.assert_equal(rng, expected) def test_dt64arr_sub_timedeltalike_scalar( self, tz_naive_fixture, two_hours, box_with_array ): tz = tz_naive_fixture rng = date_range("2000-01-01", "2000-02-01", tz=tz) expected = date_range("1999-12-31 22:00", "2000-01-31 22:00", tz=tz) rng = tm.box_expected(rng, box_with_array) expected = tm.box_expected(expected, box_with_array) result = rng - two_hours tm.assert_equal(result, expected) rng -= two_hours tm.assert_equal(rng, expected) # TODO: redundant with test_dt64arr_add_timedeltalike_scalar def test_dt64arr_add_td64_scalar(self, box_with_array): # scalar timedeltas/np.timedelta64 objects # operate with np.timedelta64 correctly ser = Series([Timestamp("20130101 9:01"), Timestamp("20130101 9:02")]) expected = Series( [Timestamp("20130101 9:01:01"), Timestamp("20130101 9:02:01")] ) dtarr = tm.box_expected(ser, box_with_array) expected = tm.box_expected(expected, box_with_array) result = dtarr + np.timedelta64(1, "s") tm.assert_equal(result, expected) result = np.timedelta64(1, "s") + dtarr tm.assert_equal(result, expected) expected = Series( [Timestamp("20130101 9:01:00.005"), Timestamp("20130101 9:02:00.005")] ) expected = tm.box_expected(expected, box_with_array) result = dtarr + np.timedelta64(5, "ms") tm.assert_equal(result, expected) result = np.timedelta64(5, "ms") + dtarr tm.assert_equal(result, expected) def test_dt64arr_add_sub_td64_nat(self, box_with_array, tz_naive_fixture): # GH#23320 special handling for timedelta64("NaT") tz = tz_naive_fixture dti = date_range("1994-04-01", periods=9, tz=tz, freq="QS") other = np.timedelta64("NaT") expected = DatetimeIndex(["NaT"] * 9, tz=tz) obj = tm.box_expected(dti, box_with_array) expected = tm.box_expected(expected, box_with_array) result = obj + other tm.assert_equal(result, expected) result = other + obj tm.assert_equal(result, expected) result = obj - other tm.assert_equal(result, expected) msg = "cannot subtract" with pytest.raises(TypeError, match=msg): other - obj def test_dt64arr_add_sub_td64ndarray(self, tz_naive_fixture, box_with_array): tz = tz_naive_fixture dti = date_range("2016-01-01", periods=3, tz=tz) tdi = TimedeltaIndex(["-1 Day", "-1 Day", "-1 Day"]) tdarr = tdi.values expected = date_range("2015-12-31", "2016-01-02", periods=3, tz=tz) dtarr = tm.box_expected(dti, box_with_array) expected = tm.box_expected(expected, box_with_array) result = dtarr + tdarr tm.assert_equal(result, expected) result = tdarr + dtarr tm.assert_equal(result, expected) expected = date_range("2016-01-02", "2016-01-04", periods=3, tz=tz) expected = tm.box_expected(expected, box_with_array) result = dtarr - tdarr tm.assert_equal(result, expected) msg = "cannot subtract|(bad|unsupported) operand type for unary" with pytest.raises(TypeError, match=msg): tdarr - dtarr # ----------------------------------------------------------------- # Subtraction of datetime-like scalars @pytest.mark.parametrize( "ts", [ Timestamp("2013-01-01"), Timestamp("2013-01-01").to_pydatetime(), Timestamp("2013-01-01").to_datetime64(), ], ) def test_dt64arr_sub_dtscalar(self, box_with_array, ts): # GH#8554, GH#22163 DataFrame op should _not_ return dt64 dtype idx = date_range("2013-01-01", periods=3)._with_freq(None) idx = tm.box_expected(idx, box_with_array) expected = TimedeltaIndex(["0 Days", "1 Day", "2 Days"]) expected = tm.box_expected(expected, box_with_array) result = idx - ts tm.assert_equal(result, expected) def test_dt64arr_sub_datetime64_not_ns(self, box_with_array): # GH#7996, GH#22163 ensure non-nano datetime64 is converted to nano # for DataFrame operation dt64 = np.datetime64("2013-01-01") assert dt64.dtype == "datetime64[D]" dti = date_range("20130101", periods=3)._with_freq(None) dtarr = tm.box_expected(dti, box_with_array) expected = TimedeltaIndex(["0 Days", "1 Day", "2 Days"]) expected = tm.box_expected(expected, box_with_array) result = dtarr - dt64 tm.assert_equal(result, expected) result = dt64 - dtarr tm.assert_equal(result, -expected) def test_dt64arr_sub_timestamp(self, box_with_array): ser = date_range("2014-03-17", periods=2, freq="D", tz="US/Eastern") ser = ser._with_freq(None) ts = ser[0] ser = tm.box_expected(ser, box_with_array) delta_series = Series([np.timedelta64(0, "D"), np.timedelta64(1, "D")]) expected = tm.box_expected(delta_series, box_with_array) tm.assert_equal(ser - ts, expected) tm.assert_equal(ts - ser, -expected) def test_dt64arr_sub_NaT(self, box_with_array): # GH#18808 dti = DatetimeIndex([NaT, Timestamp("19900315")]) ser = tm.box_expected(dti, box_with_array) result = ser - NaT expected = Series([NaT, NaT], dtype="timedelta64[ns]") expected = tm.box_expected(expected, box_with_array) tm.assert_equal(result, expected) dti_tz = dti.tz_localize("Asia/Tokyo") ser_tz = tm.box_expected(dti_tz, box_with_array) result = ser_tz - NaT expected = Series([NaT, NaT], dtype="timedelta64[ns]") expected = tm.box_expected(expected, box_with_array) tm.assert_equal(result, expected) # ------------------------------------------------------------- # Subtraction of datetime-like array-like def test_dt64arr_sub_dt64object_array(self, box_with_array, tz_naive_fixture): dti = date_range("2016-01-01", periods=3, tz=tz_naive_fixture) expected = dti - dti obj = tm.box_expected(dti, box_with_array) expected = tm.box_expected(expected, box_with_array) with tm.assert_produces_warning(PerformanceWarning): result = obj - obj.astype(object) tm.assert_equal(result, expected) def test_dt64arr_naive_sub_dt64ndarray(self, box_with_array): dti = date_range("2016-01-01", periods=3, tz=None) dt64vals = dti.values dtarr = tm.box_expected(dti, box_with_array) expected = dtarr - dtarr result = dtarr - dt64vals tm.assert_equal(result, expected) result = dt64vals - dtarr tm.assert_equal(result, expected) def test_dt64arr_aware_sub_dt64ndarray_raises( self, tz_aware_fixture, box_with_array ): tz = tz_aware_fixture dti = date_range("2016-01-01", periods=3, tz=tz) dt64vals = dti.values dtarr = tm.box_expected(dti, box_with_array) msg = "subtraction must have the same timezones or" with pytest.raises(TypeError, match=msg): dtarr - dt64vals with pytest.raises(TypeError, match=msg): dt64vals - dtarr # ------------------------------------------------------------- # Addition of datetime-like others (invalid) def test_dt64arr_add_dt64ndarray_raises(self, tz_naive_fixture, box_with_array): tz = tz_naive_fixture dti = date_range("2016-01-01", periods=3, tz=tz) dt64vals = dti.values dtarr = tm.box_expected(dti, box_with_array) assert_cannot_add(dtarr, dt64vals) def test_dt64arr_add_timestamp_raises(self, box_with_array): # GH#22163 ensure DataFrame doesn't cast Timestamp to i8 idx = DatetimeIndex(["2011-01-01", "2011-01-02"]) ts = idx[0] idx = tm.box_expected(idx, box_with_array) assert_cannot_add(idx, ts) # ------------------------------------------------------------- # Other Invalid Addition/Subtraction @pytest.mark.parametrize( "other", [ 3.14, np.array([2.0, 3.0]), # GH#13078 datetime +/- Period is invalid Period("2011-01-01", freq="D"), # https://github.com/pandas-dev/pandas/issues/10329 time(1, 2, 3), ], ) @pytest.mark.parametrize("dti_freq", [None, "D"]) def test_dt64arr_add_sub_invalid(self, dti_freq, other, box_with_array): dti = DatetimeIndex(["2011-01-01", "2011-01-02"], freq=dti_freq) dtarr = tm.box_expected(dti, box_with_array) msg = "|".join( [ "unsupported operand type", "cannot (add|subtract)", "cannot use operands with types", "ufunc '?(add|subtract)'? cannot use operands with types", "Concatenation operation is not implemented for NumPy arrays", ] ) assert_invalid_addsub_type(dtarr, other, msg) @pytest.mark.parametrize("pi_freq", ["D", "W", "Q", "H"]) @pytest.mark.parametrize("dti_freq", [None, "D"]) def test_dt64arr_add_sub_parr( self, dti_freq, pi_freq, box_with_array, box_with_array2 ): # GH#20049 subtracting PeriodIndex should raise TypeError dti = DatetimeIndex(["2011-01-01", "2011-01-02"], freq=dti_freq) pi = dti.to_period(pi_freq) dtarr = tm.box_expected(dti, box_with_array) parr = tm.box_expected(pi, box_with_array2) msg = "|".join( [ "cannot (add|subtract)", "unsupported operand", "descriptor.*requires", "ufunc.*cannot use operands", ] )
assert_invalid_addsub_type(dtarr, parr, msg)
pandas.tests.arithmetic.common.assert_invalid_addsub_type
import pandas as pd from sklearn.model_selection import train_test_split from sklearn.datasets import load_wine from pdb import set_trace as breakpoint # from IPython.display import display def enlarge(n): ''' This function will multiple the input by 100 ''' return n * 100 class MyDataSplitter(): ''' This class implements a 3-way data split and outputs summary metrics. ''' def __init__(self, df): self.df = df def train_validation_test_split(self, features, target, train_size=0.7, val_size=0.1, test_size=0.2, random_state=None, shuffle=True): ''' This function is a utility wrapper around the Scikit-Learn train_test_split that splits arrays or matrices into train, validation, and test subsets. Args: X (Numpy array or DataFrame): This is a dataframe with features. y (Numpy array or DataFrame): This is a pandas Series with target. train_size (float or int): Proportion of the dataset to include in the train split (0 to 1). val_size (float or int): Proportion of the dataset to include in the validation split (0 to 1). test_size (float or int): Proportion of the dataset to include in the test split (0 to 1). random_state (int): Controls the shuffling applied to the data before applying the split for reproducibility. shuffle (bool): Whether or not to shuffle the data before splitting Returns: Train, test, and validation dataframes for features (X) and target (y). ''' X_train_val, X_test, y_train_val, y_test = train_test_split( self.X, self.y, test_size=test_size, random_state=random_state, shuffle=shuffle) X_train, X_val, y_train, y_val = train_test_split( X_train_val, y_train_val, test_size=val_size / (train_size + val_size), random_state=random_state, shuffle=shuffle) return X_train, X_val, X_test, y_train, y_val, y_test def date_divider(self, date_col): ''' Param df: dataframe object from the Pandas library, entire dataframe where the date_column is located is required Param date_col: String value of the name of the date_column to be looked up in the passed dataframe Return: modified dataframe with the new Year, Month, and Day columns attached to the end. ''' converted_df = self.df.copy() converted_df["Year"] =
pd.DatetimeIndex(converted_df[date_col])
pandas.DatetimeIndex
__author__ = '<NAME>' __email__ = '<EMAIL>' __status__ = 'Development' import numpy as np import pandas as pd # read input data def read_data(path): data = pd.read_csv(path) data['date'] = pd.to_datetime(data['date']) return data # calculate active storage (initial state-current state) * 100 / initial state and total active storage and time to equilibrium def calc_active_storage(data): df_AS = pd.DataFrame() df_AS['date'] = data['date'] AS = TtE = np.empty([0]) for i in range(1, data.shape[1]): df_AS[data.columns[i]] = (data.iloc[0, i] - data.iloc[:, i]) * 100 / data.iloc[0, i] AS = np.append(AS, df_AS.iloc[:, i].loc[~df_AS.iloc[:, i].isnull()].iloc[-1]) TtE = np.append(TtE, df_AS.iloc[:, i].loc[~df_AS.iloc[:, i].isnull()].shape[0]-1) return [df_AS, AS, TtE] # extract features def extr_features(df_AS, AS, TtE): df_Feature =
pd.DataFrame()
pandas.DataFrame
# -*- coding: utf-8 -*- import unittest import platform import pandas as pd import numpy as np import pyarrow.parquet as pq import hpat from hpat.tests.test_utils import ( count_array_REPs, count_parfor_REPs, count_array_OneDs, get_start_end) from hpat.tests.gen_test_data import ParquetGenerator from numba import types from numba.config import IS_32BITS from numba.errors import TypingError _cov_corr_series = [(pd.Series(x), pd.Series(y)) for x, y in [ ( [np.nan, -2., 3., 9.1], [np.nan, -2., 3., 5.0], ), # TODO(quasilyte): more intricate data for complex-typed series. # Some arguments make assert_almost_equal fail. # Functions that yield mismaching results: # _column_corr_impl and _column_cov_impl. ( [complex(-2., 1.0), complex(3.0, 1.0)], [complex(-3., 1.0), complex(2.0, 1.0)], ), ( [complex(-2.0, 1.0), complex(3.0, 1.0)], [1.0, -2.0], ), ( [1.0, -4.5], [complex(-4.5, 1.0), complex(3.0, 1.0)], ), ]] min_float64 = np.finfo('float64').min max_float64 = np.finfo('float64').max test_global_input_data_float64 = [ [1., np.nan, -1., 0., min_float64, max_float64], [np.nan, np.inf, np.NINF, np.NZERO] ] min_int64 = np.iinfo('int64').min max_int64 = np.iinfo('int64').max max_uint64 = np.iinfo('uint64').max test_global_input_data_integer64 = [ [1, -1, 0], [min_int64, max_int64], [max_uint64] ] test_global_input_data_numeric = test_global_input_data_integer64 + test_global_input_data_float64 test_global_input_data_unicode_kind4 = [ 'ascii', '12345', '1234567890', '¡Y tú quién te crees?', '🐍⚡', '大处着眼,小处着手。', ] test_global_input_data_unicode_kind1 = [ 'ascii', '12345', '1234567890', ] def _make_func_from_text(func_text, func_name='test_impl'): loc_vars = {} exec(func_text, {}, loc_vars) test_impl = loc_vars[func_name] return test_impl def _make_func_use_binop1(operator): func_text = "def test_impl(A, B):\n" func_text += " return A {} B\n".format(operator) return _make_func_from_text(func_text) def _make_func_use_binop2(operator): func_text = "def test_impl(A, B):\n" func_text += " A {} B\n".format(operator) func_text += " return A\n" return _make_func_from_text(func_text) def _make_func_use_method_arg1(method): func_text = "def test_impl(A, B):\n" func_text += " return A.{}(B)\n".format(method) return _make_func_from_text(func_text) GLOBAL_VAL = 2 class TestSeries(unittest.TestCase): def test_create1(self): def test_impl(): df = pd.DataFrame({'A': [1, 2, 3]}) return (df.A == 1).sum() hpat_func = hpat.jit(test_impl) self.assertEqual(hpat_func(), test_impl()) @unittest.skip('Feature request: implement Series::ctor with list(list(type))') def test_create_list_list_unicode(self): def test_impl(): S = pd.Series([ ['abc', 'defg', 'ijk'], ['lmn', 'opq', 'rstuvwxyz'] ]) return S hpat_func = hpat.jit(test_impl) result_ref = test_impl() result = hpat_func() pd.testing.assert_series_equal(result, result_ref) @unittest.skip('Feature request: implement Series::ctor with list(list(type))') def test_create_list_list_integer(self): def test_impl(): S = pd.Series([ [123, 456, -789], [-112233, 445566, 778899] ]) return S hpat_func = hpat.jit(test_impl) result_ref = test_impl() result = hpat_func() pd.testing.assert_series_equal(result, result_ref) @unittest.skip('Feature request: implement Series::ctor with list(list(type))') def test_create_list_list_float(self): def test_impl(): S = pd.Series([ [1.23, -4.56, 7.89], [11.2233, 44.5566, -778.899] ]) return S hpat_func = hpat.jit(test_impl) result_ref = test_impl() result = hpat_func() pd.testing.assert_series_equal(result, result_ref) def test_create2(self): def test_impl(n): df = pd.DataFrame({'A': np.arange(n)}) return (df.A == 2).sum() hpat_func = hpat.jit(test_impl) n = 11 self.assertEqual(hpat_func(n), test_impl(n)) def test_create_series1(self): def test_impl(): A = pd.Series([1, 2, 3]) return A hpat_func = hpat.jit(test_impl) pd.testing.assert_series_equal(hpat_func(), test_impl()) def test_create_series_index1(self): # create and box an indexed Series def test_impl(): A = pd.Series([1, 2, 3], ['A', 'C', 'B']) return A hpat_func = hpat.jit(test_impl) pd.testing.assert_series_equal(hpat_func(), test_impl()) def test_create_series_index2(self): def test_impl(): A = pd.Series([1, 2, 3], index=['A', 'C', 'B']) return A hpat_func = hpat.jit(test_impl) pd.testing.assert_series_equal(hpat_func(), test_impl()) def test_create_series_index3(self): def test_impl(): A = pd.Series([1, 2, 3], index=['A', 'C', 'B'], name='A') return A hpat_func = hpat.jit(test_impl) pd.testing.assert_series_equal(hpat_func(), test_impl()) def test_create_series_index4(self): def test_impl(name): A = pd.Series([1, 2, 3], index=['A', 'C', 'B'], name=name) return A hpat_func = hpat.jit(test_impl) pd.testing.assert_series_equal(hpat_func('A'), test_impl('A')) def test_create_str(self): def test_impl(): df = pd.DataFrame({'A': ['a', 'b', 'c']}) return (df.A == 'a').sum() hpat_func = hpat.jit(test_impl) self.assertEqual(hpat_func(), test_impl()) def test_pass_df1(self): def test_impl(df): return (df.A == 2).sum() hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) self.assertEqual(hpat_func(df), test_impl(df)) def test_pass_df_str(self): def test_impl(df): return (df.A == 'a').sum() hpat_func = hpat.jit(test_impl) df = pd.DataFrame({'A': ['a', 'b', 'c']}) self.assertEqual(hpat_func(df), test_impl(df)) def test_pass_series1(self): # TODO: check to make sure it is series type def test_impl(A): return (A == 2).sum() hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) self.assertEqual(hpat_func(df.A), test_impl(df.A)) def test_pass_series2(self): # test creating dataframe from passed series def test_impl(A): df = pd.DataFrame({'A': A}) return (df.A == 2).sum() hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) self.assertEqual(hpat_func(df.A), test_impl(df.A)) def test_pass_series_str(self): def test_impl(A): return (A == 'a').sum() hpat_func = hpat.jit(test_impl) df = pd.DataFrame({'A': ['a', 'b', 'c']}) self.assertEqual(hpat_func(df.A), test_impl(df.A)) def test_pass_series_index1(self): def test_impl(A): return A hpat_func = hpat.jit(test_impl) S = pd.Series([3, 5, 6], ['a', 'b', 'c'], name='A') pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_size(self): def test_impl(S): return S.size hpat_func = hpat.jit(test_impl) n = 11 for S, expected in [ (pd.Series(), 0), (pd.Series([]), 0), (pd.Series(np.arange(n)), n), (pd.Series([np.nan, 1, 2]), 3), (pd.Series(['1', '2', '3']), 3), ]: with self.subTest(S=S, expected=expected): self.assertEqual(hpat_func(S), expected) self.assertEqual(hpat_func(S), test_impl(S)) def test_series_attr2(self): def test_impl(A): return A.copy().values hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) np.testing.assert_array_equal(hpat_func(df.A), test_impl(df.A)) def test_series_attr3(self): def test_impl(A): return A.min() hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) self.assertEqual(hpat_func(df.A), test_impl(df.A)) def test_series_attr4(self): def test_impl(A): return A.cumsum().values hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) np.testing.assert_array_equal(hpat_func(df.A), test_impl(df.A)) def test_series_argsort1(self): def test_impl(A): return A.argsort() hpat_func = hpat.jit(test_impl) n = 11 A = pd.Series(np.random.ranf(n)) pd.testing.assert_series_equal(hpat_func(A), test_impl(A)) def test_series_attr6(self): def test_impl(A): return A.take([2, 3]).values hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) np.testing.assert_array_equal(hpat_func(df.A), test_impl(df.A)) def test_series_attr7(self): def test_impl(A): return A.astype(np.float64) hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) np.testing.assert_array_equal(hpat_func(df.A), test_impl(df.A)) def test_series_getattr_ndim(self): '''Verifies getting Series attribute ndim is supported''' def test_impl(S): return S.ndim hpat_func = hpat.jit(test_impl) n = 11 S = pd.Series(np.arange(n)) self.assertEqual(hpat_func(S), test_impl(S)) def test_series_getattr_T(self): '''Verifies getting Series attribute T is supported''' def test_impl(S): return S.T hpat_func = hpat.jit(test_impl) n = 11 S = pd.Series(np.arange(n)) np.testing.assert_array_equal(hpat_func(S), test_impl(S)) def test_series_copy_str1(self): def test_impl(A): return A.copy() hpat_func = hpat.jit(test_impl) S = pd.Series(['aa', 'bb', 'cc']) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_copy_int1(self): def test_impl(A): return A.copy() hpat_func = hpat.jit(test_impl) S = pd.Series([1, 2, 3]) np.testing.assert_array_equal(hpat_func(S), test_impl(S)) def test_series_copy_deep(self): def test_impl(A, deep): return A.copy(deep=deep) hpat_func = hpat.jit(test_impl) for S in [ pd.Series([1, 2]), pd.Series([1, 2], index=["a", "b"]), ]: with self.subTest(S=S): for deep in (True, False): with self.subTest(deep=deep): actual = hpat_func(S, deep) expected = test_impl(S, deep) pd.testing.assert_series_equal(actual, expected) self.assertEqual(actual.values is S.values, expected.values is S.values) self.assertEqual(actual.values is S.values, not deep) # Shallow copy of index is not supported yet if deep: self.assertEqual(actual.index is S.index, expected.index is S.index) self.assertEqual(actual.index is S.index, not deep) def test_series_astype_int_to_str1(self): '''Verifies Series.astype implementation with function 'str' as argument converts integer series to series of strings ''' def test_impl(S): return S.astype(str) hpat_func = hpat.jit(test_impl) n = 11 S = pd.Series(np.arange(n)) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_astype_int_to_str2(self): '''Verifies Series.astype implementation with a string literal dtype argument converts integer series to series of strings ''' def test_impl(S): return S.astype('str') hpat_func = hpat.jit(test_impl) n = 11 S = pd.Series(np.arange(n)) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_astype_str_to_str1(self): '''Verifies Series.astype implementation with function 'str' as argument handles string series not changing it ''' def test_impl(S): return S.astype(str) hpat_func = hpat.jit(test_impl) S = pd.Series(['aa', 'bb', 'cc']) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_astype_str_to_str2(self): '''Verifies Series.astype implementation with a string literal dtype argument handles string series not changing it ''' def test_impl(S): return S.astype('str') hpat_func = hpat.jit(test_impl) S = pd.Series(['aa', 'bb', 'cc']) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_astype_str_to_str_index_str(self): '''Verifies Series.astype implementation with function 'str' as argument handles string series not changing it ''' def test_impl(S): return S.astype(str) hpat_func = hpat.jit(test_impl) S = pd.Series(['aa', 'bb', 'cc'], index=['d', 'e', 'f']) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_astype_str_to_str_index_int(self): '''Verifies Series.astype implementation with function 'str' as argument handles string series not changing it ''' def test_impl(S): return S.astype(str) hpat_func = hpat.jit(test_impl) S = pd.Series(['aa', 'bb', 'cc'], index=[1, 2, 3]) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) @unittest.skip('TODO: requires str(datetime64) support in Numba') def test_series_astype_dt_to_str1(self): '''Verifies Series.astype implementation with function 'str' as argument converts datetime series to series of strings ''' def test_impl(A): return A.astype(str) hpat_func = hpat.jit(test_impl) S = pd.Series([pd.Timestamp('20130101 09:00:00'), pd.Timestamp('20130101 09:00:02'), pd.Timestamp('20130101 09:00:03') ]) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) @unittest.skip('AssertionError: Series are different' '[left]: [0.000000, 1.000000, 2.000000, 3.000000, ...' '[right]: [0.0, 1.0, 2.0, 3.0, ...' 'TODO: needs alignment to NumPy on Numba side') def test_series_astype_float_to_str1(self): '''Verifies Series.astype implementation with function 'str' as argument converts float series to series of strings ''' def test_impl(A): return A.astype(str) hpat_func = hpat.jit(test_impl) n = 11.0 S = pd.Series(np.arange(n)) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_astype_int32_to_int64(self): '''Verifies Series.astype implementation with NumPy dtype argument converts series with dtype=int32 to series with dtype=int64 ''' def test_impl(A): return A.astype(np.int64) hpat_func = hpat.jit(test_impl) n = 11 S = pd.Series(np.arange(n), dtype=np.int32) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_astype_int_to_float64(self): '''Verifies Series.astype implementation with NumPy dtype argument converts integer series to series of float ''' def test_impl(A): return A.astype(np.float64) hpat_func = hpat.jit(test_impl) n = 11 S = pd.Series(np.arange(n)) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_astype_float_to_int32(self): '''Verifies Series.astype implementation with NumPy dtype argument converts float series to series of integers ''' def test_impl(A): return A.astype(np.int32) hpat_func = hpat.jit(test_impl) n = 11.0 S = pd.Series(np.arange(n)) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) @unittest.skip('TODO: needs Numba astype impl support string literal as dtype arg') def test_series_astype_literal_dtype1(self): '''Verifies Series.astype implementation with a string literal dtype argument converts float series to series of integers ''' def test_impl(A): return A.astype('int32') hpat_func = hpat.jit(test_impl) n = 11.0 S = pd.Series(np.arange(n)) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) @unittest.skip('TODO: needs Numba astype impl support converting unicode_type to int') def test_series_astype_str_to_int32(self): '''Verifies Series.astype implementation with NumPy dtype argument converts series of strings to series of integers ''' import numba def test_impl(A): return A.astype(np.int32) hpat_func = hpat.jit(test_impl) n = 11 S = pd.Series([str(x) for x in np.arange(n) - n // 2]) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) @unittest.skip('TODO: needs Numba astype impl support converting unicode_type to float') def test_series_astype_str_to_float64(self): '''Verifies Series.astype implementation with NumPy dtype argument converts series of strings to series of float ''' def test_impl(A): return A.astype(np.float64) hpat_func = hpat.jit(test_impl) S = pd.Series(['3.24', '1E+05', '-1', '-1.3E-01', 'nan', 'inf']) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_astype_str_index_str(self): '''Verifies Series.astype implementation with function 'str' as argument handles string series not changing it ''' def test_impl(S): return S.astype(str) hpat_func = hpat.jit(test_impl) S = pd.Series(['aa', 'bb', 'cc'], index=['a', 'b', 'c']) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_astype_str_index_int(self): '''Verifies Series.astype implementation with function 'str' as argument handles string series not changing it ''' def test_impl(S): return S.astype(str) hpat_func = hpat.jit(test_impl) S = pd.Series(['aa', 'bb', 'cc'], index=[2, 3, 5]) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_np_call_on_series1(self): def test_impl(A): return np.min(A) hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) np.testing.assert_array_equal(hpat_func(df.A), test_impl(df.A)) def test_series_values(self): def test_impl(A): return A.values hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) np.testing.assert_array_equal(hpat_func(df.A), test_impl(df.A)) def test_series_values1(self): def test_impl(A): return (A == 2).values hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) np.testing.assert_array_equal(hpat_func(df.A), test_impl(df.A)) def test_series_shape1(self): def test_impl(A): return A.shape hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) self.assertEqual(hpat_func(df.A), test_impl(df.A)) def test_static_setitem_series1(self): def test_impl(A): A[0] = 2 return (A == 2).sum() hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) self.assertEqual(hpat_func(df.A), test_impl(df.A)) def test_setitem_series1(self): def test_impl(A, i): A[i] = 2 return (A == 2).sum() hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) self.assertEqual(hpat_func(df.A.copy(), 0), test_impl(df.A.copy(), 0)) def test_setitem_series2(self): def test_impl(A, i): A[i] = 100 hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) A1 = df.A.copy() A2 = df.A hpat_func(A1, 0) test_impl(A2, 0) pd.testing.assert_series_equal(A1, A2) @unittest.skip("enable after remove dead in hiframes is removed") def test_setitem_series3(self): def test_impl(A, i): S = pd.Series(A) S[i] = 100 hpat_func = hpat.jit(test_impl) n = 11 A = np.arange(n) A1 = A.copy() A2 = A hpat_func(A1, 0) test_impl(A2, 0) np.testing.assert_array_equal(A1, A2) def test_setitem_series_bool1(self): def test_impl(A): A[A > 3] = 100 hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) A1 = df.A.copy() A2 = df.A hpat_func(A1) test_impl(A2) pd.testing.assert_series_equal(A1, A2) def test_setitem_series_bool2(self): def test_impl(A, B): A[A > 3] = B[A > 3] hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n), 'B': np.arange(n)**2}) A1 = df.A.copy() A2 = df.A hpat_func(A1, df.B) test_impl(A2, df.B) pd.testing.assert_series_equal(A1, A2) def test_static_getitem_series1(self): def test_impl(A): return A[0] hpat_func = hpat.jit(test_impl) n = 11 A = pd.Series(np.arange(n)) self.assertEqual(hpat_func(A), test_impl(A)) def test_getitem_series1(self): def test_impl(A, i): return A[i] hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) self.assertEqual(hpat_func(df.A, 0), test_impl(df.A, 0)) def test_getitem_series_str1(self): def test_impl(A, i): return A[i] hpat_func = hpat.jit(test_impl) df = pd.DataFrame({'A': ['aa', 'bb', 'cc']}) self.assertEqual(hpat_func(df.A, 0), test_impl(df.A, 0)) def test_series_iat1(self): def test_impl(A): return A.iat[3] hpat_func = hpat.jit(test_impl) n = 11 S = pd.Series(np.arange(n)**2) self.assertEqual(hpat_func(S), test_impl(S)) def test_series_iat2(self): def test_impl(A): A.iat[3] = 1 return A hpat_func = hpat.jit(test_impl) n = 11 S = pd.Series(np.arange(n)**2) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_iloc1(self): def test_impl(A): return A.iloc[3] hpat_func = hpat.jit(test_impl) n = 11 S = pd.Series(np.arange(n)**2) self.assertEqual(hpat_func(S), test_impl(S)) def test_series_iloc2(self): def test_impl(A): return A.iloc[3:8] hpat_func = hpat.jit(test_impl) n = 11 S = pd.Series(np.arange(n)**2) pd.testing.assert_series_equal( hpat_func(S), test_impl(S).reset_index(drop=True)) def test_series_op1(self): arithmetic_binops = ('+', '-', '*', '/', '//', '%', '**') for operator in arithmetic_binops: test_impl = _make_func_use_binop1(operator) hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(1, n), 'B': np.ones(n - 1)}) pd.testing.assert_series_equal(hpat_func(df.A, df.B), test_impl(df.A, df.B), check_names=False) def test_series_op2(self): arithmetic_binops = ('+', '-', '*', '/', '//', '%', '**') for operator in arithmetic_binops: test_impl = _make_func_use_binop1(operator) hpat_func = hpat.jit(test_impl) n = 11 if platform.system() == 'Windows' and not IS_32BITS: df = pd.DataFrame({'A': np.arange(1, n, dtype=np.int64)}) else: df = pd.DataFrame({'A': np.arange(1, n)}) pd.testing.assert_series_equal(hpat_func(df.A, 1), test_impl(df.A, 1), check_names=False) def test_series_op3(self): arithmetic_binops = ('+', '-', '*', '/', '//', '%', '**') for operator in arithmetic_binops: test_impl = _make_func_use_binop2(operator) hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(1, n), 'B': np.ones(n - 1)}) pd.testing.assert_series_equal(hpat_func(df.A, df.B), test_impl(df.A, df.B), check_names=False) def test_series_op4(self): arithmetic_binops = ('+', '-', '*', '/', '//', '%', '**') for operator in arithmetic_binops: test_impl = _make_func_use_binop2(operator) hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(1, n)}) pd.testing.assert_series_equal(hpat_func(df.A, 1), test_impl(df.A, 1), check_names=False) def test_series_op5(self): arithmetic_methods = ('add', 'sub', 'mul', 'div', 'truediv', 'floordiv', 'mod', 'pow') for method in arithmetic_methods: test_impl = _make_func_use_method_arg1(method) hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(1, n), 'B': np.ones(n - 1)}) pd.testing.assert_series_equal(hpat_func(df.A, df.B), test_impl(df.A, df.B), check_names=False) @unittest.skipIf(platform.system() == 'Windows', 'Series values are different (20.0 %)' '[left]: [1, 1024, 59049, 1048576, 9765625, 60466176, 282475249, 1073741824, 3486784401, 10000000000]' '[right]: [1, 1024, 59049, 1048576, 9765625, 60466176, 282475249, 1073741824, -808182895, 1410065408]') def test_series_op5_integer_scalar(self): arithmetic_methods = ('add', 'sub', 'mul', 'div', 'truediv', 'floordiv', 'mod', 'pow') for method in arithmetic_methods: test_impl = _make_func_use_method_arg1(method) hpat_func = hpat.jit(test_impl) n = 11 if platform.system() == 'Windows' and not IS_32BITS: operand_series = pd.Series(np.arange(1, n, dtype=np.int64)) else: operand_series = pd.Series(np.arange(1, n)) operand_scalar = 10 pd.testing.assert_series_equal( hpat_func(operand_series, operand_scalar), test_impl(operand_series, operand_scalar), check_names=False) def test_series_op5_float_scalar(self): arithmetic_methods = ('add', 'sub', 'mul', 'div', 'truediv', 'floordiv', 'mod', 'pow') for method in arithmetic_methods: test_impl = _make_func_use_method_arg1(method) hpat_func = hpat.jit(test_impl) n = 11 operand_series = pd.Series(np.arange(1, n)) operand_scalar = .5 pd.testing.assert_series_equal( hpat_func(operand_series, operand_scalar), test_impl(operand_series, operand_scalar), check_names=False) def test_series_op6(self): def test_impl(A): return -A hpat_func = hpat.jit(test_impl) n = 11 A = pd.Series(np.arange(n)) pd.testing.assert_series_equal(hpat_func(A), test_impl(A)) def test_series_op7(self): comparison_binops = ('<', '>', '<=', '>=', '!=', '==') for operator in comparison_binops: test_impl = _make_func_use_binop1(operator) hpat_func = hpat.jit(test_impl) n = 11 A = pd.Series(np.arange(n)) B = pd.Series(np.arange(n)**2) pd.testing.assert_series_equal(hpat_func(A, B), test_impl(A, B), check_names=False) def test_series_op8(self): comparison_methods = ('lt', 'gt', 'le', 'ge', 'ne', 'eq') for method in comparison_methods: test_impl = _make_func_use_method_arg1(method) hpat_func = hpat.jit(test_impl) n = 11 A = pd.Series(np.arange(n)) B = pd.Series(np.arange(n)**2) pd.testing.assert_series_equal(hpat_func(A, B), test_impl(A, B), check_names=False) @unittest.skipIf(platform.system() == 'Windows', "Attribute dtype are different: int64, int32") def test_series_op8_integer_scalar(self): comparison_methods = ('lt', 'gt', 'le', 'ge', 'eq', 'ne') for method in comparison_methods: test_impl = _make_func_use_method_arg1(method) hpat_func = hpat.jit(test_impl) n = 11 operand_series = pd.Series(np.arange(1, n)) operand_scalar = 10 pd.testing.assert_series_equal( hpat_func(operand_series, operand_scalar), test_impl(operand_series, operand_scalar), check_names=False) def test_series_op8_float_scalar(self): comparison_methods = ('lt', 'gt', 'le', 'ge', 'eq', 'ne') for method in comparison_methods: test_impl = _make_func_use_method_arg1(method) hpat_func = hpat.jit(test_impl) n = 11 operand_series = pd.Series(np.arange(1, n)) operand_scalar = .5 pd.testing.assert_series_equal( hpat_func(operand_series, operand_scalar), test_impl(operand_series, operand_scalar), check_names=False) def test_series_inplace_binop_array(self): def test_impl(A, B): A += B return A hpat_func = hpat.jit(test_impl) n = 11 A = np.arange(n)**2.0 # TODO: use 2 for test int casting B = pd.Series(np.ones(n)) np.testing.assert_array_equal(hpat_func(A.copy(), B), test_impl(A, B)) def test_series_fusion1(self): def test_impl(A, B): return A + B + 1 hpat_func = hpat.jit(test_impl) n = 11 if platform.system() == 'Windows' and not IS_32BITS: A = pd.Series(np.arange(n), dtype=np.int64) B = pd.Series(np.arange(n)**2, dtype=np.int64) else: A = pd.Series(np.arange(n)) B = pd.Series(np.arange(n)**2) pd.testing.assert_series_equal(hpat_func(A, B), test_impl(A, B)) self.assertEqual(count_parfor_REPs(), 1) def test_series_fusion2(self): # make sure getting data var avoids incorrect single def assumption def test_impl(A, B): S = B + 2 if A[0] == 0: S = A + 1 return S + B hpat_func = hpat.jit(test_impl) n = 11 if platform.system() == 'Windows' and not IS_32BITS: A = pd.Series(np.arange(n), dtype=np.int64) B = pd.Series(np.arange(n)**2, dtype=np.int64) else: A = pd.Series(np.arange(n)) B = pd.Series(np.arange(n)**2) pd.testing.assert_series_equal(hpat_func(A, B), test_impl(A, B)) self.assertEqual(count_parfor_REPs(), 3) def test_series_len(self): def test_impl(A, i): return len(A) hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) self.assertEqual(hpat_func(df.A, 0), test_impl(df.A, 0)) def test_series_box(self): def test_impl(): A = pd.Series([1, 2, 3]) return A hpat_func = hpat.jit(test_impl) pd.testing.assert_series_equal(hpat_func(), test_impl()) def test_series_box2(self): def test_impl(): A = pd.Series(['1', '2', '3']) return A hpat_func = hpat.jit(test_impl) pd.testing.assert_series_equal(hpat_func(), test_impl()) def test_series_list_str_unbox1(self): def test_impl(A): return A.iloc[0] hpat_func = hpat.jit(test_impl) S = pd.Series([['aa', 'b'], ['ccc'], []]) np.testing.assert_array_equal(hpat_func(S), test_impl(S)) # call twice to test potential refcount errors np.testing.assert_array_equal(hpat_func(S), test_impl(S)) def test_np_typ_call_replace(self): # calltype replacement is tricky for np.typ() calls since variable # type can't provide calltype def test_impl(i): return np.int32(i) hpat_func = hpat.jit(test_impl) self.assertEqual(hpat_func(1), test_impl(1)) def test_series_ufunc1(self): def test_impl(A, i): return np.isinf(A).values hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) np.testing.assert_array_equal(hpat_func(df.A, 1), test_impl(df.A, 1)) def test_list_convert(self): def test_impl(): df = pd.DataFrame({'one': np.array([-1, np.nan, 2.5]), 'two': ['foo', 'bar', 'baz'], 'three': [True, False, True]}) return df.one.values, df.two.values, df.three.values hpat_func = hpat.jit(test_impl) one, two, three = hpat_func() self.assertTrue(isinstance(one, np.ndarray)) self.assertTrue(isinstance(two, np.ndarray)) self.assertTrue(isinstance(three, np.ndarray)) @unittest.skip("needs empty_like typing fix in npydecl.py") def test_series_empty_like(self): def test_impl(A): return np.empty_like(A) hpat_func = hpat.jit(test_impl) n = 11 df = pd.DataFrame({'A': np.arange(n)}) self.assertTrue(isinstance(hpat_func(df.A), np.ndarray)) def test_series_fillna1(self): def test_impl(A): return A.fillna(5.0) hpat_func = hpat.jit(test_impl) df = pd.DataFrame({'A': [1.0, 2.0, np.nan, 1.0]}) pd.testing.assert_series_equal(hpat_func(df.A), test_impl(df.A), check_names=False) # test inplace fillna for named numeric series (obtained from DataFrame) def test_series_fillna_inplace1(self): def test_impl(A): A.fillna(5.0, inplace=True) return A hpat_func = hpat.jit(test_impl) df = pd.DataFrame({'A': [1.0, 2.0, np.nan, 1.0]}) pd.testing.assert_series_equal(hpat_func(df.A), test_impl(df.A), check_names=False) def test_series_fillna_str1(self): def test_impl(A): return A.fillna("dd") hpat_func = hpat.jit(test_impl) df = pd.DataFrame({'A': ['aa', 'b', None, 'ccc']}) pd.testing.assert_series_equal(hpat_func(df.A), test_impl(df.A), check_names=False) def test_series_fillna_str_inplace1(self): def test_impl(A): A.fillna("dd", inplace=True) return A hpat_func = hpat.jit(test_impl) S1 = pd.Series(['aa', 'b', None, 'ccc']) S2 = S1.copy() pd.testing.assert_series_equal(hpat_func(S1), test_impl(S2)) # TODO: handle string array reflection # hpat_func(S1) # test_impl(S2) # np.testing.assert_array_equal(S1, S2) def test_series_fillna_str_inplace_empty1(self): def test_impl(A): A.fillna("", inplace=True) return A hpat_func = hpat.jit(test_impl) S1 = pd.Series(['aa', 'b', None, 'ccc']) S2 = S1.copy() pd.testing.assert_series_equal(hpat_func(S1), test_impl(S2)) @unittest.skip('Unsupported functionality: failed to handle index') def test_series_fillna_index_str(self): def test_impl(S): return S.fillna(5.0) hpat_func = hpat.jit(test_impl) S = pd.Series([1.0, 2.0, np.nan, 1.0], index=['a', 'b', 'c', 'd']) pd.testing.assert_series_equal(hpat_func(S), test_impl(S), check_names=False) @unittest.skip('Unsupported functionality: failed to handle index') def test_series_fillna_index_int(self): def test_impl(S): return S.fillna(5.0) hpat_func = hpat.jit(test_impl) S = pd.Series([1.0, 2.0, np.nan, 1.0], index=[2, 3, 4, 5]) pd.testing.assert_series_equal(hpat_func(S), test_impl(S), check_names=False) @unittest.skipIf(hpat.config.config_pipeline_hpat_default, 'No support of axis argument in old-style Series.dropna() impl') def test_series_dropna_axis1(self): '''Verifies Series.dropna() implementation handles 'index' as axis argument''' def test_impl(S): return S.dropna(axis='index') hpat_func = hpat.jit(test_impl) S1 = pd.Series([1.0, 2.0, np.nan, 1.0, np.inf]) S2 = S1.copy() pd.testing.assert_series_equal(hpat_func(S1), test_impl(S2)) @unittest.skipIf(hpat.config.config_pipeline_hpat_default, 'No support of axis argument in old-style Series.dropna() impl') def test_series_dropna_axis2(self): '''Verifies Series.dropna() implementation handles 0 as axis argument''' def test_impl(S): return S.dropna(axis=0) hpat_func = hpat.jit(test_impl) S1 = pd.Series([1.0, 2.0, np.nan, 1.0, np.inf]) S2 = S1.copy() pd.testing.assert_series_equal(hpat_func(S1), test_impl(S2)) @unittest.skipIf(hpat.config.config_pipeline_hpat_default, 'No support of axis argument in old-style Series.dropna() impl') def test_series_dropna_axis3(self): '''Verifies Series.dropna() implementation handles correct non-literal axis argument''' def test_impl(S, axis): return S.dropna(axis=axis) hpat_func = hpat.jit(test_impl) S1 = pd.Series([1.0, 2.0, np.nan, 1.0, np.inf]) S2 = S1.copy() axis_values = [0, 'index'] for value in axis_values: pd.testing.assert_series_equal(hpat_func(S1, value), test_impl(S2, value)) @unittest.skipIf(hpat.config.config_pipeline_hpat_default, 'BUG: old-style dropna impl returns series without index') def test_series_dropna_float_index1(self): '''Verifies Series.dropna() implementation for float series with default index''' def test_impl(S): return S.dropna() hpat_func = hpat.jit(test_impl) for data in test_global_input_data_float64: S1 = pd.Series(data) S2 = S1.copy() pd.testing.assert_series_equal(hpat_func(S1), test_impl(S2)) @unittest.skipIf(hpat.config.config_pipeline_hpat_default, 'BUG: old-style dropna impl returns series without index') def test_series_dropna_float_index2(self): '''Verifies Series.dropna() implementation for float series with string index''' def test_impl(S): return S.dropna() hpat_func = hpat.jit(test_impl) S1 = pd.Series([1.0, 2.0, np.nan, 1.0, np.inf], ['a', 'b', 'c', 'd', 'e']) S2 = S1.copy() pd.testing.assert_series_equal(hpat_func(S1), test_impl(S2)) @unittest.skipIf(hpat.config.config_pipeline_hpat_default, 'BUG: old-style dropna impl returns series without index') def test_series_dropna_str_index1(self): '''Verifies Series.dropna() implementation for series of strings with default index''' def test_impl(S): return S.dropna() hpat_func = hpat.jit(test_impl) S1 = pd.Series(['aa', 'b', None, 'cccd', '']) S2 = S1.copy() pd.testing.assert_series_equal(hpat_func(S1), test_impl(S2)) @unittest.skipIf(hpat.config.config_pipeline_hpat_default, 'BUG: old-style dropna impl returns series without index') def test_series_dropna_str_index2(self): '''Verifies Series.dropna() implementation for series of strings with string index''' def test_impl(S): return S.dropna() hpat_func = hpat.jit(test_impl) S1 = pd.Series(['aa', 'b', None, 'cccd', ''], ['a', 'b', 'c', 'd', 'e']) S2 = S1.copy() pd.testing.assert_series_equal(hpat_func(S1), test_impl(S2)) @unittest.skipIf(hpat.config.config_pipeline_hpat_default, 'BUG: old-style dropna impl returns series without index') def test_series_dropna_str_index3(self): def test_impl(S): return S.dropna() hpat_func = hpat.jit(test_impl) S1 = pd.Series(['aa', 'b', None, 'cccd', ''], index=[1, 2, 5, 7, 10]) S2 = S1.copy() pd.testing.assert_series_equal(hpat_func(S1), test_impl(S2)) @unittest.skip('BUG: old-style dropna impl returns series without index, in new-style inplace is unsupported') def test_series_dropna_float_inplace_no_index1(self): '''Verifies Series.dropna() implementation for float series with default index and inplace argument True''' def test_impl(S): S.dropna(inplace=True) return S hpat_func = hpat.jit(test_impl) S1 = pd.Series([1.0, 2.0, np.nan, 1.0, np.inf]) S2 = S1.copy() pd.testing.assert_series_equal(hpat_func(S1), test_impl(S2)) @unittest.skip('TODO: add reflection support and check method return value') def test_series_dropna_float_inplace_no_index2(self): '''Verifies Series.dropna(inplace=True) results are reflected back in the original float series''' def test_impl(S): return S.dropna(inplace=True) hpat_func = hpat.jit(test_impl) S1 = pd.Series([1.0, 2.0, np.nan, 1.0, np.inf]) S2 = S1.copy() self.assertIsNone(hpat_func(S1)) self.assertIsNone(test_impl(S2)) pd.testing.assert_series_equal(S1, S2) @unittest.skip('BUG: old-style dropna impl returns series without index, in new-style inplace is unsupported') def test_series_dropna_str_inplace_no_index1(self): '''Verifies Series.dropna() implementation for series of strings with default index and inplace argument True ''' def test_impl(S): S.dropna(inplace=True) return S hpat_func = hpat.jit(test_impl) S1 = pd.Series(['aa', 'b', None, 'cccd', '']) S2 = S1.copy() pd.testing.assert_series_equal(hpat_func(S1), test_impl(S2)) @unittest.skip('TODO: add reflection support and check method return value') def test_series_dropna_str_inplace_no_index2(self): '''Verifies Series.dropna(inplace=True) results are reflected back in the original string series''' def test_impl(S): return S.dropna(inplace=True) hpat_func = hpat.jit(test_impl) S1 = pd.Series(['aa', 'b', None, 'cccd', '']) S2 = S1.copy() self.assertIsNone(hpat_func(S1)) self.assertIsNone(test_impl(S2)) pd.testing.assert_series_equal(S1, S2) def test_series_dropna_str_parallel1(self): '''Verifies Series.dropna() distributed work for series of strings with default index''' def test_impl(A): B = A.dropna() return (B == 'gg').sum() hpat_func = hpat.jit(distributed=['A'])(test_impl) S1 = pd.Series(['aa', 'b', None, 'ccc', 'dd', 'gg']) start, end = get_start_end(len(S1)) # TODO: gatherv self.assertEqual(hpat_func(S1[start:end]), test_impl(S1)) self.assertEqual(count_array_REPs(), 0) self.assertEqual(count_parfor_REPs(), 0) self.assertTrue(count_array_OneDs() > 0) @unittest.skip('AssertionError: Series are different\n' 'Series length are different\n' '[left]: 3, Int64Index([0, 1, 2], dtype=\'int64\')\n' '[right]: 2, Int64Index([1, 2], dtype=\'int64\')') def test_series_dropna_dt_no_index1(self): '''Verifies Series.dropna() implementation for datetime series with default index''' def test_impl(S): return S.dropna() hpat_func = hpat.jit(test_impl) S1 = pd.Series([pd.NaT, pd.Timestamp('1970-12-01'), pd.Timestamp('2012-07-25')]) S2 = S1.copy() pd.testing.assert_series_equal(hpat_func(S1), test_impl(S2)) def test_series_dropna_bool_no_index1(self): '''Verifies Series.dropna() implementation for bool series with default index''' def test_impl(S): return S.dropna() hpat_func = hpat.jit(test_impl) S1 = pd.Series([True, False, False, True]) S2 = S1.copy() pd.testing.assert_series_equal(hpat_func(S1), test_impl(S2)) @unittest.skipIf(hpat.config.config_pipeline_hpat_default, 'BUG: old-style dropna impl returns series without index') def test_series_dropna_int_no_index1(self): '''Verifies Series.dropna() implementation for integer series with default index''' def test_impl(S): return S.dropna() hpat_func = hpat.jit(test_impl) n = 11 S1 = pd.Series(np.arange(n, dtype=np.int64)) S2 = S1.copy() pd.testing.assert_series_equal(hpat_func(S1), test_impl(S2)) @unittest.skip('numba.errors.TypingError - fix needed\n' 'Failed in hpat mode pipeline' '(step: convert to distributed)\n' 'Invalid use of Function(<built-in function len>)' 'with argument(s) of type(s): (none)\n') def test_series_rename1(self): def test_impl(A): return A.rename('B') hpat_func = hpat.jit(test_impl) df = pd.DataFrame({'A': [1.0, 2.0, np.nan, 1.0]}) pd.testing.assert_series_equal(hpat_func(df.A), test_impl(df.A)) def test_series_sum_default(self): def test_impl(S): return S.sum() hpat_func = hpat.jit(test_impl) S = pd.Series([1., 2., 3.]) self.assertEqual(hpat_func(S), test_impl(S)) def test_series_sum_nan(self): def test_impl(S): return S.sum() hpat_func = hpat.jit(test_impl) # column with NA S = pd.Series([np.nan, 2., 3.]) self.assertEqual(hpat_func(S), test_impl(S)) # all NA case should produce 0 S = pd.Series([np.nan, np.nan]) self.assertEqual(hpat_func(S), test_impl(S)) @unittest.skipIf(hpat.config.config_pipeline_hpat_default, "Old style Series.sum() does not support parameters") def test_series_sum_skipna_false(self): def test_impl(S): return S.sum(skipna=False) hpat_func = hpat.jit(test_impl) S = pd.Series([np.nan, 2., 3.]) self.assertEqual(np.isnan(hpat_func(S)), np.isnan(test_impl(S))) @unittest.skipIf(not hpat.config.config_pipeline_hpat_default, "Series.sum() operator + is not implemented yet for Numba") def test_series_sum2(self): def test_impl(S): return (S + S).sum() hpat_func = hpat.jit(test_impl) S = pd.Series([np.nan, 2., 3.]) self.assertEqual(hpat_func(S), test_impl(S)) S = pd.Series([np.nan, np.nan]) self.assertEqual(hpat_func(S), test_impl(S)) def test_series_prod(self): def test_impl(S, skipna): return S.prod(skipna=skipna) hpat_func = hpat.jit(test_impl) data_samples = [ [6, 6, 2, 1, 3, 3, 2, 1, 2], [1.1, 0.3, 2.1, 1, 3, 0.3, 2.1, 1.1, 2.2], [6, 6.1, 2.2, 1, 3, 3, 2.2, 1, 2], [6, 6, np.nan, 2, np.nan, 1, 3, 3, np.inf, 2, 1, 2, np.inf], [1.1, 0.3, np.nan, 1.0, np.inf, 0.3, 2.1, np.nan, 2.2, np.inf], [1.1, 0.3, np.nan, 1, np.inf, 0, 1.1, np.nan, 2.2, np.inf, 2, 2], [np.nan, np.nan, np.nan], [np.nan, np.nan, np.inf], ] for data in data_samples: S = pd.Series(data) for skipna_var in [True, False]: actual = hpat_func(S, skipna=skipna_var) expected = test_impl(S, skipna=skipna_var) if np.isnan(actual) or np.isnan(expected): # con not compare Nan != Nan directly self.assertEqual(np.isnan(actual), np.isnan(expected)) else: self.assertEqual(actual, expected) def test_series_prod_skipna_default(self): def test_impl(S): return S.prod() hpat_func = hpat.jit(test_impl) S = pd.Series([np.nan, 2, 3.]) self.assertEqual(hpat_func(S), test_impl(S)) def test_series_count1(self): def test_impl(S): return S.count() hpat_func = hpat.jit(test_impl) S = pd.Series([np.nan, 2., 3.]) self.assertEqual(hpat_func(S), test_impl(S)) S = pd.Series([np.nan, np.nan]) self.assertEqual(hpat_func(S), test_impl(S)) S = pd.Series(['aa', 'bb', np.nan]) self.assertEqual(hpat_func(S), test_impl(S)) def test_series_mean(self): def test_impl(S): return S.mean() hpat_func = hpat.jit(test_impl) data_samples = [ [6, 6, 2, 1, 3, 3, 2, 1, 2], [1.1, 0.3, 2.1, 1, 3, 0.3, 2.1, 1.1, 2.2], [6, 6.1, 2.2, 1, 3, 3, 2.2, 1, 2], [6, 6, np.nan, 2, np.nan, 1, 3, 3, np.inf, 2, 1, 2, np.inf], [1.1, 0.3, np.nan, 1.0, np.inf, 0.3, 2.1, np.nan, 2.2, np.inf], [1.1, 0.3, np.nan, 1, np.inf, 0, 1.1, np.nan, 2.2, np.inf, 2, 2], [np.nan, np.nan, np.nan], [np.nan, np.nan, np.inf], ] for data in data_samples: with self.subTest(data=data): S = pd.Series(data) actual = hpat_func(S) expected = test_impl(S) if np.isnan(actual) or np.isnan(expected): self.assertEqual(np.isnan(actual), np.isnan(expected)) else: self.assertEqual(actual, expected) @unittest.skipIf(hpat.config.config_pipeline_hpat_default, "Series.mean() any parameters unsupported") def test_series_mean_skipna(self): def test_impl(S, skipna): return S.mean(skipna=skipna) hpat_func = hpat.jit(test_impl) data_samples = [ [6, 6, 2, 1, 3, 3, 2, 1, 2], [1.1, 0.3, 2.1, 1, 3, 0.3, 2.1, 1.1, 2.2], [6, 6.1, 2.2, 1, 3, 3, 2.2, 1, 2], [6, 6, np.nan, 2, np.nan, 1, 3, 3, np.inf, 2, 1, 2, np.inf], [1.1, 0.3, np.nan, 1.0, np.inf, 0.3, 2.1, np.nan, 2.2, np.inf], [1.1, 0.3, np.nan, 1, np.inf, 0, 1.1, np.nan, 2.2, np.inf, 2, 2], [np.nan, np.nan, np.nan], [np.nan, np.nan, np.inf], ] for skipna in [True, False]: for data in data_samples: S = pd.Series(data) actual = hpat_func(S, skipna) expected = test_impl(S, skipna) if np.isnan(actual) or np.isnan(expected): self.assertEqual(np.isnan(actual), np.isnan(expected)) else: self.assertEqual(actual, expected) def test_series_var1(self): def test_impl(S): return S.var() hpat_func = hpat.jit(test_impl) S = pd.Series([np.nan, 2., 3.]) self.assertEqual(hpat_func(S), test_impl(S)) def test_series_min(self): def test_impl(S): return S.min() hpat_func = hpat.jit(test_impl) # TODO type_min/type_max for input_data in [[np.nan, 2., np.nan, 3., np.inf, 1, -1000], [8, 31, 1123, -1024], [2., 3., 1, -1000, np.inf]]: S = pd.Series(input_data) result_ref = test_impl(S) result = hpat_func(S) self.assertEqual(result, result_ref) @unittest.skipIf(hpat.config.config_pipeline_hpat_default, "Series.min() any parameters unsupported") def test_series_min_param(self): def test_impl(S, param_skipna): return S.min(skipna=param_skipna) hpat_func = hpat.jit(test_impl) for input_data, param_skipna in [([np.nan, 2., np.nan, 3., 1, -1000, np.inf], True), ([2., 3., 1, np.inf, -1000], False)]: S = pd.Series(input_data) result_ref = test_impl(S, param_skipna) result = hpat_func(S, param_skipna) self.assertEqual(result, result_ref) def test_series_max(self): def test_impl(S): return S.max() hpat_func = hpat.jit(test_impl) # TODO type_min/type_max for input_data in [[np.nan, 2., np.nan, 3., np.inf, 1, -1000], [8, 31, 1123, -1024], [2., 3., 1, -1000, np.inf]]: S = pd.Series(input_data) result_ref = test_impl(S) result = hpat_func(S) self.assertEqual(result, result_ref) @unittest.skipIf(hpat.config.config_pipeline_hpat_default, "Series.max() any parameters unsupported") def test_series_max_param(self): def test_impl(S, param_skipna): return S.max(skipna=param_skipna) hpat_func = hpat.jit(test_impl) for input_data, param_skipna in [([np.nan, 2., np.nan, 3., 1, -1000, np.inf], True), ([2., 3., 1, np.inf, -1000], False)]: S = pd.Series(input_data) result_ref = test_impl(S, param_skipna) result = hpat_func(S, param_skipna) self.assertEqual(result, result_ref) def test_series_value_counts(self): def test_impl(S): return S.value_counts() hpat_func = hpat.jit(test_impl) S = pd.Series(['AA', 'BB', 'C', 'AA', 'C', 'AA']) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_dist_input1(self): '''Verify distribution of a Series without index''' def test_impl(S): return S.max() hpat_func = hpat.jit(distributed={'S'})(test_impl) n = 111 S = pd.Series(np.arange(n)) start, end = get_start_end(n) self.assertEqual(hpat_func(S[start:end]), test_impl(S)) self.assertEqual(count_array_REPs(), 0) self.assertEqual(count_parfor_REPs(), 0) def test_series_dist_input2(self): '''Verify distribution of a Series with integer index''' def test_impl(S): return S.max() hpat_func = hpat.jit(distributed={'S'})(test_impl) n = 111 S = pd.Series(np.arange(n), 1 + np.arange(n)) start, end = get_start_end(n) self.assertEqual(hpat_func(S[start:end]), test_impl(S)) self.assertEqual(count_array_REPs(), 0) self.assertEqual(count_parfor_REPs(), 0) @unittest.skip("Passed if run single") def test_series_dist_input3(self): '''Verify distribution of a Series with string index''' def test_impl(S): return S.max() hpat_func = hpat.jit(distributed={'S'})(test_impl) n = 111 S = pd.Series(np.arange(n), ['abc{}'.format(id) for id in range(n)]) start, end = get_start_end(n) self.assertEqual(hpat_func(S[start:end]), test_impl(S)) self.assertEqual(count_array_REPs(), 0) self.assertEqual(count_parfor_REPs(), 0) def test_series_tuple_input1(self): def test_impl(s_tup): return s_tup[0].max() hpat_func = hpat.jit(test_impl) n = 111 S = pd.Series(np.arange(n)) S2 = pd.Series(np.arange(n) + 1.0) s_tup = (S, 1, S2) self.assertEqual(hpat_func(s_tup), test_impl(s_tup)) @unittest.skip("pending handling of build_tuple in dist pass") def test_series_tuple_input_dist1(self): def test_impl(s_tup): return s_tup[0].max() hpat_func = hpat.jit(locals={'s_tup:input': 'distributed'})(test_impl) n = 111 S = pd.Series(np.arange(n)) S2 = pd.Series(np.arange(n) + 1.0) start, end = get_start_end(n) s_tup = (S, 1, S2) h_s_tup = (S[start:end], 1, S2[start:end]) self.assertEqual(hpat_func(h_s_tup), test_impl(s_tup)) def test_series_rolling1(self): def test_impl(S): return S.rolling(3).sum() hpat_func = hpat.jit(test_impl) S = pd.Series([1.0, 2., 3., 4., 5.]) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_concat1(self): def test_impl(S1, S2): return pd.concat([S1, S2]).values hpat_func = hpat.jit(test_impl) S1 = pd.Series([1.0, 2., 3., 4., 5.]) S2 = pd.Series([6., 7.]) np.testing.assert_array_equal(hpat_func(S1, S2), test_impl(S1, S2)) def test_series_map1(self): def test_impl(S): return S.map(lambda a: 2 * a) hpat_func = hpat.jit(test_impl) S = pd.Series([1.0, 2., 3., 4., 5.]) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_map_global1(self): def test_impl(S): return S.map(lambda a: a + GLOBAL_VAL) hpat_func = hpat.jit(test_impl) S = pd.Series([1.0, 2., 3., 4., 5.]) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_map_tup1(self): def test_impl(S): return S.map(lambda a: (a, 2 * a)) hpat_func = hpat.jit(test_impl) S = pd.Series([1.0, 2., 3., 4., 5.]) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_map_tup_map1(self): def test_impl(S): A = S.map(lambda a: (a, 2 * a)) return A.map(lambda a: a[1]) hpat_func = hpat.jit(test_impl) S = pd.Series([1.0, 2., 3., 4., 5.]) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_combine(self): def test_impl(S1, S2): return S1.combine(S2, lambda a, b: 2 * a + b) hpat_func = hpat.jit(test_impl) S1 = pd.Series([1.0, 2., 3., 4., 5.]) S2 = pd.Series([6.0, 21., 3.6, 5.]) pd.testing.assert_series_equal(hpat_func(S1, S2), test_impl(S1, S2)) def test_series_combine_float3264(self): def test_impl(S1, S2): return S1.combine(S2, lambda a, b: 2 * a + b) hpat_func = hpat.jit(test_impl) S1 = pd.Series([np.float64(1), np.float64(2), np.float64(3), np.float64(4), np.float64(5)]) S2 = pd.Series([np.float32(1), np.float32(2), np.float32(3), np.float32(4), np.float32(5)]) pd.testing.assert_series_equal(hpat_func(S1, S2), test_impl(S1, S2)) def test_series_combine_assert1(self): def test_impl(S1, S2): return S1.combine(S2, lambda a, b: 2 * a + b) hpat_func = hpat.jit(test_impl) S1 = pd.Series([1, 2, 3]) S2 = pd.Series([6., 21., 3., 5.]) with self.assertRaises(AssertionError): hpat_func(S1, S2) def test_series_combine_assert2(self): def test_impl(S1, S2): return S1.combine(S2, lambda a, b: 2 * a + b) hpat_func = hpat.jit(test_impl) S1 = pd.Series([6., 21., 3., 5.]) S2 = pd.Series([1, 2, 3]) with self.assertRaises(AssertionError): hpat_func(S1, S2) def test_series_combine_integer(self): def test_impl(S1, S2): return S1.combine(S2, lambda a, b: 2 * a + b, 16) hpat_func = hpat.jit(test_impl) S1 = pd.Series([1, 2, 3, 4, 5]) S2 = pd.Series([6, 21, 3, 5]) pd.testing.assert_series_equal(hpat_func(S1, S2), test_impl(S1, S2)) def test_series_combine_different_types(self): def test_impl(S1, S2): return S1.combine(S2, lambda a, b: 2 * a + b) hpat_func = hpat.jit(test_impl) S1 = pd.Series([6.1, 21.2, 3.3, 5.4, 6.7]) S2 = pd.Series([1, 2, 3, 4, 5]) pd.testing.assert_series_equal(hpat_func(S1, S2), test_impl(S1, S2)) def test_series_combine_integer_samelen(self): def test_impl(S1, S2): return S1.combine(S2, lambda a, b: 2 * a + b) hpat_func = hpat.jit(test_impl) S1 = pd.Series([1, 2, 3, 4, 5]) S2 = pd.Series([6, 21, 17, -5, 4]) pd.testing.assert_series_equal(hpat_func(S1, S2), test_impl(S1, S2)) def test_series_combine_samelen(self): def test_impl(S1, S2): return S1.combine(S2, lambda a, b: 2 * a + b) hpat_func = hpat.jit(test_impl) S1 = pd.Series([1.0, 2., 3., 4., 5.]) S2 = pd.Series([6.0, 21., 3.6, 5., 0.0]) pd.testing.assert_series_equal(hpat_func(S1, S2), test_impl(S1, S2)) def test_series_combine_value(self): def test_impl(S1, S2): return S1.combine(S2, lambda a, b: 2 * a + b, 1237.56) hpat_func = hpat.jit(test_impl) S1 = pd.Series([1.0, 2., 3., 4., 5.]) S2 = pd.Series([6.0, 21., 3.6, 5.]) pd.testing.assert_series_equal(hpat_func(S1, S2), test_impl(S1, S2)) def test_series_combine_value_samelen(self): def test_impl(S1, S2): return S1.combine(S2, lambda a, b: 2 * a + b, 1237.56) hpat_func = hpat.jit(test_impl) S1 = pd.Series([1.0, 2., 3., 4., 5.]) S2 = pd.Series([6.0, 21., 3.6, 5., 0.0]) pd.testing.assert_series_equal(hpat_func(S1, S2), test_impl(S1, S2)) def test_series_apply1(self): def test_impl(S): return S.apply(lambda a: 2 * a) hpat_func = hpat.jit(test_impl) S = pd.Series([1.0, 2., 3., 4., 5.]) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_abs1(self): def test_impl(S): return S.abs() hpat_func = hpat.jit(test_impl) S = pd.Series([np.nan, -2., 3., 0.5E-01, 0xFF, 0o7, 0b101]) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_cov1(self): def test_impl(S1, S2): return S1.cov(S2) hpat_func = hpat.jit(test_impl) for pair in _cov_corr_series: S1, S2 = pair np.testing.assert_almost_equal( hpat_func(S1, S2), test_impl(S1, S2), err_msg='S1={}\nS2={}'.format(S1, S2)) def test_series_corr1(self): def test_impl(S1, S2): return S1.corr(S2) hpat_func = hpat.jit(test_impl) for pair in _cov_corr_series: S1, S2 = pair np.testing.assert_almost_equal( hpat_func(S1, S2), test_impl(S1, S2), err_msg='S1={}\nS2={}'.format(S1, S2)) def test_series_str_len1(self): def test_impl(S): return S.str.len() hpat_func = hpat.jit(test_impl) S = pd.Series(['aa', 'abc', 'c', 'cccd']) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_str2str(self): str2str_methods = ('capitalize', 'lower', 'lstrip', 'rstrip', 'strip', 'swapcase', 'title', 'upper') for method in str2str_methods: func_text = "def test_impl(S):\n" func_text += " return S.str.{}()\n".format(method) test_impl = _make_func_from_text(func_text) hpat_func = hpat.jit(test_impl) S = pd.Series([' \tbbCD\t ', 'ABC', ' mCDm\t', 'abc']) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_append1(self): def test_impl(S, other): return S.append(other).values hpat_func = hpat.jit(test_impl) S1 = pd.Series([-2., 3., 9.1]) S2 = pd.Series([-2., 5.0]) # Test single series np.testing.assert_array_equal(hpat_func(S1, S2), test_impl(S1, S2)) def test_series_append2(self): def test_impl(S1, S2, S3): return S1.append([S2, S3]).values hpat_func = hpat.jit(test_impl) S1 = pd.Series([-2., 3., 9.1]) S2 = pd.Series([-2., 5.0]) S3 = pd.Series([1.0]) # Test series tuple np.testing.assert_array_equal(hpat_func(S1, S2, S3), test_impl(S1, S2, S3)) def test_series_isin_list1(self): def test_impl(S, values): return S.isin(values) hpat_func = hpat.jit(test_impl) n = 11 S = pd.Series(np.arange(n)) values = [1, 2, 5, 7, 8] pd.testing.assert_series_equal(hpat_func(S, values), test_impl(S, values)) def test_series_isin_list2(self): def test_impl(S, values): return S.isin(values) hpat_func = hpat.jit(test_impl) n = 11.0 S = pd.Series(np.arange(n)) values = [1., 2., 5., 7., 8.] pd.testing.assert_series_equal(hpat_func(S, values), test_impl(S, values)) def test_series_isin_list3(self): def test_impl(S, values): return S.isin(values) hpat_func = hpat.jit(test_impl) S = pd.Series(['a', 'b', 'q', 'w', 'c', 'd', 'e', 'r']) values = ['a', 'q', 'c', 'd', 'e'] pd.testing.assert_series_equal(hpat_func(S, values), test_impl(S, values)) def test_series_isin_set1(self): def test_impl(S, values): return S.isin(values) hpat_func = hpat.jit(test_impl) n = 11 S = pd.Series(np.arange(n)) values = {1, 2, 5, 7, 8} pd.testing.assert_series_equal(hpat_func(S, values), test_impl(S, values)) def test_series_isin_set2(self): def test_impl(S, values): return S.isin(values) hpat_func = hpat.jit(test_impl) n = 11.0 S = pd.Series(np.arange(n)) values = {1., 2., 5., 7., 8.} pd.testing.assert_series_equal(hpat_func(S, values), test_impl(S, values)) @unittest.skip('TODO: requires hashable unicode strings in Numba') def test_series_isin_set3(self): def test_impl(S, values): return S.isin(values) hpat_func = hpat.jit(test_impl) S = pd.Series(['a', 'b', 'c', 'd', 'e'] * 2) values = {'b', 'c', 'e'} pd.testing.assert_series_equal(hpat_func(S, values), test_impl(S, values)) def test_series_isna1(self): def test_impl(S): return S.isna() hpat_func = hpat.jit(test_impl) # column with NA S = pd.Series([np.nan, 2., 3., np.inf]) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_isnull1(self): def test_impl(S): return S.isnull() hpat_func = hpat.jit(test_impl) # column with NA S = pd.Series([np.nan, 2., 3.]) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_isnull_full(self): def test_impl(series): return series.isnull() hpat_func = hpat.jit(test_impl) for data in test_global_input_data_numeric + [test_global_input_data_unicode_kind4]: series = pd.Series(data * 3) ref_result = test_impl(series) jit_result = hpat_func(series) pd.testing.assert_series_equal(ref_result, jit_result) def test_series_notna1(self): def test_impl(S): return S.notna() hpat_func = hpat.jit(test_impl) # column with NA S = pd.Series([np.nan, 2., 3.]) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_notna_noidx_float(self): def test_impl(S): return S.notna() hpat_func = hpat.jit(test_impl) for input_data in test_global_input_data_float64: S = pd.Series(input_data) result_ref = test_impl(S) result_jit = hpat_func(S) pd.testing.assert_series_equal(result_jit, result_ref) @unittest.skip("Need fix test_global_input_data_integer64") def test_series_notna_noidx_int(self): def test_impl(S): return S.notna() hpat_func = hpat.jit(test_impl) for input_data in test_global_input_data_integer64: S = pd.Series(input_data) result_ref = test_impl(S) result_jit = hpat_func(S) pd.testing.assert_series_equal(result_jit, result_ref) @unittest.skip("Need fix test_global_input_data_integer64") def test_series_notna_noidx_num(self): def test_impl(S): return S.notna() hpat_func = hpat.jit(test_impl) for input_data in test_global_input_data_numeric: S = pd.Series(input_data) result_ref = test_impl(S) result_jit = hpat_func(S) pd.testing.assert_series_equal(result_jit, result_ref) def test_series_notna_noidx_str(self): def test_impl(S): return S.notna() hpat_func = hpat.jit(test_impl) input_data = test_global_input_data_unicode_kind4 S = pd.Series(input_data) result_ref = test_impl(S) result_jit = hpat_func(S) pd.testing.assert_series_equal(result_jit, result_ref) def test_series_str_notna(self): def test_impl(S): return S.notna() hpat_func = hpat.jit(test_impl) S = pd.Series(['aa', None, 'c', 'cccd']) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_str_isna1(self): def test_impl(S): return S.isna() hpat_func = hpat.jit(test_impl) S = pd.Series(['aa', None, 'c', 'cccd']) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) @unittest.skip('AssertionError: Series are different') def test_series_dt_isna1(self): def test_impl(S): return S.isna() hpat_func = hpat.jit(test_impl) S = pd.Series([pd.NaT, pd.Timestamp('1970-12-01'), pd.Timestamp('2012-07-25')]) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_nlargest1(self): def test_impl(S): return S.nlargest(4) hpat_func = hpat.jit(test_impl) m = 100 np.random.seed(0) S = pd.Series(np.random.randint(-30, 30, m)) np.testing.assert_array_equal(hpat_func(S).values, test_impl(S).values) def test_series_nlargest_default1(self): def test_impl(S): return S.nlargest() hpat_func = hpat.jit(test_impl) m = 100 np.random.seed(0) S = pd.Series(np.random.randint(-30, 30, m)) np.testing.assert_array_equal(hpat_func(S).values, test_impl(S).values) def test_series_nlargest_nan1(self): def test_impl(S): return S.nlargest(4) hpat_func = hpat.jit(test_impl) S = pd.Series([1.0, np.nan, 3.0, 2.0, np.nan, 4.0]) np.testing.assert_array_equal(hpat_func(S).values, test_impl(S).values) def test_series_nlargest_parallel1(self): # create `kde.parquet` file ParquetGenerator.gen_kde_pq() def test_impl(): df = pq.read_table('kde.parquet').to_pandas() S = df.points return S.nlargest(4) hpat_func = hpat.jit(test_impl) np.testing.assert_array_equal(hpat_func().values, test_impl().values) @unittest.skip('Unsupported functionality: failed to handle index') def test_series_nlargest_index_str(self): def test_impl(S): return S.nlargest(4) hpat_func = hpat.jit(test_impl) S = pd.Series([73, 21, 10005, 5, 1], index=['a', 'b', 'c', 'd', 'e']) np.testing.assert_array_equal(hpat_func(S).values, test_impl(S).values) @unittest.skip('Unsupported functionality: failed to handle index') def test_series_nlargest_index_int(self): def test_impl(S): return S.nlargest(4) hpat_func = hpat.jit(test_impl) S = pd.Series([73, 21, 10005, 5, 1], index=[2, 3, 4, 5, 6]) np.testing.assert_array_equal(hpat_func(S).values, test_impl(S).values) def test_series_nsmallest1(self): def test_impl(S): return S.nsmallest(4) hpat_func = hpat.jit(test_impl) m = 100 np.random.seed(0) S = pd.Series(np.random.randint(-30, 30, m)) np.testing.assert_array_equal(hpat_func(S).values, test_impl(S).values) def test_series_nsmallest_default1(self): def test_impl(S): return S.nsmallest() hpat_func = hpat.jit(test_impl) m = 100 np.random.seed(0) S = pd.Series(np.random.randint(-30, 30, m)) np.testing.assert_array_equal(hpat_func(S).values, test_impl(S).values) def test_series_nsmallest_nan1(self): def test_impl(S): return S.nsmallest(4) hpat_func = hpat.jit(test_impl) S = pd.Series([1.0, np.nan, 3.0, 2.0, np.nan, 4.0]) np.testing.assert_array_equal(hpat_func(S).values, test_impl(S).values) def test_series_nsmallest_parallel1(self): # create `kde.parquet` file ParquetGenerator.gen_kde_pq() def test_impl(): df = pq.read_table('kde.parquet').to_pandas() S = df.points return S.nsmallest(4) hpat_func = hpat.jit(test_impl) np.testing.assert_array_equal(hpat_func().values, test_impl().values) @unittest.skip('Unsupported functionality: failed to handle index') def test_series_nsmallest_index_str(self): def test_impl(S): return S.nsmallest(3) hpat_func = hpat.jit(test_impl) S = pd.Series([41, 32, 33, 4, 5], index=['a', 'b', 'c', 'd', 'e']) np.testing.assert_array_equal(hpat_func(S).values, test_impl(S).values) @unittest.skip('Unsupported functionality: failed to handle index') def test_series_nsmallest_index_int(self): def test_impl(S): return S.nsmallest(3) hpat_func = hpat.jit(test_impl) S = pd.Series([41, 32, 33, 4, 5], index=[1, 2, 3, 4, 5]) np.testing.assert_array_equal(hpat_func(S).values, test_impl(S).values) def test_series_head1(self): def test_impl(S): return S.head(4) hpat_func = hpat.jit(test_impl) m = 100 np.random.seed(0) S = pd.Series(np.random.randint(-30, 30, m)) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_head_default1(self): '''Verifies default head method for non-distributed pass of Series with no index''' def test_impl(S): return S.head() hpat_func = hpat.jit(test_impl) m = 100 np.random.seed(0) S = pd.Series(np.random.randint(-30, 30, m)) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_head_index1(self): '''Verifies head method for Series with integer index created inside jitted function''' def test_impl(): S = pd.Series([6, 9, 2, 3, 6, 4, 5], [8, 1, 6, 0, 9, 1, 3]) return S.head(3) hpat_func = hpat.jit(test_impl) pd.testing.assert_series_equal(hpat_func(), test_impl()) def test_series_head_index2(self): '''Verifies head method for Series with string index created inside jitted function''' def test_impl(): S = pd.Series([6, 9, 2, 3, 6, 4, 5], ['a', 'ab', 'abc', 'c', 'f', 'hh', '']) return S.head(3) hpat_func = hpat.jit(test_impl) pd.testing.assert_series_equal(hpat_func(), test_impl()) def test_series_head_index3(self): '''Verifies head method for non-distributed pass of Series with integer index''' def test_impl(S): return S.head(3) hpat_func = hpat.jit(test_impl) S = pd.Series([6, 9, 2, 3, 6, 4, 5], [8, 1, 6, 0, 9, 1, 3]) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) @unittest.skip("Passed if run single") def test_series_head_index4(self): '''Verifies head method for non-distributed pass of Series with string index''' def test_impl(S): return S.head(3) hpat_func = hpat.jit(test_impl) S = pd.Series([6, 9, 2, 4, 6, 4, 5], ['a', 'ab', 'abc', 'c', 'f', 'hh', '']) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_head_parallel1(self): '''Verifies head method for distributed Series with string data and no index''' def test_impl(S): return S.head(7) hpat_func = hpat.jit(distributed={'S'})(test_impl) # need to test different lenghts, as head's size is fixed and implementation # depends on relation of size of the data per processor to output data size for n in range(1, 5): S = pd.Series(['a', 'ab', 'abc', 'c', 'f', 'hh', ''] * n) start, end = get_start_end(len(S)) pd.testing.assert_series_equal(hpat_func(S[start:end]), test_impl(S)) self.assertTrue(count_array_OneDs() > 0) def test_series_head_index_parallel1(self): '''Verifies head method for distributed Series with integer index''' def test_impl(S): return S.head(3) hpat_func = hpat.jit(distributed={'S'})(test_impl) S = pd.Series([6, 9, 2, 3, 6, 4, 5], [8, 1, 6, 0, 9, 1, 3]) start, end = get_start_end(len(S)) pd.testing.assert_series_equal(hpat_func(S[start:end]), test_impl(S)) self.assertTrue(count_array_OneDs() > 0) @unittest.skip("Passed if run single") def test_series_head_index_parallel2(self): '''Verifies head method for distributed Series with string index''' def test_impl(S): return S.head(3) hpat_func = hpat.jit(distributed={'S'})(test_impl) S = pd.Series([6, 9, 2, 3, 6, 4, 5], ['a', 'ab', 'abc', 'c', 'f', 'hh', '']) start, end = get_start_end(len(S)) pd.testing.assert_series_equal(hpat_func(S[start:end]), test_impl(S)) self.assertTrue(count_array_OneDs() > 0) def test_series_head_noidx_float(self): def test_impl(S, n): return S.head(n) hpat_func = hpat.jit(test_impl) for input_data in test_global_input_data_float64: S = pd.Series(input_data) for n in [-1, 0, 2, 3]: result_ref = test_impl(S, n) result_jit = hpat_func(S, n) pd.testing.assert_series_equal(result_jit, result_ref) @unittest.skip("Need fix test_global_input_data_integer64") def test_series_head_noidx_int(self): def test_impl(S, n): return S.head(n) hpat_func = hpat.jit(test_impl) for input_data in test_global_input_data_integer64: S = pd.Series(input_data) for n in [-1, 0, 2, 3]: result_ref = test_impl(S, n) result_jit = hpat_func(S, n) pd.testing.assert_series_equal(result_jit, result_ref) @unittest.skip("Need fix test_global_input_data_integer64") def test_series_head_noidx_num(self): def test_impl(S, n): return S.head(n) hpat_func = hpat.jit(test_impl) for input_data in test_global_input_data_numeric: S = pd.Series(input_data) for n in [-1, 0, 2, 3]: result_ref = test_impl(S, n) result_jit = hpat_func(S, n) pd.testing.assert_series_equal(result_jit, result_ref) @unittest.skip("Old implementation not work with n negative and data str") def test_series_head_noidx_str(self): def test_impl(S, n): return S.head(n) hpat_func = hpat.jit(test_impl) input_data = test_global_input_data_unicode_kind4 S = pd.Series(input_data) for n in [-1, 0, 2, 3]: result_ref = test_impl(S, n) result_jit = hpat_func(S, n) pd.testing.assert_series_equal(result_jit, result_ref) @unittest.skip("Broke another three tests") def test_series_head_idx(self): def test_impl(S): return S.head() def test_impl_param(S, n): return S.head(n) hpat_func = hpat.jit(test_impl) data_test = [[6, 6, 2, 1, 3, 3, 2, 1, 2], [1.1, 0.3, 2.1, 1, 3, 0.3, 2.1, 1.1, 2.2], [6, 6.1, 2.2, 1, 3, 0, 2.2, 1, 2], ['as', 'b', 'abb', 'sss', 'ytr65', '', 'qw', 'a', 'b'], [6, 6, 2, 1, 3, np.inf, np.nan, np.nan, np.nan], [3., 5.3, np.nan, np.nan, np.inf, np.inf, 4.4, 3.7, 8.9] ] for input_data in data_test: for index_data in data_test: S = pd.Series(input_data, index_data) result_ref = test_impl(S) result = hpat_func(S) pd.testing.assert_series_equal(result, result_ref) hpat_func_param1 = hpat.jit(test_impl_param) for param1 in [1, 3, 7]: result_param1_ref = test_impl_param(S, param1) result_param1 = hpat_func_param1(S, param1) pd.testing.assert_series_equal(result_param1, result_param1_ref) def test_series_median1(self): '''Verifies median implementation for float and integer series of random data''' def test_impl(S): return S.median() hpat_func = hpat.jit(test_impl) m = 100 np.random.seed(0) S = pd.Series(np.random.randint(-30, 30, m)) self.assertEqual(hpat_func(S), test_impl(S)) S = pd.Series(np.random.ranf(m)) self.assertEqual(hpat_func(S), test_impl(S)) # odd size m = 101 S = pd.Series(np.random.randint(-30, 30, m)) self.assertEqual(hpat_func(S), test_impl(S)) S = pd.Series(np.random.ranf(m)) self.assertEqual(hpat_func(S), test_impl(S)) @unittest.skipIf(hpat.config.config_pipeline_hpat_default, "BUG: old-style median implementation doesn't filter NaNs") def test_series_median_skipna_default1(self): '''Verifies median implementation with default skipna=True argument on a series with NA values''' def test_impl(S): return S.median() hpat_func = hpat.jit(test_impl) S = pd.Series([2., 3., 5., np.nan, 5., 6., 7.]) self.assertEqual(hpat_func(S), test_impl(S)) @unittest.skipIf(hpat.config.config_pipeline_hpat_default, "Skipna argument is not supported in old-style") def test_series_median_skipna_false1(self): '''Verifies median implementation with skipna=False on a series with NA values''' def test_impl(S): return S.median(skipna=False) hpat_func = hpat.jit(test_impl) # np.inf is not NaN, so verify that a correct number is returned S1 = pd.Series([2., 3., 5., np.inf, 5., 6., 7.]) self.assertEqual(hpat_func(S1), test_impl(S1)) # TODO: both return values are 'nan', but HPAT's is not np.nan, hence checking with # assertIs() doesn't work - check if it's Numba relatated S2 = pd.Series([2., 3., 5., np.nan, 5., 6., 7.]) self.assertEqual(np.isnan(hpat_func(S2)), np.isnan(test_impl(S2))) def test_series_median_parallel1(self): # create `kde.parquet` file ParquetGenerator.gen_kde_pq() def test_impl(): df = pq.read_table('kde.parquet').to_pandas() S = df.points return S.median() hpat_func = hpat.jit(test_impl) self.assertEqual(hpat_func(), test_impl()) self.assertEqual(count_array_REPs(), 0) self.assertEqual(count_parfor_REPs(), 0) self.assertTrue(count_array_OneDs() > 0) def test_series_argsort_parallel(self): # create `kde.parquet` file ParquetGenerator.gen_kde_pq() def test_impl(): df = pq.read_table('kde.parquet').to_pandas() S = df.points return S.argsort().values hpat_func = hpat.jit(test_impl) np.testing.assert_array_equal(hpat_func(), test_impl()) def test_series_idxmin1(self): def test_impl(A): return A.idxmin() hpat_func = hpat.jit(test_impl) n = 11 np.random.seed(0) S = pd.Series(np.random.ranf(n)) np.testing.assert_array_equal(hpat_func(S), test_impl(S)) def test_series_idxmin_str(self): def test_impl(S): return S.idxmin() hpat_func = hpat.jit(test_impl) S = pd.Series([8, 6, 34, np.nan], ['a', 'ab', 'abc', 'c']) self.assertEqual(hpat_func(S), test_impl(S)) @unittest.skip("Skipna is not implemented") def test_series_idxmin_str_idx(self): def test_impl(S): return S.idxmin(skipna=False) hpat_func = hpat.jit(test_impl) S = pd.Series([8, 6, 34, np.nan], ['a', 'ab', 'abc', 'c']) self.assertEqual(hpat_func(S), test_impl(S)) def test_series_idxmin_no(self): def test_impl(S): return S.idxmin() hpat_func = hpat.jit(test_impl) S = pd.Series([8, 6, 34, np.nan]) self.assertEqual(hpat_func(S), test_impl(S)) def test_series_idxmin_int(self): def test_impl(S): return S.idxmin() hpat_func = hpat.jit(test_impl) S = pd.Series([1, 2, 3], [4, 45, 14]) self.assertEqual(hpat_func(S), test_impl(S)) def test_series_idxmin_noidx(self): def test_impl(S): return S.idxmin() hpat_func = hpat.jit(test_impl) data_test = [[6, 6, 2, 1, 3, 3, 2, 1, 2], [1.1, 0.3, 2.1, 1, 3, 0.3, 2.1, 1.1, 2.2], [6, 6.1, 2.2, 1, 3, 0, 2.2, 1, 2], [6, 6, 2, 1, 3, np.inf, np.nan, np.nan, np.nan], [3., 5.3, np.nan, np.nan, np.inf, np.inf, 4.4, 3.7, 8.9] ] for input_data in data_test: S = pd.Series(input_data) result_ref = test_impl(S) result = hpat_func(S) self.assertEqual(result, result_ref) def test_series_idxmin_idx(self): def test_impl(S): return S.idxmin() hpat_func = hpat.jit(test_impl) data_test = [[6, 6, 2, 1, 3, 3, 2, 1, 2], [1.1, 0.3, 2.1, 1, 3, 0.3, 2.1, 1.1, 2.2], [6, 6.1, 2.2, 1, 3, 0, 2.2, 1, 2], [6, 6, 2, 1, 3, -np.inf, np.nan, np.inf, np.nan], [3., 5.3, np.nan, np.nan, np.inf, np.inf, 4.4, 3.7, 8.9] ] for input_data in data_test: for index_data in data_test: S = pd.Series(input_data, index_data) result_ref = test_impl(S) result = hpat_func(S) if np.isnan(result) or np.isnan(result_ref): self.assertEqual(np.isnan(result), np.isnan(result_ref)) else: self.assertEqual(result, result_ref) def test_series_idxmax1(self): def test_impl(A): return A.idxmax() hpat_func = hpat.jit(test_impl) n = 11 np.random.seed(0) S = pd.Series(np.random.ranf(n)) np.testing.assert_array_equal(hpat_func(S), test_impl(S)) @unittest.skip("Skipna is not implemented") def test_series_idxmax_str_idx(self): def test_impl(S): return S.idxmax(skipna=False) hpat_func = hpat.jit(test_impl) S = pd.Series([8, 6, 34, np.nan], ['a', 'ab', 'abc', 'c']) self.assertEqual(hpat_func(S), test_impl(S)) def test_series_idxmax_noidx(self): def test_impl(S): return S.idxmax() hpat_func = hpat.jit(test_impl) data_test = [[6, 6, 2, 1, 3, 3, 2, 1, 2], [1.1, 0.3, 2.1, 1, 3, 0.3, 2.1, 1.1, 2.2], [6, 6.1, 2.2, 1, 3, 0, 2.2, 1, 2], [6, 6, 2, 1, 3, np.inf, np.nan, np.inf, np.nan], [3., 5.3, np.nan, np.nan, np.inf, np.inf, 4.4, 3.7, 8.9] ] for input_data in data_test: S = pd.Series(input_data) result_ref = test_impl(S) result = hpat_func(S) self.assertEqual(result, result_ref) def test_series_idxmax_idx(self): def test_impl(S): return S.idxmax() hpat_func = hpat.jit(test_impl) data_test = [[6, 6, 2, 1, 3, 3, 2, 1, 2], [1.1, 0.3, 2.1, 1, 3, 0.3, 2.1, 1.1, 2.2], [6, 6.1, 2.2, 1, 3, 0, 2.2, 1, 2], [6, 6, 2, 1, 3, np.nan, np.nan, np.nan, np.nan], [3., 5.3, np.nan, np.nan, np.inf, np.inf, 4.4, 3.7, 8.9] ] for input_data in data_test: for index_data in data_test: S = pd.Series(input_data, index_data) result_ref = test_impl(S) result = hpat_func(S) if np.isnan(result) or np.isnan(result_ref): self.assertEqual(np.isnan(result), np.isnan(result_ref)) else: self.assertEqual(result, result_ref) def test_series_sort_values1(self): def test_impl(A): return A.sort_values() hpat_func = hpat.jit(test_impl) n = 11 np.random.seed(0) S = pd.Series(np.random.ranf(n)) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_sort_values_index1(self): def test_impl(A, B): S = pd.Series(A, B) return S.sort_values() hpat_func = hpat.jit(test_impl) n = 11 np.random.seed(0) # TODO: support passing Series with Index # S = pd.Series(np.random.ranf(n), np.random.randint(0, 100, n)) A = np.random.ranf(n) B = np.random.ranf(n) pd.testing.assert_series_equal(hpat_func(A, B), test_impl(A, B)) def test_series_sort_values_parallel1(self): # create `kde.parquet` file ParquetGenerator.gen_kde_pq() def test_impl(): df = pq.read_table('kde.parquet').to_pandas() S = df.points return S.sort_values() hpat_func = hpat.jit(test_impl) np.testing.assert_array_equal(hpat_func(), test_impl()) def test_series_shift(self): def pyfunc(): series = pd.Series([1.0, np.nan, -1.0, 0.0, 5e-324]) return series.shift() cfunc = hpat.jit(pyfunc) pd.testing.assert_series_equal(cfunc(), pyfunc()) def test_series_shift_unboxing(self): def pyfunc(series): return series.shift() cfunc = hpat.jit(pyfunc) for data in test_global_input_data_float64: series = pd.Series(data) pd.testing.assert_series_equal(cfunc(series), pyfunc(series)) def test_series_shift_full(self): def pyfunc(series, periods, freq, axis, fill_value): return series.shift(periods=periods, freq=freq, axis=axis, fill_value=fill_value) cfunc = hpat.jit(pyfunc) freq = None axis = 0 for data in test_global_input_data_float64: series = pd.Series(data) for periods in [-2, 0, 3]: for fill_value in [9.1, np.nan, -3.3, None]: jit_result = cfunc(series, periods, freq, axis, fill_value) ref_result = pyfunc(series, periods, freq, axis, fill_value) pd.testing.assert_series_equal(jit_result, ref_result) def test_series_shift_str(self): def pyfunc(series): return series.shift() cfunc = hpat.jit(pyfunc) series = pd.Series(test_global_input_data_unicode_kind4) with self.assertRaises(TypingError) as raises: cfunc(series) msg = 'Method shift(). The object must be a number. Given self.data.dtype: {}' self.assertIn(msg.format(types.unicode_type), str(raises.exception)) def test_series_shift_fill_str(self): def pyfunc(series, fill_value): return series.shift(fill_value=fill_value) cfunc = hpat.jit(pyfunc) series = pd.Series(test_global_input_data_float64[0]) with self.assertRaises(TypingError) as raises: cfunc(series, fill_value='unicode') msg = 'Method shift(). The object must be a number. Given fill_value: {}' self.assertIn(msg.format(types.unicode_type), str(raises.exception)) def test_series_shift_unsupported_params(self): def pyfunc(series, freq, axis): return series.shift(freq=freq, axis=axis) cfunc = hpat.jit(pyfunc) series = pd.Series(test_global_input_data_float64[0]) with self.assertRaises(TypingError) as raises: cfunc(series, freq='12H', axis=0) msg = 'Method shift(). Unsupported parameters. Given freq: {}' self.assertIn(msg.format(types.unicode_type), str(raises.exception)) with self.assertRaises(TypingError) as raises: cfunc(series, freq=None, axis=1) msg = 'Method shift(). Unsupported parameters. Given axis != 0' self.assertIn(msg, str(raises.exception)) @unittest.skip('Unsupported functionality: failed to handle index') def test_series_shift_index_str(self): def test_impl(S): return S.shift() hpat_func = hpat.jit(test_impl) S = pd.Series([np.nan, 2., 3., 5., np.nan, 6., 7.], index=['a', 'b', 'c', 'd', 'e', 'f', 'g']) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) @unittest.skip('Unsupported functionality: failed to handle index') def test_series_shift_index_int(self): def test_impl(S): return S.shift() hpat_func = hpat.jit(test_impl) S = pd.Series([np.nan, 2., 3., 5., np.nan, 6., 7.], index=[1, 2, 3, 4, 5, 6, 7]) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_series_index1(self): def test_impl(): A = pd.Series([1, 2, 3], index=['A', 'C', 'B']) return A.index hpat_func = hpat.jit(test_impl) np.testing.assert_array_equal(hpat_func(), test_impl()) def test_series_index2(self): def test_impl(): A = pd.Series([1, 2, 3], index=[0, 1, 2]) return A.index hpat_func = hpat.jit(test_impl) np.testing.assert_array_equal(hpat_func(), test_impl()) def test_series_index3(self): def test_impl(): A = pd.Series([1, 2, 3]) return A.index hpat_func = hpat.jit(test_impl) np.testing.assert_array_equal(hpat_func(), test_impl()) def test_series_take_index_default(self): def pyfunc(): series = pd.Series([1.0, 13.0, 9.0, -1.0, 7.0]) indices = [1, 3] return series.take(indices) cfunc = hpat.jit(pyfunc) ref_result = pyfunc() result = cfunc() pd.testing.assert_series_equal(ref_result, result) def test_series_take_index_default_unboxing(self): def pyfunc(series, indices): return series.take(indices) cfunc = hpat.jit(pyfunc) series = pd.Series([1.0, 13.0, 9.0, -1.0, 7.0]) indices = [1, 3] ref_result = pyfunc(series, indices) result = cfunc(series, indices) pd.testing.assert_series_equal(ref_result, result) def test_series_take_index_int(self): def pyfunc(): series = pd.Series([1.0, 13.0, 9.0, -1.0, 7.0], index=[3, 0, 4, 2, 1]) indices = [1, 3] return series.take(indices) cfunc = hpat.jit(pyfunc) ref_result = pyfunc() result = cfunc() pd.testing.assert_series_equal(ref_result, result) def test_series_take_index_int_unboxing(self): def pyfunc(series, indices): return series.take(indices) cfunc = hpat.jit(pyfunc) series = pd.Series([1.0, 13.0, 9.0, -1.0, 7.0], index=[3, 0, 4, 2, 1]) indices = [1, 3] ref_result = pyfunc(series, indices) result = cfunc(series, indices) pd.testing.assert_series_equal(ref_result, result) def test_series_take_index_str(self): def pyfunc(): series = pd.Series([1.0, 13.0, 9.0, -1.0, 7.0], index=['test', 'series', 'take', 'str', 'index']) indices = [1, 3] return series.take(indices) cfunc = hpat.jit(pyfunc) ref_result = pyfunc() result = cfunc() pd.testing.assert_series_equal(ref_result, result) def test_series_take_index_str_unboxing(self): def pyfunc(series, indices): return series.take(indices) cfunc = hpat.jit(pyfunc) series = pd.Series([1.0, 13.0, 9.0, -1.0, 7.0], index=['test', 'series', 'take', 'str', 'index']) indices = [1, 3] ref_result = pyfunc(series, indices) result = cfunc(series, indices) pd.testing.assert_series_equal(ref_result, result) def test_series_iterator_int(self): def test_impl(A): return [i for i in A] A = pd.Series([3, 2, 1, 5, 4]) hpat_func = hpat.jit(test_impl) np.testing.assert_array_equal(hpat_func(A), test_impl(A)) def test_series_iterator_float(self): def test_impl(A): return [i for i in A] A = pd.Series([0.3, 0.2222, 0.1756, 0.005, 0.4]) hpat_func = hpat.jit(test_impl) np.testing.assert_array_equal(hpat_func(A), test_impl(A)) def test_series_iterator_boolean(self): def test_impl(A): return [i for i in A] A = pd.Series([True, False]) hpat_func = hpat.jit(test_impl) np.testing.assert_array_equal(hpat_func(A), test_impl(A)) def test_series_iterator_string(self): def test_impl(A): return [i for i in A] A = pd.Series(['a', 'ab', 'abc', '', 'dddd']) hpat_func = hpat.jit(test_impl) np.testing.assert_array_equal(hpat_func(A), test_impl(A)) def test_series_iterator_one_value(self): def test_impl(A): return [i for i in A] A = pd.Series([5]) hpat_func = hpat.jit(test_impl) np.testing.assert_array_equal(hpat_func(A), test_impl(A)) @unittest.skip("Fails when NUMA_PES>=2 due to unimplemented sync of such construction after distribution") def test_series_iterator_no_param(self): def test_impl(): A = pd.Series([3, 2, 1, 5, 4]) return [i for i in A] hpat_func = hpat.jit(test_impl) np.testing.assert_array_equal(hpat_func(), test_impl()) def test_series_iterator_empty(self): def test_impl(A): return [i for i in A] A = pd.Series([np.int64(x) for x in range(0)]) hpat_func = hpat.jit(test_impl) np.testing.assert_array_equal(hpat_func(A), test_impl(A)) def test_series_default_index(self): def test_impl(): A = pd.Series([3, 2, 1, 5, 4]) return A.index hpat_func = hpat.jit(test_impl) np.testing.assert_array_equal(hpat_func(), test_impl()) @unittest.skip("Implement drop_duplicates for Series") def test_series_drop_duplicates(self): def test_impl(): A = pd.Series(['lama', 'cow', 'lama', 'beetle', 'lama', 'hippo']) return A.drop_duplicates() hpat_func = hpat.jit(test_impl) pd.testing.assert_series_equal(hpat_func(), test_impl()) def test_series_quantile(self): def test_impl(): A = pd.Series([1, 2.5, .5, 3, 5]) return A.quantile() hpat_func = hpat.jit(test_impl) np.testing.assert_equal(hpat_func(), test_impl()) @unittest.skipIf(hpat.config.config_pipeline_hpat_default, "Series.quantile() parameter as a list unsupported") def test_series_quantile_q_vector(self): def test_series_quantile_q_vector_impl(S, param1): return S.quantile(param1) S = pd.Series(np.random.ranf(100)) hpat_func = hpat.jit(test_series_quantile_q_vector_impl) param1 = [0.0, 0.25, 0.5, 0.75, 1.0] result_ref = test_series_quantile_q_vector_impl(S, param1) result = hpat_func(S, param1) np.testing.assert_equal(result, result_ref) @unittest.skip("Implement unique without sorting like in pandas") def test_unique(self): def test_impl(S): return S.unique() hpat_func = hpat.jit(test_impl) S = pd.Series([2, 1, 3, 3]) pd.testing.assert_series_equal(hpat_func(S), test_impl(S)) def test_unique_sorted(self): def test_impl(S): return S.unique() hpat_func = hpat.jit(test_impl) n = 11 S = pd.Series(np.arange(n)) S[2] = 0 np.testing.assert_array_equal(hpat_func(S), test_impl(S)) def test_unique_str(self): def test_impl(): data = pd.Series(['aa', 'aa', 'b', 'b', 'cccc', 'dd', 'ddd', 'dd']) return data.unique() hpat_func = hpat.jit(test_impl) # since the orider of the elements are diffrent - check count of elements only ref_result = test_impl().size result = hpat_func().size np.testing.assert_array_equal(ref_result, result) def test_series_groupby_count(self): def test_impl(): A = pd.Series([13, 11, 21, 13, 13, 51, 42, 21]) grouped = A.groupby(A, sort=False) return grouped.count() hpat_func = hpat.jit(test_impl) ref_result = test_impl() result = hpat_func()
pd.testing.assert_series_equal(result, ref_result)
pandas.testing.assert_series_equal
import matplotlib.pyplot as plt import mysql.connector import numpy as np import os import pandas as pd import seaborn as sns import warnings from statsmodels.stats.outliers_influence import variance_inflation_factor warnings.filterwarnings('ignore') ROOT_PATH = os.path.dirname(os.path.abspath(__file__)) class DataProcessor: def read_data_from_database(self, schema_path, loaded_path): mydb = mysql.connector.connect( host="localhost", user="root", password="<PASSWORD>", database="even_financial" ) my_cursor = mydb.cursor() my_cursor.execute('SELECT * FROM clicks') table_rows = my_cursor.fetchall() clicks_df = pd.DataFrame(table_rows) my_cursor.execute('SELECT * FROM leads') table_rows = my_cursor.fetchall() leads_df = pd.DataFrame(table_rows) my_cursor.execute('SELECT * FROM offers') table_rows = my_cursor.fetchall() offers_df = pd.DataFrame(table_rows) click_schema = pd.read_csv(schema_path + 'clicks_schema.csv', header=1) lead_schema = pd.read_csv(schema_path + 'leads_schema.csv', header=1) offer_schema = pd.read_csv(schema_path + 'offers_schema.csv', header=1) click_columns = click_schema.columns lead_columns = lead_schema.columns offer_columns = offer_schema.columns clicks_df.columns = click_columns leads_df.columns = lead_columns offers_df.columns = offer_columns clicks_df.to_csv(loaded_path + 'clicks.csv', index=False) leads_df.to_csv(loaded_path + 'leads.csv', index=False) offers_df.to_csv(loaded_path + 'offers.csv', index=False) def generate_data_frame(self, loaded_path): click_df = pd.read_csv(loaded_path + 'clicks.csv') lead_df =
pd.read_csv(loaded_path + 'leads.csv')
pandas.read_csv
import platform from dataclasses import dataclass, field import numpy as np import pandas as pd import rpy2.robjects as robjects from pandas.tseries import offsets from rpy2.robjects import numpy2ri, pandas2ri, r from rpy2.robjects.packages import importr from epysurv.metrics.outbreak_detection import ghozzi_score def silence_r_output(): """Silence output from R code. This is useful, because some algorithm otherwise print every time they are invoked. """ if platform.system() == "Linux": r.sink("/dev/null") elif platform.system() == "Windows": r.sink("NUL") silence_r_output() numpy2ri.activate() pandas2ri.activate() surveillance = importr("surveillance") @dataclass class TimepointSurveillanceAlgorithm: """Algorithms that predict outbreaks for every timepoint.""" _training_data: pd.DataFrame = field(init=False, repr=False) def fit(self, data: pd.DataFrame) -> "TimepointSurveillanceAlgorithm": """Expects data with time series index, case counts and outbreak labels.""" # Remove outbreaks cases from baseline. data = data.copy() data.n_cases -= data.n_outbreak_cases self._training_data = data return self def predict(self, data: pd.DataFrame): """Expects data with time series index and case counts.""" self._data_in_the_future(data) def score(self, data_with_labels: pd.DataFrame): prediction_result = self.predict(data_with_labels) return ghozzi_score(prediction_result) def _validate_data(self, data: pd.DataFrame): self._contains_dates(data) self._contains_counts(data) def _contains_dates(self, data: pd.DataFrame): has_dates = "ds" in data.columns or isinstance(data.index, pd.DatetimeIndex) if not has_dates: raise ValueError("No dates") def _contains_counts(self, data: pd.DataFrame): if not {"n_cases", "n_outbreak_cases"} < set(data.columns): raise ValueError('No column named "n_cases"') def _data_in_the_future(self, data: pd.DataFrame): if data.index.min() <= self._training_data.index.max(): raise ValueError("The prediction data overlaps with the training data.") offset_to_freq = { offsets.Day: 365, offsets.Week: 52, offsets.MonthBegin: 12, offsets.MonthEnd: 12, } offset_to_attr = { offsets.Day: "day", offsets.Week: "week", offsets.MonthBegin: "month", offsets.MonthEnd: "month", } def _get_freq(data) -> int: return offset_to_freq[type(data.index.freq)] def _get_start_epoch(data: pd.DataFrame) -> int: return getattr(data.index[0], offset_to_attr[type(data.index.freq)]) class SurveillanceRPackageAlgorithm(TimepointSurveillanceAlgorithm): """Base class for the algorithm from the R package surveillance.""" def predict(self, data: pd.DataFrame) -> pd.DataFrame: """ Predict outbreaks. Parameters ---------- data Dataframe with DateTimeIndex containing the columns "n_cases". Returns ------- Original dataframe with "alarm" column added. """ super().predict(data) # Concat training and prediction data. make index array for range param. full_data = (
pd.concat((self._training_data, data), keys=["train", "test"])
pandas.concat
# imports #region import os import pyreadstat import pandas as pd import numpy as np from statsmodels.stats.weightstats import DescrStatsW from sklearn.linear_model import LinearRegression import statsmodels.api as sm import statsmodels.formula.api as smf import seaborn as sns import matplotlib as mpl mpl.use('Agg') import matplotlib.pyplot as plt from libs.utils import * from libs.plots import * from libs.extensions import * plt.ioff() #endregion # load new EDGAR v5.0 data --- root = 'D:\\projects\\fakta-o-klimatu\\work\\111-emise-svet-srovnani\\data' edgar_files = ['CH4', 'CO2_excl_short-cycle_org_C', 'CO2_org_short-cycle_C', 'N2O'] ef = edgar_files[0] edgar_df = None for ef in edgar_files: logger(ef) ey = 2018 if ef == 'CO2_excl_short-cycle_org_C' else 2015 frame = pd.read_excel(f'{root}\\edgar_v5.0\\v50_{ef}_1970_{ey}.xls', sheet_name='TOTALS BY COUNTRY', header=9) frame = frame[['ISO_A3'] + list(range(1970, ey + 1))].rename(columns={'ISO_A3': 'code'}).set_index('code') frame.columns = frame.columns.rename('year') frame = frame.unstack().rename(f'edgar50_{ef}').reset_index() frame = frame[~frame['code'].isin(['SEA', 'AIR'])] if edgar_df is None: edgar_df = frame else: edgar_df = pd.merge(edgar_df, frame, how='outer') edgar_df.to_csv(root + '\\edgar_v5.0.csv', index=False) edgar_df.show() data = edgar_df.copy() # find sensible GDP vs population vs CO2eq (or CO2) data vs time ? root = 'D:\\projects\\fakta-o-klimatu\\work\\111-emise-svet-srovnani\\data' df = pd.read_csv(root + '\\data_all.csv') df.show_csv() df.query('code == "CZE"').show_csv() df =
pd.merge(df, edgar_df, how='left', on=['code', 'year'])
pandas.merge
#!/usr/bin/python3 # somewhere you have imported your data in forms of lists # in these examples the one called `tempo` contains the time, the other contains the values of the data and is called `flusso` # I am using italian words for time (tempo) and flux (flusso), for avoiding confusion with some keyword of the various call used # the objet that will be created is named `ts_flusso` # # the following examples provide the mimimum needed for working with these packages, obviously for having a more finer control # you need to read the appropriate documentation of each package #Pandas import pandas as pd ts_flusso=pd.Series(data=flusso,index=tempo) #stumpy import stumpy ts_flusso = pd.DataFrame(np.column_stack([tempo,flusso]),columns=['label_tempo','label_flusso']) #sunpy #the method for Pandas is the one that allow to build an object compatible with sunpy import pandas as pd import sunpy ts_flusso=
pd.Series(data=flusso,index=tempo)
pandas.Series
import pandas as pd import numpy as np from sklearn.cluster import KMeans import seaborn as sns from networkx import * import matplotlib.pyplot as plt sns.set() def distance(s_lat, s_lng, e_lat, e_lng): # approximate radius of earth in km r = 6373.0 s_lat = s_lat * np.pi / 180.0 s_lng = np.deg2rad(s_lng) e_lat = np.deg2rad(e_lat) e_lng = np.deg2rad(e_lng) d = np.sin((e_lat - s_lat) / 2) ** 2 + np.cos(s_lat) * np.cos(e_lat) * np.sin((e_lng - s_lng) / 2) ** 2 return 2 * r * np.arcsin(np.sqrt(d)) def create_graph(df, auth, auth_lat, auth_long): g = nx.Graph() df_copy = df[(df.Centername == auth)].copy().reset_index() source = df_copy['identity'].tolist() authlist = [auth, ] source.extend(authlist) g.add_nodes_from(source) for index, c in df_copy.iterrows(): g.add_edge(auth, c['identity'], weight=distance(auth_lat, auth_long, c['Lat'], c['Long'])) for cindex, c in df_copy.iterrows(): for cindex1, c1 in df_copy.iterrows(): if c['identity'] == c1['identity']: continue g.add_edge(c['identity'], c1['identity'], weight=distance(c['Lat'], c['Long'], c1['Lat'], c1['Long'])) nx.draw(g) plt.savefig("{}.png".format(auth)) return g def graph_list(centers, df_final): dict_of_graphs = {} for index, a in centers.iterrows(): g = create_graph(df_final, a['Centername'], a['Center Lat'], a['Center Long']) dict_of_graphs[a['Centername']] = g return dict_of_graphs def find_tsp(centers, df_tot, df_final): dict_g = graph_list(centers, df_final) df_path = pd.DataFrame(columns=['lat', 'long', 'auth_name']) for source, g in dict_g.items(): path = find_best_path(g) print(path) for index in range(len(path)): df = {'lat': df_tot[(df_tot.identity == path[index])].iloc[0].Lat, 'long': df_tot[(df_tot.identity == path[index])].iloc[0].Long, 'auth_name': source} temp_df = pd.DataFrame([df]) df_path = pd.concat([df_path, temp_df], ignore_index=True) return df_path def find_best_path(g): global smallestdis, best_tsp_path all_tsp_paths = {} for source in g.nodes: path_calc = list(g.nodes) path_calc.remove(source) path = [source, ] dis, path = find_path(g, source, source, path, path_calc) all_tsp_paths[dis] = path smallestdis = list(all_tsp_paths.keys())[0] best_tsp_path = all_tsp_paths[smallestdis] for dis in all_tsp_paths.keys(): if dis < smallestdis: best_tsp_path = all_tsp_paths[dis] return best_tsp_path def find_path(g, gsource, source, path, path_calc, totdis=0): if len(path_calc) == 1: path.append(path_calc[0]) path.append(gsource) totdis = totdis + nx.single_source_dijkstra(g, gsource, path_calc[0])[0] return totdis, path closest_node = path_calc[0] dis = nx.single_source_dijkstra(g, source, closest_node)[0] for node in path_calc: tempdis = nx.single_source_dijkstra(g, source, node)[0] if tempdis < dis: closest_node = node dis = tempdis path.append(closest_node) path_calc.remove(closest_node) totdis = totdis + dis totdis, path = find_path(g, gsource, closest_node, path, path_calc, totdis) return totdis, path def cluster_data(df_cit, df_auth): km = KMeans(n_clusters=count_auth, random_state=101) km.fit(X=df_cit[["Lat", "Long"]]) centers = pd.DataFrame(km.cluster_centers_, columns=["Center Lat", "Center Long"]) centers["Cluster"] = centers.index df_cit["Cluster"] = km.labels_ for index, c in centers.iterrows(): clong = c['Center Long'] clat = c['Center Lat'] # when you have space between the name ds = [] for ind, auth in df_auth.iterrows(): authlong = auth.Long authlat = auth.Lat distance_center = distance(clong, clat, authlong, authlat) ds.append(distance_center) idx = np.argmin(np.array(ds)) centers.at[index, "Center Lat"] = df_auth.at[idx, "Lat"] centers.at[index, "Center Long"] = df_auth.at[idx, "Long"] centers.at[index, "Centername"] = df_auth.at[idx, "identity"] df = pd.merge(df_cit, centers) return df, centers def get_dataframes(file_name): global count_auth df = pd.read_excel(file_name) for index, c in df.iterrows(): if 'citizen' in c['identity']: df.at[index, "level"] = '1' elif 'shop' in c['identity']: df.at[index, "level"] = '2' count_auth = count_auth + 1 df_return = df.copy()[['latitude', 'longitude', 'identity', 'level']] df_return = df_return.rename(columns={"longitude": "Long", 'latitude': "Lat", 'identity': "identity"}) return df_return file_name_cit = "D:\\Documents\\project\\citizen.xlsx" file_name_auth = "D:\\Documents\\project\\shop.xlsx" df_cit = get_dataframes(file_name_cit) count_auth = 0 df_auth = get_dataframes(file_name_auth) print(count_auth) df_tot =
pd.concat([df_cit, df_auth], ignore_index=True)
pandas.concat
import copy import logging import os import time from collections import defaultdict from typing import List, Union, Tuple import networkx as nx import numpy as np import pandas as pd import psutil from .utils import process_hyperparameters from ..augmentation.distill_utils import format_distillation_labels, augment_data from ..constants import AG_ARGS, BINARY, MULTICLASS, REGRESSION, REFIT_FULL_NAME, REFIT_FULL_SUFFIX from ..models import AbstractModel, BaggedEnsembleModel, StackerEnsembleModel, WeightedEnsembleModel, GreedyWeightedEnsembleModel, SimpleWeightedEnsembleModel from ..features.feature_metadata import FeatureMetadata from ..scheduler.scheduler_factory import scheduler_factory from ..utils import default_holdout_frac, get_pred_from_proba, generate_train_test_split, infer_eval_metric, compute_permutation_feature_importance, extract_column, compute_weighted_metric from ..utils.exceptions import TimeLimitExceeded, NotEnoughMemoryError, NoValidFeatures, NoGPUError from ..utils.loaders import load_pkl from ..utils.savers import save_json, save_pkl from ..utils.feature_selection import FeatureSelector logger = logging.getLogger(__name__) # FIXME: Below is major defect! # Weird interaction for metrics like AUC during bagging. # If kfold = 5, scores are 0.9, 0.85, 0.8, 0.75, and 0.7, the score is not 0.8! It is much lower because probs are combined together and AUC is recalculated # Do we want this to happen? Should we calculate score by 5 separate scores and then averaging instead? # TODO: Dynamic model loading for ensemble models during prediction, only load more models if prediction is uncertain. This dynamically reduces inference time. # TODO: Try midstack Semi-Supervised. Just take final models and re-train them, use bagged preds for SS rows. This would be very cheap and easy to try. # TODO: Move to autogluon.core class AbstractTrainer: trainer_file_name = 'trainer.pkl' trainer_info_name = 'info.pkl' trainer_info_json_name = 'info.json' distill_stackname = 'distill' # name of stack-level for distilled student models def __init__(self, path: str, problem_type: str, eval_metric=None, num_classes=None, quantile_levels=None, low_memory=False, feature_metadata=None, k_fold=0, n_repeats=1, sample_weight=None, weight_evaluation=False, save_data=False, random_state=0, verbosity=2): self.path = path self.problem_type = problem_type self.feature_metadata = feature_metadata self.save_data = save_data self.random_state = random_state # Integer value added to the stack level to get the random_state for kfold splits or the train/val split if bagging is disabled self.verbosity = verbosity self.sample_weight = sample_weight # TODO: consider redesign where Trainer doesnt need sample_weight column name and weights are separate from X self.weight_evaluation = weight_evaluation if eval_metric is not None: self.eval_metric = eval_metric else: self.eval_metric = infer_eval_metric(problem_type=self.problem_type) logger.log(25, f"AutoGluon will gauge predictive performance using evaluation metric: '{self.eval_metric.name}'") if not (self.eval_metric.needs_pred or self.eval_metric.needs_quantile): logger.log(25, "\tThis metric expects predicted probabilities rather than predicted class labels, so you'll need to use predict_proba() instead of predict()") logger.log(20, "\tTo change this, specify the eval_metric argument of fit()") self.num_classes = num_classes self.quantile_levels = quantile_levels self.feature_prune = False # will be set to True if feature-pruning is turned on. self.low_memory = low_memory self.bagged_mode = True if k_fold >= 2 else False if self.bagged_mode: self.k_fold = k_fold # int number of folds to do model bagging, < 2 means disabled self.n_repeats = n_repeats else: self.k_fold = 0 self.n_repeats = 1 self.model_best = None self.models = {} # Dict of model name -> model object. A key, value pair only exists if a model is persisted in memory. # TODO: v0.1 Rename and consider making private self.model_graph = nx.DiGraph() # Directed Acyclic Graph (DAG) of model interactions. Describes how certain models depend on the predictions of certain other models. Contains numerous metadata regarding each model. self.model_full_dict = {} # Dict of normal model -> FULL model. FULL models are produced by self.refit_single_full() and self.refit_ensemble_full(). self._model_full_dict_val_score = {} # Dict of FULL model -> normal model validation score in case the normal model had been deleted. self.reset_paths = False self._time_limit = None # Internal float of the total time limit allowed for a given fit call. Used in logging statements. self._time_train_start = None # Internal timestamp of the time training started for a given fit call. Used in logging statements. self._num_rows_train = None self._num_cols_train = None self.is_data_saved = False self._X_saved = False self._y_saved = False self._X_val_saved = False self._y_val_saved = False self._groups = None # custom split indices self._regress_preds_asprobas = False # whether to treat regression predictions as class-probabilities (during distillation) self._extra_banned_names = set() # Names which are banned but are not used by a trained model. # self._exceptions_list = [] # TODO: Keep exceptions list for debugging during benchmarking. # path_root is the directory containing learner.pkl @property def path_root(self) -> str: return self.path.rsplit(os.path.sep, maxsplit=2)[0] + os.path.sep @property def path_utils(self) -> str: return self.path_root + 'utils' + os.path.sep @property def path_data(self) -> str: return self.path_utils + 'data' + os.path.sep def load_X(self): if self._X_saved: path = self.path_data + 'X.pkl' return load_pkl.load(path=path) return None def load_X_val(self): if self._X_val_saved: path = self.path_data + 'X_val.pkl' return load_pkl.load(path=path) return None def load_y(self): if self._y_saved: path = self.path_data + 'y.pkl' return load_pkl.load(path=path) return None def load_y_val(self): if self._y_val_saved: path = self.path_data + 'y_val.pkl' return load_pkl.load(path=path) return None def load_data(self): X = self.load_X() y = self.load_y() X_val = self.load_X_val() y_val = self.load_y_val() return X, y, X_val, y_val def save_X(self, X, verbose=True): path = self.path_data + 'X.pkl' save_pkl.save(path=path, object=X, verbose=verbose) self._X_saved = True def save_X_val(self, X, verbose=True): path = self.path_data + 'X_val.pkl' save_pkl.save(path=path, object=X, verbose=verbose) self._X_val_saved = True def save_y(self, y, verbose=True): path = self.path_data + 'y.pkl' save_pkl.save(path=path, object=y, verbose=verbose) self._y_saved = True def save_y_val(self, y, verbose=True): path = self.path_data + 'y_val.pkl' save_pkl.save(path=path, object=y, verbose=verbose) self._y_val_saved = True def get_model_names(self, stack_name: Union[List[str], str] = None, level: Union[List[int], int] = None, can_infer: bool = None, models: List[str] = None) -> List[str]: if models is None: models = list(self.model_graph.nodes) if stack_name is not None: if not isinstance(stack_name, list): stack_name = [stack_name] node_attributes: dict = self.get_models_attribute_dict(attribute='stack_name') models = [model_name for model_name in models if node_attributes[model_name] in stack_name] if level is not None: if not isinstance(level, list): level = [level] node_attributes: dict = self.get_models_attribute_dict(attribute='level') models = [model_name for model_name in models if node_attributes[model_name] in level] # TODO: can_infer is technically more complicated, if an ancestor can't infer then the model can't infer. if can_infer is not None: node_attributes = self.get_models_attribute_dict(attribute='can_infer') models = [model for model in models if node_attributes[model] == can_infer] return models def get_max_level(self, stack_name: str = None, models: List[str] = None) -> int: models = self.get_model_names(stack_name=stack_name, models=models) models_attribute_dict = self.get_models_attribute_dict(attribute='level', models=models) if models_attribute_dict: return max(list(models_attribute_dict.values())) else: return -1 def construct_model_templates(self, hyperparameters: dict, **kwargs) -> Tuple[List[AbstractModel], dict]: """Constructs a list of unfit models based on the hyperparameters dict.""" raise NotImplementedError def construct_model_templates_distillation(self, hyperparameters: dict, **kwargs) -> Tuple[List[AbstractModel], dict]: """Constructs a list of unfit models based on the hyperparameters dict for softclass distillation.""" raise NotImplementedError def get_model_level(self, model_name: str) -> int: return self.get_model_attribute(model=model_name, attribute='level') def set_contexts(self, path_context): self.path, model_paths = self.create_contexts(path_context) for model, path in model_paths.items(): self.set_model_attribute(model=model, attribute='path', val=path) def create_contexts(self, path_context: str) -> (str, dict): path = path_context model_paths = self.get_models_attribute_dict(attribute='path') for model, prev_path in model_paths.items(): model_local_path = prev_path.split(self.path, 1)[1] new_path = path + model_local_path model_paths[model] = new_path return path, model_paths def fit(self, X, y, hyperparameters: dict, X_val=None, y_val=None, **kwargs): raise NotImplementedError # TODO: Enable easier re-mapping of trained models -> hyperparameters input (They don't share a key since name can change) def train_multi_levels(self, X, y, hyperparameters: dict, X_val=None, y_val=None, X_unlabeled=None, base_model_names: List[str] = None, core_kwargs: dict = None, aux_kwargs: dict = None, level_start=1, level_end=1, time_limit=None, name_suffix: str = None, relative_stack=True, level_time_modifier=0.333) -> List[str]: """ Trains a multi-layer stack ensemble using the input data on the hyperparameters dict input. hyperparameters is used to determine the models used in each stack layer. If continuing a stack ensemble with level_start>1, ensure that base_model_names is set to the appropriate base models that will be used by the level_start level models. Trains both core and aux models. core models are standard models which are fit on the data features. Core models will also use model predictions if base_model_names was specified or if level != 1. aux models are ensemble models which only use the predictions of core models as features. These models never use the original features. level_time_modifier : float, default 0.333 The amount of extra time given relatively to early stack levels compared to later stack levels. If 0, then all stack levels are given 100%/L of the time, where L is the number of stack levels. If 1, then all stack levels are given 100% of the time, meaning if the first level uses all of the time given to it, the other levels won't train. Time given to a level = remaining_time / remaining_levels * (1 + level_time_modifier), capped by total remaining time. Returns a list of the model names that were trained from this method call, in order of fit. """ self._time_limit = time_limit self._time_train_start = time.time() time_train_start = self._time_train_start hyperparameters = self._process_hyperparameters(hyperparameters=hyperparameters) if relative_stack: if level_start != 1: raise AssertionError(f'level_start must be 1 when `relative_stack=True`. (level_start = {level_start})') level_add = 0 if base_model_names: max_base_model_level = self.get_max_level(models=base_model_names) level_start = max_base_model_level + 1 level_add = level_start - 1 level_end += level_add if level_start != 1: hyperparameters_relative = {} for key in hyperparameters: if isinstance(key, int): hyperparameters_relative[key+level_add] = hyperparameters[key] else: hyperparameters_relative[key] = hyperparameters[key] hyperparameters = hyperparameters_relative core_kwargs = {} if core_kwargs is None else core_kwargs.copy() aux_kwargs = {} if aux_kwargs is None else aux_kwargs.copy() model_names_fit = [] if level_start != level_end: logger.log(20, f'AutoGluon will fit {level_end - level_start + 1} stack levels (L{level_start} to L{level_end}) ...') for level in range(level_start, level_end + 1): core_kwargs_level = core_kwargs.copy() aux_kwargs_level = aux_kwargs.copy() if time_limit is not None: time_train_level_start = time.time() levels_left = level_end - level + 1 time_left = time_limit - (time_train_level_start - time_train_start) time_limit_for_level = min(time_left / levels_left * (1 + level_time_modifier), time_left) time_limit_core = time_limit_for_level time_limit_aux = max(time_limit_for_level * 0.1, min(time_limit, 360)) # Allows aux to go over time_limit, but only by a small amount core_kwargs_level['time_limit'] = core_kwargs_level.get('time_limit', time_limit_core) aux_kwargs_level['time_limit'] = aux_kwargs_level.get('time_limit', time_limit_aux) base_model_names, aux_models = self.stack_new_level( X=X, y=y, X_val=X_val, y_val=y_val, X_unlabeled=X_unlabeled, models=hyperparameters, level=level, base_model_names=base_model_names, core_kwargs=core_kwargs_level, aux_kwargs=aux_kwargs_level, name_suffix=name_suffix, ) model_names_fit += base_model_names + aux_models self._time_limit = None self.save() return model_names_fit def stack_new_level(self, X, y, models: Union[List[AbstractModel], dict], X_val=None, y_val=None, X_unlabeled=None, level=1, base_model_names: List[str] = None, core_kwargs: dict = None, aux_kwargs: dict = None, name_suffix: str = None) -> (List[str], List[str]): """ Similar to calling self.stack_new_level_core, except auxiliary models will also be trained via a call to self.stack_new_level_aux, with the models trained from self.stack_new_level_core used as base models. """ if base_model_names is None: base_model_names = [] if level < 1: raise AssertionError(f'Stack level must be >= 1, but level={level}.') elif not base_model_names and level > 1: logger.log(30, f'Warning: Training models at stack level {level}, but no base models were specified.') elif base_model_names and level == 1: raise AssertionError(f'Stack level 1 models cannot have base models, but base_model_names={base_model_names}.') core_kwargs = {} if core_kwargs is None else core_kwargs.copy() aux_kwargs = {} if aux_kwargs is None else aux_kwargs.copy() if name_suffix: core_kwargs['name_suffix'] = core_kwargs.get('name_suffix', '') + name_suffix aux_kwargs['name_suffix'] = aux_kwargs.get('name_suffix', '') + name_suffix core_models = self.stack_new_level_core(X=X, y=y, X_val=X_val, y_val=y_val, X_unlabeled=X_unlabeled, models=models, level=level, base_model_names=base_model_names, **core_kwargs) if X_val is None: aux_models = self.stack_new_level_aux(X=X, y=y, base_model_names=core_models, level=level+1, **aux_kwargs) else: aux_models = self.stack_new_level_aux(X=X_val, y=y_val, fit=False, base_model_names=core_models, level=level+1, **aux_kwargs) return core_models, aux_models def stack_new_level_core(self, X, y, models: Union[List[AbstractModel], dict], X_val=None, y_val=None, X_unlabeled=None, level=1, base_model_names: List[str] = None, stack_name='core', ag_args=None, ag_args_fit=None, ag_args_ensemble=None, excluded_model_types=None, ensemble_type=StackerEnsembleModel, name_suffix: str = None, get_models_func=None, refit_full=False, **kwargs) -> List[str]: """ Trains all models using the data provided. If level > 1, then the models will use base model predictions as additional features. The base models used can be specified via base_model_names. If self.bagged_mode, then models will be trained as StackerEnsembleModels. The data provided in this method should not contain stack features, as they will be automatically generated if necessary. """ if get_models_func is None: get_models_func = self.construct_model_templates if base_model_names is None: base_model_names = [] if not self.bagged_mode and level != 1: raise ValueError('Stack Ensembling is not valid for non-bagged mode.') if isinstance(models, dict): get_models_kwargs = dict( level=level, name_suffix=name_suffix, ag_args=ag_args, ag_args_fit=ag_args_fit, excluded_model_types=excluded_model_types, ) if self.bagged_mode: if level == 1: (base_model_names, base_model_paths, base_model_types) = (None, None, None) elif level > 1: base_model_names, base_model_paths, base_model_types = self._get_models_load_info(model_names=base_model_names) if len(base_model_names) == 0: logger.log(20, 'No base models to train on, skipping stack level...') return [] else: raise AssertionError(f'Stack level cannot be less than 1! level = {level}') ensemble_kwargs = { 'base_model_names': base_model_names, 'base_model_paths_dict': base_model_paths, 'base_model_types_dict': base_model_types, 'random_state': level + self.random_state, } get_models_kwargs.update(dict( ag_args_ensemble=ag_args_ensemble, ensemble_type=ensemble_type, ensemble_kwargs=ensemble_kwargs, )) models, model_args_fit = get_models_func(hyperparameters=models, **get_models_kwargs) if model_args_fit: hyperparameter_tune_kwargs = { model_name: model_args_fit[model_name]['hyperparameter_tune_kwargs'] for model_name in model_args_fit if 'hyperparameter_tune_kwargs' in model_args_fit[model_name] } kwargs['hyperparameter_tune_kwargs'] = hyperparameter_tune_kwargs logger.log(20, f'Fitting {len(models)} L{level} models ...') X_init = self.get_inputs_to_stacker(X, base_models=base_model_names, fit=True) if X_val is not None: X_val = self.get_inputs_to_stacker(X_val, base_models=base_model_names, fit=False) if refit_full and X_val is not None: X_init = pd.concat([X_init, X_val]) y = pd.concat([y, y_val]) X_val = None y_val = None if X_unlabeled is not None: X_unlabeled = self.get_inputs_to_stacker(X_unlabeled, base_models=base_model_names, fit=False) fit_kwargs = dict(num_classes=self.num_classes) # FIXME: TODO: v0.1 X_unlabeled isn't cached so it won't be available during refit_full or fit_extra. return self._train_multi(X=X_init, y=y, X_val=X_val, y_val=y_val, X_unlabeled=X_unlabeled, models=models, level=level, stack_name=stack_name, fit_kwargs=fit_kwargs, **kwargs) # TODO: Consider making level be auto-determined based off of max(base_model_levels)+1 # TODO: Remove name_suffix, hacked in # TODO: X can be optional because it isn't needed if fit=True def stack_new_level_aux(self, X, y, base_model_names: List[str], level, fit=True, stack_name='aux1', time_limit=None, name_suffix: str = None, get_models_func=None, check_if_best=True) -> List[str]: """ Trains auxiliary models (currently a single weighted ensemble) using the provided base models. Level must be greater than the level of any of the base models. Auxiliary models never use the original features and only train with the predictions of other models as features. """ X_stack_preds = self.get_inputs_to_stacker(X, base_models=base_model_names, fit=fit, use_orig_features=False) if self.weight_evaluation: X, w = extract_column(X, self.sample_weight) # TODO: consider redesign with w as separate arg instead of bundled inside X if w is not None: X_stack_preds[self.sample_weight] = w.values/w.mean() return self.generate_weighted_ensemble(X=X_stack_preds, y=y, level=level, base_model_names=base_model_names, k_fold=1, n_repeats=1, stack_name=stack_name, time_limit=time_limit, name_suffix=name_suffix, get_models_func=get_models_func, check_if_best=check_if_best) def predict(self, X, model=None): if model is None: model = self._get_best() return self._predict_model(X, model) def predict_proba(self, X, model=None): if model is None: model = self._get_best() return self._predict_proba_model(X, model) def _get_best(self): if self.model_best is not None: return self.model_best else: return self.get_model_best() # Note: model_pred_proba_dict is mutated in this function to minimize memory usage def get_inputs_to_model(self, model, X, model_pred_proba_dict=None, fit=False, preprocess_nonadaptive=False): """ For output X: If preprocess_nonadaptive=False, call model.predict(X) If preprocess_nonadaptive=True, call model.predict(X, preprocess_nonadaptive=False) """ if isinstance(model, str): # TODO: Remove unnecessary load when no stacking model = self.load_model(model) model_level = self.get_model_level(model.name) if model_level > 1 and isinstance(model, StackerEnsembleModel): if fit: model_pred_proba_dict = None else: model_set = self.get_minimum_model_set(model) model_set = [m for m in model_set if m != model.name] # TODO: Can probably be faster, get this result from graph model_pred_proba_dict = self.get_model_pred_proba_dict(X=X, models=model_set, model_pred_proba_dict=model_pred_proba_dict, fit=fit) X = model.preprocess(X=X, preprocess_nonadaptive=preprocess_nonadaptive, fit=fit, model_pred_proba_dict=model_pred_proba_dict) elif preprocess_nonadaptive: X = model.preprocess(X=X, preprocess_stateful=False) return X def score(self, X, y, model=None, weights=None) -> float: if self.eval_metric.needs_pred or self.eval_metric.needs_quantile: y_pred = self.predict(X=X, model=model) else: y_pred = self.predict_proba(X=X, model=model) return compute_weighted_metric(y, y_pred, self.eval_metric, weights, weight_evaluation=self.weight_evaluation, quantile_levels=self.quantile_levels) def score_with_y_pred_proba(self, y, y_pred_proba, weights=None) -> float: if self.eval_metric.needs_pred or self.eval_metric.needs_quantile: y_pred = get_pred_from_proba(y_pred_proba=y_pred_proba, problem_type=self.problem_type) else: y_pred = y_pred_proba return compute_weighted_metric(y, y_pred, self.eval_metric, weights, weight_evaluation=self.weight_evaluation, quantile_levels=self.quantile_levels) # TODO: Consider adding persist to disk functionality for pred_proba dictionary to lessen memory burden on large multiclass problems. # For datasets with 100+ classes, this function could potentially run the system OOM due to each pred_proba numpy array taking significant amounts of space. # This issue already existed in the previous level-based version but only had the minimum required predictions in memory at a time, whereas this has all model predictions in memory. # TODO: Add memory optimal topological ordering -> Minimize amount of pred_probas in memory at a time, delete pred probas that are no longer required # Optimally computes pred_probas for each model in `models`. Will compute each necessary model only once and store its predictions in a dictionary. # Note: Mutates model_pred_proba_dict and model_pred_time_dict input if present to minimize memory usage # fit = get oof pred proba # if record_pred_time is `True`, outputs tuple of dicts (model_pred_proba_dict, model_pred_time_dict), else output only model_pred_proba_dict def get_model_pred_proba_dict(self, X, models, model_pred_proba_dict=None, model_pred_time_dict=None, fit=False, record_pred_time=False): if model_pred_proba_dict is None: model_pred_proba_dict = {} if model_pred_time_dict is None: model_pred_time_dict = {} if fit: model_pred_order = [model for model in models if model not in model_pred_proba_dict.keys()] else: model_set = set() for model in models: if model in model_set: continue min_model_set = set(self.get_minimum_model_set(model)) model_set = model_set.union(min_model_set) model_set = model_set.difference(set(model_pred_proba_dict.keys())) models_to_load = list(model_set) subgraph = nx.subgraph(self.model_graph, models_to_load) # For model in model_pred_proba_dict, remove model node from graph and all ancestors that have no remaining descendants and are not in `models` models_to_ignore = [model for model in models_to_load if (model not in models) and (not list(subgraph.successors(model)))] while models_to_ignore: model = models_to_ignore[0] predecessors = list(subgraph.predecessors(model)) subgraph.remove_node(model) models_to_ignore = models_to_ignore[1:] for predecessor in predecessors: if (predecessor not in models) and (not list(subgraph.successors(predecessor))) and (predecessor not in models_to_ignore): models_to_ignore.append(predecessor) # Get model prediction order model_pred_order = list(nx.lexicographical_topological_sort(subgraph)) # Compute model predictions in topological order for model_name in model_pred_order: if record_pred_time: time_start = time.time() if fit: model_type = self.get_model_attribute(model=model_name, attribute='type') if issubclass(model_type, BaggedEnsembleModel): model_path = self.get_model_attribute(model=model_name, attribute='path') model_pred_proba_dict[model_name] = model_type.load_oof(path=model_path) else: raise AssertionError(f'Model {model_name} must be a BaggedEnsembleModel to return oof_pred_proba') else: model = self.load_model(model_name=model_name) if isinstance(model, StackerEnsembleModel): preprocess_kwargs = dict(infer=False, model_pred_proba_dict=model_pred_proba_dict) model_pred_proba_dict[model_name] = model.predict_proba(X, **preprocess_kwargs) else: model_pred_proba_dict[model_name] = model.predict_proba(X) if record_pred_time: time_end = time.time() model_pred_time_dict[model_name] = time_end - time_start if record_pred_time: return model_pred_proba_dict, model_pred_time_dict else: return model_pred_proba_dict # TODO: Remove _get_inputs_to_stacker_legacy eventually, move logic internally into this function instead def get_inputs_to_stacker(self, X, base_models, model_pred_proba_dict=None, fit=False, use_orig_features=True): if base_models is None: base_models = [] if not fit: model_pred_proba_dict = self.get_model_pred_proba_dict(X=X, models=base_models, model_pred_proba_dict=model_pred_proba_dict) model_pred_proba_list = [model_pred_proba_dict[model] for model in base_models] else: # TODO: After _get_inputs_to_stacker_legacy is removed, this if/else is not necessary, instead pass fit param to get_model_pred_proba_dict() model_pred_proba_list = None X_stacker_input = self._get_inputs_to_stacker_legacy(X=X, level_start=1, level_end=2, model_levels={1: base_models}, y_pred_probas=model_pred_proba_list, fit=fit) if not use_orig_features: X_stacker_input = X_stacker_input.drop(columns=X.columns) return X_stacker_input # TODO: Legacy code, still used during training because it is technically slightly faster and more memory efficient than get_model_pred_proba_dict() # Remove in future as it limits flexibility in stacker inputs during training def _get_inputs_to_stacker_legacy(self, X, level_start, level_end, model_levels, y_pred_probas=None, fit=False): if level_start > level_end: raise AssertionError(f'level_start cannot be greater than level end: ({level_start}, {level_end})') if (level_start == 1) and (level_end == 1): return X if fit: if level_start > 1: dummy_stacker_start = self._get_dummy_stacker(level=level_start, model_levels=model_levels, use_orig_features=True) cols_to_drop = dummy_stacker_start.stack_columns X = X.drop(cols_to_drop, axis=1) dummy_stacker = self._get_dummy_stacker(level=level_end, model_levels=model_levels, use_orig_features=True) X = dummy_stacker.preprocess(X=X, preprocess_nonadaptive=False, fit=True, compute_base_preds=True) elif y_pred_probas is not None: if y_pred_probas == []: return X dummy_stacker = self._get_dummy_stacker(level=level_end, model_levels=model_levels, use_orig_features=True) X_stacker = dummy_stacker.pred_probas_to_df(pred_proba=y_pred_probas, index=X.index) if dummy_stacker.params['use_orig_features']: if level_start > 1: dummy_stacker_start = self._get_dummy_stacker(level=level_start, model_levels=model_levels, use_orig_features=True) cols_to_drop = dummy_stacker_start.stack_columns X = X.drop(cols_to_drop, axis=1) X = pd.concat([X_stacker, X], axis=1) else: X = X_stacker else: dummy_stackers = {} for level in range(level_start, level_end+1): if level > 1: dummy_stackers[level] = self._get_dummy_stacker(level=level, model_levels=model_levels, use_orig_features=True) for level in range(level_start, level_end): if level > 1: cols_to_drop = dummy_stackers[level].stack_columns else: cols_to_drop = [] X = dummy_stackers[level+1].preprocess(X=X, preprocess_nonadaptive=False, fit=False, compute_base_preds=True) if len(cols_to_drop) > 0: X = X.drop(cols_to_drop, axis=1) return X # You must have previously called fit() with cache_data=True # Fits _FULL versions of specified models, but does NOT link them (_FULL stackers will still use normal models as input) def refit_single_full(self, X=None, y=None, X_val=None, y_val=None, X_unlabeled=None, models=None) -> List[str]: if X is None: X = self.load_X() if X_val is None: X_val = self.load_X_val() if y is None: y = self.load_y() if y_val is None: y_val = self.load_y_val() if models is None: models = self.get_model_names() model_levels = dict() ignore_models = [] ignore_stack_names = [REFIT_FULL_NAME] for stack_name in ignore_stack_names: ignore_models += self.get_model_names(stack_name=stack_name) # get_model_names returns [] if stack_name does not exist models = [model for model in models if model not in ignore_models] for model in models: model_level = self.get_model_level(model) if model_level not in model_levels: model_levels[model_level] = [] model_levels[model_level].append(model) levels = sorted(model_levels.keys()) models_trained_full = [] model_full_dict = {} for level in levels: models_level = model_levels[level] for model in models_level: model = self.load_model(model) model_name = model.name model_full = model.convert_to_refit_full_template() # Mitigates situation where bagged models barely had enough memory and refit requires more. Worst case results in OOM, but this lowers chance of failure. model_full._user_params_aux['max_memory_usage_ratio'] = model.params_aux['max_memory_usage_ratio'] * 1.15 # TODO: Do it for all models in the level at once to avoid repeated processing of data? base_model_names = self.get_base_model_names(model_name) stacker_type = type(model) if issubclass(stacker_type, WeightedEnsembleModel): # TODO: Technically we don't need to re-train the weighted ensemble, we could just copy the original and re-use the weights. w = None if X_val is None: if self.weight_evaluation: X, w = extract_column(X, self.sample_weight) X_stack_preds = self.get_inputs_to_stacker(X, base_models=base_model_names, fit=True, use_orig_features=False) y_input = y else: if self.weight_evaluation: X_val, w = extract_column(X_val, self.sample_weight) X_stack_preds = self.get_inputs_to_stacker(X_val, base_models=base_model_names, fit=False, use_orig_features=False) # TODO: May want to cache this during original fit, as we do with OOF preds y_input = y_val if w is not None: X_stack_preds[self.sample_weight] = w.values/w.mean() orig_weights = model._get_model_weights() base_model_names = list(orig_weights.keys()) weights = list(orig_weights.values()) child_hyperparameters = { AG_ARGS: {'model_type': 'SIMPLE_ENS_WEIGHTED'}, 'weights': weights, } # TODO: stack_name=REFIT_FULL_NAME_AUX? models_trained = self.generate_weighted_ensemble(X=X_stack_preds, y=y_input, level=level, stack_name=REFIT_FULL_NAME, k_fold=1, n_repeats=1, base_model_names=base_model_names, name_suffix=REFIT_FULL_SUFFIX, save_bag_folds=True, check_if_best=False, child_hyperparameters=child_hyperparameters) # TODO: Do the below more elegantly, ideally as a parameter to the trainer train function to disable recording scores/pred time. for model_weighted_ensemble in models_trained: model_loaded = self.load_model(model_weighted_ensemble) model_loaded.val_score = None model_loaded.predict_time = None self.set_model_attribute(model=model_weighted_ensemble, attribute='val_score', val=None) self.save_model(model_loaded) else: models_trained = self.stack_new_level_core(X=X, y=y, X_val=X_val, y_val=y_val, X_unlabeled=X_unlabeled, models=[model_full], base_model_names=base_model_names, level=level, stack_name=REFIT_FULL_NAME, hyperparameter_tune_kwargs=None, feature_prune=False, k_fold=0, n_repeats=1, ensemble_type=stacker_type, refit_full=True) if len(models_trained) == 1: model_full_dict[model_name] = models_trained[0] for model_trained in models_trained: self._model_full_dict_val_score[model_trained] = self.get_model_attribute(model_name, 'val_score') models_trained_full += models_trained keys_to_del = [] for model in model_full_dict.keys(): if model_full_dict[model] not in models_trained_full: keys_to_del.append(model) for key in keys_to_del: del model_full_dict[key] self.model_full_dict.update(model_full_dict) self.save() # TODO: This could be more efficient by passing in arg to not save if called by refit_ensemble_full since it saves anyways later. return models_trained_full # Fits _FULL models and links them in the stack so _FULL models only use other _FULL models as input during stacking # If model is specified, will fit all _FULL models that are ancestors of the provided model, automatically linking them. # If no model is specified, all models are refit and linked appropriately. def refit_ensemble_full(self, model='all') -> dict: if model == 'all': ensemble_set = self.get_model_names() else: if model == 'best': model = self.get_model_best() ensemble_set = self.get_minimum_model_set(model) existing_models = self.get_model_names() ensemble_set_valid = [] for model in ensemble_set: if model in self.model_full_dict and self.model_full_dict[model] in existing_models: logger.log(20, f"Model '{model}' already has a refit _FULL model: '{self.model_full_dict[model]}', skipping refit...") else: ensemble_set_valid.append(model) if ensemble_set_valid: models_trained_full = self.refit_single_full(models=ensemble_set_valid) else: models_trained_full = [] for model_full in models_trained_full: # TODO: Consider moving base model info to a separate pkl file so that it can be edited without having to load/save the model again # Downside: Slower inference speed when models are not persisted in memory prior. model_loaded = self.load_model(model_full) if isinstance(model_loaded, StackerEnsembleModel): for stack_column_prefix in model_loaded.stack_column_prefix_lst: base_model = model_loaded.stack_column_prefix_to_model_map[stack_column_prefix] new_base_model = self.model_full_dict[base_model] new_base_model_type = self.get_model_attribute(model=new_base_model, attribute='type') new_base_model_path = self.get_model_attribute(model=new_base_model, attribute='path') model_loaded.base_model_paths_dict[new_base_model] = new_base_model_path model_loaded.base_model_types_dict[new_base_model] = new_base_model_type model_loaded.base_model_names.append(new_base_model) model_loaded.stack_column_prefix_to_model_map[stack_column_prefix] = new_base_model model_loaded.save() # TODO: Avoid this! # Remove old edges and add new edges edges_to_remove = list(self.model_graph.in_edges(model_loaded.name)) self.model_graph.remove_edges_from(edges_to_remove) if isinstance(model_loaded, StackerEnsembleModel): for stack_column_prefix in model_loaded.stack_column_prefix_lst: base_model_name = model_loaded.stack_column_prefix_to_model_map[stack_column_prefix] self.model_graph.add_edge(base_model_name, model_loaded.name) self.save() return copy.deepcopy(self.model_full_dict) # TODO: Take best performance model with lowest inference def get_model_best(self, can_infer=None, allow_full=True): models = self.get_model_names(can_infer=can_infer) if not models: raise AssertionError('Trainer has no fit models that can infer.') model_performances = self.get_models_attribute_dict(attribute='val_score') perfs = [(m, model_performances[m]) for m in models if model_performances[m] is not None] if not perfs: model_full_dict_inverse = {full: orig for orig, full in self.model_full_dict.items()} models = [m for m in models if m in model_full_dict_inverse] perfs = [(m, self._get_full_model_val_score(m)) for m in models] if not perfs: raise AssertionError('No fit models that can infer exist with a validation score to choose the best model.') elif not allow_full: raise AssertionError('No fit models that can infer exist with a validation score to choose the best model, but refit_full models exist. Set `allow_full=True` to get the best refit_full model.') return max(perfs, key=lambda i: i[1])[0] def save_model(self, model, reduce_memory=True): # TODO: In future perhaps give option for the reduce_memory_size arguments, perhaps trainer level variables specified by user? if reduce_memory: model.reduce_memory_size(remove_fit=True, remove_info=False, requires_save=True) if self.low_memory: model.save() else: self.models[model.name] = model def save(self): models = self.models if self.low_memory: self.models = {} save_pkl.save(path=self.path + self.trainer_file_name, object=self) if self.low_memory: self.models = models def persist_models(self, model_names='all', with_ancestors=False, max_memory=None) -> List[str]: if model_names == 'all': model_names = self.get_model_names() elif model_names == 'best': if self.model_best is not None: model_names = [self.model_best] else: model_names = [self.get_model_best(can_infer=True)] if not isinstance(model_names, list): raise ValueError(f'model_names must be a list of model names. Invalid value: {model_names}') if with_ancestors: model_names = self.get_minimum_models_set(model_names) model_names_already_persisted = [model_name for model_name in model_names if model_name in self.models] if model_names_already_persisted: logger.log(30, f'The following {len(model_names_already_persisted)} models were already persisted and will be ignored in the model loading process: {model_names_already_persisted}') model_names = [model_name for model_name in model_names if model_name not in model_names_already_persisted] if not model_names: logger.log(30, f'No valid unpersisted models were specified to be persisted, so no change in model persistence was performed.') return [] if max_memory is not None: info = self.get_models_info(model_names) model_mem_size_map = {model: info[model]['memory_size'] for model in model_names} for model in model_mem_size_map: if 'children_info' in info[model]: for child in info[model]['children_info'].values(): model_mem_size_map[model] += child['memory_size'] total_mem_required = sum(model_mem_size_map.values()) available_mem = psutil.virtual_memory().available memory_proportion = total_mem_required / available_mem if memory_proportion > max_memory: logger.log(30, f'Models will not be persisted in memory as they are expected to require {round(memory_proportion * 100, 2)}% of memory, which is greater than the specified max_memory limit of {round(max_memory*100, 2)}%.') logger.log(30, f'\tModels will be loaded on-demand from disk to maintain safe memory usage, increasing inference latency. If inference latency is a concern, try to use smaller models or increase the value of max_memory.') return [] else: logger.log(20, f'Persisting {len(model_names)} models in memory. Models will require {round(memory_proportion*100, 2)}% of memory.') models = [] for model_name in model_names: model = self.load_model(model_name) self.models[model.name] = model models.append(model) for model in models: # TODO: Move this to model code if isinstance(model, BaggedEnsembleModel): for fold, fold_model in enumerate(model.models): if isinstance(fold_model, str): model.models[fold] = model.load_child(fold_model) return model_names # TODO: model_name change to model in params def load_model(self, model_name: str, path: str = None, model_type=None) -> AbstractModel: if isinstance(model_name, AbstractModel): return model_name if model_name in self.models.keys(): return self.models[model_name] else: if path is None: path = self.get_model_attribute(model=model_name, attribute='path') if model_type is None: model_type = self.get_model_attribute(model=model_name, attribute='type') return model_type.load(path=path, reset_paths=self.reset_paths) def unpersist_models(self, model_names='all') -> list: if model_names == 'all': model_names = list(self.models.keys()) if not isinstance(model_names, list): raise ValueError(f'model_names must be a list of model names. Invalid value: {model_names}') unpersisted_models = [] for model in model_names: if model in self.models: self.models.pop(model) unpersisted_models.append(model) if unpersisted_models: logger.log(20, f'Unpersisted {len(unpersisted_models)} models: {unpersisted_models}') else: logger.log(30, f'No valid persisted models were specified to be unpersisted, so no change in model persistence was performed.') return unpersisted_models def generate_weighted_ensemble(self, X, y, level, base_model_names, k_fold=1, n_repeats=1, stack_name=None, hyperparameters=None, time_limit=None, name_suffix: str = None, save_bag_folds=None, check_if_best=True, child_hyperparameters=None, get_models_func=None) -> List[str]: if get_models_func is None: get_models_func = self.construct_model_templates if len(base_model_names) == 0: logger.log(20, 'No base models to train on, skipping weighted ensemble...') return [] if child_hyperparameters is None: child_hyperparameters = {} if save_bag_folds is None: can_infer_dict = self.get_models_attribute_dict('can_infer', models=base_model_names) if False in can_infer_dict.values(): save_bag_folds = False else: save_bag_folds = True weighted_ensemble_model, _ = get_models_func( hyperparameters={ 'default': { 'ENS_WEIGHTED': [child_hyperparameters], } }, ensemble_type=WeightedEnsembleModel, ensemble_kwargs=dict( base_model_names=base_model_names, base_model_paths_dict=self.get_models_attribute_dict(attribute='path', models=base_model_names), base_model_types_dict=self.get_models_attribute_dict(attribute='type', models=base_model_names), base_model_types_inner_dict=self.get_models_attribute_dict(attribute='type_inner', models=base_model_names), base_model_performances_dict=self.get_models_attribute_dict(attribute='val_score', models=base_model_names), hyperparameters=hyperparameters, random_state=level + self.random_state, ), ag_args={'name_bag_suffix': ''}, ag_args_ensemble={'save_bag_folds': save_bag_folds}, name_suffix=name_suffix, level=level, ) weighted_ensemble_model = weighted_ensemble_model[0] w = None if self.weight_evaluation: X, w = extract_column(X, self.sample_weight) models = self._train_multi( X=X, y=y, X_val=None, y_val=None, models=[weighted_ensemble_model], k_fold=k_fold, n_repeats=n_repeats, hyperparameter_tune_kwargs=None, stack_name=stack_name, level=level, time_limit=time_limit, ens_sample_weight=w, fit_kwargs=dict(num_classes=self.num_classes, groups=None), # FIXME: Is this the right way to do this? ) for weighted_ensemble_model_name in models: if check_if_best and weighted_ensemble_model_name in self.get_model_names(): if self.model_best is None: self.model_best = weighted_ensemble_model_name else: best_score = self.get_model_attribute(self.model_best, 'val_score') cur_score = self.get_model_attribute(weighted_ensemble_model_name, 'val_score') if cur_score > best_score: # new best model self.model_best = weighted_ensemble_model_name return models def _train_single(self, X, y, model: AbstractModel, X_val=None, y_val=None, **model_fit_kwargs) -> AbstractModel: """ Trains model but does not add the trained model to this Trainer. Returns trained model object. """ model = model.fit(X=X, y=y, X_val=X_val, y_val=y_val, **model_fit_kwargs) return model def _train_and_save(self, X, y, model: AbstractModel, X_val=None, y_val=None, stack_name='core', level=1, **model_fit_kwargs) -> List[str]: """ Trains model and saves it to disk, returning a list with a single element: The name of the model, or no elements if training failed. If the model name is returned: The model can be accessed via self.load_model(model.name). The model will have metadata information stored in self.model_graph. The model's name will be appended to self.models_level[stack_name][level] The model will be accessible and usable through any Trainer function that takes as input 'model' or 'model_name'. Note: self._train_and_save should not be used outside of self._train_single_full """ fit_start_time = time.time() time_limit = model_fit_kwargs.get('time_limit', None) model_names_trained = [] try: fit_log_message = f'Fitting model: {model.name} ...' if time_limit is not None: if time_limit <= 0: logger.log(15, f'Skipping {model.name} due to lack of time remaining.') return model_names_trained if self._time_limit is not None and self._time_train_start is not None: time_left_total = self._time_limit - (fit_start_time - self._time_train_start) else: time_left_total = time_limit fit_log_message += f' Training model for up to {round(time_limit, 2)}s of the {round(time_left_total, 2)}s of remaining time.' logger.log(20, fit_log_message) model = self._train_single(X, y, model, X_val, y_val, **model_fit_kwargs) fit_end_time = time.time() if self.weight_evaluation: w = model_fit_kwargs.get('sample_weight', None) w_val = model_fit_kwargs.get('sample_weight_val', None) else: w = None w_val = None if isinstance(model, BaggedEnsembleModel): if X_val is not None and y_val is not None: score = model.score(X=X_val, y=y_val, sample_weight=w_val) elif model.is_valid_oof() or isinstance(model, WeightedEnsembleModel): score = model.score_with_oof(y=y, sample_weight=w) else: score = None else: if X_val is not None and y_val is not None: score = model.score(X=X_val, y=y_val, sample_weight=w_val) else: score = None pred_end_time = time.time() if model.fit_time is None: model.fit_time = fit_end_time - fit_start_time if model.predict_time is None: if score is None: model.predict_time = None else: model.predict_time = pred_end_time - fit_end_time model.val_score = score # TODO: Add recursive=True to avoid repeatedly loading models each time this is called for bagged ensembles (especially during repeated bagging) self.save_model(model=model) except TimeLimitExceeded: logger.log(20, f'\tTime limit exceeded... Skipping {model.name}.') # logger.log(20, '\tTime wasted: ' + str(time.time() - fit_start_time)) del model except NotEnoughMemoryError: logger.warning(f'\tNot enough memory to train {model.name}... Skipping this model.') del model except NoValidFeatures: logger.warning(f'\tNo valid features to train {model.name}... Skipping this model.') del model except NoGPUError: logger.warning(f'\tNo GPUs available to train {model.name}... Skipping this model.') del model except ImportError as err: logger.error(f'\tWarning: Exception caused {model.name} to fail during training (ImportError)... Skipping this model.') logger.error(f'\t\t{err}') if self.verbosity > 2: logger.exception('Detailed Traceback:') except Exception as err: logger.error(f'\tWarning: Exception caused {model.name} to fail during training... Skipping this model.') logger.error(f'\t\t{err}') if self.verbosity > 0: logger.exception('Detailed Traceback:') del model else: self._add_model(model=model, stack_name=stack_name, level=level) model_names_trained.append(model.name) if self.low_memory: del model return model_names_trained def _add_model(self, model: AbstractModel, stack_name: str = 'core', level: int = 1) -> bool: """ Registers the fit model in the Trainer object. Stores information such as model performance, save path, model type, and more. To use a model in Trainer, self._add_model must be called. If self.low_memory, then the model object will be deleted after this call. Use Trainer directly to leverage the model further. Parameters ---------- model : AbstractModel Model which has been fit. This model will be registered to the Trainer. stack_name : str, default 'core' Stack name to assign the model to. This is used for advanced functionality. level : int, default 1 Stack level of the stack name to assign the model to. This is used for advanced functionality. The model's name is appended to self.models_level[stack_name][level] The model's base_models (if it has any) must all be a lower level than the model. Returns ------- boolean, True if model was registered, False if model was found to be invalid and not registered. """ if model.val_score is not None: if model.eval_metric.name != self.eval_metric.name: logger.log(20, f'\tNote: model has different eval_metric than default.') logger.log(20, f'\t{round(model.val_score, 4)}\t = Validation score ({model.eval_metric.name})') if model.fit_time is not None: logger.log(20, f'\t{round(model.fit_time, 2)}s\t = Training runtime') if model.predict_time is not None: logger.log(20, f'\t{round(model.predict_time, 2)}s\t = Validation runtime') if model.val_score is not None and np.isnan(model.val_score): logger.warning(f'WARNING: {model.name} has a val_score of {model.val_score} (NaN)! This should never happen. The model will not be saved to avoid instability.') return False # TODO: Add to HPO if isinstance(model, BaggedEnsembleModel): type_inner = model._child_type else: type_inner = type(model) self.model_graph.add_node( model.name, fit_time=model.fit_time, predict_time=model.predict_time, val_score=model.val_score, path=model.path, type=type(model), # Outer type, can be BaggedEnsemble, StackEnsemble (Type that is able to load the model) type_inner=type_inner, # Inner type, if Ensemble then it is the type of the inner model (May not be able to load with this type) can_infer=model.can_infer(), can_fit=model.can_fit(), is_valid=model.is_valid(), stack_name=stack_name, level=level, **model._fit_metadata, ) if isinstance(model, StackerEnsembleModel): prior_models = self.get_model_names() # TODO: raise exception if no base models and level != 1? for stack_column_prefix in model.stack_column_prefix_lst: base_model_name = model.stack_column_prefix_to_model_map[stack_column_prefix] if base_model_name not in prior_models: raise AssertionError(f"Model '{model.name}' depends on model '{base_model_name}', but '{base_model_name}' is not registered as a trained model! Valid models: {prior_models}") elif level <= self.model_graph.nodes[base_model_name]['level']: raise AssertionError(f"Model '{model.name}' depends on model '{base_model_name}', but '{base_model_name}' is not in a lower stack level. ('{model.name}' level: {level}, '{base_model_name}' level: {self.model_graph.nodes[base_model_name]['level']})") self.model_graph.add_edge(base_model_name, model.name) if self.low_memory: del model return True # TODO: Split this to avoid confusion, HPO should go elsewhere? def _train_single_full(self, X, y, model: AbstractModel, X_unlabeled=None, X_val=None, y_val=None, hyperparameter_tune_kwargs=None, stack_name='core', k_fold=None, k_fold_start=0, k_fold_end=None, n_repeats=None, n_repeat_start=0, level=1, time_limit=None, fit_kwargs=None, **kwargs) -> List[str]: """ Trains a model, with the potential to train multiple versions of this model with hyperparameter tuning and feature pruning. Returns a list of successfully trained and saved model names. Models trained from this method will be accessible in this Trainer. """ model_fit_kwargs = self._get_model_fit_kwargs(X=X, X_val=X_val, time_limit=time_limit, k_fold=k_fold, fit_kwargs=fit_kwargs, ens_sample_weight=kwargs.get('ens_sample_weight', None)) if hyperparameter_tune_kwargs: if n_repeat_start != 0: raise ValueError(f'n_repeat_start must be 0 to hyperparameter_tune, value = {n_repeat_start}') elif k_fold_start != 0: raise ValueError(f'k_fold_start must be 0 to hyperparameter_tune, value = {k_fold_start}') if not isinstance(hyperparameter_tune_kwargs, tuple): num_trials = 1 if time_limit is None else 1000 hyperparameter_tune_kwargs = scheduler_factory(hyperparameter_tune_kwargs, num_trials=num_trials, nthreads_per_trial='auto', ngpus_per_trial='auto') # hpo_models (dict): keys = model_names, values = model_paths logger.log(20, f'Hyperparameter tuning model: {model.name} ...') try: if isinstance(model, BaggedEnsembleModel): hpo_models, hpo_model_performances, hpo_results = model.hyperparameter_tune(X=X, y=y, k_fold=k_fold, scheduler_options=hyperparameter_tune_kwargs, **model_fit_kwargs) else: hpo_models, hpo_model_performances, hpo_results = model.hyperparameter_tune(X=X, y=y, X_val=X_val, y_val=y_val, scheduler_options=hyperparameter_tune_kwargs, **model_fit_kwargs) except Exception as err: logger.exception(f'Warning: Exception caused {model.name} to fail during hyperparameter tuning... Skipping this model.') logger.warning(err) del model model_names_trained = [] else: # Commented out because it takes too much space (>>5 GB if run for an hour on a small-medium sized dataset) # self.hpo_results[model.name] = hpo_results model_names_trained = [] self._extra_banned_names.add(model.name) for model_hpo_name, model_path in hpo_models.items(): model_hpo = self.load_model(model_hpo_name, path=model_path, model_type=type(model)) logger.log(20, f'Fitted model: {model_hpo.name} ...') if self._add_model(model=model_hpo, stack_name=stack_name, level=level): model_names_trained.append(model_hpo.name) else: if isinstance(model, BaggedEnsembleModel): bagged_model_fit_kwargs = self._get_bagged_model_fit_kwargs(k_fold=k_fold, k_fold_start=k_fold_start, k_fold_end=k_fold_end, n_repeats=n_repeats, n_repeat_start=n_repeat_start) model_fit_kwargs.update(bagged_model_fit_kwargs) model_names_trained = self._train_and_save(X, y, model, X_val, y_val, X_unlabeled=X_unlabeled, stack_name=stack_name, level=level, **model_fit_kwargs) self.save() return model_names_trained # TODO: How to deal with models that fail during this? They have trained valid models before, but should we still use those models or remove the entire model? Currently we still use models. # TODO: Time allowance can be made better by only using time taken during final model training and not during HPO and feature pruning. # TODO: Time allowance not accurate if running from fit_continue # TODO: Remove level and stack_name arguments, can get them automatically # TODO: Make sure that pretraining on X_unlabeled only happens 1 time rather than every fold of bagging. (Do during pretrain API work?) def _train_multi_repeats(self, X, y, models: list, n_repeats, n_repeat_start=1, time_limit=None, time_limit_total_level=None, **kwargs) -> List[str]: """ Fits bagged ensemble models with additional folds and/or bagged repeats. Models must have already been fit prior to entering this method. This method should only be called in self._train_multi Returns a list of successfully trained and saved model names. """ if time_limit_total_level is None: time_limit_total_level = time_limit models_valid = models models_valid_next = [] repeats_completed = 0 time_start = time.time() for n in range(n_repeat_start, n_repeats): if not models_valid: break # No models to repeat if time_limit is not None: time_start_repeat = time.time() time_left = time_limit - (time_start_repeat - time_start) if n == n_repeat_start: time_required = time_limit_total_level * 0.575 # Require slightly over 50% to be safe else: time_required = (time_start_repeat - time_start) / repeats_completed * (0.575/0.425) if time_left < time_required: logger.log(15, 'Not enough time left to finish repeated k-fold bagging, stopping early ...') break logger.log(20, f'Repeating k-fold bagging: {n+1}/{n_repeats}') for i, model in enumerate(models_valid): if not self.get_model_attribute(model=model, attribute='can_fit'): if isinstance(model, str): models_valid_next.append(model) else: models_valid_next.append(model.name) continue if isinstance(model, str): model = self.load_model(model) if not isinstance(model, BaggedEnsembleModel): raise AssertionError(f'{model.name} must inherit from BaggedEnsembleModel to perform repeated k-fold bagging. Model type: {type(model).__name__}') if time_limit is None: time_left = None else: time_start_model = time.time() time_left = time_limit - (time_start_model - time_start) models_valid_next += self._train_single_full(X=X, y=y, model=model, k_fold_start=0, k_fold_end=None, n_repeats=n + 1, n_repeat_start=n, time_limit=time_left, **kwargs) models_valid = copy.deepcopy(models_valid_next) models_valid_next = [] repeats_completed += 1 logger.log(20, f'Completed {n_repeat_start + repeats_completed}/{n_repeats} k-fold bagging repeats ...') return models_valid def _train_multi_initial(self, X, y, models: List[AbstractModel], k_fold, n_repeats, hyperparameter_tune_kwargs=None, time_limit=None, feature_prune_kwargs=None, **kwargs): """ Fits models that have not previously been fit. This method should only be called in self._train_multi Returns a list of successfully trained and saved model names. """ multi_fold_time_start = time.time() fit_args = dict( X=X, y=y, k_fold=k_fold, ) fit_args.update(kwargs) hpo_enabled = False if hyperparameter_tune_kwargs: for key in hyperparameter_tune_kwargs: if hyperparameter_tune_kwargs[key] is not None: hpo_enabled = True break hpo_time_ratio = 0.9 if hpo_enabled: time_split = True else: time_split = False k_fold_start = 0 bagged = k_fold > 0 if not bagged: time_ratio = hpo_time_ratio if hpo_enabled else 1 models = self._train_multi_fold(models=models, hyperparameter_tune_kwargs=hyperparameter_tune_kwargs, time_limit=time_limit, time_split=time_split, time_ratio=time_ratio, **fit_args) else: bagged_time_start = time.time() if hpo_enabled: time_ratio = (1 / k_fold) * hpo_time_ratio models = self._train_multi_fold(models=models, hyperparameter_tune_kwargs=hyperparameter_tune_kwargs, k_fold_start=0, k_fold_end=1, n_repeats=n_repeats, n_repeat_start=0, time_limit=time_limit, time_split=time_split, time_ratio=time_ratio, **fit_args) k_fold_start = 1 bagged_time_limit = time_limit - (time.time() - bagged_time_start) if time_limit is not None else None models = self._train_multi_fold(models=models, hyperparameter_tune_kwargs=None, k_fold_start=k_fold_start, k_fold_end=k_fold, n_repeats=n_repeats, n_repeat_start=0, time_limit=bagged_time_limit, **fit_args) multi_fold_time_elapsed = time.time() - multi_fold_time_start if time_limit is not None: time_limit = time_limit - multi_fold_time_elapsed if feature_prune_kwargs is not None and len(models) > 0: feature_prune_time_start = time.time() model_fit_kwargs = self._get_model_fit_kwargs(X=X, X_val=kwargs.get('X_val', None), time_limit=None, k_fold=k_fold, fit_kwargs=kwargs.get('fit_kwargs', {}), ens_sample_weight=kwargs.get('ens_sample_weight')) model_fit_kwargs.update(dict(X=X, y=y, X_val=kwargs.get('X_val', None), y_val=kwargs.get('y_val', None))) if bagged: bagged_model_fit_kwargs = self._get_bagged_model_fit_kwargs(k_fold=k_fold, k_fold_start=k_fold_start, k_fold_end=k_fold, n_repeats=n_repeats, n_repeat_start=0) model_fit_kwargs.update(bagged_model_fit_kwargs) candidate_features = self._proxy_model_feature_prune(time_limit=time_limit, layer_fit_time=multi_fold_time_elapsed, level=kwargs['level'], features=X.columns.tolist(), model_fit_kwargs=model_fit_kwargs, **feature_prune_kwargs) if time_limit is not None: time_limit = time_limit - (time.time() - feature_prune_time_start) fit_args['X'] = X[candidate_features] fit_args['X_val'] = kwargs['X_val'][candidate_features] if isinstance(kwargs.get('X_val', None), pd.DataFrame) else kwargs.get('X_val', None) if len(candidate_features) < len(X.columns): unfit_models = [] original_prune_map = {} for model in models: unfit_model = self.load_model(model).convert_to_template() unfit_model.rename(f"{unfit_model.name}_Prune") unfit_models.append(unfit_model) original_prune_map[unfit_model.name] = model pruned_models = self._train_multi_fold(models=unfit_models, hyperparameter_tune_kwargs=None, k_fold_start=k_fold_start, k_fold_end=k_fold, n_repeats=n_repeats, n_repeat_start=0, time_limit=time_limit, **fit_args) force_prune = feature_prune_kwargs.get('force_prune', False) models = self._retain_better_pruned_models(pruned_models=pruned_models, original_prune_map=original_prune_map, force_prune=force_prune) return models # TODO: Ban KNN from being a Stacker model outside of aux. Will need to ensemble select on all stack layers ensemble selector to make it work # TODO: Robert dataset, LightGBM is super good but RF and KNN take all the time away from it on 1h despite being much worse # TODO: Add time_limit_per_model # TODO: Rename for v0.1 def _train_multi_fold(self, X, y, models: List[AbstractModel], time_limit=None, time_split=False, time_ratio=1, hyperparameter_tune_kwargs=None, **kwargs) -> List[str]: """ Trains and saves a list of models sequentially. This method should only be called in self._train_multi_initial Returns a list of trained model names. """ models_valid = [] time_start = time.time() if time_limit is not None: time_limit = time_limit * time_ratio if time_limit is not None and len(models) > 0: time_limit_model_split = time_limit / len(models) else: time_limit_model_split = time_limit for i, model in enumerate(models): if isinstance(model, str): model = self.load_model(model) elif self.low_memory: model = copy.deepcopy(model) if hyperparameter_tune_kwargs is not None and isinstance(hyperparameter_tune_kwargs, dict): hyperparameter_tune_kwargs_model = hyperparameter_tune_kwargs.get(model.name, None) else: hyperparameter_tune_kwargs_model = None # TODO: Only update scores when finished, only update model as part of final models if finished! if time_split: time_left = time_limit_model_split else: if time_limit is None: time_left = None else: time_start_model = time.time() time_left = time_limit - (time_start_model - time_start) model_name_trained_lst = self._train_single_full(X, y, model, time_limit=time_left, hyperparameter_tune_kwargs=hyperparameter_tune_kwargs_model, **kwargs) if self.low_memory: del model models_valid += model_name_trained_lst return models_valid def _train_multi(self, X, y, models: List[AbstractModel], hyperparameter_tune_kwargs=None, feature_prune_kwargs=None, k_fold=None, n_repeats=None, n_repeat_start=0, time_limit=None, **kwargs) -> List[str]: """ Train a list of models using the same data. Assumes that input data has already been processed in the form the models will receive as input (including stack feature generation). Trained models are available in the trainer object. Note: Consider using public APIs instead of this. Returns a list of trained model names. """ time_limit_total_level = time_limit if k_fold is None: k_fold = self.k_fold if n_repeats is None: n_repeats = self.n_repeats if (k_fold == 0) and (n_repeats != 1): raise ValueError(f'n_repeats must be 1 when k_fold is 0, values: ({n_repeats}, {k_fold})') if time_limit is None and feature_prune_kwargs is None: n_repeats_initial = n_repeats else: n_repeats_initial = 1 if n_repeat_start == 0: time_start = time.time() model_names_trained = self._train_multi_initial(X=X, y=y, models=models, k_fold=k_fold, n_repeats=n_repeats_initial, hyperparameter_tune_kwargs=hyperparameter_tune_kwargs, feature_prune_kwargs=feature_prune_kwargs, time_limit=time_limit, **kwargs) n_repeat_start = n_repeats_initial if time_limit is not None: time_limit = time_limit - (time.time() - time_start) else: model_names_trained = models if (n_repeats > 1) and (n_repeat_start < n_repeats): model_names_trained = self._train_multi_repeats(X=X, y=y, models=model_names_trained, k_fold=k_fold, n_repeats=n_repeats, n_repeat_start=n_repeat_start, time_limit=time_limit, time_limit_total_level=time_limit_total_level, **kwargs) return model_names_trained def _train_multi_and_ensemble(self, X, y, X_val, y_val, hyperparameters: dict = None, X_unlabeled=None, num_stack_levels=0, time_limit=None, groups=None, **kwargs) -> List[str]: """Identical to self.train_multi_levels, but also saves the data to disk. This should only ever be called once.""" if self.save_data and not self.is_data_saved: self.save_X(X) self.save_y(y) if X_val is not None: self.save_X_val(X_val) if y_val is not None: self.save_y_val(y_val) self.is_data_saved = True if self._groups is None: self._groups = groups self._num_rows_train = len(X) if X_val is not None: self._num_rows_train += len(X_val) self._num_cols_train = len(list(X.columns)) model_names_fit = self.train_multi_levels(X, y, hyperparameters=hyperparameters, X_val=X_val, y_val=y_val, X_unlabeled=X_unlabeled, level_start=1, level_end=num_stack_levels+1, time_limit=time_limit, **kwargs) if len(self.get_model_names()) == 0: raise ValueError('AutoGluon did not successfully train any models') return model_names_fit def _predict_model(self, X, model, model_pred_proba_dict=None): if isinstance(model, str): model = self.load_model(model) X = self.get_inputs_to_model(model=model, X=X, model_pred_proba_dict=model_pred_proba_dict, fit=False) y_pred = model.predict(X=X) if self._regress_preds_asprobas and model.problem_type == REGRESSION: # Convert regression preds to classes (during distillation) if (len(y_pred.shape) > 1) and (y_pred.shape[1] > 1): problem_type = MULTICLASS else: problem_type = BINARY y_pred = get_pred_from_proba(y_pred_proba=y_pred, problem_type=problem_type) return y_pred def _predict_proba_model(self, X, model, model_pred_proba_dict=None): if isinstance(model, str): model = self.load_model(model) X = self.get_inputs_to_model(model=model, X=X, model_pred_proba_dict=model_pred_proba_dict, fit=False) return model.predict_proba(X=X) def _get_dummy_stacker(self, level: int, model_levels: dict, use_orig_features=True) -> StackerEnsembleModel: model_names = model_levels[level - 1] base_models_dict = {} for model_name in model_names: if model_name in self.models.keys(): base_models_dict[model_name] = self.models[model_name] hyperparameters = dict( use_orig_features=use_orig_features, max_base_models_per_type=0, max_base_models=0, ) dummy_stacker = StackerEnsembleModel( path='', name='', model_base=AbstractModel( path='', name='', problem_type=self.problem_type, eval_metric=self.eval_metric, hyperparameters={'ag_args_fit': {'quantile_levels': self.quantile_levels}} ), base_model_names=model_names, base_models_dict=base_models_dict, base_model_paths_dict=self.get_models_attribute_dict(attribute='path', models=model_names), base_model_types_dict=self.get_models_attribute_dict(attribute='type', models=model_names), hyperparameters=hyperparameters, random_state=level+self.random_state ) dummy_stacker.initialize(num_classes=self.num_classes) return dummy_stacker def _proxy_model_feature_prune(self, model_fit_kwargs: dict, time_limit: float, layer_fit_time: float, level: int, features: List[str], **feature_prune_kwargs: dict) -> List[str]: """ Uses the best LightGBM-based base learner of this layer to perform time-aware permutation feature importance based feature pruning. If all LightGBM models fail, use the model that achieved the highest validation accuracy. Feature pruning gets the smaller of the remaining layer time limit and k times (default=2) it took to fit the base learners of this layer as its resource. Note that feature pruning can exit earlier based on arguments in feature_prune_kwargs. The method returns the list of feature names that survived the pruning procedure. Parameters ---------- feature_prune_kwargs : dict Feature pruning kwarg arguments. Should contain arguments passed to FeatureSelector.select_features. One can optionally attach the following additional kwargs that are consumed at this level: 'proxy_model_class' to use a model of particular type with the highest validation score as the proxy model, 'feature_prune_time_limit' to manually specify how long we should perform the feature pruning procedure for, 'k' to specify how long we should perform feature pruning for if 'feature_prune_time_limit' has not been set (feature selection time budget is set to k * layer_fit_time), and 'raise_exception' to signify that AutoGluon should throw an exception if feature pruning errors out. time_limit : float Time limit left within the current stack layer in seconds. Feature pruning should never take more than this time. layer_fit_time : float How long it took to fit all the models in this layer once. Used to calculate how long to feature prune for. level : int Level of this stack layer. features: List[str] The list of feature names in the inputted dataset. Returns ------- candidate_features : List[str] Feature names that survived the pruning procedure. """ k = feature_prune_kwargs.pop('k', 2) proxy_model_class = feature_prune_kwargs.pop('proxy_model_class', self._get_default_proxy_model_class()) feature_prune_time_limit = feature_prune_kwargs.pop('feature_prune_time_limit', None) raise_exception_on_fail = feature_prune_kwargs.pop('raise_exception', False) proxy_model = self._get_feature_prune_proxy_model(proxy_model_class=proxy_model_class, level=level) if proxy_model is None: return features if feature_prune_time_limit is not None: feature_prune_time_limit = min(max(time_limit - layer_fit_time, 0), feature_prune_time_limit) elif time_limit is not None: feature_prune_time_limit = min(max(time_limit - layer_fit_time, 0), max(k * layer_fit_time, 0.05 * time_limit)) else: feature_prune_time_limit = max(k * layer_fit_time, 300) if feature_prune_time_limit < 2 * proxy_model.fit_time: logger.warning(f"Insufficient time to train even a single feature pruning model (remaining: {feature_prune_time_limit}, " f"needed: {proxy_model.fit_time}). Skipping feature pruning.") return features selector = FeatureSelector(model=proxy_model, time_limit=feature_prune_time_limit, raise_exception=raise_exception_on_fail, problem_type=self.problem_type) candidate_features = selector.select_features(**feature_prune_kwargs, **model_fit_kwargs) return candidate_features def _get_default_proxy_model_class(self): return None def _retain_better_pruned_models(self, pruned_models: List[str], original_prune_map: dict, force_prune: bool = False) -> List[str]: """ Compares models fit on the pruned set of features with their counterpart, models fit on full set of features. Take the model that achieved a higher validation set score and delete the other from self.model_graph. Parameters ---------- pruned_models : List[str] A list of pruned model names. original_prune_map : dict A dictionary mapping the names of models fitted on pruned features to the names of models fitted on original features. force_prune : bool, default = False If set to true, force all base learners to work with the pruned set of features. Returns ---------- models : List[str] A list of model names. """ models = [] for pruned_model in pruned_models: original_model = original_prune_map[pruned_model] leaderboard = self.leaderboard() original_score = leaderboard[leaderboard['model'] == original_model]['score_val'].item() pruned_score = leaderboard[leaderboard['model'] == pruned_model]['score_val'].item() score_str = f"({round(pruned_score, 4)} vs {round(original_score, 4)})" if force_prune: logger.log(30, f"Pruned score vs original score is {score_str}. Replacing original model since force_prune=True...") self.delete_models(models_to_delete=original_model, dry_run=False) models.append(pruned_model) elif pruned_score > original_score: logger.log(30, f"Model trained with feature pruning score is better than original model's score {score_str}. Replacing original model...") self.delete_models(models_to_delete=original_model, dry_run=False) models.append(pruned_model) else: logger.log(30, f"Model trained with feature pruning score is not better than original model's score {score_str}. Keeping original model...") self.delete_models(models_to_delete=pruned_model, dry_run=False) models.append(original_model) return models # TODO: Enable raw=True for bagged models when X=None # This is non-trivial to implement for multi-layer stacking ensembles on the OOF data. # TODO: Consider limiting X to 10k rows here instead of inside the model call def get_feature_importance(self, model=None, X=None, y=None, raw=True, **kwargs) -> pd.DataFrame: if model is None: model = self.model_best model: AbstractModel = self.load_model(model) if X is None and model.val_score is None: raise AssertionError(f'Model {model.name} is not valid for generating feature importances on original training data because no validation data was used during training, please specify new test data to compute feature importances.') if X is None: if isinstance(model, WeightedEnsembleModel): if self.bagged_mode: if raw: raise AssertionError('`feature_stage=\'transformed\'` feature importance on the original training data is not yet supported when bagging is enabled, please specify new test data to compute feature importances.') X = None is_oof = True else: if raw: X = self.load_X_val() else: X = None is_oof = False elif isinstance(model, BaggedEnsembleModel): if raw: raise AssertionError('`feature_stage=\'transformed\'` feature importance on the original training data is not yet supported when bagging is enabled, please specify new test data to compute feature importances.') X = self.load_X() X = self.get_inputs_to_model(model=model, X=X, fit=True) is_oof = True else: X = self.load_X_val() if not raw: X = self.get_inputs_to_model(model=model, X=X, fit=False) is_oof = False else: is_oof = False if not raw: X = self.get_inputs_to_model(model=model, X=X, fit=False) if y is None and X is not None: if is_oof: y = self.load_y() else: y = self.load_y_val() if raw: return self._get_feature_importance_raw(X=X, y=y, model=model, **kwargs) else: if is_oof: kwargs['is_oof'] = is_oof return model.compute_feature_importance(X=X, y=y, **kwargs) # TODO: Can get feature importances of all children of model at no extra cost, requires scoring the values after predict_proba on each model # Could solve by adding a self.score_all() function which takes model as input and also returns scores of all children models. # This would be best solved after adding graph representation, it lives most naturally in AbstractModel # TODO: Can skip features which were pruned on all models that model depends on (Complex to implement, requires graph representation) # TODO: Note that raw importance will not equal non-raw importance for bagged models, even if raw features are identical to the model features. # This is because for non-raw, we do an optimization where each fold model calls .compute_feature_importance(), and then the feature importances are averaged across the folds. # This is different from raw, where the predictions of the folds are averaged and then feature importance is computed. # Consider aligning these methods so they produce the same result. # The output of this function is identical to non-raw when model is level 1 and non-bagged def _get_feature_importance_raw(self, X, y, model, eval_metric=None, **kwargs) -> pd.DataFrame: if eval_metric is None: eval_metric = self.eval_metric if model is None: model = self.model_best if eval_metric.needs_pred: predict_func = self.predict else: predict_func = self.predict_proba model: AbstractModel = self.load_model(model) predict_func_kwargs = dict(model=model) return compute_permutation_feature_importance( X=X, y=y, predict_func=predict_func, predict_func_kwargs=predict_func_kwargs, eval_metric=eval_metric, **kwargs ) def _get_models_load_info(self, model_names): model_names = copy.deepcopy(model_names) model_paths = self.get_models_attribute_dict(attribute='path', models=model_names) model_types = self.get_models_attribute_dict(attribute='type', models=model_names) return model_names, model_paths, model_types # Sums the attribute value across all models that the provided model depends on, including itself. # For instance, this function can return the expected total predict_time of a model. # attribute is the name of the desired attribute to be summed, or a dictionary of model name -> attribute value if the attribute is not present in the graph. def get_model_attribute_full(self, model, attribute, func=sum): base_model_set = self.get_minimum_model_set(model) if isinstance(attribute, dict): is_dict = True else: is_dict = False if len(base_model_set) == 1: if is_dict: return attribute[model] else: return self.model_graph.nodes[base_model_set[0]][attribute] # attribute_full = 0 attribute_lst = [] for base_model in base_model_set: if is_dict: attribute_base_model = attribute[base_model] else: attribute_base_model = self.model_graph.nodes[base_model][attribute] if attribute_base_model is None: return None attribute_lst.append(attribute_base_model) # attribute_full += attribute_base_model if attribute_lst: attribute_full = func(attribute_lst) else: attribute_full = 0 return attribute_full # Returns dictionary of model name -> attribute value for the provided attribute def get_models_attribute_dict(self, attribute, models: list = None) -> dict: models_attribute_dict = nx.get_node_attributes(self.model_graph, attribute) if models is not None: model_names = [] for model in models: if not isinstance(model, str): model = model.name model_names.append(model) models_attribute_dict = {key: val for key, val in models_attribute_dict.items() if key in model_names} return models_attribute_dict # TODO: v0.1 Proper error catching # Returns attribute value for the given model def get_model_attribute(self, model, attribute: str): if not isinstance(model, str): model = model.name return self.model_graph.nodes[model][attribute] def set_model_attribute(self, model, attribute: str, val): if not isinstance(model, str): model = model.name self.model_graph.nodes[model][attribute] = val # Gets the minimum set of models that the provided model depends on, including itself # Returns a list of model names def get_minimum_model_set(self, model, include_self=True) -> list: if not isinstance(model, str): model = model.name minimum_model_set = list(nx.bfs_tree(self.model_graph, model, reverse=True)) if not include_self: minimum_model_set = [m for m in minimum_model_set if m != model] return minimum_model_set # Gets the minimum set of models that the provided models depend on, including themselves # Returns a list of model names def get_minimum_models_set(self, models: list) -> list: models_set = set() for model in models: models_set = models_set.union(self.get_minimum_model_set(model)) return list(models_set) # Gets the set of base models used directly by the provided model # Returns a list of model names def get_base_model_names(self, model) -> list: if not isinstance(model, str): model = model.name base_model_set = list(self.model_graph.predecessors(model)) return base_model_set def _get_banned_model_names(self) -> list: """Gets all model names which would cause model files to be overwritten if a new model was trained with the name""" return self.get_model_names() + list(self._extra_banned_names) def leaderboard(self, extra_info=False): model_names = self.get_model_names() score_val = [] fit_time_marginal = [] pred_time_val_marginal = [] stack_level = [] fit_time = [] pred_time_val = [] can_infer = [] fit_order = list(range(1, len(model_names)+1)) score_val_dict = self.get_models_attribute_dict('val_score') fit_time_marginal_dict = self.get_models_attribute_dict('fit_time') predict_time_marginal_dict = self.get_models_attribute_dict('predict_time') for model_name in model_names: score_val.append(score_val_dict[model_name]) fit_time_marginal.append(fit_time_marginal_dict[model_name]) fit_time.append(self.get_model_attribute_full(model=model_name, attribute='fit_time')) pred_time_val_marginal.append(predict_time_marginal_dict[model_name]) pred_time_val.append(self.get_model_attribute_full(model=model_name, attribute='predict_time')) stack_level.append(self.get_model_level(model_name)) can_infer.append(self.model_graph.nodes[model_name]['can_infer']) model_info_dict = defaultdict(list) if extra_info: # TODO: feature_metadata # TODO: disk size # TODO: load time # TODO: Add persist_if_mem_safe() function to persist in memory all models if reasonable memory size (or a specific model+ancestors) # TODO: Add is_persisted() function to check which models are persisted in memory # TODO: package_dependencies, package_dependencies_full info = self.get_info(include_model_info=True) model_info = info['model_info'] custom_model_info = {} for model_name in model_info: custom_info = {} bagged_info = model_info[model_name].get('bagged_info', {}) custom_info['num_models'] = bagged_info.get('num_child_models', 1) custom_info['memory_size'] = bagged_info.get('max_memory_size', model_info[model_name]['memory_size']) custom_info['memory_size_min'] = bagged_info.get('min_memory_size', model_info[model_name]['memory_size']) custom_info['child_model_type'] = bagged_info.get('child_model_type', None) custom_info['child_hyperparameters'] = bagged_info.get('child_hyperparameters', None) custom_info['child_hyperparameters_fit'] = bagged_info.get('child_hyperparameters_fit', None) custom_info['child_ag_args_fit'] = bagged_info.get('child_ag_args_fit', None) custom_model_info[model_name] = custom_info model_info_keys = ['num_features', 'model_type', 'hyperparameters', 'hyperparameters_fit', 'ag_args_fit', 'features'] model_info_sum_keys = [] for key in model_info_keys: model_info_dict[key] = [model_info[model_name][key] for model_name in model_names] if key in model_info_sum_keys: key_dict = {model_name: model_info[model_name][key] for model_name in model_names} model_info_dict[key + '_full'] = [self.get_model_attribute_full(model=model_name, attribute=key_dict) for model_name in model_names] model_info_keys = ['num_models', 'memory_size', 'memory_size_min', 'child_model_type', 'child_hyperparameters', 'child_hyperparameters_fit', 'child_ag_args_fit'] model_info_full_keys = {'memory_size': [('memory_size_w_ancestors', sum)], 'memory_size_min': [('memory_size_min_w_ancestors', max)], 'num_models': [('num_models_w_ancestors', sum)]} for key in model_info_keys: model_info_dict[key] = [custom_model_info[model_name][key] for model_name in model_names] if key in model_info_full_keys: key_dict = {model_name: custom_model_info[model_name][key] for model_name in model_names} for column_name, func in model_info_full_keys[key]: model_info_dict[column_name] = [self.get_model_attribute_full(model=model_name, attribute=key_dict, func=func) for model_name in model_names] ancestors = [list(nx.dag.ancestors(self.model_graph, model_name)) for model_name in model_names] descendants = [list(nx.dag.descendants(self.model_graph, model_name)) for model_name in model_names] model_info_dict['num_ancestors'] = [len(ancestor_lst) for ancestor_lst in ancestors] model_info_dict['num_descendants'] = [len(descendant_lst) for descendant_lst in descendants] model_info_dict['ancestors'] = ancestors model_info_dict['descendants'] = descendants df = pd.DataFrame(data={ 'model': model_names, 'score_val': score_val, 'pred_time_val': pred_time_val, 'fit_time': fit_time, 'pred_time_val_marginal': pred_time_val_marginal, 'fit_time_marginal': fit_time_marginal, 'stack_level': stack_level, 'can_infer': can_infer, 'fit_order': fit_order, **model_info_dict, }) df_sorted = df.sort_values(by=['score_val', 'pred_time_val', 'model'], ascending=[False, True, False]).reset_index(drop=True) df_columns_lst = df_sorted.columns.tolist() explicit_order = [ 'model', 'score_val', 'pred_time_val', 'fit_time', 'pred_time_val_marginal', 'fit_time_marginal', 'stack_level', 'can_infer', 'fit_order', 'num_features', 'num_models', 'num_models_w_ancestors', 'memory_size', 'memory_size_w_ancestors', 'memory_size_min', 'memory_size_min_w_ancestors', 'num_ancestors', 'num_descendants', 'model_type', 'child_model_type' ] explicit_order = [column for column in explicit_order if column in df_columns_lst] df_columns_other = [column for column in df_columns_lst if column not in explicit_order] df_columns_new = explicit_order + df_columns_other df_sorted = df_sorted[df_columns_new] return df_sorted def get_info(self, include_model_info=False) -> dict: num_models_trained = len(self.get_model_names()) if self.model_best is not None: best_model = self.model_best else: try: best_model = self.get_model_best() except AssertionError: best_model = None if best_model is not None: best_model_score_val = self.get_model_attribute(model=best_model, attribute='val_score') best_model_stack_level = self.get_model_level(best_model) else: best_model_score_val = None best_model_stack_level = None # fit_time = None num_bag_folds = self.k_fold max_core_stack_level = self.get_max_level('core') max_stack_level = self.get_max_level() problem_type = self.problem_type eval_metric = self.eval_metric.name time_train_start = self._time_train_start num_rows_train = self._num_rows_train num_cols_train = self._num_cols_train num_classes = self.num_classes # TODO: # Disk size of models # Raw feature count # HPO time # Bag time # Feature prune time # Exception count / models failed count # True model count (models * kfold) # AutoGluon version fit on # Max memory usage # CPU count used / GPU count used info = { 'time_train_start': time_train_start, 'num_rows_train': num_rows_train, 'num_cols_train': num_cols_train, 'num_classes': num_classes, 'problem_type': problem_type, 'eval_metric': eval_metric, 'best_model': best_model, 'best_model_score_val': best_model_score_val, 'best_model_stack_level': best_model_stack_level, 'num_models_trained': num_models_trained, 'num_bag_folds': num_bag_folds, 'max_stack_level': max_stack_level, 'max_core_stack_level': max_core_stack_level, } if include_model_info: info['model_info'] = self.get_models_info() return info def get_models_info(self, models: List[str] = None) -> dict: if models is None: models = self.get_model_names() model_info_dict = dict() for model in models: if isinstance(model, str): if model in self.models.keys(): model = self.models[model] if isinstance(model, str): model_type = self.get_model_attribute(model=model, attribute='type') model_path = self.get_model_attribute(model=model, attribute='path') model_info_dict[model] = model_type.load_info(path=model_path) else: model_info_dict[model.name] = model.get_info() return model_info_dict def reduce_memory_size(self, remove_data=True, remove_fit_stack=False, remove_fit=True, remove_info=False, requires_save=True, reduce_children=False, **kwargs): if remove_data and self.is_data_saved: data_files = [ self.path_data + 'X.pkl', self.path_data + 'X_val.pkl', self.path_data + 'y.pkl', self.path_data + 'y_val.pkl', ] for data_file in data_files: try: os.remove(data_file) except FileNotFoundError: pass if requires_save: self.is_data_saved = False try: os.rmdir(self.path_data) except OSError: pass try: os.rmdir(self.path_utils) except OSError: pass models = self.get_model_names() for model in models: model = self.load_model(model) model.reduce_memory_size(remove_fit_stack=remove_fit_stack, remove_fit=remove_fit, remove_info=remove_info, requires_save=requires_save, reduce_children=reduce_children, **kwargs) if requires_save: self.save_model(model, reduce_memory=False) if requires_save: self.save() # TODO: Also enable deletion of models which didn't succeed in training (files may still be persisted) # This includes the original HPO fold for stacking # Deletes specified models from trainer and from disk (if delete_from_disk=True). def delete_models(self, models_to_keep=None, models_to_delete=None, allow_delete_cascade=False, delete_from_disk=True, dry_run=True): if models_to_keep is not None and models_to_delete is not None: raise ValueError('Exactly one of [models_to_keep, models_to_delete] must be set.') if models_to_keep is not None: if not isinstance(models_to_keep, list): models_to_keep = [models_to_keep] minimum_model_set = set() for model in models_to_keep: minimum_model_set.update(self.get_minimum_model_set(model)) minimum_model_set = list(minimum_model_set) models_to_remove = [model for model in self.get_model_names() if model not in minimum_model_set] elif models_to_delete is not None: if not isinstance(models_to_delete, list): models_to_delete = [models_to_delete] minimum_model_set = set(models_to_delete) minimum_model_set_orig = copy.deepcopy(minimum_model_set) for model in models_to_delete: minimum_model_set.update(nx.algorithms.dag.descendants(self.model_graph, model)) if not allow_delete_cascade: if minimum_model_set != minimum_model_set_orig: raise AssertionError('models_to_delete contains models which cause a delete cascade due to other models being dependent on them. Set allow_delete_cascade=True to enable the deletion.') minimum_model_set = list(minimum_model_set) models_to_remove = [model for model in self.get_model_names() if model in minimum_model_set] else: raise ValueError('Exactly one of [models_to_keep, models_to_delete] must be set.') if dry_run: logger.log(30, f'Dry run enabled, AutoGluon would have deleted the following models: {models_to_remove}') if delete_from_disk: for model in models_to_remove: model = self.load_model(model) logger.log(30, f'\tDirectory {model.path} would have been deleted.') logger.log(30, f'To perform the deletion, set dry_run=False') return if delete_from_disk: for model in models_to_remove: model = self.load_model(model) model.delete_from_disk() self.model_graph.remove_nodes_from(models_to_remove) for model in models_to_remove: if model in self.models: self.models.pop(model) models_kept = self.get_model_names() if self.model_best is not None and self.model_best not in models_kept: try: self.model_best = self.get_model_best() except AssertionError: self.model_best = None # TODO: Delete from all the other model dicts self.save() @classmethod def load(cls, path, reset_paths=False): load_path = path + cls.trainer_file_name if not reset_paths: return load_pkl.load(path=load_path) else: obj = load_pkl.load(path=load_path) obj.set_contexts(path) obj.reset_paths = reset_paths return obj @classmethod def load_info(cls, path, reset_paths=False, load_model_if_required=True): load_path = path + cls.trainer_info_name try: return load_pkl.load(path=load_path) except: if load_model_if_required: trainer = cls.load(path=path, reset_paths=reset_paths) return trainer.get_info() else: raise def save_info(self, include_model_info=False): info = self.get_info(include_model_info=include_model_info) save_pkl.save(path=self.path + self.trainer_info_name, object=info) save_json.save(path=self.path + self.trainer_info_json_name, obj=info) return info def _process_hyperparameters(self, hyperparameters: dict) -> dict: return process_hyperparameters(hyperparameters=hyperparameters) def _get_full_model_val_score(self, model: str) -> float: model_full_dict_inverse = {full: orig for orig, full in self.model_full_dict.items()} model_performances = self.get_models_attribute_dict(attribute='val_score') normal_model = model_full_dict_inverse[model] if normal_model not in model_performances: # normal model is deleted if model not in self._model_full_dict_val_score: raise ValueError(f'_FULL model {model} had the model it was based on ({normal_model}) deleted, and the validation score was not stored.') val_score = self._model_full_dict_val_score[model] else: # normal model exists val_score = model_performances[normal_model] return val_score def distill(self, X=None, y=None, X_val=None, y_val=None, X_unlabeled=None, time_limit=None, hyperparameters=None, holdout_frac=None, verbosity=None, models_name_suffix=None, teacher=None, teacher_preds='soft', augmentation_data=None, augment_method='spunge', augment_args={'size_factor':5,'max_size':int(1e5)}, augmented_sample_weight=1.0): """ Various distillation algorithms. Args: X, y: pd.DataFrame and pd.Series of training data. If None, original training data used during predictor.fit() will be loaded. This data is split into train/validation if X_val, y_val are None. X_val, y_val: pd.DataFrame and pd.Series of validation data. time_limit, hyperparameters, holdout_frac: defined as in predictor.fit() teacher (None or str): If None, uses the model with the highest validation score as the teacher model, otherwise use the specified model name as the teacher. teacher_preds (None or str): If None, we only train with original labels (no data augmentation, overrides augment_method) If 'hard', labels are hard teacher predictions given by: teacher.predict() If 'soft', labels are soft teacher predictions given by: teacher.predict_proba() Note: 'hard' and 'soft' are equivalent for regression problems. If augment_method specified, teacher predictions are only used to label augmented data (training data keeps original labels). To apply label-smoothing: teacher_preds='onehot' will use original training data labels converted to one-hots for multiclass (no data augmentation). # TODO: expose smoothing-hyperparameter. models_name_suffix (str): Suffix to append to each student model's name, new names will look like: 'MODELNAME_dstl_SUFFIX' augmentation_data: pd.DataFrame of additional data to use as "augmented data" (does not contain labels). When specified, augment_method, augment_args are ignored, and this is the only augmented data that is used (teacher_preds cannot be None). augment_method (None or str): specifies which augmentation strategy to utilize. Options: [None, 'spunge','munge'] If None, no augmentation gets applied. } augment_args (dict): args passed into the augmentation function corresponding to augment_method. augmented_sample_weight (float): Nonnegative value indicating how much to weight augmented samples. This is only considered if sample_weight was initially specified in Predictor. """ if verbosity is None: verbosity = self.verbosity if teacher is None: teacher = self._get_best() hyperparameter_tune = False # TODO: add as argument with scheduler options. if augmentation_data is not None and teacher_preds is None: raise ValueError("augmentation_data must be None if teacher_preds is None") logger.log(20, f"Distilling with teacher='{teacher}', teacher_preds={str(teacher_preds)}, augment_method={str(augment_method)} ...") if teacher not in self.get_model_names(can_infer=True): raise AssertionError(f"Teacher model '{teacher}' is not a valid teacher model! Either it does not exist or it cannot infer on new data.\n" f"Valid teacher models: {self.get_model_names(can_infer=True)}") if X is None: if y is not None: raise ValueError("X cannot be None when y specified.") X = self.load_X() X_val = self.load_X_val() if y is None: y = self.load_y() y_val = self.load_y_val() if X_val is None: if y_val is not None: raise ValueError("X_val cannot be None when y_val specified.") if holdout_frac is None: holdout_frac = default_holdout_frac(len(X), hyperparameter_tune) X, X_val, y, y_val = generate_train_test_split(X, y, problem_type=self.problem_type, test_size=holdout_frac) y_val_og = y_val.copy() og_bagged_mode = self.bagged_mode og_verbosity = self.verbosity self.bagged_mode = False # turn off bagging self.verbosity = verbosity # change verbosity for distillation if self.sample_weight is not None: X, w = extract_column(X, self.sample_weight) if teacher_preds is None or teacher_preds == 'onehot': augment_method = None logger.log(20, "Training students without a teacher model. Set teacher_preds = 'soft' or 'hard' to distill using the best AutoGluon predictor as teacher.") if teacher_preds in ['onehot','soft']: y = format_distillation_labels(y, self.problem_type, self.num_classes) y_val = format_distillation_labels(y_val, self.problem_type, self.num_classes) if augment_method is None and augmentation_data is None: if teacher_preds == 'hard': y_pred = pd.Series(self.predict(X, model=teacher)) if (self.problem_type != REGRESSION) and (len(y_pred.unique()) < len(y.unique())): # add missing labels logger.log(15, "Adding missing labels to distillation dataset by including some real training examples") indices_to_add = [] for clss in y.unique(): if clss not in y_pred.unique(): logger.log(15, f"Fetching a row with label={clss} from training data") clss_index = y[y == clss].index[0] indices_to_add.append(clss_index) X_extra = X.loc[indices_to_add].copy() y_extra = y.loc[indices_to_add].copy() # these are actually real training examples X = pd.concat([X, X_extra]) y_pred = pd.concat([y_pred, y_extra]) if self.sample_weight is not None: w =
pd.concat([w, w[indices_to_add]])
pandas.concat
import os import pandas as pd from glob import glob path1 = "/home/lsh/PycharmProjects/Audio/data/Male speech, man speaking" path2 = "/home/lsh/PycharmProjects/Audio/data/Outside, rural or natural" path3 = "/home/lsh/PycharmProjects/Audio/data/snoring" path4 = "/home/lsh/PycharmProjects/Audio/data/Traffic noise, roadway noise" path5 = "/home/lsh/PycharmProjects/Audio/data/Vehicle" paths = [path1, path2, path3, path4, path5] df = pd.DataFrame() file_names = [] labels = [] for path in paths: file_names += os.listdir(path) if path == path3: labels += [3] * len(os.listdir(path)) elif path == path1: labels += [1] * len(os.listdir(path)) elif path == path2: labels += [2] * len(os.listdir(path)) elif path == path4: labels += [4] * len(os.listdir(path)) elif path == path5: labels += [5] * len(os.listdir(path)) df["file_name"] = file_names df["labels"] = labels print(len(file_names), len(labels)) print(df.head()) df.to_csv("audio.csv", index=False) df =
pd.read_csv("audio.csv")
pandas.read_csv
# -*- coding: utf-8 -*- import pytest import numpy as np from pandas.types.dtypes import DatetimeTZDtype, PeriodDtype, CategoricalDtype from pandas.types.common import pandas_dtype, is_dtype_equal import pandas.util.testing as tm class TestPandasDtype(tm.TestCase): def test_numpy_dtype(self): for dtype in ['M8[ns]', 'm8[ns]', 'object', 'float64', 'int64']: self.assertEqual(pandas_dtype(dtype), np.dtype(dtype)) def test_numpy_string_dtype(self): # do not parse freq-like string as period dtype self.assertEqual(pandas_dtype('U'), np.dtype('U')) self.assertEqual(pandas_dtype('S'), np.dtype('S')) def test_datetimetz_dtype(self): for dtype in ['datetime64[ns, US/Eastern]', 'datetime64[ns, Asia/Tokyo]', 'datetime64[ns, UTC]']: self.assertIs(pandas_dtype(dtype), DatetimeTZDtype(dtype)) self.assertEqual(pandas_dtype(dtype), DatetimeTZDtype(dtype)) self.assertEqual(pandas_dtype(dtype), dtype) def test_categorical_dtype(self): self.assertEqual(pandas_dtype('category'), CategoricalDtype()) def test_period_dtype(self): for dtype in ['period[D]', 'period[3M]', 'period[U]', 'Period[D]', 'Period[3M]', 'Period[U]']: self.assertIs(
pandas_dtype(dtype)
pandas.types.common.pandas_dtype
""" This script compares different reference systems against each other. """ from pipeline.reference_loader import ZebrisReferenceLoader, OptogaitReferenceLoader import matplotlib.pyplot as plt import matplotlib import pandas as pd import numpy as np from scipy import stats import statsmodels.api as sm from matplotlib.lines import Line2D def reg_line(x, y): """ Calculate regression line for data. Args: x (list[float]): data x values y (list[float]): data y values Returns: tuple(list[float], ...): x values of the regression line, y values of the regression line, calculated regression line parameters (gradient, intercept, r_value, p_value, std_err, rmse, mae), p-values of the statistical model, confidence interval """ gradient, intercept, r_value, p_value, std_err = stats.linregress(x, y) # get p values and CI for the gradient and intercept X = sm.add_constant(x) model = sm.OLS(y, X) results = model.fit() pvalues = results.pvalues conf_interval = results.conf_int(alpha=0.05, cols=None) # print('p values:') # print(results.pvalues) # print('confidence intervals:') # print(conf_interval) # calculate RMSE (root mean squared error) y_pred = gradient * x + intercept rmse = np.sqrt(np.mean((y_pred - y) ** 2)) # make a regression line mn = np.min(x) mx = np.max(x + 0.5) mn = 0 x1 = np.linspace(mn, mx, 500) y1 = gradient * x1 + intercept # summary line info line_info = [ round(gradient, 4), round(intercept, 4), round(r_value, 4), round(p_value, 4), round(std_err, 4), round(rmse, 4), ] return x1, y1, line_info, pvalues, conf_interval def detect_outlier( data, column, reference_column, z_threshold=3, maximum_deviation=0.25 ): """ Detect outliers based on z-score and maximum deviation. Args: data (DataFrame): DataFrame with the data column (str): name of the column under consideration reference_column (str): name of the reference column matching the data column z_threshold (float): cutoff value for z-score maximum_deviation (float): cutoff value for deviation between systems Returns: np.array: boolean vector indicating outliers """ column_diff = np.abs(data[column] - data[reference_column]) z_score_diff = np.abs(stats.zscore(column_diff)) # outlier = np.logical_or(z_score_diff > z_threshold, column_diff > maximum_deviation) outlier = z_score_diff > z_threshold return outlier def draw_reg_line_and_info(data, outlier, column, reference_column, axis): """ Plot regression line and parameters. Args: data (DataFrame): DataFrame with actual data outliers (np.array): Boolean array, indicating if the row is an outlier column (str): name of the column under consideration reference_column (str): name of the reference column matching the data column axis (matplotlib.axis): axis to plot on Returns: None """ x1, y1, info, pvalues, conf_interval = reg_line( data[np.logical_not(outlier)][column], data[np.logical_not(outlier)][reference_column], ) textstr = "\n".join( ( r"$n=%i$" % (len(data[np.logical_not(outlier)]),), r"$r=%.2f$" % (info[2],), r"$RMSE=%.2f$" % (info[5],), r"$y=%.2fx %+.2f$" % (info[0], info[1]), ) ) props = dict(boxstyle="square", facecolor="white", edgecolor="white", alpha=0) axis.text( 0.97, 0.03, textstr, fontsize=11, transform=axis.transAxes, verticalalignment="bottom", horizontalalignment="right", bbox=props, ) axis.plot(x1, y1) axis.plot(x1, x1, color="0.75") if __name__ == "__main__": config = { "name": "manual_threshold", # "raw_base_path": "./data/raw", "raw_base_path": "./example_data_/raw", # "interim_base_path": "./data/interim", "interim_base_path": "./example_data/interim", "overwrite": False, # "dataset": "TRIPOD", "dataset": "TRIPOD_excerpt", "subjects": [ # "Sub_DF", # "Sub_HA", # "Sub_PB", # "Sub_AL", # "Sub_EN", # "Sub_KP", # "Sub_RW", # "Sub_BK", "Sub_FZ", # "Sub_LU", # "Sub_SN", # "Sub_CP", # "Sub_GK", # "Sub_OD", # "Sub_YU", ], "runs": ["PWS", "PWS+20", "PWS-20"], "experiment_duration": 120, "plot_outlier": False, } plt.rcParams.update({"font.size": 12}) cmap = matplotlib.cm.get_cmap("jet") norm = matplotlib.colors.Normalize(vmin=0.0, vmax=len(config["subjects"]) - 0.99) all_data = pd.DataFrame() fig_sl, ax_sl = plt.subplots() # stride length fig_st, ax_st = plt.subplots() # stride time fig_swt, ax_swt = plt.subplots() # swing time fig_stt, ax_stt = plt.subplots() # stance time fig_td, ax_td = plt.subplots() # timestamp difference for subject_id, subject in enumerate(config["subjects"]): for run_id, run in enumerate(config["runs"]): zebris_data = ZebrisReferenceLoader( config["name"], config["raw_base_path"], config["interim_base_path"], config["dataset"], subject, run, config["overwrite"], ).get_data() optogait_data = OptogaitReferenceLoader( config["name"], config["raw_base_path"], config["interim_base_path"], config["dataset"], subject, run, config["overwrite"], ).get_data() merged = {"left": None, "right": None} for side in ["left", "right"]: zebris_data[side]["timestamp_zebris"] = zebris_data[side]["timestamp"] merged[side] = pd.merge_asof( left=optogait_data[side], right=zebris_data[side], on="timestamp", direction="nearest", tolerance=0.1, allow_exact_matches=True, ).dropna() merged[side] = merged[side][ merged[side]["timestamp"] < config["experiment_duration"] ] merged[side]["subject"] = subject_id merged[side]["run"] = run_id all_data =
pd.concat([all_data, merged[side]])
pandas.concat
# ___________________________________________________________________________ # # Prescient # Copyright 2020 National Technology & Engineering Solutions of Sandia, LLC # (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S. # Government retains certain rights in this software. # This software is distributed under the Revised BSD License. # ___________________________________________________________________________ """ sources.py This file will contain more general versions of data containers than the sources defined in uncertainty_sources.py. The main class that this module exports is the Source class which is intended to store data of any sort in a dataframe. This class should not be modified (unless there is a bug) to be made more specific; it should be subclassed. In addition, unless the method will obviously change the state of the object, all methods should produce new objects instead of modifying objects. """ import sys import datetime import numpy as np import matplotlib.pyplot as plt import pandas as pd import prescient.util.distributions.copula as copula from prescient.util.distributions.distributions import UnivariateEmpiricalDistribution from prescient.util.distributions.distributions import UnivariateEpiSplineDistribution import prescient.gosm.derivative_patterns.derivative_patterns as dp from prescient.gosm.markov_chains.states import State from prescient.gosm.sources.segmenter import Criterion power_sources = ['solar', 'wind', 'hydro'] recognized_sources = ['solar', 'wind', 'load', 'hydro'] # Default parameters for the non-required parameters for sources defaults = { 'is_deterministic': False, 'frac_nondispatch': 1, 'scaling_factor': 1, 'forecasts_as_actuals': False, 'aggregate': False, } class Source: """ This class should act as a container for all the data related to a single source. The data is stored internally in a Pandas Dataframe. This class should have methods for segmentation (more generally pick all datetimes that satisfy a certain a criterion) and selection. Attributes: name (str): The name of the source data (pd.DataFrame): The internal dataframe storing all the data source_type (str): The type of the source (wind, solar, load, etc.) Args: name (str): the name of the source dataframe (pd.DataFrame): The frame containing all the data source_type (str): the type of the source (e.g. 'solar') """ def __init__(self, name, dataframe, source_type): self.name = name self.data = dataframe # A little validation is done here # We check for duplicates if dataframe.index.duplicated().any(): duplicates = dataframe.index[dataframe.index.duplicated()] raise ValueError("Error: Source {} has duplicate datetimes at {}" .format(name, ", ".join(map(str, duplicates)))) self.source_type = source_type.lower() if source_type.lower() not in recognized_sources: raise ValueError("The source type '{}' is unrecognized, the only " "recognized sources are {}" .format(source_type, ", ".join(recognized_sources))) def check_for_column(self, column_name): """ This method will check if the source has a column with the name specified. If it doesn't it will raise a RuntimeError. Args: column_name (str): The name of the column to check """ if column_name not in self.data.columns: raise RuntimeError("Source {} has no '{}' column".format( self.name, column_name)) def window(self, column_name, lower_bound=-np.inf, upper_bound=np.inf): """ Finds the window of data such that the column value is between the two bounds specified. Returns a Source object with data contained in the window. The bounds are inclusive. Args: column_name (str): The name of the column lower_bound (float): The lower bound, if None, no lower bound upper_bound (float): The upper bound, if None, no upper bound Returns: Source: The window of data """ self.check_for_column(column_name) new_frame = self.data[(self.data[column_name] >= lower_bound) & (self.data[column_name] <= upper_bound)] return Source(self.name, new_frame, self.source_type) def enumerate(self, column_name, value): """ Finds the window of data such that the column field is equal to the value. Returns a Source object with the data contained in the window. Args: column_name (str): The name of the column value: The value you want all datetimes to have in the new window Returns: Source: The data will have all rows which match value """ self.check_for_column(column_name) new_frame = self.data[self.data[column_name] == value] return Source(self.name, new_frame, self.source_type) def rolling_window(self, day, historic_data_start=None, historic_data_end=None): """ Creates a Rolling Window of data which contains a historic dataframe and a dayahead dataframe. The historic data is all data up to the day and the dayahead data is the data for that day. Using non-datetime objects (pd.TimeStamp, strings, np.datetime64) probably works but not guaranteed. This is contingent on pandas datetime indexing. Args: day (datetime.datetime): The datetime referring to hour zero of the desired day to create a window up to that day historic_data_start (datetime.datetime): The datetime of the start of the historic data, if None just use start of data historic_data_end (datetime.datetime): The datetime of the end of the historic data, if None draws up to the day passed Returns: RollingWindow: The rolling window of data """ # If start not specified, we take the first date in dataframe if historic_data_start is None: historic_data_start = min(self.data.index) # If end not specified, we take last date before the passed in day if historic_data_end is None: historic_data_end = day - datetime.timedelta(hours=1) historic_frame = self.data[historic_data_start:historic_data_end] dayahead_frame = self.data[day:day+datetime.timedelta(hours=23)] # This suppresses warnings, This should return a copy anyways, so don't # need a warning. historic_frame.is_copy = False dayahead_frame.is_copy = False return RollingWindow(self.name, historic_frame, self.source_type, dayahead_frame) def solar_window(self, day, historic_data_start=None, historic_data_end=None): """ Creates a SolarWindow of data which contains a historic dataframe and a dayahead dataframe. The historic data is all data up to the day and the dayahead data is the data for that day. Using non-datetime objects (pd.TimeStamp, strings, np.datetime64) probably works but not guaranteed. This is contingent on pandas datetime indexing. Args: day (datetime.datetime): The datetime referring to hour zero of the desired day to create a window up to that day historic_data_start (datetime.datetime): The datetime of the start of the historic data, if None just use start of data historic_data_end (datetime.datetime): The datetime of the end of the historic data, if None draws up to the day passed Returns: SolarWindow: The rolling window of data """ window = self.rolling_window(day, historic_data_start, historic_data_end) return window.solar_window() def add_column(self, column_name, series): """ Adds a column of data to the dataframe. This data should be indexed by datetime. Args: column_name (str): The name of the column to add series (pd.Series or dict[datetime.datetime,value]): The data indexed by datetime to add to the dataset """ self.data[column_name] = pd.Series(series) def get_day_of_data(self, column_name, day): """ This function returns a pandas Series of all the data in the column with the specific day as an index. Args: column_name (str): The desired column day (datetime-like): the day, which can be coerced into a pd.Timestamp Returns: pd.Series: A series of relevant data """ self.check_for_column(column_name) dt = pd.Timestamp(day) column = self.data[column_name] return column[column.index.date == dt.date()] def get(self, column_name, row_index): """ Get the value stored in column specified by column_name and the row specified by the row_index Args: column_name (str): The name of the column row_index (datetime.datetime): The datetime for which you want data """ self.check_for_column(column_name) return self.data[column_name][row_index] def get_column(self, column_name): """ Returns the column of data with that column name. This will also return a column without any nan values. Args: column_name (str): The name of the column Returns: pd.Series: The requested column """ self.check_for_column(column_name) return self.data[column_name].dropna() def get_state_walk(self, state_description, class_=State): """ This method should walk through the datetimes and construct a sequence of the different states of the historic data. The specification for what constitutes a state is passed in the state_description argument. Args: state_description (StateDescription): Specification for determining what the state for each datetime is class_ (Class): The type of state you wish to instantiate Returns: A dictionary of mapping datetimes to states constituting the walk """ states = {} names = state_description.keys() for dt in self.data.index: name_value_mapping = {name: self.get(name, dt) for name in names} states[dt] = state_description.to_state(class_, **name_value_mapping) return states def get_state(self, state_description, dt, class_=State): """ This method should create the state for a specific datetime. The specification for what constitutes a state is passed in the state_description argument. Args: state_description (StateDescription): Specification for determining what the state for each datetime is dt (datetime.datetime): The relevant datetime class_ (Class): The type of state you wish to instantiate Returns: State: The state of the datetime """ dt =
pd.Timestamp(dt)
pandas.Timestamp
# AUTOGENERATED! DO NOT EDIT! File to edit: utilities.ipynb (unless otherwise specified). __all__ = ['make_codes', 'make_data', 'get_rows', 'extract_codes', 'Info', 'memory', 'listify', 'reverse_dict', 'del_dot', 'del_zero', 'expand_hyphen', 'expand_star', 'expand_colon', 'expand_regex', 'expand_code', 'expand_columns', 'format_codes', 'insert_external', 'unique', 'count_codes', 'lookup_codes', 'get_codes'] # Cell import re import numpy as np import pandas as pd from functools import singledispatch # Cell def make_codes(n=100, letters=26, numbers=100, seed=False): """ Generate a dataframe with a column of random codes Args: letters (int): The number of different letters to use numbers (int): The number of different numbers to use Returns A dataframe with a column with one or more codes in the rows """ # each code is assumed to consist of a letter and a number alphabet = list('abcdefghigjklmnopqrstuvwxyz') letters=alphabet[:letters+1] # make random numbers same if seed is specified if seed: np.random.seed(0) # determine the number of codes to be drawn for each event n_codes=np.random.negative_binomial(1, p=0.3, size=n) # avoid zero (all events have to have at least one code) n_codes=n_codes+1 # for each event, randomly generate a the number of codes specified by n_codes codes=[] for i in n_codes: diag = [np.random.choice(letters).upper()+ str(int(np.random.uniform(low=1, high=numbers))) for num in range(i)] code_string=','.join(diag) codes.append(code_string) # create a dataframe based on the list df=pd.DataFrame(codes) df.columns=['code'] return df # Cell def make_data(n=100, letters=26, numbers=100, seed=False, expand=False, columns=['pid', 'gender', 'birth_date', 'date', 'region', 'codes']): """ Generate a dataframe with a column of random codes Args: letters (int): The number of different letters to use numbers (int): The number of different numbers to use Returns A dataframe with a column with one or more codes in the rows Examples >>>df = make_data(n=100, letters=5, numbers=5, seed=True) """ if seed: np.random.seed(seed=seed) pid = range(n) df_person=pd.DataFrame(index = pid) #female = np.random.binomial(1, 0.5, size =n) gender = np.random.choice(['male', 'female'], size=n) region = np.random.choice(['north', 'south', 'east', 'west'], size=n) birth_year = np.random.randint(1920, 2019, size=n) birth_month = np.random.randint(1,12, size=n) birth_day = np.random.randint(1,28, size=n) # ok, I know! events_per_year = np.random.poisson(1, size=n) years = 2020 - birth_year events = years * events_per_year events = np.where(events==0,1,events) events = events.astype(int) all_codes=[] codes = [all_codes.extend(make_codes(n=n, letters=letters, numbers=numbers, seed=seed)['code'].tolist()) for n in events] days_alive = (2020 - birth_year) *365 days_and_events = zip(days_alive.tolist(), events.tolist()) all_days=[] days_after_birth = [all_days.extend(np.random.randint(0, max_day, size=n)) for max_day, n in days_and_events] pid_and_events = zip(list(pid), events.tolist()) all_pids=[] pids = [all_pids.extend([p+1]*e) for p, e in pid_and_events] df_events = pd.DataFrame(index=all_pids) df_events['codes'] = all_codes df_events['days_after'] = all_days #df_person['female'] = female df_person['gender'] = gender df_person['region'] = region df_person['year'] = birth_year df_person['month'] = birth_month df_person['day'] = birth_day df = df_events.merge(df_person, left_index=True, right_index=True) df['birth_date'] = pd.to_datetime(df[['year', 'month', 'day']]) df['date'] = df['birth_date'] +
pd.to_timedelta(df.days_after, unit='d')
pandas.to_timedelta
import itertools from typing import Dict, List, Set, Sequence import pandas as pd from sudoku_solver.board.houses import Row, Column, Block, House, HouseType from sudoku_solver.board.cell import Cell from sudoku_solver.board.observable import SudokuObservable from sudoku_solver.board.board_constants import HORIZONTAL_INDEXES, VERTICAL_INDEXES from sudoku_solver.shared.puzzle import SudokuPuzzle class Board(SudokuObservable): def __init__(self, prefilled_values: SudokuPuzzle): super().__init__() # make sure they're sorted self.rows: Dict[int, Row] = {y: Row(y=y) for y in range(1, 10)} self.columns: Dict[int, Column] = {x: Column(x=x) for x in range(1, 10)} self.blocks: Dict[int, Block] = {z: Block(z=z) for z in range(1, 10)} self._initialize_cells(prefilled_values=prefilled_values) def _initialize_cells(self, prefilled_values: SudokuPuzzle): # loop at all cell positions and instantiate all cells cells = [] for position in itertools.product(HORIZONTAL_INDEXES, VERTICAL_INDEXES): cell = Cell(x=position[1], y=position[0], prefilled_value=prefilled_values.get(x=position[1], y=position[0])) cells.append(cell) # fill cells into their respective row, column, and block # also attach the container to the cell for cross-navigation for cell in cells: self.rows[cell.y].initialize_cell(cell) self.columns[cell.x].initialize_cell(cell) self.blocks[cell.z].initialize_cell(cell) assert len(self.rows) == 9 assert len(self.columns) == 9 assert len(self.blocks) == 9 def get_cell(self, y: int, x: int) -> Cell: all_cells = self.get_cells() cells = [c for c in all_cells if c.x == x and c.y == y] assert len(cells) == 1 return cells[0] def substribe_observer_to_cells(self, observer_finishing_value: callable, observer_invalidating_candidate: callable): """subscribe an observer (GUI) to all cells. They will emit changes to candidates and invalidated candidates""" for cell in self.get_cells(): cell.subscribe_to_finished_values(observer=observer_finishing_value) cell.subscribe_to_invalidated_candidates(observer=observer_invalidating_candidate) def as_df(self, mode='candidates') -> pd.DataFrame: series = {} for x, column in self.columns.items(): series[x] = column.as_series(mode=mode) return
pd.DataFrame(data=series)
pandas.DataFrame
# -*- coding: utf-8 -*- import numpy import pandas import matplotlib.pyplot as plt from sklearn import preprocessing from keras.models import Sequential from keras.layers.core import Dense, Activation from keras.layers.recurrent import LSTM class Prediction : def __init__(self): self.length_of_sequences = 10 self.in_out_neurons = 1 self.hidden_neurons = 300 def load_data(self, data, n_prev=10): X, Y = [], [] for i in range(len(data) - n_prev): X.append(data.iloc[i:(i+n_prev)].as_matrix()) Y.append(data.iloc[i+n_prev].as_matrix()) retX = numpy.array(X) retY = numpy.array(Y) return retX, retY def create_model(self) : model = Sequential() model.add(LSTM(self.hidden_neurons, batch_input_shape=(None, self.length_of_sequences, self.in_out_neurons), return_sequences=False)) model.add(Dense(self.in_out_neurons)) model.add(Activation("linear")) model.compile(loss="mape", optimizer="adam") return model def train(self, X_train, y_train) : model = self.create_model() # 学習 model.fit(X_train, y_train, batch_size=10, nb_epoch=100) return model if __name__ == "__main__": prediction = Prediction() # データ準備 data = None brand_num = 1332 for year in range(2014, 2018): data_ = pandas.read_csv('../stock_data/adopted_nikkeiheikin/{}/only_closing_stock_data_with_date/only_closing_stock_data_with_date_{}.csv'.format(year, brand_num)) #data_ = pandas.read_csv('csv/indices_I101_1d_' + str(year) + '.csv') data = data_ if (data is None) else pandas.concat([data, data_]) #data.columns = ['date', 'close'] data['date'] = pandas.to_datetime(data['date']) # 終値のデータを標準化 data['close'] = preprocessing.scale(data['closing price']) data = data.sort_values(by='date') data = data.reset_index(drop=True) data = data.loc[:, ['date', 'close']] # 2割をテストデータへ split_pos = int(len(data) * 0.9) x_train, y_train = prediction.load_data(data[['close']].iloc[0:split_pos], prediction.length_of_sequences) x_test, y_test = prediction.load_data(data[['close']].iloc[split_pos:], prediction.length_of_sequences) print("a : {}\nb : {}\nc : {}\nd : {}".format(x_train, y_train, x_test, y_test)) exit() model = prediction.train(x_train, y_train) predicted = model.predict(x_test) result =
pandas.DataFrame(predicted)
pandas.DataFrame
''' Multiple agent for anomaly detection file ''' import numpy as np import pandas as pd import matplotlib.pyplot as plt from keras.models import Sequential from keras.layers.core import Dense from tensorflow.keras import optimizers from keras import backend as K import json from sklearn.utils import shuffle import os import sys import time ''' Data class processing ''' class data_cls: def __init__(self,train_test,**kwargs): col_names = ["duration","protocol_type","service","flag","src_bytes", "dst_bytes","land_f","wrong_fragment","urgent","hot","num_failed_logins", "logged_in","num_compromised","root_shell","su_attempted","num_root", "num_file_creations","num_shells","num_access_files","num_outbound_cmds", "is_host_login","is_guest_login","count","srv_count","serror_rate", "srv_serror_rate","rerror_rate","srv_rerror_rate","same_srv_rate", "diff_srv_rate","srv_diff_host_rate","dst_host_count","dst_host_srv_count", "dst_host_same_srv_rate","dst_host_diff_srv_rate","dst_host_same_src_port_rate", "dst_host_srv_diff_host_rate","dst_host_serror_rate","dst_host_srv_serror_rate", "dst_host_rerror_rate","dst_host_srv_rerror_rate","labels","dificulty"] self.index = 0 # Data formated path and test path. self.loaded = False self.train_test = train_test self.train_path = kwargs.get('train_path', '../../datasets/NSL/KDDTrain+.txt') self.test_path = kwargs.get('test_path','../../datasets/NSL/KDDTest+.txt') self.formated_train_path = kwargs.get('formated_train_path', "../../datasets/formated/formated_train_adv.data") self.formated_test_path = kwargs.get('formated_test_path', "../../datasets/formated/formated_test_adv.data") self.attack_types = ['normal','DoS','Probe','R2L','U2R'] self.attack_names = [] self.attack_map = { 'normal': 'normal', 'back': 'DoS', 'land': 'DoS', 'neptune': 'DoS', 'pod': 'DoS', 'smurf': 'DoS', 'teardrop': 'DoS', 'mailbomb': 'DoS', 'apache2': 'DoS', 'processtable': 'DoS', 'udpstorm': 'DoS', 'ipsweep': 'Probe', 'nmap': 'Probe', 'portsweep': 'Probe', 'satan': 'Probe', 'mscan': 'Probe', 'saint': 'Probe', 'ftp_write': 'R2L', 'guess_passwd': '<PASSWORD>', 'imap': 'R2L', 'multihop': 'R2L', 'phf': 'R2L', 'spy': 'R2L', 'warezclient': 'R2L', 'warezmaster': 'R2L', 'sendmail': 'R2L', 'named': 'R2L', 'snmpgetattack': 'R2L', 'snmpguess': 'R2L', 'xlock': 'R2L', 'xsnoop': 'R2L', 'worm': 'R2L', 'buffer_overflow': 'U2R', 'loadmodule': 'U2R', 'perl': 'U2R', 'rootkit': 'U2R', 'httptunnel': 'U2R', 'ps': 'U2R', 'sqlattack': 'U2R', 'xterm': 'U2R' } self.all_attack_names = list(self.attack_map.keys()) formated = False # Test formated data exists if os.path.exists(self.formated_train_path) and os.path.exists(self.formated_test_path): formated = True self.formated_dir = "../../datasets/formated/" if not os.path.exists(self.formated_dir): os.makedirs(self.formated_dir) # If it does not exist, it's needed to format the data if not formated: ''' Formating the dataset for ready-2-use data''' self.df = pd.read_csv(self.train_path,sep=',',names=col_names,index_col=False) if 'dificulty' in self.df.columns: self.df.drop('dificulty', axis=1, inplace=True) #in case of difficulty data2 = pd.read_csv(self.test_path,sep=',',names=col_names,index_col=False) if 'dificulty' in data2: del(data2['dificulty']) train_indx = self.df.shape[0] frames = [self.df,data2] self.df = pd.concat(frames) # Dataframe processing self.df = pd.concat([self.df.drop('protocol_type', axis=1), pd.get_dummies(self.df['protocol_type'])], axis=1) self.df = pd.concat([self.df.drop('service', axis=1), pd.get_dummies(self.df['service'])], axis=1) self.df = pd.concat([self.df.drop('flag', axis=1), pd.get_dummies(self.df['flag'])], axis=1) # 1 if ``su root'' command attempted; 0 otherwise self.df['su_attempted'] = self.df['su_attempted'].replace(2.0, 0.0) # One hot encoding for labels self.df = pd.concat([self.df.drop('labels', axis=1), pd.get_dummies(self.df['labels'])], axis=1) # Normalization of the df #normalized_df=(df-df.mean())/df.std() for indx,dtype in self.df.dtypes.iteritems(): if dtype == 'float64' or dtype == 'int64': if self.df[indx].max() == 0 and self.df[indx].min()== 0: self.df[indx] = 0 else: self.df[indx] = (self.df[indx]-self.df[indx].min())/(self.df[indx].max()-self.df[indx].min()) # Save data test_df = self.df.iloc[train_indx:self.df.shape[0]] test_df = shuffle(test_df,random_state=np.random.randint(0,100)) self.df = self.df[:train_indx] self.df = shuffle(self.df,random_state=np.random.randint(0,100)) test_df.to_csv(self.formated_test_path,sep=',',index=False) self.df.to_csv(self.formated_train_path,sep=',',index=False) # Create a list with the existent attacks in the df for att in self.attack_map: if att in self.df.columns: # Add only if there is exist at least 1 if np.sum(self.df[att].values) > 1: self.attack_names.append(att) def get_shape(self): if self.loaded is False: self._load_df() self.data_shape = self.df.shape # stata + labels return self.data_shape ''' Get n-rows from loaded data The dataset must be loaded in RAM ''' def get_batch(self,batch_size=100): if self.loaded is False: self._load_df() # Read the df rows indexes = list(range(self.index,self.index+batch_size)) if max(indexes)>self.data_shape[0]-1: dif = max(indexes)-self.data_shape[0] indexes[len(indexes)-dif-1:len(indexes)] = list(range(dif+1)) self.index=batch_size-dif batch = self.df.iloc[indexes] else: batch = self.df.iloc[indexes] self.index += batch_size labels = batch[self.attack_names] batch = batch.drop(self.all_attack_names,axis=1) return batch,labels def get_full(self): if self.loaded is False: self._load_df() labels = self.df[self.attack_names] batch = self.df.drop(self.all_attack_names,axis=1) return batch,labels ''' Get n-row batch from the dataset Return: df = n-rows labels = correct labels for detection Sequential for largest datasets ''' # def get_sequential_batch(self, batch_size=100): # if self.loaded is False: # self.df = pd.read_csv(self.formated_path,sep=',', nrows = batch_size) # self.loaded = True # else: # self.df = pd.read_csv(self.formated_path,sep=',', nrows = batch_size, # skiprows = self.index) # # self.index += batch_size # # labels = self.df[self.attack_types] # for att in self.attack_names: # if att in self.df.columns: # del(self.df[att]) # return self.df,labels def _load_df(self): if self.train_test == 'train': self.df = pd.read_csv(self.formated_train_path,sep=',') # Read again the csv else: self.df =
pd.read_csv(self.formated_test_path,sep=',')
pandas.read_csv
""" Copyright 2020 Samsung SDS 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 in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. """ from brightics.common.repr import BrtcReprBuilder, strip_margin, pandasDF2MD, dict2MD from brightics.function.utils import _model_dict from brightics.common.utils import check_required_parameters from brightics.common.utils import get_default_from_parameters_if_required from brightics.common.validation import validate, greater_than_or_equal_to from brightics.common.exception import BrighticsFunctionException from sklearn.preprocessing import normalize import numpy as np import pandas as pd from .short_text_topic_modeling_gsdmm import gsdmm_rwalk import functools import pyLDAvis def gsdmm(table, **params): check_required_parameters(_gsdmm, params, ['table']) params = get_default_from_parameters_if_required(params, _gsdmm) param_validation_check = [greater_than_or_equal_to(params, 2, 'K'), greater_than_or_equal_to(params, 0.0, 'alpha'), greater_than_or_equal_to(params, 0.0, 'beta'), greater_than_or_equal_to(params, 1, 'max_iter'), greater_than_or_equal_to(params, 1, 'num_topic_words')] validate(*param_validation_check) return _gsdmm(table, **params) def _count_to_ratio_raw(word_count): if not word_count: return {} else: word_count_list = word_count.items() words = [pair[0] for pair in word_count_list] counts = [[pair[1]] for pair in word_count_list] counts_normalized = normalize(counts, norm='l1', axis=0) word_ratio_raw = {word: ratio[0] for word, ratio in zip(words, counts_normalized)} return word_ratio_raw def _gen_table(word_ratio_raw, num_topic_words): if not word_ratio_raw: return [""] else: word_ratio_sorted = sorted(word_ratio_raw.items(), key=lambda item: item[1], reverse=True) word_ratio = [["{}: {}".format(word, ratio), word, ratio] for word, ratio in word_ratio_sorted] return np.transpose(word_ratio[:num_topic_words]).tolist() def _gsdmm(table, input_col, topic_name='topic', K=10, alpha=0.1, beta=0.1, max_iter=50, num_topic_words=3): docs = np.array(table[input_col]) docs_set = [set(doc) for doc in docs] docs_preprocessed = [list(doc_set) for doc_set in docs_set] vocab_set = list(set.union(*docs_set)) vocab_size = len(vocab_set) # initialize and train a GSDMM model mgp = gsdmm_rwalk.MovieGroupProcess(K=K, alpha=alpha, beta=beta, n_iters=max_iter) topics = mgp.fit(docs_preprocessed, vocab_size) # generate topic table topic_word_count = mgp.cluster_word_distribution topic_words_raw = [[ind, _count_to_ratio_raw(word_count)] for ind, word_count in enumerate(topic_word_count) if word_count] topic_words = [[item[0]] + _gen_table(item[1], num_topic_words) for item in topic_words_raw] # reset topic ids nonempty_topic_indices = [item[0] for item in topic_words] reset_topic_ind = {old_ind: (new_ind + 1) for new_ind, old_ind in enumerate(nonempty_topic_indices)} topics = [reset_topic_ind[old_ind] for old_ind in topics] topic_words = [[reset_topic_ind[old_item[0]]] + old_item[1:] for old_item in topic_words] # generate output dataframes out_table = pd.DataFrame.copy(table, deep=True) if topic_name in table.columns: raise BrighticsFunctionException.from_errors( [{'0100': "Existing table contains the topic column name. Please choose another name."}]) out_table[topic_name] = topics columns = ['index', 'vocabularies_weights', 'vocabularies', 'weights'] topic_table =
pd.DataFrame(topic_words, columns=columns)
pandas.DataFrame
import pandas as pd from sklearn.model_selection import train_test_split print('Preprocessing csvs...') # load data path = 'data/{}_paired.tsv' train_path = path.format('train') val_path = path.format('dev') test_path = path.format('test') train_df = pd.read_table(train_path) val_df =
pd.read_table(val_path)
pandas.read_table
import pandas as pd import numpy as np import requests import warnings import scipy as sp from scipy import stats try: import sklearn except ImportError: sklearn = False else: from sklearn.decomposition import PCA try: from StringIO import StringIO except ImportError: from io import StringIO from . import filters, process from .utils import get_protein_id def correlation(df, rowvar=False): """ Calculate column-wise Pearson correlations using ``numpy.ma.corrcoef`` Input data is masked to ignore NaNs when calculating correlations. Data is returned as a Pandas ``DataFrame`` of column_n x column_n dimensions, with column index copied to both axes. :param df: Pandas DataFrame :return: Pandas DataFrame (n_columns x n_columns) of column-wise correlations """ # Create a correlation matrix for all correlations # of the columns (filled with na for all values) df = df.copy() maskv = np.ma.masked_where(np.isnan(df.values), df.values) cdf = np.ma.corrcoef(maskv, rowvar=False) cdf = pd.DataFrame(np.array(cdf)) cdf.columns = df.columns cdf.index = df.columns cdf = cdf.sort_index(level=0, axis=1) cdf = cdf.sort_index(level=0) return cdf def pca(df, n_components=2, mean_center=False, **kwargs): """ Principal Component Analysis, based on `sklearn.decomposition.PCA` Performs a principal component analysis (PCA) on the supplied dataframe, selecting the first ``n_components`` components in the resulting model. The model scores and weights are returned. For more information on PCA and the algorithm used, see the `scikit-learn documentation <http://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html>`_. :param df: Pandas ``DataFrame`` to perform the analysis on :param n_components: ``int`` number of components to select :param mean_center: ``bool`` mean center the data before performing PCA :param kwargs: additional keyword arguments to `sklearn.decomposition.PCA` :return: scores ``DataFrame`` of PCA scores n_components x n_samples weights ``DataFrame`` of PCA weights n_variables x n_components """ if not sklearn: assert('This library depends on scikit-learn (sklearn) to perform PCA analysis') from sklearn.decomposition import PCA df = df.copy() # We have to zero fill, nan errors in PCA df[ np.isnan(df) ] = 0 if mean_center: mean = np.mean(df.values, axis=0) df = df - mean pca = PCA(n_components=n_components, **kwargs) pca.fit(df.values.T) scores = pd.DataFrame(pca.transform(df.values.T)).T scores.index = ['Principal Component %d (%.2f%%)' % ( (n+1), pca.explained_variance_ratio_[n]*100 ) for n in range(0, scores.shape[0])] scores.columns = df.columns weights = pd.DataFrame(pca.components_).T weights.index = df.index weights.columns = ['Weights on Principal Component %d' % (n+1) for n in range(0, weights.shape[1])] return scores, weights def plsda(df, a, b, n_components=2, mean_center=False, scale=True, **kwargs): """ Partial Least Squares Discriminant Analysis, based on `sklearn.cross_decomposition.PLSRegression` Performs a binary group partial least squares discriminant analysis (PLS-DA) on the supplied dataframe, selecting the first ``n_components``. Sample groups are defined by the selectors ``a`` and ``b`` which are used to select columns from the supplied dataframe. The result model is applied to the entire dataset, projecting non-selected samples into the same space. For more information on PLS regression and the algorithm used, see the `scikit-learn documentation <http://scikit-learn.org/stable/modules/generated/sklearn.cross_decomposition.PLSRegression.html>`_. :param df: Pandas ``DataFrame`` to perform the analysis on :param a: Column selector for group a :param b: Column selector for group b :param n_components: ``int`` number of components to select :param mean_center: ``bool`` mean center the data before performing PLS regression :param kwargs: additional keyword arguments to `sklearn.cross_decomposition.PLSRegression` :return: scores ``DataFrame`` of PLSDA scores n_components x n_samples weights ``DataFrame`` of PLSDA weights n_variables x n_components """ if not sklearn: assert('This library depends on scikit-learn (sklearn) to perform PLS-DA') from sklearn.cross_decomposition import PLSRegression df = df.copy() # We have to zero fill, nan errors in PLSRegression df[ np.isnan(df) ] = 0 if mean_center: mean = np.mean(df.values, axis=0) df = df - mean sxa, _ = df.columns.get_loc_level(a) sxb, _ = df.columns.get_loc_level(b) dfa = df.iloc[:, sxa] dfb = df.iloc[:, sxb] dff = pd.concat([dfa, dfb], axis=1) y = np.ones(dff.shape[1]) y[np.arange(dfa.shape[1])] = 0 plsr = PLSRegression(n_components=n_components, scale=scale, **kwargs) plsr.fit(dff.values.T, y) # Apply the generated model to the original data x_scores = plsr.transform(df.values.T) scores = pd.DataFrame(x_scores.T) scores.index = ['Latent Variable %d' % (n+1) for n in range(0, scores.shape[0])] scores.columns = df.columns weights = pd.DataFrame(plsr.x_weights_) weights.index = df.index weights.columns = ['Weights on Latent Variable %d' % (n+1) for n in range(0, weights.shape[1])] loadings = pd.DataFrame(plsr.x_loadings_) loadings.index = df.index loadings.columns = ['Loadings on Latent Variable %d' % (n+1) for n in range(0, loadings.shape[1])] return scores, weights, loadings def plsr(df, v, n_components=2, mean_center=False, scale=True, **kwargs): """ Partial Least Squares Regression Analysis, based on `sklearn.cross_decomposition.PLSRegression` Performs a partial least squares regression (PLS-R) on the supplied dataframe ``df`` against the provided continuous variable ``v``, selecting the first ``n_components``. For more information on PLS regression and the algorithm used, see the `scikit-learn documentation <http://scikit-learn.org/stable/modules/generated/sklearn.cross_decomposition.PLSRegression.html>`_. :param df: Pandas ``DataFrame`` to perform the analysis on :param v: Continuous variable to perform regression against :param n_components: ``int`` number of components to select :param mean_center: ``bool`` mean center the data before performing PLS regression :param kwargs: additional keyword arguments to `sklearn.cross_decomposition.PLSRegression` :return: scores ``DataFrame`` of PLS-R scores n_components x n_samples weights ``DataFrame`` of PLS-R weights n_variables x n_components """ if not sklearn: assert('This library depends on scikit-learn (sklearn) to perform PLS-DA') from sklearn.cross_decomposition import PLSRegression df = df.copy() # We have to zero fill, nan errors in PLSRegression df[ np.isnan(df) ] = 0 if mean_center: mean = np.mean(df.values, axis=0) df = df - mean #TODO: Extract values if v is DataFrame? plsr = PLSRegression(n_components=n_components, scale=scale, **kwargs) plsr.fit(df.values.T, v) scores = pd.DataFrame(plsr.x_scores_.T) scores.index = ['Latent Variable %d' % (n+1) for n in range(0, scores.shape[0])] scores.columns = df.columns weights = pd.DataFrame(plsr.x_weights_) weights.index = df.index weights.columns = ['Weights on Latent Variable %d' % (n+1) for n in range(0, weights.shape[1])] loadings = pd.DataFrame(plsr.x_loadings_) loadings.index = df.index loadings.columns = ['Loadings on Latent Variable %d' % (n+1) for n in range(0, loadings.shape[1])] #r = plsr.score(df.values.T, v) predicted = plsr.predict(df.values.T) return scores, weights, loadings, predicted def _non_zero_sum(df): # Following is just to build the template; actual calculate below dfo = df.sum(axis=0, level=0) for c in df.columns.values: dft = df[c] dfo[c] = dft[ dft > 0].sum(axis=0, level=0) return dfo def enrichment_from_evidence(dfe, modification="Phospho (STY)"): """ Calculate relative enrichment of peptide modifications from evidence.txt. Taking a modifiedsitepeptides ``DataFrame`` returns the relative enrichment of the specified modification in the table. The returned data columns are generated from the input data columns. :param df: Pandas ``DataFrame`` of evidence :return: Pandas ``DataFrame`` of percentage modifications in the supplied data. """ dfe = dfe.reset_index().set_index('Experiment') dfe['Modifications'] = np.array([modification in m for m in dfe['Modifications']]) dfe = dfe.set_index('Modifications', append=True) dfes = dfe.sum(axis=0, level=[0,1]).T columns = dfes.sum(axis=1, level=0).columns total = dfes.sum(axis=1, level=0).values.flatten() # Total values modified = dfes.iloc[0, dfes.columns.get_level_values('Modifications').values ].values # Modified enrichment = modified / total return pd.DataFrame([enrichment], columns=columns, index=['% Enrichment']) def enrichment_from_msp(dfmsp, modification="Phospho (STY)"): """ Calculate relative enrichment of peptide modifications from modificationSpecificPeptides.txt. Taking a modifiedsitepeptides ``DataFrame`` returns the relative enrichment of the specified modification in the table. The returned data columns are generated from the input data columns. :param df: Pandas ``DataFrame`` of modificationSpecificPeptides :return: Pandas ``DataFrame`` of percentage modifications in the supplied data. """ dfmsp['Modifications'] = np.array([modification in m for m in dfmsp['Modifications']]) dfmsp = dfmsp.set_index(['Modifications']) dfmsp = dfmsp.filter(regex='Intensity ') dfmsp[ dfmsp == 0] = np.nan df_r = dfmsp.sum(axis=0, level=0) modified = df_r.loc[True].values total = df_r.sum(axis=0).values enrichment = modified / total return pd.DataFrame([enrichment], columns=dfmsp.columns, index=['% Enrichment']) def sitespeptidesproteins(df, site_localization_probability=0.75): """ Generate summary count of modified sites, peptides and proteins in a processed dataset ``DataFrame``. Returns the number of sites, peptides and proteins as calculated as follows: - `sites` (>0.75; or specified site localization probability) count of all sites > threshold - `peptides` the set of `Sequence windows` in the dataset (unique peptides) - `proteins` the set of unique leading proteins in the dataset :param df: Pandas ``DataFrame`` of processed data :param site_localization_probability: ``float`` site localization probability threshold (for sites calculation) :return: ``tuple`` of ``int``, containing sites, peptides, proteins """ sites = filters.filter_localization_probability(df, site_localization_probability)['Sequence window'] peptides = set(df['Sequence window']) proteins = set([str(p).split(';')[0] for p in df['Proteins']]) return len(sites), len(peptides), len(proteins) def modifiedaminoacids(df): """ Calculate the number of modified amino acids in supplied ``DataFrame``. Returns the total of all modifications and the total for each amino acid individually, as an ``int`` and a ``dict`` of ``int``, keyed by amino acid, respectively. :param df: Pandas ``DataFrame`` containing processed data. :return: total_aas ``int`` the total number of all modified amino acids quants ``dict`` of ``int`` keyed by amino acid, giving individual counts for each aa. """ amino_acids = list(df['Amino acid'].values) aas = set(amino_acids) quants = {} for aa in aas: quants[aa] = amino_acids.count(aa) total_aas = len(amino_acids) return total_aas, quants def go_enrichment(df, enrichment='function', organism='Homo sapiens', summary=True, fdr=0.05, ids_from=['Proteins','Protein IDs']): """ Calculate gene ontology (GO) enrichment for a specified set of indices, using the PantherDB GO enrichment service. Provided with a processed data ``DataFrame`` will calculate the GO ontology enrichment specified by `enrichment`, for the specified `organism`. The IDs to use for genes are taken from the field `ids_from`, which by default is compatible with both proteinGroups and modified peptide tables. Setting the `fdr` parameter (default=0.05) sets the cut-off to use for filtering the results. If `summary` is ``True`` (default) the returned ``DataFrame`` contains just the ontology summary and FDR. :param df: Pandas ``DataFrame`` to :param enrichment: ``str`` GO enrichment method to use (one of 'function', 'process', 'cellular_location', 'protein_class', 'pathway') :param organism: ``str`` organism name (e.g. "Homo sapiens") :param summary: ``bool`` return full, or summarised dataset :param fdr: ``float`` FDR cut-off to use for returned GO enrichments :param ids_from: ``list`` of ``str`` containing the index levels to select IDs from (genes, protein IDs, etc.) default=['Proteins','Protein IDs'] :return: Pandas ``DataFrame`` containing enrichments, sorted by P value. """ if isinstance(df, pd.DataFrame) or isinstance(df, pd.Series): l = list(set(ids_from) & set(df.index.names))[0] data = "\n".join([get_protein_id(s) for s in df.index.get_level_values(l)]) else: data = "\n".join([get_protein_id(s) for s in df]) r = requests.post("http://www.pantherdb.org/webservices/garuda/tools/enrichment/VER_2/enrichment.jsp", data={ 'organism': organism, 'type': 'enrichment', 'enrichmentType': enrichment}, files = { 'geneList': ('genelist.txt', StringIO(data) ), } ) try: go = pd.read_csv(StringIO(r.text), sep='\t', skiprows=5, lineterminator='\n', header=None) except ValueError: return None go.columns = ["GO", "Name", "Gene ID", "P", "FDR"] go = go.set_index(["GO", "Name"]) if summary: go = go.drop("Gene ID", axis=1).mean(axis=0, level=["GO","Name"]) if fdr: go = go[ go["P"] < fdr ] return go.sort_values(by="P", ascending=True) def anova_1way(df, *args, **kwargs): """ Perform Analysis of Variation (ANOVA) on provided dataframe and for specified groups. Groups for analysis can be specified as individual arguments, e.g. anova(df, "Group A", "Group B") anova(df, ("Group A", 5), ("Group B", 5)) At least 2 groups must be provided. :return: Dataframe containing selected groups and P/T/sig value for the comparisons. """ if len(args) < 2: raise Exception("Not enough arguments. Provide at least two group/indexes for comparison.") # Select columns for test df = df[list(args)] fdr = kwargs.get('fdr', 0.05) pv = [] tv = [] for n in range(df.shape[0]): data = [] for idx in args: dv = df.iloc[n][idx].values dv = np.ma.masked_where(np.isnan(dv), dv) data.append(dv) # Calculate the p value between two groups (t-test) t, p = sp.stats.mstats.f_oneway(*data) pv.append(p) tv.append(t) df['ANOVA p'] = pv df['ANOVA t'] = tv df['ANOVA sig'] = np.array(pv) <= fdr return df def ttest_1samp(df, is_log2=False, fillna=None): """ Perform 1 sample t-test on a dataframe df1 The mean of each group is calculated along the y-axis (per protein) and used to generate a log2 ratio. If a log2-transformed dataset is supplied set `islog2=True` (a warning will be given when negative values are present). :param df: Pandas `dataframe` :param is_log2: `bool` is the data log2 transformed already? :param fillna: `float` fill NaN values with value (default: 0) :return: """ df = df.copy() if np.any(df.values[~
pd.isnull(df.values)
pandas.isnull
import pandas as pd import numpy as np from datetime import date """ dataset split: (date_received) dateset3: 20160701~20160731 (113640),features3 from 20160315~20160630 (off_test) dateset2: 20160515~20160615 (258446),features2 from 20160201~20160514 dateset1: 20160414~20160514 (138303),features1 from 20160101~20160413 1.merchant related: sales_use_coupon. total_coupon transfer_rate = sales_use_coupon/total_coupon. merchant_avg_distance,merchant_min_distance,merchant_max_distance of those use coupon total_sales. coupon_rate = sales_use_coupon/total_sales. 2.coupon related: discount_rate. discount_man. discount_jian. is_man_jian day_of_week,day_of_month. (date_received) 3.user related: distance. user_avg_distance, user_min_distance,user_max_distance. buy_use_coupon. buy_total. coupon_received. buy_use_coupon/coupon_received. avg_diff_date_datereceived. min_diff_date_datereceived. max_diff_date_datereceived. count_merchant. 4.user_merchant: times_user_buy_merchant_before. 5. other feature: this_month_user_receive_all_coupon_count this_month_user_receive_same_coupon_count this_month_user_receive_same_coupon_lastone this_month_user_receive_same_coupon_firstone this_day_user_receive_all_coupon_count this_day_user_receive_same_coupon_count day_gap_before, day_gap_after (receive the same coupon) """ #1754884 record,1053282 with coupon_id,9738 coupon. date_received:20160101~20160615,date:20160101~20160630, 539438 users, 8415 merchants off_train = pd.read_csv('data/ccf_offline_stage1_train.csv',header=None) off_train.columns = ['user_id','merchant_id','coupon_id','discount_rate','distance','date_received','date'] #2050 coupon_id. date_received:20160701~20160731, 76309 users(76307 in trainset, 35965 in online_trainset), 1559 merchants(1558 in trainset) off_test = pd.read_csv('data/ccf_offline_stage1_test_revised.csv',header=None) off_test.columns = ['user_id','merchant_id','coupon_id','discount_rate','distance','date_received'] #11429826 record(872357 with coupon_id),762858 user(267448 in off_train) on_train = pd.read_csv('data/ccf_online_stage1_train.csv',header=None) on_train.columns = ['user_id','merchant_id','action','coupon_id','discount_rate','date_received','date'] dataset3 = off_test feature3 = off_train[((off_train.date>='20160315')&(off_train.date<='20160630'))|((off_train.date=='null')&(off_train.date_received>='20160315')&(off_train.date_received<='20160630'))] dataset2 = off_train[(off_train.date_received>='20160515')&(off_train.date_received<='20160615')] feature2 = off_train[(off_train.date>='20160201')&(off_train.date<='20160514')|((off_train.date=='null')&(off_train.date_received>='20160201')&(off_train.date_received<='20160514'))] dataset1 = off_train[(off_train.date_received>='20160414')&(off_train.date_received<='20160514')] feature1 = off_train[(off_train.date>='20160101')&(off_train.date<='20160413')|((off_train.date=='null')&(off_train.date_received>='20160101')&(off_train.date_received<='20160413'))] ############# other feature ##################3 """ 5. other feature: this_month_user_receive_all_coupon_count this_month_user_receive_same_coupon_count this_month_user_receive_same_coupon_lastone this_month_user_receive_same_coupon_firstone this_day_user_receive_all_coupon_count this_day_user_receive_same_coupon_count day_gap_before, day_gap_after (receive the same coupon) """ #for dataset3 t = dataset3[['user_id']] t['this_month_user_receive_all_coupon_count'] = 1 t = t.groupby('user_id').agg('sum').reset_index() t1 = dataset3[['user_id','coupon_id']] t1['this_month_user_receive_same_coupon_count'] = 1 t1 = t1.groupby(['user_id','coupon_id']).agg('sum').reset_index() t2 = dataset3[['user_id','coupon_id','date_received']] t2.date_received = t2.date_received.astype('str') t2 = t2.groupby(['user_id','coupon_id'])['date_received'].agg(lambda x:':'.join(x)).reset_index() t2['receive_number'] = t2.date_received.apply(lambda s:len(s.split(':'))) t2 = t2[t2.receive_number>1] t2['max_date_received'] = t2.date_received.apply(lambda s:max([int(d) for d in s.split(':')])) t2['min_date_received'] = t2.date_received.apply(lambda s:min([int(d) for d in s.split(':')])) t2 = t2[['user_id','coupon_id','max_date_received','min_date_received']] t3 = dataset3[['user_id','coupon_id','date_received']] t3 = pd.merge(t3,t2,on=['user_id','coupon_id'],how='left') t3['this_month_user_receive_same_coupon_lastone'] = t3.max_date_received - t3.date_received t3['this_month_user_receive_same_coupon_firstone'] = t3.date_received - t3.min_date_received def is_firstlastone(x): if x==0: return 1 elif x>0: return 0 else: return -1 #those only receive once t3.this_month_user_receive_same_coupon_lastone = t3.this_month_user_receive_same_coupon_lastone.apply(is_firstlastone) t3.this_month_user_receive_same_coupon_firstone = t3.this_month_user_receive_same_coupon_firstone.apply(is_firstlastone) t3 = t3[['user_id','coupon_id','date_received','this_month_user_receive_same_coupon_lastone','this_month_user_receive_same_coupon_firstone']] t4 = dataset3[['user_id','date_received']] t4['this_day_user_receive_all_coupon_count'] = 1 t4 = t4.groupby(['user_id','date_received']).agg('sum').reset_index() t5 = dataset3[['user_id','coupon_id','date_received']] t5['this_day_user_receive_same_coupon_count'] = 1 t5 = t5.groupby(['user_id','coupon_id','date_received']).agg('sum').reset_index() t6 = dataset3[['user_id','coupon_id','date_received']] t6.date_received = t6.date_received.astype('str') t6 = t6.groupby(['user_id','coupon_id'])['date_received'].agg(lambda x:':'.join(x)).reset_index() t6.rename(columns={'date_received':'dates'},inplace=True) def get_day_gap_before(s): date_received,dates = s.split('-') dates = dates.split(':') gaps = [] for d in dates: this_gap = (date(int(date_received[0:4]),int(date_received[4:6]),int(date_received[6:8]))-date(int(d[0:4]),int(d[4:6]),int(d[6:8]))).days if this_gap>0: gaps.append(this_gap) if len(gaps)==0: return -1 else: return min(gaps) def get_day_gap_after(s): date_received,dates = s.split('-') dates = dates.split(':') gaps = [] for d in dates: this_gap = (date(int(d[0:4]),int(d[4:6]),int(d[6:8]))-date(int(date_received[0:4]),int(date_received[4:6]),int(date_received[6:8]))).days if this_gap>0: gaps.append(this_gap) if len(gaps)==0: return -1 else: return min(gaps) t7 = dataset3[['user_id','coupon_id','date_received']] t7 = pd.merge(t7,t6,on=['user_id','coupon_id'],how='left') t7['date_received_date'] = t7.date_received.astype('str') + '-' + t7.dates t7['day_gap_before'] = t7.date_received_date.apply(get_day_gap_before) t7['day_gap_after'] = t7.date_received_date.apply(get_day_gap_after) t7 = t7[['user_id','coupon_id','date_received','day_gap_before','day_gap_after']] other_feature3 = pd.merge(t1,t,on='user_id') other_feature3 = pd.merge(other_feature3,t3,on=['user_id','coupon_id']) other_feature3 = pd.merge(other_feature3,t4,on=['user_id','date_received']) other_feature3 = pd.merge(other_feature3,t5,on=['user_id','coupon_id','date_received']) other_feature3 = pd.merge(other_feature3,t7,on=['user_id','coupon_id','date_received']) other_feature3.to_csv('data/other_feature3.csv',index=None) print(other_feature3.shape) #for dataset2 t = dataset2[['user_id']] t['this_month_user_receive_all_coupon_count'] = 1 t = t.groupby('user_id').agg('sum').reset_index() t1 = dataset2[['user_id','coupon_id']] t1['this_month_user_receive_same_coupon_count'] = 1 t1 = t1.groupby(['user_id','coupon_id']).agg('sum').reset_index() t2 = dataset2[['user_id','coupon_id','date_received']] t2.date_received = t2.date_received.astype('str') t2 = t2.groupby(['user_id','coupon_id'])['date_received'].agg(lambda x:':'.join(x)).reset_index() t2['receive_number'] = t2.date_received.apply(lambda s:len(s.split(':'))) t2 = t2[t2.receive_number>1] t2['max_date_received'] = t2.date_received.apply(lambda s:max([int(d) for d in s.split(':')])) t2['min_date_received'] = t2.date_received.apply(lambda s:min([int(d) for d in s.split(':')])) t2 = t2[['user_id','coupon_id','max_date_received','min_date_received']] t3 = dataset2[['user_id','coupon_id','date_received']] t3 = pd.merge(t3,t2,on=['user_id','coupon_id'],how='left') t3['this_month_user_receive_same_coupon_lastone'] = t3.max_date_received - t3.date_received.astype('int') t3['this_month_user_receive_same_coupon_firstone'] = t3.date_received.astype('int') - t3.min_date_received def is_firstlastone(x): if x==0: return 1 elif x>0: return 0 else: return -1 #those only receive once t3.this_month_user_receive_same_coupon_lastone = t3.this_month_user_receive_same_coupon_lastone.apply(is_firstlastone) t3.this_month_user_receive_same_coupon_firstone = t3.this_month_user_receive_same_coupon_firstone.apply(is_firstlastone) t3 = t3[['user_id','coupon_id','date_received','this_month_user_receive_same_coupon_lastone','this_month_user_receive_same_coupon_firstone']] t4 = dataset2[['user_id','date_received']] t4['this_day_user_receive_all_coupon_count'] = 1 t4 = t4.groupby(['user_id','date_received']).agg('sum').reset_index() t5 = dataset2[['user_id','coupon_id','date_received']] t5['this_day_user_receive_same_coupon_count'] = 1 t5 = t5.groupby(['user_id','coupon_id','date_received']).agg('sum').reset_index() t6 = dataset2[['user_id','coupon_id','date_received']] t6.date_received = t6.date_received.astype('str') t6 = t6.groupby(['user_id','coupon_id'])['date_received'].agg(lambda x:':'.join(x)).reset_index() t6.rename(columns={'date_received':'dates'},inplace=True) def get_day_gap_before(s): date_received,dates = s.split('-') dates = dates.split(':') gaps = [] for d in dates: this_gap = (date(int(date_received[0:4]),int(date_received[4:6]),int(date_received[6:8]))-date(int(d[0:4]),int(d[4:6]),int(d[6:8]))).days if this_gap>0: gaps.append(this_gap) if len(gaps)==0: return -1 else: return min(gaps) def get_day_gap_after(s): date_received,dates = s.split('-') dates = dates.split(':') gaps = [] for d in dates: this_gap = (date(int(d[0:4]),int(d[4:6]),int(d[6:8]))-date(int(date_received[0:4]),int(date_received[4:6]),int(date_received[6:8]))).days if this_gap>0: gaps.append(this_gap) if len(gaps)==0: return -1 else: return min(gaps) t7 = dataset2[['user_id','coupon_id','date_received']] t7 = pd.merge(t7,t6,on=['user_id','coupon_id'],how='left') t7['date_received_date'] = t7.date_received.astype('str') + '-' + t7.dates t7['day_gap_before'] = t7.date_received_date.apply(get_day_gap_before) t7['day_gap_after'] = t7.date_received_date.apply(get_day_gap_after) t7 = t7[['user_id','coupon_id','date_received','day_gap_before','day_gap_after']] other_feature2 = pd.merge(t1,t,on='user_id') other_feature2 = pd.merge(other_feature2,t3,on=['user_id','coupon_id']) other_feature2 = pd.merge(other_feature2,t4,on=['user_id','date_received']) other_feature2 = pd.merge(other_feature2,t5,on=['user_id','coupon_id','date_received']) other_feature2 = pd.merge(other_feature2,t7,on=['user_id','coupon_id','date_received']) other_feature2.to_csv('data/other_feature2.csv',index=None) print(other_feature2.shape) #for dataset1 t = dataset1[['user_id']] t['this_month_user_receive_all_coupon_count'] = 1 t = t.groupby('user_id').agg('sum').reset_index() t1 = dataset1[['user_id','coupon_id']] t1['this_month_user_receive_same_coupon_count'] = 1 t1 = t1.groupby(['user_id','coupon_id']).agg('sum').reset_index() t2 = dataset1[['user_id','coupon_id','date_received']] t2.date_received = t2.date_received.astype('str') t2 = t2.groupby(['user_id','coupon_id'])['date_received'].agg(lambda x:':'.join(x)).reset_index() t2['receive_number'] = t2.date_received.apply(lambda s:len(s.split(':'))) t2 = t2[t2.receive_number>1] t2['max_date_received'] = t2.date_received.apply(lambda s:max([int(d) for d in s.split(':')])) t2['min_date_received'] = t2.date_received.apply(lambda s:min([int(d) for d in s.split(':')])) t2 = t2[['user_id','coupon_id','max_date_received','min_date_received']] t3 = dataset1[['user_id','coupon_id','date_received']] t3 = pd.merge(t3,t2,on=['user_id','coupon_id'],how='left') t3['this_month_user_receive_same_coupon_lastone'] = t3.max_date_received - t3.date_received.astype('int') t3['this_month_user_receive_same_coupon_firstone'] = t3.date_received.astype('int') - t3.min_date_received def is_firstlastone(x): if x==0: return 1 elif x>0: return 0 else: return -1 #those only receive once t3.this_month_user_receive_same_coupon_lastone = t3.this_month_user_receive_same_coupon_lastone.apply(is_firstlastone) t3.this_month_user_receive_same_coupon_firstone = t3.this_month_user_receive_same_coupon_firstone.apply(is_firstlastone) t3 = t3[['user_id','coupon_id','date_received','this_month_user_receive_same_coupon_lastone','this_month_user_receive_same_coupon_firstone']] t4 = dataset1[['user_id','date_received']] t4['this_day_user_receive_all_coupon_count'] = 1 t4 = t4.groupby(['user_id','date_received']).agg('sum').reset_index() t5 = dataset1[['user_id','coupon_id','date_received']] t5['this_day_user_receive_same_coupon_count'] = 1 t5 = t5.groupby(['user_id','coupon_id','date_received']).agg('sum').reset_index() t6 = dataset1[['user_id','coupon_id','date_received']] t6.date_received = t6.date_received.astype('str') t6 = t6.groupby(['user_id','coupon_id'])['date_received'].agg(lambda x:':'.join(x)).reset_index() t6.rename(columns={'date_received':'dates'},inplace=True) def get_day_gap_before(s): date_received,dates = s.split('-') dates = dates.split(':') gaps = [] for d in dates: this_gap = (date(int(date_received[0:4]),int(date_received[4:6]),int(date_received[6:8]))-date(int(d[0:4]),int(d[4:6]),int(d[6:8]))).days if this_gap>0: gaps.append(this_gap) if len(gaps)==0: return -1 else: return min(gaps) def get_day_gap_after(s): date_received,dates = s.split('-') dates = dates.split(':') gaps = [] for d in dates: this_gap = (date(int(d[0:4]),int(d[4:6]),int(d[6:8]))-date(int(date_received[0:4]),int(date_received[4:6]),int(date_received[6:8]))).days if this_gap>0: gaps.append(this_gap) if len(gaps)==0: return -1 else: return min(gaps) t7 = dataset1[['user_id','coupon_id','date_received']] t7 = pd.merge(t7,t6,on=['user_id','coupon_id'],how='left') t7['date_received_date'] = t7.date_received.astype('str') + '-' + t7.dates t7['day_gap_before'] = t7.date_received_date.apply(get_day_gap_before) t7['day_gap_after'] = t7.date_received_date.apply(get_day_gap_after) t7 = t7[['user_id','coupon_id','date_received','day_gap_before','day_gap_after']] other_feature1 = pd.merge(t1,t,on='user_id') other_feature1 = pd.merge(other_feature1,t3,on=['user_id','coupon_id']) other_feature1 = pd.merge(other_feature1,t4,on=['user_id','date_received']) other_feature1 = pd.merge(other_feature1,t5,on=['user_id','coupon_id','date_received']) other_feature1 = pd.merge(other_feature1,t7,on=['user_id','coupon_id','date_received']) other_feature1.to_csv('data/other_feature1.csv',index=None) print(other_feature1.shape) ############# coupon related feature ############# """ 2.coupon related: discount_rate. discount_man. discount_jian. is_man_jian day_of_week,day_of_month. (date_received) """ def calc_discount_rate(s): s =str(s) s = s.split(':') if len(s)==1: return float(s[0]) else: return 1.0-float(s[1])/float(s[0]) def get_discount_man(s): s =str(s) s = s.split(':') if len(s)==1: return 'null' else: return int(s[0]) def get_discount_jian(s): s =str(s) s = s.split(':') if len(s)==1: return 'null' else: return int(s[1]) def is_man_jian(s): s =str(s) s = s.split(':') if len(s)==1: return 0 else: return 1 #dataset3 dataset3['day_of_week'] = dataset3.date_received.astype('str').apply(lambda x:date(int(x[0:4]),int(x[4:6]),int(x[6:8])).weekday()+1) dataset3['day_of_month'] = dataset3.date_received.astype('str').apply(lambda x:int(x[6:8])) dataset3['days_distance'] = dataset3.date_received.astype('str').apply(lambda x:(date(int(x[0:4]),int(x[4:6]),int(x[6:8]))-date(2016,6,30)).days) dataset3['discount_man'] = dataset3.discount_rate.apply(get_discount_man) dataset3['discount_jian'] = dataset3.discount_rate.apply(get_discount_jian) dataset3['is_man_jian'] = dataset3.discount_rate.apply(is_man_jian) dataset3['discount_rate'] = dataset3.discount_rate.apply(calc_discount_rate) d = dataset3[['coupon_id']] d['coupon_count'] = 1 d = d.groupby('coupon_id').agg('sum').reset_index() dataset3 = pd.merge(dataset3,d,on='coupon_id',how='left') dataset3.to_csv('data/coupon3_feature.csv',index=None) #dataset2 dataset2['day_of_week'] = dataset2.date_received.astype('str').apply(lambda x:date(int(x[0:4]),int(x[4:6]),int(x[6:8])).weekday()+1) dataset2['day_of_month'] = dataset2.date_received.astype('str').apply(lambda x:int(x[6:8])) dataset2['days_distance'] = dataset2.date_received.astype('str').apply(lambda x:(date(int(x[0:4]),int(x[4:6]),int(x[6:8]))-date(2016,5,14)).days) dataset2['discount_man'] = dataset2.discount_rate.apply(get_discount_man) dataset2['discount_jian'] = dataset2.discount_rate.apply(get_discount_jian) dataset2['is_man_jian'] = dataset2.discount_rate.apply(is_man_jian) dataset2['discount_rate'] = dataset2.discount_rate.apply(calc_discount_rate) d = dataset2[['coupon_id']] d['coupon_count'] = 1 d = d.groupby('coupon_id').agg('sum').reset_index() dataset2 =
pd.merge(dataset2,d,on='coupon_id',how='left')
pandas.merge
# pylint: disable-msg=E1101,W0612 from datetime import datetime, time, timedelta, date import sys import os import operator from distutils.version import LooseVersion import nose import numpy as np randn = np.random.randn from pandas import (Index, Series, TimeSeries, DataFrame, isnull, date_range, Timestamp, Period, DatetimeIndex, Int64Index, to_datetime, bdate_range, Float64Index) import pandas.core.datetools as datetools import pandas.tseries.offsets as offsets import pandas.tseries.tools as tools import pandas.tseries.frequencies as fmod import pandas as pd from pandas.util.testing import assert_series_equal, assert_almost_equal import pandas.util.testing as tm from pandas.tslib import NaT, iNaT import pandas.lib as lib import pandas.tslib as tslib import pandas.index as _index from pandas.compat import range, long, StringIO, lrange, lmap, zip, product import pandas.core.datetools as dt from numpy.random import rand from numpy.testing import assert_array_equal from pandas.util.testing import assert_frame_equal import pandas.compat as compat import pandas.core.common as com from pandas import concat from pandas import _np_version_under1p7 from numpy.testing.decorators import slow def _skip_if_no_pytz(): try: import pytz except ImportError: raise nose.SkipTest("pytz not installed") def _skip_if_has_locale(): import locale lang, _ = locale.getlocale() if lang is not None: raise nose.SkipTest("Specific locale is set {0}".format(lang)) class TestTimeSeriesDuplicates(tm.TestCase): _multiprocess_can_split_ = True def setUp(self): dates = [datetime(2000, 1, 2), datetime(2000, 1, 2), datetime(2000, 1, 2), datetime(2000, 1, 3), datetime(2000, 1, 3), datetime(2000, 1, 3), datetime(2000, 1, 4), datetime(2000, 1, 4), datetime(2000, 1, 4), datetime(2000, 1, 5)] self.dups = Series(np.random.randn(len(dates)), index=dates) def test_constructor(self): tm.assert_isinstance(self.dups, TimeSeries) tm.assert_isinstance(self.dups.index, DatetimeIndex) def test_is_unique_monotonic(self): self.assertFalse(self.dups.index.is_unique) def test_index_unique(self): uniques = self.dups.index.unique() expected = DatetimeIndex([datetime(2000, 1, 2), datetime(2000, 1, 3), datetime(2000, 1, 4), datetime(2000, 1, 5)]) self.assertEqual(uniques.dtype, 'M8[ns]') # sanity self.assertTrue(uniques.equals(expected)) self.assertEqual(self.dups.index.nunique(), 4) # #2563 self.assertTrue(isinstance(uniques, DatetimeIndex)) dups_local = self.dups.index.tz_localize('US/Eastern') dups_local.name = 'foo' result = dups_local.unique() expected = DatetimeIndex(expected, tz='US/Eastern') self.assertTrue(result.tz is not None) self.assertEqual(result.name, 'foo') self.assertTrue(result.equals(expected)) # NaT arr = [ 1370745748 + t for t in range(20) ] + [iNaT] idx = DatetimeIndex(arr * 3) self.assertTrue(idx.unique().equals(DatetimeIndex(arr))) self.assertEqual(idx.nunique(), 21) arr = [ Timestamp('2013-06-09 02:42:28') + timedelta(seconds=t) for t in range(20) ] + [NaT] idx = DatetimeIndex(arr * 3) self.assertTrue(idx.unique().equals(DatetimeIndex(arr))) self.assertEqual(idx.nunique(), 21) def test_index_dupes_contains(self): d = datetime(2011, 12, 5, 20, 30) ix = DatetimeIndex([d, d]) self.assertTrue(d in ix) def test_duplicate_dates_indexing(self): ts = self.dups uniques = ts.index.unique() for date in uniques: result = ts[date] mask = ts.index == date total = (ts.index == date).sum() expected = ts[mask] if total > 1: assert_series_equal(result, expected) else: assert_almost_equal(result, expected[0]) cp = ts.copy() cp[date] = 0 expected = Series(np.where(mask, 0, ts), index=ts.index) assert_series_equal(cp, expected) self.assertRaises(KeyError, ts.__getitem__, datetime(2000, 1, 6)) # new index ts[datetime(2000,1,6)] = 0 self.assertEqual(ts[datetime(2000,1,6)], 0) def test_range_slice(self): idx = DatetimeIndex(['1/1/2000', '1/2/2000', '1/2/2000', '1/3/2000', '1/4/2000']) ts = Series(np.random.randn(len(idx)), index=idx) result = ts['1/2/2000':] expected = ts[1:] assert_series_equal(result, expected) result = ts['1/2/2000':'1/3/2000'] expected = ts[1:4] assert_series_equal(result, expected) def test_groupby_average_dup_values(self): result = self.dups.groupby(level=0).mean() expected = self.dups.groupby(self.dups.index).mean() assert_series_equal(result, expected) def test_indexing_over_size_cutoff(self): import datetime # #1821 old_cutoff = _index._SIZE_CUTOFF try: _index._SIZE_CUTOFF = 1000 # create large list of non periodic datetime dates = [] sec = datetime.timedelta(seconds=1) half_sec = datetime.timedelta(microseconds=500000) d = datetime.datetime(2011, 12, 5, 20, 30) n = 1100 for i in range(n): dates.append(d) dates.append(d + sec) dates.append(d + sec + half_sec) dates.append(d + sec + sec + half_sec) d += 3 * sec # duplicate some values in the list duplicate_positions = np.random.randint(0, len(dates) - 1, 20) for p in duplicate_positions: dates[p + 1] = dates[p] df = DataFrame(np.random.randn(len(dates), 4), index=dates, columns=list('ABCD')) pos = n * 3 timestamp = df.index[pos] self.assertIn(timestamp, df.index) # it works! df.ix[timestamp] self.assertTrue(len(df.ix[[timestamp]]) > 0) finally: _index._SIZE_CUTOFF = old_cutoff def test_indexing_unordered(self): # GH 2437 rng = date_range(start='2011-01-01', end='2011-01-15') ts = Series(randn(len(rng)), index=rng) ts2 = concat([ts[0:4],ts[-4:],ts[4:-4]]) for t in ts.index: s = str(t) expected = ts[t] result = ts2[t] self.assertTrue(expected == result) # GH 3448 (ranges) def compare(slobj): result = ts2[slobj].copy() result = result.sort_index() expected = ts[slobj] assert_series_equal(result,expected) compare(slice('2011-01-01','2011-01-15')) compare(slice('2010-12-30','2011-01-15')) compare(slice('2011-01-01','2011-01-16')) # partial ranges compare(slice('2011-01-01','2011-01-6')) compare(slice('2011-01-06','2011-01-8')) compare(slice('2011-01-06','2011-01-12')) # single values result = ts2['2011'].sort_index() expected = ts['2011'] assert_series_equal(result,expected) # diff freq rng = date_range(datetime(2005, 1, 1), periods=20, freq='M') ts = Series(np.arange(len(rng)), index=rng) ts = ts.take(np.random.permutation(20)) result = ts['2005'] for t in result.index: self.assertTrue(t.year == 2005) def test_indexing(self): idx = date_range("2001-1-1", periods=20, freq='M') ts = Series(np.random.rand(len(idx)),index=idx) # getting # GH 3070, make sure semantics work on Series/Frame expected = ts['2001'] df = DataFrame(dict(A = ts)) result = df['2001']['A'] assert_series_equal(expected,result) # setting ts['2001'] = 1 expected = ts['2001'] df.loc['2001','A'] = 1 result = df['2001']['A'] assert_series_equal(expected,result) # GH3546 (not including times on the last day) idx = date_range(start='2013-05-31 00:00', end='2013-05-31 23:00', freq='H') ts = Series(lrange(len(idx)), index=idx) expected = ts['2013-05'] assert_series_equal(expected,ts) idx = date_range(start='2013-05-31 00:00', end='2013-05-31 23:59', freq='S') ts = Series(lrange(len(idx)), index=idx) expected = ts['2013-05'] assert_series_equal(expected,ts) idx = [ Timestamp('2013-05-31 00:00'), Timestamp(datetime(2013,5,31,23,59,59,999999))] ts = Series(lrange(len(idx)), index=idx) expected = ts['2013'] assert_series_equal(expected,ts) # GH 3925, indexing with a seconds resolution string / datetime object df = DataFrame(randn(5,5),columns=['open','high','low','close','volume'],index=date_range('2012-01-02 18:01:00',periods=5,tz='US/Central',freq='s')) expected = df.loc[[df.index[2]]] result = df['2012-01-02 18:01:02'] assert_frame_equal(result,expected) # this is a single date, so will raise self.assertRaises(KeyError, df.__getitem__, df.index[2],) def test_recreate_from_data(self): if _np_version_under1p7: freqs = ['M', 'Q', 'A', 'D', 'B', 'T', 'S', 'L', 'U', 'H'] else: freqs = ['M', 'Q', 'A', 'D', 'B', 'T', 'S', 'L', 'U', 'H', 'N', 'C'] for f in freqs: org = DatetimeIndex(start='2001/02/01 09:00', freq=f, periods=1) idx = DatetimeIndex(org, freq=f) self.assertTrue(idx.equals(org)) # unbale to create tz-aware 'A' and 'C' freq if _np_version_under1p7: freqs = ['M', 'Q', 'D', 'B', 'T', 'S', 'L', 'U', 'H'] else: freqs = ['M', 'Q', 'D', 'B', 'T', 'S', 'L', 'U', 'H', 'N'] for f in freqs: org = DatetimeIndex(start='2001/02/01 09:00', freq=f, tz='US/Pacific', periods=1) idx = DatetimeIndex(org, freq=f, tz='US/Pacific') self.assertTrue(idx.equals(org)) def assert_range_equal(left, right): assert(left.equals(right)) assert(left.freq == right.freq) assert(left.tz == right.tz) class TestTimeSeries(tm.TestCase): _multiprocess_can_split_ = True def test_is_(self): dti = DatetimeIndex(start='1/1/2005', end='12/1/2005', freq='M') self.assertTrue(dti.is_(dti)) self.assertTrue(dti.is_(dti.view())) self.assertFalse(dti.is_(dti.copy())) def test_dti_slicing(self): dti = DatetimeIndex(start='1/1/2005', end='12/1/2005', freq='M') dti2 = dti[[1, 3, 5]] v1 = dti2[0] v2 = dti2[1] v3 = dti2[2] self.assertEqual(v1, Timestamp('2/28/2005')) self.assertEqual(v2, Timestamp('4/30/2005')) self.assertEqual(v3, Timestamp('6/30/2005')) # don't carry freq through irregular slicing self.assertIsNone(dti2.freq) def test_pass_datetimeindex_to_index(self): # Bugs in #1396 rng = date_range('1/1/2000', '3/1/2000') idx = Index(rng, dtype=object) expected = Index(rng.to_pydatetime(), dtype=object) self.assert_numpy_array_equal(idx.values, expected.values) def test_contiguous_boolean_preserve_freq(self): rng = date_range('1/1/2000', '3/1/2000', freq='B') mask = np.zeros(len(rng), dtype=bool) mask[10:20] = True masked = rng[mask] expected = rng[10:20] self.assertIsNotNone(expected.freq) assert_range_equal(masked, expected) mask[22] = True masked = rng[mask] self.assertIsNone(masked.freq) def test_getitem_median_slice_bug(self): index = date_range('20090415', '20090519', freq='2B') s = Series(np.random.randn(13), index=index) indexer = [slice(6, 7, None)] result = s[indexer] expected = s[indexer[0]] assert_series_equal(result, expected) def test_series_box_timestamp(self): rng = date_range('20090415', '20090519', freq='B') s = Series(rng) tm.assert_isinstance(s[5], Timestamp) rng = date_range('20090415', '20090519', freq='B') s = Series(rng, index=rng) tm.assert_isinstance(s[5], Timestamp) tm.assert_isinstance(s.iget_value(5), Timestamp) def test_date_range_ambiguous_arguments(self): # #2538 start = datetime(2011, 1, 1, 5, 3, 40) end = datetime(2011, 1, 1, 8, 9, 40) self.assertRaises(ValueError, date_range, start, end, freq='s', periods=10) def test_timestamp_to_datetime(self): _skip_if_no_pytz() rng = date_range('20090415', '20090519', tz='US/Eastern') stamp = rng[0] dtval = stamp.to_pydatetime() self.assertEqual(stamp, dtval) self.assertEqual(stamp.tzinfo, dtval.tzinfo) def test_index_convert_to_datetime_array(self): _skip_if_no_pytz() def _check_rng(rng): converted = rng.to_pydatetime() tm.assert_isinstance(converted, np.ndarray) for x, stamp in zip(converted, rng): tm.assert_isinstance(x, datetime) self.assertEqual(x, stamp.to_pydatetime()) self.assertEqual(x.tzinfo, stamp.tzinfo) rng = date_range('20090415', '20090519') rng_eastern = date_range('20090415', '20090519', tz='US/Eastern') rng_utc = date_range('20090415', '20090519', tz='utc') _check_rng(rng) _check_rng(rng_eastern) _check_rng(rng_utc) def test_ctor_str_intraday(self): rng = DatetimeIndex(['1-1-2000 00:00:01']) self.assertEqual(rng[0].second, 1) def test_series_ctor_plus_datetimeindex(self): rng = date_range('20090415', '20090519', freq='B') data = dict((k, 1) for k in rng) result = Series(data, index=rng) self.assertIs(result.index, rng) def test_series_pad_backfill_limit(self): index = np.arange(10) s = Series(np.random.randn(10), index=index) result = s[:2].reindex(index, method='pad', limit=5) expected = s[:2].reindex(index).fillna(method='pad') expected[-3:] = np.nan assert_series_equal(result, expected) result = s[-2:].reindex(index, method='backfill', limit=5) expected = s[-2:].reindex(index).fillna(method='backfill') expected[:3] = np.nan assert_series_equal(result, expected) def test_series_fillna_limit(self): index = np.arange(10) s = Series(np.random.randn(10), index=index) result = s[:2].reindex(index) result = result.fillna(method='pad', limit=5) expected = s[:2].reindex(index).fillna(method='pad') expected[-3:] = np.nan assert_series_equal(result, expected) result = s[-2:].reindex(index) result = result.fillna(method='bfill', limit=5) expected = s[-2:].reindex(index).fillna(method='backfill') expected[:3] = np.nan assert_series_equal(result, expected) def test_frame_pad_backfill_limit(self): index = np.arange(10) df = DataFrame(np.random.randn(10, 4), index=index) result = df[:2].reindex(index, method='pad', limit=5) expected = df[:2].reindex(index).fillna(method='pad') expected.values[-3:] = np.nan tm.assert_frame_equal(result, expected) result = df[-2:].reindex(index, method='backfill', limit=5) expected = df[-2:].reindex(index).fillna(method='backfill') expected.values[:3] = np.nan tm.assert_frame_equal(result, expected) def test_frame_fillna_limit(self): index = np.arange(10) df = DataFrame(np.random.randn(10, 4), index=index) result = df[:2].reindex(index) result = result.fillna(method='pad', limit=5) expected = df[:2].reindex(index).fillna(method='pad') expected.values[-3:] = np.nan tm.assert_frame_equal(result, expected) result = df[-2:].reindex(index) result = result.fillna(method='backfill', limit=5) expected = df[-2:].reindex(index).fillna(method='backfill') expected.values[:3] = np.nan tm.assert_frame_equal(result, expected) def test_frame_setitem_timestamp(self): # 2155 columns = DatetimeIndex(start='1/1/2012', end='2/1/2012', freq=datetools.bday) index = lrange(10) data = DataFrame(columns=columns, index=index) t = datetime(2012, 11, 1) ts = Timestamp(t) data[ts] = np.nan # works def test_sparse_series_fillna_limit(self): index = np.arange(10) s = Series(np.random.randn(10), index=index) ss = s[:2].reindex(index).to_sparse() result = ss.fillna(method='pad', limit=5) expected = ss.fillna(method='pad', limit=5) expected = expected.to_dense() expected[-3:] = np.nan expected = expected.to_sparse() assert_series_equal(result, expected) ss = s[-2:].reindex(index).to_sparse() result = ss.fillna(method='backfill', limit=5) expected = ss.fillna(method='backfill') expected = expected.to_dense() expected[:3] = np.nan expected = expected.to_sparse() assert_series_equal(result, expected) def test_sparse_series_pad_backfill_limit(self): index = np.arange(10) s = Series(np.random.randn(10), index=index) s = s.to_sparse() result = s[:2].reindex(index, method='pad', limit=5) expected = s[:2].reindex(index).fillna(method='pad') expected = expected.to_dense() expected[-3:] = np.nan expected = expected.to_sparse() assert_series_equal(result, expected) result = s[-2:].reindex(index, method='backfill', limit=5) expected = s[-2:].reindex(index).fillna(method='backfill') expected = expected.to_dense() expected[:3] = np.nan expected = expected.to_sparse() assert_series_equal(result, expected) def test_sparse_frame_pad_backfill_limit(self): index = np.arange(10) df = DataFrame(np.random.randn(10, 4), index=index) sdf = df.to_sparse() result = sdf[:2].reindex(index, method='pad', limit=5) expected = sdf[:2].reindex(index).fillna(method='pad') expected = expected.to_dense() expected.values[-3:] = np.nan expected = expected.to_sparse() tm.assert_frame_equal(result, expected) result = sdf[-2:].reindex(index, method='backfill', limit=5) expected = sdf[-2:].reindex(index).fillna(method='backfill') expected = expected.to_dense() expected.values[:3] = np.nan expected = expected.to_sparse() tm.assert_frame_equal(result, expected) def test_sparse_frame_fillna_limit(self): index = np.arange(10) df = DataFrame(np.random.randn(10, 4), index=index) sdf = df.to_sparse() result = sdf[:2].reindex(index) result = result.fillna(method='pad', limit=5) expected = sdf[:2].reindex(index).fillna(method='pad') expected = expected.to_dense() expected.values[-3:] = np.nan expected = expected.to_sparse() tm.assert_frame_equal(result, expected) result = sdf[-2:].reindex(index) result = result.fillna(method='backfill', limit=5) expected = sdf[-2:].reindex(index).fillna(method='backfill') expected = expected.to_dense() expected.values[:3] = np.nan expected = expected.to_sparse() tm.assert_frame_equal(result, expected) def test_pad_require_monotonicity(self): rng = date_range('1/1/2000', '3/1/2000', freq='B') rng2 = rng[::2][::-1] self.assertRaises(ValueError, rng2.get_indexer, rng, method='pad') def test_frame_ctor_datetime64_column(self): rng = date_range('1/1/2000 00:00:00', '1/1/2000 1:59:50', freq='10s') dates = np.asarray(rng) df = DataFrame({'A': np.random.randn(len(rng)), 'B': dates}) self.assertTrue(np.issubdtype(df['B'].dtype, np.dtype('M8[ns]'))) def test_frame_add_datetime64_column(self): rng = date_range('1/1/2000 00:00:00', '1/1/2000 1:59:50', freq='10s') df = DataFrame(index=np.arange(len(rng))) df['A'] = rng self.assertTrue(np.issubdtype(df['A'].dtype, np.dtype('M8[ns]'))) def test_frame_datetime64_pre1900_repr(self): df = DataFrame({'year': date_range('1/1/1700', periods=50, freq='A-DEC')}) # it works! repr(df) def test_frame_add_datetime64_col_other_units(self): n = 100 units = ['h', 'm', 's', 'ms', 'D', 'M', 'Y'] ns_dtype = np.dtype('M8[ns]') for unit in units: dtype = np.dtype('M8[%s]' % unit) vals = np.arange(n, dtype=np.int64).view(dtype) df = DataFrame({'ints': np.arange(n)}, index=np.arange(n)) df[unit] = vals ex_vals = to_datetime(vals.astype('O')) self.assertEqual(df[unit].dtype, ns_dtype) self.assertTrue((df[unit].values == ex_vals).all()) # Test insertion into existing datetime64 column df = DataFrame({'ints': np.arange(n)}, index=np.arange(n)) df['dates'] = np.arange(n, dtype=np.int64).view(ns_dtype) for unit in units: dtype = np.dtype('M8[%s]' % unit) vals = np.arange(n, dtype=np.int64).view(dtype) tmp = df.copy() tmp['dates'] = vals ex_vals = to_datetime(vals.astype('O')) self.assertTrue((tmp['dates'].values == ex_vals).all()) def test_to_datetime_unit(self): epoch = 1370745748 s = Series([ epoch + t for t in range(20) ]) result = to_datetime(s,unit='s') expected = Series([ Timestamp('2013-06-09 02:42:28') + timedelta(seconds=t) for t in range(20) ]) assert_series_equal(result,expected) s = Series([ epoch + t for t in range(20) ]).astype(float) result = to_datetime(s,unit='s') expected = Series([ Timestamp('2013-06-09 02:42:28') + timedelta(seconds=t) for t in range(20) ]) assert_series_equal(result,expected) s = Series([ epoch + t for t in range(20) ] + [iNaT]) result = to_datetime(s,unit='s') expected = Series([ Timestamp('2013-06-09 02:42:28') + timedelta(seconds=t) for t in range(20) ] + [NaT]) assert_series_equal(result,expected) s = Series([ epoch + t for t in range(20) ] + [iNaT]).astype(float) result = to_datetime(s,unit='s') expected = Series([ Timestamp('2013-06-09 02:42:28') + timedelta(seconds=t) for t in range(20) ] + [NaT]) assert_series_equal(result,expected) s = concat([Series([ epoch + t for t in range(20) ]).astype(float),Series([np.nan])],ignore_index=True) result = to_datetime(s,unit='s') expected = Series([ Timestamp('2013-06-09 02:42:28') + timedelta(seconds=t) for t in range(20) ] + [NaT]) assert_series_equal(result,expected) def test_series_ctor_datetime64(self): rng = date_range('1/1/2000 00:00:00', '1/1/2000 1:59:50', freq='10s') dates = np.asarray(rng) series = Series(dates) self.assertTrue(np.issubdtype(series.dtype, np.dtype('M8[ns]'))) def test_index_cast_datetime64_other_units(self): arr = np.arange(0, 100, 10, dtype=np.int64).view('M8[D]') idx = Index(arr) self.assertTrue((idx.values == tslib.cast_to_nanoseconds(arr)).all()) def test_index_astype_datetime64(self): idx = Index([datetime(2012, 1, 1)], dtype=object) if not _np_version_under1p7: raise nose.SkipTest("test only valid in numpy < 1.7") casted = idx.astype(np.dtype('M8[D]')) expected = DatetimeIndex(idx.values) tm.assert_isinstance(casted, DatetimeIndex) self.assertTrue(casted.equals(expected)) def test_reindex_series_add_nat(self): rng = date_range('1/1/2000 00:00:00', periods=10, freq='10s') series = Series(rng) result = series.reindex(lrange(15)) self.assertTrue(np.issubdtype(result.dtype, np.dtype('M8[ns]'))) mask = result.isnull() self.assertTrue(mask[-5:].all()) self.assertFalse(mask[:-5].any()) def test_reindex_frame_add_nat(self): rng = date_range('1/1/2000 00:00:00', periods=10, freq='10s') df = DataFrame({'A': np.random.randn(len(rng)), 'B': rng}) result = df.reindex(lrange(15)) self.assertTrue(np.issubdtype(result['B'].dtype, np.dtype('M8[ns]'))) mask = com.isnull(result)['B'] self.assertTrue(mask[-5:].all()) self.assertFalse(mask[:-5].any()) def test_series_repr_nat(self): series = Series([0, 1000, 2000, iNaT], dtype='M8[ns]') result = repr(series) expected = ('0 1970-01-01 00:00:00\n' '1 1970-01-01 00:00:00.000001\n' '2 1970-01-01 00:00:00.000002\n' '3 NaT\n' 'dtype: datetime64[ns]') self.assertEqual(result, expected) def test_fillna_nat(self): series = Series([0, 1, 2, iNaT], dtype='M8[ns]') filled = series.fillna(method='pad') filled2 = series.fillna(value=series.values[2]) expected = series.copy() expected.values[3] = expected.values[2] assert_series_equal(filled, expected) assert_series_equal(filled2, expected) df = DataFrame({'A': series}) filled = df.fillna(method='pad') filled2 = df.fillna(value=series.values[2]) expected = DataFrame({'A': expected}) assert_frame_equal(filled, expected) assert_frame_equal(filled2, expected) series = Series([iNaT, 0, 1, 2], dtype='M8[ns]') filled = series.fillna(method='bfill') filled2 = series.fillna(value=series[1]) expected = series.copy() expected[0] = expected[1] assert_series_equal(filled, expected) assert_series_equal(filled2, expected) df = DataFrame({'A': series}) filled = df.fillna(method='bfill') filled2 = df.fillna(value=series[1]) expected = DataFrame({'A': expected}) assert_frame_equal(filled, expected) assert_frame_equal(filled2, expected) def test_string_na_nat_conversion(self): # GH #999, #858 from pandas.compat import parse_date strings = np.array(['1/1/2000', '1/2/2000', np.nan, '1/4/2000, 12:34:56'], dtype=object) expected = np.empty(4, dtype='M8[ns]') for i, val in enumerate(strings): if com.isnull(val): expected[i] = iNaT else: expected[i] = parse_date(val) result = tslib.array_to_datetime(strings) assert_almost_equal(result, expected) result2 = to_datetime(strings) tm.assert_isinstance(result2, DatetimeIndex) assert_almost_equal(result, result2) malformed = np.array(['1/100/2000', np.nan], dtype=object) result = to_datetime(malformed) assert_almost_equal(result, malformed) self.assertRaises(ValueError, to_datetime, malformed, errors='raise') idx = ['a', 'b', 'c', 'd', 'e'] series = Series(['1/1/2000', np.nan, '1/3/2000', np.nan, '1/5/2000'], index=idx, name='foo') dseries = Series([to_datetime('1/1/2000'), np.nan, to_datetime('1/3/2000'), np.nan, to_datetime('1/5/2000')], index=idx, name='foo') result = to_datetime(series) dresult = to_datetime(dseries) expected = Series(np.empty(5, dtype='M8[ns]'), index=idx) for i in range(5): x = series[i] if isnull(x): expected[i] = iNaT else: expected[i] = to_datetime(x) assert_series_equal(result, expected) self.assertEqual(result.name, 'foo') assert_series_equal(dresult, expected) self.assertEqual(dresult.name, 'foo') def test_to_datetime_iso8601(self): result = to_datetime(["2012-01-01 00:00:00"]) exp = Timestamp("2012-01-01 00:00:00") self.assertEqual(result[0], exp) result = to_datetime(['20121001']) # bad iso 8601 exp = Timestamp('2012-10-01') self.assertEqual(result[0], exp) def test_to_datetime_default(self): rs = to_datetime('2001') xp = datetime(2001, 1, 1) self.assertTrue(rs, xp) #### dayfirst is essentially broken #### to_datetime('01-13-2012', dayfirst=True) #### self.assertRaises(ValueError, to_datetime('01-13-2012', dayfirst=True)) def test_to_datetime_on_datetime64_series(self): # #2699 s = Series(date_range('1/1/2000', periods=10)) result = to_datetime(s) self.assertEqual(result[0], s[0]) def test_to_datetime_with_apply(self): # this is only locale tested with US/None locales _skip_if_has_locale() # GH 5195 # with a format and coerce a single item to_datetime fails td = Series(['May 04', 'Jun 02', 'Dec 11'], index=[1,2,3]) expected = pd.to_datetime(td, format='%b %y') result = td.apply(pd.to_datetime, format='%b %y') assert_series_equal(result, expected) td = pd.Series(['May 04', 'Jun 02', ''], index=[1,2,3]) self.assertRaises(ValueError, lambda : pd.to_datetime(td,format='%b %y')) self.assertRaises(ValueError, lambda : td.apply(pd.to_datetime, format='%b %y')) expected = pd.to_datetime(td, format='%b %y', coerce=True) result = td.apply(lambda x: pd.to_datetime(x, format='%b %y', coerce=True)) assert_series_equal(result, expected) def test_nat_vector_field_access(self): idx = DatetimeIndex(['1/1/2000', None, None, '1/4/2000']) fields = ['year', 'quarter', 'month', 'day', 'hour', 'minute', 'second', 'microsecond', 'nanosecond', 'week', 'dayofyear'] for field in fields: result = getattr(idx, field) expected = [getattr(x, field) if x is not NaT else -1 for x in idx] self.assert_numpy_array_equal(result, expected) def test_nat_scalar_field_access(self): fields = ['year', 'quarter', 'month', 'day', 'hour', 'minute', 'second', 'microsecond', 'nanosecond', 'week', 'dayofyear'] for field in fields: result = getattr(NaT, field) self.assertEqual(result, -1) self.assertEqual(NaT.weekday(), -1) def test_to_datetime_types(self): # empty string result = to_datetime('') self.assertIs(result, NaT) result = to_datetime(['', '']) self.assertTrue(isnull(result).all()) # ints result = Timestamp(0) expected = to_datetime(0) self.assertEqual(result, expected) # GH 3888 (strings) expected = to_datetime(['2012'])[0] result = to_datetime('2012') self.assertEqual(result, expected) ### array = ['2012','20120101','20120101 12:01:01'] array = ['20120101','20120101 12:01:01'] expected = list(to_datetime(array)) result = lmap(Timestamp,array) tm.assert_almost_equal(result,expected) ### currently fails ### ### result = Timestamp('2012') ### expected = to_datetime('2012') ### self.assertEqual(result, expected) def test_to_datetime_unprocessable_input(self): # GH 4928 self.assert_numpy_array_equal( to_datetime([1, '1']), np.array([1, '1'], dtype='O') ) self.assertRaises(TypeError, to_datetime, [1, '1'], errors='raise') def test_to_datetime_other_datetime64_units(self): # 5/25/2012 scalar = np.int64(1337904000000000).view('M8[us]') as_obj = scalar.astype('O') index = DatetimeIndex([scalar]) self.assertEqual(index[0], scalar.astype('O')) value = Timestamp(scalar) self.assertEqual(value, as_obj) def test_to_datetime_list_of_integers(self): rng = date_range('1/1/2000', periods=20) rng = DatetimeIndex(rng.values) ints = list(rng.asi8) result = DatetimeIndex(ints) self.assertTrue(rng.equals(result)) def test_to_datetime_dt64s(self): in_bound_dts = [ np.datetime64('2000-01-01'), np.datetime64('2000-01-02'), ] for dt in in_bound_dts: self.assertEqual( pd.to_datetime(dt), Timestamp(dt) ) oob_dts = [ np.datetime64('1000-01-01'), np.datetime64('5000-01-02'), ] for dt in oob_dts: self.assertRaises(ValueError, pd.to_datetime, dt, errors='raise') self.assertRaises(ValueError, tslib.Timestamp, dt) self.assertIs(pd.to_datetime(dt, coerce=True), NaT) def test_to_datetime_array_of_dt64s(self): dts = [ np.datetime64('2000-01-01'), np.datetime64('2000-01-02'), ] # Assuming all datetimes are in bounds, to_datetime() returns # an array that is equal to Timestamp() parsing self.assert_numpy_array_equal( pd.to_datetime(dts, box=False), np.array([Timestamp(x).asm8 for x in dts]) ) # A list of datetimes where the last one is out of bounds dts_with_oob = dts + [np.datetime64('9999-01-01')] self.assertRaises( ValueError, pd.to_datetime, dts_with_oob, coerce=False, errors='raise' ) self.assert_numpy_array_equal( pd.to_datetime(dts_with_oob, box=False, coerce=True), np.array( [ Timestamp(dts_with_oob[0]).asm8, Timestamp(dts_with_oob[1]).asm8, iNaT, ], dtype='M8' ) ) # With coerce=False and errors='ignore', out of bounds datetime64s # are converted to their .item(), which depending on the version of # numpy is either a python datetime.datetime or datetime.date self.assert_numpy_array_equal( pd.to_datetime(dts_with_oob, box=False, coerce=False), np.array( [dt.item() for dt in dts_with_oob], dtype='O' ) ) def test_index_to_datetime(self): idx = Index(['1/1/2000', '1/2/2000', '1/3/2000']) result = idx.to_datetime() expected = DatetimeIndex(datetools.to_datetime(idx.values)) self.assertTrue(result.equals(expected)) today = datetime.today() idx = Index([today], dtype=object) result = idx.to_datetime() expected = DatetimeIndex([today]) self.assertTrue(result.equals(expected)) def test_to_datetime_freq(self): xp = bdate_range('2000-1-1', periods=10, tz='UTC') rs = xp.to_datetime() self.assertEqual(xp.freq, rs.freq) self.assertEqual(xp.tzinfo, rs.tzinfo) def test_range_misspecified(self): # GH #1095 self.assertRaises(ValueError, date_range, '1/1/2000') self.assertRaises(ValueError, date_range, end='1/1/2000') self.assertRaises(ValueError, date_range, periods=10) self.assertRaises(ValueError, date_range, '1/1/2000', freq='H') self.assertRaises(ValueError, date_range, end='1/1/2000', freq='H') self.assertRaises(ValueError, date_range, periods=10, freq='H') def test_reasonable_keyerror(self): # GH #1062 index = DatetimeIndex(['1/3/2000']) try: index.get_loc('1/1/2000') except KeyError as e: self.assertIn('2000', str(e)) def test_reindex_with_datetimes(self): rng = date_range('1/1/2000', periods=20) ts = Series(np.random.randn(20), index=rng) result = ts.reindex(list(ts.index[5:10])) expected = ts[5:10] tm.assert_series_equal(result, expected) result = ts[list(ts.index[5:10])] tm.assert_series_equal(result, expected) def test_promote_datetime_date(self): rng = date_range('1/1/2000', periods=20) ts = Series(np.random.randn(20), index=rng) ts_slice = ts[5:] ts2 = ts_slice.copy() ts2.index = [x.date() for x in ts2.index] result = ts + ts2 result2 = ts2 + ts expected = ts + ts[5:] assert_series_equal(result, expected) assert_series_equal(result2, expected) # test asfreq result = ts2.asfreq('4H', method='ffill') expected = ts[5:].asfreq('4H', method='ffill') assert_series_equal(result, expected) result = rng.get_indexer(ts2.index) expected = rng.get_indexer(ts_slice.index) self.assert_numpy_array_equal(result, expected) def test_asfreq_normalize(self): rng = date_range('1/1/2000 09:30', periods=20) norm = date_range('1/1/2000', periods=20) vals = np.random.randn(20) ts = Series(vals, index=rng) result = ts.asfreq('D', normalize=True) norm = date_range('1/1/2000', periods=20) expected = Series(vals, index=norm) assert_series_equal(result, expected) vals = np.random.randn(20, 3) ts = DataFrame(vals, index=rng) result = ts.asfreq('D', normalize=True) expected = DataFrame(vals, index=norm) assert_frame_equal(result, expected) def test_date_range_gen_error(self): rng = date_range('1/1/2000 00:00', '1/1/2000 00:18', freq='5min') self.assertEqual(len(rng), 4) def test_first_subset(self): ts = _simple_ts('1/1/2000', '1/1/2010', freq='12h') result = ts.first('10d') self.assertEqual(len(result), 20) ts = _simple_ts('1/1/2000', '1/1/2010') result = ts.first('10d') self.assertEqual(len(result), 10) result = ts.first('3M') expected = ts[:'3/31/2000'] assert_series_equal(result, expected) result = ts.first('21D') expected = ts[:21] assert_series_equal(result, expected) result = ts[:0].first('3M') assert_series_equal(result, ts[:0]) def test_last_subset(self): ts = _simple_ts('1/1/2000', '1/1/2010', freq='12h') result = ts.last('10d') self.assertEqual(len(result), 20) ts = _simple_ts('1/1/2000', '1/1/2010') result = ts.last('10d') self.assertEqual(len(result), 10) result = ts.last('21D') expected = ts['12/12/2009':] assert_series_equal(result, expected) result = ts.last('21D') expected = ts[-21:] assert_series_equal(result, expected) result = ts[:0].last('3M') assert_series_equal(result, ts[:0]) def test_add_offset(self): rng = date_range('1/1/2000', '2/1/2000') result = rng + offsets.Hour(2) expected = date_range('1/1/2000 02:00', '2/1/2000 02:00') self.assertTrue(result.equals(expected)) def test_format_pre_1900_dates(self): rng = date_range('1/1/1850', '1/1/1950', freq='A-DEC') rng.format() ts = Series(1, index=rng) repr(ts) def test_repeat(self): rng = date_range('1/1/2000', '1/1/2001') result = rng.repeat(5) self.assertIsNone(result.freq) self.assertEqual(len(result), 5 * len(rng)) def test_at_time(self): rng = date_range('1/1/2000', '1/5/2000', freq='5min') ts = Series(np.random.randn(len(rng)), index=rng) rs = ts.at_time(rng[1]) self.assertTrue((rs.index.hour == rng[1].hour).all()) self.assertTrue((rs.index.minute == rng[1].minute).all()) self.assertTrue((rs.index.second == rng[1].second).all()) result = ts.at_time('9:30') expected = ts.at_time(time(9, 30)) assert_series_equal(result, expected) df = DataFrame(np.random.randn(len(rng), 3), index=rng) result = ts[time(9, 30)] result_df = df.ix[time(9, 30)] expected = ts[(rng.hour == 9) & (rng.minute == 30)] exp_df = df[(rng.hour == 9) & (rng.minute == 30)] # expected.index = date_range('1/1/2000', '1/4/2000') assert_series_equal(result, expected) tm.assert_frame_equal(result_df, exp_df) chunk = df.ix['1/4/2000':] result = chunk.ix[time(9, 30)] expected = result_df[-1:] tm.assert_frame_equal(result, expected) # midnight, everything rng = date_range('1/1/2000', '1/31/2000') ts = Series(np.random.randn(len(rng)), index=rng) result = ts.at_time(time(0, 0)) assert_series_equal(result, ts) # time doesn't exist rng = date_range('1/1/2012', freq='23Min', periods=384) ts = Series(np.random.randn(len(rng)), rng) rs = ts.at_time('16:00') self.assertEqual(len(rs), 0) def test_at_time_frame(self): rng = date_range('1/1/2000', '1/5/2000', freq='5min') ts = DataFrame(np.random.randn(len(rng), 2), index=rng) rs = ts.at_time(rng[1]) self.assertTrue((rs.index.hour == rng[1].hour).all()) self.assertTrue((rs.index.minute == rng[1].minute).all()) self.assertTrue((rs.index.second == rng[1].second).all()) result = ts.at_time('9:30') expected = ts.at_time(time(9, 30)) assert_frame_equal(result, expected) result = ts.ix[time(9, 30)] expected = ts.ix[(rng.hour == 9) & (rng.minute == 30)] assert_frame_equal(result, expected) # midnight, everything rng = date_range('1/1/2000', '1/31/2000') ts = DataFrame(np.random.randn(len(rng), 3), index=rng) result = ts.at_time(time(0, 0)) assert_frame_equal(result, ts) # time doesn't exist rng = date_range('1/1/2012', freq='23Min', periods=384) ts = DataFrame(np.random.randn(len(rng), 2), rng) rs = ts.at_time('16:00') self.assertEqual(len(rs), 0) def test_between_time(self): rng = date_range('1/1/2000', '1/5/2000', freq='5min') ts = Series(np.random.randn(len(rng)), index=rng) stime = time(0, 0) etime = time(1, 0) close_open = product([True, False], [True, False]) for inc_start, inc_end in close_open: filtered = ts.between_time(stime, etime, inc_start, inc_end) exp_len = 13 * 4 + 1 if not inc_start: exp_len -= 5 if not inc_end: exp_len -= 4 self.assertEqual(len(filtered), exp_len) for rs in filtered.index: t = rs.time() if inc_start: self.assertTrue(t >= stime) else: self.assertTrue(t > stime) if inc_end: self.assertTrue(t <= etime) else: self.assertTrue(t < etime) result = ts.between_time('00:00', '01:00') expected = ts.between_time(stime, etime) assert_series_equal(result, expected) # across midnight rng = date_range('1/1/2000', '1/5/2000', freq='5min') ts = Series(np.random.randn(len(rng)), index=rng) stime = time(22, 0) etime = time(9, 0) close_open = product([True, False], [True, False]) for inc_start, inc_end in close_open: filtered = ts.between_time(stime, etime, inc_start, inc_end) exp_len = (12 * 11 + 1) * 4 + 1 if not inc_start: exp_len -= 4 if not inc_end: exp_len -= 4 self.assertEqual(len(filtered), exp_len) for rs in filtered.index: t = rs.time() if inc_start: self.assertTrue((t >= stime) or (t <= etime)) else: self.assertTrue((t > stime) or (t <= etime)) if inc_end: self.assertTrue((t <= etime) or (t >= stime)) else: self.assertTrue((t < etime) or (t >= stime)) def test_between_time_frame(self): rng = date_range('1/1/2000', '1/5/2000', freq='5min') ts = DataFrame(np.random.randn(len(rng), 2), index=rng) stime = time(0, 0) etime = time(1, 0) close_open = product([True, False], [True, False]) for inc_start, inc_end in close_open: filtered = ts.between_time(stime, etime, inc_start, inc_end) exp_len = 13 * 4 + 1 if not inc_start: exp_len -= 5 if not inc_end: exp_len -= 4 self.assertEqual(len(filtered), exp_len) for rs in filtered.index: t = rs.time() if inc_start: self.assertTrue(t >= stime) else: self.assertTrue(t > stime) if inc_end: self.assertTrue(t <= etime) else: self.assertTrue(t < etime) result = ts.between_time('00:00', '01:00') expected = ts.between_time(stime, etime) assert_frame_equal(result, expected) # across midnight rng = date_range('1/1/2000', '1/5/2000', freq='5min') ts = DataFrame(np.random.randn(len(rng), 2), index=rng) stime = time(22, 0) etime = time(9, 0) close_open = product([True, False], [True, False]) for inc_start, inc_end in close_open: filtered = ts.between_time(stime, etime, inc_start, inc_end) exp_len = (12 * 11 + 1) * 4 + 1 if not inc_start: exp_len -= 4 if not inc_end: exp_len -= 4 self.assertEqual(len(filtered), exp_len) for rs in filtered.index: t = rs.time() if inc_start: self.assertTrue((t >= stime) or (t <= etime)) else: self.assertTrue((t > stime) or (t <= etime)) if inc_end: self.assertTrue((t <= etime) or (t >= stime)) else: self.assertTrue((t < etime) or (t >= stime)) def test_dti_constructor_preserve_dti_freq(self): rng = date_range('1/1/2000', '1/2/2000', freq='5min') rng2 = DatetimeIndex(rng) self.assertEqual(rng.freq, rng2.freq) def test_normalize(self): rng = date_range('1/1/2000 9:30', periods=10, freq='D') result = rng.normalize() expected = date_range('1/1/2000', periods=10, freq='D') self.assertTrue(result.equals(expected)) rng_ns = pd.DatetimeIndex(np.array([1380585623454345752, 1380585612343234312]).astype("datetime64[ns]")) rng_ns_normalized = rng_ns.normalize() expected = pd.DatetimeIndex(np.array([1380585600000000000, 1380585600000000000]).astype("datetime64[ns]")) self.assertTrue(rng_ns_normalized.equals(expected)) self.assertTrue(result.is_normalized) self.assertFalse(rng.is_normalized) def test_to_period(self): from pandas.tseries.period import period_range ts = _simple_ts('1/1/2000', '1/1/2001') pts = ts.to_period() exp = ts.copy() exp.index = period_range('1/1/2000', '1/1/2001') assert_series_equal(pts, exp) pts = ts.to_period('M') self.assertTrue(pts.index.equals(exp.index.asfreq('M'))) def create_dt64_based_index(self): data = [Timestamp('2007-01-01 10:11:12.123456Z'), Timestamp('2007-01-01 10:11:13.789123Z')] index = DatetimeIndex(data) return index def test_to_period_millisecond(self): index = self.create_dt64_based_index() period = index.to_period(freq='L') self.assertEqual(2, len(period)) self.assertEqual(period[0], Period('2007-01-01 10:11:12.123Z', 'L')) self.assertEqual(period[1], Period('2007-01-01 10:11:13.789Z', 'L')) def test_to_period_microsecond(self): index = self.create_dt64_based_index() period = index.to_period(freq='U') self.assertEqual(2, len(period)) self.assertEqual(period[0],
Period('2007-01-01 10:11:12.123456Z', 'U')
pandas.Period
import os import numpy as np import math import pandas as pd import sys import joblib import sklearn.metrics from math import sqrt from sklearn.neural_network import MLPRegressor from sklearn.metrics import mean_squared_error from sklearn import preprocessing base_path = os.path.dirname(os.path.abspath(__file__)) #'''/home/arakka/visibility-china/preprocessing/src/models''' def main(): if len(sys.argv) < 2: print ('Number of arguments:',len(sys.argv)) print (str(sys.argv[1])) print ('Usage: ./predict_model.py input_test_lcn') sys.exit(0) st=str(sys.argv[1]) stn=st[0:4] #load data data =
pd.read_csv(base_path+"/../../data/test_data/"+stn+".csv", sep=",")
pandas.read_csv
# -*- coding: utf-8 -*- # pylint: disable=E1101 # flake8: noqa from datetime import datetime import csv import os import sys import re import nose import platform from multiprocessing.pool import ThreadPool from numpy import nan import numpy as np from pandas.io.common import DtypeWarning from pandas import DataFrame, Series, Index, MultiIndex, DatetimeIndex from pandas.compat import( StringIO, BytesIO, PY3, range, long, lrange, lmap, u ) from pandas.io.common import URLError import pandas.io.parsers as parsers from pandas.io.parsers import (read_csv, read_table, read_fwf, TextFileReader, TextParser) import pandas.util.testing as tm import pandas as pd from pandas.compat import parse_date import pandas.lib as lib from pandas import compat from pandas.lib import Timestamp from pandas.tseries.index import date_range import pandas.tseries.tools as tools from numpy.testing.decorators import slow import pandas.parser class ParserTests(object): """ Want to be able to test either C+Cython or Python+Cython parsers """ data1 = """index,A,B,C,D foo,2,3,4,5 bar,7,8,9,10 baz,12,13,14,15 qux,12,13,14,15 foo2,12,13,14,15 bar2,12,13,14,15 """ def read_csv(self, *args, **kwargs): raise NotImplementedError def read_table(self, *args, **kwargs): raise NotImplementedError def setUp(self): import warnings warnings.filterwarnings(action='ignore', category=FutureWarning) self.dirpath = tm.get_data_path() self.csv1 = os.path.join(self.dirpath, 'test1.csv') self.csv2 = os.path.join(self.dirpath, 'test2.csv') self.xls1 = os.path.join(self.dirpath, 'test.xls') def construct_dataframe(self, num_rows): df = DataFrame(np.random.rand(num_rows, 5), columns=list('abcde')) df['foo'] = 'foo' df['bar'] = 'bar' df['baz'] = 'baz' df['date'] = pd.date_range('20000101 09:00:00', periods=num_rows, freq='s') df['int'] = np.arange(num_rows, dtype='int64') return df def generate_multithread_dataframe(self, path, num_rows, num_tasks): def reader(arg): start, nrows = arg if not start: return pd.read_csv(path, index_col=0, header=0, nrows=nrows, parse_dates=['date']) return pd.read_csv(path, index_col=0, header=None, skiprows=int(start) + 1, nrows=nrows, parse_dates=[9]) tasks = [ (num_rows * i / num_tasks, num_rows / num_tasks) for i in range(num_tasks) ] pool = ThreadPool(processes=num_tasks) results = pool.map(reader, tasks) header = results[0].columns for r in results[1:]: r.columns = header final_dataframe = pd.concat(results) return final_dataframe def test_converters_type_must_be_dict(self): with tm.assertRaisesRegexp(TypeError, 'Type converters.+'): self.read_csv(StringIO(self.data1), converters=0) def test_empty_decimal_marker(self): data = """A|B|C 1|2,334|5 10|13|10. """ self.assertRaises(ValueError, read_csv, StringIO(data), decimal='') def test_empty_thousands_marker(self): data = """A|B|C 1|2,334|5 10|13|10. """ self.assertRaises(ValueError, read_csv, StringIO(data), thousands='') def test_multi_character_decimal_marker(self): data = """A|B|C 1|2,334|5 10|13|10. """ self.assertRaises(ValueError, read_csv, StringIO(data), thousands=',,') def test_empty_string(self): data = """\ One,Two,Three a,1,one b,2,two ,3,three d,4,nan e,5,five nan,6, g,7,seven """ df = self.read_csv(StringIO(data)) xp = DataFrame({'One': ['a', 'b', np.nan, 'd', 'e', np.nan, 'g'], 'Two': [1, 2, 3, 4, 5, 6, 7], 'Three': ['one', 'two', 'three', np.nan, 'five', np.nan, 'seven']}) tm.assert_frame_equal(xp.reindex(columns=df.columns), df) df = self.read_csv(StringIO(data), na_values={'One': [], 'Three': []}, keep_default_na=False) xp = DataFrame({'One': ['a', 'b', '', 'd', 'e', 'nan', 'g'], 'Two': [1, 2, 3, 4, 5, 6, 7], 'Three': ['one', 'two', 'three', 'nan', 'five', '', 'seven']}) tm.assert_frame_equal(xp.reindex(columns=df.columns), df) df = self.read_csv( StringIO(data), na_values=['a'], keep_default_na=False) xp = DataFrame({'One': [np.nan, 'b', '', 'd', 'e', 'nan', 'g'], 'Two': [1, 2, 3, 4, 5, 6, 7], 'Three': ['one', 'two', 'three', 'nan', 'five', '', 'seven']}) tm.assert_frame_equal(xp.reindex(columns=df.columns), df) df = self.read_csv(StringIO(data), na_values={'One': [], 'Three': []}) xp = DataFrame({'One': ['a', 'b', np.nan, 'd', 'e', np.nan, 'g'], 'Two': [1, 2, 3, 4, 5, 6, 7], 'Three': ['one', 'two', 'three', np.nan, 'five', np.nan, 'seven']}) tm.assert_frame_equal(xp.reindex(columns=df.columns), df) # GH4318, passing na_values=None and keep_default_na=False yields # 'None' as a na_value data = """\ One,Two,Three a,1,None b,2,two ,3,None d,4,nan e,5,five nan,6, g,7,seven """ df = self.read_csv( StringIO(data), keep_default_na=False) xp = DataFrame({'One': ['a', 'b', '', 'd', 'e', 'nan', 'g'], 'Two': [1, 2, 3, 4, 5, 6, 7], 'Three': ['None', 'two', 'None', 'nan', 'five', '', 'seven']}) tm.assert_frame_equal(xp.reindex(columns=df.columns), df) def test_read_csv(self): if not compat.PY3: if compat.is_platform_windows(): prefix = u("file:///") else: prefix = u("file://") fname = prefix + compat.text_type(self.csv1) # it works! read_csv(fname, index_col=0, parse_dates=True) def test_dialect(self): data = """\ label1,label2,label3 index1,"a,c,e index2,b,d,f """ dia = csv.excel() dia.quoting = csv.QUOTE_NONE df = self.read_csv(StringIO(data), dialect=dia) data = '''\ label1,label2,label3 index1,a,c,e index2,b,d,f ''' exp = self.read_csv(StringIO(data)) exp.replace('a', '"a', inplace=True) tm.assert_frame_equal(df, exp) def test_dialect_str(self): data = """\ fruit:vegetable apple:brocolli pear:tomato """ exp = DataFrame({ 'fruit': ['apple', 'pear'], 'vegetable': ['brocolli', 'tomato'] }) dia = csv.register_dialect('mydialect', delimiter=':') # noqa df = self.read_csv(StringIO(data), dialect='mydialect') tm.assert_frame_equal(df, exp) csv.unregister_dialect('mydialect') def test_1000_sep(self): data = """A|B|C 1|2,334|5 10|13|10. """ expected = DataFrame({ 'A': [1, 10], 'B': [2334, 13], 'C': [5, 10.] }) df = self.read_csv(StringIO(data), sep='|', thousands=',') tm.assert_frame_equal(df, expected) df = self.read_table(StringIO(data), sep='|', thousands=',') tm.assert_frame_equal(df, expected) def test_1000_sep_with_decimal(self): data = """A|B|C 1|2,334.01|5 10|13|10. """ expected = DataFrame({ 'A': [1, 10], 'B': [2334.01, 13], 'C': [5, 10.] }) tm.assert_equal(expected.A.dtype, 'int64') tm.assert_equal(expected.B.dtype, 'float') tm.assert_equal(expected.C.dtype, 'float') df = self.read_csv(StringIO(data), sep='|', thousands=',', decimal='.') tm.assert_frame_equal(df, expected) df = self.read_table(StringIO(data), sep='|', thousands=',', decimal='.') tm.assert_frame_equal(df, expected) data_with_odd_sep = """A|B|C 1|2.334,01|5 10|13|10, """ df = self.read_csv(StringIO(data_with_odd_sep), sep='|', thousands='.', decimal=',') tm.assert_frame_equal(df, expected) df = self.read_table(StringIO(data_with_odd_sep), sep='|', thousands='.', decimal=',') tm.assert_frame_equal(df, expected) def test_separator_date_conflict(self): # Regression test for issue #4678: make sure thousands separator and # date parsing do not conflict. data = '06-02-2013;13:00;1-000.215' expected = DataFrame( [[datetime(2013, 6, 2, 13, 0, 0), 1000.215]], columns=['Date', 2] ) df = self.read_csv(StringIO(data), sep=';', thousands='-', parse_dates={'Date': [0, 1]}, header=None) tm.assert_frame_equal(df, expected) def test_squeeze(self): data = """\ a,1 b,2 c,3 """ idx = Index(['a', 'b', 'c'], name=0) expected = Series([1, 2, 3], name=1, index=idx) result = self.read_table(StringIO(data), sep=',', index_col=0, header=None, squeeze=True) tm.assertIsInstance(result, Series) tm.assert_series_equal(result, expected) def test_squeeze_no_view(self): # GH 8217 # series should not be a view data = """time,data\n0,10\n1,11\n2,12\n4,14\n5,15\n3,13""" result = self.read_csv(StringIO(data), index_col='time', squeeze=True) self.assertFalse(result._is_view) def test_inf_parsing(self): data = """\ ,A a,inf b,-inf c,Inf d,-Inf e,INF f,-INF g,INf h,-INf i,inF j,-inF""" inf = float('inf') expected = Series([inf, -inf] * 5) df = read_csv(StringIO(data), index_col=0) tm.assert_almost_equal(df['A'].values, expected.values) df = read_csv(StringIO(data), index_col=0, na_filter=False) tm.assert_almost_equal(df['A'].values, expected.values) def test_multiple_date_col(self): # Can use multiple date parsers data = """\ KORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000 KORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000 KORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000 KORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000 KORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000 KORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000 """ def func(*date_cols): return lib.try_parse_dates(parsers._concat_date_cols(date_cols)) df = self.read_csv(StringIO(data), header=None, date_parser=func, prefix='X', parse_dates={'nominal': [1, 2], 'actual': [1, 3]}) self.assertIn('nominal', df) self.assertIn('actual', df) self.assertNotIn('X1', df) self.assertNotIn('X2', df) self.assertNotIn('X3', df) d = datetime(1999, 1, 27, 19, 0) self.assertEqual(df.ix[0, 'nominal'], d) df = self.read_csv(StringIO(data), header=None, date_parser=func, parse_dates={'nominal': [1, 2], 'actual': [1, 3]}, keep_date_col=True) self.assertIn('nominal', df) self.assertIn('actual', df) self.assertIn(1, df) self.assertIn(2, df) self.assertIn(3, df) data = """\ KORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000 KORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000 KORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000 KORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000 KORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000 KORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000 """ df = read_csv(StringIO(data), header=None, prefix='X', parse_dates=[[1, 2], [1, 3]]) self.assertIn('X1_X2', df) self.assertIn('X1_X3', df) self.assertNotIn('X1', df) self.assertNotIn('X2', df) self.assertNotIn('X3', df) d = datetime(1999, 1, 27, 19, 0) self.assertEqual(df.ix[0, 'X1_X2'], d) df = read_csv(StringIO(data), header=None, parse_dates=[[1, 2], [1, 3]], keep_date_col=True) self.assertIn('1_2', df) self.assertIn('1_3', df) self.assertIn(1, df) self.assertIn(2, df) self.assertIn(3, df) data = '''\ KORD,19990127 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000 KORD,19990127 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000 KORD,19990127 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000 KORD,19990127 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000 KORD,19990127 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000 ''' df = self.read_csv(StringIO(data), sep=',', header=None, parse_dates=[1], index_col=1) d = datetime(1999, 1, 27, 19, 0) self.assertEqual(df.index[0], d) def test_multiple_date_cols_int_cast(self): data = ("KORD,19990127, 19:00:00, 18:56:00, 0.8100\n" "KORD,19990127, 20:00:00, 19:56:00, 0.0100\n" "KORD,19990127, 21:00:00, 20:56:00, -0.5900\n" "KORD,19990127, 21:00:00, 21:18:00, -0.9900\n" "KORD,19990127, 22:00:00, 21:56:00, -0.5900\n" "KORD,19990127, 23:00:00, 22:56:00, -0.5900") date_spec = {'nominal': [1, 2], 'actual': [1, 3]} import pandas.io.date_converters as conv # it works! df = self.read_csv(StringIO(data), header=None, parse_dates=date_spec, date_parser=conv.parse_date_time) self.assertIn('nominal', df) def test_multiple_date_col_timestamp_parse(self): data = """05/31/2012,15:30:00.029,1306.25,1,E,0,,1306.25 05/31/2012,15:30:00.029,1306.25,8,E,0,,1306.25""" result = self.read_csv(StringIO(data), sep=',', header=None, parse_dates=[[0, 1]], date_parser=Timestamp) ex_val = Timestamp('05/31/2012 15:30:00.029') self.assertEqual(result['0_1'][0], ex_val) def test_single_line(self): # GH 6607 # Test currently only valid with python engine because sep=None and # delim_whitespace=False. Temporarily copied to TestPythonParser. # Test for ValueError with other engines: with tm.assertRaisesRegexp(ValueError, 'sep=None with delim_whitespace=False'): # sniff separator buf = StringIO() sys.stdout = buf # printing warning message when engine == 'c' for now try: # it works! df = self.read_csv(StringIO('1,2'), names=['a', 'b'], header=None, sep=None) tm.assert_frame_equal(DataFrame({'a': [1], 'b': [2]}), df) finally: sys.stdout = sys.__stdout__ def test_multiple_date_cols_with_header(self): data = """\ ID,date,NominalTime,ActualTime,TDew,TAir,Windspeed,Precip,WindDir KORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000 KORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000 KORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000 KORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000 KORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000 KORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000""" df = self.read_csv(StringIO(data), parse_dates={'nominal': [1, 2]}) self.assertNotIsInstance(df.nominal[0], compat.string_types) ts_data = """\ ID,date,nominalTime,actualTime,A,B,C,D,E KORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000 KORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000 KORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000 KORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000 KORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000 KORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000 """ def test_multiple_date_col_name_collision(self): self.assertRaises(ValueError, self.read_csv, StringIO(self.ts_data), parse_dates={'ID': [1, 2]}) data = """\ date_NominalTime,date,NominalTime,ActualTime,TDew,TAir,Windspeed,Precip,WindDir KORD1,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000 KORD2,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000 KORD3,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000 KORD4,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000 KORD5,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000 KORD6,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000""" # noqa self.assertRaises(ValueError, self.read_csv, StringIO(data), parse_dates=[[1, 2]]) def test_index_col_named(self): no_header = """\ KORD1,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000 KORD2,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000 KORD3,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000 KORD4,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000 KORD5,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000 KORD6,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000""" h = "ID,date,NominalTime,ActualTime,TDew,TAir,Windspeed,Precip,WindDir\n" data = h + no_header rs = self.read_csv(StringIO(data), index_col='ID') xp = self.read_csv(StringIO(data), header=0).set_index('ID') tm.assert_frame_equal(rs, xp) self.assertRaises(ValueError, self.read_csv, StringIO(no_header), index_col='ID') data = """\ 1,2,3,4,hello 5,6,7,8,world 9,10,11,12,foo """ names = ['a', 'b', 'c', 'd', 'message'] xp = DataFrame({'a': [1, 5, 9], 'b': [2, 6, 10], 'c': [3, 7, 11], 'd': [4, 8, 12]}, index=Index(['hello', 'world', 'foo'], name='message')) rs = self.read_csv(StringIO(data), names=names, index_col=['message']) tm.assert_frame_equal(xp, rs) self.assertEqual(xp.index.name, rs.index.name) rs = self.read_csv(StringIO(data), names=names, index_col='message') tm.assert_frame_equal(xp, rs) self.assertEqual(xp.index.name, rs.index.name) def test_usecols_index_col_False(self): # Issue 9082 s = "a,b,c,d\n1,2,3,4\n5,6,7,8" s_malformed = "a,b,c,d\n1,2,3,4,\n5,6,7,8," cols = ['a', 'c', 'd'] expected = DataFrame({'a': [1, 5], 'c': [3, 7], 'd': [4, 8]}) df = self.read_csv(StringIO(s), usecols=cols, index_col=False) tm.assert_frame_equal(expected, df) df = self.read_csv(StringIO(s_malformed), usecols=cols, index_col=False) tm.assert_frame_equal(expected, df) def test_index_col_is_True(self): # Issue 9798 self.assertRaises(ValueError, self.read_csv, StringIO(self.ts_data), index_col=True) def test_converter_index_col_bug(self): # 1835 data = "A;B\n1;2\n3;4" rs = self.read_csv(StringIO(data), sep=';', index_col='A', converters={'A': lambda x: x}) xp = DataFrame({'B': [2, 4]}, index=Index([1, 3], name='A')) tm.assert_frame_equal(rs, xp) self.assertEqual(rs.index.name, xp.index.name) def test_date_parser_int_bug(self): # #3071 log_file = StringIO( 'posix_timestamp,elapsed,sys,user,queries,query_time,rows,' 'accountid,userid,contactid,level,silo,method\n' '1343103150,0.062353,0,4,6,0.01690,3,' '12345,1,-1,3,invoice_InvoiceResource,search\n' ) def f(posix_string): return datetime.utcfromtimestamp(int(posix_string)) # it works! read_csv(log_file, index_col=0, parse_dates=0, date_parser=f) def test_multiple_skts_example(self): data = "year, month, a, b\n 2001, 01, 0.0, 10.\n 2001, 02, 1.1, 11." pass def test_malformed(self): # all data = """ignore A,B,C 1,2,3 # comment 1,2,3,4,5 2,3,4 """ try: df = self.read_table( StringIO(data), sep=',', header=1, comment='#') self.assertTrue(False) except Exception as inst: self.assertIn('Expected 3 fields in line 4, saw 5', str(inst)) # skip_footer data = """ignore A,B,C 1,2,3 # comment 1,2,3,4,5 2,3,4 footer """ # GH 6607 # Test currently only valid with python engine because # skip_footer != 0. Temporarily copied to TestPythonParser. # Test for ValueError with other engines: try: with tm.assertRaisesRegexp(ValueError, 'skip_footer'): # XXX df = self.read_table( StringIO(data), sep=',', header=1, comment='#', skip_footer=1) self.assertTrue(False) except Exception as inst: self.assertIn('Expected 3 fields in line 4, saw 5', str(inst)) # first chunk data = """ignore A,B,C skip 1,2,3 3,5,10 # comment 1,2,3,4,5 2,3,4 """ try: it = self.read_table(StringIO(data), sep=',', header=1, comment='#', iterator=True, chunksize=1, skiprows=[2]) df = it.read(5) self.assertTrue(False) except Exception as inst: self.assertIn('Expected 3 fields in line 6, saw 5', str(inst)) # middle chunk data = """ignore A,B,C skip 1,2,3 3,5,10 # comment 1,2,3,4,5 2,3,4 """ try: it = self.read_table(StringIO(data), sep=',', header=1, comment='#', iterator=True, chunksize=1, skiprows=[2]) df = it.read(1) it.read(2) self.assertTrue(False) except Exception as inst: self.assertIn('Expected 3 fields in line 6, saw 5', str(inst)) # last chunk data = """ignore A,B,C skip 1,2,3 3,5,10 # comment 1,2,3,4,5 2,3,4 """ try: it = self.read_table(StringIO(data), sep=',', header=1, comment='#', iterator=True, chunksize=1, skiprows=[2]) df = it.read(1) it.read() self.assertTrue(False) except Exception as inst: self.assertIn('Expected 3 fields in line 6, saw 5', str(inst)) def test_passing_dtype(self): # GH 6607 # Passing dtype is currently only supported by the C engine. # Temporarily copied to TestCParser*. # Test for ValueError with other engines: with tm.assertRaisesRegexp(ValueError, "The 'dtype' option is not supported"): df = DataFrame(np.random.rand(5, 2), columns=list( 'AB'), index=['1A', '1B', '1C', '1D', '1E']) with tm.ensure_clean('__passing_str_as_dtype__.csv') as path: df.to_csv(path) # GH 3795 # passing 'str' as the dtype result = self.read_csv(path, dtype=str, index_col=0) tm.assert_series_equal(result.dtypes, Series( {'A': 'object', 'B': 'object'})) # we expect all object columns, so need to convert to test for # equivalence result = result.astype(float) tm.assert_frame_equal(result, df) # invalid dtype self.assertRaises(TypeError, self.read_csv, path, dtype={'A': 'foo', 'B': 'float64'}, index_col=0) # valid but we don't support it (date) self.assertRaises(TypeError, self.read_csv, path, dtype={'A': 'datetime64', 'B': 'float64'}, index_col=0) self.assertRaises(TypeError, self.read_csv, path, dtype={'A': 'datetime64', 'B': 'float64'}, index_col=0, parse_dates=['B']) # valid but we don't support it self.assertRaises(TypeError, self.read_csv, path, dtype={'A': 'timedelta64', 'B': 'float64'}, index_col=0) with tm.assertRaisesRegexp(ValueError, "The 'dtype' option is not supported"): # empty frame # GH12048 self.read_csv(StringIO('A,B'), dtype=str) def test_quoting(self): bad_line_small = """printer\tresult\tvariant_name Klosterdruckerei\tKlosterdruckerei <Salem> (1611-1804)\tMuller, Jacob Klosterdruckerei\tKlosterdruckerei <Salem> (1611-1804)\tMuller, Jakob Klosterdruckerei\tKlosterdruckerei <Kempten> (1609-1805)\t"Furststiftische Hofdruckerei, <Kempten"" Klosterdruckerei\tKlosterdruckerei <Kempten> (1609-1805)\tGaller, Alois Klosterdruckerei\tKlosterdruckerei <Kempten> (1609-1805)\tHochfurstliche Buchhandlung <Kempten>""" self.assertRaises(Exception, self.read_table, StringIO(bad_line_small), sep='\t') good_line_small = bad_line_small + '"' df = self.read_table(StringIO(good_line_small), sep='\t') self.assertEqual(len(df), 3) def test_non_string_na_values(self): # GH3611, na_values that are not a string are an issue with tm.ensure_clean('__non_string_na_values__.csv') as path: df = DataFrame({'A': [-999, 2, 3], 'B': [1.2, -999, 4.5]}) df.to_csv(path, sep=' ', index=False) result1 = read_csv(path, sep=' ', header=0, na_values=['-999.0', '-999']) result2 = read_csv(path, sep=' ', header=0, na_values=[-999, -999.0]) result3 = read_csv(path, sep=' ', header=0, na_values=[-999.0, -999]) tm.assert_frame_equal(result1, result2) tm.assert_frame_equal(result2, result3) result4 = read_csv(path, sep=' ', header=0, na_values=['-999.0']) result5 = read_csv(path, sep=' ', header=0, na_values=['-999']) result6 = read_csv(path, sep=' ', header=0, na_values=[-999.0]) result7 = read_csv(path, sep=' ', header=0, na_values=[-999]) tm.assert_frame_equal(result4, result3) tm.assert_frame_equal(result5, result3) tm.assert_frame_equal(result6, result3) tm.assert_frame_equal(result7, result3) good_compare = result3 # with an odd float format, so we can't match the string 999.0 # exactly, but need float matching df.to_csv(path, sep=' ', index=False, float_format='%.3f') result1 = read_csv(path, sep=' ', header=0, na_values=['-999.0', '-999']) result2 = read_csv(path, sep=' ', header=0, na_values=[-999, -999.0]) result3 = read_csv(path, sep=' ', header=0, na_values=[-999.0, -999]) tm.assert_frame_equal(result1, good_compare) tm.assert_frame_equal(result2, good_compare) tm.assert_frame_equal(result3, good_compare) result4 = read_csv(path, sep=' ', header=0, na_values=['-999.0']) result5 = read_csv(path, sep=' ', header=0, na_values=['-999']) result6 = read_csv(path, sep=' ', header=0, na_values=[-999.0]) result7 = read_csv(path, sep=' ', header=0, na_values=[-999]) tm.assert_frame_equal(result4, good_compare) tm.assert_frame_equal(result5, good_compare) tm.assert_frame_equal(result6, good_compare) tm.assert_frame_equal(result7, good_compare) def test_default_na_values(self): _NA_VALUES = set(['-1.#IND', '1.#QNAN', '1.#IND', '-1.#QNAN', '#N/A', 'N/A', 'NA', '#NA', 'NULL', 'NaN', 'nan', '-NaN', '-nan', '#N/A N/A', '']) self.assertEqual(_NA_VALUES, parsers._NA_VALUES) nv = len(_NA_VALUES) def f(i, v): if i == 0: buf = '' elif i > 0: buf = ''.join([','] * i) buf = "{0}{1}".format(buf, v) if i < nv - 1: buf = "{0}{1}".format(buf, ''.join([','] * (nv - i - 1))) return buf data = StringIO('\n'.join([f(i, v) for i, v in enumerate(_NA_VALUES)])) expected = DataFrame(np.nan, columns=range(nv), index=range(nv)) df = self.read_csv(data, header=None) tm.assert_frame_equal(df, expected) def test_custom_na_values(self): data = """A,B,C ignore,this,row 1,NA,3 -1.#IND,5,baz 7,8,NaN """ expected = [[1., nan, 3], [nan, 5, nan], [7, 8, nan]] df = self.read_csv(StringIO(data), na_values=['baz'], skiprows=[1]) tm.assert_almost_equal(df.values, expected) df2 = self.read_table(StringIO(data), sep=',', na_values=['baz'], skiprows=[1]) tm.assert_almost_equal(df2.values, expected) df3 = self.read_table(StringIO(data), sep=',', na_values='baz', skiprows=[1]) tm.assert_almost_equal(df3.values, expected) def test_nat_parse(self): # GH 3062 df = DataFrame(dict({ 'A': np.asarray(lrange(10), dtype='float64'), 'B': pd.Timestamp('20010101')})) df.iloc[3:6, :] = np.nan with tm.ensure_clean('__nat_parse_.csv') as path: df.to_csv(path) result = read_csv(path, index_col=0, parse_dates=['B']) tm.assert_frame_equal(result, df) expected = Series(dict(A='float64', B='datetime64[ns]')) tm.assert_series_equal(expected, result.dtypes) # test with NaT for the nan_rep # we don't have a method to specif the Datetime na_rep (it defaults # to '') df.to_csv(path) result = read_csv(path, index_col=0, parse_dates=['B']) tm.assert_frame_equal(result, df) def test_skiprows_bug(self): # GH #505 text = """#foo,a,b,c #foo,a,b,c #foo,a,b,c #foo,a,b,c #foo,a,b,c #foo,a,b,c 1/1/2000,1.,2.,3. 1/2/2000,4,5,6 1/3/2000,7,8,9 """ data = self.read_csv(StringIO(text), skiprows=lrange(6), header=None, index_col=0, parse_dates=True) data2 = self.read_csv(StringIO(text), skiprows=6, header=None, index_col=0, parse_dates=True) expected = DataFrame(np.arange(1., 10.).reshape((3, 3)), columns=[1, 2, 3], index=[datetime(2000, 1, 1), datetime(2000, 1, 2), datetime(2000, 1, 3)]) expected.index.name = 0 tm.assert_frame_equal(data, expected) tm.assert_frame_equal(data, data2) def test_deep_skiprows(self): # GH #4382 text = "a,b,c\n" + \ "\n".join([",".join([str(i), str(i + 1), str(i + 2)]) for i in range(10)]) condensed_text = "a,b,c\n" + \ "\n".join([",".join([str(i), str(i + 1), str(i + 2)]) for i in [0, 1, 2, 3, 4, 6, 8, 9]]) data = self.read_csv(StringIO(text), skiprows=[6, 8]) condensed_data = self.read_csv(StringIO(condensed_text)) tm.assert_frame_equal(data, condensed_data) def test_skiprows_blank(self): # GH 9832 text = """#foo,a,b,c #foo,a,b,c #foo,a,b,c #foo,a,b,c 1/1/2000,1.,2.,3. 1/2/2000,4,5,6 1/3/2000,7,8,9 """ data = self.read_csv(StringIO(text), skiprows=6, header=None, index_col=0, parse_dates=True) expected = DataFrame(np.arange(1., 10.).reshape((3, 3)), columns=[1, 2, 3], index=[datetime(2000, 1, 1), datetime(2000, 1, 2), datetime(2000, 1, 3)]) expected.index.name = 0 tm.assert_frame_equal(data, expected) def test_detect_string_na(self): data = """A,B foo,bar NA,baz NaN,nan """ expected = [['foo', 'bar'], [nan, 'baz'], [nan, nan]] df = self.read_csv(StringIO(data)) tm.assert_almost_equal(df.values, expected) def test_unnamed_columns(self): data = """A,B,C,, 1,2,3,4,5 6,7,8,9,10 11,12,13,14,15 """ expected = [[1, 2, 3, 4, 5.], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]] df = self.read_table(StringIO(data), sep=',') tm.assert_almost_equal(df.values, expected) self.assert_numpy_array_equal(df.columns, ['A', 'B', 'C', 'Unnamed: 3', 'Unnamed: 4']) def test_string_nas(self): data = """A,B,C a,b,c d,,f ,g,h """ result = self.read_csv(StringIO(data)) expected = DataFrame([['a', 'b', 'c'], ['d', np.nan, 'f'], [np.nan, 'g', 'h']], columns=['A', 'B', 'C']) tm.assert_frame_equal(result, expected) def test_duplicate_columns(self): for engine in ['python', 'c']: data = """A,A,B,B,B 1,2,3,4,5 6,7,8,9,10 11,12,13,14,15 """ # check default beahviour df = self.read_table(StringIO(data), sep=',', engine=engine) self.assertEqual(list(df.columns), ['A', 'A.1', 'B', 'B.1', 'B.2']) df = self.read_table(StringIO(data), sep=',', engine=engine, mangle_dupe_cols=False) self.assertEqual(list(df.columns), ['A', 'A', 'B', 'B', 'B']) df = self.read_table(StringIO(data), sep=',', engine=engine, mangle_dupe_cols=True) self.assertEqual(list(df.columns), ['A', 'A.1', 'B', 'B.1', 'B.2']) def test_csv_mixed_type(self): data = """A,B,C a,1,2 b,3,4 c,4,5 """ df = self.read_csv(StringIO(data)) # TODO def test_csv_custom_parser(self): data = """A,B,C 20090101,a,1,2 20090102,b,3,4 20090103,c,4,5 """ f = lambda x: datetime.strptime(x, '%Y%m%d') df = self.read_csv(StringIO(data), date_parser=f) expected = self.read_csv(StringIO(data), parse_dates=True) tm.assert_frame_equal(df, expected) def test_parse_dates_implicit_first_col(self): data = """A,B,C 20090101,a,1,2 20090102,b,3,4 20090103,c,4,5 """ df = self.read_csv(StringIO(data), parse_dates=True) expected = self.read_csv(StringIO(data), index_col=0, parse_dates=True) self.assertIsInstance( df.index[0], (datetime, np.datetime64, Timestamp)) tm.assert_frame_equal(df, expected) def test_parse_dates_string(self): data = """date,A,B,C 20090101,a,1,2 20090102,b,3,4 20090103,c,4,5 """ rs = self.read_csv( StringIO(data), index_col='date', parse_dates='date') idx = date_range('1/1/2009', periods=3) idx.name = 'date' xp = DataFrame({'A': ['a', 'b', 'c'], 'B': [1, 3, 4], 'C': [2, 4, 5]}, idx) tm.assert_frame_equal(rs, xp) def test_yy_format(self): data = """date,time,B,C 090131,0010,1,2 090228,1020,3,4 090331,0830,5,6 """ rs = self.read_csv(StringIO(data), index_col=0, parse_dates=[['date', 'time']]) idx = DatetimeIndex([datetime(2009, 1, 31, 0, 10, 0), datetime(2009, 2, 28, 10, 20, 0), datetime(2009, 3, 31, 8, 30, 0)], dtype=object, name='date_time') xp = DataFrame({'B': [1, 3, 5], 'C': [2, 4, 6]}, idx) tm.assert_frame_equal(rs, xp) rs = self.read_csv(StringIO(data), index_col=0, parse_dates=[[0, 1]]) idx = DatetimeIndex([datetime(2009, 1, 31, 0, 10, 0), datetime(2009, 2, 28, 10, 20, 0), datetime(2009, 3, 31, 8, 30, 0)], dtype=object, name='date_time') xp = DataFrame({'B': [1, 3, 5], 'C': [2, 4, 6]}, idx) tm.assert_frame_equal(rs, xp) def test_parse_dates_column_list(self): from pandas.core.datetools import to_datetime data = '''date;destination;ventilationcode;unitcode;units;aux_date 01/01/2010;P;P;50;1;12/1/2011 01/01/2010;P;R;50;1;13/1/2011 15/01/2010;P;P;50;1;14/1/2011 01/05/2010;P;P;50;1;15/1/2011''' expected = self.read_csv(StringIO(data), sep=";", index_col=lrange(4)) lev = expected.index.levels[0] levels = list(expected.index.levels) levels[0] = lev.to_datetime(dayfirst=True) # hack to get this to work - remove for final test levels[0].name = lev.name expected.index.set_levels(levels, inplace=True) expected['aux_date'] = to_datetime(expected['aux_date'], dayfirst=True) expected['aux_date'] = lmap(Timestamp, expected['aux_date']) tm.assertIsInstance(expected['aux_date'][0], datetime) df = self.read_csv(StringIO(data), sep=";", index_col=lrange(4), parse_dates=[0, 5], dayfirst=True) tm.assert_frame_equal(df, expected) df = self.read_csv(StringIO(data), sep=";", index_col=lrange(4), parse_dates=['date', 'aux_date'], dayfirst=True) tm.assert_frame_equal(df, expected) def test_no_header(self): data = """1,2,3,4,5 6,7,8,9,10 11,12,13,14,15 """ df = self.read_table(StringIO(data), sep=',', header=None) df_pref = self.read_table(StringIO(data), sep=',', prefix='X', header=None) names = ['foo', 'bar', 'baz', 'quux', 'panda'] df2 = self.read_table(StringIO(data), sep=',', names=names) expected = [[1, 2, 3, 4, 5.], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]] tm.assert_almost_equal(df.values, expected) tm.assert_almost_equal(df.values, df2.values) self.assert_numpy_array_equal(df_pref.columns, ['X0', 'X1', 'X2', 'X3', 'X4']) self.assert_numpy_array_equal(df.columns, lrange(5)) self.assert_numpy_array_equal(df2.columns, names) def test_no_header_prefix(self): data = """1,2,3,4,5 6,7,8,9,10 11,12,13,14,15 """ df_pref = self.read_table(StringIO(data), sep=',', prefix='Field', header=None) expected = [[1, 2, 3, 4, 5.], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]] tm.assert_almost_equal(df_pref.values, expected) self.assert_numpy_array_equal(df_pref.columns, ['Field0', 'Field1', 'Field2', 'Field3', 'Field4']) def test_header_with_index_col(self): data = """foo,1,2,3 bar,4,5,6 baz,7,8,9 """ names = ['A', 'B', 'C'] df = self.read_csv(StringIO(data), names=names) self.assertEqual(names, ['A', 'B', 'C']) values = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] expected = DataFrame(values, index=['foo', 'bar', 'baz'], columns=['A', 'B', 'C']) tm.assert_frame_equal(df, expected) def test_read_csv_dataframe(self): df = self.read_csv(self.csv1, index_col=0, parse_dates=True) df2 = self.read_table(self.csv1, sep=',', index_col=0, parse_dates=True) self.assert_numpy_array_equal(df.columns, ['A', 'B', 'C', 'D']) self.assertEqual(df.index.name, 'index') self.assertIsInstance( df.index[0], (datetime, np.datetime64, Timestamp)) self.assertEqual(df.values.dtype, np.float64) tm.assert_frame_equal(df, df2) def test_read_csv_no_index_name(self): df = self.read_csv(self.csv2, index_col=0, parse_dates=True) df2 = self.read_table(self.csv2, sep=',', index_col=0, parse_dates=True) self.assert_numpy_array_equal(df.columns, ['A', 'B', 'C', 'D', 'E']) self.assertIsInstance( df.index[0], (datetime, np.datetime64, Timestamp)) self.assertEqual(df.ix[:, ['A', 'B', 'C', 'D'] ].values.dtype, np.float64) tm.assert_frame_equal(df, df2) def test_read_csv_infer_compression(self): # GH 9770 expected = self.read_csv(self.csv1, index_col=0, parse_dates=True) inputs = [self.csv1, self.csv1 + '.gz', self.csv1 + '.bz2', open(self.csv1)] for f in inputs: df = self.read_csv(f, index_col=0, parse_dates=True, compression='infer') tm.assert_frame_equal(expected, df) inputs[3].close() def test_read_table_unicode(self): fin = BytesIO(u('\u0141aski, Jan;1').encode('utf-8')) df1 = read_table(fin, sep=";", encoding="utf-8", header=None) tm.assertIsInstance(df1[0].values[0], compat.text_type) def test_read_table_wrong_num_columns(self): # too few! data = """A,B,C,D,E,F 1,2,3,4,5,6 6,7,8,9,10,11,12 11,12,13,14,15,16 """ self.assertRaises(Exception, self.read_csv, StringIO(data)) def test_read_table_duplicate_index(self): data = """index,A,B,C,D foo,2,3,4,5 bar,7,8,9,10 baz,12,13,14,15 qux,12,13,14,15 foo,12,13,14,15 bar,12,13,14,15 """ result = self.read_csv(StringIO(data), index_col=0) expected = self.read_csv(StringIO(data)).set_index('index', verify_integrity=False) tm.assert_frame_equal(result, expected) def test_read_table_duplicate_index_implicit(self): data = """A,B,C,D foo,2,3,4,5 bar,7,8,9,10 baz,12,13,14,15 qux,12,13,14,15 foo,12,13,14,15 bar,12,13,14,15 """ # it works! result = self.read_csv(StringIO(data)) def test_parse_bools(self): data = """A,B True,1 False,2 True,3 """ data = self.read_csv(StringIO(data)) self.assertEqual(data['A'].dtype, np.bool_) data = """A,B YES,1 no,2 yes,3 No,3 Yes,3 """ data = self.read_csv(StringIO(data), true_values=['yes', 'Yes', 'YES'], false_values=['no', 'NO', 'No']) self.assertEqual(data['A'].dtype, np.bool_) data = """A,B TRUE,1 FALSE,2 TRUE,3 """ data = self.read_csv(StringIO(data)) self.assertEqual(data['A'].dtype, np.bool_) data = """A,B foo,bar bar,foo""" result = self.read_csv(StringIO(data), true_values=['foo'], false_values=['bar']) expected = DataFrame({'A': [True, False], 'B': [False, True]}) tm.assert_frame_equal(result, expected) def test_int_conversion(self): data = """A,B 1.0,1 2.0,2 3.0,3 """ data = self.read_csv(StringIO(data)) self.assertEqual(data['A'].dtype, np.float64) self.assertEqual(data['B'].dtype, np.int64) def test_infer_index_col(self): data = """A,B,C foo,1,2,3 bar,4,5,6 baz,7,8,9 """ data = self.read_csv(StringIO(data)) self.assertTrue(data.index.equals(Index(['foo', 'bar', 'baz']))) def test_read_nrows(self): df = self.read_csv(StringIO(self.data1), nrows=3) expected = self.read_csv(StringIO(self.data1))[:3] tm.assert_frame_equal(df, expected) def test_read_chunksize(self): reader = self.read_csv(StringIO(self.data1), index_col=0, chunksize=2) df = self.read_csv(StringIO(self.data1), index_col=0) chunks = list(reader) tm.assert_frame_equal(chunks[0], df[:2]) tm.assert_frame_equal(chunks[1], df[2:4]) tm.assert_frame_equal(chunks[2], df[4:]) def test_read_chunksize_named(self): reader = self.read_csv( StringIO(self.data1), index_col='index', chunksize=2) df = self.read_csv(StringIO(self.data1), index_col='index') chunks = list(reader) tm.assert_frame_equal(chunks[0], df[:2]) tm.assert_frame_equal(chunks[1], df[2:4]) tm.assert_frame_equal(chunks[2], df[4:]) def test_get_chunk_passed_chunksize(self): data = """A,B,C 1,2,3 4,5,6 7,8,9 1,2,3""" result = self.read_csv(StringIO(data), chunksize=2) piece = result.get_chunk() self.assertEqual(len(piece), 2) def test_read_text_list(self): data = """A,B,C\nfoo,1,2,3\nbar,4,5,6""" as_list = [['A', 'B', 'C'], ['foo', '1', '2', '3'], ['bar', '4', '5', '6']] df = self.read_csv(StringIO(data), index_col=0) parser = TextParser(as_list, index_col=0, chunksize=2) chunk = parser.read(None) tm.assert_frame_equal(chunk, df) def test_iterator(self): # GH 6607 # Test currently only valid with python engine because # skip_footer != 0. Temporarily copied to TestPythonParser. # Test for ValueError with other engines: with tm.assertRaisesRegexp(ValueError, 'skip_footer'): reader = self.read_csv(StringIO(self.data1), index_col=0, iterator=True) df = self.read_csv(StringIO(self.data1), index_col=0) chunk = reader.read(3) tm.assert_frame_equal(chunk, df[:3]) last_chunk = reader.read(5) tm.assert_frame_equal(last_chunk, df[3:]) # pass list lines = list(csv.reader(StringIO(self.data1))) parser = TextParser(lines, index_col=0, chunksize=2) df = self.read_csv(StringIO(self.data1), index_col=0) chunks = list(parser) tm.assert_frame_equal(chunks[0], df[:2]) tm.assert_frame_equal(chunks[1], df[2:4]) tm.assert_frame_equal(chunks[2], df[4:]) # pass skiprows parser = TextParser(lines, index_col=0, chunksize=2, skiprows=[1]) chunks = list(parser) tm.assert_frame_equal(chunks[0], df[1:3]) # test bad parameter (skip_footer) reader = self.read_csv(StringIO(self.data1), index_col=0, iterator=True, skip_footer=True) self.assertRaises(ValueError, reader.read, 3) treader = self.read_table(StringIO(self.data1), sep=',', index_col=0, iterator=True) tm.assertIsInstance(treader, TextFileReader) # stopping iteration when on chunksize is specified, GH 3967 data = """A,B,C foo,1,2,3 bar,4,5,6 baz,7,8,9 """ reader = self.read_csv(StringIO(data), iterator=True) result = list(reader) expected = DataFrame(dict(A=[1, 4, 7], B=[2, 5, 8], C=[ 3, 6, 9]), index=['foo', 'bar', 'baz']) tm.assert_frame_equal(result[0], expected) # chunksize = 1 reader = self.read_csv(StringIO(data), chunksize=1) result = list(reader) expected = DataFrame(dict(A=[1, 4, 7], B=[2, 5, 8], C=[ 3, 6, 9]), index=['foo', 'bar', 'baz']) self.assertEqual(len(result), 3) tm.assert_frame_equal(pd.concat(result), expected) def test_header_not_first_line(self): data = """got,to,ignore,this,line got,to,ignore,this,line index,A,B,C,D foo,2,3,4,5 bar,7,8,9,10 baz,12,13,14,15 """ data2 = """index,A,B,C,D foo,2,3,4,5 bar,7,8,9,10 baz,12,13,14,15 """ df = self.read_csv(StringIO(data), header=2, index_col=0) expected = self.read_csv(StringIO(data2), header=0, index_col=0) tm.assert_frame_equal(df, expected) def test_header_multi_index(self): expected = tm.makeCustomDataframe( 5, 3, r_idx_nlevels=2, c_idx_nlevels=4) data = """\ C0,,C_l0_g0,C_l0_g1,C_l0_g2 C1,,C_l1_g0,C_l1_g1,C_l1_g2 C2,,C_l2_g0,C_l2_g1,C_l2_g2 C3,,C_l3_g0,C_l3_g1,C_l3_g2 R0,R1,,, R_l0_g0,R_l1_g0,R0C0,R0C1,R0C2 R_l0_g1,R_l1_g1,R1C0,R1C1,R1C2 R_l0_g2,R_l1_g2,R2C0,R2C1,R2C2 R_l0_g3,R_l1_g3,R3C0,R3C1,R3C2 R_l0_g4,R_l1_g4,R4C0,R4C1,R4C2 """ df = self.read_csv(StringIO(data), header=[0, 1, 2, 3], index_col=[ 0, 1], tupleize_cols=False) tm.assert_frame_equal(df, expected) # skipping lines in the header df = self.read_csv(StringIO(data), header=[0, 1, 2, 3], index_col=[ 0, 1], tupleize_cols=False) tm.assert_frame_equal(df, expected) #### invalid options #### # no as_recarray self.assertRaises(ValueError, self.read_csv, StringIO(data), header=[0, 1, 2, 3], index_col=[0, 1], as_recarray=True, tupleize_cols=False) # names self.assertRaises(ValueError, self.read_csv, StringIO(data), header=[0, 1, 2, 3], index_col=[0, 1], names=['foo', 'bar'], tupleize_cols=False) # usecols self.assertRaises(ValueError, self.read_csv, StringIO(data), header=[0, 1, 2, 3], index_col=[0, 1], usecols=['foo', 'bar'], tupleize_cols=False) # non-numeric index_col self.assertRaises(ValueError, self.read_csv, StringIO(data), header=[0, 1, 2, 3], index_col=['foo', 'bar'], tupleize_cols=False) def test_header_multiindex_common_format(self): df = DataFrame([[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]], index=['one', 'two'], columns=MultiIndex.from_tuples([('a', 'q'), ('a', 'r'), ('a', 's'), ('b', 't'), ('c', 'u'), ('c', 'v')])) # to_csv data = """,a,a,a,b,c,c ,q,r,s,t,u,v ,,,,,, one,1,2,3,4,5,6 two,7,8,9,10,11,12""" result = self.read_csv(StringIO(data), header=[0, 1], index_col=0) tm.assert_frame_equal(df, result) # common data = """,a,a,a,b,c,c ,q,r,s,t,u,v one,1,2,3,4,5,6 two,7,8,9,10,11,12""" result = self.read_csv(StringIO(data), header=[0, 1], index_col=0) tm.assert_frame_equal(df, result) # common, no index_col data = """a,a,a,b,c,c q,r,s,t,u,v 1,2,3,4,5,6 7,8,9,10,11,12""" result = self.read_csv(StringIO(data), header=[0, 1], index_col=None) tm.assert_frame_equal(df.reset_index(drop=True), result) # malformed case 1 expected = DataFrame(np.array([[2, 3, 4, 5, 6], [8, 9, 10, 11, 12]], dtype='int64'), index=Index([1, 7]), columns=MultiIndex(levels=[[u('a'), u('b'), u('c')], [u('r'), u('s'), u('t'), u('u'), u('v')]], labels=[[0, 0, 1, 2, 2], [ 0, 1, 2, 3, 4]], names=[u('a'), u('q')])) data = """a,a,a,b,c,c q,r,s,t,u,v 1,2,3,4,5,6 7,8,9,10,11,12""" result = self.read_csv(StringIO(data), header=[0, 1], index_col=0) tm.assert_frame_equal(expected, result) # malformed case 2 expected = DataFrame(np.array([[2, 3, 4, 5, 6], [8, 9, 10, 11, 12]], dtype='int64'), index=Index([1, 7]), columns=MultiIndex(levels=[[u('a'), u('b'), u('c')], [u('r'), u('s'), u('t'), u('u'), u('v')]], labels=[[0, 0, 1, 2, 2], [ 0, 1, 2, 3, 4]], names=[None, u('q')])) data = """,a,a,b,c,c q,r,s,t,u,v 1,2,3,4,5,6 7,8,9,10,11,12""" result = self.read_csv(StringIO(data), header=[0, 1], index_col=0) tm.assert_frame_equal(expected, result) # mi on columns and index (malformed) expected = DataFrame(np.array([[3, 4, 5, 6], [9, 10, 11, 12]], dtype='int64'), index=MultiIndex(levels=[[1, 7], [2, 8]], labels=[[0, 1], [0, 1]]), columns=MultiIndex(levels=[[u('a'), u('b'), u('c')], [u('s'), u('t'), u('u'), u('v')]], labels=[[0, 1, 2, 2], [0, 1, 2, 3]], names=[None, u('q')])) data = """,a,a,b,c,c q,r,s,t,u,v 1,2,3,4,5,6 7,8,9,10,11,12""" result = self.read_csv(StringIO(data), header=[0, 1], index_col=[0, 1]) tm.assert_frame_equal(expected, result) def test_pass_names_with_index(self): lines = self.data1.split('\n') no_header = '\n'.join(lines[1:]) # regular index names = ['index', 'A', 'B', 'C', 'D'] df = self.read_csv(StringIO(no_header), index_col=0, names=names) expected = self.read_csv(StringIO(self.data1), index_col=0) tm.assert_frame_equal(df, expected) # multi index data = """index1,index2,A,B,C,D foo,one,2,3,4,5 foo,two,7,8,9,10 foo,three,12,13,14,15 bar,one,12,13,14,15 bar,two,12,13,14,15 """ lines = data.split('\n') no_header = '\n'.join(lines[1:]) names = ['index1', 'index2', 'A', 'B', 'C', 'D'] df = self.read_csv(StringIO(no_header), index_col=[0, 1], names=names) expected = self.read_csv(StringIO(data), index_col=[0, 1]) tm.assert_frame_equal(df, expected) df = self.read_csv(StringIO(data), index_col=['index1', 'index2']) tm.assert_frame_equal(df, expected) def test_multi_index_no_level_names(self): data = """index1,index2,A,B,C,D foo,one,2,3,4,5 foo,two,7,8,9,10 foo,three,12,13,14,15 bar,one,12,13,14,15 bar,two,12,13,14,15 """ data2 = """A,B,C,D foo,one,2,3,4,5 foo,two,7,8,9,10 foo,three,12,13,14,15 bar,one,12,13,14,15 bar,two,12,13,14,15 """ lines = data.split('\n') no_header = '\n'.join(lines[1:]) names = ['A', 'B', 'C', 'D'] df = self.read_csv(StringIO(no_header), index_col=[0, 1], header=None, names=names) expected = self.read_csv(StringIO(data), index_col=[0, 1]) tm.assert_frame_equal(df, expected, check_names=False) # 2 implicit first cols df2 = self.read_csv(StringIO(data2)) tm.assert_frame_equal(df2, df) # reverse order of index df = self.read_csv(StringIO(no_header), index_col=[1, 0], names=names, header=None) expected = self.read_csv(StringIO(data), index_col=[1, 0]) tm.assert_frame_equal(df, expected, check_names=False) def test_multi_index_parse_dates(self): data = """index1,index2,A,B,C 20090101,one,a,1,2 20090101,two,b,3,4 20090101,three,c,4,5 20090102,one,a,1,2 20090102,two,b,3,4 20090102,three,c,4,5 20090103,one,a,1,2 20090103,two,b,3,4 20090103,three,c,4,5 """ df = self.read_csv(StringIO(data), index_col=[0, 1], parse_dates=True) self.assertIsInstance(df.index.levels[0][0], (datetime, np.datetime64, Timestamp)) # specify columns out of order! df2 = self.read_csv(StringIO(data), index_col=[1, 0], parse_dates=True) self.assertIsInstance(df2.index.levels[1][0], (datetime, np.datetime64, Timestamp)) def test_skip_footer(self): # GH 6607 # Test currently only valid with python engine because # skip_footer != 0. Temporarily copied to TestPythonParser. # Test for ValueError with other engines: with tm.assertRaisesRegexp(ValueError, 'skip_footer'): data = """A,B,C 1,2,3 4,5,6 7,8,9 want to skip this also also skip this """ result = self.read_csv(StringIO(data), skip_footer=2) no_footer = '\n'.join(data.split('\n')[:-3]) expected = self.read_csv(StringIO(no_footer)) tm.assert_frame_equal(result, expected) result = self.read_csv(StringIO(data), nrows=3) tm.assert_frame_equal(result, expected) # skipfooter alias result = read_csv(StringIO(data), skipfooter=2) no_footer = '\n'.join(data.split('\n')[:-3]) expected = read_csv(StringIO(no_footer)) tm.assert_frame_equal(result, expected) def test_no_unnamed_index(self): data = """ id c0 c1 c2 0 1 0 a b 1 2 0 c d 2 2 2 e f """ df = self.read_table(StringIO(data), sep=' ') self.assertIsNone(df.index.name) def test_converters(self): data = """A,B,C,D a,1,2,01/01/2009 b,3,4,01/02/2009 c,4,5,01/03/2009 """ from pandas.compat import parse_date result = self.read_csv(StringIO(data), converters={'D': parse_date}) result2 = self.read_csv(StringIO(data), converters={3: parse_date}) expected = self.read_csv(StringIO(data)) expected['D'] = expected['D'].map(parse_date) tm.assertIsInstance(result['D'][0], (datetime, Timestamp)) tm.assert_frame_equal(result, expected) tm.assert_frame_equal(result2, expected) # produce integer converter = lambda x: int(x.split('/')[2]) result = self.read_csv(StringIO(data), converters={'D': converter}) expected = self.read_csv(StringIO(data)) expected['D'] = expected['D'].map(converter) tm.assert_frame_equal(result, expected) def test_converters_no_implicit_conv(self): # GH2184 data = """000102,1.2,A\n001245,2,B""" f = lambda x: x.strip() converter = {0: f} df = self.read_csv(StringIO(data), header=None, converters=converter) self.assertEqual(df[0].dtype, object) def test_converters_euro_decimal_format(self): data = """Id;Number1;Number2;Text1;Text2;Number3 1;1521,1541;187101,9543;ABC;poi;4,738797819 2;121,12;14897,76;DEF;uyt;0,377320872 3;878,158;108013,434;GHI;rez;2,735694704""" f = lambda x: float(x.replace(",", ".")) converter = {'Number1': f, 'Number2': f, 'Number3': f} df2 = self.read_csv(StringIO(data), sep=';', converters=converter) self.assertEqual(df2['Number1'].dtype, float) self.assertEqual(df2['Number2'].dtype, float) self.assertEqual(df2['Number3'].dtype, float) def test_converter_return_string_bug(self): # GH #583 data = """Id;Number1;Number2;Text1;Text2;Number3 1;1521,1541;187101,9543;ABC;poi;4,738797819 2;121,12;14897,76;DEF;uyt;0,377320872 3;878,158;108013,434;GHI;rez;2,735694704""" f = lambda x: float(x.replace(",", ".")) converter = {'Number1': f, 'Number2': f, 'Number3': f} df2 = self.read_csv(StringIO(data), sep=';', converters=converter) self.assertEqual(df2['Number1'].dtype, float) def test_read_table_buglet_4x_multiindex(self): # GH 6607 # Parsing multi-level index currently causes an error in the C parser. # Temporarily copied to TestPythonParser. # Here test that CParserError is raised: with tm.assertRaises(pandas.parser.CParserError): text = """ A B C D E one two three four a b 10.0032 5 -0.5109 -2.3358 -0.4645 0.05076 0.3640 a q 20 4 0.4473 1.4152 0.2834 1.00661 0.1744 x q 30 3 -0.6662 -0.5243 -0.3580 0.89145 2.5838""" # it works! df = self.read_table(StringIO(text), sep='\s+') self.assertEqual(df.index.names, ('one', 'two', 'three', 'four')) def test_line_comment(self): data = """# empty A,B,C 1,2.,4.#hello world #ignore this line 5.,NaN,10.0 """ expected = [[1., 2., 4.], [5., np.nan, 10.]] df = self.read_csv(StringIO(data), comment='#') tm.assert_almost_equal(df.values, expected) def test_comment_skiprows(self): data = """# empty random line # second empty line 1,2,3 A,B,C 1,2.,4. 5.,NaN,10.0 """ expected = [[1., 2., 4.], [5., np.nan, 10.]] # this should ignore the first four lines (including comments) df = self.read_csv(StringIO(data), comment='#', skiprows=4) tm.assert_almost_equal(df.values, expected) def test_comment_header(self): data = """# empty # second empty line 1,2,3 A,B,C 1,2.,4. 5.,NaN,10.0 """ expected = [[1., 2., 4.], [5., np.nan, 10.]] # header should begin at the second non-comment line df = self.read_csv(StringIO(data), comment='#', header=1) tm.assert_almost_equal(df.values, expected) def test_comment_skiprows_header(self): data = """# empty # second empty line # third empty line X,Y,Z 1,2,3 A,B,C 1,2.,4. 5.,NaN,10.0 """ expected = [[1., 2., 4.], [5., np.nan, 10.]] # skiprows should skip the first 4 lines (including comments), while # header should start from the second non-commented line starting # with line 5 df = self.read_csv(StringIO(data), comment='#', skiprows=4, header=1) tm.assert_almost_equal(df.values, expected) def test_read_csv_parse_simple_list(self): text = """foo bar baz qux foo foo bar""" df = read_csv(StringIO(text), header=None) expected = DataFrame({0: ['foo', 'bar baz', 'qux foo', 'foo', 'bar']}) tm.assert_frame_equal(df, expected) def test_parse_dates_custom_euroformat(self): text = """foo,bar,baz 31/01/2010,1,2 01/02/2010,1,NA 02/02/2010,1,2 """ parser = lambda d: parse_date(d, dayfirst=True) df = self.read_csv(StringIO(text), names=['time', 'Q', 'NTU'], header=0, index_col=0, parse_dates=True, date_parser=parser, na_values=['NA']) exp_index = Index([datetime(2010, 1, 31), datetime(2010, 2, 1), datetime(2010, 2, 2)], name='time') expected = DataFrame({'Q': [1, 1, 1], 'NTU': [2, np.nan, 2]}, index=exp_index, columns=['Q', 'NTU']) tm.assert_frame_equal(df, expected) parser = lambda d: parse_date(d, day_first=True) self.assertRaises(Exception, self.read_csv, StringIO(text), skiprows=[0], names=['time', 'Q', 'NTU'], index_col=0, parse_dates=True, date_parser=parser, na_values=['NA']) def test_na_value_dict(self): data = """A,B,C foo,bar,NA bar,foo,foo foo,bar,NA bar,foo,foo""" df = self.read_csv(StringIO(data), na_values={'A': ['foo'], 'B': ['bar']}) expected = DataFrame({'A': [np.nan, 'bar', np.nan, 'bar'], 'B': [np.nan, 'foo', np.nan, 'foo'], 'C': [np.nan, 'foo', np.nan, 'foo']}) tm.assert_frame_equal(df, expected) data = """\ a,b,c,d 0,NA,1,5 """ xp = DataFrame({'b': [np.nan], 'c': [1], 'd': [5]}, index=[0]) xp.index.name = 'a' df = self.read_csv(StringIO(data), na_values={}, index_col=0) tm.assert_frame_equal(df, xp) xp = DataFrame({'b': [np.nan], 'd': [5]}, MultiIndex.from_tuples([(0, 1)])) xp.index.names = ['a', 'c'] df = self.read_csv(StringIO(data), na_values={}, index_col=[0, 2]) tm.assert_frame_equal(df, xp) xp = DataFrame({'b': [np.nan], 'd': [5]}, MultiIndex.from_tuples([(0, 1)])) xp.index.names = ['a', 'c'] df = self.read_csv(StringIO(data), na_values={}, index_col=['a', 'c']) tm.assert_frame_equal(df, xp) @tm.network def test_url(self): # HTTP(S) url = ('https://raw.github.com/pydata/pandas/master/' 'pandas/io/tests/data/salary.table') url_table = self.read_table(url) dirpath = tm.get_data_path() localtable = os.path.join(dirpath, 'salary.table') local_table = self.read_table(localtable) tm.assert_frame_equal(url_table, local_table) # TODO: ftp testing @slow def test_file(self): # FILE if sys.version_info[:2] < (2, 6): raise nose.SkipTest("file:// not supported with Python < 2.6") dirpath = tm.get_data_path() localtable = os.path.join(dirpath, 'salary.table') local_table = self.read_table(localtable) try: url_table = self.read_table('file://localhost/' + localtable) except URLError: # fails on some systems raise nose.SkipTest("failing on %s" % ' '.join(platform.uname()).strip()) tm.assert_frame_equal(url_table, local_table) def test_parse_tz_aware(self): import pytz # #1693 data = StringIO("Date,x\n2012-06-13T01:39:00Z,0.5") # it works result = read_csv(data, index_col=0, parse_dates=True) stamp = result.index[0] self.assertEqual(stamp.minute, 39) try: self.assertIs(result.index.tz, pytz.utc) except AssertionError: # hello Yaroslav arr = result.index.to_pydatetime() result = tools.to_datetime(arr, utc=True)[0] self.assertEqual(stamp.minute, result.minute) self.assertEqual(stamp.hour, result.hour) self.assertEqual(stamp.day, result.day) def test_multiple_date_cols_index(self): data = """\ ID,date,NominalTime,ActualTime,TDew,TAir,Windspeed,Precip,WindDir KORD1,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000 KORD2,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000 KORD3,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000 KORD4,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000 KORD5,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000 KORD6,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000""" xp = self.read_csv(StringIO(data), parse_dates={'nominal': [1, 2]}) df = self.read_csv(StringIO(data), parse_dates={'nominal': [1, 2]}, index_col='nominal') tm.assert_frame_equal(xp.set_index('nominal'), df) df2 = self.read_csv(StringIO(data), parse_dates={'nominal': [1, 2]}, index_col=0) tm.assert_frame_equal(df2, df) df3 = self.read_csv(StringIO(data), parse_dates=[[1, 2]], index_col=0) tm.assert_frame_equal(df3, df, check_names=False) def test_multiple_date_cols_chunked(self): df = self.read_csv(StringIO(self.ts_data), parse_dates={ 'nominal': [1, 2]}, index_col='nominal') reader = self.read_csv(StringIO(self.ts_data), parse_dates={'nominal': [1, 2]}, index_col='nominal', chunksize=2) chunks = list(reader) self.assertNotIn('nominalTime', df) tm.assert_frame_equal(chunks[0], df[:2]) tm.assert_frame_equal(chunks[1], df[2:4]) tm.assert_frame_equal(chunks[2], df[4:]) def test_multiple_date_col_named_components(self): xp = self.read_csv(StringIO(self.ts_data), parse_dates={'nominal': [1, 2]}, index_col='nominal') colspec = {'nominal': ['date', 'nominalTime']} df = self.read_csv(StringIO(self.ts_data), parse_dates=colspec, index_col='nominal') tm.assert_frame_equal(df, xp) def test_multiple_date_col_multiple_index(self): df = self.read_csv(StringIO(self.ts_data), parse_dates={'nominal': [1, 2]}, index_col=['nominal', 'ID']) xp = self.read_csv(StringIO(self.ts_data), parse_dates={'nominal': [1, 2]}) tm.assert_frame_equal(xp.set_index(['nominal', 'ID']), df) def test_comment(self): data = """A,B,C 1,2.,4.#hello world 5.,NaN,10.0 """ expected = [[1., 2., 4.], [5., np.nan, 10.]] df = self.read_csv(StringIO(data), comment='#') tm.assert_almost_equal(df.values, expected) df = self.read_table(StringIO(data), sep=',', comment='#', na_values=['NaN']) tm.assert_almost_equal(df.values, expected) def test_bool_na_values(self): data = """A,B,C True,False,True NA,True,False False,NA,True""" result = self.read_csv(StringIO(data)) expected = DataFrame({'A': np.array([True, nan, False], dtype=object), 'B': np.array([False, True, nan], dtype=object), 'C': [True, False, True]}) tm.assert_frame_equal(result, expected) def test_nonexistent_path(self): # don't segfault pls #2428 path = '%s.csv' % tm.rands(10) self.assertRaises(Exception, self.read_csv, path) def test_missing_trailing_delimiters(self): data = """A,B,C,D 1,2,3,4 1,3,3, 1,4,5""" result = self.read_csv(StringIO(data)) self.assertTrue(result['D'].isnull()[1:].all()) def test_skipinitialspace(self): s = ('"09-Apr-2012", "01:10:18.300", 2456026.548822908, 12849, ' '1.00361, 1.12551, 330.65659, 0355626618.16711, 73.48821, ' '314.11625, 1917.09447, 179.71425, 80.000, 240.000, -350, ' '70.06056, 344.98370, 1, 1, -0.689265, -0.692787, ' '0.212036, 14.7674, 41.605, -9999.0, -9999.0, ' '-9999.0, -9999.0, -9999.0, -9999.0, 000, 012, 128') sfile = StringIO(s) # it's 33 columns result = self.read_csv(sfile, names=lrange(33), na_values=['-9999.0'], header=None, skipinitialspace=True) self.assertTrue(pd.isnull(result.ix[0, 29])) def test_utf16_bom_skiprows(self): # #2298 data = u("""skip this skip this too A\tB\tC 1\t2\t3 4\t5\t6""") data2 = u("""skip this skip this too A,B,C 1,2,3 4,5,6""") path = '__%s__.csv' % tm.rands(10) with tm.ensure_clean(path) as path: for sep, dat in [('\t', data), (',', data2)]: for enc in ['utf-16', 'utf-16le', 'utf-16be']: bytes = dat.encode(enc) with open(path, 'wb') as f: f.write(bytes) s = BytesIO(dat.encode('utf-8')) if compat.PY3: # somewhat False since the code never sees bytes from io import TextIOWrapper s = TextIOWrapper(s, encoding='utf-8') result = self.read_csv(path, encoding=enc, skiprows=2, sep=sep) expected = self.read_csv(s, encoding='utf-8', skiprows=2, sep=sep) tm.assert_frame_equal(result, expected) def test_utf16_example(self): path = tm.get_data_path('utf16_ex.txt') # it works! and is the right length result = self.read_table(path, encoding='utf-16') self.assertEqual(len(result), 50) if not compat.PY3: buf = BytesIO(open(path, 'rb').read()) result = self.read_table(buf, encoding='utf-16') self.assertEqual(len(result), 50) def test_converters_corner_with_nas(self): # skip aberration observed on Win64 Python 3.2.2 if hash(np.int64(-1)) != -2: raise nose.SkipTest("skipping because of windows hash on Python" " 3.2.2") csv = """id,score,days 1,2,12 2,2-5, 3,,14+ 4,6-12,2""" def convert_days(x): x = x.strip() if not x: return np.nan is_plus = x.endswith('+') if is_plus: x = int(x[:-1]) + 1 else: x = int(x) return x def convert_days_sentinel(x): x = x.strip() if not x: return np.nan is_plus = x.endswith('+') if is_plus: x = int(x[:-1]) + 1 else: x = int(x) return x def convert_score(x): x = x.strip() if not x: return np.nan if x.find('-') > 0: valmin, valmax = lmap(int, x.split('-')) val = 0.5 * (valmin + valmax) else: val = float(x) return val fh = StringIO(csv) result = self.read_csv(fh, converters={'score': convert_score, 'days': convert_days}, na_values=['', None]) self.assertTrue(pd.isnull(result['days'][1])) fh = StringIO(csv) result2 = self.read_csv(fh, converters={'score': convert_score, 'days': convert_days_sentinel}, na_values=['', None]) tm.assert_frame_equal(result, result2) def test_unicode_encoding(self): pth = tm.get_data_path('unicode_series.csv') result = self.read_csv(pth, header=None, encoding='latin-1') result = result.set_index(0) got = result[1][1632] expected = u('\xc1 k\xf6ldum klaka (Cold Fever) (1994)') self.assertEqual(got, expected) def test_trailing_delimiters(self): # #2442. grumble grumble data = """A,B,C 1,2,3, 4,5,6, 7,8,9,""" result = self.read_csv(StringIO(data), index_col=False) expected = DataFrame({'A': [1, 4, 7], 'B': [2, 5, 8], 'C': [3, 6, 9]}) tm.assert_frame_equal(result, expected) def test_escapechar(self): # http://stackoverflow.com/questions/13824840/feature-request-for- # pandas-read-csv data = '''SEARCH_TERM,ACTUAL_URL "bra tv bord","http://www.ikea.com/se/sv/catalog/categories/departments/living_room/10475/?se%7cps%7cnonbranded%7cvardagsrum%7cgoogle%7ctv_bord" "tv p\xc3\xa5 hjul","http://www.ikea.com/se/sv/catalog/categories/departments/living_room/10475/?se%7cps%7cnonbranded%7cvardagsrum%7cgoogle%7ctv_bord" "SLAGBORD, \\"Bergslagen\\", IKEA:s 1700-tals serie","http://www.ikea.com/se/sv/catalog/categories/departments/living_room/10475/?se%7cps%7cnonbranded%7cvardagsrum%7cgoogle%7ctv_bord"''' result = self.read_csv(StringIO(data), escapechar='\\', quotechar='"', encoding='utf-8') self.assertEqual(result['SEARCH_TERM'][2], 'SLAGBORD, "Bergslagen", IKEA:s 1700-tals serie') self.assertTrue(np.array_equal(result.columns, ['SEARCH_TERM', 'ACTUAL_URL'])) def test_header_names_backward_compat(self): # #2539 data = '1,2,3\n4,5,6' result = self.read_csv(StringIO(data), names=['a', 'b', 'c']) expected = self.read_csv(StringIO(data), names=['a', 'b', 'c'], header=None) tm.assert_frame_equal(result, expected) data2 = 'foo,bar,baz\n' + data result = self.read_csv(StringIO(data2), names=['a', 'b', 'c'], header=0) tm.assert_frame_equal(result, expected) def test_int64_min_issues(self): # #2599 data = 'A,B\n0,0\n0,' result = self.read_csv(StringIO(data)) expected = DataFrame({'A': [0, 0], 'B': [0, np.nan]}) tm.assert_frame_equal(result, expected) def test_parse_integers_above_fp_precision(self): data = """Numbers 17007000002000191 17007000002000191 17007000002000191 17007000002000191 17007000002000192 17007000002000192 17007000002000192 17007000002000192 17007000002000192 17007000002000194""" result = self.read_csv(StringIO(data)) expected = DataFrame({'Numbers': [17007000002000191, 17007000002000191, 17007000002000191, 17007000002000191, 17007000002000192, 17007000002000192, 17007000002000192, 17007000002000192, 17007000002000192, 17007000002000194]}) self.assertTrue(np.array_equal(result['Numbers'], expected['Numbers'])) def test_usecols_index_col_conflict(self): # Issue 4201 Test that index_col as integer reflects usecols data = """SecId,Time,Price,P2,P3 10000,2013-5-11,100,10,1 500,2013-5-12,101,11,1 """ expected = DataFrame({'Price': [100, 101]}, index=[ datetime(2013, 5, 11), datetime(2013, 5, 12)]) expected.index.name = 'Time' df = self.read_csv(StringIO(data), usecols=[ 'Time', 'Price'], parse_dates=True, index_col=0) tm.assert_frame_equal(expected, df) df = self.read_csv(StringIO(data), usecols=[ 'Time', 'Price'], parse_dates=True, index_col='Time') tm.assert_frame_equal(expected, df) df = self.read_csv(StringIO(data), usecols=[ 1, 2], parse_dates=True, index_col='Time') tm.assert_frame_equal(expected, df) df = self.read_csv(StringIO(data), usecols=[ 1, 2], parse_dates=True, index_col=0) tm.assert_frame_equal(expected, df) expected = DataFrame( {'P3': [1, 1], 'Price': (100, 101), 'P2': (10, 11)}) expected = expected.set_index(['Price', 'P2']) df = self.read_csv(StringIO(data), usecols=[ 'Price', 'P2', 'P3'], parse_dates=True, index_col=['Price', 'P2']) tm.assert_frame_equal(expected, df) def test_chunks_have_consistent_numerical_type(self): integers = [str(i) for i in range(499999)] data = "a\n" + "\n".join(integers + ["1.0", "2.0"] + integers) with tm.assert_produces_warning(False): df = self.read_csv(StringIO(data)) # Assert that types were coerced. self.assertTrue(type(df.a[0]) is np.float64) self.assertEqual(df.a.dtype, np.float) def test_warn_if_chunks_have_mismatched_type(self): # See test in TestCParserLowMemory. integers = [str(i) for i in range(499999)] data = "a\n" + "\n".join(integers + ['a', 'b'] + integers) with tm.assert_produces_warning(False): df = self.read_csv(StringIO(data)) self.assertEqual(df.a.dtype, np.object) def test_usecols(self): data = """\ a,b,c 1,2,3 4,5,6 7,8,9 10,11,12""" result = self.read_csv(StringIO(data), usecols=(1, 2)) result2 = self.read_csv(StringIO(data), usecols=('b', 'c')) exp = self.read_csv(StringIO(data)) self.assertEqual(len(result.columns), 2) self.assertTrue((result['b'] == exp['b']).all()) self.assertTrue((result['c'] == exp['c']).all()) tm.assert_frame_equal(result, result2) result = self.read_csv(StringIO(data), usecols=[1, 2], header=0, names=['foo', 'bar']) expected = self.read_csv(StringIO(data), usecols=[1, 2]) expected.columns = ['foo', 'bar'] tm.assert_frame_equal(result, expected) data = """\ 1,2,3 4,5,6 7,8,9 10,11,12""" result = self.read_csv(StringIO(data), names=['b', 'c'], header=None, usecols=[1, 2]) expected = self.read_csv(StringIO(data), names=['a', 'b', 'c'], header=None) expected = expected[['b', 'c']] tm.assert_frame_equal(result, expected) result2 = self.read_csv(StringIO(data), names=['a', 'b', 'c'], header=None, usecols=['b', 'c']) tm.assert_frame_equal(result2, result) # 5766 result = self.read_csv(StringIO(data), names=['a', 'b'], header=None, usecols=[0, 1]) expected = self.read_csv(StringIO(data), names=['a', 'b', 'c'], header=None) expected = expected[['a', 'b']] tm.assert_frame_equal(result, expected) # length conflict, passed names and usecols disagree self.assertRaises(ValueError, self.read_csv, StringIO(data), names=['a', 'b'], usecols=[1], header=None) def test_integer_overflow_bug(self): # #2601 data = "65248E10 11\n55555E55 22\n" result = self.read_csv(StringIO(data), header=None, sep=' ') self.assertTrue(result[0].dtype == np.float64) result = self.read_csv(StringIO(data), header=None, sep='\s+') self.assertTrue(result[0].dtype == np.float64) def test_catch_too_many_names(self): # Issue 5156 data = """\ 1,2,3 4,,6 7,8,9 10,11,12\n""" tm.assertRaises(Exception, read_csv, StringIO(data), header=0, names=['a', 'b', 'c', 'd']) def test_ignore_leading_whitespace(self): # GH 6607, GH 3374 data = ' a b c\n 1 2 3\n 4 5 6\n 7 8 9' result = self.read_table(StringIO(data), sep='\s+') expected = DataFrame({'a': [1, 4, 7], 'b': [2, 5, 8], 'c': [3, 6, 9]}) tm.assert_frame_equal(result, expected) def test_nrows_and_chunksize_raises_notimplemented(self): data = 'a b c' self.assertRaises(NotImplementedError, self.read_csv, StringIO(data), nrows=10, chunksize=5) def test_single_char_leading_whitespace(self): # GH 9710 data = """\ MyColumn a b a b\n""" expected = DataFrame({'MyColumn': list('abab')}) result = self.read_csv(StringIO(data), skipinitialspace=True) tm.assert_frame_equal(result, expected) def test_chunk_begins_with_newline_whitespace(self): # GH 10022 data = '\n hello\nworld\n' result = self.read_csv(StringIO(data), header=None) self.assertEqual(len(result), 2) # GH 9735 chunk1 = 'a' * (1024 * 256 - 2) + '\na' chunk2 = '\n a' result = pd.read_csv(StringIO(chunk1 + chunk2), header=None) expected = pd.DataFrame(['a' * (1024 * 256 - 2), 'a', ' a']) tm.assert_frame_equal(result, expected) def test_empty_with_index(self): # GH 10184 data = 'x,y' result = self.read_csv(StringIO(data), index_col=0) expected = DataFrame([], columns=['y'], index=Index([], name='x')) tm.assert_frame_equal(result, expected) def test_emtpy_with_multiindex(self): # GH 10467 data = 'x,y,z' result = self.read_csv(StringIO(data), index_col=['x', 'y']) expected = DataFrame([], columns=['z'], index=MultiIndex.from_arrays([[]] * 2, names=['x', 'y'])) tm.assert_frame_equal(result, expected, check_index_type=False) def test_empty_with_reversed_multiindex(self): data = 'x,y,z' result = self.read_csv(StringIO(data), index_col=[1, 0]) expected = DataFrame([], columns=['z'], index=MultiIndex.from_arrays([[]] * 2, names=['y', 'x'])) tm.assert_frame_equal(result, expected, check_index_type=False) def test_empty_index_col_scenarios(self): data = 'x,y,z' # None, no index index_col, expected = None, DataFrame([], columns=list('xyz')), tm.assert_frame_equal(self.read_csv( StringIO(data), index_col=index_col), expected) # False, no index index_col, expected = False, DataFrame([], columns=list('xyz')), tm.assert_frame_equal(self.read_csv( StringIO(data), index_col=index_col), expected) # int, first column index_col, expected = 0, DataFrame( [], columns=['y', 'z'], index=Index([], name='x')) tm.assert_frame_equal(self.read_csv( StringIO(data), index_col=index_col), expected) # int, not first column index_col, expected = 1, DataFrame( [], columns=['x', 'z'], index=Index([], name='y')) tm.assert_frame_equal(self.read_csv( StringIO(data), index_col=index_col), expected) # str, first column index_col, expected = 'x', DataFrame( [], columns=['y', 'z'], index=Index([], name='x')) tm.assert_frame_equal(self.read_csv( StringIO(data), index_col=index_col), expected) # str, not the first column index_col, expected = 'y', DataFrame( [], columns=['x', 'z'], index=Index([], name='y')) tm.assert_frame_equal(self.read_csv( StringIO(data), index_col=index_col), expected) # list of int index_col, expected = [0, 1], DataFrame([], columns=['z'], index=MultiIndex.from_arrays([[]] * 2, names=['x', 'y'])) tm.assert_frame_equal(self.read_csv(StringIO(data), index_col=index_col), expected, check_index_type=False) # list of str index_col = ['x', 'y'] expected = DataFrame([], columns=['z'], index=MultiIndex.from_arrays( [[]] * 2, names=['x', 'y'])) tm.assert_frame_equal(self.read_csv(StringIO(data), index_col=index_col), expected, check_index_type=False) # list of int, reversed sequence index_col = [1, 0] expected = DataFrame([], columns=['z'], index=MultiIndex.from_arrays( [[]] * 2, names=['y', 'x'])) tm.assert_frame_equal(self.read_csv(StringIO(data), index_col=index_col), expected, check_index_type=False) # list of str, reversed sequence index_col = ['y', 'x'] expected = DataFrame([], columns=['z'], index=MultiIndex.from_arrays( [[]] * 2, names=['y', 'x'])) tm.assert_frame_equal(self.read_csv(StringIO(data), index_col=index_col), expected, check_index_type=False) def test_empty_with_index_col_false(self): # GH 10413 data = 'x,y' result = self.read_csv(StringIO(data), index_col=False) expected = DataFrame([], columns=['x', 'y']) tm.assert_frame_equal(result, expected) def test_float_parser(self): # GH 9565 data = '45e-1,4.5,45.,inf,-inf' result = self.read_csv(StringIO(data), header=None) expected = pd.DataFrame([[float(s) for s in data.split(',')]]) tm.assert_frame_equal(result, expected) def test_int64_overflow(self): data = """ID 00013007854817840016671868 00013007854817840016749251 00013007854817840016754630 00013007854817840016781876 00013007854817840017028824 00013007854817840017963235 00013007854817840018860166""" result = self.read_csv(StringIO(data)) self.assertTrue(result['ID'].dtype == object) self.assertRaises((OverflowError, pandas.parser.OverflowError), self.read_csv, StringIO(data), converters={'ID': np.int64}) # Just inside int64 range: parse as integer i_max = np.iinfo(np.int64).max i_min = np.iinfo(np.int64).min for x in [i_max, i_min]: result = pd.read_csv(StringIO(str(x)), header=None) expected = pd.DataFrame([x]) tm.assert_frame_equal(result, expected) # Just outside int64 range: parse as string too_big = i_max + 1 too_small = i_min - 1 for x in [too_big, too_small]: result = pd.read_csv(StringIO(str(x)), header=None) expected = pd.DataFrame([str(x)]) tm.assert_frame_equal(result, expected) def test_empty_with_nrows_chunksize(self): # GH 9535 expected = pd.DataFrame([], columns=['foo', 'bar']) result = self.read_csv(StringIO('foo,bar\n'), nrows=10) tm.assert_frame_equal(result, expected) result = next(iter(pd.read_csv(StringIO('foo,bar\n'), chunksize=10))) tm.assert_frame_equal(result, expected) result = pd.read_csv(StringIO('foo,bar\n'), nrows=10, as_recarray=True) result = pd.DataFrame(result[2], columns=result[1], index=result[0]) tm.assert_frame_equal(pd.DataFrame.from_records( result), expected, check_index_type=False) result = next( iter(pd.read_csv(StringIO('foo,bar\n'), chunksize=10, as_recarray=True))) result = pd.DataFrame(result[2], columns=result[1], index=result[0]) tm.assert_frame_equal(pd.DataFrame.from_records( result), expected, check_index_type=False) def test_eof_states(self): # GH 10728 and 10548 # With skip_blank_lines = True expected = pd.DataFrame([[4, 5, 6]], columns=['a', 'b', 'c']) # GH 10728 # WHITESPACE_LINE data = 'a,b,c\n4,5,6\n ' result = self.read_csv(StringIO(data)) tm.assert_frame_equal(result, expected) # GH 10548 # EAT_LINE_COMMENT data = 'a,b,c\n4,5,6\n#comment' result = self.read_csv(StringIO(data), comment='#') tm.assert_frame_equal(result, expected) # EAT_CRNL_NOP data = 'a,b,c\n4,5,6\n\r' result = self.read_csv(StringIO(data)) tm.assert_frame_equal(result, expected) # EAT_COMMENT data = 'a,b,c\n4,5,6#comment' result = self.read_csv(StringIO(data), comment='#') tm.assert_frame_equal(result, expected) # SKIP_LINE data = 'a,b,c\n4,5,6\nskipme' result = self.read_csv(StringIO(data), skiprows=[2]) tm.assert_frame_equal(result, expected) # With skip_blank_lines = False # EAT_LINE_COMMENT data = 'a,b,c\n4,5,6\n#comment' result = self.read_csv( StringIO(data), comment='#', skip_blank_lines=False) expected = pd.DataFrame([[4, 5, 6]], columns=['a', 'b', 'c']) tm.assert_frame_equal(result, expected) # IN_FIELD data = 'a,b,c\n4,5,6\n ' result = self.read_csv(StringIO(data), skip_blank_lines=False) expected = pd.DataFrame( [['4', 5, 6], [' ', None, None]], columns=['a', 'b', 'c']) tm.assert_frame_equal(result, expected) # EAT_CRNL data = 'a,b,c\n4,5,6\n\r' result = self.read_csv(StringIO(data), skip_blank_lines=False) expected = pd.DataFrame( [[4, 5, 6], [None, None, None]], columns=['a', 'b', 'c']) tm.assert_frame_equal(result, expected) # Should produce exceptions # ESCAPED_CHAR data = "a,b,c\n4,5,6\n\\" self.assertRaises(Exception, self.read_csv, StringIO(data), escapechar='\\') # ESCAPE_IN_QUOTED_FIELD data = 'a,b,c\n4,5,6\n"\\' self.assertRaises(Exception, self.read_csv, StringIO(data), escapechar='\\') # IN_QUOTED_FIELD data = 'a,b,c\n4,5,6\n"' self.assertRaises(Exception, self.read_csv, StringIO(data), escapechar='\\') class TestPythonParser(ParserTests, tm.TestCase): def test_negative_skipfooter_raises(self): text = """#foo,a,b,c #foo,a,b,c #foo,a,b,c #foo,a,b,c #foo,a,b,c #foo,a,b,c 1/1/2000,1.,2.,3. 1/2/2000,4,5,6 1/3/2000,7,8,9 """ with tm.assertRaisesRegexp(ValueError, 'skip footer cannot be negative'): df = self.read_csv(StringIO(text), skipfooter=-1) def read_csv(self, *args, **kwds): kwds = kwds.copy() kwds['engine'] = 'python' return read_csv(*args, **kwds) def read_table(self, *args, **kwds): kwds = kwds.copy() kwds['engine'] = 'python' return read_table(*args, **kwds) def test_sniff_delimiter(self): text = """index|A|B|C foo|1|2|3 bar|4|5|6 baz|7|8|9 """ data = self.read_csv(StringIO(text), index_col=0, sep=None) self.assertTrue(data.index.equals(Index(['foo', 'bar', 'baz']))) data2 = self.read_csv(StringIO(text), index_col=0, delimiter='|') tm.assert_frame_equal(data, data2) text = """ignore this ignore this too index|A|B|C foo|1|2|3 bar|4|5|6 baz|7|8|9 """ data3 = self.read_csv(StringIO(text), index_col=0, sep=None, skiprows=2) tm.assert_frame_equal(data, data3) text = u("""ignore this ignore this too index|A|B|C foo|1|2|3 bar|4|5|6 baz|7|8|9 """).encode('utf-8') s = BytesIO(text) if compat.PY3: # somewhat False since the code never sees bytes from io import TextIOWrapper s = TextIOWrapper(s, encoding='utf-8') data4 = self.read_csv(s, index_col=0, sep=None, skiprows=2, encoding='utf-8') tm.assert_frame_equal(data, data4) def test_regex_separator(self): data = """ A B C D a 1 2 3 4 b 1 2 3 4 c 1 2 3 4 """ df = self.read_table(StringIO(data), sep='\s+') expected = self.read_csv(StringIO(re.sub('[ ]+', ',', data)), index_col=0) self.assertIsNone(expected.index.name) tm.assert_frame_equal(df, expected) def test_1000_fwf(self): data = """ 1 2,334.0 5 10 13 10. """ expected = [[1, 2334., 5], [10, 13, 10]] df = read_fwf(StringIO(data), colspecs=[(0, 3), (3, 11), (12, 16)], thousands=',') tm.assert_almost_equal(df.values, expected) def test_1000_sep_with_decimal(self): data = """A|B|C 1|2,334.01|5 10|13|10. """ expected = DataFrame({ 'A': [1, 10], 'B': [2334.01, 13], 'C': [5, 10.] }) df = self.read_csv(StringIO(data), sep='|', thousands=',') tm.assert_frame_equal(df, expected) df = self.read_table(StringIO(data), sep='|', thousands=',') tm.assert_frame_equal(df, expected) def test_comment_fwf(self): data = """ 1 2. 4 #hello world 5 NaN 10.0 """ expected = [[1, 2., 4], [5, np.nan, 10.]] df = read_fwf(StringIO(data), colspecs=[(0, 3), (4, 9), (9, 25)], comment='#') tm.assert_almost_equal(df.values, expected) def test_fwf(self): data_expected = """\ 2011,58,360.242940,149.910199,11950.7 2011,59,444.953632,166.985655,11788.4 2011,60,364.136849,183.628767,11806.2 2011,61,413.836124,184.375703,11916.8 2011,62,502.953953,173.237159,12468.3 """ expected = self.read_csv(StringIO(data_expected), header=None) data1 = """\ 201158 360.242940 149.910199 11950.7 201159 444.953632 166.985655 11788.4 201160 364.136849 183.628767 11806.2 201161 413.836124 184.375703 11916.8 201162 502.953953 173.237159 12468.3 """ colspecs = [(0, 4), (4, 8), (8, 20), (21, 33), (34, 43)] df = read_fwf(StringIO(data1), colspecs=colspecs, header=None) tm.assert_frame_equal(df, expected) data2 = """\ 2011 58 360.242940 149.910199 11950.7 2011 59 444.953632 166.985655 11788.4 2011 60 364.136849 183.628767 11806.2 2011 61 413.836124 184.375703 11916.8 2011 62 502.953953 173.237159 12468.3 """ df = read_fwf(StringIO(data2), widths=[5, 5, 13, 13, 7], header=None) tm.assert_frame_equal(df, expected) # From <NAME>: apparently some non-space filler characters can # be seen, this is supported by specifying the 'delimiter' character: # http://publib.boulder.ibm.com/infocenter/dmndhelp/v6r1mx/index.jsp?topic=/com.ibm.wbit.612.help.config.doc/topics/rfixwidth.html data3 = """\ 201158~~~~360.242940~~~149.910199~~~11950.7 201159~~~~444.953632~~~166.985655~~~11788.4 201160~~~~364.136849~~~183.628767~~~11806.2 201161~~~~413.836124~~~184.375703~~~11916.8 201162~~~~502.953953~~~173.237159~~~12468.3 """ df = read_fwf( StringIO(data3), colspecs=colspecs, delimiter='~', header=None) tm.assert_frame_equal(df, expected) with tm.assertRaisesRegexp(ValueError, "must specify only one of"): read_fwf(StringIO(data3), colspecs=colspecs, widths=[6, 10, 10, 7]) with tm.assertRaisesRegexp(ValueError, "Must specify either"): read_fwf(StringIO(data3), colspecs=None, widths=None) def test_fwf_colspecs_is_list_or_tuple(self): with tm.assertRaisesRegexp(TypeError, 'column specifications must be a list or ' 'tuple.+'): pd.io.parsers.FixedWidthReader(StringIO(self.data1), {'a': 1}, ',', '#') def test_fwf_colspecs_is_list_or_tuple_of_two_element_tuples(self): with tm.assertRaisesRegexp(TypeError, 'Each column specification must be.+'): read_fwf(StringIO(self.data1), [('a', 1)]) def test_fwf_colspecs_None(self): # GH 7079 data = """\ 123456 456789 """ colspecs = [(0, 3), (3, None)] result = read_fwf(StringIO(data), colspecs=colspecs, header=None) expected =
DataFrame([[123, 456], [456, 789]])
pandas.DataFrame
import os import logging import click import pandas as pd from bto_sbf_webscraper.scraper import ( get_available_flats, scrape, ) from . import __version__ os.environ["WDM_LOG_LEVEL"] = str(logging.WARNING) @click.command() @click.option( "--selection_type", "-s", default="BTO", help="Choose between BTO / SBF / OBF", show_default=True, ) @click.option( "--launch_date", "-l", help="Choose your launch date", show_default=True, ) @click.option( "--town", "-t", help="Choose your town", show_default=True, ) @click.option( "--flat_type", "-f", help="Choose your flat type (2, 3, 4, 5, All)", show_default=True, ) @click.version_option(version=__version__) def main(selection_type, launch_date, town, flat_type): """Test Project""" if selection_type and (not launch_date and not town and not flat_type): flats_available = get_available_flats(selection_type) print_flats(flats_available) if flats_available: launch_date = get_launch_date(flats_available) flat_type = get_flat_types(launch_date, flats_available) town = get_town(launch_date, flat_type, flats_available) data = scrape(selection_type, launch_date, flat_type, town) file_name = f"{selection_type}_{launch_date}_{flat_type if flat_type else 'All'} Room_{town if town else 'All'}.csv".replace( "/", "-" )
pd.DataFrame(data)
pandas.DataFrame
import pandas as pd import numpy as np from random import uniform,randint,sample import datetime import math temperature_percage = 70 frottement_foret = 0.5 vitesse_percage = 1500 temperature_eau_refroidissement = 10 long_dataset = 28800*20 def choose(): L = [0,1,2,3] return sample(L,3) def fonction_pos_tp(x): #plus 10 pour temperature_percage return x*0.001737 + uniform(-2,2) def fonction_neg_tp(x): #moins 10 pour temperature_percage return x*(-1*0.001737) + uniform(-2,2) def fonction_pos_ff(x): #plus 0.4 pour temperature_percage return x*0.00007 + uniform(-0.1,0.1) def fonction_neg_ff(x): #moins 0,4 pour temperature_percage return x*(-0.00007) + uniform(-0.1,0.1) def fonction_pos_vp(x): #plus 1500 pour temperature_percage return x*0.0864 + uniform(-50,50) def fonction_neg_vp(x): #moins 1000 pour temperature_percage return x*(-1*0.0864) + uniform(-50,50) def fonction_pos_ter(x): #plus 5 pour temperature_percage return x*(0.000868) + uniform(-1,1) def fonction_neg_ter(x): #moins 5 pour temperature_percage return x*(-1*0.000868) + uniform(-1,1) def generate_dataset(lg_ds): Temps = [datetime.datetime(2010,1,1,0,0,0)] Temp_perc = [temperature_percage] Frot_foret = [frottement_foret] Vitesse_perc = [vitesse_percage] Temp_refr = [temperature_eau_refroidissement] Target = [0] for i in range(lg_ds): if ((i % 28800) == 0): a = i + randint(1, 23040) if (i == a): b = choose() c1 = randint(0, 1) c2 = randint(0, 1) c3 = randint(0, 1) c4 = randint(0, 1) for j in range(5760): Temps.append(Temps[-1] + datetime.timedelta(minutes=5)) if ((0 in b) and (c1 == 0)): Temp_perc.append(temperature_percage + fonction_pos_tp(j)) elif ((0 in b) and (c1 == 1)): Temp_perc.append(temperature_percage + fonction_neg_tp(j)) else : Temp_perc.append(temperature_percage + uniform(-2,2)) if ((1 in b) and (c2 == 0)): Frot_foret.append(frottement_foret + fonction_pos_ff(j)) elif ((1 in b) and (c2 == 1)): Frot_foret.append(frottement_foret + fonction_neg_ff(j)) else : Frot_foret.append(frottement_foret + uniform(-0.1,0.1)) if ((2 in b) and (c3 == 0)): Vitesse_perc.append(vitesse_percage + fonction_pos_vp(j)) elif ((2 in b) and (c3 == 1)): Vitesse_perc.append(vitesse_percage + fonction_neg_vp(j)) else : Vitesse_perc.append(vitesse_percage + uniform(-50,50)) if ((3 in b) and (c4 == 0)): Temp_refr.append(temperature_eau_refroidissement + fonction_pos_ter(j)) elif ((3 in b) and (c4 == 1)): Temp_refr.append(temperature_eau_refroidissement + fonction_neg_ter(j)) else : Temp_refr.append(temperature_eau_refroidissement + uniform(-1,1)) if (j > 1000): Target.append(1) else : Target.append(0) else : Temps.append(Temps[-1] + datetime.timedelta(minutes=5)) Temp_perc.append(temperature_percage + 2*(np.sin(i/(288))) + uniform(-0.4, 0.4)) Frot_foret.append(frottement_foret + uniform(-0.1,0.1)) Vitesse_perc.append(vitesse_percage + 50*(np.sin(i/(288))) + uniform(-10, 10)) Temp_refr.append(temperature_eau_refroidissement + np.cos(i/(288)) + uniform(-0.2,0.2)) Target.append(0) df =
pd.DataFrame([Temps,Temp_perc,Frot_foret,Vitesse_perc,Temp_refr,Target])
pandas.DataFrame
# Copyright 2017 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 applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== """Convert raw PASCAL dataset to TFRecord for object_detection. Example usage: python object_detection/dataset_tools/create_pascal_tf_record.py \ --data_dir=/home/user/VOCdevkit \ --year=VOC2012 \ --output_path=/home/user/pascal.record """ from __future__ import absolute_import from __future__ import division from __future__ import print_function import hashlib import io import logging import os from lxml import etree import PIL.Image import tensorflow as tf from object_detection.utils import dataset_util from object_detection.utils import label_map_util import contextlib2 from object_detection.dataset_tools import tf_record_creation_util import numpy as np import pandas as pd from numpy.random import RandomState import cv2 import matplotlib matplotlib.use('TkAgg') import matplotlib.pyplot as plt flags = tf.app.flags flags.DEFINE_string('data_dir', '', 'Root directory to raw PASCAL VOC dataset.') flags.DEFINE_string('set', 'train', 'Convert training set, validation set or ' 'merged set.') flags.DEFINE_string('annotations_dir', 'Annotations', '(Relative) path to annotations directory.') flags.DEFINE_string('year', 'VOC2007', 'Desired challenge year.') flags.DEFINE_string('output_path', '', 'Path to output TFRecord') flags.DEFINE_string('label_map_path', 'object_detection/data/pascal_label_map.pbtxt', 'Path to label map proto') flags.DEFINE_boolean('ignore_difficult_instances', False, 'Whether to ignore ' 'difficult instances') FLAGS = flags.FLAGS SETS = ['train', 'val', 'trainval', 'test'] YEARS = ['VOC2007', 'VOC2012', 'merged'] def dict_to_tf_example(data, dataset_directory, label_map_dict, ignore_difficult_instances=False, image_subdirectory='JPEGImages'): """Convert XML derived dict to tf.Example proto. Notice that this function normalizes the bounding box coordinates provided by the raw data. Args: data: dict holding PASCAL XML fields for a single image (obtained by running dataset_util.recursive_parse_xml_to_dict) dataset_directory: Path to root directory holding PASCAL dataset label_map_dict: A map from string label names to integers ids. ignore_difficult_instances: Whether to skip difficult instances in the dataset (default: False). image_subdirectory: String specifying subdirectory within the PASCAL dataset directory holding the actual image data. Returns: example: The converted tf.Example. Raises: ValueError: if the image pointed to by data['filename'] is not a valid JPEG """ img_path = os.path.join(data['folder'], data['filename']+'.jpg') #os.path.join(data['folder'], image_subdirectory, data['filename']) full_path = os.path.join(dataset_directory, img_path) #print("full_path", full_path) with tf.gfile.GFile(full_path, 'rb') as fid: encoded_jpg = fid.read() encoded_jpg_io = io.BytesIO(encoded_jpg) image = PIL.Image.open(encoded_jpg_io) if image.format != 'JPEG': raise ValueError('Image format not JPEG') key = hashlib.sha256(encoded_jpg).hexdigest() width = int(data['size']['width']) height = int(data['size']['height']) xmin = [] ymin = [] xmax = [] ymax = [] classes = [] classes_text = [] truncated = [] poses = [] difficult_obj = [] if 'object' in data: for obj in data['object']: difficult = bool(int(obj['difficult'])) if ignore_difficult_instances and difficult: continue difficult_obj.append(int(difficult)) brands[obj['name']]=brands[obj['name']]+1 xmin.append(float(obj['bndbox']['xmin']) / width) ymin.append(float(obj['bndbox']['ymin']) / height) xmax.append(float(obj['bndbox']['xmax']) / width) ymax.append(float(obj['bndbox']['ymax']) / height) classes_text.append(obj['name'].encode('utf8')) if (obj['name'] in label_map_dict.keys()): classes.append(label_map_dict[obj['name']]) else: print("WARNING",full_path) truncated.append(int(obj['truncated'])) poses.append(obj['pose'].encode('utf8')) examples_list_number_classes_text[os.path.splitext(full_path)[0]]=len(classes_text) examples_list_number_classes[os.path.splitext(full_path)[0]]=len(classes) logging.info(xmin,ymin,xmax,ymax,classes_text,classes,poses,data['folder'], data['filename']) #print(xmin,ymin,xmax,ymax,classes_text,classes,poses,data['folder'], data['filename']) #print(xmin,ymin,xmax,ymax) example = tf.train.Example(features=tf.train.Features(feature={ 'image/height': dataset_util.int64_feature(height), 'image/width': dataset_util.int64_feature(width), 'image/filename': dataset_util.bytes_feature( data['folder']+'/'+data['filename'].encode('utf8')), 'image/source_id': dataset_util.bytes_feature( data['folder']+'/'+data['filename'].encode('utf8')), 'image/key/sha256': dataset_util.bytes_feature(key.encode('utf8')), 'image/encoded': dataset_util.bytes_feature(encoded_jpg), 'image/format': dataset_util.bytes_feature('jpeg'.encode('utf8')), 'image/object/bbox/xmin': dataset_util.float_list_feature(xmin), 'image/object/bbox/xmax': dataset_util.float_list_feature(xmax), 'image/object/bbox/ymin': dataset_util.float_list_feature(ymin), 'image/object/bbox/ymax': dataset_util.float_list_feature(ymax), 'image/object/class/text': dataset_util.bytes_list_feature(classes_text), 'image/object/class/label': dataset_util.int64_list_feature(classes), 'image/object/difficult': dataset_util.int64_list_feature(difficult_obj), 'image/object/truncated': dataset_util.int64_list_feature(truncated), 'image/object/view': dataset_util.bytes_list_feature(poses), })) if (examples_list_number_classes_text[os.path.splitext(full_path)[0]]!=examples_list_number_classes[os.path.splitext(full_path)[0]]): print(full_path,example) if ((data['folder']+'/'+data['filename']=='nike/img000105') or (len(classes_text) ==0)): #logging.info(example) #print(full_path,example) print(full_path,examples_list_number_classes_text[os.path.splitext(full_path)[0]],examples_list_number_classes[os.path.splitext(full_path)[0]]) # extract pre-trained face detector #face_cascade = cv2.CascadeClassifier('haarcascades/haarcascade_frontalface_alt.xml') # load color (BGR) image img = cv2.imread(full_path) # convert BGR image to grayscale #gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) ## find faces in image #faces = face_cascade.detectMultiScale(gray) # print number of faces detected in the image #print('Number of faces detected:', len(faces)) ## get bounding box for each detected face #for (x,y,w,h) in (xmin,ymin,xmax,ymax): # # add bounding box to color image #cv2.rectangle(img,(int(xmin[0]),int(ymin[0])),(int(xmax[0]),int(ymax[0])),(255,0,0),2) cv2.rectangle(img,(int(xmin[0]*width),int(ymin[0])),(int(xmax[0]),int(ymax[0])),(255,0,0),2) # convert BGR image to RGB for plotting cv_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) #cv2.imshow("Image",cv_rgb) # display the image, along with bounding box #plt.imshow(cv_rgb) #plt.show() return example def main(_): if FLAGS.set not in SETS: raise ValueError('set must be in : {}'.format(SETS)) if FLAGS.year not in YEARS: raise ValueError('year must be in : {}'.format(YEARS)) data_dir = FLAGS.data_dir #years = ['VOC2007', 'VOC2012'] #if FLAGS.year != 'merged': # years = [FLAGS.year] output_train_path = os.path.join(FLAGS.output_path,"pascal3_train.record") output_val_path = os.path.join(FLAGS.output_path,"pascal3_val.record") #writer = tf.python_io.TFRecordWriter(FLAGS.output_path) writer_train = tf.python_io.TFRecordWriter(output_train_path) writer_val = tf.python_io.TFRecordWriter(output_val_path) label_map_dict = label_map_util.get_label_map_dict(FLAGS.label_map_path) brands= {}.fromkeys(label_map_dict.keys(),0) print('Reading from PASCAL dataset.') examples_path = os.path.join(data_dir)#(data_dir, year, 'ImageSets', 'Main','aeroplane_' + FLAGS.set + '.txt') examples_list=[os.path.splitext(os.path.join(root, name))[0] for root, dirs, files in os.walk(examples_path) for name in files if name.endswith(("jpg"))] print(len(examples_list),examples_list) indices = list(range(len(examples_list))) num_training_instances = int(0.8 * len(examples_list)) random_state=1234567890 rs = np.random.RandomState(random_state) rs.shuffle(indices) train_indices = indices[:num_training_instances] val_indices = indices[num_training_instances:] #print("indices",indices) # split the actual data examples_list_train, examples_list_val = list(pd.DataFrame(examples_list).iloc[train_indices].values.flatten()), list(
pd.DataFrame(examples_list)
pandas.DataFrame
import unittest, os import pandas as pd import pandas.util.testing as pdt import numpy as np from inferelator_ng import kvs_controller from inferelator_ng import bbsr_python from inferelator_ng import bayes_stats from inferelator_ng import regression my_dir = os.path.dirname(__file__) class TestBBSRrunnerPython(unittest.TestCase): def __init__(self, *args, **kwargs): super(TestBBSRrunnerPython, self).__init__(*args, **kwargs) # Extra behavior: only run if KVSClient can reach the host: self.kvs = None # dummy value on failure try: self.kvs = kvs_controller.KVSController() except Exception as e: if str(e) == 'Missing host': print('Test test_bbsr.py exiting since KVS host is not running') print('Try rerunning tests with python $LOCALREPO/kvsstcp.py --execcmd "nosetests --nocapture -v"') self.missing_kvs_host = True # Mock out Slurm process IDs so that KVS can access this process ID in bbsr_python.py os.environ['SLURM_PROCID'] = str(0) os.environ['SLURM_NTASKS'] = str(1) def get_kvs(self): result = self.kvs if result is None: self.fail("Test requires missing KVS host.") return result def setUp(self): # Check for os.environ['SLURM_NTASKS'] self.rank = 0 self.brd = bbsr_python.BBSR def run_bbsr(self): kvs = self.get_kvs() return self.brd(self.X, self.Y, self.clr, self.priors, kvs=kvs).run() def set_all_zero_priors(self): self.priors = pd.DataFrame([[0, 0],[0, 0]], index = ['gene1', 'gene2'], columns = ['gene1', 'gene2']) def set_all_zero_clr(self): self.clr = pd.DataFrame([[0, 0],[0, 0]], index = ['gene1', 'gene2'], columns = ['gene1', 'gene2']) def assert_matrix_is_square(self, size, matrix): self.assertEqual(matrix.shape, (size, size)) def test_two_genes(self): self.set_all_zero_priors() self.set_all_zero_clr() self.X = pd.DataFrame([0, 0], index = ['gene1', 'gene2'], columns = ['ss']) self.Y = pd.DataFrame([0, 0], index = ['gene1', 'gene2'], columns = ['ss']) (betas, resc) = self.run_bbsr() self.assert_matrix_is_square(2, betas) self.assert_matrix_is_square(2, resc) pdt.assert_frame_equal(betas, pd.DataFrame([[0, 0],[0, 0]], index = ['gene1', 'gene2'], columns = ['gene1', 'gene2']).astype(float)) pdt.assert_frame_equal(resc, pd.DataFrame([[0, 0],[0, 0]], index = ['gene1', 'gene2'], columns = ['gene1', 'gene2']).astype(float)) ''' def test_fails_with_one_gene(self): self.set_all_zero_priors() self.set_all_zero_clr() self.X = pd.DataFrame([0], index = ['gene1'], columns = ['ss']) self.Y = pd.DataFrame([0], index = ['gene1'], columns = ['ss']) self.assertRaises(CalledProcessError, self.brd.run, self.X, self.Y, self.clr, self.priors) ''' def test_two_genes_nonzero(self): self.set_all_zero_priors() self.set_all_zero_clr() self.X = pd.DataFrame([1, 2], index = ['gene1', 'gene2'], columns = ['ss']) self.Y = pd.DataFrame([1, 2], index = ['gene1', 'gene2'], columns = ['ss']) (betas, resc) = self.run_bbsr() self.assert_matrix_is_square(2, betas) self.assert_matrix_is_square(2, resc) pdt.assert_frame_equal(betas, pd.DataFrame([[0, 0],[0, 0]], index = ['gene1', 'gene2'], columns = ['gene1', 'gene2']).astype(float)) pdt.assert_frame_equal(resc, pd.DataFrame([[0, 0],[0, 0]], index = ['gene1', 'gene2'], columns = ['gene1', 'gene2']).astype(float)) # BBSR fails when there's only one column in the design (or response) matrix # That seems like unexpected behavior to me. If it is expected, there should be checks for it earlier -<NAME> ''' @unittest.skip(""" There's some unexpected behavior in bayesianRegression.R: a 2 x 1 matrix is getting transformed into a NaN matrix ss gene1 NaN gene2 NaN attr(,"scaled:center") gene1 gene2 1 2 attr(,"scaled:scale") gene1 gene2 0 0 """) ''' def test_two_genes_nonzero_clr_nonzero(self): self.set_all_zero_priors() self.X = pd.DataFrame([1, 2], index = ['gene1', 'gene2'], columns = ['ss']) self.Y = pd.DataFrame([1, 2], index = ['gene1', 'gene2'], columns = ['ss']) self.clr = pd.DataFrame([[.1, .1],[.1, .2]], index = ['gene1', 'gene2'], columns = ['gene1', 'gene2']) (betas, resc) = self.run_bbsr() self.assert_matrix_is_square(2, betas) self.assert_matrix_is_square(2, resc) pdt.assert_frame_equal(betas, pd.DataFrame([[0, 0],[0, 0]], index = ['gene1', 'gene2'], columns = ['gene1', 'gene2']).astype(float)) pdt.assert_frame_equal(resc, pd.DataFrame([[0, 0],[0, 0]], index = ['gene1', 'gene2'], columns = ['gene1', 'gene2']).astype(float)) def test_two_genes_nonzero_clr_two_conditions_negative_influence(self): self.set_all_zero_priors() self.X = pd.DataFrame([[1, 2], [2, 1]], index = ['gene1', 'gene2'], columns = ['ss1', 'ss2']) self.Y = pd.DataFrame([[1, 2], [2, 1]], index = ['gene1', 'gene2'], columns = ['ss1', 'ss2']) self.clr = pd.DataFrame([[.1, .1],[.1, .2]], index = ['gene1', 'gene2'], columns = ['gene1', 'gene2']) (betas, resc) = self.run_bbsr() self.assert_matrix_is_square(2, betas) self.assert_matrix_is_square(2, resc) pdt.assert_frame_equal(betas, pd.DataFrame([[0, -1],[-1, 0]], index = ['gene1', 'gene2'], columns = ['gene1', 'gene2']).astype(float)) pdt.assert_frame_equal(resc, pd.DataFrame([[0, 1],[1, 0]], index = ['gene1', 'gene2'], columns = ['gene1', 'gene2']).astype(float)) def test_two_genes_nonzero_clr_two_conditions_zero_gene1_negative_influence(self): self.set_all_zero_priors() self.X = pd.DataFrame([[0, 2], [2, 0]], index = ['gene1', 'gene2'], columns = ['ss1', 'ss2']) self.Y = pd.DataFrame([[0, 1], [1, 0]], index = ['gene1', 'gene2'], columns = ['ss1', 'ss2']) self.clr =
pd.DataFrame([[.1, .1],[.1, .2]], index = ['gene1', 'gene2'], columns = ['gene1', 'gene2'])
pandas.DataFrame
import gcsfs import pandas as pd import regex class Table2Df: def __init__(self, table_fit, fs): self.table = table_fit self.fs = fs self.df = None self.data = table_fit.data self.table_data = self.table.data.drop(self.table.header_indices) def reconstruct_table(self): """ Takes the information stored in the table_fit object and reconstitutes it into a DataFrame that mirrors how we see the table on the balance sheet. Arguments: None Returns: new_df: pandas DataFrame of table data from the balance sheet Raises: None """ headers = self.headers_to_strings(self.table.header_groups) new_df = pd.DataFrame(columns=headers) # For each row from our collected data, add the value in the corresponding position for index, row in self.table_data.iterrows(): new_df.loc[row["line_num"], headers[int(row["column"])]] = row["value"] return new_df def headers_to_strings(self, headers): """ Converts groups of header indices into a list of strings of all elements of each header group combined into a string. Arguments: headers: List of grouped header indices (the result of TableFitter.group_header_points()) Returns: str_headers: List of strings corresponding to the header values Raises: None """ # Set a value for the first column (which won't have a title) str_headers = ["Entities"] # Loop over the header groups for h in headers: k = 0 new_string = "" # Add all strings together while k < len(h): new_string+= (self.data.loc[h[k], "value"] + "\n") k+=1 str_headers.append(new_string) return str_headers def get_info_headers(self, years = range(1999,2020)): """ Creates a DataFrame of information of column info (meta data). For each column in our fitted table object, we record the corresponding date and units (currency). Arguments: years: List of possible years to search for. Returns: header_data: pandas DataFrame of column number with their relevant date and units as other variables Raises: None """ # Get a list of header indicies where we see a currency symbol currency_indexes = [i for i in self.table.header_indices if len(regex.findall(r"\p{Sc}", self.data.loc[i, "value"]))] self.unit_headers = currency_indexes # As above but for where we see a year date_indexes = [] for i in self.table.header_indices: contains_year = any([str(y) in self.data.loc[i, "value"] for y in years]) if contains_year: date_indexes.append(i) self.date_headers = date_indexes # Create an empty DataFrame to add information to header_data = pd.DataFrame(columns=["column", "date", "unit"]) # Add information for each column header to the DataFrame for i, g in enumerate(self.table.header_groups): unit_col = [j for j in g if j in self.unit_headers] date_col = [j for j in g if j in self.date_headers] if len(unit_col)==1 or len(date_col)==1: header_data.loc[i, "column"] = i+1 # Work out the unit if we don't have one assigned if not unit_col: header_data.loc[i, "date"] = self.data.loc[date_col[0], "value"] header_data.loc[i, "unit"] = self.get_closest_el(self.data, date_col[0], self.unit_headers) # As above but for dates elif not date_col: header_data.loc[i, "date"] = self.get_closest_el(self.data, unit_col[0], self.date_headers) header_data.loc[i, "unit"] = self.data.loc[unit_col[0], "value"] # If we already have both add them to the dataset else: header_data.loc[i, "date"] = self.data.loc[date_col[0], "value"] header_data.loc[i, "unit"] = self.data.loc[unit_col[0], "value"] return header_data def get_info_headers_v2(self, years = range(1999,2020)): """ Creates a DataFrame of information of column info (meta data). For each column in our fitted table object, we record the corresponding date and units (currency). Arguments: years: List of possible years to search for. Returns: header_data: pandas DataFrame of column number with their relevant date and units as other variables Raises: None """ self.data_cols = [i+1 for i,g in enumerate(self.table.header_groups) if self.table.notes_row[0] not in g] data_cols = [i+1 for i,g in enumerate(self.table.header_groups) if self.table.notes_row[0] not in g] currencies = [self.data.loc[i, "value"] for i in self.table.header_indices if len(regex.findall(r"\p{Sc}", self.data.loc[i, "value"]))] currency = max(set(currencies), key=currencies.count) # As above but for where we see a year dates = [] for i in self.table.header_indices: contains_year = any([str(y) in self.data.loc[i, "value"] for y in years]) if contains_year: dates.append(self.data.loc[i, "value"]) self.dates = dates if len(data_cols)%len(dates) != 0: raise(TypeError("Cannot logically fit dates to columns")) else: header_dict = {"column": data_cols, "date":[dates[i//(len(data_cols)//len(dates))] for i in range(len(data_cols))], "unit":[currency]*len(data_cols)} # Create an empty DataFrame to add information to header_data =
pd.DataFrame.from_dict(header_dict)
pandas.DataFrame.from_dict
"""SQL io tests The SQL tests are broken down in different classes: - `PandasSQLTest`: base class with common methods for all test classes - Tests for the public API (only tests with sqlite3) - `_TestSQLApi` base class - `TestSQLApi`: test the public API with sqlalchemy engine - `TestSQLiteFallbackApi`: test the public API with a sqlite DBAPI connection - Tests for the different SQL flavors (flavor specific type conversions) - Tests for the sqlalchemy mode: `_TestSQLAlchemy` is the base class with common methods, `_TestSQLAlchemyConn` tests the API with a SQLAlchemy Connection object. The different tested flavors (sqlite3, MySQL, PostgreSQL) derive from the base class - Tests for the fallback mode (`TestSQLiteFallback`) """ import csv from datetime import date, datetime, time from io import StringIO import sqlite3 import warnings import numpy as np import pytest from pandas.core.dtypes.common import is_datetime64_dtype, is_datetime64tz_dtype import pandas as pd from pandas import ( DataFrame, Index, MultiIndex, Series, Timestamp, concat, date_range, isna, to_datetime, to_timedelta, ) import pandas._testing as tm import pandas.io.sql as sql from pandas.io.sql import read_sql_query, read_sql_table try: import sqlalchemy import sqlalchemy.schema import sqlalchemy.sql.sqltypes as sqltypes from sqlalchemy.ext import declarative from sqlalchemy.orm import session as sa_session SQLALCHEMY_INSTALLED = True except ImportError: SQLALCHEMY_INSTALLED = False SQL_STRINGS = { "create_iris": { "sqlite": """CREATE TABLE iris ( "SepalLength" REAL, "SepalWidth" REAL, "PetalLength" REAL, "PetalWidth" REAL, "Name" TEXT )""", "mysql": """CREATE TABLE iris ( `SepalLength` DOUBLE, `SepalWidth` DOUBLE, `PetalLength` DOUBLE, `PetalWidth` DOUBLE, `Name` VARCHAR(200) )""", "postgresql": """CREATE TABLE iris ( "SepalLength" DOUBLE PRECISION, "SepalWidth" DOUBLE PRECISION, "PetalLength" DOUBLE PRECISION, "PetalWidth" DOUBLE PRECISION, "Name" VARCHAR(200) )""", }, "insert_iris": { "sqlite": """INSERT INTO iris VALUES(?, ?, ?, ?, ?)""", "mysql": """INSERT INTO iris VALUES(%s, %s, %s, %s, "%s");""", "postgresql": """INSERT INTO iris VALUES(%s, %s, %s, %s, %s);""", }, "create_test_types": { "sqlite": """CREATE TABLE types_test_data ( "TextCol" TEXT, "DateCol" TEXT, "IntDateCol" INTEGER, "IntDateOnlyCol" INTEGER, "FloatCol" REAL, "IntCol" INTEGER, "BoolCol" INTEGER, "IntColWithNull" INTEGER, "BoolColWithNull" INTEGER )""", "mysql": """CREATE TABLE types_test_data ( `TextCol` TEXT, `DateCol` DATETIME, `IntDateCol` INTEGER, `IntDateOnlyCol` INTEGER, `FloatCol` DOUBLE, `IntCol` INTEGER, `BoolCol` BOOLEAN, `IntColWithNull` INTEGER, `BoolColWithNull` BOOLEAN )""", "postgresql": """CREATE TABLE types_test_data ( "TextCol" TEXT, "DateCol" TIMESTAMP, "DateColWithTz" TIMESTAMP WITH TIME ZONE, "IntDateCol" INTEGER, "IntDateOnlyCol" INTEGER, "FloatCol" DOUBLE PRECISION, "IntCol" INTEGER, "BoolCol" BOOLEAN, "IntColWithNull" INTEGER, "BoolColWithNull" BOOLEAN )""", }, "insert_test_types": { "sqlite": { "query": """ INSERT INTO types_test_data VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?) """, "fields": ( "TextCol", "DateCol", "IntDateCol", "IntDateOnlyCol", "FloatCol", "IntCol", "BoolCol", "IntColWithNull", "BoolColWithNull", ), }, "mysql": { "query": """ INSERT INTO types_test_data VALUES("%s", %s, %s, %s, %s, %s, %s, %s, %s) """, "fields": ( "TextCol", "DateCol", "IntDateCol", "IntDateOnlyCol", "FloatCol", "IntCol", "BoolCol", "IntColWithNull", "BoolColWithNull", ), }, "postgresql": { "query": """ INSERT INTO types_test_data VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s) """, "fields": ( "TextCol", "DateCol", "DateColWithTz", "IntDateCol", "IntDateOnlyCol", "FloatCol", "IntCol", "BoolCol", "IntColWithNull", "BoolColWithNull", ), }, }, "read_parameters": { "sqlite": "SELECT * FROM iris WHERE Name=? AND SepalLength=?", "mysql": 'SELECT * FROM iris WHERE `Name`="%s" AND `SepalLength`=%s', "postgresql": 'SELECT * FROM iris WHERE "Name"=%s AND "SepalLength"=%s', }, "read_named_parameters": { "sqlite": """ SELECT * FROM iris WHERE Name=:name AND SepalLength=:length """, "mysql": """ SELECT * FROM iris WHERE `Name`="%(name)s" AND `SepalLength`=%(length)s """, "postgresql": """ SELECT * FROM iris WHERE "Name"=%(name)s AND "SepalLength"=%(length)s """, }, "create_view": { "sqlite": """ CREATE VIEW iris_view AS SELECT * FROM iris """ }, } class MixInBase: def teardown_method(self, method): # if setup fails, there may not be a connection to close. if hasattr(self, "conn"): for tbl in self._get_all_tables(): self.drop_table(tbl) self._close_conn() class MySQLMixIn(MixInBase): def drop_table(self, table_name): cur = self.conn.cursor() cur.execute(f"DROP TABLE IF EXISTS {sql._get_valid_mysql_name(table_name)}") self.conn.commit() def _get_all_tables(self): cur = self.conn.cursor() cur.execute("SHOW TABLES") return [table[0] for table in cur.fetchall()] def _close_conn(self): from pymysql.err import Error try: self.conn.close() except Error: pass class SQLiteMixIn(MixInBase): def drop_table(self, table_name): self.conn.execute( f"DROP TABLE IF EXISTS {sql._get_valid_sqlite_name(table_name)}" ) self.conn.commit() def _get_all_tables(self): c = self.conn.execute("SELECT name FROM sqlite_master WHERE type='table'") return [table[0] for table in c.fetchall()] def _close_conn(self): self.conn.close() class SQLAlchemyMixIn(MixInBase): def drop_table(self, table_name): sql.SQLDatabase(self.conn).drop_table(table_name) def _get_all_tables(self): meta = sqlalchemy.schema.MetaData(bind=self.conn) meta.reflect() table_list = meta.tables.keys() return table_list def _close_conn(self): pass class PandasSQLTest: """ Base class with common private methods for SQLAlchemy and fallback cases. """ def _get_exec(self): if hasattr(self.conn, "execute"): return self.conn else: return self.conn.cursor() @pytest.fixture(params=[("data", "iris.csv")]) def load_iris_data(self, datapath, request): import io iris_csv_file = datapath(*request.param) if not hasattr(self, "conn"): self.setup_connect() self.drop_table("iris") self._get_exec().execute(SQL_STRINGS["create_iris"][self.flavor]) with io.open(iris_csv_file, mode="r", newline=None) as iris_csv: r = csv.reader(iris_csv) next(r) # skip header row ins = SQL_STRINGS["insert_iris"][self.flavor] for row in r: self._get_exec().execute(ins, row) def _load_iris_view(self): self.drop_table("iris_view") self._get_exec().execute(SQL_STRINGS["create_view"][self.flavor]) def _check_iris_loaded_frame(self, iris_frame): pytype = iris_frame.dtypes[0].type row = iris_frame.iloc[0] assert issubclass(pytype, np.floating) tm.equalContents(row.values, [5.1, 3.5, 1.4, 0.2, "Iris-setosa"]) def _load_test1_data(self): columns = ["index", "A", "B", "C", "D"] data = [ ( "2000-01-03 00:00:00", 0.980268513777, 3.68573087906, -0.364216805298, -1.15973806169, ), ( "2000-01-04 00:00:00", 1.04791624281, -0.0412318367011, -0.16181208307, 0.212549316967, ), ( "2000-01-05 00:00:00", 0.498580885705, 0.731167677815, -0.537677223318, 1.34627041952, ), ( "2000-01-06 00:00:00", 1.12020151869, 1.56762092543, 0.00364077397681, 0.67525259227, ), ] self.test_frame1 = DataFrame(data, columns=columns) def _load_test2_data(self): df = DataFrame( dict( A=[4, 1, 3, 6], B=["asd", "gsq", "ylt", "jkl"], C=[1.1, 3.1, 6.9, 5.3], D=[False, True, True, False], E=["1990-11-22", "1991-10-26", "1993-11-26", "1995-12-12"], ) ) df["E"] = to_datetime(df["E"]) self.test_frame2 = df def _load_test3_data(self): columns = ["index", "A", "B"] data = [ ("2000-01-03 00:00:00", 2 ** 31 - 1, -1.987670), ("2000-01-04 00:00:00", -29, -0.0412318367011), ("2000-01-05 00:00:00", 20000, 0.731167677815), ("2000-01-06 00:00:00", -290867, 1.56762092543), ] self.test_frame3 = DataFrame(data, columns=columns) def _load_raw_sql(self): self.drop_table("types_test_data") self._get_exec().execute(SQL_STRINGS["create_test_types"][self.flavor]) ins = SQL_STRINGS["insert_test_types"][self.flavor] data = [ { "TextCol": "first", "DateCol": "2000-01-03 00:00:00", "DateColWithTz": "2000-01-01 00:00:00-08:00", "IntDateCol": 535852800, "IntDateOnlyCol": 20101010, "FloatCol": 10.10, "IntCol": 1, "BoolCol": False, "IntColWithNull": 1, "BoolColWithNull": False, }, { "TextCol": "first", "DateCol": "2000-01-04 00:00:00", "DateColWithTz": "2000-06-01 00:00:00-07:00", "IntDateCol": 1356998400, "IntDateOnlyCol": 20101212, "FloatCol": 10.10, "IntCol": 1, "BoolCol": False, "IntColWithNull": None, "BoolColWithNull": None, }, ] for d in data: self._get_exec().execute( ins["query"], [d[field] for field in ins["fields"]] ) def _count_rows(self, table_name): result = ( self._get_exec() .execute(f"SELECT count(*) AS count_1 FROM {table_name}") .fetchone() ) return result[0] def _read_sql_iris(self): iris_frame = self.pandasSQL.read_query("SELECT * FROM iris") self._check_iris_loaded_frame(iris_frame) def _read_sql_iris_parameter(self): query = SQL_STRINGS["read_parameters"][self.flavor] params = ["Iris-setosa", 5.1] iris_frame = self.pandasSQL.read_query(query, params=params) self._check_iris_loaded_frame(iris_frame) def _read_sql_iris_named_parameter(self): query = SQL_STRINGS["read_named_parameters"][self.flavor] params = {"name": "Iris-setosa", "length": 5.1} iris_frame = self.pandasSQL.read_query(query, params=params) self._check_iris_loaded_frame(iris_frame) def _to_sql(self, method=None): self.drop_table("test_frame1") self.pandasSQL.to_sql(self.test_frame1, "test_frame1", method=method) assert self.pandasSQL.has_table("test_frame1") num_entries = len(self.test_frame1) num_rows = self._count_rows("test_frame1") assert num_rows == num_entries # Nuke table self.drop_table("test_frame1") def _to_sql_empty(self): self.drop_table("test_frame1") self.pandasSQL.to_sql(self.test_frame1.iloc[:0], "test_frame1") def _to_sql_fail(self): self.drop_table("test_frame1") self.pandasSQL.to_sql(self.test_frame1, "test_frame1", if_exists="fail") assert self.pandasSQL.has_table("test_frame1") msg = "Table 'test_frame1' already exists" with pytest.raises(ValueError, match=msg): self.pandasSQL.to_sql(self.test_frame1, "test_frame1", if_exists="fail") self.drop_table("test_frame1") def _to_sql_replace(self): self.drop_table("test_frame1") self.pandasSQL.to_sql(self.test_frame1, "test_frame1", if_exists="fail") # Add to table again self.pandasSQL.to_sql(self.test_frame1, "test_frame1", if_exists="replace") assert self.pandasSQL.has_table("test_frame1") num_entries = len(self.test_frame1) num_rows = self._count_rows("test_frame1") assert num_rows == num_entries self.drop_table("test_frame1") def _to_sql_append(self): # Nuke table just in case self.drop_table("test_frame1") self.pandasSQL.to_sql(self.test_frame1, "test_frame1", if_exists="fail") # Add to table again self.pandasSQL.to_sql(self.test_frame1, "test_frame1", if_exists="append") assert self.pandasSQL.has_table("test_frame1") num_entries = 2 * len(self.test_frame1) num_rows = self._count_rows("test_frame1") assert num_rows == num_entries self.drop_table("test_frame1") def _to_sql_method_callable(self): check = [] # used to double check function below is really being used def sample(pd_table, conn, keys, data_iter): check.append(1) data = [dict(zip(keys, row)) for row in data_iter] conn.execute(pd_table.table.insert(), data) self.drop_table("test_frame1") self.pandasSQL.to_sql(self.test_frame1, "test_frame1", method=sample) assert self.pandasSQL.has_table("test_frame1") assert check == [1] num_entries = len(self.test_frame1) num_rows = self._count_rows("test_frame1") assert num_rows == num_entries # Nuke table self.drop_table("test_frame1") def _roundtrip(self): self.drop_table("test_frame_roundtrip") self.pandasSQL.to_sql(self.test_frame1, "test_frame_roundtrip") result = self.pandasSQL.read_query("SELECT * FROM test_frame_roundtrip") result.set_index("level_0", inplace=True) # result.index.astype(int) result.index.name = None tm.assert_frame_equal(result, self.test_frame1) def _execute_sql(self): # drop_sql = "DROP TABLE IF EXISTS test" # should already be done iris_results = self.pandasSQL.execute("SELECT * FROM iris") row = iris_results.fetchone() tm.equalContents(row, [5.1, 3.5, 1.4, 0.2, "Iris-setosa"]) def _to_sql_save_index(self): df = DataFrame.from_records( [(1, 2.1, "line1"), (2, 1.5, "line2")], columns=["A", "B", "C"], index=["A"] ) self.pandasSQL.to_sql(df, "test_to_sql_saves_index") ix_cols = self._get_index_columns("test_to_sql_saves_index") assert ix_cols == [["A"]] def _transaction_test(self): with self.pandasSQL.run_transaction() as trans: trans.execute("CREATE TABLE test_trans (A INT, B TEXT)") class DummyException(Exception): pass # Make sure when transaction is rolled back, no rows get inserted ins_sql = "INSERT INTO test_trans (A,B) VALUES (1, 'blah')" try: with self.pandasSQL.run_transaction() as trans: trans.execute(ins_sql) raise DummyException("error") except DummyException: # ignore raised exception pass res = self.pandasSQL.read_query("SELECT * FROM test_trans") assert len(res) == 0 # Make sure when transaction is committed, rows do get inserted with self.pandasSQL.run_transaction() as trans: trans.execute(ins_sql) res2 = self.pandasSQL.read_query("SELECT * FROM test_trans") assert len(res2) == 1 # ----------------------------------------------------------------------------- # -- Testing the public API class _TestSQLApi(PandasSQLTest): """ Base class to test the public API. From this two classes are derived to run these tests for both the sqlalchemy mode (`TestSQLApi`) and the fallback mode (`TestSQLiteFallbackApi`). These tests are run with sqlite3. Specific tests for the different sql flavours are included in `_TestSQLAlchemy`. Notes: flavor can always be passed even in SQLAlchemy mode, should be correctly ignored. we don't use drop_table because that isn't part of the public api """ flavor = "sqlite" mode: str def setup_connect(self): self.conn = self.connect() @pytest.fixture(autouse=True) def setup_method(self, load_iris_data): self.load_test_data_and_sql() def load_test_data_and_sql(self): self._load_iris_view() self._load_test1_data() self._load_test2_data() self._load_test3_data() self._load_raw_sql() def test_read_sql_iris(self): iris_frame = sql.read_sql_query("SELECT * FROM iris", self.conn) self._check_iris_loaded_frame(iris_frame) def test_read_sql_view(self): iris_frame = sql.read_sql_query("SELECT * FROM iris_view", self.conn) self._check_iris_loaded_frame(iris_frame) def test_to_sql(self): sql.to_sql(self.test_frame1, "test_frame1", self.conn) assert sql.has_table("test_frame1", self.conn) def test_to_sql_fail(self): sql.to_sql(self.test_frame1, "test_frame2", self.conn, if_exists="fail") assert sql.has_table("test_frame2", self.conn) msg = "Table 'test_frame2' already exists" with pytest.raises(ValueError, match=msg): sql.to_sql(self.test_frame1, "test_frame2", self.conn, if_exists="fail") def test_to_sql_replace(self): sql.to_sql(self.test_frame1, "test_frame3", self.conn, if_exists="fail") # Add to table again sql.to_sql(self.test_frame1, "test_frame3", self.conn, if_exists="replace") assert sql.has_table("test_frame3", self.conn) num_entries = len(self.test_frame1) num_rows = self._count_rows("test_frame3") assert num_rows == num_entries def test_to_sql_append(self): sql.to_sql(self.test_frame1, "test_frame4", self.conn, if_exists="fail") # Add to table again sql.to_sql(self.test_frame1, "test_frame4", self.conn, if_exists="append") assert sql.has_table("test_frame4", self.conn) num_entries = 2 * len(self.test_frame1) num_rows = self._count_rows("test_frame4") assert num_rows == num_entries def test_to_sql_type_mapping(self): sql.to_sql(self.test_frame3, "test_frame5", self.conn, index=False) result = sql.read_sql("SELECT * FROM test_frame5", self.conn) tm.assert_frame_equal(self.test_frame3, result) def test_to_sql_series(self): s = Series(np.arange(5, dtype="int64"), name="series") sql.to_sql(s, "test_series", self.conn, index=False) s2 = sql.read_sql_query("SELECT * FROM test_series", self.conn) tm.assert_frame_equal(s.to_frame(), s2) def test_roundtrip(self): sql.to_sql(self.test_frame1, "test_frame_roundtrip", con=self.conn) result = sql.read_sql_query("SELECT * FROM test_frame_roundtrip", con=self.conn) # HACK! result.index = self.test_frame1.index result.set_index("level_0", inplace=True) result.index.astype(int) result.index.name = None tm.assert_frame_equal(result, self.test_frame1) def test_roundtrip_chunksize(self): sql.to_sql( self.test_frame1, "test_frame_roundtrip", con=self.conn, index=False, chunksize=2, ) result = sql.read_sql_query("SELECT * FROM test_frame_roundtrip", con=self.conn) tm.assert_frame_equal(result, self.test_frame1) def test_execute_sql(self): # drop_sql = "DROP TABLE IF EXISTS test" # should already be done iris_results = sql.execute("SELECT * FROM iris", con=self.conn) row = iris_results.fetchone() tm.equalContents(row, [5.1, 3.5, 1.4, 0.2, "Iris-setosa"]) def test_date_parsing(self): # Test date parsing in read_sql # No Parsing df = sql.read_sql_query("SELECT * FROM types_test_data", self.conn) assert not issubclass(df.DateCol.dtype.type, np.datetime64) df = sql.read_sql_query( "SELECT * FROM types_test_data", self.conn, parse_dates=["DateCol"] ) assert issubclass(df.DateCol.dtype.type, np.datetime64) assert df.DateCol.tolist() == [ pd.Timestamp(2000, 1, 3, 0, 0, 0), pd.Timestamp(2000, 1, 4, 0, 0, 0), ] df = sql.read_sql_query( "SELECT * FROM types_test_data", self.conn, parse_dates={"DateCol": "%Y-%m-%d %H:%M:%S"}, ) assert issubclass(df.DateCol.dtype.type, np.datetime64) assert df.DateCol.tolist() == [ pd.Timestamp(2000, 1, 3, 0, 0, 0), pd.Timestamp(2000, 1, 4, 0, 0, 0), ] df = sql.read_sql_query( "SELECT * FROM types_test_data", self.conn, parse_dates=["IntDateCol"] ) assert issubclass(df.IntDateCol.dtype.type, np.datetime64) assert df.IntDateCol.tolist() == [ pd.Timestamp(1986, 12, 25, 0, 0, 0), pd.Timestamp(2013, 1, 1, 0, 0, 0), ] df = sql.read_sql_query( "SELECT * FROM types_test_data", self.conn, parse_dates={"IntDateCol": "s"} ) assert issubclass(df.IntDateCol.dtype.type, np.datetime64) assert df.IntDateCol.tolist() == [ pd.Timestamp(1986, 12, 25, 0, 0, 0), pd.Timestamp(2013, 1, 1, 0, 0, 0), ] df = sql.read_sql_query( "SELECT * FROM types_test_data", self.conn, parse_dates={"IntDateOnlyCol": "%Y%m%d"}, ) assert issubclass(df.IntDateOnlyCol.dtype.type, np.datetime64) assert df.IntDateOnlyCol.tolist() == [ pd.Timestamp("2010-10-10"), pd.Timestamp("2010-12-12"), ] def test_date_and_index(self): # Test case where same column appears in parse_date and index_col df = sql.read_sql_query( "SELECT * FROM types_test_data", self.conn, index_col="DateCol", parse_dates=["DateCol", "IntDateCol"], ) assert issubclass(df.index.dtype.type, np.datetime64) assert issubclass(df.IntDateCol.dtype.type, np.datetime64) def test_timedelta(self): # see #6921 df = to_timedelta(Series(["00:00:01", "00:00:03"], name="foo")).to_frame() with
tm.assert_produces_warning(UserWarning)
pandas._testing.assert_produces_warning
""" DataFrames that are essentially n-by-m matrices. """ from __future__ import annotations import abc from copy import deepcopy from functools import partial from inspect import cleandoc from typing import Sequence, Set, Tuple, Union import numpy as np import pandas as pd from numpy.random import RandomState from typeddfs.base_dfs import BaseDf from typeddfs.df_errors import InvalidDfError, RowColumnMismatchError, VerificationFailedError from typeddfs.df_typing import FINAL_DF_TYPING, DfTyping from typeddfs.typed_dfs import TypedDf class LongFormMatrixDf(TypedDf): """ A long-form matrix with columns "row", "column", and "value". """ @classmethod def get_typing(cls) -> DfTyping: return DfTyping(_required_columns=["row", "column", "value"]) class _MatrixDf(BaseDf, metaclass=abc.ABCMeta): @classmethod def convert(cls, df: pd.DataFrame) -> __qualname__: if not isinstance(df, pd.DataFrame): raise TypeError(f"Can't convert {type(df)} to {cls.__name__}") # first always reset the index so we can manage what's in the index vs columns # index_names() will return [] if no named indices are found df.__class__ = cls t = cls.get_typing() # df = df.vanilla_reset() # df = df.set_index(t.required_index_names[0]) if df.index.names == [None] and "row" in df.columns: df = df.set_index("row") df.columns.name = "column" df.index.name = "row" if t.value_dtype is not None: df = df.astype(t.value_dtype) df.index = df.index.astype(str) df.columns = df.columns.astype(str) # now change the class df.__class__ = cls # noinspection PyProtectedMember cls._check(df) return df @classmethod def _check(cls, df) -> None: t = cls.get_typing() # TODO: Why doesn't .dtype work? if [str(c) for c in df.index.names] != list(df.index.names): raise InvalidDfError("Some index names are non-str") if [str(c) for c in df.columns] != df.columns.tolist(): raise InvalidDfError("Some columns are non-str") for req in t.verifications: value = req(df) if value is not None and value is not True: raise VerificationFailedError(str(value)) def is_symmetric(self) -> bool: """ Returns True if the matrix is fully symmetric with exact equality. """ return self.rows == self.cols and np.array_equal(self.values, self.T.values) def sub_matrix(self, rows: Set[str], cols: Set[str]) -> __qualname__: """ Returns a matrix containing only these labels. """ return self.__class__(self.loc[rows][cols]) def long_form(self) -> LongFormMatrixDf: """ Melts into a long-form DataFrame with columns "row", "column", and "value". Consider calling ``triangle`` first if the matrix is (always) symmetric. """ # TODO: melt wasn't working df = [] for r, row in enumerate(self.rows): for c, col in enumerate(self.cols): df.append(pd.Series(dict(row=row, column=col, value=self.iat[r, c]))) return LongFormMatrixDf.convert(pd.DataFrame(df)) def triangle(self, upper: bool = False, strict: bool = False) -> __qualname__: """ NaNs out the upper (or lower) triangle, returning a copy. Arguments: upper: Keep the upper triangular matrix instead of the lower strict: Discard the diagonal (set it to NaN) """ fn = np.triu if upper else np.tril fn = partial(fn, k=1) if strict else fn return self.__class__(self.where(fn(np.ones(self.shape)).astype(bool))) def sort_alphabetical(self) -> __qualname__: """ Sorts by the rows and columns alphabetically. """ df = self.sort_natural_index() df = df.transpose().sort_natural_index() df = df.transpose() return df def shuffle(self, rand: Union[None, int, RandomState] = None) -> __qualname__: """ Returns a copy with every value mapped to a new location. Destroys the correct links between labels and values. Useful for permutation tests. """ cp = deepcopy(self.flatten()) if rand is None: rand = np.random.RandomState() elif isinstance(rand, int): rand = np.random.RandomState(seed=rand) rand.shuffle(cp) values = cp.reshape((len(self.rows), len(self.columns))) return self.__class__(values, index=self.rows, columns=self.columns) def diagonals(self) -> np.array: """ Returns an array of the diagonal elements. """ return pd.Series(np.diag(self), index=[self.index, self.columns]).values def flatten(self) -> np.array: """ Flattens the values into a 1-d array. """ return self.values.flatten() @property def dim_str(self) -> str: """ Returns a simple string of n_rows by n_columns. E.g.: ``15 × 15``. """ return f"{len(self.rows)} × {len(self.columns)}" @property def dims(self) -> Tuple[int, int]: """ Returns (n rows, n_columns). """ return len(self.rows), len(self.columns) @property def rows(self) -> Sequence[str]: """ Returns the row labels. """ return self.index.tolist() @property def cols(self) -> Sequence[str]: """ Returns the column labels. """ return self.columns.tolist() def _repr_html_(self) -> str: cls = self.__class__ mark = "✅" if self.__class__.is_valid(self) else "❌" return cleandoc( f""" <strong>{cls.name}: {self.dim} {mark}</strong> {pd.DataFrame.
_repr_html_(self)
pandas.DataFrame._repr_html_
# -*- coding: utf-8 -*- """ Utility functions. """ import requests from re import search, IGNORECASE import os import pandas as pd from xmltodict import parse from multiprocessing.pool import ThreadPool from time import sleep import itertools ############################################### ### Parameters mission_product_dict = { 'gpm': { 'base_url': 'https://gpm1.gesdisc.eosdis.nasa.gov:443', 'process_level': 'GPM_L3', 'version': 6, 'products': { '3IMERGHHE': '{mission}_{product}.{version:02}/{year}/{dayofyear:03}/3B-HHR-E.MS.MRG.3IMERG.{date}-S{time_start}-E{time_end}.{minutes}.V{version:02}B.HDF5', '3IMERGHHL': '{mission}_{product}.{version:02}/{year}/{dayofyear:03}/3B-HHR-L.MS.MRG.3IMERG.{date}-S{time_start}-E{time_end}.{minutes}.V{version:02}B.HDF5', '3IMERGHH': '{mission}_{product}.{version:02}/{year}/{dayofyear:03}/3B-HHR.MS.MRG.3IMERG.{date}-S{time_start}-E{time_end}.{minutes}.V{version:02}B.HDF5' } } } master_datasets = {'3IMERGHHE': ['precipitationQualityIndex', 'IRkalmanFilterWeight', 'precipitationCal', 'HQprecipitation', 'probabilityLiquidPrecipitation', 'randomError', 'IRprecipitation'], '3IMERGHHL': ['precipitationQualityIndex', 'IRkalmanFilterWeight', 'precipitationCal', 'HQprecipitation', 'probabilityLiquidPrecipitation', 'randomError', 'IRprecipitation'], '3IMERGHH': ['precipitationQualityIndex', 'IRkalmanFilterWeight', 'precipitationCal', 'HQprecipitation', 'probabilityLiquidPrecipitation', 'randomError', 'IRprecipitation']} ############################################### ### Functions def parse_dates(date, url): """ """ counter = 4 while counter > 0: date_xml = requests.get(url + '/catalog.xml') if date_xml.status_code == 200: break else: print('Retrying in 3 seconds...') counter = counter - 1 sleep(3) date_lst = parse(date_xml.content)['thredds:catalog']['thredds:dataset']['thredds:dataset'] if not isinstance(date_lst, list): date_lst = [date_lst] date_lst = [d for d in date_lst if not '.xml' in d['@name']] lst1 = [[date, d['@name'].split('-S')[1][:6], d['@name'].split('0-E')[1][:6], d['@name'], d['@ID'], int(d['thredds:dataSize']['#text']), d['thredds:date']['#text']] for d in date_lst] return lst1 def parse_nasa_catalog(mission, product, version, from_date=None, to_date=None, min_max=False): """ Function to parse the NASA Hyrax dap server via the catalog xml. Parameters ---------- missions : str, list of str, or None The missions to parse. None will parse all available. products : str, list of str, or None The products to parse. None will parse all available. version : int The product version. from_date : str or None The start date to query. end_date : str or None The end date to query. min_max : bool Should only the min and max dates of the product and version be returned? Returns ------- DataFrame indexed by mission and product Notes ----- I wish their server was faster, but if you try to query too many dates then it might take a while. """ ## mission/product parse base_url = mission_product_dict[mission]['base_url'] mis_url = '/'.join([base_url, 'opendap/hyrax', mission_product_dict[mission]['process_level']]) prod_xml = requests.get(mis_url + '/catalog.xml') prod_lst = parse(prod_xml.content)['thredds:catalog']['thredds:dataset']['thredds:catalogRef'] prod1 = [p for p in prod_lst if (product in p['@name']) & (str(version) in p['@name'])] if not prod1: raise ValueError('No combination of product and version in specified mission') ## Parse available years years_url = '/'.join([mis_url, prod1[0]['@name']]) years_xml = requests.get(years_url + '/catalog.xml') years_lst = parse(years_xml.content)['thredds:catalog']['thredds:dataset']['thredds:catalogRef'] if isinstance(years_lst, list): years_dict = {int(y['@name']): y for y in years_lst} else: years_dict = {int(years_lst['@name']): years_lst} ## Parse available months/days of the year big_lst = [] for y in years_dict: my_url = '/'.join([years_url, str(y)]) my_xml = requests.get(my_url + '/catalog.xml') my_lst = parse(my_xml.content)['thredds:catalog']['thredds:dataset']['thredds:catalogRef'] if not isinstance(my_lst, list): my_lst = [my_lst] big_lst.extend([[y, int(d['@name']), base_url + d['@ID']] for d in my_lst]) my_df = pd.DataFrame(big_lst, columns=['year', 'dayofyear', 'url']) my_df['date'] = pd.to_datetime(my_df.year.astype(str)) +
pd.to_timedelta(my_df.dayofyear - 1, unit='D')
pandas.to_timedelta
import pytest import numpy as np import pandas import pandas.util.testing as tm from pandas.tests.frame.common import TestData import matplotlib import modin.pandas as pd from modin.pandas.utils import to_pandas from numpy.testing import assert_array_equal from .utils import ( random_state, RAND_LOW, RAND_HIGH, df_equals, df_is_empty, arg_keys, name_contains, test_data_values, test_data_keys, test_data_with_duplicates_values, test_data_with_duplicates_keys, numeric_dfs, no_numeric_dfs, test_func_keys, test_func_values, query_func_keys, query_func_values, agg_func_keys, agg_func_values, numeric_agg_funcs, quantiles_keys, quantiles_values, indices_keys, indices_values, axis_keys, axis_values, bool_arg_keys, bool_arg_values, int_arg_keys, int_arg_values, ) # TODO remove once modin-project/modin#469 is resolved agg_func_keys.remove("str") agg_func_values.remove(str) pd.DEFAULT_NPARTITIONS = 4 # Force matplotlib to not use any Xwindows backend. matplotlib.use("Agg") class TestDFPartOne: # Test inter df math functions def inter_df_math_helper(self, modin_df, pandas_df, op): # Test dataframe to datframe try: pandas_result = getattr(pandas_df, op)(pandas_df) except Exception as e: with pytest.raises(type(e)): getattr(modin_df, op)(modin_df) else: modin_result = getattr(modin_df, op)(modin_df) df_equals(modin_result, pandas_result) # Test dataframe to int try: pandas_result = getattr(pandas_df, op)(4) except Exception as e: with pytest.raises(type(e)): getattr(modin_df, op)(4) else: modin_result = getattr(modin_df, op)(4) df_equals(modin_result, pandas_result) # Test dataframe to float try: pandas_result = getattr(pandas_df, op)(4.0) except Exception as e: with pytest.raises(type(e)): getattr(modin_df, op)(4.0) else: modin_result = getattr(modin_df, op)(4.0) df_equals(modin_result, pandas_result) # Test transposed dataframes to float try: pandas_result = getattr(pandas_df.T, op)(4.0) except Exception as e: with pytest.raises(type(e)): getattr(modin_df.T, op)(4.0) else: modin_result = getattr(modin_df.T, op)(4.0) df_equals(modin_result, pandas_result) frame_data = { "{}_other".format(modin_df.columns[0]): [0, 2], modin_df.columns[0]: [0, 19], modin_df.columns[1]: [1, 1], } modin_df2 = pd.DataFrame(frame_data) pandas_df2 = pandas.DataFrame(frame_data) # Test dataframe to different dataframe shape try: pandas_result = getattr(pandas_df, op)(pandas_df2) except Exception as e: with pytest.raises(type(e)): getattr(modin_df, op)(modin_df2) else: modin_result = getattr(modin_df, op)(modin_df2) df_equals(modin_result, pandas_result) # Test dataframe to list list_test = random_state.randint(RAND_LOW, RAND_HIGH, size=(modin_df.shape[1])) try: pandas_result = getattr(pandas_df, op)(list_test, axis=1) except Exception as e: with pytest.raises(type(e)): getattr(modin_df, op)(list_test, axis=1) else: modin_result = getattr(modin_df, op)(list_test, axis=1) df_equals(modin_result, pandas_result) # Test dataframe to series series_test_modin = modin_df[modin_df.columns[0]] series_test_pandas = pandas_df[pandas_df.columns[0]] try: pandas_result = getattr(pandas_df, op)(series_test_pandas, axis=0) except Exception as e: with pytest.raises(type(e)): getattr(modin_df, op)(series_test_modin, axis=0) else: modin_result = getattr(modin_df, op)(series_test_modin, axis=0) df_equals(modin_result, pandas_result) # Test dataframe to series with different index series_test_modin = modin_df[modin_df.columns[0]].reset_index(drop=True) series_test_pandas = pandas_df[pandas_df.columns[0]].reset_index(drop=True) try: pandas_result = getattr(pandas_df, op)(series_test_pandas, axis=0) except Exception as e: with pytest.raises(type(e)): getattr(modin_df, op)(series_test_modin, axis=0) else: modin_result = getattr(modin_df, op)(series_test_modin, axis=0) df_equals(modin_result, pandas_result) # Level test new_idx = pandas.MultiIndex.from_tuples( [(i // 4, i // 2, i) for i in modin_df.index] ) modin_df_multi_level = modin_df.copy() modin_df_multi_level.index = new_idx # Defaults to pandas with pytest.warns(UserWarning): # Operation against self for sanity check getattr(modin_df_multi_level, op)(modin_df_multi_level, axis=0, level=1) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_add(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "add") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_div(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "div") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_divide(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "divide") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_floordiv(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "floordiv") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_mod(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "mod") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_mul(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "mul") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_multiply(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "multiply") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_pow(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) # TODO: Revert to others once we have an efficient way of preprocessing for positive # values try: pandas_df = pandas_df.abs() except Exception: pass else: modin_df = modin_df.abs() self.inter_df_math_helper(modin_df, pandas_df, "pow") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_sub(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "sub") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_subtract(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "subtract") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_truediv(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "truediv") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test___div__(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "__div__") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test___add__(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "__add__") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test___radd__(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "__radd__") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test___mul__(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "__mul__") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test___rmul__(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "__rmul__") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test___pow__(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "__pow__") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test___rpow__(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "__rpow__") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test___sub__(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "__sub__") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test___floordiv__(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "__floordiv__") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test___rfloordiv__(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "__rfloordiv__") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test___truediv__(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "__truediv__") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test___rtruediv__(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "__rtruediv__") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test___mod__(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "__mod__") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test___rmod__(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "__rmod__") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test___rdiv__(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_helper(modin_df, pandas_df, "__rdiv__") # END test inter df math functions # Test comparison of inter operation functions def comparison_inter_ops_helper(self, modin_df, pandas_df, op): try: pandas_result = getattr(pandas_df, op)(pandas_df) except Exception as e: with pytest.raises(type(e)): getattr(modin_df, op)(modin_df) else: modin_result = getattr(modin_df, op)(modin_df) df_equals(modin_result, pandas_result) try: pandas_result = getattr(pandas_df, op)(4) except TypeError: with pytest.raises(TypeError): getattr(modin_df, op)(4) else: modin_result = getattr(modin_df, op)(4) df_equals(modin_result, pandas_result) try: pandas_result = getattr(pandas_df, op)(4.0) except TypeError: with pytest.raises(TypeError): getattr(modin_df, op)(4.0) else: modin_result = getattr(modin_df, op)(4.0) df_equals(modin_result, pandas_result) try: pandas_result = getattr(pandas_df, op)("a") except TypeError: with pytest.raises(TypeError): repr(getattr(modin_df, op)("a")) else: modin_result = getattr(modin_df, op)("a") df_equals(modin_result, pandas_result) frame_data = { "{}_other".format(modin_df.columns[0]): [0, 2], modin_df.columns[0]: [0, 19], modin_df.columns[1]: [1, 1], } modin_df2 = pd.DataFrame(frame_data) pandas_df2 = pandas.DataFrame(frame_data) try: pandas_result = getattr(pandas_df, op)(pandas_df2) except Exception as e: with pytest.raises(type(e)): getattr(modin_df, op)(modin_df2) else: modin_result = getattr(modin_df, op)(modin_df2) df_equals(modin_result, pandas_result) new_idx = pandas.MultiIndex.from_tuples( [(i // 4, i // 2, i) for i in modin_df.index] ) modin_df_multi_level = modin_df.copy() modin_df_multi_level.index = new_idx # Defaults to pandas with pytest.warns(UserWarning): # Operation against self for sanity check getattr(modin_df_multi_level, op)(modin_df_multi_level, axis=0, level=1) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_eq(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.comparison_inter_ops_helper(modin_df, pandas_df, "eq") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_ge(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.comparison_inter_ops_helper(modin_df, pandas_df, "ge") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_gt(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.comparison_inter_ops_helper(modin_df, pandas_df, "gt") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_le(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.comparison_inter_ops_helper(modin_df, pandas_df, "le") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_lt(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.comparison_inter_ops_helper(modin_df, pandas_df, "lt") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_ne(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.comparison_inter_ops_helper(modin_df, pandas_df, "ne") # END test comparison of inter operation functions # Test dataframe right operations def inter_df_math_right_ops_helper(self, modin_df, pandas_df, op): try: pandas_result = getattr(pandas_df, op)(4) except Exception as e: with pytest.raises(type(e)): getattr(modin_df, op)(4) else: modin_result = getattr(modin_df, op)(4) df_equals(modin_result, pandas_result) try: pandas_result = getattr(pandas_df, op)(4.0) except Exception as e: with pytest.raises(type(e)): getattr(modin_df, op)(4.0) else: modin_result = getattr(modin_df, op)(4.0) df_equals(modin_result, pandas_result) new_idx = pandas.MultiIndex.from_tuples( [(i // 4, i // 2, i) for i in modin_df.index] ) modin_df_multi_level = modin_df.copy() modin_df_multi_level.index = new_idx # Defaults to pandas with pytest.warns(UserWarning): # Operation against self for sanity check getattr(modin_df_multi_level, op)(modin_df_multi_level, axis=0, level=1) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_radd(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_right_ops_helper(modin_df, pandas_df, "radd") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_rdiv(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_right_ops_helper(modin_df, pandas_df, "rdiv") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_rfloordiv(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_right_ops_helper(modin_df, pandas_df, "rfloordiv") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_rmod(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_right_ops_helper(modin_df, pandas_df, "rmod") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_rmul(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_right_ops_helper(modin_df, pandas_df, "rmul") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_rpow(self, request, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) # TODO: Revert to others once we have an efficient way of preprocessing for positive values # We need to check that negative integers are not used efficiently if "100x100" not in request.node.name: self.inter_df_math_right_ops_helper(modin_df, pandas_df, "rpow") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_rsub(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_right_ops_helper(modin_df, pandas_df, "rsub") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_rtruediv(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_right_ops_helper(modin_df, pandas_df, "rtruediv") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test___rsub__(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) self.inter_df_math_right_ops_helper(modin_df, pandas_df, "__rsub__") # END test dataframe right operations @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_abs(self, request, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) try: pandas_result = pandas_df.abs() except Exception as e: with pytest.raises(type(e)): modin_df.abs() else: modin_result = modin_df.abs() df_equals(modin_result, pandas_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_add_prefix(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) test_prefix = "TEST" new_modin_df = modin_df.add_prefix(test_prefix) new_pandas_df = pandas_df.add_prefix(test_prefix) df_equals(new_modin_df.columns, new_pandas_df.columns) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("testfunc", test_func_values, ids=test_func_keys) def test_applymap(self, request, data, testfunc): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) with pytest.raises(ValueError): x = 2 modin_df.applymap(x) try: pandas_result = pandas_df.applymap(testfunc) except Exception as e: with pytest.raises(type(e)): modin_df.applymap(testfunc) else: modin_result = modin_df.applymap(testfunc) df_equals(modin_result, pandas_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("testfunc", test_func_values, ids=test_func_keys) def test_applymap_numeric(self, request, data, testfunc): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) if name_contains(request.node.name, numeric_dfs): try: pandas_result = pandas_df.applymap(testfunc) except Exception as e: with pytest.raises(type(e)): modin_df.applymap(testfunc) else: modin_result = modin_df.applymap(testfunc) df_equals(modin_result, pandas_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_add_suffix(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) test_suffix = "TEST" new_modin_df = modin_df.add_suffix(test_suffix) new_pandas_df = pandas_df.add_suffix(test_suffix) df_equals(new_modin_df.columns, new_pandas_df.columns) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_at(self, request, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) # We skip nan datasets because nan != nan if "nan" not in request.node.name: key1 = modin_df.columns[0] # Scaler assert modin_df.at[0, key1] == pandas_df.at[0, key1] # Series df_equals(modin_df.loc[0].at[key1], pandas_df.loc[0].at[key1]) # Write Item modin_df_copy = modin_df.copy() pandas_df_copy = pandas_df.copy() modin_df_copy.at[1, key1] = modin_df.at[0, key1] pandas_df_copy.at[1, key1] = pandas_df.at[0, key1] df_equals(modin_df_copy, pandas_df_copy) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_axes(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) for modin_axis, pd_axis in zip(modin_df.axes, pandas_df.axes): assert np.array_equal(modin_axis, pd_axis) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_copy(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) # noqa F841 # pandas_df is unused but there so there won't be confusing list comprehension # stuff in the pytest.mark.parametrize new_modin_df = modin_df.copy() assert new_modin_df is not modin_df assert np.array_equal( new_modin_df._query_compiler._modin_frame._partitions, modin_df._query_compiler._modin_frame._partitions, ) assert new_modin_df is not modin_df df_equals(new_modin_df, modin_df) # Shallow copy tests modin_df = pd.DataFrame(data) modin_df_cp = modin_df.copy(False) modin_df[modin_df.columns[0]] = 0 df_equals(modin_df, modin_df_cp) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_dtypes(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) df_equals(modin_df.dtypes, pandas_df.dtypes) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_ftypes(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) df_equals(modin_df.ftypes, pandas_df.ftypes) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("key", indices_values, ids=indices_keys) def test_get(self, data, key): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) df_equals(modin_df.get(key), pandas_df.get(key)) df_equals( modin_df.get(key, default="default"), pandas_df.get(key, default="default") ) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_get_dtype_counts(self, data): modin_result = pd.DataFrame(data).get_dtype_counts().sort_index() pandas_result = pandas.DataFrame(data).get_dtype_counts().sort_index() df_equals(modin_result, pandas_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize( "dummy_na", bool_arg_values, ids=arg_keys("dummy_na", bool_arg_keys) ) @pytest.mark.parametrize( "drop_first", bool_arg_values, ids=arg_keys("drop_first", bool_arg_keys) ) def test_get_dummies(self, request, data, dummy_na, drop_first): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) try: pandas_result = pandas.get_dummies( pandas_df, dummy_na=dummy_na, drop_first=drop_first ) except Exception as e: with pytest.raises(type(e)): pd.get_dummies(modin_df, dummy_na=dummy_na, drop_first=drop_first) else: modin_result = pd.get_dummies( modin_df, dummy_na=dummy_na, drop_first=drop_first ) df_equals(modin_result, pandas_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_get_ftype_counts(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) df_equals(modin_df.get_ftype_counts(), pandas_df.get_ftype_counts()) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) @pytest.mark.parametrize("func", agg_func_values, ids=agg_func_keys) def test_agg(self, data, axis, func): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) try: pandas_result = pandas_df.agg(func, axis) except Exception as e: with pytest.raises(type(e)): modin_df.agg(func, axis) else: modin_result = modin_df.agg(func, axis) df_equals(modin_result, pandas_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) @pytest.mark.parametrize("func", agg_func_values, ids=agg_func_keys) def test_agg_numeric(self, request, data, axis, func): if name_contains(request.node.name, numeric_agg_funcs) and name_contains( request.node.name, numeric_dfs ): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) try: pandas_result = pandas_df.agg(func, axis) except Exception as e: with pytest.raises(type(e)): modin_df.agg(func, axis) else: modin_result = modin_df.agg(func, axis) df_equals(modin_result, pandas_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) @pytest.mark.parametrize("func", agg_func_values, ids=agg_func_keys) def test_aggregate(self, request, data, func, axis): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) try: pandas_result = pandas_df.aggregate(func, axis) except Exception as e: with pytest.raises(type(e)): modin_df.aggregate(func, axis) else: modin_result = modin_df.aggregate(func, axis) df_equals(modin_result, pandas_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) @pytest.mark.parametrize("func", agg_func_values, ids=agg_func_keys) def test_aggregate_numeric(self, request, data, axis, func): if name_contains(request.node.name, numeric_agg_funcs) and name_contains( request.node.name, numeric_dfs ): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) try: pandas_result = pandas_df.agg(func, axis) except Exception as e: with pytest.raises(type(e)): modin_df.agg(func, axis) else: modin_result = modin_df.agg(func, axis) df_equals(modin_result, pandas_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_aggregate_error_checking(self, data): modin_df = pd.DataFrame(data) assert modin_df.aggregate("ndim") == 2 with pytest.warns(UserWarning): modin_df.aggregate( {modin_df.columns[0]: "sum", modin_df.columns[1]: "mean"} ) with pytest.warns(UserWarning): modin_df.aggregate("cumproduct") with pytest.raises(ValueError): modin_df.aggregate("NOT_EXISTS") def test_align(self): data = test_data_values[0] with pytest.warns(UserWarning): pd.DataFrame(data).align(pd.DataFrame(data)) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) @pytest.mark.parametrize( "skipna", bool_arg_values, ids=arg_keys("skipna", bool_arg_keys) ) @pytest.mark.parametrize( "bool_only", bool_arg_values, ids=arg_keys("bool_only", bool_arg_keys) ) def test_all(self, data, axis, skipna, bool_only): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) try: pandas_result = pandas_df.all(axis=axis, skipna=skipna, bool_only=bool_only) except Exception as e: with pytest.raises(type(e)): modin_df.all(axis=axis, skipna=skipna, bool_only=bool_only) else: modin_result = modin_df.all(axis=axis, skipna=skipna, bool_only=bool_only) df_equals(modin_result, pandas_result) # Test when axis is None. This will get repeated but easier than using list in parameterize decorator try: pandas_result = pandas_df.all(axis=None, skipna=skipna, bool_only=bool_only) except Exception as e: with pytest.raises(type(e)): modin_df.all(axis=None, skipna=skipna, bool_only=bool_only) else: modin_result = modin_df.all(axis=None, skipna=skipna, bool_only=bool_only) df_equals(modin_result, pandas_result) try: pandas_result = pandas_df.T.all( axis=axis, skipna=skipna, bool_only=bool_only ) except Exception as e: with pytest.raises(type(e)): modin_df.T.all(axis=axis, skipna=skipna, bool_only=bool_only) else: modin_result = modin_df.T.all(axis=axis, skipna=skipna, bool_only=bool_only) df_equals(modin_result, pandas_result) # Test when axis is None. This will get repeated but easier than using list in parameterize decorator try: pandas_result = pandas_df.T.all( axis=None, skipna=skipna, bool_only=bool_only ) except Exception as e: with pytest.raises(type(e)): modin_df.T.all(axis=None, skipna=skipna, bool_only=bool_only) else: modin_result = modin_df.T.all(axis=None, skipna=skipna, bool_only=bool_only) df_equals(modin_result, pandas_result) # test level modin_df_multi_level = modin_df.copy() pandas_df_multi_level = pandas_df.copy() axis = modin_df._get_axis_number(axis) if axis is not None else 0 levels = 3 axis_names_list = [["a", "b", "c"], None] for axis_names in axis_names_list: if axis == 0: new_idx = pandas.MultiIndex.from_tuples( [(i // 4, i // 2, i) for i in range(len(modin_df.index))], names=axis_names, ) modin_df_multi_level.index = new_idx pandas_df_multi_level.index = new_idx else: new_col = pandas.MultiIndex.from_tuples( [(i // 4, i // 2, i) for i in range(len(modin_df.columns))], names=axis_names, ) modin_df_multi_level.columns = new_col pandas_df_multi_level.columns = new_col for level in list(range(levels)) + (axis_names if axis_names else []): try: pandas_multi_level_result = pandas_df_multi_level.all( axis=axis, bool_only=bool_only, level=level, skipna=skipna ) except Exception as e: with pytest.raises(type(e)): modin_df_multi_level.all( axis=axis, bool_only=bool_only, level=level, skipna=skipna ) else: modin_multi_level_result = modin_df_multi_level.all( axis=axis, bool_only=bool_only, level=level, skipna=skipna ) df_equals(modin_multi_level_result, pandas_multi_level_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) @pytest.mark.parametrize( "skipna", bool_arg_values, ids=arg_keys("skipna", bool_arg_keys) ) @pytest.mark.parametrize( "bool_only", bool_arg_values, ids=arg_keys("bool_only", bool_arg_keys) ) def test_any(self, data, axis, skipna, bool_only): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) try: pandas_result = pandas_df.any(axis=axis, skipna=skipna, bool_only=bool_only) except Exception as e: with pytest.raises(type(e)): modin_df.any(axis=axis, skipna=skipna, bool_only=bool_only) else: modin_result = modin_df.any(axis=axis, skipna=skipna, bool_only=bool_only) df_equals(modin_result, pandas_result) try: pandas_result = pandas_df.any(axis=None, skipna=skipna, bool_only=bool_only) except Exception as e: with pytest.raises(type(e)): modin_df.any(axis=None, skipna=skipna, bool_only=bool_only) else: modin_result = modin_df.any(axis=None, skipna=skipna, bool_only=bool_only) df_equals(modin_result, pandas_result) try: pandas_result = pandas_df.T.any( axis=axis, skipna=skipna, bool_only=bool_only ) except Exception as e: with pytest.raises(type(e)): modin_df.T.any(axis=axis, skipna=skipna, bool_only=bool_only) else: modin_result = modin_df.T.any(axis=axis, skipna=skipna, bool_only=bool_only) df_equals(modin_result, pandas_result) try: pandas_result = pandas_df.T.any( axis=None, skipna=skipna, bool_only=bool_only ) except Exception as e: with pytest.raises(type(e)): modin_df.T.any(axis=None, skipna=skipna, bool_only=bool_only) else: modin_result = modin_df.T.any(axis=None, skipna=skipna, bool_only=bool_only) df_equals(modin_result, pandas_result) # test level modin_df_multi_level = modin_df.copy() pandas_df_multi_level = pandas_df.copy() axis = modin_df._get_axis_number(axis) if axis is not None else 0 levels = 3 axis_names_list = [["a", "b", "c"], None] for axis_names in axis_names_list: if axis == 0: new_idx = pandas.MultiIndex.from_tuples( [(i // 4, i // 2, i) for i in range(len(modin_df.index))], names=axis_names, ) modin_df_multi_level.index = new_idx pandas_df_multi_level.index = new_idx else: new_col = pandas.MultiIndex.from_tuples( [(i // 4, i // 2, i) for i in range(len(modin_df.columns))], names=axis_names, ) modin_df_multi_level.columns = new_col pandas_df_multi_level.columns = new_col for level in list(range(levels)) + (axis_names if axis_names else []): try: pandas_multi_level_result = pandas_df_multi_level.any( axis=axis, bool_only=bool_only, level=level, skipna=skipna ) except Exception as e: with pytest.raises(type(e)): modin_df_multi_level.any( axis=axis, bool_only=bool_only, level=level, skipna=skipna ) else: modin_multi_level_result = modin_df_multi_level.any( axis=axis, bool_only=bool_only, level=level, skipna=skipna ) df_equals(modin_multi_level_result, pandas_multi_level_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_append(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) data_to_append = {"append_a": 2, "append_b": 1000} ignore_idx_values = [True, False] for ignore in ignore_idx_values: try: pandas_result = pandas_df.append(data_to_append, ignore_index=ignore) except Exception as e: with pytest.raises(type(e)): modin_df.append(data_to_append, ignore_index=ignore) else: modin_result = modin_df.append(data_to_append, ignore_index=ignore) df_equals(modin_result, pandas_result) try: pandas_result = pandas_df.append(pandas_df.iloc[-1]) except Exception as e: with pytest.raises(type(e)): modin_df.append(modin_df.iloc[-1]) else: modin_result = modin_df.append(modin_df.iloc[-1]) df_equals(modin_result, pandas_result) try: pandas_result = pandas_df.append(list(pandas_df.iloc[-1])) except Exception as e: with pytest.raises(type(e)): modin_df.append(list(modin_df.iloc[-1])) else: modin_result = modin_df.append(list(modin_df.iloc[-1])) df_equals(modin_result, pandas_result) verify_integrity_values = [True, False] for verify_integrity in verify_integrity_values: try: pandas_result = pandas_df.append( [pandas_df, pandas_df], verify_integrity=verify_integrity ) except Exception as e: with pytest.raises(type(e)): modin_df.append( [modin_df, modin_df], verify_integrity=verify_integrity ) else: modin_result = modin_df.append( [modin_df, modin_df], verify_integrity=verify_integrity ) df_equals(modin_result, pandas_result) try: pandas_result = pandas_df.append( pandas_df, verify_integrity=verify_integrity ) except Exception as e: with pytest.raises(type(e)): modin_df.append(modin_df, verify_integrity=verify_integrity) else: modin_result = modin_df.append( modin_df, verify_integrity=verify_integrity ) df_equals(modin_result, pandas_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) @pytest.mark.parametrize("func", agg_func_values, ids=agg_func_keys) def test_apply(self, request, data, func, axis): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) with pytest.raises(TypeError): modin_df.apply({"row": func}, axis=1) try: pandas_result = pandas_df.apply(func, axis) except Exception as e: with pytest.raises(type(e)): modin_df.apply(func, axis) else: modin_result = modin_df.apply(func, axis) df_equals(modin_result, pandas_result) def test_apply_metadata(self): def add(a, b, c): return a + b + c data = {"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]} modin_df = pd.DataFrame(data) modin_df["add"] = modin_df.apply( lambda row: add(row["A"], row["B"], row["C"]), axis=1 ) pandas_df = pandas.DataFrame(data) pandas_df["add"] = pandas_df.apply( lambda row: add(row["A"], row["B"], row["C"]), axis=1 ) df_equals(modin_df, pandas_df) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("func", agg_func_values, ids=agg_func_keys) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) def test_apply_numeric(self, request, data, func, axis): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) if name_contains(request.node.name, numeric_dfs): try: pandas_result = pandas_df.apply(func, axis) except Exception as e: with pytest.raises(type(e)): modin_df.apply(func, axis) else: modin_result = modin_df.apply(func, axis) df_equals(modin_result, pandas_result) if "empty_data" not in request.node.name: key = modin_df.columns[0] modin_result = modin_df.apply(lambda df: df.drop(key), axis=1) pandas_result = pandas_df.apply(lambda df: df.drop(key), axis=1) df_equals(modin_result, pandas_result) def test_as_blocks(self): data = test_data_values[0] with pytest.warns(UserWarning): pd.DataFrame(data).as_blocks() def test_as_matrix(self): test_data = TestData() frame = pd.DataFrame(test_data.frame) mat = frame.as_matrix() frame_columns = frame.columns for i, row in enumerate(mat): for j, value in enumerate(row): col = frame_columns[j] if np.isnan(value): assert np.isnan(frame[col][i]) else: assert value == frame[col][i] # mixed type mat = pd.DataFrame(test_data.mixed_frame).as_matrix(["foo", "A"]) assert mat[0, 0] == "bar" df = pd.DataFrame({"real": [1, 2, 3], "complex": [1j, 2j, 3j]}) mat = df.as_matrix() assert mat[0, 1] == 1j # single block corner case mat = pd.DataFrame(test_data.frame).as_matrix(["A", "B"]) expected = test_data.frame.reindex(columns=["A", "B"]).values tm.assert_almost_equal(mat, expected) def test_to_numpy(self): test_data = TestData() frame = pd.DataFrame(test_data.frame) assert_array_equal(frame.values, test_data.frame.values) def test_partition_to_numpy(self): test_data = TestData() frame = pd.DataFrame(test_data.frame) for ( partition ) in frame._query_compiler._modin_frame._partitions.flatten().tolist(): assert_array_equal(partition.to_pandas().values, partition.to_numpy()) def test_asfreq(self): index = pd.date_range("1/1/2000", periods=4, freq="T") series = pd.Series([0.0, None, 2.0, 3.0], index=index) df = pd.DataFrame({"s": series}) with pytest.warns(UserWarning): # We are only testing that this defaults to pandas, so we will just check for # the warning df.asfreq(freq="30S") def test_asof(self): df = pd.DataFrame( {"a": [10, 20, 30, 40, 50], "b": [None, None, None, None, 500]}, index=pd.DatetimeIndex( [ "2018-02-27 09:01:00", "2018-02-27 09:02:00", "2018-02-27 09:03:00", "2018-02-27 09:04:00", "2018-02-27 09:05:00", ] ), ) with pytest.warns(UserWarning): df.asof(pd.DatetimeIndex(["2018-02-27 09:03:30", "2018-02-27 09:04:30"])) def test_assign(self): data = test_data_values[0] modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) with pytest.warns(UserWarning): modin_result = modin_df.assign(new_column=pd.Series(modin_df.iloc[:, 0])) pandas_result = pandas_df.assign(new_column=pd.Series(pandas_df.iloc[:, 0])) df_equals(modin_result, pandas_result) def test_astype(self): td = TestData() modin_df = pd.DataFrame( td.frame.values, index=td.frame.index, columns=td.frame.columns ) expected_df = pandas.DataFrame( td.frame.values, index=td.frame.index, columns=td.frame.columns ) modin_df_casted = modin_df.astype(np.int32) expected_df_casted = expected_df.astype(np.int32) df_equals(modin_df_casted, expected_df_casted) modin_df_casted = modin_df.astype(np.float64) expected_df_casted = expected_df.astype(np.float64) df_equals(modin_df_casted, expected_df_casted) modin_df_casted = modin_df.astype(str) expected_df_casted = expected_df.astype(str) df_equals(modin_df_casted, expected_df_casted) modin_df_casted = modin_df.astype("category") expected_df_casted = expected_df.astype("category") df_equals(modin_df_casted, expected_df_casted) dtype_dict = {"A": np.int32, "B": np.int64, "C": str} modin_df_casted = modin_df.astype(dtype_dict) expected_df_casted = expected_df.astype(dtype_dict) df_equals(modin_df_casted, expected_df_casted) # Ignore lint because this is testing bad input bad_dtype_dict = {"B": np.int32, "B": np.int64, "B": str} # noqa F601 modin_df_casted = modin_df.astype(bad_dtype_dict) expected_df_casted = expected_df.astype(bad_dtype_dict) df_equals(modin_df_casted, expected_df_casted) with pytest.raises(KeyError): modin_df.astype({"not_exists": np.uint8}) def test_astype_category(self): modin_df = pd.DataFrame( {"col1": ["A", "A", "B", "B", "A"], "col2": [1, 2, 3, 4, 5]} ) pandas_df = pandas.DataFrame( {"col1": ["A", "A", "B", "B", "A"], "col2": [1, 2, 3, 4, 5]} ) modin_result = modin_df.astype({"col1": "category"}) pandas_result = pandas_df.astype({"col1": "category"}) df_equals(modin_result, pandas_result) assert modin_result.dtypes.equals(pandas_result.dtypes) modin_result = modin_df.astype("category") pandas_result = pandas_df.astype("category") df_equals(modin_result, pandas_result) assert modin_result.dtypes.equals(pandas_result.dtypes) def test_at_time(self): i = pd.date_range("2018-04-09", periods=4, freq="12H") ts = pd.DataFrame({"A": [1, 2, 3, 4]}, index=i) with pytest.warns(UserWarning): ts.at_time("12:00") def test_between_time(self): i = pd.date_range("2018-04-09", periods=4, freq="12H") ts = pd.DataFrame({"A": [1, 2, 3, 4]}, index=i) with pytest.warns(UserWarning): ts.between_time("0:15", "0:45") def test_bfill(self): test_data = TestData() test_data.tsframe["A"][:5] = np.nan test_data.tsframe["A"][-5:] = np.nan modin_df = pd.DataFrame(test_data.tsframe) df_equals(modin_df.bfill(), test_data.tsframe.bfill()) def test_blocks(self): data = test_data_values[0] with pytest.warns(UserWarning): pd.DataFrame(data).blocks @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_bool(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) # noqa F841 with pytest.raises(ValueError): modin_df.bool() modin_df.__bool__() single_bool_pandas_df = pandas.DataFrame([True]) single_bool_modin_df = pd.DataFrame([True]) assert single_bool_pandas_df.bool() == single_bool_modin_df.bool() with pytest.raises(ValueError): # __bool__ always raises this error for DataFrames single_bool_modin_df.__bool__() @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_boxplot(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) # noqa F841 assert modin_df.boxplot() == to_pandas(modin_df).boxplot() @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) def test_clip(self, request, data, axis): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) if name_contains(request.node.name, numeric_dfs): ind_len = ( len(modin_df.index) if not pandas.DataFrame()._get_axis_number(axis) else len(modin_df.columns) ) # set bounds lower, upper = np.sort(random_state.random_integers(RAND_LOW, RAND_HIGH, 2)) lower_list = random_state.random_integers(RAND_LOW, RAND_HIGH, ind_len) upper_list = random_state.random_integers(RAND_LOW, RAND_HIGH, ind_len) # test only upper scalar bound modin_result = modin_df.clip(None, upper, axis=axis) pandas_result = pandas_df.clip(None, upper, axis=axis) df_equals(modin_result, pandas_result) # test lower and upper scalar bound modin_result = modin_df.clip(lower, upper, axis=axis) pandas_result = pandas_df.clip(lower, upper, axis=axis) df_equals(modin_result, pandas_result) # test lower and upper list bound on each column modin_result = modin_df.clip(lower_list, upper_list, axis=axis) pandas_result = pandas_df.clip(lower_list, upper_list, axis=axis) df_equals(modin_result, pandas_result) # test only upper list bound on each column modin_result = modin_df.clip(np.nan, upper_list, axis=axis) pandas_result = pandas_df.clip(np.nan, upper_list, axis=axis) df_equals(modin_result, pandas_result) with pytest.raises(ValueError): modin_df.clip(lower=[1, 2, 3], axis=None) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) def test_clip_lower(self, request, data, axis): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) if name_contains(request.node.name, numeric_dfs): ind_len = ( len(modin_df.index) if not pandas.DataFrame()._get_axis_number(axis) else len(modin_df.columns) ) # set bounds lower = random_state.random_integers(RAND_LOW, RAND_HIGH, 1)[0] lower_list = random_state.random_integers(RAND_LOW, RAND_HIGH, ind_len) # test lower scalar bound pandas_result = pandas_df.clip_lower(lower, axis=axis) modin_result = modin_df.clip_lower(lower, axis=axis) df_equals(modin_result, pandas_result) # test lower list bound on each column pandas_result = pandas_df.clip_lower(lower_list, axis=axis) modin_result = modin_df.clip_lower(lower_list, axis=axis) df_equals(modin_result, pandas_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) def test_clip_upper(self, request, data, axis): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) if name_contains(request.node.name, numeric_dfs): ind_len = ( len(modin_df.index) if not pandas.DataFrame()._get_axis_number(axis) else len(modin_df.columns) ) # set bounds upper = random_state.random_integers(RAND_LOW, RAND_HIGH, 1)[0] upper_list = random_state.random_integers(RAND_LOW, RAND_HIGH, ind_len) # test upper scalar bound modin_result = modin_df.clip_upper(upper, axis=axis) pandas_result = pandas_df.clip_upper(upper, axis=axis) df_equals(modin_result, pandas_result) # test upper list bound on each column modin_result = modin_df.clip_upper(upper_list, axis=axis) pandas_result = pandas_df.clip_upper(upper_list, axis=axis) df_equals(modin_result, pandas_result) def test_combine(self): df1 = pd.DataFrame({"A": [0, 0], "B": [4, 4]}) df2 = pd.DataFrame({"A": [1, 1], "B": [3, 3]}) with pytest.warns(UserWarning): df1.combine(df2, lambda s1, s2: s1 if s1.sum() < s2.sum() else s2) def test_combine_first(self): df1 = pd.DataFrame({"A": [None, 0], "B": [None, 4]}) df2 = pd.DataFrame({"A": [1, 1], "B": [3, 3]}) with pytest.warns(UserWarning): df1.combine_first(df2) def test_compound(self): data = test_data_values[0] with pytest.warns(UserWarning): pd.DataFrame(data).compound() def test_corr(self): data = test_data_values[0] with pytest.warns(UserWarning): pd.DataFrame(data).corr() def test_corrwith(self): data = test_data_values[0] with pytest.warns(UserWarning): pd.DataFrame(data).corrwith(pd.DataFrame(data)) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) @pytest.mark.parametrize( "numeric_only", bool_arg_values, ids=arg_keys("numeric_only", bool_arg_keys) ) def test_count(self, request, data, axis, numeric_only): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) modin_result = modin_df.count(axis=axis, numeric_only=numeric_only) pandas_result = pandas_df.count(axis=axis, numeric_only=numeric_only) df_equals(modin_result, pandas_result) modin_result = modin_df.T.count(axis=axis, numeric_only=numeric_only) pandas_result = pandas_df.T.count(axis=axis, numeric_only=numeric_only) df_equals(modin_result, pandas_result) # test level modin_df_multi_level = modin_df.copy() pandas_df_multi_level = pandas_df.copy() axis = modin_df._get_axis_number(axis) if axis is not None else 0 levels = 3 axis_names_list = [["a", "b", "c"], None] for axis_names in axis_names_list: if axis == 0: new_idx = pandas.MultiIndex.from_tuples( [(i // 4, i // 2, i) for i in range(len(modin_df.index))], names=axis_names, ) modin_df_multi_level.index = new_idx pandas_df_multi_level.index = new_idx try: # test error pandas_df_multi_level.count( axis=1, numeric_only=numeric_only, level=0 ) except Exception as e: with pytest.raises(type(e)): modin_df_multi_level.count( axis=1, numeric_only=numeric_only, level=0 ) else: new_col = pandas.MultiIndex.from_tuples( [(i // 4, i // 2, i) for i in range(len(modin_df.columns))], names=axis_names, ) modin_df_multi_level.columns = new_col pandas_df_multi_level.columns = new_col try: # test error pandas_df_multi_level.count( axis=0, numeric_only=numeric_only, level=0 ) except Exception as e: with pytest.raises(type(e)): modin_df_multi_level.count( axis=0, numeric_only=numeric_only, level=0 ) for level in list(range(levels)) + (axis_names if axis_names else []): modin_multi_level_result = modin_df_multi_level.count( axis=axis, numeric_only=numeric_only, level=level ) pandas_multi_level_result = pandas_df_multi_level.count( axis=axis, numeric_only=numeric_only, level=level ) df_equals(modin_multi_level_result, pandas_multi_level_result) def test_cov(self): data = test_data_values[0] with pytest.warns(UserWarning): pd.DataFrame(data).cov() @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) @pytest.mark.parametrize( "skipna", bool_arg_values, ids=arg_keys("skipna", bool_arg_keys) ) def test_cummax(self, request, data, axis, skipna): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) try: pandas_result = pandas_df.cummax(axis=axis, skipna=skipna) except Exception as e: with pytest.raises(type(e)): modin_df.cummax(axis=axis, skipna=skipna) else: modin_result = modin_df.cummax(axis=axis, skipna=skipna) df_equals(modin_result, pandas_result) try: pandas_result = pandas_df.T.cummax(axis=axis, skipna=skipna) except Exception as e: with pytest.raises(type(e)): modin_df.T.cummax(axis=axis, skipna=skipna) else: modin_result = modin_df.T.cummax(axis=axis, skipna=skipna) df_equals(modin_result, pandas_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) @pytest.mark.parametrize( "skipna", bool_arg_values, ids=arg_keys("skipna", bool_arg_keys) ) def test_cummin(self, request, data, axis, skipna): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) try: pandas_result = pandas_df.cummin(axis=axis, skipna=skipna) except Exception as e: with pytest.raises(type(e)): modin_df.cummin(axis=axis, skipna=skipna) else: modin_result = modin_df.cummin(axis=axis, skipna=skipna) df_equals(modin_result, pandas_result) try: pandas_result = pandas_df.T.cummin(axis=axis, skipna=skipna) except Exception as e: with pytest.raises(type(e)): modin_df.T.cummin(axis=axis, skipna=skipna) else: modin_result = modin_df.T.cummin(axis=axis, skipna=skipna) df_equals(modin_result, pandas_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) @pytest.mark.parametrize( "skipna", bool_arg_values, ids=arg_keys("skipna", bool_arg_keys) ) def test_cumprod(self, request, data, axis, skipna): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) try: pandas_result = pandas_df.cumprod(axis=axis, skipna=skipna) except Exception as e: with pytest.raises(type(e)): modin_df.cumprod(axis=axis, skipna=skipna) else: modin_result = modin_df.cumprod(axis=axis, skipna=skipna) df_equals(modin_result, pandas_result) try: pandas_result = pandas_df.T.cumprod(axis=axis, skipna=skipna) except Exception as e: with pytest.raises(type(e)): modin_df.T.cumprod(axis=axis, skipna=skipna) else: modin_result = modin_df.T.cumprod(axis=axis, skipna=skipna) df_equals(modin_result, pandas_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) @pytest.mark.parametrize( "skipna", bool_arg_values, ids=arg_keys("skipna", bool_arg_keys) ) def test_cumsum(self, request, data, axis, skipna): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) # pandas exhibits weird behavior for this case # Remove this case when we can pull the error messages from backend if name_contains(request.node.name, ["datetime_timedelta_data"]) and ( axis == 0 or axis == "rows" ): with pytest.raises(TypeError): modin_df.cumsum(axis=axis, skipna=skipna) else: try: pandas_result = pandas_df.cumsum(axis=axis, skipna=skipna) except Exception as e: with pytest.raises(type(e)): modin_df.cumsum(axis=axis, skipna=skipna) else: modin_result = modin_df.cumsum(axis=axis, skipna=skipna) df_equals(modin_result, pandas_result) if name_contains(request.node.name, ["datetime_timedelta_data"]) and ( axis == 0 or axis == "rows" ): with pytest.raises(TypeError): modin_df.T.cumsum(axis=axis, skipna=skipna) else: try: pandas_result = pandas_df.T.cumsum(axis=axis, skipna=skipna) except Exception as e: with pytest.raises(type(e)): modin_df.T.cumsum(axis=axis, skipna=skipna) else: modin_result = modin_df.T.cumsum(axis=axis, skipna=skipna) df_equals(modin_result, pandas_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_describe(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) df_equals(modin_df.describe(), pandas_df.describe()) percentiles = [0.10, 0.11, 0.44, 0.78, 0.99] df_equals( modin_df.describe(percentiles=percentiles), pandas_df.describe(percentiles=percentiles), ) try: pandas_result = pandas_df.describe(exclude=[np.float64]) except Exception as e: with pytest.raises(type(e)): modin_df.describe(exclude=[np.float64]) else: modin_result = modin_df.describe(exclude=[np.float64]) df_equals(modin_result, pandas_result) try: pandas_result = pandas_df.describe(exclude=np.float64) except Exception as e: with pytest.raises(type(e)): modin_df.describe(exclude=np.float64) else: modin_result = modin_df.describe(exclude=np.float64) df_equals(modin_result, pandas_result) try: pandas_result = pandas_df.describe( include=[np.timedelta64, np.datetime64, np.object, np.bool] ) except Exception as e: with pytest.raises(type(e)): modin_df.describe( include=[np.timedelta64, np.datetime64, np.object, np.bool] ) else: modin_result = modin_df.describe( include=[np.timedelta64, np.datetime64, np.object, np.bool] ) df_equals(modin_result, pandas_result) modin_result = modin_df.describe(include=str(modin_df.dtypes.values[0])) pandas_result = pandas_df.describe(include=str(pandas_df.dtypes.values[0])) df_equals(modin_result, pandas_result) modin_result = modin_df.describe(include=[np.number]) pandas_result = pandas_df.describe(include=[np.number]) df_equals(modin_result, pandas_result) df_equals(modin_df.describe(include="all"), pandas_df.describe(include="all")) modin_df = pd.DataFrame(data).applymap(str) pandas_df = pandas.DataFrame(data).applymap(str) try: df_equals(modin_df.describe(), pandas_df.describe()) except AssertionError: # We have to do this because we choose the highest count slightly differently # than pandas. Because there is no true guarantee which one will be first, # If they don't match, make sure that the `freq` is the same at least. df_equals( modin_df.describe().loc[["count", "unique", "freq"]], pandas_df.describe().loc[["count", "unique", "freq"]], ) def test_describe_dtypes(self): modin_df = pd.DataFrame( { "col1": list("abc"), "col2": list("abc"), "col3": list("abc"), "col4": [1, 2, 3], } ) pandas_df = pandas.DataFrame( { "col1": list("abc"), "col2": list("abc"), "col3": list("abc"), "col4": [1, 2, 3], } ) modin_result = modin_df.describe() pandas_result = pandas_df.describe() df_equals(modin_result, pandas_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) @pytest.mark.parametrize( "periods", int_arg_values, ids=arg_keys("periods", int_arg_keys) ) def test_diff(self, request, data, axis, periods): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) try: pandas_result = pandas_df.diff(axis=axis, periods=periods) except Exception as e: with pytest.raises(type(e)): modin_df.diff(axis=axis, periods=periods) else: modin_result = modin_df.diff(axis=axis, periods=periods) df_equals(modin_result, pandas_result) try: pandas_result = pandas_df.T.diff(axis=axis, periods=periods) except Exception as e: with pytest.raises(type(e)): modin_df.T.diff(axis=axis, periods=periods) else: modin_result = modin_df.T.diff(axis=axis, periods=periods) df_equals(modin_result, pandas_result) def test_drop(self): frame_data = {"A": [1, 2, 3, 4], "B": [0, 1, 2, 3]} simple = pandas.DataFrame(frame_data) modin_simple = pd.DataFrame(frame_data) df_equals(modin_simple.drop("A", axis=1), simple[["B"]]) df_equals(modin_simple.drop(["A", "B"], axis="columns"), simple[[]]) df_equals(modin_simple.drop([0, 1, 3], axis=0), simple.loc[[2], :]) df_equals(modin_simple.drop([0, 3], axis="index"), simple.loc[[1, 2], :]) pytest.raises(ValueError, modin_simple.drop, 5) pytest.raises(ValueError, modin_simple.drop, "C", 1) pytest.raises(ValueError, modin_simple.drop, [1, 5]) pytest.raises(ValueError, modin_simple.drop, ["A", "C"], 1) # errors = 'ignore' df_equals(modin_simple.drop(5, errors="ignore"), simple) df_equals(modin_simple.drop([0, 5], errors="ignore"), simple.loc[[1, 2, 3], :]) df_equals(modin_simple.drop("C", axis=1, errors="ignore"), simple) df_equals(modin_simple.drop(["A", "C"], axis=1, errors="ignore"), simple[["B"]]) # non-unique nu_df = pandas.DataFrame( zip(range(3), range(-3, 1), list("abc")), columns=["a", "a", "b"] ) modin_nu_df = pd.DataFrame(nu_df) df_equals(modin_nu_df.drop("a", axis=1), nu_df[["b"]]) df_equals(modin_nu_df.drop("b", axis="columns"), nu_df["a"]) df_equals(modin_nu_df.drop([]), nu_df) nu_df = nu_df.set_index(pandas.Index(["X", "Y", "X"])) nu_df.columns = list("abc") modin_nu_df = pd.DataFrame(nu_df) df_equals(modin_nu_df.drop("X", axis="rows"), nu_df.loc[["Y"], :]) df_equals(modin_nu_df.drop(["X", "Y"], axis=0), nu_df.loc[[], :]) # inplace cache issue frame_data = random_state.randn(10, 3) df = pandas.DataFrame(frame_data, columns=list("abc")) modin_df = pd.DataFrame(frame_data, columns=list("abc")) expected = df[~(df.b > 0)] modin_df.drop(labels=df[df.b > 0].index, inplace=True) df_equals(modin_df, expected) midx = pd.MultiIndex( levels=[["lama", "cow", "falcon"], ["speed", "weight", "length"]], codes=[[0, 0, 0, 1, 1, 1, 2, 2, 2], [0, 1, 2, 0, 1, 2, 0, 1, 2]], ) df = pd.DataFrame( index=midx, columns=["big", "small"], data=[ [45, 30], [200, 100], [1.5, 1], [30, 20], [250, 150], [1.5, 0.8], [320, 250], [1, 0.8], [0.3, 0.2], ], ) with pytest.warns(UserWarning): df.drop(index="length", level=1) def test_drop_api_equivalence(self): # equivalence of the labels/axis and index/columns API's frame_data = [[1, 2, 3], [3, 4, 5], [5, 6, 7]] modin_df = pd.DataFrame( frame_data, index=["a", "b", "c"], columns=["d", "e", "f"] ) modin_df1 = modin_df.drop("a") modin_df2 = modin_df.drop(index="a") df_equals(modin_df1, modin_df2) modin_df1 = modin_df.drop("d", 1) modin_df2 = modin_df.drop(columns="d") df_equals(modin_df1, modin_df2) modin_df1 = modin_df.drop(labels="e", axis=1) modin_df2 = modin_df.drop(columns="e") df_equals(modin_df1, modin_df2) modin_df1 = modin_df.drop(["a"], axis=0) modin_df2 = modin_df.drop(index=["a"]) df_equals(modin_df1, modin_df2) modin_df1 = modin_df.drop(["a"], axis=0).drop(["d"], axis=1) modin_df2 = modin_df.drop(index=["a"], columns=["d"]) df_equals(modin_df1, modin_df2) with pytest.raises(ValueError): modin_df.drop(labels="a", index="b") with pytest.raises(ValueError): modin_df.drop(labels="a", columns="b") with pytest.raises(ValueError): modin_df.drop(axis=1) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_drop_transpose(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) modin_result = modin_df.T.drop(columns=[0, 1, 2]) pandas_result = pandas_df.T.drop(columns=[0, 1, 2]) df_equals(modin_result, pandas_result) modin_result = modin_df.T.drop(index=["col3", "col1"]) pandas_result = pandas_df.T.drop(index=["col3", "col1"]) df_equals(modin_result, pandas_result) modin_result = modin_df.T.drop(columns=[0, 1, 2], index=["col3", "col1"]) pandas_result = pandas_df.T.drop(columns=[0, 1, 2], index=["col3", "col1"]) df_equals(modin_result, pandas_result) def test_droplevel(self): df = ( pd.DataFrame([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]) .set_index([0, 1]) .rename_axis(["a", "b"]) ) df.columns = pd.MultiIndex.from_tuples( [("c", "e"), ("d", "f")], names=["level_1", "level_2"] ) with pytest.warns(UserWarning): df.droplevel("a") with pytest.warns(UserWarning): df.droplevel("level_2", axis=1) @pytest.mark.parametrize( "data", test_data_with_duplicates_values, ids=test_data_with_duplicates_keys ) @pytest.mark.parametrize( "keep", ["last", "first", False], ids=["last", "first", "False"] ) @pytest.mark.parametrize( "subset", [None, ["col1", "col3", "col7"]], ids=["None", "subset"] ) def test_drop_duplicates(self, data, keep, subset): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) df_equals( modin_df.drop_duplicates(keep=keep, inplace=False, subset=subset), pandas_df.drop_duplicates(keep=keep, inplace=False, subset=subset), ) modin_results = modin_df.drop_duplicates(keep=keep, inplace=True, subset=subset) pandas_results = pandas_df.drop_duplicates( keep=keep, inplace=True, subset=subset ) df_equals(modin_results, pandas_results) def test_drop_duplicates_with_missing_index_values(self): data = { "columns": ["value", "time", "id"], "index": [ 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25, 26, 27, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, ], "data": [ ["3", 1279213398000.0, 88.0], ["3", 1279204682000.0, 88.0], ["0", 1245772835000.0, 448.0], ["0", 1270564258000.0, 32.0], ["0", 1267106669000.0, 118.0], ["7", 1300621123000.0, 5.0], ["0", 1251130752000.0, 957.0], ["0", 1311683506000.0, 62.0], ["9", 1283692698000.0, 89.0], ["9", 1270234253000.0, 64.0], ["0", 1285088818000.0, 50.0], ["0", 1218212725000.0, 695.0], ["2", 1383933968000.0, 348.0], ["0", 1368227625000.0, 257.0], ["1", 1454514093000.0, 446.0], ["1", 1428497427000.0, 134.0], ["1", 1459184936000.0, 568.0], ["1", 1502293302000.0, 599.0], ["1", 1491833358000.0, 829.0], ["1", 1485431534000.0, 806.0], ["8", 1351800505000.0, 101.0], ["0", 1357247721000.0, 916.0], ["0", 1335804423000.0, 370.0], ["24", 1327547726000.0, 720.0], ["0", 1332334140000.0, 415.0], ["0", 1309543100000.0, 30.0], ["18", 1309541141000.0, 30.0], ["0", 1298979435000.0, 48.0], ["14", 1276098160000.0, 59.0], ["0", 1233936302000.0, 109.0], ], } pandas_df = pandas.DataFrame( data["data"], index=data["index"], columns=data["columns"] ) modin_df = pd.DataFrame( data["data"], index=data["index"], columns=data["columns"] ) modin_result = modin_df.sort_values(["id", "time"]).drop_duplicates(["id"]) pandas_result = pandas_df.sort_values(["id", "time"]).drop_duplicates(["id"]) df_equals(modin_result, pandas_result) def test_drop_duplicates_after_sort(self): data = [ {"value": 1, "time": 2}, {"value": 1, "time": 1}, {"value": 2, "time": 1}, {"value": 2, "time": 2}, ] modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) modin_result = modin_df.sort_values(["value", "time"]).drop_duplicates( ["value"] ) pandas_result = pandas_df.sort_values(["value", "time"]).drop_duplicates( ["value"] ) df_equals(modin_result, pandas_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) @pytest.mark.parametrize("how", ["any", "all"], ids=["any", "all"]) def test_dropna(self, data, axis, how): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) with pytest.raises(ValueError): modin_df.dropna(axis=axis, how="invalid") with pytest.raises(TypeError): modin_df.dropna(axis=axis, how=None, thresh=None) with pytest.raises(KeyError): modin_df.dropna(axis=axis, subset=["NotExists"], how=how) modin_result = modin_df.dropna(axis=axis, how=how) pandas_result = pandas_df.dropna(axis=axis, how=how) df_equals(modin_result, pandas_result) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_dropna_inplace(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) pandas_result = pandas_df.dropna() modin_df.dropna(inplace=True) df_equals(modin_df, pandas_result) modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) pandas_df.dropna(thresh=2, inplace=True) modin_df.dropna(thresh=2, inplace=True) df_equals(modin_df, pandas_df) modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) pandas_df.dropna(axis=1, how="any", inplace=True) modin_df.dropna(axis=1, how="any", inplace=True) df_equals(modin_df, pandas_df) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_dropna_multiple_axes(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) df_equals( modin_df.dropna(how="all", axis=[0, 1]), pandas_df.dropna(how="all", axis=[0, 1]), ) df_equals( modin_df.dropna(how="all", axis=(0, 1)), pandas_df.dropna(how="all", axis=(0, 1)), ) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_dropna_multiple_axes_inplace(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) modin_df_copy = modin_df.copy() pandas_df_copy = pandas_df.copy() modin_df_copy.dropna(how="all", axis=[0, 1], inplace=True) pandas_df_copy.dropna(how="all", axis=[0, 1], inplace=True) df_equals(modin_df_copy, pandas_df_copy) modin_df_copy = modin_df.copy() pandas_df_copy = pandas_df.copy() modin_df_copy.dropna(how="all", axis=(0, 1), inplace=True) pandas_df_copy.dropna(how="all", axis=(0, 1), inplace=True) df_equals(modin_df_copy, pandas_df_copy) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_dropna_subset(self, request, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) if "empty_data" not in request.node.name: column_subset = modin_df.columns[0:2] df_equals( modin_df.dropna(how="all", subset=column_subset), pandas_df.dropna(how="all", subset=column_subset), ) df_equals( modin_df.dropna(how="any", subset=column_subset), pandas_df.dropna(how="any", subset=column_subset), ) row_subset = modin_df.index[0:2] df_equals( modin_df.dropna(how="all", axis=1, subset=row_subset), pandas_df.dropna(how="all", axis=1, subset=row_subset), ) df_equals( modin_df.dropna(how="any", axis=1, subset=row_subset), pandas_df.dropna(how="any", axis=1, subset=row_subset), ) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_dropna_subset_error(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) # noqa F841 # pandas_df is unused so there won't be confusing list comprehension # stuff in the pytest.mark.parametrize with pytest.raises(KeyError): modin_df.dropna(subset=list("EF")) if len(modin_df.columns) < 5: with pytest.raises(KeyError): modin_df.dropna(axis=1, subset=[4, 5]) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_dot(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) col_len = len(modin_df.columns) # Test list input arr = np.arange(col_len) modin_result = modin_df.dot(arr) pandas_result = pandas_df.dot(arr) df_equals(modin_result, pandas_result) # Test bad dimensions with pytest.raises(ValueError): modin_result = modin_df.dot(np.arange(col_len + 10)) # Test series input modin_series = pd.Series(np.arange(col_len), index=modin_df.columns) pandas_series = pandas.Series(np.arange(col_len), index=modin_df.columns) modin_result = modin_df.dot(modin_series) pandas_result = pandas_df.dot(pandas_series) df_equals(modin_result, pandas_result) # Test when input series index doesn't line up with columns with pytest.raises(ValueError): modin_result = modin_df.dot(pd.Series(np.arange(col_len))) with pytest.warns(UserWarning): modin_df.dot(modin_df.T) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize( "keep", ["last", "first", False], ids=["last", "first", "False"] ) def test_duplicated(self, data, keep): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) pandas_result = pandas_df.duplicated(keep=keep) modin_result = modin_df.duplicated(keep=keep) df_equals(modin_result, pandas_result) import random subset = random.sample( list(pandas_df.columns), random.randint(1, len(pandas_df.columns)) ) pandas_result = pandas_df.duplicated(keep=keep, subset=subset) modin_result = modin_df.duplicated(keep=keep, subset=subset) df_equals(modin_result, pandas_result) def test_empty_df(self): df = pd.DataFrame(index=["a", "b"]) df_is_empty(df) tm.assert_index_equal(df.index, pd.Index(["a", "b"])) assert len(df.columns) == 0 df = pd.DataFrame(columns=["a", "b"]) df_is_empty(df) assert len(df.index) == 0 tm.assert_index_equal(df.columns, pd.Index(["a", "b"])) df = pd.DataFrame() df_is_empty(df) assert len(df.index) == 0 assert len(df.columns) == 0 df = pd.DataFrame(index=["a", "b"]) df_is_empty(df) tm.assert_index_equal(df.index, pd.Index(["a", "b"])) assert len(df.columns) == 0 df = pd.DataFrame(columns=["a", "b"]) df_is_empty(df) assert len(df.index) == 0 tm.assert_index_equal(df.columns, pd.Index(["a", "b"])) df = pd.DataFrame() df_is_empty(df) assert len(df.index) == 0 assert len(df.columns) == 0 def test_equals(self): frame_data = {"col1": [2.9, 3, 3, 3], "col2": [2, 3, 4, 1]} modin_df1 = pd.DataFrame(frame_data) modin_df2 = pd.DataFrame(frame_data) assert modin_df1.equals(modin_df2) df_equals(modin_df1, modin_df2) df_equals(modin_df1, pd.DataFrame(modin_df1)) frame_data = {"col1": [2.9, 3, 3, 3], "col2": [2, 3, 5, 1]} modin_df3 = pd.DataFrame(frame_data, index=list("abcd")) assert not modin_df1.equals(modin_df3) with pytest.raises(AssertionError): df_equals(modin_df3, modin_df1) with pytest.raises(AssertionError): df_equals(modin_df3, modin_df2) assert modin_df1.equals(modin_df2._query_compiler.to_pandas()) def test_eval_df_use_case(self): frame_data = {"a": random_state.randn(10), "b": random_state.randn(10)} df = pandas.DataFrame(frame_data) modin_df = pd.DataFrame(frame_data) # test eval for series results tmp_pandas = df.eval("arctan2(sin(a), b)", engine="python", parser="pandas") tmp_modin = modin_df.eval( "arctan2(sin(a), b)", engine="python", parser="pandas" ) assert isinstance(tmp_modin, pd.Series) df_equals(tmp_modin, tmp_pandas) # Test not inplace assignments tmp_pandas = df.eval("e = arctan2(sin(a), b)", engine="python", parser="pandas") tmp_modin = modin_df.eval( "e = arctan2(sin(a), b)", engine="python", parser="pandas" ) df_equals(tmp_modin, tmp_pandas) # Test inplace assignments df.eval( "e = arctan2(sin(a), b)", engine="python", parser="pandas", inplace=True ) modin_df.eval( "e = arctan2(sin(a), b)", engine="python", parser="pandas", inplace=True ) # TODO: Use a series equality validator. df_equals(modin_df, df) def test_eval_df_arithmetic_subexpression(self): frame_data = {"a": random_state.randn(10), "b": random_state.randn(10)} df = pandas.DataFrame(frame_data) modin_df = pd.DataFrame(frame_data) df.eval("not_e = sin(a + b)", engine="python", parser="pandas", inplace=True) modin_df.eval( "not_e = sin(a + b)", engine="python", parser="pandas", inplace=True ) # TODO: Use a series equality validator. df_equals(modin_df, df) def test_ewm(self): df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]}) with pytest.warns(UserWarning): df.ewm(com=0.5).mean() def test_expanding(self): data = test_data_values[0] with pytest.warns(UserWarning): pd.DataFrame(data).expanding() @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_explode(self, data): modin_df = pd.DataFrame(data) with pytest.warns(UserWarning): modin_df.explode(modin_df.columns[0]) def test_ffill(self): test_data = TestData() test_data.tsframe["A"][:5] = np.nan test_data.tsframe["A"][-5:] = np.nan modin_df = pd.DataFrame(test_data.tsframe) df_equals(modin_df.ffill(), test_data.tsframe.ffill()) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize( "method", ["backfill", "bfill", "pad", "ffill", None], ids=["backfill", "bfill", "pad", "ffill", "None"], ) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) @pytest.mark.parametrize("limit", int_arg_values, ids=int_arg_keys) def test_fillna(self, data, method, axis, limit): # We are not testing when limit is not positive until pandas-27042 gets fixed. # We are not testing when axis is over rows until pandas-17399 gets fixed. if limit > 0 and axis != 1 and axis != "columns": modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) try: pandas_result = pandas_df.fillna( 0, method=method, axis=axis, limit=limit ) except Exception as e: with pytest.raises(type(e)): modin_df.fillna(0, method=method, axis=axis, limit=limit) else: modin_result = modin_df.fillna(0, method=method, axis=axis, limit=limit) df_equals(modin_result, pandas_result) def test_fillna_sanity(self): test_data = TestData() tf = test_data.tsframe tf.loc[tf.index[:5], "A"] = np.nan tf.loc[tf.index[-5:], "A"] = np.nan zero_filled = test_data.tsframe.fillna(0) modin_df = pd.DataFrame(test_data.tsframe).fillna(0) df_equals(modin_df, zero_filled) padded = test_data.tsframe.fillna(method="pad") modin_df = pd.DataFrame(test_data.tsframe).fillna(method="pad") df_equals(modin_df, padded) # mixed type mf = test_data.mixed_frame mf.loc[mf.index[5:20], "foo"] = np.nan mf.loc[mf.index[-10:], "A"] = np.nan result = test_data.mixed_frame.fillna(value=0) modin_df = pd.DataFrame(test_data.mixed_frame).fillna(value=0) df_equals(modin_df, result) result = test_data.mixed_frame.fillna(method="pad") modin_df = pd.DataFrame(test_data.mixed_frame).fillna(method="pad") df_equals(modin_df, result) pytest.raises(ValueError, test_data.tsframe.fillna) pytest.raises(ValueError, pd.DataFrame(test_data.tsframe).fillna) with pytest.raises(ValueError): pd.DataFrame(test_data.tsframe).fillna(5, method="ffill") # mixed numeric (but no float16) mf = test_data.mixed_float.reindex(columns=["A", "B", "D"]) mf.loc[mf.index[-10:], "A"] = np.nan result = mf.fillna(value=0) modin_df = pd.DataFrame(mf).fillna(value=0) df_equals(modin_df, result) result = mf.fillna(method="pad") modin_df = pd.DataFrame(mf).fillna(method="pad") df_equals(modin_df, result) # TODO: Use this when Arrow issue resolves: # (https://issues.apache.org/jira/browse/ARROW-2122) # empty frame # df = DataFrame(columns=['x']) # for m in ['pad', 'backfill']: # df.x.fillna(method=m, inplace=True) # df.x.fillna(method=m) # with different dtype frame_data = [ ["a", "a", np.nan, "a"], ["b", "b", np.nan, "b"], ["c", "c", np.nan, "c"], ] df = pandas.DataFrame(frame_data) result = df.fillna({2: "foo"}) modin_df = pd.DataFrame(frame_data).fillna({2: "foo"}) df_equals(modin_df, result) modin_df = pd.DataFrame(df) df.fillna({2: "foo"}, inplace=True) modin_df.fillna({2: "foo"}, inplace=True) df_equals(modin_df, result) frame_data = { "Date": [pandas.NaT, pandas.Timestamp("2014-1-1")], "Date2": [pandas.Timestamp("2013-1-1"), pandas.NaT], } df = pandas.DataFrame(frame_data) result = df.fillna(value={"Date": df["Date2"]}) modin_df = pd.DataFrame(frame_data).fillna(value={"Date": df["Date2"]}) df_equals(modin_df, result) # TODO: Use this when Arrow issue resolves: # (https://issues.apache.org/jira/browse/ARROW-2122) # with timezone """ frame_data = {'A': [pandas.Timestamp('2012-11-11 00:00:00+01:00'), pandas.NaT]} df = pandas.DataFrame(frame_data) modin_df = pd.DataFrame(frame_data) df_equals(modin_df.fillna(method='pad'), df.fillna(method='pad')) frame_data = {'A': [pandas.NaT, pandas.Timestamp('2012-11-11 00:00:00+01:00')]} df = pandas.DataFrame(frame_data) modin_df = pd.DataFrame(frame_data).fillna(method='bfill') df_equals(modin_df, df.fillna(method='bfill')) """ def test_fillna_downcast(self): # infer int64 from float64 frame_data = {"a": [1.0, np.nan]} df = pandas.DataFrame(frame_data) result = df.fillna(0, downcast="infer") modin_df = pd.DataFrame(frame_data).fillna(0, downcast="infer") df_equals(modin_df, result) # infer int64 from float64 when fillna value is a dict df = pandas.DataFrame(frame_data) result = df.fillna({"a": 0}, downcast="infer") modin_df = pd.DataFrame(frame_data).fillna({"a": 0}, downcast="infer") df_equals(modin_df, result) def test_ffill2(self): test_data = TestData() test_data.tsframe["A"][:5] = np.nan test_data.tsframe["A"][-5:] = np.nan modin_df = pd.DataFrame(test_data.tsframe) df_equals( modin_df.fillna(method="ffill"), test_data.tsframe.fillna(method="ffill") ) def test_bfill2(self): test_data = TestData() test_data.tsframe["A"][:5] = np.nan test_data.tsframe["A"][-5:] = np.nan modin_df = pd.DataFrame(test_data.tsframe) df_equals( modin_df.fillna(method="bfill"), test_data.tsframe.fillna(method="bfill") ) def test_fillna_inplace(self): frame_data = random_state.randn(10, 4) df = pandas.DataFrame(frame_data) df[1][:4] = np.nan df[3][-4:] = np.nan modin_df = pd.DataFrame(df) df.fillna(value=0, inplace=True) try: df_equals(modin_df, df) except AssertionError: pass else: assert False modin_df.fillna(value=0, inplace=True) df_equals(modin_df, df) modin_df = pd.DataFrame(df).fillna(value={0: 0}, inplace=True) assert modin_df is None df[1][:4] = np.nan df[3][-4:] = np.nan modin_df = pd.DataFrame(df) df.fillna(method="ffill", inplace=True) try: df_equals(modin_df, df) except AssertionError: pass else: assert False modin_df.fillna(method="ffill", inplace=True) df_equals(modin_df, df) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_frame_fillna_limit(self, data): pandas_df = pandas.DataFrame(data) index = pandas_df.index result = pandas_df[:2].reindex(index) modin_df = pd.DataFrame(result) df_equals( modin_df.fillna(method="pad", limit=2), result.fillna(method="pad", limit=2) ) result = pandas_df[-2:].reindex(index) modin_df = pd.DataFrame(result) df_equals( modin_df.fillna(method="backfill", limit=2), result.fillna(method="backfill", limit=2), ) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_frame_pad_backfill_limit(self, data): pandas_df = pandas.DataFrame(data) index = pandas_df.index result = pandas_df[:2].reindex(index) modin_df = pd.DataFrame(result) df_equals( modin_df.fillna(method="pad", limit=2), result.fillna(method="pad", limit=2) ) result = pandas_df[-2:].reindex(index) modin_df = pd.DataFrame(result) df_equals( modin_df.fillna(method="backfill", limit=2), result.fillna(method="backfill", limit=2), ) def test_fillna_dtype_conversion(self): # make sure that fillna on an empty frame works df = pandas.DataFrame(index=range(3), columns=["A", "B"], dtype="float64") modin_df = pd.DataFrame(index=range(3), columns=["A", "B"], dtype="float64") df_equals(modin_df.fillna("nan"), df.fillna("nan")) frame_data = {"A": [1, np.nan], "B": [1.0, 2.0]} df = pandas.DataFrame(frame_data) modin_df = pd.DataFrame(frame_data) for v in ["", 1, np.nan, 1.0]: df_equals(modin_df.fillna(v), df.fillna(v)) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_fillna_skip_certain_blocks(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) # don't try to fill boolean, int blocks df_equals(modin_df.fillna(np.nan), pandas_df.fillna(np.nan)) def test_fillna_dict_series(self): frame_data = { "a": [np.nan, 1, 2, np.nan, np.nan], "b": [1, 2, 3, np.nan, np.nan], "c": [np.nan, 1, 2, 3, 4], } df = pandas.DataFrame(frame_data) modin_df = pd.DataFrame(frame_data) df_equals(modin_df.fillna({"a": 0, "b": 5}), df.fillna({"a": 0, "b": 5})) df_equals( modin_df.fillna({"a": 0, "b": 5, "d": 7}), df.fillna({"a": 0, "b": 5, "d": 7}), ) # Series treated same as dict df_equals(modin_df.fillna(modin_df.max()), df.fillna(df.max())) def test_fillna_dataframe(self): frame_data = { "a": [np.nan, 1, 2, np.nan, np.nan], "b": [1, 2, 3, np.nan, np.nan], "c": [np.nan, 1, 2, 3, 4], } df = pandas.DataFrame(frame_data, index=list("VWXYZ")) modin_df = pd.DataFrame(frame_data, index=list("VWXYZ")) # df2 may have different index and columns df2 = pandas.DataFrame( { "a": [np.nan, 10, 20, 30, 40], "b": [50, 60, 70, 80, 90], "foo": ["bar"] * 5, }, index=list("VWXuZ"), ) modin_df2 = pd.DataFrame(df2) # only those columns and indices which are shared get filled df_equals(modin_df.fillna(modin_df2), df.fillna(df2)) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_fillna_columns(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) df_equals( modin_df.fillna(method="ffill", axis=1), pandas_df.fillna(method="ffill", axis=1), ) df_equals( modin_df.fillna(method="ffill", axis=1), pandas_df.fillna(method="ffill", axis=1), ) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_fillna_invalid_method(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) # noqa F841 with tm.assert_raises_regex(ValueError, "ffil"): modin_df.fillna(method="ffil") def test_fillna_invalid_value(self): test_data = TestData() modin_df = pd.DataFrame(test_data.frame) # list pytest.raises(TypeError, modin_df.fillna, [1, 2]) # tuple pytest.raises(TypeError, modin_df.fillna, (1, 2)) # frame with series pytest.raises(TypeError, modin_df.iloc[:, 0].fillna, modin_df) @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_fillna_col_reordering(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) df_equals(modin_df.fillna(method="ffill"), pandas_df.fillna(method="ffill")) """ TODO: Use this when Arrow issue resolves: (https://issues.apache.org/jira/browse/ARROW-2122) def test_fillna_datetime_columns(self): frame_data = {'A': [-1, -2, np.nan], 'B': date_range('20130101', periods=3), 'C': ['foo', 'bar', None], 'D': ['foo2', 'bar2', None]} df = pandas.DataFrame(frame_data, index=date_range('20130110', periods=3)) modin_df = pd.DataFrame(frame_data, index=date_range('20130110', periods=3)) df_equals(modin_df.fillna('?'), df.fillna('?')) frame_data = {'A': [-1, -2, np.nan], 'B': [pandas.Timestamp('2013-01-01'), pandas.Timestamp('2013-01-02'), pandas.NaT], 'C': ['foo', 'bar', None], 'D': ['foo2', 'bar2', None]} df = pandas.DataFrame(frame_data, index=date_range('20130110', periods=3)) modin_df = pd.DataFrame(frame_data, index=date_range('20130110', periods=3)) df_equals(modin_df.fillna('?'), df.fillna('?')) """ @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_filter(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) by = {"items": ["col1", "col5"], "regex": "4$|3$", "like": "col"} df_equals( modin_df.filter(items=by["items"]), pandas_df.filter(items=by["items"]) ) df_equals( modin_df.filter(regex=by["regex"], axis=0), pandas_df.filter(regex=by["regex"], axis=0), ) df_equals( modin_df.filter(regex=by["regex"], axis=1), pandas_df.filter(regex=by["regex"], axis=1), ) df_equals(modin_df.filter(like=by["like"]), pandas_df.filter(like=by["like"])) with pytest.raises(TypeError): modin_df.filter(items=by["items"], regex=by["regex"]) with pytest.raises(TypeError): modin_df.filter() def test_first(self): i = pd.date_range("2018-04-09", periods=4, freq="2D") ts = pd.DataFrame({"A": [1, 2, 3, 4]}, index=i) with pytest.warns(UserWarning): ts.first("3D") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_first_valid_index(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) assert modin_df.first_valid_index() == (pandas_df.first_valid_index()) @pytest.mark.skip(reason="Defaulting to Pandas") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_from_dict(self, data): modin_df = pd.DataFrame(data) # noqa F841 pandas_df = pandas.DataFrame(data) # noqa F841 with pytest.raises(NotImplementedError): pd.DataFrame.from_dict(None) @pytest.mark.skip(reason="Defaulting to Pandas") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_from_items(self, data): modin_df = pd.DataFrame(data) # noqa F841 pandas_df = pandas.DataFrame(data) # noqa F841 with pytest.raises(NotImplementedError): pd.DataFrame.from_items(None) @pytest.mark.skip(reason="Defaulting to Pandas") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_from_records(self, data): modin_df = pd.DataFrame(data) # noqa F841 pandas_df = pandas.DataFrame(data) # noqa F841 with pytest.raises(NotImplementedError): pd.DataFrame.from_records(None) def test_get_value(self): data = test_data_values[0] with pytest.warns(UserWarning): pd.DataFrame(data).get_value(0, "col1") def test_get_values(self): data = test_data_values[0] with pytest.warns(UserWarning): pd.DataFrame(data).get_values() @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("n", int_arg_values, ids=arg_keys("n", int_arg_keys)) def test_head(self, data, n): # Test normal dataframe head modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) df_equals(modin_df.head(n), pandas_df.head(n)) df_equals(modin_df.head(len(modin_df) + 1), pandas_df.head(len(pandas_df) + 1)) # Test head when we call it from a QueryCompilerView modin_result = modin_df.loc[:, ["col1", "col3", "col3"]].head(n) pandas_result = pandas_df.loc[:, ["col1", "col3", "col3"]].head(n) df_equals(modin_result, pandas_result) def test_hist(self): data = test_data_values[0] with pytest.warns(UserWarning): pd.DataFrame(data).hist(None) @pytest.mark.skip(reason="Defaulting to Pandas") @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) def test_iat(self, data): modin_df = pd.DataFrame(data) pandas_df = pandas.DataFrame(data) # noqa F841 with pytest.raises(NotImplementedError): modin_df.iat() @pytest.mark.parametrize("data", test_data_values, ids=test_data_keys) @pytest.mark.parametrize("axis", axis_values, ids=axis_keys) @pytest.mark.parametrize( "skipna", bool_arg_values, ids=arg_keys("skipna", bool_arg_keys) ) def test_idxmax(self, data, axis, skipna): modin_df = pd.DataFrame(data) pandas_df =
pandas.DataFrame(data)
pandas.DataFrame
from src.apply_gnn_to_datasets import eval_original, eval_conf, eval_sbm, eval_sbm_label, eval_modcm, eval_reglabel, eval_shuffled_features from src.apply_gnn_to_datasets import eval_random, eval_erdos, eval_flipped, eval_removed_hubs, eval_added_2hop_edges, eval_random_features from src.apply_gnn_to_datasets import eval_label_sbm, eval_injected_edges, eval_injected_edges_sbm, eval_injected_edges_constant_nodes from src.apply_gnn_to_datasets import eval_sbm_swap, eval_injected_edges_degree_cat,eval_injected_edges_attack_target from src.apply_gnn_to_datasets import eval_cm_communities, eval_modsbm, eval_shifting import argparse import pandas as pd import os import warnings import numpy as np warnings.filterwarnings("ignore") def parse_args(): parser = argparse.ArgumentParser(description="Main GNN training script.") parser.add_argument('--conf', type=bool, default=False, help='Is configuration model evaluation. Default is False.') parser.add_argument('--shifting', type=bool, default=False, help='Is shifting evaluation. Default is False.') parser.add_argument('--sbm', type=bool, default=False, help='Is SBM evaluation. Default is False.') parser.add_argument('--shuffled_features', type=bool, default=False, help='Is shuffled features evaluation. Default is False.') parser.add_argument('--random_features', type=bool, default=False, help='Is random features evaluation. Default is False.') parser.add_argument('--cm_communities', type=bool, default=False, help='Is configuration model on communities evaluation. Default is False.') parser.add_argument('--modcm', type=bool, default=False, help='Is modified configuration model evaluation. Default is False.') parser.add_argument('--modsbm', type=bool, default=False, help='Is modified SBM evaluation. Default is False.') parser.add_argument('--reglabel', type=bool, default=False, help='Is label-based d-regular graph evaluation. Default is False.') parser.add_argument('--sbm_label', type=bool, default=False, help='Is SBM_label evaluation. Default is False.') parser.add_argument('--sbm_swap', type=bool, default=False, help='Is SBM evaluation with synthetic swapping. Default is False.') parser.add_argument('--swap', type=bool, default=False, help='Is it evaluation with synthetic swapping. Default is False.') parser.add_argument('--random', type=bool, default=False, help='Evaluating on a completely random d-regular graph?. Default is False.') parser.add_argument('--erdos', type=bool, default=False, help='Evaluating on a completely random Erdos-Renyi graph?. Default is False.') parser.add_argument('--label_sbm', type=bool, default=False, help='Evaluating on a completely label_sbm graph?. Default is False.') parser.add_argument('--injected_edges', type=bool, default=False, help='Evaluating on a completely injected_edges graph?. Default is False.') parser.add_argument('--injected_edges_degree_cat', type=bool, default=False, help='Evaluating on a completely injected_edges_degree_cat graph?. Default is False.') parser.add_argument('--injected_edges_constant_nodes', type=bool, default=False, help='Evaluating on a completely injected_edges_constant_nodes graph?. Default is False.') parser.add_argument('--injected_edges_attack_target', type=bool, default=False, help='Evaluating on a completely injected_edges_attack_target graph?. Default is False.') parser.add_argument('--injected_edges_sbm', type=bool, default=False, help='Evaluating on a completely injected_edges_sbm graph?. Default is False.') parser.add_argument('--flipped', type=bool, default=False, help='Evaluating with flipped edges? Default is False.') parser.add_argument('--removed_hubs', type=bool, default=False, help='Evaluating with removed hubs? Default is False.') parser.add_argument('--added_2hop_edges', type=bool, default=False, help='Evaluating with added 2-hop edges? Default is False.') parser.add_argument('--hubs_experiment', default='weak', help='hubs experiment type (loca_hubs, global_hubs, local_edges, global_edges). Default is None.') parser.add_argument('--datasets', nargs='+', help='datasets to process, e.g., --dataset cora pubmed') parser.add_argument('--models', nargs='+', help='models to evaluate, e.g., --models gcn sage gat') parser.add_argument('--splits', type=int, default=20, help='Number of random train/validation/test splits. Default is 20.') parser.add_argument('--runs', type=int, default=5, help='Number of random initializations of the model. Default is 5.') parser.add_argument('--train_examples', type=int, default=20, help='Number of training examples per class. Default is 20.') parser.add_argument('--val_examples', type=int, default=30, help='Number of validation examples per class. Default is 30.') parser.add_argument('--directionalities', nargs='+', default=['undirected'], help='directionalities, example: --directionalities undirected directed reversed. Default: undirected') args = parser.parse_args() return args datasets_similar_to_pubmed = 'cora_full ms_academic_cs ms_academic_phy'.split() def model_selection(model, dataset): if model == 'gat' and dataset in datasets_similar_to_pubmed: dataset = 'pubmed' # take pubmed hyperparams and apply them to cora_full # if dataset == 'citeseer': # dataset = 'cora' # take cora hyperparams and apply them to citeseer filename = f'reports/results/eval/{model}_val_{dataset}_undirected.csv' if not os.path.exists(filename): filename = f'reports/results/eval/{model}.csv' print(f'reading hyperparams from file {filename}') df =
pd.read_csv(filename)
pandas.read_csv
# page 14 # =============================== # Getting and checking dataset # =============================== from sklearn.datasets import load_iris iris_dataset = load_iris() # print("Keys of iris_dataset: \n{}".format(iris_dataset.keys())) """ Keys of iris_dataset: dict_keys(['data', 'DESCR', 'filename', 'target_names', 'feature_names', 'target']) """ # print(iris_dataset['DESCR'][:193] + "\n ...") """ Iris plants dataset -------------------- **Data Set Characteristics:** :Number of Instances: 150 (50 in each of three classes) :Number of Attributes: 4 numeric, pre ... """ # print("Target names: {}".format(iris_dataset['target_names'])) """ Target names: ['setosa' 'versicolor' 'virginica'] """ # print("Feature names: \n{}".format(iris_dataset['feature_names'])) """ Feature names: ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'] """ # print("Type of data: {}".format(type(iris_dataset['data']))) # print("Shape of data: {}".format(iris_dataset['data'].shape)) """ Type of data: <class 'numpy.ndarray'> Shape of data: (150, 4) """ # print("First five column of data:\n{}".format(iris_dataset['data'][:5])) """ First five column of data: [[5.1 3.5 1.4 0.2] [4.9 3. 1.4 0.2] [4.7 3.2 1.3 0.2] [4.6 3.1 1.5 0.2] [5. 3.6 1.4 0.2]] """ # print("Type of target: {}".format(type(iris_dataset['target']))) """ Type of target: <class 'numpy.ndarray'> """ # print("Shape of target: {}".format(iris_dataset['target'].shape)) """ Shape of target: (150,) """ # print("Target:\n{}".format(iris_dataset['target'])) # setona: 0, versicolor: 1, verginia: 2 """ Target: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2] """ # =================================== # Generating training and test data # =================================== from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(iris_dataset['data'], iris_dataset['target'], random_state=0) # print("X_train shape: {}".format(X_train.shape)) # matrix data for training # print("y_train shape: {}".format(y_train.shape)) # labels (results) for training """ X_train shape: (112, 4) y_train shape: (112,) """ # print("X_test shape: {}".format(X_test.shape)) # matrix data for test # print("y_test shape: {}".format(y_test.shape)) # labels (results) for test """ X_test shape: (38, 4) y_test shape: (38,) """ # ================== # Observation data # ================== import pandas as pd import matplotlib.pyplot as plt iris_dataframe =
pd.DataFrame(X_train, columns=iris_dataset.feature_names)
pandas.DataFrame
import matplotlib matplotlib.use("TkAgg") import matplotlib.pyplot as plt plt.style.use("./Styles/Scientific.mplstyle") import numpy as np import pandas as pd from plotting import plot_3D_scatter def get_features(data): features = {} for key, values in data.items(): timestamps, counts = np.unique(values["Timestamp"], return_counts=True) features[key] = np.array([timestamps, counts]).T return features def get_octaves(data): octaves = pd.DataFrame() for index, (key, values) in enumerate(data.items()): octave, counts = np.unique(values["Octave"], return_counts=True) octaves.insert(index, key, counts) return octaves def feature_plot(features, xlims, ylims): fig, ax = plt.subplots(figsize=(7, 2.0)) for key, value in features.items(): ax.plot(value[:, 0], value[:, 1], label=key) ax.set_xlabel("Time [s]") ax.set_ylabel("Num. of features [-]") ax.set_ylim(ylims) ax.set_xlim(xlims) lg = fig.legend(bbox_to_anchor=(0.69, 1.0), loc="upper center", \ frameon=True, fancybox=False, ncol=3) fr = lg.get_frame() fr.set_edgecolor("black") fr.set_facecolor("white") fig.subplots_adjust(left=0.10, right=0.975, top=0.75, bottom=0.17, \ wspace=0.2, hspace=0.675) return fig def octave_plot(octave_data): # Octave distribution. margin = 0.4 lefts, rights, centers = [], [], [] fig, ax = plt.subplots(figsize=(7, 2.5)) for index, method in enumerate(octave_data): counts = octave_data[method] fracs = counts / max(counts) levels = np.arange(1, len(counts)+1) center = (1.0 + margin) * index left = center - 0.5 right = center + 0.5 lefts.append(left) centers.append(center) rights.append(right) ax.barh(levels, fracs, left=-fracs/2+center, height=0.8, color="b", \ label=method) ax.set_ylabel("Image Pyramid Level [-]") ax.set_yticks([1, 2, 3, 4, 5, 6, 7, 8], minor=False) ax.set_yticklabels([1, 2, 3, 4, 5, 6, 7, 8]) ax.set_xticks(centers, minor=False) ax.set_xlim([lefts[0]-margin, rights[-1]+margin]) ax.set_xticklabels([col for col in octave_data.columns]) fig.tight_layout() return fig def main(): directory = "/home/martin/dev/Trajectory/Data/SLAM/" time_lims = [ 1611313305.76, 1611313730 ] paths = {} paths["Raw"] = directory + "RAW-Keypoint-Statistics.csv" paths["BLF"] = directory + "BLF-Keypoint-Statistics.csv" paths["HE"] = directory + "HE-Keypoint-Statistics.csv" paths["CLAHE"] = directory + "CLAHE-Keypoint-Statistics.csv" paths["UIENet"] = directory + "UIENet-Keypoint-Statistics.csv" data = {} data["Raw"] = pd.read_csv(paths["Raw"]) data["BLF"] = pd.read_csv(paths["BLF"]) data["HE-BLF"] =
pd.read_csv(paths["HE"])
pandas.read_csv
import os import numpy as np from urllib import request import errno import struct import tarfile import glob import scipy.io as sio from sklearn.utils.extmath import cartesian from scipy.stats import laplace import joblib from spriteworld import factor_distributions as distribs from spriteworld import renderers as spriteworld_renderers from spriteworld import sprite import csv from collections import defaultdict import ast from scripts.data_analysis_utils import load_csv import pandas as pd from sklearn import preprocessing from sklearn import utils import torch from torch.utils.data import Dataset, DataLoader from torchvision.datasets import ImageFolder from torchvision.datasets.utils import download_url, check_integrity from torchvision import transforms from PIL import Image import pickle import h5py from matplotlib import pyplot as plt class TupleLoader(Dataset): def __init__(self, k=-1, rate=1, prior='uniform', transform=None, target_transform=None): # k=-1 gives random number of changing factors as in Locatello k=rand # rate=-1 gives random rate for each sample in Uniform(1,10) self.index_manager = None # set in child class self.factor_sizes = None # set in child class self.categorical = None # set in child class self.data = None # set in child class self.prior = prior self.transform = transform self.target_transform = target_transform self.rate = rate self.k = k if prior == 'laplace' and k != -1: print('warning setting k has no effect on prior=laplace. ' 'Set k=-1 or leave to default to get rid of this warning.') if prior == 'uniform' and rate != -1: print('warning setting rate has no effect on prior=uniform. ' 'Set rate=-1 or leave to default to get rid of this warning.') def __len__(self): return len(self.data) def sample_factors(self, num, random_state): """Sample a batch of observations X. Needed in dis. lib.""" assert not(num % 2) batch_size = int(num / 2) indices = random_state.choice(self.__len__(), 2 * batch_size, replace=False) batch, latents = [], [] for ind in indices: _, _, l1, _ = self.__getitem__(ind) latents.append(l1) return np.stack(latents) def sample_observations_from_factors(self, factors, random_state): batch = [] for factor in factors: sample_ind = self.index_manager.features_to_index(factor) sample = self.data[sample_ind] if self.transform: sample = self.transform(sample) if len(sample.shape) == 2: # set channel dim to 1 sample = sample[None] if np.issubdtype(sample.dtype, np.uint8): sample = sample.astype(np.float32) / 255. batch.append(sample) return np.stack(batch) def sample(self, num, random_state): #Sample a batch of factors Y and observations X factors = self.sample_factors(num, random_state) return factors, self.sample_observations_from_factors(factors, random_state) def sample_observations(self, num, random_state): #Sample a batch of observations X return self.sample(num, random_state)[1] def __getitem__(self, idx): n_factors = len(self.factor_sizes) first_sample = self.data[idx] first_sample_feat = self.index_manager.index_to_features(idx) if self.prior == 'uniform': # only change up to k factors if self.k == -1: k = np.random.randint(1, n_factors) # number of factors which can change else: k = self.k second_sample_feat = first_sample_feat.copy() indices = np.random.choice(n_factors, k, replace=False) for ind in indices: x = np.arange(self.factor_sizes[ind]) p = np.ones_like(x) / (x.shape[0] - 1) p[x == first_sample_feat[ind]] = 0 # dont pick same second_sample_feat[ind] = np.random.choice(x, 1, p=p) assert np.equal(first_sample_feat - second_sample_feat, 0).sum() == n_factors - k elif self.prior == 'laplace': second_sample_feat = self.truncated_laplace(first_sample_feat) else: raise NotImplementedError second_sample_ind = self.index_manager.features_to_index(second_sample_feat) second_sample = self.data[second_sample_ind] if self.transform: first_sample = self.transform(first_sample) second_sample = self.transform(second_sample) if len(first_sample.shape) == 2: # set channel dim to 1 first_sample = first_sample[None] second_sample = second_sample[None] if np.issubdtype(first_sample.dtype, np.uint8) or np.issubdtype(second_sample.dtype, np.uint8): first_sample = first_sample.astype(np.float32) / 255. second_sample = second_sample.astype(np.float32) / 255. if self.target_transform: first_sample_feat = self.target_transform(first_sample_feat) second_sample_feat = self.target_transform(second_sample_feat) return first_sample, second_sample, first_sample_feat, second_sample_feat def truncated_laplace(self, start): if self.rate == -1: rate = np.random.uniform(1, 10, 1)[0] else: rate = self.rate end = [] n_factors = len(self.factor_sizes) for mean, upper in zip(start, np.array(self.factor_sizes)): # sample each feature individually x = np.arange(upper) p = laplace.pdf(x, loc=mean, scale=np.log(upper) / rate) p /= np.sum(p) end.append(np.random.choice(x, 1, p=p)[0]) end = np.array(end).astype(np.int) end[self.categorical] = start[self.categorical] # don't change categorical factors s.a. shape # make sure there is at least one change if np.sum(abs(start - end)) == 0: ind = np.random.choice(np.arange(n_factors)[~self.categorical], 1)[0] # don't change categorical factors x = np.arange(self.factor_sizes[ind]) p = laplace.pdf(x, loc=start[ind], scale=np.log(self.factor_sizes[ind]) / rate) p[x == start[ind]] = 0 p /= np.sum(p) end[ind] = np.random.choice(x, 1, p=p) assert np.sum(abs(start - end)) > 0 return end class IndexManger(object): """Index mapping from features to positions of state space atoms.""" def __init__(self, factor_sizes): """Index to latent (= features) space and vice versa. Args: factor_sizes: List of integers with the number of distinct values for each of the factors. """ self.factor_sizes = np.array(factor_sizes) self.num_total = np.prod(self.factor_sizes) self.factor_bases = self.num_total / np.cumprod(self.factor_sizes) self.index_to_feat = cartesian([np.array(list(range(i))) for i in self.factor_sizes]) def features_to_index(self, features): """Returns the indices in the input space for given factor configurations. Args: features: Numpy matrix where each row contains a different factor configuration for which the indices in the input space should be returned. """ assert np.all((0 <= features) & (features <= self.factor_sizes)) index = np.array(np.dot(features, self.factor_bases), dtype=np.int64) assert np.all((0 <= index) & (index < self.num_total)) return index def index_to_features(self, index): assert np.all((0 <= index) & (index < self.num_total)) features = self.index_to_feat[index] assert np.all((0 <= features) & (features <= self.factor_sizes)) return features class Cars3D(TupleLoader): fname = 'nips2015-analogy-data.tar.gz' url = 'http://www.scottreed.info/files/nips2015-analogy-data.tar.gz' """ [4, 24, 183] 0. phi altitude viewpoint 1. theta azimuth viewpoint 2. car type """ def __init__(self, path='./data/cars/', data=None, **tupel_loader_kwargs): super().__init__(**tupel_loader_kwargs) self.factor_sizes = [4, 24, 183] self.num_factors = len(self.factor_sizes) self.categorical = np.array([False, False, True]) self.data_shape = [64, 64, 3] self.index_manager = IndexManger(self.factor_sizes) # download automatically if not exists if not os.path.exists(path): self.download_data(path) if data is None: all_files = glob.glob(path + '/*.mat') self.data = np.moveaxis(self._load_data(all_files).astype(np.float32), 3, 1) else: # speedup for debugging self.data = data def _load_data(self, all_files): def _load_mesh(filename): """Parses a single source file and rescales contained images.""" with open(os.path.join(filename), "rb") as f: mesh = np.einsum("abcde->deabc", sio.loadmat(f)["im"]) flattened_mesh = mesh.reshape((-1,) + mesh.shape[2:]) rescaled_mesh = np.zeros((flattened_mesh.shape[0], 64, 64, 3)) for i in range(flattened_mesh.shape[0]): pic = Image.fromarray(flattened_mesh[i, :, :, :]) pic.thumbnail((64, 64), Image.ANTIALIAS) rescaled_mesh[i, :, :, :] = np.array(pic) return rescaled_mesh * 1. / 255 dataset = np.zeros((24 * 4 * 183, 64, 64, 3)) for i, filename in enumerate(all_files): data_mesh = _load_mesh(filename) factor1 = np.array(list(range(4))) factor2 = np.array(list(range(24))) all_factors = np.transpose([np.tile(factor1, len(factor2)), np.repeat(factor2, len(factor1)), np.tile(i, len(factor1) * len(factor2))]) indexes = self.index_manager.features_to_index(all_factors) dataset[indexes] = data_mesh return dataset def download_data(self, load_path='./data/cars/'): os.makedirs(load_path, exist_ok=True) print('downlading data may take a couple of seconds, total ~ 300MB') request.urlretrieve(self.url, os.path.join(load_path, self.fname)) print('extracting data, do NOT interrupt') tar = tarfile.open(os.path.join(load_path, self.fname), "r:gz") tar.extractall() tar.close() print('saved data at', load_path) class SmallNORB(TupleLoader): """`MNIST <https://cs.nyu.edu/~ylclab/data/norb-v1.0-small//>`_ Dataset. factors: [5, 10, 9, 18, 6] - 0. (0 to 4) 0 for animal, 1 for human, 2 for plane, 3 for truck, 4 for car). - 1. the instance in the category (0 to 9) - 2. the elevation (0 to 8, which mean cameras are 30, 35,40,45,50,55,60,65,70 degrees from the horizontal respectively) - 3. the azimuth (0,2,4,...,34, multiply by 10 to get the azimuth in degrees) - 4. the lighting condition (0 to 5) """ dataset_root = "https://cs.nyu.edu/~ylclab/data/norb-v1.0-small/" data_files = { 'train': { 'dat': { "name": 'smallnorb-5x46789x9x18x6x2x96x96-training-dat.mat', "md5_gz": "66054832f9accfe74a0f4c36a75bc0a2", "md5": "8138a0902307b32dfa0025a36dfa45ec" }, 'info': { "name": 'smallnorb-5x46789x9x18x6x2x96x96-training-info.mat', "md5_gz": "51dee1210a742582ff607dfd94e332e3", "md5": "19faee774120001fc7e17980d6960451" }, 'cat': { "name": 'smallnorb-5x46789x9x18x6x2x96x96-training-cat.mat', "md5_gz": "23c8b86101fbf0904a000b43d3ed2fd9", "md5": "fd5120d3f770ad57ebe620eb61a0b633" }, }, 'test': { 'dat': { "name": 'smallnorb-5x01235x9x18x6x2x96x96-testing-dat.mat', "md5_gz": "e4ad715691ed5a3a5f138751a4ceb071", "md5": "e9920b7f7b2869a8f1a12e945b2c166c" }, 'info': { "name": 'smallnorb-5x01235x9x18x6x2x96x96-testing-info.mat', "md5_gz": "a9454f3864d7fd4bb3ea7fc3eb84924e", "md5": "7c5b871cc69dcadec1bf6a18141f5edc" }, 'cat': { "name": 'smallnorb-5x01235x9x18x6x2x96x96-testing-cat.mat', "md5_gz": "5aa791cd7e6016cf957ce9bdb93b8603", "md5": "fd5120d3f770ad57ebe620eb61a0b633" }, }, } raw_folder = 'raw' processed_folder = 'processed' train_image_file = 'train_img' train_label_file = 'train_label' train_info_file = 'train_info' test_image_file = 'test_img' test_label_file = 'test_label' test_info_file = 'test_info' extension = '.pt' def __init__(self, path='./data/smallNORB/', download=True, mode="all", transform=None, evaluate=False, **tupel_loader_kwargs): super().__init__(**tupel_loader_kwargs) self.root = os.path.expanduser(path) self.mode = mode self.evaluate = evaluate self.factor_sizes = [5, 10, 9, 18, 6] self.latent_factor_indices = [0, 2, 3, 4] self.num_factors = len(self.latent_factor_indices) self.categorical = np.array([True, True, False, False, False]) self.index_manager = IndexManger(self.factor_sizes) if transform: self.transform = transform else: self.transform = transforms.Compose([ transforms.ToPILImage(), transforms.Resize((64, 64), interpolation=2), transforms.ToTensor(), lambda x: x.numpy()]) if download: self.download() if not self._check_exists(): raise RuntimeError('Dataset not found or corrupted.' + ' You can use download=True to download it') # load labels labels_train = self._load(self.train_label_file) labels_test = self._load(self.test_label_file) # load info files infos_train = self._load(self.train_info_file) infos_test = self._load(self.test_info_file) # load right set data_train = self._load("{}_left".format(self.train_image_file)) data_test = self._load("{}_left".format(self.test_image_file)) info_train = torch.cat([labels_train[:, None], infos_train], dim=1) info_test = torch.cat([labels_test[:, None], infos_test], dim=1) infos = torch.cat([info_train, info_test]) data = torch.cat([data_train, data_test]) sorted_inds = np.lexsort([infos[:, i] for i in range(4, -1, -1)]) self.infos = infos[sorted_inds] self.data = data[sorted_inds].numpy() # is uint8 def sample_factors(self, num, random_state): # override super to ignore instance (see https://github.com/google-research/disentanglement_lib/blob/86a644d4ed35c771560dc3360756363d35477357/disentanglement_lib/data/ground_truth/norb.py#L52) factors = super().sample_factors(num, random_state) if self.evaluate: factors = np.concatenate([factors[:, :1], factors[:, 2:]], 1) return factors def sample_observations_from_factors(self, factors, random_state): # override super to ignore instance (see https://github.com/google-research/disentanglement_lib/blob/86a644d4ed35c771560dc3360756363d35477357/disentanglement_lib/data/ground_truth/norb.py#L52) if self.evaluate: instances = random_state.randint(0, self.factor_sizes[1], factors[:, :1].shape) factors = np.concatenate([factors[:, :1], instances, factors[:, 1:]], 1) return super().sample_observations_from_factors(factors, random_state) def __len__(self): return len(self.data) def _transform(self, img): # doing this so that it is consistent with all other data sets # to return a PIL Image img = Image.fromarray(img.numpy(), mode='L') if self.transform is not None: img = self.transform(img) return img def _load(self, file_name): return torch.load(os.path.join(self.root, self.processed_folder, file_name + self.extension)) def _save(self, file, file_name): with open(os.path.join(self.root, self.processed_folder, file_name + self.extension), 'wb') as f: torch.save(file, f) def _check_exists(self): """ Check if processed files exists.""" files = ( "{}_left".format(self.train_image_file), "{}_right".format(self.train_image_file), "{}_left".format(self.test_image_file), "{}_right".format(self.test_image_file), self.test_label_file, self.train_label_file ) fpaths = [os.path.exists(os.path.join(self.root, self.processed_folder, f + self.extension)) for f in files] return False not in fpaths def _flat_data_files(self): return [j for i in self.data_files.values() for j in list(i.values())] def _check_integrity(self): """Check if unpacked files have correct md5 sum.""" root = self.root for file_dict in self._flat_data_files(): filename = file_dict["name"] md5 = file_dict["md5"] fpath = os.path.join(root, self.raw_folder, filename) if not check_integrity(fpath, md5): return False return True def download(self): """Download the SmallNORB data if it doesn't exist in processed_folder already.""" import gzip if self._check_exists(): return # check if already extracted and verified if self._check_integrity(): print('Files already downloaded and verified') else: # download and extract for file_dict in self._flat_data_files(): url = self.dataset_root + file_dict["name"] + '.gz' filename = file_dict["name"] gz_filename = filename + '.gz' md5 = file_dict["md5_gz"] fpath = os.path.join(self.root, self.raw_folder, filename) gz_fpath = fpath + '.gz' # download if compressed file not exists and verified download_url(url, os.path.join(self.root, self.raw_folder), gz_filename, md5) print('# Extracting data {}\n'.format(filename)) with open(fpath, 'wb') as out_f, \ gzip.GzipFile(gz_fpath) as zip_f: out_f.write(zip_f.read()) os.unlink(gz_fpath) # process and save as torch files print('Processing...') # create processed folder try: os.makedirs(os.path.join(self.root, self.processed_folder)) except OSError as e: if e.errno == errno.EEXIST: pass else: raise # read train files left_train_img, right_train_img = self._read_image_file(self.data_files["train"]["dat"]["name"]) train_info = self._read_info_file(self.data_files["train"]["info"]["name"]) train_label = self._read_label_file(self.data_files["train"]["cat"]["name"]) # read test files left_test_img, right_test_img = self._read_image_file(self.data_files["test"]["dat"]["name"]) test_info = self._read_info_file(self.data_files["test"]["info"]["name"]) test_label = self._read_label_file(self.data_files["test"]["cat"]["name"]) # save training files self._save(left_train_img, "{}_left".format(self.train_image_file)) self._save(right_train_img, "{}_right".format(self.train_image_file)) self._save(train_label, self.train_label_file) self._save(train_info, self.train_info_file) # save test files self._save(left_test_img, "{}_left".format(self.test_image_file)) self._save(right_test_img, "{}_right".format(self.test_image_file)) self._save(test_label, self.test_label_file) self._save(test_info, self.test_info_file) print('Done!') @staticmethod def _parse_header(file_pointer): # Read magic number and ignore struct.unpack('<BBBB', file_pointer.read(4)) # '<' is little endian) # Read dimensions dimensions = [] num_dims, = struct.unpack('<i', file_pointer.read(4)) # '<' is little endian) for _ in range(num_dims): dimensions.extend(struct.unpack('<i', file_pointer.read(4))) return dimensions def _read_image_file(self, file_name): fpath = os.path.join(self.root, self.raw_folder, file_name) with open(fpath, mode='rb') as f: dimensions = self._parse_header(f) assert dimensions == [24300, 2, 96, 96] num_samples, _, height, width = dimensions left_samples = np.zeros(shape=(num_samples, height, width), dtype=np.uint8) right_samples = np.zeros(shape=(num_samples, height, width), dtype=np.uint8) for i in range(num_samples): # left and right images stored in pairs, left first left_samples[i, :, :] = self._read_image(f, height, width) right_samples[i, :, :] = self._read_image(f, height, width) return torch.ByteTensor(left_samples), torch.ByteTensor(right_samples) @staticmethod def _read_image(file_pointer, height, width): """Read raw image data and restore shape as appropriate. """ image = struct.unpack('<' + height * width * 'B', file_pointer.read(height * width)) image = np.uint8(np.reshape(image, newshape=(height, width))) return image def _read_label_file(self, file_name): fpath = os.path.join(self.root, self.raw_folder, file_name) with open(fpath, mode='rb') as f: dimensions = self._parse_header(f) assert dimensions == [24300] num_samples = dimensions[0] struct.unpack('<BBBB', f.read(4)) # ignore this integer struct.unpack('<BBBB', f.read(4)) # ignore this integer labels = np.zeros(shape=num_samples, dtype=np.int32) for i in range(num_samples): category, = struct.unpack('<i', f.read(4)) labels[i] = category return torch.LongTensor(labels) def _read_info_file(self, file_name): fpath = os.path.join(self.root, self.raw_folder, file_name) with open(fpath, mode='rb') as f: dimensions = self._parse_header(f) assert dimensions == [24300, 4] num_samples, num_info = dimensions struct.unpack('<BBBB', f.read(4)) # ignore this integer infos = np.zeros(shape=(num_samples, num_info), dtype=np.int32) for r in range(num_samples): for c in range(num_info): info, = struct.unpack('<i', f.read(4)) infos[r, c] = info return torch.LongTensor(infos) class Shapes3D(TupleLoader): """Shapes3D dataset. self.factor_sizes = [10, 10, 10, 8, 4, 15] The data set was originally introduced in "Disentangling by Factorising". The ground-truth factors of variation are: 0 - floor color (10 different values) 1 - wall color (10 different values) 2 - object color (10 different values) 3 - object size (8 different values) 4 - object type (4 different values) 5 - azimuth (15 different values) """ #url = 'https://liquidtelecom.dl.sourceforge.net/project/shapes3d/Shapes3D.zip' #fname = 'shapes3d.pkl' url = 'https://storage.googleapis.com/3d-shapes/3dshapes.h5' fname = '3dshapes.h5' def __init__(self, path='./data/shapes3d/', data=None, **tupel_loader_kwargs): super().__init__(**tupel_loader_kwargs) self.factor_sizes = [10, 10, 10, 8, 4, 15] self.num_factors = len(self.factor_sizes) self.categorical = np.array([False, False, False, False, True, False]) self.index_manager = IndexManger(self.factor_sizes) self.path = path if not os.path.exists(self.path): self.download() # read dataset print('init of shapes dataset (takes a couple of seconds) (large data array)') if data is None: with h5py.File(os.path.join(self.path, self.fname), 'r') as dataset: images = dataset['images'][()] self.data = np.transpose(images, (0, 3, 1, 2)) # np.uint8 else: self.data = data def download(self): print('downloading shapes3d') os.makedirs(self.path, exist_ok=True) request.urlretrieve(self.url, os.path.join(self.path, self.fname)) class SpriteDataset(TupleLoader): """ A PyTorch wrapper for the dSprites dataset by Matthey et al. 2017. The dataset provides a 2D scene with a sprite under different transformations: # dim, type, #values avail.-range * 0, color | 1 | 1-1 * 1, shape | 3 | 1-3 * 2, scale | 6 | 0.5-1. * 3, orientation | 40 | 0-2pi * 4, x-position | 32 | 0-1 * 5, y-position | 32 | 0-1 for details see https://github.com/deepmind/dsprites-dataset """ def __init__(self, path='./data/dsprites/', **tupel_loader_kwargs): super().__init__(**tupel_loader_kwargs) url = "https://github.com/deepmind/dsprites-dataset/raw/master/dsprites_ndarray_co1sh3sc6or40x32y32_64x64.npz" self.path = path self.factor_sizes = [3, 6, 40, 32, 32] self.num_factors = len(self.factor_sizes) self.categorical = np.array([True, False, False, False, False]) self.index_manager = IndexManger(self.factor_sizes) try: self.data = self.load_data() except FileNotFoundError: if not os.path.exists(path): os.makedirs(path, exist_ok=True) print( f'downloading dataset ... saving to {os.path.join(path, "dsprites.npz")}') request.urlretrieve(url, os.path.join(path, 'dsprites.npz')) self.data = self.load_data() def __len__(self): return len(self.data) def load_data(self): dataset_zip = np.load(os.path.join(self.path, 'dsprites.npz'), encoding="latin1", allow_pickle=True) return dataset_zip["imgs"].squeeze().astype(np.float32) class MPI3DReal(TupleLoader): """ object_color white=0, green=1, red=2, blue=3, brown=4, olive=5 object_shape cone=0, cube=1, cylinder=2, hexagonal=3, pyramid=4, sphere=5 object_size small=0, large=1 camera_height top=0, center=1, bottom=2 background_color purple=0, sea green=1, salmon=2 horizontal_axis 0,...,39 vertical_axis 0,...,39 """ url = 'https://storage.googleapis.com/disentanglement_dataset/Final_Dataset/mpi3d_real.npz' fname = 'mpi3d_real.npz' def __init__(self, path='./data/mpi3d_real/', **tupel_loader_kwargs): super().__init__(**tupel_loader_kwargs) self.factor_sizes = [6, 6, 2, 3, 3, 40, 40] self.num_factors = len(self.factor_sizes) self.categorical = np.array([False, True, False, False, False, False, False]) self.index_manager = IndexManger(self.factor_sizes) if not os.path.exists(path): self.download(path) load_path = os.path.join(path, self.fname) data = np.load(load_path)['images'] self.data = np.transpose(data.reshape([-1, 64, 64, 3]), (0, 3, 1, 2)) # np.uint8 def download(self, path): os.makedirs(path, exist_ok=True) print('downloading') request.urlretrieve(self.url, os.path.join(path, self.fname)) print('download complete') def value_to_key(x, val): for k in x.keys(): if x[k] == val: return k def rgb(c): return tuple((255 * np.array(c)).astype(np.uint8)) class NaturalSprites(Dataset): def __init__(self, natural_discrete=False, path='./data/natural_sprites/'): self.natural_discrete = natural_discrete self.sequence_len = 2 #only consider pairs self.area_filter = 0.1 #filter out 10% of outliers self.path = path self.fname = 'downscale_keepaspect.csv' self.url = 'https://zenodo.org/record/3948069/files/downscale_keepaspect.csv?download=1' self.load_data() def load_data(self): # download if not avaiable file_path = os.path.join(self.path, self.fname) if not os.path.exists(file_path): os.makedirs(self.path, exist_ok=True) print(f'file not found, downloading from {self.url} ...') from urllib import request url = self.url request.urlretrieve(url, file_path) with open(file_path) as data: self.csv_dict = load_csv(data, sequence=self.sequence_len) self.orig_num = [32, 32, 6, 40, 4, 1, 1, 1] self.dsprites = {'x': np.linspace(0.2,0.8,self.orig_num[0]), 'y': np.linspace(0.2,0.8,self.orig_num[1]), 'scale': np.linspace(0,0.5,self.orig_num[2]+1)[1:], 'angle': np.linspace(0,360,self.orig_num[3],dtype=np.int,endpoint=False), 'shape': ['square', 'triangle', 'star_4', 'spoke_4'], 'c0': [1.], 'c1': [1.], 'c2': [1.]} distributions = [] for key in self.dsprites.keys(): distributions.append(distribs.Discrete(key, self.dsprites[key])) self.factor_dist = distribs.Product(distributions) self.renderer = spriteworld_renderers.PILRenderer(image_size=(64, 64), anti_aliasing=5, color_to_rgb=rgb) if self.area_filter: keep_idxes = [] print(len(self.csv_dict['x'])) for i in range(self.sequence_len): x = pd.Series(np.array(self.csv_dict['area'])[:,i]) keep_idxes.append(x.between(x.quantile(self.area_filter/2), x.quantile(1-(self.area_filter/2)))) for k in self.csv_dict.keys(): y =
pd.Series(self.csv_dict[k])
pandas.Series
from pathlib import Path from multiprocessing import Pool from opencadd.databases.klifs import setup_remote import pandas as pd CACHE_DIR = Path("../data/.cache") CACHE_DIR.mkdir(parents=True, exist_ok=True) def read_klifs_ligand(structure_id: int, directory): """Retrieve and read an orthosteric kinase ligand from KLIFS.""" from pathlib import Path from kinoml.modeling.OEModeling import read_molecules from kinoml.utils import LocalFileStorage file_path = LocalFileStorage.klifs_ligand_mol2(structure_id, Path(directory)) if not file_path.is_file(): from opencadd.databases.klifs import setup_remote remote = setup_remote() try: mol2_text = remote.coordinates.to_text(structure_id, entity="ligand", extension="mol2") except ValueError: print(f"Unable to fetch ligand coordinates of structure with KLIFS ID {structure_id}.") return None with open(file_path, "w") as wf: wf.write(mol2_text) molecule = read_molecules(file_path)[0] return molecule def count_ligands(pdb_id, chain_id, expo_id, directory): """Count the ligands in the given PDB entry.""" from openeye import oechem from kinoml.modeling.OEModeling import read_molecules, select_chain, remove_non_protein from kinoml.databases.pdb import download_pdb_structure structure_path = download_pdb_structure(pdb_id, directory) if pdb_id: structure = read_molecules(structure_path)[0] else: raise ValueError(f"Could not download PDB entry {pdb_id}!") structure = select_chain(structure, chain_id) structure = remove_non_protein(structure, exceptions=[expo_id]) hierview = oechem.OEHierView(structure) count = sum([1 for residue in hierview.GetResidues() if residue.GetResidueName() == expo_id]) return count def get_docking_template(structure, docking_templates, cache_dir): """Get most similar docking template in the same conformation excluding itself.""" from kinoml.modeling.OEModeling import ( read_smiles, generate_reasonable_conformations, overlay_molecules ) # filter for conformation docking_templates = docking_templates[ docking_templates["structure.dfg"] == structure["structure.dfg"] ] docking_templates = docking_templates[ docking_templates["structure.ac_helix"] == structure["structure.ac_helix"] ] # remove itself docking_templates = docking_templates[ docking_templates["structure.pdb_id"] != structure["structure.pdb_id"] ] # find entry with most similar ligand complex_ligands = [ read_klifs_ligand(structure_id, cache_dir) for structure_id in docking_templates["structure.klifs_id"] ] complex_ligands = [complex_ligand for complex_ligand in complex_ligands if complex_ligand] conformations_ensemble = generate_reasonable_conformations(read_smiles(structure["smiles"])) overlay_scores = [] for conformations in conformations_ensemble: overlay_scores += [ [i, overlay_molecules(complex_ligand, conformations)[0]] for i, complex_ligand in enumerate(complex_ligands) ] docking_template_index, docking_template_similarity = sorted( overlay_scores, key=lambda x: x[1], reverse=True )[0] docking_template = docking_templates.iloc[docking_template_index] # return dictionary with key pdb_id_expo_id and dictionary as value with docking template # pdb_id, expo_id and chain_id docking_template_dict = { f"{structure['structure.pdb_id']}_{structure['ligand.expo_id']}" : { "docking_template_pdb_id": docking_template["structure.pdb_id"], "docking_template_chain_id": docking_template["structure.chain"], "docking_template_expo_id": docking_template["ligand.expo_id"], "docking_template_similarity": docking_template_similarity, } } return docking_template_dict if __name__ == "__main__": print("Reading benchmark dataframe ...") structures = pd.read_csv("../data/docking_benchmark_dataset.csv") print("Retrieving available docking templates ...") remote = setup_remote() docking_templates = remote.structures.all_structures() print("Filtering available docking templates") # orthosteric ligand docking_templates = docking_templates[ docking_templates["ligand.expo_id"] != "-" ] # single orthosteric ligand docking_templates = docking_templates.groupby("structure.pdb_id").filter( lambda x: len(set(x["ligand.expo_id"])) == 1 ) # remove structures with ligands not handled by oespruce docking_templates = docking_templates[docking_templates["ligand.expo_id"] != "A"] # sort by quality docking_templates = docking_templates.sort_values( by=[ "structure.qualityscore", "structure.resolution", "structure.chain", "structure.alternate_model" ], ascending=[False, True, True, True] ) # keep highest quality structure per PDB ID docking_templates = docking_templates.groupby("structure.pdb_id").head(1) # remove structues with multiple instances of the same ligand multiple_ligands_indices = [] erroneous_indices = [] for index, structure in docking_templates.iterrows(): try: if count_ligands(structure["structure.pdb_id"], structure["structure.chain"], structure["ligand.expo_id"], CACHE_DIR) > 1: multiple_ligands_indices.append(index) except ValueError: print("Error counting ligands:") print( structure["structure.pdb_id"], structure["structure.chain"], structure["ligand.expo_id"] ) erroneous_indices.append(index) docking_templates = docking_templates[~docking_templates.index.isin(multiple_ligands_indices)] docking_templates = docking_templates[~docking_templates.index.isin(erroneous_indices)] print("Downloading ligand structures of filtered docking templates ...") unavailable_ligand_indices = [] for index, docking_template in docking_templates.iterrows(): if not read_klifs_ligand(docking_template["structure.klifs_id"], CACHE_DIR): unavailable_ligand_indices.append(index) docking_templates = docking_templates[~docking_templates.index.isin(unavailable_ligand_indices)] print("Getting docking templates ...") with Pool(processes=50) as pool: results = pool.starmap( get_docking_template, [(structure, docking_templates, CACHE_DIR) for i, structure in structures.iterrows()] ) print("Merging and saving results ...") results_merged = {} for result in results: results_merged.update(result) results_merged =
pd.DataFrame.from_dict(results_merged, orient="index")
pandas.DataFrame.from_dict
import numpy as np import pandas as pd from sklearn.model_selection import train_test_split from sklearn.base import BaseEstimator, TransformerMixin from sklearn.pipeline import Pipeline from sklearn.compose import ColumnTransformer from sklearn.preprocessing import OneHotEncoder, MinMaxScaler, OrdinalEncoder from sklearn.ensemble import GradientBoostingClassifier from imblearn.over_sampling import SMOTE #from secret import access_key, secret_access_key import joblib import streamlit as st import boto3 import tempfile import json import requests from streamlit_lottie import st_lottie_spinner train_original = pd.read_csv('https://raw.githubusercontent.com/semasuka/Credit-card-approval-prediction-classification/main/datasets/train.csv') test_original = pd.read_csv('https://raw.githubusercontent.com/semasuka/Credit-card-approval-prediction-classification/main/datasets/test.csv') full_data = pd.concat([train_original, test_original], axis=0) full_data = full_data.sample(frac=1).reset_index(drop=True) def data_split(df, test_size): train_df, test_df = train_test_split(df, test_size=test_size, random_state=42) return train_df.reset_index(drop=True), test_df.reset_index(drop=True) train_original, test_original = data_split(full_data, 0.2) train_copy = train_original.copy() test_copy = test_original.copy() def value_cnt_norm_cal(df,feature): ''' Function to calculate the count of each value in a feature and normalize it ''' ftr_value_cnt = df[feature].value_counts() ftr_value_cnt_norm = df[feature].value_counts(normalize=True) * 100 ftr_value_cnt_concat = pd.concat([ftr_value_cnt, ftr_value_cnt_norm], axis=1) ftr_value_cnt_concat.columns = ['Count', 'Frequency (%)'] return ftr_value_cnt_concat class OutlierRemover(BaseEstimator, TransformerMixin): def __init__(self,feat_with_outliers = ['Family member count','Income', 'Employment length']): self.feat_with_outliers = feat_with_outliers def fit(self,df): return self def transform(self,df): if (set(self.feat_with_outliers).issubset(df.columns)): # 25% quantile Q1 = df[self.feat_with_outliers].quantile(.25) # 75% quantile Q3 = df[self.feat_with_outliers].quantile(.75) IQR = Q3 - Q1 # keep the data within 1.5 IQR df = df[~((df[self.feat_with_outliers] < (Q1 - 3 * IQR)) |(df[self.feat_with_outliers] > (Q3 + 3 * IQR))).any(axis=1)] return df else: print("One or more features are not in the dataframe") return df class DropFeatures(BaseEstimator,TransformerMixin): def __init__(self,feature_to_drop = ['Has a mobile phone','Children count','Job title','Account age']): self.feature_to_drop = feature_to_drop def fit(self,df): return self def transform(self,df): if (set(self.feature_to_drop).issubset(df.columns)): df.drop(self.feature_to_drop,axis=1,inplace=True) return df else: print("One or more features are not in the dataframe") return df class TimeConversionHandler(BaseEstimator, TransformerMixin): def __init__(self, feat_with_days = ['Employment length', 'Age']): self.feat_with_days = feat_with_days def fit(self, X, y=None): return self def transform(self, X, y=None): if (set(self.feat_with_days).issubset(X.columns)): # convert days to absolute value X[['Employment length','Age']] = np.abs(X[['Employment length','Age']]) return X else: print("One or more features are not in the dataframe") return X class RetireeHandler(BaseEstimator, TransformerMixin): def __init__(self): pass def fit(self, df): return self def transform(self, df): if 'Employment length' in df.columns: # select rows with employment length is 365243 which corresponds to retirees df_ret_idx = df['Employment length'][df['Employment length'] == 365243].index # change 365243 to 0 df.loc[df_ret_idx,'Employment length'] = 0 return df else: print("Employment length is not in the dataframe") return df class SkewnessHandler(BaseEstimator, TransformerMixin): def __init__(self,feat_with_skewness=['Income','Age']): self.feat_with_skewness = feat_with_skewness def fit(self,df): return self def transform(self,df): if (set(self.feat_with_skewness).issubset(df.columns)): # Handle skewness with cubic root transformation df[self.feat_with_skewness] = np.cbrt(df[self.feat_with_skewness]) return df else: print("One or more features are not in the dataframe") return df class BinningNumToYN(BaseEstimator, TransformerMixin): def __init__(self,feat_with_num_enc=['Has a work phone','Has a phone','Has an email']): self.feat_with_num_enc = feat_with_num_enc def fit(self,df): return self def transform(self,df): if (set(self.feat_with_num_enc).issubset(df.columns)): # Change 0 to N and 1 to Y for all the features in feat_with_num_enc for ft in self.feat_with_num_enc: df[ft] = df[ft].map({1:'Y',0:'N'}) return df else: print("One or more features are not in the dataframe") return df class OneHotWithFeatNames(BaseEstimator,TransformerMixin): def __init__(self,one_hot_enc_ft = ['Gender', 'Marital status', 'Dwelling', 'Employment status', 'Has a car', 'Has a property', 'Has a work phone', 'Has a phone', 'Has an email']): self.one_hot_enc_ft = one_hot_enc_ft def fit(self,df): return self def transform(self,df): if (set(self.one_hot_enc_ft).issubset(df.columns)): # function to one hot encode the features in one_hot_enc_ft def one_hot_enc(df,one_hot_enc_ft): one_hot_enc = OneHotEncoder() one_hot_enc.fit(df[one_hot_enc_ft]) # get the result of the one hot encoding columns names feat_names_one_hot_enc = one_hot_enc.get_feature_names_out(one_hot_enc_ft) # change the array of the one hot encoding to a dataframe with the column names df = pd.DataFrame(one_hot_enc.transform(df[self.one_hot_enc_ft]).toarray(),columns=feat_names_one_hot_enc,index=df.index) return df # function to concatenat the one hot encoded features with the rest of features that were not encoded def concat_with_rest(df,one_hot_enc_df,one_hot_enc_ft): # get the rest of the features rest_of_features = [ft for ft in df.columns if ft not in one_hot_enc_ft] # concatenate the rest of the features with the one hot encoded features df_concat = pd.concat([one_hot_enc_df, df[rest_of_features]],axis=1) return df_concat # one hot encoded dataframe one_hot_enc_df = one_hot_enc(df,self.one_hot_enc_ft) # returns the concatenated dataframe full_df_one_hot_enc = concat_with_rest(df,one_hot_enc_df,self.one_hot_enc_ft) print(full_df_one_hot_enc.tail(25)) return full_df_one_hot_enc else: print("One or more features are not in the dataframe") return df class OrdinalFeatNames(BaseEstimator,TransformerMixin): def __init__(self,ordinal_enc_ft = ['Education level']): self.ordinal_enc_ft = ordinal_enc_ft def fit(self,df): return self def transform(self,df): if 'Education level' in df.columns: ordinal_enc = OrdinalEncoder() df[self.ordinal_enc_ft] = ordinal_enc.fit_transform(df[self.ordinal_enc_ft]) return df else: print("Education level is not in the dataframe") return df class MinMaxWithFeatNames(BaseEstimator,TransformerMixin): def __init__(self,min_max_scaler_ft = ['Age', 'Income', 'Employment length']): self.min_max_scaler_ft = min_max_scaler_ft def fit(self,df): return self def transform(self,df): if (set(self.min_max_scaler_ft).issubset(df.columns)): min_max_enc = MinMaxScaler() df[self.min_max_scaler_ft] = min_max_enc.fit_transform(df[self.min_max_scaler_ft]) return df else: print("One or more features are not in the dataframe") return df class ChangeToNumTarget(BaseEstimator,TransformerMixin): def __init__(self): pass def fit(self,df): return self def transform(self,df): if 'Is high risk' in df.columns: df['Is high risk'] = pd.to_numeric(df['Is high risk']) return df else: print("Is high risk is not in the dataframe") return df class OversampleSMOTE(BaseEstimator,TransformerMixin): def __init__(self): pass def fit(self,df): return self def transform(self,df): if 'Is high risk' in df.columns: # SMOTE function to oversample the minority class to fix the imbalance data smote = SMOTE() X_bal, y_bal = smote.fit_resample(df.iloc[:,:-1],df.iloc[:,-1]) X_y_bal = pd.concat([pd.DataFrame(X_bal),
pd.DataFrame(y_bal)
pandas.DataFrame
import bz2 from collections import Counter from contextlib import contextmanager from datetime import datetime from functools import wraps import gzip import operator import os import re import string from typing import ( Any, Callable, ContextManager, List, Optional, Sequence, Tuple, Type, Union, cast, ) import warnings import zipfile import numpy as np from pandas._config.localization import ( # noqa:F401 can_set_locale, get_locales, set_locale, ) from pandas._typing import Dtype, FilePathOrBuffer, FrameOrSeries from pandas.compat import get_lzma_file, import_lzma from pandas.core.dtypes.common import ( is_datetime64_dtype, is_datetime64tz_dtype, is_period_dtype, is_sequence, is_timedelta64_dtype, ) import pandas as pd from pandas import ( Categorical, CategoricalIndex, DataFrame, DatetimeIndex, Index, IntervalIndex, MultiIndex, RangeIndex, Series, bdate_range, ) from pandas._testing.asserters import ( # noqa:F401 assert_almost_equal, assert_attr_equal, assert_categorical_equal, assert_class_equal, assert_contains_all, assert_copy, assert_datetime_array_equal, assert_dict_equal, assert_equal, assert_extension_array_equal, assert_frame_equal, assert_index_equal, assert_interval_array_equal, assert_is_sorted, assert_is_valid_plot_return_object, assert_numpy_array_equal, assert_period_array_equal, assert_series_equal, assert_sp_array_equal, assert_timedelta_array_equal, raise_assert_detail, ) from pandas._testing.contexts import ( # noqa:F401 decompress_file, ensure_clean, ensure_clean_dir, ensure_safe_environment_variables, set_timezone, use_numexpr, with_csv_dialect, ) from pandas.core.arrays import DatetimeArray, PeriodArray, TimedeltaArray, period_array from pandas.io.common import urlopen lzma = import_lzma() _N = 30 _K = 4 _RAISE_NETWORK_ERROR_DEFAULT = False UNSIGNED_INT_DTYPES: List[Dtype] = ["uint8", "uint16", "uint32", "uint64"] UNSIGNED_EA_INT_DTYPES: List[Dtype] = ["UInt8", "UInt16", "UInt32", "UInt64"] SIGNED_INT_DTYPES: List[Dtype] = [int, "int8", "int16", "int32", "int64"] SIGNED_EA_INT_DTYPES: List[Dtype] = ["Int8", "Int16", "Int32", "Int64"] ALL_INT_DTYPES = UNSIGNED_INT_DTYPES + SIGNED_INT_DTYPES ALL_EA_INT_DTYPES = UNSIGNED_EA_INT_DTYPES + SIGNED_EA_INT_DTYPES FLOAT_DTYPES: List[Dtype] = [float, "float32", "float64"] FLOAT_EA_DTYPES: List[Dtype] = ["Float32", "Float64"] COMPLEX_DTYPES: List[Dtype] = [complex, "complex64", "complex128"] STRING_DTYPES: List[Dtype] = [str, "str", "U"] DATETIME64_DTYPES: List[Dtype] = ["datetime64[ns]", "M8[ns]"] TIMEDELTA64_DTYPES: List[Dtype] = ["timedelta64[ns]", "m8[ns]"] BOOL_DTYPES = [bool, "bool"] BYTES_DTYPES = [bytes, "bytes"] OBJECT_DTYPES = [object, "object"] ALL_REAL_DTYPES = FLOAT_DTYPES + ALL_INT_DTYPES ALL_NUMPY_DTYPES = ( ALL_REAL_DTYPES + COMPLEX_DTYPES + STRING_DTYPES + DATETIME64_DTYPES + TIMEDELTA64_DTYPES + BOOL_DTYPES + OBJECT_DTYPES + BYTES_DTYPES ) NULL_OBJECTS = [None, np.nan, pd.NaT, float("nan"), pd.NA] EMPTY_STRING_PATTERN = re.compile("^$") # set testing_mode _testing_mode_warnings = (DeprecationWarning, ResourceWarning) def set_testing_mode(): # set the testing mode filters testing_mode = os.environ.get("PANDAS_TESTING_MODE", "None") if "deprecate" in testing_mode: # pandas\_testing.py:119: error: Argument 2 to "simplefilter" has # incompatible type "Tuple[Type[DeprecationWarning], # Type[ResourceWarning]]"; expected "Type[Warning]" warnings.simplefilter( "always", _testing_mode_warnings # type: ignore[arg-type] ) def reset_testing_mode(): # reset the testing mode filters testing_mode = os.environ.get("PANDAS_TESTING_MODE", "None") if "deprecate" in testing_mode: # pandas\_testing.py:126: error: Argument 2 to "simplefilter" has # incompatible type "Tuple[Type[DeprecationWarning], # Type[ResourceWarning]]"; expected "Type[Warning]" warnings.simplefilter( "ignore", _testing_mode_warnings # type: ignore[arg-type] ) set_testing_mode() def reset_display_options(): """ Reset the display options for printing and representing objects. """ pd.reset_option("^display.", silent=True) def round_trip_pickle( obj: Any, path: Optional[FilePathOrBuffer] = None ) -> FrameOrSeries: """ Pickle an object and then read it again. Parameters ---------- obj : any object The object to pickle and then re-read. path : str, path object or file-like object, default None The path where the pickled object is written and then read. Returns ------- pandas object The original object that was pickled and then re-read. """ _path = path if _path is None: _path = f"__{rands(10)}__.pickle" with ensure_clean(_path) as temp_path: pd.to_pickle(obj, temp_path) return pd.read_pickle(temp_path) def round_trip_pathlib(writer, reader, path: Optional[str] = None): """ Write an object to file specified by a pathlib.Path and read it back Parameters ---------- writer : callable bound to pandas object IO writing function (e.g. DataFrame.to_csv ) reader : callable IO reading function (e.g. pd.read_csv ) path : str, default None The path where the object is written and then read. Returns ------- pandas object The original object that was serialized and then re-read. """ import pytest Path = pytest.importorskip("pathlib").Path if path is None: path = "___pathlib___" with ensure_clean(path) as path: writer(Path(path)) obj = reader(Path(path)) return obj def round_trip_localpath(writer, reader, path: Optional[str] = None): """ Write an object to file specified by a py.path LocalPath and read it back. Parameters ---------- writer : callable bound to pandas object IO writing function (e.g. DataFrame.to_csv ) reader : callable IO reading function (e.g. pd.read_csv ) path : str, default None The path where the object is written and then read. Returns ------- pandas object The original object that was serialized and then re-read. """ import pytest LocalPath = pytest.importorskip("py.path").local if path is None: path = "___localpath___" with ensure_clean(path) as path: writer(LocalPath(path)) obj = reader(LocalPath(path)) return obj def write_to_compressed(compression, path, data, dest="test"): """ Write data to a compressed file. Parameters ---------- compression : {'gzip', 'bz2', 'zip', 'xz'} The compression type to use. path : str The file path to write the data. data : str The data to write. dest : str, default "test" The destination file (for ZIP only) Raises ------ ValueError : An invalid compression value was passed in. """ args: Tuple[Any, ...] = (data,) mode = "wb" method = "write" compress_method: Callable if compression == "zip": compress_method = zipfile.ZipFile mode = "w" args = (dest, data) method = "writestr" elif compression == "gzip": compress_method = gzip.GzipFile elif compression == "bz2": compress_method = bz2.BZ2File elif compression == "xz": compress_method = get_lzma_file(lzma) else: raise ValueError(f"Unrecognized compression type: {compression}") with compress_method(path, mode=mode) as f: getattr(f, method)(*args) def randbool(size=(), p: float = 0.5): return np.random.rand(*size) <= p RANDS_CHARS = np.array(list(string.ascii_letters + string.digits), dtype=(np.str_, 1)) RANDU_CHARS = np.array( list("".join(map(chr, range(1488, 1488 + 26))) + string.digits), dtype=(np.unicode_, 1), ) def rands_array(nchars, size, dtype="O"): """ Generate an array of byte strings. """ retval = ( np.random.choice(RANDS_CHARS, size=nchars * np.prod(size)) .view((np.str_, nchars)) .reshape(size) ) return retval.astype(dtype) def randu_array(nchars, size, dtype="O"): """ Generate an array of unicode strings. """ retval = ( np.random.choice(RANDU_CHARS, size=nchars * np.prod(size)) .view((np.unicode_, nchars)) .reshape(size) ) return retval.astype(dtype) def rands(nchars): """ Generate one random byte string. See `rands_array` if you want to create an array of random strings. """ return "".join(np.random.choice(RANDS_CHARS, nchars)) def close(fignum=None): from matplotlib.pyplot import close as _close, get_fignums if fignum is None: for fignum in get_fignums(): _close(fignum) else: _close(fignum) # ----------------------------------------------------------------------------- # Comparators def equalContents(arr1, arr2) -> bool: """ Checks if the set of unique elements of arr1 and arr2 are equivalent. """ return frozenset(arr1) == frozenset(arr2) def box_expected(expected, box_cls, transpose=True): """ Helper function to wrap the expected output of a test in a given box_class. Parameters ---------- expected : np.ndarray, Index, Series box_cls : {Index, Series, DataFrame} Returns ------- subclass of box_cls """ if box_cls is pd.array: expected = pd.array(expected) elif box_cls is pd.Index: expected = pd.Index(expected) elif box_cls is pd.Series: expected = pd.Series(expected) elif box_cls is pd.DataFrame: expected = pd.Series(expected).to_frame() if transpose: # for vector operations, we need a DataFrame to be a single-row, # not a single-column, in order to operate against non-DataFrame # vectors of the same length. expected = expected.T elif box_cls is PeriodArray: # the PeriodArray constructor is not as flexible as period_array expected = period_array(expected) elif box_cls is DatetimeArray: expected = DatetimeArray(expected) elif box_cls is TimedeltaArray: expected = TimedeltaArray(expected) elif box_cls is np.ndarray: expected = np.array(expected) elif box_cls is to_array: expected = to_array(expected) else: raise NotImplementedError(box_cls) return expected def to_array(obj): # temporary implementation until we get pd.array in place dtype = getattr(obj, "dtype", None) if is_period_dtype(dtype): return period_array(obj) elif is_datetime64_dtype(dtype) or is_datetime64tz_dtype(dtype): return DatetimeArray._from_sequence(obj) elif is_timedelta64_dtype(dtype): return TimedeltaArray._from_sequence(obj) else: return np.array(obj) # ----------------------------------------------------------------------------- # Others def getCols(k): return string.ascii_uppercase[:k] # make index def makeStringIndex(k=10, name=None): return Index(rands_array(nchars=10, size=k), name=name) def makeUnicodeIndex(k=10, name=None): return Index(randu_array(nchars=10, size=k), name=name) def makeCategoricalIndex(k=10, n=3, name=None, **kwargs): """ make a length k index or n categories """ x = rands_array(nchars=4, size=n) return CategoricalIndex( Categorical.from_codes(np.arange(k) % n, categories=x), name=name, **kwargs ) def makeIntervalIndex(k=10, name=None, **kwargs): """ make a length k IntervalIndex """ x = np.linspace(0, 100, num=(k + 1)) return IntervalIndex.from_breaks(x, name=name, **kwargs) def makeBoolIndex(k=10, name=None): if k == 1: return Index([True], name=name) elif k == 2: return Index([False, True], name=name) return Index([False, True] + [False] * (k - 2), name=name) def makeIntIndex(k=10, name=None): return Index(list(range(k)), name=name) def makeUIntIndex(k=10, name=None): return Index([2 ** 63 + i for i in range(k)], name=name) def makeRangeIndex(k=10, name=None, **kwargs): return RangeIndex(0, k, 1, name=name, **kwargs) def makeFloatIndex(k=10, name=None): values = sorted(np.random.random_sample(k)) - np.random.random_sample(1) return Index(values * (10 ** np.random.randint(0, 9)), name=name) def makeDateIndex(k=10, freq="B", name=None, **kwargs): dt = datetime(2000, 1, 1) dr = bdate_range(dt, periods=k, freq=freq, name=name) return DatetimeIndex(dr, name=name, **kwargs) def makeTimedeltaIndex(k=10, freq="D", name=None, **kwargs): return pd.timedelta_range(start="1 day", periods=k, freq=freq, name=name, **kwargs) def makePeriodIndex(k=10, name=None, **kwargs): dt = datetime(2000, 1, 1) return
pd.period_range(start=dt, periods=k, freq="B", name=name, **kwargs)
pandas.period_range
import pandas as pd from app.archive_constants import (LABEL) import warnings from pandas.core.common import SettingWithCopyWarning pd.set_option('mode.chained_assignment', None) warnings.simplefilter(action="ignore", category=SettingWithCopyWarning) def extract_cell_metdata(df_c_md): """ Build cell metadata """ df_cell_md = pd.DataFrame() df_cell_md[LABEL.CELL_ID.value] = [df_c_md[LABEL.CELL_ID.value]] df_cell_md[LABEL.ANODE.value] = [df_c_md[LABEL.ANODE.value]] df_cell_md[LABEL.CATHODE.value] = [df_c_md[LABEL.CATHODE.value]] df_cell_md[LABEL.SOURCE.value] = [df_c_md[LABEL.SOURCE.value]] df_cell_md[LABEL.AH.value] = [df_c_md[LABEL.AH.value]] df_cell_md[LABEL.FORM_FACTOR.value] = [df_c_md[LABEL.FORM_FACTOR.value]] df_cell_md[LABEL.TEST.value] = [df_c_md[LABEL.TEST.value]] # df_cell_md[LABEL.MAPPING.value] = [df_c_md[LABEL.MAPPING.value]] df_cell_md[LABEL.TESTER.value] = [df_c_md[LABEL.TESTER.value]] return df_cell_md def split_cycle_metadata(df_c_md): df_cell_md = extract_cell_metdata(df_c_md) # Build test metadata df_test_md = pd.DataFrame() df_test_md[LABEL.CELL_ID.value] = [df_c_md[LABEL.CELL_ID.value]] df_test_md[LABEL.CRATE_C.value] = [df_c_md[LABEL.CRATE_C.value]] df_test_md[LABEL.CRATE_D.value] = [df_c_md[LABEL.CRATE_D.value]] df_test_md[LABEL.SOC_MAX.value] = [df_c_md[LABEL.SOC_MAX.value]] df_test_md[LABEL.SOC_MIN.value] = [df_c_md[LABEL.SOC_MIN.value]] df_test_md[LABEL.TEMP.value] = [df_c_md[LABEL.TEMP.value]] return df_cell_md, df_test_md def split_abuse_metadata(df_c_md): df_cell_md = extract_cell_metdata(df_c_md) # Build test metadata df_test_md = pd.DataFrame() df_test_md[LABEL.CELL_ID.value] = [df_c_md[LABEL.CELL_ID.value]] df_test_md[LABEL.THICKNESS.value] = [df_c_md[LABEL.THICKNESS.value]] df_test_md[LABEL.V_INIT.value] = [df_c_md[LABEL.V_INIT.value]] df_test_md[LABEL.INDENTOR.value] = [df_c_md[LABEL.INDENTOR.value]] df_test_md[LABEL.NAIL_SPEED.value] = [df_c_md[LABEL.NAIL_SPEED.value]] df_test_md[LABEL.TEMP.value] = [df_c_md[LABEL.TEMP.value]] return df_cell_md, df_test_md # sort data imported to insure cycle index and test times are correctly calculated def sort_timeseries(df_tmerge): # Arrange the data by date time first, then by test time # Rebuild Cycle Index and test time to increment from file to file # This method does not depend on data from a specific testers if not df_tmerge.empty: df_t = df_tmerge.sort_values( by=[LABEL.DATE_TIME.value, LABEL.TEST_TIME.value]) df_t = df_t.reset_index(drop=True) cycles = df_t[[ LABEL.CYCLE_INDEX_FILE.value, LABEL.CYCLE_INDEX.value, LABEL.FILENAME.value, LABEL.TEST_TIME.value ]].to_numpy() max_cycle = 1 past_index = 1 max_time = 0 last_file = "" delta_t = 0 start = 0 for x in cycles: if start == 0: last_file = x[2] start += 1 if x[2] != last_file: delta_t = max_time x[3] += delta_t last_file = x[2] else: x[3] += delta_t max_time = x[3] last_file = x[2] if x[0] < max_cycle: if past_index == x[0]: past_index = x[0] x[1] = max_cycle else: past_index = x[0] x[1] = max_cycle + 1 max_cycle = x[1] else: past_index = x[0] max_cycle = x[0] x[1] = x[0] df_tmp = pd.DataFrame(data=cycles[:, [1]], columns=[LABEL.CYCLE_INDEX.value]) df_t[LABEL.CYCLE_INDEX.value] = df_tmp[LABEL.CYCLE_INDEX.value] df_tmp = pd.DataFrame(data=cycles[:, [3]], columns=[LABEL.TEST_TIME.value]) df_t[LABEL.TEST_TIME.value] = pd.to_numeric( df_tmp[LABEL.TEST_TIME.value]) df_ts = df_t.sort_values(by=[LABEL.TEST_TIME.value]) # Remove quantities only needed to tag files df_ts.drop(LABEL.FILENAME.value, axis=1, inplace=True) df_ts.drop(LABEL.CYCLE_INDEX_FILE.value, axis=1, inplace=True) return df_ts # calculate statistics for abuse test def calc_abuse_stats(df_t, df_test_md): for _ in df_t.index: df_t[LABEL.NORM_D.value] = df_t.iloc[ 0:, df_t.columns.get_loc(LABEL.AXIAL_D.value)] - df_t[ LABEL.AXIAL_D.value][0] df_t[LABEL.STRAIN.value] = df_t.iloc[ 0:, df_t.columns.get_loc(LABEL.NORM_D.value)] / df_test_md[ LABEL.THICKNESS.value] return df_t def calc_cycle_stats(df_t): df_t[LABEL.CYCLE_TIME.value] = 0 no_cycles = int(df_t[LABEL.CYCLE_INDEX.value].max()) # Initialize the cycle_data time frame a = [0 for _ in range(no_cycles)] # using loops df_c = pd.DataFrame(data=a, columns=[LABEL.CYCLE_INDEX.value]) df_c[LABEL.CELL_ID.value] = df_t[LABEL.CELL_ID.value] df_c[LABEL.CYCLE_INDEX.value] = 0 df_c[LABEL.V_MAX.value] = 0 df_c[LABEL.I_MAX.value] = 0 df_c[LABEL.V_MIN.value] = 0 df_c[LABEL.I_MIN.value] = 0 df_c[LABEL.AH_C.value] = 0 df_c[LABEL.AH_D.value] = 0 df_c[LABEL.E_C.value] = 0 df_c[LABEL.E_D.value] = 0 df_c[LABEL.V_C_MEAN.value] = 0 df_c[LABEL.V_D_MEAN.value] = 0 df_c[LABEL.TEST_TIME.value] = 0 df_c[LABEL.AH_EFF.value] = 0 df_c[LABEL.E_EFF.value] = 0 for c_ind in df_c.index: x = c_ind + 1 df_f = df_t[df_t[LABEL.CYCLE_INDEX.value] == x] df_f[LABEL.AH_C.value] = 0 df_f[LABEL.E_C.value] = 0 df_f[LABEL.AH_D.value] = 0 df_f[LABEL.E_D.value] = 0 if not df_f.empty: try: df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.CYCLE_INDEX.value)] = x df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.V_MAX.value)] = df_f.loc[ df_f[LABEL.V.value].idxmax()].v df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.V_MIN.value)] = df_f.loc[ df_f[LABEL.V.value].idxmin()].v df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.I_MAX.value)] = df_f.loc[ df_f[LABEL.I.value].idxmax()].i df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.I_MIN.value)] = df_f.loc[ df_f[LABEL.I.value].idxmin()].i df_c.iloc[ c_ind, df_c.columns.get_loc(LABEL.TEST_TIME.value)] = df_f.loc[ df_f[LABEL.TEST_TIME.value].idxmax()].test_time df_f[LABEL.DT.value] = df_f[LABEL.TEST_TIME.value].diff() / 3600.0 df_f_c = df_f[df_f[LABEL.I.value] > 0] df_f_d = df_f[df_f[LABEL.I.value] < 0] df_f = calc_cycle_quantities(df_f) df_t.loc[df_t.cycle_index == x, LABEL.CYCLE_TIME.value] = df_f[LABEL.CYCLE_TIME.value] df_t.loc[df_t.cycle_index == x, LABEL.AH_C.value] = df_f[LABEL.AH_C.value] df_t.loc[df_t.cycle_index == x, LABEL.E_C.value] = df_f[LABEL.E_C.value] df_t.loc[df_t.cycle_index == x, LABEL.AH_D.value] = df_f[LABEL.AH_D.value] df_t.loc[df_t.cycle_index == x, LABEL.E_D.value] = df_f[LABEL.E_D.value] df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.AH_C.value)] = df_f[ LABEL.AH_C.value].max() df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.AH_D.value)] = df_f[ LABEL.AH_D.value].max() df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.E_C.value)] = df_f[ LABEL.E_C.value].max() df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.E_D.value)] = df_f[ LABEL.E_D.value].max() df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.V_C_MEAN.value)] = df_f_c[ LABEL.V.value].mean() df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.V_D_MEAN.value)] = df_f_d[ LABEL.V.value].mean() if df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.AH_C.value)] == 0: df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.AH_EFF.value)] = 0 else: df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.AH_EFF.value)] = df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.AH_D.value)] / \ df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.AH_C.value)] if df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.E_C.value)] == 0: df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.E_EFF.value)] = 0 else: df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.E_EFF.value)] = df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.E_D.value)] / \ df_c.iloc[c_ind, df_c.columns.get_loc(LABEL.E_C.value)] except Exception as e: pass df_cc = df_c[df_c[LABEL.CYCLE_INDEX.value] > 0] df_tt = df_t[df_t[LABEL.CYCLE_INDEX.value] > 0] return df_cc, df_tt # unpack the dataframe and calculate quantities used in statistics def calc_cycle_quantities(df): tmp_arr = df[[ LABEL.TEST_TIME.value, LABEL.I.value, LABEL.V.value, LABEL.AH_C.value, LABEL.E_C.value, LABEL.AH_D.value, LABEL.E_D.value, LABEL.CYCLE_TIME.value ]].to_numpy() start = 0 last_time = 0 last_i_c = 0 last_v_c = 0 last_i_d = 0 last_v_d = 0 last_ah_c = 0 last_e_c = 0 last_ah_d = 0 last_e_d = 0 initial_time = 0 for x in tmp_arr: if start == 0: start += 1 initial_time = x[0] else: if x[1] >= 0: x[3] = (x[0] - last_time) * (x[1] + last_i_c) * 0.5 + last_ah_c x[4] = (x[0] - last_time) * (x[1] + last_i_c) * 0.5 * ( x[2] + last_v_c) * 0.5 + last_e_c last_i_c = x[1] last_v_c = x[2] last_ah_c = x[3] last_e_c = x[4] if x[1] <= 0: x[5] = (x[0] - last_time) * (x[1] + last_i_d) * 0.5 + last_ah_d # if x[5] == 0: # print("x5=0:" + str(x[5]) + " last_ah_d: " + # str(last_ah_d)) # if last_ah_d == 0: # print("x5:" + str(x[5]) + " last_ah_d=0: " + # str(last_ah_d)) x[6] = (x[0] - last_time) * (x[1] + last_i_d) * 0.5 * ( x[2] + last_v_d) * 0.5 + last_e_d last_i_d = x[1] last_v_d = x[2] last_ah_d = x[5] last_e_d = x[6] x[7] = x[0] - initial_time last_time = x[0] df_tmp = pd.DataFrame(data=tmp_arr[:, [3]], columns=[LABEL.AH_C.value]) df_tmp.index += df.index[0] df[LABEL.AH_C.value] = df_tmp[LABEL.AH_C.value] / 3600.0 df_tmp =
pd.DataFrame(data=tmp_arr[:, [4]], columns=[LABEL.E_C.value])
pandas.DataFrame
#!/usr/bin/env python debug = True if debug: print('debug = True') computaGenero = True if debug: print('computaGenero = ' + str(computaGenero)) computaCursos = True if debug: print('computaCursos = ' + str(computaCursos)) computaRecorrencia = True # Também vale para retenção e evasão if debug: print('computaRecorrencia = ' + str(computaRecorrencia)) entrada = True if debug: print('entrada = ' + str(entrada)) incremental = False # Só tem valor caso entrada tenha valor True. Faz com que o que já estiver na saída seja mantido if debug: print('incremental = ' + str(incremental)) graficos = True if debug: print('graficos = ' + str(graficos)) if debug: print('') import json import pandas as pd import os from pathlib import Path import re import errno from enum import Enum from collections import namedtuple import numpy as np if computaGenero: from genderize import Genderize genderize = Genderize() if graficos: import matplotlib.pyplot as plt #plt.close('all') if computaRecorrencia: from unidecode import unidecode from operator import itemgetter from similarity.jarowinkler import JaroWinkler jw = JaroWinkler() if graficos: import itertools import calendar # Colunas que não fazem parte da entrada devem ter o valor de Expressão em branco # Colunas com valor de Expressão tem seus nomes substituídos pela Descrição Coluna = namedtuple('Coluna', ['Descrição', 'Expressão']) class Colunas(Enum): @property def Descrição(self): '''Nome da coluna.''' return self.value[0].Descrição @property def Expressão(self): '''Regex da coluna.''' return self.value[0].Expressão # Cuidado para não esquecer da vírgula no final da cada linha Nome = Coluna('Nome', r'NOME'), RG = Coluna('RG', r'Documento de Identidade|^R\.?G\.?$'), CPF = Coluna('CPF', r'CPF'), Curso = Coluna('Curso', r'CURSO'), ID = Coluna('ID', None), Ação = Coluna('Ação', None), Evasão = Coluna('Evasão', None), Evasora = Coluna('Evasora', None), Gênero = Coluna('Gênero', None), Porcentagem = Coluna('Porcentagem', None), Retenção = Coluna('Retenção', None), Retentora = Coluna('Retentora', None), Quantidade = Coluna('Quantidade', None), Válidos = Coluna('Qtde. voluntários válidos', None), try: with open("../Saida/generos.json") as json_file: generos = json.load(json_file) if debug: print('Lendo Saida/generos.json') except FileNotFoundError: if debug: print('Saida/generos.json não encontrado') # Nomes podem ser adicionados aqui (ou no arquivo Saida/generos.json) caso não seja encontrado pela Genderize generos = { 'ALDREI': 'm', 'EDIPO': 'm', 'FABRICIO': 'm', 'HYTALO': 'm', 'JOLINDO': 'm', 'KAWE': 'm', 'MASSARU': 'm', 'OTAVIO': 'm', 'VINICIUS': 'm', 'CARINE': 'f', 'CASSIA': 'f', 'FLAVIA': 'f', 'FRANCYELE': 'f', 'GABRIELLA': 'f', 'HELOISA': 'f', 'IHANNA': 'f', 'JENYFFER': 'f', 'JESSICA': 'f', 'JULIA': 'f', 'LAIS': 'f', 'LETICIA': 'f', 'LIGIA': 'f', 'MAITHE': 'f', 'MARIANGELA': 'f', 'MARINEIA': 'f', 'MONICA': 'f', 'NAIADY': 'f', 'NATHALIA': 'f', 'NATHALLI': 'f', 'STHEFANIE': 'f', 'TAIZA': 'f', 'TAMILES': 'f', 'TAIS': 'f', 'TASSIANY': 'f', 'TATIANY': 'f', 'THASSIA': 'f', 'VERONICA': 'f', } # Expressões podem ser adicionadas aqui para ignorar nomes de voluntários # Ignorar implica em não fazer análise de gênero, recorrência, retenção e evasão nomesExcluidos = [re.compile(expressao, re.I) for expressao in [ r'confirmou', ]] # A ordem em que os cursos aparecem no dicionário é importante, visto que a busca respeita essa ordem # Exemplo: "educação física" deve aparecer antes de "física" cursos = dict((curso, re.compile(expressao, re.I)) for curso, expressao in { 'Engenharia elétrica': r'el[eé]trica', 'Psicologia': r'psico', 'Comunicação social: jornalismo': r'jornal', 'Medicina': r'medicina|fmrp', 'Mestrando': r'mestrado|mestrando', 'Ciência da computação': r'ci[êe]ncias?\s+da\s+computa[cç][aã]o|bcc', 'Engenharia mecânica': r'mec[aâ]nica', 'Engenharia de produção': r'produ[cç][aã]o', 'Engenharia civil': r'civil', 'Economia Empresarial e Controladoria': r'ecec', 'Não universitário': r't[eé]cnic[oa]|n[aã]o\s+cursante|completo|etec|trabalho|profissional|convidad[ao]|extern[ao]|palestra|volunt[aá]ri[ao]|nenhum|socorrista|cursinho|vestibula|nutricionista|enfermeira|formad[oa]|consultora|decoradora|estudante|fiscal|terapeuta|banc[aá]ria|psic[oó]log[ao]|assessora|empres[áa]ri[ao]|noite|professor|desempregad[ao]|mãe|graduad[ao]', 'Meteorologia': r'meteoro', 'Educação física': r'(educa[çc][ãa]o|ed\.?)\s+f[íi]sica', 'Física': r'f[ií]sica', 'Doutorando': r'doutorado', 'Ciências biológicas': r'biologia|biol[oó]gicas|^bio', 'Química': r'qu[íi]mica', 'Administração': r'adm', 'Música': r'^m[úu]sica', 'Matemática aplicada a negócios': r'^man|neg[óo]cio', 'Engenharia química': r'engenharia\s+qu[íi]mica|eng\s+qu[íi]mica', 'Fisioterapia': r'fisio', 'Ciências contábeis': r'cont', 'Economia': r'econo', 'Pedagogia': r'^pedago', 'Biblioteconomia e Ciência da Informação': r'^BCI', 'Universitário: curso não informado': r'^unaerp|cultura|ufpa|ffclrp|^unesp|^integral\s+manh[aã]|^fea', 'Pós graduando': r'p[óo]s\s+gradua[çc][ãa]o', 'Agronomia': r'agro', 'Análise e desenvolvimento de sistemas': r'an[áa]lise', 'Arquitetura': r'arq', 'Artes visuais': r'artes', 'Biotecnologia': r'^biotecnologia', 'Ciências biomédicas': r'ci[eê]ncias\s+biom[eé]dicas', 'Comunicação social: radialismo': r'rtv|radialismo|r[aá]dio\s+e\s+tv', 'Dança, grafiti e teatro': r'teatro', 'Design': r'design', 'Direito': r'^direito', 'Ecologia': r'^ecologia', 'Enfermagem': r'enfermagem|eerp', 'Engenharia ambiental': r'amb', 'Engenharia de biossistemas': r'biossistemas', 'Engenharia da computação': r'engenharia\s+d[ae]\s+computa[cç][aã]o', 'Engenharia florestal': r'florestal', 'Farmácia': r'^farm[áa]cia|fcfrp', 'Filosofia': r'^filo', 'Fonoaudiologia': r'^fono', 'Genética': r'gen[ée]tica', 'Informática biomédica': r'inform[áa]tica\s+biom[eé]dica|^ibm', 'Letras': r'^letras', 'Marketing': r'marketing|mkt', 'Nutrição e metabolismo': r'nutri[çc][ãa]o', 'Medicina veterinária': r'veterin[áa]ria', 'Teologia': r'^teologia', 'Terapia ocupacional': r'ocupacional|t.o', 'Odontologia': r'^odonto|forp', 'Publicidade e propaganda': r'publicidade|pp', 'Recursos humanos': r'recursos\s+humanos|rh', 'Relações públicas': r'rela[cç][oõ]es\s+p[uú]blicas|rp', 'Serviço social': r'social', 'Sistemas de informação': r'sistemas|^b?si$', }.items()) listaCursos = [curso for curso, _ in cursos.items()] loteGeneros = {} dfs = {} desc = pd.DataFrame() pessoas = pd.DataFrame(columns = [Colunas.ID.Descrição, Colunas.Nome.Descrição, Colunas.RG.Descrição, Colunas.CPF.Descrição, Colunas.Quantidade.Descrição, Colunas.Retentora.Descrição, Colunas.Evasora.Descrição, Colunas.Curso.Descrição, Colunas.Gênero.Descrição]) lastID = 0 def createDir(path): '''Cria o diretório do caminho indicado, caso não exista.''' directory = os.path.dirname(path) if not os.path.exists(directory): if debug: print('Criando diretório ' + directory) try: os.makedirs(directory, exist_ok = True) except OSError as exc: # Guard against race condition if exc.errno != errno.EEXIST: raise def output(dataframe, path): '''Salva o dataframe como csv no caminho indicado.''' filename = "../Saida/" + path + "/output.csv" createDir(filename) if debug: print('Escrevendo ' + path + '/output.csv') dataframe.to_csv(filename, index = False, float_format = '%.f') def incluiAcao(path): ''' A partir de um arquivo csv, faz a inclusão da ação. Nenhuma análise é feita e nenhum arquivo é gerado. São preenchidas as variáveis globais `dfs`, `pessoas` e `loteGeneros`. ''' ids = [] if debug: print('Lendo ' + path + ".csv") df = pd.read_csv("../Dados/" + path + ".csv", true_values = ['Sim'], false_values = ['Não']) if debug: print('Removendo colunas desnecessárias') df = df.loc[:, df.columns.str.contains('|'.join([coluna.Expressão for coluna in Colunas if coluna.Expressão]), case = False)] # Renomeia colunas para que fiquem de forma homogêna, seguindo a propriedade `Descrição` if debug: print('Renomeando colunas') def columnIterator(): '''Retorna apenas as colunas que correspondem a alguma das expressões em `Colunas`.''' for coluna in Colunas: if coluna.Expressão: for col in df.columns: if re.search(coluna.Expressão, col, re.I): yield (col, coluna.Descrição) break df.rename(columns = dict(columnIterator()), inplace = True) if debug: print('Limpando valores') df.replace(r'\t', ' ', regex = True, inplace = True) # Substitui tabs por espaços df.replace(r'\s{2,}', ' ', regex = True, inplace = True) # Remove espaços em sequência df.replace(r'^\s+|\s+$', '', regex = True, inplace = True) # Leading and trailing trimming df.replace(r'^$', None, regex = True, inplace = True) # Transforma vazio em None if debug: print('Removendo linhas totalmente em branco') df.dropna(axis = 'index', how = 'all', inplace = True) # Após remover linhas e colunas não desejadas, refaz os índices if debug: print('Refazendo índices') df.reset_index(drop = True, inplace = True) if debug: print('') for i in df.index: temNome = False if Colunas.Nome.Descrição in df: value = df.at[i, Colunas.Nome.Descrição] if pd.isnull(value): if debug: print('Sem nome') elif any([reg.search(value) for reg in nomesExcluidos]): df.at[i, Colunas.Nome.Descrição] = None if debug: print('Sem nome') else: # Remove 'pipes' do nome, pois é utilizado como separador na análise de recorrência value = re.sub(r'\|', '', value) if value == '': df.at[i, Colunas.Nome.Descrição] = None if debug: print('Sem nome') else: temNome = True nome = df.at[i, Colunas.Nome.Descrição] = value if debug: print(value) elif debug: print('Sem nome') def validaDocumento(coluna): '''Efetua a validação de CPF ou RG, recuperando apénas dígitos (números em qualquer posição e `x` ou `X` na última posição).''' if coluna in df: value = df.at[i, coluna] if pd.notnull(value): try: int(value) # Se já é int, então não tem caracteres especiais... if debug: print(coluna + ': ' + str(value)) except ValueError: newValue = re.sub(r'[^0-9xX]|[xX].', '', value) # Remove caracteres especiais do documento (deixa apenas números) df.at[i, coluna] = None if newValue == '' else newValue if debug: print(coluna + ': ' + value + ' -> ' + newValue) validaDocumento(Colunas.RG.Descrição) validaDocumento(Colunas.CPF.Descrição) # Análise de recorrência def analiseRecorrencia(*args): '''Busca recorrência por correspondência nas colunas indicadas.''' def analiseCurso(): '''Atribuição imediata do curso de acordo com as expressões definidas no cabeçalho do arquivo. Joga exception caso não encontre.''' nome = df.at[i, Colunas.Curso.Descrição] if pd.isnull(nome): if debug: print('Curso não preenchido') else: try: curso = next(curso for curso, reg in cursos.items() if reg.search(nome)) if debug: print('Curso: ' + nome + ' -> ' + curso) return curso except StopIteration: raise Exception('Curso desconhecido: ' + nome) def analiseGenero(ID): ''' Caso o gênero esteja no dicionário local, a atribuição é imediata. Caso contrário, nome é adicionado ao lote a ser buscado após o fim das inclusões na função `computaGeneros`. ''' primeiroNome = nome.split()[0] nomeSemAcento = unidecode(primeiroNome.upper()) genero = generos.get(nomeSemAcento) if genero: pessoas.loc[pessoas[Colunas.ID.Descrição] == ID, Colunas.Gênero.Descrição] = genero if debug: print(primeiroNome + ' -> ' + genero) else: # Adiciona nome no lote a ser buscado em `computaGeneros` if nomeSemAcento in loteGeneros: if not ID in loteGeneros[nomeSemAcento]: loteGeneros[nomeSemAcento].append(ID) else: loteGeneros[nomeSemAcento] = [ID] def buscaColuna(coluna): '''Busca recorrência por correspondência na coluna indicada.''' if coluna in df: key = df.at[i, coluna] if pd.notnull(key): if computaRecorrencia: nonlocal nome upperName = unidecode(nome.upper()) # Similaridade não considera acentos (a = á) e é case insensitive (a = A) def analiseNomes(pessoa): '''Retorna o grau de similaridade (0-1) e o nome referente à melhor correspondência (maior similaridade) encontrada.''' nomes = pessoa.split('|') values = [jw.similarity(unidecode(nome.upper()), upperName) for nome in nomes] index, value = max(enumerate(values), key = itemgetter(1)) return value, nomes[index] if coluna == Colunas.Nome.Descrição: similaridades = pessoas[coluna].map(analiseNomes) matches = pd.Series([similaridade[0] for similaridade in similaridades]) > .96 # Grau de similaridade mínimo aceitável: 96% else: matches = pessoas[coluna] == key if matches.sum() > 1: # Se acontecer com nome, talvez seja interessante aumentar o grau de similaridade mínimo aceitável # Se acontecer com documento, provavelmente é bug raise Exception('Mais de um registro de ' + coluna + ' "' + key + '" encontrado') if matches.any(): ID = pessoas.loc[matches, Colunas.ID.Descrição].iloc[0] if coluna == Colunas.Nome.Descrição: similaridade = max(similaridades, key = itemgetter(0)) elif computaRecorrencia: similaridade = analiseNomes(pessoas.loc[matches, Colunas.Nome.Descrição].iloc[0]) else: similaridade = [1] if similaridade[0] < 1: # Caso a mesma pessoa dê entrada com nomes diferentes, todos são salvos pessoas.loc[matches & (pessoas[Colunas.Nome.Descrição] == ''), Colunas.Nome.Descrição] = nome pessoas.loc[matches & (pessoas[Colunas.Nome.Descrição] != ''), Colunas.Nome.Descrição] += '|' + nome # Se coluna diverge dentre registros da mesma pessoa, o primeiro encontrado tem valor e o resto é ignorado # Curso if computaCursos and Colunas.Curso.Descrição in df and pd.isnull(pessoas.loc[matches, Colunas.Curso.Descrição].iloc[0]): curso = analiseCurso() if curso: pessoas.loc[matches, Colunas.Curso.Descrição] = curso # Gênero if computaGenero and Colunas.Nome.Descrição in df and pd.isnull(pessoas.loc[matches, Colunas.Gênero.Descrição].iloc[0]): analiseGenero(ID) if debug: print('Recorrência encontrada pelo ' + coluna + f' ({key})') if coluna == Colunas.Nome.Descrição: print(f'Similaridade: {similaridade[0] * 100:.0f}% (' + similaridade[1] + ')') print(f'ID: {ID:.0f}') pessoas.loc[matches, Colunas.Quantidade.Descrição] += 1 pessoas.loc[matches, Colunas.Evasora.Descrição] = path return ID for arg in args: if arg is not None: ID = buscaColuna(arg) if ID: return ID global lastID lastID += 1 if debug: print(f'Recorrência não encontrada. ID atribuído: {lastID:.0f}') pessoas.loc[pessoas.shape[0]] = { Colunas.ID.Descrição: lastID, Colunas.RG.Descrição: df.at[i, Colunas.RG.Descrição] if Colunas.RG.Descrição in df else None, Colunas.CPF.Descrição: df.at[i, Colunas.CPF.Descrição] if Colunas.CPF.Descrição in df else None, Colunas.Nome.Descrição: df.at[i, Colunas.Nome.Descrição] if temNome else '', Colunas.Quantidade.Descrição: 1, Colunas.Retentora.Descrição: path, Colunas.Evasora.Descrição: path, Colunas.Curso.Descrição: analiseCurso() if computaCursos and Colunas.Curso.Descrição in df and pd.notnull(df.at[i, Colunas.Curso.Descrição]) else None, Colunas.Gênero.Descrição: None, } if computaGenero and Colunas.Nome.Descrição in df and pd.notnull(df.at[i, Colunas.Nome.Descrição]): analiseGenero(lastID) return lastID ID = analiseRecorrencia(Colunas.RG.Descrição, Colunas.CPF.Descrição, Colunas.Nome.Descrição if temNome and computaRecorrencia else None) df.at[i, Colunas.ID.Descrição] = ID ids.append(ID) df.at[i, Colunas.Curso.Descrição] = None if debug: print('') if Colunas.Curso.Descrição in df: df[Colunas.Curso.Descrição] = df[Colunas.Curso.Descrição].apply(lambda value: str(value) if pd.notnull(value) else None) dfs[path] = df if debug: print('') return ids def chunks(l, n): for i in range(0, len(l), n): yield l[i:i + n] def computaGeneros(): ''' Busca os gêneros de lotes de 10 nomes a partir da variável `loteGeneros` para o dicionário de gêneros e atribuindo o gênero a cada pessoa. Busca acontece primeiro para os nomes mais recorrentes. Caso uma pessoa com múltiplos nomes tenha o gênero encontrado, os outros nomes serão ignorados. Caso o nome seja ignorado por todas as pessoas referentes, ele deixa de ser buscado. ''' def iteradorLote(): for nome, IDs in loteGeneros.items(): matches = pessoas[Colunas.ID.Descrição].isin(IDs) if any(pd.isnull(pessoas.loc[matches, Colunas.Gênero.Descrição])): yield nome, matches, IDs.__len__() for lote in chunks(sorted(iteradorLote(), key = lambda item: item[2], reverse = True), 10): retorno = genderize.get([nome for nome, _, _ in lote]) #country_id = 'br', language_id = 'pt' for genero, (nome, matches, _) in zip([genero[0] if genero else 'n' for genero in [genero['gender'] for genero in retorno]], lote): pessoas.loc[matches, Colunas.Gênero.Descrição] = generos[nome] = genero if debug: print(nome + ' -> ' + genero) arquivo = "../Saida/generos.json" createDir(arquivo) with open(arquivo, 'w') as outfile: json.dump(generos, outfile, sort_keys = True, indent = 2) if debug: print('Salvando Saida/generos.json') print('') def analisaAcao(path, ids): ''' Faz a análise de gênero e cursos da açao a partir do `DataFrame` referente ao caminho indicado em `dfs`. Opcionalmente, indica-se `ids` para restringir a análise apenas a certas pessoas (útil para entrada incremental). ''' if debug: print('Analisando ' + path) df = dfs[path] algum = not incremental or not os.path.exists("../Saida/" + path + "/output.csv") if computaCursos or computaGenero: for i in df.index: pessoa = pessoas[pessoas[Colunas.ID.Descrição] == df.at[i, Colunas.ID.Descrição]] ID = pessoa[Colunas.ID.Descrição].item() if ids and not ID in ids: continue if debug: print(ID) # Curso if computaCursos and (not Colunas.Curso.Descrição in df or pd.isnull(df.at[i, Colunas.Curso.Descrição])): value = pessoa[Colunas.Curso.Descrição].item() if pd.isnull(value): if debug: print('Curso não preenchido') else: try: df.at[i, Colunas.Curso.Descrição] = value if debug: print('Curso: ' + value) algum = True except StopIteration: raise Exception('Curso desconhecido: ' + value) # Gênero if computaGenero and (not Colunas.Gênero.Descrição in df or pd.isnull(df.at[i, Colunas.Gênero.Descrição])): value = pessoa[Colunas.Gênero.Descrição].item() genero = 'n' if pd.isnull(value) else value df.at[i, Colunas.Gênero.Descrição] = genero if debug: print('Gênero: ' + genero) algum = True if debug: print('') if algum: output(df, path) def get_last(a): '''Retorno o índice da última ocorrência de elemento diferente de `None` na coleção `a`.''' return get_n_last(a, 1) def get_n_last(a, n): '''Retorna o índice da enésima última ocorrência de elemento diferente de `None` na coleção `a`.''' for i, e in enumerate(reversed(a)): if e is not None: n = n - 1 if n == 0: return len(a) - i - 1 return -1 def ranking(nome, colunas, legendas): posicaoMaxima = 2 # 0 = Ano # 1 = Mês # 2 = Cidade g = desc[:-1].groupby(['0', '1', '2']).agg( { coluna: np.sum for coluna in colunas }) cidades = g.index.get_level_values('2').unique() for cidade in cidades: if debug: print('Gerando gráfico de ranking por ' + nome + ' para ' + cidade) dfAux = pd.DataFrame() descCidade = desc[desc['2'] == cidade].reset_index(drop = True) r = pd.date_range(pd.to_datetime(calendar.month_abbr[int(descCidade.at[0, '1'])] + '-' + descCidade.at[0, '0']), pd.to_datetime(calendar.month_abbr[int(descCidade.iloc[-1]['1'])] + '-' + descCidade.iloc[-1]['0']), freq = 'MS') for date in r: filtro = g[(g.index.get_level_values('0') == str(date.year)) & (g.index.get_level_values('1') == f'{date.month:02d}') & (g.index.get_level_values('2') == cidade)] dfAux = dfAux.append(filtro.apply(lambda x: x.reset_index(drop = True)) .T .nlargest(posicaoMaxima, columns = 0) .rank(method = 'first', ascending = False) .T if not filtro.empty else
pd.Series()
pandas.Series
from bs4 import BeautifulSoup import requests import pandas as pd ## don't truncate printed urls pd.set_option('display.max_colwidth', None) ## spoof user-agent headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.80 Safari/537.36', 'Content-Type': 'text/html'} ## category urls urls = ['http://www.irishnews.com/dyna/partial/articlesbycategory?s=0&e=2501&category=%2firishnews%2fnews%2fpoliticalnews&onlyPrimary=false', 'http://www.irishnews.com/dyna/partial/articlesbycategory?s=0&e=2501&category=%2firishnews%2fnews%2frepublicofirelandnews&onlyPrimary=false', 'http://www.irishnews.com/dyna/partial/articlesbycategory?s=0&e=2501&category=%2firishnews%2fnews%2fassemblyelection&onlyPrimary=false', 'http://www.irishnews.com/dyna/partial/articlesbycategory?s=0&e=2501&category=%2firishnews%2fnews%2fbrexit&onlyPrimary=false', 'http://www.irishnews.com/dyna/partial/articlesbycategory?s=0&e=2501&category=%2firishnews%2fnews%2fcivilrights&onlyPrimary=false', 'http://www.irishnews.com/dyna/partial/articlesbycategory?s=0&e=2501&category=%2firishnews%2fnews%2fgeneralelection&onlyPrimary=false', 'http://www.irishnews.com/dyna/partial/articlesbycategory?s=0&e=2501&category=%2firishnews%2fnews%2fnorthernirelandnews&onlyPrimary=false', 'http://www.irishnews.com/dyna/partial/articlesbycategory?s=0&e=2501&category=%2firishnews%2fnews%2fuknews&onlyPrimary=false'] ## takes <article></article> element and converts to df row def elementToRow(soup): titleBlock = soup.find(class_="lancio-title") title = titleBlock.find("a").get_text() url = titleBlock.find("a")["href"].lstrip("/") ## warning, stub is often similar to title stub = soup.find(class_="lancio-text").get_text() if(soup.find(class_="lancio-tag")): author = soup.find(class_="lancio-tag").get_text() else: author = "" rawDate = soup.find(class_="lancio-datetime-string")['datetime'].split(" ")[0] d = {"title": [title], "url": [url], "stub":[stub], "author":[author], "date":[rawDate]} df = pd.DataFrame(data=d) df['date'] = pd.to_datetime(df['date']) return df ## iterate over category urls, populate df def scrape(): res = pd.DataFrame() for u in urls: r = requests.get(u, headers=headers) soup = BeautifulSoup(r.text, 'html.parser'); for ele in soup.find_all(class_="row lancio"): tmp = [res, elementToRow(ele)] res =
pd.concat(tmp)
pandas.concat
#!/usr/bin/env python3 import pandas as pd import re, ntpath, time, shlex, datetime, warnings, os import numpy as np from ast import literal_eval warnings.filterwarnings("ignore") try: import easygui except ModuleNotFoundError: print("A library is missing, please wait while it gets installed.\n") os.system("pip install easygui") print("Library installed sucessfully.\n") import easygui timestr = time.strftime("%Y%m%d-%H%M%S") #Reading contents from the file path = easygui.fileopenbox(msg=None, title="Select file", default='*', filetypes=None, multiple=False) outname = ntpath.basename(path).replace(".txt", "") def filecontent(path): #checking for possible unnecessary 8 digit numbers in each line with open(path, 'r') as file: content = file.readlines() for line in content: line = line.rstrip() a = re.findall(r"\D(0000\d{4})\D", " "+line+" ") if a: a = "".join(a) line = line.replace(a, "").rstrip() with open("temp.txt", 'a') as f: f.write(line + "\n") #splitting the txt based on a delimiter with open("temp.txt", 'r') as file: content = file.read().rstrip() lines = content.split('.') lines = [x for x in lines if x] os.remove("temp.txt") return lines lines = filecontent(path) #Removing quotes from the csv file def file_modify(filename, a=None): with open(filename, 'r+') as file: content = file.read() for ch in ['"','[',']']: if ch in content: content = content.replace(ch,'') if "\n\n" in content: content = content.replace("\n\n", "\n") if a: content = content.replace(",", "") with open(filename, 'w') as file: file.write(content) #Checking for duplicate rows in code table def check_dup(f): duplicateRowsDF = f[f.duplicated(['Table Name', '1st'])] print("We have " + str(len(duplicateRowsDF)) + " duplicate rows in code generation table. \n") print(duplicateRowsDF) #Intializing variables for parsing, used later to convert to dataframe table_name, version_name, type_name, issorted, isduplicate, table_data, value_name, time_t, search_type = ([] for i in range(9)) counter = 0 print("\n--------------------------------WARNINGS/ERRORS------------------------------------\n\n") for line in lines: if '*+' in line: #removing comment symbols line.replace('*+', " ") #for table name field try: tname = re.search('TABLE NAME IS (.*) VERSION', line) table_name.append(tname.group(1)) except AttributeError: print("There is no such attribute. Check the file for correct table name at index " + str(counter)) table_name.append("NaN") #for version field try: vname = re.search('VERSION IS (.*)', line) version_name.append("Version " + vname.group(1)) except AttributeError: print("There is no such attribute. Check the file for correct version at index " + str(counter)) version_name.append("NaN") #for type field try: tyname = re.search('TYPE IS (.*)', line) if tyname.group(1) in ['EDIT VALID', 'EDIT INVALID', 'CODE']: type_name.append(tyname.group(1)) else: print("There is no such attribute. Check the file for correct type at index " + str(counter)) type_name.append("NaN") if tyname.group(1) in ['EDIT VALID', 'EDIT INVALID']: #for alphanumeric field incase of EDIT VALID tbldata = re.search('TABLE DATA IS (.*)', line) if tbldata == None: table_data.append("") else: table_data.append(tbldata.group(1)) elif tyname.group(1) == 'CODE': encodedata = re.search('ENCODE DATA IS (.*)', line) decodedata = re.search('DECODE DATA IS (.*)', line) if encodedata and decodedata == None: table_data.append("") else: tbldata = ",".join((encodedata.group(1),decodedata.group(1))) table_data.append(tbldata) else: print("There is no such attribute. Check the file for correct datatype at index " + str(counter)) table_data.append("NaN") except AttributeError: print("There is no such attribute. Check the file for correct type & datatype at index " + str(counter)) type_name.append("NaN") table_data.append("NaN") #for sorted/unsorted field try: sname = re.search('TABLE IS (.*)', line) if sname.group(1) in ['SORTED', 'UNSORTED']: issorted.append(sname.group(1)) else: print("There is no such attribute. Check the file for correct table sorted/unsorted value at index " + str(counter)) issorted.append("NaN") except AttributeError: print("There is no such attribute. Check the file for correct table sorted/unsorted value at index " + str(counter)) issorted.append("NaN") #for whether duplicate values are allowed or not try: dname = re.search('DUPLICATES ARE (.*)', line) if dname == None: isduplicate.append("") elif dname.group(1) == 'NOT ALLOWED': isduplicate.append("NODUP") elif dname.group(1) == 'ALLOWED': isduplicate.append("DUP") except AttributeError: print("There is no such attribute. Check the file for duplicate field at index " + str(counter)) #for values field try: vname = re.search('VALUES ARE \( (.*) \)', line, flags=re.DOTALL) temp1 = vname.group(1).replace("' '", "''") temp2 = ' '.join(map(str.strip, temp1.split("\n"))) value_name.append(temp2) except AttributeError: print("There is no such attribute. Check the file for Value field at index " + str(counter)) #for searchtype field try: temp = re.search('SEARCH IS (.*)', line) if "BINARY" in temp.group(1): search_type.append("BIN") elif "LINEAR" in temp.group(1): search_type.append("LIN") except AttributeError: print("There is no such attribute. Check the file for Value field at index " + str(counter)) search_type.append("NaN") #for timestamp try: time_t.append(" * Table generated at " + str(datetime.datetime.now()) + "\n\t ") except AttributeError: print("There is no such attribute. Check the code for correct code syntax or OS for time.") counter += 1 #Creating Dataframe summary = { "Table Name": table_name, "Version": version_name, "Type": type_name, "Is_sorted": issorted, "Duplicate": isduplicate, "Datatype": table_data, "Searchtype": search_type, "Timestamp": time_t, "Value": value_name } df = pd.DataFrame(summary) df['Datatype'] = df['Datatype'].str.replace('ALPHANUMERIC','X') df['Datatype'] = df['Datatype'].str.replace('NUMERIC','9') df["Is_sorted"].replace({"SORTED": "Y", "UNSORTED": "N"}, inplace=True) df_summary = df.iloc[:,:-2] print("\n--------------------------------SUMMARY FILE-----------------------------------\n\n") print(df_summary) print("\n\n") #Export to csv file csv_filename = outname + "_summary" + ".csv" df_summary.to_csv(csv_filename, header=False, index=False) csvmodify = file_modify(csv_filename) #################################################################################### #Function for Code Generation Table def code_table(): df_type_code_orig = df[df["Type"]=="CODE"] #df_type_code columns = ['Table Name', 'Value'] df_type_code = pd.DataFrame(df_type_code_orig, columns=columns) for index, row in df_type_code.iterrows(): span = 2 words = shlex.split(row.Value, posix = False) row.Value = [",".join(words[i:i+span]) for i in range(0, len(words), span)] df_type_code['Index'] = df_type_code.index df_temp = (pd.DataFrame({'Table Name': list(df_type_code['Table Name']), 'Value': list(df_type_code['Value']), 'Index': list(df_type_code['Index'])}) .set_index(['Index', 'Table Name'])) temp = df_temp.explode('Value') temp.reset_index(inplace=True, level=1) df_new = temp[['Table Name', 'Value']] df_final = pd.concat([df_new, df_new['Value'].str.split(',', expand=True)], axis=1) df_final = df_final.drop(df_final.columns[[1]], axis=1) df_final.columns = ['Table Name', '1st', '2nd'] df_final.reset_index(inplace=True) df_final['type'] = 'C' df_final['blank'] = '' df_final['zero'] = '0' columns = ['Table Name', 'type', '1st', 'zero', 'Table Name', 'type', '2nd', 'blank'] df_final = df_final[columns] temp1 = df_type_code_orig["Searchtype"] + "," + df_type_code_orig['Is_sorted'] + "," + df_type_code_orig['Datatype'] + "," temp1 = pd.DataFrame(temp1, columns=['one']) temp2 = df_type_code['Value'].to_frame() temp = pd.concat([temp1, temp2], axis=1, ignore_index=True) temp.columns = ['one', 'two'] df2 = temp.explode('two') df_final2 = pd.concat([df2, df2['two'].str.split(',', expand=True)], axis=1) df_final2 = df_final2.drop(df_final2.columns[[1]], axis=1) df_final2.columns = ['Name', '1st', '2nd'] df_final2.reset_index(inplace=True) df_final2 = df_final2[['Name']] result = pd.concat([df_final, df_final2], axis=1) result_f1 = result.iloc[:, :3] result_f11 = result_f1[['Table Name', 'type', '1st']].apply(lambda x: ''.join(x), axis=1).to_frame() result_f2 = result.iloc[:,3:7] result_f22 = result_f2[['zero', 'Table Name', 'type', '2nd']].apply(lambda x: ''.join(x), axis=1).to_frame() result_f3 = result.iloc[:,-1:] final_result =
pd.concat([result_f11,result_f22,result_f3], axis=1)
pandas.concat
""" This module will hold general functions used by main """ import argparse # type: ignore from datetime import datetime # type: ignore from datetime import timedelta # type: ignore import pandas as pd # type: ignore import app.modules.stock as stock # type: ignore import app.modules.database as database # type: ignore import app.modules.sql as sql # type: ignore import app.modules.ml_gmm as ml_gmm # type: ignore import app.modules.mlflow as mlflow # type: ignore def get_args(): """ get_args returns the arguments passed :return: """ parser = argparse.ArgumentParser() parser.add_argument("task") args = parser.parse_args() return args def init_stocks_db(config: dict): """ init_stocks_db used for setting up the database :param config: config used to access DB :return: """ database_manager: database.DatabaseManager = database.DatabaseManager(config) database_manager.connect_db() database_manager.send_sql(sql_query=sql.create_stock_table("stocks")) database_manager.close_conn() def upload_this_weeks_stock(config: dict, stock_symbol: str): """ upload_this_weeks_stock is used to download the weeks stock data :param config: config used to access DB :param stock_symbol: stock company to download :return: """ start_date: str = (datetime.today() - timedelta(days=7)).strftime("%Y-%m-%d") stock_data_frame: pd.DataFrame = stock.get_stock(stock.stock_man, stock_symbol, start_date) database_manager: database.DatabaseManager = database.DatabaseManager(config) database_manager.connect_db() database_manager.df_to_sql(stock_data_frame, "stocks") database_manager.close_conn() def upload_ayear_stock(config: dict, stock_symbol: str): """ upload_ayear_stock is used to download the years stock data :param config: config used to access DB :param stock_symbol: stock company to download :return: """ start_date: str = (datetime.today() - timedelta(days=360)).strftime("%Y-%m-%d") stock_data_frame: pd.DataFrame = stock.get_stock(stock.stock_man, stock_symbol, start_date) database_manager: database.DatabaseManager = database.DatabaseManager(config) database_manager.connect_db() database_manager.df_to_sql(stock_data_frame, "stocks") database_manager.close_conn() def search_train_gmm_model(config: dict, table: str): """ search_train_gmm_model is used to get all the metrics for gmm models on stock data :param config: config used to access DB :param table: table that has stck data :return: """ mlflow_manager = mlflow.MlFlowManager(config["ip"], "GMM_example") database_manager: database.DatabaseManager = database.DatabaseManager(config) database_manager.connect_db() stocks: list = database_manager.receive_sql_fetchall(sql.select_all_table(table)) database_manager.close_conn() gmm_ml_manager: ml_gmm.GmmMlManager = ml_gmm.GmmMlManager(
pd.DataFrame(stocks)
pandas.DataFrame
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Wed Jun 12 13:02:14 2019 @author: ranap V = l/mu D = 2 * sigma^2 = (2*l^2) / lambda Args: N: number of particle Return: dataframe with probabilty """ import numpy as np import pandas as pd import matplotlib.pyplot as plt plt.switch_backend('agg') from scipy.stats import invgauss import math import time import sys from joblib import Parallel, delayed def brownian(d,v,sigma,t_bin=0.001): # simulate brownian motion pos= 0 t= 1 v_t = v*t_bin while pos < d: pos = pos + v_t + (sigma * np.random.randn() * math.sqrt(t_bin)) t+=1 return t * t_bin def eq1(t,T): s = 2 arr =np.sort(t, axis=None) t_bind=1 t_next=2 while t_next < len(arr): if(arr[t_next] -arr[t_bind] > T): s+=1; t_bind = t_next; t_next+=1 else: t_next+=1 s_arr = np.zeros((len(arr)-1,), dtype=int) s_arr[s-2] = 1 return s_arr def sim(N,d,v,sigma,T,tau, no_sim=100000): # simulate N particle model s_count = np.zeros(N-1) for i in range(1,no_sim): tauT = np.zeros((N,),dtype=float) tauT[0] = 0 for i in range(1,len(tauT)): tauT[i] =tauT[i-1]+ np.random.exponential(tau) t = np.zeros((N,),dtype=float) for i in range(0,len(t)): t[i] =tauT[i]+ brownian(d,v,sigma) t=t-t[0] # making relatiove to 1st particle s = eq1(t,T) s_count +=s s_prob = s_count/no_sim res= np.zeros((5+N-1,), dtype=float) res[0]=d; res[1]=v; res[2]=sigma; res[3]=T; res[4]=tau; res[5:]=s_prob return(res) def test(): N=4; d=1; v=1; sigma=1; T=1; tau=1 start = time.time() res = sim(N,d,v,sigma,T,tau) print("result : ", res, " Time: ", time.time()-start) def main_prl(N): # run for different parameter combination d=1; v=1; sigma=1 t_range = np.arange(0.1,4.01,0.2) tau_range = np.arange(0.5,4.01,0.2) Data = np.zeros((len(t_range)*len(tau_range),5+N-1),dtype=float) res = Parallel(n_jobs=16)(delayed(sim)(N,d,v,sigma,i,j) for j in tau_range for i in t_range) res = np.array(res) col_name= ['d', 'v', 'sigma', 'T', 'tau'] + ['S'+ str(i) for i in range(2,N+1)] Data =
pd.DataFrame(res, columns=col_name)
pandas.DataFrame
""" Base tools for handling various kinds of data structures, attaching metadata to results, and doing data cleaning """ from statsmodels.compat.python import lmap from functools import reduce import numpy as np from pandas import DataFrame, Series, isnull, MultiIndex import statsmodels.tools.data as data_util from statsmodels.tools.decorators import cache_readonly, cache_writable from statsmodels.tools.sm_exceptions import MissingDataError def _asarray_2dcolumns(x): if np.asarray(x).ndim > 1 and np.asarray(x).squeeze().ndim == 1: return def _asarray_2d_null_rows(x): """ Makes sure input is an array and is 2d. Makes sure output is 2d. True indicates a null in the rows of 2d x. """ #Have to have the asarrays because isnull does not account for array_like #input x = np.asarray(x) if x.ndim == 1: x = x[:, None] return np.any(isnull(x), axis=1)[:, None] def _nan_rows(*arrs): """ Returns a boolean array which is True where any of the rows in any of the _2d_ arrays in arrs are NaNs. Inputs can be any mixture of Series, DataFrames or array_like. """ if len(arrs) == 1: arrs += ([[False]],) def _nan_row_maybe_two_inputs(x, y): # check for dtype bc dataframe has dtypes x_is_boolean_array = hasattr(x, 'dtype') and x.dtype == bool and x return np.logical_or(_asarray_2d_null_rows(x), (x_is_boolean_array | _asarray_2d_null_rows(y))) return reduce(_nan_row_maybe_two_inputs, arrs).squeeze() class ModelData(object): """ Class responsible for handling input data and extracting metadata into the appropriate form """ _param_names = None _cov_names = None def __init__(self, endog, exog=None, missing='none', hasconst=None, **kwargs): if data_util._is_recarray(endog) or data_util._is_recarray(exog): import warnings from statsmodels.tools.sm_exceptions import recarray_warning warnings.warn(recarray_warning, FutureWarning) if 'design_info' in kwargs: self.design_info = kwargs.pop('design_info') if 'formula' in kwargs: self.formula = kwargs.pop('formula') if missing != 'none': arrays, nan_idx = self.handle_missing(endog, exog, missing, **kwargs) self.missing_row_idx = nan_idx self.__dict__.update(arrays) # attach all the data arrays self.orig_endog = self.endog self.orig_exog = self.exog self.endog, self.exog = self._convert_endog_exog(self.endog, self.exog) else: self.__dict__.update(kwargs) # attach the extra arrays anyway self.orig_endog = endog self.orig_exog = exog self.endog, self.exog = self._convert_endog_exog(endog, exog) self.const_idx = None self.k_constant = 0 self._handle_constant(hasconst) self._check_integrity() self._cache = {} def __getstate__(self): from copy import copy d = copy(self.__dict__) if "design_info" in d: del d["design_info"] d["restore_design_info"] = True return d def __setstate__(self, d): if "restore_design_info" in d: # NOTE: there may be a more performant way to do this from patsy import dmatrices, PatsyError exc = [] try: data = d['frame'] except KeyError: data = d['orig_endog'].join(d['orig_exog']) for depth in [2, 3, 1, 0, 4]: # sequence is a guess where to likely find it try: _, design = dmatrices(d['formula'], data, eval_env=depth, return_type='dataframe') break except (NameError, PatsyError) as e: exc.append(e) # why do I need a reference from outside except block pass else: raise exc[-1] self.design_info = design.design_info del d["restore_design_info"] self.__dict__.update(d) def _handle_constant(self, hasconst): if hasconst is False or self.exog is None: self.k_constant = 0 self.const_idx = None else: # detect where the constant is check_implicit = False exog_max = np.max(self.exog, axis=0) if not np.isfinite(exog_max).all(): raise MissingDataError('exog contains inf or nans') exog_min = np.min(self.exog, axis=0) const_idx = np.where(exog_max == exog_min)[0].squeeze() self.k_constant = const_idx.size if self.k_constant == 1: if self.exog[:, const_idx].mean() != 0: self.const_idx = int(const_idx) else: # we only have a zero column and no other constant check_implicit = True elif self.k_constant > 1: # we have more than one constant column # look for ones values = [] # keep values if we need != 0 for idx in const_idx: value = self.exog[:, idx].mean() if value == 1: self.k_constant = 1 self.const_idx = int(idx) break values.append(value) else: # we did not break, no column of ones pos = (np.array(values) != 0) if pos.any(): # take the first nonzero column self.k_constant = 1 self.const_idx = int(const_idx[pos.argmax()]) else: # only zero columns check_implicit = True elif self.k_constant == 0: check_implicit = True else: # should not be here pass if check_implicit and not hasconst: # look for implicit constant # Compute rank of augmented matrix augmented_exog = np.column_stack( (np.ones(self.exog.shape[0]), self.exog)) rank_augm = np.linalg.matrix_rank(augmented_exog) rank_orig = np.linalg.matrix_rank(self.exog) self.k_constant = int(rank_orig == rank_augm) self.const_idx = None elif hasconst: # Ensure k_constant is 1 any time hasconst is True # even if one is not found self.k_constant = 1 @classmethod def _drop_nans(cls, x, nan_mask): return x[nan_mask] @classmethod def _drop_nans_2d(cls, x, nan_mask): return x[nan_mask][:, nan_mask] @classmethod def handle_missing(cls, endog, exog, missing, **kwargs): """ This returns a dictionary with keys endog, exog and the keys of kwargs. It preserves Nones. """ none_array_names = [] # patsy's already dropped NaNs in y/X missing_idx = kwargs.pop('missing_idx', None) if missing_idx is not None: # y, X already handled by patsy. add back in later. combined = () combined_names = [] if exog is None: none_array_names += ['exog'] elif exog is not None: combined = (endog, exog) combined_names = ['endog', 'exog'] else: combined = (endog,) combined_names = ['endog'] none_array_names += ['exog'] # deal with other arrays combined_2d = () combined_2d_names = [] if len(kwargs): for key, value_array in kwargs.items(): if value_array is None or value_array.ndim == 0: none_array_names += [key] continue # grab 1d arrays if value_array.ndim == 1: combined += (np.asarray(value_array),) combined_names += [key] elif value_array.squeeze().ndim == 1: combined += (np.asarray(value_array),) combined_names += [key] # grab 2d arrays that are _assumed_ to be symmetric elif value_array.ndim == 2: combined_2d += (np.asarray(value_array),) combined_2d_names += [key] else: raise ValueError("Arrays with more than 2 dimensions " "are not yet handled") if missing_idx is not None: nan_mask = missing_idx updated_row_mask = None if combined: # there were extra arrays not handled by patsy combined_nans = _nan_rows(*combined) if combined_nans.shape[0] != nan_mask.shape[0]: raise ValueError("Shape mismatch between endog/exog " "and extra arrays given to model.") # for going back and updated endog/exog updated_row_mask = combined_nans[~nan_mask] nan_mask |= combined_nans # for updating extra arrays only if combined_2d: combined_2d_nans = _nan_rows(combined_2d) if combined_2d_nans.shape[0] != nan_mask.shape[0]: raise ValueError("Shape mismatch between endog/exog " "and extra 2d arrays given to model.") if updated_row_mask is not None: updated_row_mask |= combined_2d_nans[~nan_mask] else: updated_row_mask = combined_2d_nans[~nan_mask] nan_mask |= combined_2d_nans else: nan_mask = _nan_rows(*combined) if combined_2d: nan_mask = _nan_rows(*(nan_mask[:, None],) + combined_2d) if not np.any(nan_mask): # no missing do not do anything combined = dict(zip(combined_names, combined)) if combined_2d: combined.update(dict(zip(combined_2d_names, combined_2d))) if none_array_names: combined.update(dict(zip(none_array_names, [None] * len(none_array_names)))) if missing_idx is not None: combined.update({'endog': endog}) if exog is not None: combined.update({'exog': exog}) return combined, [] elif missing == 'raise': raise MissingDataError("NaNs were encountered in the data") elif missing == 'drop': nan_mask = ~nan_mask drop_nans = lambda x: cls._drop_nans(x, nan_mask) drop_nans_2d = lambda x: cls._drop_nans_2d(x, nan_mask) combined = dict(zip(combined_names, lmap(drop_nans, combined))) if missing_idx is not None: if updated_row_mask is not None: updated_row_mask = ~updated_row_mask # update endog/exog with this new information endog = cls._drop_nans(endog, updated_row_mask) if exog is not None: exog = cls._drop_nans(exog, updated_row_mask) combined.update({'endog': endog}) if exog is not None: combined.update({'exog': exog}) if combined_2d: combined.update(dict(zip(combined_2d_names, lmap(drop_nans_2d, combined_2d)))) if none_array_names: combined.update(dict(zip(none_array_names, [None] * len(none_array_names)))) return combined, np.where(~nan_mask)[0].tolist() else: raise ValueError("missing option %s not understood" % missing) def _convert_endog_exog(self, endog, exog): # for consistent outputs if endog is (n,1) yarr = self._get_yarr(endog) xarr = None if exog is not None: xarr = self._get_xarr(exog) if xarr.ndim == 1: xarr = xarr[:, None] if xarr.ndim != 2: raise ValueError("exog is not 1d or 2d") return yarr, xarr @cache_writable() def ynames(self): endog = self.orig_endog ynames = self._get_names(endog) if not ynames: ynames = _make_endog_names(self.endog) if len(ynames) == 1: return ynames[0] else: return list(ynames) @cache_writable() def xnames(self): exog = self.orig_exog if exog is not None: xnames = self._get_names(exog) if not xnames: xnames = _make_exog_names(self.exog) return list(xnames) return None @property def param_names(self): # for handling names of 'extra' parameters in summary, etc. return self._param_names or self.xnames @param_names.setter def param_names(self, values): self._param_names = values @property def cov_names(self): """ Labels for covariance matrices In multidimensional models, each dimension of a covariance matrix differs from the number of param_names. If not set, returns param_names """ # for handling names of covariance names in multidimensional models if self._cov_names is not None: return self._cov_names return self.param_names @cov_names.setter def cov_names(self, value): # for handling names of covariance names in multidimensional models self._cov_names = value @cache_readonly def row_labels(self): exog = self.orig_exog if exog is not None: row_labels = self._get_row_labels(exog) else: endog = self.orig_endog row_labels = self._get_row_labels(endog) return row_labels def _get_row_labels(self, arr): return None def _get_names(self, arr): if isinstance(arr, DataFrame): if isinstance(arr.columns, MultiIndex): # Flatten MultiIndexes into "simple" column names return ['_'.join((level for level in c if level)) for c in arr.columns] else: return list(arr.columns) elif isinstance(arr, Series): if arr.name: return [arr.name] else: return else: try: return arr.dtype.names except AttributeError: pass return None def _get_yarr(self, endog): if data_util._is_structured_ndarray(endog): endog = data_util.struct_to_ndarray(endog) endog = np.asarray(endog) if len(endog) == 1: # never squeeze to a scalar if endog.ndim == 1: return endog elif endog.ndim > 1: return np.asarray([endog.squeeze()]) return endog.squeeze() def _get_xarr(self, exog): if data_util._is_structured_ndarray(exog): exog = data_util.struct_to_ndarray(exog) return np.asarray(exog) def _check_integrity(self): if self.exog is not None: if len(self.exog) != len(self.endog): raise ValueError("endog and exog matrices are different sizes") def wrap_output(self, obj, how='columns', names=None): if how == 'columns': return self.attach_columns(obj) elif how == 'rows': return self.attach_rows(obj) elif how == 'cov': return self.attach_cov(obj) elif how == 'dates': return self.attach_dates(obj) elif how == 'columns_eq': return self.attach_columns_eq(obj) elif how == 'cov_eq': return self.attach_cov_eq(obj) elif how == 'generic_columns': return self.attach_generic_columns(obj, names) elif how == 'generic_columns_2d': return self.attach_generic_columns_2d(obj, names) elif how == 'ynames': return self.attach_ynames(obj) elif how == 'multivariate_confint': return self.attach_mv_confint(obj) else: return obj def attach_columns(self, result): return result def attach_columns_eq(self, result): return result def attach_cov(self, result): return result def attach_cov_eq(self, result): return result def attach_rows(self, result): return result def attach_dates(self, result): return result def attach_mv_confint(self, result): return result def attach_generic_columns(self, result, *args, **kwargs): return result def attach_generic_columns_2d(self, result, *args, **kwargs): return result def attach_ynames(self, result): return result class PatsyData(ModelData): def _get_names(self, arr): return arr.design_info.column_names class PandasData(ModelData): """ Data handling class which knows how to reattach pandas metadata to model results """ def _convert_endog_exog(self, endog, exog=None): #TODO: remove this when we handle dtype systematically endog = np.asarray(endog) exog = exog if exog is None else np.asarray(exog) if endog.dtype == object or exog is not None and exog.dtype == object: raise ValueError("Pandas data cast to numpy dtype of object. " "Check input data with np.asarray(data).") return super(PandasData, self)._convert_endog_exog(endog, exog) @classmethod def _drop_nans(cls, x, nan_mask): if isinstance(x, (Series, DataFrame)): return x.loc[nan_mask] else: # extra arguments could be plain ndarrays return super(PandasData, cls)._drop_nans(x, nan_mask) @classmethod def _drop_nans_2d(cls, x, nan_mask): if isinstance(x, (Series, DataFrame)): return x.loc[nan_mask].loc[:, nan_mask] else: # extra arguments could be plain ndarrays return super(PandasData, cls)._drop_nans_2d(x, nan_mask) def _check_integrity(self): endog, exog = self.orig_endog, self.orig_exog # exog can be None and we could be upcasting one or the other if (exog is not None and (hasattr(endog, 'index') and hasattr(exog, 'index')) and not self.orig_endog.index.equals(self.orig_exog.index)): raise ValueError("The indices for endog and exog are not aligned") super(PandasData, self)._check_integrity() def _get_row_labels(self, arr): try: return arr.index except AttributeError: # if we've gotten here it's because endog is pandas and # exog is not, so just return the row labels from endog return self.orig_endog.index def attach_generic_columns(self, result, names): # get the attribute to use column_names = getattr(self, names, None) return Series(result, index=column_names) def attach_generic_columns_2d(self, result, rownames, colnames=None): colnames = colnames or rownames rownames = getattr(self, rownames, None) colnames = getattr(self, colnames, None) return DataFrame(result, index=rownames, columns=colnames) def attach_columns(self, result): # this can either be a 1d array or a scalar # do not squeeze because it might be a 2d row array # if it needs a squeeze, the bug is elsewhere if result.ndim <= 1: return Series(result, index=self.param_names) else: # for e.g., confidence intervals return DataFrame(result, index=self.param_names) def attach_columns_eq(self, result): return DataFrame(result, index=self.xnames, columns=self.ynames) def attach_cov(self, result): return DataFrame(result, index=self.cov_names, columns=self.cov_names) def attach_cov_eq(self, result): return DataFrame(result, index=self.ynames, columns=self.ynames) def attach_rows(self, result): # assumes if len(row_labels) > len(result) it's bc it was truncated # at the front, for AR lags, for example squeezed = result.squeeze() k_endog = np.array(self.ynames, ndmin=1).shape[0] if k_endog > 1 and squeezed.shape == (k_endog,): squeezed = squeezed[None, :] # May be zero-dim, for example in the case of forecast one step in tsa if squeezed.ndim < 2: return Series(squeezed, index=self.row_labels[-len(result):]) else: return DataFrame(result, index=self.row_labels[-len(result):], columns=self.ynames) def attach_dates(self, result): squeezed = result.squeeze() k_endog = np.array(self.ynames, ndmin=1).shape[0] if k_endog > 1 and squeezed.shape == (k_endog,): squeezed = np.asarray(squeezed)[None, :] # May be zero-dim, for example in the case of forecast one step in tsa if squeezed.ndim < 2: return Series(squeezed, index=self.predict_dates) else: return DataFrame(np.asarray(result), index=self.predict_dates, columns=self.ynames) def attach_mv_confint(self, result): return DataFrame(result.reshape((-1, 2)), index=self.cov_names, columns=['lower', 'upper']) def attach_ynames(self, result): squeezed = result.squeeze() # May be zero-dim, for example in the case of forecast one step in tsa if squeezed.ndim < 2: return Series(squeezed, name=self.ynames) else: return
DataFrame(result, columns=self.ynames)
pandas.DataFrame
#as duas bases estão nessa aplicação #import matplotlib #import matplotlib.mlab as mlab #import matplotlib.gridspec as gridspec #from scipy.misc import electrocardiogram #from scipy import stats import matplotlib.pyplot as plt from scipy.signal import find_peaks import pandas as pd import numpy as np from scipy.stats import kurtosis, skew #Funções #Média def media(lista): return (sum(lista)/len(lista)) def comportamento(s, lista_dif, lista_dif_index, peaks): for i in range(len(s)-1): sub = abs(s[i]-s[i+1]) sub_index = abs(peaks[i]-peaks[i+1]) lista_dif.append(sub) lista_dif_index.append(sub_index) def peaks(lista): #distancia = frequencia amostral peaks, _ = find_peaks(lista, distance=fs//2) np.diff(peaks) return peaks def num_peaks(lista, peaks): #número de picos num_peaks = np.zeros(len(peaks)-2) for i in range(len(peaks)-2): num_peaks[i]=lista[peaks[i]]-lista[peaks[i+1]] return num_peaks def plot_comport(lista, peaks): #plot de comportamento dos picos s = lista[peaks] lista_dif = [] lista_dif_index = [] return comportamento(s, lista_dif, lista_dif_index, peaks) # REFERENCIA # https://media.readthedocs.org/pdf/python-heart-rate-analysis-toolkit/latest/python-heart-rate-analysis-toolkit.pdf # x = electrocardiogram()#[2000:4000] data = pd.read_csv('lista2.txt') data2 =
pd.read_csv('lista3.txt')
pandas.read_csv
import decimal import numpy as np from numpy import iinfo import pytest import pandas as pd from pandas import to_numeric from pandas.util import testing as tm class TestToNumeric(object): def test_empty(self): # see gh-16302 s = pd.Series([], dtype=object) res = to_numeric(s) expected = pd.Series([], dtype=np.int64) tm.assert_series_equal(res, expected) # Original issue example res = to_numeric(s, errors='coerce', downcast='integer') expected = pd.Series([], dtype=np.int8) tm.assert_series_equal(res, expected) def test_series(self): s = pd.Series(['1', '-3.14', '7']) res = to_numeric(s) expected = pd.Series([1, -3.14, 7]) tm.assert_series_equal(res, expected) s = pd.Series(['1', '-3.14', 7]) res = to_numeric(s) tm.assert_series_equal(res, expected) def test_series_numeric(self): s = pd.Series([1, 3, 4, 5], index=list('ABCD'), name='XXX') res = to_numeric(s) tm.assert_series_equal(res, s) s = pd.Series([1., 3., 4., 5.], index=list('ABCD'), name='XXX') res = to_numeric(s) tm.assert_series_equal(res, s) # bool is regarded as numeric s = pd.Series([True, False, True, True], index=list('ABCD'), name='XXX') res = to_numeric(s) tm.assert_series_equal(res, s) def test_error(self): s = pd.Series([1, -3.14, 'apple']) msg = 'Unable to parse string "apple" at position 2' with pytest.raises(ValueError, match=msg): to_numeric(s, errors='raise') res = to_numeric(s, errors='ignore') expected = pd.Series([1, -3.14, 'apple']) tm.assert_series_equal(res, expected) res = to_numeric(s, errors='coerce') expected = pd.Series([1, -3.14, np.nan]) tm.assert_series_equal(res, expected) s = pd.Series(['orange', 1, -3.14, 'apple']) msg = 'Unable to parse string "orange" at position 0' with pytest.raises(ValueError, match=msg): to_numeric(s, errors='raise') def test_error_seen_bool(self): s = pd.Series([True, False, 'apple']) msg = 'Unable to parse string "apple" at position 2' with pytest.raises(ValueError, match=msg): to_numeric(s, errors='raise') res = to_numeric(s, errors='ignore') expected = pd.Series([True, False, 'apple']) tm.assert_series_equal(res, expected) # coerces to float res = to_numeric(s, errors='coerce') expected = pd.Series([1., 0., np.nan]) tm.assert_series_equal(res, expected) def test_list(self): s = ['1', '-3.14', '7'] res = to_numeric(s) expected = np.array([1, -3.14, 7]) tm.assert_numpy_array_equal(res, expected) def test_list_numeric(self): s = [1, 3, 4, 5] res = to_numeric(s) tm.assert_numpy_array_equal(res, np.array(s, dtype=np.int64)) s = [1., 3., 4., 5.] res = to_numeric(s) tm.assert_numpy_array_equal(res, np.array(s)) # bool is regarded as numeric s = [True, False, True, True] res = to_numeric(s) tm.assert_numpy_array_equal(res, np.array(s)) def test_numeric(self): s = pd.Series([1, -3.14, 7], dtype='O') res = to_numeric(s) expected = pd.Series([1, -3.14, 7]) tm.assert_series_equal(res, expected) s = pd.Series([1, -3.14, 7]) res = to_numeric(s) tm.assert_series_equal(res, expected) # GH 14827 df = pd.DataFrame(dict( a=[1.2, decimal.Decimal(3.14), decimal.Decimal("infinity"), '0.1'], b=[1.0, 2.0, 3.0, 4.0], )) expected = pd.DataFrame(dict( a=[1.2, 3.14, np.inf, 0.1], b=[1.0, 2.0, 3.0, 4.0], )) # Test to_numeric over one column df_copy = df.copy() df_copy['a'] = df_copy['a'].apply(to_numeric) tm.assert_frame_equal(df_copy, expected) # Test to_numeric over multiple columns df_copy = df.copy() df_copy[['a', 'b']] = df_copy[['a', 'b']].apply(to_numeric) tm.assert_frame_equal(df_copy, expected) def test_numeric_lists_and_arrays(self): # Test to_numeric with embedded lists and arrays df = pd.DataFrame(dict( a=[[decimal.Decimal(3.14), 1.0], decimal.Decimal(1.6), 0.1] )) df['a'] = df['a'].apply(to_numeric) expected = pd.DataFrame(dict( a=[[3.14, 1.0], 1.6, 0.1], )) tm.assert_frame_equal(df, expected) df = pd.DataFrame(dict( a=[np.array([decimal.Decimal(3.14), 1.0]), 0.1] )) df['a'] = df['a'].apply(to_numeric) expected = pd.DataFrame(dict( a=[[3.14, 1.0], 0.1], )) tm.assert_frame_equal(df, expected) def test_all_nan(self): s = pd.Series(['a', 'b', 'c']) res = to_numeric(s, errors='coerce') expected = pd.Series([np.nan, np.nan, np.nan]) tm.assert_series_equal(res, expected) @pytest.mark.parametrize("errors", [None, "ignore", "raise", "coerce"]) def test_type_check(self, errors): # see gh-11776 df = pd.DataFrame({"a": [1, -3.14, 7], "b": ["4", "5", "6"]}) kwargs = dict(errors=errors) if errors is not None else dict() error_ctx = pytest.raises(TypeError, match="1-d array") with error_ctx: to_numeric(df, **kwargs) def test_scalar(self): assert pd.to_numeric(1) == 1 assert pd.to_numeric(1.1) == 1.1 assert pd.to_numeric('1') == 1 assert pd.to_numeric('1.1') == 1.1 with pytest.raises(ValueError): to_numeric('XX', errors='raise') assert to_numeric('XX', errors='ignore') == 'XX' assert np.isnan(to_numeric('XX', errors='coerce')) def test_numeric_dtypes(self): idx = pd.Index([1, 2, 3], name='xxx') res = pd.to_numeric(idx) tm.assert_index_equal(res, idx) res = pd.to_numeric(pd.Series(idx, name='xxx')) tm.assert_series_equal(res, pd.Series(idx, name='xxx')) res = pd.to_numeric(idx.values) tm.assert_numpy_array_equal(res, idx.values) idx = pd.Index([1., np.nan, 3., np.nan], name='xxx') res = pd.to_numeric(idx) tm.assert_index_equal(res, idx) res = pd.to_numeric(pd.Series(idx, name='xxx')) tm.assert_series_equal(res, pd.Series(idx, name='xxx')) res = pd.to_numeric(idx.values) tm.assert_numpy_array_equal(res, idx.values) def test_str(self): idx = pd.Index(['1', '2', '3'], name='xxx') exp = np.array([1, 2, 3], dtype='int64') res = pd.to_numeric(idx) tm.assert_index_equal(res, pd.Index(exp, name='xxx')) res = pd.to_numeric(pd.Series(idx, name='xxx')) tm.assert_series_equal(res, pd.Series(exp, name='xxx')) res = pd.to_numeric(idx.values) tm.assert_numpy_array_equal(res, exp) idx = pd.Index(['1.5', '2.7', '3.4'], name='xxx') exp = np.array([1.5, 2.7, 3.4]) res = pd.to_numeric(idx) tm.assert_index_equal(res, pd.Index(exp, name='xxx')) res = pd.to_numeric(pd.Series(idx, name='xxx')) tm.assert_series_equal(res, pd.Series(exp, name='xxx')) res = pd.to_numeric(idx.values) tm.assert_numpy_array_equal(res, exp) def test_datetime_like(self, tz_naive_fixture): idx = pd.date_range("20130101", periods=3, tz=tz_naive_fixture, name="xxx") res = pd.to_numeric(idx) tm.assert_index_equal(res,
pd.Index(idx.asi8, name="xxx")
pandas.Index
import numpy as np import pandas as pd class PricingInstance(object): """Instance of the pricing problem""" def __init__(self, rp, rn, Xp, Xn, v0, z0): self.rp = rp self.rn = rn self.Xp = Xp self.Xn = Xn self.v0 = v0 self.z0 = z0 def eval_singletons(self, lambda1): """Evaluate all singleton solutions (adding one literal)""" self.Rp = np.dot(self.rp, self.Xp) self.Rn = np.dot(self.rn, self.Xn) self.v1 = self.v0 - self.Rp - self.Rn + lambda1 self.v1 = pd.Series(self.v1, index=self.Xp.columns) def compute_LB(self, lambda1): """Compute lower bound on higher-order solutions""" Rp0 = self.rp.sum() if np.ndim(lambda1): self.LB = np.array([]) else: self.LB = np.minimum(np.cumsum(np.sort(self.Rp)[::-1])[1:], Rp0) self.LB += np.sort(self.Rn)[-2::-1] self.LB -= lambda1 * np.arange(2, len(self.Rp)+1) self.LB = self.v0 - self.LB # Lower bound specific to each singleton solution self.LB1 = self.v1 + self.Rp - Rp0 + lambda1 if len(self.LB): self.LB1[self.LB1 < self.LB.min()] = self.LB.min() def beam_search_K1(r, X, lambda0, lambda1, UB=0, D=10, B=5, wLB=0.5, eps=1e-6, stopEarly=True): """Beam search to generate SINGLE SOLUTION (K = 1) to pricing problem Problem parameters: r = cost vector (residuals) X = binary feature DataFrame lambda0 = fixed cost of a term lambda1 = cost per literal Algorithm parameters: UB = initial upper bound on value of solutions D = maximum degree B = beam width wLB = weight on lower bound in evaluating nodes eps = numerical tolerance on comparisons stopEarly = stop after current degree once solution is found """ # Initialize output vOut = np.array([]) zOut = pd.Series(index=X.columns) # Initialize queue with root instance # Separate data according to positive and negative residuals rp = r[r > 0] rn = r[r < 0] Xp = 1 - X.loc[r > 0] Xn = 1 - X.loc[r < 0] instCurr = [PricingInstance(rp, rn, Xp, Xn, r.sum() + lambda0, pd.Series(0, index=zOut.index))] # Iterate over increasing degree while queue is non-empty deg = 0 while (not len(vOut) or not stopEarly) and len(instCurr) and deg < D: deg += 1 # Initialize list of children to process vNext = np.array([]) vNextMax = np.inf zNext = pd.DataFrame([], index=X.columns) idxInstNext = np.array([], dtype=int) idxFeatNext = np.array([]) # Process instances in queue for (idxInst, inst) in enumerate(instCurr): # Evaluate all singleton solutions inst.eval_singletons(lambda1) # Solutions that improve on current output vCand = inst.v1[inst.v1 < UB - eps] if len(vCand): # Update output with best of these solutions idxMin = vCand.idxmin() UB = vCand[idxMin] vOut = np.array([UB]) zOut = inst.z0.copy() zOut[idxMin] = 1 # Compute lower bounds on higher-degree solutions inst.compute_LB(lambda1) # Evaluate children using weighted average of their costs and LBs vChild = (1 - wLB) * inst.v1 + wLB * inst.LB1 # Best children with potential to improve on current output and current candidates (allow for duplicate removal) vChild = vChild[(inst.LB1 < UB - eps) & (vChild < vNextMax - eps)].sort_values()[:B+idxInst] if len(vChild): # Feature indicators of these best children zChild = pd.DataFrame(zOut.index.values[:,np.newaxis] == vChild.index.values, index=zOut.index).astype(int) zChild = zChild.add(inst.z0, axis=0) # Append to current candidates vNext = np.append(vNext, vChild.values) zNext = pd.concat([zNext, zChild], axis=1, ignore_index=True) idxInstNext = np.append(idxInstNext, np.full(B+idxInst, idxInst)) idxFeatNext = np.append(idxFeatNext, vChild.index.values) # Remove duplicates _, idxUniq = np.unique(zNext, return_index=True, axis=1) vNext = vNext[idxUniq] zNext = zNext.iloc[:,idxUniq] idxInstNext = idxInstNext[idxUniq] idxFeatNext = idxFeatNext[idxUniq] # Update candidates idxBest = np.argsort(vNext)[:B] vNext = vNext[idxBest] if len(vNext): vNextMax = vNext[-1] zNext = zNext.iloc[:,idxBest] zNext.columns = range(zNext.shape[1]) idxInstNext = idxInstNext[idxBest] idxFeatNext = idxFeatNext[idxBest] # Instances to process in next iteration instNext = [] for (idxInst, i, idxz) in zip(idxInstNext, idxFeatNext, zNext): # Create pricing instance # Remove covered rows rowKeep = instCurr[idxInst].Xp[i] == 0 rp = instCurr[idxInst].rp[rowKeep] Xp = instCurr[idxInst].Xp.loc[rowKeep] rowKeep = instCurr[idxInst].Xn[i] == 0 rn = instCurr[idxInst].rn[rowKeep] Xn = instCurr[idxInst].Xn.loc[rowKeep] # Remove redundant features if type(Xp.columns) is pd.MultiIndex: colKeep = pd.Series(Xp.columns.get_level_values(0) != i[0], index=Xp.columns) if i[1] == '<=': thresh = Xp[i[0]].columns.get_level_values(1).to_series().replace('NaN', np.nan).values colKeep[i[0]] = (Xp[i[0]].columns.get_level_values(0) == '>') & (thresh < i[2]) elif i[1] == '>': thresh = Xp[i[0]].columns.get_level_values(1).to_series().replace('NaN', np.nan).values colKeep[i[0]] = (Xp[i[0]].columns.get_level_values(0) == '<=') & (thresh > i[2]) elif i[1] == '!=': colKeep[i[0]] = (Xp[i[0]].columns.get_level_values(0) == '!=') & (Xp[i[0]].columns.get_level_values(1) != i[2]) Xp = Xp.loc[:, colKeep] Xn = Xn.loc[:, colKeep] instNext.append(PricingInstance(rp, rn, Xp, Xn, instCurr[idxInst].v1[i], zNext[idxz])) instCurr = instNext # Conjunctions corresponding to solutions if zOut.count(): zOut = pd.DataFrame(zOut) else: zOut = pd.DataFrame(index=X.columns) aOut = 1 - (np.dot(1 - X, zOut) > 0) return vOut, zOut, aOut def beam_search(r, X, lambda0, lambda1, K=1, UB=0, D=10, B=5, wLB=0.5, eps=1e-6, stopEarly=False): """Beam search to generate solutions to pricing problem Problem parameters: r = cost vector (residuals) X = binary feature DataFrame lambda0 = fixed cost of a term lambda1 = cost per literal Algorithm parameters: K = maximum number of solutions returned UB = initial upper bound on value of solutions D = maximum degree B = beam width wLB = weight on lower bound in evaluating nodes eps = numerical tolerance on comparisons stopEarly = stop after current degree once solution is found """ # Initialize output vOut = np.array([]) zOut = pd.DataFrame(index=X.columns) # Remove redundant rows by grouping by unique feature combinations and summing residual X2 = X.copy() r2 = r # Initialize queue with root instance # Separate data according to positive and negative residuals rp = r2[r2 > 0] rn = r2[r2 < 0] Xp = 1 - X2.loc[r2 > 0] Xn = 1 - X2.loc[r2 < 0] instCurr = [PricingInstance(rp, rn, Xp, Xn, r2.sum() + lambda0, pd.Series(0, index=zOut.index))] # Iterate over increasing degree while queue is non-empty deg = 0 while (not len(vOut) or not stopEarly) and len(instCurr) and deg < D: deg += 1 # Initialize list of children to process vNext = np.array([]) vNextMax = np.inf zNext = pd.DataFrame([], index=X2.columns) idxInstNext = np.array([], dtype=int) idxFeatNext = np.array([]) # Process instances in queue for (idxInst, inst) in enumerate(instCurr): # Evaluate all singleton solutions inst.eval_singletons(lambda1) # Best solutions that also improve on current output (allow for duplicate removal) vCand = inst.v1[inst.v1 < UB - eps].sort_values()[:K+B] if len(vCand): zCand = pd.DataFrame(zOut.index.values[:,np.newaxis] == vCand.index.values, index=zOut.index).astype(int) zCand = zCand.add(inst.z0, axis=0) # Append to current output vOut = np.append(vOut, vCand.values) zOut =
pd.concat([zOut, zCand], axis=1, ignore_index=True)
pandas.concat
#!/usr/bin/env python # -*- coding: utf-8 -*- import sys import os import numpy as np import pandas as pd import datetime as dt import netCDF4 as cdf import matplotlib.pyplot as plt import matplotlib.ticker as mticker import cartopy cartopy.config['data_dir'] = '/data/project/cartopy/' import cartopy.crs as ccrs import cartopy.feature as cfeature from cartopy.feature import NaturalEarthFeature, LAND, COASTLINE, LAKES import json import requests #Import ICOS tools: from icoscp.cpb.dobj import Dobj from icoscp.sparql.runsparql import RunSparql from icoscp.sparql import sparqls my_home = os.getenv('HOME') sys.path.insert(0,my_home+'/new_jupyter/modules') from extra_sparqls import get_station_class, get_icos_stations_atc_samplingheight #, atc_station_tracer_query # paths --- changed for new JupyterHub instance path_stiltweb = '/data/stiltweb/' path_stilt = '/data/stilt/' path_edgar = '/data/stilt/Emissions/' #path_plots = './plots/' #------------------------------------------------------------------------------------------------------------------ def read_icos_data(f_icos,tracer,flag=True): if (len(f_icos)>0): df = Dobj(f_icos.dobj.iloc[0]).getColumns() df.set_index('TIMESTAMP',inplace=True) if flag: if (tracer.lower() == 'mto'): value_cols =[x.replace('-Flag','') for x in df.columns[df.columns.str.contains('Flag')]] for x in value_cols: df[x].loc[df[x+'-Flag']!='O']=np.nan else: df[tracer.lower()].loc[df['Flag']!='O']=np.nan df['Stdev'].loc[df['Flag']!='O']=np.nan else: if (tracer.lower() != 'mto'): df[tracer.lower()].loc[df[tracer.lower()]<0.0]=np.nan df['Stdev'].loc[df['Stdev']<0.0]=np.nan else: df =
pd.DataFrame(None)
pandas.DataFrame
import numpy as np import pandas as pd from datetime import datetime import seaborn as sns import matplotlib.pyplot as plt from sklearn.ensemble import RandomForestClassifier from sklearn.model_selection import train_test_split from sklearn.tree import DecisionTreeClassifier from sklearn.metrics import classification_report, confusion_matrix loan_data = pd.read_csv('C:/Users/PC1/Desktop/GitHub/Decision trees and random forests/LoanStats3a.csv', header=1, skip_blank_lines=False) loan_data = loan_data.dropna(thresh=500, axis=1) df_loan = loan_data.filter(['purpose', 'funded_amnt_inv', 'int_rate', 'installment', 'annual_inc', 'dti', 'earliest_cr_line', 'revol_bal', 'revol_util', 'inq_last_6mths', 'loan_status'], axis=1, ) # separate data by policy code -> 1 = permitted loan, 0 = no loan df1_loan = np.split(df_loan, df_loan[df_loan.isnull().all(axis=1)].index) df1 = df1_loan[0] df2 = df1_loan[3] df1['policy_code'] = 1 df2['policy_code'] = 0 df_loan = df1.append(df2[1:]) # clean column data df_loan['fully_paid'] = np.where(df_loan['loan_status'] == 'Fully Paid', 1, 0) df_loan['log.annual.inc'] = np.log(df_loan['annual_inc']) df_loan['int.rate'] = df_loan['int_rate'].str.rstrip('%').astype('float') / 100.0 df_loan['revol.util'] = df_loan['int_rate'].str.rstrip('%').astype('float') / 100.0 df_loan.drop(['int_rate', 'revol_util', 'annual_inc', 'loan_status'], axis=1, inplace=True) # Determine the number of days individuals have had a credit line end_date = datetime(2011, 12, 31) df_loan['earliest_cr_line'] = pd.to_datetime(df_loan['earliest_cr_line']) df_loan['earliest_cr_line'] = (end_date - df_loan['earliest_cr_line']).dt.days # df_loan = df_loan.fillna({'desc':'none'}) df_loan = df_loan.fillna(0) ## Only 182 rows contain the FICO score so the description column will not be used # df_loan['fico']= np.where(df_loan['desc'].str.contains('fico', case=False), 1,0) # print(len(df_loan[df_loan['fico']==1])) # sns.pairplot(df_loan, hue='policy_code') # plt.show() # Debt to income for the two credit.policy outcomes plt.figure(figsize=(10, 6)) df_loan[df_loan['policy_code'] == 1]['dti'].hist(bins=30, label='Loan approved: Yes', alpha=0.5) df_loan[df_loan['policy_code'] == 0]['dti'].hist(color='red', bins=30, label='Loan approved: No', alpha=0.5) plt.legend() plt.xlabel('Debt to income ratio') plt.ylabel('Individuals') plt.title('Lending club - loan approvals by debt to income ratio') plt.show() # Countplot showing counts of loans by purpose and hue fully paid. ** plt.figure(figsize=(20, 6)) c_plot = sns.countplot(data=df_loan, x='purpose', hue='policy_code', palette='RdBu') plt.xlabel('Purpose', fontweight='bold') plt.ylabel('Count', fontweight='bold') plt.title('Loan status by purpose', fontweight='bold') L = plt.legend() L.get_texts()[0].set_text('Not repaid') L.get_texts()[1].set_text('Repaid') plt.tight_layout() # Compare log of debt to income ratio to the interest rate sns.jointplot(data=df_loan, x='log.annual.inc', y='int.rate', color='indigo') plt.show() # Compare the trend between fully_paid and policy_code. sns.set_style('darkgrid') sns.lmplot(data=df_loan, x='log.annual.inc', y='int.rate', hue='policy_code', legend_out=True, col='fully_paid', palette='Set1') plt.show() ''' A decision tree or random forest model would likely be able to predict the policy_code since there is a little separation between groups (ex. sns.pairplot(df_loan)) ''' # Generate separate columns of dummy variables from the purpose column cat_feats = ['purpose'] df_loan =
pd.get_dummies(df_loan, columns=cat_feats, drop_first=True)
pandas.get_dummies
import logging import os import math import glob import pyfastaq import pysam import pandas as pd from Bio import pairwise2, SeqIO from cluster_vcf_records import vcf_clusterer, vcf_file_read from minos import dependencies, dnadiff, plots, utils class Error (Exception): pass class EvaluateRecall: '''tto write''' def __init__(self, truth_vcf_file, truth_vcf_ref, query_vcf_file, query_vcf_ref, outprefix, flank_length=31, merge_length=None, filter_and_cluster_vcf=True, discard_ref_calls=True, allow_flank_mismatches=True, exclude_regions_bed_file=None, max_soft_clipped=3): self.truth_vcf_file = os.path.abspath(truth_vcf_file) self.truth_vcf_ref = os.path.abspath(truth_vcf_ref) self.query_vcf_file = os.path.abspath(query_vcf_file) self.query_vcf_ref = os.path.abspath(query_vcf_ref) self.sam_file_out = os.path.abspath(outprefix + '.sam') self.seqs_out_truth = os.path.abspath(outprefix + '.truth.fa') self.filtered_query_vcf = os.path.abspath(outprefix + '.query.filter.vcf') self.filtered_truth_vcf = os.path.abspath(outprefix + '.truth.filter.vcf') self.clustered_vcf_query = os.path.abspath(outprefix + '.query.filter.cluster.vcf') self.clustered_vcf_truth = os.path.abspath(outprefix + '.truth.filter.cluster.vcf') self.seqs_out_query = os.path.abspath(outprefix + '.query.fa') self.sam_summary = os.path.abspath(outprefix + '.summary.tsv') self.stats_out = os.path.abspath(outprefix + '.stats.tsv') self.gt_conf_hist_out = os.path.abspath(outprefix + '.gt_conf_hist.tsv') self.flank_length = flank_length self.merge_length = flank_length if merge_length is None else merge_length self.filter_and_cluster_vcf = filter_and_cluster_vcf self.discard_ref_calls = discard_ref_calls self.allow_flank_mismatches = allow_flank_mismatches if self.filter_and_cluster_vcf: self.vcf_to_check_truth = self.clustered_vcf_truth self.vcf_to_check_query = self.clustered_vcf_query else: self.vcf_to_check_truth = self.truth_vcf_file self.vcf_to_check_query = self.query_vcf_file self.exclude_regions = EvaluateRecall._load_exclude_regions_bed_file(exclude_regions_bed_file) self.max_soft_clipped = max_soft_clipped self.number_ns = 5 @classmethod def _load_exclude_regions_bed_file(cls, infile): regions = {} if infile is not None: with open(infile) as f: for line in f: fields = line.rstrip().split('\t') if fields[0] not in regions: regions[fields[0]] = [] start = int(fields[1]) end = int(fields[2]) - 1 regions[fields[0]].append(pyfastaq.intervals.Interval(start, end)) for ref_name in regions: pyfastaq.intervals.merge_overlapping_in_list(regions[ref_name]) return regions @classmethod def _interval_intersects_an_interval_in_list(cls, interval, interval_list): # This could be faster by doing something like a binary search. # But we're looking for points in intervals, so fiddly to implement. # Not expecting a log interval list, so just do a simple check # from start to end for now i = 0 while i < len(interval_list) and interval.start > interval_list[i].end: i += 1 return i < len(interval_list) and interval.intersects(interval_list[i]) @classmethod def _filter_vcf_for_clustering(cls, infile, outfile, discard_ref_calls=True): header_lines, vcf_records = vcf_file_read.vcf_file_to_dict(infile, sort=True, homozygous_only=False, remove_asterisk_alts=True, remove_useless_start_nucleotides=True) with open(outfile, 'w') as f: print(*header_lines, sep='\n', file=f) for ref_name in vcf_records: for vcf_record in vcf_records[ref_name]: if vcf_record.FILTER == 'MISMAPPED_UNPLACEABLE': continue if vcf_record.FORMAT is None or 'GT' not in vcf_record.FORMAT: logging.warning('No GT in vcf record:' + str(vcf_record)) continue if vcf_record.REF in [".", ""]: continue genotype = vcf_record.FORMAT['GT'] genotypes = genotype.split('/') called_alleles = set(genotypes) if len(called_alleles) != 1 or (discard_ref_calls and called_alleles == {'0'}) or '.' in called_alleles: continue if len(vcf_record.ALT) > 1: if called_alleles != {'0'}: vcf_record.set_format_key_value('GT', '1/1') try: vcf_record.ALT = [vcf_record.ALT[int(genotypes[0]) - 1]] except: raise Error('BAD VCf line:' + str(vcf_record)) else: vcf_record.set_format_key_value('GT', '0/0') vcf_record.ALT = [vcf_record.ALT[0]] if vcf_record.ALT[0] in [".",""]: continue if vcf_record.FORMAT['GT'] == '0': vcf_record.FORMAT['GT'] = '0/0' elif vcf_record.FORMAT['GT'] == '1': vcf_record.FORMAT['GT'] = '1/1' if 'GL' in vcf_record.FORMAT.keys() and 'GT_CONF' not in vcf_record.FORMAT.keys(): likelihoods = vcf_record.FORMAT['GL'].split(',') assert(len(likelihoods) > 2) if called_alleles == {'0'}: vcf_record.set_format_key_value('GT_CONF',str(float(likelihoods[0]) - float(likelihoods[1]))) else: vcf_record.set_format_key_value('GT_CONF', str(float(likelihoods[int(genotypes[0])]) - float(likelihoods[0]))) if 'SupportFraction' in vcf_record.INFO.keys() and 'GT_CONF' not in vcf_record.FORMAT.keys(): vcf_record.set_format_key_value('GT_CONF', str(float(vcf_record.INFO['SupportFraction'])*100)) print(vcf_record, file=f) @classmethod def _write_vars_plus_flanks_to_fasta(cls, outfile, vcf_records, ref_seqs, flank_length, ref_only=False, number_ns=0): '''Given a dict of vcf records made by vcf_file_read.vcf_file_to_dict(), and its correcsponding file of reference sequences, writes a new fasta file of each ref seq and inferred variant sequence plus flank_length nucleotides added to its start and end. Calls each sequence: ref_name.start_position.vcf_list_index.allele_number where allele_numbers in same order as VCF, with ref seq = allele 0.''' prev_ref_name = None prev_ref_pos = None j = 0 with open(outfile, 'w') as f: for ref_name in sorted(vcf_records): for i, vcf_record in enumerate(vcf_records[ref_name]): start_position, alleles = vcf_record.inferred_var_seqs_plus_flanks(ref_seqs[ref_name], flank_length) for allele_index, allele_seq in enumerate(alleles): if not ref_only or allele_index == 0: seq_name = '.'.join([ref_name, str(start_position + 1), str(j), str(i), str(allele_index)]) allele_seq = allele_seq.replace('.','') for n in range(number_ns): allele_seq = "N" + allele_seq + "N" print('>' + seq_name, allele_seq, sep='\n', file=f) if prev_ref_name == ref_name and prev_ref_pos == start_position: j += 1 else: j = 0 prev_ref_name = ref_name prev_ref_pos = start_position @classmethod def _map_seqs_to_seqs(cls, seqs_file_ref, seqs_file_query, outfile): '''Map seqs_file to ref_file using BWA MEM. Output is SAM file written to outfile''' bwa_binary = dependencies.find_binary('bwa') command = ' '.join([ bwa_binary, 'index', seqs_file_ref, ]) utils.syscall(command) command = ' '.join([ bwa_binary, 'aln', seqs_file_ref, seqs_file_query, '>', outfile + ".tmp", ]) utils.syscall(command) command = ' '.join([ bwa_binary, 'samse', seqs_file_ref, outfile + ".tmp", seqs_file_query, '>', outfile, ]) utils.syscall(command) #os.unlink(outfile + ".tmp") @classmethod def _check_if_sam_match_is_good(cls, sam_record, flank_length, query_sequence=None, allow_mismatches=True, max_soft_clipped=3): logging.debug(f'Checking SAM: {sam_record}') if sam_record.is_unmapped: return 'Unmapped' if not allow_mismatches: try: nm = sam_record.get_tag('NM') except: raise Error('No NM tag found in sam record:' + str(sam_record)) all_mapped = len(sam_record.cigartuples) == 1 and sam_record.cigartuples[0][0] == 0 if all_mapped and nm == 0: logging.debug('SAM record passed no mismatches allowed check') return 'Good' else: logging.debug('SAM record failed no mismatches allowed check') return 'Bad_mismatches' # don't allow too many soft clipped bases if (sam_record.cigartuples[0][0] == 4 and sam_record.cigartuples[0][1] > max_soft_clipped) \ or (sam_record.cigartuples[-1][0] == 4 and sam_record.cigartuples[-1][1] > max_soft_clipped): logging.debug('SAM record failed soft clipping check') return 'Bad_soft_clipped' if query_sequence is None: query_sequence = sam_record.query_sequence assert query_sequence is not None # if the query is short, which happens when the variant we # are checking is too near the start or end of the ref sequence if len(query_sequence) < 2 * flank_length + 1: # This is an edge case. We don't really know which part # of the query seq we're looking for, so guess length_diff = 2 * flank_length - len(query_sequence) if sam_record.query_alignment_start < 5: alt_seq_end = len(query_sequence) - flank_length - 1 alt_seq_start = min(alt_seq_end, flank_length - length_diff) else: alt_seq_start = flank_length alt_seq_end = max(alt_seq_start, length_diff + len(query_sequence) - flank_length - 1) else: alt_seq_start = flank_length alt_seq_end = len(query_sequence) - flank_length - 1 aligned_pairs = sam_record.get_aligned_pairs(with_seq=True) logging.debug(f'aligned_pairs: {aligned_pairs}') wanted_aligned_pairs = [] current_pos = 0 i = 0 while i < len(query_sequence): if aligned_pairs[i][0] is None: if alt_seq_start - 1 <= current_pos <= alt_seq_end + 1: wanted_aligned_pairs.append(aligned_pairs[i]) elif current_pos > alt_seq_end: break else: current_pos = aligned_pairs[i][0] if alt_seq_start - 1 <= current_pos <= alt_seq_end + 1: wanted_aligned_pairs.append(aligned_pairs[i]) i += 1 logging.debug(f'wanted_aligned_pairs: {wanted_aligned_pairs}') assert len(wanted_aligned_pairs) > 0 for pair in wanted_aligned_pairs: if None in pair or query_sequence[pair[0]].upper() != pair[2].upper(): logging.debug('SAM record failed because mismatch in allele sequence plus 1bp either side') return 'Bad_allele_mismatch' logging.debug('SAM record passed all checks') return 'Good' @classmethod def _index_vcf(cls, vcffile): '''Index VCF file''' bgzip_binary = dependencies.find_binary('bgzip') command = ' '.join([ bgzip_binary, '-c', vcffile, '>', vcffile + ".gz", ]) utils.syscall(command) tabix_binary = dependencies.find_binary('tabix') command = ' '.join([ tabix_binary, '-p', 'vcf', vcffile + ".gz", ]) utils.syscall(command) @classmethod def _parse_sam_file_and_vcf(cls, samfile, query_vcf_file, flank_length, allow_mismatches, exclude_regions=None, max_soft_clipped=3, number_ns=0): if exclude_regions is None: exclude_regions = {} found = [] match_flag = [] correct_allele = [] gt_conf = [] allele = [] samfile_handle = pysam.AlignmentFile(samfile, "r") sam_previous_record_name = None for sam_record in samfile_handle.fetch(until_eof=True): if sam_record.query_name == sam_previous_record_name: continue sam_previous_record_name = sam_record.query_name found_conf = False found_allele = False # see if excluded region in bed file ref, start, ref_num, var_num, allele_num = sam_record.query_name.rsplit('.', maxsplit=5) start = int(start) + flank_length exclude = False for ref_name in exclude_regions.keys(): end = int(start) + 1 interval = pyfastaq.intervals.Interval(start, end) exclude = EvaluateRecall._interval_intersects_an_interval_in_list(interval, exclude_regions[ref_name]) if exclude: found.append('Exclude') gt_conf.append(0) allele.append('0') continue match = EvaluateRecall._check_if_sam_match_is_good(sam_record, flank_length, query_sequence=sam_record.query_sequence, allow_mismatches=allow_mismatches, max_soft_clipped=max_soft_clipped) alignment_start = str(sam_record).split("\t")[3] match_flag.append(match) if match == 'Good': logging.debug('SAM record is a good match') logging.debug('SAM record reference is %s' %sam_record.reference_name) ref_name, expected_start, vcf_pos_index, vcf_record_index, allele_index = sam_record.reference_name.rsplit('.', maxsplit=4) vcf_reader = pysam.VariantFile(query_vcf_file) vcf_interval_start = int(expected_start) + int(alignment_start) + flank_length - 2 - number_ns vcf_interval_end = int(expected_start) + int(alignment_start) + flank_length - number_ns logging.debug('Find VCF records matching ref %s in interval [%i,%i]' %(ref_name, vcf_interval_start, vcf_interval_end)) for i, vcf_record in enumerate(vcf_reader.fetch(ref_name, vcf_interval_start, vcf_interval_end)): if i == int(vcf_pos_index): sample_name = vcf_record.samples.keys()[0] if 'GT' in vcf_record.format.keys() and len(set(vcf_record.samples[sample_name]['GT'])) == 1: if int(allele_index) == int(vcf_record.samples[sample_name]['GT'][0]): found.append('1') allele.append(str(allele_index)) correct_allele.append('1') found_allele = True if 'GT_CONF' in vcf_record.format.keys(): gt_conf.append(int(float(vcf_record.samples[sample_name]['GT_CONF']))) found_conf = True if not found_allele: found.append('0') allele.append('0') correct_allele.append('0') if not found_conf: gt_conf.append(0) assert len(found) == len(gt_conf) assert len(found) == len(allele) assert len(found) == len(match_flag) assert len(found) == len(correct_allele) return found, gt_conf, allele, match_flag, correct_allele @classmethod def _parse_sam_files(cls, truth_vcf_file, samfile, query_vcf_file, outfile, flank_length, allow_mismatches=True, exclude_regions=None, max_soft_clipped=3, number_ns=0): '''Input is the original dnadiff snps file of sites we are searching for and 2 SAM files made by _map_seqs_to_seqs(), which show mappings of snp sites from from the dnadiff snps file to the vcf (i.e. searches if VCF contains an record with the appropriate sequence. Creates a tsv detailing whether the snp difference could be detected and at what GT_CONF threshold. ''' header_lines, vcf_records = vcf_file_read.vcf_file_to_dict(truth_vcf_file, sort=True, homozygous_only=False, remove_asterisk_alts=True, remove_useless_start_nucleotides=True) id = [] ref = [] alt = [] for ref_name in vcf_records: for record in vcf_records[ref_name]: id.append(record.POS) ref.append(record.REF) alt.append(record.ALT[0]) query_found, query_conf, query_allele, query_match_flag, query_allele_flag = EvaluateRecall._parse_sam_file_and_vcf(samfile, query_vcf_file, flank_length, allow_mismatches, exclude_regions, max_soft_clipped, number_ns) assert len(id) == len(query_found) out_df = pd.DataFrame({'id': id, 'ref': ref, 'alt': alt, 'query_found': query_found, 'query_conf': query_conf, 'query_allele': query_allele, 'query_match_flag': query_match_flag, 'query_allele_correct': query_allele_flag}) out_df.to_csv(outfile, sep='\t') @classmethod def _gather_stats(cls, tsv_file): stats = {x: 0 for x in ['total', 'found_vars', 'missed_vars', 'excluded_vars']} gt_conf_hist = {} snps =
pd.read_csv(tsv_file, sep='\t')
pandas.read_csv
# -*- coding: utf-8 -*- """ Zerodha Kite Connect - candlestick pattern scanner @author: <NAME> (http://rasuquant.com/wp/) """ from kiteconnect import KiteConnect import pandas as pd import datetime as dt import os import time import numpy as np from technicalta import * #cwd = os.chdir("D:\\Udemy\\Zerodha KiteConnect API\\1_account_authorization") apikey = '<KEY>' #generate trading session '''access_token = open("access_token.txt",'r').read() key_secret = open("api_key.txt",'r').read().split() kite = KiteConnect(api_key=key_secret[0]) kite.set_access_token(access_token) #get dump of all NSE instruments instrument_dump = kite.instruments("NSE") instrument_df = pd.DataFrame(instrument_dump) ''' def instrumentLookup(instrument_df,symbol): """Looks up instrument token for a given script from instrument dump""" try: return instrument_df[instrument_df.tradingsymbol==symbol].instrument_token.values[0] except: return -1 def fetchOHLC(ticker,interval,duration): """extracts historical data and outputs in the form of dataframe""" instrument = instrumentLookup(instrument_df,ticker) data = pd.DataFrame(kite.historical_data(instrument,dt.date.today()-dt.timedelta(duration), dt.date.today(),interval)) data.set_index("date",inplace=True) return data def doji(ohlc_df): """returns dataframe with doji candle column""" df = ohlc_df.copy() avg_candle_size = abs(df['close']-df['open']).median()#abs(df["close"]- df["open"]).median() df["doji"] = abs(df["close"] - df["open"]) <= (0.05 * avg_candle_size) return df def maru_bozu(ohlc_df): """returns dataframe with maru bozu candle column""" df = ohlc_df.copy() avg_candle_size = abs(df["close"] - df["open"]).median() df["h-c"] = df["high"]-df["close"] df["l-o"] = df["low"]-df["open"] df["h-o"] = df["high"]-df["open"] df["l-c"] = df["low"]-df["close"] df["maru_bozu"] = np.where((df["close"] - df["open"] > 2*avg_candle_size) & \ (df[["h-c","l-o"]].max(axis=1) < 0.005*avg_candle_size),"maru_bozu_green", np.where((df["open"] - df["close"] > 2*avg_candle_size) & \ (abs(df[["h-o","l-c"]]).max(axis=1) < 0.005*avg_candle_size),"maru_bozu_red",False)) df.drop(["h-c","l-o","h-o","l-c"],axis=1,inplace=True) return df def hammer(ohlc_df): """returns dataframe with hammer candle column""" df = ohlc_df.copy() df["hammer"] = (((df["high"] - df["low"])>3*(df["open"] - df["close"])) & \ ((df["close"] - df["low"])/(.001 + df["high"] - df["low"]) > 0.6) & \ ((df["open"] - df["low"])/(.001 + df["high"] - df["low"]) > 0.6)) & \ (abs(df["close"] - df["open"]) > 0.1* (df["high"] - df["low"])) return df def shooting_star(ohlc_df): """returns dataframe with shooting star candle column""" df = ohlc_df.copy() df["sstar"] = (((df["high"] - df["low"])>3*(df["open"] - df["close"])) & \ ((df["high"] - df["close"])/(.001 + df["high"] - df["low"]) > 0.6) & \ ((df["high"] - df["open"])/(.001 + df["high"] - df["low"]) > 0.6)) & \ (abs(df["close"] - df["open"]) > 0.1* (df["high"] - df["low"])) return df def levels(ohlc_day): """returns pivot point and support/resistance levels""" high = round(ohlc_day["high"][-1],2) low = round(ohlc_day["low"][-1],2) close = round(ohlc_day["close"][-1],2) pivot = round((high + low + close)/3,2) r1 = round((2*pivot - low),2) r2 = round((pivot + (high - low)),2) r3 = round((high + 2*(pivot - low)),2) s1 = round((2*pivot - high),2) s2 = round((pivot - (high - low)),2) s3 = round((low - 2*(high - pivot)),2) return (pivot,r1,r2,r3,s1,s2,s3) def trend(ohlc_df,n): "function to assess the trend by analyzing each candle" df = ohlc_df.copy() df["up"] = np.where(df["low"]>=df["low"].shift(1),1,0) df["dn"] = np.where(df["high"]<=df["high"].shift(1),1,0) if df["close"][-1] > df["open"][-1]: if df["up"][-1*n:].sum() >= 0.7*n: return "uptrend" elif df["open"][-1] > df["close"][-1]: if df["dn"][-1*n:].sum() >= 0.7*n: return "downtrend" else: return None def res_sup(ohlc_df,ohlc_day): """calculates closest resistance and support levels for a given candle""" level = ((ohlc_df["close"][-1] + ohlc_df["open"][-1])/2 + (ohlc_df["high"][-1] + ohlc_df["low"][-1])/2)/2 p,r1,r2,r3,s1,s2,s3 = levels(ohlc_day) l_r1=level-r1 l_r2=level-r2 l_r3=level-r3 l_p=level-p l_s1=level-s1 l_s2=level-s2 l_s3=level-s3 lev_ser = pd.Series([l_p,l_r1,l_r2,l_r3,l_s1,l_s2,l_s3],index=["p","r1","r2","r3","s1","s2","s3"]) sup = lev_ser[lev_ser>0].idxmin() res = lev_ser[lev_ser>0].idxmax() return (eval('{}'.format(res)), eval('{}'.format(sup))) def candle_type(ohlc_df): """returns the candle type of the last candle of an OHLC DF""" '''ohlc_df['open']=int(ohlc_df['open']) ohlc_df['close']=int(ohlc_df['close']) ohlc_df['high']=int(ohlc_df['high']) ohlc_df['low']=int(ohlc_df['low'])''' candle = None if doji(ohlc_df)["doji"][-1] == True: candle = "doji" if maru_bozu(ohlc_df)["maru_bozu"][-1] == "maru_bozu_green": candle = "maru_bozu_green" if maru_bozu(ohlc_df)["maru_bozu"][-1] == "maru_bozu_red": candle = "maru_bozu_red" if shooting_star(ohlc_df)["sstar"][-1] == True: candle = "shooting_star" if hammer(ohlc_df)["hammer"][-1] == True: candle = "hammer" return candle def candle_pattern(ohlc_df,ohlc_day): """returns the candle pattern identified""" pattern = None signi = "low" avg_candle_size = abs(ohlc_df["close"] - ohlc_df["open"]).median() sup, res = res_sup(ohlc_df,ohlc_day) if (sup - 1.5*avg_candle_size) < ohlc_df["close"][-1] < (sup + 1.5*avg_candle_size): signi = "HIGH" if (res - 1.5*avg_candle_size) < ohlc_df["close"][-1] < (res + 1.5*avg_candle_size): signi = "HIGH" if candle_type(ohlc_df) == 'doji' \ and ohlc_df["close"][-1] > ohlc_df["close"][-2] \ and ohlc_df["close"][-1] > ohlc_df["open"][-1]: pattern = "doji_bullish" if candle_type(ohlc_df) == 'doji' \ and ohlc_df["close"][-1] < ohlc_df["close"][-2] \ and ohlc_df["close"][-1] < ohlc_df["open"][-1]: pattern = "doji_bearish" if candle_type(ohlc_df) == "maru_bozu_green": pattern = "maru_bozu_bullish" if candle_type(ohlc_df) == "maru_bozu_red": pattern = "maru_bozu_bearish" if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" and candle_type(ohlc_df) == "hammer": pattern = "hanging_man_bearish" if trend(ohlc_df.iloc[:-1,:],7) == "downtrend" and candle_type(ohlc_df) == "hammer": pattern = "hammer_bullish" if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" and candle_type(ohlc_df) == "shooting_star": pattern = "shooting_star_bearish" if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" \ and candle_type(ohlc_df) == "doji" \ and ohlc_df["high"][-1] < ohlc_df["close"][-2] \ and ohlc_df["low"][-1] > ohlc_df["open"][-2]: pattern = "harami_cross_bearish" if trend(ohlc_df.iloc[:-1,:],7) == "downtrend" \ and candle_type(ohlc_df) == "doji" \ and ohlc_df["high"][-1] < ohlc_df["open"][-2] \ and ohlc_df["low"][-1] > ohlc_df["close"][-2]: pattern = "harami_cross_bullish" if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" \ and candle_type(ohlc_df) != "doji" \ and ohlc_df["open"][-1] > ohlc_df["high"][-2] \ and ohlc_df["close"][-1] < ohlc_df["low"][-2]: pattern = "engulfing_bearish" if trend(ohlc_df.iloc[:-1,:],7) == "downtrend" \ and candle_type(ohlc_df) != "doji" \ and ohlc_df["close"][-1] > ohlc_df["high"][-2] \ and ohlc_df["open"][-1] < ohlc_df["low"][-2]: pattern = "engulfing_bullish" return "Significance - {}, Pattern - {}".format(signi,pattern) ############################################################################################## tickers = ["ZEEL","WIPRO","VEDL","ULTRACEMCO","UPL","TITAN","TECHM","TATASTEEL", "TATAMOTORS","TCS","SUNPHARMA","SBIN","SHREECEM","RELIANCE","POWERGRID", "ONGC","NESTLEIND","NTPC","MARUTI","M&M","LT","KOTAKBANK","JSWSTEEL","INFY", "INDUSINDBK","IOC","ITC","ICICIBANK","HDFC","HINDUNILVR","HINDALCO", "HEROMOTOCO","HDFCBANK","HCLTECH","GRASIM","GAIL","EICHERMOT","DRREDDY", "COALINDIA","CIPLA","BRITANNIA","INFRATEL","BHARTIARTL","BPCL","BAJAJFINSV", "BAJFINANCE","BAJAJ-AUTO","AXISBANK","ASIANPAINT","ADANIPORTS","IDEA", "MCDOWELL-N","UBL","NIACL","SIEMENS","SRTRANSFIN","SBILIFE","PNB", "PGHH","PFC","PEL","PIDILITIND","PETRONET","PAGEIND","OFSS","NMDC","NHPC", "MOTHERSUMI","MARICO","LUPIN","L&TFH","INDIGO","IBULHSGFIN","ICICIPRULI", "ICICIGI","HINDZINC","HINDPETRO","HAVELLS","HDFCLIFE","HDFCAMC","GODREJCP", "GICRE","DIVISLAB","DABUR","DLF","CONCOR","COLPAL","CADILAHC","BOSCHLTD", "BIOCON","BERGEPAINT","BANKBARODA","BANDHANBNK","BAJAJHLDNG","DMART", "AUROPHARMA","ASHOKLEY","AMBUJACEM","ADANITRANS","ACC", "WHIRLPOOL","WABCOINDIA","VOLTAS","VINATIORGA","VBL","VARROC","VGUARD", "UNIONBANK","UCOBANK","TRENT","TORNTPOWER","TORNTPHARM","THERMAX","RAMCOCEM", "TATAPOWER","TATACONSUM","TVSMOTOR","TTKPRESTIG","SYNGENE","SYMPHONY", "SUPREMEIND","SUNDRMFAST","SUNDARMFIN","SUNTV","STRTECH","SAIL","SOLARINDS", "SHRIRAMCIT","SCHAEFFLER","SANOFI","SRF","SKFINDIA","SJVN","RELAXO", "RAJESHEXPO","RECLTD","RBLBANK","QUESS","PRESTIGE","POLYCAB","PHOENIXLTD", "PFIZER","PNBHOUSING","PIIND","OIL","OBEROIRLTY","NAM-INDIA","NATIONALUM", "NLCINDIA","NBCC","NATCOPHARM","MUTHOOTFIN","MPHASIS","MOTILALOFS","MINDTREE", "MFSL","MRPL","MANAPPURAM","MAHINDCIE","M&MFIN","MGL","MRF","LTI","LICHSGFIN", "LTTS","KANSAINER","KRBL","JUBILANT","JUBLFOOD","JINDALSTEL","JSWENERGY", "IPCALAB","NAUKRI","IGL","IOB","INDHOTEL","INDIANB","IBVENTURES","IDFCFIRSTB", "IDBI","ISEC","HUDCO","HONAUT","HAL","HEXAWARE","HATSUN","HEG","GSPL", "GUJGASLTD","GRAPHITE","GODREJPROP","GODREJIND","GODREJAGRO","GLENMARK", "GLAXO","GILLETTE","GMRINFRA","FRETAIL","FCONSUMER","FORTIS","FEDERALBNK", "EXIDEIND","ESCORTS","ERIS","ENGINERSIN","ENDURANCE","EMAMILTD","EDELWEISS", "EIHOTEL","LALPATHLAB","DALBHARAT","CUMMINSIND","CROMPTON","COROMANDEL","CUB", "CHOLAFIN","CHOLAHLDNG","CENTRALBK","CASTROLIND","CANBK","CRISIL","CESC", "BBTC","BLUEDART","BHEL","BHARATFORG","BEL","BAYERCROP","BATAINDIA", "BANKINDIA","BALKRISIND","ATUL","ASTRAL","APOLLOTYRE","APOLLOHOSP", "AMARAJABAT","ALKEM","APLLTD","AJANTPHARM","ABFRL","ABCAPITAL","ADANIPOWER", "ADANIGREEN","ADANIGAS","ABBOTINDIA","AAVAS","AARTIIND","AUBANK","AIAENG","3MINDIA"] def main(): for ticker in tickers: try: ohlc = fetchOHLC(ticker, '5minute',5) ohlc_day = fetchOHLC(ticker, 'day',30) ohlc_day = ohlc_day.iloc[:-1,:] cp = candle_pattern(ohlc,ohlc_day) print(ticker, ": ",cp) except: print("skipping for ",ticker) ''' # Continuous execution starttime=time.time() timeout = time.time() + 60*60*1 # 60 seconds times 60 meaning the script will run for 1 hr while time.time() <= timeout: try: print("passthrough at ",time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))) main() time.sleep(300 - ((time.time() - starttime) % 300.0)) # 300 second interval between each new execution except KeyboardInterrupt: print('\n\nKeyboard exception received. Exiting.') exit()''' from pprint import pprint def AlphaData_fxintraday(frombase,to,interval): import requests import json from pprint import pprint global apikey url="https://www.alphavantage.co/query?function=FX_INTRADAY&from_symbol={}&to_symbol={}&interval={}min&apikey={}".format(frombase,to,interval,apikey) data=requests.get(url).json() #pprint(dict(data['Time Series FX ({}min)'.format(interval)]))#['2020-07-31 20:20:00'])#['4. close']) import pandas as pd try: if data: data=data['Time Series FX ({}min)'.format(interval)] df=pd.DataFrame(data).T df['open']=df['1. open'] df['high']=df['2. high'] df['low']=df['3. low'] df['close']=df['4. close'] df=df.drop(['1. open','2. high','3. low', '4. close'], axis=1) return df#data['Time Series FX ({}min)'.format(interval)] except: print("An exception occurred") frombase=['EUR','USD','GBP','AUD','EUR'] to=['USD','JPY','CAD','CNY','CHF','HKD','GBP','KRW'] ''' for j in frombase: for i in to: pprint('{}/{} in process'.format(i,j)) data=AlphaData_intraday(i,j,60) pprint('{}/{} Done'.format(i,j)) time.sleep(30) ''' def AlphaData_fxdaily(frombase,to): import requests import json from pprint import pprint global apikey url="https://www.alphavantage.co/query?function=FX_DAILY&from_symbol={}&to_symbol={}&apikey={}".format(frombase,to,apikey) #url="https://www.alphavantage.co/query?function=FX_INTRADAY&from_symbol={}&to_symbol={}&interval={}min&apikey={}".format(frombase,to,interval,apikey) data=requests.get(url).json() #pprint(dict(data['Time Series FX ({}min)'.format(interval)]))#['2020-07-31 20:20:00'])#['4. close']) import pandas as pd try: if data: data=data['Time Series FX (Daily)'] df=pd.DataFrame(data).T df['open']=df['1. open'] df['high']=df['2. high'] df['low']=df['3. low'] df['close']=df['4. close'] df=df.drop(['1. open','2. high','3. low', '4. close'], axis=1) return df#data['Time Series FX ({}min)'.format(interval)] except: print("An exception occurred") ''' for j in frombase: for i in to: pprint('{}/{} in process'.format(i,j)) dataintra=AlphaData_intraday(i,j,5) datadaily=AlphaData_daily(i,j) pprint(dataintra) if len(dataintra) > 0: if len(datadaily) > 0 : pprint(candle_type(dataintra)) #cp = candle_pattern(dataintra,datadaily) pprint('{}/{} Done'.format(i,j)) time.sleep(5)''' ''' for j in frombase: for i in to: pprint('{}/{} in process'.format(i,j)) data=AlphaData_daily(i,j) pprint('{}/{} Done'.format(i,j)) time.sleep(5) ''' def AlphaData_intraday(symbol,interval): import requests import json from pprint import pprint global apikey url="https://www.alphavantage.co/query?function=TIME_SERIES_INTRADAY&symbol={}&interval={}min&apikey={}".format(symbol,interval,apikey) data=requests.get(url).json() #pprint(dict(data['Time Series FX ({}min)'.format(interval)]))#['2020-07-31 20:20:00'])#['4. close']) import pandas as pd try: if data: data=data['Time Series ({}min)'.format(interval)] df=pd.DataFrame(data).T df['open']=df['1. open'] df['high']=df['2. high'] df['low']=df['3. low'] df['close']=df['4. close'] df['volume']=df['5. volume'] df['volume']=df['5. volume'] df=df.drop(['1. open','2. high','3. low', '4. close','5. volume'], axis=1) df['open']=pd.to_numeric(df['open']) df['high']=pd.to_numeric(df['high']) df['low']=pd.to_numeric(df['low']) df['close']=pd.to_numeric(df['close']) df['volume']=pd.to_numeric(df['volume']) return df#data['Time Series FX ({}min)'.format(interval)] except: print("An exception occurred") def AlphaData_daily(symbol): import requests import json from pprint import pprint global apikey url="https://www.alphavantage.co/query?function=TIME_SERIES_DAILY&symbol={}&apikey={}".format(symbol,apikey) #url="https://www.alphavantage.co/query?function=FX_INTRADAY&from_symbol={}&to_symbol={}&interval={}min&apikey={}".format(frombase,to,interval,apikey) data=requests.get(url).json() #pprint(dict(data['Time Series FX ({}min)'.format(interval)]))#['2020-07-31 20:20:00'])#['4. close']) import pandas as pd try: if data: data=data['Time Series (Daily)'] df=pd.DataFrame(data).T df['open']=df['1. open'] df['high']=df['2. high'] df['low']=df['3. low'] df['close']=df['4. close'] df['volume']=df['5. volume'] df=df.drop(['1. open','2. high','3. low', '4. close','5. volume'], axis=1) df['open']=pd.to_numeric(df['open']) df['high']=pd.to_numeric(df['high']) df['low']=pd.to_numeric(df['low']) df['close']=pd.to_numeric(df['close']) df['volume']=pd.to_numeric(df['volume']) return df#data['Time Series FX ({}min)'.format(interval)] except: print("An exception occurred") '''' for i in to: pprint('{}/{} in process'.format(i,j)) dataintra=AlphaData_intraday(i,5) datadaily=AlphaData_daily(i) pprint(dataintra) if len(dataintra) > 0: if len(datadaily) > 0 : pprint(candle_type(dataintra)) #cp = candle_pattern(dataintra,datadaily) pprint('{}/{} Done'.format(i,j)) time.sleep(5)''' def main(): for ticker in tickers: try: ohlc = fetchOHLC(ticker, '5minute',5) ohlc_day = fetchOHLC(ticker, 'day',30) ohlc_day = ohlc_day.iloc[:-1,:] cp = candle_pattern(ohlc,ohlc_day) print(ticker, ": ",cp) except: print("skipping for ",ticker) ticks=['atvi','adbe','amd','alxn','algn','goog','googl','amzn','amgn','adi','anss','aapl','amat','asml','adsk','adp','bidu','biib','bmrn','bkng','avgo','cdns','cdw','cern','chtr','chkp','ctas','csco','ctxs','ctsh','cmcsa','cprt','cost','csx','dxcm','docu','dltr','ebay','ea','exc','expe','fb','fast','fisv','fox','foxa','gild','idxx','ilmn','incy','intc','intu','isrg','jd','klac','lrcx','lbtya','lbtyk','lulu','mar','mxim','meli','mchp','mu','msft','mrna','mdlz','mnst','ntap','ntes','nflx','nvda','nxpi','orly','pcar','payx','pypl','pep','qcom','regn','rost','sgen','siri','swks','splk','sbux','snps','tmus','ttwo','tsla','txn','khc','tcom','ulta','vrsn','vrsk','vrtx','wba','wdc','wday','xel','xlnx','zm'] patterns=['Two Crows', 'Three Black Crows', 'Three Inside Up/Down', 'Three-Line Strike', 'Three Outside Up/Down', 'Three Stars In The South', 'Three Advancing White Soldiers', 'Abandoned Baby', 'Advance Block', 'Belt-hold', 'Breakaway', 'Closing Marubozu', 'Concealing Baby Swallow', 'Counterattack', 'Dark Cloud Cover', 'Doji', 'Doji Star', 'Dragonfly Doji', 'Engulfing Pattern', 'Evening Doji Star', 'Evening Star', 'Up/Down-gap side-by-side white lines', 'Gravestone Doji', 'Hammer', 'Hanging Man', 'Harami Pattern', 'Harami Cross Pattern', 'High-Wave Candle', 'Hikkake Pattern', 'Modified Hikkake Pattern', 'Homing Pigeon', 'Identical Three Crows', 'In-Neck Pattern', 'Inverted Hammer', 'Kicking', 'Kicking - bull/bear', 'Ladder Bottom', 'Long Legged Doji', 'Long Line Candle', 'Marubozu', 'Matching Low', 'Mat Hold', 'Morning Doji Star', 'Morning Star', 'On-Neck Pattern', 'Piercing Pattern', 'Rickshaw Man', 'Rising/Falling Three Methods', 'Separating Lines', 'Shooting Star', 'Short Line Candle', 'Spinning Top', 'Stalled Pattern', 'Stick Sandwich', 'Takuri', 'Tasuki Gap', 'Thrusting Pattern', 'Tristar Pattern', 'Unique 3 River', 'Upside Gap Two Crows', 'Upside/Downside Gap Three Methods'] def texterconversion(text): tex=text.replace('/','').replace('-','_').replace(' ','_').replace('(','').replace(')','') return tex def technical_lib(technical,df): open=df['open'] high=df['high'] low=df['low'] close=df['close'] if technical == 'Two_Crows': tech=Two_Crows(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Three_Black_Crows': tech=Three_Black_Crows(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Three_Inside_UpDown': tech=Three_Inside_UpDown(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Three_Line_Strike': tech=Three_Line_Strike(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Three_Outside_UpDown': tech=Three_Outside_UpDown(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Three_Stars_In_The_South': tech=Three_Stars_In_The_South(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Three_Advancing_White_Soldiers': tech=Three_Advancing_White_Soldiers(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Abandoned_Baby': tech=Abandoned_Baby(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Advance_Block': tech=Advance_Block(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Belt_hold': tech=Belt_hold(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Breakaway': tech=Breakaway(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Closing_Marubozu': tech=Closing_Marubozu(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Concealing_Baby_Swallow': tech=Concealing_Baby_Swallow(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Counterattack': tech=Counterattack(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Dark_Cloud_Cover': tech=Dark_Cloud_Cover(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Doji': tech=Doji(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Doji_Star': tech=Doji_Star(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Dragonfly_Doji': tech=Dragonfly_Doji(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Engulfing_Pattern': tech=Engulfing_Pattern(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Evening_Doji_Star': tech=Evening_Doji_Star(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Evening_Star': tech=Evening_Star(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'UpDown_gap_side_by_side_white_lines': tech=UpDown_gap_side_by_side_white_lines(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Gravestone_Doji': tech=Gravestone_Doji(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Hammer': tech=Hammer(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Hanging_Man': tech=Hanging_Man(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Harami_Pattern': tech=Harami_Pattern(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Harami_Cross_Pattern': tech=Harami_Cross_Pattern(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'High_Wave_Candle': tech=High_Wave_Candle(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Hikkake_Pattern': tech=Hikkake_Pattern(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Modified_Hikkake_Pattern': tech=Modified_Hikkake_Pattern(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Homing_Pigeon': tech=Homing_Pigeon(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Identical_Three_Crows': tech=Identical_Three_Crows(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'In_Neck_Pattern': tech=In_Neck_Pattern(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Inverted_Hammer': tech=Inverted_Hammer(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Kicking': tech=Kicking(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Kicking___bullbear': tech=Kicking___bullbear(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Ladder_Bottom': tech=Ladder_Bottom(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Long_Legged_Doji': tech=Long_Legged_Doji(open,high,low,close) tech=pd.DataFrame(tech) tech[0]=(np.where(tech[0] > 0,'{}_bullish'.format(technical),np.where(tech[0] < 0,'{}_bearish'.format(technical),0))) elif technical == 'Long_Line_Candle': tech=Long_Line_Candle(open,high,low,close) tech=
pd.DataFrame(tech)
pandas.DataFrame
#!/usr/bin/python # -*- coding: utf-8 -*- """ Library to execute a exploratory data analysis (EDA). It is an approach to analyzing data sets to summarize their main characteristics, often with visual methods. Primarily EDA is for seeing what the data can tell us beyond the formal modeling or hypothesis testing task. @author: ucaiado Created on 10/20/2016 """ ########################################### # Suppress matplotlib user warnings # Necessary for newer version of matplotlib try: import warnings from IPython import get_ipython import matplotlib as mpl import matplotlib.pyplot as plt import seaborn as sns from collections import defaultdict import json import numpy as np import pandas as pd import StringIO warnings.filterwarnings('ignore', category=UserWarning, module='matplotlib') # Display inline matplotlib plots with IPython get_ipython().run_line_magic('matplotlib', 'inline') # aesthetics sns.set_palette('deep', desat=.6) sns.set_context(rc={'figure.figsize': (8, 4)}) sns.set_style('whitegrid') sns.set_palette(sns.color_palette('Set2', 10)) # loading style sheet get_ipython().run_cell('from IPython.core.display import HTML') get_ipython().run_cell('HTML(open("ipython_style.css").read())') except: pass ########################################### ''' Begin help functions ''' def func_estimator(x): ''' pseudo estimator to be used by poinplot ''' return x[0] ''' End help functions ''' def read_logs(i_desired_trial, s_fname): ''' Return a dictionary with information for the passed log file and trial and the number of trades in the main instrument of the strategy :param i_desired_trial: integer. the trial ID to colect data :param s_fname: string. the name of the log file analized ''' with open(s_fname) as fr: # initiate the returned dictionary ans other control variables d_rtn = {'pnl': defaultdict(dict), 'position': defaultdict(dict), 'duration': defaultdict(dict), 'mid': defaultdict(dict)} f_reward = 0. f_count_step = 0 last_reward = 0. i_trial = 0 i_trades = 0 for idx, row in enumerate(fr): if row == '\n': continue # extract desired information # count the number of trials if ' New Trial will start!' in row: i_trial += 1 f_count_step = 0 f_reward = 0 elif '.update():' in row and i_trial == i_desired_trial: s_aux = row.strip().split(';')[1] s_x = row.split('time = ')[1].split(',')[0] s_date_all = s_x s_x = s_date_all[:-7] s_date = s_x ts_date_all = pd.to_datetime(s_date_all) ts_date = pd.to_datetime(s_date) last_reward = float(s_aux.split('reward = ')[1].split(',')[0]) f_duration = float(s_aux.split('duration = ')[1].split(',')[0]) f_reward += last_reward f_count_step += 1. # extract some data d_rtn['duration'][i_trial][ts_date_all] = f_duration if ', position = ' in s_aux: s_pos = s_aux.split(', position = ')[1].split('}')[0][1:] s_pos = s_pos.replace("'", "") l_pos = [(a.strip(), float(b)) for a, b in [s.split(': ')for s in s_pos.split(',')]] d_rtn['position'][i_trial][ts_date_all] = dict(l_pos) if ', pnl = ' in s_aux: s_action = s_aux.split(', pnl = ')[1].split(',')[0] f_aux = float(s_action) d_rtn['pnl'][i_trial][ts_date_all] = f_aux if 'crossed_prices' in s_aux or 'correction_by_trade' in s_aux: i_trades += 1 if ', inputs = ' in s_aux: s_mid = s_aux.split(', inputs = ')[1].split("{'midPrice':") s_mid = s_mid[1][1:].split('}}')[0] s_mid = s_mid.replace("'", "")[1:] l_pos = [(a.strip(), float(b)) for a, b in [s.split(': ')for s in s_mid.split(',')]] d_rtn['mid'][i_trial][ts_date_all] = dict(l_pos) # finish the loop as soon as the trial is analyzed if i_trial > i_desired_trial: break return d_rtn, i_trades def read_logs2(i_desired_trial, s_fname): ''' Return a dictionary with information for the passed log file and trial and the number of trades in the main instrument of the strategy :param i_desired_trial: integer. the trial ID to colect data :param s_fname: string. the name of the log file analized ''' with open(s_fname) as fr: # initiate the returned dictionary ans other control variables d_rtn = {'pnl': defaultdict(dict), 'position': defaultdict(dict), 'duration': defaultdict(dict), 'mid': defaultdict(dict)} f_reward = 0. f_count_step = 0 last_reward = 0. i_trial = 0 i_trades = 0 for idx, row in enumerate(fr): if row == '\n': continue # extract desired information # count the number of trials if ' New Trial will start!' in row: i_trial += 1 f_count_step = 0 f_reward = 0 elif '.update():' in row and i_trial == i_desired_trial: s_aux = row.strip().split(';')[1] s_x = row.split('time = ')[1].split(',')[0] s_date_all = s_x s_x = s_date_all[:-7] s_date = s_x ts_date_all = pd.to_datetime(s_date_all) ts_date = pd.to_datetime(s_date) last_reward = float(s_aux.split('reward = ')[1].split(',')[0]) f_duration = float(s_aux.split('duration = ')[1].split(',')[0]) f_reward += last_reward f_count_step += 1. # extract some data d_rtn['duration'][i_trial][ts_date_all] = f_duration if ', position = ' in s_aux: s_pos = s_aux.split(', position = ')[1].split('}')[0][1:] s_pos = s_pos.replace("'", "") l_pos = [(a.strip(), float(b)) for a, b in [s.split(': ')for s in s_pos.split(',')]] d_rtn['position'][i_trial][ts_date_all] = dict(l_pos) if ', pnl = ' in s_aux: s_action = s_aux.split(', pnl = ')[1].split(',')[0] f_aux = float(s_action) d_rtn['pnl'][i_trial][ts_date_all] = f_aux if 'crossed_prices' in s_aux or 'correction_by_trade' in s_aux: i_trades += 1 if ', inputs = ' in s_aux: s_mid = s_aux.split(', inputs = ')[1].split("{'midPrice':") s_mid = s_mid[0].split(', position =')[0] s_mid = s_mid.replace("'", '"').replace('None', '0') l_mid = json.loads(s_mid) s_mid = s_mid.replace("'", "")[1:] l_mid = [(s_key, (float(x))) for s_key, x in l_mid['midPrice'].iteritems()] d_rtn['mid'][i_trial][ts_date_all] = dict(l_mid) # finish the loop as soon as the trial is analyzed if i_trial > i_desired_trial: break return d_rtn, i_trades def read_logs_to_form_spread(i_desired_trial, s_fname): ''' Return a dictionary with information for the passed log file and trial and the number of trades in the main instrument of the strategy (just F21 and F19) :param i_desired_trial: integer. the trial ID to colect data :param s_fname: string. the name of the log file analized ''' with open(s_fname) as fr: # initiate the returned dictionary ans other control variables d_rtn = {'pnl': defaultdict(dict), 'position': defaultdict(dict), 'mid': defaultdict(dict), 'duration': defaultdict(dict), 'TOB_F21': defaultdict(dict), 'TOB_F19': defaultdict(dict), 'MY_PRICES': defaultdict(dict), 'EXEC': defaultdict(dict), 'LAST_SPREAD': defaultdict(dict)} # where I am most aggres f_reward = 0. f_count_step = 0 last_reward = 0. i_trial = 0 i_trades = 0 l_trade_actions = ['TAKE', 'crossed_prices', 'correction_by_trade', 'HIT'] for idx, row in enumerate(fr): if row == '\n': continue # extract desired information # count the number of trials if ' New Trial will start!' in row: i_trial += 1 f_count_step = 0 f_reward = 0 elif '.update():' in row and i_trial == i_desired_trial: s_aux = row.strip().split(';')[1] s_x = row.split('time = ')[1].split(',')[0] s_date_all = s_x s_x = s_date_all[:-7] s_date = s_x ts_date_all = pd.to_datetime(s_date_all) ts_date =
pd.to_datetime(s_date)
pandas.to_datetime
#!/usr/bin/env python2 # -*- coding: utf-8 -*- """ Created on Fri Dec 1 16:30:36 2017 @author: yhsui """ from math import sqrt from numpy import concatenate import numpy as np from pandas import read_csv from pandas import DataFrame from pandas import concat from sklearn.preprocessing import MinMaxScaler from sklearn.preprocessing import LabelEncoder from sklearn.metrics import mean_squared_error from keras.models import Sequential from keras.layers import Dense from keras.layers import LSTM # convert data to multiple time steps def series_to_supervised(data, n_in=1, n_out=1, dropnan=True): n_vars = 1 if type(data) is list else data.shape[1] df =
DataFrame(data)
pandas.DataFrame
import pandas as pd #import numpy as np StreamsSheet =
pd.read_csv('Streams.csv', header=0, index_col=0)
pandas.read_csv
from collections import namedtuple from pathlib import Path import numpy as np import pandas as pd import pytest import tfs from pandas.testing import assert_frame_equal from test_rdt import arrays_are_close_almost_everywhere from optics_functions.constants import ( ALPHA, BETA, F1001, F1010, GAMMA, IMAG, NAME, PHASE_ADV, REAL, TUNE, S, X, Y ) from optics_functions.coupling import ( COUPLING_RDTS, check_resonance_relation, closest_tune_approach, coupling_via_cmatrix, coupling_via_rdts, rmatrix_from_coupling, ) from optics_functions.utils import prepare_twiss_dataframe INPUT = Path(__file__).parent.parent / "inputs" COUPLING_BUMP_INPUTS = INPUT / "coupling_bump" COUPLING_BUMP_TWISS_BEAM_1 = COUPLING_BUMP_INPUTS / "twiss.lhc.b1.coupling_bump.tfs" @pytest.mark.basic def test_cmatrix(): n = 5 np.random.seed(487423872) df = generate_fake_data(n) df_res = coupling_via_cmatrix(df) assert all(c in df_res.columns for c in (F1001, F1010, "C11", "C12", "C21", "C22", GAMMA)) assert not df_res.isna().any().any() # Checks based on CalagaBetatronCoupling2005 detC = df_res["C11"] * df_res["C22"] - df_res["C12"] * df_res["C21"] fsq_diff = df_res[F1001].abs() ** 2 - df_res[F1010].abs() ** 2 f_term = 1 / (1 + 4 * fsq_diff) g_sq = df_res[GAMMA] ** 2 assert all(np.abs(detC + g_sq - 1) < 1e-15) assert all(np.abs(detC / (4 * g_sq) - fsq_diff) < 1e-15) # Eq. (13) assert all(np.abs(detC + f_term - 1) < 1e-15) # Eq. (13) assert all(np.abs(g_sq - f_term) < 1e-15) # Eq. (14) @pytest.mark.basic @pytest.mark.parametrize("source", ["real", "fake"]) def test_rmatrix_to_coupling_to_rmatrix(source): if source == "fake": np.random.seed(487423872) df = generate_fake_data(5) else: df = tfs.read(INPUT / "coupling_bump" / f"twiss.lhc.b1.coupling_bump.tfs", index=NAME) df_coupling = coupling_via_cmatrix(df) for col in (f"{ALPHA}X", f"{BETA}X", f"{ALPHA}Y", f"{BETA}Y"): df_coupling[col] = df[col] df_res = rmatrix_from_coupling(df_coupling) for col in ("R11", "R12", "R21", "R22"): # print(col, "\n", max(np.abs(df[col] - df_res[col]))) # for debugging assert all(np.abs(df[col] - df_res[col]) < 5e-15) @pytest.mark.basic def test_real_output(): n = 7 np.random.seed(474987942) df = generate_fake_data(n) df = prepare_twiss_dataframe(df_twiss=df) df.loc[:, "K1L"] = np.random.rand(n) df.loc[:, "K1SL"] = np.random.rand(n) df_cmatrix = coupling_via_cmatrix(df, complex_columns=False) df_rdts = coupling_via_rdts(df, qx=1.31, qy=1.32, complex_columns=False) assert all(np.real(df_cmatrix) == df_cmatrix) assert all(np.real(df_rdts) == df_rdts) columns = [f"{c}{r}" for c in COUPLING_RDTS for r in (REAL, IMAG)] assert df_rdts[columns].all().all() # check no 0-values assert df_cmatrix[columns].all().all() # check no 0-values assert df_cmatrix.columns.str.match(f".+{REAL}$").sum() == 2 assert df_cmatrix.columns.str.match(f".+{IMAG}$").sum() == 2 assert df_rdts.columns.str.match(f".+{REAL}$").sum() == 2 assert df_rdts.columns.str.match(f".+{IMAG}$").sum() == 2 @pytest.mark.basic @pytest.mark.parametrize( "cta_method, max_relative_error_to_teapot, result_should_be_real", [ ("calaga", 0, True), # this is the same as teapot, hence 0 relative error ("franchi", 0.001, True), ("teapot_franchi", 0.0005, True), ("persson", 0.25, False), # not sure why it is so high from here ("persson_alt", 0.25, False), ("hoydalsvik", 0.25, False), ("hoydalsvik_alt", 0.25, False), ], ) def test_closest_tune_approach( cta_method, max_relative_error_to_teapot, result_should_be_real, _coupling_bump_teapot_cta ): df_twiss = tfs.read(COUPLING_BUMP_TWISS_BEAM_1, index=NAME) df = prepare_twiss_dataframe(df_twiss=df_twiss, max_order=7) df_cmatrix = coupling_via_cmatrix(df) df_twiss[F1001] = df_cmatrix[F1001] # ignoring F1010 in this test as it is bigger than F1001 cta_df = closest_tune_approach(df_twiss, method=cta_method) # only one column cminus = cta_df.mean().abs()[0] relative_error = _relative_error(cminus, _coupling_bump_teapot_cta) assert relative_error <= max_relative_error_to_teapot assert not cta_df.isna().any().any() # check no NaNs assert all(cta_df[df_cmatrix[F1001] != 0] != 0) if result_should_be_real: assert all(np.isreal(cta_df)) @pytest.mark.basic def test_check_resonance_relation_with_nan(caplog): df = pd.DataFrame([[1, 2, 3, 4], [2, 1, -5, 1]], index=[F1001, F1010]).T df_nan = check_resonance_relation(df, to_nan=True) assert all(df_nan.loc[0, :].isna()) assert all(df_nan.loc[2, :].isna()) assert all(df_nan.loc[1, :] == df.loc[1, :]) assert all(df_nan.loc[3, :] == df.loc[3, :]) assert "|F1001| < |F1010|" in caplog.text @pytest.mark.basic def test_check_resonance_relation_without_nan(caplog): df = pd.DataFrame([[1, 2, 3, 4], [2, 1, 5, 1]], index=[F1001, F1010]).T df_out = check_resonance_relation(df, to_nan=False) assert_frame_equal(df_out, df) assert "|F1001| < |F1010|" in caplog.text @pytest.mark.basic def test_check_resonance_relation_all_good(caplog): df =
pd.DataFrame([[2, 3, 4, 5], [1, 3, 3, 4]], index=[F1001, F1010])
pandas.DataFrame
import json import io import plotly.graph_objects as go from plotly.subplots import make_subplots import dash from dash import html from dash import dcc import dash_bootstrap_components as dbc import pandas as pd import numpy as np import plotly.express as px from dash.dependencies import Output, Input, State from datetime import datetime, timedelta from server import app import plotly.graph_objects as go import plotly.express as px from sqlalchemy import create_engine from flask import send_file import os from joblib import Parallel, delayed from dash.exceptions import PreventUpdate import time import re # ----------------------------------------------------------------------------------------------------- 一级图一 ---------------------------------------------------------------------------------------------------------------------- # 获取抗菌药物-菌检出-药敏一级第一张图数据 def get_first_lev_first_fig_date(engine): res = pd.DataFrame(columns=['业务类型', 'num', 'month' ]) # 问题类别、问题数据量统计、全数据统计 bus_dic = { '生化': "select '生化' as 业务类型 ,count(1) as num ,substr(REQUESTTIME,1,7) as month from ROUTINE2 where REQUESTTIME is not null group by substr(REQUESTTIME,1,7)", '检查': " select '检查' as 业务类型 , count(1) as num ,substr(EXAM_DATE,1,7) as month from EXAM where EXAM_DATE is not null group by substr(EXAM_DATE,1,7) ", '体温': " select '体温' as 业务类型 , count(1) as num ,substr(RECORDDATE,1,7) as month from TEMPERATURE where RECORDDATE is not null group by substr(RECORDDATE,1,7) ", } for bus in bus_dic: res = res.append(pd.read_sql(bus_dic[bus],con=engine)) return res # 更新抗菌药物-菌检出-药敏一级图一 @app.callback( Output('rout_exam_temp_first_level_first_fig','figure'), Output('rout_exam_temp_first_level_first_fig_data','data'), Input('rout_exam_temp_first_level_first_fig_data','data'), Input("db_con_url", "data"), Input("count_time", "data"), # prevent_initial_call=True ) def update_first_level_first_fig(rout_exam_temp_first_level_first_fig_data,db_con_url,count_time): if db_con_url is None : return dash.no_update else: db_con_url = json.loads(db_con_url) count_time = json.loads(count_time) btime = count_time['btime'][0:7] etime = count_time['etime'][0:7] engine = create_engine(db_con_url['db']) if rout_exam_temp_first_level_first_fig_data is None: rout_exam_temp_first_level_first_fig_data = {} rout_exam_temp_first_level_first_fig = get_first_lev_first_fig_date(engine) rout_exam_temp_first_level_first_fig_data['rout_exam_temp_first_level_first_fig'] = rout_exam_temp_first_level_first_fig.to_json(orient='split', date_format='iso') rout_exam_temp_first_level_first_fig_data['hosname'] = db_con_url['hosname'] rout_exam_temp_first_level_first_fig_data['btime'] = btime rout_exam_temp_first_level_first_fig_data['etime'] = etime rout_exam_temp_first_level_first_fig_data = json.dumps(rout_exam_temp_first_level_first_fig_data) else: rout_exam_temp_first_level_first_fig_data = json.loads(rout_exam_temp_first_level_first_fig_data) if db_con_url['hosname'] != rout_exam_temp_first_level_first_fig_data['hosname']: rout_exam_temp_first_level_first_fig = get_first_lev_first_fig_date(engine) rout_exam_temp_first_level_first_fig_data['rout_exam_temp_first_level_first_fig'] = rout_exam_temp_first_level_first_fig.to_json(orient='split',date_format='iso') rout_exam_temp_first_level_first_fig_data['hosname'] = db_con_url['hosname'] rout_exam_temp_first_level_first_fig_data = json.dumps(rout_exam_temp_first_level_first_fig_data) else: rout_exam_temp_first_level_first_fig = pd.read_json(rout_exam_temp_first_level_first_fig_data['rout_exam_temp_first_level_first_fig'], orient='split') rout_exam_temp_first_level_first_fig_data = dash.no_update # rout_exam_temp_first_level_first_fig = rout_exam_temp_first_level_first_fig[(rout_exam_temp_first_level_first_fig['month']>=btime) & (rout_exam_temp_first_level_first_fig['month']<=etime)] rout_exam_temp_first_level_first_fig = rout_exam_temp_first_level_first_fig.sort_values(['month','业务类型']) fig1 = px.line(rout_exam_temp_first_level_first_fig, x='month', y='num', color='业务类型', color_discrete_sequence=px.colors.qualitative.Dark24) # 设置水平图例及位置 fig1.update_layout( margin=dict(l=20, r=20, t=20, b=20), legend=dict( orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1 )) fig1.update_yaxes(title_text="业务数据量") fig1.update_xaxes(title_text="时间") return fig1,rout_exam_temp_first_level_first_fig_data # ----------------------------------------------------------------------------------------------------- 一级图二 ---------------------------------------------------------------------------------------------------------------------- # 获取一级第二张图片数据 def get_first_lev_second_fig_date(engine): res = pd.DataFrame(columns=['问题类型', 'num' ]) # 问题类别、问题数据量统计、全数据统计 bus_dic = { '体温测量时间缺失': f"select '体温测量时间缺失' as 问题类型 ,count(1) as num from TEMPERATURE where RECORDDATE is null ", '生化检验申请时间缺失': f"select '生化检验申请时间缺失' as 问题类型 ,count(1) as num from ROUTINE2 where REQUESTTIME is null ", '生化检验报告时间缺失': f"select '生化检验报告时间缺失' as 问题类型 ,count(1) as num from ROUTINE2 where REPORTTIME is null", '检查时间为空': f"select '检查时间为空' as 问题类型 ,count(1) as num from exam where EXAM_DATE is null ", } for bus in bus_dic: res = res.append(pd.read_sql(bus_dic[bus],con=engine)) return res # 更新一级图二 @app.callback( Output('rout_exam_temp_first_level_second_fig','figure'), Output('rout_exam_temp_first_level_second_fig_data','data'), Input('rout_exam_temp_first_level_second_fig_data','data'), Input("db_con_url", "data"), Input("count_time", "data"), # prevent_initial_call=True ) def update_first_level_first_fig(rout_exam_temp_first_level_second_fig_data,db_con_url,count_time): if db_con_url is None: return dash.no_update else: db_con_url = json.loads(db_con_url) count_time = json.loads(count_time) engine = create_engine(db_con_url['db']) btime = count_time['btime'][0:7] etime = count_time['etime'][0:7] if rout_exam_temp_first_level_second_fig_data is None: rout_exam_temp_first_level_second_fig = get_first_lev_second_fig_date(engine) rout_exam_temp_first_level_second_fig_data = {} rout_exam_temp_first_level_second_fig_data['rout_exam_temp_first_level_second_fig'] = rout_exam_temp_first_level_second_fig.to_json( orient='split', date_format='iso') rout_exam_temp_first_level_second_fig_data['hosname'] = db_con_url['hosname'] rout_exam_temp_first_level_second_fig_data = json.dumps(rout_exam_temp_first_level_second_fig_data) else: rout_exam_temp_first_level_second_fig_data = json.loads(rout_exam_temp_first_level_second_fig_data) if db_con_url['hosname'] != rout_exam_temp_first_level_second_fig_data['hosname']: rout_exam_temp_first_level_second_fig = get_first_lev_second_fig_date(engine) rout_exam_temp_first_level_second_fig_data = {} rout_exam_temp_first_level_second_fig_data[ 'rout_exam_temp_first_level_second_fig'] = rout_exam_temp_first_level_second_fig.to_json( orient='split', date_format='iso') rout_exam_temp_first_level_second_fig_data['hosname'] = db_con_url['hosname'] rout_exam_temp_first_level_second_fig_data = json.dumps(rout_exam_temp_first_level_second_fig_data) else: rout_exam_temp_first_level_second_fig = pd.read_json( rout_exam_temp_first_level_second_fig_data['rout_exam_temp_first_level_second_fig'], orient='split') rout_exam_temp_first_level_second_fig_data = dash.no_update fig = go.Figure() # fig = px.bar(rout_exam_temp_first_level_second_fig,x='问题类型',y='num',color_discrete_sequence=px.colors.qualitative.Dark24 ) fig.add_trace( go.Bar(x=rout_exam_temp_first_level_second_fig['问题类型'], y=rout_exam_temp_first_level_second_fig['num'], name="问题类型", marker_color=px.colors.qualitative.Dark24, ) ) fig.update_layout( margin=dict(l=20, r=20, t=20, b=20), legend=dict( orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1 ) ) fig.update_yaxes(title_text="问题数量") fig.update_xaxes(title_text="月份") return fig, rout_exam_temp_first_level_second_fig_data # 下载一级图二明细 @app.callback( Output('rout_exam_temp_first_level_second_fig_detail', 'data'), Input('rout_exam_temp_first_level_second_fig_data_detail_down','n_clicks'), Input("db_con_url", "data"), Input("count_time", "data"), prevent_initial_call=True, ) def download_first_level_third_fig_data_detail(n_clicks,db_con_url,count_time): if db_con_url is None : return dash.no_update else: if n_clicks is not None and n_clicks>0: n_clicks = 0 db_con_url = json.loads(db_con_url) count_time = json.loads(count_time) engine = create_engine(db_con_url['db']) bus_dic = { '体温测量时间缺失': f"select * from TEMPERATURE where RECORDDATE is null ", '生化检验申请时间缺失': f"select * from ROUTINE2 where REQUESTTIME is null ", '生化检验报告时间缺失': f"select * from ROUTINE2 where REPORTTIME is null", '检查时间为空': f"select * from exam where EXAM_DATE is null ", } output = io.BytesIO() writer = pd.ExcelWriter(output, engine='xlsxwriter') for key in bus_dic.keys(): try: temp = pd.read_sql(bus_dic[key], con=engine) if temp.shape[0] > 0: temp.to_excel(writer, sheet_name=key) except: error_df = pd.DataFrame(['明细数据获取出错'], columns=[key]) error_df.to_excel(writer, sheet_name=key) writer.save() data = output.getvalue() hosName = db_con_url['hosname'] return dcc.send_bytes(data, f'{hosName}时间缺失数据明细.xlsx') else: return dash.no_update # # ----------------------------------------------------------------------------------------------------- 二级图一 ---------------------------------------------------------------------------------------------------------------------- # # 获取体温二级第一张图数据 def get_second_lev_first_fig_date(engine,btime,etime): res = pd.DataFrame(columns=['问题类型','num','momth']) bus_dic = { '体温测量值异常': f"select '体温测量值异常' as 问题类型 ,count(1) as num ,substr(RECORDDATE,1,7) as month from TEMPERATURE where (VALUE >46 or VALUE<34) and substr(RECORDDATE,1,7)>='{btime}' and substr(RECORDDATE,1,7)<='{etime}' group by substr(RECORDDATE,1,7)", '体温测量值缺失': f"select '体温测量值缺失' as 问题类型 ,count(1) as num ,substr(RECORDDATE,1,7) as month from TEMPERATURE where VALUE is null and substr(RECORDDATE,1,7)>='{btime}' and substr(RECORDDATE,1,7)<='{etime}' group by substr(RECORDDATE,1,7)", '科室缺失': f"select '科室缺失' as 问题类型 ,count(1) as num ,substr(RECORDDATE,1,7) as month from TEMPERATURE where DEPT is null and substr(RECORDDATE,1,7)>='{btime}' and substr(RECORDDATE,1,7)<='{etime}' group by substr(RECORDDATE,1,7)", '体温测量时机缺失': f"select '体温测量时机缺失' as 问题类型 ,count(1) as num ,substr(RECORDDATE,1,7) as month from TEMPERATURE where OUTSIDE is null and substr(RECORDDATE,1,7)>='{btime}' and substr(RECORDDATE,1,7)<='{etime}' group by substr(RECORDDATE,1,7)", '体温测量时间无时间点': f"select '检验测量时间无时间点' as 问题类型 ,count(1) as num ,substr(RECORDDATE,1,7) as month from TEMPERATURE where length(RECORDDATE)<19 and substr(RECORDDATE,1,7)>='{btime}' and substr(RECORDDATE,1,7)<='{etime}' group by substr(RECORDDATE,1,7)", '体温测量时间在出入院时间之外': f""" select '体温测量时间在出入院时间之外' as 问题类型,count(1) as num ,substr(RECORDDATE,1,7) as month from TEMPERATURE t1,overall t2 where ( t1.RECORDDATE is not null and t2.in_time is not null and t2.out_time is not null) and t1.caseid = t2.caseid and (t1.RECORDDATE<t2.IN_TIME or t1.RECORDDATE > t2.OUT_TIME ) and (substr(t1.RECORDDATE,1,7)>='{btime}' and substr(t1.RECORDDATE,1,7)<='{etime}') group by substr(RECORDDATE,1,7) """, } for bus in bus_dic: res = res.append(pd.read_sql(bus_dic[bus],con=engine)) return res # 更新二级图一 @app.callback( Output('temp_second_level_first_fig','figure'), Output('temp_second_level_first_fig_data','data'), Input('temp_second_level_first_fig_data','data'), Input("db_con_url", "data"), Input("count_time", "data"), ) def update_first_level_second_fig(temp_second_level_first_fig_data,db_con_url,count_time): if db_con_url is None: return dash.no_update else: db_con_url = json.loads(db_con_url) count_time = json.loads(count_time) engine = create_engine(db_con_url['db']) btime = count_time['btime'][0:7] etime = count_time['etime'][0:7] if temp_second_level_first_fig_data is None: temp_second_level_first_fig_data = {} temp_second_level_first_fig = get_second_lev_first_fig_date(engine, btime, etime) temp_second_level_first_fig_data['temp_second_level_first_fig'] = temp_second_level_first_fig.to_json( orient='split', date_format='iso') temp_second_level_first_fig_data['hosname'] = db_con_url['hosname'] temp_second_level_first_fig_data['btime'] = btime temp_second_level_first_fig_data['etime'] = etime temp_second_level_first_fig_data = json.dumps(temp_second_level_first_fig_data) else: temp_second_level_first_fig_data = json.loads(temp_second_level_first_fig_data) if db_con_url['hosname'] != temp_second_level_first_fig_data['hosname']: temp_second_level_first_fig = get_second_lev_first_fig_date(engine, btime, etime) temp_second_level_first_fig_data['temp_second_level_first_fig'] = temp_second_level_first_fig.to_json( orient='split', date_format='iso') temp_second_level_first_fig_data['hosname'] = db_con_url['hosname'] temp_second_level_first_fig_data['btime'] = btime temp_second_level_first_fig_data['etime'] = etime temp_second_level_first_fig_data = json.dumps(temp_second_level_first_fig_data) else: if temp_second_level_first_fig_data['btime'] != btime or temp_second_level_first_fig_data[ 'etime'] != etime: temp_second_level_first_fig = get_second_lev_first_fig_date(engine, btime, etime) temp_second_level_first_fig_data[ 'temp_second_level_first_fig'] = temp_second_level_first_fig.to_json( orient='split', date_format='iso') temp_second_level_first_fig_data['btime'] = btime temp_second_level_first_fig_data['etime'] = etime temp_second_level_first_fig_data = json.dumps(temp_second_level_first_fig_data) else: temp_second_level_first_fig = pd.read_json( temp_second_level_first_fig_data['temp_second_level_first_fig'], orient='split') temp_second_level_first_fig_data = dash.no_update temp_second_level_first_fig = temp_second_level_first_fig.sort_values(['month']) fig = px.line(temp_second_level_first_fig, x="month", y="num", color='问题类型', color_discrete_sequence=px.colors.qualitative.Dark24) fig.update_layout( margin=dict(l=30, r=30, t=30, b=30), legend=dict( orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1 ), ) fig.update_yaxes(title_text="体温测量数量", ) fig.update_xaxes(title_text="月份", ) return fig, temp_second_level_first_fig_data # 下载二级图一明细 @app.callback( Output('temp_second_level_first_fig_detail', 'data'), Input('temp_second_level_first_fig_data_detail_down','n_clicks'), Input("db_con_url", "data"), Input("count_time", "data"), prevent_initial_call=True, ) def download_first_level_third_fig_data_detail(n_clicks,db_con_url,count_time): if db_con_url is None : return dash.no_update else: if n_clicks is not None and n_clicks>0: n_clicks = 0 db_con_url = json.loads(db_con_url) count_time = json.loads(count_time) btime = count_time['btime'][0:7] etime = count_time['etime'][0:7] engine = create_engine(db_con_url['db']) bus_dic = { '体温测量值异常': f"select * from TEMPERATURE where (VALUE >46 or VALUE<34) and substr(RECORDDATE,1,7)>='{btime}' and substr(RECORDDATE,1,7)<='{etime}' ", '体温测量值缺失': f"select * from TEMPERATURE where VALUE is null and substr(RECORDDATE,1,7)>='{btime}' and substr(RECORDDATE,1,7)<='{etime}' ", '科室缺失': f"select * from TEMPERATURE where DEPT is null and substr(RECORDDATE,1,7)>='{btime}' and substr(RECORDDATE,1,7)<='{etime}' ", '体温测量时机缺失': f"select * from TEMPERATURE where OUTSIDE is null and substr(RECORDDATE,1,7)>='{btime}' and substr(RECORDDATE,1,7)<='{etime}' ", '体温测量时间无时间点': f"select * from TEMPERATURE where length(RECORDDATE)<19 and substr(RECORDDATE,1,7)>='{btime}' and substr(RECORDDATE,1,7)<='{etime}' ", '体温测量时间在出入院时间之外': f""" select t1.*,t2.in_time as 入院时间,t2.out_time as 出院时间 from TEMPERATURE t1,overall t2 where ( t1.RECORDDATE is not null and t2.in_time is not null and t2.out_time is not null) and t1.caseid = t2.caseid and (t1.RECORDDATE<t2.IN_TIME or t1.RECORDDATE > t2.OUT_TIME ) and (substr(t1.RECORDDATE,1,7)>='{btime}' and substr(t1.RECORDDATE,1,7)<='{etime}') """, } output = io.BytesIO() writer = pd.ExcelWriter(output, engine='xlsxwriter') for key in bus_dic.keys(): try: temp = pd.read_sql(bus_dic[key], con=engine) if temp.shape[0] > 0: temp.to_excel(writer, sheet_name=key) except: error_df = pd.DataFrame(['明细数据获取出错'], columns=[key]) error_df.to_excel(writer, sheet_name=key) writer.save() data = output.getvalue() hosName = db_con_url['hosname'] return dcc.send_bytes(data, f'{hosName}体温问题数据明细.xlsx') else: return dash.no_update # # # # ----------------------------------------------------------------------------------------------------- 三级图一 ---------------------------------------------------------------------------------------------------------------------- # 获取生化检验三级第一张图数据 def get_third_lev_first_fig_date(engine,btime,etime): res_数据时间缺失及汇总 = pd.DataFrame(columns=['问题类型', 'num', 'month' ]) # 问题类别、问题数据量统计、全数据统计 bus_dic = { '标本缺失': f"select '标本缺失' as 问题类型 ,count(1) as num ,substr(REQUESTTIME,1,7) as month from ROUTINE2 where REQUESTTIME is not null and substr(REQUESTTIME,1,7)>='{btime}' and substr(REQUESTTIME,1,7)<='{etime}' and SPECIMEN is null group by substr(REQUESTTIME,1,7)", '检验项目缺失': f"select '检验项目缺失' as 问题类型 ,count(1) as num ,substr(REQUESTTIME,1,7) as month from ROUTINE2 where REQUESTTIME is not null and substr(REQUESTTIME,1,7)>='{btime}' and substr(REQUESTTIME,1,7)<='{etime}' and RTYPE is null group by substr(REQUESTTIME,1,7)", '检验结果缺失': f"select '检验结果缺失' as 问题类型 ,count(1) as num ,substr(REQUESTTIME,1,7) as month from ROUTINE2 where REQUESTTIME is not null and substr(REQUESTTIME,1,7)>='{btime}' and substr(REQUESTTIME,1,7)<='{etime}' and RVALUE is null group by substr(REQUESTTIME,1,7)", '院内外标识缺失': f"select '院内外标识缺失' as 问题类型 ,count(1) as num ,substr(REQUESTTIME,1,7) as month from ROUTINE2 where REQUESTTIME is not null and substr(REQUESTTIME,1,7)>='{btime}' and substr(REQUESTTIME,1,7)<='{etime}' and OUTSIDE is null group by substr(REQUESTTIME,1,7)", '检验子项缺失': f"select '检验子项缺失' as 问题类型 ,count(1) as num ,substr(REQUESTTIME,1,7) as month from ROUTINE2 where REQUESTTIME is not null and substr(REQUESTTIME,1,7)>='{btime}' and substr(REQUESTTIME,1,7)<='{etime}' and RITEM is null group by substr(REQUESTTIME,1,7)", '定性结果缺失': f"select '定性结果缺失' as 问题类型 ,count(1) as num ,substr(REQUESTTIME,1,7) as month from ROUTINE2 where REQUESTTIME is not null and substr(REQUESTTIME,1,7)>='{btime}' and substr(REQUESTTIME,1,7)<='{etime}' and ABNORMAL is null group by substr(REQUESTTIME,1,7)", '申请时间大于等于报告时间': f"select '申请时间大于等于报告时间' as 问题类型 ,count(1) as num ,substr(REQUESTTIME,1,7) as month from ROUTINE2 where REQUESTTIME >= REPORTTIME and substr(REQUESTTIME,1,7)>='{btime}' and substr(REQUESTTIME,1,7)<='{etime}' group by substr(REQUESTTIME,1,7)", '申请时间在出入院时间之外': f""" select '申请时间在出入院时间之外' as 问题类型,count(1) as num ,substr(REQUESTTIME,1,7) as month from ROUTINE2 t1,overall t2 where ( t1.REQUESTTIME is not null and t1.REPORTTIME is not null and t2.in_time is not null and t2.out_time is not null) and t1.caseid = t2.caseid and (t1.REQUESTTIME<t2.IN_TIME or t1.REQUESTTIME > t2.OUT_TIME ) and (substr(t1.REQUESTTIME,1,7)>='{btime}' and substr(t1.REQUESTTIME,1,7)<='{etime}') group by substr(REQUESTTIME,1,7) """, } for bus in bus_dic: res_数据时间缺失及汇总 = res_数据时间缺失及汇总.append(pd.read_sql(bus_dic[bus],con=engine)) return res_数据时间缺失及汇总 # 更新抗菌药物-菌检出-药敏一级图一 @app.callback( Output('rout_third_level_first_fig','figure'), Output('rout_third_level_first_fig_data','data'), Input('rout_third_level_first_fig_data','data'), Input("db_con_url", "data"), Input("count_time", "data"), # prevent_initial_call=True ) def update_first_level_first_fig(rout_third_level_first_fig_data,db_con_url,count_time): if db_con_url is None: return dash.no_update else: db_con_url = json.loads(db_con_url) count_time = json.loads(count_time) engine = create_engine(db_con_url['db']) btime = count_time['btime'][0:7] etime = count_time['etime'][0:7] if rout_third_level_first_fig_data is None: rout_third_level_first_fig_data = {} rout_third_level_first_fig = get_third_lev_first_fig_date(engine, btime, etime) rout_third_level_first_fig_data['rout_third_level_first_fig'] = rout_third_level_first_fig.to_json( orient='split', date_format='iso') rout_third_level_first_fig_data['hosname'] = db_con_url['hosname'] rout_third_level_first_fig_data['btime'] = btime rout_third_level_first_fig_data['etime'] = etime rout_third_level_first_fig_data = json.dumps(rout_third_level_first_fig_data) else: rout_third_level_first_fig_data = json.loads(rout_third_level_first_fig_data) if db_con_url['hosname'] != rout_third_level_first_fig_data['hosname']: rout_third_level_first_fig = get_third_lev_first_fig_date(engine, btime, etime) rout_third_level_first_fig_data['rout_third_level_first_fig'] = rout_third_level_first_fig.to_json( orient='split', date_format='iso') rout_third_level_first_fig_data['hosname'] = db_con_url['hosname'] rout_third_level_first_fig_data['btime'] = btime rout_third_level_first_fig_data['etime'] = etime rout_third_level_first_fig_data = json.dumps(rout_third_level_first_fig_data) else: if rout_third_level_first_fig_data['btime'] != btime or rout_third_level_first_fig_data[ 'etime'] != etime: rout_third_level_first_fig = get_third_lev_first_fig_date(engine, btime, etime) rout_third_level_first_fig_data[ 'rout_third_level_first_fig'] = rout_third_level_first_fig.to_json(orient='split', date_format='iso') rout_third_level_first_fig_data['btime'] = btime rout_third_level_first_fig_data['etime'] = etime rout_third_level_first_fig_data = json.dumps(rout_third_level_first_fig_data) else: rout_third_level_first_fig = pd.read_json( rout_third_level_first_fig_data['rout_third_level_first_fig'], orient='split') rout_third_level_first_fig_data = dash.no_update rout_third_level_first_fig = rout_third_level_first_fig.sort_values(['month']) fig = px.line(rout_third_level_first_fig,x='month',y='num',color='问题类型',color_discrete_sequence=px.colors.qualitative.Dark24 ) fig.update_layout( margin=dict(l=20, r=20, t=20, b=20), legend=dict( orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1 ) ) fig.update_yaxes(title_text="问题数量") fig.update_xaxes(title_text="月份") return fig, rout_third_level_first_fig_data # 下载三级图一明细 @app.callback( Output('rout_third_level_first_fig_detail', 'data'), Input('rout_third_level_first_fig_data_detail_down','n_clicks'), Input("db_con_url", "data"), Input("count_time", "data"), prevent_initial_call=True, ) def download_first_level_third_fig_data_detail(n_clicks,db_con_url,count_time): if db_con_url is None : return dash.no_update else: if n_clicks is not None and n_clicks>0: n_clicks = 0 db_con_url = json.loads(db_con_url) count_time = json.loads(count_time) engine = create_engine(db_con_url['db']) btime = count_time['btime'][0:7] etime = count_time['etime'][0:7] bus_dic = { '标本缺失': f"select * from ROUTINE2 where REQUESTTIME is not null and substr(REQUESTTIME,1,7)>='{btime}' and substr(REQUESTTIME,1,7)<='{etime}' and SPECIMEN is null ", '检验项目缺失': f"select * from ROUTINE2 where REQUESTTIME is not null and substr(REQUESTTIME,1,7)>='{btime}' and substr(REQUESTTIME,1,7)<='{etime}' and RTYPE is null ", '检验结果缺失': f"select * from ROUTINE2 where REQUESTTIME is not null and substr(REQUESTTIME,1,7)>='{btime}' and substr(REQUESTTIME,1,7)<='{etime}' and RVALUE is null ", '院内外标识缺失': f"select * from ROUTINE2 where REQUESTTIME is not null and substr(REQUESTTIME,1,7)>='{btime}' and substr(REQUESTTIME,1,7)<='{etime}' and OUTSIDE is null ", '检验子项缺失': f"select * from ROUTINE2 where REQUESTTIME is not null and substr(REQUESTTIME,1,7)>='{btime}' and substr(REQUESTTIME,1,7)<='{etime}' and RITEM is null ", '定性结果缺失': f"select * from ROUTINE2 where REQUESTTIME is not null and substr(REQUESTTIME,1,7)>='{btime}' and substr(REQUESTTIME,1,7)<='{etime}' and ABNORMAL is null ", '申请时间大于等于报告时间': f"select * from ROUTINE2 where REQUESTTIME >= REPORTTIME and substr(REQUESTTIME,1,7)>='{btime}' and substr(REQUESTTIME,1,7)<='{etime}' ", '申请时间在出入院时间之外': f""" select t1.* ,t2.in_time as 入院时间,t2.out_time as 出院时间 from ROUTINE2 t1,overall t2 where ( t1.REQUESTTIME is not null and t1.REPORTTIME is not null and t2.in_time is not null and t2.out_time is not null) and t1.caseid = t2.caseid and (t1.REQUESTTIME<t2.IN_TIME or t1.REQUESTTIME > t2.OUT_TIME ) and (substr(t1.REQUESTTIME,1,7)>='{btime}' and substr(t1.REQUESTTIME,1,7)<='{etime}') """, } output = io.BytesIO() writer = pd.ExcelWriter(output, engine='xlsxwriter') for key in bus_dic.keys(): try: temp = pd.read_sql(bus_dic[key], con=engine) if temp.shape[0] > 0: temp.to_excel(writer, sheet_name=key) except: error_df = pd.DataFrame(['明细数据获取出错'], columns=[key]) error_df.to_excel(writer, sheet_name=key) writer.save() data = output.getvalue() hosName = db_con_url['hosname'] return dcc.send_bytes(data, f'{hosName}生化检验问题数据明细.xlsx') else: return dash.no_update # # # ----------------------------------------------------------------------------------------------------- 三级图二 ---------------------------------------------------------------------------------------------------------------------- # 获取生化三级第二张图数据 def get_third_level_second_fig_date(engine,btime,etime): res = pd.read_sql(f"select RTYPE as 生化检验类型,count(distinct CASEID||TESTNO||RTYPE) as num ,substr(REQUESTTIME,1,7) as month from ROUTINE2 where RTYPE is not null and substr(REQUESTTIME,1,7)>='{btime}' and substr(REQUESTTIME,1,7)<='{etime}' group by RTYPE,substr(REQUESTTIME,1,7)",con=engine) return res # 更新生化三级第二张图 @app.callback( Output('rout_third_level_second_fig','figure'), Output('rout_third_level_second_fig_data','data'), Input('rout_third_level_second_fig_data','data'), Input("db_con_url", "data"), Input("count_time", "data"), # prevent_initial_call=True ) def update_second_level_fig(rout_third_level_second_fig_data,db_con_url,count_time): if db_con_url is None: return dash.no_update else: db_con_url = json.loads(db_con_url) count_time = json.loads(count_time) engine = create_engine(db_con_url['db']) btime = count_time['btime'][0:7] etime = count_time['etime'][0:7] if rout_third_level_second_fig_data is None: rout_third_level_second_fig_data = {} rout_third_level_second_fig = get_third_level_second_fig_date(engine, btime, etime) rout_third_level_second_fig_data['rout_third_level_second_fig'] = rout_third_level_second_fig.to_json(orient='split', date_format='iso') rout_third_level_second_fig_data['hosname'] = db_con_url['hosname'] rout_third_level_second_fig_data['btime'] = btime rout_third_level_second_fig_data['etime'] = etime rout_third_level_second_fig_data = json.dumps(rout_third_level_second_fig_data) else: rout_third_level_second_fig_data = json.loads(rout_third_level_second_fig_data) if db_con_url['hosname'] != rout_third_level_second_fig_data['hosname']: rout_third_level_second_fig = get_third_level_second_fig_date(engine, btime, etime) rout_third_level_second_fig_data['rout_third_level_second_fig'] = rout_third_level_second_fig.to_json(orient='split',date_format='iso') rout_third_level_second_fig_data['hosname'] = db_con_url['hosname'] rout_third_level_second_fig_data['btime'] = btime rout_third_level_second_fig_data['etime'] = etime rout_third_level_second_fig_data = json.dumps(rout_third_level_second_fig_data) else: if rout_third_level_second_fig_data['btime'] != btime or rout_third_level_second_fig_data['etime'] != etime: rout_third_level_second_fig = get_third_level_second_fig_date(engine, btime, etime) rout_third_level_second_fig_data['rout_third_level_second_fig'] = rout_third_level_second_fig.to_json(orient='split',date_format='iso') rout_third_level_second_fig_data['btime'] = btime rout_third_level_second_fig_data['etime'] = etime rout_third_level_second_fig_data = json.dumps(rout_third_level_second_fig_data) else: rout_third_level_second_fig = pd.read_json(rout_third_level_second_fig_data['rout_third_level_second_fig'], orient='split') rout_third_level_second_fig_data = dash.no_update rout_third_level_second_fig = rout_third_level_second_fig.sort_values(['month']) # fig = px.line(rout_third_level_second_fig,x='month',y='num',color='生化检验类型',color_discrete_sequence=px.colors.qualitative.Dark24) fig = px.bar(rout_third_level_second_fig,x='month',y='num',color='生化检验类型',color_discrete_sequence=px.colors.qualitative.Dark24) fig.update_layout( margin=dict(l=20, r=20, t=20, b=20), legend=dict( orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1 ) ) fig.update_yaxes(title_text="生化检验数量", ) fig.update_xaxes(title_text="月份", ) return fig,rout_third_level_second_fig_data # # # ----------------------------------------------------------------------------------------------------- 四级图一 ---------------------------------------------------------------------------------------------------------------------- # 获取检查四级第一张图数据 def get_fourth_level_first_fig_date(engine,btime,etime): res = pd.DataFrame(columns=['问题类型', 'num', 'month']) # 问题类别、问题数据量统计、全数据统计 bus_dic = { '检查类别缺失': f"select '检查类别缺失' as 问题类型 ,count(1) as num ,substr(EXAM_DATE,1,7) as month from EXAM where EXAM_DATE is not null and substr(EXAM_DATE,1,7)>='{btime}' and substr(EXAM_DATE,1,7)<='{etime}' and EXAM_CLASS is null group by substr(EXAM_DATE,1,7)", '检查部位缺失': f"select '检验部位缺失' as 问题类型 ,count(1) as num ,substr(EXAM_DATE,1,7) as month from EXAM where EXAM_DATE is not null and substr(EXAM_DATE,1,7)>='{btime}' and substr(EXAM_DATE,1,7)<='{etime}' and EXAM_PARA is null group by substr(EXAM_DATE,1,7)", '检查所见缺失': f"select '检查所见缺失' as 问题类型 ,count(1) as num ,substr(EXAM_DATE,1,7) as month from EXAM where EXAM_DATE is not null and substr(EXAM_DATE,1,7)>='{btime}' and substr(EXAM_DATE,1,7)<='{etime}' and DESCRIPTION is null group by substr(EXAM_DATE,1,7)", '检查印象缺失': f"select '检查印象缺失' as 问题类型 ,count(1) as num ,substr(EXAM_DATE,1,7) as month from EXAM where EXAM_DATE is not null and substr(EXAM_DATE,1,7)>='{btime}' and substr(EXAM_DATE,1,7)<='{etime}' and IMPRESSION is null group by substr(EXAM_DATE,1,7)", '检查时间在出入院时间之外': f""" select '检查时间在出入院时间之外' as 问题类型,count(1) as num ,substr(EXAM_DATE,1,7) as month from EXAM t1,overall t2 where ( t1.EXAM_DATE is not null and t2.in_time is not null and t2.out_time is not null) and t1.caseid = t2.caseid and (t1.EXAM_DATE<t2.IN_TIME or t1.EXAM_DATE > t2.OUT_TIME ) and (substr(t1.EXAM_DATE,1,7)>='{btime}' and substr(t1.EXAM_DATE,1,7)<='{etime}') group by substr(EXAM_DATE,1,7) """, } for bus in bus_dic: res = res.append(pd.read_sql(bus_dic[bus], con=engine)) return res # 四级第一张图更新 @app.callback( Output('exam_fourth_level_first_fig','figure'), Output('exam_fourth_level_first_fig_data', 'data'), Input('exam_fourth_level_first_fig_data', 'data'), Input("db_con_url", "data"), Input("count_time", "data"), ) def update_third_level_first_fig(exam_fourth_level_first_fig_data,db_con_url,count_time): if db_con_url is None: return dash.no_update else: db_con_url = json.loads(db_con_url) count_time = json.loads(count_time) engine = create_engine(db_con_url['db']) btime = count_time['btime'][0:7] etime = count_time['etime'][0:7] if exam_fourth_level_first_fig_data is None: exam_fourth_level_first_fig_data = {} exam_fourth_level_first_fig = get_fourth_level_first_fig_date(engine, btime, etime) exam_fourth_level_first_fig_data['exam_fourth_level_first_fig'] = exam_fourth_level_first_fig.to_json( orient='split', date_format='iso') exam_fourth_level_first_fig_data['hosname'] = db_con_url['hosname'] exam_fourth_level_first_fig_data['btime'] = btime exam_fourth_level_first_fig_data['etime'] = etime exam_fourth_level_first_fig_data = json.dumps(exam_fourth_level_first_fig_data) else: exam_fourth_level_first_fig_data = json.loads(exam_fourth_level_first_fig_data) if db_con_url['hosname'] != exam_fourth_level_first_fig_data['hosname']: exam_fourth_level_first_fig = get_fourth_level_first_fig_date(engine, btime, etime) exam_fourth_level_first_fig_data['exam_fourth_level_first_fig'] = exam_fourth_level_first_fig.to_json(orient='split', date_format='iso') exam_fourth_level_first_fig_data['hosname'] = db_con_url['hosname'] exam_fourth_level_first_fig_data['btime'] = btime exam_fourth_level_first_fig_data['etime'] = etime exam_fourth_level_first_fig_data = json.dumps(exam_fourth_level_first_fig_data) else: if exam_fourth_level_first_fig_data['btime'] != btime or exam_fourth_level_first_fig_data['etime'] != etime: exam_fourth_level_first_fig = get_fourth_level_first_fig_date(engine, btime, etime) exam_fourth_level_first_fig_data['exam_fourth_level_first_fig'] = exam_fourth_level_first_fig.to_json(orient='split', date_format='iso') exam_fourth_level_first_fig_data['btime'] = btime exam_fourth_level_first_fig_data['etime'] = etime exam_fourth_level_first_fig_data = json.dumps(exam_fourth_level_first_fig_data) else: exam_fourth_level_first_fig = pd.read_json( exam_fourth_level_first_fig_data['exam_fourth_level_first_fig'], orient='split') exam_fourth_level_first_fig_data = dash.no_update exam_fourth_level_first_fig = exam_fourth_level_first_fig.sort_values(['month']) fig = px.line(exam_fourth_level_first_fig, x="month", y="num", color='问题类型', color_discrete_sequence=px.colors.qualitative.Dark24) fig.update_layout( margin=dict(l=30, r=30, t=30, b=30), legend=dict( orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1 ), ) fig.update_yaxes(title_text="问题数量", ) fig.update_xaxes(title_text="月份", ) return fig,exam_fourth_level_first_fig_data # 下载四级图一明细 @app.callback( Output('exam_fourth_level_first_fig_detail', 'data'), Input('exam_fourth_level_first_fig_data_detail_down','n_clicks'), Input("db_con_url", "data"), Input("count_time", "data"), prevent_initial_call=True, ) def download_first_level_third_fig_data_detail(n_clicks,db_con_url,count_time): if db_con_url is None : return dash.no_update else: if n_clicks is not None and n_clicks>0: n_clicks = 0 db_con_url = json.loads(db_con_url) count_time = json.loads(count_time) engine = create_engine(db_con_url['db']) btime = count_time['btime'][0:7] etime = count_time['etime'][0:7] bus_dic = { '检查类别缺失': f"select * from EXAM where EXAM_DATE is not null and substr(EXAM_DATE,1,7)>='{btime}' and substr(EXAM_DATE,1,7)<='{etime}' and EXAM_CLASS is null ", '检查部位缺失': f"select * from EXAM where EXAM_DATE is not null and substr(EXAM_DATE,1,7)>='{btime}' and substr(EXAM_DATE,1,7)<='{etime}' and EXAM_PARA is null ", '检查所见缺失': f"select * from EXAM where EXAM_DATE is not null and substr(EXAM_DATE,1,7)>='{btime}' and substr(EXAM_DATE,1,7)<='{etime}' and DESCRIPTION is null ", '检查印象缺失': f"select * from EXAM where EXAM_DATE is not null and substr(EXAM_DATE,1,7)>='{btime}' and substr(EXAM_DATE,1,7)<='{etime}' and IMPRESSION is null ", '检查时间在出入院时间之外': f""" select t1.* ,t2.in_time as 入院时间,t2.out_time as 出院时间 from EXAM t1,overall t2 where ( t1.EXAM_DATE is not null and t2.in_time is not null and t2.out_time is not null) and t1.caseid = t2.caseid and (t1.EXAM_DATE<t2.IN_TIME or t1.EXAM_DATE > t2.OUT_TIME ) and (substr(t1.EXAM_DATE,1,7)>='{btime}' and substr(t1.EXAM_DATE,1,7)<='{etime}') """, } output = io.BytesIO() writer = pd.ExcelWriter(output, engine='xlsxwriter') for key in bus_dic.keys(): try: temp = pd.read_sql(bus_dic[key], con=engine) if temp.shape[0] > 0: temp.to_excel(writer, sheet_name=key) except: error_df = pd.DataFrame(['明细数据获取出错'], columns=[key]) error_df.to_excel(writer, sheet_name=key) writer.save() data = output.getvalue() hosName = db_con_url['hosname'] return dcc.send_bytes(data, f'{hosName}检查问题数据明细.xlsx') else: return dash.no_update # # ----------------------------------------------------------------------------------------------------- 四级图二 ---------------------------------------------------------------------------------------------------------------------- # 获取检查四级第二张图数据 def get_fourth_level_second_fig_date(engine,btime,etime): res = pd.read_sql(f"select EXAM_CLASS as 检查类别,count(1) as num ,substr(EXAM_DATE,1,7) as month from EXAM where EXAM_CLASS is not null and substr(EXAM_DATE,1,7)>='{btime}' and substr(EXAM_DATE,1,7)<='{etime}' group by substr(EXAM_DATE,1,7),EXAM_CLASS ",con=engine) return res # 四级第一张图更新 @app.callback( Output('exam_fourth_level_second_fig','figure'), Output('exam_fourth_level_second_fig_data', 'data'), Input('exam_fourth_level_second_fig_data', 'data'), Input("db_con_url", "data"), Input("count_time", "data"), ) def update_third_level_first_fig(exam_fourth_level_second_fig_data,db_con_url,count_time): if db_con_url is None: return dash.no_update else: db_con_url = json.loads(db_con_url) count_time = json.loads(count_time) engine = create_engine(db_con_url['db']) btime = count_time['btime'][0:7] etime = count_time['etime'][0:7] if exam_fourth_level_second_fig_data is None: exam_fourth_level_second_fig_data = {} exam_fourth_level_second_fig = get_fourth_level_second_fig_date(engine, btime, etime) exam_fourth_level_second_fig_data['exam_fourth_level_second_fig'] = exam_fourth_level_second_fig.to_json( orient='split', date_format='iso') exam_fourth_level_second_fig_data['hosname'] = db_con_url['hosname'] exam_fourth_level_second_fig_data['btime'] = btime exam_fourth_level_second_fig_data['etime'] = etime exam_fourth_level_second_fig_data = json.dumps(exam_fourth_level_second_fig_data) else: exam_fourth_level_second_fig_data = json.loads(exam_fourth_level_second_fig_data) if db_con_url['hosname'] != exam_fourth_level_second_fig_data['hosname']: exam_fourth_level_second_fig = get_fourth_level_second_fig_date(engine, btime, etime) exam_fourth_level_second_fig_data['exam_fourth_level_second_fig'] = exam_fourth_level_second_fig.to_json(orient='split', date_format='iso') exam_fourth_level_second_fig_data['hosname'] = db_con_url['hosname'] exam_fourth_level_second_fig_data['btime'] = btime exam_fourth_level_second_fig_data['etime'] = etime exam_fourth_level_second_fig_data = json.dumps(exam_fourth_level_second_fig_data) else: if exam_fourth_level_second_fig_data['btime'] != btime or exam_fourth_level_second_fig_data['etime'] != etime: exam_fourth_level_second_fig = get_fourth_level_second_fig_date(engine, btime, etime) exam_fourth_level_second_fig_data['exam_fourth_level_second_fig'] = exam_fourth_level_second_fig.to_json(orient='split', date_format='iso') exam_fourth_level_second_fig_data['btime'] = btime exam_fourth_level_second_fig_data['etime'] = etime exam_fourth_level_second_fig_data = json.dumps(exam_fourth_level_second_fig_data) else: exam_fourth_level_second_fig = pd.read_json( exam_fourth_level_second_fig_data['exam_fourth_level_second_fig'], orient='split') exam_fourth_level_second_fig_data = dash.no_update exam_fourth_level_second_fig = exam_fourth_level_second_fig.sort_values(['month']) fig = px.bar(exam_fourth_level_second_fig, x="month", y="num", color='检查类别', color_discrete_sequence=px.colors.qualitative.Dark24) fig.update_layout( margin=dict(l=30, r=30, t=30, b=30), legend=dict( orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1 ), ) fig.update_yaxes(title_text="检查数量", ) fig.update_xaxes(title_text="月份", ) return fig,exam_fourth_level_second_fig_data # # # ----------------------------------------------------------------------------------------------------- 全部下载 ---------------------------------------------------------------------------------------------------------------------- # 页面数据统计结果下载 @app.callback( Output("down-rout-exam-temp", "data"), Input("rout-exam-temp-all-count-data-down", "n_clicks"), Input("rout_exam_temp_first_level_first_fig_data", "data"), Input("rout_exam_temp_first_level_second_fig_data", "data"), Input("temp_second_level_first_fig_data", "data"), Input("rout_third_level_first_fig_data", "data"), Input("rout_third_level_second_fig_data", "data"), Input("exam_fourth_level_first_fig_data", "data"), Input("exam_fourth_level_second_fig_data", "data"), Input("db_con_url", "data"), Input("count_time", "data"), prevent_initial_call=True, ) def get_all_count_data(n_clicks, rout_exam_temp_first_level_first_fig_data, rout_exam_temp_first_level_second_fig_data, temp_second_level_first_fig_data, rout_third_level_first_fig_data, rout_third_level_second_fig_data, exam_fourth_level_first_fig_data, exam_fourth_level_second_fig_data, db_con_url,count_time): if db_con_url is None : return dash.no_update else: if n_clicks is not None and n_clicks>0: n_clicks = 0 db_con_url = json.loads(db_con_url) count_time = json.loads(count_time) engine = create_engine(db_con_url['db']) hosName = db_con_url['hosname'] btime = count_time['btime'][0:7] etime = count_time['etime'][0:7] now_time = str(datetime.now())[0:19].replace(' ', '_').replace(':', '_') if rout_exam_temp_first_level_first_fig_data is not None and rout_exam_temp_first_level_second_fig_data is not None and temp_second_level_first_fig_data is not None and \ rout_third_level_first_fig_data is not None and rout_third_level_second_fig_data is not None and exam_fourth_level_first_fig_data is not None and exam_fourth_level_second_fig_data is not None : rout_exam_temp_first_level_first_fig_data = json.loads(rout_exam_temp_first_level_first_fig_data ) rout_exam_temp_first_level_second_fig_data = json.loads(rout_exam_temp_first_level_second_fig_data ) temp_second_level_first_fig_data = json.loads(temp_second_level_first_fig_data ) rout_third_level_first_fig_data = json.loads(rout_third_level_first_fig_data ) rout_third_level_second_fig_data = json.loads(rout_third_level_second_fig_data ) exam_fourth_level_first_fig_data = json.loads(exam_fourth_level_first_fig_data ) exam_fourth_level_second_fig_data = json.loads(exam_fourth_level_second_fig_data ) if rout_exam_temp_first_level_first_fig_data['hosname'] == hosName and \ rout_exam_temp_first_level_second_fig_data['hosname'] == hosName and \ temp_second_level_first_fig_data['hosname'] == hosName and temp_second_level_first_fig_data['btime'] == btime and temp_second_level_first_fig_data['etime'] == etime and \ rout_third_level_first_fig_data['hosname'] == hosName and rout_third_level_first_fig_data['btime'] == btime and rout_third_level_first_fig_data['etime'] == etime and\ rout_third_level_second_fig_data['hosname'] == hosName and rout_third_level_second_fig_data['btime'] == btime and rout_third_level_second_fig_data['etime'] == etime and \ exam_fourth_level_first_fig_data['hosname'] == hosName and exam_fourth_level_first_fig_data['btime'] == btime and exam_fourth_level_first_fig_data['etime'] == etime and \ exam_fourth_level_second_fig_data['hosname'] == hosName and exam_fourth_level_second_fig_data['btime'] == btime and exam_fourth_level_second_fig_data['etime'] == etime : rout_exam_temp_first_level_first_fig_data =
pd.read_json( rout_exam_temp_first_level_first_fig_data['rout_exam_temp_first_level_first_fig'], orient='split')
pandas.read_json
"""Regression Model""" __docformat__ = "numpy" import os import warnings import logging from typing import List, Tuple, Dict, Any import pandas as pd from linearmodels import PooledOLS from linearmodels.panel import ( RandomEffects, BetweenOLS, PanelOLS, FirstDifferenceOLS, compare, ) from pandas import DataFrame from statsmodels.api import add_constant import statsmodels.api as sm from statsmodels.stats.api import het_breuschpagan from statsmodels.stats.diagnostic import acorr_breusch_godfrey from statsmodels.stats.stattools import durbin_watson from openbb_terminal.decorators import log_start_end from openbb_terminal.helper_funcs import export_data from openbb_terminal.rich_config import console logger = logging.getLogger(__name__) def get_regressions_results( regression_type: str, regression_variables: List[Tuple], data: Dict[str, pd.DataFrame], datasets: Dict[pd.DataFrame, Any], entity_effects: bool = False, time_effects: bool = False, ) -> Tuple[DataFrame, Any, List[Any], Any]: """Based on the regression type, this function decides what regression to run. Parameters ---------- regression_type: str The type of regression you wish to execute. regression_variables : list The regressions variables entered where the first variable is the dependent variable. data : dict A dictionary containing the datasets. datasets: dict A dictionary containing the column and dataset names of each column/dataset combination. entity_effects: bool Whether to apply Fixed Effects on entities. time_effects: bool Whether to apply Fixed Effects on time. Returns ------- The dataset used, the dependent variable, the independent variable and the regression model. """ if regression_type == "OLS": return get_ols(regression_variables, data, datasets, False) if regression_type == "POLS": return get_pols(regression_variables, data, datasets) if regression_type == "RE": return get_re(regression_variables, data, datasets) if regression_type == "BOLS": return get_bols(regression_variables, data, datasets) if regression_type == "FE": return get_fe( regression_variables, data, datasets, entity_effects, time_effects ) if regression_type == "FDOLS": return get_fdols(regression_variables, data, datasets) return console.print(f"{regression_type} is not an option.") def get_regression_data( regression_variables: List[tuple], data: Dict[str, pd.DataFrame], datasets: Dict[pd.DataFrame, Any], regression_type: str = "", ) -> Tuple[DataFrame, Any, List[Any]]: """This function creates a DataFrame with the required regression data as well sets up the dependent and independent variables. Parameters ---------- regression_variables : list The regressions variables entered where the first variable is the dependent variable. data : dict A dictionary containing the datasets. datasets: dict A dictionary containing the column and dataset names of each column/dataset combination. regression_type: str The type of regression that is executed. Returns ------- The dataset used, the dependent variable, the independent variable and the OLS model. """ regression = {} independent_variables = [] dependent_variable = None for variable in regression_variables: column, dataset = datasets[variable].keys() regression[f"{column}_{dataset}"] = data[dataset][column] if variable == regression_variables[0]: dependent_variable = f"{column}_{dataset}" elif variable in regression_variables[1:]: independent_variables.append(f"{column}_{dataset}") regression_df =
pd.DataFrame(regression)
pandas.DataFrame
from py_ball import league, image, boxscore import matplotlib.pyplot as plt import time import pandas as pd import sys import requests_cache HEADERS = {'Host': 'stats.nba.com', 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:72.0) Gecko/20100101 Firefox/72.0', 'Accept': 'application/json, text/plain, */*', 'Accept-Language': 'en-US,en;q=0.5', 'Accept-Encoding': 'gzip, deflate, br', 'x-nba-stats-origin': 'stats', 'x-nba-stats-token': 'true', 'Connection': 'keep-alive', 'Referer': 'https://stats.nba.com/', 'Pragma': 'no-cache', 'Cache-Control': 'no-cache'} def pad_id(num): """ pad_id adds the requisite number of leading zeroes to a game number to form a valid game_id @param num (int): Regular season game number Returns: num_str (str): Regular season game number with leading zeroes """ num_str = str(num) while len(num_str) < 4: num_str = '0' + num_str return num_str def get_year_boxscores(year): """ get_year_boxscores pulls data from the boxscores endpoint of the stats.nba.com API @param year (int): year corresponding to the year in which the season began. For example, the 2017-2018 NBA season is represented as the year 2017. Returns: Saves two .csv files of the player and team boxscore data to the current working directory with a name formatted as player_boxscores_[year].csv and team_boxscores_[year].csv """ requests_cache.install_cache('nba_cache_' +str(year)) year_sub = str(year)[-2:] base = '002' + year_sub + '0' box_score_plus = pd.DataFrame({}) game_summaries = pd.DataFrame({}) total_officals = pd.DataFrame({}) if year == 2019: num_games = 706 elif year > 2011: num_games = 41 * 30 elif year == 2011: num_games = 990 elif year > 2003: num_games = 41 * 30 elif year > 1998: num_games = 41 * 29 elif year == 1998: num_games = 25 * 29 elif year > 1994: num_games = 41 * 29 elif year > 1989: num_games = 41 * 27 elif year > 1987: num_games = 41 * 25 else: num_games = 41 * 23 for x in range(1, num_games + 1): print(str(year) + ': Game #' + str(x)) game_id_here = base + pad_id(x) t0 = time.time() success = 0 counter = 0 while ((not success) and (counter < 10)): try: trad = boxscore.BoxScore(headers=HEADERS, game_id=game_id_here, endpoint='boxscoretraditionalv2') time.sleep(2) if (year > 1995): ff = boxscore.BoxScore(headers=HEADERS, game_id=game_id_here, endpoint='boxscorefourfactorsv2') time.sleep(2) misc = boxscore.BoxScore(headers=HEADERS, game_id=game_id_here, endpoint='boxscoremiscv2') time.sleep(2) summary = boxscore.BoxScore(headers=HEADERS, game_id=game_id_here, endpoint='boxscoresummaryv2') success = 1 except: print("Trying again") time.sleep(2) success = 0 counter += 1 if counter == 10: continue box_score_headers = [ 'GAME_ID', 'TEAM_ID', 'TEAM_ABBREVIATION', 'TEAM_CITY', 'PLAYER_ID', 'PLAYER_NAME', 'START_POSITION', 'COMMENT', 'MIN', 'FGM', 'FGA', 'FG_PCT', 'FG3A', 'FG3M', 'FG3_PCT', 'FTA', 'FTM', 'FT_PCT', 'DREB', 'OREB', 'REB', 'AST', 'STL', 'BLK', 'TO', 'PF', 'PTS', 'PLUS_MINUS' ] player_box = pd.DataFrame(trad.data['PlayerStats']) player_box = player_box[box_score_headers] new_player_box = player_box.sort_values(['TEAM_CITY','PLAYER_ID']) if (year > 1995): ff_headers = [ 'EFG_PCT', 'FTA_RATE', 'OPP_EFG_PCT', 'OPP_FTA_RATE', 'OPP_OREB_PCT', 'OPP_TOV_PCT', 'OREB_PCT', 'TM_TOV_PCT'] new_ff = pd.DataFrame(ff.data['sqlPlayersFourFactors']).sort_values(['TEAM_CITY','PLAYER_ID'])[ff_headers] misc_headers = ['BLKA', 'OPP_PTS_2ND_CHANCE', 'OPP_PTS_FB', 'OPP_PTS_OFF_TOV', 'OPP_PTS_PAINT', 'PFD', 'PTS_2ND_CHANCE', 'PTS_FB', 'PTS_OFF_TOV', 'PTS_PAINT'] new_misc = pd.DataFrame(misc.data['sqlPlayersMisc']).sort_values(['TEAM_CITY','PLAYER_ID'])[misc_headers] new_box = pd.concat([new_player_box, new_ff, new_misc], axis=1) else: new_box = new_player_box game_summary = pd.DataFrame(summary.data['GameSummary']) game_info = pd.DataFrame(summary.data['GameInfo']) new_summary = pd.concat([game_summary, game_info], axis=1) new_summary['HOME_TEAM_ID'] = new_summary['HOME_TEAM_ID'].apply(str) new_summary['VISITOR_TEAM_ID'] = new_summary['VISITOR_TEAM_ID'].apply(str) officals = pd.DataFrame(summary.data['Officials']) officals['GAMECODE'] =
pd.DataFrame(game_summary)
pandas.DataFrame