prompt
stringlengths
19
1.03M
completion
stringlengths
4
2.12k
api
stringlengths
8
90
import logging import os import re import warnings # import numpy as np from os import listdir from os.path import isfile, join import numpy as np import pandas as pd import sqlalchemy as sa # from odo import odo from sqlalchemy.inspection import inspect from sqlalchemy.orm import sessionmaker import spherpro.bro as bro import spherpro.bromodules.io_anndata as io_anndata import spherpro.configuration as config import spherpro.db as db import spherpro.library as lib DICT_DB_KEYS = { "image_id": db.images.image_id.key, "object_number": db.objects.object_number.key, "measurement_type": db.measurement_types.measurement_type.key, "measurement_name": db.measurement_names.measurement_name.key, "stack_name": db.stacks.stack_name.key, "plane_id": db.ref_planes.ref_plane_number.key, "object_id": db.objects.object_id.key, } OBJECTS_STACKNAME = "ObjectStack" OBJECTS_CHANNELNAME = "object" OBJECTS_PLANEID = "1" OBJECTS_CHANNELTYPE = "object" READONLY = "_readonly" class DataStore(object): """DataStore The DataStore class is intended to be used as a storage for spheroid IMC data. Methods: Base: read_config: read configfile import_data: reads and writes data to the database resume_data: reads non-database files and configures backend """ def __init__(self): # init empty properties here self.experiment_layout = None self.barcode_key = None self.well_measurements = None self.cut_meta = None self.roi_meta = None self.channel_meta = None self.sphere_meta = None self.measurement_meta_cache = None self._pannel = None self._session = None self._session_maker = None self.connectors = { config.CON_SQLITE: db.connect_sqlite, config.CON_SQLITE + READONLY: db.connect_sqlite_ro, config.CON_MYSQL: db.connect_mysql, config.CON_POSTGRESQL: db.connect_postgresql, } ######################################################################### ######################################################################### # Import or Resume functions: # ######################################################################### ######################################################################### def read_config(self, configpath): """ finds the measurement meta information from a given string Args: configpath: A string denoting the location of the config file Raises: YAMLError """ self.conf = config.read_configuration(configpath) def import_data(self, minimal=None): """read_data Reads the Data using the file locations given in the configfile. Args: minimal: Bool, if True, the import process only imports values from the RefStacks and no location values """ if minimal is None: minimal = False # Read the data based on the config self._read_experiment_layout() self._read_barcode_key() # self._read_measurement_data() self._read_image_data() self._read_relation_data() self._read_stack_meta() self._populate_db(minimal) def resume_data(self, readonly=False): """read_data Reads non-database files and configures backend according to the configfile. """ # Read the data based on the config # self._read_experiment_layout() # self._read_barcode_key() # self._readWellMeasurements() # self._read_cut_meta() # self._read_roi_meta() # self._read_measurement_data() # self._read_stack_meta() self._read_pannel() backend = self.conf[config.BACKEND] if readonly: backend += READONLY self.db_conn = self.connectors[backend](self.conf) self.bro = bro.Bro(self) def drop_all(self): self.db_conn = self.connectors[self.conf[config.BACKEND]](self.conf) db.drop_all(self.db_conn) ########################################## # Helper functions used by readData: # ########################################## def _read_experiment_layout(self): """ reads the experiment layout as stated in the config and saves it in the datastore """ if self.conf[config.LAYOUT_CSV][config.PATH] is not None: sep = self.conf[config.LAYOUT_CSV][config.SEP] experiment_layout = pd.read_csv( self.conf[config.LAYOUT_CSV][config.PATH], sep=sep ) # rename the columns rename_dict = { self.conf[config.LAYOUT_CSV][c]: target for c, target in [ (config.LAYOUT_CSV_COND_ID, db.conditions.condition_id.key), (config.LAYOUT_CSV_COND_NAME, db.conditions.condition_name.key), (config.LAYOUT_CSV_TIMEPOINT_NAME, db.conditions.time_point.key), (config.LAYOUT_CSV_BARCODE, db.conditions.barcode.key), ( config.LAYOUT_CSV_CONCENTRATION_NAME, db.conditions.concentration.key, ), (config.LAYOUT_CSV_BC_PLATE_NAME, db.conditions.bc_plate.key), (config.LAYOUT_CSV_PLATE_NAME, db.conditions.plate_id.key), (config.LAYOUT_CSV_WELL_NAME, db.conditions.well_name.key), ] } experiment_layout = experiment_layout.rename(columns=rename_dict) self.experiment_layout = experiment_layout.fillna(0) else: self.experiment_layout = None def _read_barcode_key(self): """ reads the barcode key as stated in the config """ conf_bc = self.conf[config.BARCODE_CSV] conf_layout = self.conf[config.LAYOUT_CSV] path = conf_bc[config.PATH] if path is not None: # Load the barcode key sep = conf_bc[config.SEP] barcodes =
pd.read_csv(path, sep=sep)
pandas.read_csv
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ synbioParts (c) University of Manchester 2019 synbioParts is licensed under the MIT License. To view a copy of this license, visit <http://opensource.org/licenses/MIT/>. Created on Fri May 31 13:38:19 2019 @author: <NAME>, SYNBIOCHEM @description: Routines to interface with synbio repositories - parts: list of pointers to SynBiohub, we assume that each part (origin, resistance, promoter) has been already registered in the part registry; - pathway: list of enzymes referred by either: - SynbioHub identifier: useful if the part has been previously registered or for gene variants (RBS library or mutants) - UniProt identifier: a new empty container for this part is created in SynBioHub, which will be later filled by the DNA design step """ import os import re import sbol2 as sbol import requests import time import numpy as np import pandas as pd from .OptDes import getDoe from .Args import ( DEFAULT_libsize, DEFAULT_get_sequences, DEFAULT_backtranslate, DEFAULT_condon_table, ) from logging import ( Logger, getLogger, DEBUG ) logger = getLogger(__name__) # logger.setLevel(DEBUG) def doeSBOL(pfile='RefParts.csv', gfile='GeneParts.csv', libsize=32, ofile='out.sbol'): """ Perform the DoE and generate the SBOL file from the parts and genes files - RefParts.csv: Name, Type, Part - GeneParts.csv: Name, Type, Part, Step Type: origin, resistance, promoter, terminator, gene Step: Enzyme step in the pathway (eventually could be implemented for the other genetic parts) """ diagnostics, cons = getTheDoe(pfile,gfile,libsize) doc = getSBOL(pfile,gfile,cons) doc.write(ofile) def doeGetSBOL( gfile, pfile='RefParts.csv', gsbol=None, libsize=DEFAULT_libsize, getSequences=DEFAULT_get_sequences, backtranslate=DEFAULT_backtranslate, codontable=DEFAULT_condon_table ): """ Perform the DoE and generate the SBOL file from the parts and genes files - RefParts.csv: Name, Type, Part Name: part name Type: origin, resistance, promoter, terminator, gene Part: SynBioHub URI - GeneParts.csv: Name, Type, Part, Step, Sequence Name: gene name Type: gene Step: Enzyme step in the pathway (eventually could be implemented for the other genetic parts) Part: identifier (UniProt, etc) or SynBioHub URI Sequence: gene sequence (optional: if not given they are retrieved from UniProt or SynBioHub) - Gsbol: SBOL file containing optimised versions of the genes (RBS, etc) """ parts = pd.read_csv(pfile) genes = pd.read_csv(gfile) if gsbol is not None and os.path.exists(gsbol): genes = _readGenesSBOL(gsbol, genes) diagnostics, cons = getTheDoe(parts,genes,libsize) doc = getSBOL(parts,genes,cons,getSequences,backtranslate,codontable, gsbol) diagnostics['sbol'] = doc.writeString() return diagnostics def _readGenesSBOL(gsbol, genes, roles=[sbol.SO_GENE]): """ Create a new gene table containing the genes in the SBOL """ partsdoc = sbol.Document() partsdoc.read(gsbol) gdict = {} for i in genes.index: gid = genes.loc[i,'Part'] if gid not in gdict: gdict[gid] = [] gdict[gid].append( genes.loc[i,:] ) ngenes = [] for part in partsdoc.componentDefinitions: if len( set(part.roles) & set(roles) ) > 0: dispid = part.displayId disp = dispid.split('_') rbs = disp[-2] cds = '_'.join( disp[0:(len(disp)-2)] ) if cds in gdict: for row in gdict[cds]: row = row.copy() row.loc['Name'] = dispid row.loc['Part'] = part.persistentIdentity ngenes.append( row ) ngenes =
pd.DataFrame(ngenes, columns=genes.columns)
pandas.DataFrame
""" The Transform components allow transforming tables in arbitrary ways. """ import datetime as dt import numpy as np import pandas as pd import panel as pn import param from ..util import resolve_module_reference class Transform(param.Parameterized): """ A Transform provides the ability to transform a table supplied by a Source. """ controls = param.List(default=[], doc=""" Parameters that should be exposed as widgets in the UI.""") transform_type = None _field_params = [] __abstract = True @classmethod def _get_type(cls, transform_type): if '.' in transform_type: return resolve_module_reference(transform_type, Transform) try: __import__(f'lumen.transforms.{transform_type}') except Exception: pass for transform in param.concrete_descendents(cls).values(): if transform.transform_type == transform_type: return transform raise ValueError(f"No Transform for transform_type '{transform_type}' could be found.") @classmethod def from_spec(cls, spec): """ Resolves a Transform specification. Parameters ---------- spec: dict Specification declared as a dictionary of parameter values. Returns ------- The resolved Transform object. """ spec = dict(spec) transform_type = Transform._get_type(spec.pop('type', None)) new_spec = {} for k, v in spec.items(): if (k in transform_type.param and isinstance(transform_type.param[k], param.ListSelector) and not isinstance(v, list)): v = [v] new_spec[k] = v return transform_type(**new_spec) @classmethod def apply_to(cls, table, **kwargs): """ Calls the apply method based on keyword arguments passed to define transform. Parameters ---------- table: `pandas.DataFrame` Returns ------- A DataFrame with the results of the transformation. """ return cls(**kwargs).apply(table) def apply(self, table): """ Given a table transform it in some way and return it. Parameters ---------- table : DataFrame The queried table as a DataFrame. Returns ------- DataFrame A DataFrame containing the transformed data. """ return table @property def control_panel(self): return pn.Param( self.param, parameters=self.controls, sizing_mode='stretch_width', margin=(-10, 0, 5, 0) ) class HistoryTransform(Transform): """ The HistoryTransform accumulates a history of the queried data in a buffer up to the supplied length and (optionally) adds a date_column to the data. """ date_column = param.Selector(doc=""" If defined adds a date column with the supplied name.""") length = param.Integer(default=10, bounds=(1, None), doc=""" Accumulates a history of data.""") transform_type = 'history' _field_params = ['date_column'] def __init__(self, **params): super().__init__(**params) self._buffer = [] def apply(self, table): """ Accumulates a history of the data in a buffer up to the declared `length` and optionally adds the current datetime to the declared `date_column`. Parameters ---------- data : DataFrame The queried table as a DataFrame. Returns ------- DataFrame A DataFrame containing the buffered history of the data. """ if self.date_column: table = table.copy() table[self.date_column] = dt.datetime.now() self._buffer.append(table) self._buffer[:] = self._buffer[-self.length:] return
pd.concat(self._buffer)
pandas.concat
""" Filters joint involvement data to treatment-naive patients diagnosed up to one year after symptom onset who have joint involvement at baseline. Patients must also not be withdrawn at any point from the study. """ import click import feather import pandas as pd from logging import * def load_data(basic_path: str, medication_path: str, joint_injection_path: str, joint_path: str) -> (pd.DataFrame, pd.DataFrame, pd.DataFrame, pd.DataFrame): """ Loads data from the given paths. Returns: The loaded data. """ info('Reading basic information from {}'.format(basic_path)) basic_data = feather.read_dataframe(basic_path) basic_data.info() basic_data.set_index('subject_id', inplace=True) info('Reading medications from {}'.format(medication_path)) medication_data = feather.read_dataframe(medication_path) medication_data.info() medication_data = medication_data.loc[medication_data['visit_id'] == 1].set_index('subject_id') info('Reading joint injections from {}'.format(joint_injection_path)) joint_injection_data = feather.read_dataframe(joint_injection_path) joint_injection_data.info() joint_injection_data = joint_injection_data.loc[joint_injection_data[ 'visit_id'] == 1].set_index('subject_id') info('Reading joint involvements from {}'.format(joint_path)) joint_data = feather.read_dataframe(joint_path) joint_data.info() return basic_data, medication_data, joint_injection_data, joint_data def get_basic_masks(df: pd.DataFrame) -> pd.DataFrame: """ Obtains masks for the given basic data. Args: df: A table of basic information. Returns: The masks. """ mask_sex = pd.notnull(df['sex']) info('{} patients had sex information'.format(mask_sex.sum())) mask_dx = pd.notnull(df['diagnosis_6_months']) info('{} patients had recorded diagnoses'.format(mask_dx.sum())) mask_withdrawn = ~(df['withdrawn']) info('{} patients were not withdrawn'.format(mask_withdrawn.sum())) mask_symptom_onset_age = (df['symptom_onset_age'] > 0) & ( df['symptom_onset_age'] < 16) info('{} patients were between 0 and 16 years of age at symptom onset'. format(mask_symptom_onset_age.sum())) mask_onset_to_diagnosis = (df['symptom_onset_to_diagnosis_days'] >= 0) & ( df['symptom_onset_to_diagnosis_days'] < 365) info(('{} patients were diagnosed between 0 days and before one year ' 'after symptom onset').format(mask_onset_to_diagnosis.sum())) mask_basic = (mask_sex & mask_dx & mask_withdrawn & mask_symptom_onset_age & mask_onset_to_diagnosis) info('{} patients satisfied basic inclusion criteria'.format( mask_basic.sum())) return pd.DataFrame.from_items( [('sex', mask_sex), ('diagnosis', mask_dx), ('withdrawn', mask_withdrawn), ('symptom_onset_age', mask_symptom_onset_age), ('onset_to_diagnosis', mask_onset_to_diagnosis), ('basic_combined', mask_basic)]) def get_medication_masks(medication_df: pd.DataFrame, joint_injection_df: pd.DataFrame) -> pd.DataFrame: """ Obtains masks for the given medication data and joint injection data. Args: df: A table of medications. Returns: The masks. """ mask_dmards = medication_df['dmard_status'].isin(['NONE', 'NEW']) info('{} patients were not previously on DMARDs'.format(mask_dmards.sum())) mask_steroids = medication_df['steroid_status'].isin(['NONE', 'NEW']) info('{} patients were not previously on steroids'.format( mask_steroids.sum())) mask_ivig = medication_df['ivig_status'].isin(['NONE', 'NEW']) info('{} patients were not previously on IVIG'.format(mask_ivig.sum())) mask_biologics = medication_df['biologic_status'].isin(['NONE', 'NEW']) info('{} patients were not previously on biologics'.format( mask_biologics.sum())) mask_joint_injections = ( joint_injection_df['injection_status'] == 'NONE') | ( joint_injection_df['days_max'] < 0) info('{} patients had no joint injections'.format( mask_joint_injections.sum())) mask_medications = (mask_dmards & mask_steroids & mask_ivig & mask_biologics & mask_joint_injections) info('{} patients satisfied medication requirements'.format( mask_medications.sum())) return pd.DataFrame.from_items( [('dmards', mask_dmards), ('steroids', mask_steroids), ('ivig', mask_ivig), ('biologics', mask_biologics), ('joint_injections', mask_joint_injections), ('medications_combined', mask_medications)]) def get_joint_count_masks(df: pd.DataFrame) -> pd.DataFrame: """ Obtains a joint count mask. Args: df: A table of joint involvements. Returns: The mask. """ baseline_joint_counts = df.loc[df['visit_id'] == 1].drop( 'visit_id', axis=1).set_index('subject_id').sum(axis=1) mask_joints = baseline_joint_counts > 0 info('{} patients had joints involved at baseline'.format(mask_joints.sum( ))) return
pd.DataFrame.from_items([('joint_count', mask_joints)])
pandas.DataFrame.from_items
# # Copyright (c) 2018 Intel Corporation # # 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. # """This module provides various model summary information. This code is currently in "experimental" state, as we wait for the next release of PyTorch with stable support for the JIT tracer functionality we employ in this code (it was built with a 4.x master branch). """ import torch import torchvision from torch.autograd import Variable import torch.jit as jit import pandas as pd from tabulate import tabulate class SummaryGraph(object): """We use Pytorch's JIT tracer to run a forward pass and generate a trace graph, which is an internal representation of the model. We then use ONNX to "clean" this representation. After builiding a new representation of the graph, we can print it to a table, a PNG, add information to nodes, etc. The trace is a C++ component and the API is not documented, so we need to dig into some Pytorch internals code to understand how to get the info we need. https://github.com/pytorch/pytorch/blob/master/torch/onnx/__init__.py https://github.com/pytorch/pytorch/blob/master/torch/onnx/symbolic.py We think that using the trace output to generate a representation of the graph, is the best method available in Pytorch, due to the module's dynamic nature. Pytorch's module API naturally ignores layers/operations which are implemented as torch.autograd.Function, without an nn.Module. For example: out = F.relu(self.bn1(self.conv1(x))) Another case where traversing the nn.Module API is not sufficient to create a representation of the graph, is the same nn.Module is used several times in the graph. For example: out = self.conv1(x) out = self.bn1(out) out = self.relu(out) <=== First use of self.relu out = self.conv2(out) out = self.bn2(out) out = self.relu(out) <=== Second use of self.relu """ def __init__(self, model, dummy_input): with torch.onnx.set_training(model, False): trace, _ = jit.trace(model, dummy_input) # Let ONNX do the heavy lifting: fusing the convolution nodes; fusing the nodes # composing a GEMM operation; etc. torch.onnx._optimize_trace(trace, False) graph = trace.graph() self.ops = [] self.params = {} self.edges = [] self.temp = {} in_out = list(graph.inputs()) + list(graph.outputs()) for param in in_out: self.__add_param(param) for node in graph.nodes(): op = {} op['name'] = node.scopeName() op['orig-name'] = node.scopeName() op['type'] = node.kind() op['inputs'] = [] op['outputs'] = [] op['params'] = [] # in-place operators create very confusing graphs (Resnet, for example), # so we "unroll" them same = [layer for layer in self.ops if layer['orig-name'] == op['orig-name']] if len(same) > 0: op['name'] += "." + str(len(same)) self.ops.append(op) for input_ in node.inputs(): self.__add_input(op, input_) self.edges.append((input_.uniqueName(), op['name'])) for output in node.outputs(): self.__add_output(op, output) self.edges.append((op['name'], output.uniqueName())) op['attrs'] = {attr_name: node[attr_name] for attr_name in node.attributeNames()} def __add_input(self, op, n): param = self.__add_param(n) if param is None: return if param['id'] not in op['inputs']: op['inputs'].append(param['id']) def __add_output(self, op, n): param = self.__add_param(n) if param is None: return if param['id'] not in op['outputs']: op['outputs'].append(param['id']) def __add_param(self, n): param = {} if n.uniqueName() not in self.params: param = self.__tensor_desc(n) self.params[n.uniqueName()] = param else: param = self.params[n.uniqueName()] return param def __tensor_desc(self, n): tensor = {} tensor['id'] = n.uniqueName() try: s = str(n.type()) tensor['type'] = s[:s.find('(')] s = s[s.find('(')+1: s.find(')')] tensor['shape'] = tuple(map(lambda x: int(x), s.split(','))) except: return None return tensor def attributes_summary(sgraph, ignore_attrs): """Generate a summary of a graph's attributes. Args: sgraph: a SummaryGraph instance ignore_attrs: a list of attributes to ignore in the output datafraem Output: A Pandas dataframe """ def pretty_val(val): if type(val) == int: return format(val, ",d") return str(val) def pretty_attrs(attrs, ignore_attrs): ret = '' for key, val in attrs.items(): if key in ignore_attrs: continue ret += key + ': ' + pretty_val(val) + '\n' return ret df = pd.DataFrame(columns=['Name', 'Type', 'Attributes']) pd.set_option('precision', 5) for i, op in enumerate(sgraph.ops): df.loc[i] = [op['name'], op['type'], pretty_attrs(op['attrs'], ignore_attrs)] return df def attributes_summary_tbl(sgraph, ignore_attrs): df = attributes_summary(sgraph, ignore_attrs) return tabulate(df, headers='keys', tablefmt='psql') def connectivity_summary(sgraph): """Generate a summary of each node's connectivity. Args: sgraph: a SummaryGraph instance """ df = pd.DataFrame(columns=['Name', 'Type', 'Inputs', 'Outputs']) pd.set_option('precision', 5) for i, op in enumerate(sgraph.ops): df.loc[i] = [op['name'], op['type'], op['inputs'], op['outputs']] return df def connectivity_summary_verbose(sgraph): """Generate a summary of each node's connectivity, with details about the parameters. Args: sgraph: a SummaryGraph instance """ def format_list(l): ret = '' for i in l: ret += str(i) + '\n' return ret[:-1] df = pd.DataFrame(columns=['Name', 'Type', 'Inputs', 'Outputs'])
pd.set_option('precision', 5)
pandas.set_option
""" This file originated from the online analysis project at: https://github.com/OlafHaag/UCM-WebApp """ import itertools import pandas as pd import pingouin as pg import numpy as np from scipy.stats import wilcoxon from sklearn.decomposition import PCA from sklearn.covariance import EllipticEnvelope def preprocess_data(users, blocks, trials): """ Clean data. :param users: Data from users table :type users: pandas.DataFrame :param blocks: Data from circletask_blocks table. :type blocks: pandas.DataFrame :param trials: Data from circletask_trials table. :type trials: pandas.DataFrame :returns: Joined and recoded DataFrame. Number of erroneous blocks. Number of sessions removed as a consequence. Number of removed trials. :rtype: tuple[pandas.DataFrame, int, int, int] """ blocks, n_errors, invalid_sessions = remove_erroneous_blocks(blocks) # Merge to 1 table. df = join_data(users, blocks, trials) # Remove invalid trials. cleaned, n_trials_removed = get_valid_trials(df) return cleaned, n_errors, len(invalid_sessions), n_trials_removed def remove_erroneous_blocks(blocks, delta_time=2.0, n_blocks=3): """ Remove sessions with erroneous data due to a NeuroPsy Research App malfunction. The error causes block data to be duplicated and the values for df1 & df2 multiplied again by 100. The duplicated blocks are identified by comparing their time stamps to the previous block (less than 2 seconds difference). If the error caused the session to end early, the whole session is removed. NeuroPsyResearchApp issue #1. :param pandas.DataFrame blocks: Data about blocks. :param float delta_time: Threshold in seconds for which a consecutive block in a session is considered invalid if it was completed within this period after the previous. Default is 2.0 seconds. :param int n_blocks: Required number of blocks per session. If a session doesn't have this many blocks, it gets removed. :returns: Cleaned block data. Number of errors found. List of sessions that were removed as a consequence. :rtype: tuple[pandas.DataFrame, int, list] """ # Identify duplicated blocks. Consecutive time stamps are usually less than 2 seconds apart. mask = blocks.groupby(['session_uid'])['time'].diff() < delta_time try: n_errors = mask.value_counts()[True] except KeyError: n_errors = 0 blocks = blocks.loc[~mask, :] # Now, after removal of erroneous data a session might not have all 3 blocks we expect. Exclude whole session. invalid_sessions = blocks['session_uid'].value_counts() != n_blocks invalid_sessions = invalid_sessions.loc[invalid_sessions].index.to_list() blocks = blocks.loc[~blocks['session_uid'].isin(invalid_sessions), :] return blocks, n_errors, invalid_sessions def join_data(users, blocks, trials): """ Take data from different database tables and join them to a single DataFrame. Some variables are renamed and recoded in the process, some are dropped. :param users: Data from users table :type users: pandas.DataFrame :param blocks: Data from circletask_blocks table. :type blocks: pandas.DataFrame :param trials: Data from circletask_trials table. :type trials: pandas.DataFrame :return: Joined and recoded DataFrame. :rtype: pandas.DataFrame """ # Use users' index instead of id for obfuscation and shorter display. users_inv_map = pd.Series(users.index, index=users.id) # Remove trials that don't belong to any block. Those have been excluded. trials = trials.loc[trials['block_id'].isin(blocks.index), :] # Start a new table for trials and augment with data from other tables. df = pd.DataFrame(index=trials.index) df['user'] = trials.user_id.map(users_inv_map).astype('category') df['session'] = trials['block_id'].map(blocks['nth_session']).astype('category') # Map whole sessions to the constraint in the treatment block as a condition for easier grouping during analysis. df['condition'] = trials['block_id'].map(blocks[['session_uid', 'treatment']].replace( {'treatment': {'': np.nan}}).groupby('session_uid')['treatment'].ffill().bfill()).astype('category') df['block'] = trials['block_id'].map(blocks['nth_block']).astype('category') # Add pre and post labels to trials for each block. Name it task instead of treatment. # Theoretically, one could have changed number of blocks and order of treatment, but we assume default order here. df['task'] = trials['block_id'].map(blocks['treatment'].replace('', np.nan).where(~blocks['treatment'].isna(), blocks['nth_block'].map( {1: 'pre', 3: 'post' }) ) ).astype('category') #df['task'] = trials['block_id'].map(blocks['treatment'].replace(to_replace={r'\w+': 1, r'^\s*$': 0}, regex=True) # ).astype('category') df = pd.concat((df, trials), axis='columns') # Add columns for easier filtering. df['grab_diff'] = (df['df2_grab'] - df['df1_grab']).abs() df['duration_diff'] = (df['df2_duration'] - df['df1_duration']).abs() # Exclude columns. df.drop(columns=['user_id'], inplace=True) return df def get_valid_trials(dataframe): """ Remove trials where sliders where not grabbed concurrently or grabbed at all. :param dataframe: Trial data. :type dataframe: pandas.DataFrame :returns: Filtered trials. Number of removed trials. :rtype: tuple[pandas.DataFrame, int] """ # Remove trials with missing values. This means at least one slider wasn't grabbed. df = dataframe.dropna(axis='index', how='any') # Remove trials where sliders where not grabbed concurrently. mask = ~((df['df1_release'] <= df['df2_grab']) | (df['df2_release'] <= df['df1_grab'])) df = df.loc[mask, :] n_removed = len(dataframe) - len(df) return df, n_removed def get_outlyingness(data, contamination=0.1): """ Outlier detection from covariance estimation in a Gaussian distributed dataset. :param data: Data in which to detect outliers. Take care that n_samples > n_features ** 2 . :type data: pandas.DataFrame :param contamination: The amount of contamination of the data set, i.e. the proportion of outliers in the data set. Range is (0, 0.5). :type contamination: float :returns: Decision on each row if it's an outlier. And contour array for drawing ellipse in graph. :rtype: tuple[numpy.ndarray, numpy.ndarray] """ robust_cov = EllipticEnvelope(support_fraction=1., contamination=contamination) outlyingness = robust_cov.fit_predict(data) decision = (outlyingness-1).astype(bool) # Visualisation. xx, yy = np.meshgrid(np.linspace(0, 100, 101), np.linspace(0, 100, 101)) z = robust_cov.predict(np.c_[xx.ravel(), yy.ravel()]) z = z.reshape(xx.shape) return decision, z #ToDo: remove blocks/sessions with sum mean way off. #ToDo: remove sessions with less than 10 trials in any block. def get_performance_data(dataframe): """[summary] :param dataframe: [description] :type dataframe: [type] """ dataframe.groupby(['user', 'block', 'task'])[['df1', 'df2']].mean().dropna().sort_index(level=['user','block']) def get_pca_data(dataframe): """ Conduct Principal Component Analysis on 2D dataset. :param dataframe: Data holding 'df1' and 'df2' values as columns. :type dataframe: pandas.DataFrame :return: Explained variance, components and means. :rtype: pandas.DataFrame """ # We don't reduce dimensionality, but overlay the 2 principal components in 2D. pca = PCA(n_components=2) x = dataframe[['df1', 'df2']].values try: # df1 and df2 have the same scale. No need to standardize. Standardizing might actually distort PCA here. pca.fit(x) except ValueError: # Return empty. df = pd.DataFrame(columns=['var_expl', 'var_expl_ratio', 'x', 'y', 'meanx', 'meany']) else: df = pd.DataFrame({'var_expl': pca.explained_variance_.T, 'var_expl_ratio': pca.explained_variance_ratio_.T * 100, # In percent 'x': pca.components_[:, 0], 'y': pca.components_[:, 1], 'meanx': pca.mean_[0], 'meany': pca.mean_[1], }, index=[1, 2] # For designating principal components. ) df.index.rename('PC', inplace=True) return df def get_pca_vectors(dataframe): """ Get principal components as vectors. Vectors can then be used to annotate graphs. :param dataframe: Tabular PCA data. :type dataframe: pandas.DataFrame :return: Principal components as vector pairs in input space with mean as origin first and offset second. :rtype: list """ # Use the "components" to define the direction of the vectors, # and the "explained variance" to define the squared-length of the vectors. directions = dataframe[['x', 'y']] * np.sqrt(dataframe[['var_expl']].values) * 3 # Move the directions by the mean, so we get vectors pointing to the start and vectors pointing to the destination. vector2 = directions + dataframe[['meanx', 'meany']].values vectors = list(zip(dataframe[['meanx', 'meany']].values, vector2.values)) return vectors def get_pca_vectors_by(dataframe, by=None): """ Get principal components for each group as vectors. Vectors can then be used to annotate graphs. :param dataframe: Data holding 'df1' and 'df2' values as columns. :type dataframe: pandas.DataFrame :param by: Column to group data by and return 2 vectors for each group. :type by: str|list :return: list of principal components as vector pairs in input space with mean as origin first and offset second. :rtype: list """ vector_pairs = list() if by is None: pca_df = get_pca_data(dataframe) v = get_pca_vectors(pca_df) vector_pairs.append(v) else: grouped = dataframe.groupby(by, observed=True) # With categorical groupers we want only non-empty groups. for group, data in grouped: pca_df = get_pca_data(data) v = get_pca_vectors(pca_df) vector_pairs.append(v) # ToDo: Augment by groupby criteria. return vector_pairs def get_interior_angle(vec0, vec1): """ Get the smaller angle between vec0 and vec1 in degrees. :param vec0: Vector 0 :type vec0: numpy.ndarray :param vec1: Vector 1 :type vec1: numpy.ndarray :return: Interior angle between vector0 and vector1 in degrees. :rtype: float """ angle = np.math.atan2(np.linalg.det([vec0, vec1]), np.dot(vec0, vec1)) degrees = abs(np.degrees(angle)) # Min and max should be between 0° an 90°. degrees = min(degrees, 180.0 - degrees) return degrees def get_ucm_vec(p0=None, p1=None): """ Returns 2D unit vector in direction of uncontrolled manifold. """ if p0 is None: p0 = np.array([25, 100]) if p1 is None: p1 = np.array([100, 25]) parallel = p1 - p0 parallel = parallel / np.linalg.norm(parallel) # Normalize. return parallel def get_orthogonal_vec2d(vec): """ Get a vector that is orthogonal to vec and has same length. :param vec: 2D Vector :return: 2D Vector orthogonal to vec. :rtype: numpy.ndarray """ ortho = np.array([-vec[1], vec[0]]) return ortho def get_pc_ucm_angles(dataframe, vec_ucm): """ Computes the interior angles between pca vectors and ucm parallel/orthogonal vectors. :param dataframe: PCA data. :type dataframe: pandas.DataFrame :param vec_ucm: Vector parallel to UCM. :type vec_ucm: numpy.ndarray :return: Each angle between principal components and UCM parallel and orthogonal vector. :rtype: pandas.DataFrame """ df_angles = dataframe[['x', 'y']].transform(lambda x: (a:=get_interior_angle(vec_ucm, x), 90.0 - a), axis='columns').rename(columns={'x': 'parallel', 'y': 'orthogonal'}) df_angles = pd.concat((dataframe[['task', 'PC']], df_angles), axis='columns') return df_angles def get_projections(points, vec_ucm): """ Returns coefficients a and b in x = a*vec_ucm + b*vec_ortho with x being the difference of a data point and the mean. Projection is computed using a transformation matrix with ucm parallel and orthogonal vectors as basis. :param points: Data of 2D points. :type points: pandas.Dataframe :param vec_ucm: Unit vector parallel to uncontrolled manifold. :type vec_ucm: numpy.ndarray :return: Array with projected lengths onto vector parallel to UCM as 'a', onto vector orthogonal to UCM as 'b'. :rtype: pandas.Dataframe """ # Get the vector orthogonal to the UCM. vec_ortho = get_orthogonal_vec2d(vec_ucm) # Build a transformation matrix with vec_ucm and vec_ortho as new basis vectors. A = np.vstack((vec_ucm, vec_ortho)).T # A is not an orthogonal projection matrix (A=A.T), but this works. # Centralize the data. Analogous to calculating across trials deviation from average for each time step. diffs = points - points.mean() # For computational efficiency we shortcut the projection calculation with matrix multiplication. # The actual math behind it: # coeffs = vec_ucm.T@diff/np.sqrt(vec_ucm.T@vec_ucm), vec_ortho.T@diff/np.sqrt(vec_ortho.T@vec_ortho) # Biased variance (normalized by (n-1)) of projection onto UCM vector: # var_ucm = [email protected](diffs, bias=True, rowvar=False)@vec_ucm/(vec_ucm.T@vec_ucm) # Rayleigh fraction. coeffs = diffs@A coeffs.columns = ['parallel', 'orthogonal'] return coeffs def get_synergy_indices(variances, n=2, d=1): """ n: Number of degrees of freedom. In our case 2. d: Dimensionality of performance variable. In our case a scalar (1). Vucm = 1/N * 1/(n - d) * sum(ProjUCM**2) Vort = 1/N * 1/(d) * sum(ProjORT**2) Vtotal = 1/n * (d * Vort + (n-d) * Vucm) # Anull the weights on Vucm and Vort for the sum. dV = (Vucm - Vort) / Vtotal dV = n*(Vucm - Vort) / ((n - d)*Vucm + d*Vort) Zhang (2008) without weighting Vucm, Vort and Vtotal first: dV = n * (Vucm/(n - d) - Vort/d) / (Vucm + Vort) dVz = 0.5*ln((n / d + dV) / (n / ((n - d) - dV)) dVz = 0.5*ln((2 + dV) / (2 - dV)) Reference: https://www.frontiersin.org/articles/10.3389/fnagi.2019.00032/full#supplementary-material :param variances: Unweighted variances of parallel and orthogonal projections to the UCM. :type variances: pandas.DataFrame :param n: Number of degrees of freedom. Defaults to 2. :type: int :param d: Dimensionality of performance variable. Defaults to 1. :type d: int :returns: Synergy index, Fisher's z-transformed synergy index. :rtype: pandas.DataFrame """ try: dV = n * (variances['parallel']/(n-d) - variances['orthogonal']/d) \ / variances[['parallel', 'orthogonal']].sum(axis='columns') except KeyError: synergy_indices = pd.DataFrame(columns=["dV", "dVz"]) else: dVz = 0.5 * np.log((n/d + dV)/(n/(n-d) - dV)) synergy_indices = pd.DataFrame({"dV": dV, "dVz": dVz}) return synergy_indices def get_synergy_idx_bounds(n=2, d=1): """ Get lower and upper bounds of the synergy index. dV = n * (Vucm/(n - d) - Vort/d) / (Vucm + Vort) If all variance lies within the UCM, then Vort=0 and it follows for the upper bound: dV = n/(n-d) If all variance lies within Vort, then Vucm=0 and it follows for the lower bound: dV = -n/d :param n: Number of degrees of freedom. :type: int :param d: Dimensionality of performance variable. :type d: int :returns: Lower and upper bounds of synergy index. :rtype: tuple """ dV_lower = -n/d dV_upper = n/(n-d) return dV_lower, dV_upper def get_mean(dataframe, column, by=None): """ Return mean values of column x (optionally grouped) :param dataframe: Data :type dataframe: pandas.Dataframe :param column: Column name :type column: str :param by: Column names by which to group. :type by: str|list :return: mean value, optionally for each group. :rtype: numpy.float64|pandas.Series """ if by is None: means = dataframe[column].mean() else: means = dataframe.groupby(by, observed=True)[column].mean() return means def get_descriptive_stats(data, by=None): """ Return mean and variance statistics for data. :param data: numerical data. :type data: pandas.Dataframe :param by: groupby column name(s) :type by: str|List :return: Dataframe with columns mean, var, count and column names of data as rows. :rtype: pandas.Dataframe """ # There's a bug in pandas 1.0.4 where you can't use custom numpy functions in agg anymore (ValueError). # Note that the variance of projections is usually divided by (n-d) for Vucm and d for Vort. Both are 1 in our case. # Pandas default var returns unbiased population variance /(n-1). Doesn't make a difference for synergy indices. f_var = lambda series: series.var(ddof=0) f_var.__name__ = 'variance' # Column name gets function name. # When there're no data, return empty DataFrame with columns. if data.empty: if by: data.set_index(by, drop=True, inplace=True) col_idx = pd.MultiIndex.from_product([data.columns, ['mean', f_var.__name__]]) stats = pd.DataFrame(None, index=data.index, columns=col_idx) stats['count'] = None return stats if not by: stats = data.agg(['mean', f_var, 'count']).T stats['count'] = stats['count'].astype(int) else: grouped = data.groupby(by, observed=True) stats = grouped.agg(['mean', f_var]) stats['count'] = grouped.size() stats.dropna(inplace=True) return stats def get_statistics(dataframe): """ Calculate descriptive statistics including synergy indices for key values of the anaylsis. :param dataframe: Data from joined table on trials with projections. :type dataframe: pandas.DataFrame :return: Descriptive statistics and synergy indices. :rtype: pandas.DataFrame """ groupers = ['user', 'session', 'condition', 'block_id', 'block', 'task'] try: dataframe[groupers] = dataframe[groupers].astype('category') except (KeyError, ValueError): df_stats = get_descriptive_stats(pd.DataFrame(columns=dataframe.columns)) cov = pd.DataFrame(columns=[('df1,df2 covariance', '')]) else: df_stats = get_descriptive_stats(dataframe[groupers + ['df1', 'df2', 'sum', 'parallel', 'orthogonal']], by=groupers).drop(columns=[('parallel', 'mean'), # Always equal 0. ('orthogonal', 'mean')]) # Get statistic characteristics of absolute lengths of projections. length = dataframe.groupby(groupers, observed=True)[['parallel', 'orthogonal']].agg(lambda x: x.abs().mean()) length.columns = pd.MultiIndex.from_product([length.columns, ['absolute average']]) # Get covariance between degrees of freedom. cov = dataframe.groupby(groupers, observed=True)[['df1', 'df2']].apply(lambda x: np.cov(x.T, ddof=0)[0, 1]) try: cov = cov.to_frame(('df1,df2 covariance', '')) # MultiIndex. except AttributeError: # In case cov is an empty Dataframe. cov = pd.DataFrame(columns=pd.MultiIndex.from_tuples([('df1,df2 covariance', '')])) # Get synergy indices based on projection variances we just calculated. df_synergies = get_synergy_indices(df_stats[['parallel', 'orthogonal']].xs('variance', level=1, axis='columns')) # Before we merge dataframes, give this one a Multiindex, too. df_synergies.columns =
pd.MultiIndex.from_product([df_synergies.columns, ['']])
pandas.MultiIndex.from_product
import csv from io import StringIO import os import numpy as np import pytest from pandas.errors import ParserError import pandas as pd from pandas import ( DataFrame, Index, MultiIndex, NaT, Series, Timestamp, date_range, read_csv, to_datetime, ) import pandas._testing as tm import pandas.core.common as com from pandas.io.common import get_handle MIXED_FLOAT_DTYPES = ["float16", "float32", "float64"] MIXED_INT_DTYPES = [ "uint8", "uint16", "uint32", "uint64", "int8", "int16", "int32", "int64", ] class TestDataFrameToCSV: def read_csv(self, path, **kwargs): params = {"index_col": 0, "parse_dates": True} params.update(**kwargs) return read_csv(path, **params) def test_to_csv_from_csv1(self, float_frame, datetime_frame): with tm.ensure_clean("__tmp_to_csv_from_csv1__") as path: float_frame["A"][:5] = np.nan float_frame.to_csv(path) float_frame.to_csv(path, columns=["A", "B"]) float_frame.to_csv(path, header=False) float_frame.to_csv(path, index=False) # test roundtrip # freq does not roundtrip datetime_frame.index = datetime_frame.index._with_freq(None) datetime_frame.to_csv(path) recons = self.read_csv(path) tm.assert_frame_equal(datetime_frame, recons) datetime_frame.to_csv(path, index_label="index") recons = self.read_csv(path, index_col=None) assert len(recons.columns) == len(datetime_frame.columns) + 1 # no index datetime_frame.to_csv(path, index=False) recons = self.read_csv(path, index_col=None) tm.assert_almost_equal(datetime_frame.values, recons.values) # corner case dm = DataFrame( { "s1": Series(range(3), index=np.arange(3)), "s2": Series(range(2), index=np.arange(2)), } ) dm.to_csv(path) recons = self.read_csv(path) tm.assert_frame_equal(dm, recons) def test_to_csv_from_csv2(self, float_frame): with tm.ensure_clean("__tmp_to_csv_from_csv2__") as path: # duplicate index df = DataFrame( np.random.randn(3, 3), index=["a", "a", "b"], columns=["x", "y", "z"] ) df.to_csv(path) result = self.read_csv(path) tm.assert_frame_equal(result, df) midx = MultiIndex.from_tuples([("A", 1, 2), ("A", 1, 2), ("B", 1, 2)]) df = DataFrame(np.random.randn(3, 3), index=midx, columns=["x", "y", "z"]) df.to_csv(path) result = self.read_csv(path, index_col=[0, 1, 2], parse_dates=False) tm.assert_frame_equal(result, df, check_names=False) # column aliases col_aliases = Index(["AA", "X", "Y", "Z"]) float_frame.to_csv(path, header=col_aliases) rs = self.read_csv(path) xp = float_frame.copy() xp.columns = col_aliases tm.assert_frame_equal(xp, rs) msg = "Writing 4 cols but got 2 aliases" with pytest.raises(ValueError, match=msg): float_frame.to_csv(path, header=["AA", "X"]) def test_to_csv_from_csv3(self): with tm.ensure_clean("__tmp_to_csv_from_csv3__") as path: df1 = DataFrame(np.random.randn(3, 1)) df2 = DataFrame(np.random.randn(3, 1)) df1.to_csv(path) df2.to_csv(path, mode="a", header=False) xp = pd.concat([df1, df2]) rs = read_csv(path, index_col=0) rs.columns = [int(label) for label in rs.columns] xp.columns = [int(label) for label in xp.columns] tm.assert_frame_equal(xp, rs) def test_to_csv_from_csv4(self): with tm.ensure_clean("__tmp_to_csv_from_csv4__") as path: # GH 10833 (TimedeltaIndex formatting) dt = pd.Timedelta(seconds=1) df = DataFrame( {"dt_data": [i * dt for i in range(3)]}, index=Index([i * dt for i in range(3)], name="dt_index"), ) df.to_csv(path) result = read_csv(path, index_col="dt_index") result.index = pd.to_timedelta(result.index) result["dt_data"] = pd.to_timedelta(result["dt_data"]) tm.assert_frame_equal(df, result, check_index_type=True) def test_to_csv_from_csv5(self, timezone_frame): # tz, 8260 with tm.ensure_clean("__tmp_to_csv_from_csv5__") as path: timezone_frame.to_csv(path) result = read_csv(path, index_col=0, parse_dates=["A"]) converter = ( lambda c:
to_datetime(result[c])
pandas.to_datetime
# -*- coding: utf-8 -*- """ Created on Sun Apr 10 14:16:55 2022 @author: <NAME> """ import time import pandas as pd import colorcet as cc import numpy as np import datetime as dt from bokeh.io import show, curdoc from bokeh.plotting import figure from bokeh.themes import built_in_themes from bokeh.layouts import layout, column, gridplot, row from bokeh.models import CustomJS, ColumnDataSource, CDSView, DateRangeSlider, Select, BoxSelectTool, HoverTool, \ CrosshairTool, VArea, Patch, Patches, BoxZoomTool, Div, HArea, IndexFilter, ColorBar, Span, Label, RadioButtonGroup from bokeh.transform import linear_cmap, LinearColorMapper from bokeh.palettes import Spectral6, GnBu, mpl, brewer, all_palettes, Viridis256, Cividis256, Turbo256, Viridis, Cividis, cividis, viridis, inferno, linear_palette # -----clean and format the data raw_data = pd.read_csv("US_Energy.csv", delimiter=",", na_values=('--')) cleaned_data = raw_data.drop([13, 15, 17, 19], axis=0) cleaned_data = cleaned_data.drop(['remove', 'units', 'source key', 'category'], axis=1) cleaned_data = cleaned_data.transpose() new_header = cleaned_data.iloc[0] # grab the first row for the header cleaned_data = cleaned_data[1:] # take the data less the header row cleaned_data.columns = new_header for (columnName, columnData) in cleaned_data.iteritems(): cleaned_data["Change in " + columnName] =
pd.to_numeric(cleaned_data[columnName])
pandas.to_numeric
from json import load from matplotlib.pyplot import title from database.database import DbClient from discord import Embed import pandas as pd from util.data import load_data class Analytics: def __init__(self, server_id: str, db): self.server_id = server_id self.db = db @staticmethod def no_data_embed(topic: str) -> Embed: """CREATE AN EMBED IF NO DATA WAS COLLECTED""" embed = Embed(title="SORRY", description=f"Sorry, but there were no `{topic}` data collected on this server!") return embed async def analyze_message(self): """ANALYZE THE MESSAGE DATA""" data = await load_data(self.db, self.server_id) data = data["message"] if len(data) == 0: return self.no_data_embed("message") # ANALYZE THE DATA: df = pd.DataFrame(data) channelid_counts = pd.value_counts(df["channelid"]) role_counts = pd.value_counts(df["roles"]) df["timestamp"] = pd.to_datetime(df["timestamp"]) df["hours"] = df["timestamp"].dt.hour df["weekday"] = df["timestamp"].dt.day_name() hours_count = pd.value_counts(df["hours"]) weekday_count = pd.value_counts(df["weekday"]) embed_title = "Message ~ Analytics" embeds = [ Embed(title=embed_title, description="Here you can see the analyzed message data"), Embed(title=embed_title, description="Message counted in channels:\n"f"```{channelid_counts}```"), Embed(title=embed_title, description="Message send from roles:\n"f"```{role_counts}```"), Embed(title=embed_title, description="Message counted in which hours:\n"f"```{hours_count}```"), Embed(title=embed_title, description="Message counted on which weekday:\n"f"```{weekday_count}```") ] return embeds async def analyze_message_delete(self): """ANALYZE MESSAGE DELETE""" data = await load_data(self.db, self.server_id) data = data["message_delete"] if len(data) == 0: return self.no_data_embed("message delete") # ANALYZE THE DATA df = pd.DataFrame(data) role_counts = pd.value_counts(df["roles"]) channelid_counts = pd.value_counts(df["channelid"]) df["timestamp"] = pd.to_datetime(df["timestamp"]) df["hours"] = df["timestamp"].dt.hour df["weekday"] = df["timestamp"].dt.day_name() hours_count = pd.value_counts(df["hours"]) weekday_count = pd.value_counts(df["weekday"]) embed_title = "Message delete ~ Analytics" embeds = [ Embed(title=embed_title, description="Here you can see the analyzed message edit data"), Embed(title=embed_title, description="Message delete counted in channels:\n"f"```{channelid_counts}```"), Embed(title=embed_title, description="Message delete from roles:\n"f"```{role_counts}```"), Embed(title=embed_title, description="Message delete counted in which hours:\n"f"```{hours_count}```"), Embed(title=embed_title, description="Message delete counted on which weekday:\n"f"```{weekday_count}```") ] return embeds async def analyze_message_edit(self): """ANALYZE MESSAGE EDIT""" data = await load_data(self.db, self.server_id) data = data["message_edit"] if len(data) == 0: return self.no_data_embed("message edit") # ANALYZE THE DATA df = pd.DataFrame(data) role_counts = pd.value_counts(df["roles"]) channelid_counts = pd.value_counts(df["channelid"]) df["timestamp"] = pd.to_datetime(df["timestamp"]) df["hours"] = df["timestamp"].dt.hour df["weekday"] = df["timestamp"].dt.day_name() hours_count = pd.value_counts(df["hours"]) weekday_count = pd.value_counts(df["weekday"]) embed_title = "Message edit ~ Analytics" embeds = [ Embed(title=embed_title, description="Here you can see the analyzed message edit data"), Embed(title=embed_title, description="Message edits counted in channels:\n"f"```{channelid_counts}```"), Embed(title=embed_title, description="Message edits from roles:\n"f"```{role_counts}```"), Embed(title=embed_title, description="Message edits counted in which hours:\n"f"```{hours_count}```"), Embed(title=embed_title, description="Message edits counted on which weekday:\n"f"```{weekday_count}```") ] return embeds async def analyze_reaction(self): """ANALYZE THE REACTION DATA""" data = await load_data(self.db, self.server_id) data = data["reaction"] if len(data) == 0: return self.no_data_embed("reaction") # ANALYZE THE DATA: df = pd.DataFrame(data) name_count = pd.value_counts(df["reactionname"]) role_counts = pd.value_counts(df["roles"]) channelid_counts = pd.value_counts(df["channelid"]) df["timestamp"] = pd.to_datetime(df["timestamp"]) df["hours"] = df["timestamp"].dt.hour df["weekday"] = df["timestamp"].dt.day_name() hours_count =
pd.value_counts(df["hours"])
pandas.value_counts
# Copyright 1999-2021 Alibaba Group Holding Ltd. # # 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. import itertools import operator import re from copy import copy as copy_obj from numbers import Integral from typing import Type, Sequence import numpy as np import pandas as pd from pandas._libs import lib from pandas.api.indexers import check_array_indexer from pandas.api.types import ( pandas_dtype, is_scalar, is_array_like, is_string_dtype, is_list_like, ) from pandas.api.extensions import ( ExtensionArray, ExtensionDtype, register_extension_dtype, ) from pandas.arrays import StringArray as StringArrayBase from pandas.core import ops from pandas.core.algorithms import take from pandas.compat import set_function_name try: from pandas._libs.arrays import NDArrayBacked except ImportError: NDArrayBacked = None try: import pyarrow as pa pa_null = pa.NULL except ImportError: # pragma: no cover pa = None pa_null = None from ..config import options from ..core import is_kernel_mode from ..lib.version import parse as parse_version from ..utils import tokenize _use_bool_any_all = parse_version(pd.__version__) >= parse_version("1.3.0") class ArrowDtype(ExtensionDtype): @property def arrow_type(self): # pragma: no cover raise NotImplementedError def __from_arrow__(self, array): return self.construct_array_type()(array) @register_extension_dtype class ArrowStringDtype(ArrowDtype): """ Extension dtype for arrow string data. .. warning:: ArrowStringDtype is considered experimental. The implementation and parts of the API may change without warning. In particular, ArrowStringDtype.na_value may change to no longer be ``numpy.nan``. Attributes ---------- None Methods ------- None Examples -------- >>> import mars.dataframe as md >>> md.ArrowStringDtype() ArrowStringDtype """ type = str kind = "U" name = "Arrow[string]" na_value = pa_null @classmethod def construct_from_string(cls, string): if string == cls.name: return cls() else: raise TypeError(f"Cannot construct a '{cls}' from '{string}'") @classmethod def construct_array_type(cls) -> "Type[ArrowStringArray]": return ArrowStringArray @property def arrow_type(self): return pa.string() @register_extension_dtype class ArrowStringDtypeAlias(ArrowStringDtype): name = "arrow_string" # register an alias name for compatibility class ArrowListDtypeType(type): """ the type of ArrowListDtype, this metaclass determines subclass ability """ pass class ArrowListDtype(ArrowDtype): _metadata = ("_value_type",) def __init__(self, dtype): if isinstance(dtype, type(self)): dtype = dtype.value_type if pa and isinstance(dtype, pa.DataType): dtype = dtype.to_pandas_dtype() dtype = pandas_dtype(dtype) if is_string_dtype(dtype) and not isinstance(dtype, ArrowStringDtype): # convert string dtype to arrow string dtype dtype = ArrowStringDtype() self._value_type = dtype @property def value_type(self): return self._value_type @property def kind(self): return "O" @property def type(self): return ArrowListDtypeType @property def name(self): return f"Arrow[List[{self.value_type.name}]]" @property def arrow_type(self): if isinstance(self._value_type, ArrowDtype): arrow_subdtype = self._value_type.arrow_type else: arrow_subdtype = pa.from_numpy_dtype(self._value_type) return pa.list_(arrow_subdtype) def __repr__(self) -> str: return self.name @classmethod def construct_array_type(cls) -> "Type[ArrowListArray]": return ArrowListArray @classmethod def construct_from_string(cls, string): msg = f"Cannot construct a 'ArrowListDtype' from '{string}'" xpr = re.compile(r"Arrow\[List\[(?P<value_type>[^,]*)\]\]$") m = xpr.match(string) if m: value_type = m.groupdict()["value_type"] return ArrowListDtype(value_type) else: raise TypeError(msg) @classmethod def is_dtype(cls, dtype) -> bool: dtype = getattr(dtype, "dtype", dtype) if isinstance(dtype, str): try: cls.construct_from_string(dtype) except TypeError: return False else: return True else: return isinstance(dtype, cls) def __hash__(self): return super().__hash__() def __eq__(self, other): if not isinstance(other, ArrowListDtype): return False value_type = self._value_type other_value_type = other._value_type try: return value_type == other_value_type except TypeError: # cannot compare numpy dtype and extension dtype return other_value_type == value_type class ArrowArray(ExtensionArray): _arrow_type = None def __init__(self, values, dtype: ArrowDtype = None, copy=False): pandas_only = self._pandas_only() if pa is not None and not pandas_only: self._init_by_arrow(values, dtype=dtype, copy=copy) elif not is_kernel_mode(): # not in kernel mode, allow to use numpy handle data # just for infer dtypes purpose self._init_by_numpy(values, dtype=dtype, copy=copy) else: raise ImportError( "Cannot create ArrowArray " "when `pyarrow` not installed" ) # for test purpose self._force_use_pandas = pandas_only def _init_by_arrow(self, values, dtype: ArrowDtype = None, copy=False): if isinstance(values, (pd.Index, pd.Series)): # for pandas Index and Series, # convert to PandasArray values = values.array if isinstance(values, type(self)): arrow_array = values._arrow_array elif isinstance(values, ExtensionArray): # if come from pandas object like index, # convert to pandas StringArray first, # validation will be done in construct arrow_array = pa.chunked_array([pa.array(values, from_pandas=True)]) elif isinstance(values, pa.ChunkedArray): arrow_array = values elif isinstance(values, pa.Array): arrow_array = pa.chunked_array([values]) else: arrow_array = pa.chunked_array([pa.array(values, type=dtype.arrow_type)]) if copy: arrow_array = copy_obj(arrow_array) self._use_arrow = True self._arrow_array = arrow_array if NDArrayBacked is not None and isinstance(self, NDArrayBacked): NDArrayBacked.__init__(self, np.array([]), dtype) else: self._dtype = dtype def _init_by_numpy(self, values, dtype: ArrowDtype = None, copy=False): self._use_arrow = False ndarray = np.array(values, copy=copy) if NDArrayBacked is not None and isinstance(self, NDArrayBacked): NDArrayBacked.__init__(self, ndarray, dtype) else: self._dtype = dtype self._ndarray = np.array(values, copy=copy) @classmethod def _pandas_only(cls): return options.dataframe.arrow_array.pandas_only def __repr__(self): return f"{type(self).__name__}({repr(self._array)})" @property def _array(self): return self._arrow_array if self._use_arrow else self._ndarray @property def dtype(self) -> "Type[ArrowDtype]": return self._dtype @property def nbytes(self) -> int: if self._use_arrow: return sum( x.size for chunk in self._arrow_array.chunks for x in chunk.buffers() if x is not None ) else: return self._ndarray.nbytes @property def shape(self): if self._use_arrow: return (self._arrow_array.length(),) else: return self._ndarray.shape def memory_usage(self, deep=True) -> int: if self._use_arrow: return self.nbytes else: return
pd.Series(self._ndarray)
pandas.Series
# coding=utf-8 # pylint: disable-msg=E1101,W0612 from datetime import datetime, timedelta from numpy import nan import numpy as np import pandas as pd from pandas.types.common import is_integer, is_scalar from pandas import Index, Series, DataFrame, isnull, date_range from pandas.core.index import MultiIndex from pandas.core.indexing import IndexingError from pandas.tseries.index import Timestamp from pandas.tseries.offsets import BDay from pandas.tseries.tdi import Timedelta from pandas.compat import lrange, range from pandas import compat from pandas.util.testing import assert_series_equal, assert_almost_equal import pandas.util.testing as tm from pandas.tests.series.common import TestData JOIN_TYPES = ['inner', 'outer', 'left', 'right'] class TestSeriesIndexing(TestData, tm.TestCase): _multiprocess_can_split_ = True def test_get(self): # GH 6383 s = Series(np.array([43, 48, 60, 48, 50, 51, 50, 45, 57, 48, 56, 45, 51, 39, 55, 43, 54, 52, 51, 54])) result = s.get(25, 0) expected = 0 self.assertEqual(result, expected) s = Series(np.array([43, 48, 60, 48, 50, 51, 50, 45, 57, 48, 56, 45, 51, 39, 55, 43, 54, 52, 51, 54]), index=pd.Float64Index( [25.0, 36.0, 49.0, 64.0, 81.0, 100.0, 121.0, 144.0, 169.0, 196.0, 1225.0, 1296.0, 1369.0, 1444.0, 1521.0, 1600.0, 1681.0, 1764.0, 1849.0, 1936.0], dtype='object')) result = s.get(25, 0) expected = 43 self.assertEqual(result, expected) # GH 7407 # with a boolean accessor df = pd.DataFrame({'i': [0] * 3, 'b': [False] * 3}) vc = df.i.value_counts() result = vc.get(99, default='Missing') self.assertEqual(result, 'Missing') vc = df.b.value_counts() result = vc.get(False, default='Missing') self.assertEqual(result, 3) result = vc.get(True, default='Missing') self.assertEqual(result, 'Missing') def test_delitem(self): # GH 5542 # should delete the item inplace s = Series(lrange(5)) del s[0] expected = Series(lrange(1, 5), index=lrange(1, 5)) assert_series_equal(s, expected) del s[1] expected = Series(lrange(2, 5), index=lrange(2, 5)) assert_series_equal(s, expected) # empty s = Series() def f(): del s[0] self.assertRaises(KeyError, f) # only 1 left, del, add, del s = Series(1) del s[0] assert_series_equal(s, Series(dtype='int64', index=Index( [], dtype='int64'))) s[0] = 1 assert_series_equal(s, Series(1)) del s[0] assert_series_equal(s, Series(dtype='int64', index=Index( [], dtype='int64'))) # Index(dtype=object) s = Series(1, index=['a']) del s['a'] assert_series_equal(s, Series(dtype='int64', index=Index( [], dtype='object'))) s['a'] = 1 assert_series_equal(s, Series(1, index=['a'])) del s['a'] assert_series_equal(s, Series(dtype='int64', index=Index( [], dtype='object'))) def test_getitem_setitem_ellipsis(self): s = Series(np.random.randn(10)) np.fix(s) result = s[...] assert_series_equal(result, s) s[...] = 5 self.assertTrue((result == 5).all()) def test_getitem_negative_out_of_bounds(self): s = Series(tm.rands_array(5, 10), index=tm.rands_array(10, 10)) self.assertRaises(IndexError, s.__getitem__, -11) self.assertRaises(IndexError, s.__setitem__, -11, 'foo') def test_pop(self): # GH 6600 df = DataFrame({'A': 0, 'B': np.arange(5, dtype='int64'), 'C': 0, }) k = df.iloc[4] result = k.pop('B') self.assertEqual(result, 4) expected = Series([0, 0], index=['A', 'C'], name=4) assert_series_equal(k, expected) def test_getitem_get(self): idx1 = self.series.index[5] idx2 = self.objSeries.index[5] self.assertEqual(self.series[idx1], self.series.get(idx1)) self.assertEqual(self.objSeries[idx2], self.objSeries.get(idx2)) self.assertEqual(self.series[idx1], self.series[5]) self.assertEqual(self.objSeries[idx2], self.objSeries[5]) self.assertEqual( self.series.get(-1), self.series.get(self.series.index[-1])) self.assertEqual(self.series[5], self.series.get(self.series.index[5])) # missing d = self.ts.index[0] - BDay() self.assertRaises(KeyError, self.ts.__getitem__, d) # None # GH 5652 for s in [Series(), Series(index=list('abc'))]: result = s.get(None) self.assertIsNone(result) def test_iget(self): s = Series(np.random.randn(10), index=lrange(0, 20, 2)) # 10711, deprecated with tm.assert_produces_warning(FutureWarning): s.iget(1) # 10711, deprecated with tm.assert_produces_warning(FutureWarning): s.irow(1) # 10711, deprecated with tm.assert_produces_warning(FutureWarning): s.iget_value(1) for i in range(len(s)): result = s.iloc[i] exp = s[s.index[i]] assert_almost_equal(result, exp) # pass a slice result = s.iloc[slice(1, 3)] expected = s.ix[2:4] assert_series_equal(result, expected) # test slice is a view result[:] = 0 self.assertTrue((s[1:3] == 0).all()) # list of integers result = s.iloc[[0, 2, 3, 4, 5]] expected = s.reindex(s.index[[0, 2, 3, 4, 5]]) assert_series_equal(result, expected) def test_iget_nonunique(self): s = Series([0, 1, 2], index=[0, 1, 0]) self.assertEqual(s.iloc[2], 2) def test_getitem_regression(self): s = Series(lrange(5), index=lrange(5)) result = s[lrange(5)] assert_series_equal(result, s) def test_getitem_setitem_slice_bug(self): s = Series(lrange(10), lrange(10)) result = s[-12:] assert_series_equal(result, s) result = s[-7:] assert_series_equal(result, s[3:]) result = s[:-12] assert_series_equal(result, s[:0]) s = Series(lrange(10), lrange(10)) s[-12:] = 0 self.assertTrue((s == 0).all()) s[:-12] = 5 self.assertTrue((s == 0).all()) def test_getitem_int64(self): idx = np.int64(5) self.assertEqual(self.ts[idx], self.ts[5]) def test_getitem_fancy(self): slice1 = self.series[[1, 2, 3]] slice2 = self.objSeries[[1, 2, 3]] self.assertEqual(self.series.index[2], slice1.index[1]) self.assertEqual(self.objSeries.index[2], slice2.index[1]) self.assertEqual(self.series[2], slice1[1]) self.assertEqual(self.objSeries[2], slice2[1]) def test_getitem_boolean(self): s = self.series mask = s > s.median() # passing list is OK result = s[list(mask)] expected = s[mask] assert_series_equal(result, expected) self.assert_index_equal(result.index, s.index[mask]) def test_getitem_boolean_empty(self): s = Series([], dtype=np.int64) s.index.name = 'index_name' s = s[s.isnull()] self.assertEqual(s.index.name, 'index_name') self.assertEqual(s.dtype, np.int64) # GH5877 # indexing with empty series s = Series(['A', 'B']) expected = Series(np.nan, index=['C'], dtype=object) result = s[Series(['C'], dtype=object)] assert_series_equal(result, expected) s = Series(['A', 'B']) expected = Series(dtype=object, index=Index([], dtype='int64')) result = s[Series([], dtype=object)] assert_series_equal(result, expected) # invalid because of the boolean indexer # that's empty or not-aligned def f(): s[Series([], dtype=bool)] self.assertRaises(IndexingError, f) def f(): s[Series([True], dtype=bool)] self.assertRaises(IndexingError, f) def test_getitem_generator(self): gen = (x > 0 for x in self.series) result = self.series[gen] result2 = self.series[iter(self.series > 0)] expected = self.series[self.series > 0] assert_series_equal(result, expected) assert_series_equal(result2, expected) def test_type_promotion(self): # GH12599 s = pd.Series() s["a"] = pd.Timestamp("2016-01-01") s["b"] = 3.0 s["c"] = "foo" expected = Series([pd.Timestamp("2016-01-01"), 3.0, "foo"], index=["a", "b", "c"]) assert_series_equal(s, expected) def test_getitem_boolean_object(self): # using column from DataFrame s = self.series mask = s > s.median() omask = mask.astype(object) # getitem result = s[omask] expected = s[mask] assert_series_equal(result, expected) # setitem s2 = s.copy() cop = s.copy() cop[omask] = 5 s2[mask] = 5 assert_series_equal(cop, s2) # nans raise exception omask[5:10] = np.nan self.assertRaises(Exception, s.__getitem__, omask) self.assertRaises(Exception, s.__setitem__, omask, 5) def test_getitem_setitem_boolean_corner(self): ts = self.ts mask_shifted = ts.shift(1, freq=BDay()) > ts.median() # these used to raise...?? self.assertRaises(Exception, ts.__getitem__, mask_shifted) self.assertRaises(Exception, ts.__setitem__, mask_shifted, 1) # ts[mask_shifted] # ts[mask_shifted] = 1 self.assertRaises(Exception, ts.ix.__getitem__, mask_shifted) self.assertRaises(Exception, ts.ix.__setitem__, mask_shifted, 1) # ts.ix[mask_shifted] # ts.ix[mask_shifted] = 2 def test_getitem_setitem_slice_integers(self): s = Series(np.random.randn(8), index=[2, 4, 6, 8, 10, 12, 14, 16]) result = s[:4] expected = s.reindex([2, 4, 6, 8]) assert_series_equal(result, expected) s[:4] = 0 self.assertTrue((s[:4] == 0).all()) self.assertTrue(not (s[4:] == 0).any()) def test_getitem_out_of_bounds(self): # don't segfault, GH #495 self.assertRaises(IndexError, self.ts.__getitem__, len(self.ts)) # GH #917 s = Series([]) self.assertRaises(IndexError, s.__getitem__, -1) def test_getitem_setitem_integers(self): # caused bug without test s = Series([1, 2, 3], ['a', 'b', 'c']) self.assertEqual(s.ix[0], s['a']) s.ix[0] = 5 self.assertAlmostEqual(s['a'], 5) def test_getitem_box_float64(self): value = self.ts[5] tm.assertIsInstance(value, np.float64) def test_getitem_ambiguous_keyerror(self): s = Series(lrange(10), index=lrange(0, 20, 2)) self.assertRaises(KeyError, s.__getitem__, 1) self.assertRaises(KeyError, s.ix.__getitem__, 1) def test_getitem_unordered_dup(self): obj = Series(lrange(5), index=['c', 'a', 'a', 'b', 'b']) self.assertTrue(is_scalar(obj['c'])) self.assertEqual(obj['c'], 0) def test_getitem_dups_with_missing(self): # breaks reindex, so need to use .ix internally # GH 4246 s = Series([1, 2, 3, 4], ['foo', 'bar', 'foo', 'bah']) expected = s.ix[['foo', 'bar', 'bah', 'bam']] result = s[['foo', 'bar', 'bah', 'bam']] assert_series_equal(result, expected) def test_getitem_dups(self): s = Series(range(5), index=['A', 'A', 'B', 'C', 'C'], dtype=np.int64) expected = Series([3, 4], index=['C', 'C'], dtype=np.int64) result = s['C'] assert_series_equal(result, expected) def test_getitem_dataframe(self): rng = list(range(10)) s = pd.Series(10, index=rng) df = pd.DataFrame(rng, index=rng) self.assertRaises(TypeError, s.__getitem__, df > 5) def test_getitem_callable(self): # GH 12533 s = pd.Series(4, index=list('ABCD')) result = s[lambda x: 'A'] self.assertEqual(result, s.loc['A']) result = s[lambda x: ['A', 'B']] tm.assert_series_equal(result, s.loc[['A', 'B']]) result = s[lambda x: [True, False, True, True]] tm.assert_series_equal(result, s.iloc[[0, 2, 3]]) def test_setitem_ambiguous_keyerror(self): s = Series(lrange(10), index=lrange(0, 20, 2)) # equivalent of an append s2 = s.copy() s2[1] = 5 expected = s.append(Series([5], index=[1])) assert_series_equal(s2, expected) s2 = s.copy() s2.ix[1] = 5 expected = s.append(Series([5], index=[1])) assert_series_equal(s2, expected) def test_setitem_float_labels(self): # note labels are floats s = Series(['a', 'b', 'c'], index=[0, 0.5, 1]) tmp = s.copy() s.ix[1] = 'zoo' tmp.iloc[2] = 'zoo' assert_series_equal(s, tmp) def test_setitem_callable(self): # GH 12533 s = pd.Series([1, 2, 3, 4], index=list('ABCD')) s[lambda x: 'A'] = -1 tm.assert_series_equal(s, pd.Series([-1, 2, 3, 4], index=list('ABCD'))) def test_setitem_other_callable(self): # GH 13299 inc = lambda x: x + 1 s = pd.Series([1, 2, -1, 4]) s[s < 0] = inc expected = pd.Series([1, 2, inc, 4]) tm.assert_series_equal(s, expected) def test_slice(self): numSlice = self.series[10:20] numSliceEnd = self.series[-10:] objSlice = self.objSeries[10:20] self.assertNotIn(self.series.index[9], numSlice.index) self.assertNotIn(self.objSeries.index[9], objSlice.index) self.assertEqual(len(numSlice), len(numSlice.index)) self.assertEqual(self.series[numSlice.index[0]], numSlice[numSlice.index[0]]) self.assertEqual(numSlice.index[1], self.series.index[11]) self.assertTrue(tm.equalContents(numSliceEnd, np.array(self.series)[ -10:])) # test return view sl = self.series[10:20] sl[:] = 0 self.assertTrue((self.series[10:20] == 0).all()) def test_slice_can_reorder_not_uniquely_indexed(self): s = Series(1, index=['a', 'a', 'b', 'b', 'c']) s[::-1] # it works! def test_slice_float_get_set(self): self.assertRaises(TypeError, lambda: self.ts[4.0:10.0]) def f(): self.ts[4.0:10.0] = 0 self.assertRaises(TypeError, f) self.assertRaises(TypeError, self.ts.__getitem__, slice(4.5, 10.0)) self.assertRaises(TypeError, self.ts.__setitem__, slice(4.5, 10.0), 0) def test_slice_floats2(self): s = Series(np.random.rand(10), index=np.arange(10, 20, dtype=float)) self.assertEqual(len(s.ix[12.0:]), 8) self.assertEqual(len(s.ix[12.5:]), 7) i = np.arange(10, 20, dtype=float) i[2] = 12.2 s.index = i self.assertEqual(len(s.ix[12.0:]), 8) self.assertEqual(len(s.ix[12.5:]), 7) def test_slice_float64(self): values = np.arange(10., 50., 2) index = Index(values) start, end = values[[5, 15]] s = Series(np.random.randn(20), index=index) result = s[start:end] expected = s.iloc[5:16] assert_series_equal(result, expected) result = s.loc[start:end]
assert_series_equal(result, expected)
pandas.util.testing.assert_series_equal
# %% import lightgbm as lgb import pandas as pd import numpy as np import time from sklearn.metrics import accuracy_score # %% print('Loading all data...') start = time.time() all_train_data = pd.read_csv( 'data/train_preliminary/clicklog_ad_user_train_eval_test.csv') df_test = pd.read_csv('data/test/clicklog_ad.csv') print('Split data into train and validation...') TRAIN_DATA_PERCENT = 0.9 msk = np.random.rand(len(all_train_data)) < TRAIN_DATA_PERCENT df_train = all_train_data[msk] df_val = all_train_data[~msk] feature_columns = df_train.columns.values.tolist() feature_columns.remove('age') feature_columns.remove('gender') label_age, label_gender = ['age'], ['gender'] X_train = df_train[feature_columns] y_train_gender = df_train[label_gender] # set label 0 and 1 y_train_gender.gender = y_train_gender.gender-1 y_train_age = df_train[label_age] y_train_age.age = y_train_age.age-1 X_val = df_val[feature_columns] y_val_gender = df_val[label_gender] y_val_gender.gender = y_val_gender.gender-1 y_val_age = df_val[label_age] y_val_age.age = y_val_age.age-1 X_test = df_test[feature_columns] print('Loading data uses {:.1f}s'.format(time.time()-start)) categorical_feature = ['industry', 'advertiser_id', 'product_category', 'product_id', 'ad_id', 'creative_id', 'user_id'] # 构建性别数据 lgb_train_gender = lgb.Dataset( X_train, y_train_gender, feature_name=feature_columns, categorical_feature=categorical_feature) lgb_eval_gender = lgb.Dataset( X_val, y_val_gender, reference=lgb_train_gender, feature_name=feature_columns, categorical_feature=categorical_feature) # 构建年龄数据 lgb_train_age = lgb.Dataset( X_train, y_train_age, feature_name=feature_columns, categorical_feature=categorical_feature) lgb_eval_age = lgb.Dataset( X_val, y_val_age, reference=lgb_train_age, feature_name=feature_columns, categorical_feature=categorical_feature) # %% # write to hdf5 to read fast X_train.to_hdf('data/clicklog_ad_user_train_eval_test.h5', key='X_train', mode='w') y_train_gender.to_hdf('data/clicklog_ad_user_train_eval_test.h5', key='y_train_gender', mode='a') y_train_age.to_hdf('data/clicklog_ad_user_train_eval_test.h5', key='y_train_age', mode='a') X_val.to_hdf('data/clicklog_ad_user_train_eval_test.h5', key='X_val', mode='a') y_val_gender.to_hdf('data/clicklog_ad_user_train_eval_test.h5', key='y_val_gender', mode='a') y_val_age.to_hdf('data/clicklog_ad_user_train_eval_test.h5', key='y_val_age', mode='a') X_test.to_hdf('data/clicklog_ad_user_train_eval_test.h5', key='X_test', mode='a') # %% # read from hdf5 X_train = pd.read_hdf( 'data/clicklog_ad_user_train_eval_test.h5', key='X_train', mode='r') y_train_gender = pd.read_hdf('data/clicklog_ad_user_train_eval_test.h5', key='y_train_gender', mode='r') y_train_age = pd.read_hdf('data/clicklog_ad_user_train_eval_test.h5', key='y_train_age', mode='r') X_val = pd.read_hdf( 'data/clicklog_ad_user_train_eval_test.h5', key='X_val', mode='r') y_val_gender = pd.read_hdf('data/clicklog_ad_user_train_eval_test.h5', key='y_val_gender', mode='r') y_val_age = pd.read_hdf( 'data/clicklog_ad_user_train_eval_test.h5', key='y_val_age', mode='r') X_test = pd.read_hdf( 'data/clicklog_ad_user_train_eval_test.h5', key='X_test', mode='r') # %% def LGBM_gender(): params_gender = { 'task': 'train', 'boosting_type': 'gbdt', 'objective': 'binary', 'metric': {'binary_logloss', 'binary_error'}, # evaluate指标 'max_depth': -1, # 不限制树深度 # 更高的accuracy 'max_bin': 2**10-1, 'num_leaves': 2**10, 'min_data_in_leaf': 1, 'learning_rate': 0.01, # 'feature_fraction': 0.9, # 'bagging_fraction': 0.8, # 'bagging_freq': 5, # 'is_provide_training_metric': True, 'verbose': 1 } print('Start training...') # train gbm = lgb.train(params_gender, lgb_train_gender, num_boost_round=10, valid_sets=lgb_eval_gender, # early_stopping_rounds=5, ) print('training done!') print('Saving model...') # save model to file gbm.save_model('tmp/model_gender.txt') print('save model done!') return gbm # %% def LGBM_age(): params_age = { 'boosting_type': 'gbdt', 'objective': 'multiclass', "num_class": 10, # fine-tuning最重要的三个参数 'num_leaves': 2**10-1, 'max_depth': -1, # 不限制树深度 'min_data_in_leaf': 1, # 更高的accuracy # 'max_bin': 2**9-1, 'metric': {'multi_logloss', 'multi_error'}, 'learning_rate': 0.1, # 'feature_fraction': 0.9, # 'bagging_fraction': 0.8, # 'bagging_freq': 5, 'verbose': 1 } print('Start training...') # train gbm = lgb.train(params_age, lgb_train_age, num_boost_round=50, valid_sets=lgb_eval_age, # early_stopping_rounds=5, ) print('Saving model...') # save model to file gbm.save_model('tmp/model_age.txt') print('save model done!') return gbm # %% gbm_gender = LGBM_gender() gbm_age = LGBM_age() # gbm_gender = lgb.Booster(model_file='tmp/model_gender.txt') # gbm_age = lgb.Booster(model_file='tmp/model_age.txt') # %% def evaluate(): print('Start predicting...') y_pred_gender_probability = gbm_gender.predict( X_val, num_iteration=gbm_gender.best_iteration) threshold = 0.5 y_pred_gender = np.where(y_pred_gender_probability > threshold, 1, 0) # eval print('threshold: {:.1f} The accuracy of prediction is:{:.2f}'.format(threshold, accuracy_score(y_val_gender, y_pred_gender))) # %% print('Start evaluate data predicting...') y_pred_age_probability = gbm_age.predict( X_val, num_iteration=gbm_age.best_iteration) y_pred_age = np.argmax(y_pred_age_probability, axis=1) # eval print('The accuracy of prediction is:{:.2f}'.format( accuracy_score(y_val_age, y_pred_age))) d = {'user_id': X_val.user_id.values.tolist(), 'gender': y_pred_gender.tolist(), 'age': y_pred_age.tolist()} ans_df = pd.DataFrame(data=d) # 投票的方式决定gender、age ans_df_grouped = ans_df.groupby(['user_id']).agg( lambda x: x.value_counts().index[0]) ans_df_grouped.gender = ans_df_grouped.gender+1 ans_df_grouped.age = ans_df_grouped.age+1 ans_df_grouped.to_csv('data/ans.csv', header=True) # %% evaluate() # %% def test(): print('Start predicting test gender data ...') y_pred_gender_probability = gbm_gender.predict( X_test, num_iteration=gbm_gender.best_iteration) threshold = 0.5 y_pred_gender = np.where(y_pred_gender_probability > threshold, 1, 0) print('Start predicting test age data ...') y_pred_age_probability = gbm_age.predict( X_test, num_iteration=gbm_age.best_iteration) y_pred_age = np.argmax(y_pred_age_probability, axis=1) print('start voting...') d = {'user_id': X_test.user_id.values.tolist(), 'predicted_age': y_pred_age.tolist(), 'predicted_gender': y_pred_gender.tolist(), } ans_df =
pd.DataFrame(data=d)
pandas.DataFrame
#!/usr/bin/python from __future__ import (absolute_import, division, print_function, unicode_literals) import argparse import requests import time import datetime import pandas as pd from bs4 import BeautifulSoup from dateutil.parser import parse from collections import defaultdict try: from urllib import urlencode, quote, unquote except ImportError: from urllib.parse import urlencode, quote, unquote list_of_commands = ('tv', 'season=<>') help_text = 'commands=%s,[number]' % ','.join(list_of_commands) # additional_channels = ('BBCA', 'WCBS', 'WNBC', 'WNYW', 'WABC', 'FREEFRM') additional_channels = ('BBCA', 'WNYW', 'FREEFRM', 'FXX') veto_channels = ('Fox', 'MyNetwork', 'ABCF', 'HALMRK', 'WGNAMER') proxy_endpoint = '/browse.php?u=' proxy_uri = 'http://openwebproxy.pw' + proxy_endpoint def t_request(endpoint): timeout = 1 while True: try: resp = requests.get(endpoint, timeout=60) resp.raise_for_status() return resp except (requests.exceptions.ConnectionError, requests.exceptions.HTTPError) as exc: print('timeout %s, %s' % (timeout, exc)) if '404 Client Error: Not Found for url:' in exc.message: raise time.sleep(timeout) timeout *= 2 if timeout >= 64: raise def get_available_dates_channels(zip_code=None, tv_prov=None): # zip_code=10026, tv_prov='NY31534' endpoint = 'http://www.imdb.com/tvgrid' if zip_code is not None and tv_prov is not None: endpoint += '?' + urlencode({'zip': zip_code, 'tv_prov': tv_prov}) resp = t_request(endpoint) if resp.status_code != 200: raise Exception('bad status %s' % resp.status_code) soup = BeautifulSoup(resp.text, 'html.parser') available_dates = [] available_channels = [] for s in soup.find_all('select'): if hasattr(s, 'attrs') and 'name' in s.attrs and s.attrs['name'] == 'start_date': available_dates = [o.attrs['value'] for o in s.find_all('option')] available_dates = map(lambda x: parse(x).date(), available_dates) if hasattr(s, 'attrs') and 'name' in s.attrs and s.attrs['name'] == 'channel': available_channels = [ o.attrs['value'].strip('#') for o in s.find_all('option') if '#' in o.attrs['value'] ] return available_dates, available_channels def get_time_program_list(date=datetime.date.today(), channel='AMC'): endpoint = 'http://www.imdb.com/tvgrid/%s/%s' % (str(date), channel) resp = t_request(endpoint) soup = BeautifulSoup(resp.text, 'html.parser') for table in soup.find_all('table'): if 'class' not in table.attrs: for tr_idx, tr in enumerate(table.find_all('tr')): (start_time, start_time_url, title, desc, imdb_title, imdb_url, ep_title, ep_url) = 8 * [''] for td_idx, td in enumerate(tr.find_all('td')): if td_idx == 0: start_time = td.text try: start_time_url = [ int(a.attrs['href'].split('/')[3]) for a in td.find_all('a') ][0] except ValueError: start_time_url = sum( int(x) * 100**i for i, x in enumerate(td.text.split()[0].split(':')[::-1])) else: title = list(td.find_all('b'))[0].text for a in td.find_all('a'): if not imdb_title: imdb_title = a.text imdb_url = a.attrs['href'].split('/')[2] elif not ep_title: ep_title = a.text ep_url = a.attrs['href'].split('/')[2] desc = td.text.replace(title, '').strip() if ep_title: desc = desc.replace(ep_title, '').strip() yield { 'start_int': start_time_url, 'start_str': start_time, 'title': title, 'desc': desc, 'imdb_title': imdb_title, 'imdb_url': imdb_url, 'ep_title': ep_title, 'ep_url': ep_url } def get_time_from_grid(date=datetime.date.today(), start_time='0000', channels=None): last_date = ( datetime.datetime.combine(date, datetime.time()) + datetime.timedelta(days=-1)).date() resp = t_request('http://www.imdb.com/tvgrid/%s/%s' % (str(date), start_time)) soup = BeautifulSoup(resp.text, 'html.parser') shows = {} for div in soup.find_all('div'): if 'tv_channel' in div.attrs.get('class', {}): channel_name = [ a.attrs['name'] for x in div.find_all('div') if 'tv_callsign' in x.attrs.get('class', {}) for a in x.find_all('a') ][0] if channels is not None and channel_name not in channels: continue for li in div.find_all('li'): imdb_title, imdb_url = 2 * [''] id_ = li.attrs['id'].replace('_show', '_info') start_time_ = li.attrs['id'].replace(channel_name, '').replace('_show', '') ampm = start_time_[-2:] hr = int(start_time_[:-2]) // 100 mn = int(start_time_[:-2]) % 100 if start_time == '0000' and ampm == 'PM': start_time_ = parse('%s %02d:%02d %s EST' % (last_date, hr, mn, ampm)) else: start_time_ = parse('%s %02d:%02d %s EST' % (date, hr, mn, ampm)) for d in li.find_all('div'): if 'tv_title' not in d.attrs.get('class', {}): continue imdb_title = d.text.strip() for a in d.find_all('a'): imdb_title = a.attrs['title'].strip() imdb_url = a.attrs['href'] shows[id_] = { 'channel': channel_name, 'start_time': start_time_, 'title': imdb_title, 'imdb_title': imdb_title, 'imdb_url': imdb_url, 'ep_title': '', 'ep_url': '' } elif 'tv_phantom' in div.attrs.get('class', {}): id_ = div.table.attrs.get('id', '') if id_ in shows: for a in div.find_all('a'): url = a.attrs['href'] if shows[id_]['imdb_url'] != url: shows[id_]['ep_url'] = url shows[id_]['ep_title'] = a.text.strip() return shows.values() def parse_imdb_tv_listings(additional_channels=additional_channels): available_dates, available_channels = get_available_dates_channels() available_channels = set(available_channels) available_channels |= set(additional_channels) available_channels -= set(veto_channels) dataframes = [] for channel in available_channels: tmp_dfs = [] for date in available_dates: if date < datetime.date.today(): continue print('channel %s date %s' % (channel, date)) last_date = (datetime.datetime.combine(date, datetime.time()) + datetime.timedelta(days=-1)).date() time_prog_list = list(get_time_program_list(date, channel=channel)) df = pd.DataFrame(time_prog_list) df['start_time'] = df.start_str.apply(lambda x: parse('%s %s EST' % (date, x))) if df.shape[0] > 1: if df.start_int[0] > df.start_int[1]: df.ix[0, 'start_time'] = parse('%s %s EST' % (last_date, df.start_str[0])) df['end_time'] = df.loc[1:, 'start_time'].reset_index(drop=True) else: df['end_time'] = pd.NaT df['channel'] = channel tmp_dfs.append(df) df = pd.concat(tmp_dfs) df = df.sort_values(by=['start_time']).reset_index(drop=True) idx = df[df.end_time.isnull()].index nidx = idx + 1 df.loc[df.index.isin(idx[:-1]), 'end_time'] = df[df.index.isin(nidx)].start_time.values df = df[df.end_time.notnull()] dataframes.append(df) df = pd.concat(dataframes) df = df[[ 'channel', 'start_time', 'end_time', 'title', 'imdb_title', 'imdb_url', 'ep_title', 'ep_url' ]].reset_index(drop=True) return df def get_bad_channels(available_dates, bad_channels): dataframes = [] for date in available_dates: for start_time in ['%04d' % (x * 100) for x in range(0, 24, 3)]: print(date, start_time) time_prog_list = get_time_from_grid( date=date, start_time=start_time, channels=bad_channels) df_ = pd.DataFrame(time_prog_list) dataframes.append(df_) df_ = pd.concat(dataframes) df_ = df_[['channel', 'start_time', 'title', 'imdb_title', 'imdb_url', 'ep_title', 'ep_url']].sort_values(by=['channel', 'start_time']).reset_index(drop=True) dataframes = [] for channel in df_.channel.unique(): tmp_df = df_[df_.channel == channel].reset_index(drop=True) if tmp_df.shape[0] > 1: tmp_df['end_time'] = tmp_df.loc[1:, 'start_time'].reset_index(drop=True) else: tmp_df['start_time'] = pd.NaT dataframes.append(tmp_df) df_ =
pd.concat(dataframes)
pandas.concat
import sys import numpy as np import faiss import math import argparse import pandas as pd class Initializer: def __init__(self, args): self.args = args self.long_long_size = 8 self.long_size = 4 self.int_size = 2 self.output_file_binary_components = args.binary_components self.input_file_items_ids = args.items_ids if self.output_file_binary_components is None: print('One must provide [--binary_components], [--encoded_items] or [--index_file].' + '\r\n' + 'Please use [-h] or [--help] for more information.') sys.exit(1) self.input_file_index = args.index_file self.input_file_encoded_items = args.encoded_items if self.input_file_encoded_items is None and self.input_file_index is None: print('One must provide [--encoded_items] or [--index_file].' + '\r\n' + 'Please use [-h] or [--help] for more information.') sys.exit(1) self.component_type_size = args.component_type_size if self.component_type_size is self.long_long_size: self.data_type = np.ulonglong elif self.component_type_size is self.long_size: self.data_type = np.uint32 elif self.component_type_size is self.int_size: self.data_type = np.uint16 else: self.component_type_size = self.long_long_size self.data_type = np.ulonglong if self.input_file_encoded_items is not None: self.encoded_items_vec = np.load(self.input_file_encoded_items) else: self.encoded_items_vec = None self.input_file_training_set = args.training_set if self.input_file_training_set is None: self.training_set_vec = self.encoded_items_vec else: self.training_set_vec = np.load(self.input_file_training_set) self.number_of_bits = args.number_of_bits if self.input_file_index is None: _, self.dimensions = self.encoded_items_vec.shape if self.number_of_bits is None: self.number_of_bits = self.dimensions * 2 self.lsh_index = self.get_lsh_index() else: self.lsh_index = faiss.read_index(self.input_file_index) self.dimensions = None def get_lsh_index(self): index = faiss.IndexLSH(self.dimensions, self.number_of_bits) index.train(self.training_set_vec) index.add(self.encoded_items_vec) return index class Binarizer: def __init__(self, initializer): self.initializer = initializer def __get_binary_components(self): print('Type size: ' + str(self.initializer.component_type_size) + ' bytes.') bytes_per_vector = self.initializer.lsh_index.bytes_per_vec print('Bytes per vector: ' + str(bytes_per_vector)) print('Number of bits: ' + str(bytes_per_vector * 8)) vectors_bytes = faiss.vector_to_array(self.initializer.lsh_index.codes) n_components = math.ceil(bytes_per_vector / self.initializer.component_type_size) print('Number of binary components per vector: ' + str(n_components)) n = int(len(vectors_bytes) / bytes_per_vector) resulting_components = np.zeros((n, n_components), dtype=self.initializer.data_type) vector_start = 0 vector_stop = bytes_per_vector vector_count = 0 while vector_count < n: binary_vector = np.zeros((n_components,), dtype=self.initializer.data_type) vector_bytes = vectors_bytes[vector_start:vector_stop] component_start = 0 component_stop = self.initializer.component_type_size component_count = 0 while component_count < n_components: numerical_component_bytes = vector_bytes[component_start:component_stop] numerical_component = int.from_bytes(numerical_component_bytes, byteorder='big', signed=False) binary_vector[component_count] = numerical_component component_start = component_stop component_stop = component_stop + self.initializer.component_type_size component_count += 1 resulting_components[vector_count] = binary_vector vector_start = vector_stop vector_stop = vector_stop + bytes_per_vector vector_count += 1 print('Total items: ' + str(len(resulting_components))) return resulting_components def __zip_with_ids(self, components): ids = np.load(self.initializer.input_file_items_ids) id_series = pd.Series(ids, name='item_id') bin_vec_series = pd.Series(components.tolist(), name='binary_vector') frame = {'item_id': id_series, 'binary_vector': bin_vec_series} df =
pd.DataFrame(frame)
pandas.DataFrame
import numpy as np import matplotlib.pyplot as plt import psycopg2 as sql import pandas as pd db = sql.connect( database='IMDb', user='username', password = 'password' ) c = db.cursor() def media_scores(q_tvEpisode, q_short, q_movie, q_video, q_tvMovie, q_tvSeries, whichplot='overall'): c.execute(q_tvEpisode) rows = c.fetchall() tv_Episode_data = pd.DataFrame(rows, columns=['year_produced', 'Average_Score', 'st_dev_score']) c.execute(q_short) rows = c.fetchall() short_data =
pd.DataFrame(rows, columns=['year_produced', 'Average_Score', 'st_dev_score'])
pandas.DataFrame
import numpy as np from numpy.random import seed seed(1) import pandas as pd from math import sqrt from sklearn.decomposition import PCA ###################################################################### # METRICS ###################################################################### def mse(y, y_hat): """ Calculates Mean Squared Error. MSE measures the prediction accuracy of a forecasting method by calculating the squared deviation of the prediction and the true value at a given time and averages these devations over the length of the series. y: numpy array actual test values y_hat: numpy array predicted values return: MSE """ mse = np.mean(np.square(y - y_hat)) return mse def rmse(y, y_hat): """ Calculates Root Mean Squared Error. RMSE measures the prediction accuracy of a forecasting method by calculating the squared deviation of the prediction and the true value at a given time and averages these devations over the length of the series. Finally the RMSE will be in the same scale as the original time series so its comparison with other series is possible only if they share a common scale. y: numpy array actual test values y_hat: numpy array predicted values return: RMSE """ rmse = sqrt(np.mean(np.square(y - y_hat))) return rmse def mape(y, y_hat): """ Calculates Mean Absolute Percentage Error. MAPE measures the relative prediction accuracy of a forecasting method by calculating the percentual deviation of the prediction and the true value at a given time and averages these devations over the length of the series. y: numpy array actual test values y_hat: numpy array predicted values return: MAPE """ mape = np.mean(np.abs(y - y_hat) / np.abs(y)) mape = 100 * mape return mape def smape(y, y_hat): """ Calculates Symmetric Mean Absolute Percentage Error. SMAPE measures the relative prediction accuracy of a forecasting method by calculating the relative deviation of the prediction and the true value scaled by the sum of the absolute values for the prediction and true value at a given time, then averages these devations over the length of the series. This allows the SMAPE to have bounds between 0% and 200% which is desireble compared to normal MAPE that may be undetermined. y: numpy array actual test values y_hat: numpy array predicted values return: SMAPE """ smape = np.mean(np.abs(y - y_hat) / (np.abs(y) + np.abs(y_hat))) smape = 200 * smape return smape def mase(y, y_hat, y_train, seasonality=1): """ Calculates the M4 Mean Absolute Scaled Error. MASE measures the relative prediction accuracy of a forecasting method by comparinng the mean absolute errors of the prediction and the true value against the mean absolute errors of the seasonal naive model. y: numpy array actual test values y_hat: numpy array predicted values y_train: numpy array actual train values for Naive1 predictions seasonality: int main frequency of the time series Hourly 24, Daily 7, Weekly 52, Monthly 12, Quarterly 4, Yearly 1 return: MASE """ scale = np.mean(abs(y_train[seasonality:] - y_train[:-seasonality])) mase = np.mean(abs(y - y_hat)) / scale mase = 100 * mase return mase def rmsse(y, y_hat, y_train, seasonality=1): """ Calculates the M5 Root Mean Squared Scaled Error. Calculates the M4 Mean Absolute Scaled Error. MASE measures the relative prediction accuracy of a forecasting method by comparinng the mean squared errors of the prediction and the true value against the mean squared errors of the seasonal naive model. y: numpy array actual test values y_hat: numpy array of len h (forecasting horizon) predicted values seasonality: int main frequency of the time series Hourly 24, Daily 7, Weekly 52, Monthly 12, Quarterly 4, Yearly 1 return: RMSSE """ scale = np.mean(np.square(y_train[seasonality:] - y_train[:-seasonality])) rmsse = sqrt(mse(y, y_hat) / scale) rmsse = 100 * rmsse return rmsse def pinball_loss(y, y_hat, tau=0.5): """ Calculates the Pinball Loss. The Pinball loss measures the deviation of a quantile forecast. By weighting the absolute deviation in a non symmetric way, the loss pays more attention to under or over estimation. A common value for tau is 0.5 for the deviation from the median. y: numpy array actual test values y_hat: numpy array of len h (forecasting horizon) predicted values tau: float Fixes the quantile against which the predictions are compared. return: pinball_loss """ delta_y = y - y_hat pinball = np.maximum(tau * delta_y, (tau-1) * delta_y) pinball = pinball.mean() return pinball_loss def evaluate_panel(y_test, y_hat, y_train, metric, seasonality): """ Calculates a specific metric for y and y_hat y_test: pandas df df with columns unique_id, ds, y y_hat: pandas df df with columns unique_id, ds, y_hat y_train: pandas df df with columns unique_id, ds, y (train) this is used in the scaled metrics seasonality: int main frequency of the time series Hourly 24, Daily 7, Weekly 52, Monthly 12, Quarterly 4, Yearly 1 return: list of metric evaluations for each unique_id in the panel data """ metric_name = metric.__code__.co_name uids = y_test.index.get_level_values('unique_id').unique() y_hat_uids = y_hat.index.get_level_values('unique_id').unique() assert len(y_test)==len(y_hat), "not same length" assert all(uids == y_hat_uids), "not same u_ids" idxs, evaluations = [], [] for uid in uids: y_test_uid = y_test.loc[uid].values y_hat_uid = y_hat.loc[uid].values y_train_uid = y_train.loc[uid].y.values if metric_name in ['mase', 'rmsse']: evaluation_uid = metric(y=y_test_uid, y_hat=y_hat_uid, y_train=y_train_uid, seasonality=seasonality) else: evaluation_uid = metric(y=y_test_uid, y_hat=y_hat_uid) idxs.append(uid) evaluations.append(evaluation_uid) idxs = pd.Index(idxs, name='unique_id') evaluations =
pd.Series(evaluations, index=idxs)
pandas.Series
# Copyright (c) Meta Platforms, Inc. and affiliates. # # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. import io import os import pkgutil from datetime import datetime from typing import cast, List from unittest import TestCase import matplotlib.pyplot as plt import numpy as np import pandas as pd import pytest import pytz from dateutil import parser from dateutil.relativedelta import relativedelta from kats.compat.pandas import ( assert_frame_equal, assert_index_equal, assert_series_equal, ) from kats.consts import ( DEFAULT_TIME_NAME, DEFAULT_VALUE_NAME, TimeSeriesData, TSIterator, ) def load_data(file_name: str) -> pd.DataFrame: ROOT = "kats" if "kats" in os.getcwd().lower(): path = "data/" else: path = "kats/data/" data_object = pkgutil.get_data(ROOT, path + file_name) # pyre-fixme[6]: For 1st param expected `bytes` but got `Optional[bytes]`. return pd.read_csv(io.BytesIO(data_object), encoding="utf8") TIME_COL_NAME = "ds" VALUE_COL_NAME = "y" MULTIVAR_VALUE_DF_COLS: List[str] = [VALUE_COL_NAME, VALUE_COL_NAME + "_1"] EMPTY_DF = pd.DataFrame() EMPTY_TIME_SERIES = pd.Series([], name=DEFAULT_TIME_NAME, dtype=float) EMPTY_VALUE_SERIES = pd.Series([], name=DEFAULT_VALUE_NAME, dtype=float) EMPTY_VALUE_SERIES_NO_NAME = pd.Series([], dtype=float) EMPTY_TIME_DATETIME_INDEX = pd.DatetimeIndex(pd.Series([], dtype=object)) EMPTY_DF_WITH_COLS: pd.DataFrame = pd.concat([EMPTY_TIME_SERIES, EMPTY_VALUE_SERIES], axis=1) NUM_YEARS_OFFSET = 12 class TimeSeriesBaseTest(TestCase): def setUp(self) -> None: # load Dataframes for testing self.AIR_DF = load_data("air_passengers.csv") self.AIR_DF_DATETIME = self.AIR_DF.copy(deep=True) self.AIR_DF_DATETIME.ds = self.AIR_DF_DATETIME.ds.apply( lambda x: parser.parse(x) ) self.AIR_DF_UNIXTIME = self.AIR_DF.copy(deep=True) self.AIR_DF_UNIXTIME.ds = self.AIR_DF_DATETIME.ds.apply( lambda x: (x - datetime(1970, 1, 1)).total_seconds() ) self.AIR_DF_WITH_DEFAULT_NAMES = self.AIR_DF.copy(deep=True) self.AIR_DF_WITH_DEFAULT_NAMES.columns = [DEFAULT_TIME_NAME, DEFAULT_VALUE_NAME] self.MULTIVAR_AIR_DF = self.AIR_DF.copy(deep=True) self.MULTIVAR_AIR_DF[VALUE_COL_NAME + "_1"] = self.MULTIVAR_AIR_DF.y * 2 self.MULTIVAR_AIR_DF_DATETIME = self.MULTIVAR_AIR_DF.copy(deep=True) self.MULTIVAR_AIR_DF_DATETIME.ds = self.MULTIVAR_AIR_DF_DATETIME.ds.apply( lambda x: parser.parse(x) ) self.MULTIVAR_VALUE_DF = self.MULTIVAR_AIR_DF[MULTIVAR_VALUE_DF_COLS] self.AIR_TIME_SERIES = self.AIR_DF.ds self.AIR_TIME_SERIES_PD_DATETIME = pd.to_datetime(self.AIR_TIME_SERIES) self.AIR_TIME_SERIES_UNIXTIME = self.AIR_TIME_SERIES_PD_DATETIME.apply( lambda x: (x - datetime(1970, 1, 1)).total_seconds() ) self.AIR_VALUE_SERIES = self.AIR_DF[VALUE_COL_NAME] self.AIR_TIME_DATETIME_INDEX = pd.DatetimeIndex(self.AIR_TIME_SERIES) class TimeSeriesDataInitTest(TimeSeriesBaseTest): def setUp(self) -> None: super(TimeSeriesDataInitTest, self).setUp() # Univariate TimeSeriesData initialized from a pd.DataFrame self.ts_from_df = TimeSeriesData(df=self.AIR_DF, time_col_name=TIME_COL_NAME) # Univariate TimeSeriesData initialized from a pd.DataFrame with time # as a datetime.datetime object self.ts_from_df_datetime = TimeSeriesData( df=self.AIR_DF_DATETIME, time_col_name=TIME_COL_NAME ) # Univariate TimeSeriesData initialized from a pd.DataFrame with time # as unix time self.ts_from_df_with_unix = TimeSeriesData( df=self.AIR_DF_UNIXTIME, use_unix_time=True, unix_time_units="s", time_col_name=TIME_COL_NAME, ) # Multivariate TimeSeriesData initialized from a pd.DataFrame self.ts_from_df_multi = TimeSeriesData( df=self.MULTIVAR_AIR_DF, time_col_name=TIME_COL_NAME ) # Multivariate TimeSeriesData initialized from a pd.DataFrame with time # as a datetime.datetime object self.ts_from_df_multi_datetime = TimeSeriesData( df=self.MULTIVAR_AIR_DF_DATETIME, time_col_name=TIME_COL_NAME ) # Univariate TimeSeriesData initialized from two pd.Series with time # as a string self.ts_from_series_univar_no_datetime = TimeSeriesData( time=self.AIR_TIME_SERIES, value=self.AIR_VALUE_SERIES ) # Univariate TimeSeriesData initialized from two pd.Series with time # as a pd.Timestamp self.ts_from_series_univar_with_datetime = TimeSeriesData( time=self.AIR_TIME_SERIES_PD_DATETIME, value=self.AIR_VALUE_SERIES ) # Univariate TimeSeriesData initialized from two pd.Series with time # as unix time self.ts_from_series_with_unix = TimeSeriesData( time=self.AIR_TIME_SERIES_UNIXTIME, value=self.AIR_VALUE_SERIES, use_unix_time=True, unix_time_units="s", time_col_name=TIME_COL_NAME, ) # Univariate TimeSeriesData initialized with time as a pd.Series and # value as a pd.DataFrame self.ts_from_series_and_df_univar = TimeSeriesData( time=self.AIR_TIME_SERIES, value=self.AIR_VALUE_SERIES.to_frame() ) # Multivariate TimeSeriesData initialized from a pd.Series for time # and DataFrame for value self.ts_from_series_and_df_multivar = TimeSeriesData( time=self.AIR_TIME_SERIES, value=self.MULTIVAR_VALUE_DF ) # Univariate TimeSeriesData initialized with time as a pd.DateTimeIndex # and value as a pd.Series self.ts_from_index_and_series_univar = TimeSeriesData( time=self.AIR_TIME_DATETIME_INDEX, value=self.AIR_VALUE_SERIES, time_col_name=TIME_COL_NAME, ) # Multivariate TimeSeriesData initialized with time as a # pd.DateTimeIndex and value as a pd.DataFrame self.ts_from_index_and_series_multivar = TimeSeriesData( time=self.AIR_TIME_DATETIME_INDEX, value=self.MULTIVAR_VALUE_DF, time_col_name=TIME_COL_NAME, ) # TimeSeriesData initialized from None Objects self.ts_df_none = TimeSeriesData(df=None) self.ts_time_none_and_value_none = TimeSeriesData(time=None, value=None) # TimeSeriesData initialized from Empty Objects self.ts_df_empty = TimeSeriesData(df=EMPTY_DF) self.ts_time_empty_value_empty = TimeSeriesData( time=EMPTY_TIME_SERIES, value=EMPTY_VALUE_SERIES ) self.ts_time_empty_value_empty_no_name = TimeSeriesData( time=EMPTY_TIME_SERIES, value=EMPTY_VALUE_SERIES_NO_NAME ) self.ts_time_empty_value_empty_df = TimeSeriesData( time=EMPTY_TIME_SERIES, value=EMPTY_DF ) self.ts_time_empty_value_empty_df_with_cols = TimeSeriesData( time=EMPTY_TIME_SERIES, value=EMPTY_DF_WITH_COLS ) # univariate data with missing time self.ts_univariate_missing = TimeSeriesData( df=pd.DataFrame( { "time": ["2010-01-01", "2010-01-02", "2010-01-03", "2010-01-05"], "value": [1, 2, 3, 4], } ) ) # multivariate data with missing time self.ts_multi_missing = TimeSeriesData( df=pd.DataFrame( { "time": ["2010-01-01", "2010-01-02", "2010-01-03", "2010-01-05"], "value1": [1, 2, 3, 4], "value2": [4, 3, 2, 1], } ) ) # univariate data with unixtime in US/Pacific with time zone self.unix_list = ( ( pd.date_range( "2020-03-01", "2020-03-10", tz="US/Pacific", freq="1d" ).astype(int) / 1e9 ) .astype(int) .to_list() ) self.ts_univar_PST_tz = TimeSeriesData( df=pd.DataFrame({"time": self.unix_list, "value": [0] * 10}), use_unix_time=True, unix_time_units="s", tz="US/Pacific", ) # univariate data with unixtime in US/Pacific without time zone self.ts_univar_PST = TimeSeriesData( df=pd.DataFrame({"time": self.unix_list, "value": [0] * 10}), use_unix_time=True, unix_time_units="s", ) # univariate data with date str with tz date = ["2020-10-31", "2020-11-01", "2020-11-02"] self.ts_univar_str_date_tz = TimeSeriesData( df=pd.DataFrame({"time": date, "value": [0] * 3}), date_format="%Y-%m-%d", tz="US/Pacific", ) # univariate data with date str without tz self.ts_univar_str_date = TimeSeriesData( df=pd.DataFrame({"time": date, "value": [0] * 3}), date_format="%Y-%m-%d", ) # univariate data in US/Pacific Time Zone with missing data self.ts_univar_PST_missing_tz = TimeSeriesData( df=pd.DataFrame( {"time": (self.unix_list[0:4] + self.unix_list[7:10]), "value": [0] * 7} ), use_unix_time=True, unix_time_units="s", tz="US/Pacific", ) # Testing univariate time series intialized from a DataFrame def test_init_from_df_univar(self) -> None: # DataFrame with string time assert_series_equal(self.ts_from_df.time, self.AIR_TIME_SERIES_PD_DATETIME) assert_series_equal( cast(pd.Series, self.ts_from_df.value), self.AIR_VALUE_SERIES ) # DataFrame with datetime time assert_series_equal( self.ts_from_df_datetime.time, self.AIR_TIME_SERIES_PD_DATETIME ) assert_series_equal( cast(pd.Series, self.ts_from_df_datetime.value), self.AIR_VALUE_SERIES ) # DataFrame with unix time assert_series_equal( self.ts_from_df_with_unix.time, self.AIR_TIME_SERIES_PD_DATETIME ) assert_series_equal( cast(pd.Series, self.ts_from_df_with_unix.value), self.AIR_VALUE_SERIES ) # Testing multivariate time series initialized from a DataFrame def test_init_from_df_multi(self) -> None: assert_series_equal( self.ts_from_df_multi.time, self.AIR_TIME_SERIES_PD_DATETIME ) assert_frame_equal( cast(pd.DataFrame, self.ts_from_df_multi.value), self.MULTIVAR_VALUE_DF ) # Testing univariate time series initialized from a Series and Series/DataFrame def test_init_from_series_univar(self) -> None: # time and value from Series, with time as string assert_series_equal( self.ts_from_series_univar_no_datetime.time, self.AIR_TIME_SERIES_PD_DATETIME, ) # time and value from Series, with time as pd.Timestamp assert_series_equal( self.ts_from_series_univar_with_datetime.time, self.AIR_TIME_SERIES_PD_DATETIME, ) assert_series_equal( cast(pd.Series, self.ts_from_series_univar_no_datetime.value), self.AIR_VALUE_SERIES, ) # time and value from Series, with time out of order and `sort_by_time=True` unsorted_df = self.AIR_DF.sample(frac=1) resorted_ts = TimeSeriesData( time=unsorted_df.ds, value=unsorted_df.y, time_col_name=TIME_COL_NAME, sort_by_time=True, ) self.assertEqual(resorted_ts, self.ts_from_df) # time and value from Series, with time as unix time assert_series_equal( self.ts_from_series_with_unix.time, self.AIR_TIME_SERIES_PD_DATETIME ) assert_series_equal( cast(pd.Series, self.ts_from_series_with_unix.value), self.AIR_VALUE_SERIES ) # time from Series and value from DataFrame assert_series_equal( self.ts_from_series_and_df_univar.time, self.AIR_TIME_SERIES_PD_DATETIME ) print(type(self.ts_from_series_and_df_univar.value)) assert_series_equal( cast(pd.Series, self.ts_from_series_and_df_univar.value), self.AIR_VALUE_SERIES, ) # Testing multivariate time series initialized from a Series/DataFrame def test_init_from_series_multivar(self) -> None: # Testing multivariate time series initialized from a assert_series_equal( self.ts_from_series_and_df_multivar.time, self.AIR_TIME_SERIES_PD_DATETIME ) assert_frame_equal( cast(pd.DataFrame, self.ts_from_series_and_df_multivar.value), self.MULTIVAR_VALUE_DF, ) # Testing univariate time series with time initialized as a # pd.DateTimeIndex def test_init_from_index_univar(self) -> None: assert_series_equal( self.ts_from_index_and_series_univar.time, self.AIR_TIME_SERIES_PD_DATETIME ) assert_series_equal( cast(pd.Series, self.ts_from_index_and_series_univar.value), self.AIR_VALUE_SERIES, ) # Testing multivariate time series with time initialized as a # pd.DateTimeIndex def test_init_from_index_multivar(self) -> None: assert_series_equal( self.ts_from_index_and_series_multivar.time, self.AIR_TIME_SERIES_PD_DATETIME, ) assert_frame_equal( cast(pd.DataFrame, self.ts_from_index_and_series_multivar.value), self.MULTIVAR_VALUE_DF, ) # Testing initialization from None Objects def test_none(self) -> None: # Testing initialization from None DataFrame assert_series_equal(self.ts_df_none.time, EMPTY_TIME_SERIES) assert_series_equal(cast(pd.Series, self.ts_df_none.value), EMPTY_VALUE_SERIES) # Testing initialization from two None Series assert_series_equal(self.ts_time_none_and_value_none.time, EMPTY_TIME_SERIES) assert_series_equal( cast(pd.Series, self.ts_time_none_and_value_none.value), EMPTY_VALUE_SERIES ) # Testing initialization from Empty Objects def test_empty(self) -> None: # Testing intialization from empty DataFrame assert_series_equal(self.ts_df_empty.time, EMPTY_TIME_SERIES) assert_series_equal(cast(pd.Series, self.ts_df_empty.value), EMPTY_VALUE_SERIES) # Testing intialization from two empty Series assert_series_equal(self.ts_time_empty_value_empty.time, EMPTY_TIME_SERIES) assert_series_equal( cast(pd.Series, self.ts_time_empty_value_empty.value), EMPTY_VALUE_SERIES ) # Testing intialization from two empty no name Series assert_series_equal( self.ts_time_empty_value_empty_no_name.time, EMPTY_TIME_SERIES ) assert_series_equal( cast(pd.Series, self.ts_time_empty_value_empty_no_name.value), EMPTY_VALUE_SERIES, ) # Make sure the time and value objects here have the default names self.assertEqual( self.ts_time_empty_value_empty_no_name.time.name, DEFAULT_TIME_NAME ) self.assertEqual( self.ts_time_empty_value_empty_no_name.value.name, DEFAULT_VALUE_NAME ) # Testing initialization from time as empty Series and value as empty # DataFrame assert_series_equal(self.ts_time_empty_value_empty_df.time, EMPTY_TIME_SERIES) assert_series_equal( cast(pd.Series, self.ts_time_empty_value_empty_df.value), EMPTY_VALUE_SERIES ) # Testing initialization from time as empty Series and value as empty # DataFrame assert_series_equal( self.ts_time_empty_value_empty_df_with_cols.time, EMPTY_TIME_SERIES ) assert_series_equal( cast(pd.Series, self.ts_time_empty_value_empty_df_with_cols.value), EMPTY_VALUE_SERIES, ) # Testing incorrect initializations def test_incorrect_init_types(self) -> None: # Incorrect initialization with DF with self.assertRaises(ValueError): # pyre-fixme[6]: Expected `Optional[pd.core.frame.DataFrame]` for 1st # param but got `List[Variable[_T]]`. TimeSeriesData(df=[]) # Incorrect initialization with value with self.assertRaises(ValueError): TimeSeriesData(time=self.AIR_TIME_SERIES, value=None) with self.assertRaises(ValueError): # pyre-fixme[6]: Expected `Union[None, pd.core.frame.DataFrame, # pd.core.series.Series]` for 2nd param but got `List[Variable[_T]]`. TimeSeriesData(time=self.AIR_TIME_SERIES, value=[]) # Incorrect initialization with time with self.assertRaises(ValueError): TimeSeriesData(time=None, value=self.AIR_VALUE_SERIES) with self.assertRaises(ValueError): # pyre-fixme[6]: Expected `Union[None, # pd.core.indexes.datetimes.DatetimeIndex, pd.core.series.Series]` for 1st # param but got `List[Variable[_T]]`. TimeSeriesData(time=[], value=self.AIR_VALUE_SERIES) # Incorrect initialization with time and value with self.assertRaises(ValueError): # pyre-fixme[6]: Expected `Union[None, # pd.core.indexes.datetimes.DatetimeIndex, pd.core.series.Series]` for 1st # param but got `List[Variable[_T]]`. TimeSeriesData(time=[], value=[]) # Incorrect initialization with value dtypes with self.assertRaises(ValueError): TimeSeriesData(time=self.AIR_TIME_SERIES, value=self.AIR_VALUE_SERIES.map(str)) with self.assertRaises(ValueError): TimeSeriesData(time=self.AIR_TIME_SERIES, value=self.MULTIVAR_VALUE_DF.applymap(str)) # Testing incorrect initializations def test_incorrect_init_lengths(self) -> None: # Incorrect initialization with different length time and values with self.assertRaises(ValueError): TimeSeriesData(time=self.AIR_TIME_SERIES, value=self.AIR_VALUE_SERIES[:-1]) with self.assertRaises(ValueError): TimeSeriesData(time=self.AIR_TIME_SERIES[:-1], value=self.AIR_VALUE_SERIES) with self.assertRaises(ValueError): TimeSeriesData(time=self.AIR_TIME_SERIES, value=self.MULTIVAR_VALUE_DF[:-1]) with self.assertRaises(ValueError): TimeSeriesData(time=self.AIR_TIME_SERIES[:-1], value=self.MULTIVAR_VALUE_DF) # Testing DataFrame conversion def test_to_dataframe(self) -> None: # Univariate case assert_frame_equal(self.ts_from_df.to_dataframe(), self.AIR_DF_DATETIME) # Multivariate case assert_frame_equal( self.ts_from_df_multi_datetime.to_dataframe(), self.MULTIVAR_AIR_DF_DATETIME ) # Series Cases assert_frame_equal( self.ts_from_series_univar_no_datetime.to_dataframe(), self.AIR_DF_DATETIME ) assert_frame_equal( self.ts_from_series_univar_with_datetime.to_dataframe(), self.AIR_DF_DATETIME, ) # Series/DataFrame Cases assert_frame_equal( self.ts_from_series_and_df_univar.to_dataframe(), self.AIR_DF_DATETIME ) assert_frame_equal( self.ts_from_series_and_df_multivar.to_dataframe(), self.MULTIVAR_AIR_DF_DATETIME, ) # Empty/None Cases assert_frame_equal(self.ts_df_none.to_dataframe(), EMPTY_DF_WITH_COLS) assert_frame_equal( self.ts_time_none_and_value_none.to_dataframe(), EMPTY_DF_WITH_COLS ) assert_frame_equal(self.ts_df_empty.to_dataframe(), EMPTY_DF_WITH_COLS) assert_frame_equal( self.ts_time_empty_value_empty.to_dataframe(), EMPTY_DF_WITH_COLS ) assert_frame_equal( self.ts_time_empty_value_empty_df.to_dataframe(), EMPTY_DF_WITH_COLS ) # Testing Data Interpolate def test_interpolate(self) -> None: # univariate self.assertEqual( self.ts_univariate_missing.interpolate(freq="D", method="linear"), TimeSeriesData( pd.DataFrame( { "time": [ "2010-01-01", "2010-01-02", "2010-01-03", "2010-01-04", "2010-01-05", ], "value": [1, 2, 3, 3.5, 4], } ) ), ) self.assertEqual( self.ts_univariate_missing.interpolate(freq="D", method="ffill"), TimeSeriesData( pd.DataFrame( { "time": [ "2010-01-01", "2010-01-02", "2010-01-03", "2010-01-04", "2010-01-05", ], "value": [1, 2, 3, 3, 4], } ) ), ) self.assertEqual( self.ts_univariate_missing.interpolate(freq="D", method="bfill"), TimeSeriesData( pd.DataFrame( { "time": [ "2010-01-01", "2010-01-02", "2010-01-03", "2010-01-04", "2010-01-05", ], "value": [1, 2, 3, 4, 4], } ) ), ) # multivariate self.assertEqual( self.ts_multi_missing.interpolate(freq="D", method="linear"), TimeSeriesData( pd.DataFrame( { "time": [ "2010-01-01", "2010-01-02", "2010-01-03", "2010-01-04", "2010-01-05", ], "value1": [1, 2, 3, 3.5, 4], "value2": [4, 3, 2, 1.5, 1], } ) ), ) self.assertEqual( self.ts_multi_missing.interpolate(freq="D", method="ffill"), TimeSeriesData( pd.DataFrame( { "time": [ "2010-01-01", "2010-01-02", "2010-01-03", "2010-01-04", "2010-01-05", ], "value1": [1, 2, 3, 3, 4], "value2": [4, 3, 2, 2, 1], } ) ), ) self.assertEqual( self.ts_multi_missing.interpolate(freq="D", method="bfill"), TimeSeriesData( pd.DataFrame( { "time": [ "2010-01-01", "2010-01-02", "2010-01-03", "2010-01-04", "2010-01-05", ], "value1": [1, 2, 3, 4, 4], "value2": [4, 3, 2, 1, 1], } ) ), ) # test with no frequency given univariate self.assertEqual( self.ts_univariate_missing.interpolate(method="linear"), TimeSeriesData( pd.DataFrame( { "time": [ "2010-01-01", "2010-01-02", "2010-01-03", "2010-01-04", "2010-01-05", ], "value": [1, 2, 3, 3.5, 4], } ) ), ) # no frequency given, for multivariate self.assertEqual( self.ts_multi_missing.interpolate(method="linear"), TimeSeriesData( pd.DataFrame( { "time": [ "2010-01-01", "2010-01-02", "2010-01-03", "2010-01-04", "2010-01-05", ], "value1": [1, 2, 3, 3.5, 4], "value2": [4, 3, 2, 1.5, 1], } ) ), ) def test_to_array(self) -> None: # Univariate case np.testing.assert_array_equal( self.ts_from_df.to_array(), self.AIR_DF_DATETIME.to_numpy() ) # Multivariate case np.testing.assert_array_equal( self.ts_from_df_multi_datetime.to_array(), self.MULTIVAR_AIR_DF_DATETIME.to_numpy(), ) # Series Cases np.testing.assert_array_equal( self.ts_from_series_univar_no_datetime.to_array(), self.AIR_DF_DATETIME.to_numpy(), ) np.testing.assert_array_equal( self.ts_from_series_univar_with_datetime.to_array(), self.AIR_DF_DATETIME.to_numpy(), ) # Series/DataFrame Cases np.testing.assert_array_equal( self.ts_from_series_and_df_univar.to_array(), self.AIR_DF_DATETIME.to_numpy(), ) np.testing.assert_array_equal( self.ts_from_series_and_df_multivar.to_array(), self.MULTIVAR_AIR_DF_DATETIME.to_numpy(), ) # Empty/None Cases np.testing.assert_array_equal(self.ts_df_none.to_array(), np.empty) np.testing.assert_array_equal( self.ts_time_none_and_value_none.to_array(), np.empty ) np.testing.assert_array_equal(self.ts_df_empty.to_array(), np.empty) np.testing.assert_array_equal( self.ts_time_empty_value_empty.to_array(), np.empty ) np.testing.assert_array_equal( self.ts_time_empty_value_empty_df.to_array(), np.empty ) def test_tz(self) -> None: self.ts_univar_PST_tz.validate_data( validate_frequency=True, validate_dimension=True ) self.assertEqual(self.ts_univar_PST_tz.freq_to_timedelta(), pd.Timedelta("1d")) self.assertEqual(self.ts_univar_PST_tz.tz(), pytz.timezone("US/Pacific")) self.assertTrue( ( np.array(self.unix_list) == (self.ts_univar_PST_tz.time.values.astype(int) / 1e9).astype(int) ).all() ) with self.assertRaisesRegex( ValueError, "Only constant frequency is supported for time!" ): self.ts_univar_PST.validate_data( validate_frequency=True, validate_dimension=True ) self.ts_univar_str_date.validate_data( validate_frequency=True, validate_dimension=True ) self.assertEqual( self.ts_univar_str_date.freq_to_timedelta(), pd.Timedelta("1d") ) self.ts_univar_str_date_tz.validate_data( validate_frequency=True, validate_dimension=True ) self.assertEqual( self.ts_univar_str_date_tz.freq_to_timedelta(), pd.Timedelta("1d") ) self.assertEqual(self.ts_univar_PST_tz.tz(), pytz.timezone("US/Pacific")) # test ambiguous tsd = TimeSeriesData( df=pd.DataFrame( { "time": [ "2018-10-28 01:30:00", "2018-10-28 02:00:00", "2018-10-28 02:30:00", "2018-10-28 02:00:00", "2018-10-28 02:30:00", "2018-10-28 03:00:00", "2018-10-28 03:30:00", ], "value": [0] * 7, } ), tz="CET", tz_ambiguous="infer", ) tsd.validate_data(validate_frequency=True, validate_dimension=True) # test nonexistent tsd = TimeSeriesData( df=pd.DataFrame( { "time": [ "2020-03-08 02:00:00", "2020-03-08 02:30:00", "2020-03-08 03:00:00", ], "value": [0] * 3, } ), tz="US/Pacific", tz_nonexistent="shift_forward", ) def test_infer_freq_robust(self) -> None: self.assertEqual( self.ts_univariate_missing.infer_freq_robust(), pd.Timedelta(value=1, unit="D"), ) self.assertEqual( self.ts_univar_PST_missing_tz.infer_freq_robust(), pd.Timedelta(value=1, unit="D"), ) def test_is_data_missing(self) -> None: self.assertEqual(self.ts_univariate_missing.is_data_missing(), True) self.assertEqual(self.ts_univar_PST_missing_tz.is_data_missing(), True) self.assertEqual(self.ts_from_series_and_df_univar.is_data_missing(), False) self.assertEqual(self.ts_from_series_and_df_multivar.is_data_missing(), False) def test_min_max_values(self) -> None: # test min/max value for univariate self.assertEqual(self.ts_from_df.min, np.nanmin(self.ts_from_df.value.values)) self.assertEqual(self.ts_from_df.max, np.nanmax(self.ts_from_df.value.values)) # test min/max value for multivariate self.assertEqual( # pyre-fixme[16]: `float` has no attribute `equals`. self.ts_from_df_multi.min.equals( self.ts_from_df_multi.value.min(skipna=True) ), True, ) self.assertEqual( # pyre-fixme[16]: Item `float` of `Union[float, Series]` has no # attribute `equals`. self.ts_from_df_multi.max.equals( self.ts_from_df_multi.value.max(skipna=True) ), True, ) # test min/max value for empty TS empty_ts = TimeSeriesData(pd.DataFrame()) self.assertEqual(np.isnan(empty_ts.min), True) self.assertEqual(np.isnan(empty_ts.max), True) # test if min/max changes if values are re-assigned for univariate ts_from_df_new = TimeSeriesData(df=self.AIR_DF, time_col_name=TIME_COL_NAME) new_val = np.random.randn(len(self.AIR_DF)) ts_from_df_new.value = pd.Series(new_val) self.assertEqual(ts_from_df_new.min, np.min(new_val)) self.assertEqual(ts_from_df_new.max, np.max(new_val)) # test if min/max changes if values are re-assigned with NaNs for univariate new_val[-1] = np.nan ts_from_df_new.value = pd.Series(new_val) self.assertEqual(ts_from_df_new.min, np.nanmin(new_val)) self.assertEqual(ts_from_df_new.max, np.nanmax(new_val)) # test min/max changes if values are re-assigned for multivariate ts_from_df_multi_new = TimeSeriesData( self.MULTIVAR_AIR_DF, time_col_name=TIME_COL_NAME ) new_val_multi = np.random.randn( self.MULTIVAR_VALUE_DF.shape[0], self.MULTIVAR_VALUE_DF.shape[1] - 1 ) ts_from_df_multi_new.value = pd.DataFrame(new_val_multi) self.assertEqual( # pyre-fixme[16]: Item `float` of `Union[float, Series]` has no # attribute `equals`. ts_from_df_multi_new.min.equals(pd.DataFrame(new_val_multi).min()), True, ) self.assertEqual( # pyre-fixme[16]: Item `float` of `Union[float, Series]` has no # attribute `equals`. ts_from_df_multi_new.max.equals(pd.DataFrame(new_val_multi).max()), True, ) # test min/max changes if values are re-assigned with NaNs for multivariate new_val_multi[0] = np.nan ts_from_df_multi_new.value = pd.DataFrame(new_val_multi) self.assertEqual( # pyre-fixme[16]: Item `float` of `Union[float, Series]` has no # attribute `equals`. ts_from_df_multi_new.min.equals( pd.DataFrame(new_val_multi).min(skipna=True) ), True, ) self.assertEqual( # pyre-fixme[16]: Item `float` of `Union[float, Series]` has no # attribute `equals`. ts_from_df_multi_new.max.equals( pd.DataFrame(new_val_multi).max(skipna=True) ), True, ) class TimeSeriesDataOpsTest(TimeSeriesBaseTest): def setUp(self) -> None: super(TimeSeriesDataOpsTest, self).setUp() # Creating DataFrames # DataFrame with date offset transformed_df_date = self.AIR_DF_DATETIME.copy(deep=True) transformed_df_date.ds = transformed_df_date.ds.apply( lambda x: x + relativedelta(years=NUM_YEARS_OFFSET) ) transformed_df_date_concat = self.AIR_DF.append( transformed_df_date, ignore_index=True ) transformed_df_date_double = self.AIR_DF_DATETIME.copy(deep=True) transformed_df_date_double.ds = transformed_df_date.ds.apply( lambda x: x + relativedelta(years=NUM_YEARS_OFFSET * 2) ) transformed_df_date_concat_double = self.AIR_DF.append( transformed_df_date_double, ignore_index=True ) # DataFrames with value offset transformed_df_value = self.AIR_DF.copy(deep=True) transformed_df_value.y = transformed_df_value.y.apply(lambda x: x * 2) transformed_df_value_inv = self.AIR_DF.copy(deep=True) transformed_df_value_inv.y = transformed_df_value_inv.y.apply(lambda x: x * -1) # DataFrame with date and value offset transformed_df_date_and_value = transformed_df_date.copy(deep=True) transformed_df_date_and_value.y = transformed_df_date_and_value.y.apply( lambda x: x * 2 ) # DataFrame with date offset (multivariate) transformed_df_date_multi = transformed_df_date.copy(deep=True) transformed_df_date_multi[VALUE_COL_NAME + "_1"] = ( transformed_df_date_multi.y * 2 ) transformed_df_date_concat_multi = self.MULTIVAR_AIR_DF.append( transformed_df_date_multi, ignore_index=True ) transformed_df_date_concat_mixed = self.MULTIVAR_AIR_DF_DATETIME.append( transformed_df_date ) transformed_df_date_double_multi = transformed_df_date_double.copy(deep=True) transformed_df_date_double_multi[VALUE_COL_NAME + "_1"] = ( transformed_df_date_double_multi.y * 2 ) transformed_df_date_concat_double_multi = self.MULTIVAR_AIR_DF.append( transformed_df_date_double_multi, ignore_index=True ) transformed_df_date_concat_double_mixed = self.MULTIVAR_AIR_DF_DATETIME.append( transformed_df_date_double ) # DataFrame with value offset (multivariate) transformed_df_value_none_multi = self.MULTIVAR_AIR_DF.copy(deep=True) transformed_df_value_none_multi.y = transformed_df_value_none_multi.y_1 transformed_df_value_none_multi.y_1 = np.nan # DataFrame with date and value offset (multivariate) transformed_df_date_and_value_multi = transformed_df_date_and_value.copy( deep=True ) transformed_df_date_and_value_multi[VALUE_COL_NAME + "_1"] = ( transformed_df_date_and_value_multi.y * 2 ) # DataFrame with all constant values df_zeros = self.AIR_DF.copy(deep=True) df_zeros.y.values[:] = 0 df_ones = self.AIR_DF.copy(deep=True) df_ones.y.values[:] = 1 df_twos = df_ones.copy(deep=True) df_twos.y.values[:] = 2 df_neg_ones = self.AIR_DF.copy(deep=True) df_neg_ones.y.values[:] = -1 df_ones_multi = df_ones.copy(deep=True) df_ones_multi[VALUE_COL_NAME + "_1"] = df_ones_multi.y * 2 # Creating TimeSeriesData objects # Univariate TimeSeriesData initialized from a pd.DataFrame self.ts_univ_1 = TimeSeriesData(df=self.AIR_DF, time_col_name=TIME_COL_NAME) self.ts_univ_2 = TimeSeriesData(df=self.AIR_DF, time_col_name=TIME_COL_NAME) self.ts_univ_default_names = TimeSeriesData(df=self.AIR_DF_WITH_DEFAULT_NAMES) self.ts_univ_default_names_2 = TimeSeriesData(df=self.AIR_DF_WITH_DEFAULT_NAMES) # Multivariate TimeSeriesData initialized from a pd.DataFrame self.ts_multi_1 = TimeSeriesData( df=self.MULTIVAR_AIR_DF, time_col_name=TIME_COL_NAME ) self.ts_multi_2 = TimeSeriesData( df=self.MULTIVAR_AIR_DF, time_col_name=TIME_COL_NAME ) # TimeSeriesData with date offset self.ts_date_transform_univ = TimeSeriesData( df=transformed_df_date, time_col_name=TIME_COL_NAME ) self.ts_date_transform_concat_univ = TimeSeriesData( df=transformed_df_date_concat, time_col_name=TIME_COL_NAME ) self.ts_date_transform_double_univ = TimeSeriesData( df=transformed_df_date_double, time_col_name=TIME_COL_NAME ) self.ts_date_transform_concat_double_univ = TimeSeriesData( df=transformed_df_date_concat_double, time_col_name=TIME_COL_NAME ) # TimeSeriesData with date offset (multivariate) self.ts_date_transform_multi = TimeSeriesData( df=transformed_df_date_multi, time_col_name=TIME_COL_NAME ) self.ts_date_transform_concat_multi = TimeSeriesData( df=transformed_df_date_concat_multi, time_col_name=TIME_COL_NAME ) self.ts_date_transform_concat_mixed = TimeSeriesData( df=transformed_df_date_concat_mixed, time_col_name=TIME_COL_NAME ) self.ts_date_transform_double_multi = TimeSeriesData( df=transformed_df_date_double_multi, time_col_name=TIME_COL_NAME ) self.ts_date_transform_concat_double_multi = TimeSeriesData( df=transformed_df_date_concat_double_multi, time_col_name=TIME_COL_NAME ) self.ts_date_transform_concat_double_mixed = TimeSeriesData( df=transformed_df_date_concat_double_mixed, time_col_name=TIME_COL_NAME ) # TimeSeriesData with value offset self.ts_value_transform_univ = TimeSeriesData( df=transformed_df_value, time_col_name=TIME_COL_NAME ) self.ts_value_transform_inv_univ = TimeSeriesData( df=transformed_df_value_inv, time_col_name=TIME_COL_NAME ) # TimeSeriesData with value offset (multivariate) self.ts_value_transform_none_multi = TimeSeriesData( df=transformed_df_value_none_multi, time_col_name=TIME_COL_NAME ) # TimeSeriesData with date and value offset self.ts_date_and_value_transform_univ = TimeSeriesData( df=transformed_df_date_and_value, time_col_name=TIME_COL_NAME ) # TimeSeriesData with date and value offset (multivariate) self.ts_date_and_value_transform_multi = TimeSeriesData( df=transformed_df_date_and_value_multi, time_col_name=TIME_COL_NAME ) # TimeSeriesData object with all constant values self.ts_zero = TimeSeriesData(df=df_zeros, time_col_name=TIME_COL_NAME) self.ts_ones = TimeSeriesData(df=df_ones, time_col_name=TIME_COL_NAME) self.ts_twos = TimeSeriesData(df=df_twos, time_col_name=TIME_COL_NAME) self.ts_neg_ones = TimeSeriesData(df=df_neg_ones, time_col_name=TIME_COL_NAME) self.ts_ones_multi = TimeSeriesData( df=df_ones_multi, time_col_name=TIME_COL_NAME ) # Empty TimeSeriesData Object self.ts_empty = TimeSeriesData(df=EMPTY_DF) self.ts_empty_with_cols = TimeSeriesData( df=EMPTY_DF_WITH_COLS, time_col_name=TIME_COL_NAME ) # Copies for Extended objects self.ts_univ_extend = TimeSeriesData( df=self.AIR_DF, time_col_name=TIME_COL_NAME ) self.ts_univ_extend_2 = TimeSeriesData( df=self.AIR_DF, time_col_name=TIME_COL_NAME ) self.ts_univ_extend_err = TimeSeriesData( df=self.AIR_DF, time_col_name=TIME_COL_NAME ) self.ts_multi_extend = TimeSeriesData( df=self.MULTIVAR_AIR_DF, time_col_name=TIME_COL_NAME ) self.ts_multi_extend_2 = TimeSeriesData( df=self.MULTIVAR_AIR_DF, time_col_name=TIME_COL_NAME ) self.ts_multi_extend_3 = TimeSeriesData( df=self.MULTIVAR_AIR_DF, time_col_name=TIME_COL_NAME ) self.ts_multi_extend_4 = TimeSeriesData( df=self.MULTIVAR_AIR_DF, time_col_name=TIME_COL_NAME ) self.ts_multi_extend_err = TimeSeriesData( df=self.MULTIVAR_AIR_DF, time_col_name=TIME_COL_NAME ) self.ts_multi_extend_err_2 = TimeSeriesData( df=self.MULTIVAR_AIR_DF, time_col_name=TIME_COL_NAME ) self.ts_empty_extend = TimeSeriesData(df=EMPTY_DF) self.ts_empty_extend_err = TimeSeriesData(df=EMPTY_DF) # Other values self.length = len(self.AIR_DF) def test_eq(self) -> None: # Univariate equality self.assertTrue(self.ts_univ_1 == self.ts_univ_2) # Multivariate equality self.assertTrue(self.ts_multi_1 == self.ts_multi_2) # Univariate inequality self.assertFalse(self.ts_univ_1 == self.ts_date_transform_univ) self.assertFalse(self.ts_univ_1 == self.ts_value_transform_univ) self.assertFalse(self.ts_univ_1 == self.ts_date_and_value_transform_univ) # Multivariate inequality self.assertFalse(self.ts_multi_1 == self.ts_date_transform_multi) self.assertFalse(self.ts_multi_1 == self.ts_value_transform_none_multi) self.assertFalse(self.ts_multi_1 == self.ts_date_and_value_transform_multi) # Univariate vs. Multivariate inequality self.assertFalse(self.ts_univ_1 == self.ts_multi_1) self.assertFalse(self.ts_multi_1 == self.ts_univ_1) def test_ne(self) -> None: # Univariate equality self.assertFalse(self.ts_univ_1 != self.ts_univ_2) # Multivariate equality self.assertFalse(self.ts_multi_1 != self.ts_multi_2) # Univariate inequality self.assertTrue(self.ts_univ_1 != self.ts_date_transform_univ) self.assertTrue(self.ts_univ_1 != self.ts_value_transform_univ) self.assertTrue(self.ts_univ_1 != self.ts_date_and_value_transform_univ) # Multivariate inequality self.assertTrue(self.ts_multi_1 != self.ts_date_transform_multi) self.assertTrue(self.ts_multi_1 != self.ts_value_transform_none_multi) self.assertTrue(self.ts_multi_1 != self.ts_date_and_value_transform_multi) # Univariate vs. Multivariate inequality self.assertTrue(self.ts_univ_1 != self.ts_multi_1) self.assertTrue(self.ts_multi_1 != self.ts_univ_1) def test_add(self) -> None: # Add same DataFrames self.assertEqual(self.ts_univ_1 + self.ts_univ_2, self.ts_value_transform_univ) # Add different DataFrames self.assertEqual( self.ts_univ_1 + self.ts_value_transform_inv_univ, self.ts_zero ) # Add Univariate and Multivariate DataFrames self.assertEqual( self.ts_univ_1 + self.ts_multi_1, self.ts_value_transform_none_multi ) # Empty Case self.assertEqual(self.ts_empty + self.ts_empty, self.ts_empty) # Add DataFrames with different dates with self.assertRaises(ValueError): self.ts_univ_1 + self.ts_date_transform_univ def test_sub(self) -> None: # Subtract same DataFrames self.assertEqual(self.ts_univ_1 - self.ts_univ_2, self.ts_zero) # Subtract different DataFrames self.assertEqual( self.ts_univ_1 - self.ts_value_transform_inv_univ, self.ts_value_transform_univ, ) # Subtract Univariate and Multivariate DataFrames self.assertEqual( self.ts_multi_1 - self.ts_value_transform_inv_univ, self.ts_value_transform_none_multi, ) # Empty Case self.assertEqual(self.ts_empty - self.ts_empty, self.ts_empty) # Subtract DataFrames with different dates with self.assertRaises(ValueError): self.ts_univ_1 - self.ts_date_transform_univ def test_div(self) -> None: # Divide same DataFrames self.assertEqual(self.ts_univ_1 / self.ts_univ_2, self.ts_ones) # Divide different DataFrames self.assertEqual( self.ts_univ_1 / self.ts_value_transform_inv_univ, self.ts_neg_ones ) # Divide Univariate and Multivariate DataFrames self.assertEqual( self.ts_value_transform_univ / self.ts_ones_multi, self.ts_value_transform_none_multi, ) # Empty Case self.assertEqual(self.ts_empty / self.ts_empty, self.ts_empty) # Divide DataFrames with different dates with self.assertRaises(ValueError): self.ts_univ_1 / self.ts_date_transform_univ def test_mul(self) -> None: # Multiply same DataFrames self.assertEqual(self.ts_ones * self.ts_ones, self.ts_ones) # Multiply different DataFrames self.assertEqual(self.ts_univ_1 * self.ts_twos, self.ts_value_transform_univ) # Multiply Univariate and Multivariate DataFrames self.assertEqual( self.ts_multi_1 * self.ts_twos, self.ts_value_transform_none_multi ) # Empty Case self.assertEqual(self.ts_empty * self.ts_empty, self.ts_empty) # Multiply DataFrames with different dates with self.assertRaises(ValueError): self.ts_univ_1 * self.ts_date_transform_univ def test_len(self) -> None: # Normal case self.assertEqual(len(self.ts_univ_1), self.length) # Empty case self.assertEqual(len(self.ts_empty), 0) def test_empty(self) -> None: # Empty case self.assertTrue(self.ts_empty.is_empty()) # Not empty case self.assertFalse(self.ts_univ_1.is_empty()) def test_extend(self) -> None: # Testing cases with validate=True # Univariate case self.ts_univ_extend.extend(self.ts_date_transform_univ) self.assertEqual(self.ts_univ_extend, self.ts_date_transform_concat_univ) # Multivariate case self.ts_multi_extend.extend(self.ts_date_transform_multi) self.assertEqual(self.ts_multi_extend, self.ts_date_transform_concat_multi) # Univariate and multivariate case self.ts_multi_extend_2.extend(self.ts_date_transform_univ) self.assertEqual(self.ts_multi_extend_2, self.ts_date_transform_concat_mixed) # Empty case self.ts_univ_default_names.extend(self.ts_empty) self.assertEqual(self.ts_univ_default_names, self.ts_univ_default_names_2) # Catching errors with self.assertRaises(ValueError): self.ts_univ_extend_err.extend(self.ts_date_transform_double_univ) # Multivariate case self.ts_multi_extend_err.extend(self.ts_date_transform_double_multi) # Univariate and multivariate case self.ts_multi_extend_err_2.extend(self.ts_date_transform_double_univ) # Empty case self.ts_empty_extend_err.extend(self.ts_empty) # Testing cases with validate=False # Univariate case self.ts_univ_extend_2.extend(self.ts_date_transform_double_univ, validate=False) self.assertEqual( self.ts_univ_extend_2, self.ts_date_transform_concat_double_univ ) # Multivariate case self.ts_multi_extend_3.extend( self.ts_date_transform_double_multi, validate=False ) self.assertEqual( self.ts_multi_extend_3, self.ts_date_transform_concat_double_multi ) # Univariate and multivariate case self.ts_multi_extend_4.extend( self.ts_date_transform_double_univ, validate=False ) self.assertEqual( self.ts_multi_extend_4, self.ts_date_transform_concat_double_mixed ) # Empty case self.ts_empty_extend.extend(self.ts_empty, validate=False) self.assertEqual(self.ts_empty_extend, self.ts_empty) def test_get_item(self) -> None: # Univariate test case self.assertEqual( self.ts_date_transform_concat_univ[: len(self.ts_univ_1)], self.ts_univ_1 ) # Multivariate test case self.assertEqual( self.ts_date_transform_concat_multi[: len(self.ts_multi_1)], self.ts_multi_1 ) # Multivariate test case where we select a specific column for col in self.ts_date_transform_concat_multi.value.columns: ts_univ = TimeSeriesData( time=self.ts_date_transform_concat_multi.time, value=self.ts_date_transform_concat_multi.value[col], time_col_name=self.ts_date_transform_concat_multi.time_col_name, ) self.assertEqual(self.ts_date_transform_concat_multi[col], ts_univ) # Multivariate test case where we select multiple columns self.assertEqual( self.ts_date_transform_concat_multi[MULTIVAR_VALUE_DF_COLS], self.ts_date_transform_concat_multi, ) # Full/Empty cases self.assertEqual(self.ts_univ_1[:], self.ts_univ_1) self.assertEqual( self.ts_univ_1[0:0], TimeSeriesData( time=pd.Series(name=TIME_COL_NAME), value=pd.Series(name=VALUE_COL_NAME), time_col_name=TIME_COL_NAME, ), ) # pyre-fixme[56]: Pyre was not able to infer the type of the decorator # `pytest.mark.mpl_image_compare`. @pytest.mark.mpl_image_compare def test_plot(self) -> plt.Figure: # Univariate test case ax = self.ts_univ_1.plot(cols=["y"]) self.assertIsNotNone(ax) return plt.gcf() # pyre-fixme[56]: Pyre was not able to infer the type of the decorator # `pytest.mark.mpl_image_compare`. @pytest.mark.mpl_image_compare def test_plot_multivariate(self) -> plt.Figure: # Multivariate test case ax = self.ts_multi_1.plot() self.assertIsNotNone(ax) return plt.gcf() # pyre-fixme[56]: Pyre was not able to infer the type of the decorator # `pytest.mark.mpl_image_compare`. @pytest.mark.mpl_image_compare def test_plot_params(self) -> plt.Figure: # Test more parameter overrides. ax = self.ts_multi_1.plot( figsize=(8, 3), plot_kwargs={"cmap": "Purples"}, grid=False ) self.assertIsNotNone(ax) return plt.gcf() # pyre-fixme[56]: Pyre was not able to infer the type of the decorator # `pytest.mark.mpl_image_compare`. @pytest.mark.mpl_image_compare def test_plot_grid_ax(self) -> plt.Figure: # Test grid and ax parameter overrides. fig, ax = plt.subplots(figsize=(6, 4)) ax = self.ts_univ_1.plot(ax=ax, grid_kwargs={"lw": 2, "ls": ":"}) self.assertIsNotNone(ax) return fig def test_plot_missing_column(self) -> None: # Columns not in data. with self.assertRaises(ValueError): self.ts_univ_1.plot(cols=["z"]) def test_plot_empty(self) -> None: # No data to plot. with self.assertRaises(ValueError): self.ts_empty.plot() class TimeSeriesDataMiscTest(TimeSeriesBaseTest): def setUp(self) -> None: super(TimeSeriesDataMiscTest, self).setUp() # Creating TimeSeriesData objects # Univariate TimeSeriesData initialized from a pd.DataFrame self.ts_univ = TimeSeriesData(df=self.AIR_DF, time_col_name=TIME_COL_NAME) # Multivariate TimeSeriesData initialized from a pd.DataFrame self.ts_multi = TimeSeriesData( df=self.MULTIVAR_AIR_DF, time_col_name=TIME_COL_NAME ) def test_is_univariate(self) -> None: # Univariate case self.assertTrue(self.ts_univ.is_univariate()) # Multivariate case self.assertFalse(self.ts_multi.is_univariate()) def test_time_to_index(self) -> None: # Univariate case assert_index_equal(self.ts_univ.time_to_index(), self.AIR_TIME_DATETIME_INDEX) # Multivariate case assert_index_equal(self.ts_multi.time_to_index(), self.AIR_TIME_DATETIME_INDEX) def test_repr(self) -> None: # Univariate case self.assertEqual(self.ts_univ.__repr__(), self.AIR_DF_DATETIME.__repr__()) # Multivariate case self.assertEqual( self.ts_multi.__repr__(), self.MULTIVAR_AIR_DF_DATETIME.__repr__() ) def test_repr_html(self) -> None: # Univariate case self.assertEqual(self.ts_univ._repr_html_(), self.AIR_DF_DATETIME._repr_html_()) # Multivariate case self.assertEqual( self.ts_multi._repr_html_(), self.MULTIVAR_AIR_DF_DATETIME._repr_html_() ) class TSIteratorTest(TestCase): def test_ts_iterator_univariate_next(self) -> None: df = pd.DataFrame( [["2020-03-01", 100], ["2020-03-02", 120], ["2020-03-03", 130]], columns=["time", "y"], ) kats_data = TimeSeriesData(df=df) kats_iterator = TSIterator(kats_data) val = next(kats_iterator) assert_series_equal( val.time, pd.Series([pd.Timestamp("2020-03-01")]), check_names=False ) assert_series_equal( cast(pd.Series, val.value), pd.Series([100]), check_names=False ) val = next(kats_iterator) assert_series_equal( val.time, pd.Series([pd.Timestamp("2020-03-02")]), check_names=False ) assert_series_equal( cast(pd.Series, val.value), pd.Series([120]), check_names=False ) val = next(kats_iterator) assert_series_equal( val.time, pd.Series([pd.Timestamp("2020-03-03")]), check_names=False ) assert_series_equal( cast(pd.Series, val.value),
pd.Series([130])
pandas.Series
from fastapi import APIRouter, HTTPException import numpy as np import pandas as pd import plotly.graph_objects as go import plotly.express as px import os router = APIRouter() DATA_FILEPATH = os.path.join(os.path.dirname(__file__), "..", "..","data", "job_industry_data.csv") @router.get('/jobs/{city_id}') async def pop_to_dict(city_id: int): """ Job Industry insights """ rt_dict = {} rt_data_dict = {} df = pd.read_csv(DATA_FILEPATH, encoding='utf-8') dataframe = df[df['city_id']==city_id] rt_data = dataframe.to_numpy() rt_data_dict['id'] = rt_data[0][1] rt_data_dict['city'] = rt_data[0][2] rt_data_dict['state'] = rt_data[0][3] rt_data_dict['city_state'] = rt_data[0][4] rt_data_dict["job_ranked_1"] = top_jobs(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[0] rt_data_dict["job_ranked_1_%"] = percentage(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[0] rt_data_dict["job_ranked_2"] = top_jobs(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[1] rt_data_dict["job_ranked_2_%"] = percentage(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[1] rt_data_dict["job_ranked_3"] = top_jobs(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[2] rt_data_dict["job_ranked_3_%"] = percentage(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[2] rt_data_dict["job_ranked_4"] = top_jobs(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[3] rt_data_dict["job_ranked_4_%"] = percentage(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[3] rt_data_dict["job_ranked_5"] = top_jobs(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[4] rt_data_dict["job_ranked_5_%"] = percentage(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[4] rt_data_dict["job_ranked_6"] = top_jobs(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[5] rt_data_dict["job_ranked_6_%"] = percentage(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[5] rt_data_dict["job_ranked_7"] = top_jobs(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[6] rt_data_dict["job_ranked_7_%"] = percentage(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[6] rt_data_dict["job_ranked_8"] = top_jobs(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[7] rt_data_dict["job_ranked_8_%"] = percentage(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[7] rt_data_dict["job_ranked_9"] = top_jobs(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[8] rt_data_dict["job_ranked_9_%"] = percentage(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[8] rt_data_dict["job_ranked_10"] = top_jobs(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[9] rt_data_dict["job_ranked_10_%"] = percentage(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10).iloc[9] rt_dict["data"] = rt_data_dict rt_dict["viz"] = cityjobsviz(df = pd.read_csv(DATA_FILEPATH, encoding='utf-8'), city_id=rt_data[0][1], n_industries=10) return rt_dict def cityjobsviz(df, city_id , n_industries = 10): df =
pd.read_csv(DATA_FILEPATH, encoding='utf-8')
pandas.read_csv
import urllib.request import json from credentials import API_KEY from stores import locations, station BASE_URL = 'https://maps.googleapis.com/maps/api/distancematrix/json?key=%s&' % API_KEY def lookup(locations): grid = [] for i in range(len(locations)-1): origin = '%s,%s' % locations[i] for j in range(i+1, len(locations)): print(i,j) dest = '%s,%s' % locations[j] url = (BASE_URL + 'origins={}&destinations={}&mode=driving&sensor=false').format(origin, dest) seconds = 0 if True: html = urllib.request.urlopen(url).read() data = json.loads(html) try: seconds = data["rows"][0]["elements"][0]["duration"]["value"] except: print('failed to get time') print(field1, field2) raise return grid.append((i, j, seconds)) table =
pd.DataFrame(grid, columns=['from', 'to', 'weight'])
pandas.DataFrame
# --- # jupyter: # jupytext: # formats: ipynb,py:nomarker # text_representation: # extension: .py # format_name: nomarker # format_version: '1.0' # jupytext_version: 1.10.2 # kernelspec: # display_name: Python 3 # language: python # name: python3 # --- # # CNN - Example 01 import numpy as np import pandas as pd import matplotlib.pyplot as plt # ### Load Keras Dataset from tensorflow.keras.datasets import mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() # #### Visualize data print(x_train.shape) single_image = x_train[0] print(single_image.shape) plt.imshow(single_image) # ### Pre-Process data # #### One Hot encode # Make it one hot encoded otherwise it will think as a regression problem on a continuous axis from tensorflow.keras.utils import to_categorical print("Shape before one hot encoding" +str(y_train.shape)) y_example = to_categorical(y_train) print(y_example) print("Shape after one hot encoding" +str(y_train.shape)) y_example[0] y_cat_test = to_categorical(y_test,10) y_cat_train = to_categorical(y_train,10) # #### Normalize the images x_train = x_train/255 x_test = x_test/255 scaled_single = x_train[0] plt.imshow(scaled_single) # #### Reshape the images # Reshape to include channel dimension (in this case, 1 channel) # x_train.shape x_train = x_train.reshape(60000, 28, 28, 1) x_test = x_test.reshape(10000,28,28,1) # ### Image data augmentation from tensorflow.keras.preprocessing.image import ImageDataGenerator # help(ImageDataGenerator) datagen = ImageDataGenerator( featurewise_center=True, featurewise_std_normalization=True, rotation_range=20, width_shift_range=0.2, height_shift_range=0.2, horizontal_flip=True) datagen.fit(x_train) it = datagen.flow(x_train, y_cat_train, batch_size=32) # Preparing the Samples and Plot for displaying output for i in range(9): # preparing the subplot plt.subplot(330 + 1 + i) # generating images in batches batch = it.next() # Remember to convert these images to unsigned integers for viewing image = batch[0][0].astype('uint8') # Plotting the data plt.imshow(image) # Displaying the figure plt.show() # ### Model # 1 from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Conv2D, MaxPool2D, Flatten model = Sequential() model.add(Conv2D(filters=32, kernel_size=(4,4), input_shape=(28, 28, 1), activation='relu',)) model.add(MaxPool2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(128, activation='relu')) model.add(Dense(10, activation='softmax')) # Notes : If y is not one hot coded then loss= sparse_categorical_crossentropy model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy', 'categorical_accuracy']) # we can add in additional metrics https://keras.io/metrics/ model.summary() # #### Add Early Stopping from tensorflow.keras.callbacks import EarlyStopping early_stop = EarlyStopping(monitor='val_loss', patience=2) # ##### Training using one hot encoding # fits the model on batches with real-time data augmentation: history = model.fit(datagen.flow(x_train, y_cat_train, batch_size=32), epochs=10, steps_per_epoch=len(x_train) / 32, validation_data=(x_test,y_cat_test), callbacks=[early_stop]) # #### Save model # Saving model # from tensorflow.keras.models import load_model # model_file = 'D:\\Sandbox\\Github\\MODELS\\' + '01_mnist.h5' # model.save(model_file) # #### Retreive model # Retrieve model # model = load_model(model_file) # #### Evaluate # Rule of thumb # 1. High Bias accuracy = 80% val-accuracy = 78% (2% gap) # 2. High Variance accuracy = 98% val-accuracy = 80% (18% gap) # 3. High Bias and High Variance accuracy = 80% val-accuracy = 60% (20% gap) # 4. Low Bias and Low Variance accuracy = 98% val-accuracy = 96% (2% gap) # #### Eval - Train model.metrics_names pd.DataFrame(history.history).head() #pd.DataFrame(model.history.history).head() # pd.DataFrame(history.history).plot() losses =
pd.DataFrame(history.history)
pandas.DataFrame
import logging import os import re import shutil import sys import warnings from datetime import datetime from typing import Union import h5py import numpy as np import pandas as pd from omegaconf import DictConfig, OmegaConf, ListConfig from tqdm import tqdm import deepethogram from deepethogram.utils import get_subfiles, log from deepethogram.zscore import zscore_video from . import utils from .file_io import read_labels, convert_video log = logging.getLogger(__name__) required_keys = ['project', 'augs'] projects_file_directory = os.path.dirname(os.path.abspath(__file__)) def initialize_project(directory: Union[str, os.PathLike], project_name: str, behaviors: list = None, make_subdirectory: bool = True, labeler: str = None): """Initializes a DeepEthogram project. Copies the default configuration file and updates it with the directory, name, and behaviors specified. Makes directories where project info, data, and models will live. Args: directory: str, os.PathLike Directory where DeepEthogram data and models will be made / copied. Should be on an SSD. Should also have plenty of space. project_name: str name of the deepethogram project behaviors: optional list. First should be background. make_subdirectory: bool if True, make a subdirectory like "/path/to/DATA/project_name_deepethogram" if False, keep as the input directory: "/path/to/DATA" Example: intialize_project('C:/DATA', 'grooming', ['background', 'face_groom', 'body_groom', 'rear']) """ assert os.path.isdir(directory), 'Directory does not exist: {}'.format(directory) if behaviors is not None: assert behaviors[0] == 'background' root = os.path.dirname(os.path.abspath(__file__)) project_config = utils.load_yaml(os.path.join(root, 'conf', 'project', 'project_config_default.yaml')) project_name = project_name.replace(' ', '_') project_config['project']['name'] = project_name project_config['project']['class_names'] = behaviors if make_subdirectory: project_dir = os.path.join(directory, '{}_deepethogram'.format(project_name)) else: project_dir = directory project_config['project']['path'] = project_dir project_config['project']['data_path'] = 'DATA' project_config['project']['model_path'] = 'models' project_config['project']['labeler'] = labeler if not os.path.isdir(project_config['project']['path']): os.makedirs(project_config['project']['path']) # os.chdir(project_config['project']['path']) data_abs = os.path.join(project_config['project']['path'], project_config['project']['data_path']) if not os.path.isdir(data_abs): os.makedirs(data_abs) model_abs = os.path.join(project_config['project']['path'], project_config['project']['model_path']) if not os.path.isdir(model_abs): os.makedirs(model_abs) fname = os.path.join(project_dir, 'project_config.yaml') project_config['project']['config_file'] = fname utils.save_dict_to_yaml(project_config, fname) return project_config def add_video_to_project(project: dict, path_to_video: Union[str, os.PathLike], mode: str = 'copy') -> str: """ Adds a video file to a DEG project. 1. Copies the video file to the project's data directory 2. initializes a record.yaml file 3. Computes per-channel image statistics (for input normalization) Parameters ---------- project: dict pre-loaded configuration dictionary path_to_video: str, PathLike absolute path to a video file. Filetype must be acceptable to deepethogram.file_io.VideoReader mode: str if 'copy': copies files to new directory if 'symlink': tries to make a symlink from the old location to the new location. NOT RECOMMENDED. if you delete the video in its current location, the symlink will break, and we will have errors during training or inference if 'move': moves the file Returns ------- new_path: str path to the video file after moving to the DEG project data directory. """ # assert (os.path.isdir(project_directory)) assert os.path.exists(path_to_video), 'video not found! {}'.format(path_to_video) if os.path.isdir(path_to_video): copy_func = shutil.copytree elif os.path.isfile(path_to_video): copy_func = shutil.copy else: raise ValueError('video does not exist: {}'.format(path_to_video)) assert mode in ['copy', 'symlink', 'move'] # project = utils.load_yaml(os.path.join(project_directory, 'project_config.yaml')) # project = convert_config_paths_to_absolute(project) log.debug('configuration file when adding video: {}'.format(project)) datadir = os.path.join(project['project']['path'], project['project']['data_path']) assert os.path.isdir(datadir), 'data path not found: {}'.format(datadir) # for speed during training, videos can be saved as directories of PNG / JPEG files. if os.path.isdir(path_to_video): video_is_directory = True else: video_is_directory = False basename = os.path.basename(path_to_video) vidname = os.path.splitext(basename)[0] video_directory = os.path.join(datadir, vidname) if os.path.isdir(video_directory): raise ValueError('Directory {} already exists in your data dir! ' \ 'Please rename the video to a unique name'.format(vidname)) os.makedirs(video_directory) new_path = os.path.join(video_directory, basename) if mode == 'copy': if video_is_directory: shutil.copytree(path_to_video, new_path) else: shutil.copy(path_to_video, new_path) elif mode == 'symlink': os.symlink(path_to_video, new_path) elif mode == 'move': shutil.move(path_to_video, new_path) else: raise ValueError('invalid argument to mode: {}'.format(mode)) record = parse_subdir(video_directory) log.debug('New record after adding: {}'.format(record)) utils.save_dict_to_yaml(record, os.path.join(video_directory, 'record.yaml')) zscore_video(os.path.join(video_directory, basename), project) return new_path def add_label_to_project(path_to_labels: Union[str, os.PathLike], path_to_video) -> str: """Adds an externally created label file to the project. Updates record""" assert os.path.isfile(path_to_labels) assert os.path.isfile(path_to_video) assert is_deg_file(path_to_video) viddir = os.path.dirname(path_to_video) label_dst = os.path.join(viddir, os.path.basename(path_to_labels)) if os.path.isfile(label_dst): warnings.warn('Label already exists in destination {}, overwriting...'.format(label_dst)) df =
pd.read_csv(path_to_labels, index_col=0)
pandas.read_csv
# Copyright (c) 2019-2021, NVIDIA CORPORATION. import datetime import decimal import os import random from io import BytesIO from string import ascii_lowercase import numpy as np import pandas as pd import pyarrow as pa import pyarrow.orc import pyorc as po import pytest import cudf from cudf.core.dtypes import Decimal64Dtype from cudf.io.orc import ORCWriter from cudf.testing._utils import ( assert_eq, gen_rand_series, supported_numpy_dtypes, ) @pytest.fixture(scope="module") def datadir(datadir): return datadir / "orc" @pytest.fixture def path_or_buf(datadir): fname = datadir / "TestOrcFile.test1.orc" try: with open(fname, "rb") as f: buffer = BytesIO(f.read()) except Exception as excpr: if type(excpr).__name__ == "FileNotFoundError": pytest.skip(".parquet file is not found") else: print(type(excpr).__name__) def _make_path_or_buf(src): if src == "filepath": return str(fname) if src == "pathobj": return fname if src == "bytes_io": return buffer if src == "bytes": return buffer.getvalue() if src == "url": return fname.as_uri() raise ValueError("Invalid source type") yield _make_path_or_buf @pytest.mark.filterwarnings("ignore:Using CPU") @pytest.mark.parametrize("engine", ["pyarrow", "cudf"]) @pytest.mark.parametrize("use_index", [False, True]) @pytest.mark.parametrize( "inputfile, columns", [ ("TestOrcFile.emptyFile.orc", ["boolean1"]), ( "TestOrcFile.test1.orc", [ "boolean1", "byte1", "short1", "int1", "long1", "float1", "double1", ], ), ("TestOrcFile.RLEv2.orc", ["x", "y"]), ("TestOrcFile.testSnappy.orc", None), ("TestOrcFile.demo-12-zlib.orc", ["_col2", "_col3", "_col4", "_col5"]), ], ) def test_orc_reader_basic(datadir, inputfile, columns, use_index, engine): path = datadir / inputfile try: orcfile = pa.orc.ORCFile(path) except pa.ArrowIOError as e: pytest.skip(".orc file is not found: %s" % e) expect = orcfile.read(columns=columns).to_pandas() got = cudf.read_orc( path, engine=engine, columns=columns, use_index=use_index ) assert_eq(expect, got, check_categorical=False) def test_orc_reader_filenotfound(tmpdir): with pytest.raises(FileNotFoundError): cudf.read_orc("TestMissingFile.orc") with pytest.raises(FileNotFoundError): cudf.read_orc(tmpdir.mkdir("cudf_orc")) def test_orc_reader_local_filepath(): path = "~/TestLocalFile.orc" if not os.path.isfile(path): pytest.skip("Local .orc file is not found") cudf.read_orc(path) @pytest.mark.parametrize( "src", ["filepath", "pathobj", "bytes_io", "bytes", "url"] ) def test_orc_reader_filepath_or_buffer(path_or_buf, src): cols = ["int1", "long1", "float1", "double1"] orcfile = pa.orc.ORCFile(path_or_buf("filepath")) expect = orcfile.read(columns=cols).to_pandas() got = cudf.read_orc(path_or_buf(src), columns=cols) assert_eq(expect, got) def test_orc_reader_trailing_nulls(datadir): path = datadir / "TestOrcFile.nulls-at-end-snappy.orc" try: orcfile = pa.orc.ORCFile(path) except pa.ArrowIOError as e: pytest.skip(".orc file is not found: %s" % e) expect = orcfile.read().to_pandas().fillna(0) got = cudf.read_orc(path).fillna(0) # PANDAS uses NaN to represent invalid data, which forces float dtype # For comparison, we can replace NaN with 0 and cast to the cuDF dtype for col in expect.columns: expect[col] = expect[col].astype(got[col].dtype) assert_eq(expect, got, check_categorical=False) @pytest.mark.parametrize("use_index", [False, True]) @pytest.mark.parametrize( "inputfile", ["TestOrcFile.testDate1900.orc", "TestOrcFile.testDate2038.orc"], ) def test_orc_reader_datetimestamp(datadir, inputfile, use_index): path = datadir / inputfile try: orcfile = pa.orc.ORCFile(path) except pa.ArrowIOError as e: pytest.skip(".orc file is not found: %s" % e) pdf = orcfile.read().to_pandas(date_as_object=False) gdf = cudf.read_orc(path, use_index=use_index) assert_eq(pdf, gdf, check_categorical=False) def test_orc_reader_strings(datadir): path = datadir / "TestOrcFile.testStringAndBinaryStatistics.orc" try: orcfile = pa.orc.ORCFile(path) except pa.ArrowIOError as e: pytest.skip(".orc file is not found: %s" % e) expect = orcfile.read(columns=["string1"]) got = cudf.read_orc(path, columns=["string1"]) assert_eq(expect, got, check_categorical=False) def test_orc_read_statistics(datadir): # Read in file containing 2 columns ("int1" and "string1") and 3 stripes # (sizes 5000, 5000 and 1000 respectively). Each stripe has the same value # in every one of its rows. The values the stripes have are 1, 2, and 3 in # "int1" and "one", "two", and "three" in "string1". path = datadir / "TestOrcFile.testStripeLevelStats.orc" try: ( file_statistics, stripes_statistics, ) = cudf.io.orc.read_orc_statistics([path, path]) except pa.ArrowIOError as e: pytest.skip(".orc file is not found: %s" % e) # Check numberOfValues assert_eq(file_statistics[0]["int1"]["number_of_values"], 11_000) assert_eq( file_statistics[0]["int1"]["number_of_values"], sum( [ stripes_statistics[0]["int1"]["number_of_values"], stripes_statistics[1]["int1"]["number_of_values"], stripes_statistics[2]["int1"]["number_of_values"], ] ), ) assert_eq( stripes_statistics[1]["int1"]["number_of_values"], stripes_statistics[1]["string1"]["number_of_values"], ) assert_eq(stripes_statistics[2]["string1"]["number_of_values"], 1_000) # Check other statistics assert_eq(stripes_statistics[2]["string1"]["has_null"], False) assert_eq( file_statistics[0]["int1"]["minimum"], min( stripes_statistics[0]["int1"]["minimum"], stripes_statistics[1]["int1"]["minimum"], stripes_statistics[2]["int1"]["minimum"], ), ) assert_eq(file_statistics[0]["int1"]["minimum"], 1) assert_eq(file_statistics[0]["string1"]["minimum"], "one") @pytest.mark.filterwarnings("ignore:Using CPU") @pytest.mark.parametrize("engine", ["cudf", "pyarrow"]) @pytest.mark.parametrize( "predicate,expected_len", [ ([[("int1", "==", 1)]], 5000), ([[("int1", "<=", 2)]], 10000), ([[("int1", "==", -1)]], 0), ([[("int1", "in", range(3))]], 10000), ([[("int1", "in", {1, 3})]], 6000), ([[("int1", "not in", {1, 3})]], 5000), ], ) def test_orc_read_filtered(datadir, engine, predicate, expected_len): path = datadir / "TestOrcFile.testStripeLevelStats.orc" try: df_filtered = cudf.read_orc(path, engine=engine, filters=predicate) except pa.ArrowIOError as e: pytest.skip(".orc file is not found: %s" % e) # Assert # of rows after filtering assert len(df_filtered) == expected_len @pytest.mark.filterwarnings("ignore:Using CPU") @pytest.mark.parametrize("engine", ["cudf", "pyarrow"]) def test_orc_read_stripes(datadir, engine): path = datadir / "TestOrcFile.testDate1900.orc" try: pdf = cudf.read_orc(path, engine=engine) except pa.ArrowIOError as e: pytest.skip(".orc file is not found: %s" % e) num_rows, stripes, col_names = cudf.io.read_orc_metadata(path) # Read stripes one at a time gdf = [ cudf.read_orc(path, engine=engine, stripes=[[i]]) for i in range(stripes) ] gdf = cudf.concat(gdf).reset_index(drop=True) assert_eq(pdf, gdf, check_categorical=False, check_index_type=True) # Read stripes all at once gdf = cudf.read_orc( path, engine=engine, stripes=[[int(x) for x in range(stripes)]] ) assert_eq(pdf, gdf, check_categorical=False) # Read only some stripes gdf = cudf.read_orc(path, engine=engine, stripes=[[0, 1]]) assert_eq(gdf, pdf.head(25000)) gdf = cudf.read_orc(path, engine=engine, stripes=[[0, stripes - 1]]) assert_eq( gdf, cudf.concat([pdf.head(15000), pdf.tail(10000)], ignore_index=True), check_index_type=True, ) @pytest.mark.parametrize("num_rows", [1, 100, 3000]) @pytest.mark.parametrize("skiprows", [0, 1, 3000]) def test_orc_read_rows(datadir, skiprows, num_rows): path = datadir / "TestOrcFile.decimal.orc" try: orcfile = pa.orc.ORCFile(path) except pa.ArrowIOError as e: pytest.skip(".orc file is not found: %s" % e) pdf = orcfile.read().to_pandas() gdf = cudf.read_orc(path, skiprows=skiprows, num_rows=num_rows) # Slice rows out of the whole dataframe for comparison as PyArrow doesn't # have an API to read a subsection of rows from the file pdf = pdf[skiprows : skiprows + num_rows] pdf = pdf.reset_index(drop=True) assert_eq(pdf, gdf) def test_orc_read_skiprows(tmpdir): buff = BytesIO() df = pd.DataFrame( {"a": [1, 0, 1, 0, None, 1, 1, 1, 0, None, 0, 0, 1, 1, 1, 1]}, dtype=pd.BooleanDtype(), ) writer = po.Writer(buff, po.Struct(a=po.Boolean())) tuples = list( map( lambda x: (None,) if x[0] is pd.NA else x, list(df.itertuples(index=False, name=None)), ) ) writer.writerows(tuples) writer.close() skiprows = 10 expected = cudf.read_orc(buff)[skiprows::].reset_index(drop=True) got = cudf.read_orc(buff, skiprows=skiprows) assert_eq(expected, got) def test_orc_reader_uncompressed_block(datadir): path = datadir / "uncompressed_snappy.orc" try: orcfile = pa.orc.ORCFile(path) except pa.ArrowIOError as e: pytest.skip(".orc file is not found: %s" % e) expect = orcfile.read().to_pandas() got = cudf.read_orc(path) assert_eq(expect, got, check_categorical=False) def test_orc_reader_nodata_block(datadir): path = datadir / "nodata.orc" try: orcfile = pa.orc.ORCFile(path) except Exception as excpr: if type(excpr).__name__ == "ArrowIOError": pytest.skip(".orc file is not found") else: print(type(excpr).__name__) expect = orcfile.read().to_pandas() got = cudf.read_orc(path, num_rows=1) assert_eq(expect, got, check_categorical=False) @pytest.mark.parametrize("compression", [None, "snappy"]) @pytest.mark.parametrize( "reference_file, columns", [ ( "TestOrcFile.test1.orc", [ "boolean1", "byte1", "short1", "int1", "long1", "float1", "double1", ], ), ("TestOrcFile.demo-12-zlib.orc", ["_col1", "_col3", "_col5"]), ], ) def test_orc_writer(datadir, tmpdir, reference_file, columns, compression): pdf_fname = datadir / reference_file gdf_fname = tmpdir.join("gdf.orc") try: orcfile = pa.orc.ORCFile(pdf_fname) except Exception as excpr: if type(excpr).__name__ == "ArrowIOError": pytest.skip(".orc file is not found") else: print(type(excpr).__name__) expect = orcfile.read(columns=columns).to_pandas() cudf.from_pandas(expect).to_orc(gdf_fname.strpath, compression=compression) got = pa.orc.ORCFile(gdf_fname).read(columns=columns).to_pandas() assert_eq(expect, got) @pytest.mark.parametrize("compression", [None, "snappy"]) @pytest.mark.parametrize( "reference_file, columns", [ ( "TestOrcFile.test1.orc", [ "boolean1", "byte1", "short1", "int1", "long1", "float1", "double1", ], ), ("TestOrcFile.demo-12-zlib.orc", ["_col1", "_col3", "_col5"]), ], ) def test_chunked_orc_writer( datadir, tmpdir, reference_file, columns, compression ): pdf_fname = datadir / reference_file gdf_fname = tmpdir.join("chunked_gdf.orc") try: orcfile = pa.orc.ORCFile(pdf_fname) except Exception as excpr: if type(excpr).__name__ == "ArrowIOError": pytest.skip(".orc file is not found") else: print(type(excpr).__name__) pdf = orcfile.read(columns=columns).to_pandas() gdf = cudf.from_pandas(pdf) expect = pd.concat([pdf, pdf]).reset_index(drop=True) writer = ORCWriter(gdf_fname, compression=compression) writer.write_table(gdf) writer.write_table(gdf) writer.close() got = pa.orc.ORCFile(gdf_fname).read(columns=columns).to_pandas() assert_eq(expect, got) @pytest.mark.parametrize( "dtypes", [ {"c": str, "a": int}, {"c": int, "a": str}, {"c": int, "a": str, "b": float}, {"c": str, "a": object}, ], ) def test_orc_writer_strings(tmpdir, dtypes): gdf_fname = tmpdir.join("gdf_strings.orc") expect = cudf.datasets.randomdata(nrows=10, dtypes=dtypes, seed=1) expect.to_orc(gdf_fname) got = pa.orc.ORCFile(gdf_fname).read().to_pandas() assert_eq(expect, got) @pytest.mark.parametrize( "dtypes", [ {"c": str, "a": int}, {"c": int, "a": str}, {"c": int, "a": str, "b": float}, {"c": str, "a": object}, ], ) def test_chunked_orc_writer_strings(tmpdir, dtypes): gdf_fname = tmpdir.join("chunked_gdf_strings.orc") gdf = cudf.datasets.randomdata(nrows=10, dtypes=dtypes, seed=1) pdf = gdf.to_pandas() expect = pd.concat([pdf, pdf]).reset_index(drop=True) writer = ORCWriter(gdf_fname) writer.write_table(gdf) writer.write_table(gdf) writer.close() got = pa.orc.ORCFile(gdf_fname).read().to_pandas() assert_eq(expect, got) def test_orc_writer_sliced(tmpdir): cudf_path = tmpdir.join("cudf.orc") df = pd.DataFrame() df["String"] = np.array(["Alpha", "Beta", "Gamma", "Delta"]) df = cudf.from_pandas(df) df_select = df.iloc[1:3] df_select.to_orc(cudf_path) assert_eq(cudf.read_orc(cudf_path), df_select.reset_index(drop=True)) @pytest.mark.parametrize( "orc_file", [ "TestOrcFile.decimal.orc", "TestOrcFile.decimal.same.values.orc", "TestOrcFile.decimal.multiple.values.orc", # For additional information take look at PR 7034 "TestOrcFile.decimal.runpos.issue.orc", ], ) def test_orc_reader_decimal_type(datadir, orc_file): file_path = datadir / orc_file try: orcfile = pa.orc.ORCFile(file_path) except pa.ArrowIOError as e: pytest.skip(".orc file is not found: %s" % e) pdf = orcfile.read().to_pandas() df = cudf.read_orc(file_path).to_pandas() assert_eq(pdf, df) def test_orc_decimal_precision_fail(datadir): file_path = datadir / "TestOrcFile.int_decimal.precision_19.orc" try: orcfile = pa.orc.ORCFile(file_path) except pa.ArrowIOError as e: pytest.skip(".orc file is not found: %s" % e) # Max precision supported is 18 (Decimal64Dtype limit) # and the data has the precision 19. This test should be removed # once Decimal128Dtype is introduced. with pytest.raises(RuntimeError): cudf.read_orc(file_path) # Shouldn't cause failure if decimal column is not chosen to be read. pdf = orcfile.read(columns=["int"]).to_pandas() gdf = cudf.read_orc(file_path, columns=["int"]) assert_eq(pdf, gdf) # For additional information take look at PR 6636 and 6702 @pytest.mark.parametrize( "orc_file", [ "TestOrcFile.boolean_corruption_PR_6636.orc", "TestOrcFile.boolean_corruption_PR_6702.orc", ], ) def test_orc_reader_boolean_type(datadir, orc_file): file_path = datadir / orc_file pdf = pd.read_orc(file_path) df = cudf.read_orc(file_path).to_pandas() assert_eq(pdf, df) def test_orc_reader_tzif_timestamps(datadir): # Contains timstamps in the range covered by the TZif file # Other timedate tests only cover "future" times path = datadir / "TestOrcFile.lima_timezone.orc" try: orcfile = pa.orc.ORCFile(path) except pa.ArrowIOError as e: pytest.skip(".orc file is not found: %s" % e) pdf = orcfile.read().to_pandas() gdf = cudf.read_orc(path).to_pandas() assert_eq(pdf, gdf) def test_int_overflow(tmpdir): file_path = tmpdir.join("gdf_overflow.orc") # The number of rows and the large element trigger delta encoding num_rows = 513 df = cudf.DataFrame({"a": [None] * num_rows}, dtype="int32") df["a"][0] = 1024 * 1024 * 1024 df["a"][num_rows - 1] = 1 df.to_orc(file_path) assert_eq(cudf.read_orc(file_path), df) def normalized_equals(value1, value2): if isinstance(value1, (datetime.datetime, np.datetime64)): value1 = np.datetime64(value1, "ms") if isinstance(value2, (datetime.datetime, np.datetime64)): value2 = np.datetime64(value2, "ms") # Compare integers with floats now if isinstance(value1, float) or isinstance(value2, float): return np.isclose(value1, value2) return value1 == value2 @pytest.mark.parametrize("nrows", [1, 100, 6000000]) def test_orc_write_statistics(tmpdir, datadir, nrows): supported_stat_types = supported_numpy_dtypes + ["str"] # Can't write random bool columns until issue #6763 is fixed if nrows == 6000000: supported_stat_types.remove("bool") # Make a dataframe gdf = cudf.DataFrame( { "col_" + str(dtype): gen_rand_series(dtype, nrows, has_nulls=True) for dtype in supported_stat_types } ) fname = tmpdir.join("gdf.orc") # Write said dataframe to ORC with cuDF gdf.to_orc(fname.strpath) # Read back written ORC's statistics orc_file = pa.orc.ORCFile(fname) (file_stats, stripes_stats,) = cudf.io.orc.read_orc_statistics([fname]) # check file stats for col in gdf: if "minimum" in file_stats[0][col]: stats_min = file_stats[0][col]["minimum"] actual_min = gdf[col].min() assert normalized_equals(actual_min, stats_min) if "maximum" in file_stats[0][col]: stats_max = file_stats[0][col]["maximum"] actual_max = gdf[col].max() assert normalized_equals(actual_max, stats_max) if "number_of_values" in file_stats[0][col]: stats_num_vals = file_stats[0][col]["number_of_values"] actual_num_vals = gdf[col].count() assert stats_num_vals == actual_num_vals # compare stripe statistics with actual min/max for stripe_idx in range(0, orc_file.nstripes): stripe = orc_file.read_stripe(stripe_idx) # pandas is unable to handle min/max of string col with nulls stripe_df = cudf.DataFrame(stripe.to_pandas()) for col in stripe_df: if "minimum" in stripes_stats[stripe_idx][col]: actual_min = stripe_df[col].min() stats_min = stripes_stats[stripe_idx][col]["minimum"] assert normalized_equals(actual_min, stats_min) if "maximum" in stripes_stats[stripe_idx][col]: actual_max = stripe_df[col].max() stats_max = stripes_stats[stripe_idx][col]["maximum"] assert normalized_equals(actual_max, stats_max) if "number_of_values" in stripes_stats[stripe_idx][col]: stats_num_vals = stripes_stats[stripe_idx][col][ "number_of_values" ] actual_num_vals = stripe_df[col].count() assert stats_num_vals == actual_num_vals @pytest.mark.parametrize("nrows", [1, 100, 6000000]) def test_orc_write_bool_statistics(tmpdir, datadir, nrows): # Make a dataframe gdf = cudf.DataFrame({"col_bool": gen_rand_series("bool", nrows)}) fname = tmpdir.join("gdf.orc") # Write said dataframe to ORC with cuDF gdf.to_orc(fname.strpath) # Read back written ORC's statistics orc_file = pa.orc.ORCFile(fname) (file_stats, stripes_stats,) = cudf.io.orc.read_orc_statistics([fname]) # check file stats col = "col_bool" if "true_count" in file_stats[0][col]: stats_true_count = file_stats[0][col]["true_count"] actual_true_count = gdf[col].sum() assert normalized_equals(actual_true_count, stats_true_count) if "number_of_values" in file_stats[0][col]: stats_valid_count = file_stats[0][col]["number_of_values"] actual_valid_count = gdf[col].valid_count assert normalized_equals(actual_valid_count, stats_valid_count) # compare stripe statistics with actual min/max for stripe_idx in range(0, orc_file.nstripes): stripe = orc_file.read_stripe(stripe_idx) # pandas is unable to handle min/max of string col with nulls stripe_df = cudf.DataFrame(stripe.to_pandas()) if "true_count" in stripes_stats[stripe_idx][col]: actual_true_count = stripe_df[col].sum() stats_true_count = stripes_stats[stripe_idx][col]["true_count"] assert normalized_equals(actual_true_count, stats_true_count) if "number_of_values" in stripes_stats[stripe_idx][col]: actual_valid_count = stripe_df[col].valid_count stats_valid_count = stripes_stats[stripe_idx][col][ "number_of_values" ] assert normalized_equals(actual_valid_count, stats_valid_count) def test_orc_reader_gmt_timestamps(datadir): path = datadir / "TestOrcFile.gmt.orc" try: orcfile = pa.orc.ORCFile(path) except pa.ArrowIOError as e: pytest.skip(".orc file is not found: %s" % e) pdf = orcfile.read().to_pandas() gdf = cudf.read_orc(path).to_pandas() assert_eq(pdf, gdf) def test_orc_bool_encode_fail(): np.random.seed(0) buffer = BytesIO() # Generate a boolean column longer than a single stripe fail_df = cudf.DataFrame({"col": gen_rand_series("bool", 600000)}) # Invalidate the first row in the second stripe to break encoding fail_df["col"][500000] = None # Should throw instead of generating a file that is incompatible # with other readers (see issue #6763) with pytest.raises(RuntimeError): fail_df.to_orc(buffer) # Generate a boolean column that fits into a single stripe okay_df = cudf.DataFrame({"col": gen_rand_series("bool", 500000)}) okay_df["col"][500000 - 1] = None # Invalid row is in the last row group of the stripe; # encoding is assumed to be correct okay_df.to_orc(buffer) # Also validate data pdf = pa.orc.ORCFile(buffer).read().to_pandas() assert_eq(okay_df, pdf) def test_nanoseconds_overflow(): buffer = BytesIO() # Use nanosecond values that take more than 32 bits to encode s = cudf.Series([710424008, -1338482640], dtype="datetime64[ns]") expected = cudf.DataFrame({"s": s}) expected.to_orc(buffer) cudf_got = cudf.read_orc(buffer) assert_eq(expected, cudf_got) pyarrow_got = pa.orc.ORCFile(buffer).read() assert_eq(expected.to_pandas(), pyarrow_got.to_pandas()) def test_empty_dataframe(): buffer = BytesIO() expected = cudf.DataFrame() expected.to_orc(buffer) # Raise error if column name is mentioned, but it doesn't exist. with pytest.raises(RuntimeError): cudf.read_orc(buffer, columns=["a"]) got_df = cudf.read_orc(buffer) expected_pdf = pd.read_orc(buffer) assert_eq(expected, got_df) assert_eq(expected_pdf, got_df) @pytest.mark.parametrize( "data", [[None, ""], ["", None], [None, None], ["", ""]] ) def test_empty_string_columns(data): buffer = BytesIO() expected = cudf.DataFrame({"string": data}, dtype="str") expected.to_orc(buffer) expected_pdf = pd.read_orc(buffer) got_df = cudf.read_orc(buffer) assert_eq(expected, got_df) assert_eq(expected_pdf, got_df) @pytest.mark.parametrize("scale", [-3, 0, 3]) def test_orc_writer_decimal(tmpdir, scale): np.random.seed(0) fname = tmpdir / "decimal.orc" expected = cudf.DataFrame({"dec_val": gen_rand_series("i", 100)}) expected["dec_val"] = expected["dec_val"].astype(Decimal64Dtype(7, scale)) expected.to_orc(fname) got = pd.read_orc(fname) assert_eq(expected.to_pandas()["dec_val"], got["dec_val"]) @pytest.mark.parametrize("num_rows", [1, 100, 3000]) def test_orc_reader_multiple_files(datadir, num_rows): path = datadir / "TestOrcFile.testSnappy.orc" df_1 = pd.read_orc(path) df_2 = pd.read_orc(path) df = pd.concat([df_1, df_2], ignore_index=True) gdf = cudf.read_orc([path, path], num_rows=num_rows).to_pandas() # Slice rows out of the whole dataframe for comparison as PyArrow doesn't # have an API to read a subsection of rows from the file df = df[:num_rows] df = df.reset_index(drop=True) assert_eq(df, gdf) def test_orc_reader_multi_file_single_stripe(datadir): path = datadir / "TestOrcFile.testSnappy.orc" # should raise an exception with pytest.raises(ValueError): cudf.read_orc([path, path], stripes=[0]) def test_orc_reader_multi_file_multi_stripe(datadir): path = datadir / "TestOrcFile.testStripeLevelStats.orc" gdf = cudf.read_orc([path, path], stripes=[[0, 1], [2]]) pdf = pd.read_orc(path) assert_eq(pdf, gdf) def test_orc_string_stream_offset_issue(): size = 30000 vals = { str(x): [decimal.Decimal(1)] * size if x != 0 else ["XYZ"] * size for x in range(0, 5) } df = cudf.DataFrame(vals) buffer = BytesIO() df.to_orc(buffer) assert_eq(df, cudf.read_orc(buffer)) # Data is generated using pyorc module def generate_list_struct_buff(size=100_000): rd = random.Random(1) np.random.seed(seed=1) buff = BytesIO() schema = { "lvl3_list": po.Array(po.Array(po.Array(po.BigInt()))), "lvl1_list": po.Array(po.BigInt()), "lvl1_struct": po.Struct(**{"a": po.BigInt(), "b": po.BigInt()}), "lvl2_struct": po.Struct( **{ "a": po.BigInt(), "lvl1_struct": po.Struct( **{"c": po.BigInt(), "d": po.BigInt()} ), } ), "list_nests_struct": po.Array( po.Array(po.Struct(**{"a": po.BigInt(), "b": po.BigInt()})) ), "struct_nests_list": po.Struct( **{ "struct": po.Struct(**{"a": po.BigInt(), "b": po.BigInt()}), "list": po.Array(po.BigInt()), } ), } schema = po.Struct(**schema) lvl3_list = [ rd.choice( [ None, [ [ [ rd.choice([None, np.random.randint(1, 3)]) for z in range(np.random.randint(1, 3)) ] for z in range(np.random.randint(0, 3)) ] for y in range(np.random.randint(0, 3)) ], ] ) for x in range(size) ] lvl1_list = [ [ rd.choice([None, np.random.randint(0, 3)]) for y in range(np.random.randint(1, 4)) ] for x in range(size) ] lvl1_struct = [ rd.choice([None, (np.random.randint(0, 3), np.random.randint(0, 3))]) for x in range(size) ] lvl2_struct = [ rd.choice( [ None, ( rd.choice([None, np.random.randint(0, 3)]), ( rd.choice([None, np.random.randint(0, 3)]), np.random.randint(0, 3), ), ), ] ) for x in range(size) ] list_nests_struct = [ [ [rd.choice(lvl1_struct), rd.choice(lvl1_struct)] for y in range(np.random.randint(1, 4)) ] for x in range(size) ] struct_nests_list = [(lvl1_struct[x], lvl1_list[x]) for x in range(size)] df = pd.DataFrame( { "lvl3_list": lvl3_list, "lvl1_list": lvl1_list, "lvl1_struct": lvl1_struct, "lvl2_struct": lvl2_struct, "list_nests_struct": list_nests_struct, "struct_nests_list": struct_nests_list, } ) writer = po.Writer(buff, schema, stripe_size=1024) tuples = list( map( lambda x: (None,) if x[0] is pd.NA else x, list(df.itertuples(index=False, name=None)), ) ) writer.writerows(tuples) writer.close() return buff @pytest.fixture(scope="module") def list_struct_buff(): return generate_list_struct_buff() @pytest.mark.parametrize( "columns", [ None, ["lvl3_list", "list_nests_struct", "lvl2_struct", "struct_nests_list"], ["lvl2_struct", "lvl1_struct"], ], ) @pytest.mark.parametrize("num_rows", [0, 15, 1005, 10561, 100_000]) @pytest.mark.parametrize("use_index", [True, False]) def test_lists_struct_nests(columns, num_rows, use_index, list_struct_buff): gdf = cudf.read_orc( list_struct_buff, columns=columns, num_rows=num_rows, use_index=use_index, ) pyarrow_tbl = pyarrow.orc.ORCFile(list_struct_buff).read() pyarrow_tbl = ( pyarrow_tbl[:num_rows] if columns is None else pyarrow_tbl.select(columns)[:num_rows] ) if num_rows > 0: assert pyarrow_tbl.equals(gdf.to_arrow()) else: assert_eq(pyarrow_tbl.to_pandas(), gdf) @pytest.mark.parametrize("columns", [None, ["lvl1_struct"], ["lvl1_list"]]) def test_skip_rows_for_nested_types(columns, list_struct_buff): with pytest.raises( RuntimeError, match="skip_rows is not supported by nested column" ): cudf.read_orc( list_struct_buff, columns=columns, use_index=True, skiprows=5, ) def test_pyspark_struct(datadir): path = datadir / "TestOrcFile.testPySparkStruct.orc" pdf = pa.orc.ORCFile(path).read().to_pandas() gdf = cudf.read_orc(path) assert_eq(pdf, gdf) def gen_map_buff(size=10000): from string import ascii_letters as al rd = random.Random(1) np.random.seed(seed=1) buff = BytesIO() schema = { "lvl1_map": po.Map(key=po.String(), value=po.BigInt()), "lvl2_map": po.Map(key=po.String(), value=po.Array(po.BigInt())), "lvl2_struct_map": po.Map( key=po.String(), value=po.Struct(**{"a": po.BigInt(), "b": po.BigInt()}), ), } schema = po.Struct(**schema) lvl1_map = [ rd.choice( [ None, [ ( rd.choice(al), rd.choice([None, np.random.randint(1, 1500)]), ) for y in range(2) ], ] ) for x in range(size) ] lvl2_map = [ rd.choice( [ None, [ ( rd.choice(al), rd.choice( [ None, [ rd.choice( [None, np.random.randint(1, 1500)] ) for z in range(5) ], ] ), ) for y in range(2) ], ] ) for x in range(size) ] lvl2_struct_map = [ rd.choice( [ None, [ ( rd.choice(al), rd.choice( [ None, ( rd.choice( [None, np.random.randint(1, 1500)] ), rd.choice( [None, np.random.randint(1, 1500)] ), ), ] ), ) for y in range(2) ], ] ) for x in range(size) ] pdf = pd.DataFrame( { "lvl1_map": lvl1_map, "lvl2_map": lvl2_map, "lvl2_struct_map": lvl2_struct_map, } ) writer = po.Writer( buff, schema, stripe_size=1024, compression=po.CompressionKind.NONE ) tuples = list( map( lambda x: (None,) if x[0] is pd.NA else x, list(pdf.itertuples(index=False, name=None)), ) ) writer.writerows(tuples) writer.close() return buff map_buff = gen_map_buff(size=100000) @pytest.mark.parametrize( "columns", [None, ["lvl1_map", "lvl2_struct_map"], ["lvl2_struct_map", "lvl2_map"]], ) @pytest.mark.parametrize("num_rows", [0, 15, 1005, 10561, 100000]) @pytest.mark.parametrize("use_index", [True, False]) def test_map_type_read(columns, num_rows, use_index): tbl = pa.orc.ORCFile(map_buff).read() lvl1_map = ( tbl["lvl1_map"] .combine_chunks() .view(pa.list_(pa.struct({"key": pa.string(), "value": pa.int64()}))) ) lvl2_map = ( tbl["lvl2_map"] .combine_chunks() .view( pa.list_( pa.struct({"key": pa.string(), "value": pa.list_(pa.int64())}) ) ) ) lvl2_struct_map = ( tbl["lvl2_struct_map"] .combine_chunks() .view( pa.list_( pa.struct( { "key": pa.string(), "value": pa.struct({"a": pa.int64(), "b": pa.int64()}), } ) ) ) ) expected_tbl = pa.table( { "lvl1_map": lvl1_map, "lvl2_map": lvl2_map, "lvl2_struct_map": lvl2_struct_map, } ) gdf = cudf.read_orc( map_buff, columns=columns, num_rows=num_rows, use_index=use_index ) expected_tbl = ( expected_tbl[:num_rows] if columns is None else expected_tbl.select(columns)[:num_rows] ) if num_rows > 0: assert expected_tbl.equals(gdf.to_arrow()) else: assert_eq(expected_tbl.to_pandas(), gdf) @pytest.mark.parametrize( "data", [["_col0"], ["FakeName", "_col0", "TerriblyFakeColumnName"]] ) def test_orc_reader_decimal(datadir, data): path = datadir / "TestOrcFile.decimal.orc" try: orcfile = pa.orc.ORCFile(path) except pa.ArrowIOError as e: pytest.skip(".orc file is not found: %s" % e) pdf = orcfile.read().to_pandas() gdf = cudf.read_orc(path, decimal_cols_as_float=data).to_pandas() # Convert the decimal dtype from PyArrow to float64 for comparison to cuDF # This is because cuDF returns as float64 pdf = pdf.apply(pd.to_numeric) assert_eq(pdf, gdf) @pytest.mark.parametrize("data", [["InvalidColumnName"]]) def test_orc_reader_decimal_invalid_column(datadir, data): path = datadir / "TestOrcFile.decimal.orc" try: orcfile = pa.orc.ORCFile(path) except pa.ArrowIOError as e: pytest.skip(".orc file is not found: %s" % e) pdf = orcfile.read().to_pandas() gdf = cudf.read_orc(path, decimal_cols_as_float=data).to_pandas() # Since the `decimal_cols_as_float` column name # is invalid, this should be a decimal assert_eq(pdf, gdf) # This test case validates the issue raised in #8665, # please check the issue for more details. def test_orc_timestamp_read(datadir): path = datadir / "TestOrcFile.timestamp.issue.orc" pdf = pd.read_orc(path) gdf = cudf.read_orc(path) assert_eq(pdf, gdf) def dec(num): return decimal.Decimal(str(num)) @pytest.mark.parametrize( "data", [ # basic + nested strings { "lls": [[["a"], ["bb"]] * 5 for i in range(12345)], "lls2": [[["ccc", "dddd"]] * 6 for i in range(12345)], "ls_dict": [["X"] * 7 for i in range(12345)], "ls_direct": [[str(i)] * 9 for i in range(12345)], "li": [[i] * 11 for i in range(12345)], "lf": [[i * 0.5] * 13 for i in range(12345)], "ld": [[dec(i / 2)] * 15 for i in range(12345)], }, # with nulls { "ls": [ [str(i) if i % 5 else None, str(2 * i)] if i % 2 else None for i in range(12345) ], "li": [[i, i * i, i % 2] if i % 3 else None for i in range(12345)], "ld": [ [dec(i), dec(i / 2) if i % 7 else None] if i % 5 else None for i in range(12345) ], }, # with empty elements { "ls": [ [str(i), str(2 * i)] if i % 2 else [] for i in range(12345) ], "lls": [ [[str(i), str(2 * i)]] if i % 2 else [[], []] for i in range(12345) ], "li": [[i, i * i, i % 2] if i % 3 else [] for i in range(12345)], "lli": [ [[i], [i * i], [i % 2]] if i % 3 else [[]] for i in range(12345) ], "ld": [ [dec(i), dec(i / 2)] if i % 5 else [] for i in range(12345) ], }, # variable list lengths { "ls": [[str(i)] * i for i in range(123)], "li": [[i, i * i] * i for i in range(123)], "ld": [[dec(i), dec(i / 2)] * i for i in range(123)], }, # many child elements (more that max_stripe_rows) {"li": [[i] * 1100 for i in range(11000)]}, ], ) def test_orc_writer_lists(data): pdf_in = pd.DataFrame(data) buffer = BytesIO() cudf.from_pandas(pdf_in).to_orc( buffer, stripe_size_rows=2048, row_index_stride=512 ) pdf_out = pa.orc.ORCFile(buffer).read().to_pandas() assert_eq(pdf_out, pdf_in) def test_chunked_orc_writer_lists(): num_rows = 12345 pdf_in = pd.DataFrame( { "ls": [[str(i), str(2 * i)] for i in range(num_rows)], "ld": [[dec(i / 2)] * 5 for i in range(num_rows)], } ) gdf = cudf.from_pandas(pdf_in) expect =
pd.concat([pdf_in, pdf_in])
pandas.concat
import numpy as np import pytest import pandas.util._test_decorators as td from pandas import ( Categorical, DataFrame, DatetimeIndex, NaT, PeriodIndex, Series, TimedeltaIndex, Timestamp, date_range, ) import pandas._testing as tm from pandas.tests.frame.common import _check_mixed_float class TestFillNA: def test_fillna_datetime(self, datetime_frame): tf = datetime_frame tf.loc[tf.index[:5], "A"] = np.nan tf.loc[tf.index[-5:], "A"] = np.nan zero_filled = datetime_frame.fillna(0) assert (zero_filled.loc[zero_filled.index[:5], "A"] == 0).all() padded = datetime_frame.fillna(method="pad") assert np.isnan(padded.loc[padded.index[:5], "A"]).all() assert ( padded.loc[padded.index[-5:], "A"] == padded.loc[padded.index[-5], "A"] ).all() msg = "Must specify a fill 'value' or 'method'" with pytest.raises(ValueError, match=msg): datetime_frame.fillna() msg = "Cannot specify both 'value' and 'method'" with pytest.raises(ValueError, match=msg): datetime_frame.fillna(5, method="ffill") def test_fillna_mixed_type(self, float_string_frame): mf = float_string_frame mf.loc[mf.index[5:20], "foo"] = np.nan mf.loc[mf.index[-10:], "A"] = np.nan # TODO: make stronger assertion here, GH 25640 mf.fillna(value=0) mf.fillna(method="pad") def test_fillna_mixed_float(self, mixed_float_frame): # mixed numeric (but no float16) mf = mixed_float_frame.reindex(columns=["A", "B", "D"]) mf.loc[mf.index[-10:], "A"] = np.nan result = mf.fillna(value=0) _check_mixed_float(result, dtype={"C": None}) result = mf.fillna(method="pad") _check_mixed_float(result, dtype={"C": None}) def test_fillna_empty(self): # empty frame (GH#2778) df = DataFrame(columns=["x"]) for m in ["pad", "backfill"]: df.x.fillna(method=m, inplace=True) df.x.fillna(method=m) def test_fillna_different_dtype(self): # with different dtype (GH#3386) df = DataFrame( [["a", "a", np.nan, "a"], ["b", "b", np.nan, "b"], ["c", "c", np.nan, "c"]] ) result = df.fillna({2: "foo"}) expected = DataFrame( [["a", "a", "foo", "a"], ["b", "b", "foo", "b"], ["c", "c", "foo", "c"]] ) tm.assert_frame_equal(result, expected) return_value = df.fillna({2: "foo"}, inplace=True) tm.assert_frame_equal(df, expected) assert return_value is None def test_fillna_limit_and_value(self): # limit and value df = DataFrame(np.random.randn(10, 3)) df.iloc[2:7, 0] = np.nan df.iloc[3:5, 2] = np.nan expected = df.copy() expected.iloc[2, 0] = 999 expected.iloc[3, 2] = 999 result = df.fillna(999, limit=1) tm.assert_frame_equal(result, expected) def test_fillna_datelike(self): # with datelike # GH#6344 df = DataFrame( { "Date": [NaT, Timestamp("2014-1-1")], "Date2": [Timestamp("2013-1-1"), NaT], } ) expected = df.copy() expected["Date"] = expected["Date"].fillna(df.loc[df.index[0], "Date2"]) result = df.fillna(value={"Date": df["Date2"]}) tm.assert_frame_equal(result, expected) def test_fillna_tzaware(self): # with timezone # GH#15855 df = DataFrame({"A": [Timestamp("2012-11-11 00:00:00+01:00"), NaT]}) exp = DataFrame( { "A": [ Timestamp("2012-11-11 00:00:00+01:00"), Timestamp("2012-11-11 00:00:00+01:00"), ] } ) tm.assert_frame_equal(df.fillna(method="pad"), exp) df = DataFrame({"A": [NaT, Timestamp("2012-11-11 00:00:00+01:00")]}) exp = DataFrame( { "A": [ Timestamp("2012-11-11 00:00:00+01:00"), Timestamp("2012-11-11 00:00:00+01:00"), ] } ) tm.assert_frame_equal(df.fillna(method="bfill"), exp) def test_fillna_tzaware_different_column(self): # with timezone in another column # GH#15522 df = DataFrame( { "A": date_range("20130101", periods=4, tz="US/Eastern"), "B": [1, 2, np.nan, np.nan], } ) result = df.fillna(method="pad") expected = DataFrame( { "A": date_range("20130101", periods=4, tz="US/Eastern"), "B": [1.0, 2.0, 2.0, 2.0], } ) tm.assert_frame_equal(result, expected) def test_na_actions_categorical(self): cat = Categorical([1, 2, 3, np.nan], categories=[1, 2, 3]) vals = ["a", "b", np.nan, "d"] df = DataFrame({"cats": cat, "vals": vals}) cat2 = Categorical([1, 2, 3, 3], categories=[1, 2, 3]) vals2 = ["a", "b", "b", "d"] df_exp_fill = DataFrame({"cats": cat2, "vals": vals2}) cat3 =
Categorical([1, 2, 3], categories=[1, 2, 3])
pandas.Categorical
#!/usr/bin/env python3 import pytest import os import pathlib import pandas as pd import numpy as np import matplotlib.pyplot as plt import logging import math import torch from neuralprophet import NeuralProphet, set_random_seed from neuralprophet import df_utils log = logging.getLogger("NP.test") log.setLevel("WARNING") log.parent.setLevel("WARNING") DIR = pathlib.Path(__file__).parent.parent.absolute() DATA_DIR = os.path.join(DIR, "tests", "test-data") PEYTON_FILE = os.path.join(DATA_DIR, "wp_log_peyton_manning.csv") AIR_FILE = os.path.join(DATA_DIR, "air_passengers.csv") YOS_FILE = os.path.join(DATA_DIR, "yosemite_temps.csv") NROWS = 256 EPOCHS = 2 BATCH_SIZE = 64 LR = 1.0 PLOT = False def test_names(): log.info("testing: names") m = NeuralProphet() m._validate_column_name("hello_friend") def test_train_eval_test(): log.info("testing: Train Eval Test") m = NeuralProphet( n_lags=10, n_forecasts=3, ar_sparsity=0.1, epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=LR, ) df = pd.read_csv(PEYTON_FILE, nrows=95) df = df_utils.check_dataframe(df, check_y=False) df = m._handle_missing_data(df, freq="D", predicting=False) df_train, df_test = m.split_df(df, freq="D", valid_p=0.1) metrics = m.fit(df_train, freq="D", validation_df=df_test) val_metrics = m.test(df_test) log.debug("Metrics: train/eval: \n {}".format(metrics.to_string(float_format=lambda x: "{:6.3f}".format(x)))) log.debug("Metrics: test: \n {}".format(val_metrics.to_string(float_format=lambda x: "{:6.3f}".format(x)))) def test_df_utils_func(): log.info("testing: df_utils Test") df = pd.read_csv(PEYTON_FILE, nrows=95) df = df_utils.check_dataframe(df, check_y=False) # test find_time_threshold df_dict, _ = df_utils.prep_copy_df_dict(df) time_threshold = df_utils.find_time_threshold(df_dict, n_lags=2, valid_p=0.2, inputs_overbleed=True) df_train, df_val = df_utils.split_considering_timestamp( df_dict, n_lags=2, n_forecasts=2, inputs_overbleed=True, threshold_time_stamp=time_threshold ) # init data params with a list global_data_params = df_utils.init_data_params(df_dict, normalize="soft") global_data_params = df_utils.init_data_params(df_dict, normalize="soft1") global_data_params = df_utils.init_data_params(df_dict, normalize="standardize") log.debug("Time Threshold: \n {}".format(time_threshold)) log.debug("Df_train: \n {}".format(type(df_train))) log.debug("Df_val: \n {}".format(type(df_val))) def test_trend(): log.info("testing: Trend") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) m = NeuralProphet( growth="linear", n_changepoints=10, changepoints_range=0.9, trend_reg=1, trend_reg_threshold=False, yearly_seasonality=False, weekly_seasonality=False, daily_seasonality=False, epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=LR, ) # print(m.config_trend) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, periods=60, n_historic_predictions=60) forecast = m.predict(df=future) if PLOT: m.plot(forecast) # m.plot_components(forecast) m.plot_parameters() plt.show() def test_custom_changepoints(): log.info("testing: Custom Changepoints") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) dates = df["ds"][range(1, len(df) - 1, int(len(df) / 5.0))] dates_list = [str(d) for d in dates] dates_array = pd.to_datetime(dates_list).values log.debug("dates: {}".format(dates)) log.debug("dates_list: {}".format(dates_list)) log.debug("dates_array: {} {}".format(dates_array.dtype, dates_array)) for cp in [dates_list, dates_array]: m = NeuralProphet( changepoints=cp, yearly_seasonality=False, weekly_seasonality=False, daily_seasonality=False, epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=LR, ) # print(m.config_trend) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, periods=60, n_historic_predictions=60) forecast = m.predict(df=future) if PLOT: # m.plot(forecast) # m.plot_components(forecast) m.plot_parameters() plt.show() def test_no_trend(): log.info("testing: No-Trend") df = pd.read_csv(PEYTON_FILE, nrows=512) m = NeuralProphet( growth="off", yearly_seasonality=False, weekly_seasonality=False, daily_seasonality=False, epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=LR, ) # m.highlight_nth_step_ahead_of_each_forecast(m.n_forecasts) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, periods=60, n_historic_predictions=60) forecast = m.predict(df=future) if PLOT: m.plot(forecast) m.plot_components(forecast) m.plot_parameters() plt.show() def test_seasons(): log.info("testing: Seasonality: additive") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) m = NeuralProphet( yearly_seasonality=8, weekly_seasonality=4, seasonality_mode="additive", seasonality_reg=1, epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=LR, ) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, n_historic_predictions=365, periods=365) forecast = m.predict(df=future) log.debug("SUM of yearly season params: {}".format(sum(abs(m.model.season_params["yearly"].data.numpy())))) log.debug("SUM of weekly season params: {}".format(sum(abs(m.model.season_params["weekly"].data.numpy())))) log.debug("season params: {}".format(m.model.season_params.items())) if PLOT: m.plot(forecast) # m.plot_components(forecast) m.plot_parameters() plt.show() log.info("testing: Seasonality: multiplicative") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) # m = NeuralProphet(n_lags=60, n_changepoints=10, n_forecasts=30, verbose=True) m = NeuralProphet( yearly_seasonality=8, weekly_seasonality=4, seasonality_mode="multiplicative", epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=LR, ) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, n_historic_predictions=365, periods=365) forecast = m.predict(df=future) def test_custom_seasons(): log.info("testing: Custom Seasonality") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) other_seasons = False m = NeuralProphet( yearly_seasonality=other_seasons, weekly_seasonality=other_seasons, daily_seasonality=other_seasons, seasonality_mode="additive", # seasonality_mode="multiplicative", seasonality_reg=1, epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=LR, ) m = m.add_seasonality(name="quarterly", period=90, fourier_order=5) log.debug("seasonalities: {}".format(m.season_config.periods)) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, n_historic_predictions=365, periods=365) forecast = m.predict(df=future) log.debug("season params: {}".format(m.model.season_params.items())) if PLOT: m.plot(forecast) # m.plot_components(forecast) m.plot_parameters() plt.show() def test_ar(): log.info("testing: AR") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) m = NeuralProphet( n_forecasts=7, n_lags=7, yearly_seasonality=False, epochs=EPOCHS, # batch_size=BATCH_SIZE, learning_rate=LR, ) m.highlight_nth_step_ahead_of_each_forecast(m.n_forecasts) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, n_historic_predictions=90) forecast = m.predict(df=future) if PLOT: m.plot_last_forecast(forecast, include_previous_forecasts=3) m.plot(forecast) m.plot_components(forecast) m.plot_parameters() plt.show() def test_ar_sparse(): log.info("testing: AR (sparse") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) m = NeuralProphet( n_forecasts=3, n_lags=14, ar_sparsity=0.5, yearly_seasonality=False, epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=LR, ) m.highlight_nth_step_ahead_of_each_forecast(m.n_forecasts) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, n_historic_predictions=90) forecast = m.predict(df=future) if PLOT: m.plot_last_forecast(forecast, include_previous_forecasts=3) m.plot(forecast) m.plot_components(forecast) m.plot_parameters() plt.show() def test_ar_deep(): log.info("testing: AR-Net (deep)") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) m = NeuralProphet( n_forecasts=7, n_lags=14, num_hidden_layers=2, d_hidden=32, yearly_seasonality=False, weekly_seasonality=False, daily_seasonality=False, epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=LR, ) m.highlight_nth_step_ahead_of_each_forecast(m.n_forecasts) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, n_historic_predictions=90) forecast = m.predict(df=future) if PLOT: m.plot_last_forecast(forecast, include_previous_forecasts=3) m.plot(forecast) m.plot_components(forecast) m.plot_parameters() plt.show() def test_lag_reg(): log.info("testing: Lagged Regressors") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) m = NeuralProphet( n_forecasts=2, n_lags=3, weekly_seasonality=False, daily_seasonality=False, epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=LR, ) df["A"] = df["y"].rolling(7, min_periods=1).mean() df["B"] = df["y"].rolling(30, min_periods=1).mean() m = m.add_lagged_regressor(names="A") m = m.add_lagged_regressor(names="B", only_last_value=True) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, n_historic_predictions=10) forecast = m.predict(future) if PLOT: print(forecast.to_string()) m.plot_last_forecast(forecast, include_previous_forecasts=5) m.plot(forecast) m.plot_components(forecast) m.plot_parameters() plt.show() def test_lag_reg_deep(): log.info("testing: List of Lagged Regressors (deep)") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) m = NeuralProphet( n_forecasts=1, n_lags=14, num_hidden_layers=2, d_hidden=32, weekly_seasonality=False, daily_seasonality=False, epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=LR, ) df["A"] = df["y"].rolling(7, min_periods=1).mean() df["B"] = df["y"].rolling(15, min_periods=1).mean() df["C"] = df["y"].rolling(30, min_periods=1).mean() cols = [col for col in df.columns if col not in ["ds", "y"]] m = m.add_lagged_regressor(names=cols) m.highlight_nth_step_ahead_of_each_forecast(m.n_forecasts) metrics_df = m.fit(df, freq="D") forecast = m.predict(df) if PLOT: # print(forecast.to_string()) # m.plot_last_forecast(forecast, include_previous_forecasts=10) # m.plot(forecast) # m.plot_components(forecast) m.plot_parameters() plt.show() def test_events(): log.info("testing: Events") df = pd.read_csv(PEYTON_FILE)[-NROWS:] playoffs = pd.DataFrame( { "event": "playoff", "ds": pd.to_datetime( [ "2008-01-13", "2009-01-03", "2010-01-16", "2010-01-24", "2010-02-07", "2011-01-08", "2013-01-12", "2014-01-12", "2014-01-19", "2014-02-02", "2015-01-11", "2016-01-17", "2016-01-24", "2016-02-07", ] ), } ) superbowls = pd.DataFrame( { "event": "superbowl", "ds": pd.to_datetime(["2010-02-07", "2014-02-02", "2016-02-07"]), } ) events_df = pd.concat((playoffs, superbowls)) m = NeuralProphet( n_lags=2, n_forecasts=30, daily_seasonality=False, epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=LR, ) # set event windows m = m.add_events( ["superbowl", "playoff"], lower_window=-1, upper_window=1, mode="multiplicative", regularization=0.5 ) # add the country specific holidays m = m.add_country_holidays("US", mode="additive", regularization=0.5) m.add_country_holidays("Indonesia") m.add_country_holidays("Thailand") m.add_country_holidays("Philippines") m.add_country_holidays("Pakistan") m.add_country_holidays("Belarus") history_df = m.create_df_with_events(df, events_df) metrics_df = m.fit(history_df, freq="D") future = m.make_future_dataframe(df=history_df, events_df=events_df, periods=30, n_historic_predictions=90) forecast = m.predict(df=future) log.debug("Event Parameters:: {}".format(m.model.event_params)) if PLOT: m.plot_components(forecast) m.plot(forecast) m.plot_parameters() plt.show() def test_future_reg(): log.info("testing: Future Regressors") df = pd.read_csv(PEYTON_FILE, nrows=NROWS + 50) m = NeuralProphet( epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=LR, ) df["A"] = df["y"].rolling(7, min_periods=1).mean() df["B"] = df["y"].rolling(30, min_periods=1).mean() regressors_df_future = pd.DataFrame(data={"A": df["A"][-50:], "B": df["B"][-50:]}) df = df[:-50] m = m.add_future_regressor(name="A") m = m.add_future_regressor(name="B", mode="multiplicative") metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df=df, regressors_df=regressors_df_future, n_historic_predictions=10, periods=50) forecast = m.predict(df=future) if PLOT: m.plot(forecast) m.plot_components(forecast) m.plot_parameters() plt.show() def test_plot(): log.info("testing: Plotting") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) m = NeuralProphet( n_forecasts=7, n_lags=14, epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=LR, ) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, periods=m.n_forecasts, n_historic_predictions=10) forecast = m.predict(future) m.plot(forecast) m.plot_last_forecast(forecast, include_previous_forecasts=10) m.plot_components(forecast) m.plot_parameters() m.highlight_nth_step_ahead_of_each_forecast(7) forecast = m.predict(df) m.plot(forecast) m.plot_last_forecast(forecast, include_previous_forecasts=10) m.plot_components(forecast) m.plot_parameters() if PLOT: plt.show() def test_air_data(): log.info("TEST air_passengers.csv") df = pd.read_csv(AIR_FILE) m = NeuralProphet( n_changepoints=0, yearly_seasonality=2, seasonality_mode="multiplicative", epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=LR, ) metrics = m.fit(df, freq="MS") future = m.make_future_dataframe(df, periods=48, n_historic_predictions=len(df) - m.n_lags) forecast = m.predict(future) if PLOT: m.plot(forecast) m.plot_components(forecast) m.plot_parameters() plt.show() def test_random_seed(): log.info("TEST random seed") df = pd.read_csv(PEYTON_FILE, nrows=512) set_random_seed(0) m = NeuralProphet( epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=LR, ) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, periods=10, n_historic_predictions=10) forecast = m.predict(future) checksum1 = sum(forecast["yhat1"].values) set_random_seed(0) m = NeuralProphet( epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=LR, ) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, periods=10, n_historic_predictions=10) forecast = m.predict(future) checksum2 = sum(forecast["yhat1"].values) set_random_seed(1) m = NeuralProphet( epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=LR, ) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, periods=10, n_historic_predictions=10) forecast = m.predict(future) checksum3 = sum(forecast["yhat1"].values) log.debug("should be same: {} and {}".format(checksum1, checksum2)) log.debug("should not be same: {} and {}".format(checksum1, checksum3)) assert math.isclose(checksum1, checksum2) assert not math.isclose(checksum1, checksum3) def test_yosemite(): log.info("TEST Yosemite Temps") df = pd.read_csv(YOS_FILE, nrows=NROWS) m = NeuralProphet( changepoints_range=0.95, n_changepoints=15, weekly_seasonality=False, epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=LR, ) metrics = m.fit(df, freq="5min") future = m.make_future_dataframe(df, periods=12 * 24, n_historic_predictions=12 * 24) forecast = m.predict(future) if PLOT: m.plot(forecast) m.plot_parameters() plt.show() def test_model_cv(): log.info("CV from model") def check_simple(df): m = NeuralProphet( learning_rate=LR, ) folds = m.crossvalidation_split_df(df, freq="D", k=5, fold_pct=0.1, fold_overlap_pct=0.5) assert all([70 + i * 5 == len(train) for i, (train, val) in enumerate(folds)]) assert all([10 == len(val) for (train, val) in folds]) def check_cv(df, freq, n_lags, n_forecasts, k, fold_pct, fold_overlap_pct): m = NeuralProphet( n_lags=n_lags, n_forecasts=n_forecasts, learning_rate=LR, ) folds = m.crossvalidation_split_df(df, freq=freq, k=k, fold_pct=fold_pct, fold_overlap_pct=fold_overlap_pct) total_samples = len(df) - m.n_lags + 2 - (2 * m.n_forecasts) per_fold = int(fold_pct * total_samples) not_overlap = per_fold - int(fold_overlap_pct * per_fold) assert all([per_fold == len(val) - m.n_lags + 1 - m.n_forecasts for (train, val) in folds]) assert all( [ total_samples - per_fold - (k - i - 1) * not_overlap == len(train) - m.n_lags + 1 - m.n_forecasts for i, (train, val) in enumerate(folds) ] ) check_simple(pd.DataFrame({"ds": pd.date_range(start="2017-01-01", periods=100), "y": np.arange(100)})) check_cv( df=pd.DataFrame({"ds":
pd.date_range(start="2017-01-01", periods=100)
pandas.date_range
import pandas as pd import numpy as np def groupby_reset(col): colname = "'%s'" % col df = (
pd.groupby([colname])
pandas.groupby
import pandas as pd import sklearn from sklearn.model_selection import train_test_split from pandas import DataFrame class Helper_Functions: def add_columns(self): """ When activated it will add a column into existing dataframe """ df = pd.DataFrame({10, 20, 40, 60, 70, 80, 80, 100, 110, 120}) names = pd.DataFrame({'Mario', 'Sonic', 'Sly', 'Duke', 'Tails', 'Luigi', 'CaptainMak', 'Crash', 'Knuckles', 'Tupac'}) return df def train_validate_test(self): """ Function will split data into train and test sets for machine learning """ df =
pd.DataFrame({10, 20, 40, 60, 70, 80, 80, 100, 110})
pandas.DataFrame
# -*- coding: utf-8 -*- # Copyright (c) 2016-2020 by University of Kassel and Fraunhofer Institute for Energy Economics # and Energy System Technology (IEE), Kassel. All rights reserved. from math import pi from numpy import sign, nan, append, zeros, array, sqrt, where from numpy import max as max_ from pandas import Series, DataFrame, concat from pandapower.pypower.idx_gen import GEN_BUS, PMIN, PMAX, QMIN, QMAX, GEN_STATUS from pandapower.pypower.idx_cost import COST, NCOST from pandapower.pypower.idx_bus import BUS_I, BASE_KV import pandapower as pp try: import pplog as logging except ImportError: import logging logger = logging.getLogger(__name__) try: from pypower import ppoption, runpf, runopf, rundcpf, rundcopf ppopt = ppoption.ppoption(VERBOSE=0, OUT_ALL=0) pypower_import = True except ImportError: pypower_import = False ppc_elms = ["bus", "branch", "gen"] def _create_costs(net, ppc, gen_lookup, type, idx): if ppc['gencost'][idx, 0] == 1: if not len(ppc['gencost'][idx, COST:]) == 2*ppc['gencost'][idx, NCOST]: logger.error("In gencost line %s, the number n does not fit to the number of values" % idx) raise NotImplementedError pp.create_pwl_cost(net, gen_lookup.element.at[idx], gen_lookup.element_type.at[idx], ppc['gencost'][idx, 4:], type) elif ppc['gencost'][idx, 0] == 2: ncost = ppc['gencost'][idx, NCOST] if ncost == 2: cp2 = 0 cp1 = ppc['gencost'][idx, COST] cp0 = ppc['gencost'][idx, COST + 1] elif ncost == 3: cp2 = ppc['gencost'][idx, COST] cp1 = ppc['gencost'][idx, COST + 1] cp0 = ppc['gencost'][idx, COST + 2] pp.create_poly_cost(net, gen_lookup.element.at[idx], gen_lookup.element_type.at[idx], cp1_eur_per_mw=cp1, cp2_eur_per_mw2=cp2, cp0_eur=cp0) else: logger.info("Cost mode of gencost line %s is unknown." % idx) def _gen_bus_info(ppc, idx_gen): bus_name = int(ppc["gen"][idx_gen, GEN_BUS]) # assumption: there is only one bus with this bus_name: idx_bus = int(where(ppc["bus"][:, BUS_I] == bus_name)[0][0]) current_bus_type = int(ppc["bus"][idx_bus, 1]) same_bus_gen_idx = where(ppc["gen"][:, GEN_BUS] == ppc["gen"][idx_gen, GEN_BUS])[0].astype(int) same_bus_in_service_gen_idx = same_bus_gen_idx[where(ppc["gen"][same_bus_gen_idx, GEN_STATUS] > 0)] first_same_bus_in_service_gen_idx = same_bus_in_service_gen_idx[0] if len( same_bus_in_service_gen_idx) else None last_same_bus_in_service_gen_idx = same_bus_in_service_gen_idx[-1] if len( same_bus_in_service_gen_idx) else None return current_bus_type, idx_bus, same_bus_gen_idx, first_same_bus_in_service_gen_idx, \ last_same_bus_in_service_gen_idx def from_ppc(ppc, f_hz=50, validate_conversion=False, **kwargs): """ This function converts pypower case files to pandapower net structure. INPUT: **ppc** : The pypower case file. OPTIONAL: **f_hz** (float, 50) - The frequency of the network. **validate_conversion** (bool, False) - If True, validate_from_ppc is run after conversion. For running the validation, the ppc must already contain the pypower powerflow results or pypower must be importable. ****kwargs** keyword arguments for validate_from_ppc if validate_conversion is True OUTPUT: **net** : pandapower net. EXAMPLE: import pandapower.converter as pc from pypower import case4gs ppc_net = case4gs.case4gs() net = pc.from_ppc(ppc_net, f_hz=60) """ # --- catch common failures if Series(ppc['bus'][:, BASE_KV] <= 0).any(): logger.info('There are false baseKV given in the pypower case file.') # --- general_parameters baseMVA = ppc['baseMVA'] # MVA omega = pi * f_hz # 1/s MAX_VAL = 99999. net = pp.create_empty_network(f_hz=f_hz, sn_mva=baseMVA) # --- bus data -> create buses, sgen, load, shunt for i in range(len(ppc['bus'])): # create buses pp.create_bus(net, name=int(ppc['bus'][i, 0]), vn_kv=ppc['bus'][i, 9], type="b", zone=ppc['bus'][i, 10], in_service=bool(ppc['bus'][i, 1] != 4), max_vm_pu=ppc['bus'][i, 11], min_vm_pu=ppc['bus'][i, 12]) # create sgen, load if ppc['bus'][i, 2] > 0: pp.create_load(net, i, p_mw=ppc['bus'][i, 2], q_mvar=ppc['bus'][i, 3], controllable=False) elif ppc['bus'][i, 2] < 0: pp.create_sgen(net, i, p_mw=-ppc['bus'][i, 2], q_mvar=-ppc['bus'][i, 3], type="", controllable=False) elif ppc['bus'][i, 3] != 0: pp.create_load(net, i, p_mw=ppc['bus'][i, 2], q_mvar=ppc['bus'][i, 3], controllable=False) # create shunt if ppc['bus'][i, 4] != 0 or ppc['bus'][i, 5] != 0: pp.create_shunt(net, i, p_mw=ppc['bus'][i, 4], q_mvar=-ppc['bus'][i, 5]) # unused data of ppc: Vm, Va (partwise: in ext_grid), zone # --- gen data -> create ext_grid, gen, sgen gen_lookup = DataFrame(nan, columns=['element', 'element_type'], index=range(len(ppc['gen'][:, 0]))) # if in ppc is only one gen -> numpy initially uses one dim array -> change to two dim array if len(ppc["gen"].shape) == 1: ppc["gen"] = array(ppc["gen"], ndmin=2) for i in range(len(ppc['gen'][:, 0])): current_bus_type, current_bus_idx, same_bus_gen_idx, first_same_bus_in_service_gen_idx, \ last_same_bus_in_service_gen_idx = _gen_bus_info(ppc, i) # create ext_grid if current_bus_type == 3: if i == first_same_bus_in_service_gen_idx: gen_lookup.element.loc[i] = pp.create_ext_grid( net, bus=current_bus_idx, vm_pu=ppc['gen'][last_same_bus_in_service_gen_idx, 5], va_degree=ppc['bus'][current_bus_idx, 8], in_service=bool(ppc['gen'][i, 7] > 0), max_p_mw=ppc['gen'][i, PMAX], min_p_mw=ppc['gen'][i, PMIN], max_q_mvar=ppc['gen'][i, QMAX], min_q_mvar=ppc['gen'][i, QMIN]) gen_lookup.element_type.loc[i] = 'ext_grid' if ppc['gen'][i, 4] > ppc['gen'][i, 3]: logger.info('min_q_mvar of gen %d must be less than max_q_mvar but is not.' % i) if -ppc['gen'][i, 9] < -ppc['gen'][i, 8]: logger.info('max_p_mw of gen %d must be less than min_p_mw but is not.' % i) else: current_bus_type = 1 # create gen elif current_bus_type == 2: if i == first_same_bus_in_service_gen_idx: gen_lookup.element.loc[i] = pp.create_gen( net, bus=current_bus_idx, vm_pu=ppc['gen'][last_same_bus_in_service_gen_idx, 5], p_mw=ppc['gen'][i, 1], in_service=bool(ppc['gen'][i, 7] > 0), controllable=True, max_p_mw=ppc['gen'][i, PMAX], min_p_mw=ppc['gen'][i, PMIN], max_q_mvar=ppc['gen'][i, QMAX], min_q_mvar=ppc['gen'][i, QMIN]) gen_lookup.element_type.loc[i] = 'gen' if ppc['gen'][i, 1] < 0: logger.info('p_mw of gen %d must be less than zero but is not.' % i) if ppc['gen'][i, 4] > ppc['gen'][i, 3]: logger.info('min_q_mvar of gen %d must be less than max_q_mvar but is not.' % i) if -ppc['gen'][i, 9] < -ppc['gen'][i, 8]: logger.info('max_p_mw of gen %d must be less than min_p_mw but is not.' % i) else: current_bus_type = 1 # create sgen if current_bus_type == 1: gen_lookup.element.loc[i] = pp.create_sgen( net, bus=current_bus_idx, p_mw=ppc['gen'][i, 1], q_mvar=ppc['gen'][i, 2], type="", in_service=bool(ppc['gen'][i, 7] > 0), max_p_mw=ppc['gen'][i, PMAX], min_p_mw=ppc['gen'][i, PMIN], max_q_mvar=ppc['gen'][i, QMAX], min_q_mvar=ppc['gen'][i, QMIN], controllable=True) gen_lookup.element_type.loc[i] = 'sgen' if ppc['gen'][i, 1] < 0: logger.info('p_mw of sgen %d must be less than zero but is not.' % i) if ppc['gen'][i, 4] > ppc['gen'][i, 3]: logger.info('min_q_mvar of gen %d must be less than max_q_mvar but is not.' % i) if -ppc['gen'][i, 9] < -ppc['gen'][i, 8]: logger.info('max_p_mw of gen %d must be less than min_p_mw but is not.' % i) # unused data of ppc: Vg (partwise: in ext_grid and gen), mBase, Pc1, Pc2, Qc1min, Qc1max, # Qc2min, Qc2max, ramp_agc, ramp_10, ramp_30,ramp_q, apf # --- branch data -> create line, trafo for i in range(len(ppc['branch'])): from_bus = pp.get_element_index(net, 'bus', name=int(ppc['branch'][i, 0])) to_bus = pp.get_element_index(net, 'bus', name=int(ppc['branch'][i, 1])) from_vn_kv = ppc['bus'][from_bus, 9] to_vn_kv = ppc['bus'][to_bus, 9] if (from_vn_kv == to_vn_kv) & ((ppc['branch'][i, 8] == 0) | (ppc['branch'][i, 8] == 1)) & \ (ppc['branch'][i, 9] == 0): # create line Zni = ppc['bus'][to_bus, 9]**2/baseMVA # ohm max_i_ka = ppc['branch'][i, 5]/ppc['bus'][to_bus, 9]/sqrt(3) if max_i_ka == 0.0: max_i_ka = MAX_VAL logger.debug("ppc branch rateA is zero -> Using MAX_VAL instead to calculate " + "maximum branch flow") pp.create_line_from_parameters( net, from_bus=from_bus, to_bus=to_bus, length_km=1, r_ohm_per_km=ppc['branch'][i, 2]*Zni, x_ohm_per_km=ppc['branch'][i, 3]*Zni, c_nf_per_km=ppc['branch'][i, 4]/Zni/omega*1e9/2, max_i_ka=max_i_ka, type='ol', max_loading_percent=100, in_service=bool(ppc['branch'][i, 10])) else: # create transformer if from_vn_kv >= to_vn_kv: hv_bus = from_bus vn_hv_kv = from_vn_kv lv_bus = to_bus vn_lv_kv = to_vn_kv tap_side = 'hv' else: hv_bus = to_bus vn_hv_kv = to_vn_kv lv_bus = from_bus vn_lv_kv = from_vn_kv tap_side = 'lv' if from_vn_kv == to_vn_kv: logger.warning('The pypower branch %d (from_bus, to_bus)=(%d, %d) is considered' ' as a transformer because of a ratio != 0 | 1 but it connects ' 'the same voltage level', i, ppc['branch'][i, 0], ppc['branch'][i, 1]) rk = ppc['branch'][i, 2] xk = ppc['branch'][i, 3] zk = (rk ** 2 + xk ** 2) ** 0.5 sn = ppc['branch'][i, 5] if sn == 0.0: sn = MAX_VAL logger.debug("ppc branch rateA is zero -> Using MAX_VAL instead to calculate " + "apparent power") ratio_1 = 0 if ppc['branch'][i, 8] == 0 else (ppc['branch'][i, 8] - 1) * 100 i0_percent = -ppc['branch'][i, 4] * 100 * baseMVA / sn if i0_percent < 0: logger.info('A transformer always behaves inductive consumpting but the ' 'susceptance of pypower branch %d (from_bus, to_bus)=(%d, %d) is ' 'positive.', i, ppc['branch'][i, 0], ppc['branch'][i, 1]) pp.create_transformer_from_parameters( net, hv_bus=hv_bus, lv_bus=lv_bus, sn_mva=sn, vn_hv_kv=vn_hv_kv, vn_lv_kv=vn_lv_kv, vk_percent=sign(xk) * zk * sn * 100 / baseMVA, vkr_percent=rk * sn * 100 / baseMVA, max_loading_percent=100, pfe_kw=0, i0_percent=i0_percent, shift_degree=ppc['branch'][i, 9], tap_step_percent=abs(ratio_1) if ratio_1 else nan, tap_pos=sign(ratio_1) if ratio_1 else nan, tap_side=tap_side if ratio_1 else None, tap_neutral=0 if ratio_1 else nan) # unused data of ppc: rateB, rateC # --- gencost -> create polynomial_cost, piecewise_cost if 'gencost' in ppc: if len(ppc['gencost'].shape) == 1: # reshape gencost if only one gencost is given -> no indexError ppc['gencost'] = ppc['gencost'].reshape((1, -1)) if ppc['gencost'].shape[0] <= gen_lookup.shape[0]: idx_p = range(ppc['gencost'].shape[0]) idx_q = [] elif ppc['gencost'].shape[0] > gen_lookup.shape[0]: idx_p = range(gen_lookup.shape[0]) idx_q = range(gen_lookup.shape[0], ppc['gencost'].shape[0]) if ppc['gencost'].shape[0] >= 2*gen_lookup.shape[0]: idx_p = range(gen_lookup.shape[0]) idx_q = range(gen_lookup.shape[0], 2*gen_lookup.shape[0]) for idx in idx_p: _create_costs(net, ppc, gen_lookup, 'p', idx) for idx in idx_q: _create_costs(net, ppc, gen_lookup, 'q', idx) # areas are unconverted if validate_conversion: logger.setLevel(logging.DEBUG) if not validate_from_ppc(ppc, net, **kwargs): logger.error("Validation failed.") return net def _validate_diff_res(diff_res, max_diff_values): to_iterate = set(max_diff_values.keys()) & {'gen_q_mvar', 'branch_p_mw', 'branch_q_mvar', 'gen_p_mw', 'bus_va_degree', 'bus_vm_pu'} if not len(to_iterate): logger.warning("There are no keys to validate.") val = True for i in to_iterate: elm = i.split("_")[0] sought = ["p", "q"] if elm != "bus" else ["vm", "va"] col = int(array([0, 1])[[j in i for j in sought]][0]) if elm != "branch" else \ list(array([[0, 2], [1, 3]])[[j in i for j in sought]][0]) val &= bool(max_(abs(diff_res[elm][:, col])) < max_diff_values[i]) return val def validate_from_ppc(ppc_net, net, pf_type="runpp", max_diff_values={ "bus_vm_pu": 1e-6, "bus_va_degree": 1e-5, "branch_p_mw": 1e-6, "branch_q_mvar": 1e-6, "gen_p_mw": 1e-6, "gen_q_mvar": 1e-6}, run=True): """ This function validates the pypower case files to pandapower net structure conversion via a \ comparison of loadflow calculation results. (Hence the opf cost conversion is not validated.) INPUT: **ppc_net** - The pypower case file, which must already contain the pypower powerflow results or pypower must be importable. **net** - The pandapower network. OPTIONAL: **pf_type** ("runpp", string) - Type of validated power flow. Possible are ("runpp", "rundcpp", "runopp", "rundcopp") **max_diff_values** - Dict of maximal allowed difference values. The keys must be 'vm_pu', 'va_degree', 'p_branch_mw', 'q_branch_mvar', 'p_gen_mw' and 'q_gen_mvar' and the values floats. **run** (True, bool or list of two bools) - changing the value to False avoids trying to run (optimal) loadflows. Giving a list of two bools addresses first pypower and second pandapower. OUTPUT: **conversion_success** - conversion_success is returned as False if pypower or pandapower cannot calculate a powerflow or if the maximum difference values (max_diff_values ) cannot be hold. EXAMPLE: import pandapower.converter as pc net = cv.from_ppc(ppc_net, f_hz=50) conversion_success = cv.validate_from_ppc(ppc_net, net) NOTE: The user has to take care that the loadflow results already are included in the provided \ ppc_net or pypower is importable. """ # check in case of optimal powerflow comparison whether cost information exist if "opp" in pf_type: if not (len(net.polynomial_cost) | len(net.piecewise_linear_cost)): if "gencost" in ppc_net: if not len(ppc_net["gencost"]): logger.debug('ppc and pandapower net do not include cost information.') return True else: logger.error('The pandapower net does not include cost information.') return False else: logger.debug('ppc and pandapower net do not include cost information.') return True # guarantee run parameter as list, for pypower and pandapower (optimal) powerflow run run = [run, run] if isinstance(run, bool) else run # --- check pypower powerflow success, if possible if pypower_import and run[0]: try: if pf_type == "runpp": ppc_net = runpf.runpf(ppc_net, ppopt)[0] elif pf_type == "rundcpp": ppc_net = rundcpf.rundcpf(ppc_net, ppopt)[0] elif pf_type == "runopp": ppc_net = runopf.runopf(ppc_net, ppopt) elif pf_type == "rundcopp": ppc_net = rundcopf.rundcopf(ppc_net, ppopt) else: raise ValueError("The pf_type %s is unknown" % pf_type) except: logger.debug("The pypower run did not work.") ppc_success = True if 'success' in ppc_net.keys(): if ppc_net['success'] != 1: ppc_success = False logger.error("The given ppc data indicates an unsuccessful pypower powerflow: " + "'ppc_net['success'] != 1'") if (ppc_net['branch'].shape[1] < 17): ppc_success = False logger.error("The shape of given ppc data indicates missing pypower powerflow results.") # --- try to run a pandapower powerflow if run[1]: if pf_type == "runpp": try: pp.runpp(net, init="dc", calculate_voltage_angles=True, trafo_model="pi") except pp.LoadflowNotConverged: try: pp.runpp(net, calculate_voltage_angles=True, init="flat", trafo_model="pi") except pp.LoadflowNotConverged: try: pp.runpp(net, trafo_model="pi", calculate_voltage_angles=False) if "bus_va_degree" in max_diff_values.keys(): max_diff_values["bus_va_degree"] = 1e2 if max_diff_values[ "bus_va_degree"] < 1e2 else max_diff_values["bus_va_degree"] logger.info("voltage_angles could be calculated.") except pp.LoadflowNotConverged: logger.error('The pandapower powerflow does not converge.') elif pf_type == "rundcpp": try: pp.rundcpp(net, trafo_model="pi") except pp.LoadflowNotConverged: logger.error('The pandapower dc powerflow does not converge.') elif pf_type == "runopp": try: pp.runopp(net, init="flat", calculate_voltage_angles=True) except pp.OPFNotConverged: try: pp.runopp(net, init="pf", calculate_voltage_angles=True) except (pp.OPFNotConverged, pp.LoadflowNotConverged, KeyError): try: pp.runopp(net, init="flat", calculate_voltage_angles=False) logger.info("voltage_angles could be calculated.") if "bus_va_degree" in max_diff_values.keys(): max_diff_values["bus_va_degree"] = 1e2 if max_diff_values[ "bus_va_degree"] < 1e2 else max_diff_values["bus_va_degree"] except pp.OPFNotConverged: try: pp.runopp(net, init="pf", calculate_voltage_angles=False) if "bus_va_degree" in max_diff_values.keys(): max_diff_values["bus_va_degree"] = 1e2 if max_diff_values[ "bus_va_degree"] < 1e2 else max_diff_values["bus_va_degree"] logger.info("voltage_angles could be calculated.") except (pp.OPFNotConverged, pp.LoadflowNotConverged, KeyError): logger.error('The pandapower optimal powerflow does not converge.') elif pf_type == "rundcopp": try: pp.rundcopp(net) except pp.LoadflowNotConverged: logger.error('The pandapower dc optimal powerflow does not converge.') else: raise ValueError("The pf_type %s is unknown" % pf_type) # --- prepare powerflow result comparison by reordering pp results as they are in ppc results if not ppc_success: return False if "opp" in pf_type: if not net.OPF_converged: return elif not net.converged: return False # --- store pypower powerflow results ppc_res = dict.fromkeys(ppc_elms) ppc_res["branch"] = ppc_net['branch'][:, 13:17] ppc_res["bus"] = ppc_net['bus'][:, 7:9] ppc_res["gen"] = ppc_net['gen'][:, 1:3] # --- pandapower bus result table pp_res = dict.fromkeys(ppc_elms) pp_res["bus"] = array(net.res_bus.sort_index()[['vm_pu', 'va_degree']]) # --- pandapower gen result table pp_res["gen"] = zeros([1, 2]) # consideration of parallel generators via storing how much generators have been considered # each node # if in ppc is only one gen -> numpy initially uses one dim array -> change to two dim array if len(ppc_net["gen"].shape) == 1: ppc_net["gen"] = array(ppc_net["gen"], ndmin=2) GENS = DataFrame(ppc_net['gen'][:, [0]].astype(int)) GEN_uniq = GENS.drop_duplicates() already_used_gen = Series(zeros(GEN_uniq.shape[0]).astype(int), index=[int(v) for v in GEN_uniq.values]) change_q_compare = [] for i, j in GENS.iterrows(): current_bus_type, current_bus_idx, same_bus_gen_idx, first_same_bus_in_service_gen_idx, \ last_same_bus_in_service_gen_idx = _gen_bus_info(ppc_net, i) if current_bus_type == 3 and i == first_same_bus_in_service_gen_idx: pp_res["gen"] = append(pp_res["gen"], array(net.res_ext_grid[ net.ext_grid.bus == current_bus_idx][['p_mw', 'q_mvar']]).reshape((1, 2)), 0) elif current_bus_type == 2 and i == first_same_bus_in_service_gen_idx: pp_res["gen"] = append(pp_res["gen"], array(net.res_gen[ net.gen.bus == current_bus_idx][['p_mw', 'q_mvar']]).reshape((1, 2)), 0) else: pp_res["gen"] = append(pp_res["gen"], array(net.res_sgen[ net.sgen.bus == current_bus_idx][['p_mw', 'q_mvar']])[ already_used_gen.at[int(j)]].reshape((1, 2)), 0) already_used_gen.at[int(j)] += 1 change_q_compare += [int(j)] pp_res["gen"] = pp_res["gen"][1:, :] # delete initial zero row # --- pandapower branch result table pp_res["branch"] = zeros([1, 4]) # consideration of parallel branches via storing how often branches were considered # each node-to-node-connection try: init1 = concat([net.line.from_bus, net.line.to_bus], axis=1, sort=True).drop_duplicates() init2 = concat([net.trafo.hv_bus, net.trafo.lv_bus], axis=1, sort=True).drop_duplicates() except TypeError: # legacy pandas < 0.21 init1 = concat([net.line.from_bus, net.line.to_bus], axis=1).drop_duplicates() init2 =
concat([net.trafo.hv_bus, net.trafo.lv_bus], axis=1)
pandas.concat
from flask import Flask, render_template, jsonify, request from flask_pymongo import PyMongo from flask_cors import CORS, cross_origin import json import collections import numpy as np import re from numpy import array from statistics import mode import pandas as pd import warnings import copy from joblib import Memory from itertools import chain import ast import timeit from sklearn.neighbors import KNeighborsClassifier # 1 neighbors from sklearn.svm import SVC # 1 svm from sklearn.naive_bayes import GaussianNB # 1 naive bayes from sklearn.neural_network import MLPClassifier # 1 neural network from sklearn.linear_model import LogisticRegression # 1 linear model from sklearn.discriminant_analysis import LinearDiscriminantAnalysis, QuadraticDiscriminantAnalysis # 2 discriminant analysis from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier, AdaBoostClassifier, GradientBoostingClassifier # 4 ensemble models from joblib import Parallel, delayed import multiprocessing from sklearn.pipeline import make_pipeline from sklearn import model_selection from sklearn.manifold import MDS from sklearn.manifold import TSNE from sklearn.metrics import matthews_corrcoef from sklearn.metrics import log_loss from sklearn.metrics import fbeta_score from sklearn.metrics import accuracy_score from sklearn.metrics import precision_score from sklearn.metrics import recall_score from sklearn.metrics import f1_score from imblearn.metrics import geometric_mean_score import umap from sklearn.metrics import classification_report from sklearn.preprocessing import scale import eli5 from eli5.sklearn import PermutationImportance from sklearn.feature_selection import SelectKBest from sklearn.feature_selection import chi2 from sklearn.feature_selection import RFE from sklearn.decomposition import PCA from mlxtend.classifier import StackingCVClassifier from mlxtend.feature_selection import ColumnSelector from sklearn.model_selection import GridSearchCV from sklearn.model_selection import ShuffleSplit from scipy.spatial import procrustes # This block of code == for the connection between the server, the database, and the client (plus routing). # Access MongoDB app = Flask(__name__) app.config["MONGO_URI"] = "mongodb://localhost:27017/mydb" mongo = PyMongo(app) cors = CORS(app, resources={r"/data/*": {"origins": "*"}}) # Retrieve data from client @cross_origin(origin='localhost',headers=['Content-Type','Authorization']) @app.route('/data/Reset', methods=["GET", "POST"]) def Reset(): global DataRawLength global DataResultsRaw global previousState previousState = [] global filterActionFinal filterActionFinal = '' global keySpecInternal keySpecInternal = 1 global dataSpacePointsIDs dataSpacePointsIDs = [] global previousStateActive previousStateActive = [] global StanceTest StanceTest = False global status status = True global factors factors = [1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,1,1,1] global KNNModelsCount global SVCModelsCount global GausNBModelsCount global MLPModelsCount global LRModelsCount global LDAModelsCount global QDAModelsCount global RFModelsCount global ExtraTModelsCount global AdaBModelsCount global GradBModelsCount global keyData keyData = 0 KNNModelsCount = 0 SVCModelsCount = 576 GausNBModelsCount = 736 MLPModelsCount = 1236 LRModelsCount = 1356 LDAModelsCount = 1996 QDAModelsCount = 2196 RFModelsCount = 2446 ExtraTModelsCount = 2606 AdaBModelsCount = 2766 GradBModelsCount = 2926 global XData XData = [] global yData yData = [] global XDataStored XDataStored = [] global yDataStored yDataStored = [] global detailsParams detailsParams = [] global algorithmList algorithmList = [] global ClassifierIDsList ClassifierIDsList = '' # Initializing models global resultsList resultsList = [] global RetrieveModelsList RetrieveModelsList = [] global allParametersPerformancePerModel allParametersPerformancePerModel = [] global all_classifiers all_classifiers = [] global crossValidation crossValidation = 5 # models global KNNModels KNNModels = [] global RFModels RFModels = [] global scoring scoring = {'accuracy': 'accuracy', 'precision_micro': 'precision_micro', 'precision_macro': 'precision_macro', 'precision_weighted': 'precision_weighted', 'recall_micro': 'recall_micro', 'recall_macro': 'recall_macro', 'recall_weighted': 'recall_weighted', 'roc_auc_ovo_weighted': 'roc_auc_ovo_weighted'} global loopFeatures loopFeatures = 2 global results results = [] global resultsMetrics resultsMetrics = [] global parametersSelData parametersSelData = [] global target_names target_names = [] global target_namesLoc target_namesLoc = [] return 'The reset was done!' # Retrieve data from client and select the correct data set @cross_origin(origin='localhost',headers=['Content-Type','Authorization']) @app.route('/data/ServerRequest', methods=["GET", "POST"]) def RetrieveFileName(): global DataRawLength global DataResultsRaw global DataResultsRawTest global DataRawLengthTest fileName = request.get_data().decode('utf8').replace("'", '"') global keySpecInternal keySpecInternal = 1 global filterActionFinal filterActionFinal = '' global dataSpacePointsIDs dataSpacePointsIDs = [] global RANDOM_SEED RANDOM_SEED = 42 global keyData keyData = 0 global XData XData = [] global previousState previousState = [] global previousStateActive previousStateActive = [] global status status = True global yData yData = [] global XDataStored XDataStored = [] global yDataStored yDataStored = [] global filterDataFinal filterDataFinal = 'mean' global ClassifierIDsList ClassifierIDsList = '' global algorithmList algorithmList = [] global detailsParams detailsParams = [] # Initializing models global RetrieveModelsList RetrieveModelsList = [] global resultsList resultsList = [] global allParametersPerformancePerModel allParametersPerformancePerModel = [] global all_classifiers all_classifiers = [] global scoring scoring = {'accuracy': 'accuracy', 'precision_micro': 'precision_micro', 'precision_macro': 'precision_macro', 'precision_weighted': 'precision_weighted', 'recall_micro': 'recall_micro', 'recall_macro': 'recall_macro', 'recall_weighted': 'recall_weighted', 'roc_auc_ovo_weighted': 'roc_auc_ovo_weighted'} global loopFeatures loopFeatures = 2 # models global KNNModels global SVCModels global GausNBModels global MLPModels global LRModels global LDAModels global QDAModels global RFModels global ExtraTModels global AdaBModels global GradBModels KNNModels = [] SVCModels = [] GausNBModels = [] MLPModels = [] LRModels = [] LDAModels = [] QDAModels = [] RFModels = [] ExtraTModels = [] AdaBModels = [] GradBModels = [] global results results = [] global resultsMetrics resultsMetrics = [] global parametersSelData parametersSelData = [] global StanceTest StanceTest = False global target_names target_names = [] global target_namesLoc target_namesLoc = [] DataRawLength = -1 DataRawLengthTest = -1 data = json.loads(fileName) if data['fileName'] == 'HeartC': CollectionDB = mongo.db.HeartC.find() elif data['fileName'] == 'StanceC': StanceTest = True CollectionDB = mongo.db.StanceC.find() CollectionDBTest = mongo.db.StanceCTest.find() elif data['fileName'] == 'DiabetesC': CollectionDB = mongo.db.diabetesC.find() elif data['fileName'] == 'BreastC': CollectionDB = mongo.db.breastC.find() elif data['fileName'] == 'WineC': CollectionDB = mongo.db.WineC.find() elif data['fileName'] == 'ContraceptiveC': CollectionDB = mongo.db.ContraceptiveC.find() elif data['fileName'] == 'VehicleC': CollectionDB = mongo.db.VehicleC.find() elif data['fileName'] == 'BiodegC': StanceTest = True CollectionDB = mongo.db.biodegC.find() CollectionDBTest = mongo.db.biodegCTest.find() else: CollectionDB = mongo.db.IrisC.find() DataResultsRaw = [] for index, item in enumerate(CollectionDB): item['_id'] = str(item['_id']) item['InstanceID'] = index DataResultsRaw.append(item) DataRawLength = len(DataResultsRaw) DataResultsRawTest = [] if (StanceTest): for index, item in enumerate(CollectionDBTest): item['_id'] = str(item['_id']) item['InstanceID'] = index DataResultsRawTest.append(item) DataRawLengthTest = len(DataResultsRawTest) DataSetSelection() return 'Everything is okay' def Convert(lst): it = iter(lst) res_dct = dict(zip(it, it)) return res_dct # Retrieve data set from client @cross_origin(origin='localhost',headers=['Content-Type','Authorization']) @app.route('/data/SendtoSeverDataSet', methods=["GET", "POST"]) def SendToServerData(): uploadedData = request.get_data().decode('utf8').replace("'", '"') uploadedDataParsed = json.loads(uploadedData) DataResultsRaw = uploadedDataParsed['uploadedData'] DataResults = copy.deepcopy(DataResultsRaw) for dictionary in DataResultsRaw: for key in dictionary.keys(): if (key.find('*') != -1): target = key continue continue DataResultsRaw.sort(key=lambda x: x[target], reverse=True) DataResults.sort(key=lambda x: x[target], reverse=True) for dictionary in DataResults: del dictionary[target] global AllTargets global target_names global target_namesLoc AllTargets = [o[target] for o in DataResultsRaw] AllTargetsFloatValues = [] previous = None Class = 0 for i, value in enumerate(AllTargets): if (i == 0): previous = value target_names.append(value) if (value == previous): AllTargetsFloatValues.append(Class) else: Class = Class + 1 target_names.append(value) AllTargetsFloatValues.append(Class) previous = value ArrayDataResults = pd.DataFrame.from_dict(DataResults) global XData, yData, RANDOM_SEED XData, yData = ArrayDataResults, AllTargetsFloatValues global XDataStored, yDataStored XDataStored = XData.copy() yDataStored = yData.copy() return 'Processed uploaded data set' # Sent data to client @app.route('/data/ClientRequest', methods=["GET", "POST"]) def CollectionData(): json.dumps(DataResultsRaw) response = { 'Collection': DataResultsRaw } return jsonify(response) def DataSetSelection(): global XDataTest, yDataTest XDataTest = pd.DataFrame() global StanceTest global AllTargets global target_names target_namesLoc = [] if (StanceTest): DataResultsTest = copy.deepcopy(DataResultsRawTest) for dictionary in DataResultsRawTest: for key in dictionary.keys(): if (key.find('*') != -1): target = key continue continue DataResultsRawTest.sort(key=lambda x: x[target], reverse=True) DataResultsTest.sort(key=lambda x: x[target], reverse=True) for dictionary in DataResultsTest: del dictionary['_id'] del dictionary['InstanceID'] del dictionary[target] AllTargetsTest = [o[target] for o in DataResultsRawTest] AllTargetsFloatValuesTest = [] previous = None Class = 0 for i, value in enumerate(AllTargetsTest): if (i == 0): previous = value target_namesLoc.append(value) if (value == previous): AllTargetsFloatValuesTest.append(Class) else: Class = Class + 1 target_namesLoc.append(value) AllTargetsFloatValuesTest.append(Class) previous = value ArrayDataResultsTest = pd.DataFrame.from_dict(DataResultsTest) XDataTest, yDataTest = ArrayDataResultsTest, AllTargetsFloatValuesTest DataResults = copy.deepcopy(DataResultsRaw) for dictionary in DataResultsRaw: for key in dictionary.keys(): if (key.find('*') != -1): target = key continue continue DataResultsRaw.sort(key=lambda x: x[target], reverse=True) DataResults.sort(key=lambda x: x[target], reverse=True) for dictionary in DataResults: del dictionary['_id'] del dictionary['InstanceID'] del dictionary[target] AllTargets = [o[target] for o in DataResultsRaw] AllTargetsFloatValues = [] previous = None Class = 0 for i, value in enumerate(AllTargets): if (i == 0): previous = value target_names.append(value) if (value == previous): AllTargetsFloatValues.append(Class) else: Class = Class + 1 target_names.append(value) AllTargetsFloatValues.append(Class) previous = value ArrayDataResults = pd.DataFrame.from_dict(DataResults) global XData, yData, RANDOM_SEED XData, yData = ArrayDataResults, AllTargetsFloatValues global XDataStored, yDataStored XDataStored = XData.copy() yDataStored = yData.copy() warnings.simplefilter('ignore') return 'Everything is okay' def callPreResults(): global XData global yData global target_names global impDataInst DataSpaceResMDS = FunMDS(XData) DataSpaceResTSNE = FunTsne(XData) DataSpaceResTSNE = DataSpaceResTSNE.tolist() DataSpaceUMAP = FunUMAP(XData) XDataJSONEntireSetRes = XData.to_json(orient='records') global preResults preResults = [] preResults.append(json.dumps(target_names)) # Position: 0 preResults.append(json.dumps(DataSpaceResMDS)) # Position: 1 preResults.append(json.dumps(XDataJSONEntireSetRes)) # Position: 2 preResults.append(json.dumps(yData)) # Position: 3 preResults.append(json.dumps(AllTargets)) # Position: 4 preResults.append(json.dumps(DataSpaceResTSNE)) # Position: 5 preResults.append(json.dumps(DataSpaceUMAP)) # Position: 6 preResults.append(json.dumps(impDataInst)) # Position: 7 # Sending each model's results to frontend @app.route('/data/requestDataSpaceResults', methods=["GET", "POST"]) def SendDataSpaceResults(): global preResults callPreResults() response = { 'preDataResults': preResults, } return jsonify(response) # Main function if __name__ == '__main__': app.run() # Debugging and mirroring client @app.route('/', defaults={'path': ''}) @app.route('/<path:path>') def catch_all(path): if app.debug: return requests.get('http://localhost:8080/{}'.format(path)).text return render_template("index.html") # This block of code is for server computations def column_index(df, query_cols): cols = df.columns.values sidx = np.argsort(cols) return sidx[np.searchsorted(cols,query_cols,sorter=sidx)].tolist() def class_feature_importance(X, Y, feature_importances): N, M = X.shape X = scale(X) out = {} for c in set(Y): out[c] = dict( zip(range(N), np.mean(X[Y==c, :], axis=0)*feature_importances) ) return out @cross_origin(origin='localhost',headers=['Content-Type','Authorization']) @app.route('/data/EnsembleMode', methods=["GET", "POST"]) def EnsembleMethod(): global crossValidation global RANDOM_SEED global XData RANDOM_SEED = 42 RetrievedStatus = request.get_data().decode('utf8').replace("'", '"') RetrievedStatus = json.loads(RetrievedStatus) modeMethod = RetrievedStatus['defaultModeMain'] if (modeMethod == 'blend'): crossValidation = ShuffleSplit(n_splits=1, test_size=.20, random_state=RANDOM_SEED) else: crossValidation = 5 return 'Okay' # Initialize every model for each algorithm @cross_origin(origin='localhost',headers=['Content-Type','Authorization']) @app.route('/data/ServerRequestSelParameters', methods=["GET", "POST"]) def RetrieveModel(): # get the models from the frontend RetrievedModel = request.get_data().decode('utf8').replace("'", '"') RetrievedModel = json.loads(RetrievedModel) global algorithms algorithms = RetrievedModel['Algorithms'] toggle = RetrievedModel['Toggle'] global crossValidation global XData global yData global SVCModelsCount global GausNBModelsCount global MLPModelsCount global LRModelsCount global LDAModelsCount global QDAModelsCount global RFModelsCount global ExtraTModelsCount global AdaBModelsCount global GradBModelsCount # loop through the algorithms global allParametersPerformancePerModel start = timeit.default_timer() print('CVorTT', crossValidation) for eachAlgor in algorithms: if (eachAlgor) == 'KNN': clf = KNeighborsClassifier() params = {'n_neighbors': list(range(1, 25)), 'metric': ['chebyshev', 'manhattan', 'euclidean', 'minkowski'], 'algorithm': ['brute', 'kd_tree', 'ball_tree'], 'weights': ['uniform', 'distance']} AlgorithmsIDsEnd = 0 elif (eachAlgor) == 'SVC': clf = SVC(probability=True,random_state=RANDOM_SEED) params = {'C': list(np.arange(0.1,4.43,0.11)), 'kernel': ['rbf','linear', 'poly', 'sigmoid']} AlgorithmsIDsEnd = SVCModelsCount elif (eachAlgor) == 'GauNB': clf = GaussianNB() params = {'var_smoothing': list(np.arange(0.00000000001,0.0000001,0.0000000002))} AlgorithmsIDsEnd = GausNBModelsCount elif (eachAlgor) == 'MLP': clf = MLPClassifier(random_state=RANDOM_SEED) params = {'alpha': list(np.arange(0.00001,0.001,0.0002)), 'tol': list(np.arange(0.00001,0.001,0.0004)), 'max_iter': list(np.arange(100,200,100)), 'activation': ['relu', 'identity', 'logistic', 'tanh'], 'solver' : ['adam', 'sgd']} AlgorithmsIDsEnd = MLPModelsCount elif (eachAlgor) == 'LR': clf = LogisticRegression(random_state=RANDOM_SEED) params = {'C': list(np.arange(0.5,2,0.075)), 'max_iter': list(np.arange(50,250,50)), 'solver': ['lbfgs', 'newton-cg', 'sag', 'saga'], 'penalty': ['l2', 'none']} AlgorithmsIDsEnd = LRModelsCount elif (eachAlgor) == 'LDA': clf = LinearDiscriminantAnalysis() params = {'shrinkage': list(np.arange(0,1,0.01)), 'solver': ['lsqr', 'eigen']} AlgorithmsIDsEnd = LDAModelsCount elif (eachAlgor) == 'QDA': clf = QuadraticDiscriminantAnalysis() params = {'reg_param': list(np.arange(0,1,0.02)), 'tol': list(np.arange(0.00001,0.001,0.0002))} AlgorithmsIDsEnd = QDAModelsCount elif (eachAlgor) == 'RF': clf = RandomForestClassifier(random_state=RANDOM_SEED) params = {'n_estimators': list(range(60, 140)), 'criterion': ['gini', 'entropy']} AlgorithmsIDsEnd = RFModelsCount elif (eachAlgor) == 'ExtraT': clf = ExtraTreesClassifier(random_state=RANDOM_SEED) params = {'n_estimators': list(range(60, 140)), 'criterion': ['gini', 'entropy']} AlgorithmsIDsEnd = ExtraTModelsCount elif (eachAlgor) == 'AdaB': clf = AdaBoostClassifier(random_state=RANDOM_SEED) params = {'n_estimators': list(range(40, 80)), 'learning_rate': list(np.arange(0.1,2.3,1.1)), 'algorithm': ['SAMME.R', 'SAMME']} AlgorithmsIDsEnd = AdaBModelsCount else: clf = GradientBoostingClassifier(random_state=RANDOM_SEED) params = {'n_estimators': list(range(85, 115)), 'learning_rate': list(np.arange(0.01,0.23,0.11)), 'criterion': ['friedman_mse', 'mse', 'mae']} AlgorithmsIDsEnd = GradBModelsCount allParametersPerformancePerModel = GridSearchForModels(XData, yData, clf, params, eachAlgor, AlgorithmsIDsEnd, toggle, crossValidation) # New visualization - model space # header = "model_id,algorithm_id,mean_test_accuracy,mean_test_precision_micro,mean_test_precision_macro,mean_test_precision_weighted,mean_test_recall_micro,mean_test_recall_macro,mean_test_recall_weighted,mean_test_roc_auc_ovo_weighted,geometric_mean_score_micro,geometric_mean_score_macro,geometric_mean_score_weighted,matthews_corrcoef,f5_micro,f5_macro,f5_weighted,f1_micro,f1_macro,f1_weighted,f2_micro,f2_macro,f2_weighted,log_loss\n" # dataReceived = [] # counter = 0 # for indx, el in enumerate(allParametersPerformancePerModel): # dictFR = json.loads(el) # frame = pd.DataFrame.from_dict(dictFR) # for ind, elInside in frame.iterrows(): # counter = counter + 1 # dataReceived.append(str(counter)) # dataReceived.append(',') # dataReceived.append(str(indx+1)) # dataReceived.append(',') # dataReceived.append(str(elInside['mean_test_accuracy'])) # dataReceived.append(',') # dataReceived.append(str(elInside['mean_test_precision_micro'])) # dataReceived.append(',') # dataReceived.append(str(elInside['mean_test_precision_macro'])) # dataReceived.append(',') # dataReceived.append(str(elInside['mean_test_precision_weighted'])) # dataReceived.append(',') # dataReceived.append(str(elInside['mean_test_recall_micro'])) # dataReceived.append(',') # dataReceived.append(str(elInside['mean_test_recall_macro'])) # dataReceived.append(',') # dataReceived.append(str(elInside['mean_test_recall_weighted'])) # dataReceived.append(',') # dataReceived.append(str(elInside['mean_test_roc_auc_ovo_weighted'])) # dataReceived.append(',') # dataReceived.append(str(elInside['geometric_mean_score_micro'])) # dataReceived.append(',') # dataReceived.append(str(elInside['geometric_mean_score_macro'])) # dataReceived.append(',') # dataReceived.append(str(elInside['geometric_mean_score_weighted'])) # dataReceived.append(',') # dataReceived.append(str(elInside['matthews_corrcoef'])) # dataReceived.append(',') # dataReceived.append(str(elInside['f5_micro'])) # dataReceived.append(',') # dataReceived.append(str(elInside['f5_macro'])) # dataReceived.append(',') # dataReceived.append(str(elInside['f5_weighted'])) # dataReceived.append(',') # dataReceived.append(str(elInside['f1_micro'])) # dataReceived.append(',') # dataReceived.append(str(elInside['f1_macro'])) # dataReceived.append(',') # dataReceived.append(str(elInside['f1_weighted'])) # dataReceived.append(',') # dataReceived.append(str(elInside['f2_micro'])) # dataReceived.append(',') # dataReceived.append(str(elInside['f2_macro'])) # dataReceived.append(',') # dataReceived.append(str(elInside['f2_weighted'])) # dataReceived.append(',') # dataReceived.append(str(elInside['log_loss'])) # dataReceived.append("\n") # dataReceivedItems = ''.join(dataReceived) # csvString = header + dataReceivedItems # fw = open ("modelSpace.csv","w+",encoding="utf-8") # fw.write(csvString) # fw.close() # call the function that sends the results to the frontend stop = timeit.default_timer() print('Time GridSearch: ', stop - start) SendEachClassifiersPerformanceToVisualize() return 'Everything Okay' location = './cachedir' memory = Memory(location, verbose=0) # calculating for all algorithms and models the performance and other results @memory.cache def GridSearchForModels(XData, yData, clf, params, eachAlgor, AlgorithmsIDsEnd, toggle, crossVal): print('loop') # this is the grid we use to train the models grid = GridSearchCV( estimator=clf, param_grid=params, cv=crossVal, refit='accuracy', scoring=scoring, verbose=0, n_jobs=-1) # fit and extract the probabilities grid.fit(XData, yData) # process the results cv_results = [] cv_results.append(grid.cv_results_) df_cv_results = pd.DataFrame.from_dict(cv_results) # number of models stored number_of_models = len(df_cv_results.iloc[0][0]) # initialize results per row df_cv_results_per_row = [] # loop through number of models modelsIDs = [] for i in range(number_of_models): modelsIDs.append(AlgorithmsIDsEnd+i) # initialize results per item df_cv_results_per_item = [] for column in df_cv_results.iloc[0]: df_cv_results_per_item.append(column[i]) df_cv_results_per_row.append(df_cv_results_per_item) # store the results into a pandas dataframe df_cv_results_classifiers = pd.DataFrame(data = df_cv_results_per_row, columns= df_cv_results.columns) # copy and filter in order to get only the metrics metrics = df_cv_results_classifiers.copy() metrics = metrics.filter(['mean_test_accuracy','mean_test_precision_micro','mean_test_precision_macro','mean_test_precision_weighted','mean_test_recall_micro','mean_test_recall_macro','mean_test_recall_weighted','mean_test_roc_auc_ovo_weighted']) # concat parameters and performance parametersPerformancePerModel = pd.DataFrame(df_cv_results_classifiers['params']) parametersPerformancePerModel = parametersPerformancePerModel.to_json() parametersLocal = json.loads(parametersPerformancePerModel)['params'].copy() Models = [] for index, items in enumerate(parametersLocal): Models.append(str(index)) parametersLocalNew = [ parametersLocal[your_key] for your_key in Models ] permList = [] PerFeatureAccuracy = [] PerFeatureAccuracyAll = [] PerClassMetric = [] perModelProb = [] perModelPrediction = [] resultsMicro = [] resultsMacro = [] resultsWeighted = [] resultsCorrCoef = [] resultsMicroBeta5 = [] resultsMacroBeta5 = [] resultsWeightedBeta5 = [] resultsMicroBeta1 = [] resultsMacroBeta1 = [] resultsWeightedBeta1 = [] resultsMicroBeta2 = [] resultsMacroBeta2 = [] resultsWeightedBeta2 = [] resultsLogLoss = [] resultsLogLossFinal = [] loop = 8 # influence calculation for all the instances inputs = range(len(XData)) num_cores = multiprocessing.cpu_count() #impDataInst = Parallel(n_jobs=num_cores)(delayed(processInput)(i,XData,yData,crossValidation,clf) for i in inputs) for eachModelParameters in parametersLocalNew: clf.set_params(**eachModelParameters) if (toggle == 1): perm = PermutationImportance(clf, cv = None, refit = True, n_iter = 25).fit(XData, yData) permList.append(perm.feature_importances_) n_feats = XData.shape[1] PerFeatureAccuracy = [] for i in range(n_feats): scores = model_selection.cross_val_score(clf, XData.values[:, i].reshape(-1, 1), yData, cv=5) PerFeatureAccuracy.append(scores.mean()) PerFeatureAccuracyAll.append(PerFeatureAccuracy) else: permList.append(0) PerFeatureAccuracyAll.append(0) clf.fit(XData, yData) yPredict = clf.predict(XData) yPredict = np.nan_to_num(yPredict) perModelPrediction.append(yPredict) # retrieve target names (class names) PerClassMetric.append(classification_report(yData, yPredict, target_names=target_names, digits=2, output_dict=True)) yPredictProb = clf.predict_proba(XData) yPredictProb = np.nan_to_num(yPredictProb) perModelProb.append(yPredictProb.tolist()) resultsMicro.append(geometric_mean_score(yData, yPredict, average='micro')) resultsMacro.append(geometric_mean_score(yData, yPredict, average='macro')) resultsWeighted.append(geometric_mean_score(yData, yPredict, average='weighted')) resultsCorrCoef.append(matthews_corrcoef(yData, yPredict)) resultsMicroBeta5.append(fbeta_score(yData, yPredict, average='micro', beta=0.5)) resultsMacroBeta5.append(fbeta_score(yData, yPredict, average='macro', beta=0.5)) resultsWeightedBeta5.append(fbeta_score(yData, yPredict, average='weighted', beta=0.5)) resultsMicroBeta1.append(fbeta_score(yData, yPredict, average='micro', beta=1)) resultsMacroBeta1.append(fbeta_score(yData, yPredict, average='macro', beta=1)) resultsWeightedBeta1.append(fbeta_score(yData, yPredict, average='weighted', beta=1)) resultsMicroBeta2.append(fbeta_score(yData, yPredict, average='micro', beta=2)) resultsMacroBeta2.append(fbeta_score(yData, yPredict, average='macro', beta=2)) resultsWeightedBeta2.append(fbeta_score(yData, yPredict, average='weighted', beta=2)) resultsLogLoss.append(log_loss(yData, yPredictProb, normalize=True)) maxLog = max(resultsLogLoss) minLog = min(resultsLogLoss) for each in resultsLogLoss: resultsLogLossFinal.append((each-minLog)/(maxLog-minLog)) metrics.insert(loop,'geometric_mean_score_micro',resultsMicro) metrics.insert(loop+1,'geometric_mean_score_macro',resultsMacro) metrics.insert(loop+2,'geometric_mean_score_weighted',resultsWeighted) metrics.insert(loop+3,'matthews_corrcoef',resultsCorrCoef) metrics.insert(loop+4,'f5_micro',resultsMicroBeta5) metrics.insert(loop+5,'f5_macro',resultsMacroBeta5) metrics.insert(loop+6,'f5_weighted',resultsWeightedBeta5) metrics.insert(loop+7,'f1_micro',resultsMicroBeta1) metrics.insert(loop+8,'f1_macro',resultsMacroBeta1) metrics.insert(loop+9,'f1_weighted',resultsWeightedBeta1) metrics.insert(loop+10,'f2_micro',resultsMicroBeta2) metrics.insert(loop+11,'f2_macro',resultsMacroBeta2) metrics.insert(loop+12,'f2_weighted',resultsWeightedBeta2) metrics.insert(loop+13,'log_loss',resultsLogLossFinal) perModelPredPandas = pd.DataFrame(perModelPrediction) perModelPredPandas = perModelPredPandas.to_json() perModelProbPandas = pd.DataFrame(perModelProb) perModelProbPandas = perModelProbPandas.to_json() PerClassMetricPandas = pd.DataFrame(PerClassMetric) del PerClassMetricPandas['accuracy'] del PerClassMetricPandas['macro avg'] del PerClassMetricPandas['weighted avg'] PerClassMetricPandas = PerClassMetricPandas.to_json() perm_imp_eli5PD = pd.DataFrame(permList) perm_imp_eli5PD = perm_imp_eli5PD.to_json() PerFeatureAccuracyPandas = pd.DataFrame(PerFeatureAccuracyAll) PerFeatureAccuracyPandas = PerFeatureAccuracyPandas.to_json() bestfeatures = SelectKBest(score_func=chi2, k='all') fit = bestfeatures.fit(XData,yData) dfscores = pd.DataFrame(fit.scores_) dfcolumns = pd.DataFrame(XData.columns) featureScores = pd.concat([dfcolumns,dfscores],axis=1) featureScores.columns = ['Specs','Score'] #naming the dataframe columns featureScores = featureScores.to_json() # gather the results and send them back results.append(modelsIDs) # Position: 0 and so on results.append(parametersPerformancePerModel) # Position: 1 and so on results.append(PerClassMetricPandas) # Position: 2 and so on results.append(PerFeatureAccuracyPandas) # Position: 3 and so on results.append(perm_imp_eli5PD) # Position: 4 and so on results.append(featureScores) # Position: 5 and so on metrics = metrics.to_json() results.append(metrics) # Position: 6 and so on results.append(perModelProbPandas) # Position: 7 and so on results.append(json.dumps(perModelPredPandas)) # Position: 8 and so on return results # Sending each model's results to frontend @app.route('/data/PerformanceForEachModel', methods=["GET", "POST"]) def SendEachClassifiersPerformanceToVisualize(): response = { 'PerformancePerModel': allParametersPerformancePerModel, } return jsonify(response) def Remove(duplicate): final_list = [] for num in duplicate: if num not in final_list: if (isinstance(num, float)): if np.isnan(num): pass else: final_list.append(float(num)) else: final_list.append(num) return final_list # Retrieve data from client @cross_origin(origin='localhost',headers=['Content-Type','Authorization']) @app.route('/data/SendBrushedParam', methods=["GET", "POST"]) def RetrieveModelsParam(): RetrieveModelsPar = request.get_data().decode('utf8').replace("'", '"') RetrieveModelsPar = json.loads(RetrieveModelsPar) counterKNN = 0 counterSVC = 0 counterGausNB = 0 counterMLP = 0 counterLR = 0 counterLDA = 0 counterQDA = 0 counterRF = 0 counterExtraT = 0 counterAdaB = 0 counterGradB = 0 global KNNModels global SVCModels global GausNBModels global MLPModels global LRModels global LDAModels global QDAModels global RFModels global ExtraTModels global AdaBModels global GradBModels global algorithmsList algorithmsList = RetrieveModelsPar['algorithms'] for index, items in enumerate(algorithmsList): if (items == 'KNN'): counterKNN += 1 KNNModels.append(int(RetrieveModelsPar['models'][index])) elif (items == 'SVC'): counterSVC += 1 SVCModels.append(int(RetrieveModelsPar['models'][index])) elif (items == 'GauNB'): counterGausNB += 1 GausNBModels.append(int(RetrieveModelsPar['models'][index])) elif (items == 'MLP'): counterMLP += 1 MLPModels.append(int(RetrieveModelsPar['models'][index])) elif (items == 'LR'): counterLR += 1 LRModels.append(int(RetrieveModelsPar['models'][index])) elif (items == 'LDA'): counterLDA += 1 LDAModels.append(int(RetrieveModelsPar['models'][index])) elif (items == 'QDA'): counterQDA += 1 QDAModels.append(int(RetrieveModelsPar['models'][index])) elif (items == 'RF'): counterRF += 1 RFModels.append(int(RetrieveModelsPar['models'][index])) elif (items == 'ExtraT'): counterExtraT += 1 ExtraTModels.append(int(RetrieveModelsPar['models'][index])) elif (items == 'AdaB'): counterAdaB += 1 AdaBModels.append(int(RetrieveModelsPar['models'][index])) else: counterGradB += 1 GradBModels.append(int(RetrieveModelsPar['models'][index])) return 'Everything Okay' # Retrieve data from client @cross_origin(origin='localhost',headers=['Content-Type','Authorization']) @app.route('/data/factors', methods=["GET", "POST"]) def RetrieveFactors(): global factors global allParametersPerformancePerModel Factors = request.get_data().decode('utf8').replace("'", '"') FactorsInt = json.loads(Factors) factors = FactorsInt['Factors'] # this is if we want to change the factors before running the search #if (len(allParametersPerformancePerModel) == 0): # pass #else: global sumPerClassifierSel global ModelSpaceMDSNew global ModelSpaceTSNENew global metricsPerModel sumPerClassifierSel = [] sumPerClassifierSel = preProcsumPerMetric(factors) ModelSpaceMDSNew = [] ModelSpaceTSNENew = [] loopThroughMetrics = PreprocessingMetrics() loopThroughMetrics = loopThroughMetrics.fillna(0) metricsPerModel = preProcMetricsAllAndSel() flagLocal = 0 countRemovals = 0 for l,el in enumerate(factors): if el == 0: loopThroughMetrics.drop(loopThroughMetrics.columns[[l-countRemovals]], axis=1, inplace=True) countRemovals = countRemovals + 1 flagLocal = 1 if flagLocal == 1: ModelSpaceMDSNew = FunMDS(loopThroughMetrics) ModelSpaceTSNENew = FunTsne(loopThroughMetrics) ModelSpaceTSNENew = ModelSpaceTSNENew.tolist() return 'Everything Okay' @app.route('/data/UpdateOverv', methods=["GET", "POST"]) def UpdateOverview(): ResultsUpdateOverview = [] ResultsUpdateOverview.append(sumPerClassifierSel) ResultsUpdateOverview.append(ModelSpaceMDSNew) ResultsUpdateOverview.append(ModelSpaceTSNENew) ResultsUpdateOverview.append(metricsPerModel) response = { 'Results': ResultsUpdateOverview } return jsonify(response) def PreprocessingMetrics(): dicKNN = json.loads(allParametersPerformancePerModel[6]) dicSVC = json.loads(allParametersPerformancePerModel[15]) dicGausNB = json.loads(allParametersPerformancePerModel[24]) dicMLP = json.loads(allParametersPerformancePerModel[33]) dicLR = json.loads(allParametersPerformancePerModel[42]) dicLDA = json.loads(allParametersPerformancePerModel[51]) dicQDA = json.loads(allParametersPerformancePerModel[60]) dicRF = json.loads(allParametersPerformancePerModel[69]) dicExtraT = json.loads(allParametersPerformancePerModel[78]) dicAdaB = json.loads(allParametersPerformancePerModel[87]) dicGradB = json.loads(allParametersPerformancePerModel[96]) dfKNN = pd.DataFrame.from_dict(dicKNN) dfSVC = pd.DataFrame.from_dict(dicSVC) dfGausNB = pd.DataFrame.from_dict(dicGausNB) dfMLP = pd.DataFrame.from_dict(dicMLP) dfLR = pd.DataFrame.from_dict(dicLR) dfLDA = pd.DataFrame.from_dict(dicLDA) dfQDA = pd.DataFrame.from_dict(dicQDA) dfRF = pd.DataFrame.from_dict(dicRF) dfExtraT = pd.DataFrame.from_dict(dicExtraT) dfAdaB = pd.DataFrame.from_dict(dicAdaB) dfGradB = pd.DataFrame.from_dict(dicGradB) dfKNN.index = dfKNN.index.astype(int) dfSVC.index = dfSVC.index.astype(int) + SVCModelsCount dfGausNB.index = dfGausNB.index.astype(int) + GausNBModelsCount dfMLP.index = dfMLP.index.astype(int) + MLPModelsCount dfLR.index = dfLR.index.astype(int) + LRModelsCount dfLDA.index = dfLDA.index.astype(int) + LDAModelsCount dfQDA.index = dfQDA.index.astype(int) + QDAModelsCount dfRF.index = dfRF.index.astype(int) + RFModelsCount dfExtraT.index = dfExtraT.index.astype(int) + ExtraTModelsCount dfAdaB.index = dfAdaB.index.astype(int) + AdaBModelsCount dfGradB.index = dfGradB.index.astype(int) + GradBModelsCount dfKNNFiltered = dfKNN.loc[KNNModels, :] dfSVCFiltered = dfSVC.loc[SVCModels, :] dfGausNBFiltered = dfGausNB.loc[GausNBModels, :] dfMLPFiltered = dfMLP.loc[MLPModels, :] dfLRFiltered = dfLR.loc[LRModels, :] dfLDAFiltered = dfLDA.loc[LDAModels, :] dfQDAFiltered = dfQDA.loc[QDAModels, :] dfRFFiltered = dfRF.loc[RFModels, :] dfExtraTFiltered = dfExtraT.loc[ExtraTModels, :] dfAdaBFiltered = dfAdaB.loc[AdaBModels, :] dfGradBFiltered = dfGradB.loc[GradBModels, :] df_concatMetrics = pd.concat([dfKNNFiltered, dfSVCFiltered, dfGausNBFiltered, dfMLPFiltered, dfLRFiltered, dfLDAFiltered, dfQDAFiltered, dfRFFiltered, dfExtraTFiltered, dfAdaBFiltered, dfGradBFiltered]) return df_concatMetrics def PreprocessingPred(): dicKNN = json.loads(allParametersPerformancePerModel[7]) dicSVC = json.loads(allParametersPerformancePerModel[16]) dicGausNB = json.loads(allParametersPerformancePerModel[25]) dicMLP = json.loads(allParametersPerformancePerModel[34]) dicLR = json.loads(allParametersPerformancePerModel[43]) dicLDA = json.loads(allParametersPerformancePerModel[52]) dicQDA = json.loads(allParametersPerformancePerModel[61]) dicRF = json.loads(allParametersPerformancePerModel[70]) dicExtraT = json.loads(allParametersPerformancePerModel[79]) dicAdaB = json.loads(allParametersPerformancePerModel[88]) dicGradB = json.loads(allParametersPerformancePerModel[97]) dfKNN = pd.DataFrame.from_dict(dicKNN) dfSVC = pd.DataFrame.from_dict(dicSVC) dfGausNB = pd.DataFrame.from_dict(dicGausNB) dfMLP = pd.DataFrame.from_dict(dicMLP) dfLR = pd.DataFrame.from_dict(dicLR) dfLDA =
pd.DataFrame.from_dict(dicLDA)
pandas.DataFrame.from_dict
# create dataframes based on the available data import json import os import geopandas as gpd import pandas as pd import rasterio import rasterstats import time import random def generate_dataframe(shapefile, raster): # Read the shapefile and convert its crs districts = gpd.read_file(shapefile) s = shapefile.split("/") e = s[6].split("_") nuts = e[1].split(".")[0] reg = e[0] #exclusive for europe shapefile try: districts["GEN"]=districts["NAME"] districts["SHN"]=districts["NUTS"] except: pass # districts.drop(["GEN"], axis=1) # districts["GEN"]= districts["POPULATION"] districts = districts.to_crs('epsg:4326') # convert it into a geoJson file districts.to_file("./data/geojsonFiles/geojson_{}_{}".format(reg, nuts), driver="GeoJSON", encoding="utf-8") with open("./data/geojsonFiles/geojson_{}_{}".format(reg, nuts), encoding="utf-8") as geofile: geojson_layer = json.load(geofile) # concordance between the df and the geojson file based on an 'id' key state_id_map = {} for feature in geojson_layer['features']: feature['id'] = feature['properties']['GEN'] state_id_map[feature['properties']['SHN']] = feature['id'] districts['id'] = districts['SHN'].apply(lambda x: state_id_map[x]) # import the raster file rf = rasterio.open(raster, mode='r') # get the stats from the raster and the shapefile # Assign raster values to a numpy nd array polluant = rf.read(1) affine = rf.transform # Calculating the zonal statistics avg_pl = rasterstats.zonal_stats(districts, polluant, affine=affine, stats=['mean', 'min', 'max', 'std'], geojson_out=True) # Extracting the average data from the list avg_poll = [] i = 0 while i < len(avg_pl): avg_poll.append(avg_pl[i]['properties']) i = i + 1 # Transfering the infromation from the list to a pandas DataFrame avg_pl_gr = pd.DataFrame(avg_poll) districts["mean"] = avg_pl_gr["mean"] districts["min"] = avg_pl_gr["min"] districts["max"] = avg_pl_gr["max"] districts["std"] = avg_pl_gr["std"] districts ["nuts"] = nuts districts ["zone"] = reg districts ["COVID Cases"] = random.randint(10000,30000) keep = ["SHN", "GEN", "mean", "min", "max", "std", "nuts", "zone", "id", "COVID Cases"] districts = districts[[c for c in districts.columns if c in keep]] return districts, geojson_layer def rem_dir(saving_path, p, n): names = os.listdir(p) names = pd.DataFrame(names) names.to_excel("{}/{}.xlsx".format(saving_path, n), index=False) return def create_csvs(path): zones = os.listdir(path) rem_dir(path, path, "ancienCountries") for zone in zones: if ".xlsx" not in zone: nuts1 = os.listdir(('{}/{}/shapefiles/nuts1').format(path, zone)) nuts2 = os.listdir(('{}/{}/shapefiles/nuts2').format(path, zone)) nuts3 = os.listdir(('{}/{}/shapefiles/nuts3').format(path, zone)) poll = os.listdir(('{}/{}/polluant').format(path, zone)) # rem_dir(('{}/{}/shapefiles/nuts1').format(path, zone), ('{}/{}/shapefiles/nuts1').format(path, zone), "{}_nuts1".format(zone)) rem_dir(('{}/{}/shapefiles/nuts2').format(path, zone), ('{}/{}/shapefiles/nuts2').format(path, zone), "{}_nuts2".format(zone)) rem_dir(('{}/{}/shapefiles/nuts3').format(path, zone), ('{}/{}/shapefiles/nuts3').format(path, zone), "{}_nuts3".format(zone)) rem_dir(('{}/{}/polluant').format(path, zone), ('{}/{}/polluant').format(path, zone), "{}_polluants".format(zone)) # for p in poll: if ".xlsx" not in p: ppath = os.path.join( ('{}/{}/polluant/').format(path, zone), p) pelement = os.listdir(ppath) rem_dir(('{}/{}/polluant/{}').format(path, zone, p), ('{}/{}/polluant/{}').format(path, zone, p), "{}_polluants_{}".format(zone, p)) for tif in pelement: if ".xlsx" not in tif: part = tif.split("_") year = part[1] month = part[2] month = month.split(".") month = month[0] month = str(int(month)) for n in [nuts1, nuts2, nuts3]: if n == nuts1: try: res = [i for i in n if '.shp' in i] dataframe, jsonfile = generate_dataframe( ('{}/{}/shapefiles/nuts1/{}' ).format(path, zone, res[0]), ('{}/{}/polluant/{}/{}').format( path, zone, p, tif)) dataframe['year'] = int(year) dataframe['month'] = int(month) dataframe['date'] = '{}/{}'.format(month, year) dataframe['polluant'] = p dataframe.to_excel(( './data/processedData/{}_{}_nuts1_{}_{}.xlsx' ).format(zone, p, year, month)) except: pass elif n == nuts2: try: res = [i for i in n if '.shp' in i] dataframe, jsonfile = generate_dataframe( ('{}/{}/shapefiles/nuts2/{}' ).format(path, zone, res[0]), ('{}/{}/polluant/{}/{}').format( path, zone, p, tif)) dataframe['year'] = int(year) dataframe['month'] = int(month) dataframe['date'] = '{}/{}'.format(month, year) dataframe['polluant'] = p dataframe.to_excel(( './data/processedData/{}_{}_nuts2_{}_{}.xlsx' ).format(zone, p, year, month)) except: pass else: try: res = [i for i in n if '.shp' in i] dataframe, jsonfile = generate_dataframe( ('{}/{}/shapefiles/nuts3/{}' ).format(path, zone, res[0]), ('{}/{}/polluant/{}/{}').format( path, zone, p, tif)) dataframe['year'] = int(year) dataframe['month'] = int(month) dataframe['date'] = '{}/{}'.format(month, year) dataframe['polluant'] = p dataframe.to_excel(( './data/processedData/{}_{}_nuts3_{}_{}.xlsx' ).format(zone, p, year, month)) except: pass return def generate_from_countries(path, zone): ''' This function allows the generation of csvs based on a given path and specific region ''' nuts1 = os.listdir(('{}/{}/shapefiles/nuts1').format(path, zone)) nuts2 = os.listdir(('{}/{}/shapefiles/nuts2').format(path, zone)) nuts3 = os.listdir(('{}/{}/shapefiles/nuts3').format(path, zone)) poll = os.listdir(('{}/{}/polluant').format(path, zone)) # rem_dir(('{}/{}/shapefiles/nuts1').format(path, zone), ('{}/{}/shapefiles/nuts1').format(path, zone), "{}_nuts1".format(zone)) rem_dir(('{}/{}/shapefiles/nuts2').format(path, zone), ('{}/{}/shapefiles/nuts2').format(path, zone), "{}_nuts2".format(zone)) rem_dir(('{}/{}/shapefiles/nuts3').format(path, zone), ('{}/{}/shapefiles/nuts3').format(path, zone), "{}_nuts3".format(zone)) rem_dir(('{}/{}/polluant').format(path, zone), ('{}/{}/polluant').format(path, zone), "{}_polluants".format(zone)) # for p in poll: ppath = os.path.join(('{}/{}/polluant/').format(path, zone), p) pelement = os.listdir(ppath) rem_dir(('{}/{}/polluant/{}').format(path, zone, p), ('{}/{}/polluant/{}').format(path, zone, p), "{}_polluants_{}".format(zone, p)) for tif in pelement: if ".xlsx" not in tif: part = tif.split("_") year = part[1] month = part[2] month = month.split(".") month = month[0] month = str(int(month)) for n in [nuts1, nuts2, nuts3]: if n == nuts1: try: res = [i for i in n if '.shp' in i] dataframe, jsonfile = generate_dataframe( ('{}/{}/shapefiles/nuts1/{}').format( path, zone, res[0]), ('{}/{}/polluant/{}/{}').format( path, zone, p, tif)) dataframe['year'] = int(year) dataframe['month'] = int(month) dataframe['date'] = '{}/{}'.format(month, year) dataframe['polluant'] = p dataframe.to_excel( ('./data/processedData/{}_{}_nuts1_{}_{}.xlsx' ).format(zone, p, year, month)) except: pass elif n == nuts2: try: res = [i for i in n if '.shp' in i] dataframe, jsonfile = generate_dataframe( ('{}/{}/shapefiles/nuts2/{}').format( path, zone, res[0]), ('{}/{}/polluant/{}/{}').format( path, zone, p, tif)) dataframe['year'] = int(year) dataframe['month'] = int(month) dataframe['date'] = '{}/{}'.format(month, year) dataframe['polluant'] = p dataframe.to_excel( ('./data/processedData/{}_{}_nuts2_{}_{}.xlsx' ).format(zone, p, year, month)) except: pass else: try: res = [i for i in n if '.shp' in i] dataframe, jsonfile = generate_dataframe( ('{}/{}/shapefiles/nuts3/{}').format( path, zone, res[0]), ('{}/{}/polluant/{}/{}').format( path, zone, p, tif)) dataframe['year'] = int(year) dataframe['month'] = int(month) dataframe['date'] = '{}/{}'.format(month, year) dataframe['polluant'] = p dataframe.to_excel( ('./data/processedData/{}_{}_nuts3_{}_{}.xlsx' ).format(zone, p, year, month)) except: pass return def generate_from_polluant(path, zone, polluant): pelement = os.listdir(('{}/{}/polluant/{}').format(path, zone, polluant)) nuts1 = os.listdir(('{}/{}/shapefiles/nuts1').format(path, zone)) nuts2 = os.listdir(('{}/{}/shapefiles/nuts2').format(path, zone)) nuts3 = os.listdir(('{}/{}/shapefiles/nuts3').format(path, zone)) for tif in pelement: if ".xlsx" not in tif: part = tif.split("_") year = part[1] month = part[2] month = month.split(".") month = month[0] month = str(int(month)) for n in [nuts1, nuts2, nuts3]: if n == nuts1: try: res = [i for i in n if '.shp' in i] dataframe, jsonfile = generate_dataframe( ('{}/{}/shapefiles/nuts1/{}').format( path, zone, res[0]), ('{}/{}/polluant/{}/{}').format( path, zone, polluant, tif)) dataframe['year'] = int(year) dataframe['month'] = int(month) dataframe['date'] = '{}/{}'.format(month, year) dataframe['polluant'] = polluant dataframe.to_excel( ('./data/processedData/{}_{}_nuts1_{}_{}.xlsx' ).format(zone, polluant, year, month)) except: pass elif n == nuts2: try: res = [i for i in n if '.shp' in i] dataframe, jsonfile = generate_dataframe( ('{}/{}/shapefiles/nuts2/{}').format( path, zone, res[0]), ('{}/{}/polluant/{}/{}').format( path, zone, polluant, tif)) dataframe['year'] = int(year) dataframe['month'] = int(month) dataframe['date'] = '{}/{}'.format(month, year) dataframe['polluant'] = polluant dataframe.to_excel( ('./data/processedData/{}_{}_nuts2_{}_{}.xlsx' ).format(zone, polluant, year, month)) except: pass else: try: res = [i for i in n if '.shp' in i] dataframe, jsonfile = generate_dataframe( ('{}/{}/shapefiles/nuts3/{}').format( path, zone, res[0]), ('{}/{}/polluant/{}/{}').format( path, zone, polluant, tif)) dataframe['year'] = int(year) dataframe['month'] = int(month) dataframe['date'] = '{}/{}'.format(month, year) dataframe['polluant'] = polluant dataframe.to_excel( ('./data/processedData/{}_{}_nuts3_{}_{}.xlsx' ).format(zone, polluant, year, month)) except: pass return def generate_from_nuts(n, path, zone, nutfile): poll = os.listdir(('{}/{}/polluant').format(path, zone)) for p in poll: if ".xlsx" not in p: ppath = os.path.join(('{}/{}/polluant/').format(path, zone), p) pelement = os.listdir(ppath) for tif in pelement: if ".xlsx" not in tif: part = tif.split("_") year = part[1] month = part[2] month = month.split(".") month = month[0] month = str(int(month)) #try: dataframe, jsonfile = generate_dataframe( ('{}/{}/shapefiles/{}/{}').format( path, zone, n, nutfile), ('{}/{}/polluant/{}/{}').format(path, zone, p, tif)) dataframe['year'] = int(year) dataframe['month'] = int(month) dataframe['date'] = '{}/{}'.format(month, year) dataframe['polluant'] = p dataframe.to_excel( ('./data/processedData/{}_{}_{}_{}_{}.xlsx').format( zone, p, n, year, month)) #except: # pass return def generate_from_tif(path, zone, p, tif): nuts1 = os.listdir(('{}/{}/shapefiles/nuts1').format(path, zone)) nuts2 = os.listdir(('{}/{}/shapefiles/nuts2').format(path, zone)) nuts3 = os.listdir(('{}/{}/shapefiles/nuts3').format(path, zone)) part = tif.split("_") year = part[1] month = part[2] month = month.split(".") month = month[0] month = str(int(month)) for n in [nuts1, nuts2, nuts3]: if n == nuts1: try: res = [i for i in n if '.shp' in i] dataframe, jsonfile = generate_dataframe( ('{}/{}/shapefiles/nuts1/{}').format(path, zone, res[0]), ('{}/{}/polluant/{}/{}').format(path, zone, p, tif)) dataframe['year'] = int(year) dataframe['month'] = int(month) dataframe['date'] = '{}/{}'.format(month, year) dataframe['polluant'] = p dataframe.to_excel( ('./data/processedData/{}_{}_nuts1_{}_{}.xlsx').format( zone, p, year, month)) except: pass elif n == nuts2: try: res = [i for i in n if '.shp' in i] dataframe, jsonfile = generate_dataframe( ('{}/{}/shapefiles/nuts2/{}').format(path, zone, res[0]), ('{}/{}/polluant/{}/{}').format(path, zone, p, tif)) dataframe['year'] = int(year) dataframe['month'] = int(month) dataframe['date'] = '{}/{}'.format(month, year) dataframe['polluant'] = p dataframe.to_excel( ('./data/processedData/{}_{}_nuts2_{}_{}.xlsx').format( zone, p, year, month)) except: pass else: try: res = [i for i in n if '.shp' in i] dataframe, jsonfile = generate_dataframe( ('{}/{}/shapefiles/nuts3/{}').format(path, zone, res[0]), ('{}/{}/polluant/{}/{}').format(path, zone, p, tif)) dataframe['year'] = int(year) dataframe['month'] = int(month) dataframe['date'] = '{}/{}'.format(month, year) dataframe['polluant'] = p dataframe.to_excel( ('./data/processedData/{}_{}_nuts3_{}_{}.xlsx').format( zone, p, year, month)) except: pass return def check_new_countries(path): ''' This function allow us to check the countries directory and generate csvs from newly added regions ''' zones = os.listdir(path) ancien =
pd.read_excel("./data/rawData/ancienCountries.xlsx")
pandas.read_excel
import requests from bs4 import BeautifulSoup as bs import pandas as pd import datetime now = datetime.datetime.now() spotrac_ids = ['Boston Red Sox BOS', 'San Francisco Giants SF', 'Chicago Cubs CHC', 'Washington Nationals WSH', 'Los Angeles Dodgers LAD', 'Los Angeles Angels LAA', 'New York Yankees NYY', 'Toronto Blue Jays TOR', 'St. Louis Cardinals STL', 'New York Mets NYM', 'Houston Astros HOU', 'Seattle Mariners SEA', 'Texas Rangers TEX', 'Baltimore Orioles BAL', 'Colorado Rockies COL', 'Detroit Tigers DET', 'Cleveland Indians CLE', 'Arizona Diamondbacks ARI', 'Kansas City Royals KC', 'Minnesota Twins MIN', 'Atlanta Braves ATL', 'Philadelphia Phillies PHI', 'Miami Marlins MIA', 'San Diego Padres SD', 'Cincinnati Reds CIN', 'Pittsburgh Pirates PIT', 'Milwaukee Brewers MIL', 'Tampa Bay Rays TB', 'Oakland Athletics OAK', 'Chicago White Sox CHW'] fangraphs_ids = ['Red Sox','Giants','Cubs','Nationals','Dodgers','Angels', 'Yankees','Blue Jays','Cardinals','Mets','Astros','Mariners','Rangers', 'Orioles','Rockies','Tigers','Indians','Diamondbacks','Royals','Twins', 'Braves','Phillies','Marlins','Padres','Reds','Pirates','Brewers','Rays', 'Athletics','White Sox'] class TeamLeaderboard: def __init__(self,year): if (int(year) < 2011): raise ValueError('Incomplete or missing data from this year! Please try another year.') pd.options.mode.chained_assignment = None #this keeps my console from getting spammed with stupid messages team_url = ('https://www.fangraphs.com/leaders.aspx?pos=all&stats=bat&lg=all&qual=0&type=c,53,11,6,111,199,3,58&season=%s&month=0&season1=%s&ind=0&team=0,ts&rost=&age=&filter=&players=0' % (str(year),str(year))) team_page = requests.get(team_url) team_soup = bs(team_page.content, 'html.parser') table = team_soup.find(lambda tag: tag.name=='table' and tag.has_attr('id') and tag['id']=="LeaderBoard1_dg1_ctl00") df = pd.read_html(str(table),header=1) df = df[0] df = df.iloc[:-1] df['PA'] = pd.to_numeric(df['PA'], downcast="float") if (min(list(df['PA'])) >= 225): #makes sure that at least a week of play has passed roughly #This part grabs and attaches bullpen xFIP data to the main DF bullpen_url = ('https://www.fangraphs.com/leaders.aspx?pos=all&stats=rel&lg=all&qual=0&type=c,6,62&season=%s&month=0&season1=%s&ind=0&team=0,ts&rost=0&age=0&filter=&players=0' % (str(year),str(year))) bullpen_page = requests.get(bullpen_url) bullpen_soup = bs(bullpen_page.content, 'html.parser') table = bullpen_soup.find(lambda tag: tag.name=='table' and tag.has_attr('id') and tag['id']=="LeaderBoard1_dg1_ctl00") bp_df = pd.read_html(str(table),header=1) bp_df = bp_df[0] bp_df = bp_df.iloc[:-1] df = df.merge(bp_df, on='Team') #This part, a pain in the ass, attaches payroll data from SportTrac to the main DF payroll_url = 'https://www.spotrac.com/mlb/payroll/' payroll_page = requests.get(payroll_url) payroll_soup = bs(payroll_page.content,'lxml') table = payroll_soup.find_all('table')[0] pr_df = pd.read_html(str(table),header=0) pr_df = pr_df[0] pr_df.loc[pr_df['Team'] != 'League Average'] #removes annoying "league average" stuff for index in range(0,len(spotrac_ids)): #replaces spotrac ids with FanGraphs IDs pr_df['Team'].loc[pr_df['Team'] == spotrac_ids[index]] = fangraphs_ids[index] df = df.merge(pr_df, on='Team') #grabs pitching WAR and Wins to determine team luckiness pitch_url = ('https://www.fangraphs.com/leaders.aspx?pos=all&stats=pit&lg=all&qual=0&type=c,59,4&season=%s&month=0&season1=%s&ind=0&team=0,ts&rost=0&age=0&filter=&players=0' % (str(year),str(year))) pitch_page = requests.get(pitch_url) pitch_soup = bs(pitch_page.content, 'html.parser') table = pitch_soup.find(lambda tag: tag.name=='table' and tag.has_attr('id') and tag['id']=="LeaderBoard1_dg1_ctl00") pit_df = pd.read_html(str(table),header=1) pit_df = pit_df[0] pit_df = pit_df.iloc[:-1] df = df.merge(pit_df, on='Team') #grabs park factors for adjusting HR rate pf_url = ('https://www.fangraphs.com/guts.aspx?type=pf&teamid=0&season=%s' % (str(year))) pf_page = requests.get(pf_url) pf_soup = bs(pf_page.content,'html.parser') table = pf_soup.find(lambda tag: tag.name=='table' and tag.has_attr('id') and tag['id']=="GutsBoard1_dg1_ctl00") pf_df = pd.read_html(str(table),header=0) pf_df = pf_df[0] df = df.merge(pf_df, on='Team') #calculates NERD df['Bat'] = pd.to_numeric(df['Bat'], downcast="float") df['HR_x'] = pd.to_numeric(df['HR_x'], downcast="float") df['HR_y'] = pd.to_numeric(df['HR_y'], downcast="float") df['BsR'] = pd.to_numeric(df['BsR'], downcast="float") df['xFIP'] = pd.to_numeric(df['xFIP'], downcast="float") df['Def'] = pd.to_numeric(df['Def'], downcast="float") df['Total Payroll'] = df[str(now.year) + ' Total Payroll'].replace('[\$,]', '', regex=True).astype(float) df['Total Payroll'] = pd.to_numeric(df['Total Payroll'], downcast="float") df['Age'] = pd.to_numeric(df['Age'], downcast="float") df['WAR_x'] = pd.to_numeric(df['WAR_x'], downcast="float") df['WAR_y'] = pd.to_numeric(df['WAR_y'], downcast="float") df['W'] = pd.to_numeric(df['W'], downcast="float") df['zBat'] = (df['Bat'] - df['Bat'].mean())/df['Bat'].std(ddof=0) #Finds Z-score values for calculation df['HRpPA'] = df['HR_x'] / df['PA'] #calculates HR per PA per team df['HRpPA'] = df['HRpPA'] * df['HR_y'] / 100 #adjusts for park factors df['zHRpPA'] = (df['HRpPA'] - df['HRpPA'].mean())/df['HRpPA'].std(ddof=0) df['zBsR'] = (df['BsR'] - df['BsR'].mean())/df['BsR'].std(ddof=0) df['zBull'] = -((df['xFIP'] - df['xFIP'].mean())/df['xFIP'].std(ddof=0)) df['zDef'] = (df['Def'] - df['Def'].mean())/df['Def'].std(ddof=0) df['Total Payroll'] = df['Total Payroll'].replace('[\$,]', '', regex=True).astype(float) #converts dollar amounts to numbers df['zPay'] = -((df['Total Payroll'] - df['Total Payroll'].mean())/df['Total Payroll'].std(ddof=0)) df['zAge'] = -((df['Age'] - df['Age'].mean())/df['Age'].std(ddof=0)) df['tWAR'] = df['WAR_x'] + df['WAR_y'] df['Luck'] = (df['tWAR'] - df['W'])/20 #Adjusted for calculation df['zPay'][df['zPay'] < 0] = 0 #replaces values. These throw warnings for no reason because Pandas can't act like R without throwing a goddamn fit df['zAge'][df['zAge'] < 0] = 0 df['Luck'][df['Luck'] < 0] = 0 df['Luck'][df['Luck'] > 2] = 2 df['NERD'] = df['zBat'] + df['zHRpPA'] + df['zBsR'] + (df['zBull'] / 2) + (df['zDef'] / 2) + df['zPay'] + df['zAge'] + df['Luck'] #unadjusted NERD df['NERD'] = (((df['NERD'] - min(list(df['NERD']))) * (10)) / (max(list(df['NERD'])) - min(list(df['NERD'])))) #feature scaled self.df = df self.year = year else: #This does the exact same stuff as above, except it does it for the previous year if there aren't enough teams in the previous year. pd.options.mode.chained_assignment = None #this keeps my console from getting spammed with stupid messages team_url = ('https://www.fangraphs.com/leaders.aspx?pos=all&stats=bat&lg=all&qual=0&type=c,53,11,6,111,199,3,58&season=%s&month=0&season1=%s&ind=0&team=0,ts&rost=&age=&filter=&players=0' % (str(year-1),str(year-1))) team_page = requests.get(team_url) team_soup = bs(team_page.content, 'html.parser') table = team_soup.find(lambda tag: tag.name=='table' and tag.has_attr('id') and tag['id']=="LeaderBoard1_dg1_ctl00") df = pd.read_html(str(table),header=1) df = df[0] df = df.iloc[:-1] bullpen_url = ('https://www.fangraphs.com/leaders.aspx?pos=all&stats=rel&lg=all&qual=0&type=c,6,62&season=%s&month=0&season1=%s&ind=0&team=0,ts&rost=0&age=0&filter=&players=0' % (str(year-1),str(year-1))) bullpen_page = requests.get(bullpen_url) bullpen_soup = bs(bullpen_page.content, 'html.parser') table = bullpen_soup.find(lambda tag: tag.name=='table' and tag.has_attr('id') and tag['id']=="LeaderBoard1_dg1_ctl00") bp_df = pd.read_html(str(table),header=1) bp_df = bp_df[0] bp_df = bp_df.iloc[:-1] df = df.merge(bp_df, on='Team') #This part, a pain in the ass, attaches payroll data from SportTrac to the main DF payroll_url = 'https://www.spotrac.com/mlb/payroll/' #yo, please don't use this to do previous years because payroll data might be off payroll_page = requests.get(payroll_url) payroll_soup = bs(payroll_page.content,'lxml') table = payroll_soup.find_all('table')[0] pr_df = pd.read_html(str(table),header=0) pr_df = pr_df[0] pr_df = pr_df.loc[:14].append(pr_df.loc[17:]) #removes annoying "league average" stuff for index in range(0,len(spotrac_ids)): #replaces spotrac ids with FanGraphs IDs pr_df['Team'].loc[pr_df['Team'] == spotrac_ids[index]] = fangraphs_ids[index] df = df.merge(pr_df, on='Team') #grabs pitching WAR and Wins to determine team luckiness pitch_url = ('https://www.fangraphs.com/leaders.aspx?pos=all&stats=pit&lg=all&qual=0&type=c,59,4&season=%s&month=0&season1=%s&ind=0&team=0,ts&rost=0&age=0&filter=&players=0' % (str(year-1),str(year-1))) pitch_page = requests.get(pitch_url) pitch_soup = bs(pitch_page.content, 'html.parser') table = pitch_soup.find(lambda tag: tag.name=='table' and tag.has_attr('id') and tag['id']=="LeaderBoard1_dg1_ctl00") pit_df = pd.read_html(str(table),header=1) pit_df = pit_df[0] pit_df = pit_df.iloc[:-1] df = df.merge(pit_df, on='Team') #grabs park factors for adjusting HR rate pf_url = ('https://www.fangraphs.com/guts.aspx?type=pf&teamid=0&season=%s' % (str(year-1))) pf_page = requests.get(pf_url) pf_soup = bs(pf_page.content,'html.parser') table = pf_soup.find(lambda tag: tag.name=='table' and tag.has_attr('id') and tag['id']=="GutsBoard1_dg1_ctl00") pf_df = pd.read_html(str(table),header=0) pf_df = pf_df[0] df = df.merge(pf_df, on='Team') #calculates NERD df['Bat'] =
pd.to_numeric(df['Bat'], downcast="float")
pandas.to_numeric
import os, glob import pandas as pd import numpy as np import torch from itertools import compress def imorphics_info(): df = pd.read_excel(os.getenv("HOME") + '/Dropbox/Z_DL/OAIDataBase/oai_active_contour_parameters.xlsx') df['subject_id'] = df['subject_id'].values.astype(np.int32) return df def moaks00(): return pd.read_csv(os.getenv("HOME") + '/Dropbox/Z_DL/OAIDataBase/moaks00.csv') def locate_lateral_and_medial(slices, pick=False): """ Select certain slices by the z-locations""" dess_info = oai_dess_info() for i in list(slices.keys()): loc = dess_info.loc[dess_info['ID'] == i] if pick == 'lateral': slices[i] = [x for x in slices[i] if int(x.split('_')[1]) in list(range(loc['lateral0'].values[0], loc['lateral1'].values[0] + 1))] if pick == 'medial': slices[i] = [x for x in slices[i] if int(x.split('_')[1]) in list(range(loc['medial0'].values[0], loc['medial1'].values[0] + 1))] return slices def slice_location_normalized(dess_info, id, scheme=2): """ slices location information""" i = int(id.split('_')[0]) s = int(id.split('_')[1]) side, s_0, s_1, lateral0, lateral1, medial0, medial1 \ = dess_info.loc[dess_info['ID'] == i, ['side', 's_0', 's_1', 'lateral0', 'lateral1', 'medial0', 'medial1']].values[0] if scheme == 1: if side == 2: return (s - medial0) / (lateral1 - medial0) elif side == 1: return (s - medial1) / (lateral0 - medial1) # lateral---notch---medial # 0 1 2 3 elif scheme == 2: if side == 2: if s >= lateral0: return (s - s_1) / (lateral0 - s_1) elif s >= medial1: return (s - lateral0) / (medial1 - lateral0) + 1 #elif s >= s_0: # return (s - medial1) / (s_0 - medial1) + 2 else: return (s - medial1) / (s_0 - medial1) + 2 elif side == 1: if s <= lateral1: return (s - s_0) / (lateral1 - s_0) elif s <= medial0: return (s - lateral1) / (medial0 - lateral1) + 1 #elif s <= s_1: # return (s - medial0) / (s_1 - medial0) + 2 else: return (s - medial0) / (s_1 - medial0) + 2 def get_ids_by_subjects(dir_img, method): neighbors = dict() slices = dict() dess_info = imorphics_info() """Returns a list of the ids in the directory""" if method == 'automatic': ids = list(set([f.split('/')[-1].split('.')[0] for f in glob.glob(dir_img+'*')])) ids = [tuple(int(y) for y in (x.split('_'))) for x in ids] ids = sorted(ids, key=lambda element: [e for e in element]) slices_all = dict() for x in ids: if x[0] not in slices_all: slices_all[x[0]] = list() slices_all[x[0]].append('_'.join([str(y) for y in x])) subjects = list(slices_all.keys()) subjects.sort() for s in subjects: slices[s] = slices_all[s] if method == 'manual': subjects = list(dess_info['ID']) for s in subjects: slice_range = list(range(dess_info.loc[dess_info['ID'] == s, 's_0'].values[0], dess_info.loc[dess_info['ID'] == s, 's_1'].values[0] + 4, 4)) slices[s] = [str(s) + '_' + str(y) for y in slice_range] for x in slices[s]: neighbors[x] = [x] return subjects, slices def imorphics_dess_info(): dess_info = oai_dess_info() subjects = [(dess_info.iloc[i]['subject_id'], dess_info.iloc[i]['tags'] + '_imorphics') for i in range(len(dess_info['ID']))] crop = {'subjects': subjects, 'cropx0': dess_info['cropx0'], 'cropx1': dess_info['cropx1'], 'cropy0': dess_info['cropy0'], 'cropy1': dess_info['cropy1']} crop = pd.DataFrame(crop) zrange = {'subjects': subjects, 's_0': dess_info['s_0'], 's_1': dess_info['s_1']} zrange = pd.DataFrame(zrange) return subjects, crop, zrange def oai_mri_info(dir_img, dir_tag, crop_file): subjects = glob.glob(dir_img + dir_tag + '/*') subjects.sort() subjects = [(int(x.split(dir_img + dir_tag + '/')[1].split('.')[0]), dir_tag) for x in subjects] if crop_file is not None: crop_file['subjects'] = subjects crop = crop_file[['subjects', 'cropx0', 'cropx1', 'cropy0', 'cropy1']] zrange = crop_file[['subjects', 's_0', 's_1']] else: crop = None zrange = None return subjects, crop, zrange def dess_crop_files(x): df = pd.read_csv(x, header=None) df.columns = ['ID', 's_0', 's_1', 'cropx0', 'cropx1', 'cropy0', 'cropy1'] df['ID'] = df['ID'].astype(np.int32) return df def get_oai_XR(subjects, tags): """ labels""" df = pd.read_csv('/home/ghc/Dropbox/Z_DL/scripts/OAI_stats/collected/XR.csv') y = dict() y['subjects'] = subjects for tag in tags: label = [] for x in subjects: try: label.append(df.loc[(df['ID'] == x[0]) & (df['SIDE'] == 2), tag].values[0]) except: label.append(np.nan) y[tag] = np.array(label) labels =
pd.DataFrame(y)
pandas.DataFrame
from ...cost.metrics_datadog import DatadogManager, DatadogAssistant, DataNotFoundForHostInDdg, HostNotFoundInDdg, DatadogCached import pandas as pd import pytest @pytest.fixture def datadog_assistant(mocker): def factory(series=[], host_list=[]): mockreturn = lambda *args, **kwargs: {'series': series, 'status': 'ok'} mockee = 'datadog.api.Metric.query' mocker.patch(mockee, side_effect=mockreturn) mockreturn = lambda *args, **kwargs: {'total_returned': len(host_list), 'host_list': host_list} mockee = 'datadog.api.Hosts.search' mocker.patch(mockee, side_effect=mockreturn) # set start/end import datetime as dt from datetime import timedelta dt_now = dt.datetime.now() dt_1w = dt_now - timedelta(days=7) dda = DatadogAssistant(dt_1w, dt_now, host_id='i-123456') return dda return factory class TestDatadogAssistant: def test_init(self, datadog_assistant): dda = datadog_assistant([]) assert True def test_getMetricsCore_noData(self, datadog_assistant): dda = datadog_assistant(series=[]) with pytest.raises(DataNotFoundForHostInDdg): df = dda._get_metrics_core(None, 'Average') def test_getMetricsCore_ok(self, datadog_assistant): dda = datadog_assistant(series=[{'pointlist': [{'ts_int': 1234567, 'Average': 2}]}]) df = dda._get_metrics_core(None, 'Average') assert df.shape[0]==1 def test_getMeta_noData(self, datadog_assistant): dda = datadog_assistant(host_list=[]) with pytest.raises(HostNotFoundInDdg): df = dda._get_meta() def test_getMeta_ok(self, datadog_assistant): dda = datadog_assistant(host_list=[{'meta': {'gohai': '{"memory": {"total": "10kB"}}', 'cpuCores': 2}, 'name': 'i-123456'}]) res = dda._get_meta() assert res=={'cpuCores': 2, 'memory_total': 10240} def test_getMetricsXxxYyy(self, datadog_assistant): pointlist = [{'ts_int': 1234567, 'cpu_idle_min': 2.5, 'cpu_idle_avg': 2.5, 'ram_free_min': 10, 'ram_free_avg': 5}] dda = datadog_assistant( series=[{'pointlist': pointlist}], host_list=[{'meta': {'gohai': '{"memory": {"total": "10kB"}}', 'cpuCores': 2}, 'name': 'i-123456'}], ) actual = dda.get_metrics_cpu_max() assert actual.shape[0]==1 assert actual.shape[1]==3 # columns: cpu_idle_min ts_dt cpu_used_max actual = dda.get_metrics_cpu_avg() assert actual.shape[0]==1 assert actual.shape[1]==3 actual = dda.get_metrics_ram_max() assert actual.shape[0]==1 assert actual.shape[1]==3 actual = dda.get_metrics_ram_avg() assert actual.shape[0]==1 assert actual.shape[1]==3 @pytest.fixture def datadog_manager(mocker): def factory(): mockreturn = lambda *args, **kwargs: None mockee = 'datadog.initialize' mocker.patch(mockee, side_effect=mockreturn) ddm = DatadogManager() return ddm return factory @pytest.fixture def ddgenv_set(monkeypatch): monkeypatch.setenv('DATADOG_API_KEY', 'abcdef') monkeypatch.setenv('DATADOG_APP_KEY', 'abcdef') @pytest.fixture def ddgenv_missing(monkeypatch): monkeypatch.delenv('DATADOG_API_KEY') monkeypatch.delenv('DATADOG_APP_KEY') class TestDatadogManager: def test_init(self, datadog_manager): ddm = datadog_manager() assert True # no exception def test_isConfigured_true(self, datadog_manager, ddgenv_set): ddm = datadog_manager() assert ddm.is_configured() def test_isConfigured_false(self, datadog_manager, ddgenv_missing): ddm = datadog_manager() assert not ddm.is_configured() def test_getMetricsAll(self, datadog_manager, mocker): def mymock(mr, me): mockreturn = lambda *args, **kwargs: mr mockee = 'isitfit.cost.metrics_datadog.DatadogAssistant.%s'%me mocker.patch(mockee, side_effect=mockreturn) import datetime as dt dtnow = dt.datetime.now() mockees = [ ( pd.DataFrame({'ts_int':[1], 'ts_dt':[dtnow], 'cpu_used_max': [3]}), 'get_metrics_cpu_max' ), ( pd.DataFrame({'ts_int':[1], 'ts_dt':[dtnow], 'cpu_used_avg': [3]}), 'get_metrics_cpu_avg' ), ( pd.DataFrame({'ts_int':[1], 'ts_dt':[dtnow], 'cpu_used_min': [3]}), 'get_metrics_cpu_min' ), ( pd.DataFrame({'ts_int':[1], 'ts_dt':[dtnow], 'ram_used_max': [3]}), 'get_metrics_ram_max' ), ( pd.DataFrame({'ts_int':[1], 'ts_dt':[dtnow], 'ram_used_avg': [3]}), 'get_metrics_ram_avg' ), ( pd.DataFrame({'ts_int':[1], 'ts_dt':[dtnow], 'ram_used_min': [3]}), 'get_metrics_ram_min' ), ( pd.DataFrame({'ts_int':[1], 'ts_dt':[dtnow], 'nhours': [3]}), 'get_metrics_count' ), ] for mr, me in mockees: mymock(mr, me) ddm = datadog_manager() actual = ddm.get_metrics_all('i-123456') assert actual.shape[0]==1 assert actual.shape[1]==8 # columns: ts_dt cpu_used_max cpu_used_avg cpu_used_min ram_used_max ram_used_avg ram_used_min nhours @pytest.fixture def cache_man(mocker): """ Mocked cache manager """ class MockCacheMan: def __init__(self): self._map = {} self.ready = False def isReady(self): return self.ready def get(self, key): return self._map.get(key) def set(self, key, val): self._map[key] = val cache_man = MockCacheMan() mocker.spy(cache_man, 'get') mocker.spy(cache_man, 'set') return cache_man class TestDatadogCachedGetMetricsDerived: def test_notReady_noData(self, mocker, cache_man): # mock parent # mockreturn = lambda *args, **kwargs: pd.DataFrame() def mockreturn(*args, **kwargs): raise DataNotFoundForHostInDdg mockee = 'isitfit.cost.metrics_datadog.DatadogManager.get_metrics_all' mocker.patch(mockee, side_effect=mockreturn) ddc = DatadogCached(cache_man) # after first call with pytest.raises(DataNotFoundForHostInDdg): actual = ddc.get_metrics_derived(None, 'i-123456', None) assert cache_man.get.call_count == 0 assert cache_man.set.call_count == 0 assert cache_man._map == {} # after 2nd call with pytest.raises(DataNotFoundForHostInDdg): actual = ddc.get_metrics_derived(None, 'i-123456', None) assert cache_man.get.call_count == 0 assert cache_man.set.call_count == 0 assert cache_man._map == {} def test_notReady_yesData(self, mocker, cache_man): # mock parent mockreturn = lambda *args, **kwargs: pd.DataFrame({'a': [1,2,3]}) mockee = 'isitfit.cost.metrics_datadog.DatadogManager.get_metrics_all' mocker.patch(mockee, side_effect=mockreturn) ddc = DatadogCached(cache_man) actual = ddc.get_metrics_derived(None, 'i-123456', None) assert actual is not None assert actual.shape[0]==3 assert cache_man.get.call_count == 0 assert cache_man.set.call_count == 0 assert cache_man._map == {} def test_yesReady_noData(self, mocker, cache_man): # mark as ready cache_man.ready = True # mock parent # mockreturn = lambda *args, **kwargs: pd.DataFrame() def mockreturn(*args, **kwargs): raise DataNotFoundForHostInDdg mockee = 'isitfit.cost.metrics_datadog.DatadogManager.get_metrics_all' mocker.patch(mockee, side_effect=mockreturn) ddc = DatadogCached(cache_man) host_id = 'i-123456' # after first call with pytest.raises(DataNotFoundForHostInDdg): actual = ddc.get_metrics_derived(None, host_id, None) assert cache_man.get.call_count == 1 # checks cache and doesn't find key assert cache_man.set.call_count == 1 # first set key assert callable(cache_man._map[ddc.get_key(host_id)]) # after 2nd call with pytest.raises(DataNotFoundForHostInDdg): actual = ddc.get_metrics_derived(None, host_id, None) assert cache_man.get.call_count == 2 # incremented assert cache_man.set.call_count == 1 # no increment assert callable(cache_man._map[ddc.get_key(host_id)]) def test_yesReady_invalidCache(self, mocker, cache_man): # enable mocked cache cache_man.ready = True # set key in cache host_id = 'i-123456' ddc = DatadogCached(cache_man) cache_man._map[ddc.get_key(host_id)] = pd.DataFrame() # fetch will raise with pytest.raises(Exception): actual = ddc.get_metrics_derived(None, host_id, None) def test_yesReady_yesData(self, mocker, cache_man): # mark as ready cache_man.ready = True # mock parent mockreturn = lambda *args, **kwargs:
pd.DataFrame({'a': [1,2,3]})
pandas.DataFrame
from datetime import datetime import json from collections import OrderedDict import os.path from math import log from math import e from sklearn.preprocessing import minmax_scale from sklearn.preprocessing import MinMaxScaler import numpy as np from math import sqrt import pandas as pd data = OrderedDict() weights = [] lat = [] long = [] num_points = 500 if os.path.isfile('maps.json') : with open ('maps.json', 'r+') as fp: data = json.load(fp, object_pairs_hook=OrderedDict) for key in range(len(list(data.keys()))): if key > num_points: break stored = data[list(data.keys())[len(list(data.keys())) - 1 - key]] month = stored['Month'] day = stored['Day'] year = stored['Year'] lat.append(stored['Latitude']) long.append(stored['Longitude']) date = month + " " + str(day) + ", " + str(year) date_format = "%B %d, %Y" now = datetime.now() date_object = datetime.strptime(date, date_format) delta = now - date_object num_hours = delta.days*24 if num_hours != 0: weights.append(sqrt(1.0/num_hours) * 1000) else: weights.append(25) weights = np.array(weights) weights = weights.reshape(-1, 1) min_max_scaler = MinMaxScaler(feature_range=(0, 2)) weights = min_max_scaler.fit_transform(np.float32(weights)) weights = weights.tolist() points = OrderedDict() long_shit = [] lat_shit = [] weight_shit = [] for i in range(num_points): long_shit.append(long[i]) lat_shit.append(lat[i]) weight_shit.append(weights[i][0]) df =
pd.DataFrame()
pandas.DataFrame
# general import math import logging import json import os,sys from pIMZ.regions import SpectraRegion import random from collections import defaultdict, Counter import glob import shutil, io, base64 # general package from natsort import natsorted import pandas as pd import numpy as np from numpy.ctypeslib import ndpointer from pyimzml.ImzMLParser import ImzMLParser, browse, getionimage import ms_peak_picker import regex as re # image import skimage from skimage import measure as sk_measure from adjustText import adjust_text # processing import ctypes import subprocess import dill as pickle #vis import dabest import matplotlib import matplotlib.pyplot as plt import seaborn as sns #methods import umap import hdbscan import diffxpy.api as de import anndata from scipy import ndimage, misc, sparse from scipy.sparse.linalg import spsolve from scipy.spatial.distance import squareform, pdist import scipy.cluster as spc import scipy as sp import sklearn as sk from sklearn.metrics.pairwise import cosine_similarity #web/html import jinja2 # applications import progressbar class CombinedSpectra(): """CombinedSpectra class for a combined analysis of several spectra regions. """ def __setlogger(self): """Sets up logging facilities for CombinedSpectra. """ self.logger = logging.getLogger('CombinedSpectra') if len(self.logger.handlers) == 0: self.logger.setLevel(logging.INFO) consoleHandler = logging.StreamHandler() consoleHandler.setLevel(logging.INFO) self.logger.addHandler(consoleHandler) formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s: %(message)s') consoleHandler.setFormatter(formatter) def __init__(self, regions): """Initializes a CombinedSpectra object with the following attributes: - logger (logging.Logger): Reference to the Logger object. - regions (dict): A dictionary that has SpectraRegion objects names as keys and respective SpectraRegion objects as values. If a SpectraRegion object does not have a name attribute it will be named according to the region id. - consensus_similarity_matrix (pandas.DataFrame): Pairwise similarity matrix between consensus spectra of all combinations of regions. Initialized with None. - region_cluster2cluster (dict): A dictionary where every tuple (region name, region id) is mapped to its cluster id where it belongs. Initialized with None. - region_array_scaled (dict): A dictionary where each SpectraRegion name is mapped to the respective scaled region array either using "avg" (average) or "median" method. Initialized with an empty dict. - de_results_all (dict): Methods mapped to their differential analysis results (as pd.DataFrame). Initialized with an empty defaultdict. Args: regions (dict): A dictionary that maps region ids to respective SpectraRegion objects. """ self.regions = {} self.consensus_similarity_matrix = None self.region_cluster2cluster = None self.region_array_scaled = {} self.de_results_all = defaultdict(lambda: dict()) self.df_results_all = defaultdict(lambda: dict()) self.logger = None self.__setlogger() for x in regions: addregion = regions[x] if addregion.name == None: addregion.name = x self.regions[addregion.name] = regions[x] def __get_spectra_similarity(self, vA, vB): """Calculates cosine similarity between two vectors of the same length. Args: vA (numpy.array/list): First vector. vB (numpy.array/list): Second vector. Returns: float: cosine similarity. """ if (np.all((vA == 0)) or np.all((vB == 0))): return 0 return np.dot(vA, vB) / (np.sqrt(np.dot(vA,vA)) * np.sqrt(np.dot(vB,vB))) def consensus_similarity(self): """ Calculates consensus_similarity_matrix of CombinedSpectra object. The resulting pandas.DataFrame is a pairwise similarity matrix between consensus spectra of all combinations of regions. If the object was not yet scaled, it will get scaled. """ self.check_scaled() allConsSpectra = {} for regionName in self.region_array_scaled: scaled_region = self.region_array_scaled[regionName] region = self.regions[regionName] regionCS = region.consensus_spectra(array=scaled_region, set_consensus=False) for clusterid in regionCS: allConsSpectra[(regionName, clusterid)] = regionCS[clusterid] allRegionClusters = sorted([x for x in allConsSpectra]) distDF = pd.DataFrame(0.0, index=allRegionClusters, columns=allRegionClusters) for i in range(0, len(allRegionClusters)): regionI = allRegionClusters[i] for j in range(i, len(allRegionClusters)): regionJ = allRegionClusters[j] specSim = self.__get_spectra_similarity(allConsSpectra[regionI], allConsSpectra[regionJ]) distDF[regionI][regionJ] = specSim distDF[regionJ][regionI] = specSim self.consensus_similarity_matrix = distDF def plot_consensus_similarity(self): """Plots the similarity matrix represented as seaborn.heatmap. """ sns.heatmap(self.consensus_similarity_matrix, xticklabels=1, yticklabels=1) plt.show() plt.close() def cluster_concensus_spectra(self, number_of_clusters=5): """Performs clustering using Ward variance minimization algorithm on similarity matrix of consensus spectra and updates region_cluster2cluster with the results. region_cluster2cluster dictionary maps every tuple (region name, region id) to its cluster id where it belongs. Additionally plots the resulting dendrogram depicting relationships of regions to each other. Args: number_of_clusters (int, optional): Number of desired clusters. Defaults to 5. """ df = self.consensus_similarity_matrix.copy() # Calculate the distance between each sample Z = spc.hierarchy.linkage(df.values, 'ward') plt.figure(figsize=(8,8)) # Make the dendro spc.hierarchy.dendrogram(Z, labels=df.columns.values, leaf_rotation=0, orientation="left", color_threshold=240, above_threshold_color='grey') c = spc.hierarchy.fcluster(Z, t=number_of_clusters, criterion='maxclust') lbl2cluster = {} region2cluster = {} for lbl, clus in zip(df.columns.values, c): lbl2cluster[str(lbl)] = clus region2cluster[lbl] = clus # Create a color palette with 3 color for the 3 cyl possibilities my_palette = plt.cm.get_cmap("viridis", number_of_clusters) # Apply the right color to each label ax = plt.gca() xlbls = ax.get_ymajorticklabels() for lbl in xlbls: val=lbl2cluster[lbl.get_text()] #print(lbl.get_text() + " " + str(val)) lbl.set_color(my_palette(val-1)) plt.show() plt.close() self.region_cluster2cluster = region2cluster def check_scaled(self): """Detects not scaled region arrays and norms them using "median" method. """ hasToReprocess = False for regionName in self.regions: if not regionName in self.region_array_scaled: hasToReprocess = True break if hasToReprocess: self.logger.info("Calculating internormed regions") self.get_internormed_regions() def mass_intensity(self, masses, regions=None, scaled=False, verbose=True): """Plots seaborn.boxplot for every selected region depicting the range of intensity values in each cluster. Args: masses (float/list/tuple/set): Desired mass(es). regions (list/numpy.array, optional): Desired regions where to look for mass intensities. Defaults to None meaning to consider all available regions. scaled (bool, optional): Whether to use intensity values of scaled region arrays. Defaults to False. verbose (bool, optional): Whether to add information to the logger. Defaults to True. """ if not isinstance(masses, (list, tuple, set)): masses = [masses] if scaled: self.check_scaled() for regionName in self.regions: if not regions is None and not regionName in regions: continue cregion = self.regions[regionName] cluster2coords = cregion.getCoordsForSegmented() if not scaled: dataArray = cregion.region_array else: dataArray = self.region_array_scaled[regionName] for mass in masses: bestExMassForMass, bestExMassIdx = cregion._get_exmass_for_mass(mass) if verbose: self.logger.info("Processing Mass {} with best existing mass {}".format(mass, bestExMassForMass)) clusterIntensities = defaultdict(list) for clusterid in cluster2coords: for coord in cluster2coords[clusterid]: intValue = dataArray[coord[0], coord[1], bestExMassIdx] clusterIntensities[clusterid].append(intValue) clusterVec = [] intensityVec = [] massVec = [] specIdxVec = [] for x in clusterIntensities: elems = clusterIntensities[x] specIdxVec += [i for i in range(0, len(elems))] clusterVec += ["Cluster " + str(x)] * len(elems) intensityVec += elems massVec += [mass] * len(elems) dfObj = pd.DataFrame({"mass": massVec, "specidx": specIdxVec, "cluster": clusterVec, "intensity": intensityVec}) sns.boxplot(data=dfObj, x="cluster", y="intensity") plt.xticks(rotation=90) plt.title("Intensities for Region {} ({}m/z)".format(regionName, mass)) plt.show() plt.close() def mass_heatmap(self, masses, log=False, min_cut_off=None, plot=True, scaled=False, verbose=True, title="{mz}"): """Plots heatmap for every selected region depicting region_array spectra reduced to the sum of the specified masses. Args: masses (float/list/tuple/set): Desired mass(es). log (bool, optional): Whether to take logarithm of the output matrix. Defaults to False. min_cut_off (int/float, optional): Lower limit of values in the output matrix. Smaller values will be replaced with min_cut_off. Defaults to None. plot (bool, optional): Whether to plot the output matrix. Defaults to True. scaled (bool, optional): Whether to use intensity values of scaled region arrays. Defaults to False. verbose (bool, optional): Whether to add information to the logger. Defaults to True. title (str, optional): Format string defining the plot's title. Returns: numpy.array: A matrix of the last region where each element is a sum of intensities at given masses. """ if not isinstance(masses, (list, tuple, set)): masses = [masses] if scaled: self.check_scaled() region2segments = {} for regionName in self.regions: cregion = self.regions[regionName] if scaled == False: dataArray = self.regions[regionName].region_array else: dataArray = self.region_array_scaled[regionName] image = np.zeros((dataArray.shape[0], dataArray.shape[1])) for mass in masses: bestExMassForMass, bestExMassIdx = cregion._get_exmass_for_mass(mass) if verbose: self.logger.info("Processing Mass {} with best existing mass {}".format(mass, bestExMassForMass)) for i in range(dataArray.shape[0]): for j in range(dataArray.shape[1]): image[i,j] += dataArray[i,j,bestExMassIdx] if log: image = np.log(image) if min_cut_off != None: image[image <= min_cut_off] = min_cut_off region2segments[regionName] = image if plot: rows = math.ceil(len(self.regions) / 2) fig, axes = plt.subplots(rows, 2) if len(axes.shape) > 1: axes = np.reshape(axes, (1, axes.shape[0] * axes.shape[1]))[0][:] allMin, allMax = 0,0 for regionName in region2segments: allMin = min(allMin, np.min(region2segments[regionName])) allMax = max(allMax, np.max(region2segments[regionName])) didx = 0 for didx, regionName in enumerate(region2segments): ax = axes[didx] heatmap = ax.matshow(region2segments[regionName], vmin=allMin, vmax=allMax) # We must be sure to specify the ticks matching our target names ax.set_title(regionName, color="w", y=0.1) for ddidx in range(didx+1, rows*2): ax = axes[ddidx] ax.axis('off') #fig.colorbar(heatmap, ax=axes[-1]) plt.colorbar(heatmap, ax=axes[:], spacing='proportional') plt.suptitle(title.format(mz=";".join([str(round(x, 3)) if not type(x) in [str] else x for x in masses]))) plt.show() plt.close() return image def plot_segments(self, highlight=None): """Plots segmented arrays of all regions as heatmaps. Args: highlight (list/tuple/set/int, optional): If cluster ids are specified here, the resulting clustering will have cluster id 2 for highlight clusters, cluster id 0 for background, and cluster id 1 for the rest. Defaults to None. """ assert(not self.region_cluster2cluster is None) allClusters = [self.region_cluster2cluster[x] for x in self.region_cluster2cluster] valid_vals = sorted(set(allClusters)) region2segments = {} for regionName in self.regions: origSegments = np.array(self.regions[regionName].segmented, copy=True) region2segments[regionName] = origSegments if highlight != None: if not isinstance(highlight, (list, tuple, set)): highlight = [highlight] for regionName in region2segments: showcopy = np.copy(region2segments[regionName]) for i in range(0, showcopy.shape[0]): for j in range(0, showcopy.shape[1]): if showcopy[i,j] != 0: if showcopy[i,j] in highlight: showcopy[i,j] = 2 elif showcopy[i,j] != 0: showcopy[i,j] = 1 region2segments[regionName] = showcopy self._plot_arrays(region2segments) def plot_common_segments(self, highlight=None): """Plots segmented arrays of every region annotating the clusters with respect to new clustering done with CombinedSpectra (saved in region_cluster2cluster). Args: highlight (list/tuple/set/int, optional): If cluster ids are specified here, the resulting clustering will have cluster id 2 for highlight clusters, cluster id 0 for background, and cluster id 1 for the rest. Defaults to None. """ assert(not self.region_cluster2cluster is None) allClusters = [self.region_cluster2cluster[x] for x in self.region_cluster2cluster] valid_vals = sorted(set(allClusters)) region2segments = {} for regionName in self.regions: origSegments = np.array(self.regions[regionName].segmented, copy=True) origCluster2New = {} for x in self.region_cluster2cluster: if x[0] == regionName: origCluster2New[x[1]] = self.region_cluster2cluster[x] newSegments = np.zeros(origSegments.shape) print(origCluster2New) for i in range(0, newSegments.shape[0]): for j in range(0, newSegments.shape[1]): newSegments[i,j] = origCluster2New.get(origSegments[i,j], 0) region2segments[regionName] = newSegments if highlight != None: if not isinstance(highlight, (list, tuple, set)): highlight = [highlight] for regionName in region2segments: showcopy = np.copy(region2segments[regionName]) for i in range(0, showcopy.shape[0]): for j in range(0, showcopy.shape[1]): if showcopy[i,j] != 0: if showcopy[i,j] in highlight: showcopy[i,j] = 2 elif showcopy[i,j] != 0: showcopy[i,j] = 1 region2segments[regionName] = showcopy self._plot_arrays(region2segments) def _plot_arrays(self, region2segments): """Plots heatmaps for every region given in region2segments. Args: region2segments (dict): A dictionary with region names as keys and respective segmented arrays as values. """ rows = math.ceil(len(region2segments) / 2) fig, axes = plt.subplots(rows, 2) valid_vals = set() for regionName in region2segments: plotarray = region2segments[regionName] valid_vals = valid_vals.union(list(np.unique(plotarray))) valid_vals = sorted(valid_vals) min_ = min(valid_vals) max_ = max(valid_vals) positions = np.linspace(min_, max_, len(valid_vals)) val_lookup = dict(zip(positions, valid_vals)) print(val_lookup) def formatter_func(x, pos): 'The two args are the value and tick position' val = val_lookup[x] return val if len(axes.shape) > 1: axes = np.reshape(axes, (1, axes.shape[0] * axes.shape[1]))[0][:] didx=0 for didx, regionName in enumerate(region2segments): ax = axes[didx] im = ax.matshow(region2segments[regionName], cmap=plt.cm.get_cmap('viridis', len(valid_vals)), vmin=min_, vmax=max_) formatter = plt.FuncFormatter(formatter_func) # We must be sure to specify the ticks matching our target names ax.set_title(regionName, color="w", y=0.9, x=0.1) for ddidx in range(didx+1, rows*2): ax = axes[ddidx] ax.axis('off') plt.colorbar(im, ax=axes[:], ticks=positions, format=formatter, spacing='proportional') plt.show() plt.close() def __make_de_res_key(self, region0, clusters0, region1, clusters1): """Generates the storage key for two sets of clusters. Args: region0 (int): first region id. clusters0 (list): list of cluster ids 1. region1 (int): second region id. clusters1 (list): list of cluster ids 2. Returns: tuple: tuple (region0, sorted clusters0, region1, sorted clusters1) """ return (region0, tuple(sorted(clusters0)), region1, tuple(sorted(clusters1))) def to_region_cluster_input(self, region_cluster_list): rcl0 = defaultdict(list) for x in region_cluster_list: rcl0[x[0]].append(x[1]) rcl0 = [(x, tuple(sorted(rcl0[x]))) for x in rcl0] return rcl0 def find_markers(self, region_cluster_list0, region_cluster_list1, protWeights, mz_dist=3, mz_best=False, use_methods = ["empire", "ttest", "rank"], count_scale={"ttest": 1, "rank": 1}, scaled=True, sample_max=-1): """Performs differential analysis to finds marker proteins for specific regions and clusters. Args: region_cluster_list0 (list/numpy.array): A list of tuples (region id, list of clusters) that will be used as the 0 conditional vector by differential analysis. region_cluster_list1 (list/numpy.array): A list of tuples (region id, list of clusters) that will be used as the 1 conditional vector by differential analysis. protWeights (ProteinWeights): ProteinWeights object for translation of masses to protein names. mz_dist (float/int, optional): Allowed offset for protein lookup of needed masses. Defaults to 3. mz_best (bool, optional): Wether to consider only the closest found protein within mz_dist (with the least absolute mass difference). Defaults to False. use_methods (str/list, optional): Test method(s) for differential expression. Defaults to ["empire", "ttest", "rank"].\n - "empire": Empirical and Replicate based statistics (EmpiRe).\n - "ttest": Welch’s t-test for differential expression using diffxpy.api.\n - "rank": Mann-Whitney rank test (Wilcoxon rank-sum test) for differential expression using diffxpy.api.\n count_scale (dict, optional): Count scales for different methods (relevant for empire, which can only use integer counts). Defaults to {"ttest": 1, "rank": 1}. scaled (bool, optional): Wether each processed region is normalized. Those which are not will be scaled with the median method. Defaults to True. sample_max (int, optional): Allowed number of samples (spectra of specified regions&clusters) will be used by differential analysis (will be randomly picked if there are more available than allowed). Defaults to -1 meaning all samples are used. Returns: tuple: Tuple (collections.defaultdict, pandas.core.frame.DataFrame, pandas.core.frame.DataFrame). Dictionary with test method mapped to each tuple (region, clusters) and respective results. Two further data frames with expression data and test design. """ if type(region_cluster_list0) in (list, tuple): region_cluster_list0 = self.to_region_cluster_input(region_cluster_list0) if type(region_cluster_list1) in (list, tuple): region_cluster_list1 = self.to_region_cluster_input(region_cluster_list1) for pair in region_cluster_list0: assert(pair[0] in self.regions) assert([x for x in self.regions[region_cluster_list0[0][0]].idx2mass] == [x for x in self.regions[pair[0]].idx2mass]) for pair in region_cluster_list1: assert(pair[0] in self.regions) assert([x for x in self.regions[region_cluster_list1[0][0]].idx2mass] == [x for x in self.regions[pair[0]].idx2mass]) cluster2coords0 = {} for pair in region_cluster_list0: cluster2coords0[pair[0]] = self.regions[pair[0]].getCoordsForSegmented() assert(all([x in cluster2coords0[pair[0]] for x in pair[1]])) cluster2coords1 = {} for pair in region_cluster_list1: cluster2coords1[pair[0]] = self.regions[pair[0]].getCoordsForSegmented() assert(all([x in cluster2coords1[pair[0]] for x in pair[1]])) resKey = self.__make_de_res_key(region_cluster_list0[0][0], region_cluster_list0[0][1], region_cluster_list1[0][0], region_cluster_list1[0][1]) if scaled: self.check_scaled() if self.de_results_all is None: self.de_results_all = defaultdict(lambda: dict()) sampleVec = [] conditionVec = [] exprData =
pd.DataFrame()
pandas.DataFrame
#%% import numpy as np import pandas as pd import cmdstanpy import arviz as az # Load the datasets calib_data =
pd.read_csv('../../data/calibration/2021-04-05_hplc_calibration/processed/2021-04-05_NC_DM_calibration_relative_areas.csv')
pandas.read_csv
#!/usr/bin/env python3 # -*- coding: utf-8 -*- import os import pandas as pd import numpy as np import matplotlib.pyplot as plt #Get working directory os.getcwd() os.chdir('/Users/pablobottero/github/master/python/data_analysis') os.getcwd() rentals_2011=
pd.read_csv('washington_bike_rentals_2011.csv', sep=';', decimal=',')
pandas.read_csv
""" This module includes two types of discrete state-space formulations for biogas plants. The anaerobic digestion model in FlexibleBiogasPlantModel is based on the work in https://doi.org/10.1016/j.energy.2017.12.073 and ISBN: 978-3-319-16192-1 The module is designed to work with fledge: https://doi.org/10.5281/zenodo.3715873 The code is organized and implemented based on the flexible building model cobmo: https://zenodo.org/record/3523539 """ import numpy as np import pandas as pd import scipy.linalg import os import inspect import sys import datetime as dt import pyomo.environ as pyo import bipmo.utils class BiogasPlantModel(object): """ BiogasPlantModel represents all attributes and functions that all biogas plants have in common. It is the basis for every model that inherits from it. Caution: It does not work as a standalone model! """ model_type: str = None der_name: str = 'Biogas Plant' plant_scenarios: pd.DataFrame states: pd.Index controls: pd.Index outputs: pd.Index switches: pd.Index chp_schedule: pd.DataFrame disturbances: pd.Index state_vector_initial: pd.Series state_matrix: pd.DataFrame control_matrix: pd.DataFrame disturbance_matrix: pd.DataFrame state_output_matrix: pd.DataFrame control_output_matrix: pd.DataFrame disturbance_output_matrix: pd.DataFrame timestep_start: pd.Timestamp timestep_end: pd.Timestamp timestep_interval: pd.Timedelta timesteps: pd.Index disturbance_timeseries: pd.DataFrame output_maximum_timeseries: pd.DataFrame output_minimum_timeseries: pd.DataFrame marginal_cost: float lhv_table: pd.DataFrame temp_in: float cp_water: float feedstock_limit_type: str available_feedstock: float def __init__( self, scenario_name: str, timestep_start=None, timestep_end=None, timestep_interval=None, connect_electric_grid=True, ): # Scenario name. self.scenario_name = scenario_name # Define the biogas plant model (change paths accordingly). base_path = os.path.dirname(os.path.dirname(os.path.normpath(__file__))) # Load the scenario. self.plant_scenarios = pd.read_csv( os.path.join(base_path, 'data/biogas_plant_scenario.csv') ) self.plant_scenarios = self.plant_scenarios[ self.plant_scenarios['scenario_name'] == self.scenario_name] self.plant_scenarios.index = pd.Index([self.scenario_name]) # Load marginal cost self.marginal_cost = self.plant_scenarios.loc[ self.scenario_name, 'marginal_cost_EUR_Wh-1'] # Load feedstock data used in the scenario. self.plant_feedstock = pd.read_csv( os.path.join(base_path, 'data/biogas_plant_feedstock.csv') ) self.plant_feedstock = self.plant_feedstock[ self.plant_feedstock['feedstock_type'] == self.plant_scenarios.loc[self.scenario_name, 'feedstock_type'] ] self.plant_feedstock.index = pd.Index([self.scenario_name]) self.feedstock_limit_type = self.plant_scenarios.loc[ self.scenario_name, 'availability_limit_type'] self.available_feedstock = self.plant_scenarios.loc[ self.scenario_name, 'availability_substrate_ton_per_year'] # Load CHP data used in the scenario. self.CHP_list = self.plant_scenarios.CHP_name[self.scenario_name].split() self.number_CHP = len(self.CHP_list) self.plant_CHP_source = pd.read_csv( os.path.join(base_path, 'data/biogas_plant_CHP.csv') ) self.plant_CHP =
pd.DataFrame(columns=self.plant_CHP_source.columns)
pandas.DataFrame
import os import pymongo import logging import requests import pandas as pd from lxml import etree from urllib.parse import urlsplit from six.moves.configparser import ConfigParser from scrapy.exceptions import CloseSpider logger = logging.getLogger('custom-logger') def remove_url_schema(url): split_url = urlsplit(url) edited_url = split_url.netloc + split_url.path + \ split_url.query + split_url.fragment return edited_url def connect_db(settings): client = pymongo.MongoClient( settings['MONGODB_SERVER'], int(settings['MONGODB_PORT']) ) try: client.server_info() except pymongo.errors.ServerSelectionTimeoutError as e: raise CloseSpider('Unable to connect to MongoDB') logger.info("Connected to MongoDB") return client def drop_db(settings): client = pymongo.MongoClient( settings['MONGODB_SERVER'], int(settings['MONGODB_PORT']) ) try: client.server_info() client.drop_database(settings['MONGODB_DB']) client.close() except pymongo.errors.ServerSelectionTimeoutError as e: raise CloseSpider('Unable to connect to MongoDB') def get_sitemap_url(): config_file = "config/settings.ini" parser = ConfigParser() parser.read(config_file) for section_name in parser.sections(): if section_name == "Sitemaps": urls = list() for name, value in parser.items(section_name): urls.append(value) logger.info("Sitemap URL - %s", value) return urls raise CloseSpider('Sitemap URL not provided') def parse_sitemap(sitemap_urls): urls = dict() for url in sitemap_urls: response = requests.get(url) sitemap_xml = etree.fromstring(response.content) for urlset in sitemap_xml: children = urlset.getchildren() edited_url = remove_url_schema(children[0].text) urls[edited_url] = 0 return urls def generate_report(stats): filepath = 'log/scrapy_stats.csv' stats['scraping time'] = stats['finish_time'] - stats['start_time'] df = pd.DataFrame(list(stats.items()), columns=['parameter', 'value']) df.set_index('parameter', inplace=True) if not os.path.isfile(filepath): df.to_csv(filepath) else: cdf = pd.read_csv(filepath, index_col='parameter') concat_df =
pd.concat([df, cdf], axis=1, sort=False, join='inner')
pandas.concat
# !/usr/bin/env python # -*- coding:utf-8 -*- """ Test the projection module """ import unittest import numpy as np import pandas as pd from numpy.polynomial import legendre from pyrotor.projection import trajectory_to_coef from pyrotor.projection import trajectories_to_coefs from pyrotor.projection import compute_weighted_coef from pyrotor.projection import coef_to_trajectory def test_trajectory_to_coef(): # Test Legendre y = pd.DataFrame({"A": [1, 2, 3, 4, 5], "B": [-4, -1, 4, 11, 20]}) basis_dimension = {"A": 3, "B": 2} basis_features = basis_dimension basis = "legendre" expected_coef = np.array([3., 2., 0., 6., 12.], dtype='float64') result = trajectory_to_coef(y, basis, basis_features, basis_dimension) np.testing.assert_almost_equal(expected_coef, result) # Test B-spline x = np.linspace(0, 1, 20) y = pd.DataFrame({"A": x, "B": x**2}) basis_features = {"knots": [.25, .5, .75], "A": 2, "B": 3} basis_dimension = {"A": 6, "B": 7} basis = "bspline" expected_coef = np.array([0., .125, .375, .625, .875, 1., 0., 0., 4.16666667e-02, 2.29166667e-01, 5.41666667e-01, 8.33333333e-01, 1.], dtype='float64') result = trajectory_to_coef(y, basis, basis_features, basis_dimension) np.testing.assert_almost_equal(expected_coef, result) def test_trajectories_to_coefs(): # Test Legendre y = [pd.DataFrame({"A": [1, 2, 3, 4, 5]}), pd.DataFrame({"A": [-4, -1, 4, 11, 20]})] basis_dimension = {"A": 2} basis_features = basis_dimension basis = "legendre" expected_coefs_traj_1 = np.array([3., 2.]) expected_coefs_traj_2 = np.array([6., 12.]) n_jobs = None result = trajectories_to_coefs(y, basis, basis_features, basis_dimension, n_jobs) result_1 = result[0] result_2 = result[1] np.testing.assert_almost_equal(result_1, expected_coefs_traj_1) np.testing.assert_almost_equal(result_2, expected_coefs_traj_2) # Test B-spline x = np.linspace(0, 1, 20) y = [pd.DataFrame({"A": x}), pd.DataFrame({"A": 2 * x})] basis_features = {"knots": [.25, .5, .75], "A": 2} basis_dimension = {"A": 6} basis = "bspline" expected_coefs_traj_1 = np.array([0., .125, .375, .625, .875, 1.]) expected_coefs_traj_2 = np.array([0., .25, .75, 1.25, 1.75, 2.]) n_jobs = None result = trajectories_to_coefs(y, basis, basis_features, basis_dimension, n_jobs) result_1 = result[0] result_2 = result[1] np.testing.assert_almost_equal(result_1, expected_coefs_traj_1) np.testing.assert_almost_equal(result_2, expected_coefs_traj_2) def test_compute_weighted_coef(): coef1 = pd.Series([1, 2, 0], dtype='float64') coef2 =
pd.Series([-2, 0, 1], dtype='float64')
pandas.Series
from IMLearn.utils import split_train_test from IMLearn.learners.regressors import LinearRegression from typing import NoReturn import numpy as np import pandas as pd import plotly.graph_objects as go import plotly.express as px import plotly.io as pio from utils import animation_to_gif pio.templates.default = "simple_white" FEAT_NAMES = {"waterfront": "Waterfront", "view": "View", "condition": "Condition", "grade": "Grade", "price": "Price", "sqft_living": "Interior Living Space (sqft)", "sqft_above": "Interior Housing Space Above Ground Level (sqft)", "sqft_lot": "Land Space (sqft)", "yr_built": "Year of Initial Built", "sqft_living15": "Interior Living Space for the Nearest 15 Neighbors (sqft)", "sqft_lot15": "Land Space of the Nearest 15 Neighbors (sqft)", "bathrooms": "Bathrooms", "floors": "Floors", "sqft_basement": "Interior Housing Space Below Ground Level (sqft)", "yr_renovated": "Year of last renovation"} def load_data(filename: str): """ Load house prices dataset and preprocess data. Parameters ---------- filename: str Path to house prices dataset Returns ------- Design matrix and response vector (prices) - either as a single DataFrame or a Tuple[DataFrame, Series] """ df = pd.read_csv(filename).dropna().drop_duplicates() # eliminate irrelevant columns "home id", "date of home sale" and "longitude/"latitude" irrelevant_feats = {"id", "lat", "long", "date"} for feat in irrelevant_feats: df = df.drop(feat, 1) # check feats in a specific range range_feats = {"waterfront": [0, 1], "view": range(5), "condition": range(1, 6), "grade": range(1, 14)} for feat in range_feats: df = df[df[feat].isin(range_feats[feat])] # check positive / non-negative feats positive_feats = {"price", "sqft_living", "sqft_lot", "sqft_above", "yr_built", "sqft_living15", "sqft_lot15"} non_negative_feats = {"bathrooms", "floors", "sqft_basement", "yr_renovated"} for feat in positive_feats: df = df[df[feat] > 0] for feat in non_negative_feats: df = df[df[feat] >= 0] # zipcode manipulation df = pd.get_dummies(df, prefix='zipcode_', columns=['zipcode']) df.insert(0, 'intercept', 1, True) return df.drop("price", 1), df.price def feature_evaluation(X: pd.DataFrame, y: pd.Series, output_path: str = ".") -> NoReturn: """ Create scatter plot between each feature and the response. - Plot title specifies feature name - Plot title specifies Pearson Correlation between feature and response - Plot saved under given folder with file name including feature name Parameters ---------- X : DataFrame of shape (n_samples, n_features) Design matrix of regression problem y : array-like of shape (n_samples, ) Response vector to evaluate against output_path: str (default ".") Path to folder in which plots are saved """ for feat in X: if feat == "zipcode": pearson_cor = np.cov(X[feat], y) / (np.std(X[feat]) * np.std(y)) name = feat if feat in FEAT_NAMES: name = FEAT_NAMES[feat] fig = px.scatter(
pd.DataFrame({'x': X[feat], 'y': y})
pandas.DataFrame
""" This script contains a function for converting a text file into a csv file. Unlike the conversion from csv to text, text to csv does not require as many functionalities. """ from argparse import ArgumentParser import os.path as osp import sys import pandas as pd import numpy as np def _parse_args(): """ Parses arguments for the main script. """ parser = ArgumentParser(description='utility script for converting a midi text file into a csv file', prog='python text_to_csv.py') parser.add_argument( '-t', '--ticks', help="Ticks per each time step (default: 25). " "You should use the same value that you used to convert the original csv into the text.", type=int, default=25 ) parser.add_argument( '-v', '--velocity', help="Velocity value for notes (default: 80).", type=int, default=80 ) parser.add_argument( '-e', '--end-track', help="Add an 'End_track' item after the last note. " "Use it if you are not using the original midi text " "(e.g. if you're using a machine-generated text).", action='store_true', default=False ) parser.add_argument( '-f', '--filter-out', help="This value will be used for filtering out short sounds. " "If set to 0, then no filtering will be done. (default: 0)", type=int, default=0 ) parser.add_argument( '-m', '--merge', help="This value will be used for merging nearby notes. " "If set to 0, then no merging will be done. (default: 0)", type=int, default=0 ) parser.add_argument( '--merge-first', help="Merge notes and then filter.", action='store_true', default=False ) parser.add_argument( '--verbose', help="make the process more verbose.", action='store_true', default=False ) parser.add_argument( 'text', type=str, help="File path for the text file to convert." ) parser.add_argument( 'csv', nargs='?', type=str, help="File path for the resulting csv file (Optional). By default, the csv file will be " "generated in the same directory as the source text file." ) if len(sys.argv) == 1: parser.print_help(sys.stderr) sys.exit(1) args = parser.parse_args() if not args.ticks > 0: parser.error("The value for ticks per time step must be at least 1.") if not args.velocity >= 0: parser.error("The value for ticks per time step must be non-negative.") if not osp.isfile(args.text): parser.error("The input text file does not exist. Please, check the file path and try again.") if args.csv and not osp.isdir(osp.dirname(args.csv)): parser.error("The result path does not exist. Please, use an existing directory.") if args.filter_out < 0: parser.error("The value for filter_out must be a non-negative integer.") if args.merge < 0: parser.error("The value for merge must be a non-negative integer.") return args def text_to_midicsv(midi_text, ticks_per_step=25, vel=80, add_end_track=False, filter_interval=0, merge_interval=0, merge_first=False, verbose=False): """ Converts the given midi text file into a pandas dataframe. Then, the resulting dataframe is returned. When constructing the dataframe, it uses ticks_per_step to determine the time tick value of each note. All 'Note_on's will have the same velocity specified as a parameter. If add_end_track is True, it will add an 'End_track' 1920 ticks after the last item from the text. Otherwise, it will consider the last item in the text as the 'End_track'. If clean is True, it will filter out short noises that are only 1 timestep long and merge notes that are only 1 timestep away from each other. I verbose is True, it will report the progress as it processes the data. """ NUMBER_OF_PITCH = 128 COL_NAMES = ['Track', 'Time', 'Type', 'Val1', 'Val2', 'Val3'] HEADER = [0, 0, 'Header', 1, 1, 480] START_TRACK = [1, 0, 'Start_track', np.nan, np.nan, np.nan] midi_text = ' ' + midi_text if add_end_track: midi_text = midi_text + ' 0' text_list = midi_text.split(' 0') # Total number of time steps n_steps = len(text_list) if verbose: print("\n* Converting the text into a numpy matrix ...") note_time_matrix = np.zeros((NUMBER_OF_PITCH, n_steps), dtype=np.uint8) for time_step in range(n_steps): note_str = text_list[time_step] if note_str != '': for note_num in note_str.strip().split(' '): note_time_matrix[int(note_num) - 1, time_step] = 1 if merge_first and merge_interval > 0: if verbose: print("* Merging nearby notes ...") for interval in range(1, merge_interval + 1): pattern = [1] + [0] * interval + [1] for time_step in range(1, n_steps - interval): pattern_match_indices = np.equal(note_time_matrix[:, (time_step - 1) : (time_step + interval + 1)], pattern).all(axis=1).nonzero()[0] if len(pattern_match_indices) > 0: note_time_matrix[pattern_match_indices, time_step : (time_step + interval)] = 1 if filter_interval > 0: if verbose: print("* Filtering short notes ...") for interval in range(1, filter_interval + 1): pattern = [1] * interval + [0] pattern_match_indices = np.equal(note_time_matrix[:, :interval + 1], pattern).all(axis=1).nonzero()[0] if len(pattern_match_indices) > 0: note_time_matrix[pattern_match_indices, :interval] = 0 pattern = [0] + [1] * interval + [0] for time_step in range(1, n_steps - interval): pattern_match_indices = np.equal(note_time_matrix[:, (time_step - 1) : (time_step + interval + 1)], pattern).all(axis=1).nonzero()[0] if len(pattern_match_indices) > 0: note_time_matrix[pattern_match_indices, time_step : (time_step + interval)] = 0 if not merge_first and merge_interval > 0: if verbose: print("* Merging nearby notes ...") for interval in range(1, merge_interval + 1): pattern = [1] + [0] * interval + [1] for time_step in range(1, n_steps - interval): pattern_match_indices = np.equal(note_time_matrix[:, (time_step - 1) : (time_step + interval + 1)], pattern).all(axis=1).nonzero()[0] if len(pattern_match_indices) > 0: note_time_matrix[pattern_match_indices, time_step : (time_step + interval)] = 1 if verbose: print("* Converting the matrix into a pandas dataframe ...") data_lists = [HEADER, START_TRACK] if note_time_matrix[:, 0].nonzero()[0].any(): for pitch in note_time_matrix[:, 0].nonzero()[0]: data_lists.append([1, 0, 'Note_on_c', 0, pitch, vel]) for time_step in range(1, n_steps - 1): change_occured = note_time_matrix[:, time_step - 1] != note_time_matrix[:, time_step] for pitch in change_occured.nonzero()[0]: if note_time_matrix[pitch, time_step] == 1: velocity = vel else: velocity = 0 data_lists.append([1, (time_step * ticks_per_step), 'Note_on_c', 0, pitch, velocity]) if not add_end_track: data_lists.append([1, ((n_steps - 1) * ticks_per_step), 'End_track']) else: change_occured = note_time_matrix[:, n_steps - 2] != note_time_matrix[:, n_steps - 1] for pitch in change_occured.nonzero()[0]: if note_time_matrix[pitch, time_step] == 1: velocity = vel else: velocity = 0 data_lists.append([1, ((n_steps - 1) * ticks_per_step), 'Note_on_c', 0, pitch, velocity]) data_lists.append([1, ((n_steps - 1) * ticks_per_step) + 1920, 'End_track']) data_lists.append([0, 0, 'End_of_file']) midi_csv =
pd.DataFrame(data=data_lists, columns=COL_NAMES)
pandas.DataFrame
import pandas as pd import numpy as np import datetime import calendar from math import e from brightwind.analyse import plot as plt # noinspection PyProtectedMember from brightwind.analyse.analyse import dist_by_dir_sector, dist_12x24, coverage, _convert_df_to_series from ipywidgets import FloatProgress from IPython.display import display from IPython.display import clear_output import re import warnings pd.options.mode.chained_assignment = None __all__ = ['Shear'] class Shear: class TimeSeries: def __init__(self, wspds, heights, min_speed=3, calc_method='power_law', max_plot_height=None, maximise_data=False): """ Calculates alpha, using the power law, or the roughness coefficient, using the log law, for each timestamp of a wind series. :param wspds: pandas DataFrame, list of pandas.Series or list of wind speeds to be used for calculating shear. :type wspds: pandas.DataFrame, list of pandas.Series or list. :param heights: List of anemometer heights. :type heights: list :param min_speed: Only speeds higher than this would be considered for calculating shear, default is 3. :type min_speed: float :param calc_method: method to use for calculation, either 'power_law' (returns alpha) or 'log_law' (returns the roughness coefficient). :type calc_method: str :param max_plot_height: height to which the wind profile plot is extended. :type max_plot_height: float :param maximise_data: If maximise_data is True, calculations will be carried out on all data where two or more anemometers readings exist for a timestamp. If False, calculations will only be carried out on timestamps where readings exist for all anemometers. :type maximise_data: Boolean :return TimeSeries object containing calculated alpha/roughness coefficient values, a plot and other data. :rtype TimeSeries object **Example usage** :: import brightwind as bw import pprint # Load anemometer data to calculate exponents data = bw.load_csv(C:\\Users\\Stephen\\Documents\\Analysis\\demo_data) anemometers = data[['Spd80mS', 'Spd60mS','Spd40mS']] heights = [80, 60, 40] # Using with a DataFrame of wind speeds timeseries_power_law = bw.Shear.TimeSeries(anemometers, heights, maximise_data=True) timeseries_log_law = bw.Shear.TimeSeries(anemometers, heights, calc_method='log_law', max_plot_height=120) # Get the alpha or roughness values calculated timeseries_power_law.alpha timeseries_log_law.roughness # View plot timeseries_power_law.plot timeseries_log_law.plot # View input anemometer data timeseries_power_law.wspds timeseries_log_law.wspds # View other information pprint.pprint(timeseries_power_law.info) pprint.pprint(timeseries_log_law.info) """ print('This may take a while...') wspds, cvg = Shear._data_prep(wspds=wspds, heights=heights, min_speed=min_speed, maximise_data=maximise_data) if calc_method == 'power_law': alpha_c = (wspds[(wspds > min_speed).all(axis=1)].apply(Shear._calc_power_law, heights=heights, return_coeff=True, maximise_data=maximise_data, axis=1)) alpha = pd.Series(alpha_c.iloc[:, 0], name='alpha') self._alpha = alpha elif calc_method == 'log_law': slope_intercept = (wspds[(wspds > min_speed).all(axis=1)].apply(Shear._calc_log_law, heights=heights, return_coeff=True, maximise_data=maximise_data, axis=1)) slope = slope_intercept.iloc[:, 0] intercept = slope_intercept.iloc[:, 1] roughness_coefficient = pd.Series(Shear._calc_roughness(slope=slope, intercept=intercept), name='roughness_coefficient') self._roughness = roughness_coefficient clear_output() avg_plot = Shear.Average(wspds=wspds, heights=heights, calc_method=calc_method, max_plot_height=max_plot_height) self.origin = 'TimeSeries' self.calc_method = calc_method self.wspds = wspds self.plot = avg_plot.plot self.info = Shear._create_info(self, heights=heights, cvg=cvg, min_speed=min_speed) @property def alpha(self): return self._alpha @property def roughness(self): return self._roughness def apply(self, wspds, height, shear_to): """" Applies shear calculated to a wind speed time series and scales wind speed from one height to another for each matching timestamp. :param self: TimeSeries object to use when applying shear to the data. :type self: TimeSeries object :param wspds: Wind speed time series to apply shear to. :type wspds: pandas.Series :param height: height of above wspds. :type height: float :param shear_to: height to which wspds should be scaled to. :type shear_to: float :return: a pandas.Series of the scaled wind speeds. :rtype: pandas.Series **Example Usage** :: import brightwind as bw # Load anemometer data to calculate exponents data = bw.load_csv(C:\\Users\\Stephen\\Documents\\Analysis\\demo_data) anemometers = data[['Spd80mS', 'Spd60mS','Spd40mS']] heights = [80, 60, 40] # Get power law object timeseries_power_law = bw.Shear.TimeSeries(anemometers, heights) timeseries_log_law = bw.Shear.TimeSeries(anemometers, heights, calc_method='log_law') # Scale wind speeds using calculated exponents timeseries_power_law.apply(data['Spd40mN'], height=40, shear_to=70) timeseries_log_law.apply(data['Spd40mN'], height=40, shear_to=70) """ return Shear._apply(self, wspds, height, shear_to) class TimeOfDay: def __init__(self, wspds, heights, min_speed=3, calc_method='power_law', by_month=True, segment_start_time=7, segments_per_day=24, plot_type='line'): """ Calculates alpha, using the power law, or the roughness coefficient, using the log law, for a wind series binned by time of the day and (optionally by) month, depending on the user's inputs. The alpha/roughness coefficient values are calculated based on the average wind speeds at each measurement height in each bin. :param wspds: pandas.DataFrame, list of pandas.Series or list of wind speeds to be used for calculating shear. :type wspds: pandas.DataFrame, list of pandas.Series or list. :param heights: List of anemometer heights.. :type heights: list :param min_speed: Only speeds higher than this would be considered for calculating shear, default is 3 :type min_speed: float :param calc_method: method to use for calculation, either 'power_law' (returns alpha) or 'log_law' (returns the roughness coefficient). :type calc_method: str :param by_month: If True, calculate alpha or roughness coefficient values for each daily segment and month. If False, average alpha or roughness coefficient values are calculated for each daily segment across all months. :type by_month: Boolean :param segment_start_time: Starting time for first segment. :type segment_start_time: int :param segments_per_day: Number of segments into which each 24 period is split. Must be a divisor of 24. :type segments_per_day: int :param plot_type: Type of plot to be generated. Options include 'line', 'step' and '12x24'. :type plot_type: str :return: TimeOfDay object containing calculated alpha/roughness coefficient values, a plot and other data. :rtype: TimeOfDay object **Example usage** :: import brightwind as bw import pprint # Load anemometer data to calculate exponents data = bw.load_csv(C:\\Users\\Stephen\\Documents\\Analysis\\demo_data) anemometers = data[['Spd80mS', 'Spd60mS','Spd40mS']] heights = [80, 60, 40] # Using with a DataFrame of wind speeds timeofday_power_law = bw.Shear.TimeOfDay(anemometers, heights, daily_segments=2, segment_start_time=7) timeofday_log_law = bw.Shear.TimeOfDay(anemometers, heights, calc_method='log_law', by_month=False) # Get alpha or roughness values calculated timeofday_power_law.alpha timeofday_log_law.roughness # View plot timeofday_power_law.plot timeofday_log_law.plot # View input data timeofday_power_law.wspds timeofday_log_law.wspds # View other information pprint.pprint(timeofday_power_law.info) pprint.pprint(timeofday_log_law.info) """ wspds, cvg = Shear._data_prep(wspds=wspds, heights=heights, min_speed=min_speed) # initialise empty series for later use start_times = pd.Series([]) time_wspds = pd.Series([]) mean_time_wspds = pd.Series([]) c = pd.Series([]) slope = pd.Series([]) intercept = pd.Series([]) alpha = pd.Series([]) roughness = pd.Series([]) slope_df = pd.DataFrame([]) intercept_df = pd.DataFrame([]) roughness_df = pd.DataFrame([]) alpha_df = pd.DataFrame([]) # time of day shear calculations interval = int(24 / segments_per_day) if by_month is False and plot_type == '12x24': raise ValueError("12x24 plot is only possible when 'by_month=True'") if not int(segment_start_time) % 1 == 0: raise ValueError("'segment_start_time' must be an integer between 0 and 24'") if not (24 % segments_per_day == 0) | (segments_per_day == 1): raise ValueError("'segments_per_day' must be a divisor of 24'") segment_start_time = str(segment_start_time) start_times[0] = datetime.datetime.strptime(segment_start_time, '%H') dt = datetime.timedelta(hours=interval) # extract wind speeds for each daily segment for i in range(1, segments_per_day): start_times[i] = start_times[i - 1] + dt # extract wind speeds for each month months_tot = pd.unique(wspds.index.month.values) for j in months_tot: anemometers_df = wspds[wspds.index.month == j] for i in range(0, segments_per_day): if segments_per_day == 1: mean_time_wspds[i] = anemometers_df.mean().dropna() elif i == segments_per_day - 1: start_times[i] = start_times[i].strftime("%H:%M:%S") start = str(start_times[i].time()) end = str(start_times[0].time()) time_wspds[i] = pd.DataFrame(anemometers_df).between_time(start, end, include_end=False) mean_time_wspds[i] = time_wspds[i][(time_wspds[i] > min_speed).all(axis=1)].mean().dropna() else: start_times[i] = start_times[i].strftime("%H:%M:%S") start = str(start_times[i].time()) end = str(start_times[i + 1].time()) time_wspds[i] = pd.DataFrame(anemometers_df).between_time(start, end, include_end=False) mean_time_wspds[i] = time_wspds[i][(time_wspds[i] > min_speed).all(axis=1)].mean().dropna() # calculate shear if calc_method == 'power_law': for i in range(0, len(mean_time_wspds)): alpha[i], c[i] = Shear._calc_power_law(mean_time_wspds[i].values, heights, return_coeff=True) alpha_df = pd.concat([alpha_df, alpha], axis=1) if calc_method == 'log_law': for i in range(0, len(mean_time_wspds)): slope[i], intercept[i] = Shear._calc_log_law(mean_time_wspds[i].values, heights, return_coeff=True) roughness[i] = Shear._calc_roughness(slope=slope[i], intercept=intercept[i]) roughness_df = pd.concat([roughness_df, roughness], axis=1) slope_df = pd.concat([slope_df, slope], axis=1) intercept_df = pd.concat([intercept_df, intercept], axis=1) # error check if mean_time_wspds.shape[0] == 0: raise ValueError('None of the input wind speeds are greater than the min_speed, cannot calculate shear') if calc_method == 'power_law': alpha_df.index = start_times alpha_df.index = alpha_df.index.time alpha_df.sort_index(inplace=True) if by_month is True: alpha_df.columns = [calendar.month_abbr[month] for month in months_tot] self.plot = plt.plot_shear_time_of_day(Shear._fill_df_12x24(alpha_df), calc_method=calc_method, plot_type=plot_type) else: n_months = len(alpha_df.columns.values) alpha_df = pd.DataFrame(alpha_df.mean(axis=1)) alpha_df.columns = [str(n_months) + ' Month Average'] df_in = pd.DataFrame((Shear._fill_df_12x24(alpha_df)).iloc[:, 0]) df_in.columns = [str(n_months) + ' Month Average'] self.plot = plt.plot_shear_time_of_day(df_in, calc_method=calc_method, plot_type=plot_type) alpha_df.index.name = 'segment_start_time' self._alpha = alpha_df if calc_method == 'log_law': roughness_df.index = slope_df.index = intercept_df.index = start_times roughness_df.index = slope_df.index = intercept_df.index = roughness_df.index.time roughness_df.sort_index(inplace=True) slope_df.sort_index(inplace=True) intercept_df.sort_index(inplace=True) if by_month is True: roughness_df.columns = slope_df.columns = intercept_df.columns = \ [calendar.month_abbr[month] for month in months_tot] self.plot = plt.plot_shear_time_of_day(Shear._fill_df_12x24(roughness_df), calc_method=calc_method, plot_type=plot_type) else: n_months = len(slope_df.columns.values) slope_df = pd.DataFrame(slope_df.mean(axis=1)) intercept_df = pd.DataFrame(intercept_df.mean(axis=1)) roughness_df = pd.DataFrame(roughness_df.mean(axis=1)) roughness_df.columns = slope_df.columns = intercept_df.columns = \ [str(len(months_tot)) + '_month_average'] df_in = pd.DataFrame(Shear._fill_df_12x24(roughness_df).iloc[:, 0]) df_in.columns = [str(n_months) + ' Month Average'] self.plot = plt.plot_shear_time_of_day(df_in, calc_method=calc_method, plot_type=plot_type) roughness_df.index.name = 'segment_start_time' self._roughness = roughness_df self.calc_method = calc_method self.wspds = wspds self.origin = 'TimeOfDay' self.info = Shear._create_info(self, heights=heights, cvg=cvg, min_speed=min_speed, segment_start_time=segment_start_time, segments_per_day=segments_per_day) @property def alpha(self): return self._alpha @property def roughness(self): return self._roughness def apply(self, wspds, height, shear_to): """ Applies shear calculated to a wind speed time series by time of day (and optionally by month) to scale wind speed from one height to another. :param self: TimeOfDay object to use when applying shear to the data. :type self: TimeOfDay object :param wspds: Wind speed time series to apply shear to. :type wspds: pandas.Series :param height: height of above wspds. :type height: float :param shear_to: height to which wspds should be scaled. :type shear_to: float :return: a pandas.Series of the scaled wind speeds. :rtype: pandas.Series **Example Usage** :: import brightwind as bw # Load anemometer data to calculate exponents data = bw.load_csv(C:\\Users\\Stephen\\Documents\\Analysis\\demo_data) anemometers = data[['Spd80mS', 'Spd60mS','Spd40mS']] heights = [80, 60, 40] # Get power law object timeofday_power_law = bw.Shear.TimeOfDay(anemometers, heights) timeofday_log_law = bw.Shear.TimeOfDay(anemometers, heights, calc_method='log_law') # Scale wind speeds using calculated exponents timeofday_power_law.apply(data['Spd40mN'], height=40, shear_to=70) timeofday_log_law.apply(data['Spd40mN'], height=40, shear_to=70) """ return Shear._apply(self, wspds, height, shear_to) class Average: def __init__(self, wspds, heights, min_speed=3, calc_method='power_law', plot_both=False, max_plot_height=None): """ Calculates alpha, using the power law, or the roughness coefficient, using the log law, based on the average wind speeds of each supplied time series. :param wspds: pandas.DataFrame, list of pandas.Series or list of wind speeds to be used for calculating shear. :type wspds: pandas.DataFrame, list of pandas.Series or list. :param heights: List of anemometer heights :type heights: list :param min_speed: Only speeds higher than this would be considered for calculating shear, default is 3. :type min_speed: float :param calc_method: method to use for calculation, either 'power_law' (returns alpha) or 'log_law' (returns the roughness coefficient). :type calc_method: str :param max_plot_height: height to which the wind profile plot is extended. :type max_plot_height: float :return: Average object containing calculated alpha/roughness coefficient values, a plot and other data. :rtype: Average object **Example usage** :: import brightwind as bw import pprint # Load anemometer data to calculate exponents data = bw.load_csv(C:\\Users\\Stephen\\Documents\\Analysis\\demo_data) anemometers = data[['Spd80mS', 'Spd60mS','Spd40mS']] heights = [80, 60, 40] # Using with a DataFrame of wind speeds average_power_law = bw.Shear.Average(anemometers, heights) average_log_law = bw.Shear.Average(anemometers, heights, calc_method='log_law', max_plot_height=120) # Get the alpha or roughness values calculated average_power_law.alpha average_log_law.roughness # View plot average_power_law.plot average_log_law.plot # View input data average_power_law.wspds average_log_law.wspds # View other information pprint.pprint(average_power_law.info) pprint.pprint(average_log_law.info) """ wspds, cvg = Shear._data_prep(wspds=wspds, heights=heights, min_speed=min_speed) mean_wspds = wspds.mean(axis=0) if mean_wspds.shape[0] == 0: raise ValueError('None of the input wind speeds are greater than the min_speed, cannot calculate shear') if calc_method == 'power_law': alpha, c = Shear._calc_power_law(mean_wspds.values, heights, return_coeff=True) if plot_both is True: slope, intercept = Shear._calc_log_law(mean_wspds.values, heights, return_coeff=True) self.plot = plt.plot_power_law(plot_both=True, avg_alpha=alpha, avg_c=c, avg_slope=slope, avg_intercept=intercept, wspds=mean_wspds.values, heights=heights, max_plot_height=max_plot_height) else: self.plot = plt.plot_power_law(alpha, c, mean_wspds.values, heights, max_plot_height=max_plot_height) self._alpha = alpha elif calc_method == 'log_law': slope, intercept = Shear._calc_log_law(mean_wspds.values, heights, return_coeff=True) roughness = Shear._calc_roughness(slope=slope, intercept=intercept) self._roughness = roughness if plot_both is True: alpha, c = Shear._calc_power_law(mean_wspds.values, heights, return_coeff=True) self.plot = plt.plot_power_law(avg_alpha=alpha, avg_c=c, avg_slope=slope, avg_intercept=intercept, wspds=mean_wspds.values, heights=heights, max_plot_height=max_plot_height) else: self.plot = plt.plot_log_law(slope, intercept, mean_wspds.values, heights, max_plot_height=max_plot_height) else: raise ValueError("Please enter a valid calculation method, either 'power_law' or 'log_law'.") self.wspds = wspds self.origin = 'Average' self.calc_method = calc_method self.info = Shear._create_info(self, heights=heights, min_speed=min_speed, cvg=cvg) @property def alpha(self): return self._alpha @property def roughness(self): return self._roughness def apply(self, wspds, height, shear_to): """ Applies average shear calculated to a wind speed time series to scale wind speed from one height to another. :param self: Average object to use when applying shear to the data. :type self: Average object :param wspds: Wind speed time series to apply shear to. :type wspds: pandas.Series :param height: height of above wspds. :type height: float :param shear_to: height to which wspds should be scaled to. :type shear_to: float :return: a pandas.Series of the scaled wind speeds. :rtype: pandas.Series **Example Usage** :: import brightwind as bw # Load anemometer data to calculate exponents data = bw.load_csv(C:\\Users\\Stephen\\Documents\\Analysis\\demo_data) anemometers = data[['Spd80mS', 'Spd60mS','Spd40mS']] heights = [80, 60, 40] # Get power law object average_power_law = bw.Shear.Average(anemometers, heights) average_log_law = bw.Shear.Average(anemometers, heights, calc_method='log_law', max_plot_height=120) # Scale wind speeds using exponents average_power_law.apply(data['Spd40mN'], height=40, shear_to=70) average_log_law.apply(data['Spd40mN'], height=40, shear_to=70) """ return Shear._apply(self, wspds, height, shear_to) class BySector: def __init__(self, wspds, heights, wdir, min_speed=3, calc_method='power_law', sectors=12, direction_bin_array=None, direction_bin_labels=None): """ Calculates alpha, using the power law, or the roughness coefficient, using the log law, for a wind series binned by direction. The alpha/roughness coefficient values are calculated based on the average wind speeds at each measurement height in each bin. :param wspds: pandas.DataFrame, list of pandas.Series or list of wind speeds to be used for calculating shear. :type wspds: pandas.DataFrame, list of pandas.Series or list. :param heights: List of anemometer heights :type heights: list :param wdir: Wind direction measurements :type wdir: pandas.DataFrame or Series :param: min_speed: Only speeds higher than this would be considered for calculating shear, default is 3. :type: min_speed: float :param calc_method: Method to use for calculation, either 'power_law' (returns alpha) or 'log_law' (returns the roughness coefficient). :type calc_method: str :param sectors: Number of sectors for the shear to be calculated for. :type sectors: int :param direction_bin_array: Specific array of directional bins to be used. If None, bins are calculated by 360/sectors. :type direction_bin_array: list or array :param direction_bin_labels: Labels to be given to the above direction_bin array. :type direction_bin_labels: list or array :return: BySector object containing calculated alpha/roughness coefficient values, a plot and other data. :rtype: BySector object **Example usage** :: import brightwind as bw import pprint # Load anemometer data to calculate exponents data = bw.load_csv(C:\\Users\\Stephen\\Documents\\Analysis\\demo_data) anemometers = data[['Spd80mS', 'Spd60mS','Spd40mS']] heights = [80, 60, 40] directions = data['Dir78mS'] # Calculate shear exponents using default bins ([345,15,45,75,105,135,165,195,225,255,285,315,345]) by_sector_power_law= bw.Shear.BySector(anemometers, heights, directions) by_sector_log_law= bw.Shear.BySector(anemometers, heights, directions, calc_method='log_law') # Calculate shear exponents using custom bins custom_bins = [0,30,60,90,120,150,180,210,240,270,300,330,360] by_sector_power_law_custom_bins = bw.Shear.BySector(anemometers, heights, directions, direction_bin_array=custom_bins) # Get alpha or roughness values calculated by_sector_power_law.alpha by_sector_log_law.roughness # View plot by_sector_power_law.plot by_sector_log_law.plot # View input data by_sector_power_law.wspds by_sector_log_law.wspds # View other information pprint.pprint(by_sector_power_law.info) pprint.pprint(by_sector_log_law.info) """ print('This may take a while...') wspds, cvg = Shear._data_prep(wspds=wspds, heights=heights, min_speed=min_speed) if direction_bin_array is not None: sectors = len(direction_bin_array) - 1 wdir = _convert_df_to_series(wdir) mean_wspds = pd.Series([]) mean_wspds_df = pd.DataFrame([]) count_df = pd.DataFrame([]) count = pd.Series([]) for i in range(len(wspds.columns)): w = wspds.iloc[:, i] plot, mean_wspds[i] = dist_by_dir_sector(w, wdir, direction_bin_array=direction_bin_array, sectors=sectors, aggregation_method='mean', return_data=True) plot, count[i] = dist_by_dir_sector(w, wdir, direction_bin_array=direction_bin_array, sectors=sectors, aggregation_method='count', return_data=True) if i == 0: mean_wspds_df = mean_wspds[i].copy() count_df = count[i].copy() else: mean_wspds_df = pd.concat([mean_wspds_df, mean_wspds[i]], axis=1) count_df = pd.concat([count_df, count[i]], axis=1) count_df = count_df.mean(axis=1) wind_rose_plot, wind_rose_dist = dist_by_dir_sector(wspds.iloc[:, 0], wdir, direction_bin_array=direction_bin_array, sectors=sectors, direction_bin_labels=direction_bin_labels, return_data=True) if calc_method == 'power_law': alpha = mean_wspds_df.apply(Shear._calc_power_law, heights=heights, return_coeff=False, axis=1) wind_rose_plot, wind_rose_dist = dist_by_dir_sector(wspds.iloc[:, 0], wdir, direction_bin_array=direction_bin_array, sectors=sectors, direction_bin_labels=direction_bin_labels, return_data=True) self.alpha_count = count_df self._alpha = pd.Series(alpha, name='alpha') clear_output() self.plot = plt.plot_shear_by_sector(scale_variable=alpha, wind_rose_data=wind_rose_dist, calc_method=calc_method) elif calc_method == 'log_law': slope_intercept = mean_wspds_df.apply(Shear._calc_log_law, heights=heights, return_coeff=True, axis=1) slope = slope_intercept.iloc[:, 0] intercept = slope_intercept.iloc[:, 1] roughness = Shear._calc_roughness(slope=slope, intercept=intercept) self.roughness_count = count_df self._roughness = pd.Series(roughness, name='roughness_coefficient') clear_output() self.plot = plt.plot_shear_by_sector(scale_variable=roughness, wind_rose_data=wind_rose_dist, calc_method=calc_method) else: raise ValueError("Please enter a valid calculation method, either 'power_law' or 'log_law'.") self.wspds = wspds self.wdir = wdir self.origin = 'BySector' self.sectors = sectors self.calc_method = calc_method self.info = Shear._create_info(self, heights=heights, cvg=cvg, min_speed=min_speed, direction_bin_array=direction_bin_array) @property def alpha(self): return self._alpha @property def roughness(self): return self._roughness def apply(self, wspds, wdir, height, shear_to): """ Applies shear calculated to a wind speed time series by wind direction to scale wind speed from one height to another. :param self: BySector object to use when applying shear to the data :type self: BySector object :param wspds: Wind speed time series to apply shear to. :type wspds: pandas.Series :param wdir: Wind direction measurements of wspds, only required if shear is to be applied by direction sector. :type wdir: pandas.Series :param height: Height of wspds. :type height: float :param shear_to: Height to which wspds should be scaled to. :type shear_to: float :return: A pandas.Series of the scaled wind speeds. :rtype: pandas.Series **Example Usage** :: import brightwind as bw # Load anemometer data to calculate exponents data = bw.load_csv(C:\\Users\\Stephen\\Documents\\Analysis\\demo_data) anemometers = data[['Spd80mS', 'Spd60mS']] heights = [80, 60] directions = data[['Dir78mS']] # Calculate shear exponents by_sector_power_law = bw.Shear.BySector(anemometers, heights, directions) by_sector_log_law = bw.Shear.BySector(anemometers, heights, directions, calc_method='log_law') # Calculate shear exponents using default bins ([345,15,45,75,105,135,165,195,225,255,285,315,345]) by_sector_power_law= bw.Shear.BySector(anemometers, heights, directions) # Scale wind speeds using exponents by_sector_power_law.apply(data['Spd40mN'], data['Dir38mS'], height=40, shear_to=70) by_sector_log_law.apply(data['Spd40mN'], data['Dir38mS'], height=40, shear_to=70) """ return Shear._apply(self, wspds=wspds, height=height, shear_to=shear_to, wdir=wdir) @staticmethod def _log_roughness_scale(wspds, height, shear_to, roughness): """ Scale wind speeds using the logarithmic wind shear law. :param wspds: wind speeds at height z1, U1 :param height: z1 :param shear_to: z2 :param roughness: z0 :return: Scaled wind speeds, U2 :rtype: pandas.Series or float METHODOLOGY: U2 = (ln(z2/z0)/ln(z1/z0))U1 Where: - U2 is the wind speed at height z2 - U1 is the wind speed at height z1 - z1 is the lower height - z2 is the upper height - zo is the roughness coefficient """ scale_factor = np.log(shear_to / roughness) / (np.log(height / roughness)) scaled_wspds = wspds * scale_factor return scaled_wspds @staticmethod def _calc_log_law(wspds, heights, return_coeff=False, maximise_data=False) -> (np.array, float): """ Derive the best fit logarithmic law line from a given time-step of speed data at 2 or more elevations :param wspds: List of wind speeds [m/s] :param heights: List of heights [m above ground]. The position of the height in the list must be the same position in the list as its corresponding wind speed value. :return: The slope and intercept of the best fit line, as defined above :rtype: pandas.Series and float METHODOLOGY: Derive natural log of elevation data sets Derive coefficients of linear best fit along ln(heights)- wspds distribution Characterise new distribution of speed values based on linear best fit Return the slope and the intercept of this linear best fit. The slope and intercept can then be used to find the corresponding roughness coefficient, using the equivilant laws: 1) $U(z) = (v/k)*ln(z/zo)$ which can be rewritten as: $U(z) = (v/k)*ln(z) - (v/k)ln(zo)$ where zo = e ** (-c/m) of this line Where: - U(z) is the wind speed at height z - v is the friction velocity at the location - k is the Von Karmen constant, taken aa .4 - z is the height - zo is the roughness coefficient 2) $U2 = (ln(z2/z0)/ln(z1/z0))U1$ """ if maximise_data: log_heights = np.log( pd.Series(heights).drop(wspds[wspds == 0].index.values.astype(int))) # take log of elevations wspds = wspds.drop(wspds[wspds == 0].index.values.astype(int)) else: log_heights = np.log(heights) # take log of elevations coeffs = np.polyfit(log_heights, wspds, deg=1) if return_coeff: return pd.Series([coeffs[0], coeffs[1]]) return coeffs[0] @staticmethod def _calc_power_law(wspds, heights, return_coeff=False, maximise_data=False) -> (np.array, float): """ Derive the best fit power law exponent (as 1/alpha) from a given time-step of speed data at 2 or more elevations :param wspds: pandas.Series or list of wind speeds [m/s] :param heights: List of heights [m above ground]. The position of the height in the list must be the same position in the list as its corresponding wind speed value. :return: The shear value (alpha), as the inverse exponent of the best fit power law, based on the form: $(v1/v2) = (z1/z2)^(1/alpha)$ :rtype: pandas.Series and float METHODOLOGY: Derive natural log of elevation and speed data sets Derive coefficients of linear best fit along log-log distribution Characterise new distribution of speed values based on linear best fit Derive 'alpha' based on gradient of first and last best fit points (function works for 2 or more points) Return alpha value """ if maximise_data: log_heights = np.log(pd.Series(heights).drop(wspds[wspds == 0].index.values.astype(int))) log_wspds = np.log(wspds.drop(wspds[wspds == 0].index.values.astype(int))) else: log_heights = np.log(heights) # take log of elevations log_wspds = np.log(wspds) # take log of speeds coeffs = np.polyfit(log_heights, log_wspds, deg=1) # get coefficients of linear best fit to log distribution if return_coeff: return pd.Series([coeffs[0], np.exp(coeffs[1])]) return coeffs[0] @staticmethod def _calc_roughness(slope, intercept): return e**(-intercept/slope) @staticmethod def _by_12x24(wspds, heights, min_speed=3, return_data=False, var_name='Shear'): tab_12x24 = dist_12x24(wspds[(wspds > min_speed).all(axis=1)].apply(Shear._calc_power_law, heights=heights, axis=1), return_data=True)[1] if return_data: return plt.plot_12x24_contours(tab_12x24, label=(var_name, 'mean')), tab_12x24 return plt.plot_12x24_contours(tab_12x24, label=(var_name, 'mean')) @staticmethod def scale(wspd, height, shear_to, alpha=None, roughness=None, calc_method='power_law'): """ Scales wind speeds from one height to another given a value of alpha or roughness coefficient (zo) :param wspd: Wind speed time series to apply shear to. :type wspd: pandas.Series :param height: height of above wspds. :type height: float :param shear_to: Height to which wspd should be scaled to. :type shear_to: float :param alpha: Shear exponent to be used when scaling wind speeds. :type alpha: Float :param roughness: Roughness coefficient to be used when scaling wind speeds. :type roughness: float :param calc_method: calculation method used to scale the wind speed. Using either: 1) 'power_law' : $(v1/v2) = (z1/z2)^(1/alpha)$ 2) 'log_law': $v2 = (ln(z2/z0)/ln(z1/z0))v1$ :type calc_method: string :return: a pandas series of the scaled wind speed :return: pandas.Series or float **Example Usage** :: # Scale wind speeds using exponents # Specify alpha to use alpha_value = .2 # Specify roughness coefficient to use zo = .03 height = 40 shear_to = 80 scaled_by_power_law = bw.Shear.scale(data['Spd40mN'], height, shear_to, alpha=alpha_value) scaled_by_log_law = bw.Shear.scale(data['Spd40mN'], height, shear_to, roughness=zo, calc_method='log_law') """ return Shear._scale(wspds=wspd, height=height, shear_to=shear_to, calc_method=calc_method, alpha=alpha, roughness=roughness) @staticmethod def _scale(wspds, height, shear_to, calc_method='power_law', alpha=None, roughness=None, origin=None): """ Private function for execution of scale() """ if not isinstance(wspds, pd.Series): wspds = pd.Series(wspds) if calc_method == 'power_law': scale_factor = (shear_to / height) ** alpha scaled_wspds = wspds * scale_factor elif calc_method == 'log_law': if origin == 'TimeSeries': scaled_wspds = Shear._log_roughness_scale(wspds=wspds, height=height, shear_to=shear_to, roughness=roughness) else: scaled_wspds = wspds.apply(Shear._log_roughness_scale, args=(height, shear_to, roughness)) else: raise ValueError("Please enter a valid calculation method, either 'power_law' or 'log_law'.") return scaled_wspds @staticmethod def _apply(self, wspds, height, shear_to, wdir=None): scaled_wspds = pd.Series([]) result = pd.Series([]) if self.origin == 'TimeSeries': if self.calc_method == 'power_law': df = pd.concat([wspds, self.alpha], axis=1).dropna() scaled_wspds = Shear._scale(wspds=df.iloc[:, 0], height=height, shear_to=shear_to, calc_method='power_law', alpha=df.iloc[:, 1]) else: df = pd.concat([wspds, self.roughness], axis=1).dropna() scaled_wspds = Shear._scale(wspds=df.iloc[:, 0], height=height, shear_to=shear_to, calc_method=self.calc_method, roughness=self._roughness, origin=self.origin) result = scaled_wspds.dropna() if self.origin == 'TimeOfDay': if self.calc_method == 'power_law': filled_alpha = Shear._fill_df_12x24(self.alpha) else: filled_roughness = Shear._fill_df_12x24(self._roughness) filled_alpha = filled_roughness df_wspds = [[None for y in range(12)] for x in range(24)] f = FloatProgress(min=0, max=24 * 12, description='Calculating', bar_style='success') display(f) for i in range(0, 24): for j in range(0, 12): if i == 23: df_wspds[i][j] = wspds[ (wspds.index.time >= filled_alpha.index[i]) & (wspds.index.month == j + 1)] else: df_wspds[i][j] = wspds[ (wspds.index.time >= filled_alpha.index[i]) & (wspds.index.time < filled_alpha.index[i + 1]) & (wspds.index.month == j + 1)] if self.calc_method == 'power_law': df_wspds[i][j] = Shear._scale(df_wspds[i][j], shear_to=shear_to, height=height, alpha=filled_alpha.iloc[i, j], calc_method=self.calc_method) else: df_wspds[i][j] = Shear._scale(df_wspds[i][j], shear_to=shear_to, height=height, roughness=filled_roughness.iloc[i, j], calc_method=self.calc_method) scaled_wspds = pd.concat([scaled_wspds, df_wspds[i][j]], axis=0) f.value += 1 result = scaled_wspds.sort_index() f.close() if self.origin == 'BySector': # initialise series for later use bin_edges = pd.Series([]) by_sector = pd.Series([]) if self.calc_method == 'power_law': direction_bins = self.alpha else: direction_bins = self._roughness # join wind speeds and directions together in DataFrame df = pd.concat([wspds, wdir], axis=1) df.columns = ['Unscaled_Wind_Speeds', 'Wind_Direction'] # get directional bin edges from Shear.by_sector output for i in range(self.sectors): bin_edges[i] = float(re.findall(r"[-+]?\d*\.\d+|\d+", direction_bins.index[i])[0]) if i == self.sectors - 1: bin_edges[i + 1] = -float(re.findall(r"[-+]?\d*\.\d+|\d+", direction_bins.index[i])[1]) for i in range(0, self.sectors): if bin_edges[i] > bin_edges[i + 1]: by_sector[i] = df[ (df['Wind_Direction'] >= bin_edges[i]) | (df['Wind_Direction'] < bin_edges[i + 1])] elif bin_edges[i + 1] == 360: by_sector[i] = df[(df['Wind_Direction'] >= bin_edges[i])] else: by_sector[i] = df[ (df['Wind_Direction'] >= bin_edges[i]) & (df['Wind_Direction'] < bin_edges[i + 1])] by_sector[i].columns = ['Unscaled_Wind_Speeds', 'Wind_Direction'] if self.calc_method == 'power_law': scaled_wspds[i] = Shear._scale(wspds=by_sector[i]['Unscaled_Wind_Speeds'], height=height, shear_to=shear_to, calc_method=self.calc_method, alpha=self.alpha[i]) elif self.calc_method == 'log_law': scaled_wspds[i] = Shear._scale(wspds=by_sector[i]['Unscaled_Wind_Speeds'], height=height, shear_to=shear_to, calc_method=self.calc_method, roughness=self._roughness[i]) if i == 0: result = scaled_wspds[i] else: result = pd.concat([result, scaled_wspds[i]], axis=0) result.sort_index(axis='index', inplace=True) if self.origin == 'Average': if wdir is not None: warnings.warn('Warning: Wind direction will not be accounted for when calculating scaled wind speeds.' ' The shear exponents for this object were not calculated by sector. ' 'Check the origin of the object using ".origin". ') if self.calc_method == 'power_law': result = Shear._scale(wspds=wspds, height=height, shear_to=shear_to, calc_method=self.calc_method, alpha=self.alpha) elif self.calc_method == 'log_law': result = Shear._scale(wspds=wspds, height=height, shear_to=shear_to, calc_method=self.calc_method, roughness=self._roughness) new_name = wspds.name + '_scaled_to_' + str(shear_to) + 'm' result.rename(new_name, inplace=True) return result @staticmethod def _fill_df_12x24(data): """ Fills a pandas.DataFrame or Series to be a 12 month x 24 hour pandas.DataFrame by duplicating entries. Used for plotting TimeOfDay shear. :param data: pandas.DataFrame or Series to be turned into a 12x24 dataframe :type data: pandas.Series or pandas.DataFrame. :return: 12x24 pandas.DataFrame """ # create copy for later use df_copy = data.copy() interval = int(24 / len(data)) # set index for new data frame to deal with less than 24 sectors idx =
pd.date_range('2017-01-01 00:00', '2017-01-01 23:00', freq='1H')
pandas.date_range
# -*- coding: utf-8 -*- import pandas as pd, numpy as np from matplotlib import pyplot as plt import os import seaborn as sns import matplotlib.colors as mcolors def plot_metrics(out_fld, selected_ids, pp_colors, labels, metrics, all_runs_mae, figsize=(8, 5), suffix='', ylim_top=0.1, disaggregate=False): plt.rcParams.update({'font.size': 16}) all_runs_mae_mean = dict() for set_name in all_runs_mae: all_runs_mae_mean[set_name] = np.mean(all_runs_mae[set_name], axis=2) n_runs = all_runs_mae_mean[set_name].shape[0] palette = [pp_colors[i] for i in selected_ids] series_1 = pd.Series() series_2 = pd.Series() series_3 = pd.Series() series_4 = pd.Series() for i, pp in enumerate(labels[selected_ids]): for set_name in all_runs_mae_mean: series_1 = series_1.append(pd.Series(all_runs_mae_mean[set_name][:, selected_ids[i]]), ignore_index=True) series_2 = series_2.append(pd.Series([set_name] * n_runs), ignore_index=True) series_3 = series_3.append(pd.Series(np.arange(n_runs)), ignore_index=True) series_4 = series_4.append(pd.Series([pp.replace('(amazon)', '[3]').replace('(naver)', '[2]')] * n_runs), ignore_index=True) display_df = pd.DataFrame({'absolute error': series_1, 'set': series_2, 'run': series_3, 'Performance Predictor': series_4}) plt.figure(figsize=figsize); # plt.title('Absolute Error of Performance Predictors') sns.boxplot(x="set", y="absolute error", hue="Performance Predictor", data=display_df, palette=palette, fliersize=0) plt.ylim(bottom=-0.001); # , ylim_top); plt.legend(); # bbox_to_anchor=(1.4, 1.05)); plt.tight_layout() plt.savefig(os.path.join(out_fld, 'abs_error' + suffix + '.png'), bbox_inches='tight') plt.close() for name, all_runs_metric in metrics: plt.figure(figsize=(12, 8)); for i, lab in enumerate(labels): if i in selected_ids: metric_all = [] for set_name in all_runs_metric: metric_all.append(all_runs_metric[set_name][:, i]) y = np.mean(metric_all, axis=1) lo = np.quantile(metric_all, 0.1, axis=1) hi = np.quantile(metric_all, 0.9, axis=1) plt.plot(y, label=labels[i].replace('(amazon)', '[3]').replace('(naver)', '[2]'), color=pp_colors[i], marker='o', linewidth=2, markersize=8); plt.fill_between(np.arange(len(all_runs_metric.keys())), lo, hi, alpha=0.3, color=pp_colors[i]) plt.legend(); # bbox_to_anchor=(1.2, 1.05)); plt.xticks(range(len(all_runs_metric.keys())), all_runs_metric.keys()); # plt.ylim(-0.1, 1.1); # plt.hlines(y=0.0, xmin=0, xmax=len(all_runs_metric.keys()), linestyles='dashed'); # plt.title("%s of Performance Predictors" % name); plt.ylabel('%s' % name.replace('auc_sigma_mae', r'$MAE_{CI}$').replace('within_ci_mae', r'$MAE_{CI_{0.05}}$')); plt.tight_layout() plt.savefig(os.path.join(out_fld, '%s%s.png' % (name, suffix)), bbox_inches='tight') plt.close() # desaggregated results if disaggregate: for run in range(n_runs): series_1 =
pd.Series()
pandas.Series
import numpy as np import pandas as pd import torch import torch.nn as nn import torch.nn.functional as F import time import random import matplotlib.pyplot as plt import seaborn as sns import Levenshtein from tqdm import tqdm from torch.utils import data from torch.autograd import Variable from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence from attention import Attention from utils import LETTER_LIST, letter2index, index2letter from search import greedy_search, beam_search cuda = torch.cuda.is_available() device = torch.device("cuda" if cuda else "cpu") def train(model, train_loader, criterion, optimizer, mode='train', TF_rate=0.95): model.train() running_entropy_loss = 0.0 running_perx_loss = 0.0 running_dist = 0.0 for i, (packed_x, packed_y, x_lengths, y_lengths) in enumerate(tqdm(train_loader)): optimizer.zero_grad() x, y, x_len, y_len = packed_x.to(device), packed_y.to(device), x_lengths.to(device), y_lengths.to(device) y, _ = pad_packed_sequence(y, batch_first=True) predictions, attentions = model(x, x_len, y, mode='train', TF_rate=TF_rate) b, seq_max, _ = predictions.shape # generate a mask to cross-out those padding's KL-divergence mask = Variable(torch.zeros(b, seq_max), requires_grad=False).to(device) for k in range(b): mask[k][:y_len[k]] = 1 loss = criterion(predictions.view(-1, predictions.shape[2]), y.view(-1)) avg_masked_loss = torch.sum(loss * mask.view(-1)) / torch.sum(mask) running_entropy_loss += float(avg_masked_loss.item()) running_perx_loss += float(torch.exp(avg_masked_loss).item()) avg_masked_loss.backward() # visualize graident distribution and attention plot for debugging purpose # if you are using jupyter notebook, you can comment out the below to see plots # if (i == 0): # plot_grad_flow(model.named_parameters(), i, i) # plot_attention(attentions) # clipping to avoid graident exploding clipping_value = 1.0 torch.nn.utils.clip_grad_norm(model.parameters(), clipping_value) optimizer.step() # translation for Lev Distance, use greedy search during training pred_strs = greedy_search(torch.argmax(predictions, dim=-1).detach().cpu().numpy()) ans_strs = greedy_search(y.detach().cpu().numpy()) running_dist += np.mean([Levenshtein.distance(pred, ans) for pred, ans in zip(pred_strs, ans_strs)]) # clear cuda cache for memory issue del x, y, x_len, y_len torch.cuda.empty_cache() running_entropy_loss /= (i+1) running_perx_loss /= (i+1) running_dist /= (i+1) print("Train Result: Cross Entropy Loss : {:.3f} and Perplex Loss : {:.3f} and Lev Dist : {:.3f}".format(running_entropy_loss, running_perx_loss, running_dist)) return running_entropy_loss, running_perx_loss, running_dist def val(model, valid_loader, criterion, beam_width=8): model.eval() running_entropy_loss = 0.0 running_perx_loss = 0.0 running_dist = 0.0 with torch.no_grad(): for i, (packed_x, packed_y, x_lengths, y_lengths) in enumerate(tqdm(valid_loader)): x, y, x_len, y_len = packed_x.to(device), packed_y.to(device), x_lengths.to(device), y_lengths.to(device) y, _ = pad_packed_sequence(y, batch_first=True) # one predictions is ending-controlled for loss computation # another is free-generation util max-len reached predictions, attentions = model(x, x_len, y, mode='eval') predictions_loss, attentions = model(x, x_len, y, mode='train') # generate a mask to cross-out those padding's KL-divergence b, seq_max, _ = predictions_loss.shape mask = Variable(torch.zeros(b, seq_max), requires_grad=False).to(device) for k in range(b): mask[k][:y_len[k]] = 1 loss = criterion(predictions_loss.view(-1, predictions_loss.shape[2]), y.view(-1)) avg_masked_loss = torch.sum(loss * mask.view(-1)) / torch.sum(mask) running_entropy_loss += float(avg_masked_loss.item()) running_perx_loss += float(torch.exp(avg_masked_loss).item()) # translation for Lev Distance, using beam search in validation beam_pred_strs = beam_search(F.softmax(predictions, dim=-1).detach().cpu().numpy(), beam_width) ans_strs = greedy_search(y.detach().cpu().numpy()) running_dist += np.mean([Levenshtein.distance(pred, ans) for pred, ans in zip(beam_pred_strs, ans_strs)]) del x, y, x_len, y_len torch.cuda.empty_cache() running_entropy_loss /= (i+1) running_perx_loss /= (i+1) running_dist /= (i+1) print("Valid: Cross Entropy Loss : {:.3f} and Perplex Loss : {:.3f} and Lev Dist(beam width={}) : {:.3f}".format(running_entropy_loss, running_perx_loss, beam_width, running_dist)) return running_entropy_loss, running_perx_loss, running_dist def inference(model, test_loader, output_path="../output", beam_width=8): """ inference """ def test(model, test_loader, beam_width): """ Generate testing string transaltion for the test dataset """ model.eval() str_predictions = [] with torch.no_grad(): for i, (packed_x, x_lengths) in enumerate(tqdm(test_loader)): x, x_len = packed_x.to(device), x_lengths.to(device) predictions, attentions = model(x, x_len, y=None, mode='eval') # You can choose to use greedy search(more efficient) or beam search(more exploratory) # pred_strs = greedy_search(torch.argmax(predictions, dim=-1).detach().cpu().numpy()) pred_strs = beam_search(F.softmax(predictions, dim=-1).detach().cpu().numpy(), beam_width) str_predictions.extend(pred_strs) del x, x_len torch.cuda.empty_cache() return str_predictions def output(predictions, output_path): """ Output the inference result to the proper csv file with column header for submission @param: inferences [List] : inferenced state label for test dataset """ df =
pd.DataFrame(predictions, columns=["label"])
pandas.DataFrame
import re import json import os import string import pickle import datetime import ipdb import pandas as pd from reuter_data import logging NEWS_MONTH = ['07', '08', '09', '10'] NEWS_NUMBER = [14793, 11978, 11337, 9743] def clean_sentence(s): s = re.sub("\n", " ", s) s = re.sub("[" + string.punctuation + "]", " ", s) s = re.sub(" +", " ", s) return s.strip() def collect_webhose_news(): df = pd.DataFrame() for i, month in enumerate(NEWS_MONTH): for index in range(1, NEWS_NUMBER[i] + 1): logging('{0:s}: {1:05d}/{2:05d}'.format(month, index, NEWS_NUMBER[i])) news_path = "data/{0:s}/news_{1:07d}.json".format(month, index) with open(news_path) as f: datum_json = json.load(f) datum = pd.Series( data={ 'text':datum_json['text'], 'published_time':datum_json['published'], 'country':datum_json['thread']['country'], 'title':datum_json['thread']['title'], 'site':datum_json['thread']['site'] } ) df = df.append(datum, ignore_index=True) df.to_csv('webhose_data.csv', index=False) ipdb.set_trace() def read_news_dataframe(news_per_day): df = pd.DataFrame() date_news_count = {} for i, month in enumerate(NEWS_MONTH): for index in range(NEWS_NUMBER[i]): news_path = "data/{0:s}/news_{1:07d}.json".format(month, NEWS_NUMBER[i] - index) with open(news_path) as f: datum_json = json.load(f) publish_time = pd.to_datetime(datum_json['published']) date_str = publish_time.strftime('%Y-%m-%d') start_time = datetime.datetime.strptime('{0:s} 0930'.format(date_str), '%Y-%m-%d %H%M') end_time = datetime.datetime.strptime('{0:s} 1600'.format(date_str), '%Y-%m-%d %H%M') if date_str not in date_news_count: date_news_count[date_str] = 0 if date_news_count[date_str] > news_per_day: continue if publish_time <= start_time or publish_time >= end_time: continue if datum_json['thread']['country'] != 'US' or 'finance' not in str(datum_json): continue text = clean_sentence(datum_json['text']) if len(text.split(' ')) < 100: continue date_news_count[date_str] += 1 datum = pd.Series( data={ 'text':text, 'date':date_str } ) df = df.append(datum, ignore_index=True) #pickle.dump(date_news_count, open("data/date_news_count.p", "wb")) return df def read_SNP_dataframe(): snp = pd.read_csv("data/GSPC.csv") snp['target'] = pd.Series('2015-06-30').append(snp['Date'][0:-1], ignore_index=True) for offset in range(1, 6): name = 'previous_price_{0:d}'.format(offset) snp[name] = pd.Series([None for _ in range(offset)]).append(snp['Close'][0:-offset] - snp['Open'][0:-offset], ignore_index=True) return snp def find_price(ticker, timestamp): date_str = timestamp.strftime('%Y%m%d') path = 'data/SNP/{0:s}/price/price_{1:s}.json'.format(ticker, date_str) if not os.path.exists(path): return None with open(path, 'rb') as f: data = pickle.load(f) start_time = datetime.datetime.strptime(date_str + ' 09:30', '%Y%m%d %H:%M') offset = int((timestamp - start_time).total_seconds() // 60) return data[offset] def generate_reuter_price(): reuter = pd.read_csv('reuter_data.csv') reuter['published_time'] = pd.to_datetime(reuter['published_time']) reuter.sort_values('published_time', inplace=True) twenty_min = datetime.timedelta(minutes=20) df =
pd.DataFrame()
pandas.DataFrame
import os import sys module_path = os.path.abspath(os.path.join('.')) if module_path not in sys.path: sys.path.append(module_path) import pandas as pd import numpy as np import matplotlib.pyplot as plt hippocampusAreas = { 'CA1' : 1, 'CA2' : 2, 'CA3' : 3, 'DG' : 4, 'Outer' : 0 } def loadFromFile(fileName = "") : if fileName == "" : return unprocessedDataSet = pd.read_csv(fileName) # convert to labels to numbers unprocessedDataSet.loc[unprocessedDataSet['Y'] == 'CA1', ['Y']] = 1 unprocessedDataSet.loc[unprocessedDataSet['Y'] == 'CA2', ['Y']] = 2 unprocessedDataSet.loc[unprocessedDataSet['Y'] == 'CA3', ['Y']] = 3 unprocessedDataSet.loc[unprocessedDataSet['Y'] == 'DG', ['Y']] = 4 unprocessedDataSet.loc[unprocessedDataSet['Y'] == 'Outer', ['Y']] = 0 #remove bogus records unprocessedDataSet = unprocessedDataSet.replace([np.inf, -np.inf], np.nan) unprocessedDataSet = unprocessedDataSet.dropna(); nulls = np.where(pd.isnull(unprocessedDataSet)) #Main Dataset hipAreaData = unprocessedDataSet.drop(unprocessedDataSet.index[nulls[0]]) #Get all Non hippocampal pixels isOuterData = hipAreaData['Y']==0 outerData = hipAreaData[isOuterData] #Get all Hippocampal pixels: CA1, CA2, CA3, DG isCA1Data = hipAreaData['Y']==1 CA1Data = hipAreaData[isCA1Data] isCA2Data = hipAreaData['Y']==2 CA2Data = hipAreaData[isCA2Data] isCA3Data = hipAreaData['Y']==3 CA3Data = hipAreaData[isCA3Data] isDgData = hipAreaData['Y']==4 dgData = hipAreaData[isDgData] #stack all hippocampall pixels together data = [CA1Data, CA2Data, CA3Data, dgData] xDevDataset =
pd.concat(data)
pandas.concat
from dataclasses import dataclass, field, asdict from typing import Dict, List, Union, Iterable import pandas as pd from pandas import DataFrame from PyQt5 import QtCore, QtGui, QtWidgets, sip from PyQt5.QtCore import Qt import traceback from functools import wraps from datetime import datetime from pandasgui.utility import get_logger, unique_name, in_interactive_console import os import collections logger = get_logger(__name__) @dataclass class Settings: # Should GUI block code execution until closed block: bool # Are table cells editable editable: bool = True style: str = "Fusion" def __init__(self, block=None): # Default blocking behavior if block is None: if in_interactive_console(): # Don't block if in an interactive console (so you can view GUI and still continue running commands) self.block = False else: # If in a script, we need to block or the script will continue and finish without allowing GUI interaction self.block = True @dataclass class Filter: expr: str enabled: bool failed: bool @dataclass class HistoryItem: name: str args: tuple kwargs: dict time: str def track_history(func): @wraps(func) def wrapper(pgdf, *args, **kwargs): history_item = HistoryItem(name=func.__name__, args=args, kwargs=kwargs, time=datetime.now().strftime("%H:%M:%S")) pgdf.history.append(history_item) return func(pgdf, *args, **kwargs) return wrapper class PandasGuiDataFrame: def __init__(self, df: DataFrame, name: str = 'Untitled'): super().__init__() df = df.copy() self.dataframe = df self.dataframe_original = df self.name = name self.history: List[HistoryItem] = [] # References to other object instances that may be assigned later self.settings: Settings = Settings() self.store: Union[Store, None] = None self.dataframe_explorer: Union["DataFrameExplorer", None] = None self.dataframe_viewer: Union["DataFrameViewer", None] = None self.filter_viewer: Union["FilterViewer", None] = None self.column_sorted: Union[int, None] = None self.index_sorted: Union[int, None] = None self.sort_is_ascending: Union[bool, None] = None self.filters: List[Filter] = [] # Refresh PyQt models when the underlying pgdf is changed in anyway that needs to be reflected in the GUI def update(self): models = [] if self.dataframe_viewer is not None: models += [self.dataframe_viewer.dataView.model(), self.dataframe_viewer.columnHeader.model(), self.dataframe_viewer.indexHeader.model(), self.dataframe_viewer.columnHeaderNames.model(), self.dataframe_viewer.indexHeaderNames.model(), ] if self.filter_viewer is not None: models += [self.filter_viewer.list_model, ] for model in models: model.beginResetModel() model.endResetModel() for view in [self.dataframe_viewer.columnHeader, self.dataframe_viewer.indexHeader]: view.set_spans() @track_history def edit_data(self, row, col, value, skip_update=False): # Not using iat here because it won't work with MultiIndex self.dataframe_original.at[self.dataframe.index[row], self.dataframe.columns[col]] = value if not skip_update: self.apply_filters() self.update() @track_history def paste_data(self, top_row, left_col, df_to_paste): # Not using iat here because it won't work with MultiIndex for i in range(df_to_paste.shape[0]): for j in range(df_to_paste.shape[1]): value = df_to_paste.iloc[i, j] self.edit_data(top_row + i, left_col + j, value, skip_update=True) self.apply_filters() self.update() @track_history def sort_column(self, ix: int): col_name = self.dataframe.columns[ix] # Clicked an unsorted column if ix != self.column_sorted: self.dataframe = self.dataframe.sort_values(col_name, ascending=True, kind="mergesort") self.column_sorted = ix self.sort_is_ascending = True # Clicked a sorted column elif ix == self.column_sorted and self.sort_is_ascending: self.dataframe = self.dataframe.sort_values(col_name, ascending=False, kind="mergesort") self.column_sorted = ix self.sort_is_ascending = False # Clicked a reverse sorted column - reset to the original unsorted order elif ix == self.column_sorted: unsorted_index = self.dataframe_original[self.dataframe_original.index.isin(self.dataframe.index)].index self.dataframe = self.dataframe.reindex(unsorted_index) self.column_sorted = None self.sort_is_ascending = None self.index_sorted = None self.update() @track_history def sort_index(self, ix: int): # Clicked an unsorted index level if ix != self.index_sorted: self.dataframe = self.dataframe.sort_index(level=ix, ascending=True, kind="mergesort") self.index_sorted = ix self.sort_is_ascending = True # Clicked a sorted index level elif ix == self.index_sorted and self.sort_is_ascending: self.dataframe = self.dataframe.sort_index(level=ix, ascending=False, kind="mergesort") self.index_sorted = ix self.sort_is_ascending = False # Clicked a reverse sorted index level - reset to the original unsorted order elif ix == self.index_sorted: unsorted_index = self.dataframe_original[self.dataframe_original.index.isin(self.dataframe.index)].index self.dataframe = self.dataframe.reindex(unsorted_index) self.index_sorted = None self.sort_is_ascending = None self.column_sorted = None self.update() @track_history def add_filter(self, expr: str, enabled=True): filt = Filter(expr=expr, enabled=enabled, failed=False) self.filters.append(filt) self.apply_filters() @track_history def remove_filter(self, index: int): self.filters.pop(index) self.apply_filters() @track_history def edit_filter(self, index: int, expr: str): filt = self.filters[index] filt.expr = expr filt.failed = False self.apply_filters() @track_history def toggle_filter(self, index: int): self.filters[index].enabled = not self.filters[index].enabled self.apply_filters() def apply_filters(self): df = self.dataframe_original for ix, filt in enumerate(self.filters): if filt.enabled and not filt.failed: try: df = df.query(filt.expr) except Exception as e: self.filters[ix].failed = True logger.exception(e) self.dataframe = df self.update() @staticmethod def cast(x: Union["PandasGuiDataFrame", pd.DataFrame, pd.Series, Iterable]): if type(x) == PandasGuiDataFrame: return x if type(x) == pd.DataFrame: return PandasGuiDataFrame(x) elif type(x) == pd.Series: return PandasGuiDataFrame(x.to_frame()) else: try: return PandasGuiDataFrame(
pd.DataFrame(x)
pandas.DataFrame
## Dataset.py __all__ = ["Proxy", "Train", "Predict"] import pandas as pd from .utils import * from .Descriptors import * from tqdm import tqdm import logging class Proxy: """ It will communicate with diffrent object of BBPRED """ def __init__(self): self.Full_Cached_DataFrame = None self.Cached_DataFrame_HASH = None def _Data_splitter(self,csv_file): if file_validator(csv_file): self.Cached_DataFrame_HASH = File_hash_calculator(csv_file) df = pd.read_csv(csv_file) SMILES = df["SMILES"] Target = df["Target"] return [SMILES,Target] def _Descriptor_calc(self,smiles_target,args=None): print(smiles_target) SMILES,Target = smiles_validator(*smiles_target) if args == None: data = [] for i in tqdm(SMILES): dis = Descriptor(i) data.append(Data_dict(dis.get_all())) return Data_frame(data,Target) else: single_data = [] for i in tqdm(SMILES): single_data.append(Data_dict(Descriptor(i).get(args))) return Data_frame(single_data,Target) def get_raw(self,csv_file,): SMILES , Target = self._Data_splitter(csv_file) return pd.DataFrame({"SMILES":SMILES, "Target":Target},) def get_raw_descriptor(self,csv_file,*args,as_csv=False,path=""): if File_hash_calculator(csv_file) == self.Cached_DataFrame_HASH: return self.Full_Cached_DataFrame else: self.Cached_DataFrame_HASH = None self.Full_Cached_DataFrame = None if len(args) == 0: if self.Full_Cached_DataFrame == None: Smiles_data = self._Data_splitter(csv_file) data = self._Descriptor_calc(Smiles_data) self.Full_Cached_DataFrame = data if as_csv: return
pd.to_csv(data,path)
pandas.to_csv
""" RNA-Seq analysis pipeline following the methods used by ICGC. This script works specifically for the mice data on the JLU server. Some of the functions could be rewritten for general use. Function: 1. Walk through DATA_DIR and generate a design matrix. 2. Concatenate samples with multiple fastq files (splitted lanes). 3. Run fastp on all fq.gz files, and store the trimmed file under RES_DIR/data. Reports of fastp are stored in RES_DIR/fastp. 4. Align each sample using a two-pass method with STAR Output: Under `RES_DIR/data` and `RES_DIR/fastp`, we have the trimmed FASTQ files and their corresponding fastp reports. MultiQC reports is under `RES_DIR/fastp/multiqc`. Under `RES_DIR/bam`, each sample should have its own sub-directory containing the following files with the `sample_group` as a prefix: - Aligned.out.bam: all genomic alignments including chimeric and unaligned reads - Aligned.toTranscriptome.out.bam: aligned reads with transcript coordinates rather than genomic coordinates - Chimeric.out.junction: reads that were mapped to different chromosomes or strands (fusion alignments) - SJ.out.tab: high confidence collapsed splice junctions - Log(.final|.progress).out Under `RES_DIR/counts`, the counts produced by STAR is moved here. See https://www.biostars.org/p/218995/. In our case cols 1 and 2 should be kept. Under `RES_DIR/tpm`, TPM values produced by Salmon is stored. Ensembl transcript IDs are used because it's mapped to the reference transcriptome. Software and data: - fastp v0.20.0: https://github.com/OpenGene/fastp - FastQC v0.11.9: http://www.bioinformatics.babraham.ac.uk/projects/fastqc/fastqc_v0.11.9.zip - multiQC v1.8: https://multiqc.info - STAR v2.7.2b: https://github.com/alexdobin/STAR - Salmon v1.1.0: https://github.com/COMBINE-lab/salmon/releases/download/v1.1.0/salmon-1.1.0_linux_x86_64.tar.gz - Reference genome: ftp://ftp.ebi.ac.uk/pub/databases/gencode/Gencode_mouse/release_M24/GRCm38.primary_assembly.genome.fa.gz - Reference transcriptome: ftp://ftp.ebi.ac.uk/pub/databases/gencode/Gencode_mouse/release_M24/gencode.vM24.transcripts.fa.gz - Gene annotation: ftp://ftp.ebi.ac.uk/pub/databases/gencode/Gencode_mouse/release_M24/gencode.vM24.annotation.gtf.gz References: https://docs.gdc.cancer.gov/Data/Bioinformatics_Pipelines/Expression_mRNA_Pipeline/ https://github.com/akahles/icgc_rnaseq_align/blob/master/star_align.py https://salmon.readthedocs.io/en/latest/salmon.html https://combine-lab.github.io/alevin-tutorial/2019/selective-alignment/ Choice of software: https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4728800/ """ import glob import gzip import logging import os import re import shutil import subprocess from typing import List import pandas as pd # Filepath variables WORK_DIR = os.path.expanduser("~/rna_seq") DATA_DIR = os.path.join(WORK_DIR, "mm_liver_data") RES_DIR = os.path.join(WORK_DIR, "results") REFERENCE_GENOME_PATH = os.path.join(WORK_DIR, "genome", "GRCm38.p6.genome.fa") REFERENCE_TRANSCRIPTOME_PATH = os.path.join( WORK_DIR, "genome", "gencode.vM24.transcripts.fa" ) GENCODE_PATH = os.path.join(WORK_DIR, "genome", "gencode.vM24.annotation.gtf") STAR_INDEX_DIR = os.path.join(WORK_DIR, "star_index") FASTP_PATH = os.path.expanduser("~/pkg/bin/fastp") FASTQC_PATH = os.path.expanduser("~/pkg/bin/fastqc") MULTIQC_PATH = os.path.expanduser("~/.local/bin/multiqc") STAR_PATH = os.path.expanduser("~/pkg/bin/STAR") SALMON_PATH = os.path.expanduser("~/pkg/bin/salmon/bin/salmon") for d in [ f"{RES_DIR}/data", f"{RES_DIR}/fastp/multiqc", f"{RES_DIR}/fastqc", f"{RES_DIR}/bam", f"{RES_DIR}/counts", f"{RES_DIR}/tpm", STAR_INDEX_DIR, ]: os.makedirs(d, exist_ok=True) # Log settings logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) handler = logging.FileHandler(os.path.join(f"{__file__.rstrip('.py')}.log")) handler.setLevel(logging.INFO) formatter = logging.Formatter( "%(asctime)s [%(levelname)s]{%(lineno)d:%(funcName)12s()} %(message)s", "%Y-%m-%d %H:%M:%S", ) handler.setFormatter(formatter) logger.addHandler(handler) def ListFastqFiles(group: str = "original") -> List[List[str]]: """ List fastq files to be analyzed in the current working directory. Folders could contain multiple files for the same sample, which should be joined as they are from multiple lanes. Returns: A list of lists of absolute paths to the fq.gz files. Each sublist contains files in the same directory. """ # Find the lowest-level directories containing the files all_files = glob.glob(f"{DATA_DIR}/{group}/**/FCH*.fq.gz", recursive=True) dir_names = set((os.path.dirname(x) for x in all_files)) res = [] for dir_name in dir_names: # Assuming we don't have any missing files uniq_samples = list( set( ( re.sub(r"^(.*)_[12]\.fq\.gz$", r"\1", x) for x in glob.glob(f"{dir_name}/FCH*.fq.gz") ) ) ) logger.debug(f"Found {len(uniq_samples)} for {dir_name}") res.append(uniq_samples) return res def Samples2DesignMatrix(samples: List[List[str]]) -> pd.DataFrame: """ Convert the samples list to a design matrix. Args: samples (List[List[str]]): return from function `ListFastqFiles`. Returns: pd.DataFrame: a design matrix with the following columns: - timepoint: 1 - 9 - sample_type: Control / Model / Genpin - sample_group: e.g. original/T1_C/11_90bp - filename: comma-separated filenames (_[1|2] removed) """ _samples = [x for subl in samples for x in subl] _samples = [re.sub(f"{DATA_DIR}/", "", x) for x in _samples] filenames = [os.path.basename(x) for x in _samples] sample_groups = [os.path.dirname(x) for x in _samples] possible_sample_types = {"C": "Control", "M": "Model", "G": "Genpin"} timepoints = [] sample_type = [] for sg in sample_groups: if sg.startswith("original"): tmp = re.search("/T(\d+)_([CMG])", sg) timepoints.append(tmp.group(1)) sample_type.append(possible_sample_types[tmp.group(2)]) else: # A "new" sample tmp = re.search("/Time_(\d+)_.*/(Control|Model)", sg) timepoints.append(tmp.group(1)) sample_type.append(tmp.group(2)) df = pd.DataFrame( { "timepoint": timepoints, "sample_type": sample_type, # Control/Model "sample_group": sample_groups, # "filename": filenames, # FCH*_[1|2].fq.gz } ) df = df.sort_values(by=["timepoint", "sample_type", "sample_group"]) df = ( df.groupby(["timepoint", "sample_type", "sample_group"])["filename"] .agg(",".join) .reset_index() ) return df def ConcatSamples(samples: List[str]): """ Concatenate samples in the same group to two fq.gz files. Files are cat together because they are the same sample split to multiple lanes. The concatenate files are for the forward and reverse reads. Args: samples (List[str]): comma-separated absolute file paths with the trailing _[1|2].fq.gz stripped Returns: the `sample_group` of the concatenated files. """ f_out = f"{os.path.dirname(samples[0])}/" sample_group = re.sub(DATA_DIR, "", f_out).strip("/") if not os.path.exists(f"{f_out}merged_1.fq.gz"): f_of_sample = " ".join([f"{x}_1.fq.gz" for x in samples]) cmd1 = f"cat {f_of_sample} > {f_out}merged_1.fq.gz" subprocess.check_call(cmd1, shell=True) logger.info(f"Concatenated fastq files for {sample_group}_1") if not os.path.exists(f"{f_out}merged_2.fq.gz"): f_of_sample = " ".join([f"{x}_2.fq.gz" for x in samples]) cmd2 = f"cat {f_of_sample} > {f_out}merged_2.fq.gz" subprocess.check_call(cmd2, shell=True) logger.info(f"Concatenated fastq files for {sample_group}_2") return sample_group if __name__ == "__main__": logger.info("\x1b[31;1m" + "/*** GDC RNA-Seq pipeline started! ***/" + "\x1b[0m") ################################################################### # Get design matrix # ################################################################### logger.info("\x1b[33;21m" + "Step 1: get design matrix" + "\x1b[0m") if os.path.exists(f"{DATA_DIR}/design_matrix.csv"): design_mat = pd.read_csv(f"{DATA_DIR}/design_matrix.csv") logger.info("Read design matrix from file") else: # Get sample paths for original and new files original_samples = ListFastqFiles(group="original") new_samples = ListFastqFiles(group="new") all_samples = original_samples + new_samples # Make design matrix of raw data files design_mat = Samples2DesignMatrix(all_samples) design_mat.to_csv(f"{DATA_DIR}/design_matrix.csv", index=False) logger.info("Created design matrix") ################################################################### # Concatenate multi-lane samples # ################################################################### logger.info("\x1b[33;21m" + "Step 2: concatenate multi-lane samples" + "\x1b[0m") sm_multi_lanes = design_mat[design_mat["filename"].str.contains(",")] filenames = sm_multi_lanes.apply( lambda x: [ f"{DATA_DIR}/{x['sample_group']}/{ele}" for ele in x["filename"].split(",") ], axis=1, ).tolist() for f in filenames: sg = ConcatSamples(f) design_mat.loc[design_mat["sample_group"] == sg, "filename"] = "merged" assert not any(design_mat.filename.str.contains(",")) ################################################################### # Run fastp on all fq files # ################################################################### logger.info("\x1b[33;21m" + "Step 3: QC and preprocess with fastp" + "\x1b[0m") filenames = ( DATA_DIR + "/" + design_mat["sample_group"] + "/" + design_mat["filename"] ) filenames = filenames.tolist() sample_groups = [x.replace("/", "_") for x in design_mat["sample_group"]] for i, (f, sg) in enumerate(zip(filenames, sample_groups)): if os.path.exists(f"{RES_DIR}/fastp/{sg}_fastp.json"): continue logger.info(f"Running fastp on sample {sg}...") subprocess.check_call( f"""{FASTP_PATH} -V -i {f}_1.fq.gz -I {f}_2.fq.gz \ -o {RES_DIR}/data/{sg}_1.fq.gz \ -O {RES_DIR}/data/{sg}_2.fq.gz \ --html {RES_DIR}/fastp/{sg}_fastp.html \ --json {RES_DIR}/fastp/{sg}_fastp.json \ -w 4""", shell=True, ) logger.info(f"Generated fastp report for sample {sg}") subprocess.check_call( f"{MULTIQC_PATH} {RES_DIR}/fastp/ -m fastp -o {RES_DIR}/fastp/multiqc/", shell=True, ) if not os.path.exists(f"{RES_DIR}/fastqc/multiqc_report.html"): subprocess.check_call( f"{FASTQC_PATH} {RES_DIR}/data/* --noextract -o {RES_DIR}/fastqc/ -t 4" ) subprocess.check_call( f"{MULTIQC_PATH} {RES_DIR}/fastp/ -m fastqc -o {RES_DIR}/fastqc/", shell=True, ) ################################################################### # Align sequences and call counts # ################################################################### logger.info("\x1b[33;21m" + "Step 4: STAR alignment" + "\x1b[0m") # Build the STAR index if it's not already built if not os.path.exists(f"{STAR_INDEX_DIR}/Genome"): logger.info("STAR index not found. Building now...") subprocess.check_call( f"""STAR \ --runMode genomeGenerate \ --genomeDir {STAR_INDEX_DIR} \ --genomeFastaFiles {REFERENCE_GENOME_PATH} \ --sjdbOverhang 100 \ --sjdbGTFfile {GENCODE_PATH} \ --runThreadN 8 \ --outFileNamePrefix {WORK_DIR}/logs/star_index""", shell=True, ) logger.info(f"STAR index built to {STAR_INDEX_DIR}") # Run STAR for each sample if output files are not found sg_sms = design_mat["sample_group"].apply(os.path.basename) for i, (sg, sm) in enumerate(zip(sample_groups, sg_sms)): if os.path.exists(f"{RES_DIR}/counts/{sg}.tsv") and os.path.exists( f"{RES_DIR}/bam/{sg}" ): continue os.makedirs(f"{RES_DIR}/bam/{sg}", exist_ok=True) logger.info(f"Aligning sample {sg}") subprocess.check_call( f"""{STAR_PATH} \ --readFilesIn {RES_DIR}/data/{sg}_1.fq.gz {RES_DIR}/data/{sg}_2.fq.gz \ --outSAMattrRGline ID:{sg} SM:{sm} \ --alignIntronMax 1000000 \ --alignIntronMin 20 \ --alignMatesGapMax 1000000 \ --alignSJDBoverhangMin 1 \ --alignSJoverhangMin 8 \ --alignSoftClipAtReferenceEnds Yes \ --chimJunctionOverhangMin 15 \ --chimMainSegmentMultNmax 1 \ --chimOutType Junctions SeparateSAMold WithinBAM SoftClip \ --chimSegmentMin 15 \ --genomeDir {STAR_INDEX_DIR} \ --genomeLoad NoSharedMemory \ --limitSjdbInsertNsj 1200000 \ --outFileNamePrefix {RES_DIR}/bam/{sg}/{sg} \ --outFilterIntronMotifs None \ --outFilterMatchNminOverLread 0.33 \ --outFilterMismatchNmax 999 \ --outFilterMismatchNoverLmax 0.1 \ --outFilterMultimapNmax 20 \ --outFilterScoreMinOverLread 0.33 \ --outFilterType BySJout \ --outSAMattributes NH HI AS nM NM ch \ --outSAMstrandField intronMotif \ --outSAMtype BAM Unsorted \ --outSAMunmapped Within \ --quantMode TranscriptomeSAM GeneCounts \ --readFilesCommand zcat \ --runThreadN 8 \ --twopassMode Basic""", shell=True, ) shutil.move( f"{RES_DIR}/bam/{sg}/{sg}ReadsPerGene.out.tab", f"{RES_DIR}/counts/{sg}.tsv" ) logger.info(f"Counts for sample {sg} generated") ################################################################### # Get TPM using Salmon # ################################################################### logger.info("\x1b[33;21m" + "Step 5: Get TPM values using Salmon" + "\x1b[0m") for sg in sample_groups: if os.path.exists(f"{RES_DIR}/tpm/{sg}"): continue logger.info(f"Calling TPM values for sample {sg}") subprocess.check_call( f"""{SALMON_PATH} quant \ -t {REFERENCE_TRANSCRIPTOME_PATH} \ -l A \ -a {RES_DIR}/bam/{sg}/{sg}Aligned.toTranscriptome.out.bam \ -o {RES_DIR}/tpm/{sg} \ --gencode""", shell=True, ) ################################################################### # Combine counts and TPM tables # ################################################################### logger.info("\x1b[33;21m" + "Step 6: Combine counts and TPM tables" + "\x1b[0m") counts_table = [] tpm_table = [] for sg in sample_groups: # Combine counts files into one table df = pd.read_table(f"{RES_DIR}/counts/{sg}.tsv", header=None).iloc[:, 0:2] df.columns = ["Ensembl", "count"] df["sample_group"] = sg counts_table.append(df) # Combine TPM files, also copy the quant.sf files to a separate folder df = pd.read_table(f"{RES_DIR}/tpm/{sg}/quant.sf")[["Name", "TPM"]] df.columns = ["Ensembl", "TPM"] df["sample_group"] = sg tpm_table.append(df) counts_table =
pd.concat(counts_table, axis=0, ignore_index=True)
pandas.concat
import unittest import tempfile import json import numpy as np import pandas as pd from numpy.testing import assert_almost_equal from supervised.preprocessing.loo_encoder import LooEncoder class LabelEncoderTest(unittest.TestCase): def test_fit(self): # training data d = {"col1": ["a", "a", "c"], "col2": ["w", "e", "d"], "y": [1, 2, 0]} df = pd.DataFrame(data=d) le = LooEncoder(cols=["col1"]) le.fit(df[["col1", "col2"]], df["y"]) self.assertTrue(le.enc is not None) self.assertTrue(le.enc._dim == 2) assert_almost_equal(le.enc._mean, 1.0) self.assertTrue("col1" in le.enc.mapping) self.assertTrue("col2" not in le.enc.mapping) def test_transform(self): # training data d = {"col1": ["a", "a", "c"]} y = [1, 1, 0] df =
pd.DataFrame(data=d)
pandas.DataFrame
import mne import matplotlib.pyplot as plt import os import numpy as np import scipy.signal as sp import pandas as pd import seaborn as sns def load_file(file_name, channels=False): os.chdir(r"") # EDF data file data = mne.io.read_raw_edf(file_name, preload=True) channels = data.ch_names print(channels) dataraw = data.get_data() events = np.genfromtxt(file_name[:-4] + ".ann", dtype=int, delimiter=",", skip_header=1) if channels == True: return dataraw, events, channels else: return dataraw, events channels = load_file("data.edf", channels=True)[2] def FFT(data, window=500, freqs=False): spectre = abs(np.fft.fft(data).real) ** 2 freq = np.fft.fftfreq(window, d=.004) if freqs == True: return freq, spectre else: return spectre data, events = load_file("data.edf") print(data.shape) def Epoched_data(data, window): e_data = data[:, events[0, 0]:events[0, 0] + window] for i in events[1:, 0]: e_data = np.append(e_data, data[:, i:i + window], axis=1) return e_data[:-4,:].reshape(-1, 19, 500) print(Epoched_data(load_file("data.edf")[0], 500)) freqs = FFT(Epoched_data(load_file("data.edf")[0], 500), freqs=True)[0][:250] freqs1 = np.array(list(freqs) * 118).reshape(-1, 1) ev = list(events[:, 2]) * 250 ev = np.array(ev).reshape(250, -1) ev = ev.T.reshape(-1, 1) result = np.append(ev, freqs1, axis=1) def Feat_Spectre(): ex_t = np.zeros((1, 19)) e_data = Epoched_data(load_file("data.edf")[0], 500) for j in range(e_data.shape[0]): temp = np.zeros((1, 250)) for i in range(e_data.shape[1]): temp = np.append(temp, [FFT(e_data[j, i, :])[:250]], axis=0) temp = np.rot90(np.flip(temp[1:20,:], axis = 1), k = 1) ex_t = np.append(ex_t, temp, axis=0) return ex_t[1:,:] spectre = Feat_Spectre() db =
pd.DataFrame(spectre)
pandas.DataFrame
from __future__ import print_function import pandas as pd import numpy as np import matplotlib.pyplot as plt import matplotlib.cm as cm from matplotlib import colors from collections import defaultdict df =
pd.read_csv('stats.txt', index_col=0, dtype={'game': 'str'})
pandas.read_csv
#/usr/bin/env python from matplotlib import pyplot as plt import pandas as pd import seaborn as sns from sklearn.datasets import load_breast_cancer from sklearn.model_selection import train_test_split from sklearn.metrics import precision_score, recall_score, f1_score, roc_curve # import argparse, os # # parser = argparse.ArgumentParser() # parser.add_argument("path_to_data") # args = parser.parse_args() # testfile = args.path_to_data df = load_breast_cancer() data, target, target_names, feature_names = df.data, df.target, df.target_names, df.feature_names # plot heatmap df =
pd.DataFrame(data, columns=feature_names)
pandas.DataFrame
# -*- coding: utf-8 -*- """ Created on Thu Nov 23 21:53:32 2017 @author: gason """ import pandas as pd import numpy as np import re import time import os from collections import Iterable from pandas.api.types import is_string_dtype from pandas.api.types import is_numeric_dtype from pandas.api.types import is_number from pandas.api.types import is_datetime64_any_dtype from pandas.api.types import is_categorical_dtype from scipy import stats from sklearn import metrics from . import report as _rpt from . import config from .report import genwordcloud from .utils.metrics import entropyc from .utils import iqr #from sklearn.neighbors import KernelDensity import matplotlib.pyplot as plt import seaborn as sns _thisdir = os.path.split(__file__)[0] # default chinese font from matplotlib.font_manager import FontProperties font_path=config.font_path if font_path: myfont=FontProperties(fname=font_path) sns.set(font=myfont.get_name()) __all__=['type_of_var', 'describe', 'plot', 'features_analysis', 'distributions', 'AnalysisReport', 'ClassifierReport'] def _freedman_diaconis_bins(a): """Calculate number of hist bins using Freedman-Diaconis rule.""" # From http://stats.stackexchange.com/questions/798/ a = np.asarray(a) assert len(a.shape)>0 assert len(a)>0 h = 2 * iqr(a) / (len(a) ** (1 / 3)) # fall back to sqrt(a) bins if iqr is 0 if h == 0: return int(np.sqrt(a.size)) else: return int(np.ceil((a.max() - a.min()) / h)) def distributions(a,hist=True,bins=None,norm_hist=True,kde=False,grid=None,gridsize=100,clip=None): '''数组的分布信息 hist=True,则返回分布直方图(counts,bins) kde=True,则返回核密度估计数组(grid,y) example ------- a=np.random.randint(1,50,size=(1000,1)) ''' a = np.asarray(a).squeeze() if hist: if bins is None: bins = min(_freedman_diaconis_bins(a), 50) counts,bins=np.histogram(a,bins=bins) if norm_hist: counts=counts/counts.sum() if kde: bw='scott' cut=3 if clip is None: clip = (-np.inf, np.inf) try: kdemodel = stats.gaussian_kde(a, bw_method=bw) except TypeError: kdemodel = stats.gaussian_kde(a) bw = "scotts" if bw == "scott" else bw bw = getattr(kdemodel, "%s_factor" % bw)() * np.std(a) if grid is None: support_min = max(a.min() - bw * cut, clip[0]) support_max = min(a.max() + bw * cut, clip[1]) grid=np.linspace(support_min, support_max, gridsize) y = kdemodel(grid) if hist and not(kde): return counts,bins elif not(hist) and kde: return grid,y elif hist and kde: return ((counts,bins),(grid,y)) else: return None def dtype_detection(data,category_detection=True,StructureText_detection=True,\ datetime_to_category=True,criterion='sqrt',min_mean_counts=5,fix=False): '''检测数据中单个变量的数据类型 将数据类型分为以下4种 1. number,数值型 2. category,因子 3. datetime,时间类型 4. text,文本型 5. text_st,结构性文本,比如ID, 6. group_number,连续 parameter --------- data: pd.Series 数据, 仅支持一维 # 如果有data,则函数会改变原来data的数据类型 category_detection: bool,根据 nunique 检测是否是因子类型 StructureText_detection: bool, 结构化文本,如列中都有一个分隔符"-" datetime_to_category: 时间序列如果 nunique过少是否转化成因子变量 criterion: string or int, optional (default="sqrt",即样本数的开根号) 支持:'sqrt':样本量的开根号, int: 绝对数, 0-1的float:样本数的百分多少 检测因子变量时,如果一个特征的nunique小于criterion,则判定为因子变量 min_mean_counts: default 5,数值型判定为因子变量时,需要满足每个类别的平均频数要大于min_mean_counts fix: bool,是否返回修改好类型的数据 return: result:dict{ 'name':列名, 'vtype':变量类型, 'ordered':是否是有序因子, 'categories':所有的因子} ''' assert len(data.shape)==1 data=data.copy() data=pd.Series(data) dtype,name,n_sample=data.dtype,data.name,data.count() min_mean_counts=5 if criterion=='sqrt': max_nuniques=np.sqrt(n_sample) elif isinstance(criterion,int): max_nuniques=criterion elif isinstance(criterion,float) and (0<criterion<1): max_nuniques=criterion else: max_nuniques=np.sqrt(n_sample) ordered=False categories=[] if is_numeric_dtype(dtype): vtype='number' ordered=False categories=[] # 纠正误分的数据类型。如将1.0,2.0,3.0都修正为1,2,3 if data.dropna().astype(np.int64).sum()==data.dropna().sum(): data[data.notnull()]=data[data.notnull()].astype(np.int64) if category_detection: nunique=len(data.dropna().unique()) mean_counts=data.value_counts().median() if nunique<max_nuniques and mean_counts>=min_mean_counts: data=data.astype('category') ordered=data.cat.ordered vtype='category' categories=list(data.dropna().cat.categories) result={'name':name,'vtype':vtype,'ordered':ordered,'categories':categories} elif is_string_dtype(dtype): # 处理时间类型 tmp=data.map(lambda x: np.nan if '%s'%x == 'nan' else len('%s'%x)) tmp=tmp.dropna().astype(np.int64) if not(any(data.dropna().map(is_number))) and 7<tmp.max()<20 and tmp.std()<0.1: try: data=pd.to_datetime(data) except : pass # 处理可能的因子类型 #时间格式是否处理为True 且 if datetime_to_category: if len(data.dropna().unique())<np.sqrt(n_sample): data=data.astype('category') else: nunique=len(data.dropna().unique()) #print(data.dtype) if not(is_categorical_dtype(data.dtype)) and not(np.issubdtype(data.dtype,np.datetime64)) and nunique<max_nuniques: data=data.astype('category') # 在非因子类型的前提下,将百分数转化成浮点数,例如21.12%-->0.2112 if is_string_dtype(data.dtype) and not(is_categorical_dtype(data.dtype)) and all(data.str.contains('%')): data=data.str.strip('%').astype(np.float64)/100 if
is_categorical_dtype(data.dtype)
pandas.api.types.is_categorical_dtype
import pandas as pa import json import datetime as dt dfc = pa.read_json('./data/clients.json') dft = pa.read_json('./data/tarifs.json') dfv =
pa.read_json('./data/vehicules.json')
pandas.read_json
import numpy as np import pandas as pd from sklearn.impute import SimpleImputer from src.shared.config import loadConfig def imputeByMean(data, nonNumeric): # for median imputation replace 'mean' with 'median' imputedMean = SimpleImputer(strategy='mean') dataNumeric = data.drop(nonNumeric, axis=1) imputedMean.fit(dataNumeric) imputedData = imputedMean.transform(dataNumeric) d1 =
pd.DataFrame(imputedData)
pandas.DataFrame
# Perform tolerance sweep tolerance by ESM-SSP and well-characterized errors # for an audience seeking to emulate from the full CMIP6 archive and for the # scenarioMIP approach, for all ESMs # For each ESM, loop over various tolerances and generate Ndraws = 500 # GSAT trajectories. Archives with and without each target to characterize # error. (Reproducible mode off so draws are different). And the ScenMIP. # Compare to the target ensemble via 4 metrics (E1, E2 on both Tgavs and # jumps) and record errors for each draw and tolerance. ## TODO: comment out saving the GSATs ## TODO functionalize at least some part of the analysis or at least use a for-loop ## over the different SSP targets so that the code isn't so long and repetitive # making a table of avail runs X planned archives and for looping over that would # trim things down (see approach for max tol runs). And rewrite the tolerance # iteration to be a while loop, comparing current to prev instead of calculating # and saving it all? Update writes and reads to be subdir so things are tidier # would be better to functionalize this script with ESM, tol and Ndraws as arguments # and then have the .sh just call the function and dispatch to diff nodes for each run I guess. # ############################################################################# # General setup # ############################################################################# # Import packages import pandas as pd import numpy as np import stitches as stitches import pkg_resources import os from pathlib import Path
pd.set_option('display.max_columns', None)
pandas.set_option
import os import sys import inspect from copy import deepcopy import numpy as np import pandas as pd from ucimlr.helpers import (download_file, download_unzip, one_hot_encode_df_, xy_split, normalize_df_, split_normalize_sequence, split_df, get_split, split_df_on_column) from ucimlr.dataset import Dataset from ucimlr.constants import TRAIN from ucimlr.constants import REGRESSION def all_datasets(): """ Returns a list of all RegressionDataset classes. """ return [cls for _, cls in inspect.getmembers(sys.modules[__name__]) if inspect.isclass(cls) and issubclass(cls, RegressionDataset) and cls != RegressionDataset] class RegressionDataset(Dataset): type_ = REGRESSION # Is this necessary? @property def num_targets(self): return self.y.shape[1] class Abalone(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Abalone). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'data.csv' file_path = os.path.join(dataset_path, filename) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/abalone/abalone.data' download_file(url, dataset_path, filename) df = pd.read_csv(file_path, header=None) y_columns = df.columns[-1:] one_hot_encode_df_(df) df_test, df_train, df_valid = split_df(df, [0.2, 0.8 - 0.8 * validation_size, 0.8 * validation_size]) normalize_df_(df_train, other_dfs=[df_valid, df_test]) df_res = get_split(df_train, df_valid, df_test, split) self.x, self.y = xy_split(df_res, y_columns) class AirFoil(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Airfoil+Self-Noise). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'airfoil_self_noise.dat' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00291/airfoil_self_noise.dat' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path, sep='\t', names =["Frequency(Hz)", "Angle of attacks(Deg)", "Chord length(m)", "Free-stream velocity(m/s)", "Suction side displacement thickness(m)", " Scaled sound pressure level(Db)"]) y_columns = ['Scaled sound pressure level(Db)'] self.x, self.y = split_normalize_sequence(df, y_columns, validation_size, split, self.type_) class AirQuality(RegressionDataset): """ # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'AirQualityUCI.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00360/AirQualityUCI.zip' download_unzip(url, dataset_path) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path, sep=';', parse_dates=[0, 1]) df.dropna(axis=0, how='all', inplace=True) df.dropna(axis=1, how='all', inplace=True) df.Date = (df.Date - df.Date.min()).astype('timedelta64[D]') # Days as int df.Time = df.Time.apply(lambda x: int(x.split('.')[0])) # Hours as int df['C6H6(GT)'] = df['C6H6(GT)'].apply(lambda x: float(x.replace(',', '.'))) # Target as float # Some floats are given with ',' instead of '.' df = df.applymap(lambda x: float(x.replace(',', '.')) if type(x) is str else x) # Target as float df = df[df['C6H6(GT)'] != -200] # Drop all rows with missing target values df.loc[df['CO(GT)'] == -200, 'CO(GT)'] = -10 # -200 means missing value, shifting this to be closer to # the other values for this column y_columns = ['C6H6(GT)'] self.x, self.y = split_normalize_sequence(df, y_columns, validation_size, split, self.type_) class Appliances_energy_prediction(RegressionDataset): """ Link to the dataset [description](https://archive.ics.uci.edu/ml/datasets/Appliances+energy+prediction). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'energydata_complete.csv' url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/00374/energydata_complete.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path, parse_dates=[0, 1]) df.date = (df.date - df.date.min()).astype('timedelta64[D]') y_columns = ['Appliances'] self.x, self.y = split_normalize_sequence(df, y_columns, validation_size, split, self.type_) self.problem_type = REGRESSION class AutoMPG(RegressionDataset): """ Link to the dataset [description](https://archive.ics.uci.edu/ml/datasets/Automobile). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'auto-mpg.data' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path, sep='\s+', names =["mpg", "cylinders", "displacements", "horsepower", "weight", "acceleration", "model year", "origin", "car name"]) y_columns = ['mpg'] self.x, self.y = split_normalize_sequence(df, y_columns, validation_size, split, self.type_) sel.problem_type=REGRESSION class Automobile(RegressionDataset): """ Link to the dataset [description](https://archive.ics.uci.edu/ml/datasets/Automobile). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'imports-85.data' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/autos/imports-85.data' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path, names = ["symboling", "normalized-losses", "make", "fuel-type", " aspiration", "num-of-doors", "body-style", "drive-wheels", "engine-location", "wheel-base", " length", "width", " height", "curb-weight", "engine-type", "num-of-cylinders", "engine-size", " fuel-system", " bore", "stroke", " compression-ratio", "horsepower", "peak-rpm", "city-mpg", "highway-mpg", "price"]) y_columns = [''] self.x, self.y = split_normalize_sequence(df, y_columns, validation_size, split, self.type_) class BeijingAirQuality(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Beijing+Multi-Site+Air-Quality+Data). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00501/PRSA2017_Data_20130301-20170228.zip' download_unzip(url, dataset_path) df = [] for fn in os.listdir(dataset_path): if 'PRSA_Data' not in fn: continue file_path = os.path.join(dataset_path, fn) df.append(pd.read_csv(file_path)) class BeijingPM(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Beijing+PM2.5+Data). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'PRSA_data_2010.1.1-2014.12.31.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00381/PRSA_data_2010.1.1-2014.12.31.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path) y_columns=['pm2.5'] self.x, self.y = split_normalize_sequence(df, y_columns, validation_size, split, self.type) self.problem_type = REGRESSION class BiasCorrection(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Bias+correction+of+numerical+prediction+model+temperature+forecast). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'Bias_correction_ucl.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00514/Bias_correction_ucl.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path, index_col = 'Date', parse_dates= True) class BikeSharing(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Bike+Sharing+Dataset). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00275/Bike-Sharing-Dataset.zip' download_unzip(url, dataset_path) df = [] for fn in os.listdir(dataset_path): file_path = os.path.join(dataset_path, fn) df.append(pd.read_csv(file_path)) class CarbonNanotubes(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Carbon+Nanotubes). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'carbon_nanotubes.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00448/carbon_nanotubes.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path,sep=';') class ChallengerShuttleORing(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Challenger+USA+Space+Shuttle+O-Ring). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'o-ring-erosion-only.data' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/space-shuttle/o-ring-erosion-only.data' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path,sep='\s+') class BlogFeedback(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/BlogFeedback). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): file_name = 'blogData_train.csv' dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00304/BlogFeedback.zip' download_unzip(url, dataset_path) # Iterate all test csv and concatenate to one DataFrame test_dfs = [] for fn in os.listdir(dataset_path): if 'blogData_test' not in fn: continue file_path = os.path.join(dataset_path, fn) test_dfs.append(pd.read_csv(file_path, header=None)) df_test = pd.concat(test_dfs) file_path = os.path.join(dataset_path, file_name) df_train_valid = pd.read_csv(file_path, header=None) y_columns = [280] df_train_valid[y_columns[0]] = np.log(df_train_valid[y_columns[0]] + 0.01) df_test[y_columns[0]] = np.log(df_test[y_columns[0]] + 0.01) page_columns = list(range(50)) for i, (_, df_group) in enumerate(df_train_valid.groupby(page_columns)): df_train_valid.loc[df_group.index, 'page_id'] = i df_train, df_valid = split_df_on_column(df_train_valid, [1 - validation_size, validation_size], 'page_id') df_train.drop(columns='page_id', inplace=True) df_valid.drop(columns='page_id', inplace=True) normalize_df_(df_train, other_dfs=[df_valid, df_test]) df_res = get_split(df_train, df_valid, df_test, split) self.x, self.y = xy_split(df_res, y_columns) class CommunitiesCrime(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Communities+and+Crime). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'communities.data' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/communities/communities.data' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path,header=None) class ConcreteSlumpTest(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Concrete+Slump+Test). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'slump_test.data' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/concrete/slump/slump_test.data' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path,sep='\s+') class PropulsionPlants (RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Condition+Based+Maintenance+of+Naval+Propulsion+Plants). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00316/UCI CBM Dataset.zip' download_unzip(url, dataset_path) filename = 'data.txt' file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path, index_col='dteday', parse_dates=True) class ConcreteCompressiveStrength (RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Concrete+Compressive+Strength). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'Concrete_Data.xls' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/concrete/compressive/Concrete_Data.xls' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_excel(file_path) class ComputerHardware (RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Computer+Hardware). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'machine.data' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/cpu-performance/machine.data' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path, names=["vendor name", "Model Name", "MYCT", "MMIN", "MMAX", "CACH", "CHMIN", "CHMAX", "PRP", "ERP"]) class CommunitiesCrimeUnnormalized (RegressionDataset): """ Link to the dataset [description]http://archive.ics.uci.edu/ml/datasets/Communities+and+Crime+Unnormalized). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'CommViolPredUnnormalizedData.txt' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00211/CommViolPredUnnormalizedData.txt' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path, keep_default_na=False, header=None) class CTSlices(RegressionDataset): """ # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00206/slice_localization_data.zip' download_unzip(url, dataset_path) file_name = 'slice_localization_data.csv' file_path = os.path.join(dataset_path, file_name) df = pd.read_csv(file_path) # No patient should be in both train and test set df_train_valid = deepcopy(df.loc[df.patientId < 80, :]) # Pandas complains if it is a view df_test = deepcopy(df.loc[df.patientId >= 80, :]) # - " - df_train, df_valid = split_df_on_column(df_train_valid, [1 - validation_size, validation_size], 'patientId') y_columns = ['reference'] normalize_df_(df_train, other_dfs=[df_valid, df_test]) df_res = get_split(df_train, df_valid, df_test, split) df_res = df_res.drop(columns='patientId') self.x, self.y = xy_split(df_res, y_columns) class ForecastingOrders(RegressionDataset): """ Link to the dataset [description]http://archive.ics.uci.edu/ml/datasets/Daily+Demand+Forecasting+Orders). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'Daily_Demand_Forecasting_Orders.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00409/Daily_Demand_Forecasting_Orders.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path,sep=';') class ForecastingStoreData(RegressionDataset): """ Link to the dataset [description]http://archive.ics.uci.edu/ml/datasets/Demand+Forecasting+for+a+store). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'Daily_Demand_Forecasting_Orders.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00409/' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path,sep='\s+') class FacebookComments(RegressionDataset): """ Predict the number of likes on posts from a collection of Facebook pages. Every page has multiple posts, making the number of pages less than the samples in the dataset (each sample is one post). # Note The provided test split has a relatively large discrepancy in terms of distributions of the features and targets. Training and validation splits are also made to ensure that the same page is not in both splits. This makes the distributions of features in training and validation splits vary to a relatively large extent, possible because the number of pages are not that many, while the features are many. Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Facebook+Comment+Volume+Dataset). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00363/Dataset.zip' download_unzip(url, dataset_path) dataset_path = os.path.join(dataset_path, 'Dataset') # The 5th variant has the most data train_path = os.path.join(dataset_path, 'Training', 'Features_Variant_5.csv') test_path = os.path.join(dataset_path, 'Testing', 'Features_TestSet.csv') df_train_valid = pd.read_csv(train_path, header=None) df_test = pd.read_csv(test_path, header=None) y_columns = df_train_valid.columns[-1:] # Page ID is not included, but can be derived. Page IDs can not be # in both training and validation sets page_columns = list(range(29)) for i, (_, df_group) in enumerate(df_train_valid.groupby(page_columns)): df_train_valid.loc[df_group.index, 'page_id'] = i df_train, df_valid = split_df_on_column(df_train_valid, [1 - validation_size, validation_size], 'page_id') df_train.drop(columns='page_id', inplace=True) df_valid.drop(columns='page_id', inplace=True) normalize_df_(df_train, other_dfs=[df_valid, df_test]) df_res = get_split(df_train, df_valid, df_test, split) self.x, self.y = xy_split(df_res, y_columns) class Facebookmetrics (RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Condition+Based+Maintenance+of+Naval+Propulsion+Plants). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00368/Facebook_metrics.zip' download_unzip(url, dataset_path) filename = 'dataset_Facebook.csv' file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path, sep=';') class ForestFires(RegressionDataset): """ Link to the dataset [description]http://archive.ics.uci.edu/ml/datasets/Forest+Fires). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'forestfires.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/forest-fires/forestfires.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path) class GNFUV(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/GNFUV+Unmanned+Surface+Vehicles+Sensor+Data). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00452/GNFUV USV Dataset.zip' download_unzip(url, dataset_path) dfs = [] for fn in os.listdir(dataset_path): file_path = os.path.join(dataset_path, fn) dfs.append(pd.read_csv(file_path, header=None)) class GNFUV_2(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/GNFUV+Unmanned+Surface+Vehicles+Sensor+Data+Set+2). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00466/CNFUV_Datasets.zip' download_unzip(url, dataset_path) df = [] for fn in os.listdir(dataset_path): file_path = os.path.join(dataset_path, fn) df.append(pd.read_csv(file_path, header=None)) class Greenhouse_Gas_Observing_Network (RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Greenhouse+Gas+Observing+Network). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00328/ghg_data.zip' download_unzip(url, dataset_path) df = [] for fn in os.listdir(dataset_path): file_path = os.path.join(dataset_path, fn) df.append(pd.read_csv(file_path, header=None, sep='\s+')) class Hungarian_Chickenpox_Cases (RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Hungarian+Chickenpox+Cases). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00580/hungary_chickenpox.zip' download_unzip(url, dataset_path) df = [] for fn in os.listdir(dataset_path): file_path = os.path.join(dataset_path, fn) df.append(pd.read_csv(file_path, index_col='Date', parse_dates=True)) class IIWA14_R820_Gazebo_Dataset_10Trajectories(RegressionDataset): """ Link to the dataset [description]http://archive.ics.uci.edu/ml/datasets/IIWA14-R820-Gazebo-Dataset-10Trajectories). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'IIWA14-R820-Gazebo-Dataset-10Trayectorias.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00574/IIWA14-R820-Gazebo-Dataset-10Trayectorias.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path, header=None) class Metro_Interstate_Traffic_Volume(RegressionDataset): """ Link to the dataset [description]http://archive.ics.uci.edu/ml/datasets/Metro+Interstate+Traffic+Volume). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'Metro_Interstate_Traffic_Volume.csv.gz' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00492/Metro_Interstate_Traffic_Volume.csv.gz' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path) class News_Popularity_Facebook_Economy(RegressionDataset): """ Link to the dataset [descriptionhttp://archive.ics.uci.edu/ml/datasets/News+Popularity+in+Multiple+Social+Media+Platforms). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'Facebook_Economy.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00432/Data/Facebook_Economy.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path) class News_Popularity_Facebook_Microsoft(RegressionDataset): """ Link to the dataset [descriptionhttp://archive.ics.uci.edu/ml/datasets/News+Popularity+in+Multiple+Social+Media+Platforms). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'Facebook_Microsoft.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00432/Data/Facebook_Microsoft.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path) class News_Popularity_Facebook_Palestine(RegressionDataset): """ Link to the dataset [descriptionhttp://archive.ics.uci.edu/ml/datasets/News+Popularity+in+Multiple+Social+Media+Platforms). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'Facebook_Palestine.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00432/Data/Facebook_Palestine.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path) class News_Popularity_GooglePlus_Economy(RegressionDataset): """ Link to the dataset [descriptionhttp://archive.ics.uci.edu/ml/datasets/News+Popularity+in+Multiple+Social+Media+Platforms). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'GooglePlus_Economy.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00432/Data/GooglePlus_Economy.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path) class News_Popularity_GooglePlus_Microsoft(RegressionDataset): """ Link to the dataset [descriptionhttp://archive.ics.uci.edu/ml/datasets/News+Popularity+in+Multiple+Social+Media+Platforms). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'GooglePlus_Microsoft.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00432/Data/GooglePlus_Microsoft.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path) class News_Popularity_GooglePlus_Palestine(RegressionDataset): """ Link to the dataset [descriptionhttp://archive.ics.uci.edu/ml/datasets/News+Popularity+in+Multiple+Social+Media+Platforms). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'GooglePlus_Palestine.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00432/Data/GooglePlus_Palestine.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path) class News_Popularity_GooglePlus_Obama(RegressionDataset): """ Link to the dataset [descriptionhttp://archive.ics.uci.edu/ml/datasets/News+Popularity+in+Multiple+Social+Media+Platforms). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'GooglePlus_Obama.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00432/Data/GooglePlus_Obama.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path) class News_Popularity_LinkedIn_Economy(RegressionDataset): """ Link to the dataset [descriptionhttp://archive.ics.uci.edu/ml/datasets/News+Popularity+in+Multiple+Social+Media+Platforms). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'LinkedIn_Economy.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00432/Data/LinkedIn_Economy.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path) class News_Popularity_LinkedIn_Microsoft(RegressionDataset): """ Link to the dataset [descriptionhttp://archive.ics.uci.edu/ml/datasets/News+Popularity+in+Multiple+Social+Media+Platforms). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'LinkedIn_Microsoft.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00432/Data/LinkedIn_Microsoft.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path) class News_Popularity_LinkedIn_Obama(RegressionDataset): """ Link to the dataset [descriptionhttp://archive.ics.uci.edu/ml/datasets/News+Popularity+in+Multiple+Social+Media+Platforms). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'LinkedIn_Obama.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00432/Data/LinkedIn_Obama.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path) class News_Popularity_LinkedIn_Palestine(RegressionDataset): """ Link to the dataset [descriptionhttp://archive.ics.uci.edu/ml/datasets/News+Popularity+in+Multiple+Social+Media+Platforms). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'LinkedIn_Palestine.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00432/Data/LinkedIn_Palestine.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path) class News_Popularity_News_Final(RegressionDataset): """ Link to the dataset [descriptionhttp://archive.ics.uci.edu/ml/datasets/News+Popularity+in+Multiple+Social+Media+Platforms). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'News_Final.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00432/Data/News_Final.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path) class Online_Video_Characteristics_and_Transcoding_Time(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Online+Video+Characteristics+and+Transcoding+Time+Dataset). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00335/online_video_dataset.zip' download_unzip(url, dataset_path) df = [] for fn in os.listdir(dataset_path): if fn == 'README.txt': continue file_path = os.path.join(dataset_path, fn) df.append(pd.read_csv(file_path, sep='\t')) class OnlineNews(RegressionDataset): """ # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00332/OnlineNewsPopularity.zip' download_unzip(url, dataset_path) file_path = os.path.join(dataset_path, 'OnlineNewsPopularity', 'OnlineNewsPopularity.csv') df = pd.read_csv(file_path, ) df.drop(columns=['url', ' timedelta'], inplace=True) y_columns = [' shares'] df[y_columns[0]] = np.log(df[y_columns[0]]) self.x, self. y = split_normalize_sequence(df, y_columns, validation_size, split, self.type_) class Parkinson(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/parkinsons). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'data.csv' file_path: str = os.path.join(dataset_path, filename) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/' \ 'parkinsons/telemonitoring/parkinsons_updrs.data' download_file(url, dataset_path, filename) df = pd.read_csv(file_path) y_columns = ['motor_UPDRS', 'total_UPDRS'] df_train_valid = df[df['subject#'] <= 30] df_test = deepcopy(df[df['subject#'] > 30]) df_train, df_valid = split_df_on_column(df_train_valid, [1 - validation_size, validation_size], 'subject#') normalize_df_(df_train, other_dfs=[df_valid, df_test]) df_res = get_split(df_train, df_valid, df_test, split) df_res.drop(columns='subject#', inplace=True) self.x, self.y = xy_split(df_res, y_columns) class Physicochemical_Properties_of_Protein_Tertiary_Structure(RegressionDataset): """ Link to the dataset [description]http://archive.ics.uci.edu/ml/datasets/Physicochemical+Properties+of+Protein+Tertiary+Structure). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'CASP.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00265/CASP.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path) class PPG_DaLiA_Data_Set(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/PPG-DaLiA). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00495/data.zip' download_unzip(url, dataset_path) df = [] for fn in os.listdir(dataset_path): file_path = os.path.join(dataset_path, fn) df.append(pd.read_csv(file_path, sep='\t')) class QSAR_aquatic_toxicity(RegressionDataset): """ Link to the dataset [description]http://archive.ics.uci.edu/ml/datasets/QSAR+aquatic+toxicity). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'qsar_aquatic_toxicity.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00505/qsar_aquatic_toxicity.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path, sep=';', names=["TPSA(Tot)", "SAacc", "H-050", "MLOGP", "RDCHI", " GATS1p", "nN", "C-040", "quantitative response, LC50 [-LOG(mol/L)]"]) class QSAR_fish_bioconcentration_factor(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/QSAR+fish+bioconcentration+factor+%28BCF%29). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00511/QSAR_fish_BCF.zip' download_unzip(url, dataset_path) df = [] for fn in os.listdir(dataset_path): if fn =='ECFP_1024_m0-2_b2_c.txt': continue file_path = os.path.join(dataset_path, fn) df.append(pd.read_csv(file_path, sep='\t')) class QSAR(RegressionDataset): """ Link to the dataset [description]http://archive.ics.uci.edu/ml/datasets/QSAR+fish+toxicity). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'qsar_fish_toxicity.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00504/qsar_fish_toxicity.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path, sep=';', names=[" CIC0", "SM1_Dz(Z)", " GATS1i", "NdsCH", " NdssC", "MLOGP", "quantitative response, LC50 [-LOG(mol/L)]"]) class PowerPlant(RegressionDataset): """ # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00294/CCPP.zip' download_unzip(url, dataset_path) file_path = os.path.join(dataset_path, 'CCPP', 'Folds5x2_pp.xlsx') df = pd.read_excel(file_path) y_columns = ['PE'] # Not clear if this is the aim of the dataset self.x, self.y = split_normalize_sequence(df, y_columns, validation_size, split, self.type_) class ResidentialBuilding(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Real+estate+valuation+data+set). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'Residential-Building-Data-Set.xlsx' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00437/Residential-Building-Data-Set.xlsx' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_excel(file_path) y_columns = ['Y house price of unit area'] self.x, self.y = split_normalize_sequence(df, y_columns, validation_size, split, self.type_) class RealEstate(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Real+estate+valuation+data+set). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'Real estate valuation data set.xlsx' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00477/Real%20estate%20valuation%20data%20set.xlsx' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_excel(file_path, index_col='No') class Real_time_Election_Results (RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/QSAR+fish+bioconcentration+factor+%28BCF%29). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00513/ElectionData2019.zip' download_unzip(url, dataset_path) df = [] for fn in os.listdir(dataset_path): if '.csv' not in fn: continue file_path = os.path.join(dataset_path, fn) df.append(pd.read_csv(file_path)) class Seoul_Bike_Sharing_Demand(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Seoul+Bike+Sharing+Demand). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'SeoulBikeData.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00560/SeoulBikeData.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path) class Servo(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Servo). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'servo.data' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/servo/servo.data' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path, names=["motor", "screw", " pgain", "vgain", "class"]) class SGEMM_GPU_kernel_performance (RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/SGEMM+GPU+kernel+performance). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00440/sgemm_product_dataset.zip' download_unzip(url, dataset_path) df = [] for fn in os.listdir(dataset_path): if fn == 'Readme.txt': continue file_path = os.path.join(dataset_path, fn) df.append(pd.read_csv(file_path)) class Simulated_data_for_survival_modelling (RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Simulated+data+for+survival+modelling). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00581/MLtoSurvival-Data.zip' download_unzip(url, dataset_path) df = [] for fn in os.listdir(dataset_path): if fn == '.gitkeep': continue file_path = os.path.join(dataset_path, fn) df.append(pd.read_csv(file_path)) class SkillCraft1(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/SkillCraft1+Master+Table+Dataset). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'SkillCraft1_Dataset.csv' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00272/SkillCraft1_Dataset.csv' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df = pd.read_csv(file_path) class SML2010 (RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/SML2010). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00274/NEW-DATA.zip' download_unzip(url, dataset_path) df = [] for fn in os.listdir(dataset_path): if fn == '.gitkeep': continue file_path = os.path.join(dataset_path, fn) df.append(pd.read_csv(file_path, sep='\s+')) class Solar_Flare(RegressionDataset): """ Link to the dataset [description](http://archive.ics.uci.edu/ml/datasets/Solar+Flare). # Parameters root (str): Local path for storing/reading dataset files. split (str): One of {'train', 'validation', 'test'} validation_size (float): How large fraction in (0, 1) of the training partition to use for validation. """ def __init__(self, root, split=TRAIN, validation_size=0.2): dataset_path = os.path.join(root, self.name) filename = 'flare.data1' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/solar-flare/flare.data1' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df1 = pd.read_csv(file_path, header=None, skiprows=[0], sep='\s+') filename = 'flare.data2' url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/solar-flare/flare.data2' download_file(url, dataset_path, filename) file_path = os.path.join(dataset_path, filename) df2 = pd.read_csv(file_path, header=None, skiprows=[0], sep='\s+') df =
pd.merge(df1, df2)
pandas.merge
#!/usr/bin/python3.7 #Dependencies import numpy as np import pandas as pd from scipy.interpolate import interp1d from scipy.optimize import minimize_scalar import scipy.special as sp import matplotlib.pyplot as plt from scipy.stats import linregress from scipy.stats import t from scipy import integrate import derivative #----------------------------------------------------------------------------------------------------------- class DataExtraction(object): """ Class that manipulates raw data to create lists and Data Frames that will be used to compute the Activation Energy. """ def __init__(self): """ Constructor. Parameters: None Notes: It only defines variables. """ self.DFlis = [] #list of DataFrames containing data self.Beta = [] #list of heating rates self.BetaCC = [] #list of correlation coefficient for T vs t self.files = [] #list of files containing raw data self.da_dt = [] #list of experimental conversion rates self.T = [] #list of experimental temperature self.t = [] #list off experimental time self.TempIsoDF = pd.DataFrame() #Isoconversional temperature DataFrame self.timeIsoDF = pd.DataFrame() #Isoconversional time DataFrame self.diffIsoDF = pd.DataFrame() #Isoconversional conversion rate DataFrame self.TempAdvIsoDF = pd.DataFrame() #Advanced isoconversional temperature DataFrame self.timeAdvIsoDF = pd.DataFrame() #Advanced isoconversional time DataFrame self.alpha = [] #list of experimental conversion self.d_a = 0.00001 #default value of alpha step for aVy method #----------------------------------------------------------------------------------------------------------- def set_data(self, filelist): """ Method to establish the file list for the extrator. Parameters: filelist : list object containing the paths of the files to be used. Notes: The paths must be sorted in ascendent heating rate order. """ print("Files to be used: \n{} ".format(filelist)) self.files = filelist #----------------------------------------------------------------------------------------------------------- def data_extraction(self,encoding='utf8'): """ Method to extract the data contained in the files into a list of DataFrames. Adds three columns: one corresponding to the absolute temperature, another corresponding to the conversion ('alpha') and a third for d(alpha)/dt. Also computes The heating rate ('Beta') with its Correlation Coefficient. Parameters: encoding: The available encodings for pandas.read_csv() method. Includes but not limited to 'utf8', 'utf16','latin1'. For more information on the python standar encoding: (https://docs.python.org/3/library/codecs.html#standard-encodings) """ BetaCorrCoeff = self.BetaCC DFlis = self.DFlis Beta = self.Beta filelist = self.files alpha = self.alpha da_dt = self.da_dt T = self.T t = self.t # Read the data from each csv # Create the Dataframe of each experiment # Add three columns (T,alpha,(da/dt)) # Compute the linear regression of T vs t for item in filelist: try: DF = pd.read_table(item, sep = '\t', encoding = encoding) DF['Temperature [K]'] = DF[DF.columns[1]] + 273.15 DF[r'$\alpha$'] = (DF[DF.columns[2]][0]-DF[DF.columns[2]])/(DF[DF.columns[2]][0]-DF[DF.columns[2]][DF.shape[0]-1]) dadt = derivative.dxdt(DF[r'$\alpha$'],DF[DF.columns[0]],kind='spline',s=0.01,order=5) DF[r'$d\alpha/dt$'] = DF[DF.columns[0]] DF[r'$d\alpha/dt$'] = dadt except IndexError: DF = pd.read_table(item, sep = ',', encoding = encoding) DF['Temperature [K]'] = DF[DF.columns[1]] + 273.15 DF[r'$\alpha$'] = (DF[DF.columns[2]][0]-DF[DF.columns[2]])/(DF[DF.columns[2]][0]-DF[DF.columns[2]][DF.shape[0]-1]) dadt = derivative.dxdt(DF[r'$\alpha$'],DF[DF.columns[0]],kind='spline',s=0.01,order=5) DF[r'$d\alpha/dt$'] = DF[DF.columns[0]] DF[r'$d\alpha/dt$'] = dadt LR = linregress(DF[DF.columns[0]],DF[DF.columns[3]]) BetaCorrCoeff.append(LR.rvalue) Beta.append(LR.slope) DFlis.append(DF) # Create an array of sorted in ascendent order values of conversion (alpha) and arrays # for the temperature, time and rate of conversion corresponding to said conversion values for i in range(len(DFlis)): a = [DFlis[i][r'$\alpha$'].values[0]] Temp = [DFlis[i]['Temperature [K]'].values[0]] time = [DFlis[i][DFlis[i].columns[0]].values[0]] diff = [DFlis[i][r'$d\alpha/dt$'].values[1]] for j in range(len(DFlis[i][r'$\alpha$'].values)): if DFlis[i][r'$\alpha$'].values[j] == a[-1]: pass elif DFlis[i][r'$\alpha$'].values[j] > a[-1]: a.append(DFlis[i][r'$\alpha$'].values[j]) Temp.append(DFlis[i]['Temperature [K]'].values[j]) time.append(DFlis[i][DFlis[i].columns[0]].values[j]) diff.append(DFlis[i][r'$d\alpha/dt$'].values[j]) else: pass alpha.append(np.array(a)) T.append(np.array(Temp)) t.append(np.array(time)) da_dt.append(np.array(diff)) self.BetaCC = BetaCorrCoeff self.DFlis = DFlis self.Beta = Beta self.da_dt = da_dt self.T = T self.t = t self.alpha = alpha #----------------------------------------------------------------------------------------------------------- def get_beta(self): """ Parameters: None Returns: list object containing the experimental heating rate sorted in ascendent order obtained from a linear regression of T vs t. """ return self.Beta #----------------------------------------------------------------------------------------------------------- def get_betaCC(self): """ Parameters: None Returns: list object containing the experimental T vs t correlation coefficient obtained from a linear regression, sorted in correspondance with the heating rate list (attribute Beta). """ return self.BetaCC #----------------------------------------------------------------------------------------------------------- def get_DFlis(self): """ Parameters: None Returns: list object containing the DataFrames with the experimental data, sorted in correspondance with the heating rate list (attribute Beta). """ return self.DFlis #----------------------------------------------------------------------------------------------------------- def isoconversional(self): """ Isoconversional DataFrames building method for the Friedman, KAS, OFW and Vyazovkin methods. The isoconversional values for T, t and da/dt are obtained by interpolation. Parameters: None Returns: None Notes: This method asigns values to the attributes: TempIsoDF, timeIsoDF and diffIsoDF """ alpha = self.alpha da_dt = self.da_dt T = self.T t = self.t DFlis = self.DFlis TempIsoDF = pd.DataFrame() timeIsoDF = pd.DataFrame() diffIsoDF = pd.DataFrame() Beta = self.Beta # Take the experimental data set with the less data points (alps), so the interpolation is made with the # data sets with more experimental information. # Create the interpolation functions and evaluate them over the conversion values of the latter set (alps). # Create the isoconversional DataFrames with the conversion values (alps) as index and the # interpolation values as columns corresponding to their experimental heating rates. alps = np.array(alpha[-1]) TempIsoDF['HR '+str(np.round(Beta[-1], decimals = 1)) + ' K/min'] = np.round(T[-1], decimals = 4) timeIsoDF['HR '+str(np.round(Beta[-1], decimals = 1)) + ' K/min'] = np.round(t[-1], decimals = 4) diffIsoDF['HR '+str(np.round(Beta[-1], decimals = 1)) + ' K/min'] = np.round(da_dt[-1], decimals = 4) for i in range(len(Beta)-1): inter_func = interp1d(alpha[i], t[i], kind='cubic', bounds_error=False, fill_value="extrapolate") timeIsoDF['HR '+str(np.round(Beta[i], decimals = 1)) + ' K/min'] = np.round(inter_func(alps), decimals = 4) inter_func2 = interp1d(alpha[i], T[i], kind='cubic', bounds_error=False, fill_value="extrapolate") TempIsoDF['HR '+str(np.round(Beta[i], decimals = 1)) + ' K/min'] = np.round(inter_func2(alps), decimals = 4) inter_func3 = interp1d(alpha[i], da_dt[i], kind='cubic', bounds_error=False, fill_value="extrapolate") diffIsoDF['HR '+str(np.round(Beta[i], decimals = 1)) + ' K/min'] = np.round(inter_func3(alps), decimals = 4) colnames = TempIsoDF.columns.tolist() colnames = colnames[1:] + colnames[:1] TempIsoDF.index = alpha[-1] TempIsoDF = TempIsoDF[colnames] timeIsoDF.index = alpha[-1] timeIsoDF = timeIsoDF[colnames] diffIsoDF.index = alpha[-1] diffIsoDF = diffIsoDF[colnames] self.TempIsoDF = TempIsoDF self.timeIsoDF = timeIsoDF self.diffIsoDF = diffIsoDF #----------------------------------------------------------------------------------------------------------- def get_TempIsoDF(self): """ Parameters: None Returns: DataFrame of isoconversional temperatures. The index is the set of conversion values from the experiment with the less data points (which correspond to the smallest heating rate). The columns are isoconversional temperatures, sorted in heating rate ascendent order from left to right. """ return self.TempIsoDF #----------------------------------------------------------------------------------------------------------- def get_timeIsoDF(self): """ Parameters: None Returns: DataFrame of isoconversional times. The index is the set of conversion values from the experiment with the less data points (which correspond to the smallest heating rate). The columns are isoconversional times, sorted in heating rate ascendent order from left to right. """ return self.timeIsoDF #----------------------------------------------------------------------------------------------------------- def get_diffIsoDF(self): """ Parameters: None Returns: DataFrame of isoconversional conversion rates. The index is the set of conversion values from the experiment with the less data points (which correspond to the smallest heating rate). The columns are isoconversional conversion rates, sorted in heating rate ascendent order from left to right. """ return self.timeIsoDF #----------------------------------------------------------------------------------------------------------- def adv_isoconversional(self, method='points', N = 1000, d_a = 0.001): """ Isoconversional DataFrames building method for the advanced Vyazovkin method. The isoconversional values for T and t are obtained by interpolation. Parameters: method : String. Value can be either 'points' or 'interval'. ṕoints'is the default value. N : Int. Number of conversion points if the 'points' method is given. 1000 is the default value. d_a : Float. Size of the interval between conversion values if the method 'interval' is given. 0.001 is the default value. Returns: None Notes: This method asigns values to the attributes: TempAdvIsoDF, timeAdvIsoDF and d_a """ TempAdvIsoDF = pd.DataFrame() timeAdvIsoDF =
pd.DataFrame()
pandas.DataFrame
from django.shortcuts import render, redirect, get_object_or_404 from django.http import HttpResponse, JsonResponse from django.contrib.auth.models import User, auth from django.contrib.auth import get_user_model from django.db.models import Sum, Q, F from django.contrib import messages from django.views.generic import FormView from rest_framework.views import APIView from rest_framework.response import Response from sqlalchemy import create_engine from .mixins import AjaxFormMixin from .forms import Item_Form, Day_Form, New_Item_Form from .models import Item, New_item from . import connectpsql from .filters import ItemFilters import pandas as pd import numpy as np import datetime import matplotlib.pyplot as plt from numpy import exp, array, random, dot from sklearn.preprocessing import MinMaxScaler, scale from sklearn.model_selection import train_test_split from sklearn.linear_model import LinearRegression, LogisticRegression from sklearn.metrics import mean_squared_error from keras.models import Sequential from keras.layers import Dense, LSTM from keras import models from statsmodels.tsa.arima_model import ARIMA, ARMA from statsmodels.tsa.vector_ar.var_model import VAR from statsmodels.graphics.tsaplots import plot_pacf from pmdarima.arima.utils import ndiffs from TFANN import ANNR from pandas.plotting import autocorrelation_plot from flask import Flask, render_template from django.views.decorators.csrf import csrf_exempt, csrf_protect # point to CustomUser table User = get_user_model() # fill up the empty rows with zero def insertZero(costList): # daily total dfDay = costList.cost.resample('D').sum() today = datetime.datetime.today() #yyyy-mm-dd last_date = dfDay.iloc[[-1]].index # find the last date of dfDay # add zero until today while last_date < today - datetime.timedelta(days=1): last_date += datetime.timedelta(days=1) # add 1 day new_row = pd.Series(data={" ": 0}, index=last_date) # create a new row dfDay = dfDay.append(new_row, ignore_index=False) # insert into dfDay dfDay = dfDay.replace(to_replace=np.nan, value=0) return round(dfDay, 2) # predicting def processPrediction(dfDay, history, prediction_days): last_date = dfDay.iloc[[-1]].index + datetime.timedelta(days=1) ## orginal days list dfOrginal = pd.DataFrame(columns=["date", "cost"]) # dfOrginal = pd.DataFrame(columns=["cost"]) dfOrginal.date = dfDay.index dfOrginal.cost = dfDay.tolist() # dfOrginal.set_index("date", inplace=True) ## predict days list dfPredict = pd.DataFrame(columns=["date", "cost"]) dfPredict.date = pd.date_range(last_date[0], periods=prediction_days, freq="D") dfPredict.cost = history[-prediction_days:] # dfPredict.set_index("date", inplace=True) ## Combine two data lists # dfOrginal = dfOrginal.append(dfPredict) # plt.plot(dfOrginal.index, dfOrginal) # plt.show( ) return dfOrginal, dfPredict # inverse the difference in the dataset def inverse_diffference(history, predict, interval=1): # print(predict, " + ", history[-interval]) return predict + history[-interval] # find the difference in the dataset def difference(df, interval=1): diff_list = [] for i in range(interval, len(df)): value = df[i] - df[i - interval] # print("i = ", i, " i - interval = ", (i -interval)) # print(df[i], " - ", df[i - interval], " = ", value) diff_list.append(value) return array(diff_list) # convert to number def convertToNum(df): df = df.replace(to_replace="Income", value=0) df = df.replace(to_replace="Expense", value=1) df = df.replace(to_replace="Salaries and wages", value=10) df = df.replace(to_replace="Utility expenses", value=11) df = df.replace(to_replace="Administration expenses", value=12) df = df.replace(to_replace="Finance costs", value=13) df = df.replace(to_replace="Depreciation", value=14) df = df.replace(to_replace="Impairment losses", value=15) df = df.replace(to_replace="Food", value=16) df = df.replace(to_replace="Others", value=17) return df # processing data from psql def processingDataset(dataset, predict_type): pd.set_option('display.max_rows', None) # Create a DataFrame df = pd.DataFrame(columns=["date", "itemType", "costType", "cost"]) df.date = dataset.date.tolist() df.itemType = dataset.item_type.tolist() df.costType = dataset.cost_type.tolist() df.cost = dataset.cost.tolist() # Set date to be df.index df.set_index("date", inplace=True) df.index = pd.to_datetime(df.index) # Convert string to num df = convertToNum(df) # today = today.replace(hour=0, minute=0, second=0, microsecond=0) # dfDay.index[-1] #yyyy-mm-dd hh:mm:ss # Filter costType if predict_type == "income": incomeList = df[df.costType==0] # incomeList = incomeList.drop(columns="costType") dfDay = insertZero(incomeList) return dfDay elif predict_type == "expense": expensesList = df[df.costType==1] # expensesList = expensesList.drop(columns="costType") dfDay = insertZero(expensesList) return dfDay ## Sort by date, item type, and cost type # dfGroup = expensesList.groupby(["date", "itemType"]).sum() ## Weekly total # dfWeek = expensesList.cost.resample('W').sum() ## Monthly total # dfMonth = expensesList.cost.resample('M').sum() # dfWeekDay = pd.merge(dfWeek, dfDay, how="outer", on="date", sort=True, suffixes=("_week", "_day")) # dfMonth = pd.merge(dfMonth, dfWeekDay, how="outer", on="date", sort=True) # dfMonth = dfMonth.replace(to_replace=np.nan, value=-1) # prediction function def prediction(days, predict_type, username): # Connect to psql server engine = create_engine(connectpsql.psql) sql_command = "SELECT date, item_type, cost_type, cost FROM budget_new_item i INNER JOIN user_customuser u ON i.username_id = u.id WHERE u.username = '" + str(username) + "' ORDER BY i.date" # Read dataset from psql server dataset =
pd.read_sql(sql_command, engine, parse_dates=["date"])
pandas.read_sql
#!/usr/bin/env python import pandas as pd from collections import namedtuple from dataclasses import dataclass from dataclasses import asdict Author = namedtuple('Author', 'authorName journal date') authorList = [] authorList.append(Author('<NAME>','Journal of Witchcraft',2018)) authorList.append(Author('<NAME>','Duck Duck Goose Transactions',2019)) authorList.append(Author('<NAME>','Journal of Ambiguity',2017)) df =
pd.DataFrame.from_records(authorList,columns=Author._fields)
pandas.DataFrame.from_records
""" Microsoft Learning to Rank Dataset: https://www.microsoft.com/en-us/research/project/mslr/ """ import datetime import os import numpy as np import pandas as pd from sklearn import preprocessing def get_time(): return datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') class DataLoader: def __init__(self, path): """ :param path: str """ self.path = path self.pickle_path = path[:-3] + 'pkl' self.df = None self.num_pairs = None self.num_sessions = None def get_num_pairs(self): if self.num_pairs is not None: return self.num_pairs self.num_pairs = 0 for _, Y in self.generate_batch_per_query(self.df): Y = Y.reshape(-1, 1) pairs = Y - Y.T pos_pairs = np.sum(pairs > 0, (0, 1)) neg_pairs = np.sum(pairs < 0, (0, 1)) assert pos_pairs == neg_pairs self.num_pairs += pos_pairs + neg_pairs return self.num_pairs def get_num_sessions(self): return self.num_sessions def _load_mslr(self): print(get_time(), "load file from {}".format(self.path)) df =
pd.read_csv(self.path, sep=" ", header=None)
pandas.read_csv
#!/usr/bin/env python3 """ September 2020 <EMAIL> flagellin.py formerly: pipeline_flagellin_TLR5.py The D1 subunit of bacterial flagellin has the potential to act an an immune adjuvant via direct iteraction with Toll LIke Receptor 5. Structural studies suggest an Arginine at reference position R[89] in bascillus subtilis is conserved amoung TLR5-activiating flagelliln. Based on multiple sequence alignment, the molecular pattern used in this study t o identify TLR5 activating (hereafter TLR5+) flagelin is '([LVIM].R[MIALV]..[LI])'. This pipeline permits the interogation of raw metagenomic .fastq datafiles, quantifying detectable bacterial flagellins and scoring whether they match TLR5+ reference genes. The primary motif responsible for the D1-flagelline subunit-TLR5 interface is found within the Bacterial flagellin N-terminal helical region (https://pfam.xfam.org/family/PF00669). As of September 2020, EMBL-EBI PFAM database conatins (73m795) protein sequences from NCBI annotated as members of thsi protein family. These secquencs were downloaded /data/PF00669_ncbi.txt/. He et al 2020 also constructed a taxanomically annotated database of flagellin sequences from the Protein Family00669 as well Protein Family 00700 Bacterial flagellin C-terminal helical region). Version 1 of our flagellin database is the intersection of sequences in PF00669_ncbi.txt and the Flagellin DB. """ import numpy as np import os import pandas as pd import re from Bio import SeqIO def safe_re_search(s, pattern, group = 0): r = re.search(pattern =pattern , string =s) if r is not None: return r.groups()[group] else: return None def construct_reference_flagellin_dataframe(pfam_ncbi_fasta_filename, hu_accession_list_filename, hu_table_filename, tlr5_pos_pattern = '([LVIM].R[MIALV]..[LI])', base_dir = '/Users/kmayerbl/TLR/'): """ Constructs a DataFrame that will be used later on to score diamond results Parameters ---------- pfam_ncbi_fasta_filename : str Default 'inputs/PF00669_ncbi.txt' hu_accession_list_filename : str Default 'inputs/hu_all_ncbi.txt' hu_table_filename : str Default 'inputs/hu_table.csv' tlr5_pos_pattern : str Default '([LVIM].R[MIALV]..[LI])' base_dir : str Returns ------- df : Pandas DataFrame """ record_dict = SeqIO.to_dict(SeqIO.parse(pfam_ncbi_fasta_filename, 'fasta')) mapr = {x.strip().split("/")[0]:x for x in record_dict.keys()} ncbi_in_pfam = [x.strip().split("/")[0] for x in record_dict.keys()] with open(hu_accession_list_filename, 'r') as f: accessions = f.readlines() hu_ncbi_all = [x.strip() for x in accessions] set(hu_ncbi_all).intersection(set(ncbi_in_pfam)) acc = list(set(hu_ncbi_all).intersection(set(ncbi_in_pfam))) df =
pd.DataFrame({"Accession": acc})
pandas.DataFrame
import os os.environ['NUMEXPR_NUM_THREADS'] = '1' import pandas as pd import streamlit as st import numexpr numexpr.set_num_threads(1) from models.first_model import read_data, split_data, train_model df = read_data() X_train, X_test, y_train, y_test = split_data(df) clf = train_model(X_train, X_test, y_train, y_test) def predict(): dict_slides.update(dict_selects) print(dict_slides) df =
pd.DataFrame([dict_slides])
pandas.DataFrame
import dataset import librosa from torch.utils.data import DataLoader, random_split import torch import torch.nn.functional as F from utils import * import torchvision.models as models from torch.optim.lr_scheduler import StepLR from torch.utils.tensorboard import SummaryWriter import argparse import yaml from pathlib import Path import pandas as pd import time #from models import * #from filter import * from networks import * from torch.autograd import Variable import glob from mel2wav.modules import MelGAN_Generator, Audio2Mel LongTensor = torch.cuda.LongTensor FloatTensor = torch.cuda.FloatTensor def parse_args(): parser = argparse.ArgumentParser() parser.add_argument("--device", type = str, default = '0') parser.add_argument("--experiment_path", type = str, default = None) parser.add_argument("--save_specs", type = bool, default = False) parser.add_argument("--save_audio", type = bool, default = False) parser.add_argument("--filter_receptive_field", type = int, default = 3) parser.add_argument("--n_mel_channels", type = int, default = 80) parser.add_argument("--ngf", type = int, default = 32) parser.add_argument("--n_residual_layers", type = int, default = 3) # Data parameters parser.add_argument("--sampling_rate", type = int, default = 8000) parser.add_argument("--segment_length", type = int, default = 8192) parser.add_argument("--batch_size", type = int, default = 8) args = parser.parse_args() return args def main(): args = parse_args() runs = sorted(listdirs(args.experiment_path)) num_runs = len(runs) # Some hyper parameters num_genders = 2 num_digits = 10 device = 'cuda:' + args.device print(device) # Meta data and list of data files annotation_file = '/home/edvinli/thesis_spring_2020/audio_mnist/audioMNIST_meta.json' train_file_index = librosa.util.find_files('/home/edvinli/thesis_spring_2020/audio_mnist/') split_ratio = 5 # Build indices for the data file_index, annotation_index_gender, annotation_index_digit, annotation_index_speaker_id = dataset.build_annotation_index( train_file_index, annotation_file, balanced_genders = False) test_annotation_index, train_annotation_index, test_ids, train_ids = dataset.balanced_annotation_split(file_index, annotation_index_gender, annotation_index_digit, annotation_index_speaker_id, split_ratio) # Create the dataset test_data = dataset.AnnotatedAudioDataset( test_annotation_index, args.sampling_rate, args.segment_length ) n_test = test_data.__len__() if args.save_audio: test_loader = DataLoader(test_data, batch_size = 25, num_workers = 1) else: test_loader = DataLoader(test_data, batch_size = args.batch_size, num_workers = 1) # Set up models that are not trained fft = Audio2Mel(sampling_rate = args.sampling_rate) Mel2Audio = MelGAN_Generator(args.n_mel_channels, args.ngf, args.n_residual_layers).to(device) utility_netD = load_modified_AlexNet(num_digits).to(device) fixed_netD = load_modified_AlexNet(num_genders).to(device) utility_audio_net = AudioNet(num_digits).to(device) privacy_audio_net = AudioNet(num_genders).to(device) spec_FID_net = FID_AlexNet(num_digits).to(device) audio_FID_net = AudioNet(num_digits).to(device) # Pretrained Mel spectrogram inversion and digit classification Mel2Audio.load_state_dict(torch.load('mel2wav/best_netG_epoch_2120.pt')) utility_netD.load_state_dict(torch.load('fixed_classifier_checkpoints/best_digit_alexnet_spectrograms_epoch_26.pt')) fixed_netD.load_state_dict(torch.load('fixed_classifier_checkpoints/best_gender_alexnet_epoch_29.pt')) utility_audio_net.load_state_dict(torch.load('fixed_classifier_checkpoints/audio_digit_net_early_stop_epoch_26.pt')) privacy_audio_net.load_state_dict(torch.load('fixed_classifier_checkpoints/audio_gender_net_early_stop_epoch_36.pt')) utility_netD.eval() fixed_netD.eval() utility_audio_net.eval() privacy_audio_net.eval() # Pretrained FID loading spec_FID_net.load_state_dict(torch.load('fixed_classifier_checkpoints/best_digit_alexnet_spectrograms_epoch_26.pt')) audio_FID_net.load_state_dict(torch.load('fixed_classifier_checkpoints/audio_digit_net_early_stop_epoch_26.pt')) # Initialize arrays for accuracies and fid scores spec_digit_accuracy_F = [] spec_original_gender_accuracy_F = [] spec_digit_accuracy_G = [] spec_original_gender_accuracy_G = [] spec_sampled_gender_accuracy_G = [] audio_digit_accuracy_F = [] audio_original_gender_accuracy_F = [] audio_digit_accuracy_G = [] audio_original_gender_accuracy_G = [] audio_sampled_gender_accuracy_G = [] fid_spec_F = [] fid_spec_G = [] fid_audio_F = [] fid_audio_G = [] fid_inverted_audio = [] for i in range(num_runs): run_path = os.path.join(args.experiment_path, runs[i]) result_dir = os.path.join(run_path, 'results') audio_result_dir = os.path.join(result_dir, 'audio') spec_result_dir = os.path.join(result_dir, 'spectrograms') checkpoint_dir = os.path.join(run_path, 'checkpoints') # os.mkdir(result_dir) # os.mkdir(audio_result_dir) # os.mkdir(spec_result_dir) # Set up and load trained model netF = UNetFilter(1, 1, chs=[8, 16, 32, 64, 128], kernel_size = args.filter_receptive_field, image_width=32, image_height=80, noise_dim=10, nb_classes=2, embedding_dim=16, use_cond = False).to(device) netG = UNetFilter(1, 1, chs=[8, 16, 32, 64, 128], kernel_size = args.filter_receptive_field, image_width=32, image_height=80, noise_dim=10, nb_classes=2, embedding_dim=16, use_cond = True).to(device) netF.load_state_dict(torch.load(os.path.join(checkpoint_dir, 'netF_latest_epoch_1000.pt'))) netG.load_state_dict(torch.load(os.path.join(checkpoint_dir, 'netG_latest_epoch_1000.pt'))) spec_correct_digit_F = 0 spec_correct_original_gender_F = 0 spec_correct_digit_G = 0 spec_correct_original_gender_G = 0 spec_correct_sampled_gender_G = 0 audio_correct_digit_F = 0 audio_correct_original_gender_F = 0 audio_correct_digit_G = 0 audio_correct_original_gender_G = 0 audio_correct_sampled_gender_G = 0 acts_real_spec = [] acts_fake_spec_F = [] acts_fake_spec_G = [] acts_real_audio = [] acts_fake_audio_F = [] acts_fake_audio_G = [] acts_inverted_audio = [] for j, (x, gender, digit, speaker_id) in enumerate(test_loader): x = torch.unsqueeze(x,1) spectrograms = fft(x).detach() spectrograms, means, stds = preprocess_spectrograms(spectrograms) spectrograms = torch.unsqueeze(spectrograms,1).to(device) gender = gender.to(device) digit = digit.to(device) # -------------------------- # Spectrogram calculations # -------------------------- z1 = torch.randn(spectrograms.shape[0], 10).to(device) filter_mel = netF(spectrograms,z1, gender.long()) z2 = torch.randn(filter_mel.shape[0], 10).to(device) gen_secret = Variable(LongTensor(np.random.choice([0.0, 1.0], filter_mel.shape[0]))).to(device) gen_mel = netG(filter_mel,z2,gen_secret) spec_pred_digit_F = utility_netD(filter_mel) spec_pred_gender_F = fixed_netD(filter_mel) spec_pred_digit_G = utility_netD(gen_mel) spec_pred_gender_G = fixed_netD(gen_mel) # Calculate digit accuracy for fixed net on F and G outputs pred_digit_F = torch.argmax(spec_pred_digit_F.data,1) spec_correct_digit_F += (pred_digit_F == digit).sum().item() pred_digit_G = torch.argmax(spec_pred_digit_G.data,1) spec_correct_digit_G += (pred_digit_G == digit).sum().item() # Calculate gender accuracy for fixed net on F and G outputs pred_gender_F = torch.argmax(spec_pred_gender_F.data,1) spec_correct_original_gender_F += (pred_gender_F == gender.long()).sum().item() pred_gender_G = torch.argmax(spec_pred_gender_G.data,1) spec_correct_original_gender_G += (pred_gender_G == gender.long()).sum().item() spec_correct_sampled_gender_G += (pred_gender_G == gen_secret).sum().item() # Calculate FID on transformed spectrograms # acts1_tmp = spec_FID_net(spectrograms) # acts2_tmp = spec_FID_net(filter_mel) # acts3_tmp = spec_FID_net(gen_mel) # # acts_real_spec.append(np.squeeze(acts1_tmp.detach().cpu().numpy())) # acts_fake_spec_F.append(np.squeeze(acts2_tmp.detach().cpu().numpy())) # acts_fake_spec_G.append(np.squeeze(acts3_tmp.detach().cpu().numpy())) # Save spectrogram samples if args.save_specs: z1 = torch.randn(spectrograms.shape[0], 10).to(device) filtered = netF(spectrograms,z1,gender.long()).detach() z2 = torch.randn(spectrograms.shape[0], 10).to(device) male = Variable(LongTensor(spectrograms.size(0)).fill_(1.0), requires_grad=False).to(device) female = Variable(LongTensor(spectrograms.size(0)).fill_(0.0), requires_grad=False).to(device) generated_male = netG(filtered, z2, male).detach() generated_female = netG(filtered, z2, female).detach() filtered = torch.squeeze(filtered,1).to(device) * 3 * stds.to(device) + means.to(device) generated_male = generated_male.to(device) * 3 * stds.to(device) + means.to(device) generated_female = generated_female.to(device) * 3 * stds.to(device) + means.to(device) spectrograms = spectrograms.to(device) * 3 * stds.to(device) + means.to(device) if gender == 0: gender_title = 'female' else: gender_title = 'male' orig_title = 'Original spectrogram - Gender: {} - Digit: {}'.format(gender_title, digit.item()) male_title = 'Sampled gender: male ' female_title = 'Sampled gender: female' filtered_title = 'Filtered spectrogram' f_name_original = os.path.join(spec_result_dir, 'speaker_{}_digit_{}_original.png'.format( speaker_id.item(), digit.item() )) f_name_male = os.path.join(spec_result_dir, 'speaker_{}_digit_{}_male.png'.format( speaker_id.item(), digit.item() )) f_name_female = os.path.join(spec_result_dir, 'speaker_{}_digit_{}_female.png'.format( speaker_id.item(), digit.item() )) f_name_filtered = os.path.join(spec_result_dir, 'speaker_{}_digit_{}_filtered.png'.format(speaker_id.item(), digit.item() )) save_spec_plot(f_name_original, spectrograms, orig_title) save_spec_plot(f_name_male, generated_male, male_title) save_spec_plot(f_name_female, generated_female, female_title) save_spec_plot(f_name_filtered, filtered, filtered_title) # -------------------------- # Audio calculations # -------------------------- # Denormalize spectrograms before inversion filter_mel = torch.squeeze(filter_mel,1).to(device) * 3 * stds.to(device) + means.to(device) gen_mel = torch.squeeze(gen_mel,1).to(device) * 3 * stds.to(device) + means.to(device) spectrograms = torch.squeeze(spectrograms,1).to(device) * 3 * stds.to(device) + means.to(device) # Invert spectrograms using MelGAN original_audio = Mel2Audio(spectrograms) filter_audio = Mel2Audio(filter_mel) gen_audio = Mel2Audio(gen_mel) # Classify transformed audio audio_pred_digit_F, _ = utility_audio_net(filter_audio) audio_pred_gender_F, _ = privacy_audio_net(filter_audio) audio_pred_digit_G, _ = utility_audio_net(gen_audio) audio_pred_gender_G, _ = privacy_audio_net(gen_audio) pred_digit_F = torch.argmax(audio_pred_digit_F.data, 1) pred_gender_F = torch.argmax(audio_pred_gender_F.data, 1) pred_digit_G = torch.argmax(audio_pred_digit_G.data, 1) pred_gender_G = torch.argmax(audio_pred_gender_G.data, 1) audio_correct_digit_F += (pred_digit_F == digit).sum().item() audio_correct_original_gender_F += (pred_gender_F == gender.long()).sum().item() audio_correct_digit_G += (pred_digit_G == digit).sum().item() audio_correct_sampled_gender_G += (pred_gender_G == gen_secret).sum().item() audio_correct_original_gender_G += (pred_gender_G == gender.long()).sum().item() # Compute activations for FID calculations for the transformed audio _, acts1_tmp = audio_FID_net(x.to(device)) _, acts2_tmp = audio_FID_net(filter_audio.to(device)) _, acts3_tmp = audio_FID_net(gen_audio.to(device)) _, acts4_tmp = audio_FID_net(original_audio.to(device)) acts1_tmp = torch.flatten(acts1_tmp,1) acts2_tmp = torch.flatten(acts2_tmp,1) acts3_tmp = torch.flatten(acts3_tmp,1) acts4_tmp = torch.flatten(acts4_tmp,1) acts_real_audio.append(np.squeeze(acts1_tmp.detach().cpu().numpy())) acts_fake_audio_F.append(np.squeeze(acts2_tmp.detach().cpu().numpy())) acts_fake_audio_G.append(np.squeeze(acts3_tmp.detach().cpu().numpy())) acts_inverted_audio.append(np.squeeze(acts4_tmp.detach().cpu().numpy())) # -------------------------- # Save audio sample # -------------------------- if args.save_audio: if j % 2 == 0: original_audio_sample = torch.squeeze(original_audio[0]).detach().cpu() gen_audio_sample = torch.squeeze(gen_audio[0]).detach().cpu() speaker_id_sample = speaker_id[0].detach().cpu() digit_sample = digit[0].detach().cpu() gender_sample = gender[0].detach().cpu() gen_secret_sample = gen_secret[0].detach().cpu() f_name_orig_audio = os.path.join(audio_result_dir,'speaker_{}_digit_{}_original_inverted.wav'.format(speaker_id_sample, digit_sample, gender_sample, gen_secret_sample)) f_name_gen_audio = os.path.join(audio_result_dir,'speaker_{}_digit_{}_gender_orig_{}_sampled_{}.wav'.format(speaker_id_sample, digit_sample, gender_sample, gen_secret_sample)) save_sample(f_name_orig_audio, args.sampling_rate, original_audio_sample) save_sample(f_name_gen_audio, args.sampling_rate, gen_audio_sample) # Calcuate accuracies spec_digit_accuracy_F.append(100*spec_correct_digit_F / n_test) spec_original_gender_accuracy_F.append(100*spec_correct_original_gender_F / n_test) spec_digit_accuracy_G.append(100*spec_correct_digit_G / n_test) spec_original_gender_accuracy_G.append(100*spec_correct_original_gender_G / n_test) spec_sampled_gender_accuracy_G.append(100*spec_correct_sampled_gender_G / n_test) audio_digit_accuracy_F.append(100*audio_correct_digit_F / n_test) audio_original_gender_accuracy_F.append(100*audio_correct_original_gender_F / n_test) audio_digit_accuracy_G.append(100*audio_correct_digit_G / n_test) audio_original_gender_accuracy_G.append(100*audio_correct_original_gender_G / n_test) audio_sampled_gender_accuracy_G.append(100*audio_correct_sampled_gender_G / n_test) # Concatenate batch activations into single array # acts_real_spec = np.concatenate(acts_real_spec, axis = 0) # acts_fake_spec_F = np.concatenate(acts_fake_spec_F, axis = 0) # acts_fake_spec_G = np.concatenate(acts_fake_spec_G, axis = 0) acts_real_audio = np.concatenate(acts_real_audio, axis = 0) acts_fake_audio_F = np.concatenate(acts_fake_audio_F, axis = 0) acts_fake_audio_G = np.concatenate(acts_fake_audio_G, axis = 0) acts_inverted_audio = np.concatenate(acts_inverted_audio, axis = 0) # Calculate FID scores # fid_spec_tmp_F = compute_frechet_inception_distance(acts_real_spec, acts_fake_spec_F) # fid_spec_tmp_G = compute_frechet_inception_distance(acts_real_spec, acts_fake_spec_G) #fid_audio_tmp_F = compute_frechet_inception_distance(acts_real_audio, acts_fake_audio_F) #fid_audio_tmp_G = compute_frechet_inception_distance(acts_real_audio, acts_fake_audio_G) #if i == 0: # fid_inverted_audio_tmp = compute_frechet_inception_distance(acts_real_audio, acts_inverted_audio) # fid_spec_F.append(fid_spec_tmp_F) #fid_audio_F.append(fid_audio_tmp_F) # fid_spec_G.append(fid_spec_tmp_G) #fid_audio_G.append(fid_audio_tmp_G) #fid_inverted_audio.append(fid_inverted_audio_tmp) print("Computed accuracies and FID for run {}.".format(i)) # Create data frames with the accuracies spec_digit_acc_F_df = pd.DataFrame(spec_digit_accuracy_F) spec_orig_gender_acc_F_df = pd.DataFrame(spec_original_gender_accuracy_F) spec_digit_acc_G_df = pd.DataFrame(spec_digit_accuracy_G) spec_orig_gender_acc_G_df = pd.DataFrame(spec_original_gender_accuracy_G) spec_sampled_gender_acc_G_df = pd.DataFrame(spec_sampled_gender_accuracy_G) audio_digit_acc_F_df = pd.DataFrame(audio_digit_accuracy_F) audio_orig_gender_acc_F_df =
pd.DataFrame(audio_original_gender_accuracy_F)
pandas.DataFrame
import pandas as pd import numpy as np import re from unidecode import unidecode # Map district in Kraków to integers. # For details see: # https://en.wikipedia.org/wiki/Districts_of_Krak%C3%B3w districts = {'stare miasto': 1, 'grzegórzki': 2, 'prądnik czerwony': 3, 'prądnik biały': 4, 'krowodrza': 5, 'bronowice': 6, 'zwierzyniec': 7, 'dębniki': 8, 'łagiewniki': 9, 'borek fałęcki': 9, 'swoszowice': 10, 'podgórze duchackie': 11, 'bieżanów': 12, 'prokocim': 12, 'podgórze': 13, 'czyżyny': 14, 'mistrzejowice': 15, 'bieńczyce': 16, 'wzgórza krzesławickie': 17, 'nowa huta': 18} # Remove polish characters from key names for key in list(districts.keys()): districts[unidecode(key)] = districts.pop(key) # Translate data from polish to english. translation = {'Cena': 'Price', 'Lokalizacja': 'Location', 'Data dodania': 'Date', 'Na sprzedaż przez': 'Seller', 'Rodzaj nieruchomości': 'Property', 'Liczba pokoi': 'Rooms', 'Liczba łazienek': 'Bathrooms', 'Wielkość (m2)': 'Area', 'Parking': 'Parking', 'Tytuł': 'Title', 'Opis': 'Description', 'Link': 'Link'} def remove_polish_characters(x): """ Remove polsih chars Examples -------- >>> remove_polish_characters('ąćęłńóśźż') 'acelnoszz' """ if pd.isnull(x): return x else: x = unidecode(x) return x def parse_price(x): """ Convert string with price to a integer value. Parameters ---------- x : str Row from price column. Returns ------- int : Price of the property. Example ------- >>> parse_price('349\xa0000 zł') 349000 >>> parse_price('349 000 zł') 349000 >>> parse_price('349\xa0000') 349000 >>> parse_price('349000') 349000 >>> parse_price(349000) 349000 >>> parse_price(349000.1235) 349000 >>> parse_price(np.nan) nan >>> parse_price('Proszę o kontakt') nan """ if pd.isnull(x): return x else: if isinstance(x, str): x = x.replace('\xa0', '') x = x.replace('zł', '') x = x.replace(' ', '') x = x.strip() try: x = int(x) except ValueError: x = np.nan return x elif isinstance(x, int): return x elif isinstance(x, float): x = int(x) return x else: return np.nan def extract_currency(x): """ Exctract currency from price column. Examples -------- >>> extract_currency('123000zł') 'pln' """ if pd.isnull(x): return x else: if isinstance(x, str): x = x.lower() if 'zł' in x or 'zł' in x or 'pln' in x: return 'pln' else: return np.nan else: return np.nan def parse_bathrooms(x): """ Extract first digit from string describing the number of bathrooms. Parameters ---------- x : str String describing the number of bathrooms. Returns ------- int : The number of bathrooms or nan. Examples -------- >>> parse_bathrooms('1 łazienka') 1 >>> parse_bathrooms('2 łazienki') 2 >>> parse_bathrooms('4') 4 >>> parse_bathrooms(3) 3 """ if pd.isnull(x): return x else: if isinstance(x, str): x = [s for s in x if s.isdigit()] if x: return int(x[0]) else: return np.nan elif isinstance(x, int): return x elif isinstance(x, float): return int(x) else: return np.nan def parse_rooms(x): """ Extract first digit in string describing the number of bathrooms. Parameters ---------- x : str Row of rooms column. Returns ------- int The number of rooms in the property. Examples -------- >>> parse_rooms('2 pokoje') 2 >>> parse_rooms('5') 5 >>> parse_rooms('3') 3 """ if pd.isnull(x): return x else: if isinstance(x, str): # Check for special # cases first x = x.lower() if 'kawalerka' in x: return 1 elif 'garsoniera' in x: return 1 else: # If not special case extract # first digit in string. x = [s for s in x if s.isdigit()] if x: return int(x[0]) else: return np.nan elif isinstance(x, float): return int(x) elif isinstance(x, int): return x else: return np.nan def extract_city(x): """ Extract city from location column. Parameters ---------- x : str Row of location column. Returns ------- str : Kraków if the property is located in Kraków else nan. Examples -------- >>> extract_city('Piotra Stachiewicza, Kraków-Krowodrza, Kraków') 'kraków' >>> extract_city('os. Na Stoku, Kraków-Nowa Huta, Kraków') 'kraków' >>> extract_city('Modlniczka, Wielka Wieś, krakowski') nan >>> extract_city('random string') nan """ if pd.isnull(x): return x else: if isinstance(x, str): x = x.split(',') x = [s.strip().lower() for s in x] if 'kraków' in x or 'krakow' in x or 'cracow' in x: return 'kraków' else: return np.nan else: return np.nan def extract_district(x): """ Extract district from location column. Parameters ---------- x : str Row from location column. Returns ------- str : The district where the property is located. Examples -------- >>> extract_district('Piotra Stachiewicza, Kraków-Krowodrza, Kraków') 'krowodrza' >>> extract_district('os. Na Stoku, Kraków-Nowa Huta, Kraków') 'nowa huta' >>> extract_district('Modlniczka, Wielka Wieś, krakowski') nan >>> extract_city('random string') nan """ if pd.isnull(x): return x else: if isinstance(x, str): x = x.lower() x = x.replace('kraków', '') x = x.replace(',', ' ') x = x.replace('-', ' ') x = x.replace('.', ' ') x = x.split(' ') x = [s.replace(' ', '') for s in x if s != ''] x = ' '.join(x) if x == '': return np.nan else: for key in districts: if key in x: return key return np.nan def parse_seller(x): """ Translate seller column to english. """ if pd.isnull(x): return x else: if isinstance(x, str): x = x.lower() if 'agencja' in x: return 'realtor' elif 'właściciel' in x: return 'owner' else: return np.nan else: return np.nan def parse_property(x): if pd.isnull(x): return x else: if isinstance(x, str): x = x.lower() if 'dom' in x: return 'house' elif 'mieszkanie' in x: return 'flat' else: return np.nan else: return np.nan def parse_parking(x): """ Translate parking column. Examples -------- >>> parse_parking('garaż') 'garage' >>> parse_parking('Ulica') 'street' >>> parse_parking('Brak') 'no parking' """ if pd.isnull(x): return x else: if isinstance(x, str): x = x.lower() if 'garaż' in x: return 'garage' elif 'kryty' in x: return 'covered' elif 'ulica' in x: return 'street' elif 'brak' in x: return 'no parking' else: return np.nan else: return np.nan def extract_garden(x): """ Check if property has garden. Examples -------- >>> extract_garden('piękny ogrod') True >>> extract_garden('piękny dom') False >>> extract_garden('1223') False """ if pd.isnull(x): return x else: if isinstance(x, str): x = x.lower() if 'ogrod' in x: return True else: return False else: return False def extract_balcony(x): """ Check if property has balcony. Examples -------- >>> extract_balcony('Mieszkanie z pięknym balkonem') True >>> extract_balcony('Brzydkie mieszkanie') False """ if pd.isnull(x): return x else: if isinstance(x, str): x = x.lower() if 'balkon' in x: return True else: return False else: return False def extract_terrace(x): """ Check if property has terrace. Examples -------- >>> extract_terrace('Mieszkanie z tarasem') True >>> extract_terrace('Brzydkie mieszkanie') False >>> extract_terrace('125') False """ if pd.isnull(x): return x else: if isinstance(x, str): x = x.lower() if 'taras' in x: return True else: return False else: return False def extract_basement(x): """ Check if property has a basement. Examples -------- >>> extract_basement('Mieszkanie z przynależną piwnica') True >>> extract_basement('Pierwsze pietro') False """ if pd.isnull(x): return x else: if isinstance(x, str): x = x.lower() if 'piwnica' in x: return True else: return False else: return False def extract_new(x): """ Check if property is new. Examples -------- >>> extract_new('Nowe mieszkanie') True >>> extract_new('Stare mieszkanie') False """ if pd.isnull(x): return x else: if isinstance(x, str): x = x.lower() if 'nowe' in x or 'nowa' in x: return True else: return False else: return False def extract_block(x): """ Check if property is in an block. Examples -------- >>> extract_block('Piękne mieszkanie w bloku xxx') True >>> extract_block(123) False """ if pd.isnull(x): return x else: if isinstance(x, str): x = x.lower() if 'bloku' in x: return True else: return False else: return False def extract_town_house(x): """ Check if property is in a town house. Examples -------- >>> extract_town_house('Małe mieszkanie w kamienicy') True >>> extract_town_house('Duże mieszkanie w bloku') False """ if pd.isnull(x): return x else: if isinstance(x, str): x = x.lower() if 'kamienica' in x or 'kamienicy' in x: return True else: return False else: return False def extract_apartment(x): """ Check if property is an apartment. Examples -------- >>> extract_apartment('Apartament na sprzedaż') True >>> extract_apartment('Kawalerka na sprzedaż') False """ if pd.isnull(x): return x else: if isinstance(x, str): x = x.lower() if 'apartament' in x or 'apartamencie' in x: return True else: return False else: return False def extract_studio(x): """ Check if property is studio flat. Examples -------- >>> extract_studio('Kawalerka na sprzedaż') True >>> extract_studio('Apartament na sprzedaż') False """ if pd.isnull(x): return x else: if isinstance(x, str): x = x.lower() if 'kawalerka' in x or 'kawaler' in x: return True else: return False else: return False def extract_bus_stops(x): """ Check is property has bus stops nearby. Examples -------- >>> extract_bus_stops('Blisko przystanki komunkacji miejskiej') True """ if pd.isnull(x): return x else: if isinstance(x, str): x = x.lower() if 'miejskiej' in x: return True else: return False else: return False def parse_title(x): """ Remove non letters from title. Examples -------- >>> parse_title('Piękne mieszkanie !!!') 'piękne mieszkanie' """ if
pd.isnull(x)
pandas.isnull
import pytz import pytest import dateutil import warnings import numpy as np from datetime import timedelta from itertools import product import pandas as pd import pandas._libs.tslib as tslib import pandas.util.testing as tm from pandas.errors import PerformanceWarning from pandas.core.indexes.datetimes import cdate_range from pandas import (DatetimeIndex, PeriodIndex, Series, Timestamp, Timedelta, date_range, TimedeltaIndex, _np_version_under1p10, Index, datetime, Float64Index, offsets, bdate_range) from pandas.tseries.offsets import BMonthEnd, CDay, BDay from pandas.tests.test_base import Ops START, END = datetime(2009, 1, 1), datetime(2010, 1, 1) class TestDatetimeIndexOps(Ops): tz = [None, 'UTC', 'Asia/Tokyo', 'US/Eastern', 'dateutil/Asia/Singapore', 'dateutil/US/Pacific'] def setup_method(self, method): super(TestDatetimeIndexOps, self).setup_method(method) mask = lambda x: (isinstance(x, DatetimeIndex) or isinstance(x, PeriodIndex)) self.is_valid_objs = [o for o in self.objs if mask(o)] self.not_valid_objs = [o for o in self.objs if not mask(o)] def test_ops_properties(self): f = lambda x: isinstance(x, DatetimeIndex) self.check_ops_properties(DatetimeIndex._field_ops, f) self.check_ops_properties(DatetimeIndex._object_ops, f) self.check_ops_properties(DatetimeIndex._bool_ops, f) def test_ops_properties_basic(self): # sanity check that the behavior didn't change # GH7206 for op in ['year', 'day', 'second', 'weekday']: pytest.raises(TypeError, lambda x: getattr(self.dt_series, op)) # attribute access should still work! s = Series(dict(year=2000, month=1, day=10)) assert s.year == 2000 assert s.month == 1 assert s.day == 10 pytest.raises(AttributeError, lambda: s.weekday) def test_asobject_tolist(self): idx = pd.date_range(start='2013-01-01', periods=4, freq='M', name='idx') expected_list = [Timestamp('2013-01-31'), Timestamp('2013-02-28'), Timestamp('2013-03-31'), Timestamp('2013-04-30')] expected = pd.Index(expected_list, dtype=object, name='idx') result = idx.asobject assert isinstance(result, Index) assert result.dtype == object tm.assert_index_equal(result, expected) assert result.name == expected.name assert idx.tolist() == expected_list idx = pd.date_range(start='2013-01-01', periods=4, freq='M', name='idx', tz='Asia/Tokyo') expected_list = [Timestamp('2013-01-31', tz='Asia/Tokyo'), Timestamp('2013-02-28', tz='Asia/Tokyo'), Timestamp('2013-03-31', tz='Asia/Tokyo'), Timestamp('2013-04-30', tz='Asia/Tokyo')] expected = pd.Index(expected_list, dtype=object, name='idx') result = idx.asobject assert isinstance(result, Index) assert result.dtype == object tm.assert_index_equal(result, expected) assert result.name == expected.name assert idx.tolist() == expected_list idx = DatetimeIndex([datetime(2013, 1, 1), datetime(2013, 1, 2), pd.NaT, datetime(2013, 1, 4)], name='idx') expected_list = [Timestamp('2013-01-01'), Timestamp('2013-01-02'), pd.NaT, Timestamp('2013-01-04')] expected = pd.Index(expected_list, dtype=object, name='idx') result = idx.asobject assert isinstance(result, Index) assert result.dtype == object tm.assert_index_equal(result, expected) assert result.name == expected.name assert idx.tolist() == expected_list def test_minmax(self): for tz in self.tz: # monotonic idx1 = pd.DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03'], tz=tz) assert idx1.is_monotonic # non-monotonic idx2 = pd.DatetimeIndex(['2011-01-01', pd.NaT, '2011-01-03', '2011-01-02', pd.NaT], tz=tz) assert not idx2.is_monotonic for idx in [idx1, idx2]: assert idx.min() == Timestamp('2011-01-01', tz=tz) assert idx.max() == Timestamp('2011-01-03', tz=tz) assert idx.argmin() == 0 assert idx.argmax() == 2 for op in ['min', 'max']: # Return NaT obj = DatetimeIndex([]) assert pd.isna(getattr(obj, op)()) obj = DatetimeIndex([pd.NaT]) assert pd.isna(getattr(obj, op)()) obj = DatetimeIndex([pd.NaT, pd.NaT, pd.NaT]) assert pd.isna(getattr(obj, op)()) def test_numpy_minmax(self): dr = pd.date_range(start='2016-01-15', end='2016-01-20') assert np.min(dr) == Timestamp('2016-01-15 00:00:00', freq='D') assert np.max(dr) == Timestamp('2016-01-20 00:00:00', freq='D') errmsg = "the 'out' parameter is not supported" tm.assert_raises_regex(ValueError, errmsg, np.min, dr, out=0) tm.assert_raises_regex(ValueError, errmsg, np.max, dr, out=0) assert np.argmin(dr) == 0 assert np.argmax(dr) == 5 if not _np_version_under1p10: errmsg = "the 'out' parameter is not supported" tm.assert_raises_regex( ValueError, errmsg, np.argmin, dr, out=0) tm.assert_raises_regex( ValueError, errmsg, np.argmax, dr, out=0) def test_round(self): for tz in self.tz: rng = pd.date_range(start='2016-01-01', periods=5, freq='30Min', tz=tz) elt = rng[1] expected_rng = DatetimeIndex([ Timestamp('2016-01-01 00:00:00', tz=tz, freq='30T'), Timestamp('2016-01-01 00:00:00', tz=tz, freq='30T'), Timestamp('2016-01-01 01:00:00', tz=tz, freq='30T'), Timestamp('2016-01-01 02:00:00', tz=tz, freq='30T'), Timestamp('2016-01-01 02:00:00', tz=tz, freq='30T'), ]) expected_elt = expected_rng[1] tm.assert_index_equal(rng.round(freq='H'), expected_rng) assert elt.round(freq='H') == expected_elt msg = pd.tseries.frequencies._INVALID_FREQ_ERROR with tm.assert_raises_regex(ValueError, msg): rng.round(freq='foo') with tm.assert_raises_regex(ValueError, msg): elt.round(freq='foo') msg = "<MonthEnd> is a non-fixed frequency" tm.assert_raises_regex(ValueError, msg, rng.round, freq='M') tm.assert_raises_regex(ValueError, msg, elt.round, freq='M') # GH 14440 & 15578 index = pd.DatetimeIndex(['2016-10-17 12:00:00.0015'], tz=tz) result = index.round('ms') expected = pd.DatetimeIndex(['2016-10-17 12:00:00.002000'], tz=tz) tm.assert_index_equal(result, expected) for freq in ['us', 'ns']: tm.assert_index_equal(index, index.round(freq)) index = pd.DatetimeIndex(['2016-10-17 12:00:00.00149'], tz=tz) result = index.round('ms') expected = pd.DatetimeIndex(['2016-10-17 12:00:00.001000'], tz=tz) tm.assert_index_equal(result, expected) index = pd.DatetimeIndex(['2016-10-17 12:00:00.001501031']) result = index.round('10ns') expected = pd.DatetimeIndex(['2016-10-17 12:00:00.001501030']) tm.assert_index_equal(result, expected) with tm.assert_produces_warning(): ts = '2016-10-17 12:00:00.001501031' pd.DatetimeIndex([ts]).round('1010ns') def test_repeat_range(self): rng = date_range('1/1/2000', '1/1/2001') result = rng.repeat(5) assert result.freq is None assert len(result) == 5 * len(rng) for tz in self.tz: index = pd.date_range('2001-01-01', periods=2, freq='D', tz=tz) exp = pd.DatetimeIndex(['2001-01-01', '2001-01-01', '2001-01-02', '2001-01-02'], tz=tz) for res in [index.repeat(2), np.repeat(index, 2)]: tm.assert_index_equal(res, exp) assert res.freq is None index = pd.date_range('2001-01-01', periods=2, freq='2D', tz=tz) exp = pd.DatetimeIndex(['2001-01-01', '2001-01-01', '2001-01-03', '2001-01-03'], tz=tz) for res in [index.repeat(2), np.repeat(index, 2)]: tm.assert_index_equal(res, exp) assert res.freq is None index = pd.DatetimeIndex(['2001-01-01', 'NaT', '2003-01-01'], tz=tz) exp = pd.DatetimeIndex(['2001-01-01', '2001-01-01', '2001-01-01', 'NaT', 'NaT', 'NaT', '2003-01-01', '2003-01-01', '2003-01-01'], tz=tz) for res in [index.repeat(3), np.repeat(index, 3)]: tm.assert_index_equal(res, exp) assert res.freq is None def test_repeat(self): reps = 2 msg = "the 'axis' parameter is not supported" for tz in self.tz: rng = pd.date_range(start='2016-01-01', periods=2, freq='30Min', tz=tz) expected_rng = DatetimeIndex([ Timestamp('2016-01-01 00:00:00', tz=tz, freq='30T'), Timestamp('2016-01-01 00:00:00', tz=tz, freq='30T'), Timestamp('2016-01-01 00:30:00', tz=tz, freq='30T'), Timestamp('2016-01-01 00:30:00', tz=tz, freq='30T'), ]) res = rng.repeat(reps) tm.assert_index_equal(res, expected_rng) assert res.freq is None tm.assert_index_equal(np.repeat(rng, reps), expected_rng) tm.assert_raises_regex(ValueError, msg, np.repeat, rng, reps, axis=1) def test_representation(self): idx = [] idx.append(DatetimeIndex([], freq='D')) idx.append(DatetimeIndex(['2011-01-01'], freq='D')) idx.append(DatetimeIndex(['2011-01-01', '2011-01-02'], freq='D')) idx.append(DatetimeIndex( ['2011-01-01', '2011-01-02', '2011-01-03'], freq='D')) idx.append(DatetimeIndex( ['2011-01-01 09:00', '2011-01-01 10:00', '2011-01-01 11:00' ], freq='H', tz='Asia/Tokyo')) idx.append(DatetimeIndex( ['2011-01-01 09:00', '2011-01-01 10:00', pd.NaT], tz='US/Eastern')) idx.append(DatetimeIndex( ['2011-01-01 09:00', '2011-01-01 10:00', pd.NaT], tz='UTC')) exp = [] exp.append("""DatetimeIndex([], dtype='datetime64[ns]', freq='D')""") exp.append("DatetimeIndex(['2011-01-01'], dtype='datetime64[ns]', " "freq='D')") exp.append("DatetimeIndex(['2011-01-01', '2011-01-02'], " "dtype='datetime64[ns]', freq='D')") exp.append("DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03'], " "dtype='datetime64[ns]', freq='D')") exp.append("DatetimeIndex(['2011-01-01 09:00:00+09:00', " "'2011-01-01 10:00:00+09:00', '2011-01-01 11:00:00+09:00']" ", dtype='datetime64[ns, Asia/Tokyo]', freq='H')") exp.append("DatetimeIndex(['2011-01-01 09:00:00-05:00', " "'2011-01-01 10:00:00-05:00', 'NaT'], " "dtype='datetime64[ns, US/Eastern]', freq=None)") exp.append("DatetimeIndex(['2011-01-01 09:00:00+00:00', " "'2011-01-01 10:00:00+00:00', 'NaT'], " "dtype='datetime64[ns, UTC]', freq=None)""") with pd.option_context('display.width', 300): for indx, expected in zip(idx, exp): for func in ['__repr__', '__unicode__', '__str__']: result = getattr(indx, func)() assert result == expected def test_representation_to_series(self): idx1 = DatetimeIndex([], freq='D') idx2 = DatetimeIndex(['2011-01-01'], freq='D') idx3 = DatetimeIndex(['2011-01-01', '2011-01-02'], freq='D') idx4 = DatetimeIndex( ['2011-01-01', '2011-01-02', '2011-01-03'], freq='D') idx5 = DatetimeIndex(['2011-01-01 09:00', '2011-01-01 10:00', '2011-01-01 11:00'], freq='H', tz='Asia/Tokyo') idx6 = DatetimeIndex(['2011-01-01 09:00', '2011-01-01 10:00', pd.NaT], tz='US/Eastern') idx7 = DatetimeIndex(['2011-01-01 09:00', '2011-01-02 10:15']) exp1 = """Series([], dtype: datetime64[ns])""" exp2 = """0 2011-01-01 dtype: datetime64[ns]""" exp3 = """0 2011-01-01 1 2011-01-02 dtype: datetime64[ns]""" exp4 = """0 2011-01-01 1 2011-01-02 2 2011-01-03 dtype: datetime64[ns]""" exp5 = """0 2011-01-01 09:00:00+09:00 1 2011-01-01 10:00:00+09:00 2 2011-01-01 11:00:00+09:00 dtype: datetime64[ns, Asia/Tokyo]""" exp6 = """0 2011-01-01 09:00:00-05:00 1 2011-01-01 10:00:00-05:00 2 NaT dtype: datetime64[ns, US/Eastern]""" exp7 = """0 2011-01-01 09:00:00 1 2011-01-02 10:15:00 dtype: datetime64[ns]""" with pd.option_context('display.width', 300): for idx, expected in zip([idx1, idx2, idx3, idx4, idx5, idx6, idx7], [exp1, exp2, exp3, exp4, exp5, exp6, exp7]): result = repr(Series(idx)) assert result == expected def test_summary(self): # GH9116 idx1 = DatetimeIndex([], freq='D') idx2 = DatetimeIndex(['2011-01-01'], freq='D') idx3 = DatetimeIndex(['2011-01-01', '2011-01-02'], freq='D') idx4 = DatetimeIndex( ['2011-01-01', '2011-01-02', '2011-01-03'], freq='D') idx5 = DatetimeIndex(['2011-01-01 09:00', '2011-01-01 10:00', '2011-01-01 11:00'], freq='H', tz='Asia/Tokyo') idx6 = DatetimeIndex(['2011-01-01 09:00', '2011-01-01 10:00', pd.NaT], tz='US/Eastern') exp1 = """DatetimeIndex: 0 entries Freq: D""" exp2 = """DatetimeIndex: 1 entries, 2011-01-01 to 2011-01-01 Freq: D""" exp3 = """DatetimeIndex: 2 entries, 2011-01-01 to 2011-01-02 Freq: D""" exp4 = """DatetimeIndex: 3 entries, 2011-01-01 to 2011-01-03 Freq: D""" exp5 = ("DatetimeIndex: 3 entries, 2011-01-01 09:00:00+09:00 " "to 2011-01-01 11:00:00+09:00\n" "Freq: H") exp6 = """DatetimeIndex: 3 entries, 2011-01-01 09:00:00-05:00 to NaT""" for idx, expected in zip([idx1, idx2, idx3, idx4, idx5, idx6], [exp1, exp2, exp3, exp4, exp5, exp6]): result = idx.summary() assert result == expected def test_resolution(self): for freq, expected in zip(['A', 'Q', 'M', 'D', 'H', 'T', 'S', 'L', 'U'], ['day', 'day', 'day', 'day', 'hour', 'minute', 'second', 'millisecond', 'microsecond']): for tz in self.tz: idx = pd.date_range(start='2013-04-01', periods=30, freq=freq, tz=tz) assert idx.resolution == expected def test_union(self): for tz in self.tz: # union rng1 = pd.date_range('1/1/2000', freq='D', periods=5, tz=tz) other1 = pd.date_range('1/6/2000', freq='D', periods=5, tz=tz) expected1 = pd.date_range('1/1/2000', freq='D', periods=10, tz=tz) rng2 = pd.date_range('1/1/2000', freq='D', periods=5, tz=tz) other2 = pd.date_range('1/4/2000', freq='D', periods=5, tz=tz) expected2 = pd.date_range('1/1/2000', freq='D', periods=8, tz=tz) rng3 = pd.date_range('1/1/2000', freq='D', periods=5, tz=tz) other3 = pd.DatetimeIndex([], tz=tz) expected3 = pd.date_range('1/1/2000', freq='D', periods=5, tz=tz) for rng, other, expected in [(rng1, other1, expected1), (rng2, other2, expected2), (rng3, other3, expected3)]: result_union = rng.union(other) tm.assert_index_equal(result_union, expected) def test_add_iadd(self): for tz in self.tz: # offset offsets = [pd.offsets.Hour(2), timedelta(hours=2), np.timedelta64(2, 'h'), Timedelta(hours=2)] for delta in offsets: rng = pd.date_range('2000-01-01', '2000-02-01', tz=tz) result = rng + delta expected = pd.date_range('2000-01-01 02:00', '2000-02-01 02:00', tz=tz) tm.assert_index_equal(result, expected) rng += delta tm.assert_index_equal(rng, expected) # int rng = pd.date_range('2000-01-01 09:00', freq='H', periods=10, tz=tz) result = rng + 1 expected = pd.date_range('2000-01-01 10:00', freq='H', periods=10, tz=tz) tm.assert_index_equal(result, expected) rng += 1 tm.assert_index_equal(rng, expected) idx = DatetimeIndex(['2011-01-01', '2011-01-02']) msg = "cannot add a datelike to a DatetimeIndex" with tm.assert_raises_regex(TypeError, msg): idx + Timestamp('2011-01-01') with tm.assert_raises_regex(TypeError, msg): Timestamp('2011-01-01') + idx def test_add_dti_dti(self): # previously performed setop (deprecated in 0.16.0), now raises # TypeError (GH14164) dti = date_range('20130101', periods=3) dti_tz = date_range('20130101', periods=3).tz_localize('US/Eastern') with pytest.raises(TypeError): dti + dti with pytest.raises(TypeError): dti_tz + dti_tz with pytest.raises(TypeError): dti_tz + dti with pytest.raises(TypeError): dti + dti_tz def test_difference(self): for tz in self.tz: # diff rng1 = pd.date_range('1/1/2000', freq='D', periods=5, tz=tz) other1 = pd.date_range('1/6/2000', freq='D', periods=5, tz=tz) expected1 = pd.date_range('1/1/2000', freq='D', periods=5, tz=tz) rng2 = pd.date_range('1/1/2000', freq='D', periods=5, tz=tz) other2 = pd.date_range('1/4/2000', freq='D', periods=5, tz=tz) expected2 = pd.date_range('1/1/2000', freq='D', periods=3, tz=tz) rng3 = pd.date_range('1/1/2000', freq='D', periods=5, tz=tz) other3 = pd.DatetimeIndex([], tz=tz) expected3 = pd.date_range('1/1/2000', freq='D', periods=5, tz=tz) for rng, other, expected in [(rng1, other1, expected1), (rng2, other2, expected2), (rng3, other3, expected3)]: result_diff = rng.difference(other) tm.assert_index_equal(result_diff, expected) def test_sub_isub(self): for tz in self.tz: # offset offsets = [pd.offsets.Hour(2), timedelta(hours=2), np.timedelta64(2, 'h'), Timedelta(hours=2)] for delta in offsets: rng = pd.date_range('2000-01-01', '2000-02-01', tz=tz) expected = pd.date_range('1999-12-31 22:00', '2000-01-31 22:00', tz=tz) result = rng - delta tm.assert_index_equal(result, expected) rng -= delta tm.assert_index_equal(rng, expected) # int rng = pd.date_range('2000-01-01 09:00', freq='H', periods=10, tz=tz) result = rng - 1 expected = pd.date_range('2000-01-01 08:00', freq='H', periods=10, tz=tz) tm.assert_index_equal(result, expected) rng -= 1 tm.assert_index_equal(rng, expected) def test_sub_dti_dti(self): # previously performed setop (deprecated in 0.16.0), now changed to # return subtraction -> TimeDeltaIndex (GH ...) dti = date_range('20130101', periods=3) dti_tz = date_range('20130101', periods=3).tz_localize('US/Eastern') dti_tz2 = date_range('20130101', periods=3).tz_localize('UTC') expected = TimedeltaIndex([0, 0, 0]) result = dti - dti tm.assert_index_equal(result, expected) result = dti_tz - dti_tz tm.assert_index_equal(result, expected) with pytest.raises(TypeError): dti_tz - dti with pytest.raises(TypeError): dti - dti_tz with pytest.raises(TypeError): dti_tz - dti_tz2 # isub dti -= dti tm.assert_index_equal(dti, expected) # different length raises ValueError dti1 = date_range('20130101', periods=3) dti2 = date_range('20130101', periods=4) with pytest.raises(ValueError): dti1 - dti2 # NaN propagation dti1 = DatetimeIndex(['2012-01-01', np.nan, '2012-01-03']) dti2 = DatetimeIndex(['2012-01-02', '2012-01-03', np.nan]) expected = TimedeltaIndex(['1 days', np.nan, np.nan]) result = dti2 - dti1 tm.assert_index_equal(result, expected) def test_sub_period(self): # GH 13078 # not supported, check TypeError p = pd.Period('2011-01-01', freq='D') for freq in [None, 'D']: idx = pd.DatetimeIndex(['2011-01-01', '2011-01-02'], freq=freq) with pytest.raises(TypeError): idx - p with pytest.raises(TypeError): p - idx def test_comp_nat(self): left = pd.DatetimeIndex([pd.Timestamp('2011-01-01'), pd.NaT, pd.Timestamp('2011-01-03')]) right = pd.DatetimeIndex([pd.NaT, pd.NaT, pd.Timestamp('2011-01-03')]) for l, r in [(left, right), (left.asobject, right.asobject)]: result = l == r expected = np.array([False, False, True]) tm.assert_numpy_array_equal(result, expected) result = l != r expected = np.array([True, True, False]) tm.assert_numpy_array_equal(result, expected) expected = np.array([False, False, False]) tm.assert_numpy_array_equal(l == pd.NaT, expected) tm.assert_numpy_array_equal(pd.NaT == r, expected) expected = np.array([True, True, True]) tm.assert_numpy_array_equal(l != pd.NaT, expected) tm.assert_numpy_array_equal(pd.NaT != l, expected) expected = np.array([False, False, False]) tm.assert_numpy_array_equal(l < pd.NaT, expected) tm.assert_numpy_array_equal(pd.NaT > l, expected) def test_value_counts_unique(self): # GH 7735 for tz in self.tz: idx = pd.date_range('2011-01-01 09:00', freq='H', periods=10) # create repeated values, 'n'th element is repeated by n+1 times idx = DatetimeIndex(np.repeat(idx.values, range(1, len(idx) + 1)), tz=tz) exp_idx = pd.date_range('2011-01-01 18:00', freq='-1H', periods=10, tz=tz) expected = Series(range(10, 0, -1), index=exp_idx, dtype='int64') for obj in [idx, Series(idx)]: tm.assert_series_equal(obj.value_counts(), expected) expected = pd.date_range('2011-01-01 09:00', freq='H', periods=10, tz=tz) tm.assert_index_equal(idx.unique(), expected) idx = DatetimeIndex(['2013-01-01 09:00', '2013-01-01 09:00', '2013-01-01 09:00', '2013-01-01 08:00', '2013-01-01 08:00', pd.NaT], tz=tz) exp_idx = DatetimeIndex(['2013-01-01 09:00', '2013-01-01 08:00'], tz=tz) expected = Series([3, 2], index=exp_idx) for obj in [idx, Series(idx)]: tm.assert_series_equal(obj.value_counts(), expected) exp_idx = DatetimeIndex(['2013-01-01 09:00', '2013-01-01 08:00', pd.NaT], tz=tz) expected = Series([3, 2, 1], index=exp_idx) for obj in [idx, Series(idx)]: tm.assert_series_equal(obj.value_counts(dropna=False), expected) tm.assert_index_equal(idx.unique(), exp_idx) def test_nonunique_contains(self): # GH 9512 for idx in map(DatetimeIndex, ([0, 1, 0], [0, 0, -1], [0, -1, -1], ['2015', '2015', '2016'], ['2015', '2015', '2014'])): assert idx[0] in idx def test_order(self): # with freq idx1 = DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03'], freq='D', name='idx') idx2 = DatetimeIndex(['2011-01-01 09:00', '2011-01-01 10:00', '2011-01-01 11:00'], freq='H', tz='Asia/Tokyo', name='tzidx') for idx in [idx1, idx2]: ordered = idx.sort_values() tm.assert_index_equal(ordered, idx) assert ordered.freq == idx.freq ordered = idx.sort_values(ascending=False) expected = idx[::-1] tm.assert_index_equal(ordered, expected) assert ordered.freq == expected.freq assert ordered.freq.n == -1 ordered, indexer = idx.sort_values(return_indexer=True) tm.assert_index_equal(ordered, idx) tm.assert_numpy_array_equal(indexer, np.array([0, 1, 2]), check_dtype=False) assert ordered.freq == idx.freq ordered, indexer = idx.sort_values(return_indexer=True, ascending=False) expected = idx[::-1] tm.assert_index_equal(ordered, expected) tm.assert_numpy_array_equal(indexer, np.array([2, 1, 0]), check_dtype=False) assert ordered.freq == expected.freq assert ordered.freq.n == -1 # without freq for tz in self.tz: idx1 = DatetimeIndex(['2011-01-01', '2011-01-03', '2011-01-05', '2011-01-02', '2011-01-01'], tz=tz, name='idx1') exp1 = DatetimeIndex(['2011-01-01', '2011-01-01', '2011-01-02', '2011-01-03', '2011-01-05'], tz=tz, name='idx1') idx2 = DatetimeIndex(['2011-01-01', '2011-01-03', '2011-01-05', '2011-01-02', '2011-01-01'], tz=tz, name='idx2') exp2 = DatetimeIndex(['2011-01-01', '2011-01-01', '2011-01-02', '2011-01-03', '2011-01-05'], tz=tz, name='idx2') idx3 = DatetimeIndex([pd.NaT, '2011-01-03', '2011-01-05', '2011-01-02', pd.NaT], tz=tz, name='idx3') exp3 = DatetimeIndex([pd.NaT, pd.NaT, '2011-01-02', '2011-01-03', '2011-01-05'], tz=tz, name='idx3') for idx, expected in [(idx1, exp1), (idx2, exp2), (idx3, exp3)]: ordered = idx.sort_values() tm.assert_index_equal(ordered, expected) assert ordered.freq is None ordered = idx.sort_values(ascending=False) tm.assert_index_equal(ordered, expected[::-1]) assert ordered.freq is None ordered, indexer = idx.sort_values(return_indexer=True) tm.assert_index_equal(ordered, expected) exp = np.array([0, 4, 3, 1, 2]) tm.assert_numpy_array_equal(indexer, exp, check_dtype=False) assert ordered.freq is None ordered, indexer = idx.sort_values(return_indexer=True, ascending=False) tm.assert_index_equal(ordered, expected[::-1]) exp = np.array([2, 1, 3, 4, 0]) tm.assert_numpy_array_equal(indexer, exp, check_dtype=False) assert ordered.freq is None def test_getitem(self): idx1 = pd.date_range('2011-01-01', '2011-01-31', freq='D', name='idx') idx2 = pd.date_range('2011-01-01', '2011-01-31', freq='D', tz='Asia/Tokyo', name='idx') for idx in [idx1, idx2]: result = idx[0] assert result == Timestamp('2011-01-01', tz=idx.tz) result = idx[0:5] expected = pd.date_range('2011-01-01', '2011-01-05', freq='D', tz=idx.tz, name='idx') tm.assert_index_equal(result, expected) assert result.freq == expected.freq result = idx[0:10:2] expected = pd.date_range('2011-01-01', '2011-01-09', freq='2D', tz=idx.tz, name='idx') tm.assert_index_equal(result, expected) assert result.freq == expected.freq result = idx[-20:-5:3] expected = pd.date_range('2011-01-12', '2011-01-24', freq='3D', tz=idx.tz, name='idx') tm.assert_index_equal(result, expected) assert result.freq == expected.freq result = idx[4::-1] expected = DatetimeIndex(['2011-01-05', '2011-01-04', '2011-01-03', '2011-01-02', '2011-01-01'], freq='-1D', tz=idx.tz, name='idx') tm.assert_index_equal(result, expected) assert result.freq == expected.freq def test_drop_duplicates_metadata(self): # GH 10115 idx = pd.date_range('2011-01-01', '2011-01-31', freq='D', name='idx') result = idx.drop_duplicates() tm.assert_index_equal(idx, result) assert idx.freq == result.freq idx_dup = idx.append(idx) assert idx_dup.freq is None # freq is reset result = idx_dup.drop_duplicates() tm.assert_index_equal(idx, result) assert result.freq is None def test_drop_duplicates(self): # to check Index/Series compat base = pd.date_range('2011-01-01', '2011-01-31', freq='D', name='idx') idx = base.append(base[:5]) res = idx.drop_duplicates() tm.assert_index_equal(res, base) res = Series(idx).drop_duplicates() tm.assert_series_equal(res, Series(base)) res = idx.drop_duplicates(keep='last') exp = base[5:].append(base[:5]) tm.assert_index_equal(res, exp) res = Series(idx).drop_duplicates(keep='last') tm.assert_series_equal(res, Series(exp, index=np.arange(5, 36))) res = idx.drop_duplicates(keep=False) tm.assert_index_equal(res, base[5:]) res = Series(idx).drop_duplicates(keep=False) tm.assert_series_equal(res, Series(base[5:], index=np.arange(5, 31))) def test_take(self): # GH 10295 idx1 = pd.date_range('2011-01-01', '2011-01-31', freq='D', name='idx') idx2 = pd.date_range('2011-01-01', '2011-01-31', freq='D', tz='Asia/Tokyo', name='idx') for idx in [idx1, idx2]: result = idx.take([0]) assert result == Timestamp('2011-01-01', tz=idx.tz) result = idx.take([0, 1, 2]) expected = pd.date_range('2011-01-01', '2011-01-03', freq='D', tz=idx.tz, name='idx') tm.assert_index_equal(result, expected) assert result.freq == expected.freq result = idx.take([0, 2, 4]) expected = pd.date_range('2011-01-01', '2011-01-05', freq='2D', tz=idx.tz, name='idx') tm.assert_index_equal(result, expected) assert result.freq == expected.freq result = idx.take([7, 4, 1]) expected = pd.date_range('2011-01-08', '2011-01-02', freq='-3D', tz=idx.tz, name='idx') tm.assert_index_equal(result, expected) assert result.freq == expected.freq result = idx.take([3, 2, 5]) expected = DatetimeIndex(['2011-01-04', '2011-01-03', '2011-01-06'], freq=None, tz=idx.tz, name='idx') tm.assert_index_equal(result, expected) assert result.freq is None result = idx.take([-3, 2, 5]) expected = DatetimeIndex(['2011-01-29', '2011-01-03', '2011-01-06'], freq=None, tz=idx.tz, name='idx') tm.assert_index_equal(result, expected) assert result.freq is None def test_take_invalid_kwargs(self): idx = pd.date_range('2011-01-01', '2011-01-31', freq='D', name='idx') indices = [1, 6, 5, 9, 10, 13, 15, 3] msg = r"take\(\) got an unexpected keyword argument 'foo'" tm.assert_raises_regex(TypeError, msg, idx.take, indices, foo=2) msg = "the 'out' parameter is not supported" tm.assert_raises_regex(ValueError, msg, idx.take, indices, out=indices) msg = "the 'mode' parameter is not supported" tm.assert_raises_regex(ValueError, msg, idx.take, indices, mode='clip') def test_infer_freq(self): # GH 11018 for freq in ['A', '2A', '-2A', 'Q', '-1Q', 'M', '-1M', 'D', '3D', '-3D', 'W', '-1W', 'H', '2H', '-2H', 'T', '2T', 'S', '-3S']: idx = pd.date_range('2011-01-01 09:00:00', freq=freq, periods=10) result = pd.DatetimeIndex(idx.asi8, freq='infer') tm.assert_index_equal(idx, result) assert result.freq == freq def test_nat_new(self): idx = pd.date_range('2011-01-01', freq='D', periods=5, name='x') result = idx._nat_new() exp = pd.DatetimeIndex([pd.NaT] * 5, name='x') tm.assert_index_equal(result, exp) result = idx._nat_new(box=False) exp = np.array([tslib.iNaT] * 5, dtype=np.int64) tm.assert_numpy_array_equal(result, exp) def test_shift(self): # GH 9903 for tz in self.tz: idx = pd.DatetimeIndex([], name='xxx', tz=tz) tm.assert_index_equal(idx.shift(0, freq='H'), idx) tm.assert_index_equal(idx.shift(3, freq='H'), idx) idx = pd.DatetimeIndex(['2011-01-01 10:00', '2011-01-01 11:00' '2011-01-01 12:00'], name='xxx', tz=tz) tm.assert_index_equal(idx.shift(0, freq='H'), idx) exp = pd.DatetimeIndex(['2011-01-01 13:00', '2011-01-01 14:00' '2011-01-01 15:00'], name='xxx', tz=tz) tm.assert_index_equal(idx.shift(3, freq='H'), exp) exp = pd.DatetimeIndex(['2011-01-01 07:00', '2011-01-01 08:00' '2011-01-01 09:00'], name='xxx', tz=tz) tm.assert_index_equal(idx.shift(-3, freq='H'), exp) def test_nat(self): assert pd.DatetimeIndex._na_value is pd.NaT assert pd.DatetimeIndex([])._na_value is pd.NaT for tz in [None, 'US/Eastern', 'UTC']: idx = pd.DatetimeIndex(['2011-01-01', '2011-01-02'], tz=tz) assert idx._can_hold_na tm.assert_numpy_array_equal(idx._isnan, np.array([False, False])) assert not idx.hasnans tm.assert_numpy_array_equal(idx._nan_idxs, np.array([], dtype=np.intp)) idx = pd.DatetimeIndex(['2011-01-01', 'NaT'], tz=tz) assert idx._can_hold_na tm.assert_numpy_array_equal(idx._isnan, np.array([False, True])) assert idx.hasnans tm.assert_numpy_array_equal(idx._nan_idxs, np.array([1], dtype=np.intp)) def test_equals(self): # GH 13107 for tz in [None, 'UTC', 'US/Eastern', 'Asia/Tokyo']: idx = pd.DatetimeIndex(['2011-01-01', '2011-01-02', 'NaT']) assert idx.equals(idx) assert idx.equals(idx.copy()) assert idx.equals(idx.asobject) assert idx.asobject.equals(idx) assert idx.asobject.equals(idx.asobject) assert not idx.equals(list(idx)) assert not idx.equals(pd.Series(idx)) idx2 = pd.DatetimeIndex(['2011-01-01', '2011-01-02', 'NaT'], tz='US/Pacific') assert not idx.equals(idx2) assert not idx.equals(idx2.copy()) assert not idx.equals(idx2.asobject) assert not idx.asobject.equals(idx2) assert not idx.equals(list(idx2)) assert not idx.equals(pd.Series(idx2)) # same internal, different tz idx3 = pd.DatetimeIndex._simple_new(idx.asi8, tz='US/Pacific') tm.assert_numpy_array_equal(idx.asi8, idx3.asi8) assert not idx.equals(idx3) assert not idx.equals(idx3.copy()) assert not idx.equals(idx3.asobject) assert not idx.asobject.equals(idx3) assert not idx.equals(list(idx3)) assert not idx.equals(pd.Series(idx3)) class TestDateTimeIndexToJulianDate(object): def test_1700(self): r1 = Float64Index([2345897.5, 2345898.5, 2345899.5, 2345900.5, 2345901.5]) r2 = date_range(start=Timestamp('1710-10-01'), periods=5, freq='D').to_julian_date() assert isinstance(r2, Float64Index) tm.assert_index_equal(r1, r2) def test_2000(self): r1 = Float64Index([2451601.5, 2451602.5, 2451603.5, 2451604.5, 2451605.5]) r2 = date_range(start=Timestamp('2000-02-27'), periods=5, freq='D').to_julian_date() assert isinstance(r2, Float64Index) tm.assert_index_equal(r1, r2) def test_hour(self): r1 = Float64Index( [2451601.5, 2451601.5416666666666666, 2451601.5833333333333333, 2451601.625, 2451601.6666666666666666]) r2 = date_range(start=Timestamp('2000-02-27'), periods=5, freq='H').to_julian_date() assert isinstance(r2, Float64Index) tm.assert_index_equal(r1, r2) def test_minute(self): r1 = Float64Index( [2451601.5, 2451601.5006944444444444, 2451601.5013888888888888, 2451601.5020833333333333, 2451601.5027777777777777]) r2 = date_range(start=Timestamp('2000-02-27'), periods=5, freq='T').to_julian_date() assert isinstance(r2, Float64Index)
tm.assert_index_equal(r1, r2)
pandas.util.testing.assert_index_equal
from unittest import TestCase from os import path as os_path import shutil from pandas import DatetimeIndex, DataFrame, Series, Timedelta, infer_freq, \ Timestamp import numpy as np from plotly.graph_objects import Figure from matplotlib.axes import Axes from timeatlas import TimeSeries, Metadata from timeatlas.config.constants import * class TestTimeSeries(TestCase): def setUp(self) -> None: # Create a time indexed series index = DatetimeIndex(['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04']) self.my_data = Series([0.4, 1.0, 0.7, 0.6], index=index).to_frame() # Create metadata my_unit = { "name": "power", "symbol": "W", "data_type": "float" } my_coordinates = { "lat": 46.796611, "lon": 7.147563 } my_dict = { "unit": my_unit, "coordinates": my_coordinates } self.my_metadata = Metadata(my_dict) # self.my_time_series = TimeSeries(self.my_series, self.my_metadata) self.my_time_series = TimeSeries(self.my_data) # Define a target directory self.target_dir = "data/test-export" def test__init__is_instance(self): my_time_series = TimeSeries() self.assertIsInstance(my_time_series, TimeSeries, "The TimeSeries hasn't the right type") def test__init__has_right_types(self): # Add some data index = DatetimeIndex(['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04']) my_series = DataFrame([0.4, 1.0, 0.7, 0.6], index=index) my_metadata = Metadata() my_ts = TimeSeries(my_series, my_metadata) # Check types self.assertIsInstance(my_ts._data, DataFrame, "The TimeSeries series is not a Pandas DataFrame") self.assertIsInstance(my_ts.metadata, Metadata, "The TimeSeries Metadata hasn't got the right type") def test__init__contains_metadata(self): # Add some data index = DatetimeIndex(['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04']) my_series = DataFrame([0.4, 1.0, 0.7, 0.6], index=index) my_metadata = Metadata() my_ts = TimeSeries(my_series, my_metadata) # Check types self.assertNotEqual(my_ts.metadata, None, "The TimeSeries Metadata is probably None") def test__init__has_values_as_column_name(self): index = DatetimeIndex(['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04']) my_series = Series([0.4, 1.0, 0.7, 0.6], index=index) ts = TimeSeries(my_series) self.assertTrue(COMPONENT_VALUES in ts._data.columns) def test__init__wrong_index_type(self): values = Series([0.4, 1.0, 0.7, 0.6]) with self.assertRaises(AssertionError): TimeSeries(values) def test__init__with_Series_input(self): index = DatetimeIndex(['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04']) my_series = Series([0.4, 1.0, 0.7, 0.6], index=index) ts = TimeSeries(my_series) self.assertTrue(COMPONENT_VALUES in ts._data.columns) self.assertIsInstance(ts, TimeSeries) def test__init__with_DataFrame_input_single_column(self): index = DatetimeIndex(['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04']) my_series = Series([0.4, 1.0, 0.7, 0.6], index=index) df = DataFrame(data=my_series) ts = TimeSeries(df) self.assertTrue(COMPONENT_VALUES in ts._data.columns) self.assertIsInstance(ts, TimeSeries) def test__init__with_DataFrame_input_many_columns__without_values(self): index = DatetimeIndex(['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04']) my_series = Series([0.4, 1.0, 0.7, 0.6], index=index) df = DataFrame({"one": my_series, "two": my_series}) with self.assertRaises(AssertionError): ts = TimeSeries(df) def test__init__with_DataFrame_input_many_columns__with_values(self): index = DatetimeIndex(['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04']) my_series = Series([0.4, 1.0, 0.7, 0.6], index=index) df = DataFrame({COMPONENT_VALUES: my_series, "two": my_series}) ts = TimeSeries(df) self.assertIsInstance(ts, TimeSeries) def test__init__freq_is_infered(self): index = DatetimeIndex(['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04']) my_series = Series([0.4, 1.0, 0.7, 0.6], index=index) ts = TimeSeries(my_series) self.assertEqual(
infer_freq(index)
pandas.infer_freq
import os import pytest import pandas as pd import numpy as np from collections import OrderedDict from ..catalog_matching import (crossmatch, select_min_dist, post_k2_clean, find_campaigns, match_k2_epic_campaign, extract_extensions, assign_PMem_mean, merge_k2_info_and_protocol, crossmatch_multiple_catalogs, pick_members_and_produce_k2_search_input, ) ra = 'RAJ2000' dec = 'DEJ2000' def test_pick_members_and_produce_k2_search_input(): #--------------------------------------------------------- # Produce fake data cross = pd.DataFrame(dict(zip(["RAJ2000_1", "DEJ2000_1", "somecolumn", "PMem_1", "PMem_2", "PMem_3"], [[20, 20, 20], [20, 20, 20], ["rolf", "hagen", "busch"], [.1, .8, .9], [.1, .8, .9], [.9, np.nan, .9]], ))) sname, name = "test", "Test" coords = "1" series = cross.loc[2,:] #this row should be preserved in result outfile = ('catalog_matching/matched_catalogs/' 'membership_matches/radec/{}_radec.csv' .format(sname)) #--------------------------------------------------------- # Call function res = pick_members_and_produce_k2_search_input(cross, sname, name, coords=coords) df = pd.read_csv(outfile, header=None) #--------------------------------------------------------- # Check if the RA/Dec file is correct: assert df.loc[0,0] == 20 assert df.loc[0,1] == 20 assert df.shape[0] == 1 assert df.shape[1] == 2 # Remove output file os.remove(outfile) # Check if the DataFrame was processed correctly assert res.shape[0] == 1 # only one member is left assert (res.loc[2,series.index] == series).all() # input columns are preserved def test_crossmatch_multiple_catalogs(): #----------------------------------------------------------- # Create a fake data set diff = 1.49/3600 # 1.5 arcsec distance c1 = pd.DataFrame(dict(zip(["RAJ2000_1","DEJ2000_1","PMem_1"], [[21,20,19],[10,10,10],[.9,.8,.7]]))) c2 = pd.DataFrame(dict(zip(["RAJ2000_2","DEJ2000_2","PMem_2","binary_2"], [[21,20+diff,19+3*diff],[10,10,10], [.75,.85,.3],[.1,.02,.11]]))) c3 = pd.DataFrame(dict(zip(["RAJ2000_3","DEJ2000_3","PMem_3"], [[np.nan,20-diff,19],[10,10,10],[.9,.9,.9]]))) d = {"1":c1, "2":c2, "3":c3} renamed_catalogs = OrderedDict(sorted(d.items(), key=lambda t: t[0])) # order the dicts, not necessary for performance but helpful for testing name = "Test" sname = "test" #----------------------------------------------------------- # Call the function res = crossmatch_multiple_catalogs(renamed_catalogs, name, sname, arcsec=3., plot=True, union=True, bijective=True) #----------------------------------------------------------- # Do some checks # Check that the table size is correct assert res.shape[0] == 5 assert res.shape[1] == 16 # Check that relevant columns are created with the right names/values assert "DEJ2000_1_2_3" in res.columns.tolist() assert set(c1.columns.values).issubset(set(res.columns.values)) assert set(c2.columns.values).issubset(set(res.columns.values)) assert set(c3.columns.values).issubset(set(res.columns.values)) # Check that the distance calculation was done correctly assert res.loc[1, "dist_1_2_3"] == pytest.approx(2.235, rel=.1) assert res.loc[2, "dist_1_2_3"] == 0. # Check that NaNs stay NaNs: assert np.isnan(res.loc[4, "RAJ2000_3"]) # Check individual values and NaNs: assert res.loc[2, "RAJ2000_1_2_3"] == 19. assert (res.DEJ2000_1_2_3.values == 10.).all() assert res.dist_1_2.dropna().shape[0] == 2 assert res.dist_1_2_3.dropna().shape[0] == 2 def test_merge_k2_info_and_protocol(): # Fake data folder = "catalog_matching/tests/exfiles/" sname = "tiny" df =
pd.read_csv('catalog_matching/tests/exfiles/select_min_dist_union_k2.csv')
pandas.read_csv
import numpy as np import pytest from pandas._libs import join as _join from pandas import Categorical, DataFrame, Index, merge import pandas._testing as tm class TestIndexer: @pytest.mark.parametrize( "dtype", ["int32", "int64", "float32", "float64", "object"] ) def test_outer_join_indexer(self, dtype): indexer = _join.outer_join_indexer left = np.arange(3, dtype=dtype) right = np.arange(2, 5, dtype=dtype) empty = np.array([], dtype=dtype) result, lindexer, rindexer = indexer(left, right) assert isinstance(result, np.ndarray) assert isinstance(lindexer, np.ndarray) assert isinstance(rindexer, np.ndarray) tm.assert_numpy_array_equal(result, np.arange(5, dtype=dtype)) exp = np.array([0, 1, 2, -1, -1], dtype=np.int64) tm.assert_numpy_array_equal(lindexer, exp) exp = np.array([-1, -1, 0, 1, 2], dtype=np.int64) tm.assert_numpy_array_equal(rindexer, exp) result, lindexer, rindexer = indexer(empty, right) tm.assert_numpy_array_equal(result, right) exp = np.array([-1, -1, -1], dtype=np.int64) tm.assert_numpy_array_equal(lindexer, exp) exp = np.array([0, 1, 2], dtype=np.int64) tm.assert_numpy_array_equal(rindexer, exp) result, lindexer, rindexer = indexer(left, empty) tm.assert_numpy_array_equal(result, left) exp = np.array([0, 1, 2], dtype=np.int64) tm.assert_numpy_array_equal(lindexer, exp) exp = np.array([-1, -1, -1], dtype=np.int64)
tm.assert_numpy_array_equal(rindexer, exp)
pandas._testing.assert_numpy_array_equal
import pandas as pd import numpy as np from sklearn.impute import SimpleImputer from src.utils.io import load, save def drop_not_relevant(features, targets, days): features = features.iloc[days:] targets = targets.iloc[days:] return features, targets def impute(features): imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean') features_imputed = pd.DataFrame(imp_mean.fit_transform(features), columns=features.columns) return features_imputed def build_timeseries_windows(dataset, target, start_index, end_index, lookback, target_size, step, single_step=True): data = [] labels = [] start_index = start_index + lookback if end_index is None: end_index = min(len(dataset), len(target)) - target_size for i in range(start_index, end_index): indices = range(i-lookback, i, step) data.append(dataset[indices]) if single_step: labels.append(target[i]) else: labels.append(target[i:i+target_size]) return np.array(data), np.array(labels) def scale(data, train_size): data_mean = data[:-train_size].mean(axis=0) data_std = data[:-train_size].std(axis=0) data = (data-data_mean)/data_std return data def train_val_test_split(x, y, test_size, val_size): test_x = x[-test_size:] test_y = y[-test_size:] val_x = x[-(test_size+val_size):-test_size] val_y = y[-(test_size+val_size):-test_size] train_x = x[:-(test_size+val_size)] train_y = y[:-(test_size+val_size)] print(train_x.shape) print(val_x.shape) print(test_x.shape) return train_x, train_y, val_x, val_y, test_x, test_y def check_if_data_valid(dataset, lookback): train_x, train_y, val_x, val_y, test_x, test_y = dataset for data_x, data_y in zip([train_x, val_x, test_x], [train_y, val_y, test_y]): data_x_bin = (data_x >= 0).astype(np.int32) for i in range(0, data_y.shape[0]-lookback): assert data_x_bin[i+lookback, 0, 0] == data_y[i] def build_data(features, targets, lookback=1, test_size=250, val_size=250, encode_binary=True, scaled=True, check_data=True, pct_change=True): name = 'data_lookback_' + str(lookback) future_target = 1 step = 1 if pct_change: targets = pd.DataFrame(targets['Close'].pct_change(), columns=['Close']) else: targets =
pd.DataFrame(targets['Close'], columns=['Close'])
pandas.DataFrame
"""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): df.to_sql("test_timedelta", self.conn) result = sql.read_sql_query("SELECT * FROM test_timedelta", self.conn) tm.assert_series_equal(result["foo"], df["foo"].astype("int64")) def test_complex_raises(self): df = DataFrame({"a": [1 + 1j, 2j]}) msg = "Complex datatypes not supported" with pytest.raises(ValueError, match=msg): df.to_sql("test_complex", self.conn) @pytest.mark.parametrize( "index_name,index_label,expected", [ # no index name, defaults to 'index' (None, None, "index"), # specifying index_label (None, "other_label", "other_label"), # using the index name ("index_name", None, "index_name"), # has index name, but specifying index_label ("index_name", "other_label", "other_label"), # index name is integer (0, None, "0"), # index name is None but index label is integer (None, 0, "0"), ], ) def test_to_sql_index_label(self, index_name, index_label, expected): temp_frame = DataFrame({"col1": range(4)}) temp_frame.index.name = index_name query = "SELECT * FROM test_index_label" sql.to_sql(temp_frame, "test_index_label", self.conn, index_label=index_label) frame = sql.read_sql_query(query, self.conn) assert frame.columns[0] == expected def test_to_sql_index_label_multiindex(self): temp_frame = DataFrame( {"col1": range(4)}, index=MultiIndex.from_product([("A0", "A1"), ("B0", "B1")]), ) # no index name, defaults to 'level_0' and 'level_1' sql.to_sql(temp_frame, "test_index_label", self.conn) frame = sql.read_sql_query("SELECT * FROM test_index_label", self.conn) assert frame.columns[0] == "level_0" assert frame.columns[1] == "level_1" # specifying index_label sql.to_sql( temp_frame, "test_index_label", self.conn, if_exists="replace", index_label=["A", "B"], ) frame = sql.read_sql_query("SELECT * FROM test_index_label", self.conn) assert frame.columns[:2].tolist() == ["A", "B"] # using the index name temp_frame.index.names = ["A", "B"] sql.to_sql(temp_frame, "test_index_label", self.conn, if_exists="replace") frame = sql.read_sql_query("SELECT * FROM test_index_label", self.conn) assert frame.columns[:2].tolist() == ["A", "B"] # has index name, but specifying index_label sql.to_sql( temp_frame, "test_index_label", self.conn, if_exists="replace", index_label=["C", "D"], ) frame = sql.read_sql_query("SELECT * FROM test_index_label", self.conn) assert frame.columns[:2].tolist() == ["C", "D"] msg = "Length of 'index_label' should match number of levels, which is 2" with pytest.raises(ValueError, match=msg): sql.to_sql( temp_frame, "test_index_label", self.conn, if_exists="replace", index_label="C", ) def test_multiindex_roundtrip(self): df = DataFrame.from_records( [(1, 2.1, "line1"), (2, 1.5, "line2")], columns=["A", "B", "C"], index=["A", "B"], ) df.to_sql("test_multiindex_roundtrip", self.conn) result = sql.read_sql_query( "SELECT * FROM test_multiindex_roundtrip", self.conn, index_col=["A", "B"] ) tm.assert_frame_equal(df, result, check_index_type=True) def test_integer_col_names(self): df = DataFrame([[1, 2], [3, 4]], columns=[0, 1]) sql.to_sql(df, "test_frame_integer_col_names", self.conn, if_exists="replace") def test_get_schema(self): create_sql = sql.get_schema(self.test_frame1, "test", con=self.conn) assert "CREATE" in create_sql def test_get_schema_dtypes(self): float_frame = DataFrame({"a": [1.1, 1.2], "b": [2.1, 2.2]}) dtype = sqlalchemy.Integer if self.mode == "sqlalchemy" else "INTEGER" create_sql = sql.get_schema( float_frame, "test", con=self.conn, dtype={"b": dtype} ) assert "CREATE" in create_sql assert "INTEGER" in create_sql def test_get_schema_keys(self): frame = DataFrame({"Col1": [1.1, 1.2], "Col2": [2.1, 2.2]}) create_sql = sql.get_schema(frame, "test", con=self.conn, keys="Col1") constraint_sentence = 'CONSTRAINT test_pk PRIMARY KEY ("Col1")' assert constraint_sentence in create_sql # multiple columns as key (GH10385) create_sql = sql.get_schema( self.test_frame1, "test", con=self.conn, keys=["A", "B"] ) constraint_sentence = 'CONSTRAINT test_pk PRIMARY KEY ("A", "B")' assert constraint_sentence in create_sql def test_chunksize_read(self): df = DataFrame(np.random.randn(22, 5), columns=list("abcde")) df.to_sql("test_chunksize", self.conn, index=False) # reading the query in one time res1 = sql.read_sql_query("select * from test_chunksize", self.conn) # reading the query in chunks with read_sql_query res2 = DataFrame() i = 0 sizes = [5, 5, 5, 5, 2] for chunk in sql.read_sql_query( "select * from test_chunksize", self.conn, chunksize=5 ): res2 = concat([res2, chunk], ignore_index=True) assert len(chunk) == sizes[i] i += 1 tm.assert_frame_equal(res1, res2) # reading the query in chunks with read_sql_query if self.mode == "sqlalchemy": res3 = DataFrame() i = 0 sizes = [5, 5, 5, 5, 2] for chunk in sql.read_sql_table("test_chunksize", self.conn, chunksize=5): res3 = concat([res3, chunk], ignore_index=True) assert len(chunk) == sizes[i] i += 1 tm.assert_frame_equal(res1, res3) def test_categorical(self): # GH8624 # test that categorical gets written correctly as dense column df = DataFrame( { "person_id": [1, 2, 3], "person_name": ["<NAME>", "<NAME>", "<NAME>"], } ) df2 = df.copy() df2["person_name"] = df2["person_name"].astype("category") df2.to_sql("test_categorical", self.conn, index=False) res = sql.read_sql_query("SELECT * FROM test_categorical", self.conn) tm.assert_frame_equal(res, df) def test_unicode_column_name(self): # GH 11431 df = DataFrame([[1, 2], [3, 4]], columns=["\xe9", "b"]) df.to_sql("test_unicode", self.conn, index=False) def test_escaped_table_name(self): # GH 13206 df = DataFrame({"A": [0, 1, 2], "B": [0.2, np.nan, 5.6]}) df.to_sql("d1187b08-4943-4c8d-a7f6", self.conn, index=False) res = sql.read_sql_query("SELECT * FROM `d1187b08-4943-4c8d-a7f6`", self.conn) tm.assert_frame_equal(res, df) @pytest.mark.single @pytest.mark.skipif(not SQLALCHEMY_INSTALLED, reason="SQLAlchemy not installed") class TestSQLApi(SQLAlchemyMixIn, _TestSQLApi): """ Test the public API as it would be used directly Tests for `read_sql_table` are included here, as this is specific for the sqlalchemy mode. """ flavor = "sqlite" mode = "sqlalchemy" def connect(self): return sqlalchemy.create_engine("sqlite:///:memory:") def test_read_table_columns(self): # test columns argument in read_table sql.to_sql(self.test_frame1, "test_frame", self.conn) cols = ["A", "B"] result = sql.read_sql_table("test_frame", self.conn, columns=cols) assert result.columns.tolist() == cols def test_read_table_index_col(self): # test columns argument in read_table sql.to_sql(self.test_frame1, "test_frame", self.conn) result = sql.read_sql_table("test_frame", self.conn, index_col="index") assert result.index.names == ["index"] result = sql.read_sql_table("test_frame", self.conn, index_col=["A", "B"]) assert result.index.names == ["A", "B"] result = sql.read_sql_table( "test_frame", self.conn, index_col=["A", "B"], columns=["C", "D"] ) assert result.index.names == ["A", "B"] assert result.columns.tolist() == ["C", "D"] def test_read_sql_delegate(self): iris_frame1 = sql.read_sql_query("SELECT * FROM iris", self.conn) iris_frame2 = sql.read_sql("SELECT * FROM iris", self.conn) tm.assert_frame_equal(iris_frame1, iris_frame2) iris_frame1 = sql.read_sql_table("iris", self.conn) iris_frame2 = sql.read_sql("iris", self.conn) tm.assert_frame_equal(iris_frame1, iris_frame2) def test_not_reflect_all_tables(self): # create invalid table qry = """CREATE TABLE invalid (x INTEGER, y UNKNOWN);""" self.conn.execute(qry) qry = """CREATE TABLE other_table (x INTEGER, y INTEGER);""" self.conn.execute(qry) with warnings.catch_warnings(record=True) as w: # Cause all warnings to always be triggered. warnings.simplefilter("always") # Trigger a warning. sql.read_sql_table("other_table", self.conn) sql.read_sql_query("SELECT * FROM other_table", self.conn) # Verify some things assert len(w) == 0 def test_warning_case_insensitive_table_name(self): # see gh-7815 # # We can't test that this warning is triggered, a the database # configuration would have to be altered. But here we test that # the warning is certainly NOT triggered in a normal case. with warnings.catch_warnings(record=True) as w: # Cause all warnings to always be triggered. warnings.simplefilter("always") # This should not trigger a Warning self.test_frame1.to_sql("CaseSensitive", self.conn) # Verify some things assert len(w) == 0 def _get_index_columns(self, tbl_name): from sqlalchemy.engine import reflection insp = reflection.Inspector.from_engine(self.conn) ixs = insp.get_indexes("test_index_saved") ixs = [i["column_names"] for i in ixs] return ixs def test_sqlalchemy_type_mapping(self): # Test Timestamp objects (no datetime64 because of timezone) (GH9085) df = DataFrame( {"time": to_datetime(["201412120154", "201412110254"], utc=True)} ) db = sql.SQLDatabase(self.conn) table = sql.SQLTable("test_type", db, frame=df) # GH 9086: TIMESTAMP is the suggested type for datetimes with timezones assert isinstance(table.table.c["time"].type, sqltypes.TIMESTAMP) def test_database_uri_string(self): # Test read_sql and .to_sql method with a database URI (GH10654) test_frame1 = self.test_frame1 # db_uri = 'sqlite:///:memory:' # raises # sqlalchemy.exc.OperationalError: (sqlite3.OperationalError) near # "iris": syntax error [SQL: 'iris'] with tm.ensure_clean() as name: db_uri = "sqlite:///" + name table = "iris" test_frame1.to_sql(table, db_uri, if_exists="replace", index=False) test_frame2 = sql.read_sql(table, db_uri) test_frame3 = sql.read_sql_table(table, db_uri) query = "SELECT * FROM iris" test_frame4 = sql.read_sql_query(query, db_uri) tm.assert_frame_equal(test_frame1, test_frame2) tm.assert_frame_equal(test_frame1, test_frame3) tm.assert_frame_equal(test_frame1, test_frame4) # using driver that will not be installed on Travis to trigger error # in sqlalchemy.create_engine -> test passing of this error to user try: # the rest of this test depends on pg8000's being absent import pg8000 # noqa pytest.skip("pg8000 is installed") except ImportError: pass db_uri = "postgresql+pg8000://user:pass@host/dbname" with pytest.raises(ImportError, match="pg8000"): sql.read_sql("select * from table", db_uri) def _make_iris_table_metadata(self): sa = sqlalchemy metadata = sa.MetaData() iris = sa.Table( "iris", metadata, sa.Column("SepalLength", sa.REAL), sa.Column("SepalWidth", sa.REAL), sa.Column("PetalLength", sa.REAL), sa.Column("PetalWidth", sa.REAL), sa.Column("Name", sa.TEXT), ) return iris def test_query_by_text_obj(self): # WIP : GH10846 name_text = sqlalchemy.text("select * from iris where name=:name") iris_df = sql.read_sql(name_text, self.conn, params={"name": "Iris-versicolor"}) all_names = set(iris_df["Name"]) assert all_names == {"Iris-versicolor"} def test_query_by_select_obj(self): # WIP : GH10846 iris = self._make_iris_table_metadata() name_select = sqlalchemy.select([iris]).where( iris.c.Name == sqlalchemy.bindparam("name") ) iris_df = sql.read_sql(name_select, self.conn, params={"name": "Iris-setosa"}) all_names = set(iris_df["Name"]) assert all_names == {"Iris-setosa"} class _EngineToConnMixin: """ A mixin that causes setup_connect to create a conn rather than an engine. """ @pytest.fixture(autouse=True) def setup_method(self, load_iris_data): super().load_test_data_and_sql() engine = self.conn conn = engine.connect() self.__tx = conn.begin() self.pandasSQL = sql.SQLDatabase(conn) self.__engine = engine self.conn = conn yield self.__tx.rollback() self.conn.close() self.conn = self.__engine self.pandasSQL = sql.SQLDatabase(self.__engine) # XXX: # super().teardown_method(method) @pytest.mark.single class TestSQLApiConn(_EngineToConnMixin, TestSQLApi): pass @pytest.mark.single class TestSQLiteFallbackApi(SQLiteMixIn, _TestSQLApi): """ Test the public sqlite connection fallback API """ flavor = "sqlite" mode = "fallback" def connect(self, database=":memory:"): return sqlite3.connect(database) def test_sql_open_close(self): # Test if the IO in the database still work if the connection closed # between the writing and reading (as in many real situations). with tm.ensure_clean() as name: conn = self.connect(name) sql.to_sql(self.test_frame3, "test_frame3_legacy", conn, index=False) conn.close() conn = self.connect(name) result = sql.read_sql_query("SELECT * FROM test_frame3_legacy;", conn) conn.close() tm.assert_frame_equal(self.test_frame3, result) @pytest.mark.skipif(SQLALCHEMY_INSTALLED, reason="SQLAlchemy is installed") def test_con_string_import_error(self): conn = "mysql://root@localhost/pandas_nosetest" msg = "Using URI string without sqlalchemy installed" with pytest.raises(ImportError, match=msg): sql.read_sql("SELECT * FROM iris", conn) def test_read_sql_delegate(self): iris_frame1 = sql.read_sql_query("SELECT * FROM iris", self.conn) iris_frame2 = sql.read_sql("SELECT * FROM iris", self.conn) tm.assert_frame_equal(iris_frame1, iris_frame2) msg = "Execution failed on sql 'iris': near \"iris\": syntax error" with pytest.raises(sql.DatabaseError, match=msg): sql.read_sql("iris", self.conn) def test_safe_names_warning(self): # GH 6798 df = DataFrame([[1, 2], [3, 4]], columns=["a", "b "]) # has a space # warns on create table with spaces in names with tm.assert_produces_warning(): sql.to_sql(df, "test_frame3_legacy", self.conn, index=False) def test_get_schema2(self): # without providing a connection object (available for backwards comp) create_sql = sql.get_schema(self.test_frame1, "test") assert "CREATE" in create_sql def _get_sqlite_column_type(self, schema, column): for col in schema.split("\n"): if col.split()[0].strip('""') == column: return col.split()[1] raise ValueError(f"Column {column} not found") def test_sqlite_type_mapping(self): # Test Timestamp objects (no datetime64 because of timezone) (GH9085) df = DataFrame( {"time": to_datetime(["201412120154", "201412110254"], utc=True)} ) db = sql.SQLiteDatabase(self.conn) table = sql.SQLiteTable("test_type", db, frame=df) schema = table.sql_schema() assert self._get_sqlite_column_type(schema, "time") == "TIMESTAMP" # ----------------------------------------------------------------------------- # -- Database flavor specific tests class _TestSQLAlchemy(SQLAlchemyMixIn, PandasSQLTest): """ Base class for testing the sqlalchemy backend. Subclasses for specific database types are created below. Tests that deviate for each flavor are overwritten there. """ flavor: str @pytest.fixture(autouse=True, scope="class") def setup_class(cls): cls.setup_import() cls.setup_driver() conn = cls.connect() conn.connect() def load_test_data_and_sql(self): self._load_raw_sql() self._load_test1_data() @pytest.fixture(autouse=True) def setup_method(self, load_iris_data): self.load_test_data_and_sql() @classmethod def setup_import(cls): # Skip this test if SQLAlchemy not available if not SQLALCHEMY_INSTALLED: pytest.skip("SQLAlchemy not installed") @classmethod def setup_driver(cls): raise NotImplementedError() @classmethod def connect(cls): raise NotImplementedError() def setup_connect(self): try: self.conn = self.connect() self.pandasSQL = sql.SQLDatabase(self.conn) # to test if connection can be made: self.conn.connect() except sqlalchemy.exc.OperationalError: pytest.skip(f"Can't connect to {self.flavor} server") def test_read_sql(self): self._read_sql_iris() def test_read_sql_parameter(self): self._read_sql_iris_parameter() def test_read_sql_named_parameter(self): self._read_sql_iris_named_parameter() def test_to_sql(self): self._to_sql() def test_to_sql_empty(self): self._to_sql_empty() def test_to_sql_fail(self): self._to_sql_fail() def test_to_sql_replace(self): self._to_sql_replace() def test_to_sql_append(self): self._to_sql_append() def test_to_sql_method_multi(self): self._to_sql(method="multi") def test_to_sql_method_callable(self): self._to_sql_method_callable() def test_create_table(self): temp_conn = self.connect() temp_frame = DataFrame( {"one": [1.0, 2.0, 3.0, 4.0], "two": [4.0, 3.0, 2.0, 1.0]} ) pandasSQL = sql.SQLDatabase(temp_conn) pandasSQL.to_sql(temp_frame, "temp_frame") assert temp_conn.has_table("temp_frame") def test_drop_table(self): temp_conn = self.connect() temp_frame = DataFrame( {"one": [1.0, 2.0, 3.0, 4.0], "two": [4.0, 3.0, 2.0, 1.0]} ) pandasSQL = sql.SQLDatabase(temp_conn) pandasSQL.to_sql(temp_frame, "temp_frame") assert temp_conn.has_table("temp_frame") pandasSQL.drop_table("temp_frame") assert not temp_conn.has_table("temp_frame") def test_roundtrip(self): self._roundtrip() def test_execute_sql(self): self._execute_sql() def test_read_table(self): iris_frame = sql.read_sql_table("iris", con=self.conn) self._check_iris_loaded_frame(iris_frame) def test_read_table_columns(self): iris_frame = sql.read_sql_table( "iris", con=self.conn, columns=["SepalLength", "SepalLength"] ) tm.equalContents(iris_frame.columns.values, ["SepalLength", "SepalLength"]) def test_read_table_absent_raises(self): msg = "Table this_doesnt_exist not found" with pytest.raises(ValueError, match=msg): sql.read_sql_table("this_doesnt_exist", con=self.conn) def test_default_type_conversion(self): df = sql.read_sql_table("types_test_data", self.conn) assert issubclass(df.FloatCol.dtype.type, np.floating) assert issubclass(df.IntCol.dtype.type, np.integer) assert issubclass(df.BoolCol.dtype.type, np.bool_) # Int column with NA values stays as float assert issubclass(df.IntColWithNull.dtype.type, np.floating) # Bool column with NA values becomes object assert issubclass(df.BoolColWithNull.dtype.type, np.object) def test_bigint(self): # int64 should be converted to BigInteger, GH7433 df = DataFrame(data={"i64": [2 ** 62]}) df.to_sql("test_bigint", self.conn, index=False) result = sql.read_sql_table("test_bigint", self.conn) tm.assert_frame_equal(df, result) def test_default_date_load(self): df = sql.read_sql_table("types_test_data", self.conn) # IMPORTANT - sqlite has no native date type, so shouldn't parse, but # MySQL SHOULD be converted. assert issubclass(df.DateCol.dtype.type, np.datetime64) def test_datetime_with_timezone(self): # edge case that converts postgresql datetime with time zone types # to datetime64[ns,psycopg2.tz.FixedOffsetTimezone..], which is ok # but should be more natural, so coerce to datetime64[ns] for now def check(col): # check that a column is either datetime64[ns] # or datetime64[ns, UTC] if is_datetime64_dtype(col.dtype): # "2000-01-01 00:00:00-08:00" should convert to # "2000-01-01 08:00:00" assert col[0] == Timestamp("2000-01-01 08:00:00") # "2000-06-01 00:00:00-07:00" should convert to # "2000-06-01 07:00:00" assert col[1] == Timestamp("2000-06-01 07:00:00") elif is_datetime64tz_dtype(col.dtype): assert str(col.dt.tz) == "UTC" # "2000-01-01 00:00:00-08:00" should convert to # "2000-01-01 08:00:00" # "2000-06-01 00:00:00-07:00" should convert to # "2000-06-01 07:00:00" # GH 6415 expected_data = [ Timestamp("2000-01-01 08:00:00", tz="UTC"), Timestamp("2000-06-01 07:00:00", tz="UTC"), ] expected = Series(expected_data, name=col.name) tm.assert_series_equal(col, expected) else: raise AssertionError( f"DateCol loaded with incorrect type -> {col.dtype}" ) # GH11216 df = pd.read_sql_query("select * from types_test_data", self.conn) if not hasattr(df, "DateColWithTz"): pytest.skip("no column with datetime with time zone") # this is parsed on Travis (linux), but not on macosx for some reason # even with the same versions of psycopg2 & sqlalchemy, possibly a # Postgresql server version difference col = df.DateColWithTz assert is_datetime64tz_dtype(col.dtype) df = pd.read_sql_query( "select * from types_test_data", self.conn, parse_dates=["DateColWithTz"] ) if not hasattr(df, "DateColWithTz"): pytest.skip("no column with datetime with time zone") col = df.DateColWithTz assert is_datetime64tz_dtype(col.dtype) assert str(col.dt.tz) == "UTC" check(df.DateColWithTz) df = pd.concat( list( pd.read_sql_query( "select * from types_test_data", self.conn, chunksize=1 ) ), ignore_index=True, ) col = df.DateColWithTz assert is_datetime64tz_dtype(col.dtype) assert str(col.dt.tz) == "UTC" expected = sql.read_sql_table("types_test_data", self.conn) col = expected.DateColWithTz assert is_datetime64tz_dtype(col.dtype) tm.assert_series_equal(df.DateColWithTz, expected.DateColWithTz) # xref #7139 # this might or might not be converted depending on the postgres driver df = sql.read_sql_table("types_test_data", self.conn) check(df.DateColWithTz) def test_datetime_with_timezone_roundtrip(self): # GH 9086 # Write datetimetz data to a db and read it back # For dbs that support timestamps with timezones, should get back UTC # otherwise naive data should be returned expected = DataFrame( {"A": date_range("2013-01-01 09:00:00", periods=3, tz="US/Pacific")} ) expected.to_sql("test_datetime_tz", self.conn, index=False) if self.flavor == "postgresql": # SQLAlchemy "timezones" (i.e. offsets) are coerced to UTC expected["A"] = expected["A"].dt.tz_convert("UTC") else: # Otherwise, timestamps are returned as local, naive expected["A"] = expected["A"].dt.tz_localize(None) result = sql.read_sql_table("test_datetime_tz", self.conn) tm.assert_frame_equal(result, expected) result = sql.read_sql_query("SELECT * FROM test_datetime_tz", self.conn) if self.flavor == "sqlite": # read_sql_query does not return datetime type like read_sql_table assert isinstance(result.loc[0, "A"], str) result["A"] = to_datetime(result["A"]) tm.assert_frame_equal(result, expected) def test_naive_datetimeindex_roundtrip(self): # GH 23510 # Ensure that a naive DatetimeIndex isn't converted to UTC dates = date_range("2018-01-01", periods=5, freq="6H") expected = DataFrame({"nums": range(5)}, index=dates) expected.to_sql("foo_table", self.conn, index_label="info_date") result = sql.read_sql_table("foo_table", self.conn, index_col="info_date") # result index with gain a name from a set_index operation; expected tm.assert_frame_equal(result, expected, check_names=False) def test_date_parsing(self): # No Parsing df = sql.read_sql_table("types_test_data", self.conn) expected_type = object if self.flavor == "sqlite" else np.datetime64 assert issubclass(df.DateCol.dtype.type, expected_type) df = sql.read_sql_table("types_test_data", self.conn, parse_dates=["DateCol"]) assert issubclass(df.DateCol.dtype.type, np.datetime64) df = sql.read_sql_table( "types_test_data", self.conn, parse_dates={"DateCol": "%Y-%m-%d %H:%M:%S"} ) assert issubclass(df.DateCol.dtype.type, np.datetime64) df = sql.read_sql_table( "types_test_data", self.conn, parse_dates={"DateCol": {"format": "%Y-%m-%d %H:%M:%S"}}, ) assert issubclass(df.DateCol.dtype.type, np.datetime64) df = sql.read_sql_table( "types_test_data", self.conn, parse_dates=["IntDateCol"] ) assert issubclass(df.IntDateCol.dtype.type, np.datetime64) df = sql.read_sql_table( "types_test_data", self.conn, parse_dates={"IntDateCol": "s"} ) assert issubclass(df.IntDateCol.dtype.type, np.datetime64) df = sql.read_sql_table( "types_test_data", self.conn, parse_dates={"IntDateCol": {"unit": "s"}} ) assert issubclass(df.IntDateCol.dtype.type, np.datetime64) def test_datetime(self): df = DataFrame( {"A": date_range("2013-01-01 09:00:00", periods=3), "B": np.arange(3.0)} ) df.to_sql("test_datetime", self.conn) # with read_table -> type information from schema used result = sql.read_sql_table("test_datetime", self.conn) result = result.drop("index", axis=1) tm.assert_frame_equal(result, df) # with read_sql -> no type information -> sqlite has no native result = sql.read_sql_query("SELECT * FROM test_datetime", self.conn) result = result.drop("index", axis=1) if self.flavor == "sqlite": assert isinstance(result.loc[0, "A"], str) result["A"] = to_datetime(result["A"]) tm.assert_frame_equal(result, df) else: tm.assert_frame_equal(result, df) def test_datetime_NaT(self): df = DataFrame( {"A": date_range("2013-01-01 09:00:00", periods=3), "B": np.arange(3.0)} ) df.loc[1, "A"] = np.nan df.to_sql("test_datetime", self.conn, index=False) # with read_table -> type information from schema used result = sql.read_sql_table("test_datetime", self.conn) tm.assert_frame_equal(result, df) # with read_sql -> no type information -> sqlite has no native result = sql.read_sql_query("SELECT * FROM test_datetime", self.conn) if self.flavor == "sqlite": assert isinstance(result.loc[0, "A"], str) result["A"] = to_datetime(result["A"], errors="coerce") tm.assert_frame_equal(result, df) else: tm.assert_frame_equal(result, df) def test_datetime_date(self): # test support for datetime.date df = DataFrame([date(2014, 1, 1), date(2014, 1, 2)], columns=["a"]) df.to_sql("test_date", self.conn, index=False) res = read_sql_table("test_date", self.conn) result = res["a"] expected = to_datetime(df["a"]) # comes back as datetime64 tm.assert_series_equal(result, expected) def test_datetime_time(self): # test support for datetime.time df = DataFrame([time(9, 0, 0), time(9, 1, 30)], columns=["a"]) df.to_sql("test_time", self.conn, index=False) res = read_sql_table("test_time", self.conn) tm.assert_frame_equal(res, df) # GH8341 # first, use the fallback to have the sqlite adapter put in place sqlite_conn = TestSQLiteFallback.connect() sql.to_sql(df, "test_time2", sqlite_conn, index=False) res = sql.read_sql_query("SELECT * FROM test_time2", sqlite_conn) ref = df.applymap(lambda _: _.strftime("%H:%M:%S.%f")) tm.assert_frame_equal(ref, res) # check if adapter is in place # then test if sqlalchemy is unaffected by the sqlite adapter sql.to_sql(df, "test_time3", self.conn, index=False) if self.flavor == "sqlite": res = sql.read_sql_query("SELECT * FROM test_time3", self.conn) ref = df.applymap(lambda _: _.strftime("%H:%M:%S.%f")) tm.assert_frame_equal(ref, res) res = sql.read_sql_table("test_time3", self.conn) tm.assert_frame_equal(df, res) def test_mixed_dtype_insert(self): # see GH6509 s1 = Series(2 ** 25 + 1, dtype=np.int32) s2 = Series(0.0, dtype=np.float32) df = DataFrame({"s1": s1, "s2": s2}) # write and read again df.to_sql("test_read_write", self.conn, index=False) df2 = sql.read_sql_table("test_read_write", self.conn) tm.assert_frame_equal(df, df2, check_dtype=False, check_exact=True) def test_nan_numeric(self): # NaNs in numeric float column df = DataFrame({"A": [0, 1, 2], "B": [0.2, np.nan, 5.6]}) df.to_sql("test_nan", self.conn, index=False) # with read_table result = sql.read_sql_table("test_nan", self.conn) tm.assert_frame_equal(result, df) # with read_sql result = sql.read_sql_query("SELECT * FROM test_nan", self.conn) tm.assert_frame_equal(result, df) def test_nan_fullcolumn(self): # full NaN column (numeric float column) df = DataFrame({"A": [0, 1, 2], "B": [np.nan, np.nan, np.nan]}) df.to_sql("test_nan", self.conn, index=False) # with read_table result = sql.read_sql_table("test_nan", self.conn) tm.assert_frame_equal(result, df) # with read_sql -> not type info from table -> stays None df["B"] = df["B"].astype("object") df["B"] = None result = sql.read_sql_query("SELECT * FROM test_nan", self.conn) tm.assert_frame_equal(result, df) def test_nan_string(self): # NaNs in string column df = DataFrame({"A": [0, 1, 2], "B": ["a", "b", np.nan]}) df.to_sql("test_nan", self.conn, index=False) # NaNs are coming back as None df.loc[2, "B"] = None # with read_table result = sql.read_sql_table("test_nan", self.conn) tm.assert_frame_equal(result, df) # with read_sql result = sql.read_sql_query("SELECT * FROM test_nan", self.conn) tm.assert_frame_equal(result, df) def _get_index_columns(self, tbl_name): from sqlalchemy.engine import reflection insp = reflection.Inspector.from_engine(self.conn) ixs = insp.get_indexes(tbl_name) ixs = [i["column_names"] for i in ixs] return ixs def test_to_sql_save_index(self): self._to_sql_save_index() def test_transactions(self): self._transaction_test() def test_get_schema_create_table(self): # Use a dataframe without a bool column, since MySQL converts bool to # TINYINT (which read_sql_table returns as an int and causes a dtype # mismatch) self._load_test3_data() tbl = "test_get_schema_create_table" create_sql = sql.get_schema(self.test_frame3, tbl, con=self.conn) blank_test_df = self.test_frame3.iloc[:0] self.drop_table(tbl) self.conn.execute(create_sql) returned_df = sql.read_sql_table(tbl, self.conn) tm.assert_frame_equal(returned_df, blank_test_df, check_index_type=False) self.drop_table(tbl) def test_dtype(self): cols = ["A", "B"] data = [(0.8, True), (0.9, None)] df = DataFrame(data, columns=cols) df.to_sql("dtype_test", self.conn) df.to_sql("dtype_test2", self.conn, dtype={"B": sqlalchemy.TEXT}) meta = sqlalchemy.schema.MetaData(bind=self.conn) meta.reflect() sqltype = meta.tables["dtype_test2"].columns["B"].type assert isinstance(sqltype, sqlalchemy.TEXT) msg = "The type of B is not a SQLAlchemy type" with pytest.raises(ValueError, match=msg): df.to_sql("error", self.conn, dtype={"B": str}) # GH9083 df.to_sql("dtype_test3", self.conn, dtype={"B": sqlalchemy.String(10)}) meta.reflect() sqltype = meta.tables["dtype_test3"].columns["B"].type assert isinstance(sqltype, sqlalchemy.String) assert sqltype.length == 10 # single dtype df.to_sql("single_dtype_test", self.conn, dtype=sqlalchemy.TEXT) meta = sqlalchemy.schema.MetaData(bind=self.conn) meta.reflect() sqltypea = meta.tables["single_dtype_test"].columns["A"].type sqltypeb = meta.tables["single_dtype_test"].columns["B"].type assert isinstance(sqltypea, sqlalchemy.TEXT) assert isinstance(sqltypeb, sqlalchemy.TEXT) def test_notna_dtype(self): cols = { "Bool": Series([True, None]), "Date": Series([datetime(2012, 5, 1), None]), "Int": Series([1, None], dtype="object"), "Float": Series([1.1, None]), } df = DataFrame(cols) tbl = "notna_dtype_test" df.to_sql(tbl, self.conn) returned_df = sql.read_sql_table(tbl, self.conn) # noqa meta = sqlalchemy.schema.MetaData(bind=self.conn) meta.reflect() if self.flavor == "mysql": my_type = sqltypes.Integer else: my_type = sqltypes.Boolean col_dict = meta.tables[tbl].columns assert isinstance(col_dict["Bool"].type, my_type) assert isinstance(col_dict["Date"].type, sqltypes.DateTime) assert isinstance(col_dict["Int"].type, sqltypes.Integer) assert isinstance(col_dict["Float"].type, sqltypes.Float) def test_double_precision(self): V = 1.23456789101112131415 df = DataFrame( { "f32": Series([V], dtype="float32"), "f64": Series([V], dtype="float64"), "f64_as_f32": Series([V], dtype="float64"), "i32": Series([5], dtype="int32"), "i64": Series([5], dtype="int64"), } ) df.to_sql( "test_dtypes", self.conn, index=False, if_exists="replace", dtype={"f64_as_f32": sqlalchemy.Float(precision=23)}, ) res = sql.read_sql_table("test_dtypes", self.conn) # check precision of float64 assert np.round(df["f64"].iloc[0], 14) == np.round(res["f64"].iloc[0], 14) # check sql types meta = sqlalchemy.schema.MetaData(bind=self.conn) meta.reflect() col_dict = meta.tables["test_dtypes"].columns assert str(col_dict["f32"].type) == str(col_dict["f64_as_f32"].type) assert isinstance(col_dict["f32"].type, sqltypes.Float) assert isinstance(col_dict["f64"].type, sqltypes.Float) assert isinstance(col_dict["i32"].type, sqltypes.Integer) assert isinstance(col_dict["i64"].type, sqltypes.BigInteger) def test_connectable_issue_example(self): # This tests the example raised in issue # https://github.com/pandas-dev/pandas/issues/10104 def foo(connection): query = "SELECT test_foo_data FROM test_foo_data" return sql.read_sql_query(query, con=connection) def bar(connection, data): data.to_sql(name="test_foo_data", con=connection, if_exists="append") def main(connectable): with connectable.connect() as conn: with conn.begin(): foo_data = conn.run_callable(foo) conn.run_callable(bar, foo_data) DataFrame({"test_foo_data": [0, 1, 2]}).to_sql("test_foo_data", self.conn) main(self.conn) def test_temporary_table(self): test_data = "Hello, World!" expected = DataFrame({"spam": [test_data]}) Base = declarative.declarative_base() class Temporary(Base): __tablename__ = "temp_test" __table_args__ = {"prefixes": ["TEMPORARY"]} id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True) spam = sqlalchemy.Column(sqlalchemy.Unicode(30), nullable=False) Session = sa_session.sessionmaker(bind=self.conn) session = Session() with session.transaction: conn = session.connection() Temporary.__table__.create(conn) session.add(Temporary(spam=test_data)) session.flush() df = sql.read_sql_query(sql=sqlalchemy.select([Temporary.spam]), con=conn) tm.assert_frame_equal(df, expected) class _TestSQLAlchemyConn(_EngineToConnMixin, _TestSQLAlchemy): def test_transactions(self): pytest.skip("Nested transactions rollbacks don't work with Pandas") class _TestSQLiteAlchemy: """ Test the sqlalchemy backend against an in-memory sqlite database. """ flavor = "sqlite" @classmethod def connect(cls): return sqlalchemy.create_engine("sqlite:///:memory:") @classmethod def setup_driver(cls): # sqlite3 is built-in cls.driver = None def test_default_type_conversion(self): df = sql.read_sql_table("types_test_data", self.conn) assert issubclass(df.FloatCol.dtype.type, np.floating) assert issubclass(df.IntCol.dtype.type, np.integer) # sqlite has no boolean type, so integer type is returned assert issubclass(df.BoolCol.dtype.type, np.integer) # Int column with NA values stays as float assert issubclass(df.IntColWithNull.dtype.type, np.floating) # Non-native Bool column with NA values stays as float assert issubclass(df.BoolColWithNull.dtype.type, np.floating) def test_default_date_load(self): df = sql.read_sql_table("types_test_data", self.conn) # IMPORTANT - sqlite has no native date type, so shouldn't parse, but assert not issubclass(df.DateCol.dtype.type, np.datetime64) def test_bigint_warning(self): # test no warning for BIGINT (to support int64) is raised (GH7433) df = DataFrame({"a": [1, 2]}, dtype="int64") df.to_sql("test_bigintwarning", self.conn, index=False) with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") sql.read_sql_table("test_bigintwarning", self.conn) assert len(w) == 0 class _TestMySQLAlchemy: """ Test the sqlalchemy backend against an MySQL database. """ flavor = "mysql" @classmethod def connect(cls): url = "mysql+{driver}://root@localhost/pandas_nosetest" return sqlalchemy.create_engine( url.format(driver=cls.driver), connect_args=cls.connect_args ) @classmethod def setup_driver(cls): pymysql = pytest.importorskip("pymysql") cls.driver = "pymysql" cls.connect_args = {"client_flag": pymysql.constants.CLIENT.MULTI_STATEMENTS} def test_default_type_conversion(self): df = sql.read_sql_table("types_test_data", self.conn) assert issubclass(df.FloatCol.dtype.type, np.floating) assert issubclass(df.IntCol.dtype.type, np.integer) # MySQL has no real BOOL type (it's an alias for TINYINT) assert issubclass(df.BoolCol.dtype.type, np.integer) # Int column with NA values stays as float assert issubclass(df.IntColWithNull.dtype.type, np.floating) # Bool column with NA = int column with NA values => becomes float assert issubclass(df.BoolColWithNull.dtype.type, np.floating) def test_read_procedure(self): import pymysql # see GH7324. Although it is more an api test, it is added to the # mysql tests as sqlite does not have stored procedures df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3]}) df.to_sql("test_procedure", self.conn, index=False) proc = """DROP PROCEDURE IF EXISTS get_testdb; CREATE PROCEDURE get_testdb () BEGIN SELECT * FROM test_procedure; END""" connection = self.conn.connect() trans = connection.begin() try: r1 = connection.execute(proc) # noqa trans.commit() except pymysql.Error: trans.rollback() raise res1 = sql.read_sql_query("CALL get_testdb();", self.conn) tm.assert_frame_equal(df, res1) # test delegation to read_sql_query res2 = sql.read_sql("CALL get_testdb();", self.conn) tm.assert_frame_equal(df, res2) class _TestPostgreSQLAlchemy: """ Test the sqlalchemy backend against an PostgreSQL database. """ flavor = "postgresql" @classmethod def connect(cls): url = "postgresql+{driver}://postgres@localhost/pandas_nosetest" return sqlalchemy.create_engine(url.format(driver=cls.driver)) @classmethod def setup_driver(cls): pytest.importorskip("psycopg2") cls.driver = "psycopg2" def test_schema_support(self): # only test this for postgresql (schema's not supported in # mysql/sqlite) df = DataFrame({"col1": [1, 2], "col2": [0.1, 0.2], "col3": ["a", "n"]}) # create a schema self.conn.execute("DROP SCHEMA IF EXISTS other CASCADE;") self.conn.execute("CREATE SCHEMA other;") # write dataframe to different schema's df.to_sql("test_schema_public", self.conn, index=False) df.to_sql( "test_schema_public_explicit", self.conn, index=False, schema="public" ) df.to_sql("test_schema_other", self.conn, index=False, schema="other") # read dataframes back in res1 = sql.read_sql_table("test_schema_public", self.conn) tm.assert_frame_equal(df, res1) res2 = sql.read_sql_table("test_schema_public_explicit", self.conn) tm.assert_frame_equal(df, res2) res3 = sql.read_sql_table( "test_schema_public_explicit", self.conn, schema="public" ) tm.assert_frame_equal(df, res3) res4 = sql.read_sql_table("test_schema_other", self.conn, schema="other") tm.assert_frame_equal(df, res4) msg = "Table test_schema_other not found" with pytest.raises(ValueError, match=msg): sql.read_sql_table("test_schema_other", self.conn, schema="public") # different if_exists options # create a schema self.conn.execute("DROP SCHEMA IF EXISTS other CASCADE;") self.conn.execute("CREATE SCHEMA other;") # write dataframe with different if_exists options df.to_sql("test_schema_other", self.conn, schema="other", index=False) df.to_sql( "test_schema_other", self.conn, schema="other", index=False, if_exists="replace", ) df.to_sql( "test_schema_other", self.conn, schema="other", index=False, if_exists="append", ) res = sql.read_sql_table("test_schema_other", self.conn, schema="other") tm.assert_frame_equal(concat([df, df], ignore_index=True), res) # specifying schema in user-provided meta # The schema won't be applied on another Connection # because of transactional schemas if isinstance(self.conn, sqlalchemy.engine.Engine): engine2 = self.connect() meta = sqlalchemy.MetaData(engine2, schema="other") pdsql = sql.SQLDatabase(engine2, meta=meta) pdsql.to_sql(df, "test_schema_other2", index=False) pdsql.to_sql(df, "test_schema_other2", index=False, if_exists="replace") pdsql.to_sql(df, "test_schema_other2", index=False, if_exists="append") res1 = sql.read_sql_table("test_schema_other2", self.conn, schema="other") res2 = pdsql.read_table("test_schema_other2") tm.assert_frame_equal(res1, res2) def test_copy_from_callable_insertion_method(self): # GH 8953 # Example in io.rst found under _io.sql.method # not available in sqlite, mysql def psql_insert_copy(table, conn, keys, data_iter): # gets a DBAPI connection that can provide a cursor dbapi_conn = conn.connection with dbapi_conn.cursor() as cur: s_buf = StringIO() writer = csv.writer(s_buf) writer.writerows(data_iter) s_buf.seek(0) columns = ", ".join(f'"{k}"' for k in keys) if table.schema: table_name = f"{table.schema}.{table.name}" else: table_name = table.name sql_query = f"COPY {table_name} ({columns}) FROM STDIN WITH CSV" cur.copy_expert(sql=sql_query, file=s_buf) expected = DataFrame({"col1": [1, 2], "col2": [0.1, 0.2], "col3": ["a", "n"]}) expected.to_sql( "test_copy_insert", self.conn, index=False, method=psql_insert_copy ) result = sql.read_sql_table("test_copy_insert", self.conn) tm.assert_frame_equal(result, expected) @pytest.mark.single @pytest.mark.db class TestMySQLAlchemy(_TestMySQLAlchemy, _TestSQLAlchemy): pass @pytest.mark.single @pytest.mark.db class TestMySQLAlchemyConn(_TestMySQLAlchemy, _TestSQLAlchemyConn): pass @pytest.mark.single @pytest.mark.db class TestPostgreSQLAlchemy(_TestPostgreSQLAlchemy, _TestSQLAlchemy): pass @pytest.mark.single @pytest.mark.db class TestPostgreSQLAlchemyConn(_TestPostgreSQLAlchemy, _TestSQLAlchemyConn): pass @pytest.mark.single class TestSQLiteAlchemy(_TestSQLiteAlchemy, _TestSQLAlchemy): pass @pytest.mark.single class TestSQLiteAlchemyConn(_TestSQLiteAlchemy, _TestSQLAlchemyConn): pass # ----------------------------------------------------------------------------- # -- Test Sqlite / MySQL fallback @pytest.mark.single class TestSQLiteFallback(SQLiteMixIn, PandasSQLTest): """ Test the fallback mode against an in-memory sqlite database. """ flavor = "sqlite" @classmethod def connect(cls): return sqlite3.connect(":memory:") def setup_connect(self): self.conn = self.connect() def load_test_data_and_sql(self): self.pandasSQL = sql.SQLiteDatabase(self.conn) self._load_test1_data() @pytest.fixture(autouse=True) def setup_method(self, load_iris_data): self.load_test_data_and_sql() def test_read_sql(self): self._read_sql_iris() def test_read_sql_parameter(self): self._read_sql_iris_parameter() def test_read_sql_named_parameter(self): self._read_sql_iris_named_parameter() def test_to_sql(self): self._to_sql() def test_to_sql_empty(self): self._to_sql_empty() def test_to_sql_fail(self): self._to_sql_fail() def test_to_sql_replace(self): self._to_sql_replace() def test_to_sql_append(self): self._to_sql_append() def test_to_sql_method_multi(self): # GH 29921 self._to_sql(method="multi") def test_create_and_drop_table(self): temp_frame = DataFrame( {"one": [1.0, 2.0, 3.0, 4.0], "two": [4.0, 3.0, 2.0, 1.0]} ) self.pandasSQL.to_sql(temp_frame, "drop_test_frame") assert self.pandasSQL.has_table("drop_test_frame") self.pandasSQL.drop_table("drop_test_frame") assert not self.pandasSQL.has_table("drop_test_frame") def test_roundtrip(self): self._roundtrip() def test_execute_sql(self): self._execute_sql() def test_datetime_date(self): # test support for datetime.date df = DataFrame([date(2014, 1, 1), date(2014, 1, 2)], columns=["a"]) df.to_sql("test_date", self.conn, index=False) res = read_sql_query("SELECT * FROM test_date", self.conn) if self.flavor == "sqlite": # comes back as strings tm.assert_frame_equal(res, df.astype(str)) elif self.flavor == "mysql": tm.assert_frame_equal(res, df) def test_datetime_time(self): # test support for datetime.time, GH #8341 df = DataFrame([time(9, 0, 0), time(9, 1, 30)], columns=["a"]) df.to_sql("test_time", self.conn, index=False) res = read_sql_query("SELECT * FROM test_time", self.conn) if self.flavor == "sqlite": # comes back as strings expected = df.applymap(lambda _: _.strftime("%H:%M:%S.%f")) tm.assert_frame_equal(res, expected) def _get_index_columns(self, tbl_name): ixs = sql.read_sql_query( "SELECT * FROM sqlite_master WHERE type = 'index' " + f"AND tbl_name = '{tbl_name}'", self.conn, ) ix_cols = [] for ix_name in ixs.name: ix_info = sql.read_sql_query(f"PRAGMA index_info({ix_name})", self.conn) ix_cols.append(ix_info.name.tolist()) return ix_cols def test_to_sql_save_index(self): self._to_sql_save_index() def test_transactions(self): self._transaction_test() def _get_sqlite_column_type(self, table, column): recs = self.conn.execute(f"PRAGMA table_info({table})") for cid, name, ctype, not_null, default, pk in recs: if name == column: return ctype raise ValueError(f"Table {table}, column {column} not found") def test_dtype(self): if self.flavor == "mysql": pytest.skip("Not applicable to MySQL legacy") cols = ["A", "B"] data = [(0.8, True), (0.9, None)] df = DataFrame(data, columns=cols) df.to_sql("dtype_test", self.conn) df.to_sql("dtype_test2", self.conn, dtype={"B": "STRING"}) # sqlite stores Boolean values as INTEGER assert self._get_sqlite_column_type("dtype_test", "B") == "INTEGER" assert self._get_sqlite_column_type("dtype_test2", "B") == "STRING" msg = r"B \(<class 'bool'>\) not a string" with pytest.raises(ValueError, match=msg): df.to_sql("error", self.conn, dtype={"B": bool}) # single dtype df.to_sql("single_dtype_test", self.conn, dtype="STRING") assert self._get_sqlite_column_type("single_dtype_test", "A") == "STRING" assert self._get_sqlite_column_type("single_dtype_test", "B") == "STRING" def test_notna_dtype(self): if self.flavor == "mysql": pytest.skip("Not applicable to MySQL legacy") cols = { "Bool": Series([True, None]), "Date": Series([datetime(2012, 5, 1), None]), "Int": Series([1, None], dtype="object"), "Float": Series([1.1, None]), } df = DataFrame(cols) tbl = "notna_dtype_test" df.to_sql(tbl, self.conn) assert self._get_sqlite_column_type(tbl, "Bool") == "INTEGER" assert self._get_sqlite_column_type(tbl, "Date") == "TIMESTAMP" assert self._get_sqlite_column_type(tbl, "Int") == "INTEGER" assert self._get_sqlite_column_type(tbl, "Float") == "REAL" def test_illegal_names(self): # For sqlite, these should work fine df = DataFrame([[1, 2], [3, 4]], columns=["a", "b"]) msg = "Empty table or column name specified" with pytest.raises(ValueError, match=msg): df.to_sql("", self.conn) for ndx, weird_name in enumerate( [ "test_weird_name]", "test_weird_name[", "test_weird_name`", 'test_weird_name"', "test_weird_name'", "_b.test_weird_name_01-30", '"_b.test_weird_name_01-30"', "99beginswithnumber", "12345", "\xe9", ] ): df.to_sql(weird_name, self.conn) sql.table_exists(weird_name, self.conn) df2 = DataFrame([[1, 2], [3, 4]], columns=["a", weird_name]) c_tbl = f"test_weird_col_name{ndx:d}" df2.to_sql(c_tbl, self.conn) sql.table_exists(c_tbl, self.conn) # ----------------------------------------------------------------------------- # -- Old tests from 0.13.1 (before refactor using sqlalchemy) def date_format(dt): """Returns date in YYYYMMDD format.""" return dt.strftime("%Y%m%d") _formatters = { datetime: "'{}'".format, str: "'{}'".format, np.str_: "'{}'".format, bytes: "'{}'".format, float: "{:.8f}".format, int: "{:d}".format, type(None): lambda x: "NULL", np.float64: "{:.10f}".format, bool: "'{!s}'".format, } def format_query(sql, *args): """ """ processed_args = [] for arg in args: if isinstance(arg, float) and isna(arg): arg = None formatter = _formatters[type(arg)] processed_args.append(formatter(arg)) return sql % tuple(processed_args) def tquery(query, con=None, cur=None): """Replace removed sql.tquery function""" res = sql.execute(query, con=con, cur=cur).fetchall() if res is None: return None else: return list(res) @pytest.mark.single class TestXSQLite(SQLiteMixIn): @pytest.fixture(autouse=True) def setup_method(self, request, datapath): self.method = request.function self.conn = sqlite3.connect(":memory:") # In some test cases we may close db connection # Re-open conn here so we can perform cleanup in teardown yield self.method = request.function self.conn = sqlite3.connect(":memory:") def test_basic(self): frame = tm.makeTimeDataFrame() self._check_roundtrip(frame) def test_write_row_by_row(self): frame = tm.makeTimeDataFrame() frame.iloc[0, 0] = np.nan create_sql = sql.get_schema(frame, "test") cur = self.conn.cursor() cur.execute(create_sql) cur = self.conn.cursor() ins = "INSERT INTO test VALUES (%s, %s, %s, %s)" for idx, row in frame.iterrows(): fmt_sql = format_query(ins, *row) tquery(fmt_sql, cur=cur) self.conn.commit() result = sql.read_sql("select * from test", con=self.conn) result.index = frame.index tm.assert_frame_equal(result, frame, check_less_precise=True) def test_execute(self): frame = tm.makeTimeDataFrame() create_sql = sql.get_schema(frame, "test") cur = self.conn.cursor() cur.execute(create_sql) ins = "INSERT INTO test VALUES (?, ?, ?, ?)" row = frame.iloc[0] sql.execute(ins, self.conn, params=tuple(row)) self.conn.commit() result = sql.read_sql("select * from test", self.conn) result.index = frame.index[:1] tm.assert_frame_equal(result, frame[:1]) def test_schema(self): frame = tm.makeTimeDataFrame() create_sql = sql.get_schema(frame, "test") lines = create_sql.splitlines() for l in lines: tokens = l.split(" ") if len(tokens) == 2 and tokens[0] == "A": assert tokens[1] == "DATETIME" frame = tm.makeTimeDataFrame() create_sql = sql.get_schema(frame, "test", keys=["A", "B"]) lines = create_sql.splitlines() assert 'PRIMARY KEY ("A", "B")' in create_sql cur = self.conn.cursor() cur.execute(create_sql) def test_execute_fail(self): create_sql = """ CREATE TABLE test ( a TEXT, b TEXT, c REAL, PRIMARY KEY (a, b) ); """ cur = self.conn.cursor() cur.execute(create_sql) sql.execute('INSERT INTO test VALUES("foo", "bar", 1.234)', self.conn) sql.execute('INSERT INTO test VALUES("foo", "baz", 2.567)', self.conn) with pytest.raises(Exception): sql.execute('INSERT INTO test VALUES("foo", "bar", 7)', self.conn) def test_execute_closed_connection(self): create_sql = """ CREATE TABLE test ( a TEXT, b TEXT, c REAL, PRIMARY KEY (a, b) ); """ cur = self.conn.cursor() cur.execute(create_sql) sql.execute('INSERT INTO test VALUES("foo", "bar", 1.234)', self.conn) self.conn.close() with pytest.raises(Exception): tquery("select * from test", con=self.conn) def test_na_roundtrip(self): pass def _check_roundtrip(self, frame): sql.to_sql(frame, name="test_table", con=self.conn, index=False) result = sql.read_sql("select * from test_table", self.conn) # HACK! Change this once indexes are handled properly. result.index = frame.index expected = frame tm.assert_frame_equal(result, expected) frame["txt"] = ["a"] * len(frame) frame2 = frame.copy() new_idx = Index(np.arange(len(frame2))) + 10 frame2["Idx"] = new_idx.copy() sql.to_sql(frame2, name="test_table2", con=self.conn, index=False) result = sql.read_sql("select * from test_table2", self.conn, index_col="Idx") expected = frame.copy() expected.index = new_idx expected.index.name = "Idx" tm.assert_frame_equal(expected, result) def test_keyword_as_column_names(self): df = DataFrame({"From": np.ones(5)}) sql.to_sql(df, con=self.conn, name="testkeywords", index=False) def test_onecolumn_of_integer(self): # GH 3628 # a column_of_integers dataframe should transfer well to sql mono_df = DataFrame([1, 2], columns=["c0"]) sql.to_sql(mono_df, con=self.conn, name="mono_df", index=False) # computing the sum via sql con_x = self.conn the_sum = sum(my_c0[0] for my_c0 in con_x.execute("select * from mono_df")) # it should not fail, and gives 3 ( Issue #3628 ) assert the_sum == 3 result = sql.read_sql("select * from mono_df", con_x) tm.assert_frame_equal(result, mono_df) def test_if_exists(self): df_if_exists_1 = DataFrame({"col1": [1, 2], "col2": ["A", "B"]}) df_if_exists_2 = DataFrame({"col1": [3, 4, 5], "col2": ["C", "D", "E"]}) table_name = "table_if_exists" sql_select = f"SELECT * FROM {table_name}" def clean_up(test_table_to_drop): """ Drops tables created from individual tests so no dependencies arise from sequential tests """ self.drop_table(test_table_to_drop) msg = "'notvalidvalue' is not valid for if_exists" with pytest.raises(ValueError, match=msg): sql.to_sql( frame=df_if_exists_1, con=self.conn, name=table_name, if_exists="notvalidvalue", ) clean_up(table_name) # test if_exists='fail' sql.to_sql( frame=df_if_exists_1, con=self.conn, name=table_name, if_exists="fail" ) msg = "Table 'table_if_exists' already exists" with pytest.raises(ValueError, match=msg): sql.to_sql( frame=df_if_exists_1, con=self.conn, name=table_name, if_exists="fail" ) # test if_exists='replace' sql.to_sql( frame=df_if_exists_1, con=self.conn, name=table_name, if_exists="replace", index=False, ) assert tquery(sql_select, con=self.conn) == [(1, "A"), (2, "B")] sql.to_sql( frame=df_if_exists_2, con=self.conn, name=table_name, if_exists="replace", index=False, ) assert tquery(sql_select, con=self.conn) == [(3, "C"), (4, "D"), (5, "E")] clean_up(table_name) # test if_exists='append' sql.to_sql( frame=df_if_exists_1, con=self.conn, name=table_name, if_exists="fail", index=False, ) assert tquery(sql_select, con=self.conn) == [(1, "A"), (2, "B")] sql.to_sql( frame=df_if_exists_2, con=self.conn, name=table_name, if_exists="append", index=False, ) assert tquery(sql_select, con=self.conn) == [ (1, "A"), (2, "B"), (3, "C"), (4, "D"), (5, "E"), ] clean_up(table_name) @pytest.mark.single @pytest.mark.db @pytest.mark.skip( reason="gh-13611: there is no support for MySQL if SQLAlchemy is not installed" ) class TestXMySQL(MySQLMixIn): @pytest.fixture(autouse=True, scope="class") def setup_class(cls): pymysql = pytest.importorskip("pymysql") pymysql.connect(host="localhost", user="root", passwd="", db="pandas_nosetest") try: pymysql.connect(read_default_group="pandas") except pymysql.ProgrammingError: raise RuntimeError( "Create a group of connection parameters under the heading " "[pandas] in your system's mysql default file, " "typically located at ~/.my.cnf or /etc/.my.cnf." ) except pymysql.Error: raise RuntimeError( "Cannot connect to database. " "Create a group of connection parameters under the heading " "[pandas] in your system's mysql default file, " "typically located at ~/.my.cnf or /etc/.my.cnf." ) @pytest.fixture(autouse=True) def setup_method(self, request, datapath): pymysql = pytest.importorskip("pymysql") pymysql.connect(host="localhost", user="root", passwd="", db="pandas_nosetest") try: pymysql.connect(read_default_group="pandas") except pymysql.ProgrammingError: raise RuntimeError( "Create a group of connection parameters under the heading " "[pandas] in your system's mysql default file, " "typically located at ~/.my.cnf or /etc/.my.cnf." ) except pymysql.Error: raise RuntimeError( "Cannot connect to database. " "Create a group of connection parameters under the heading " "[pandas] in your system's mysql default file, " "typically located at ~/.my.cnf or /etc/.my.cnf." ) self.method = request.function def test_basic(self): frame = tm.makeTimeDataFrame() self._check_roundtrip(frame) def test_write_row_by_row(self): frame = tm.makeTimeDataFrame() frame.iloc[0, 0] = np.nan drop_sql = "DROP TABLE IF EXISTS test" create_sql = sql.get_schema(frame, "test") cur = self.conn.cursor() cur.execute(drop_sql) cur.execute(create_sql) ins = "INSERT INTO test VALUES (%s, %s, %s, %s)" for idx, row in frame.iterrows(): fmt_sql = format_query(ins, *row) tquery(fmt_sql, cur=cur) self.conn.commit() result = sql.read_sql("select * from test", con=self.conn) result.index = frame.index tm.assert_frame_equal(result, frame, check_less_precise=True) def test_chunksize_read_type(self): frame = tm.makeTimeDataFrame() frame.index.name = "index" drop_sql = "DROP TABLE IF EXISTS test" cur = self.conn.cursor() cur.execute(drop_sql) sql.to_sql(frame, name="test", con=self.conn) query = "select * from test" chunksize = 5 chunk_gen = pd.read_sql_query( sql=query, con=self.conn, chunksize=chunksize, index_col="index" ) chunk_df = next(chunk_gen) tm.assert_frame_equal(frame[:chunksize], chunk_df) def test_execute(self): frame = tm.makeTimeDataFrame() drop_sql = "DROP TABLE IF EXISTS test" create_sql = sql.get_schema(frame, "test") cur = self.conn.cursor() with warnings.catch_warnings(): warnings.filterwarnings("ignore", "Unknown table.*") cur.execute(drop_sql) cur.execute(create_sql) ins = "INSERT INTO test VALUES (%s, %s, %s, %s)" row = frame.iloc[0].values.tolist() sql.execute(ins, self.conn, params=tuple(row)) self.conn.commit() result = sql.read_sql("select * from test", self.conn) result.index = frame.index[:1] tm.assert_frame_equal(result, frame[:1]) def test_schema(self): frame = tm.makeTimeDataFrame() create_sql = sql.get_schema(frame, "test") lines = create_sql.splitlines() for l in lines: tokens = l.split(" ") if len(tokens) == 2 and tokens[0] == "A": assert tokens[1] == "DATETIME" frame = tm.makeTimeDataFrame() drop_sql = "DROP TABLE IF EXISTS test" create_sql = sql.get_schema(frame, "test", keys=["A", "B"]) lines = create_sql.splitlines() assert "PRIMARY KEY (`A`, `B`)" in create_sql cur = self.conn.cursor() cur.execute(drop_sql) cur.execute(create_sql) def test_execute_fail(self): drop_sql = "DROP TABLE IF EXISTS test" create_sql = """ CREATE TABLE test ( a TEXT, b TEXT, c REAL, PRIMARY KEY (a(5), b(5)) ); """ cur = self.conn.cursor() cur.execute(drop_sql) cur.execute(create_sql) sql.execute('INSERT INTO test VALUES("foo", "bar", 1.234)', self.conn) sql.execute('INSERT INTO test VALUES("foo", "baz", 2.567)', self.conn) with pytest.raises(Exception): sql.execute('INSERT INTO test VALUES("foo", "bar", 7)', self.conn) def test_execute_closed_connection(self, request, datapath): drop_sql = "DROP TABLE IF EXISTS test" create_sql = """ CREATE TABLE test ( a TEXT, b TEXT, c REAL, PRIMARY KEY (a(5), b(5)) ); """ cur = self.conn.cursor() cur.execute(drop_sql) cur.execute(create_sql)
sql.execute('INSERT INTO test VALUES("foo", "bar", 1.234)', self.conn)
pandas.io.sql.execute
#!/usr/bin/env python ''' This script requires some additional dependencies, which are installed using: pip install pandas utm colour ''' import django from geocamUtil.loader import LazyGetModelByName django.setup() from django.conf import settings from xgds_braille_app.models import BandDepthDefinition, BandDepthGeoJSON, BandDepthTimeSeries import pandas as pd from colour import Color from utm import from_latlon, to_latlon from json import dumps colors = list(Color("blue").range_to(Color("red"), 100)) def lat_lon_to_utm(row): return from_latlon(row['latitude'], row['longitude']) def clip_to_range(minimum, maximum, x): return max(minimum, min(x, maximum)) def scale_between(minimum, maximum, x): rng = maximum - minimum return minimum + x * rng def get_color(percentage): clipped = clip_to_range(0, 0.5, percentage) clipped *= 2 # it is now between 0 and 1 return colors[int(clipped * (len(colors) - 1))] def create_feature_collection(collection): return { "type": "FeatureCollection", "features": collection, } def create_geojson(easting, northing, zone_number, zone_letter, band_depth, confidence, stddev): clipped_confidence = clip_to_range(0, 150, confidence) / 150.0 radius = scale_between(0.25, 0.5, clipped_confidence) lat_minus_radius, lng_minus_radius = to_latlon(easting - radius, northing - radius, zone_number, zone_letter) lat_plus_radius, lng_plus_radius = to_latlon(easting + radius, northing + radius, zone_number, zone_letter) return { "type": "Feature", "properties": { "stroke-width": 0, "fill": str(get_color(band_depth)), "fill-opacity": 1, "band-depth": "%f +- %f" % (round(float(band_depth), 4), round(float(stddev), 4)), "confidence": int(confidence), }, "geometry": { "type": "Polygon", "coordinates": [[ [lng_plus_radius, lat_minus_radius], [lng_minus_radius, lat_minus_radius], [lng_minus_radius, lat_plus_radius], [lng_plus_radius, lat_plus_radius], [lng_plus_radius, lat_minus_radius], ]] } } def create_geojson_for_flight(flight, band_depth_definition): band_depth_time_series = BandDepthTimeSeries.objects.filter( time_stamp__gte=flight.start_time, time_stamp__lte=flight.end_time, band_depth_definition=band_depth_definition, flight=flight, ) band_depth = [] for bdts in band_depth_time_series: band_depth.append({ "timestamp": bdts.time_stamp, "value": bdts.band_depth, }) band_depth =
pd.DataFrame(data=band_depth)
pandas.DataFrame
from flask import Flask, render_template,request,redirect,flash,url_for from flask import * from flaskext.mysql import MySQL from flask import request import pandas as pd from sklearn.model_selection import train_test_split import missingno as msno import warnings warnings.filterwarnings('ignore') import pickle mysql = MySQL() app = Flask(__name__) model = pickle.load(open('model.pkl', 'rb' )) app.secret_key = 'your_secret_key' @app.route("/") def home(): return render_template("index.html") @app.route("/register") def register(): #Loading the quiz data #reading data df0 = pd.read_csv('data/LWR1.csv') df1 = pd.read_csv('data/MOR1.csv') df2 = pd.read_csv('data/PCR1.csv') df3 = pd.read_csv('data/PVR1.csv') df4 = pd.read_csv('data/SRR1.csv') #spelling data df5 = pd.read_csv('data/LWS1.csv') df6 = pd.read_csv('data/PVS1.csv') df7 = pd.read_csv('data/SOSS1.csv') #memory data df8 = pd.read_csv('data/LWM1.csv') df9 =
pd.read_csv('data/LSM1.csv')
pandas.read_csv
import os import pandas as pd ''' Process Pipline: -Get the CSV -Get the file name in a folder --Return list -Frame the list of file name in sequence --Can thought of Dict-like container for series object --pd.DataFrame({'Column': Value}) -Assign the framed list to image2 column --Return new_train_label['image2'] -MAJOR PART: -The image2 label is of the form "100_right_mir.jpeg" OR "100_right_90.jpeg" --we have to make it '100_right.jpeg' i.e remove '_90.jpeg' OR '_mir.jpeg' -We can split the the string from '_' --there are two '_' in the 100_right_mir.jpeg" so we have to split from second '_' therefore use [0:2] ---Try: test = "100_right_mir.jpeg" print(test.split('_')[0:2]) ---Return: ['100', 'right'] -To combine the splited string(['100', 'right']) use join --join the two list with '_' ---Try: test = "100_right_mir.jpeg" print('_'.join(test.split('_')[0:2])) ---Return: 100_right -Use the above concept to apply through all label and use --"lambda argument: expression" ---EG: (Without Lambda) def add(x, y): return x + y add(2, 3) ---EG: (With Lambda) add = lambda x, y : x + y print add(2, 3) -Locate(.loc) the label 'image2' and apply the lambda function on it -After the label is split and joined again there are still original files in list which don't have '_mir.jpeg' OR '_90.jpeg' labels in it i.e 100_right.jpeg(original file) -So to make it like other file in the list we have to remove the '.jpeg' extension from the list of original files and again add the '.jpeg' to all the files in the list. ---lambda x: '_'.join(x.split('_')).strip('.jpeg') -This will remove .jpeg extension form original file ---lambda x: '_'.join(x.split('_')).strip('.jpeg') + '.jpeg') -This will again add the '.jpeg' extension. -TRY PRINTING THE LABELS BEFORE AND AFTER ADDING THE '.JPEG' SO YOU WILL GET IDEA TRY:- 'print(new_train_label['image2'])' -Replace the 'image' column with the 'train_image_name' --'new_train_label.columns = ['train_image_name', 'image']' -Merge the dataFrame with original CSV. --pd.merge(left, right, how='outer', on=None) ---left: A DataFrame object. ---right: Another DataFrame object. ---on: Column or index level names to join on. Must be found in both the left and right DataFrame objects ---how: One of 'left', 'right', 'outer', 'inner'. -outer:- Use union of keys from both frames -Save .to_csv ''' def get_images_list(file_path): # .DS_Store is for Mac Users return [i for i in os.listdir(file_path) if i != '.DS_Store'] if __name__ == '__main__': #read CSV (INCLUDE trainLabels_find_black_images.csv) trainLabels = pd.read_csv('E:/Tirth/trainlabel_zip/trainLabels_csv/trainLabels_find_black_images.csv') #get file name list_images = get_images_list('E:/Tirth/train/crop_256/') #framing the list_of_filename in sequence new_trainLabels = pd.DataFrame({'image': list_images}) new_trainLabels['image2'] = new_trainLabels.image #Remove the suffix from the image names. new_trainLabels['image2'] = new_trainLabels.loc[:, 'image2'].apply(lambda x: '_'.join(x.split('_')[0:2])) #Strip and add .jpeg back into file name new_trainLabels['image2'] = new_trainLabels.loc[:, 'image2'].apply( lambda x: '_'.join(x.split('_')[0:2]).strip('.jpeg') + '.jpeg') new_trainLabels.columns = ['train_image_name', 'image'] trainLabels =
pd.merge(trainLabels, new_trainLabels, how='outer', on='image')
pandas.merge
#!/usr/bin/env python3 # 10.05.21 # Assignment lab 07 # Master Class: Machine Learning (5MI2018) # Faculty of Economic Science # University of Neuchatel (Switzerland) # Lab 7, see ML21_Exercise_7.pdf for more information # https://github.com/RomainClaret/msc.ml.labs # Authors: # - <NAME> @RomainClaret # - <NAME> @Nic0uds # 2. Interpret the results for one year using a decision tree. (with the original fields) # 3. Compare the results to the clusters from exercise 5. import pandas as pd import numpy as np import matplotlib.pyplot as plt from sklearn.preprocessing import FunctionTransformer, Normalizer, StandardScaler from sklearn.neural_network import MLPRegressor from sklearn.model_selection import train_test_split from sklearn.metrics import r2_score from joblib import dump # Import the data and filter the two datasets for the chosen two years. df = pd.read_stata('pwt100.dta') # 2. Select the input features that you deem useful for the purpose. features = [ "hc", "ctfp", "cwtfp", "delta", "pl_con", "pl_da", "pl_gdpo", "csh_g", "pl_c", "pl_i", "pl_g", #"pl_k", ] features_logarithmic = [ #"rgdpe", "pop", "ccon", #"rgdpna", "rconna", "xr", ] # 1. Select the target variable rgdpna or rtfpna. targeted_feature = [ "rgdpna", # log required #"rtfpna", # log not required ] # Apply the logarithmic function on badly proportionated features log_transformer = FunctionTransformer(np.log1p) df_log_features = df[features_logarithmic+targeted_feature] df_log = log_transformer.transform(df_log_features) # Concat logarithmic features with unlogarithmic features df_concat = pd.concat([df[features], df_log], axis=1, join="inner") # Drop rows with na values df_cleaned = df_concat.dropna() # normalization to merge logarithmic and non-logarithmic features df_normalized = pd.DataFrame(Normalizer().fit_transform(df_cleaned[features+features_logarithmic+targeted_feature])) # build train and target datasets X = pd.DataFrame(df_normalized,columns=df_normalized.columns[:-1]) y =
pd.DataFrame(df_normalized,columns=[df_normalized.columns[-1]])
pandas.DataFrame
# -*- coding:utf-8 -*- import pandas as pd import numpy as np import matplotlib as mt from gensim.models import word2vec from sklearn.model_selection import train_test_split import sys # 数据合并 dealed_data = dealed_data['top10'] + [" "] + dealed_data['top9'] + [" "] + dealed_data['top8'] + [" "] + \ dealed_data['top7'] + [" "] + dealed_data['top6'] + [" "] + dealed_data['top5'] + [" "] + dealed_data[ 'top4'] + [" "] + dealed_data['top3'] + [" "] + dealed_data['top2'] + [" "] + dealed_data['top1'] # 数据分列 dealed_data = [s.encode('utf-8').split() for s in dealed_data] # 数据拆分 train_data, test_data = train_test_split(dealed_data, test_size=0.3, random_state=42) # 原始数据训练 # sg=1,skipgram;sg=0,SBOW # hs=1:hierarchical softmax,huffmantree # nagative = 0 非负采样 model = word2vec.Word2Vec(train_data, sg=1, min_count=10, window=2, hs=1, negative=0) # 最后一次购物最相似的商品组top3 x = 1000 result = [] result = pd.DataFrame(result) for i in range(x): test_data_split = [s.encode('utf-8').split() for s in test_data[i]] k = len(test_data_split) last_one = test_data_split[k - 1] last_one_recommended = model.most_similar(last_one, topn=3) tmp = last_one_recommended[0] + last_one_recommended[1] + last_one_recommended[2] last_one_recommended = pd.concat([pd.DataFrame(last_one), pd.DataFrame(np.array(tmp))], axis=0) last_one_recommended = last_one_recommended.T result = pd.concat([pd.DataFrame(last_one_recommended), result], axis=0) # 倒数第二次购物最相似的商品组top3 x = 1000 result1 = [] result1 = pd.DataFrame(result1) for i in range(x): test_data_split = [s.encode('utf-8').split() for s in test_data[i]] k = len(test_data_split) last_one = test_data_split[k - 2] last_one_recommended = model.most_similar(last_one, topn=3) tmp = last_one_recommended[0] + last_one_recommended[1] + last_one_recommended[2] last_one_recommended = pd.concat([pd.DataFrame(last_one), pd.DataFrame(np.array(tmp))], axis=0) last_one_recommended = last_one_recommended.T result1 = pd.concat([
pd.DataFrame(last_one_recommended)
pandas.DataFrame
import numpy as np import pandas as pd from tqdm import tqdm class DataTransformers: @staticmethod def simulate_admissions(prior, batch_size: int = None, n_iterations: int = 0): prior_sample_dict = {} if n_iterations == 0: # sequential retriever n_iterations = len(prior) // batch_size retriver = lambda loc: np.split(prior, np.arange(batch_size, len(prior), batch_size))[loc] else: # bootstrap retriever batch_size = len(prior) if batch_size is None else batch_size retriver = lambda loc: np.random.choice(prior, size=batch_size, replace=True) for iteration in tqdm(range(n_iterations), desc="admission batches"): sample = retriver(iteration) prior_sample_dict.update({ iteration: { "readmission_mean": sample.mean(), "readmission_sum": sample.sum(), "patients_cnt": batch_size } }) prior_df =
pd.DataFrame(prior_sample_dict)
pandas.DataFrame
""" for f in sorted(glob('*.py')): # print(f'nohup python -u {f} 0 > LOG/log_{f}.txt &') print(f'python -u {f} > LOG/log_{f}.txt') """ import warnings warnings.filterwarnings("ignore") import pandas as pd import numpy as np from glob import glob import os from socket import gethostname HOSTNAME = gethostname() from tqdm import tqdm #from itertools import combinations from sklearn.model_selection import KFold from time import time, sleep from datetime import datetime from multiprocessing import cpu_count, Pool import gc # ============================================================================= # global variables # ============================================================================= COMPETITION_NAME = 'santander-customer-transaction-prediction' IMP_FILE = 'LOG/xxx.csv' IMP_FILE_BEST = 'LOG/xxx.csv' SUB_BEST = '../output/0328-1.csv.gz' # ============================================================================= # def # ============================================================================= def start(fname): global st_time st_time = time() print(""" #============================================================================== # START!!! {} PID: {} time: {} #============================================================================== """.format( fname, os.getpid(), datetime.today() )) send_line(f'{HOSTNAME} START {fname} time: {elapsed_minute():.2f}min') return def reset_time(): global st_time st_time = time() return def end(fname): print(""" #============================================================================== # SUCCESS !!! {} #============================================================================== """.format(fname)) print('time: {:.2f}min'.format( elapsed_minute() )) send_line(f'{HOSTNAME} FINISH {fname} time: {elapsed_minute():.2f}min') return def elapsed_minute(): return (time() - st_time)/60 def mkdir_p(path): try: os.stat(path) except: os.mkdir(path) def to_feature(df, path): if df.columns.duplicated().sum()>0: raise Exception(f'duplicated!: { df.columns[df.columns.duplicated()] }') df.reset_index(inplace=True, drop=True) df.columns = [c.replace('/', '-').replace(' ', '-') for c in df.columns] for c in df.columns: df[[c]].to_feather(f'{path}_{c}.f') return def to_pickles(df, path, split_size=3, inplace=True): """ path = '../output/mydf' wirte '../output/mydf/0.p' '../output/mydf/1.p' '../output/mydf/2.p' """ print(f'shape: {df.shape}') if inplace==True: df.reset_index(drop=True, inplace=True) else: df = df.reset_index(drop=True) gc.collect() mkdir_p(path) kf = KFold(n_splits=split_size) for i, (train_index, val_index) in enumerate(tqdm(kf.split(df))): df.iloc[val_index].to_pickle(f'{path}/{i:03d}.p') return def read_pickles(path, col=None, use_tqdm=True): if col is None: if use_tqdm: df = pd.concat([ pd.read_pickle(f) for f in tqdm(sorted(glob(path+'/*'))) ]) else: print(f'reading {path}') df = pd.concat([ pd.read_pickle(f) for f in sorted(glob(path+'/*')) ]) else: df = pd.concat([ pd.read_pickle(f)[col] for f in tqdm(sorted(glob(path+'/*'))) ]) return df def to_pkl_gzip(df, path): df.to_pickle(path) os.system('rm ' + path + '.gz') os.system('gzip ' + path) return def save_test_features(df): for c in df.columns: df[[c]].to_pickle(f'../feature/test_{c}.pkl') return # ============================================================================= # # ============================================================================= def get_dummies(df): """ binary would be drop_first """ col = df.select_dtypes('O').columns.tolist() nunique = df[col].nunique() col_binary = nunique[nunique==2].index.tolist() [col.remove(c) for c in col_binary] df = pd.get_dummies(df, columns=col) df = pd.get_dummies(df, columns=col_binary, drop_first=True) df.columns = [c.replace(' ', '-') for c in df.columns] return df def reduce_mem_usage(df): start_mem = df.memory_usage().sum() / 1024**2 print('Memory usage of dataframe is {:.2f} MB'.format(start_mem)) for col in df.columns: col_type = df[col].dtype if col_type != 'object' and col_type != 'datetime64[ns]': c_min = df[col].min() c_max = df[col].max() if str(col_type)[:3] == 'int': if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max: df[col] = df[col].astype(np.int8) elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max: df[col] = df[col].astype(np.int16) elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max: df[col] = df[col].astype(np.int32) elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max: df[col] = df[col].astype(np.int64) else: if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max: df[col] = df[col].astype(np.float32) # feather-format cannot accept float16 elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max: df[col] = df[col].astype(np.float32) else: df[col] = df[col].astype(np.float64) end_mem = df.memory_usage().sum() / 1024**2 print('Memory usage after optimization is: {:.2f} MB'.format(end_mem)) print('Decreased by {:.1f}%'.format(100 * (start_mem - end_mem) / start_mem)) return df def savefig_imp(imp, path, x='gain', y='feature', n=30, title='Importance'): import matplotlib as mpl mpl.use('Agg') import seaborn as sns import matplotlib.pyplot as plt fig, ax = plt.subplots() # the size of A4 paper fig.set_size_inches(11.7, 8.27) sns.barplot(x=x, y=y, data=imp.head(n), label=x) plt.subplots_adjust(left=.4, right=.9) plt.title(title+' TOP{0}'.format(n), fontsize=20, alpha=0.8) plt.savefig(path) # ============================================================================= # # ============================================================================= def load_train(col=None): if col is None: return pd.read_pickle('../data/train.pkl') else: return
pd.read_pickle('../data/train.pkl')
pandas.read_pickle
import pandas as pd #from pandas.io.parsers import read_csv # import plotly.express as px # import plotly.graph_objects as go import matplotlib.pyplot as plt import numpy as np datapoints = 101 def dsoc_interpolation(soc_data, volt_data, soc_in): for i in range(len(soc_data)-1):# soc_in.max()): if soc_in == 0: volt_out = volt_data[0] break if soc_in == 1: volt_out = volt_data[len(soc_data)-1] break if soc_data[i+1] >= soc_in and soc_data[i] < soc_in: #Función de interpolación volt_out = volt_data[i] + (volt_data[i+1] - volt_data[i]) * (soc_in - soc_data[i]) / (soc_data[i+1] - soc_data[i]) break return volt_out ################################################################################# ################################# PARA DESCARGA ################################# ################################################################################# dsd = pd.read_csv('discharge_data09_10_2021_22_55.csv')#Upload csv dsd.columns = ['time','seconds','voltage','current','capacity','temperature'] # Limpiando los datos PARA DESCARGA dsd.capacity = dsd.capacity - dsd.capacity.min() dsd.seconds = dsd.seconds - dsd.seconds.min() socd = 1 - dsd.capacity/dsd.capacity.max() dsd = dsd.assign(soc=socd.values) dsd = dsd.sort_values(by=['seconds'], ascending=False) dsd = dsd.reset_index(drop=True) # print(dsd.head()) #c_eff = dsd.capacity.max() / dsd.capacity.max() #dsd.capacity = c_eff*dsd.capacity #soc = 1 - dsc.capacity/dsc.capacity.max() #dsd = dsd.assign(soc=soc.values) volt_datad = dsd.voltage.values soc_datad = dsd.soc.values new_socd = np.linspace(0,1,datapoints) #1000 divisions of the new x axis (SoC) new_voltd = np.zeros(len(new_socd)) for i in range(len(new_socd)): new_voltd[i] = dsoc_interpolation(soc_datad, volt_datad, new_socd[i]) newdsd = pd.DataFrame() #New empty DataFrame newdsd = newdsd.assign(soc=new_socd) newdsd = newdsd.assign(voltage=new_voltd) ################################################################################## ################################### PARA CARGA ################################### ################################################################################## dsc = pd.read_csv('charge_data11_10_2021_23_55.csv')#Upload csv dsc.columns = ['time','seconds','voltage','current','capacity','temperature'] # Limpiando los datos PARA CARGA dsc.capacity = dsc.capacity - dsc.capacity.min() dsc.seconds = dsc.seconds - dsc.seconds.min() # Coulumb eff c_eff = dsd.capacity.max() / dsc.capacity.max() print(c_eff) dsc.capacity = c_eff*dsc.capacity socc = dsc.capacity/dsc.capacity.max() dsc = dsc.assign(soc=socc.values) ##Prueba print("Carga: ", dsc.capacity.max()) print("Descarga: ", dsd.capacity.max()) volt_datac = dsc.voltage.values soc_datac = dsc.soc.values new_socc = np.linspace(0,1,datapoints) #1000 divisions of the new x axis (SoC) new_voltc = np.zeros(len(new_socc)) for i in range(len(new_socc)): new_voltc[i] = dsoc_interpolation(soc_datac, volt_datac, new_socc[i]) newdsc = pd.DataFrame() #New empty DataFrame newdsc = newdsc.assign(soc=new_socc) newdsc = newdsc.assign(voltage=new_voltc) soc = np.linspace(0,1,datapoints) ocv = (newdsc.voltage.values + newdsd.voltage.values)/2 sococv =
pd.DataFrame(data={"soc":soc,"ocv": ocv})
pandas.DataFrame
import datetime as dt import time from pathlib import Path import numpy as np import pandas as pd import pytest from apipe import ( DelayedParameter, DelayedParameters, cached, clear_cache, delayed_cached, delayed_compute, eager_cached, ) CACHE_DIR = Path("cache/temp/") EPS = 0.00001 def _count_cache_files() -> int: return len([f for f in CACHE_DIR.iterdir() if f.is_file()]) @pytest.mark.parametrize( "data, ftype", [ ((0, 1, 3, 5, -1), "pickle"), ((0, 1.0, 3232.22, 5.0, -1.0, None), "pickle"), ([0, 1, 3, 5, -1], "pickle"), ([0, 1.0, 3232.22, 5.0, -1.0, None], "pickle"), (np.array([0, 1.0, 3232.22, 5.0, -1.0]), "pickle"), (np.array([dt.datetime(2019, 1, 1)] * 3), "pickle"), (pd.Series([0, 1, 3, 5, -1]), "pickle"), (pd.Series([0, 1.0, 3232.22, 5.0, -1.0, np.nan]), "pickle"), (pd.Series([1, 2, 3, 4], dtype="category"), "pickle"), (pd.Series(pd.date_range("2018-01-01", periods=5)), "pickle"), ( pd.DataFrame( { "a": [0, 1, 3, 5, -1], "b": [2, 1, 0, 0, 14], } ), "pickle", ), ( pd.DataFrame( { "a": [0, 1.0, 3232.22, -1.0, np.nan], "b": ["a", "b", "c", "ee", "14"], "c": [ dt.datetime(2018, 1, 1), dt.datetime(2019, 1, 1), dt.datetime(2020, 1, 1), dt.datetime(2021, 1, 1), dt.datetime(2022, 1, 1), ], } ), "pickle", ), ( pd.DataFrame( { "a": [0, 1, 3, 5, -1], "b": [2, 1, 0, 0, 14], } ), "parquet", ), ( pd.DataFrame( { "a": [0, 1.0, 3232.22, -1.0, np.nan], "b": ["a", "b", "c", "ee", "14"], "c": [ dt.datetime(2018, 1, 1), dt.datetime(2019, 1, 1), dt.datetime(2020, 1, 1), dt.datetime(2021, 1, 1), dt.datetime(2022, 1, 1), ], "d": [ pd.Timestamp("2018-01-01"), pd.Timestamp("2018-01-01"), pd.Timestamp("2018-01-01"), pd.Timestamp("2018-01-01"), pd.Timestamp("2018-01-01"), ], } ), "parquet", ), ( pd.DataFrame( { "a": [0, 1.0, 3232.22, -1.0, np.nan], "b": [ dt.timedelta(hours=1), dt.timedelta(hours=1), dt.timedelta(hours=1), dt.timedelta(hours=1), dt.timedelta(hours=1), ], } ), "pickle", ), ], ) def test_cached_load_and_hash(data, ftype): clear_cache(CACHE_DIR) @cached(folder=CACHE_DIR, ftype=ftype, override=False) def load_data(): return data @cached(folder=CACHE_DIR, ftype="pickle", override=False) def compute_data(data): return 0 loaded = load_data().load() _ = compute_data(loaded).load() assert _count_cache_files() == 4 loaded = load_data().load() _ = compute_data(loaded).load() assert _count_cache_files() == 4 if isinstance(data, pd.Series): pd.testing.assert_series_equal(loaded, data) elif isinstance(data, pd.DataFrame): pd.testing.assert_frame_equal(loaded, data) elif isinstance(data, np.ndarray): np.testing.assert_equal(loaded, data) else: assert loaded == data @pytest.mark.parametrize( "data, ftype, eps, ts", [ ( pd.DataFrame( { "a": [0, 1, 3, 5, -1], "b": [2, 1, 0, 0, 14], } ), "parquet", 0.1, pd.Timestamp("2018-01-01"), ), ( pd.DataFrame( { "a": [0, 1.0, 3232.22, -1.0, np.nan], "b": ["a", "b", "c", "ee", "14"], "c": [ dt.datetime(2018, 1, 1), dt.datetime(2019, 1, 1), dt.datetime(2020, 1, 1), dt.datetime(2021, 1, 1), dt.datetime(2022, 1, 1), ], "d": [ pd.Timestamp("2018-01-01"), pd.Timestamp("2018-01-01"), pd.Timestamp("2018-01-01"),
pd.Timestamp("2018-01-01")
pandas.Timestamp
#!/usr/licensed/anaconda3/2020.11/bin/python base = "/home/jdh4/bin/gpus" import sys sys.path = list(filter(lambda p: p.startswith("/usr"), sys.path)) sys.path.append(base) import json import subprocess import pandas as pd from dossier import ldap_plus if 1: rows = [] with open(base + "/utilization.json") as fp: for line in fp.readlines(): x = json.loads(line) rows.append(list(x.values())) df = pd.DataFrame(rows) del rows df.columns = ['timestamp', 'host', 'index', 'username', 'usage', 'jobid'] netids = list(df.username.drop_duplicates().values) if "root" in netids: netids.remove("root") if "OFFLINE" in netids: netids.remove("OFFLINE") else: cmd = "getent passwd | cut -d: -f1 | sort | uniq" output = subprocess.run(cmd, capture_output=True, shell=True) netids = output.stdout.decode("utf-8").split('\n') netids.remove('') netids.remove('+') univ_info = ldap_plus(sorted(netids)) df = pd.DataFrame(univ_info[1:], columns=univ_info[0]) cols = ['NETID', 'POSITION', 'DEPT', 'NAME', 'SPONSOR'] df = df[cols] df = df[
pd.notna(df.POSITION)
pandas.notna
import pandas as pd import os import string import csv import copy import typing from annotation.generation.annotation_to_template import run_wikifier as get_wikifier_result from pathlib import Path from collections import defaultdict """ How to use: Step 1: load file b. call "load_xlsx" send with one file path Step 2: generate file call "generate" after you loaded the file the output folder location and column name config (optional) if needed if column name config not given or partial not given the system will use: Example file: https://docs.google.com/spreadsheets/d/1NuTmRIxpy460S4CRdP6XORKFILssOby_RxiFbONXwv0/edit#gid=756069733 For attribute file: Assume "Property" column exist and it is the node column Assume "Attribute" column exist and it is the label column For unit file: Assume "Unit" column exist and it is the node column Assume "Q-Node" column exist and it is the label column """ stop_punctuation = string.punctuation TRANSLATOR = str.maketrans(stop_punctuation, ' ' * len(stop_punctuation)) # deprecated! not use def load_csvs(dataset_file: str, attributes_file: str, units_file: str): loaded_file = {} files = [dataset_file, attributes_file, units_file] file_type = ["dataset_file", "attributes_file", "units_file"] for each_file, each_file_type in zip(files, file_type): if each_file: if not os.path.exists(each_file): raise ValueError("{} {} not exist!".format(each_file_type, each_file)) loaded_file[each_file_type] = pd.read_csv(each_file) return loaded_file def load_xlsx(input_file: str, sheet_name_config: dict = None): loaded_file = {} sheet_names = pd.ExcelFile(input_file).sheet_names if not sheet_name_config: sheet_name_config = {"dataset_file": "Dataset", "attributes_file": "Attributes", "units_file": "Units", "extra_edges": "Extra Edges" } for k, v in sheet_name_config.items(): if v not in sheet_names: raise ValueError("Sheet name {} used for {} does not found!".format(v, k)) loaded_file[k] = pd.read_excel(input_file, v) optional_sheet_name_config = { "wikifier": "Wikifier", "qualifiers": "Qualifiers", "Wikifier_t2wml": "Wikifier_t2wml", "Wikifier Columns": "Wikifier Columns" } for k, v in optional_sheet_name_config.items(): if v not in sheet_names: loaded_sheet = None else: loaded_sheet = pd.read_excel(input_file, v) loaded_file[k] = loaded_sheet return loaded_file def generate(loaded_file: dict, output_path: str = ".", column_name_config=None, to_disk=True, datamart_properties_file: str = None, dataset_qnode: str = None, dataset_id: str = None, debug: bool = False, ) -> typing.Optional[dict]: """ The main entry function for generating datamart files from template input, base on input parameter `to_disk`, the output can be None or dict of dataframe """ if column_name_config is None: column_name_config = {} if "attributes_file_node_column_name" not in column_name_config: column_name_config["attributes_file_node_column_name"] = "Property" if "attributes_file_node_label_column_name" not in column_name_config: column_name_config["attributes_file_node_label_column_name"] = "Attribute" if "unit_file_node_column_name" not in column_name_config: column_name_config["unit_file_node_column_name"] = "Q-Node" if "unit_file_node_label_column_name" not in column_name_config: column_name_config["unit_file_node_label_column_name"] = "Unit" if len(loaded_file["dataset_file"]["dataset"].unique()) > 1: raise ValueError("One dataset file should only contains 1 dataset ID in `dataset` column.") if loaded_file["wikifier"] is not None: extra_wikifier_dict = get_wikifier_part(loaded_file["wikifier"]) else: extra_wikifier_dict = {} # update 2020.7.22: accept user specified dataset id if given if dataset_qnode is None: dataset_qnode = loaded_file["dataset_file"]["dataset"].iloc[0] if len(dataset_qnode) == 0 or not dataset_qnode[0] == 'Q': raise Exception('First column of "Dataset" tab has be Qnodes') if dataset_id is None: # dataset_id = loaded_file["dataset_file"]["dataset"].iloc[0] result = loaded_file['dataset_file']['node2'][loaded_file["dataset_file"]['label'] == 'P1813'] if len(result) == 0: raise Exception('Missing dataset identifier. Missing "P1813" edge in "Dataset" tab') else: dataset_id = result.iloc[0] if dataset_id[0] == '"' and dataset_id[-1] == '"': dataset_id = dataset_id[1:-1] # generate files memo = defaultdict(dict) kgtk_properties_df = _generate_KGTK_properties_file(loaded_file["attributes_file"], loaded_file["qualifiers"], dataset_qnode, dataset_id, memo, column_name_config["attributes_file_node_column_name"], column_name_config["attributes_file_node_label_column_name"]) kgtk_variables_df = _generate_KGTK_variables_file(loaded_file["attributes_file"], dataset_qnode, dataset_id, memo, column_name_config["attributes_file_node_column_name"], column_name_config["attributes_file_node_label_column_name"]) kgtk_units_df = _generate_KGTK_units_file(loaded_file["units_file"], dataset_qnode, memo, column_name_config["unit_file_node_column_name"], column_name_config["unit_file_node_label_column_name"]) wikifier_df = _generate_wikifier_file(memo, extra_wikifier_dict) if loaded_file["Wikifier_t2wml"] is not None: wikifier_df = pd.concat([wikifier_df, loaded_file["Wikifier_t2wml"]]) dataset_df = _generate_dataset_file(loaded_file["dataset_file"]) extra_edges_df = _generate_extra_edges_file(loaded_file["extra_edges"], memo) output_files = {"kgtk_properties.tsv": kgtk_properties_df, "kgtk_variables.tsv": kgtk_variables_df, "kgtk_units.tsv": kgtk_units_df, "wikifier.csv": wikifier_df, "extra_edges.tsv": extra_edges_df, "dataset.tsv": dataset_df} if datamart_properties_file is not None: datamart_schema_df = pd.read_csv(datamart_properties_file, sep='\t') output_files['datamart_schema_properties.tsv'] = datamart_schema_df # save to disk if required or running in debug mode if to_disk or debug: os.makedirs(output_path, exist_ok=True) for each_file_name, each_file in output_files.items(): output_file_path = os.path.join(output_path, each_file_name) if each_file_name.endswith(".csv"): each_file.to_csv(output_file_path, index=False) elif each_file_name.endswith(".tsv"): each_file.to_csv(output_file_path, sep='\t', index=False, quoting=csv.QUOTE_NONE) if not to_disk: return output_files def _generate_KGTK_properties_file(input_df: pd.DataFrame, qualifier_df: pd.DataFrame, dataset_q_node: str, dataset_id: str, memo: dict, node_column_name="Property", node_label_column_name="Attribute", qualifier_column_name="Qualifiers") -> pd.DataFrame: """ sample format for each property (totally 3 rows) Please note that data type may change (to String, Date) base on the given input template file id node1 label node2 0 Paid-security-002-data_type Paid-security-002 data_type Quantity 1 Paid-security-002-P31 Paid-security-002 P31 Q18616576 2 Paid-security-002-label Paid-security-002 label UN :return: kgtk format property dataframe """ node_number = 1 output_df_list = [] input_df = input_df.fillna("") has_relationship = 'Relationship' in input_df.columns and 'Role' in input_df.columns for _, each_row in input_df.iterrows(): node_number += 1 if has_relationship: role = each_row["Role"].upper() else: role = "" if each_row[node_column_name] == "": node_label = to_kgtk_format_string(each_row[node_label_column_name]) node_id = _generate_p_nodes(role, dataset_q_node, node_number, memo, each_row['Attribute']) # get type if specified if "type" in each_row: value_type = each_row["type"] else: value_type = "Quantity" labels = ["wikidata_data_type", "data_type", "P31", "label"] node2s = [value_type, value_type, "Q18616576", node_label] for i in range(len(labels)): id_ = "{}-{}".format(node_id, labels[i]) output_df_list.append({"id": id_, "node1": node_id, "label": labels[i], "node2": node2s[i]}) else: node_id = each_row[node_column_name] # add to memo for future use memo["property"][node_id] = each_row[node_label_column_name] if "Role" in each_row: memo["property_role"][node_id] = each_row["Role"].lower() # add qualifier part if we have if qualifier_df is not None: qualifier_df = qualifier_df.fillna("") for _, each_row in qualifier_df.iterrows(): node_number += 1 if each_row[node_column_name] == "": node_id = _generate_p_nodes("QUALIFIER", dataset_q_node, node_number, memo, each_row["Attribute"]) memo["qualifier_target_nodes"][each_row[qualifier_column_name]] = memo["property_name_to_id"][ each_row[node_label_column_name]] memo["qualifier_name_to_id"][each_row[qualifier_column_name]] = node_id memo["property"][node_id] = each_row[qualifier_column_name] labels = ["data_type", "P31", "label"] node2s = ["String", "Q18616576", to_kgtk_format_string(each_row[qualifier_column_name])] for i in range(3): id_ = "{}-{}".format(node_id, labels[i]) output_df_list.append({"id": id_, "node1": node_id, "label": labels[i], "node2": node2s[i]}) else: memo["property"][each_row[node_column_name]] = each_row[qualifier_column_name] memo["qualifier_name_to_id"][each_row[qualifier_column_name]] = each_row[node_column_name] memo["qualifier_target_nodes"][each_row[qualifier_column_name]] = memo["property_name_to_id"][ each_row[node_label_column_name]] # get output output_df = pd.DataFrame(output_df_list) # in case of empty df if output_df.shape == (0, 0): output_df = pd.DataFrame(columns=['id', 'node1', 'label', 'node2']) return output_df def _generate_KGTK_variables_file(input_df: pd.DataFrame, dataset_q_node: str, dataset_id: str, memo: dict, node_column_name="Property", node_label_column_name="Attribute"): """ sample format for each variable, totally 10 + n (n is the count of related qualifiers) rows "id" "node1" "label" "node2" 0 QVARIABLE-OECD-002-label QVARIABLE-002 label "GDP per capita" 1 QVARIABLE-OECD-002-P1476 QVARIABLE-002 P1476 "GDP per capita" 2 QVARIABLE-OECD-002-description QVARIABLE-002 description "GDP per capita variable in OECD" 3 QVARIABLE-OECD-002-P31-1 QVARIABLE-002 P31 Q50701 4 QVARIABLE-OECD-002-P2006020002-P248 QVARIABLE-002 P2006020002 P585 5 QVARIABLE-OECD-002-P2006020002-P248 QVARIABLE-002 P2006020002 P248 6 QVARIABLE-OECD-002-P1687-1 QVARIABLE-002 P1687 PVARIABLE-OECD-002 7 QVARIABLE-OECD-002-P2006020004-1 QVARIABLE-002 P2006020004 QOECD 8 QVARIABLE-OECD-002-P1813 QVARIABLE-002 P1813 "gdp_per_capita" 9 QVARIABLE-OECD-P2006020003-QOECD002 QVARIABLE P2006020003 QOECD-002 ------------------------------------------------- 10 QVARIABLE-OECD-P2006020002-PQUALIFIER-OECD-101 QVARIABLE P2006020003 PQUALIFIER-OECD-101 11 QVARIABLE-OECD-P2006020002-PQUALIFIER-OECD-102 QVARIABLE P2006020003 PQUALIFIER-OECD-102 ------------------------------------------------- 12 ... QVARIABLE-002 P2010050001 FactorClass:EconomicAgricuturalCapability 13 ... QVARIABLE-002 P2010050001 Relevance:1 """ node_number = 1 output_df_list = [] short_name_memo = set() input_df = input_df.fillna("") all_qualifier_properties = [] for node, role in memo["property_role"].items(): if role == "qualifier": all_qualifier_properties.append(node) has_relationship = 'Relationship' in input_df.columns and 'Role' in input_df.columns for _, each_row in input_df.iterrows(): if has_relationship: role = each_row["Role"].upper() else: role = "" # not add QUALIFIER to variables tab if has_relationship and role == "QUALIFIER": continue target_properties = [] # update 2020.7.22: consider role and relationship for new template file if has_relationship: relations = each_row['Relationship'] # qualifier should not have qualifier properties if each_row['Role'].lower() != "qualifier": if relations == "": target_properties = all_qualifier_properties else: for each_relation in relations.slipt("|"): if each_relation not in memo["property_name_to_id"]: raise ValueError( "Annotation specify variable {} not exist in input data.".format(each_relation)) target_properties.append(memo["property_name_to_id"][each_relation]) node_number += 1 if each_row[node_column_name] == "": # update 2020.7.23, also add role for P nodes p_node_id = _generate_p_nodes(role, dataset_q_node, node_number, memo, each_row["Attribute"]) else: p_node_id = each_row[node_column_name] # update 2020.7.22: change to add role in Q node id q_node_id = _generate_q_nodes(role, dataset_q_node, node_number) memo["variable"][q_node_id] = each_row[node_label_column_name] fixed_labels = ["label", "P1476", "description", # 1-3 "P31", "P2006020002", "P2006020002", # 4-6 "P1687", "P2006020004", "P1813", # 7-9 "P2006020003"] labels = fixed_labels + len(target_properties) * ["P2006020002"] if each_row['label'] == "": node2_label = to_kgtk_format_string(each_row[node_label_column_name]) else: node2_label = to_kgtk_format_string(each_row['label']) if each_row['description'] == "": node2_description = to_kgtk_format_string("{} in {}".format(each_row[node_label_column_name], dataset_id)) else: node2_description = to_kgtk_format_string(each_row['description']) node2s = [node2_label, # to_kgtk_format_string(each_row[node_label_column_name]), # 1 node2_label, # to_kgtk_format_string(each_row[node_label_column_name]), # 2 node2_description, # to_kgtk_format_string("{} in {}".format(each_row[node_label_column_name], dataset_id)), # 3 "Q50701", "P585", "P248", # 4(Q50701 = variable), 5(P585 = Point in time), 6(P249 = stated in) p_node_id, # 7 dataset_q_node, # 8 to_kgtk_format_string(get_short_name(short_name_memo, each_row[node_label_column_name])), # 9 q_node_id # 10 ] + target_properties node1s = [q_node_id] * (len(fixed_labels) - 1) + [dataset_q_node] + [q_node_id] * len(target_properties) # Add tag edges if 'tag' in input_df.columns and each_row['tag']: tag_values = [to_kgtk_format_string(x) for x in each_row['tag'].split('|')] node1s += [q_node_id] * len(tag_values) labels += ['P2010050001'] * len(tag_values) node2s += tag_values # add those nodes for i, each_label in enumerate(labels): id_ = _generate_edge_id(node1s[i], labels[i], node2s[i]) output_df_list.append({"id": id_, "node1": node1s[i], "label": labels[i], "node2": node2s[i]}) # get output output_df = pd.DataFrame(output_df_list) # in case of empty df if output_df.shape == (0, 0): output_df = pd.DataFrame(columns=['id', 'node1', 'label', 'node2']) return output_df def _generate_KGTK_units_file(input_df: pd.DataFrame, dataset_q_node: str, memo: dict, node_column_name="Q-Node", node_label_column_name="Unit") -> pd.DataFrame: """ sample format for each unit (totally 2 rows) id node1 label node2 0 QUNIT-aid-security-U002-label Qaid-security-U002 label person 1 QUNIT-aid-security-U002-P31 Qaid-security-U002 P31 Q47574 :return: """ node_number = 1 count = 0 output_df_dict = {} input_df = input_df.fillna("") for _, each_row in input_df.iterrows(): node_number += 1 if each_row[node_column_name] == "": # update 2020.7.22: change to use QUNIT* instead of Q* node_id = _generate_q_nodes("UNIT", dataset_q_node, node_number) labels = ["label", "P31"] node2s = [to_kgtk_format_string(each_row[node_label_column_name]), "Q47574"] memo["unit"][node_id] = each_row[node_label_column_name] for i in range(2): id_ = _generate_edge_id(node_id, labels[i], node2s[i]) output_df_dict[count] = {"id": id_, "node1": node_id, "label": labels[i], "node2": node2s[i]} count += 1 else: memo["unit"][each_row[node_column_name]] = each_row[node_label_column_name] # get output output_df = pd.DataFrame.from_dict(output_df_dict, orient="index") # in case of empty df if output_df.shape == (0, 0): output_df = pd.DataFrame(columns=['id', 'node1', 'label', 'node2']) return output_df def _generate_wikifier_file(memo, extra_wikifier_dict): """ generate the wikifier part from template(those properties, variables, units generated in above functions) Sample file looks like: column row value context item 0 "" "" UN property Paid-security-002 1 "" "" INGO property Paid-security-003 2 "" "" LNGO/NRCS property Paid-security-004 3 "" "" ICRC property Paid-security-005 4 "" "" UN variable Qaid-security-002 5 "" "" INGO variable Qaid-security-003 6 "" "" person unit Qaid-security-U002 """ output_df_list = [] for memo_type, each_memo in memo.items(): if memo_type in {"property", "unit", "variable"}: for node, label in each_memo.items(): output_df_list.append({"column": "", "row": "", "value": label, "context": memo_type, "item": node}) # for those specific alias of wikifier names combo = (label, memo_type) if combo in extra_wikifier_dict: output_df_list.append( {"column": "", "row": "", "value": extra_wikifier_dict[combo], "context": memo_type, "item": node}) # get output output_df = pd.DataFrame(output_df_list) return output_df def _generate_dataset_file(input_df: pd.DataFrame): """ A sample dataset file looks like: node1 label node2 id Qaid-security P31 Q1172284 aid-security-P31 Qaid-security label aid-security dataset aid-security-label Qaid-security P1476 aid-security dataset aid-security-P1476 Qaid-security description aid-security dataset aid-security-description Qaid-security P2699 aid-security aid-security-P2699 Qaid-security P1813 aid-security aid-security-P1813 :return: """ output_df = copy.deepcopy(input_df) ids = [] for _, each_row in output_df.iterrows(): ids.append("{}-{}".format(each_row["dataset"], each_row["label"])) output_df['id'] = ids # Assume the the first column are already Q nodes # output_df["dataset"] = output_df['dataset'].apply(lambda x: "Q" + x) output_df = output_df.rename(columns={"dataset": "node1"}) # check double quotes output_df = _check_double_quotes(output_df, check_content_startswith=True) return output_df def _generate_extra_edges_file(input_df: pd.DataFrame, memo: dict): qualifier_extra_edges_list = [] if "qualifier_target_nodes" in memo: for k, v in memo['qualifier_target_nodes'].items(): qualifier_extra_edges_list.append({"id": "", "node1": v, "label": "P2006020002", "node2": memo["qualifier_name_to_id"][k]}) output_df = pd.concat([input_df, pd.DataFrame(qualifier_extra_edges_list)]) # check double quotes output_df = _check_double_quotes(output_df, label_types={"label", "description"}) return output_df # update 2020.7.24, add support of run wikifier and record t2wml wikifier file in template def run_wikifier(input_folder_path: str, wikifier_columns_df: pd.DataFrame, template_output_path: str): """ run wikifier on all table files(csv, xlsx, xls) and add the new wikifier results to "wikifier.csv" file :param input_folder_path: :param wikifier_columns_df: :param template_output_path: :return: """ new_wikifier_df_list = [] input_data = [] for each_file in os.listdir(input_folder_path): if each_file.startswith("~") or each_file.startswith("."): continue each_file = os.path.join(input_folder_path, each_file) if each_file.endswith(".csv"): input_data.append(pd.read_csv(each_file, header=None)) elif each_file.endswith(".xlsx") or each_file.endswith("xls"): for each_sheet in get_sheet_names(each_file): input_data.append(pd.read_excel(each_file, each_sheet, header=None)) for each_df in input_data: each_df = each_df.fillna("") # get only data part that need to be parsed for _, each_row in wikifier_columns_df.iterrows(): target_column_number = ord(each_row['Columns']) - ord("A") start_row, end_row = each_row["Rows"].split(":") start_row = int(start_row) - 1 if end_row == "": end_row = len(each_df) else: end_row = int(end_row) if target_column_number >= each_df.shape[1] or end_row > each_df.shape[0]: print("Required to wikify on column No.{} and end row at {} but the input dataframe shape is only {}". \ format(target_column_number, end_row, each_df.shape)) continue each_df = each_df.iloc[start_row:end_row, :] # run wikifier new_wikifier_df_list.extend(get_wikifier_result(input_df=each_df, target_col=target_column_number, wikifier_type="country")) wikified_values = set([each["value"] for each in new_wikifier_df_list]) remained_df_part = each_df[~each_df.iloc[:, target_column_number].isin(wikified_values)] new_wikifier_df_list.extend(get_wikifier_result(input_df=remained_df_part, target_col=target_column_number, wikifier_type="ethiopia")) new_wikifier_df = pd.DataFrame(new_wikifier_df_list) # combine the previous wikifier file if exists output_wikifier_file_path = os.path.join(template_output_path, "wikifier.csv") if os.path.exists(output_wikifier_file_path): new_wikifier_df = pd.concat([pd.read_csv(output_wikifier_file_path), new_wikifier_df]) # save to disk new_wikifier_df.to_csv(output_wikifier_file_path, index=False) def get_short_name(short_name_memo, input_str): words_processed = str(input_str).lower().translate(TRANSLATOR).split() short_name = "_".join(words_processed) if short_name[0].isnumeric(): short_name = "_" + short_name i = 0 while short_name in short_name_memo: i += 1 short_name = "_".join(words_processed) + "_{}".format(i) short_name_memo.add(short_name) return short_name def get_wikifier_part(wikifier_input_df: pd.DataFrame): result = {} for _, each_row in wikifier_input_df.iterrows(): result[(each_row["attribute"], each_row["context"])] = (each_row["value"]) return result def get_sheet_names(file_path): """ This function returns the first sheet name of the excel file :param file_path: :return: """ file_extension = Path(file_path).suffix is_csv = True if file_extension.lower() == ".csv" else False if is_csv: return [Path(file_path).name] xl =
pd.ExcelFile(file_path)
pandas.ExcelFile
# ============================================================================== # This file defines a class that contains a method that takes in a # file name and then using delta loads the wave files for that subject. # # Based on a configuration dictionary that is provided to the method it # will segregate the files up into a train and test set. # # author: <NAME> # ============================================================================== import pandas as pd import delta.compat as tf from pathlib import Path from delta.data.frontend.read_wav import ReadWav # ============================================================================== # Description: # This method takes in a file name and a set of configuration data and loads # the wav file. # # author: <NAME> # # inputs: # fileName - The file name of the wav file to load. # func_config - A dictonary containing settings. # # output: # The loaded wav object # ============================================================================== def LoadWavFile(fileName, func_config): config = {'sample_rate': func_config['sample_rate']} read_wav = ReadWav.params(config).instantiate() data, srate = read_wav(fileName) return data # ============================================================================== # This method loads wave files into a pandas array. # # Based on a configuration dictionary that is provided to the method it # will segregate the files up into a train and test set. # # author: <NAME> # ============================================================================== # ============================================================================== # Description: # This file loads the subject numbers from a file and then load all of # the requsted files for each of the listed subjects into a DataFrame. # # author: <NAME> # # inputs: # fileName - The file name of the wav file to load. # func_config - A dictonary containing settings. # # output: # A data frame containing the subject ID, sample rate of the file and the # wav file loaded. # ============================================================================== def LoadSubjects(fileName, func_config): dfData =
pd.DataFrame({}, columns=['Subject', 'sample_rate', 'wavFile'])
pandas.DataFrame
# -*- coding: utf-8 -*- # Dirichlet Mixing Module v1.2 # Implemented by <NAME>, based on original MatLab code by <NAME>. # Mathematics described in Rudge et al. import numpy as np import pandas as pd import matplotlib.pyplot as plt # Mean composition of melts from all lithologies def mean_comp_total(f,w,c): return np.sum(f*c*w) # Import a Melts output file def Import_Melts_output(filename,dX=0.0001,RudgeMethod=False): """Import a Melts csv file and recasts the melting column in terms of equal dX increments. Converts pressure from bars to GPa. Returns a pandas dataframe. Parameters ---------- filename: string Name of the file (and path relative to script) to import dX: float Discretization interval. Default 0.01%. RudgeMethod: bool Use the Rudge method for calculating melt fraction from the MELTS input. I think this method is erroneous, but have kept it so his results may be reproduced. """ meltsFile = pd.read_csv(filename,skiprows=1) if RudgeMethod == True: # Calculate Melt Fraction meltsFile['F'] = (100-meltsFile.Mass)/100 # Calculate residual porosity ResidualPorosity = meltsFile.F.iloc[0] X = (meltsFile.F - ResidualPorosity)/(1-ResidualPorosity) else: X = (meltsFile.Mass[0]-meltsFile.Mass)/meltsFile.Mass[0] # Find last X=0 term during upwelling (and first DeltaX>0 term) # Find last melting step MeltingBounds = [0,0] MeltingBounds[0] = np.argmin(X[X>0]) - 1 MeltingBounds[1] = np.argmax(X) # Make list of columns for new array columns = ['X','P','T'] columns = columns + (meltsFile.columns[3:].tolist()) # Set up list of X values to map all other variables to X_to_map = np.arange(X[MeltingBounds[0]],X[MeltingBounds[1]],dX) # Create an array of zeroes with the length of the number of rows needed in the dataframe EmptyColumns = np.array([np.zeros(np.shape(X_to_map))]*np.shape(columns)[0]).T # Create Empty Dataframe d = pd.DataFrame(EmptyColumns, columns=columns) # Start filling Dataframe d.X = X_to_map d['T'] = np.interp(d.X,X,meltsFile.Temperature) d['P'] = np.interp(d.X,X,meltsFile.Pressure)/1e4 # Map all the chemistry to the new X variable for col in columns[3:]: d[col] = np.interp(d.X,X,meltsFile[col]) return d # Import a Melts output file def Import_Katz_output(filename,dX=0.0001,MajorElements=pd.Series([7.48,8.51],index=['MgO','FeO']),WalterComps=False,file=True): """Import a numpy file generated by the single melting region function of the DualLithologyMelting script and recasts the melting column in terms of equal dX increments. Returns a pandas dataframe. Parameters ---------- filename: string Name of the file (and path relative to script) to import dX: float Discretization interval. Default 0.01%. MajorElements: series Major Element concentrations to add to each fractional melt. Same composition will apply to all melts. MgO and FeO must always be set, otherwise some functionality of the dirichlet module won't work (but can be ignored). WalterComps: bool If true the major element composition of the melts will be calculated using the parameterisation of the Walter KR4003 melting experiments by Duncan et al. (2017). file: bool If true filename is interpreted as a file name, if false, filename is interpreted as the array object itself. """ if file == True: mr_raw = np.load(filename) else: mr_raw = filename mr = np.zeros([3,np.shape(mr_raw)[1]]) mr[0] = mr_raw[0] mr[1] = mr_raw[1] mr[2] = mr_raw[3] mr = pd.DataFrame(mr.T,columns=['P','T','X']) # Find last X=0 term during upwelling (and first DeltaX>0 term) # Find last melting step MeltingBounds = [0,0] MeltingBounds[0] = np.argmin(mr.X[mr.X>0]) - 1 MeltingBounds[1] = np.argmax(mr.X) # Make list of columns for new array columns = ['X','P','T'] if WalterComps == False: columns = columns + MajorElements.index.tolist() # Set up list of X values to map all other variables to X_to_map = np.arange(mr.X[MeltingBounds[0]],mr.X[MeltingBounds[1]],dX) # Create an array of zeroes with the length of the number of rows needed in the dataframe EmptyColumns = np.array([np.zeros(np.shape(X_to_map))]*np.shape(columns)[0]).T # Create Empty Dataframe d =
pd.DataFrame(EmptyColumns, columns=columns)
pandas.DataFrame
import pandas as pd import numpy as np import matplotlib.pyplot as plt from IPython.core.display import HTML def data(): df = pd.read_stata('data, R and html files/1section.dta') df['loansgdp'] = df.tloans/df.gdp return df.head() def fig21(): # dynamics of loans to gdp ratio over time for USA, Germany, Australia, France df = pd.read_stata('data, R and html files/1section.dta') usa = df[df.country == 'USA'] ger = df[df.country == 'Germany'] aus = df[df.country == 'Australia'] fr = df[df.country == 'France'] uk = df[df.country == 'UK'] sp = df[df.country == 'Spain'] fig = plt.figure(figsize=(10,5)) plt.suptitle('Figure 2.1 Ratio of private loans to GDP in selected developed economies') plt.subplot(2, 3, 1) plt.plot(usa.year, usa.loansgdp, color='c') plt.title('USA') plt.subplot(2, 3, 2) plt.plot(ger.year, ger.loansgdp, color='c') plt.title('Germany') plt.subplot(2, 3, 3) plt.plot(aus.year, aus.loansgdp, color='c') plt.title('Australia') plt.subplot(2, 3, 4) plt.plot(fr.year, fr.loansgdp, color='c') plt.title('France', y=-0.35) plt.subplot(2, 3, 5) plt.plot(uk.year, uk.loansgdp, color='c') plt.title('UK', y=-0.35) plt.subplot(2, 3, 6) plt.plot(sp.year, sp.loansgdp, color='c') plt.title('Spain', y=-0.35) fig.text(0.05,-0.08,'Source: Jorda et al.(2013) set'); plt.show() def prep1(): #preparation of excess credit dummy df = pd.read_stata('data, R and html files/1section.dta') df['loansgdp'] = df.tloans/df.gdp df['diff_loansgdp'] = 100*df['loansgdp'].diff() loans_table = df.pivot_table(values = 'diff_loansgdp', index = 'country', columns = 'year') pd.options.display.float_format = '{:,.3f}'.format mean_year = loans_table.mean() mean_all = mean_year.mean() df['excredit'] = (df['diff_loansgdp'] > mean_all).astype(int) #data preparation df['year'] = df['year'].astype('int') df['pk_fin'] = df['pk_fin'].astype('int') df['pk_norm'] = df['pk_norm'].astype('int') df['lrgdp'] = np.log(df.rgdp) #copy to the file for R df.to_stata('data, R and html files/1section1.dta') df = df.loc[(df['pk_fin'] == 1) & (df['excredit'] == 1)] df = df[['year','country', 'pk_norm', 'pk_fin', 'excredit', 'pop', 'gdp', 'rgdp', 'lrgdp', 'tloans', 'loansgdp', 'diff_loansgdp', 'dlcpi', 'dlriy', 'stir', 'ltrate', 'ldlrgdp', 'ldlcpi', 'ldlriy', 'lstir', 'lltrate']] return df.head() def data2(): #obtaining the data df = pd.read_stata('data, R and html files/2section.dta') pd.set_option('display.float_format', lambda x: '%.3f' % x) df['year'] = df['year'].astype('int') df = df[['year', 'state', 'stateid', 'Total_GSP', 'cpi', 'population', 'spend', 'employ_CES', 'Dcpi_ACCRA']] #state output #output in millions df['out'] = df.Total_GSP*1000000 #real output df['rout'] = df.out/df.cpi #real output per capita df['rcapout'] = df.rout/df.population #percent change of real output per capita df['Drcapout'] = df.sort_values(['year']).groupby('state')['rcapout'].pct_change() #state spending #real spending df['rspend'] = df.spend/df.cpi #real spending per capita df['rcapspend'] = df.rspend/df.population #real p.c.spending change as % of real p.c. output df['rcapspend_lag'] = df.sort_values('year').groupby(['state'])['rcapspend'].shift(1) df['rcapout_lag'] = df.sort_values('year').groupby(['state'])['rcapout'].shift(1) df['Drcapspend'] = (df.rcapspend - df.rcapspend_lag)/df.rcapout_lag #state employment #employment in thousands df['emp'] = df.employ_CES*1000 #% change in employment rate df['emp_lag'] = df.sort_values('year').groupby(['state'])['emp'].shift(1) df['population_lag'] = df.sort_values('year').groupby(['state'])['population'].shift(1) df['Demp'] = (df.emp/df.population - df.emp_lag/df.population_lag)/(df.emp_lag/df.population_lag) #state population #% change of population df['Dpop'] = (df.population-df.population_lag)/df.population_lag #aggregate population df1 = df.groupby('year')['population'].sum() df1 = df1.to_frame().reset_index() df1 = pd.concat([df1]*51) df1 = df1.drop(columns="year") df1 = df1.to_numpy() df['population_nat'] = df1 #aggregate output #aggregation of real output df1 = df.groupby('year')['rout'].sum() df1 = df1.to_frame().reset_index() df1 = pd.concat([df1]*51) df1 = df1.drop(columns="year") df1 = df1.to_numpy() df['rout_nat'] = df1 #agg real output per capita df['rcapout_nat'] = df.rout_nat/df.population_nat #percent change of real output per capita df['Drcapout_nat'] = df.sort_values(['year']).groupby('state')['rcapout_nat'].pct_change() #aggregate spending #aggregation of real spending summ_spend = df.groupby('year')['rspend'].sum() summ_spend = summ_spend.to_frame().reset_index() df1 = pd.concat([summ_spend]*51) df1 = df1.drop(columns="year") df1 = df1.to_numpy() df['rspend_nat'] = df1 #total national real spending per capita df['rcapspend_nat'] = df.rspend_nat/df.population_nat #change of national real (work) p.c. spending as % of real national output p.c. df['rcapspend_nat_lag'] = df.sort_values('year').groupby(['state'])['rcapspend_nat'].shift(1) df['rcapout_nat_lag'] = df.sort_values('year').groupby(['state'])['rcapout_nat'].shift(1) df['Drcapspend_nat'] = (df.rcapspend_nat - df.rcapspend_nat_lag)/df.rcapout_nat_lag df2 = df[['year', 'state', 'Drcapout', 'Drcapspend', 'Drcapspend_nat', 'Demp', 'Dpop']] df2.to_stata('data, R and html files/2section2.dta') return df2.head() def fig31(): #obtaining the data df = pd.read_stata('data, R and html files/2section.dta') pd.set_option('display.float_format', lambda x: '%.3f' % x) df['year'] = df['year'].astype('int') df = df[['year', 'state', 'stateid', 'Total_GSP', 'cpi', 'population', 'spend', 'employ_CES', 'Dcpi_ACCRA']] #state output #output in millions df['out'] = df.Total_GSP*1000000 #real output df['rout'] = df.out/df.cpi #state spending #real spending df['rspend'] = df.spend/df.cpi #real spending per capita #data for states states = df[['year', 'state', 'rspend', 'rout']] IL = states[states.state == 'IL'] CA = states[states.state == 'CA'] #aggregate data summsp = df.groupby('year')['rspend'].sum() summsp = summsp.to_frame().reset_index() summout = df.groupby('year')['rout'].sum() summout = summout.to_frame().reset_index() summout = summout.drop(columns="year") summout = summout.to_numpy() summsp['rout'] = summout summsp['state'] = "All" #merge 3 datasets st =
pd.concat([IL, CA])
pandas.concat
import numpy as np import pandas as pd import matplotlib.pyplot as plt import sklearn import seaborn import scipy.io as scio def load_dataset(): breastw_path = 'duibi_dataset/breastw.mat' data = scio.loadmat(breastw_path) data_train_data = data.get('X') # 取出字典里的data data_train_label = data.get('y') # 取出字典里的label ccdata =
pd.DataFrame(data_train_data)
pandas.DataFrame
from arche import SH_URL from arche.readers.items import Items, CollectionItems, JobItems from conftest import Collection, Job import numpy as np import pandas as pd import pytest @pytest.mark.parametrize( "df, expected_raw, expected_df", [ (pd.DataFrame({"0": [0]}), [{"0": 0}], pd.DataFrame({"0": [0]})), ( pd.DataFrame({"0": [0], "_key": ["0"]}), [{"0": 0, "_key": "0"}],
pd.DataFrame({"0": [0], "_key": ["0"]})
pandas.DataFrame
import sys sys.path.append('../mss') import matplotlib.pyplot as plt import visreader as mvis import mssmain as mss import pandas as pd import numpy as np from tqdm import tqdm def mz_selector(scans, mz_list, export_name): sample_list = [] for mz in tqdm(mz_list): rt, i = ms_chromatogram_list(scans, mz, 20) count = 0 for ints in i: if ints >= 5000: count += 1 if count == 7: sample_list.append([mz, i]) break else: count = 0 continue d_sample =
pd.DataFrame(sample_list)
pandas.DataFrame
import unittest from unittest.mock import patch, PropertyMock import time import mt5_correlation.correlation as correlation import pandas as pd from datetime import datetime, timedelta from test_mt5 import Symbol import random import os class TestCorrelation(unittest.TestCase): # Mock symbols. 4 Symbols, 3 visible. mock_symbols = [Symbol(name='SYMBOL1', visible=True), Symbol(name='SYMBOL2', visible=True), Symbol(name='SYMBOL3', visible=False), Symbol(name='SYMBOL4', visible=True), Symbol(name='SYMBOL5', visible=True)] # Start and end date for price data and mock prices: base; correlated; and uncorrelated. start_date = None end_date = None price_columns = None mock_base_prices = None mock_correlated_prices = None mock_uncorrelated_prices = None def setUp(self): """ Creates some price data fro use in tests :return: """ # Start and end date for price data and mock price dataframes. One for: base; correlated; uncorrelated and # different dates. self.start_date = datetime(2021, 1, 1, 1, 5, 0) self.end_date = datetime(2021, 1, 1, 11, 30, 0) self.price_columns = ['time', 'close'] self.mock_base_prices = pd.DataFrame(columns=self.price_columns) self.mock_correlated_prices = pd.DataFrame(columns=self.price_columns) self.mock_uncorrelated_prices = pd.DataFrame(columns=self.price_columns) self.mock_correlated_different_dates = pd.DataFrame(columns=self.price_columns) self.mock_inverse_correlated_prices = pd.DataFrame(columns=self.price_columns) # Build the price data for the test. One price every 5 minutes for 500 rows. Base will use min for price, # correlated will use min + 5 and uncorrelated will use random for date in (self.start_date + timedelta(minutes=m) for m in range(0, 500*5, 5)): self.mock_base_prices = self.mock_base_prices.append(pd.DataFrame(columns=self.price_columns, data=[[date, date.minute]])) self.mock_correlated_prices = \ self.mock_correlated_prices.append(pd.DataFrame(columns=self.price_columns, data=[[date, date.minute + 5]])) self.mock_uncorrelated_prices = \ self.mock_uncorrelated_prices.append(pd.DataFrame(columns=self.price_columns, data=[[date, random.randint(0, 1000000)]])) self.mock_correlated_different_dates = \ self.mock_correlated_different_dates.append(pd.DataFrame(columns=self.price_columns, data=[[date + timedelta(minutes=100), date.minute + 5]])) self.mock_inverse_correlated_prices = \ self.mock_inverse_correlated_prices.append(pd.DataFrame(columns=self.price_columns, data=[[date, (date.minute + 5) * -1]])) @patch('mt5_correlation.mt5.MetaTrader5') def test_calculate(self, mock): """ Test the calculate method. Uses mock for MT5 symbols and prices. :param mock: :return: """ # Mock symbol return values mock.symbols_get.return_value = self.mock_symbols # Correlation class cor = correlation.Correlation(monitoring_threshold=1, monitor_inverse=True) # Calculate for price data. We should have 100% matching dates in sets. Get prices should be called 4 times. # We don't have a SYMBOL3 as this is set as not visible. Correlations should be as follows: # SYMBOL1:SYMBOL2 should be fully correlated (1) # SYMBOL1:SYMBOL4 should be uncorrelated (0) # SYMBOL1:SYMBOL5 should be negatively correlated # SYMBOL2:SYMBOL5 should be negatively correlated # We will not use p_value as the last set uses random numbers so p value will not be useful. mock.copy_rates_range.side_effect = [self.mock_base_prices, self.mock_correlated_prices, self.mock_uncorrelated_prices, self.mock_inverse_correlated_prices] cor.calculate(date_from=self.start_date, date_to=self.end_date, timeframe=5, min_prices=100, max_set_size_diff_pct=100, overlap_pct=100, max_p_value=1) # Test the output. We should have 6 rows. S1:S2 c=1, S1:S4 c<1, S1:S5 c=-1, S2:S5 c=-1. We are not checking # S2:S4 or S4:S5 self.assertEqual(len(cor.coefficient_data.index), 6, "There should be six correlations rows calculated.") self.assertEqual(cor.get_base_coefficient('SYMBOL1', 'SYMBOL2'), 1, "The correlation for SYMBOL1:SYMBOL2 should be 1.") self.assertTrue(cor.get_base_coefficient('SYMBOL1', 'SYMBOL4') < 1, "The correlation for SYMBOL1:SYMBOL4 should be <1.") self.assertEqual(cor.get_base_coefficient('SYMBOL1', 'SYMBOL5'), -1, "The correlation for SYMBOL1:SYMBOL5 should be -1.") self.assertEqual(cor.get_base_coefficient('SYMBOL2', 'SYMBOL5'), -1, "The correlation for SYMBOL2:SYMBOL5 should be -1.") # Monitoring threshold is 1 and we are monitoring inverse. Get filtered correlations. There should be 3 (S1:S2, # S1:S5 and S2:S5) self.assertEqual(len(cor.filtered_coefficient_data.index), 3, "There should be 3 rows in filtered coefficient data when we are monitoring inverse " "correlations.") # Now aren't monitoring inverse correlations. There should only be one correlation when filtered cor.monitor_inverse = False self.assertEqual(len(cor.filtered_coefficient_data.index), 1, "There should be only 1 rows in filtered coefficient data when we are not monitoring inverse " "correlations.") # Now were going to recalculate, but this time SYMBOL1:SYMBOL2 will have non overlapping dates and coefficient # should be None. There shouldn't be a row. We should have correlations for S1:S4, S1:S5 and S4:S5 mock.copy_rates_range.side_effect = [self.mock_base_prices, self.mock_correlated_different_dates, self.mock_correlated_prices, self.mock_correlated_prices] cor.calculate(date_from=self.start_date, date_to=self.end_date, timeframe=5, min_prices=100, max_set_size_diff_pct=100, overlap_pct=100, max_p_value=1) self.assertEqual(len(cor.coefficient_data.index), 3, "There should be three correlations rows calculated.") self.assertEqual(cor.coefficient_data.iloc[0, 2], 1, "The correlation for SYMBOL1:SYMBOL4 should be 1.") self.assertEqual(cor.coefficient_data.iloc[1, 2], 1, "The correlation for SYMBOL1:SYMBOL5 should be 1.") self.assertEqual(cor.coefficient_data.iloc[2, 2], 1, "The correlation for SYMBOL4:SYMBOL5 should be 1.") # Get the price data used to calculate the coefficients for symbol 1. It should match mock_base_prices. price_data = cor.get_price_data('SYMBOL1') self.assertTrue(price_data.equals(self.mock_base_prices), "Price data returned post calculation should match " "mock price data.") def test_calculate_coefficient(self): """ Tests the coefficient calculation. :return: """ # Correlation class cor = correlation.Correlation() # Test 2 correlated sets coefficient = cor.calculate_coefficient(self.mock_base_prices, self.mock_correlated_prices) self.assertEqual(coefficient, 1, "Coefficient should be 1.") # Test 2 uncorrelated sets. Set p value to 1 to force correlation to be returned. coefficient = cor.calculate_coefficient(self.mock_base_prices, self.mock_uncorrelated_prices, max_p_value=1) self.assertTrue(coefficient < 1, "Coefficient should be < 1.") # Test 2 sets where prices dont overlap coefficient = cor.calculate_coefficient(self.mock_base_prices, self.mock_correlated_different_dates) self.assertTrue(coefficient < 1, "Coefficient should be None.") # Test 2 inversely correlated sets coefficient = cor.calculate_coefficient(self.mock_base_prices, self.mock_inverse_correlated_prices) self.assertEqual(coefficient, -1, "Coefficient should be -1.") @patch('mt5_correlation.mt5.MetaTrader5') def test_get_ticks(self, mock): """ Test that caching works. For the purpose of this test, we can use price data rather than tick data. Mock 2 different sets of prices. Get three times. Base, One within cache threshold and one outside. Set 1 should match set 2 but differ from set 3. :param mock: :return: """ # Correlation class to test cor = correlation.Correlation() # Mock the tick data to contain 2 different sets. Then get twice. They should match as the data was cached. mock.copy_ticks_range.side_effect = [self.mock_base_prices, self.mock_correlated_prices] # We need to start and stop the monitor as this will set the cache time cor.start_monitor(interval=10, calculation_params={'from': 10, 'min_prices': 0, 'max_set_size_diff_pct': 0, 'overlap_pct': 0, 'max_p_value': 1}, cache_time=3) cor.stop_monitor() # Get the ticks within cache time and check that they match base_ticks = cor.get_ticks('SYMBOL1', None, None) cached_ticks = cor.get_ticks('SYMBOL1', None, None) self.assertTrue(base_ticks.equals(cached_ticks), "Both sets of tick data should match as set 2 came from cache.") # Wait 3 seconds time.sleep(3) # Retrieve again. This one should be different as the cache has expired. non_cached_ticks = cor.get_ticks('SYMBOL1', None, None) self.assertTrue(not base_ticks.equals(non_cached_ticks), "Both sets of tick data should differ as cached data had expired.") @patch('mt5_correlation.mt5.MetaTrader5') def test_start_monitor(self, mock): """ Test that starting the monitor and running for 2 seconds produces two sets of coefficient history when using an interval of 1 second. :param mock: :return: """ # Mock symbol return values mock.symbols_get.return_value = self.mock_symbols # Create correlation class. We will set a divergence threshold so that we can test status. cor = correlation.Correlation(divergence_threshold=0.8, monitor_inverse=True) # Calculate for price data. We should have 100% matching dates in sets. Get prices should be called 4 times. # We dont have a SYMBOL2 as this is set as not visible. All pairs should be correlated for the purpose of this # test. mock.copy_rates_range.side_effect = [self.mock_base_prices, self.mock_correlated_prices, self.mock_correlated_prices, self.mock_inverse_correlated_prices] cor.calculate(date_from=self.start_date, date_to=self.end_date, timeframe=5, min_prices=100, max_set_size_diff_pct=100, overlap_pct=100, max_p_value=1) # We will build some tick data for each symbol and patch it in. Tick data will be from 10 seconds ago to now. # We only need to patch in one set of tick data for each symbol as it will be cached. columns = ['time', 'ask'] starttime = datetime.now() - timedelta(seconds=10) tick_data_s1 = pd.DataFrame(columns=columns) tick_data_s2 = pd.DataFrame(columns=columns) tick_data_s4 = pd.DataFrame(columns=columns) tick_data_s5 = pd.DataFrame(columns=columns) now = datetime.now() price_base = 1 while starttime < now: tick_data_s1 = tick_data_s1.append(pd.DataFrame(columns=columns, data=[[starttime, price_base * 0.5]])) tick_data_s2 = tick_data_s1.append(pd.DataFrame(columns=columns, data=[[starttime, price_base * 0.1]])) tick_data_s4 = tick_data_s1.append(pd.DataFrame(columns=columns, data=[[starttime, price_base * 0.25]])) tick_data_s5 = tick_data_s1.append(pd.DataFrame(columns=columns, data=[[starttime, price_base * -0.25]])) starttime = starttime + timedelta(milliseconds=10*random.randint(0, 100)) price_base += 1 # Patch it in mock.copy_ticks_range.side_effect = [tick_data_s1, tick_data_s2, tick_data_s4, tick_data_s5] # Start the monitor. Run every second. Use ~10 and ~5 seconds of data. Were not testing the overlap and price # data quality metrics here as that is set elsewhere so these can be set to not take effect. Set cache level # high and don't use autosave. Timer runs in a separate thread so test can continue after it has started. cor.start_monitor(interval=1, calculation_params=[{'from': 0.66, 'min_prices': 0, 'max_set_size_diff_pct': 0, 'overlap_pct': 0, 'max_p_value': 1}, {'from': 0.33, 'min_prices': 0, 'max_set_size_diff_pct': 0, 'overlap_pct': 0, 'max_p_value': 1}], cache_time=100, autosave=False) # Wait 2 seconds so timer runs twice time.sleep(2) # Stop the monitor cor.stop_monitor() # We should have 2 coefficients calculated for each symbol pair (6), for each date_from value (2), # for each run (2) so 24 in total. self.assertEqual(len(cor.coefficient_history.index), 24) # We should have 2 coefficients calculated for a single symbol pair and timeframe self.assertEqual(len(cor.get_coefficient_history({'Symbol 1': 'SYMBOL1', 'Symbol 2': 'SYMBOL2', 'Timeframe': 0.66})), 2, "We should have 2 history records for SYMBOL1:SYMBOL2 using the 0.66 min timeframe.") # The status should be DIVERGED for SYMBOL1:SYMBOL2 and CORRELATED for SYMBOL1:SYMBOL4 and SYMBOL2:SYMBOL4. self.assertTrue(cor.get_last_status('SYMBOL1', 'SYMBOL2') == correlation.STATUS_DIVERGED) self.assertTrue(cor.get_last_status('SYMBOL1', 'SYMBOL4') == correlation.STATUS_CORRELATED) self.assertTrue(cor.get_last_status('SYMBOL2', 'SYMBOL4') == correlation.STATUS_CORRELATED) # We are monitoring inverse correlations, status for SYMBOL1:SYMBOL5 should be DIVERGED self.assertTrue(cor.get_last_status('SYMBOL2', 'SYMBOL5') == correlation.STATUS_DIVERGED) @patch('mt5_correlation.mt5.MetaTrader5') def test_load_and_save(self, mock): """Calculate and run monitor for a few seconds. Store the data. Save it, load it then compare against stored data.""" # Correlation class cor = correlation.Correlation() # Patch symbol and price data, then calculate mock.symbols_get.return_value = self.mock_symbols mock.copy_rates_range.side_effect = [self.mock_base_prices, self.mock_correlated_prices, self.mock_correlated_prices, self.mock_inverse_correlated_prices] cor.calculate(date_from=self.start_date, date_to=self.end_date, timeframe=5, min_prices=100, max_set_size_diff_pct=100, overlap_pct=100, max_p_value=1) # Patch the tick data columns = ['time', 'ask'] starttime = datetime.now() - timedelta(seconds=10) tick_data_s1 =
pd.DataFrame(columns=columns)
pandas.DataFrame
import numpy as np import pandas as pd def constantsSetting(): output = {} output["General"] = general() # loading dictionary with general, physical constants output["Steam"] = steamProperties() # loading dictionary with steam properties constants output["MainEngines"] = mainEngines(output) # loading dictionary with main-engine related constants output["AuxEngines"] = auxiliaryEngines(output) # loading dictionary with auxiliary-engine related constants output["OtherUnits"] = otherUnits(output) return output def general(): # GENERAL CONSTANTS output = {} output["R_0"] = 8.3140 # Ideal gas constant, in [J/mol*K] output["R_AIR"] = output["R_0"] * 1000 / 29 # Air gas constant, in [J/kg*K] output["K_AIR"] = 1.4 # Air specific heat ratio output["CP_AIR"] = 1.015 # Air specific heat, in [kJ/kgK] output["CP_EG"] = 1.11 # EG specific heat, in [kJ/kgK] output["CP_LO"] = 2.1 # Lubricating oil specific heat, in [kW/kgK] output["CP_WATER"] = 4.187 # Water specifi heat, in [kW/kgK] output["RHO_W"] = 1000.0 # Water density, in [kg/m^3] output["RHO_LO"] = 850.0 # Lubricating oil density, in [kg/m^3] # output["RHO_HFO"] = np.mean([890, 919, 924, 926, 925, 921, 924, 918, 920, 919, 933]) # HFO density, in [kg/m^3] output["AIR_STOIC"] = 14.7 # Stoichiometric ratio fuel/air for Diesel-type fuels output["ETA_VOL"] = 0.97 # Assumption about volumetric efficiency output["P_ATM"] = 101325 # Assumption on atmospheric pressure output["T_STANDARD"] = 323 # Standard temperature, for the calculation of the exergy in the exhaust gas output["ISO"] = {"LHV": 42700, "T_CA": 298, "T_LT": 298, "ETA_MECH": 0.8} # Reference values for ISO conditions output["NAMES"] = {"MainEngines": {"ME1", "ME2", "ME3", "ME4"}, "AuxEngines": {"AE1", "AE2", "AE3", "AE4"}} output["PROPERTY_LIST"] = {} output["PROPERTY_LIST"]["CPF"] = {"mdot", "T", "p", "h", "b", "Edot", "Bdot"} # Compressible physical flow output["PROPERTY_LIST"]["IPF"] = {"mdot", "T", "h", "b", "Edot", "Bdot"} # Incompressible physical flow output["PROPERTY_LIST"]["SF"] = {"mdot", "h", "b", "Edot", "Bdot"} # Incompressible physical flow output["PROPERTY_LIST"]["Qdot"] = {"T", "Edot", "Bdot"} # Heat flow output["PROPERTY_LIST"]["Wdot"] = {"omega", "Edot", "Bdot"} # Mechanical rotational energy flow output["PROPERTY_LIST"]["Che"] = {"Edot", "Bdot"} # Chemical energy flows output["PROPERTY_LIST"]["Ele"] = {"Edot", "Bdot"} # Electrical energy flows output["PROPERTY_LIST"]["REF"] = {"Wdot": 0, "omega":0, "mdot":0, "T": 273, "p": output["P_ATM"], "h": 0, "b": 0, "Edot": 0, "Bdot": 0, "Qdot": 0} output["EFFICIENCY_LIST"] = {} output["EFFICIENCY_LIST"]["STANDARD"] = {"eta", "eps", "lambda", "delta"} output["EFFICIENCY_LIST"]["HEX"] = {"eps", "lambda", "delta"} output["EFFICIENCY_LIST"]["MIXMERGE"] = {"lambda", "delta"} output["UNIT_TYPES"] = {} output["UNIT_TYPES"]["STANDARD"] = {"cyl", "comp", "turbine", "ag", "boiler", "shaft"} output["UNIT_TYPES"]["MIXMERGE"] = {"merge", "split", "distribution", "collector", "valve", "Distribution", "HotWell"} # output["FLUIDS"] = {"BP": "Air", "Air": "Air", "Water": "Water"} output["MDO"] = {"LHV": 42230.0, "CP": 1.8, "C": 0.87, "H": 0.13} output["MDO"]["HHV"] = output["MDO"]["LHV"] * (1.0406 + 0.0144 * output["MDO"]["H"] / output["MDO"]["C"] * 12) * 1.01 # Calculated Higher heating value output["MDO"]["specificExergy"] = output["MDO"]["LHV"] * (1.0401 + 0.1728 * output["MDO"]["H"] / output["MDO"]["C"]) output["HFO"] = {"LHV": 40360.0, "CP": 1.8, "C": 0.89, "H": 0.11} output["HFO"]["HHV"] = output["HFO"]["LHV"] * (1.0406 + 0.0144 * output["HFO"]["H"] / output["HFO"]["C"] * 12) * 1.01 # Calculated Higher heating value output["HFO"]["specificExergy"] = output["HFO"]["LHV"] * (1.0401 + 0.1728 * output["HFO"]["H"] / output["HFO"]["C"]) output["NASA_POLY"] = {"N2": [0.03298677E+02, 0.14082404E-02, -0.03963222E-04, 0.05641515E-07, -0.02444854E-10, -0.10208999E+04, 0.03950372E+02], "O2": [3.78245636E+00, -2.99673416E-03, 9.84730201E-06, -9.68129509E-09, 3.24372837E-12, -1.06394356E+03, 3.65767573E+00], "CO2": [2.35677352E+00, 8.98459677E-03, -7.12356269E-06, 2.45919022E-09, -1.43699548E-13, -4.83719697E+04, 9.90105222E+00], "H2O": [4.19864056E+00, -2.03643410E-03, 6.52040211E-06, -5.48797062E-09, 1.77197817E-12, -3.02937267E+04, -8.49032208E-01]} output["MOLAR_MASSES"] = {"N2": 28, "O2": 32, "CO2": 44, "H2O": 18} return output def steamProperties(): # STEAM PROPERTIES output = {} output["H_STEAM_LS"] = 662.0 # Specific enthalpy of 6 bar steam, saturated liquid, in [kJ/kg] output["H_STEAM_VS"] = 2754.0 # Specific enthalpy of 6 bar steam, saturated vapour, in [kJ/kg] output["S_STEAM_LS"] = 1.9108 # Specific entropy of 6 bar steam, saturated liquid, in [kJ/kg] output["S_STEAM_VS"] = 6.7766 # Specific entrpy of 6 bar steam, saturated vapour, in [kJ/kg] output["DH_STEAM"] = output["H_STEAM_VS"] - output["H_STEAM_LS"] output["DS_STEAM"] = output["S_STEAM_VS"] - output["S_STEAM_LS"] output["TSAT_STEAM"] = 430.0 # Saturation temperature chosen for the selected pressure, in [kJ/kg] return output def mainEngines(CONSTANTS): output = {"MCR": 5890} # Main engines maximum power, in [kW] output["RPM_DES"] = 500 # Main engine design speed, in [rpm] output["RPM_TC_DES"] = 22000 # Main engine Turbocharger design speed, in [rpm] output["MFR_FUEL_DES_ISO"] = 184 * output["MCR"] / 1000 / 3600 # Fuel flow at 100# load at ISO conditions, in [kg/s]. 184 is the ISO bsfc at 100% load (average for the 4 MEs) # output["POLY_FUEL_RACK_2_MFR_FUEL"] = polyfit([24 31 38 42 46]/46, [336.3 587.8 836.6 953.1 1141]/3600, 2) # Fits a 2nd degree polynomial relating relative fuel rack position to fuel flow in kg/s # Here we write all the required info for the fuel rack position to mass flow rate relation output["FRP_2_MFR"] = {} output["FRP_2_MFR"]["POLY"] = {"ME1": [-159.612, 24.23254], "ME2": [-159.612, 28.282788], "ME3": [-159.612, 28.282788], "ME4": [-159.612, 28.282788]} output["FRP_2_MFR"]["FRP_MIN"] = {"ME1": 18.0, "ME2": 16.6, "ME3": 17.5, "ME4": 16.4} output["FRP_2_MFR"]["FRP_MAX"] = {"ME1": 51, "ME2": 47, "ME3": 47, "ME4": 46} # output["POLY_FUEL_LOAD_2_BSFC_ISO"] = np.polyfit(np.array([336.3, 587.8, 836.6, 953.1, 1141])/1141, [216.9, 187.1, 178.5, 179.2, 181.4], 2) # Fits a 2nd degree polynomial relating relative fuel rack position to fuel flow in kg/s output["POLY_FUEL_LOAD_2_BSFC_ISO"] = np.polyfit(np.array([336.3, 587.8, 836.6, 953.1, 1141]) / 1141, [205, 187.1, 178.5, 179.2, 181.4], 2) # Fits a 2nd degree polynomial relating relative fuel rack position to fuel flow in kg/s output["POLY_RPM_2_ISO_BSFC"] = np.polyfit([315.0, 397.0, 454.0, 474.0, 500.0, 516.0], [np.mean([216.1, 207.6, 225.5, 209.9]), 188.2, 179.7, 181.6, 185, 191.1], 2) output["POLY_LOAD_2_ISO_BSFC"] = np.polyfit([0.25, 0.5, 0.75, 0.85, 1.0, 1.1], [np.mean([216.1, 207.6, 225.5, 209.9]), 188.2, 179.7, 181.6, 185, 191.1], 2) output["QDOT_HT_DES"] = 1650.0 # Heat flow to the HT cooling systems at design load, in [kW] output["QDOT_LT_DES"] = 1450.0 # Heat flow to the HT cooling systems at design load, in [kW] # output["POLY_LOAD_2_QDOT_HT"] = np.array([0.7826 , 0.2204 , 0]) output["POLY_LOAD_2_QDOT_HT"] = np.array([0.5826, 0.5204, 0]) output["POLY_LOAD_2_QDOT_LT"] = np.array([-0.1206 , 1.0978 , 0]) output["POLY_H_2_QDOT"] = np.array([-3.65E-4, +3.17E-2, 2.85E1]) output["BSFC_ISO_DES"] = np.polyval(output["POLY_LOAD_2_ISO_BSFC"], 1) # Function handle that allows to calculate the fuel load output["BORE"] = 0.46 # Main engine bore output["STROKE"] = 0.58 # Main engine stroke output["N_CYL"] = 6 # Number of cylinders output["R_C"] = 14 # Assumption of compression ratio output["V_SW"] = output["BORE"]**2 / 4 * np.pi * output["STROKE"] # Swept volume, in [m^3] output["V_MAX"] = output["V_SW"] * output["R_C"] / (output["R_C"] - 1) # Maximum volume, in [m^3] output["MFR_LO"] = 120.0 * CONSTANTS["General"]["RHO_LO"] / 3600.0 # Mass flow rate of oil in each main engine, in [kg/s] output["MFR_LT"] = 120.0 * CONSTANTS["General"]["RHO_W"] / 3600.0 # Mass flow rate of LT cooling water, in [kg/s] output["MFR_HT"] = 120.0 * CONSTANTS["General"]["RHO_W"] / 3600.0 # Mass flow rate of LT cooling water, in [kg/s] output["POLY_PIN_2_ETA_IS"] = [-1.18e-2, 8.74e-2, 6.81e-1] # Polynoimial regression for isentropic efficiency of the compressor output["ETA_CORR"] = 1.05 output["ETA_MECH_TC"] = 0.9 # Mechanical efficiency of the turbocharger [-]. Variations from "Development and validation of a new turbocharger simulation methodology for marine two stroke diesel engine modelling and diagnostic applications" output["POLY_TC_RPM_2_ETA_MECH"] = np.polyfit(np.array([6000, 9500, 13000, 16500, 20000])/output["RPM_TC_DES"], [0.7 , 0.76 , 0.84 , 0.91 , 0.91], 2) output["EPS_CAC_HTSTAGE"] = 0.7 # Effectiveness, as defined by the epsNTU method, of the High Temperature stage of the Charge Air Cooler, in [-] output["ETA_GB"] = 0.985 # Mechanical efficiency of the gearbox output["ETA_SHAFT"] = 0.99 # Mechanical efficiency of the engine shaft output["FRP_DES"] = {"ME1": 51, "ME2": 47, "ME3": 47, "ME4": 46} # Value of the fuel rack position at 100% load # output["BYPASS_FLOW"] = 1.1 output["STATIC_HEAD"] = 19 output["T_COOLING_MIX"] = 71 + 273.15 # Temperature of the LT/HT mix before the mixing with the HT cooling systems output["AIR_FLOW_MULT"] = 0.95 return output def auxiliaryEngines(CONSTANTS): output = {"MCR": 2760.0} # Auxiliary engines maximum power, in [kW] output["RPM_DES"] = 750.0 # Auxiliary engines design speed, in [rpm] output["RPM_TC_DES"] = 26000 # Auxiliary engines design speed, in [rpm] # AE_POLY_FUEL_RACK_2_MFR_FUEL = polyfit([17 27 37 44.5 46]/46, [336.3 587.8 836.6 953.1 1141]/3600, 2) # Fits a 2nd degree polynomial relating relative fuel rack position to fuel flow in kg/s output["POLY_LOAD_2_ISO_BSFC"] = np.polyfit(np.array([0.5, 0.75, 0.85, 1.0]), np.array([193.0, 182.0, 181.0, 184.0])/184.0*190.0, 2) # Fits a 2nd degree polynomial relating relative fuel rack position to fuel flow in kg/s output["POLY_PIN_2_ETA_IS"] = np.array([-1.18e-2, 8.74e-2, 6.81e-1]) output["BORE"] = 0.32 # Main engine bore, in [m] output["STROKE"] = 0.40 # Main engine stroke, in [m] output["N_CYL"] = 6.0 # Number of cylinders output["V_SW"] = output["BORE"]**2 / 4.0 * np.pi * output["STROKE"] # Swept volume, in [m^3] output["R_C"] = 14.0 # Assumption of compression ratio output["V_MAX"] = output["V_SW"] * output["R_C"] / (output["R_C"] - 1) # Maximum volume, in [m^3] output["MFR_LO"] = 70 * CONSTANTS["General"]["RHO_LO"] / 3600 # Mass flow rate of oil in each auxiliary engine, in [kg/s] output["QDOT_2_CAC_HT_DES"] = 351.0 # Heat flow to the charge air cooler, High temperature stage, at the engine design point, in [kW] output["QDOT_2_CAC_LT_DES"] = 433.0 # Heat flow to the charge air cooler, Low temperature stage, at the engine design point, in [kW] output["QDOT_2_JWC_DES"] = 414.0 # Heat flow to the jacket water cooler at the engine design point, in [kW] output["QDOT_2_LOC_DES"] = 331.0 # Heat flow to the lubricating oil cooler at the engine design point, in [kW] output["QDOT_HT_DES"] = output["QDOT_2_CAC_HT_DES"] + output["QDOT_2_JWC_DES"] output["QDOT_LT_DES"] = output["QDOT_2_CAC_LT_DES"] + output["QDOT_2_LOC_DES"] # Assuming that the amount of heat from the engine to the HT cooling systems behaves in the same way as that of the main engines. output["POLY_LOAD_2_QDOT_HT"] = CONSTANTS["MainEngines"]["POLY_LOAD_2_QDOT_HT"] output["POLY_LOAD_2_QDOT_LT"] = CONSTANTS["MainEngines"]["POLY_LOAD_2_QDOT_LT"] output["POLY_H_2_QDOT"] = np.array([-1.74E-3, -1.36E-2, 3.48E1]) # Assuming that the sare of the charge air cooling heat going to the HT stage is linearly increasing from 0 to its value at the engine design point. output["POLY_LOAD_2_SHARE_CAC"] = np.polyfit([0, 1], [0, output["QDOT_2_CAC_HT_DES"]/(output["QDOT_2_CAC_HT_DES"]+output["QDOT_2_CAC_LT_DES"])], 1) output["MFR_LT"] = 60.0 * CONSTANTS["General"]["RHO_W"] / 3600.0 # Mass flow rate of LT cooling water, in [kg/s] output["MFR_HT"] = 60.0 * CONSTANTS["General"]["RHO_W"] / 3600.0 # Mass flow rate of HT cooling water, in [kg/s] output["ETA_CORR"] = 1.15 # Used because one of the engines need correction, to be checked # The efficiency is calculated at eta = eta_des - A exp(-k (x-x_ref)/x_ref) output["AG"] = {} output["AG"]["ETA_DES"] = 0.97 output["AG"]["A"] = 0.18 output["AG"]["k"] = 5 output["EPS_CAC_HTSTAGE"] = 0.85 # Effectiveness, as defined by the epsNTU method, of the High Temperature stage of the Charge Air Cooler, in [-] # output["STATIC_HEAD"] = 15 # Now it is calculated instead output["T_COOLING_MIX"] = 71 + 273.15 # Temperature of the LT/HT mix before the mixing with the HT cooling systems return output def otherUnits(CONSTANTS): output = {} # Initializing the output dictionary # Providing the optimal optimization vector # param = [0.00000000e+00, 0.00000000e+00, 3.02453747e-01, 6.10256462e-01, 1.00000000e+00, 7.37813650e-01, # 6.13233358e-01, 3.44252126e+02, 5.61738566e-01, 7.19654306e+06, 4.16518191e+03] param = [2.04820342e+01, 0.00000000e+00, 3.97004436e-01, 7.22620258e-01, 1.00000000e+00, 6.81708153e-01, 2.14566717e-01, 3.47857597e+02, 5.00000000e-01, 9.54336804e+06, 5.13466015e+03] Qdot_HTHR_constant = param[0] Qdot_steam_constant = param[1] HVACreheaterCoefficient = param[2] HotWaterHeaterCoefficient = param[3] HVACpreheaterCoefficient = param[4] GalleyCoefficient = param[5] OtherCoefficient = param[6] HTHRinletTemperature = param[7] HTHRhexEffectiveness = param[8] BoilerStorageSize = param[9] BoilerReferencePower = param[10] # Boiler output["BOILER"] = {} # Initializing the boiler sub-dictionary output["BOILER"]["ETA_DES"] = 0.8 output["BOILER"]["ETA_REGR_X"] = [6.79E-02, 1.20E-01, 1.62E-01, 2.12E-01, 2.86E-01, 3.52E-01, 4.03E-01, 4.41E-01, 4.90E-01, 5.40E-01, 5.89E-01, 6.54E-01, 7.16E-01, 7.67E-01, 8.31E-01, 8.94E-01, 9.47E-01, 9.89E-01, 1.04E+00, 1.09E+00, 1.14E+00, 1.20E+00] output["BOILER"]["ETA_REGR_Y"] = [0.8787, 0.8830, 0.8864, 0.8889, 0.8910, 0.8897, 0.8870, 0.8842, 0.8810, 0.8777, 0.8740, 0.8692, 0.86486, 0.8613, 0.8570, 0.8528, 0.8491, 0.8462, 0.8427, 0.8390, 0.8356, 0.8317] output["BOILER"]["OXYGEN_EG"] = 0.04 # Here we calculate the air/fuel ratio of the boiler, given the concentration of oxygen in the exhaust output["BOILER"]["LAMBDA"] = (CONSTANTS["General"]["MDO"]["C"] / 12 + CONSTANTS["General"]["MDO"]["H"] / 4 * (1 + output["BOILER"]["OXYGEN_EG"]) ) / (1 - 100/21 * output["BOILER"]["OXYGEN_EG"]) * (32 + 100 / 21 * 28) for idx in range(len(output["BOILER"]["ETA_REGR_Y"])): output["BOILER"]["ETA_REGR_Y"][idx] = output["BOILER"]["ETA_REGR_Y"][idx] / max(output["BOILER"]["ETA_REGR_Y"]) output["BOILER"]["STORAGE_SIZE"] = BoilerStorageSize output["BOILER"]["REFERENCE_POWER"] = BoilerReferencePower # Propulsion train output["PROPULSION"] = {} output["PROPULSION"]["ETA_GB"] = 0.98 output["PROPULSION"]["ETA_SH"] = 0.99 # Heat demand output["HEAT_DEMAND"] = {} output["HEAT_DEMAND"]["DESIGN"] = {} output["HEAT_DEMAND"]["DESIGN"]["HOT_WATER_HEATER"] = 1200 output["HEAT_DEMAND"]["DESIGN"]["HVAC_PREHEATER"] = 3500 output["HEAT_DEMAND"]["DESIGN"]["HVAC_REHEATER"] = 1780 output["HEAT_DEMAND"]["DESIGN"]["TANK_HEATING"] = 210 output["HEAT_DEMAND"]["DESIGN"]["OTHER_TANKS"] = 140 output["HEAT_DEMAND"]["DESIGN"]["HFO_TANK_HEATING"] = 270 output["HEAT_DEMAND"]["DESIGN"]["MACHINERY_SPACE_HEATERS"] = 280 output["HEAT_DEMAND"]["DESIGN"]["GALLEY"] = 600 output["HEAT_DEMAND"]["DESIGN"]["OTHER_HTHR"] = Qdot_HTHR_constant output["HEAT_DEMAND"]["DESIGN"]["OTHER_STEAM"] = Qdot_steam_constant output["HEAT_DEMAND"]["LIN"] = {} output["HEAT_DEMAND"]["LIN"]["HOT_WATER_HEATER"] = HotWaterHeaterCoefficient output["HEAT_DEMAND"]["LIN"]["HVAC_PREHEATER"] = HVACpreheaterCoefficient output["HEAT_DEMAND"]["LIN"]["HVAC_REHEATER"] = HVACreheaterCoefficient output["HEAT_DEMAND"]["LIN"]["OTHER_CONSUMERS"] = OtherCoefficient output["HEAT_DEMAND"]["LIN"]["GALLEY"] = GalleyCoefficient output["HEAT_DEMAND"]["HWH_HOURLY"] = [0.10, 0.10, 0.10, 0.10, 0.70, 1.00, 1.00, 1.00, 0.50, 0.50, 0.50, 0.50, 0.50, 0.50, 0.50, 0.50, 0.70, 0.70, 1.00, 1.00, 1.00, 0.50, 0.50, 0.30] output["HEAT_DEMAND"]["GALLEY_HOURLY"] = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 1.0, 1.0, 1.0, 0.5, 1.0, 1.0, 0.5, 0.1, 0.1, 0.5, 1.0, 1.0, 1.0, 1.0, 0.5, 0.1, 0.1] output["HEAT_DEMAND"]["T_INSIDE"] = 22 + 273.15 output["HEAT_DEMAND"]["WINTER_START"] = np.datetime64("2013-12-03") output["HEAT_DEMAND"]["WINTER_END"] = np.datetime64("2014-04-14") output["HEAT_DEMAND"]["SPRING_START"] = np.datetime64("2014-04-15") output["HEAT_DEMAND"]["SPRING_END"] = np.datetime64("2014-07-02") output["HEAT_DEMAND"]["SUMMER_START"] = np.datetime64("2014-07-03") output["HEAT_DEMAND"]["SUMMER_END"] = np.datetime64("2014-08-21") output["HEAT_DEMAND"]["AUTUMN_START"] = np.datetime64("2014-08-22") output["HEAT_DEMAND"]["AUTUMN_END"] = np.datetime64("2014-12-02") output["HEAT_DEMAND"]["TOTAL_AREA"] = (150 + 30) * 2 * 20 + 2 * 150 * 30 output["HEAT_DEMAND"]["T_AIR_REF_MIN"] = -20 + 273 output["HEAT_DEMAND"]["T_AIR_REF_MAX"] = 15 + 273 output["HEAT_DEMAND"]["TOTAL_U"] = output["HEAT_DEMAND"]["DESIGN"]["HVAC_PREHEATER"] / output["HEAT_DEMAND"]["TOTAL_AREA"] / (output["HEAT_DEMAND"]["T_INSIDE"] - output["HEAT_DEMAND"]["T_AIR_REF_MIN"]) output["HEAT_DEMAND"]["HTHR_EPS"] = HTHRhexEffectiveness # Effectiveness of the HTHR water-water heat exchangers. Old: 0.85 output["HEAT_DEMAND"]["HTHR_INLET_TEMPERATURE"] = HTHRinletTemperature output["HEAT_DEMAND"]["HVAC_POWER_DES"] = 1500 # Design power of the HVAC compressors return output def seasons(dataset_raw, processed, CONSTANTS): # This function is used to define some time-related features, such as the season, the weekends, etc. # Definition of the weekend: all data points are 1 if it's weekend, 0 if it is a weekday. temp = pd.Series(index = processed.index) temp[processed.index.dayofweek == 4] = 1 # Fridays temp[processed.index.dayofweek == 5] = 1 # Saturdays temp[processed.index.dayofweek == 6] = 1 # Sundays temp[temp.isnull()] = 0 # All other weekdays temp = temp.shift(16*4-1) # Shifting to account for the fact that passengers are going on and off at 16 temp[temp.isnull()] = 0 processed["Weekends"] = temp # Definition of the seasons based on energy demand # 0 = winter, 1 = spring/fall, 2 = summer temp = pd.Series(index=processed.index) temp[CONSTANTS["OtherUnits"]["HEAT_DEMAND"]["WINTER_START"]:CONSTANTS["OtherUnits"]["HEAT_DEMAND"]["WINTER_END"]] = 0 temp[CONSTANTS["OtherUnits"]["HEAT_DEMAND"]["SPRING_START"]:CONSTANTS["OtherUnits"]["HEAT_DEMAND"]["SPRING_END"]] = 1 temp[CONSTANTS["OtherUnits"]["HEAT_DEMAND"]["SUMMER_START"]:CONSTANTS["OtherUnits"]["HEAT_DEMAND"]["SUMMER_END"]] = 2 temp[CONSTANTS["OtherUnits"]["HEAT_DEMAND"]["AUTUMN_START"]:CONSTANTS["OtherUnits"]["HEAT_DEMAND"]["AUTUMN_END"]] = 1 processed["Seasons"] = temp # Definition of the summer based on the number of passengers temp =
pd.Series(index=processed.index)
pandas.Series
import matplotlib matplotlib.use('Agg') import pandas as pd import os,sys,math import tempfile import tarfile import json import pprint #import custom_config as cc import atomsci.ddm.utils.pubchem_utils as pu from os import path from target_data_curation import AMPLDataset from atomsci.ddm.utils import struct_utils as su from atomsci.ddm.utils import data_curation_functions as dcf from atomsci.ddm.utils import curate_data import atomsci.ddm.pipeline.diversity_plots as dp import atomsci.ddm.pipeline.chem_diversity as cd import seaborn as sns import matplotlib.pyplot as plt from matplotlib.backends.backend_pdf import PdfPages import numpy as np from tqdm import tqdm # Using data_curation_functions # Initial dataset downloaded org/record/173258#.XcXWHZJKhhE # cd /usr/workspace/atom/excapedb/ # Look for Last-Modified and Length to check whether to download update DATE=date -Idate #--- # wget -S https://zenodo.org/record/173258/files/pubchem.chembl.dataset4publication_inchi_smiles.tsv.xz?download=1 -O excape_data.csv.$DATE Last-Modified: 12/29/2016 # head -1 pubchem.chembl.dataset4publication_inchi_smiles.tsv > cyp3a4_excape.csv # grep 'CYP3A4' pubchem.chembl.dataset4publication_inchi_smiles.tsv >> cyp3a4_excape.csv #--- # grep CYP3A4 pubchem.chembl.dataset4publication_inchi_smiles.tsv > raw_data.txt # head -1 pubchem.chembl.dataset4publication_inchi_smiles.tsv > header # cat header raw_data.txt > cyp3a4_excape.csv #--- class ExcapeActivityDump(AMPLDataset): """Class responsible for parsing and extracting data from the Excape-DB tsv data dump file """ def set_columns(self,sec) : """ Sets expected column names for input file and reads the table. """ self.smiles_col = 'SMILES' self.base_smiles_col = 'base_rdkit_smiles' self.id_col = 'compound_id' self.standard_col = 'Standard Type' self.target_name_col = 'Target Name' self.target_id_col = 'Gene_Symbol' self.relation_col = 'relation' self.value_col = 'activity' self.date_col = 'Document Year' self.data_source_name=sec def __init__(self, parser=None, sec = None, raw_target_lst = None, dataset = None, df = None): super().__init__() """ Initialize object Params: parser : pointer to the config file parser to access user specificied configuration settings sec : specifies where in the config file to retrieve settings from raw_target_lst : list of gene targets to extract data for dataset : gives an identifier df : dataframe storing the raw data to be extracted and curated """ if dataset is not None and df is not None : self.set_columns(dataset.data_source_name) self.df = df else : self.set_columns(sec) filename = parser.check_get(sec,'activity_csv') self.df = pd.read_csv(filename,sep="\t",engine="python",error_bad_lines=False) #the reason to fill empty values is to track what is likely inactive measurements #self.df['pXC50'] = self.df['pXC50'].fillna(0) #we just ignore them for now self.df = self.df.dropna(subset=['pXC50']) # (Yaru) Remove inf in curated_df self.df = self.df[~self.df.isin([np.inf]).any(1)] # standardize column names self.df.rename( columns={ "pXC50" : self.value_col, "Ambit_InchiKey" : self.id_col }, inplace=True) self.df[self.relation_col] = "" self.df.loc[self.df.Activity_Flag == 'N',self.relation_col] = '<' self.df.loc[self.df.Activity_Flag == 'A',self.relation_col] = '' # FILTER ON 9606 (human) self.df=self.df[self.df.Tax_ID == 9606] self.df = self.df[self.df[self.target_id_col].isin(raw_target_lst)] class DrugTargetCommonsActivityDump(AMPLDataset): """Class responsible for parsing and extracting data from the Drug Target Commons data dump file """ def set_columns(self, sec ) : """ Sets expected column names for input file and reads the table. """ self.smiles_col = 'smiles' self.base_smiles_col = 'base_rdkit_smiles' self.id_col = 'compound_id' self.standard_col = 'standard_type' self.target_name_col = 'gene_names' self.target_id_col = 'gene_names' self.relation_col = 'relation' self.value_col = 'standard_value' self.date_col = '' self.tmp_dir = './' # where to cache retrieved SMILES strings self.data_source_name=sec def __init__(self, parser=None, sec = None, raw_target_lst = None, dataset = None, df = None): super().__init__() """ Initialize object Params: parser : pointer to the config file parser to access user specificied configuration settings sec : specifies where in the config file to retrieve settings from raw_target_lst : list of gene targets to extract data for dataset : gives an identifier df : dataframe storing the raw data to be extracted and curated """ if dataset is not None and df is not None : self.set_columns(dataset.data_source_name) self.df = df else : self.set_columns(sec) self.tmp_dir = parser.check_get(sec,'output_data_dir') filename = parser.check_get(sec,'activity_csv') self.smiles_file=parser.check_get(sec,'smiles_csv') self.df = pd.read_csv(filename,sep=",",engine="python",error_bad_lines=False) end_point_lst=parser.check_get(sec,"end_points").split(',') self.df.standard_type = self.df.standard_type.str.lower() end_point_lst = [ x.lower() for x in end_point_lst ] # # might want to filter on human # data_curatoin_functions.filter_dtc_data # #TODO : SHOULD FILTER ON 9606 (human) -Jonathan, why isn't this done? self.df = self.df[self.df.gene_names.isin(raw_target_lst) & ~(self.df.standard_inchi_key.isna()) & self.df.standard_type.isin( end_point_lst ) & (self.df.standard_units == 'NM') & ~self.df.standard_value.isna() & ~self.df.compound_id.isna() & (self.df.wildtype_or_mutant != 'mutated') ] ####WARNING: I had to convert this explicitly to a floating point value!!! self.df[self.value_col]=self.df[self.value_col].astype(float) ## convert values to -log10 molar values (function assumes input is in NM units) self.df[self.value_col]=self.df[self.value_col].apply(dcf.ic50topic50) # (Yaru) Remove inf in curated_df self.df = self.df[~self.df.isin([np.inf]).any(1)] # we shouldn't have to do this, but compound_id is hard coded in the aggregate_data function # we need to use the inchikey as the compound id, since the normal compound id isn't always defined/available # so rename column to something different and name inchikey column as the compound_id column self.df.rename( columns={"standard_relation" : self.relation_col }, inplace=True) self.df.rename( columns={self.id_col : "orig_compound_id" }, inplace=True) self.df.rename( columns={"standard_inchi_key" : self.id_col }, inplace=True) def add_base_smiles_col(self): """ requires a specialized SMILES curation step as SMILES strings are stored separately """ targLst=self.df[self.target_name_col].unique().tolist() targLst.sort() targ_name='_'.join(targLst) if len(targ_name) >= 25 : targ_name='target' fileNameTooLong=True else : fileNameTooLong=False myList=self.df[self.id_col].unique().tolist() # #TODO: Need to make this caching scheme user defined # now just hardcoded to write to current directory # Retrieve SMILES strings for compounds through PUBCHEM web interface. # THIS is slow so it should only be done once and then cached to file tmp_dir=self.tmp_dir ofile=tmp_dir+targ_name+'_dtc_smiles_raw.csv' if not path.exists(ofile): if not path.exists(self.smiles_file) : print("download from PubChem ") ## smiles are stored in 'smiles' column in returned dataframe save_smiles_df,fail_lst,discard_lst=pu.download_smiles(myList) save_smiles_df.to_csv(ofile, index=False) else : print("retrieve SMILES from predownloaded file",self.smiles_file) # save_smiles_df=pd.read_csv(self.smiles_file) # save_smiles_df.rename( columns={"inchikey" : self.id_col }, inplace=True) # save_smiles_df.to_csv(ofile, index=False) sed_cmd = f"sed 's/inchikey/{self.id_col}/' {self.smiles_file} > {ofile}" os.system(sed_cmd) save_smiles_df=pd.read_csv(ofile) else : print("Already download file",ofile) save_smiles_df=pd.read_csv(ofile) print("debug make sure smiles not empty",save_smiles_df.shape) #the file puts the SMILES string in quotes, which need to be removed save_smiles_df[self.smiles_col]=save_smiles_df[self.smiles_col].str.replace('"','') #need to join SMILES strings with main data_frame self.df=self.df.merge(save_smiles_df,on=self.id_col,suffixes=('_'+targ_name,'_')) # calculate base rdkit smiles and add them to the dataframe super().add_base_smiles_col() class ChEMBLActivityDump(AMPLDataset): """Class responsible for parsing and extracting data from a ChEMBL json data dump file """ def set_columns(self,sec) : """ Sets expected column names for input file and reads the table. """ self.smiles_col = 'smiles' self.base_smiles_col = 'base_rdkit_smiles' self.id_col = 'compound_id' self.standard_col = 'standard_type' self.target_id_col = 'gene_names' self.relation_col = 'relation' self.value_col = 'pAct' self.units = 'units' self.assay_id = 'assay_id' self.data_source_name=sec def __init__(self, parser=None, sec = None, raw_target_lst = None, dataset = None, df = None): super().__init__() """ Initialize object Params: parser : pointer to the config file parser to access user specificied configuration settings sec : specifies where in the config file to retrieve settings from raw_target_lst : list of gene targets to extract data for dataset : gives an identifier df : dataframe storing the raw data to be extracted and curated """ if dataset is not None and df is not None : self.set_columns(dataset.data_source_name) self.df = df else : self.set_columns(sec) mapgn=parser.check_get(sec,'target_mapping') self.target_dict = json.load(open(mapgn)) end_point_lst=parser.check_get(sec,"end_points").split(',') end_point_lst = [ x.lower() for x in end_point_lst ] filename=parser.check_get(sec,'activity_csv') dc=json.load(open(filename)) target_lst=[] for val in raw_target_lst : target_lst.append( self.target_dict[val] ) df_lst=[] for kv in raw_target_lst : tmp_df_lst=[] for cid in dc[kv].keys() : lst=dc[kv][cid]['pAct'] for it in range(len(lst)) : row={ self.id_col : cid, self.value_col : dc[kv][cid]['pAct'][it], self.relation_col : dc[kv][cid]['relation'][it], self.smiles_col : dc[kv][cid]['smiles'], self.standard_col : dc[kv][cid]['type'][it], self.units : dc[kv][cid]['units'][it], self.assay_id : dc[kv][cid]['assay_id'][it] } tmp_df_lst.append(row) df=pd.DataFrame(tmp_df_lst) df[self.target_id_col] = self.target_dict[kv] df = df.dropna(subset=[self.value_col,self.standard_col,self.id_col]) df_lst.append(df) self.df = pd.concat(df_lst) ## do we need to do any other filter/checks here, like units? self.df=self.df[(self.df.units.str.lower() == 'nm')] self.df.standard_type = self.df.standard_type.str.lower() self.df=self.df[self.df.standard_type.isin( end_point_lst ) ] def filter_task(self, target_id): """when the gene target label isn't standardized, need to return the gene target mapping """ return self.df[(self.df[self.target_id_col] == self.target_dict[target_id])],self.target_dict[target_id] def convert_dtype(x): if not x: return 0.0 try: return float(x) except: return 0.0 class GPCRChEMBLActivityDump(AMPLDataset): """Class responsible for parsing and extracting data from a custom ChEMBL formatted csv data dump file """ def set_columns(self,sec) : """ Sets expected column names for input file and reads the table. """ ## complaining about mixed datatypes and I can't seem to fix it! self.smiles_col = 'Smiles' self.base_smiles_col = 'base_rdkit_smiles' self.id_col = 'compound_id' self.standard_col = 'relation' self.target_name_col = 'Target Name' self.target_id_col = 'gene_names' self.relation_col = 'relation' self.value_col = 'pChEMBL Value' self.date_col = 'Document Year' self.data_source_name=sec def __init__(self, parser=None, sec = None, raw_target_lst = None, dataset = None, df = None): super().__init__() """ Initialize object Params: parser : pointer to the config file parser to access user specificied configuration settings sec : specifies where in the config file to retrieve settings from raw_target_lst : list of gene targets to extract data for dataset : gives an identifier df : dataframe storing the raw data to be extracted and curated """ if dataset is not None and df is not None : self.set_columns(dataset.data_source_name) self.df = df else : self.set_columns(sec) my_conv={'Molecular Weight' : convert_dtype} filename = parser.check_get(sec,'activity_csv') self.df = pd.read_csv(filename,error_bad_lines=True, index_col=False, converters=my_conv) mapgn=parser.check_get(sec,'target_mapping') end_point_lst=parser.check_get(sec,"end_points").split(',') end_point_lst = [ x.lower() for x in end_point_lst ] ##warning this assumes first column is the key and second column is the value chk =
pd.read_csv(mapgn)
pandas.read_csv
import os import matplotlib.pyplot as plt, mpld3 import matplotlib.ticker as ticker import pandas as pd import numpy as np from my_utils import (connect_db, exists_table, update_databasebog, make_query) def estado(table_name, conn): casos = make_query( f"SELECT ESTADO, count(*) as cantidad FROM {table_name} WHERE ESTADO not null GROUP BY ESTADO ORDER BY cantidad", conn ) _ , ax = plt.subplots() ax.pie(casos['cantidad'], startangle=-90, autopct='%1.1f%%') ax.legend(casos['ESTADO'], loc="upper center", ncol=2) ax.set_title("Estado contagiados") plt.tight_layout(pad=0.4, w_pad=0.5, h_pad=1.5) plt.savefig('plots/estado') plt.show() def ubicacion(table_name, conn): casos = make_query( f"SELECT UBICACION, count(*) as cantidad FROM {table_name} WHERE UBICACION not null GROUP BY UBICACION ORDER BY cantidad", conn ) _ , ax = plt.subplots() ax.pie(casos['cantidad'], wedgeprops=dict(width=0.5), startangle=-40, autopct='%1.1f%%') ax.legend(casos['UBICACION'], loc="upper center", ncol=2) ax.set_title("Ubicacion contagiados") plt.tight_layout(pad=0.4, w_pad=0.5, h_pad=1.5) plt.savefig('plots/ubicacion') #plt.show() def sexo_edad(table_name, conn): rango_edad = ['0-9', '10-19', '20-29', '30-39', '40-49', '50-59', '60-69', '70-79', '80-...'] casosf = make_query( f"""SELECT SUM(CASE WHEN EDAD <= 9.0 THEN 1 ELSE 0 END) AS [0-9], SUM(CASE WHEN EDAD BETWEEN 10.0 AND 19.0 THEN 1 ELSE 0 END) AS [10-19], SUM(CASE WHEN EDAD BETWEEN 20.0 AND 29.0 THEN 1 ELSE 0 END) AS [20-29], SUM(CASE WHEN EDAD BETWEEN 30.0 AND 39.0 THEN 1 ELSE 0 END) AS [30-39], SUM(CASE WHEN EDAD BETWEEN 40.0 AND 49.0 THEN 1 ELSE 0 END) AS [40-49], SUM(CASE WHEN EDAD BETWEEN 50.0 AND 59.0 THEN 1 ELSE 0 END) AS [50-59], SUM(CASE WHEN EDAD BETWEEN 60.0 AND 69.0 THEN 1 ELSE 0 END) AS [60-69], SUM(CASE WHEN EDAD BETWEEN 70.0 AND 79.0 THEN 1 ELSE 0 END) AS [70-79], SUM(CASE WHEN EDAD >= 80 THEN 1 ELSE 0 END) AS [80-...] FROM {table_name} WHERE SEXO = 'F'""", conn ) casosm = make_query( f"""SELECT SUM(CASE WHEN EDAD <= 9.0 THEN 1 ELSE 0 END) AS [0-9], SUM(CASE WHEN EDAD BETWEEN 10.0 AND 19.0 THEN 1 ELSE 0 END) AS [10-19], SUM(CASE WHEN EDAD BETWEEN 20.0 AND 29.0 THEN 1 ELSE 0 END) AS [20-29], SUM(CASE WHEN EDAD BETWEEN 30.0 AND 39.0 THEN 1 ELSE 0 END) AS [30-39], SUM(CASE WHEN EDAD BETWEEN 40.0 AND 49.0 THEN 1 ELSE 0 END) AS [40-49], SUM(CASE WHEN EDAD BETWEEN 50.0 AND 59.0 THEN 1 ELSE 0 END) AS [50-59], SUM(CASE WHEN EDAD BETWEEN 60.0 AND 69.0 THEN 1 ELSE 0 END) AS [60-69], SUM(CASE WHEN EDAD BETWEEN 70.0 AND 79.0 THEN 1 ELSE 0 END) AS [70-79], SUM(CASE WHEN EDAD >= 80 THEN 1 ELSE 0 END) AS [80-...] FROM {table_name} WHERE SEXO = 'M'""", conn ) f = casosf.values.tolist() m = casosm.values.tolist() x = np.arange(len(rango_edad)) width = 0.35 fig, ax = plt.subplots() mujeres = ax.bar(x - width/2, f[0], width, label='Mujeres') hombres = ax.bar(x + width/2, m[0], width, label='Hombres') ax.set_ylabel('Contagios') ax.set_title('Contagios por sexo y edad') ax.set_xticks(x) ax.set_xticklabels(rango_edad) ax.legend() fig.tight_layout() fig.savefig('plots/sexo_edad.png') #plt.show() def localidad_sexo(table_name, conn): casosf = make_query( f"SELECT LOCALIDAD_ASIS, count(*) as cantidad FROM {table_name} WHERE LOCALIDAD_ASIS not null and SEXO='F' GROUP BY LOCALIDAD_ASIS ORDER BY cantidad", conn ) casosm = make_query( f"SELECT LOCALIDAD_ASIS, count(*) as cantidad FROM {table_name} WHERE LOCALIDAD_ASIS not null and SEXO='M' GROUP BY LOCALIDAD_ASIS ORDER BY cantidad", conn ) y = np.arange(len(casosf['LOCALIDAD_ASIS'])) width = 0.35 fig, ax = plt.subplots() mujeres = ax.barh(y - width/2, casosf['cantidad'], width, label='Mujeres') hombres = ax.barh(y + width/2, casosm['cantidad'], width, label='Hombres') ax.set_ylabel('Localidad') ax.set_yticks(y) ax.set_yticklabels(casosf['LOCALIDAD_ASIS']) ax.legend() plt.title('Contagiados por localidad y sexo') fig.tight_layout() fig.savefig('plots/localidad_sexo.png') plt.show() def localidad(table_name, conn): casos = make_query( f"SELECT LOCALIDAD_ASIS, count(*) as cantidad FROM {table_name} WHERE LOCALIDAD_ASIS not null GROUP BY LOCALIDAD_ASIS ORDER BY cantidad", conn ) casos.plot(x='LOCALIDAD_ASIS', y='cantidad', kind='barh', xlabel='Localidad', ylabel='contagios') plt.title('Contagio por localidad') plt.tight_layout() plt.savefig('plots/localidades.png') #plt.show() def evolucion_casos(table_name, conn): casos = make_query( f"SELECT FECHA_DIAGNOSTICO, count(*) as cantidad FROM {table_name} WHERE FECHA_DIAGNOSTICO not null GROUP BY FECHA_DIAGNOSTICO ORDER BY FECHA_DIAGNOSTICO", conn ) casos['FECHA_DIAGNOSTICO'] =
pd.to_datetime(casos['FECHA_DIAGNOSTICO'])
pandas.to_datetime
import logging import os import re import shutil from datetime import datetime from itertools import combinations from random import randint import numpy as np import pandas as pd import psutil import pytest from dask import dataframe as dd from distributed.utils_test import cluster from tqdm import tqdm import featuretools as ft from featuretools import EntitySet, Timedelta, calculate_feature_matrix, dfs from featuretools.computational_backends import utils from featuretools.computational_backends.calculate_feature_matrix import ( FEATURE_CALCULATION_PERCENTAGE, _chunk_dataframe_groups, _handle_chunk_size, scatter_warning ) from featuretools.computational_backends.utils import ( bin_cutoff_times, create_client_and_cluster, n_jobs_to_workers ) from featuretools.feature_base import ( AggregationFeature, DirectFeature, IdentityFeature ) from featuretools.primitives import ( Count, Max, Min, Percentile, Sum, TransformPrimitive ) from featuretools.tests.testing_utils import ( backward_path, get_mock_client_cluster, to_pandas ) from featuretools.utils.gen_utils import Library, import_or_none ks = import_or_none('databricks.koalas') def test_scatter_warning(caplog): logger = logging.getLogger('featuretools') match = "EntitySet was only scattered to {} out of {} workers" warning_message = match.format(1, 2) logger.propagate = True scatter_warning(1, 2) logger.propagate = False assert warning_message in caplog.text # TODO: final assert fails w/ Dask def test_calc_feature_matrix(es): if not all(isinstance(entity.df, pd.DataFrame) for entity in es.entities): pytest.xfail('Distributed dataframe result not ordered') times = list([datetime(2011, 4, 9, 10, 30, i * 6) for i in range(5)] + [datetime(2011, 4, 9, 10, 31, i * 9) for i in range(4)] + [datetime(2011, 4, 9, 10, 40, 0)] + [datetime(2011, 4, 10, 10, 40, i) for i in range(2)] + [datetime(2011, 4, 10, 10, 41, i * 3) for i in range(3)] + [datetime(2011, 4, 10, 11, 10, i * 3) for i in range(2)]) instances = range(17) cutoff_time = pd.DataFrame({'time': times, es['log'].index: instances}) labels = [False] * 3 + [True] * 2 + [False] * 9 + [True] + [False] * 2 property_feature = ft.Feature(es['log']['value']) > 10 feature_matrix = calculate_feature_matrix([property_feature], es, cutoff_time=cutoff_time, verbose=True) assert (feature_matrix[property_feature.get_name()] == labels).values.all() error_text = 'features must be a non-empty list of features' with pytest.raises(AssertionError, match=error_text): feature_matrix = calculate_feature_matrix('features', es, cutoff_time=cutoff_time) with pytest.raises(AssertionError, match=error_text): feature_matrix = calculate_feature_matrix([], es, cutoff_time=cutoff_time) with pytest.raises(AssertionError, match=error_text): feature_matrix = calculate_feature_matrix([1, 2, 3], es, cutoff_time=cutoff_time) error_text = "cutoff_time times must be datetime type: try casting via "\ "pd\\.to_datetime\\(\\)" with pytest.raises(TypeError, match=error_text): calculate_feature_matrix([property_feature], es, instance_ids=range(17), cutoff_time=17) error_text = 'cutoff_time must be a single value or DataFrame' with pytest.raises(TypeError, match=error_text): calculate_feature_matrix([property_feature], es, instance_ids=range(17), cutoff_time=times) cutoff_times_dup = pd.DataFrame({'time': [datetime(2018, 3, 1), datetime(2018, 3, 1)], es['log'].index: [1, 1]}) error_text = 'Duplicated rows in cutoff time dataframe.' with pytest.raises(AssertionError, match=error_text): feature_matrix = calculate_feature_matrix([property_feature], entityset=es, cutoff_time=cutoff_times_dup) cutoff_reordered = cutoff_time.iloc[[-1, 10, 1]] # 3 ids not ordered by cutoff time feature_matrix = calculate_feature_matrix([property_feature], es, cutoff_time=cutoff_reordered, verbose=True) assert all(feature_matrix.index == cutoff_reordered["id"].values) # fails with Dask and Koalas entitysets, cutoff time not reordered; cannot verify out of order # - can't tell if wrong/different all are false so can't check positional def test_cfm_warns_dask_cutoff_time(es): times = list([datetime(2011, 4, 9, 10, 30, i * 6) for i in range(5)] + [datetime(2011, 4, 9, 10, 31, i * 9) for i in range(4)] + [datetime(2011, 4, 9, 10, 40, 0)] + [datetime(2011, 4, 10, 10, 40, i) for i in range(2)] + [datetime(2011, 4, 10, 10, 41, i * 3) for i in range(3)] + [datetime(2011, 4, 10, 11, 10, i * 3) for i in range(2)]) instances = range(17) cutoff_time = pd.DataFrame({'time': times, es['log'].index: instances}) cutoff_time = dd.from_pandas(cutoff_time, npartitions=4) property_feature = ft.Feature(es['log']['value']) > 10 match = "cutoff_time should be a Pandas DataFrame: " \ "computing cutoff_time, this may take a while" with pytest.warns(UserWarning, match=match): calculate_feature_matrix([property_feature], es, cutoff_time=cutoff_time) def test_cfm_compose(es, lt): property_feature = ft.Feature(es['log']['value']) > 10 feature_matrix = calculate_feature_matrix([property_feature], es, cutoff_time=lt, verbose=True) feature_matrix = to_pandas(feature_matrix, index='id', sort_index=True) assert (feature_matrix[property_feature.get_name()] == feature_matrix['label_func']).values.all() def test_cfm_compose_approximate(es, lt): if not all(isinstance(entity.df, pd.DataFrame) for entity in es.entities): pytest.xfail('dask does not support approximate') property_feature = ft.Feature(es['log']['value']) > 10 feature_matrix = calculate_feature_matrix([property_feature], es, cutoff_time=lt, approximate='1s', verbose=True) assert(type(feature_matrix) == pd.core.frame.DataFrame) feature_matrix = to_pandas(feature_matrix, index='id', sort_index=True) assert (feature_matrix[property_feature.get_name()] == feature_matrix['label_func']).values.all() def test_cfm_dask_compose(dask_es, lt): property_feature = ft.Feature(dask_es['log']['value']) > 10 feature_matrix = calculate_feature_matrix([property_feature], dask_es, cutoff_time=lt, verbose=True) feature_matrix = feature_matrix.compute() assert (feature_matrix[property_feature.get_name()] == feature_matrix['label_func']).values.all() # tests approximate, skip for dask/koalas def test_cfm_approximate_correct_ordering(): trips = { 'trip_id': [i for i in range(1000)], 'flight_time': [datetime(1998, 4, 2) for i in range(350)] + [datetime(1997, 4, 3) for i in range(650)], 'flight_id': [randint(1, 25) for i in range(1000)], 'trip_duration': [randint(1, 999) for i in range(1000)] } df = pd.DataFrame.from_dict(trips) es = EntitySet('flights') es.entity_from_dataframe("trips", dataframe=df, index="trip_id", time_index='flight_time') es.normalize_entity(base_entity_id="trips", new_entity_id="flights", index="flight_id", make_time_index=True) features = dfs(entityset=es, target_entity='trips', features_only=True) flight_features = [feature for feature in features if isinstance(feature, DirectFeature) and isinstance(feature.base_features[0], AggregationFeature)] property_feature = IdentityFeature(es['trips']['trip_id']) cutoff_time = pd.DataFrame.from_dict({'instance_id': df['trip_id'], 'time': df['flight_time']}) time_feature = IdentityFeature(es['trips']['flight_time']) feature_matrix = calculate_feature_matrix(flight_features + [property_feature, time_feature], es, cutoff_time_in_index=True, cutoff_time=cutoff_time) feature_matrix.index.names = ['instance', 'time'] assert(np.all(feature_matrix.reset_index('time').reset_index()[['instance', 'time']].values == feature_matrix[['trip_id', 'flight_time']].values)) feature_matrix_2 = calculate_feature_matrix(flight_features + [property_feature, time_feature], es, cutoff_time=cutoff_time, cutoff_time_in_index=True, approximate=Timedelta(2, 'd')) feature_matrix_2.index.names = ['instance', 'time'] assert(np.all(feature_matrix_2.reset_index('time').reset_index()[['instance', 'time']].values == feature_matrix_2[['trip_id', 'flight_time']].values)) for column in feature_matrix: for x, y in zip(feature_matrix[column], feature_matrix_2[column]): assert ((pd.isnull(x) and pd.isnull(y)) or (x == y)) # uses approximate, skip for dask/koalas entitysets def test_cfm_no_cutoff_time_index(pd_es): agg_feat = ft.Feature(pd_es['log']['id'], parent_entity=pd_es['sessions'], primitive=Count) agg_feat4 = ft.Feature(agg_feat, parent_entity=pd_es['customers'], primitive=Sum) dfeat = DirectFeature(agg_feat4, pd_es['sessions']) cutoff_time = pd.DataFrame({ 'time': [datetime(2013, 4, 9, 10, 31, 19), datetime(2013, 4, 9, 11, 0, 0)], 'instance_id': [0, 2] }) feature_matrix = calculate_feature_matrix([dfeat, agg_feat], pd_es, cutoff_time_in_index=False, approximate=Timedelta(12, 's'), cutoff_time=cutoff_time) assert feature_matrix.index.name == 'id' assert feature_matrix.index.values.tolist() == [0, 2] assert feature_matrix[dfeat.get_name()].tolist() == [10, 10] assert feature_matrix[agg_feat.get_name()].tolist() == [5, 1] cutoff_time = pd.DataFrame({ 'time': [datetime(2011, 4, 9, 10, 31, 19), datetime(2011, 4, 9, 11, 0, 0)], 'instance_id': [0, 2] }) feature_matrix_2 = calculate_feature_matrix([dfeat, agg_feat], pd_es, cutoff_time_in_index=False, approximate=Timedelta(10, 's'), cutoff_time=cutoff_time) assert feature_matrix_2.index.name == 'id' assert feature_matrix_2.index.tolist() == [0, 2] assert feature_matrix_2[dfeat.get_name()].tolist() == [7, 10] assert feature_matrix_2[agg_feat.get_name()].tolist() == [5, 1] # TODO: fails with dask entitysets # TODO: fails with koalas entitysets def test_cfm_duplicated_index_in_cutoff_time(es): if not all(isinstance(entity.df, pd.DataFrame) for entity in es.entities): pytest.xfail('Distributed results not ordered, missing duplicates') times = [datetime(2011, 4, 1), datetime(2011, 5, 1), datetime(2011, 4, 1), datetime(2011, 5, 1)] instances = [1, 1, 2, 2] property_feature = ft.Feature(es['log']['value']) > 10 cutoff_time = pd.DataFrame({'id': instances, 'time': times}, index=[1, 1, 1, 1]) feature_matrix = calculate_feature_matrix([property_feature], es, cutoff_time=cutoff_time, chunk_size=1) assert (feature_matrix.shape[0] == cutoff_time.shape[0]) # TODO: fails with Dask, Koalas def test_saveprogress(es, tmpdir): if not all(isinstance(entity.df, pd.DataFrame) for entity in es.entities): pytest.xfail('saveprogress fails with distributed entitysets') times = list([datetime(2011, 4, 9, 10, 30, i * 6) for i in range(5)] + [datetime(2011, 4, 9, 10, 31, i * 9) for i in range(4)] + [datetime(2011, 4, 9, 10, 40, 0)] + [datetime(2011, 4, 10, 10, 40, i) for i in range(2)] + [datetime(2011, 4, 10, 10, 41, i * 3) for i in range(3)] + [datetime(2011, 4, 10, 11, 10, i * 3) for i in range(2)]) cutoff_time = pd.DataFrame({'time': times, 'instance_id': range(17)}) property_feature = ft.Feature(es['log']['value']) > 10 save_progress = str(tmpdir) fm_save = calculate_feature_matrix([property_feature], es, cutoff_time=cutoff_time, save_progress=save_progress) _, _, files = next(os.walk(save_progress)) files = [os.path.join(save_progress, file) for file in files] # there are 17 datetime files created above assert len(files) == 17 list_df = [] for file_ in files: df = pd.read_csv(file_, index_col="id", header=0) list_df.append(df) merged_df = pd.concat(list_df) merged_df.set_index(pd.DatetimeIndex(times), inplace=True, append=True) fm_no_save = calculate_feature_matrix([property_feature], es, cutoff_time=cutoff_time) assert np.all((merged_df.sort_index().values) == (fm_save.sort_index().values)) assert np.all((fm_no_save.sort_index().values) == (fm_save.sort_index().values)) assert np.all((fm_no_save.sort_index().values) == (merged_df.sort_index().values)) shutil.rmtree(save_progress) def test_cutoff_time_correctly(es): property_feature = ft.Feature(es['log']['id'], parent_entity=es['customers'], primitive=Count) times = [datetime(2011, 4, 10), datetime(2011, 4, 11), datetime(2011, 4, 7)] cutoff_time = pd.DataFrame({'time': times, 'instance_id': [0, 1, 2]}) feature_matrix = calculate_feature_matrix([property_feature], es, cutoff_time=cutoff_time) feature_matrix = to_pandas(feature_matrix, index='id', sort_index=True) labels = [10, 5, 0] assert (feature_matrix[property_feature.get_name()] == labels).values.all() def test_cutoff_time_binning(): cutoff_time = pd.DataFrame({ 'time': [ datetime(2011, 4, 9, 12, 31), datetime(2011, 4, 10, 11), datetime(2011, 4, 10, 13, 10, 1) ], 'instance_id': [1, 2, 3] }) binned_cutoff_times = bin_cutoff_times(cutoff_time, Timedelta(4, 'h')) labels = [datetime(2011, 4, 9, 12), datetime(2011, 4, 10, 8), datetime(2011, 4, 10, 12)] for i in binned_cutoff_times.index: assert binned_cutoff_times['time'][i] == labels[i] binned_cutoff_times = bin_cutoff_times(cutoff_time, Timedelta(25, 'h')) labels = [datetime(2011, 4, 8, 22), datetime(2011, 4, 9, 23), datetime(2011, 4, 9, 23)] for i in binned_cutoff_times.index: assert binned_cutoff_times['time'][i] == labels[i] error_text = "Unit is relative" with pytest.raises(ValueError, match=error_text): binned_cutoff_times = bin_cutoff_times(cutoff_time, Timedelta(1, 'mo')) def test_training_window_fails_dask(dask_es): property_feature = ft.Feature(dask_es['log']['id'], parent_entity=dask_es['customers'], primitive=Count) error_text = "Using training_window is not supported with Dask Entities" with pytest.raises(ValueError, match=error_text): calculate_feature_matrix([property_feature], dask_es, training_window='2 hours') def test_cutoff_time_columns_order(es): property_feature = ft.Feature(es['log']['id'], parent_entity=es['customers'], primitive=Count) times = [datetime(2011, 4, 10), datetime(2011, 4, 11), datetime(2011, 4, 7)] id_col_names = ['instance_id', es['customers'].index] time_col_names = ['time', es['customers'].time_index] for id_col in id_col_names: for time_col in time_col_names: cutoff_time = pd.DataFrame({'dummy_col_1': [1, 2, 3], id_col: [0, 1, 2], 'dummy_col_2': [True, False, False], time_col: times}) feature_matrix = calculate_feature_matrix([property_feature], es, cutoff_time=cutoff_time) labels = [10, 5, 0] feature_matrix = to_pandas(feature_matrix, index='id', sort_index=True) assert (feature_matrix[property_feature.get_name()] == labels).values.all() def test_cutoff_time_df_redundant_column_names(es): property_feature = ft.Feature(es['log']['id'], parent_entity=es['customers'], primitive=Count) times = [datetime(2011, 4, 10), datetime(2011, 4, 11), datetime(2011, 4, 7)] cutoff_time = pd.DataFrame({es['customers'].index: [0, 1, 2], 'instance_id': [0, 1, 2], 'dummy_col': [True, False, False], 'time': times}) err_msg = 'Cutoff time DataFrame cannot contain both a column named "instance_id" and a column' \ ' with the same name as the target entity index' with pytest.raises(AttributeError, match=err_msg): calculate_feature_matrix([property_feature], es, cutoff_time=cutoff_time) cutoff_time = pd.DataFrame({es['customers'].time_index: [0, 1, 2], 'instance_id': [0, 1, 2], 'dummy_col': [True, False, False], 'time': times}) err_msg = 'Cutoff time DataFrame cannot contain both a column named "time" and a column' \ ' with the same name as the target entity time index' with pytest.raises(AttributeError, match=err_msg): calculate_feature_matrix([property_feature], es, cutoff_time=cutoff_time) def test_training_window(pd_es): property_feature = ft.Feature(pd_es['log']['id'], parent_entity=pd_es['customers'], primitive=Count) top_level_agg = ft.Feature(pd_es['customers']['id'], parent_entity=pd_es[u'régions'], primitive=Count) # make sure features that have a direct to a higher level agg # so we have multiple "filter eids" in get_pandas_data_slice, # and we go through the loop to pull data with a training_window param more than once dagg = DirectFeature(top_level_agg, pd_es['customers']) # for now, warns if last_time_index not present times = [datetime(2011, 4, 9, 12, 31), datetime(2011, 4, 10, 11), datetime(2011, 4, 10, 13, 10)] cutoff_time = pd.DataFrame({'time': times, 'instance_id': [0, 1, 2]}) warn_text = "Using training_window but last_time_index is not set on entity customers" with pytest.warns(UserWarning, match=warn_text): feature_matrix = calculate_feature_matrix([property_feature, dagg], pd_es, cutoff_time=cutoff_time, training_window='2 hours') pd_es.add_last_time_indexes() error_text = 'Training window cannot be in observations' with pytest.raises(AssertionError, match=error_text): feature_matrix = calculate_feature_matrix([property_feature], pd_es, cutoff_time=cutoff_time, training_window=Timedelta(2, 'observations')) # Case1. include_cutoff_time = True feature_matrix = calculate_feature_matrix([property_feature, dagg], pd_es, cutoff_time=cutoff_time, training_window='2 hours', include_cutoff_time=True) prop_values = [4, 5, 1] dagg_values = [3, 2, 1] assert (feature_matrix[property_feature.get_name()] == prop_values).values.all() assert (feature_matrix[dagg.get_name()] == dagg_values).values.all() # Case2. include_cutoff_time = False feature_matrix = calculate_feature_matrix([property_feature, dagg], pd_es, cutoff_time=cutoff_time, training_window='2 hours', include_cutoff_time=False) prop_values = [5, 5, 2] dagg_values = [3, 2, 1] assert (feature_matrix[property_feature.get_name()] == prop_values).values.all() assert (feature_matrix[dagg.get_name()] == dagg_values).values.all() # Case3. include_cutoff_time = False with single cutoff time value feature_matrix = calculate_feature_matrix([property_feature, dagg], pd_es, cutoff_time=pd.to_datetime("2011-04-09 10:40:00"), training_window='9 minutes', include_cutoff_time=False) prop_values = [0, 4, 0] dagg_values = [3, 3, 3] assert (feature_matrix[property_feature.get_name()] == prop_values).values.all() assert (feature_matrix[dagg.get_name()] == dagg_values).values.all() # Case4. include_cutoff_time = True with single cutoff time value feature_matrix = calculate_feature_matrix([property_feature, dagg], pd_es, cutoff_time=pd.to_datetime("2011-04-10 10:40:00"), training_window='2 days', include_cutoff_time=True) prop_values = [0, 10, 1] dagg_values = [3, 3, 3] assert (feature_matrix[property_feature.get_name()] == prop_values).values.all() assert (feature_matrix[dagg.get_name()] == dagg_values).values.all() def test_training_window_overlap(pd_es): pd_es.add_last_time_indexes() count_log = ft.Feature( base=pd_es['log']['id'], parent_entity=pd_es['customers'], primitive=Count, ) cutoff_time = pd.DataFrame({ 'id': [0, 0], 'time': ['2011-04-09 10:30:00', '2011-04-09 10:40:00'], }).astype({'time': 'datetime64[ns]'}) # Case1. include_cutoff_time = True actual = calculate_feature_matrix( features=[count_log], entityset=pd_es, cutoff_time=cutoff_time, cutoff_time_in_index=True, training_window='10 minutes', include_cutoff_time=True, )['COUNT(log)'] np.testing.assert_array_equal(actual.values, [1, 9]) # Case2. include_cutoff_time = False actual = calculate_feature_matrix( features=[count_log], entityset=pd_es, cutoff_time=cutoff_time, cutoff_time_in_index=True, training_window='10 minutes', include_cutoff_time=False, )['COUNT(log)'] np.testing.assert_array_equal(actual.values, [0, 9]) def test_include_cutoff_time_without_training_window(es): es.add_last_time_indexes() count_log = ft.Feature( base=es['log']['id'], parent_entity=es['customers'], primitive=Count, ) cutoff_time = pd.DataFrame({ 'id': [0, 0], 'time': ['2011-04-09 10:30:00', '2011-04-09 10:31:00'], }).astype({'time': 'datetime64[ns]'}) # Case1. include_cutoff_time = True actual = calculate_feature_matrix( features=[count_log], entityset=es, cutoff_time=cutoff_time, cutoff_time_in_index=True, include_cutoff_time=True, )['COUNT(log)'] actual = to_pandas(actual) np.testing.assert_array_equal(actual.values, [1, 6]) # Case2. include_cutoff_time = False actual = calculate_feature_matrix( features=[count_log], entityset=es, cutoff_time=cutoff_time, cutoff_time_in_index=True, include_cutoff_time=False, )['COUNT(log)'] actual = to_pandas(actual) np.testing.assert_array_equal(actual.values, [0, 5]) # Case3. include_cutoff_time = True with single cutoff time value actual = calculate_feature_matrix( features=[count_log], entityset=es, cutoff_time=pd.to_datetime("2011-04-09 10:31:00"), instance_ids=[0], cutoff_time_in_index=True, include_cutoff_time=True, )['COUNT(log)'] actual = to_pandas(actual) np.testing.assert_array_equal(actual.values, [6]) # Case4. include_cutoff_time = False with single cutoff time value actual = calculate_feature_matrix( features=[count_log], entityset=es, cutoff_time=pd.to_datetime("2011-04-09 10:31:00"), instance_ids=[0], cutoff_time_in_index=True, include_cutoff_time=False, )['COUNT(log)'] actual = to_pandas(actual) np.testing.assert_array_equal(actual.values, [5]) def test_approximate_dfeat_of_agg_on_target_include_cutoff_time(pd_es): agg_feat = ft.Feature(pd_es['log']['id'], parent_entity=pd_es['sessions'], primitive=Count) agg_feat2 = ft.Feature(agg_feat, parent_entity=pd_es['customers'], primitive=Sum) dfeat = DirectFeature(agg_feat2, pd_es['sessions']) cutoff_time = pd.DataFrame({'time': [datetime(2011, 4, 9, 10, 31, 19)], 'instance_id': [0]}) feature_matrix = calculate_feature_matrix([dfeat, agg_feat2, agg_feat], pd_es, approximate=Timedelta(20, 's'), cutoff_time=cutoff_time, include_cutoff_time=False) # binned cutoff_time will be datetime(2011, 4, 9, 10, 31, 0) and # log event 5 at datetime(2011, 4, 9, 10, 31, 0) will be # excluded due to approximate cutoff time point assert feature_matrix[dfeat.get_name()].tolist() == [5] assert feature_matrix[agg_feat.get_name()].tolist() == [5] feature_matrix = calculate_feature_matrix([dfeat, agg_feat], pd_es, approximate=Timedelta(20, 's'), cutoff_time=cutoff_time, include_cutoff_time=True) # binned cutoff_time will be datetime(2011, 4, 9, 10, 31, 0) and # log event 5 at datetime(2011, 4, 9, 10, 31, 0) will be # included due to approximate cutoff time point assert feature_matrix[dfeat.get_name()].tolist() == [6] assert feature_matrix[agg_feat.get_name()].tolist() == [5] def test_training_window_recent_time_index(pd_es): # customer with no sessions row = { 'id': [3], 'age': [73], u'région_id': ['United States'], 'cohort': [1], 'cancel_reason': ["Lost interest"], 'loves_ice_cream': [True], 'favorite_quote': ["Don't look back. Something might be gaining on you."], 'signup_date': [datetime(2011, 4, 10)], 'upgrade_date': [datetime(2011, 4, 12)], 'cancel_date': [datetime(2011, 5, 13)], 'date_of_birth': [datetime(1938, 2, 1)], 'engagement_level': [2], } to_add_df = pd.DataFrame(row) to_add_df.index = range(3, 4) # have to convert category to int in order to concat old_df = pd_es['customers'].df old_df.index = old_df.index.astype("int") old_df["id"] = old_df["id"].astype(int) df = pd.concat([old_df, to_add_df], sort=True) # convert back after df.index = df.index.astype("category") df["id"] = df["id"].astype("category") pd_es['customers'].update_data(df=df, recalculate_last_time_indexes=False) pd_es.add_last_time_indexes() property_feature = ft.Feature(pd_es['log']['id'], parent_entity=pd_es['customers'], primitive=Count) top_level_agg = ft.Feature(pd_es['customers']['id'], parent_entity=pd_es[u'régions'], primitive=Count) dagg = DirectFeature(top_level_agg, pd_es['customers']) instance_ids = [0, 1, 2, 3] times = [datetime(2011, 4, 9, 12, 31), datetime(2011, 4, 10, 11), datetime(2011, 4, 10, 13, 10, 1), datetime(2011, 4, 10, 1, 59, 59)] cutoff_time = pd.DataFrame({'time': times, 'instance_id': instance_ids}) # Case1. include_cutoff_time = True feature_matrix = calculate_feature_matrix( [property_feature, dagg], pd_es, cutoff_time=cutoff_time, training_window='2 hours', include_cutoff_time=True, ) prop_values = [4, 5, 1, 0] assert (feature_matrix[property_feature.get_name()] == prop_values).values.all() dagg_values = [3, 2, 1, 3] feature_matrix.sort_index(inplace=True) assert (feature_matrix[dagg.get_name()] == dagg_values).values.all() # Case2. include_cutoff_time = False feature_matrix = calculate_feature_matrix( [property_feature, dagg], pd_es, cutoff_time=cutoff_time, training_window='2 hours', include_cutoff_time=False, ) prop_values = [5, 5, 1, 0] assert (feature_matrix[property_feature.get_name()] == prop_values).values.all() dagg_values = [3, 2, 1, 3] feature_matrix.sort_index(inplace=True) assert (feature_matrix[dagg.get_name()] == dagg_values).values.all() # TODO: add test to fail w/ koalas def test_approximate_fails_dask(dask_es): agg_feat = ft.Feature(dask_es['log']['id'], parent_entity=dask_es['sessions'], primitive=Count) error_text = "Using approximate is not supported with Dask Entities" with pytest.raises(ValueError, match=error_text): calculate_feature_matrix([agg_feat], dask_es, approximate=Timedelta(1, 'week')) def test_approximate_multiple_instances_per_cutoff_time(pd_es): agg_feat = ft.Feature(pd_es['log']['id'], parent_entity=pd_es['sessions'], primitive=Count) agg_feat2 = ft.Feature(agg_feat, parent_entity=pd_es['customers'], primitive=Sum) dfeat = DirectFeature(agg_feat2, pd_es['sessions']) times = [datetime(2011, 4, 9, 10, 31, 19), datetime(2011, 4, 9, 11, 0, 0)] cutoff_time = pd.DataFrame({'time': times, 'instance_id': [0, 2]}) feature_matrix = calculate_feature_matrix([dfeat, agg_feat], pd_es, approximate=Timedelta(1, 'week'), cutoff_time=cutoff_time) assert feature_matrix.shape[0] == 2 assert feature_matrix[agg_feat.get_name()].tolist() == [5, 1] def test_approximate_with_multiple_paths(pd_diamond_es): pd_es = pd_diamond_es path = backward_path(pd_es, ['regions', 'customers', 'transactions']) agg_feat = ft.AggregationFeature(pd_es['transactions']['id'], parent_entity=pd_es['regions'], relationship_path=path, primitive=Count) dfeat = DirectFeature(agg_feat, pd_es['customers']) times = [datetime(2011, 4, 9, 10, 31, 19), datetime(2011, 4, 9, 11, 0, 0)] cutoff_time = pd.DataFrame({'time': times, 'instance_id': [0, 2]}) feature_matrix = calculate_feature_matrix([dfeat], pd_es, approximate=Timedelta(1, 'week'), cutoff_time=cutoff_time) assert feature_matrix[dfeat.get_name()].tolist() == [6, 2] def test_approximate_dfeat_of_agg_on_target(pd_es): agg_feat = ft.Feature(pd_es['log']['id'], parent_entity=pd_es['sessions'], primitive=Count) agg_feat2 = ft.Feature(agg_feat, parent_entity=pd_es['customers'], primitive=Sum) dfeat = DirectFeature(agg_feat2, pd_es['sessions']) times = [datetime(2011, 4, 9, 10, 31, 19), datetime(2011, 4, 9, 11, 0, 0)] cutoff_time = pd.DataFrame({'time': times, 'instance_id': [0, 2]}) feature_matrix = calculate_feature_matrix([dfeat, agg_feat], pd_es, instance_ids=[0, 2], approximate=Timedelta(10, 's'), cutoff_time=cutoff_time) assert feature_matrix[dfeat.get_name()].tolist() == [7, 10] assert feature_matrix[agg_feat.get_name()].tolist() == [5, 1] def test_approximate_dfeat_of_need_all_values(pd_es): p = ft.Feature(pd_es['log']['value'], primitive=Percentile) agg_feat = ft.Feature(p, parent_entity=pd_es['sessions'], primitive=Sum) agg_feat2 = ft.Feature(agg_feat, parent_entity=pd_es['customers'], primitive=Sum) dfeat = DirectFeature(agg_feat2, pd_es['sessions']) times = [datetime(2011, 4, 9, 10, 31, 19), datetime(2011, 4, 9, 11, 0, 0)] cutoff_time = pd.DataFrame({'time': times, 'instance_id': [0, 2]}) feature_matrix = calculate_feature_matrix([dfeat, agg_feat], pd_es, approximate=Timedelta(10, 's'), cutoff_time_in_index=True, cutoff_time=cutoff_time) log_df = pd_es['log'].df instances = [0, 2] cutoffs = [pd.Timestamp('2011-04-09 10:31:19'), pd.Timestamp('2011-04-09 11:00:00')] approxes = [pd.Timestamp('2011-04-09 10:31:10'), pd.Timestamp('2011-04-09 11:00:00')] true_vals = [] true_vals_approx = [] for instance, cutoff, approx in zip(instances, cutoffs, approxes): log_data_cutoff = log_df[log_df['datetime'] < cutoff] log_data_cutoff['percentile'] = log_data_cutoff['value'].rank(pct=True) true_agg = log_data_cutoff.loc[log_data_cutoff['session_id'] == instance, 'percentile'].fillna(0).sum() true_vals.append(round(true_agg, 3)) log_data_approx = log_df[log_df['datetime'] < approx] log_data_approx['percentile'] = log_data_approx['value'].rank(pct=True) true_agg_approx = log_data_approx.loc[log_data_approx['session_id'].isin([0, 1, 2]), 'percentile'].fillna(0).sum() true_vals_approx.append(round(true_agg_approx, 3)) lapprox = [round(x, 3) for x in feature_matrix[dfeat.get_name()].tolist()] test_list = [round(x, 3) for x in feature_matrix[agg_feat.get_name()].tolist()] assert lapprox == true_vals_approx assert test_list == true_vals def test_uses_full_entity_feat_of_approximate(pd_es): agg_feat = ft.Feature(pd_es['log']['value'], parent_entity=pd_es['sessions'], primitive=Sum) agg_feat2 = ft.Feature(agg_feat, parent_entity=pd_es['customers'], primitive=Sum) agg_feat3 = ft.Feature(agg_feat, parent_entity=pd_es['customers'], primitive=Max) dfeat = DirectFeature(agg_feat2, pd_es['sessions']) dfeat2 = DirectFeature(agg_feat3, pd_es['sessions']) p = ft.Feature(dfeat, primitive=Percentile) times = [datetime(2011, 4, 9, 10, 31, 19), datetime(2011, 4, 9, 11, 0, 0)] cutoff_time = pd.DataFrame({'time': times, 'instance_id': [0, 2]}) # only dfeat2 should be approximated # because Percentile needs all values feature_matrix_only_dfeat2 = calculate_feature_matrix( [dfeat2], pd_es, approximate=Timedelta(10, 's'), cutoff_time_in_index=True, cutoff_time=cutoff_time) assert feature_matrix_only_dfeat2[dfeat2.get_name()].tolist() == [50, 50] feature_matrix_approx = calculate_feature_matrix( [p, dfeat, dfeat2, agg_feat], pd_es, approximate=Timedelta(10, 's'), cutoff_time_in_index=True, cutoff_time=cutoff_time) assert feature_matrix_only_dfeat2[dfeat2.get_name()].tolist() == feature_matrix_approx[dfeat2.get_name()].tolist() feature_matrix_small_approx = calculate_feature_matrix( [p, dfeat, dfeat2, agg_feat], pd_es, approximate=Timedelta(10, 'ms'), cutoff_time_in_index=True, cutoff_time=cutoff_time) feature_matrix_no_approx = calculate_feature_matrix( [p, dfeat, dfeat2, agg_feat], pd_es, cutoff_time_in_index=True, cutoff_time=cutoff_time) for f in [p, dfeat, agg_feat]: for fm1, fm2 in combinations([feature_matrix_approx, feature_matrix_small_approx, feature_matrix_no_approx], 2): assert fm1[f.get_name()].tolist() == fm2[f.get_name()].tolist() def test_approximate_dfeat_of_dfeat_of_agg_on_target(pd_es): agg_feat = ft.Feature(pd_es['log']['id'], parent_entity=pd_es['sessions'], primitive=Count) agg_feat2 = ft.Feature(agg_feat, parent_entity=pd_es['customers'], primitive=Sum) dfeat = DirectFeature(ft.Feature(agg_feat2, pd_es["sessions"]), pd_es['log']) times = [datetime(2011, 4, 9, 10, 31, 19), datetime(2011, 4, 9, 11, 0, 0)] cutoff_time = pd.DataFrame({'time': times, 'instance_id': [0, 2]}) feature_matrix = calculate_feature_matrix([dfeat], pd_es, approximate=Timedelta(10, 's'), cutoff_time=cutoff_time) assert feature_matrix[dfeat.get_name()].tolist() == [7, 10] def test_empty_path_approximate_full(pd_es): pd_es['sessions'].df['customer_id'] = pd.Series([np.nan, np.nan, np.nan, 1, 1, 2], dtype="category") agg_feat = ft.Feature(pd_es['log']['id'], parent_entity=pd_es['sessions'], primitive=Count) agg_feat2 = ft.Feature(agg_feat, parent_entity=pd_es['customers'], primitive=Sum) dfeat = DirectFeature(agg_feat2, pd_es['sessions']) times = [datetime(2011, 4, 9, 10, 31, 19), datetime(2011, 4, 9, 11, 0, 0)] cutoff_time = pd.DataFrame({'time': times, 'instance_id': [0, 2]}) feature_matrix = calculate_feature_matrix([dfeat, agg_feat], pd_es, approximate=Timedelta(10, 's'), cutoff_time=cutoff_time) vals1 = feature_matrix[dfeat.get_name()].tolist() assert (vals1[0] == 0) assert (vals1[1] == 0) assert feature_matrix[agg_feat.get_name()].tolist() == [5, 1] # todo: do we need to test this situation? # def test_empty_path_approximate_partial(pd_es): # pd_es = copy.deepcopy(pd_es) # pd_es['sessions'].df['customer_id'] = pd.Categorical([0, 0, np.nan, 1, 1, 2]) # agg_feat = ft.Feature(pd_es['log']['id'], parent_entity=pd_es['sessions'], primitive=Count) # agg_feat2 = ft.Feature(agg_feat, parent_entity=pd_es['customers'], primitive=Sum) # dfeat = DirectFeature(agg_feat2, pd_es['sessions']) # times = [datetime(2011, 4, 9, 10, 31, 19), datetime(2011, 4, 9, 11, 0, 0)] # cutoff_time = pd.DataFrame({'time': times, 'instance_id': [0, 2]}) # feature_matrix = calculate_feature_matrix([dfeat, agg_feat], # pd_es, # approximate=Timedelta(10, 's'), # cutoff_time=cutoff_time) # vals1 = feature_matrix[dfeat.get_name()].tolist() # assert vals1[0] == 7 # assert np.isnan(vals1[1]) # assert feature_matrix[agg_feat.get_name()].tolist() == [5, 1] def test_approx_base_feature_is_also_first_class_feature(pd_es): log_to_products = DirectFeature(pd_es['products']['rating'], pd_es['log']) # This should still be computed properly agg_feat = ft.Feature(log_to_products, parent_entity=pd_es['sessions'], primitive=Min) customer_agg_feat = ft.Feature(agg_feat, parent_entity=pd_es['customers'], primitive=Sum) # This is to be approximated sess_to_cust = DirectFeature(customer_agg_feat, pd_es['sessions']) times = [datetime(2011, 4, 9, 10, 31, 19), datetime(2011, 4, 9, 11, 0, 0)] cutoff_time = pd.DataFrame({'time': times, 'instance_id': [0, 2]}) feature_matrix = calculate_feature_matrix([sess_to_cust, agg_feat], pd_es, approximate=Timedelta(10, 's'), cutoff_time=cutoff_time) vals1 = feature_matrix[sess_to_cust.get_name()].tolist() assert vals1 == [8.5, 7] vals2 = feature_matrix[agg_feat.get_name()].tolist() assert vals2 == [4, 1.5] def test_approximate_time_split_returns_the_same_result(pd_es): agg_feat = ft.Feature(pd_es['log']['id'], parent_entity=pd_es['sessions'], primitive=Count) agg_feat2 = ft.Feature(agg_feat, parent_entity=pd_es['customers'], primitive=Sum) dfeat = DirectFeature(agg_feat2, pd_es['sessions']) cutoff_df = pd.DataFrame({'time': [pd.Timestamp('2011-04-09 10:07:30'), pd.Timestamp('2011-04-09 10:07:40')], 'instance_id': [0, 0]}) feature_matrix_at_once = calculate_feature_matrix([dfeat, agg_feat], pd_es, approximate=Timedelta(10, 's'), cutoff_time=cutoff_df) divided_matrices = [] separate_cutoff = [cutoff_df.iloc[0:1], cutoff_df.iloc[1:]] # Make sure indexes are different # Not that this step is unecessary and done to showcase the issue here separate_cutoff[0].index = [0] separate_cutoff[1].index = [1] for ct in separate_cutoff: fm = calculate_feature_matrix([dfeat, agg_feat], pd_es, approximate=Timedelta(10, 's'), cutoff_time=ct) divided_matrices.append(fm) feature_matrix_from_split = pd.concat(divided_matrices) assert feature_matrix_from_split.shape == feature_matrix_at_once.shape for i1, i2 in zip(feature_matrix_at_once.index, feature_matrix_from_split.index): assert (pd.isnull(i1) and pd.isnull(i2)) or (i1 == i2) for c in feature_matrix_from_split: for i1, i2 in zip(feature_matrix_at_once[c], feature_matrix_from_split[c]): assert (pd.isnull(i1) and pd.isnull(i2)) or (i1 == i2) def test_approximate_returns_correct_empty_default_values(pd_es): agg_feat = ft.Feature(pd_es['log']['id'], parent_entity=pd_es['customers'], primitive=Count) dfeat = DirectFeature(agg_feat, pd_es['sessions']) cutoff_df = pd.DataFrame({'time': [pd.Timestamp('2011-04-08 11:00:00'), pd.Timestamp('2011-04-09 11:00:00')], 'instance_id': [0, 0]}) fm = calculate_feature_matrix([dfeat], pd_es, approximate=Timedelta(10, 's'), cutoff_time=cutoff_df) assert fm[dfeat.get_name()].tolist() == [0, 10] # def test_approximate_deep_recurse(pd_es): # pd_es = pd_es # agg_feat = ft.Feature(pd_es['customers']['id'], parent_entity=pd_es[u'régions'], primitive=Count) # dfeat1 = DirectFeature(agg_feat, pd_es['sessions']) # agg_feat2 = Sum(dfeat1, pd_es['customers']) # dfeat2 = DirectFeature(agg_feat2, pd_es['sessions']) # agg_feat3 = ft.Feature(pd_es['log']['id'], parent_entity=pd_es['products'], primitive=Count) # dfeat3 = DirectFeature(agg_feat3, pd_es['log']) # agg_feat4 = Sum(dfeat3, pd_es['sessions']) # feature_matrix = calculate_feature_matrix([dfeat2, agg_feat4], # pd_es, # instance_ids=[0, 2], # approximate=Timedelta(10, 's'), # cutoff_time=[datetime(2011, 4, 9, 10, 31, 19), # datetime(2011, 4, 9, 11, 0, 0)]) # # dfeat2 and agg_feat4 should both be approximated def test_approximate_child_aggs_handled_correctly(pd_es): agg_feat = ft.Feature(pd_es['customers']['id'], parent_entity=pd_es[u'régions'], primitive=Count) dfeat = DirectFeature(agg_feat, pd_es['customers']) agg_feat_2 = ft.Feature(pd_es['log']['value'], parent_entity=pd_es['customers'], primitive=Sum) cutoff_df = pd.DataFrame({'time': [pd.Timestamp('2011-04-08 10:30:00'), pd.Timestamp('2011-04-09 10:30:06')], 'instance_id': [0, 0]}) fm = calculate_feature_matrix([dfeat], pd_es, approximate=Timedelta(10, 's'), cutoff_time=cutoff_df) fm_2 = calculate_feature_matrix([dfeat, agg_feat_2], pd_es, approximate=Timedelta(10, 's'), cutoff_time=cutoff_df) assert fm[dfeat.get_name()].tolist() == [2, 3] assert fm_2[agg_feat_2.get_name()].tolist() == [0, 5] def test_cutoff_time_naming(es): agg_feat = ft.Feature(es['customers']['id'], parent_entity=es[u'régions'], primitive=Count) dfeat = DirectFeature(agg_feat, es['customers']) cutoff_df = pd.DataFrame({'time': [pd.Timestamp('2011-04-08 10:30:00'), pd.Timestamp('2011-04-09 10:30:06')], 'instance_id': [0, 0]}) cutoff_df_index_name = cutoff_df.rename(columns={"instance_id": "id"}) cutoff_df_wrong_index_name = cutoff_df.rename(columns={"instance_id": "wrong_id"}) cutoff_df_wrong_time_name = cutoff_df.rename(columns={"time": "cutoff_time"}) fm1 = calculate_feature_matrix([dfeat], es, cutoff_time=cutoff_df) fm1 = to_pandas(fm1, index='id', sort_index=True) fm2 = calculate_feature_matrix([dfeat], es, cutoff_time=cutoff_df_index_name) fm2 = to_pandas(fm2, index='id', sort_index=True) assert all((fm1 == fm2.values).values) error_text = 'Cutoff time DataFrame must contain a column with either the same name' \ ' as the target entity index or a column named "instance_id"' with pytest.raises(AttributeError, match=error_text): calculate_feature_matrix([dfeat], es, cutoff_time=cutoff_df_wrong_index_name) time_error_text = 'Cutoff time DataFrame must contain a column with either the same name' \ ' as the target entity time_index or a column named "time"' with pytest.raises(AttributeError, match=time_error_text): calculate_feature_matrix([dfeat], es, cutoff_time=cutoff_df_wrong_time_name) # TODO: order doesn't match, but output matches def test_cutoff_time_extra_columns(es): if not all(isinstance(entity.df, pd.DataFrame) for entity in es.entities): pytest.xfail('Distributed result not ordered') agg_feat = ft.Feature(es['customers']['id'], parent_entity=es[u'régions'], primitive=Count) dfeat = DirectFeature(agg_feat, es['customers']) cutoff_df = pd.DataFrame({'time': [pd.Timestamp('2011-04-09 10:30:06'), pd.Timestamp('2011-04-09 10:30:03'), pd.Timestamp('2011-04-08 10:30:00')], 'instance_id': [0, 1, 0], 'label': [True, True, False]}, columns=['time', 'instance_id', 'label']) fm = calculate_feature_matrix([dfeat], es, cutoff_time=cutoff_df) # check column was added to end of matrix assert 'label' == fm.columns[-1] assert (fm['label'].values == cutoff_df['label'].values).all() def test_cutoff_time_extra_columns_approximate(pd_es): agg_feat = ft.Feature(pd_es['customers']['id'], parent_entity=pd_es[u'régions'], primitive=Count) dfeat = DirectFeature(agg_feat, pd_es['customers']) cutoff_df = pd.DataFrame({'time': [
pd.Timestamp('2011-04-09 10:30:06')
pandas.Timestamp
import requests from bs4 import BeautifulSoup import pandas as pd from difflib import SequenceMatcher desired_width = 320 pd.set_option('display.width', desired_width) pd.set_option('display.max_columns', 10) pd.set_option('display.max_rows', 1000) pd.set_option('display.max_colwidth', None) #To display full URL in dataframe from datetime import datetime def df_column_switch(df, column1, column2): i = list(df.columns) a, b = i.index(column1), i.index(column2) i[b], i[a] = i[a], i[b] df = df[i] return df def create_jobsdf_greenhouse(company_name, url, save_to_excel = False): ''' Add function description here ''' url = str(url) company_name = str(company_name) page = requests.get(url) sections = BeautifulSoup(page.text, 'html.parser').find_all('section', {'class': 'level-0'}) roles = [] role_urls = [] for section in sections: #print(section) for opening in section.find_all('div', {'class': 'opening'}): #print(opening) #print(' ') role_title = opening.find('a').getText().strip() role_location = opening.find('span', {'class': 'location'}).getText().strip() partial_url = [elem.get('href') for elem in opening.find_all('a')][0] if ((company_name == 'Optiver') or (company_name == 'Glovo') or (company_name == 'Graviton Research Capital')): job_no = partial_url.split('/')[-1].split('=')[-1] role_url = partial_url elif company_name == 'Squarepoint Capital': job_no = partial_url.split('/')[-1].split('=')[-1] role_url = partial_url.split('?')[0] + '/job#' + job_no else: job_no = partial_url.split('/')[-1] common_size = SequenceMatcher(None, partial_url, url).get_matching_blocks()[0].size #U #.find_longest_match(0, len(partial_url), 0, len(url)) role_url = url + partial_url[common_size : ] #U roles.append(role_title + ' - ' + role_location + ' - ' + job_no) role_urls.append(role_url) jobs_df = pd.DataFrame(
pd.Series(roles)
pandas.Series
import pandas as pd import numpy as np import os import math import random import pickle from typing import List, Tuple from sklearn.model_selection import train_test_split from sklearn.ensemble import RandomForestClassifier from lightgbm import LGBMRegressor from progress.bar import Bar from prismx.utils import read_gmt, load_correlation, load_feature from prismx.feature import load_features def create_training_data(workdir: str, gmt_file: str, false_sample_count: int=50000) -> List: correlation_files = os.listdir(workdir+"/correlation") correlation = load_correlation(workdir, 0) background_genes = list(correlation.columns) library, rev_library, ugenes = read_gmt(gmt_file, background_genes) df_true = pd.DataFrame() lk = list(range(0, len(correlation_files)-1)) lk.append("global") bar = Bar('Retrieve training data', max=2*len(lk)) for i in lk: feature = load_feature(workdir, i) features = [] keys = list(feature.columns) setname = [] genename = [] for se in keys: vals = library[se] for val in vals: setname.append(val) genename.append(se) features.append(feature.loc[val.encode('UTF-8'), se]) df_true.loc[:,i] = features bar.next() df_true2 = pd.concat([pd.DataFrame(genename), pd.DataFrame(setname),df_true, pd.DataFrame(np.ones(len(setname)))], axis=1) samp_set = [] samp_gene = [] npw = np.array(df_true2.iloc[:, 0]) false_gene_count = math.ceil(false_sample_count/len(background_genes)) for i in background_genes: rkey = random.sample(keys,1)[0] ww = np.where(npw == rkey)[0] for j in range(0, false_gene_count): rgene = random.sample(background_genes,1)[0] if rgene not in df_true2.iloc[ww, 1]: samp_set.append(rkey) samp_gene.append(rgene) df_false = pd.DataFrame() Bar('Retrieve false samples ', max=len(lk)) for i in lk: feature = load_feature(workdir, i) features = [] setname = [] genename = [] for k in range(0,len(samp_set)): se = samp_set[k] val = samp_gene[k] setname.append(se) genename.append(val) features.append(feature.loc[val.encode('UTF-8'), se]) df_false.loc[:,i] = features bar.next() df_false2 = pd.concat([
pd.DataFrame(setname)
pandas.DataFrame
import os, sys, inspect, itertools sys.path.insert(1, os.path.join(sys.path[0], '../../')) import numpy as np import random import matplotlib.pyplot as plt import pandas as pd from sklearn.preprocessing import StandardScaler from sklearn.ensemble import GradientBoostingRegressor, IsolationForest from sklearn.neighbors import LocalOutlierFactor from scipy.stats import spearmanr from core.concentration import * from tqdm import tqdm import pdb def fix_randomness(seed=0): np.random.seed(seed=seed) random.seed(seed) def get_data(): #df = pd.concat( [ pd.read_csv('./data/meps_19_reg.csv'), pd.read_csv('./data/meps_20_reg.csv'), pd.read_csv('./data/meps_21_reg.csv') ] ) df =
pd.read_csv('./data/meps_19_reg.csv')
pandas.read_csv
#!/usr/bin/env python2 # -*- coding: utf-8 -*- """ This module defines objects storing results from cross-correlation analysis. """ from __future__ import print_function import numpy as np import os import pandas as pd from tunacell.io import analysis from tunacell.stats.utils import _dtype_converter class BivariateConditioned(object): """Stores dynamics conditioned statistics for a couple of observables. Parameters ---------- obss : couple of :class:`Observable` instances times : couple of 1d arrays each item refers to the array of times at which single obs conditioned statistics have been evaluated. The row and column indices of created matrices refers to the indices of first and second item respectively. applied_filter : :class:`FilterSet` instance """ def __init__(self, bivariate, applied_filter=None): self.bivariate = bivariate self.applied_filter = applied_filter if applied_filter is not None: self.condition = repr(applied_filter) else: self.condition = 'master' # alias self.times = [uni.eval_times for uni in self.bivariate.univariates] self.counts = None # 2-d array, sample counts at time t_i, t_j self.cross = None # 2-d array, covariance matrix at (t_i, t_j) self.std_dev = None # 2-d array, standard dev of covariances estimates return def as_dataframe(self): # unroll row_times = self.times[0] col_times = self.times[1] unroll_row_times = np.concatenate([np.array(len(col_times) * [rt, ]) for rt in row_times]) unroll_col_times = np.concatenate([col_times for rt in row_times]) counts = self.counts.flatten() cov = self.cross.flatten() std = self.std_dev.flatten() names = ['time-row', 'time-col', 'counts', 'covariance', 'std-cov'] data = {'time-row': unroll_row_times, 'time-col': unroll_col_times, 'counts': counts, 'covariance': cov, 'std-cov' : std } return pd.DataFrame(data, columns=names) def _get_path(self, user_root=None, write=False): """Get condition path""" obs_path = self.bivariate._get_obs_path(user_root=user_root, write=write) res = analysis.get_condition_path(obs_path, self.applied_filter, write=write) index_condition, condition_path = res return condition_path def write_text(self, path=None): # 2 columns for times (already stored elsewhere, but just in case) cdt_path = self._get_path(user_root=path, write=True) item_path = os.path.join(cdt_path, 'times.tsv') with open(item_path, 'w') as f: f.write('row:') for t in self.times[0]: f.write('\t{:.2f}'.format(t)) f.write('\n') f.write('column:') for t in self.times[1]: f.write('\t{:.2f}'.format(t)) f.write('\n') # matrix for counts item_path = os.path.join(cdt_path, 'count_cross.tsv') np.savetxt(item_path, self.counts, fmt='%d', delimiter='\t') # matrix for cross-correlations item_path = os.path.join(cdt_path, 'cross.tsv') np.savetxt(item_path, self.cross, fmt='%.8e', delimiter='\t') item_path = os.path.join(cdt_path, 'std_dev.tsv') np.savetxt(item_path, self.std_dev, fmt='%.8e', delimiter='\t') return def read_text(self, path=None): cdt_path = self._get_path(user_root=path, write=False) item_path = os.path.join(cdt_path, 'times.tsv') if not os.path.exists(item_path): raise analysis.MissingFileError(item_path) times = [] with open(item_path, 'r') as f: for line in f.readlines(): times.append(list(map(float, line.rstrip().split('\t')[1:]))) self.times = times # matrix for counts item_path = os.path.join(cdt_path, 'count_cross.tsv') if not os.path.exists(item_path): raise analysis.MissingFileError(item_path) arr = np.genfromtxt(item_path, dtype='i8', delimiter='\t') self.counts = arr # matrix for cross-correlations item_path = os.path.join(cdt_path, 'cross.tsv') if not os.path.exists(item_path): raise analysis.MissingFileError(item_path) arr = np.genfromtxt(item_path, dtype='f8', delimiter='\t') self.cross = arr # matrix for standard deviation of covariance estimates item_path = os.path.join(cdt_path, 'std_dev.tsv') if not os.path.exists(item_path): raise analysis.MissingFileError(item_path) arr = np.genfromtxt(item_path, dtype='f8', delimiter='\t') self.std_dev = arr pass def compute_stationary(self, indexify, tmin=None, tmax=None): """Computes stationary cross-correlation between tmin and tmax. DEPRECATED """ # Narrow down valid times? time1 = self.single[str(self.obs[0])].time time2 = self.single[str(self.obs[1])].time rec = {} for index, t1 in enumerate(time1): if tmin is not None and t1 < tmin: continue if tmax is not None and t1 >= tmax: continue for jindex, t2 in enumerate(time2): if tmin is not None and t2 < tmin: continue if tmax is not None and t2 >= tmax: continue dt = t2 - t1 sdt = indexify.indexify(dt) if sdt not in rec.keys(): rec[sdt] = [0, 0.] # Hum, I may have made a mistake, comment it: dcount = self.count_cross[index, jindex] rec[sdt][0] += dcount rec[sdt][1] += dcount * self.cross[index, jindex] dt_array = np.array(sorted(map(indexify.desindexify, rec.keys()))) count_array = np.zeros(len(dt_array), dtype='u4') corr_array = np.zeros(len(dt_array), dtype='f8') for index, dt in enumerate(dt_array): sdt = indexify.indexify(dt) count_array[index] = rec[sdt][0] corr_array[index] = rec[sdt][1]/rec[sdt][0] array = np.zeros(len(dt_array), dtype=[('time_interval', 'f8'), ('count', 'u4'), ('cross-correlation', 'f8')]) array['time_interval'] = dt_array array['count'] = count_array array['cross-correlation'] = corr_array return array class BivariateError(Exception): pass class BivariateIOError(IOError): pass class Bivariate(object): """Stores dynamics statistics for a couple of observables. Parameters ---------- row_univariate : :class:`Univariate` corresponds to row in cross-correlation matrices col_univariate : :class:`Univariate` corresponds to colum in cross-correlation matrices """ def __init__(self, row_univariate, col_univariate): # check whether exp instances match s1, s2 = row_univariate, col_univariate if s1.exp.abspath != s2.exp.abspath: raise BivariateError('Experiments do not match') if repr(s1.exp.fset) != repr(s2.exp.fset): raise BivariateError('Filter sets do not match') self.univariates = (row_univariate, col_univariate) self.exp = s1.exp # build common conditions cset = [] for cdt in s1.cset: if repr(cdt) in map(repr, s2.cset): cset.append(cdt) self.cset = cset self._items = {} self._condition_labels = ['master', ] # alias Bic = BivariateConditioned self._items['master'] = Bic(self, applied_filter=None) for cdt in cset: lab = repr(cdt) self._condition_labels.append(lab) self._items[lab] = Bic(self, applied_filter=cdt) return def _get_obs_path(self, user_root=None, write=False): """Get observable path""" obss = [univ.obs for univ in self.univariates] exp = self.exp fset = self.exp.fset analysis_path = analysis.get_analysis_path(exp, user_abspath=user_root, write=write) res = analysis.get_filter_path(analysis_path, fset, write=write) index_filter, filter_path = res obs_path = analysis.get_biobservable_path(filter_path, obss, write=write) return obs_path def export_text(self, analysis_folder=None): # write each condition for key, val in self._items.items(): val.write_text(analysis_folder) return def import_from_text(self, analysis_folder=None): # read each condition try: for key, val in self._items.items(): val.read_text(analysis_folder) except (analysis.MissingFileError, analysis.MissingFolderError) as missing: raise BivariateIOError(missing) return def __getitem__(self, key): return self._items[key] @property def master(self): """There's always a master (no condition)""" return self['master'] class StationaryBivariateConditioned(object): """Cross-correlation as a function of time difference, for a univariate cdtion. Parameters ---------- obss : couple of :class:`Observable` instances times : couple of 1d arrays each item refers to the array of times at which univariate obs conditioned statistics have been evaluated. The row and column indices of created matrices refers to the indices of first and second item respectively. applied_filter : :class:`FilterSet` instance tmin : float (default None) tmax : float (default None) adjust_mean : str {'global', 'local'} """ def __init__(self, statbivariate, applied_filter=None, array=None): self.statbivariate = statbivariate self.basename = 'stationary_cross' # add region label self.basename += '_' + self.statbivariate.region.name # add computation options self.basename += '_' + self.statbivariate.options.as_string_code() self.applied_filter = applied_filter self.basename = 'stationary_bivariate' if applied_filter is not None: self.condition = repr(applied_filter) else: self.condition = 'master' self.array = array # should be a 3 columns array return def as_dataframe(self): return pd.DataFrame(self.array) def _get_path(self, user_root=None, write=False): """Get condition path""" obs_path = self.statbivariate._get_obs_path(user_root=user_root, write=write) res = analysis.get_condition_path(obs_path, self.applied_filter, write=write) index_condition, condition_path = res return condition_path def write_text(self, path='.'): """Write array to file.""" # get condition p cdt_path = self._get_path(user_root=path, write=True) if self.array is None: print('Nothing to write') return ffmt = '%.8e' # floating point numbers ifmt = '%d' # integers item_path = os.path.join(cdt_path, self.basename + '.tsv') names = self.array.dtype.names header = '\t'.join(names) fmt = [ifmt if 'count' in n_ else ffmt for n_ in names] np.savetxt(item_path, self.array, fmt=fmt, delimiter='\t', comments='', header=header) return def read_text(self, path='.'): """Initialize object by reading text output.""" cdt_path = self._get_path(user_root=path, write=False) item_path = os.path.join(cdt_path, self.basename + '.tsv') if not os.path.exists(item_path): raise analysis.MissingFileError(item_path) arr = np.genfromtxt(item_path, delimiter='\t', names=True) self.array = arr return @property def time(self): if self.array is not None: return self.array['time_interval'] else: return None @property def count(self): if self.array is not None: return self.array['count'] else: return None @property def crosscorr(self): if self.array is not None: return self.array['cross_correlation'] else: return None class StationaryBivariateIOError(IOError): pass class StationaryBivariate(object): """Cross-correlation analysis at stationarity Parameters ---------- row_univariate : :class:`Univariate` instance col_univariate : :class:`Univariate` instance region : object with tmin, tmax, name attributes determine where the process is (hypothetically) stationary options : :class:`CompuParams` instance """ def __init__(self, row_univariate, col_univariate, region=None, options=None): self.region = region self.options = options s1, s2 = row_univariate, col_univariate # obss = [univariate.obs for univariate in univariates] if s1.exp.abspath != s2.exp.abspath: raise BivariateError('Experiments do not match') if repr(s1.exp.fset) != repr(s2.exp.fset): raise BivariateError('Filter sets do not match') self.univariates = (row_univariate, col_univariate) self.label = self.region.name self.tmin = self.region.tmin self.tmax = self.region.tmax self.adjust_mean = self.options.adjust_mean self.disjoint = self.options.disjoint self.exp = s1.exp # build common conditions cset = [] for cdt in s1.cset: if repr(cdt) in map(repr, s2.cset): cset.append(cdt) self.cset = cset self.dataframe = None # to be updated with pandas.DataFrame object self._condition_labels = ['master', ] self._items = {} # alias SBic = StationaryBivariateConditioned self._items['master'] = SBic(self, applied_filter=None, array=None) for cdt in cset: self._condition_labels.append(repr(cdt)) self._items[repr(cdt)] = SBic(self, applied_filter=cdt, array=None) return def _get_obs_path(self, user_root=None, write=False): """Get observable path""" obss = [univ.obs for univ in self.univariates] exp = self.exp fset = self.exp.fset analysis_path = analysis.get_analysis_path(exp, user_abspath=user_root, write=write) res = analysis.get_filter_path(analysis_path, fset, write=write) index_filter, filter_path = res obs_path = analysis.get_biobservable_path(filter_path, obss, write=write) return obs_path def export_text(self, analysis_folder=None): # write each condition try: for key, val in self._items.items(): val.write_text(analysis_folder) # when not possible it means single object has not been exported yet except analysis.MissingFolderError: for uni in self.univariates: uni.export_text(analysis_folder) for key, val in self._items.items(): val.write_text(analysis_folder) # export dataframe as csv file if self.dataframe is not None: exp = self.exp fset = self.exp.fset analysis_path = analysis.get_analysis_path(exp, user_abspath=analysis_folder, write=True) res = analysis.get_filter_path(analysis_path, fset, write=True) index_filter, filter_path = res o1, o2 = [uni.obs for uni in self.univariates] basename = 'data_{}_{}---{}'.format(self.label, o1.name, o2.name) text_file = os.path.join(filter_path, basename + '.csv') self.dataframe.to_csv(text_file, index=False) return def import_from_text(self, analysis_folder=None): try: for key, val in self._items.items(): val.read_text(analysis_folder) exp = self.exp fset = self.exp.fset analysis_path = analysis.get_analysis_path(exp, user_abspath=analysis_folder, write=False) res = analysis.get_filter_path(analysis_path, fset, write=False) index_filter, filter_path = res o1, o2 = [uni.obs for uni in self.univariates] basename = 'data_{}_{}---{}'.format(self.label, o1.name, o2.name) text_file = os.path.join(filter_path, basename + '.csv') if not os.path.exists(text_file): raise analysis.MissingFileError df =
pd.read_csv(text_file, index_col=False)
pandas.read_csv
import logging import pandas as pd import numpy as np from spaceone.core.manager import BaseManager from spaceone.statistics.error import * from spaceone.statistics.connector.service_connector import ServiceConnector _LOGGER = logging.getLogger(__name__) _JOIN_TYPE_MAP = { 'LEFT': 'left', 'RIGHT': 'right', 'OUTER': 'outer', 'INNER': 'inner' } _SUPPORTED_AGGREGATE_OPERATIONS = [ 'query', 'join', 'concat', 'sort', 'formula', 'fill_na' ] class ResourceManager(BaseManager): def stat(self, aggregate, page, domain_id): results = self._execute_aggregate_operations(aggregate, domain_id) return self._page(page, results) def _execute_aggregate_operations(self, aggregate, domain_id): df = None if 'query' not in aggregate[0]: raise ERROR_REQUIRED_QUERY_OPERATION() for stage in aggregate: if 'query' in stage: df = self._query(stage['query'], domain_id) elif 'join' in stage: df = self._join(stage['join'], domain_id, df) elif 'concat' in stage: df = self._concat(stage['concat'], domain_id, df) elif 'sort' in stage: df = self._sort(stage['sort'], df) elif 'formula' in stage: df = self._execute_formula(stage['formula'], df) elif 'fill_na' in stage: df = self._fill_na(stage['fill_na'], df) else: raise ERROR_REQUIRED_PARAMETER(key='aggregate.query | aggregate.join | aggregate.concat | ' 'aggregate.sort | aggregate.formula | aggregate.fill_na') df = df.replace({np.nan: None}) results = df.to_dict('records') return results @staticmethod def _fill_na(options, base_df): data = options.get('data', {}) if len(data.keys()) > 0: base_df = base_df.fillna(data) return base_df def _execute_formula(self, options, base_df): if len(base_df) > 0: if 'eval' in options: base_df = self._execute_formula_eval(options['eval'], base_df) elif 'query' in options: base_df = self._execute_formula_query(options['query'], base_df) else: raise ERROR_REQUIRED_PARAMETER(key='aggregate.formula.eval | aggregate.formula.query') return base_df @staticmethod def _execute_formula_query(formula, base_df): try: base_df = base_df.query(formula) except Exception as e: raise ERROR_STATISTICS_FORMULA(formula=formula) return base_df @staticmethod def _execute_formula_eval(formula, base_df): try: base_df = base_df.eval(formula) except Exception as e: raise ERROR_STATISTICS_FORMULA(formula=formula) return base_df @staticmethod def _sort(options, base_df): if 'key' in options and len(base_df) > 0: ascending = not options.get('desc', False) try: return base_df.sort_values(by=options['key'], ascending=ascending) except Exception as e: raise ERROR_STATISTICS_QUERY(reason=f'Sorting failed. (sort = {options})') else: return base_df def _concat(self, options, domain_id, base_df): concat_df = self._query(options, domain_id, operator='join') try: base_df = pd.concat([base_df, concat_df], ignore_index=True) except Exception as e: raise ERROR_STATISTICS_CONCAT(reason=str(e)) return base_df @staticmethod def _generate_empty_data(query): empty_data = {} aggregate = query.get('aggregate', []) aggregate.reverse() for stage in aggregate: if 'group' in stage: group = stage['group'] for key in group.get('keys', []): if 'name' in key: empty_data[key['name']] = [] for field in group.get('fields', []): if 'name' in field: empty_data[field['name']] = [] break return pd.DataFrame(empty_data) def _join(self, options, domain_id, base_df): if 'type' in options and options['type'] not in _JOIN_TYPE_MAP: raise ERROR_INVALID_PARAMETER_TYPE(key='aggregate.join.type', type=list(_JOIN_TYPE_MAP.keys())) join_keys = options.get('keys') join_type = options.get('type', 'LEFT') join_df = self._query(options, domain_id, operator='join') try: if join_keys: base_df = pd.merge(base_df, join_df, on=join_keys, how=_JOIN_TYPE_MAP[join_type]) else: base_df = pd.merge(base_df, join_df, left_index=True, right_index=True, how=_JOIN_TYPE_MAP[join_type]) except Exception as e: if join_keys is None: raise ERROR_STATISTICS_INDEX_JOIN(reason=str(e)) else: raise ERROR_STATISTICS_JOIN(resource_type=options['resource_type'], join_keys=join_keys) return base_df def _query(self, options, domain_id, operator='query'): resource_type = options.get('resource_type') query = options.get('query') extend_data = options.get('extend_data', {}) if resource_type is None: raise ERROR_REQUIRED_PARAMETER(key=f'aggregate.{operator}.resource_type') if query is None: raise ERROR_REQUIRED_PARAMETER(key=f'aggregate.{operator}.query') self.service_connector: ServiceConnector = self.locator.get_connector('ServiceConnector') service, resource = self._parse_resource_type(resource_type) try: response = self.service_connector.stat_resource(service, resource, query, domain_id) results = response.get('results', []) if len(results) > 0 and not isinstance(results[0], dict): df = pd.DataFrame(results, columns=['value']) else: df =
pd.DataFrame(results)
pandas.DataFrame
# topic_modeling.py # Topic model analysis for professional articles on machine intelligence. import numpy as np import pandas as pd import altair as alt import streamlit as st def buildAcademicData(data): df =
pd.DataFrame()
pandas.DataFrame