prompt
stringlengths 19
1.03M
| completion
stringlengths 4
2.12k
| api
stringlengths 8
90
|
|---|---|---|
# *****************************************************************************
# © Copyright IBM Corp. 2018. All Rights Reserved.
#
# This program and the accompanying materials
# are made available under the terms of the Apache V2.0
# which accompanies this distribution, and is available at
# http://www.apache.org/licenses/LICENSE-2.0
#
# *****************************************************************************
import datetime as dt
import importlib
import json
import logging
import time
import warnings
from collections import OrderedDict
import numpy as np
import pandas as pd
from sqlalchemy import Column, Integer, String, DateTime, Float
from sqlalchemy.sql.sqltypes import TIMESTAMP, VARCHAR, FLOAT, INTEGER
import iotfunctions
from . import db as db_module
from .automation import (TimeSeriesGenerator, DateGenerator, MetricGenerator, CategoricalGenerator)
from .exceptions import StageException
from .pipeline import (CalcPipeline, DropNull, JobController, JobLogNull, Trace, AggregateItems)
from .stages import (DataReader, DataWriter, DataWriterFile)
from .util import (MemoryOptimizer, build_grouper, categorize_args, reset_df_index)
logger = logging.getLogger(__name__)
def retrieve_entity_type_metadata(raise_error=True, **kwargs):
"""
Get server metadata for entity type
"""
db = kwargs['_db']
# get kpi functions metadata
meta = db.http_request(object_type='engineInput', object_name=kwargs['logical_name'], request='GET',
raise_error=raise_error)
try:
meta = json.loads(meta)
except (TypeError, json.JSONDecodeError):
meta = None
if meta is None or 'exception' in meta:
raise RuntimeError(('API call to server did not retrieve valid entity '
' type properties for %s.' % kwargs['logical_name']))
if meta['kpiDeclarations'] is None:
meta['kpiDeclarations'] = []
logger.warning(('This entity type has no calculated kpis'))
# cache function catalog metadata in the db object
function_list = [x['functionName'] for x in meta['kpiDeclarations']]
db.load_catalog(install_missing=True, function_list=function_list)
# map server properties
params = {}
params['_entity_type_id'] = meta['entityTypeId']
params['_db_schema'] = meta['schemaName']
params['name'] = meta['metricsTableName']
params['_timestamp'] = meta['metricTimestampColumn']
params['_dimension_table_name'] = meta['dimensionsTable']
params['_data_items'] = meta['dataItems']
# constants
c_meta = db.http_request(object_type='constants', object_name=kwargs['logical_name'], request='GET')
try:
c_meta = json.loads(c_meta)
except (TypeError, json.JSONDecodeError):
logger.debug(('API call to server did not retrieve valid entity type'
' properties. No properties set.'))
else:
for p in c_meta:
key = p['name']
if isinstance(p['value'], dict):
params[key] = p['value'].get('value', p['value'])
else:
params[key] = p['value']
logger.debug('Retrieved server constant %s with value %s', key, params[key])
params = {**kwargs, **params}
return (params, meta)
class EntityType(object):
"""
Data is organised around Entity Types. Entity Types have one or more
physical database object for their data. When creating a new Entity Type,
it will attempt to connect itself to a table of the same name in the
database. If no table exists the Entity Type will create one.
Entity types describe the payload of an AS job. A job is built by a
JobController using functions metadata prepared by the Entity Type.
Metadata prepared is:
_functions:
List of function objects
_data_items:
List of data items and all of their metadata such as their
datatype.
_granularities_dict:
Dictionary keyed on granularity name. Contains a granularity object
that provides access to granularity metadata such as the time
level and other dimensions involved in the aggregation.
_schedules_dict:
Dictionary keyed on a schedule frequency containing other metadata
about the operations to be run at this frequency, e.g. how many days
should be backtracked when retrieving daat.
Entity types may be initialized as client objects for local testing
or may be loaded from the server. After initialization all of the
above instance variables will be populated. The metadata looks the same
regardless of whether the entity type was loaded from the server
or initialized on the client. The logic to build the metadata is
different though.
Parameters
----------
name: str
Name of the entity type. Use lower case. Will be used as the physical
database table name so don't use database reserved works of special
characters.
db: Database object
Contains the connection info for the database
*args:
Additional positional arguments are used to add the list of SQL Alchemy
Column objects contained within this table. Similar to the style of a
CREATE TABLE sql statement. There is no need to specify column names
if you are using an existing database table as an entity type.
**kwargs
Additional keywork args.
_timestamp: str
Overide the timestamp column name from the default of 'evt_timestamp'
"""
is_entity_type = True
is_local = False
auto_create_table = True
aggregate_complete_periods = True # align data for aggregation with time grain to avoid partial periods
log_table = 'KPI_LOGGING' # deprecated, to be removed
checkpoint_table = 'KPI_CHECKPOINT' # deprecated,to be removed
chunk_size = None # use job controller default chunk
default_backtrack = None
trace_df_changes = True
drop_existing = False
# These two columns will be available in the dataframe of a pipeline
_entity_id = 'deviceid' # identify the instance
_timestamp_col = '_timestamp' # copy of the event timestamp from the index
# This column will identify an instance in the index
_df_index_entity_id = 'id'
# when automatically creating a new dimension, use this suffix
_auto_dim_suffix = '_auto_dim'
# when looking for an automatically created numeric index it should be named:
auto_index_name = '_auto_index_'
# constants declared as part of an entity type definition
ui_constants = None
_functions = None
# generator
_scd_frequency = '2D' # deprecated. Use parameters on EntityDataGenerator
_activity_frequency = '3D' # deprecated. Use parameters on EntityDataGenerator
_start_entity_id = 73000 # deprecated. Use parameters on EntityDataGenerator
_auto_entity_count = 5 # deprecated. Use parameters on EntityDataGenerator
# pipeline work variables stages
_dimension_table = None
_scd_stages = None
_custom_calendar = None
# variabes that will be set when loading from the server
_entity_type_id = None
logical_name = None
_timestamp = 'evt_timestamp'
_dimension_table_name = None
_db_connection_dbi = None
_db_schema = None
_data_items = None
tenant_id = None
_entity_filter_list = None
_start_ts_override = None
_end_ts_override = None
_stages = None
_schedules_dict = None
_granularities_dict = None
_input_set = None
_output_list = None
_invalid_stages = None
_disabled_stages = None
# processing defaults
_pre_aggregate_time_grain = None # aggregate incoming data before processing
_auto_read_from_ts_table = True # read new data from designated time series table for the entity
_pre_agg_rules = None # pandas agg dictionary containing list of aggregates to apply for each item
_pre_agg_outputs = None # dictionary containing list of output items names for each item
_data_reader = DataReader
_abort_on_fail = False
_auto_save_trace = 30
save_trace_to_file = False
drop_null_class = DropNull
enable_downcast = False
allow_projection_list_trim = True
_write_usage = False
# deprecated class variables (to be removed)
_checkpoint_by_entity = True # manage a separate checkpoint for each entity instance
_is_initial_transform = True
_is_preload_complete = False
def __init__(self, name, db, *args, **kwargs):
logger.debug('Initializing new entity type using iotfunctions %s', iotfunctions.__version__)
try:
self.logical_name = kwargs.get('logical_name', None)
if self.logical_name is None:
self.logical_name = name
except AttributeError:
self.logical_name = name
if db == None:
name = 'None'
elif db.db_type == 'db2':
name = name.upper()
else:
name = name.lower()
self.name = name
self.description = kwargs.get('description', None)
if self.description is None:
self.description = ''
else:
del (kwargs['description'])
self.activity_tables = {}
self.scd = {}
self.db = db
if self.db is not None:
self.tenant_id = self.db.tenant_id
self._system_columns = [self._entity_id, self._timestamp_col, 'logicalinterface_id', 'devicetype', 'format',
'updated_utc', self._timestamp]
self._stage_type_map = self.default_stage_type_map()
self._custom_exclude_col_from_auto_drop_nulls = []
self._drop_all_null_rows = True
if self._scd_stages is None:
self._scd_stages = []
if self._data_items is None:
self._data_items = []
if self._granularities_dict is None:
self._granularities_dict = {}
# additional params set from kwargs
self.set_params(**kwargs)
# Start a trace to record activity on the entity type
self._trace = Trace(object_name=None, parent=self, db=db)
if self._disabled_stages is None:
self._disabled_stages = []
if self._invalid_stages is None:
self._invalid_stages = []
if len(self._disabled_stages) > 0 or len(self._invalid_stages) > 0:
self.trace_append(created_by=self, msg='Skipping disabled and invalid stages', log_method=logger.info,
**{'skipped_disabled_stages': [s['functionName'] for s in self._disabled_stages],
'skipped_disabled_data_items': [s['output'] for s in self._disabled_stages],
'skipped_invalid_stages': [s['functionName'] for s in self._invalid_stages],
'skipped_invalid_data_items': [s['output'] for s in self._invalid_stages]})
# attach to time series table
if self._db_schema is None:
logger.warning(('No _db_schema specified in **kwargs. Using'
'default database schema.'))
self._mandatory_columns = [self._timestamp, self._entity_id]
# separate args into categories
categories = [('constant', 'is_ui_control', None), ('granularity', 'is_granularity', None),
('function', 'is_function', None), ('column', None, Column)]
categorized = categorize_args(categories, 'functions', *args)
cols = list(categorized.get('column', []))
functions = list(categorized.get('function', []))
constants = list(categorized.get('constant', []))
grains = list(categorized.get('granularity', []))
if self.drop_existing and db is not None and not self.is_local:
self.drop_tables()
# create a database table if needed using cols
if name is not None and db is not None and not self.is_local:
try:
self.table = self.db.get_table(self.name, self._db_schema)
except KeyError:
if self.auto_create_table:
ts = db_module.TimeSeriesTable(self.name, self.db, *cols, **kwargs)
self.table = ts.table
# self.db.create()
msg = 'Create table %s' % self.name
logger.info(msg)
else:
msg = ('Database table %s not found. Unable to create'
' entity type instance. Provide a valid table name'
' or use the auto_create_table = True keyword arg'
' to create a table. ' % (self.name))
raise ValueError(msg)
# populate the data items metadata from the supplied columns
if isinstance(self._data_items, list) and len(self._data_items) == 0:
self._data_items = self.build_item_metadata(self.table)
else:
logger.warning((
'Created a logical entity type. It is not connected to a real database table, so it cannot perform any database operations.'))
# add granularities
for g in grains:
logger.debug('Adding granularity to entity type: %s', g.name)
self._granularities_dict[g.name] = g
# add constants
self.ui_constants = constants
self.build_ui_constants()
# _functions
# functions may have been provided as kwarg and may be includes as args
# compbine all
if self._functions is None:
self._functions = []
self._functions.extend(functions)
if name is not None and db is not None and not self.is_local:
db.entity_type_metadata[self.logical_name] = self
logger.debug(('Initialized entity type %s'), str(self))
def add_activity_table(self, name, activities, *args, **kwargs):
"""
add an activity table for this entity type.
parameters
----------
name: str
table name
activities: list of strs
activity type codes: these identify the nature of the activity, e.g. PM is Preventative Maintenance
*args: Column objects
other columns describing the activity, e.g. materials_cost
"""
if self.db is None:
msg = ('Entity type has no db connection. Local entity types'
' are not allowed to add activity tables ')
raise ValueError(msg)
kwargs['_activities'] = activities
kwargs['schema'] = self._db_schema
# name = name.lower()
if self.db.db_type == 'db2':
name = name.upper()
else:
name = name.lower()
table = db_module.ActivityTable(name, self.db, *args, **kwargs)
try:
sqltable = self.db.get_table(name, self._db_schema)
except KeyError:
table.create()
self.activity_tables[name] = table
def add_slowly_changing_dimension(self, property_name, datatype, **kwargs):
"""
add a slowly changing dimension table containing a single property for this entity type
parameters
----------
property_name : str
name of property, e.g. firmware_version (lower case, no database reserved words)
datatype: sqlalchemy datatype
"""
if self.db is None:
msg = ('Entity type has no db connection. Local entity types'
' are not allowed to add slowly changing dimensions ')
raise ValueError(msg)
property_name = property_name.lower()
name = '%s_scd_%s' % (self.name, property_name)
kwargs['schema'] = self._db_schema
if self.db.db_type == 'db2':
name = name.upper()
else:
name = name.lower()
table = db_module.SlowlyChangingDimension(name=name, database=self.db, property_name=property_name,
datatype=datatype, **kwargs)
try:
self.db.get_table(name, self._db_schema)
except KeyError:
table.create()
self.scd[property_name] = table
def _add_scd_pipeline_stage(self, scd_lookup):
self._scd_stages.append(scd_lookup)
def build_agg_dict_from_meta_list(self, meta_list):
agg_dict = OrderedDict()
input_items = set()
output_items = []
for f in meta_list:
input_item = f['input'].get('source')
output_item = f['output'].get('name')
aggregate = f['functionName']
try:
agg_dict[input_item].append(aggregate)
except KeyError:
agg_dict[input_item] = [aggregate]
input_items.add(input_item)
output_items.append(output_item)
return (agg_dict, input_items, output_items)
def build_arg_metadata(self, obj):
"""
Examine the metadata provided by build_ui() to understand more about
the arguments to a function.
Place the values of inputs and outputs into 2 dicts
Return these two dicts in a tuple along with an output_meta dict
that contains argument values and types
Build the _input_set and _output list. These describe the set of
data items required as inputs to a function and the list of data
items produced by the function.
"""
name = obj.__class__.__name__
try:
(inputs, outputs) = obj.build_ui()
except (AttributeError, NotImplementedError) as e:
try:
fn_metadata = obj.metadata()
inputs = fn_metadata.get('input', None)
outputs = fn_metadata.get('output', None)
except (AttributeError, KeyError) as ex:
msg = ('Can\'t get metadata for function %s. Implement the'
' build_ui() method for this function. %s' % (name, str(e)))
raise NotImplementedError(msg)
input_args = {} # this is not used. Included only to maintain compatibility of return signature
output_args = {} # this is not used. Included only to maintain compatibility of return signature
output_meta = {} # this is not used. Included only to maintain compatibility of return signature
output_list = []
# There are two ways to gather inputs to a function.
# 1) from the arguments of the function
# 2) from the an explicit list of items returned by the get_input_items
# method
try:
input_set = set(obj.get_input_items())
except AttributeError:
input_set = set()
else:
if len(input_set) > 0:
logger.debug(('Function %s has explicit required input items '
' delivered by the get_input_items() method: %s'), name, input_set)
if not isinstance(inputs, list):
raise TypeError(('Function registration metadata must be defined',
' using a list of objects derived from iotfunctions',
' BaseUIControl. Check metadata for %s'
' %s ' % (name, inputs)))
if not isinstance(outputs, list):
raise TypeError(('Function registration metadata must be defined',
' using a list of objects derived from iotfunctions',
' BaseUIControl. Check metadata for %s'
' %s ' % (name, outputs)))
args = []
args.extend(inputs)
args.extend(outputs)
for a in args:
try:
# get arg name and type from UI object
type_ = a.type_
arg = a.name
except AttributeError as e:
try:
# get arg name and type from legacy dict
type_ = a.get('type', None)
arg = a.get('name', None)
except AttributeError:
type_ = None
arg = None
if type_ is None or arg is None:
msg = ('Error while getting metadata from function. The inputs'
' and outputs of the function are not described correctly'
' using UIcontrols with a type_ %s and name %s' % (type_, arg))
raise TypeError(msg)
arg_value = getattr(obj, arg)
out_arg = None
out_arg_value = None
if type_ == 'DATA_ITEM':
# the argument is an input that contains a data item or
# list of data items
if isinstance(arg_value, list):
input_set |= set(arg_value)
else:
input_set.add(arg_value)
logger.debug('Using input items %s for %s', arg_value, arg)
elif type_ == 'OUTPUT_DATA_ITEM':
# the arg is an output item or list of them
out_arg = arg
out_arg_value = arg_value
# some inputs implicitly describe outputs
try:
out_arg = a.output_item
except AttributeError:
pass # no need to check legacy dict for this property as it was not supported in the legacy dict
else:
if out_arg is not None:
out_arg_value = getattr(obj, out_arg)
# process output args
if out_arg is not None:
if isinstance(out_arg_value, list):
output_list.extend(out_arg_value)
else:
output_list.append(out_arg_value)
logger.debug('Using output items %s for %s', out_arg_value, out_arg)
# output_meta is present in the AS metadata structure, but not
# currently produced for local functions
return (input_args, output_args, output_meta, input_set, output_list)
def build_ui_constants(self):
"""
Build attributes for each ui constants declared with the entity type
"""
if self.ui_constants is None:
logger.debug('No constants declared in entity definition')
self.ui_constants = []
params = {}
for c in self.ui_constants:
try:
params[c.name] = c.default
except AttributeError:
logger.warning(('Cannot set value of parameter %s as it does'
' not have a default value'), c.name)
self.set_params(**params)
def build_flat_stage_list(self):
"""
Build a flat list of all function objects defined for entity type
"""
stages = []
for stage in self._functions:
try:
is_system = stage.is_system_function
except AttributeError:
is_system = False
logger.warning(('Function %s has no is_system_function property.'
' This means it was not inherited from '
' an iotfunctions base class. AS authors are'
' strongly encouraged to always inherit '
' from iotfunctions base classes'), stage.__class__.__name__)
if not is_system:
stages.append(stage)
return stages
def build_granularities(self, grain_meta, freq_lookup):
"""
Convert AS granularity metadata to granularity objects.
"""
out = {}
for g in grain_meta:
grouper = []
freq = None
entity_id = None
if g['entityFirst']:
grouper.append(pd.Grouper(key=self._entity_id))
entity_id = self._entity_id
if g['frequency'] is not None:
freq = (self.get_grain_freq(g['frequency'], freq_lookup, None))
if freq is None:
raise ValueError(('Invalid frequency name %s. The frequency name'
' must exist in the frequency lookup %s' % (g['frequency'], freq_lookup)))
# add a number to the frequency to make it compatible with pd.Timedelta
if freq[0] not in ['1', '2', '3', '4', '5', '6', '7', '8', '9']:
freq = '1' + freq
grouper.append(pd.Grouper(key=self._timestamp, freq=freq))
custom_calendar = None
custom_calendar_keys = []
dimensions = []
# differentiate between dimensions and custom calendar items
for d in g['dataItems']:
grouper.append(pd.Grouper(key=d))
if self._custom_calendar is not None:
if d in self._custom_calendar._output_list:
custom_calendar_keys.append(d)
dimensions.append(d)
granularity = Granularity(name=g['name'], grouper=grouper, dimensions=dimensions,
entity_name=self.logical_name, timestamp=self._timestamp, entity_id=entity_id,
custom_calendar_keys=custom_calendar_keys, freq=freq,
custom_calendar=custom_calendar)
out[g['name']] = granularity
return out
def build_item_metadata(self, table):
"""
Build a client generated version of AS server metadata from a
sql alachemy table object.
"""
if self.db is None:
msg = ('Entity type has no db connection. Local entity types'
' cannot build item metadata from tables ')
raise ValueError(msg)
for col_name, col in list(table.c.items()):
item = {}
if col_name not in self.get_excluded_cols():
item['name'] = col_name
item['type'] = 'METRIC'
item['parentDataItem'] = None
item['kpiFunctionDto'] = None
item['columnName'] = col.name
item['columnType'] = self.db.get_as_datatype(col)
item['sourceTableName'] = self.name
item['tags'] = []
item['transient'] = False
self._data_items.append(item)
return self._data_items
def build_schedules(self, metadata):
"""
Build a dictionary of schedule metadata from the schedules contained
within function definitions.
The schedule dictionary is keyed on a pandas freq string. This
frequency denotes the schedule interval. The dictionary contains a
tuple (start_hour,start_minute,backtrack_days)
Returns
-------
tuple containing updated metadata and a dict of schedules
Example
-------
{ '5min': [16,3,7] }
5 minute schedule interval with a start time of 4:03pm and backtrack of 7 days.
"""
freqs = {}
for f in metadata:
if f['schedule'] is not None:
freq = f['schedule']['every']
start = time.strptime(f['schedule']['starting_at'], '%H:%M:%S')
start_hour = start[3]
start_min = start[4]
backtrack = f['backtrack']
if backtrack is not None:
backtrack_days = backtrack.get('days', 0) + (backtrack.get('hours', 0) / 24) + (
backtrack.get('minutes', 0) / 1440)
else:
backtrack_days = None
existing_schedule = freqs.get(freq, None)
if existing_schedule is None:
f[freq] = (start_hour, start_min, backtrack_days)
else:
corrected_schedule = list(existing_schedule)
if existing_schedule[0] > start_hour:
corrected_schedule[0] = start_hour
logger.warning(('There is a conflict in the schedule metadata.'
' Picked the earlier start hour of %s instead of %s'
' for schedule %s.' % (start_hour, corrected_schedule[0], freq)))
if existing_schedule[1] > start_min:
corrected_schedule[1] = start_min
logger.warning(('There is a conflict in the schedule metadata.'
' Picked the earlier start minute of %s instead of %s'
' for schedule %s.' % (start_min, existing_schedule[1], freq)))
if backtrack_days is not None:
if existing_schedule[2] is None or existing_schedule[2] < backtrack_days:
corrected_schedule[2] = backtrack_days
logger.warning(('There is a conflict in the schedule metadata.'
' Picked the longer backtrack of %s instead of %s'
' for schedule %s.' % (backtrack_days, existing_schedule[2], freq)))
f[freq] = tuple(corrected_schedule)
freqs[freq] = f[freq]
f['schedule'] = freq
return freqs
def classify_stages(self):
"""
Create a dictionary of stage objects. Dictionary is keyed by
stage type and a granularity obj. It contains a list of stage
objects. Stages are classified by timing of execution, ie: preload,
get_data, transform, aggregate
"""
logger.debug('Classifying stages by timing of execution, ie: preload, get_data, transform, aggregate')
stage_metadata = dict()
active_granularities = set()
# Add a data_reader stage. This will read entity data.
if self._auto_read_from_ts_table:
auto_reader = self._data_reader(name='read_entity_data', obj=self)
stage_type = self.get_stage_type(auto_reader)
granularity = None # input level
stage_metadata[(stage_type, granularity)] = [auto_reader]
auto_reader.schedule = None
auto_reader._entity_type = self
else:
logger.debug(('Skipped auto read of payload data as'
' payload does not have _auto_read_from_ts_table'
' set to True'))
# Build a stage for each function.
for s in self._functions:
# replace deprecated function
obj = self.get_replacement(s)
# add metadata to stage
try:
obj.name
except AttributeError:
obj.name = obj.__class__.__name__
try:
obj._schedule
except AttributeError:
obj._schedule = None
try:
obj.granularity
except AttributeError:
obj.granularity = None
# the stage needs to know what entity type it belongs to
obj._entity_type = self
# classify stage
stage_type = self.get_stage_type(obj)
granularity = obj.granularity
if granularity is not None and isinstance(granularity, str):
granularity = self._granularities_dict.get(granularity, False)
if not granularity:
msg = ('Cannot build stage metdata. The granularity metadata'
' is invalid. Granularity of function is %s. Valid '
' granularities are %s' % (granularity, list(self._granularities_dict.keys())))
raise StageException(msg, obj.name)
elif isinstance(granularity, Granularity):
pass
else:
granularity = None
try:
# add to stage_type / granularity
stage_metadata[(stage_type, granularity)].append(obj)
except KeyError:
# start a new stage_type / granularity
stage_metadata[(stage_type, granularity)] = [obj]
# Remember all active granularities
if granularity is not None:
active_granularities.add(granularity)
# add metadata derived from function registration and function args
# input set and output list are critical metadata for the dependency model
# there are three ways to set them
# 1) using the instance variables _input_set and _output_list
# 2) using the methods get_input_set and get_output_list
# 3) using the function's registration metadata
if obj._input_set is not None:
logger.debug('Input set was preset for function %s', obj.name)
input_set = obj._input_set
else:
try:
input_set = obj.get_input_set()
except AttributeError:
input_set = None
if obj._output_list is not None:
logger.debug('Output list set was preset for function %s', obj.name)
output_list = obj._output_list
else:
try:
output_list = obj.get_output_list()
except AttributeError:
output_list = None
if input_set is None or output_list is None:
# get the input set and output list from the function argument metadata
(in_, out, out_meta, reg_input_set, reg_output_list) = self.build_arg_metadata(obj)
if input_set is None:
input_set = reg_input_set
if output_list is None:
output_list = reg_output_list
# set the _input_set and _output_list
obj._input_set = input_set
obj._output_list = output_list
# The stage may have metadata parameters that need to be
# copied onto the entity type
try:
entity_metadata = obj._metadata_params
except AttributeError:
entity_metadata = {}
logger.debug(('Function %s has no _metadata_params'
' property. This property allows the stage'
' to add properties to the entity type.'
' Using default of %s'), obj.name, entity_metadata)
if entity_metadata is not None and entity_metadata:
self.set_params(**entity_metadata)
self.trace_append(created_by=obj, msg='Adding entity type properties from function',
log_method=logger.debug, **entity_metadata)
# The stage may be a special stage that should be added to
# a special stages list, e.g. stages that have
# the property is_scd_lookup = True should be added to the
# _scd_stages list
specials = {'is_scd_lookup': self._scd_stages}
for function_prop, list_obj in list(specials.items()):
try:
is_function_prop = getattr(obj, function_prop)
except AttributeError:
is_function_prop = False
if is_function_prop:
list_obj.append(obj)
# Add for each granularity without frequency two AggregateItem stages. The result columns of these stages
# are used in the DataWriter when the aggregation results are pushed to the database
for gran in active_granularities:
if gran.freq is None:
for func_name, output_name in {('max', DataWriter.ITEM_NAME_TIMESTAMP_MAX),
('min', DataWriter.ITEM_NAME_TIMESTAMP_MIN)}:
new_stage = AggregateItems(input_items=[self._timestamp], aggregation_function=func_name,
output_items=[output_name])
new_stage._entity_type = self
new_stage.name = new_stage.__class__.__name__
new_stage._schedule = None
new_stage.granularity = gran
new_stage._input_set = {self._timestamp}
new_stage._output_list = [output_name]
stage_type = self.get_stage_type(new_stage)
stage_metadata[(stage_type, gran)].append(new_stage)
return stage_metadata
def build_stage_metadata(self, *args):
"""
Make a new JobController payload from a list of function objects
"""
metadata = []
for f in args:
# if function is deprecated it may have a replacement
f = self.get_replacement(f)
fn = {}
try:
name = f.name
except AttributeError:
name = f.__class__.__name__
fn['name'] = name
fn['object_instance'] = f
fn['description'] = f.__doc__
fn['functionName'] = f.__class__.__name__
fn['enabled'] = True
fn['execStatus'] = False
fn['schedule'] = None
fn['backtrack'] = None
fn['granularity'] = f.granularity
(fn['input'], fn['output'], fn['outputMeta'], fn['input_set'], fn['output_list']) = self.build_arg_metadata(
f)
fn['inputMeta'] = None
metadata.append(fn)
logger.debug(('Added local function instance as job stage: %s'), fn)
self._stages = self.build_stages(function_meta=metadata, granularities_dict=self._granularities_dict)
return metadata
def index_df(self, df):
"""
Create an index on the deviceid and the timestamp
"""
if self._df_index_entity_id is None:
self._df_index_entity_id = self._entity_id
if self._timestamp_col is None:
self._timestamp_col = self._timestamp
if df.index.names != [self._df_index_entity_id, self._timestamp]:
try:
df = df.set_index([self._df_index_entity_id, self._timestamp])
except KeyError:
df = reset_df_index(df, auto_index_name=self.auto_index_name)
try:
df = df.set_index([self._df_index_entity_id, self._timestamp])
except KeyError:
try:
df[self._df_index_entity_id] = df[self._entity_id]
df = df.set_index([self._df_index_entity_id, self._timestamp])
except KeyError:
raise KeyError(('Error attempting to index time series'
' dataframe. Unable to locate index'
' columns: %s or %s, %s') % (
self._df_index_entity_id, self._entity_id, self._timestamp))
logger.debug(('Indexed dataframe on %s, %s'), self._df_index_entity_id, self._timestamp)
else:
logger.debug(('Found existing index on %s, %s.'
'No need to recreate index'), self._df_index_entity_id, self._timestamp)
# create a dummy column for _entity_id
if self._entity_id != self._df_index_entity_id:
df[self._entity_id] = df.index.get_level_values(self._df_index_entity_id)
# create a dummy column for _timestamp
if self._timestamp != self._timestamp_col:
df[self._timestamp_col] = df.index.get_level_values(self._timestamp)
return df
def cos_save(self):
if self.db is None:
msg = ('Entity type has no db connection. Local entity types'
' are not allowed to save to cloud object storage ')
raise ValueError(msg)
name = ['entity_type', self.name]
name = '.'.join(name)
self.db.cos_save(self, name)
@classmethod
def default_stage_type_map(cls):
"""
Configure how properties of stages are used to set the stage type
that is used by the job controller to decide how to process a stage
"""
return [('preload', 'is_preload'), ('get_data', 'is_data_source'), ('transform', 'is_transformer'),
('aggregate', 'is_data_aggregator'), ('simple_aggregate', 'is_simple_aggregator'),
('complex_aggregate', 'is_complex_aggregator'), ]
def df_sort_timestamp(self, df):
"""
Sort a dataframe on the timestamp column. Returns a tuple containing
the sorted dataframe and a column_name for the timestamp column.
"""
ts_col_name = self._timestamp
# timestamp may be column or in index
try:
df.sort_values([ts_col_name], inplace=True)
except KeyError:
try:
# legacy check for a redundant _timestamp alternative column
df.sort_values([self._timestamp_col], inplace=True)
ts_col_name = self._timestamp_col
except KeyError:
try:
df.sort_index(level=[ts_col_name], inplace=True)
except:
raise
return (df, ts_col_name)
def drop_tables(self, recreate=False):
"""
Drop tables known to be associated with this entity type
"""
self.db.drop_table(self.name, schema=self._db_schema, recreate=recreate)
self.drop_child_tables(recreate=recreate)
def drop_child_tables(self, recreate=False):
"""
Drop all child tables
"""
if self.db is None:
msg = ('Entity type has no db connection. Local entity types'
' are not allowed to drop child tables ')
raise ValueError(msg)
if self._dimension_table_name is None:
tables = []
else:
tables = [self._dimension_table_name]
tables.extend(self.activity_tables.values())
tables.extend(self.scd.values())
[self.db.drop_table(x, self._db_schema, recreate=recreate) for x in tables]
msg = 'dropped tables %s' % tables
logger.info(msg)
def exec_local_pipeline(self, start_ts=None, end_ts=None, entities=None, **kw):
"""
Test the functions on an entity type
Test will be run on local metadata. It will not use the server
job log. Results will be written to file.
"""
params = {'data_writer': DataWriterFile, 'keep_alive_duration': None, 'save_trace_to_file': True,
'default_backtrack': 'checkpoint', 'trace_df_changes': True, '_abort_on_fail': True,
'job_log_class': JobLogNull, '_auto_save_trace': None, '_start_ts_override': start_ts,
'_end_ts_override': end_ts, '_entity_filter_list': entities, '_production_mode': False}
kw = {**params, **kw}
job = JobController(payload=self, **kw)
# propagate parameters to functions
for f in self._functions:
for key, value in list(kw.items()):
setattr(f, key, value)
job.execute()
def get_attributes_dict(self):
"""
Produce a dictionary containing all attributes
"""
c = {}
for att in dir(self):
value = getattr(self, att)
if not callable(value):
c[att] = value
return c
def get_calc_pipeline(self, stages=None):
"""
Make a new CalcPipeline object. Reset processing variables.
"""
warnings.warn('get_calc_pipeline() is deprecated. Use build_job()', DeprecationWarning)
self._scd_stages = []
self._custom_calendar = None
self._is_initial_transform = True
return CalcPipeline(stages=stages, entity_type=self)
def get_function_replacement_metadata(self, meta):
"""
replace incoming function metadata for aggregate functions with
metadata that will be used to build a DataAggregator
"""
replacement = {'Sum': 'sum', 'Minimum': 'min', 'Maximum': 'max', 'Mean': 'mean', 'Median': 'median',
'Count': 'count', 'DistinctCount': 'count_distinct', 'StandardDeviation': 'std',
'Variance': 'var', 'Product': 'product', 'First': 'first', 'Last': 'last'}
name = meta.get('functionName', None)
replacement_name = replacement.get(name, None)
if replacement_name is not None:
meta['functionName'] = replacement_name
return (meta.get('granularity', None), meta)
else:
return (None, None)
def get_local_column_lists_by_type(self, columns, known_categoricals_set=None):
"""
Examine a list of columns and poduce a tuple containing names
of metric,dates,categoricals and others
"""
if known_categoricals_set is None:
known_categoricals_set = set()
metrics = []
dates = []
categoricals = []
others = []
if columns is None:
columns = []
all_cols = set([x.name for x in columns])
# exclude known categoricals that are not present in table
known_categoricals_set = known_categoricals_set.intersection(all_cols)
for c in columns:
data_type = c.type
if isinstance(data_type, (FLOAT, Float, INTEGER, Integer)):
metrics.append(c.name)
elif db_module.DB2_DOUBLE is not None and isinstance(data_type, db_module.DB2_DOUBLE):
metrics.append(c.name)
elif isinstance(data_type, (VARCHAR, String)):
categoricals.append(c.name)
elif isinstance(data_type, (TIMESTAMP, DateTime)):
dates.append(c.name)
else:
others.append(c.name)
msg = 'Found column %s of unknown data type %s' % (c, data_type.__class__.__name__)
logger.warning(msg)
# reclassify categoricals that did were not correctly classified based on data type
for c in known_categoricals_set:
if c not in categoricals:
categoricals.append(c)
metrics = [x for x in metrics if x != c]
dates = [x for x in dates if x != c]
others = [x for x in others if x != c]
return (metrics, dates, categoricals, others)
def get_custom_calendar(self):
return self._custom_calendar
def get_data(self, start_ts=None, end_ts=None, entities=None, columns=None):
"""
Retrieve entity data at input grain or preaggregated
"""
if self.db is None:
msg = ('Entity type has no db connection. Local entity types'
' are not allowed to retrieve database data ')
raise ValueError(msg)
tw = {} # info to add to trace
if entities is None:
tw['entity_filter'] = 'all'
else:
tw['entity_filter'] = '%s entities' % len(entities)
if self._pre_aggregate_time_grain is None:
df = self.db.read_table(table_name=self.name, schema=self._db_schema, timestamp_col=self._timestamp,
parse_dates=None, columns=columns, start_ts=start_ts, end_ts=end_ts,
entities=entities, dimension=self._dimension_table_name)
tw['pre-aggregeted'] = None
else:
(metrics, dates, categoricals, others) = self.db.get_column_lists_by_type(self.name, self._db_schema)
if self._dimension_table_name is not None:
categoricals.extend(self.db.get_column_names(self._dimension_table_name, self._db_schema))
if columns is None:
columns = []
columns.extend(metrics)
columns.extend(dates)
columns.extend(categoricals)
columns.extend(others)
# make sure each column is in the aggregate dictionary
# apply a default aggregate for each column not specified in the aggregation metadata
if self._pre_agg_rules is None:
self._pre_agg_rules = {}
self._pre_agg_outputs = {}
for c in columns:
try:
self._pre_agg_rules[c]
except KeyError:
if c not in [self._timestamp, self._entity_id]:
if c in metrics:
self._pre_agg_rules[c] = 'mean'
self._pre_agg_outputs[c] = 'mean_%s' % c
else:
self._pre_agg_rules[c] = 'max'
self._pre_agg_outputs[c] = 'max_%s' % c
else:
pass
df = self.db.read_agg(table_name=self.name, schema=self._db_schema, groupby=[self._entity_id],
timestamp=self._timestamp, time_grain=self._pre_aggregate_time_grain,
agg_dict=self._pre_agg_rules, agg_outputs=self._pre_agg_outputs, start_ts=start_ts,
end_ts=end_ts, entities=entities, dimension=self._dimension_table_name)
tw['pre-aggregeted'] = self._pre_aggregate_time_grain
tw['rows_retrieved'] = len(df.index)
tw['start_ts'] = start_ts
tw['end_ts'] = end_ts
self.trace_append(created_by=self, msg='Retrieved entity timeseries data for %s' % self.name, **tw)
# Optimizing the data frame size using downcasting
if self.enable_downcast:
memo = MemoryOptimizer()
df = memo.downcastNumeric(df)
try:
df = self.index_df(df)
except (AttributeError, KeyError):
pass
return df
def get_data_items(self):
"""
Get the list of data items defined
:return: list of dicts containting data item metadata
"""
return self._data_items
def get_excluded_cols(self):
"""
Return a list of physical columns that should be excluded when returning
the list of data items
"""
return ['logicalinterface_id', 'format', 'updated_utc', 'devicetype', 'eventtype']
def get_grain_freq(self, grain_name, lookup, default):
"""
Lookup a pandas frequency string from an AS granularity name
"""
for l in lookup:
if grain_name == l['name']:
return l['alias']
return default
def get_output_items(self):
"""
Get a list of non calculated items: outputs from the time series table
"""
items = [x.get('columnName') for x in self._data_items if
x.get('type') == 'METRIC' or x.get('type') == 'DIMENSION']
return items
def get_log(self, rows=100):
"""
Get KPI execution log info. Returns a dataframe.
"""
if self.db is None:
msg = ('Entity type has no db connection. Local entity types'
' are not allowed to get log data ')
raise ValueError(msg)
query, log = self.db.query(self.log_table, self._db_schema)
query = query.filter(log.c.entity_type == self.name).order_by(log.c.timestamp_utc.desc()).limit(rows)
df = self.db.read_sql_query(query)
return df
def get_latest_log_entry(self):
"""
Get the most recent log entry. Returns dict.
"""
last = self.get_log(rows=1)
last = last.to_dict('records')[0]
return last
def get_param(self, param, default=None):
try:
out = getattr(self, param)
except AttributeError:
out = default
return out
def get_end_ts_override(self):
if self._end_ts_override is not None:
if isinstance(self._end_ts_override, dt.datetime):
return self._end_ts_override
date_time_obj = dt.datetime.strptime(self._end_ts_override[0], '%Y-%m-%d %H:%M:%S')
return date_time_obj
return None
def get_stage_type(self, stage):
"""
Examine the stage object to determine how it should be processed by
the JobController
Sets the stage type to the first valid entry in the stage map
the stage map is a list of tuples containing a stage type and
a boolean property name:
example:
[('get_data','is_data_source'),
('simple_aggregate','is_simple_aggregate')]
if a stage has both an is_data_source = True and
a is_simple_aggregate = True, the stage type will be returned as
'get_data'
"""
for (stage_type, prop) in self._stage_type_map:
try:
prop_value = getattr(stage, prop)
except AttributeError:
pass
else:
if prop_value:
return stage_type
raise TypeError(('Could not identify stage type for stage'
' %s from the stage map. Adjust the stage map'
' for the entity type or define an appropriate'
' is_<something> property on the class of the '
' stage. Stage map is %s' % (stage.name, self._stage_type_map)))
def get_start_ts_override(self):
if self._start_ts_override is not None:
if isinstance(self._start_ts_override, dt.datetime):
date_time_obj = self._start_ts_override
else:
date_time_obj = dt.datetime.strptime(self._start_ts_override[0], '%Y-%m-%d %H:%M:%S')
return date_time_obj
return None
def get_replacement(self, obj):
"""
Get replacement for deprecated function
"""
try:
is_deprecated = obj.is_deprecated
except AttributeError:
is_deprecated = False
if is_deprecated:
try:
obj = obj.get_replacement()
except AttributeError:
msg = ('Skipped deprecated function. The function'
' %s has no designated replacement. Provide a'
' replacement by implementing the get_replacement()'
' method or rework entity type to remove the reference'
' to the deprecated function' % obj.__class__.__name__)
raise StageException(msg, obj.__class__.__name__)
else:
logger.debug('Entity Type has a reference to a deprecated'
' function. This function was automatically'
' replaced by %s', obj.__class__.__name__)
return obj
def generate_data(self, entities=None, days=0, seconds=300, freq='1min', scd_freq='1D', write=True,
drop_existing=False, data_item_mean=None, data_item_sd=None, data_item_domain=None, columns=None,
start_entity_id=None, auto_entity_count=None, datasource=None, datasourcemetrics=None):
"""
Generate random time series data for entities
Parameters
----------
entities: list
List of entity ids to genenerate data for
days: number
Number of days worth of data to generate (back from system date)
seconds: number
Number of seconds of worth of data to generate (back from system date)
freq: str
Pandas frequency string - interval of time between subsequent rows of data
write: bool
write generated data back to table with same name as entity
drop_existing: bool
drop existing time series, dimension, activity and scd table
data_item_mean: dict
mean values for generated data items. dict is keyed on data item name
data_item_sd: dict
std values for generated data items. dict is keyed on data item name
data_item_domain: dict
domains of values for categorical data items. dict is keyed on data item name
datasource: dataframe
dataframe as data source
datasourcemetrics : list of strings
list of relevant column for datasource
"""
if entities is None:
if start_entity_id is None:
start_entity_id = self._start_entity_id
if auto_entity_count is None:
auto_entity_count = self._auto_entity_count
entities = [str(start_entity_id + x) for x in list(range(auto_entity_count))]
if data_item_mean is None:
data_item_mean = {}
if data_item_sd is None:
data_item_sd = {}
if data_item_domain is None:
data_item_domain = {}
if drop_existing and self.db is not None:
self.drop_tables(recreate=True)
known_categoricals = set(data_item_domain.keys())
exclude_cols = ['deviceid', 'devicetype', 'format', 'updated_utc', 'logicalinterface_id', self._timestamp]
if self.db is None or self.is_local:
write = False
msg = 'This is a local entity or entity with no database connection, test data will not be written'
logger.debug(msg)
(metrics, dates, categoricals, others) = self.get_local_column_lists_by_type(columns,
known_categoricals_set=known_categoricals)
else:
(metrics, dates, categoricals, others) = self.db.get_column_lists_by_type(self.table, self._db_schema,
exclude_cols=exclude_cols,
known_categoricals_set=known_categoricals)
msg = 'Generating data for %s with metrics %s and dimensions %s and dates %s' % (
self.name, metrics, categoricals, dates)
logger.debug(msg)
ts = TimeSeriesGenerator(metrics=metrics, ids=entities, days=days, seconds=seconds, freq=freq,
categoricals=categoricals, dates=dates, timestamp=self._timestamp,
domains=data_item_domain, datasource=datasource, datasourcemetrics=datasourcemetrics)
ts.data_item_mean = data_item_mean
ts.data_item_sd = data_item_sd
ts.data_item_domain = data_item_domain
df = ts.execute()
dimension_table_exists = False
try:
dimension_table_exists = self.db.if_exists(table_name=self._dimension_table_name, schema=self._db_schema)
except Exception:
pass
if self._dimension_table_name is not None and dimension_table_exists:
self.generate_dimension_data(entities, write=write, data_item_mean=data_item_mean,
data_item_sd=data_item_sd, data_item_domain=data_item_domain)
if write and self.db is not None:
for o in others:
if o not in df.columns:
df[o] = None
df['logicalinterface_id'] = ''
df['devicetype'] = self.logical_name
df['format'] = ''
df['updated_utc'] = dt.datetime.utcnow()
self.db.write_frame(table_name=self.name, df=df, schema=self._db_schema, timestamp_col=self._timestamp)
for (at_name, at_table) in list(self.activity_tables.items()):
adf = self.generate_activity_data(table_name=at_name, activities=at_table._activities, entities=entities,
days=days, seconds=seconds, write=write)
msg = 'generated data for activity table %s' % at_name
logger.debug(msg)
for scd in list(self.scd.values()):
sdf = self.generate_scd_data(scd_obj=scd, entities=entities, days=days, seconds=seconds, write=write,
freq=scd_freq, domains=data_item_domain)
msg = 'generated data for scd table %s' % scd.name
logger.debug(msg)
return df
def generate_activity_data(self, table_name, activities, entities, days, seconds, write=True):
if self.db is None:
msg = ('Entity type has no db connection. Local entity types'
' are not allowed to generate activity data ')
raise ValueError(msg)
try:
(metrics, dates, categoricals, others) = self.db.get_column_lists_by_type(table_name, self._db_schema,
exclude_cols=[self._entity_id,
'start_date',
'end_date'])
except KeyError:
metrics = []
dates = []
categoricals = []
others = []
metrics.append('duration')
categoricals.append('activity')
ts = TimeSeriesGenerator(metrics=metrics, dates=dates, categoricals=categoricals, ids=entities, days=days,
seconds=seconds, freq=self._activity_frequency)
ts.set_domain('activity', activities)
df = ts.execute()
df['start_date'] = df[self._timestamp]
duration = df['duration'].abs()
df['end_date'] = df['start_date'] + pd.to_timedelta(duration, unit='h')
# probability that an activity took place in the interval
p_activity = (days * 60 * 60 * 24 + seconds) / pd.to_timedelta(self._activity_frequency).total_seconds()
is_activity = p_activity >= np.random.uniform(0, 1, len(df.index))
df = df[is_activity]
cols = [x for x in df.columns if x not in ['duration', self._timestamp]]
df = df[cols]
if write:
msg = 'Generated %s rows of data and inserted into %s' % (len(df.index), table_name)
logger.debug(msg)
self.db.write_frame(table_name=table_name, df=df, schema=self._db_schema)
return df
def generate_dimension_data(self, entities, write=True, data_item_mean=None, data_item_sd=None,
data_item_domain=None):
if self.db is None:
msg = ('Entity type has no db connection. Local entity types'
' are not allowed to generate dimension data ')
raise ValueError(msg)
# check for existing dimension data
df_existing = self.db.read_dimension(self._dimension_table_name, schema=self._db_schema, entities=entities)
existing_entities = set(df_existing[self._entity_id])
# do not generate data for existing entities
entities = list(set(entities) - existing_entities)
if len(entities) > 0:
if data_item_mean is None:
data_item_mean = {}
if data_item_sd is None:
data_item_sd = {}
if data_item_domain is None:
data_item_domain = {}
known_categoricals = set(data_item_domain.keys())
(metrics, dates, categoricals, others) = self.db.get_column_lists_by_type(self._dimension_table_name,
self._db_schema,
exclude_cols=[self._entity_id],
known_categoricals_set=known_categoricals)
rows = len(entities)
data = {}
for m in metrics:
mean = data_item_mean.get(m, 0)
sd = data_item_sd.get(m, 1)
data[m] = MetricGenerator(m, mean=mean, sd=sd).get_data(rows=rows)
for c in categoricals:
categories = data_item_domain.get(c, None)
data[c] = CategoricalGenerator(c, categories).get_data(rows=rows)
data[self._entity_id] = entities
df = pd.DataFrame(data=data)
for d in dates:
df[d] = DateGenerator(d).get_data(rows=rows)
df[d] = pd.to_datetime(df[d])
if write:
if self.db.db_type == 'db2':
self._dimension_table_name = self._dimension_table_name.upper()
else:
self._dimension_table_name = self._dimension_table_name.lower()
self.db.write_frame(df, table_name=self._dimension_table_name, if_exists='append',
schema=self._db_schema)
else:
logger.debug('No new entities. Did not generate dimension data.')
def get_entity_filter(self):
"""
Get the list of entity ids that are valid for pipeline processing.
"""
return self._entity_filter_list
def get_last_checkpoint(self):
"""
Get the last checkpoint recorded for entity type
"""
if self.db is None:
msg = ('Entity type has no db connection. Local entity'
' types do not have a checkpoint')
logger.debug(msg)
return None
(query, table) = self.db.query_column_aggregate(table_name=self.checkpoint_table, schema=self._db_schema,
column='TIMESTAMP', aggregate='max')
query.filter(table.c.entity_type_id == self._entity_type_id)
return query.scalar()
def generate_scd_data(self, scd_obj, entities, days, seconds, freq, write=True, domains=None):
if self.db is None:
msg = ('Entity type has no db connection. Local entity types'
' are not allowed to generate scd data ')
raise ValueError(msg)
if domains is None:
domains = {}
table_name = scd_obj.name
msg = 'generating data for %s for %s days and %s seconds' % (table_name, days, seconds)
try:
(metrics, dates, categoricals, others) = self.db.get_column_lists_by_type(table_name, self._db_schema,
exclude_cols=[self._entity_id,
'start_date',
'end_date'])
except KeyError:
metrics = []
dates = []
categoricals = [scd_obj.property_name.name]
others = []
msg = msg + ' with metrics %s, dates %s, categorials %s and others %s' % (metrics, dates, categoricals, others)
logger.debug(msg)
ts = TimeSeriesGenerator(metrics=metrics, dates=dates, categoricals=categoricals, ids=entities, days=days,
seconds=seconds, freq=freq, domains=domains)
df = ts.execute()
df['start_date'] = df[self._timestamp]
# probability that a change took place in the interval
p_activity = (days * 60 * 60 * 24 + seconds) / pd.to_timedelta(freq).total_seconds()
is_activity = p_activity >= np.random.uniform(0, 1, len(df.index))
df = df[is_activity]
cols = [x for x in df.columns if x not in [self._timestamp]]
df = df[cols]
df['end_date'] = None
if len(df.index) > 0:
df = df.groupby([self._entity_id]).apply(self._set_end_date)
try:
self.db.truncate(table_name, schema=self._db_schema)
except KeyError:
pass
if write:
msg = 'Generated %s rows of data and inserted into %s' % (len(df.index), table_name)
logger.debug(msg)
self.db.write_frame(table_name=table_name, df=df, schema=self._db_schema, if_exists='append')
return df
def _get_scd_list(self):
return [(s.output_item, s.table_name) for s in self._scd_stages]
def is_base_item(self, item_name):
"""
Base items are non calculated data items.
"""
item_type = self._data_items[item_name]['columnType']
if item_type == 'METRIC':
return True
else:
return False
def is_data_item(self, name):
"""
Determine whether an item is a data item
"""
if name in [x.name for x in self._data_items]:
return True
else:
return False
def make_dimension(self, name=None, *args, **kw):
"""
Add dimension table by specifying additional columns
Parameters
----------
name: str
dimension table name
*args: sql alchemchy Column objects
* kw: : schema
"""
if self.db is None:
msg = ('Entity type has no db connection. Local entity types'
' are not allowed to make dimensions ')
raise ValueError(msg)
kw['schema'] = self._db_schema
if name is None:
name = '%s_dimension' % self.name
# name = name.lower()
# self._dimension_table_name = name
if self.db.db_type == 'db2':
self._dimension_table_name = name.upper()
else:
self._dimension_table_name = name.lower()
try:
self._dimension_table = self.db.get_table(self._dimension_table_name, self._db_schema)
except KeyError:
dim = db_module.Dimension(self._dimension_table_name, self.db, *args, **kw)
self._dimension_table = dim.table
# dim.create()
# msg = 'Created dimension table %s' % self._dimension_table_name
msg = 'Dimension table not created'
logger.debug(msg)
def publish_kpis(self, raise_error=True):
warnings.warn(('publish_kpis() is deprecated for EntityType. Instead'
' use an EntityType inherited from BaseCustomEntityType'), DeprecationWarning)
"""
Publish the stages assigned to this entity type to the AS Server
"""
export = []
stages = self.build_flat_stage_list()
self.db.register_functions(stages)
for s in stages:
try:
name = s.name
except AttributeError:
name = s.__class__.__name__
logger.debug(('Function class %s has no name property.'
' Using the class name'), name)
try:
args = s._get_arg_metadata()
except AttributeError:
msg = ('Attempting to publish kpis for an entity type.'
' Function %s has no _get_arg_spec() method.'
' It cannot be published') % name
raise NotImplementedError(msg)
metadata = {'name': name, 'args': args}
export.append(metadata)
logger.debug('Published kpis to entity type')
logger.debug(export)
response = self.db.http_request(object_type='kpiFunctions', object_name=self.logical_name, request='POST',
payload=export, raise_error=raise_error)
logger.debug(response)
return response
def raise_error(self, exception, msg=None, abort_on_fail=False, stage_name=None):
"""
Raise an exception. Append a message and the current trace to the stacktrace.
"""
err_info = {'AttributeError': 'The function %s makes reference to an object property that does not exist.',
'SyntaxError': 'The function %s contains a syntax error. If the function includes a type-in expression, make sure this is correct.',
'ValueError': 'The function %s is operating on a data that has an unexpected value for its data type.',
'TypeError': 'The function %s is operating on a data that has an unexpected data type.',
'KeyError': 'The function %s is refering to a dictionary key or dataframe column name that doesnt exist.',
'NameError': 'The function %s is refering to an object that doesnt exist. If refering to data items in a pandas dataframe, ensure that you quote them, e.g. df["temperature"].', }
if msg is None:
msg = err_info.get(exception.__class__.__name__, 'The function %s failed to execute.') % stage_name
if abort_on_fail:
raise StageException(error_message=msg, stage_name=stage_name, exception=exception)
else:
logger.warning(msg)
return msg
def create_sample_data(self, drop_existing, generate_days, generate_entities=None,
populate_dm_wiot_entity_list=False):
if generate_days > 0:
# classify stages is adds entity metdata to the stages
# need to run it before executing any stage
self.classify_stages()
generators = [x for x in self._functions if x.is_data_generator]
start = dt.datetime.utcnow() - dt.timedelta(days=generate_days)
for g in generators:
logger.debug(('Running generator %s with start date %s.'
' Drop existing %s'), g.__class__.__name__, start, drop_existing)
g.execute(df=None, start_ts=start, entities=generate_entities)
if populate_dm_wiot_entity_list:
self.populate_entity_list_table()
def populate_entity_list_table(self):
entity_list_table_name = 'dm_wiot_entity_list'
try:
if self.db.db_type == 'db2':
entity_list_table_name = entity_list_table_name.upper()
else:
entity_list_table_name = entity_list_table_name.lower()
entities = [str(self._start_entity_id + x) for x in list(range(self._auto_entity_count))]
self.db.start_session()
table = self.db.get_table(entity_list_table_name, self._db_schema)
for entity_id in entities:
stmt = table.insert().values({'entity_type_id': self._entity_type_id, 'entity_id': entity_id})
self.db.connection.execute(stmt)
self.db.commit()
except Exception:
logger.debug('Error populating dm_wiot_entity_list table.')
def register(self, publish_kpis=False, raise_error=False, sample_entity_type=False):
"""
Register entity type so that it appears in the UI. Create a table for input data.
Parameters
----------
credentials: dict
credentials for the ICS metadata service
"""
if self.db is None:
msg = ('Entity type has no db connection. Local entity types'
' may not be registered ')
raise ValueError(msg)
cols = []
columns = []
metric_column_names = []
table = {}
table['name'] = self.logical_name
table['metricTableName'] = self.name
table['metricTimestampColumn'] = self._timestamp
table['description'] = self.description
table['origin'] = 'AS_SAMPLE'
for c in self.db.get_column_names(self.table, schema=self._db_schema):
cols.append((self.table, c, 'METRIC'))
metric_column_names.append(c)
if self._dimension_table is not None:
table['dimensionTableName'] = self._dimension_table_name
for c in self.db.get_column_names(self._dimension_table, schema=self._db_schema):
if c not in metric_column_names:
cols.append((self._dimension_table, c, 'DIMENSION'))
for (table_obj, column_name, col_type) in cols:
msg = 'found %s column %s' % (col_type, column_name)
logger.debug(msg)
# if column_name not in self.get_excluded_cols():
data_type = table_obj.c[column_name].type
if isinstance(data_type, (FLOAT, Float, INTEGER, Integer)):
data_type = 'NUMBER'
elif db_module.DB2_DOUBLE is not None and isinstance(data_type, db_module.DB2_DOUBLE):
data_type = 'NUMBER'
elif isinstance(data_type, (VARCHAR, String)):
data_type = 'LITERAL'
elif isinstance(data_type, (TIMESTAMP, DateTime)):
data_type = 'TIMESTAMP'
else:
data_type = str(data_type)
logger.warning('Unknown datatype %s for column %s' % (data_type, column_name))
columns.append({'name': column_name, 'type': col_type, 'columnName': column_name, 'columnType': data_type,
'tags': None, 'transient': False})
table['dataItemDto'] = columns
if self._db_schema is not None:
table['schemaName'] = self._db_schema
else:
try:
table['schemaName'] = self.db.credentials['db2']['username']
except KeyError:
try:
username = self.db.credentials["postgresql"]['username']
table["schemaName"] = "public"
except KeyError:
raise KeyError('No database credentials found. Unable to register table.')
payload = [table]
response = self.db.http_request(request='POST', object_type='entityType', object_name=self.name,
payload=payload, raise_error=raise_error, sample_entity_type=sample_entity_type)
msg = 'Metadata registered for table %s ' % self.name
logger.debug(msg)
if publish_kpis:
self.publish_kpis(raise_error=raise_error)
self.db.register_constants(self.ui_constants)
return response
def trace_append(self, created_by, msg, log_method=None, df=None, **kwargs):
"""
Write to entity type trace
"""
self._trace.write(created_by=created_by, log_method=log_method, text=msg, df=df, **kwargs)
def set_custom_calendar(self, custom_calendar):
"""
Set a custom calendar for the entity type.
"""
if custom_calendar is not None:
self._custom_calendar = custom_calendar
def get_server_params(self):
"""
Retrieve the set of properties assigned through the UI
Assign to instance variables
"""
if self.db is None:
msg = ('Entity type has no db connection. Local entity types'
' are not able to get server params ')
logger.debug(msg)
return {}
meta = self.db.http_request(object_type='constants', object_name=self.logical_name, request='GET')
try:
meta = json.loads(meta)
except (TypeError, json.JSONDecodeError):
params = {}
logger.debug('API call to server did not retrieve valid entity type properties. No properties set.')
else:
params = {}
for p in meta:
key = p['name']
if isinstance(p['value'], dict):
params[key] = p['value'].get('value', p['value'])
else:
params[key] = p['value']
logger.debug('Adding server property %s with value %s to entity type', key, params[key])
self.set_params(**params)
return params
def _set_end_date(self, df):
df['end_date'] = df['start_date'].shift(-1)
df['end_date'] = df['end_date'] - | pd.Timedelta(microseconds=1) | pandas.Timedelta |
# -*- coding: utf-8 -*-
"""HAR_Opportunity.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/1qfhns0ykD6eLkoWICPu6WbdD4r7V-6Uf
# Introduction
This notebook presents the several machine learning models using CNN and LSTM for HAR. To obtain a detailed description of the architecture, please refer to the dissertation, **"RECOGNISING HUMAN ACTIVITIES AUTONOMOUSLY THROUGH FUSION OF SENSOR DATA"**.
## Dataset
As a dataset, the [OPPORTUNITY Activity Recognition Data Set](http://archive.ics.uci.edu/ml/datasets/OPPORTUNITY+Activity+Recognition) is used. To prepare this dataset for the program, the following code is uncommented and executed.
"""
# Download dataset zip file and place data files in training and test set directries
zipfile_dataset_opportunity = "OpportunityUCIDataset.zip"
url_dataset_opportunity = "https://archive.ics.uci.edu/ml/machine-learning-databases/00226/OpportunityUCIDataset.zip"
#!wget $url_dataset_opportunity
#!unzip $zipfile_dataset_opportunity
#!ls OpportunityUCIDataset/dataset/
# Deploy dataset files into training and test directories
#!mkdir -p ../data/test
#!mkdir ../data/train
#%cd OpportunityUCIDataset/dataset/
#!cp S[1-3]-Drill.dat S1-ADL[1-5].dat S2-ADL[1-3].dat S3-ADL[1-3].dat ../../../data/train/
#!cp S[23]-ADL[23].dat ../../../data/test/
#%cd ../../
#!ls ../data/train/
#!ls ../data/test/
"""# 1.Parameters
Adjustable flags and parameters are listed. Hyperparameters for each ML model are in "[F] ML models" section.
|Name|Type|Explanation|
|-|-|-|
|flag_delete_null|Flag|Whether delete the Null class or not|
|flag_label|Flag|Activity type (gesture or locomotion)|
|flag_(ML model name)|Flag|Whether execute the model or not|
|flag_experiment|Flag|Whether run repeated evaluation for summary statistics or not|
|flag_model_load|Flag|Whether load the model from the file or not|
|flag_model_save|Flag|Whether save the model to the file after training or not|
|flag_EarlyStopping|Flag|Enable Early stopping|
|flag_es_monitor|Flag|Monitor type for Early stopping|
|ratio_train|Parameter|The ratio between training and validation sets|
|seed|Parameter|Fix the seed for reproducibility|
|flag_scale|Flag|Scaling technique|
|window_size|Parameter|The length of the sliding window|
|window_step|Parameter|The step of the sliding window|
|flag_sw_label|Flag|Class label of the sliding window|
|flag_balance_*|Flag|Enable data balancing|
|flag_data_dist|Flag|Display dataset distribution|
|flag_interpolate|Flag|Enable interpolation|
|flag_plot_model|Flag|Whether plot model graphs or not|
|flag_save_fig|Flag|Whether save graphs or not|
|flag_summary|Flag|Show summary of the dataset|
|flag_cm_norm|Flag|Whether normalise confusion matrix or not|
|flag_TensorBoard|Flag|Whether save the Tensorboard data or not|
"""
### [Note]
#
# Hyperparameters for each ML model are in "[F] ML models" section
#
### ---------- ---------- ---------- ---------- ----------
### Flags
flag_delete_null = False
# Label
flag_label = "ML_Both_Arms"
#flag_label = "Locomotion"
# ML
flag_CNN_1d = True
flag_LSTM_Mto1 = True
flag_CNN1D_LSTM = True
flag_ConvLSTM = True
flag_Ensemble = True
flag_experiment = True
flag_model_load = False
flag_model_save = True
flag_EarlyStopping = True
flag_es_monitor = "val_loss"
#flag_es_monitor = "val_accuracy"
### ---------- ---------- ---------- ---------- ----------
### Pre-processing
# Ratio of training dataset to be split
ratio_train = 0.85
# Randam seed for reproducibility
seed = 7
# scaling
flag_scaling = "Std" # for Gaussian
#flag_scaling = "Norm" # (0 - 1)
# Sliding window
window_size = 15
window_step = 8
flag_sw_label = "last"
#flag_sw_label = "mode"
# Data balancing
flag_balance_under1 = False
flag_balance_under2 = False
flag_balance_under3 = False
flag_balance_over1 = False
flag_balance_over2 = False
flag_balance_over3 = False
### ---------- ---------- ---------- ---------- ----------
### Evaluation
flag_data_dist = False
flag_interpolate = True
flag_plot_model = True
flag_savefig = True
flag_summary = True
flag_cm_norm = True
flag_TensorBoard = False
### ---------- ---------- ---------- ---------- ----------
### Directories
dir_log = 'log'
dir_model = 'model'
### ---------- ---------- ---------- ---------- ----------
### Names
# models
modelname_cnn_1d = 'CNN_1D'
modelname_lstm_Mto1 = 'LSTM_Mto1'
modelname_cnn1d_lstm = 'CNN1D_LSTM'
modelname_convlstm = 'ConvLSTM'
modelname_ensemble = 'Ensemble'
modelname_lstm_Mto1_null = 'LSTM_Mto1_null'
# Label list
labels_Loco = ['(Null)',
'Stand',
'Walk',
'Sit',
'Lie']
labels_ML = ['(Null)',
'Open Door 1', 'Open Door 2',
'Close Door 1', 'Close Door 2',
'Open Fridge', 'Close Fridge',
'Open Dishwasher', 'Close Dishwasher',
'Open Drawer 1', 'Close Drawer 1',
'Open Drawer 2', 'Close Drawer 2',
'Open Drawer 3', 'Close Drawer 3',
'Clean Table', 'Drink from Cup', 'Toggle Switch']
### ---------- ---------- ---------- ---------- ----------
"""# 2.Setup
## Import libraries
"""
# Pre-process
import os
import glob
import numpy as np
import random as rn
import pandas as pd
from numpy.lib.stride_tricks import as_strided
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, MinMaxScaler
from tensorflow.keras.utils import to_categorical
import collections
# Evaluation
from sklearn.metrics import f1_score, classification_report, confusion_matrix
import matplotlib.pyplot as plt
import time
from datetime import datetime
from numpy import mean, std
from matplotlib import pyplot
import seaborn as sns
sns.set()
# NNs
from tensorflow.keras.models import load_model
from tensorflow.keras.utils import plot_model
from tensorflow.keras.callbacks import EarlyStopping, TensorBoard
# CNN
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.layers import Conv1D, MaxPool1D
from tensorflow.keras.layers import Activation, Dropout, Flatten, Dense
from tensorflow.keras.layers import Input, BatchNormalization
from tensorflow.keras.optimizers import Adam
# LSTM
from tensorflow.keras.layers import LSTM, TimeDistributed
from tensorflow.keras import regularizers
# ConvLSTM
from tensorflow.keras.layers import ConvLSTM2D
# Ensemble
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, Concatenate
# Set random seed (for reproducibility)
# Hash seed
os.environ["PYTHONHASHSEED"] = str(seed)
# Built-in random
rn.seed(seed)
# Numpy.random
np.random.seed(seed)
# Tensorflow
tf.random.set_seed(seed)
"""## [F] Pre-processing"""
def read_files(files):
for i, file in enumerate(files):
print(f'[{i+1}] Reading file: {file}')
d = pd.read_csv(file, header=None, sep=' ')
# Truncate last residual records for sliding window
mod = (len(d) - window_size) % window_step
d = d[:len(d)-mod]
# Count records with NaN
d_nan = d.isnull().sum()
# Convert NaN
# Linear interpolation
if flag_interpolate:
d.interpolate(inplace=True)
# Convert remaining NaNs into 0
if flag_interpolate:
d.replace(np.nan, 0, inplace=True)
if i == 0:
dataset = d
dataset_nan = d_nan
else:
dataset = pd.concat([dataset, d])
dataset_nan = dataset_nan + d_nan
return dataset, dataset_nan
# Adjust label values (0 to num_classes)
def adjust_idx_labels(data_y):
if flag_label == 'Locomotion':
data_y[data_y == 4] = 3
data_y[data_y == 5] = 4
elif flag_label == 'ML_Both_Arms':
data_y[data_y == 406516] = 1
data_y[data_y == 406517] = 2
data_y[data_y == 404516] = 3
data_y[data_y == 404517] = 4
data_y[data_y == 406520] = 5
data_y[data_y == 404520] = 6
data_y[data_y == 406505] = 7
data_y[data_y == 404505] = 8
data_y[data_y == 406519] = 9
data_y[data_y == 404519] = 10
data_y[data_y == 406511] = 11
data_y[data_y == 404511] = 12
data_y[data_y == 406508] = 13
data_y[data_y == 404508] = 14
data_y[data_y == 408512] = 15
data_y[data_y == 407521] = 16
data_y[data_y == 405506] = 17
return data_y
def sliding_window(data, w_size, w_step):
shape = np.array(data.shape)
# Compute new shape & strides based on window size & step
newshape = ((shape - w_size) // w_step) + 1
newshape = np.append(newshape, [w_size[0], data.shape[1]])
# Original strides * window step
newstrides = np.array(data.strides) * w_step
# For window size & features, set original strides
newstrides = np.append(newstrides, data.strides)
# Create a view for new shape & stride
data_strided = as_strided(data, shape=newshape, strides=newstrides)
# Flatten strided shape
newshape_flatten = [i for i in newshape if i != 1]
return data_strided.reshape(newshape_flatten)
def opp_sliding_window(X, Y):
X = sliding_window(X, (window_size, X.shape[1]), (window_step, 1))
Y = sliding_window(Y, (window_size, Y.shape[1]), (window_step, 1))
return X, Y
"""## [F] ML models"""
# Train
epochs = 100
batch_size = 100
repeats = 10
# EarlyStopping
es_patience = 5
"""### CNN"""
# Layer
cnn_padding ='same'
cnn_activation = 'relu'
cnn_units = 128
cnn_dropout = 0.5
cnn_pool_size = 2
## 1D Conv
cnn_1d_filters = 64
cnn_1d_kernel_size = 5
def build_model_cnn_1d():
model = Sequential(name=modelname_cnn_1d)
# Conv layer 1
model.add(Conv1D(
input_shape = cnn_1d_input_shape,
filters = cnn_1d_filters,
kernel_size = cnn_1d_kernel_size,
padding = cnn_padding,
activation = cnn_activation))
# Conv layer 2
model.add(Conv1D(
filters = cnn_1d_filters,
kernel_size = cnn_1d_kernel_size,
padding = cnn_padding,
activation = cnn_activation))
# Conv layer 3
model.add(Conv1D(
filters = cnn_1d_filters,
kernel_size = cnn_1d_kernel_size,
padding = cnn_padding,
activation = cnn_activation))
# Conv layer 4
model.add(Conv1D(
filters = cnn_1d_filters,
kernel_size = cnn_1d_kernel_size,
padding = cnn_padding,
activation = cnn_activation))
# Maxpool layer
# model.add(MaxPool1D(
# pool_size = cnn_pool_size))
model.add(Flatten())
# Dense layer 1
model.add(Dense(
units = cnn_units,
activation = 'relu'))
# Dropout
model.add(Dropout(cnn_dropout))
# Dense layer 2
model.add(Dense(
units = cnn_units,
activation = 'relu'))
# Dropout
model.add(Dropout(cnn_dropout))
# Output layer
model.add(Dense(
units = num_classes,
activation = 'softmax'))
model.compile(
loss = 'categorical_crossentropy',
optimizer = 'adam',
metrics = ['accuracy'])
return model
"""### LSTM"""
# Layer
lstm_units = 128
lstm_dropout = 0.5
lstm_weight_decay = 1e-4
# LSTM (Many-to-One, stateless)
def build_model_lstm_Mto1():
model = Sequential(name=modelname_lstm_Mto1)
# LSTM layer
model.add(LSTM(
input_shape = lstm_input_shape,
units = lstm_units,
# kernel_regularizer = regularizers.l2(lstm_weight_decay),
return_sequences = False)) # final layer of LSTM (only final output)
# Dropout
model.add(Dropout(lstm_dropout))
# Dense layer
model.add(Dense(
units = lstm_units,
activation = 'relu'))
# Dropout
model.add(Dropout(lstm_dropout))
# Output layer
model.add(Dense(
units = num_classes,
activation = 'softmax'))
model.compile(
loss = 'categorical_crossentropy',
optimizer = 'adam',
metrics = ['accuracy'])
return model
"""### CNN-LSTM"""
# Data
cnn_lstm_steps = 3
cnn_lstm_length = int(window_size / cnn_lstm_steps)
# Layer
cnn_lstm_padding = 'same'
cnn_lstm_activation = 'relu'
cnn_lstm_dropout = 0.5
cnn_lstm_pool_size = 2
## CNN
cnn_lstm_filters = 64
cnn1d_lstm_kernel_size = 3
# LSTM
cnn_lstm_units = 128
def build_model_cnn1d_lstm():
model = Sequential(name=modelname_cnn1d_lstm)
## CNN (with TimeDistributed)
# Conv layer 1
model.add(TimeDistributed(Conv1D(
filters = cnn_lstm_filters,
kernel_size = cnn1d_lstm_kernel_size,
padding = cnn_lstm_padding,
activation = cnn_lstm_activation),
input_shape = cnn1d_lstm_input_shape))
# Conv layer 2
model.add(TimeDistributed(Conv1D(
filters = cnn_lstm_filters,
kernel_size = cnn1d_lstm_kernel_size,
padding = cnn_lstm_padding,
activation = cnn_lstm_activation)))
# Conv layer 3
model.add(TimeDistributed(Conv1D(
filters = cnn_lstm_filters,
kernel_size = cnn1d_lstm_kernel_size,
padding = cnn_lstm_padding,
activation = cnn_lstm_activation)))
# Conv layer 4
model.add(TimeDistributed(Conv1D(
filters = cnn_lstm_filters,
kernel_size = cnn1d_lstm_kernel_size,
padding = cnn_lstm_padding,
activation = cnn_lstm_activation)))
# Dropout
model.add(TimeDistributed(Dropout(cnn_lstm_dropout)))
# Maxpool layer
model.add(TimeDistributed(MaxPool1D(
pool_size = cnn_lstm_pool_size)))
model.add(TimeDistributed(Flatten()))
## LSTM
# LSTM layer 1
model.add(LSTM(
units = cnn_lstm_units,
return_sequences = True))
# Dropout
model.add(Dropout(cnn_lstm_dropout))
# LSTM layer 2
model.add(LSTM(
units = cnn_lstm_units,
return_sequences = False))
# Dropout
model.add(Dropout(cnn_lstm_dropout))
# Output layer
model.add(Dense(
units = num_classes,
activation = 'softmax'))
model.compile(
loss = 'categorical_crossentropy',
optimizer = 'adam',
metrics = ['accuracy'])
return model
"""### ConvLSTM"""
# Data
convlstm_steps = 3
convlstm_length = int(window_size / convlstm_steps)
# Layer
convlstm_padding = 'same'
convlstm_activation = 'relu'
convlstm_dropout = 0.5
convlstm_pool_size = 2
## CNN
convlstm_filters = 64
convlstm_kernel_size = (1, 3)
convlstm_units = 128
def build_model_convlstm():
model = Sequential(name=modelname_convlstm)
# Conv LSTM layer 1
model.add(ConvLSTM2D(
filters = convlstm_filters,
kernel_size = convlstm_kernel_size,
padding = convlstm_padding,
activation = convlstm_activation,
input_shape = convlstm_input_shape,
return_sequences = True))
# return_sequences = False)) # final layer of LSTM (only final output)
# Conv LSTM layer 2
model.add(ConvLSTM2D(
filters = convlstm_filters,
kernel_size = convlstm_kernel_size,
padding = convlstm_padding,
activation = convlstm_activation,
return_sequences = True))
# Conv LSTM layer 3
model.add(ConvLSTM2D(
filters = convlstm_filters,
kernel_size = convlstm_kernel_size,
padding = convlstm_padding,
activation = convlstm_activation,
return_sequences = True))
# Conv LSTM layer 4
model.add(ConvLSTM2D(
filters = convlstm_filters,
kernel_size = convlstm_kernel_size,
padding = convlstm_padding,
activation = convlstm_activation,
return_sequences = False))
# Dropout
model.add(Dropout(convlstm_dropout))
model.add(Flatten())
# Dense layer
model.add(Dense(
units = convlstm_units,
activation = convlstm_activation))
# Output layer
model.add(Dense(
units = num_classes,
activation = 'softmax'))
model.compile(
loss = 'categorical_crossentropy',
optimizer = 'adam',
metrics = ['accuracy'])
return model
"""### Ensemble"""
# Layer
ensemble_units = 10
ensemble_activation = 'relu'
def build_model_ensemble(inputs, outputs):
ensemble_merge = Concatenate(axis=1)(outputs)
# Dense layer
ensemble_hidden = Dense(
units = ensemble_units,
activation = ensemble_activation)(ensemble_merge)
# Output layer
ensemble_output = Dense(
units = num_classes,
activation = 'softmax')(ensemble_hidden)
model = Model(
inputs = inputs,
outputs = ensemble_output,
name = modelname_ensemble)
model.compile(
loss = 'categorical_crossentropy',
optimizer = 'adam',
metrics = ['accuracy'])
return model
"""## [F] Evaluation"""
# Train and evaluate a model (once)
def evaluate_model(model_name, X_train, y_train, X_val, y_val, X_test, y_test):
# Build model
if model_name == modelname_cnn_1d:
model = build_model_cnn_1d()
elif model_name == modelname_lstm_Mto1:
model = build_model_lstm_Mto1()
elif model_name == modelname_cnn1d_lstm:
model = build_model_cnn1d_lstm()
elif model_name == modelname_convlstm:
model = build_model_convlstm()
else:
print("Error: specify correct model name")
return -1
# Train
history = model.fit(
x = X_train,
y = y_train,
batch_size = batch_size,
epochs = epochs,
verbose = 0,
callbacks = [cb],
validation_data = (X_val, y_val)
)
num_epochs = len(history.history['loss'])
## Evaluate
# Accuracy
_, accuracy = model.evaluate(X_test, y_test, batch_size=batch_size, verbose=0)
# F1
y_pred = model.predict(X_test)
f1 = f1_score(y_test.argmax(axis=-1), y_pred.argmax(axis=-1), average='weighted')
return accuracy, f1, num_epochs
# Repeat experiment
def run_experiment(model_name, X_train, X_val, X_test, y_train, y_val, y_test, repeats=10):
print(f'Model: {model_name}')
scores_acc = []
scores_f1 = []
scores_epoch = []
for r in range(repeats):
acc, f1, epoch = evaluate_model(model_name, X_train, y_train, X_val, y_val, X_test, y_test)
print(f'[#{r+1:>2d}] Accuracy: {acc:.3f}, F1 score(weighted): {f1:.3f}, epoch: {epoch}')
scores_acc.append(acc)
scores_f1.append(f1)
scores_epoch.append(epoch)
# Summarise mean and standard deviation
print(f'Accuracy: {mean(scores_acc):.3f} (+/- {std(scores_acc):.3f})')
print(f'F1 score(weighted): {mean(scores_f1):.3f} (+/- {std(scores_f1):.3f})')
print(f'epoch: {mean(scores_epoch):.1f} (+/- {std(scores_epoch):.3f})')
# Boxplot of scores
metrics_list = ['Accuracy', 'F1 score']
all_scores = []
all_scores.append(scores_acc)
all_scores.append(scores_f1)
plt.boxplot(all_scores, labels=metrics_list)
if flag_savefig:
plt.savefig("boxplot_" + model_name + ".png")
plt.show()
# Plot a histogram of each variable in the dataset
def plot_variable_distributions(X, start=0, end=None, xlim=None):
if end is None:
end = X.shape[1]-1
print(X.shape)
num_features = end - start +1
print(f'# of plots: {num_features} ({start} - {end})')
plt.figure(figsize=(10, 2*num_features), tight_layout=True)
xaxis = None
for i, f in enumerate(range(start, end+1)):
print(i)
if xlim is None:
ax = plt.subplot(num_features, 1, i+1, title='Feature: ' + str(f))
else:
ax = plt.subplot(num_features, 1, i+1, sharex=xaxis, title='Feature: ' + str(f))
ax.set_xlim(xlim)
if i == 0:
xaxis = ax
plt.hist(X[:, f], bins=100)
plt.show()
# Plot graphs for loss and accuracy
def plot_acc_graph(history):
# Set figure size
fig = plt.figure(figsize=(15, 6))
plt.subplots_adjust(wspace=0.2)
# Loss
plt.subplot(1,2,1)
plt.plot(history.history['loss'],
label='Train',
color='black')
plt.plot(history.history['val_loss'],
label='Val',
color='red')
#plt.ylim(0, 1)
plt.legend()
plt.grid(True)
plt.xlabel('Epoch')
plt.ylabel('Loss')
# Accuracy
plt.subplot(1,2,2)
plt.plot(history.history['accuracy'],
label='Train',
color='black')
plt.plot(history.history['val_accuracy'],
label='Val',
color='red')
plt.ylim(0, 1)
plt.legend()
plt.grid(True)
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
if flag_savefig:
plt.savefig("acc_graph_" + history.model.name + ".png")
plt.show()
# Print execution time
def print_execution_time(time_start):
time_elapsed = time.perf_counter() - time_start
min, sec = divmod(time_elapsed, 60)
hour, min = divmod(min, 60)
print(f"Execution time: {hour:.0f} hour {min:.0f} min {sec:.0f} sec")
"""# 3.Pre-processing"""
# For CSF3 (UoM) setting
import platform
system_name = platform.system()
print('system_name: ' + system_name)
if system_name == "Linux":
flag_summary = False
flag_cm_norm = False
flag_plot_model = False
"""## Read files"""
# dataset files (train & test)
files_train = glob.glob('../data/train/*.dat')
files_test = glob.glob('../data/test/*.dat')
# Read datafiles (if not yet)
if not 'R_dataset_train' in locals():
R_dataset_train, nan_train = read_files(files_train)
R_dataset_test, nan_test = read_files(files_test)
# Discard null action records
if flag_delete_null:
if flag_label == 'Locomotion':
dataset_train = R_dataset_train[R_dataset_train.iloc[:, 243] != 0]
dataset_test = R_dataset_test[R_dataset_test.iloc[:, 243] != 0]
elif flag_label == 'ML_Both_Arms':
dataset_train = R_dataset_train[R_dataset_train.iloc[:, 249] != 0]
dataset_test = R_dataset_test[R_dataset_test.iloc[:, 249] != 0]
else:
dataset_train = R_dataset_train
dataset_test = R_dataset_test
# Balancing data 1 (After reading files)
if flag_balance_under1:
if flag_label == 'Locomotion':
idx_label = 243
elif flag_label == 'ML_Both_Arms':
idx_label = 249
min_train = dataset_train.iloc[:, idx_label].value_counts().min()
dataset_train_np = dataset_train.to_numpy()
for i in dataset_train.iloc[:, idx_label].unique():
dataset_train_np = np.delete(dataset_train_np, np.where(dataset_train_np[:, idx_label] == i)[0][min_train:], axis=0)
dataset_train = pd.DataFrame(dataset_train_np)
"""## Divide X / Y
(features and labels)
"""
## Features (X)
# Strip unnecessay columns
# (following opportunity challenge specification)
X_train = pd.concat([
dataset_train.iloc[:, 1:46], # (included:excluded)
dataset_train.iloc[:, 50:59],
dataset_train.iloc[:, 63:72],
dataset_train.iloc[:, 76:85],
dataset_train.iloc[:, 89:98],
dataset_train.iloc[:, 102:134]],
axis=1)
X_test = pd.concat([
dataset_test.iloc[:, 1:46],
dataset_test.iloc[:, 50:59],
dataset_test.iloc[:, 63:72],
dataset_test.iloc[:, 76:85],
dataset_test.iloc[:, 89:98],
dataset_test.iloc[:, 102:134]],
axis=1)
## Labels (Y)
# from last 7 columns
if flag_label == 'Locomotion':
y_train = dataset_train.iloc[:,243]
y_test = dataset_test.iloc[:,243]
elif flag_label == 'ML_Both_Arms':
y_train = dataset_train.iloc[:,249]
y_test = dataset_test.iloc[:,249]
y_train = y_train.rename('Label')
y_test = y_test.rename('Label')
num_features = len(X_train.columns)
# Input shape of NNs
cnn_1d_input_shape = (window_size, num_features)
lstm_input_shape = (window_size, num_features)
cnn1d_lstm_input_shape = (None, cnn_lstm_length, num_features)
convlstm_input_shape = (convlstm_steps, 1, convlstm_length, num_features)
"""## (Distributions)"""
if flag_data_dist:
plot_variable_distributions(X_train.to_numpy(), start=0, end=29)
plot_variable_distributions(X_train.to_numpy(), start=30, end=59)
plot_variable_distributions(X_train.to_numpy(), start=60, end=89)
plot_variable_distributions(X_train.to_numpy(), start=90, end=112)
"""## Encode labels"""
## Encode label (one-hot)
# Adjust label values for to_categorical()
y_train = adjust_idx_labels(y_train)
y_test = adjust_idx_labels(y_test)
# Convert class vector (int) to one-hot vector
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)
y_train = pd.DataFrame(y_train)
y_test = pd.DataFrame(y_test)
"""## Split train / val"""
# Split into train and val (No shuffle)
X_train, X_val, y_train, y_val = \
train_test_split(X_train, y_train,
train_size=ratio_train,
random_state=seed,
shuffle=False)
# Balancing data 2 (After splitting train, val, and test)
if flag_balance_under2:
min_train = y_train.value_counts().min()
X_train = X_train.to_numpy()
y_train = y_train.to_numpy()
y_train_n = y_train.argmax(axis=-1)
for i in range(len(np.unique(y_train_n))):
X_train = np.delete(X_train, np.where(y_train_n == i)[0][min_train:], axis=0)
y_train_n = np.delete(y_train_n, np.where(y_train_n == i)[0][min_train:], axis=0)
y_train = to_categorical(y_train_n)
X_train = pd.DataFrame(X_train)
y_train = pd.DataFrame(y_train)
# The number of classes
num_classes = len(y_train.columns)
# label list (for classification_report, confusion_matrix)
if flag_label == 'Locomotion':
labels_cr = labels_Loco
labels_cm = labels_Loco
elif flag_label == 'ML_Both_Arms':
labels_cr = labels_ML
labels_cm = labels_ML
if flag_delete_null:
labels_cr = np.delete(labels_cr, 0)
# labels_cm = np.delete(labels_cm, 0)
# confusion_matrix
labels = np.arange(0, num_classes)
"""## Scaling
"""
if flag_scaling == "Norm":
scaler = MinMaxScaler()
elif flag_scaling == "Std":
scaler = StandardScaler()
# Fit the scaler on the training data (to avoid data leakage)
scaler.fit(X_train)
# Scale (to numpy)
X_train = scaler.transform(X_train)
X_val = scaler.transform(X_val)
X_test = scaler.transform(X_test)
# Convert to numpy
y_train = y_train.to_numpy()
y_val = y_val.to_numpy()
y_test = y_test.to_numpy()
"""## (Distributions)"""
if flag_data_dist:
plot_variable_distributions(X_train, start=0, end=29)
plot_variable_distributions(X_train, start=30, end=59)
plot_variable_distributions(X_train, start=60, end=89)
plot_variable_distributions(X_train, start=90, end=112)
"""## Sliding window"""
X_train_sw, y_train_sw = opp_sliding_window(X_train, y_train)
X_val_sw, y_val_sw = opp_sliding_window(X_val, y_val)
X_test_sw, y_test_sw = opp_sliding_window(X_test, y_test)
if flag_sw_label == "last":
# last class of each sliding window
y_train_sw_label = np.asarray([[i[-1]] for i in y_train_sw]).reshape(-1, y_train_sw.shape[-1])
y_val_sw_label = np.asarray([[i[-1]] for i in y_val_sw]).reshape(-1, y_val_sw.shape[-1])
y_test_sw_label = np.asarray([[i[-1]] for i in y_test_sw]).reshape(-1, y_test_sw.shape[-1])
elif flag_sw_label == "mode":
# mode in each sliding window
y_train_sw_mode = np.asarray([collections.Counter(i.argmax(axis=-1)).most_common()[0][0] for i in y_train_sw])
y_train_sw_label = to_categorical(y_train_sw_mode)
y_val_sw_mode = np.asarray([collections.Counter(i.argmax(axis=-1)).most_common()[0][0] for i in y_val_sw])
y_val_sw_label = to_categorical(y_val_sw_mode)
y_test_sw_mode = np.asarray([collections.Counter(i.argmax(axis=-1)).most_common()[0][0] for i in y_test_sw])
y_test_sw_label = to_categorical(y_test_sw_mode)
# For evaluation
y_test_classes_sw_label = y_test_sw_label.argmax(axis=-1)
# Blancing data 3 (After sliding window)
if flag_balance_under3:
y_train_sw_n = y_train_sw_label.argmax(axis=-1)
min_train = pd.DataFrame(y_train_sw_label).value_counts().min()
for i in range(num_classes):
X_train_sw = np.delete(X_train_sw, np.where(y_train_sw_n == i)[0][min_train:], axis=0)
y_train_sw_n = np.delete(y_train_sw_n, np.where(y_train_sw_n == i)[0][min_train:], axis=0)
y_train_sw_label = to_categorical(y_train_sw_n)
elif flag_balance_over3:
y_train_sw_n = y_train_sw_label.argmax(axis=-1)
max_train = pd.DataFrame(y_train_sw_n)[0].value_counts().max()
num_labels = np.unique(y_train_sw_n).size
X_train_sw_balanced = np.empty((num_labels * max_train, X_train_sw.shape[1], X_train_sw.shape[2]))
y_train_sw_balanced = np.empty((num_labels * max_train, y_train_sw.shape[1], y_train_sw.shape[2]))
y_train_sw_label_balanced = np.empty((num_labels * max_train, y_train_sw_label.shape[1]))
X_train_sw_balanced[:X_train_sw.shape[0]] = X_train_sw
y_train_sw_balanced[:y_train_sw.shape[0]] = y_train_sw
y_train_sw_label_balanced[:y_train_sw_label.shape[0]] = y_train_sw_label
l = X_train_sw.shape[0]
for c in np.unique(y_train_sw_n):
num = np.count_nonzero(y_train_sw_n == c)
if max_train > num:
num_diff = max_train - num
idx_c = np.where(y_train_sw_n == c)[0]
idx_add = np.random.choice(idx_c, num_diff, replace=True)
for i in idx_add:
X_train_sw_balanced[l] = X_train_sw[i]
y_train_sw_balanced[l] = y_train_sw[i]
y_train_sw_label_balanced[l] = y_train_sw_label[i]
l += 1
X_train_sw = X_train_sw_balanced
y_train_sw = y_train_sw_balanced
y_train_sw_label = y_train_sw_label_balanced
"""## [Summary]"""
if flag_summary:
# The number of samples (train, val, test)
num_samples = len(X_train) + len(X_val) + len(X_test)
num_train = X_train.shape[0]
num_val = X_val.shape[0]
num_test = X_test.shape[0]
num_classes_train = y_train.shape[-1]
num_classes_val = y_val.shape[-1]
num_classes_test = y_test.shape[-1]
y_counts = pd.concat([np.flip( | pd.DataFrame(y_train) | pandas.DataFrame |
import pandas as pd
import pytest
# Wawa on toy YSDA
@pytest.fixture
def toy_labels_result_zbs():
return pd.Series(
['no', 'yes', 'no', 'yes', 'no'],
index= | pd.Index(['t1', 't2', 't3', 't4', 't5'], name='task') | pandas.Index |
# -*- coding: utf-8 -*-
import sys
import json
import logging
from typing import Tuple, List
from docopt import docopt
from munch import Munch
import pandas as pd
from wetterdienst import (
__version__,
metadata_for_climate_observations,
get_nearby_stations,
)
from wetterdienst.additionals.geo_location import stations_to_geojson
from wetterdienst.additionals.time_handling import mktimerange, parse_datetime
from wetterdienst.additionals.util import normalize_options, setup_logging, read_list
from wetterdienst.api import DWDStationRequest
from wetterdienst.enumerations.column_names_enumeration import DWDMetaColumns
from wetterdienst.enumerations.parameter_enumeration import Parameter
from wetterdienst.enumerations.period_type_enumeration import PeriodType
from wetterdienst.enumerations.time_resolution_enumeration import TimeResolution
log = logging.getLogger(__name__)
def run():
"""
Usage:
wetterdienst stations --parameter=<parameter> --resolution=<resolution> --period=<period> [--station=] [--latitude=] [--longitude=] [--count=] [--distance=] [--persist] [--format=<format>] # noqa:E501
wetterdienst readings --parameter=<parameter> --resolution=<resolution> --period=<period> --station=<station> [--persist] [--date=<date>] [--format=<format>] # noqa:E501
wetterdienst readings --parameter=<parameter> --resolution=<resolution> --period=<period> --latitude= --longitude= [--count=] [--distance=] [--persist] [--date=<date>] [--format=<format>] # noqa:E501
wetterdienst about [parameters] [resolutions] [periods]
wetterdienst --version
wetterdienst (-h | --help)
Options:
--parameter=<parameter> Parameter/variable, e.g. "kl", "air_temperature", "precipitation", etc. # noqa:E501
--resolution=<resolution> Dataset resolution: "annual", "monthly", "daily", "hourly", "minute_10", "minute_1" # noqa:E501
--period=<period> Dataset period: "historical", "recent", "now"
--station=<station> Comma-separated list of station identifiers
--latitude=<latitude> Latitude for filtering by geoposition.
--longitude=<longitude> Longitude for filtering by geoposition.
--count=<count> Number of nearby stations when filtering by geoposition. # noqa:E501
--distance=<distance> Maximum distance in km when filtering by geoposition. # noqa:E501
--persist Save and restore data to filesystem w/o going to the network # noqa:E501
--date=<date> Date for filtering data. Can be either a single date(time) or # noqa:E501
an ISO-8601 time interval, see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals. # noqa:E501
--format=<format> Output format. [Default: json]
--version Show version information
--debug Enable debug messages
-h --help Show this screen
Examples requesting stations:
# Get list of all stations for daily climate summary data in JSON format
wetterdienst stations --parameter=kl --resolution=daily --period=recent
# Get list of all stations in CSV format
wetterdienst stations --parameter=kl --resolution=daily --period=recent --format=csv # noqa:E501
# Get list of specific stations
wetterdienst stations --resolution=daily --parameter=kl --period=recent --station=1,1048,2667 # noqa:E501
# Get list of specific stations in GeoJSON format
wetterdienst stations --resolution=daily --parameter=kl --period=recent --station=1,1048,2667 --format=geojson # noqa:E501
Examples requesting readings:
# Get daily climate summary data for stations 44 and 1048
wetterdienst readings --station=44,1048 --parameter=kl --resolution=daily --period=recent # noqa:E501
# Optionally save/restore to/from disk in order to avoid asking upstream servers each time # noqa:E501
wetterdienst readings --station=44,1048 --parameter=kl --resolution=daily --period=recent --persist # noqa:E501
# Limit output to specific date
wetterdienst readings --station=44,1048 --parameter=kl --resolution=daily --period=recent --date=2020-05-01 # noqa:E501
# Limit output to specified date range in ISO-8601 time interval format
wetterdienst readings --station=44,1048 --parameter=kl --resolution=daily --period=recent --date=2020-05-01/2020-05-05 # noqa:E501
# The real power horse: Acquire data across historical+recent data sets
wetterdienst readings --station=44,1048 --parameter=kl --resolution=daily --period=historical,recent --date=1969-01-01/2020-06-11 # noqa:E501
# Acquire monthly data for 2020-05
wetterdienst readings --station=44,1048 --parameter=kl --resolution=monthly --period=recent,historical --date=2020-05 # noqa:E501
# Acquire monthly data from 2017-01 to 2019-12
wetterdienst readings --station=44,1048 --parameter=kl --resolution=monthly --period=recent,historical --date=2017-01/2019-12 # noqa:E501
# Acquire annual data for 2019
wetterdienst readings --station=44,1048 --parameter=kl --resolution=annual --period=recent,historical --date=2019 # noqa:E501
# Acquire annual data from 2010 to 2020
wetterdienst readings --station=44,1048 --parameter=kl --resolution=annual --period=recent,historical --date=2010/2020 # noqa:E501
# Acquire hourly data
wetterdienst readings --station=44,1048 --parameter=air_temperature --resolution=hourly --period=recent --date=2020-06-15T12 # noqa:E501
Examples using geospatial features:
# Acquire stations and readings by geoposition, request specific number of nearby stations. # noqa:E501
wetterdienst stations --resolution=daily --parameter=kl --period=recent --lat=50.2 --lon=10.3 --count=10 # noqa:E501
wetterdienst readings --resolution=daily --parameter=kl --period=recent --lat=50.2 --lon=10.3 --count=10 --date=2020-06-30 # noqa:E501
# Acquire stations and readings by geoposition, request stations within specific radius. # noqa:E501
wetterdienst stations --resolution=daily --parameter=kl --period=recent --lat=50.2 --lon=10.3 --distance=20 # noqa:E501
wetterdienst readings --resolution=daily --parameter=kl --period=recent --lat=50.2 --lon=10.3 --distance=20 --date=2020-06-30 # noqa:E501
"""
# Read command line options.
options = normalize_options(
docopt(run.__doc__, version=f"wetterdienst {__version__}")
)
# Setup logging.
debug = options.get("debug")
log_level = logging.INFO
if debug:
log_level = logging.DEBUG
setup_logging(log_level)
if options.about:
about(options)
return
if options.stations:
df = metadata_for_climate_observations(
parameter=options.parameter,
time_resolution=options.resolution,
period_type=options.period,
)
if options.station:
station_ids = read_list(options.station)
df = df[df.STATION_ID.isin(station_ids)]
elif options.latitude and options.longitude:
nearby_stations, distances = get_nearby(options)
df = df[df.STATION_ID.isin(nearby_stations)]
if df.empty:
log.error("No data available for given constraints")
sys.exit(1)
elif options.readings:
if options.station:
station_ids = read_list(options.station)
elif options.latitude and options.longitude:
nearby_stations, distances = get_nearby(options)
station_ids = nearby_stations
else:
raise KeyError("Either --station or --lat, --lon required")
request = DWDStationRequest(
station_ids=station_ids,
parameter=read_list(options.parameter),
time_resolution=options.resolution,
period_type=read_list(options.period),
write_file=options.persist,
prefer_local=options.persist,
humanize_column_names=True,
tidy_data=True,
)
data = list(request.collect_data())
if not data:
log.error("No data available for given constraints")
sys.exit(1)
df = | pd.concat(data) | pandas.concat |
import pandas as pd
import os
import numpy as np
from matplotlib import pyplot as plt
import matplotlib.dates as mdates
from pandas.plotting import register_matplotlib_converters
register_matplotlib_converters()
root = '/Users/Gabe/Downloads/thesis spreadies'
# sg_1k_1k = pd.read_csv(os.path.join(root,'we_depletions_sg_SWHC1000_INIDEP1000_timeseries.csv'), parse_dates=True)
# sg_600_600 = pd.read_csv(os.path.join(root, 'we_depletions_sg_SWHC600_INIDEP600_timeseries.csv'), parse_dates=True)
# sg_600_300 = pd.read_csv(os.path.join(root,'we_depletions_sg_SWHC600_INIDEP300_timeseries.csv'), parse_dates=True)
# sg_600_150 = pd.read_csv(os.path.join(root, 'we_depletions_sg_SWHC600_INIDEP150_timeseries.csv'), parse_dates=True)
#
# sg_300_300 = pd.read_csv(os.path.join(root, 'we_depletions_sg_SWHC300_INIDEP300_timeseries.csv'), parse_dates=True)
# sg_300_150 = pd.read_csv(os.path.join(root,'we_depletions_sg_SWHC300_INIDEP150_timeseries.csv'), parse_dates=True)
# sg_300_0 = pd.read_csv(os.path.join(root, 'we_depletions_sg_SWHC300_INIDEP0_timeseries.csv'), parse_dates=True)
#
# sg_150_150 = pd.read_csv(os.path.join(root, 'we_depletions_sg_SWHC150_INIDEP150_timeseries.csv'), parse_dates=True)
# sg_150_75 = pd.read_csv(os.path.join(root,'we_depletions_sg_SWHC150_INIDEP75_timeseries.csv'), parse_dates=True)
# sg_150_0 = pd.read_csv(os.path.join(root, 'we_depletions_sg_SWHC150_INIDEP0_timeseries.csv'), parse_dates=True)
#
# print sg_1k_1k.head()
#
# vcm_600_600 = pd.read_csv(os.path.join(root,'we_depletions_vcm_SWHC600_INIDEP600_timeseries.csv'), parse_dates=True)
# vcm_600_300 = pd.read_csv(os.path.join(root,'we_depletions_vcm_SWHC600_INIDEP300_timeseries.csv'), parse_dates=True)
# vcm_600_150 = pd.read_csv(os.path.join(root,'we_depletions_vcm_SWHC600_INIDEP150_timeseries.csv'), parse_dates=True)
# vcm_300_300 = pd.read_csv(os.path.join(root, 'ext_we_depletions_vcm_SWHC300_INIDEP300.csv'), parse_dates=True)
# vcm_300_150 = pd.read_csv(os.path.join(root,'ext_we_depletions_vcm_SWHC300_INIDEP150.csv'), parse_dates=True)
# vcm_300_0 = pd.read_csv(os.path.join(root, 'ext_we_depletions_vcm_SWHC300_INIDEP0.csv'), parse_dates=True)
# plt.plot([1,2,3], [3, 5,7])
# plt.show()
vcm_600_600 = pd.read_csv(os.path.join(root, 'ext_we_depletions_vcm_SWHC600_INIDEP600.csv'), parse_dates=True)
vcm_600_300 = pd.read_csv(os.path.join(root, 'ext_we_depletions_vcm_SWHC600_INIDEP300.csv'), parse_dates=True)
vcm_600_000 = pd.read_csv(os.path.join(root, 'ext_we_depletions_vcm_SWHC600_INIDEP0.csv'), parse_dates=True)
vcm_300_300 = pd.read_csv(os.path.join(root, 'ext_we_depletions_vcm_SWHC300_INIDEP300.csv'), parse_dates=True)
vcm_300_150 = pd.read_csv(os.path.join(root, 'ext_we_depletions_vcm_SWHC300_INIDEP150.csv'), parse_dates=True)
vcm_300_000 = pd.read_csv(os.path.join(root, 'ext_we_depletions_vcm_SWHC300_INIDEP0.csv'), parse_dates=True)
sg_600_600 = pd.read_csv(os.path.join(root, 'ext_we_depletions_sg_SWHC600_INIDEP600.csv'), parse_dates=True)
sg_600_300 = pd.read_csv(os.path.join(root, 'ext_we_depletions_sg_SWHC600_INIDEP300.csv'), parse_dates=True)
sg_600_000 = pd.read_csv(os.path.join(root, 'ext_we_depletions_sg_SWHC600_INIDEP0.csv'), parse_dates=True)
sg_300_300 = pd.read_csv(os.path.join(root, 'ext_we_depletions_sg_SWHC300_INIDEP300.csv'), parse_dates=True)
sg_300_150 = pd.read_csv(os.path.join(root, 'ext_we_depletions_sg_SWHC300_INIDEP150.csv'), parse_dates=True)
sg_300_000 = pd.read_csv(os.path.join(root, 'ext_we_depletions_sg_SWHC300_INIDEP0.csv'), parse_dates=True)
sg_150_150 = pd.read_csv(os.path.join(root, 'ext_we_depletions_sg_SWHC150_INIDEP150.csv'), parse_dates=True)
sg_150_075 = pd.read_csv(os.path.join(root,'ext_we_depletions_sg_SWHC150_INIDEP75.csv'), parse_dates=True)
sg_150_000 = pd.read_csv(os.path.join(root, 'ext_we_depletions_sg_SWHC150_INIDEP0.csv'), parse_dates=True)
sg_50_050 = pd.read_csv(os.path.join(root, 'ext_we_depletions_sg_SWHC50_INIDEP50.csv'), parse_dates=True)
sg_50_025 = pd.read_csv(os.path.join(root,'ext_we_depletions_sg_SWHC50_INIDEP25.csv'), parse_dates=True)
sg_50_000 = pd.read_csv(os.path.join(root, 'ext_we_depletions_sg_SWHC50_INIDEP0.csv'), parse_dates=True)
vcm_150_150 = pd.read_csv(os.path.join(root, 'ext_we_depletions_sg_SWHC150_INIDEP150.csv'), parse_dates=True)
vcm_150_075 = pd.read_csv(os.path.join(root,'ext_we_depletions_sg_SWHC150_INIDEP75.csv'), parse_dates=True)
vcm_150_000 = pd.read_csv(os.path.join(root, 'ext_we_depletions_sg_SWHC150_INIDEP0.csv'), parse_dates=True)
# # plt.plot([1,2,3], [3, 5,7])
# # plt.show()
#
# vcm_600_600 = pd.read_csv(os.path.join(root,'we_depletions_vcm_SWHC600_INIDEP600_timeseries.csv'), parse_dates=True)
# vcm_600_300 = pd.read_csv(os.path.join(root,'we_depletions_vcm_SWHC600_INIDEP300_timeseries.csv'), parse_dates=True)
# vcm_600_150 = pd.read_csv(os.path.join(root,'we_depletions_vcm_SWHC600_INIDEP150_timeseries.csv'), parse_dates=True)
#
# vcm_300_300 = pd.read_csv(os.path.join(root, 'we_depletions_vcm_SWHC300_INIDEP300_timeseries.csv'), parse_dates=True)
# vcm_300_150 = pd.read_csv(os.path.join(root,'we_depletions_vcm_SWHC300_INIDEP150_timeseries.csv'), parse_dates=True)
# vcm_300_0 = pd.read_csv(os.path.join(root, 'we_depletions_vcm_SWHC300_INIDEP0_timeseries.csv'), parse_dates=True)
# print(sg_600_600['date'])
#
# plt.plot(sg_600_150['date'], sg_600_150['depletion'], label='sg')
# # plt.grid()
# plt.legend()
# plt.show()
# # plt.savefig(os.path.join(root, 'testfig.png'))
years = mdates.YearLocator()
months = mdates.MonthLocator()
years_fmt = mdates.DateFormatter('%Y')
### ===== SG 50 ======
fig, (ax1, ax2) = plt.subplots(nrows=2, sharey=False, sharex=True)
ax1.plot(pd.to_datetime(sg_50_000['date']), sg_50_000['depletion'], color='r', label='swhc_50_inidep_000', linewidth=5)
ax1.plot(pd.to_datetime(sg_50_025['date']), sg_50_025['depletion'], color='b', label='swhc_50_inidep_025', linewidth=3)
ax1.plot(pd.to_datetime(sg_50_050['date']), sg_50_050['depletion'], color='g', label='swhc_50_inidep_050', linewidth=1)
ax1.set_xlabel('Date')
ax1.set_ylabel('Depletion (mm)')
ax1.set_title('Depletion with Given SWHC and Initial Depletion - Sevilleta')
ax1.legend()
ax1.grid()
ax2.plot(pd.to_datetime(sg_50_000['date']), sg_50_000['recharge_ro'], color='r', label='swhc_50_inidep_000', linewidth=3)
ax2.plot(pd.to_datetime(sg_50_025['date']), sg_50_025['recharge_ro'], color='b', label='swhc_50_inidep_025', linewidth=2)
ax2.plot(pd.to_datetime(sg_50_050['date']), sg_50_050['recharge_ro'], color='g', label='swhc_50_inidep_050', linewidth=1)
ax2.set_xlabel('Date')
ax2.set_ylabel('Recharge (mm)')
ax2.legend()
ax2.grid()
ax2.set_title('Recharge with Given SWHC and Initial Depletion - Sevilleta')
plt.subplots_adjust(hspace=1)
plt.show()
### ===== vcm 150 ======
fig, (ax1, ax2) = plt.subplots(nrows=2, sharey=False, sharex=True)
ax1.plot(pd.to_datetime(vcm_150_000['date']), vcm_150_000['depletion'], color='r', label='swhc_150_inidep_000', linewidth=5)
ax1.plot(pd.to_datetime(vcm_150_075['date']), vcm_150_075['depletion'], color='b', label='swhc_150_inidep_075', linewidth=3)
ax1.plot(pd.to_datetime(vcm_150_150['date']), vcm_150_150['depletion'], color='g', label='swhc_600_inidep_150', linewidth=1)
ax1.set_title('Depletion with Given SWHC and Initial Depletion - <NAME>')
ax1.grid()
ax1.legend()
ax2.plot(pd.to_datetime(vcm_150_000['date']), vcm_150_000['recharge_ro'], color='r', label='swhc_150_inidep_000', linewidth=5)
ax2.plot(pd.to_datetime(vcm_150_075['date']), vcm_150_075['recharge_ro'], color='b', label='swhc_150_inidep_075', linewidth=3)
ax2.plot( | pd.to_datetime(vcm_150_150['date']) | pandas.to_datetime |
# flask imports
from datetime import datetime
from eve.auth import requires_auth
from eve.render import send_response
from flask import request, abort, Blueprint, g, Response
from flask import current_app as app
# utils imports
import numpy as np
import pandas as pd
from auth.authentication import EVETokenAuth
edinet_methods = Blueprint('edinet_methods', __name__)
"""
EVE docs has been modified to add desired blueprints function to the "API DOC". To use it:
1. The method's name must start with "api_"
2. Docstring to the function with the json:
{
"doc": {
"title": "title",
"body": "body",
},
#for each method i.e GET (optional, if not provided, default from the function signature will be used)
"GET": {
"label": "information of GET method",
"params" [{"name": "first_param", "type": "type", "required":"false", "doc":"aditional_info", "**kwargs": "more_inofo"},..]
}
}
"""
@edinet_methods.route("/league_table_summarised/<leagueTableId>", methods=['GET'])
@requires_auth(EVETokenAuth)
def api_get_league_table_summarised(leagueTableId):
"""
{
"doc": {
"title": "league table summarised help",
"body": "<p> Obtain the sumarized of the league table </p>"
},
"GET": {
"label": "Obtain the league_table sumarized",
"params":[{"name": "leagueTableId", "type":"string", "required":"true", "doc":"id of the leage_table"},
{"name": "period", "type":"string", "required":"false", "info":"the period to sumarize", "values": ["D", "W", "M", "Y"]},
{"name": "type", "type":"list", "required":"false", "info":"the field to sumarize"}]
}
}
"""
companyId = g.get("auth_value")
# params from url
period = request.args.get('period', 'M')
type = request.args.get('type', ['savings', 'smileys'])
if not isinstance(type, list):
type = type.split(',') # type=savings,smileys in the url
periodsAllowed = ['D', 'W', 'M', 'Y'] # Weekly means Monday to Sunday
period = period[0].upper()
# recupero la info de mongo
query = {'companyId': companyId, 'leagueTableId': leagueTableId}
doc = app.data.driver.db['league_table'].find_one(query, {'_id': 0}, timeout=False)
try:
reporting_Units = doc['reporting_Units']
except:
reporting_Units = []
# recupero la info de mongo de baseline i creo el resultat per cadascu
res_report = {}
for reportingUnit in reporting_Units:
query_reporting = {'companyId': companyId, 'reportingUnitId': reportingUnit}
doc_reporting = app.data.driver.db['reporting_units'].find_one(query_reporting, timeout=False)
if doc_reporting:
modelling_Units = doc_reporting['modelling_Units']
res_report[reportingUnit] = []
for modelUnit in modelling_Units:
# update_baseline(companyId, modellingUnitId) # TO DO
query_baseline = {'companyId': companyId, 'modellingUnitId': modelUnit}
doc_baseline = app.data.driver.db['baselines'].find_one(query_baseline,
{'prediction': 1, 'values': 1, 'smileys': 1,
'timestamps': 1}, timeout=False)
if doc_baseline:
res_parcial = {}
# creo el dataframe
df = pd.DataFrame.from_records(
{'values': doc_baseline['values'], 'smileys': doc_baseline['smileys'],
'prediction': doc_baseline['prediction'], 'timestamps': doc_baseline['timestamps']})
df = df.set_index(pd.DatetimeIndex(df['timestamps']))
if df.empty != True and period in periodsAllowed:
for typ in type:
if typ in doc_baseline.keys() or typ == 'savings':
if typ in ['savings', 'values', 'prediction']:
df_grouped = df.groupby(pd.TimeGrouper(freq=period)).sum()
else:
df_grouped = df.groupby(pd.TimeGrouper(freq=period)).mean()
if typ == 'savings':
res_parcial[typ] = df_grouped['prediction'] - df_grouped['values']
else:
res_parcial[typ] = df_grouped[typ]
res_parcial[typ] = res_parcial[typ].where(( | pd.notnull(res_parcial[typ]) | pandas.notnull |
# -*- coding: utf-8 -*-
"""
Created on Tue Mar 26 14:02:03 2019
@author: <NAME>
"""
import pandas as pd
from pandas import ExcelWriter
from fuzzywuzzy import fuzz
from fuzzywuzzy import process
def match2Lists(list1,list2):
"""
Loops over a list and returns fuzzy matches found in a second list.
Inputs:
list1 - list of terms to search for in the master list
list2 - master list that is searched for matches over and over
"""
TopMatch = []
TopScore = []
TopRowIdx = []
for member in list1:
x=process.extractOne(member, list2)
TopMatch.append(x[0])
TopScore.append(x[1])
TopRowIdx.append(x[2])
return TopMatch, TopScore, TopRowIdx
def createRUID_List(rowIdxList, headerStr):
"""
Loops over a series containing row indices and returns a list of RUID strings.
Inputs:
rowIdxList - collection of row index values
headerStr - DataFrame header string value for column containing RUIDs
Outputs:
new list containing RUID strings
"""
RUID_List = []
for aRowIdx in rowIdxList:
workingRUID=df[headerStr].iloc[aRowIdx]
RUID_List.append(workingRUID)
return RUID_List
df = pd.read_excel("abcd_rucdr_master_forPython.xlsx")
print ('Finished reading in input file.')
#blackList=['NDAR_INV']
#for pattern in blackList:
# df['pGUID_Rutgers'] = df['pGUID_Rutgers'].replace(pattern, '')
#datasets
Mismatch_DAIC_IDs = df.iloc[1949:2201,0].dropna()
print (Mismatch_DAIC_IDs)
Mismatch_Rutgers_IDs = df.iloc[1949:2201,1].dropna()
print (Mismatch_Rutgers_IDs)
Unique_DAIC_IDs = df.iloc[1403:1948,0].dropna()
print (Unique_DAIC_IDs)
Unique_Rutgers_IDs = df.iloc[0:1403,1].dropna()
print (Unique_Rutgers_IDs)
AllRutgersIDs = df['rucdr.SUBCODE'].dropna()
AllDAIC_IDs = df['abcd.id_redcap'].dropna()
print ('About to start first match2collections.')
BestMatch_Mismatch_DtoR, BestScore_Mismatch_DtoR, BestRowIdx_Mismatch_DtoR = match2Lists(Mismatch_DAIC_IDs,AllRutgersIDs)
print ('Just finished first match2collections.')
print ('About to start second match2collections.')
BestMatch_Mismatch_RtoD, BestScore__Mismatch_RtoD, BestRowIdx_Mismatch_RtoD = match2Lists(Mismatch_Rutgers_IDs, AllDAIC_IDs)
print ('Just finished second match2collections.')
print ('About to start third match2collections.')
BestMatch_Unique_DtoR, BestScore_Unique_DtoR, BestRowIdx_Unique_DtoR = match2Lists(Unique_DAIC_IDs, AllRutgersIDs)
print ('Just finished third match2collections.')
print ('About to start fourth match2collections.')
BestMatch_Unique_RtoD, BestScore_Unique_RtoD, BestRowIdx_Unique_RtoD = match2Lists(Unique_Rutgers_IDs, AllDAIC_IDs)
print ('Just finished fourth match2collections.')
df['BestMatchdf_Mismatch_DtoR']=pd.Series(BestMatch_Mismatch_DtoR)
df['BestScoredf_Mismatch_DtoR']=pd.Series(BestScore_Mismatch_DtoR)
df['BestRowIdxdf_Mismatch_DtoR']=pd.Series(BestRowIdx_Mismatch_DtoR)
df['BestMatchdf_Mismatch_RtoD']=pd.Series(BestMatch_Mismatch_RtoD)
df['BestScoredf_Mismatch_RtoD']=pd.Series(BestScore__Mismatch_RtoD)
df['BestRowIdxdf_Mismatch_RtoD']=pd.Series(BestRowIdx_Mismatch_RtoD)
df['BestMatchdf_Unique_DtoR']= | pd.Series(BestMatch_Unique_DtoR) | pandas.Series |
# coding=utf-8
# Author: <NAME> & <NAME>
# Date: Jan 06, 2021
#
# Description: Parse Epilepsy Foundation Forums and extract dictionary matches
#
import os
import sys
#
#include_path = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, os.pardir, 'include'))
include_path = '/nfs/nfs7/home/rionbr/myaura/include'
sys.path.insert(0, include_path)
#
import pandas as pd
pd.set_option('display.max_rows', 100)
pd.set_option('display.max_columns', 500)
| pd.set_option('display.width', 1000) | pandas.set_option |
"""A module to store some results that are parsed from .txt files."""
import os
from configparser import ConfigParser
from types import SimpleNamespace
import pandas as pd
import numpy as np
from skm_pyutils.py_table import list_to_df
from dictances.bhattacharyya import bhattacharyya
from .main import main as ctrl_main
here = os.path.dirname(os.path.abspath(__file__))
def parse_cfg(name):
"""Parse the configs at configs/name."""
cfg_path = os.path.join(here, "..", "configs", name)
cfg = ConfigParser()
cfg.read(cfg_path)
return cfg
def df_from_dict(dict, cols):
"""Form a dataframe from a dictionary with cols, keys are considered an entry."""
vals = []
for k, v in dict.items():
vals.append([k, v])
df = pd.DataFrame(vals, columns=cols)
return df
def store_region_results():
np.random.seed(42)
vals = []
names = [
"Tetrode CA3 CA1",
"MOp to SSp-ll",
"Figure 1 E",
"Max distance 3",
"Figure 1 A",
]
mean_vals = [
0.4248 / 5.0,
6.7371 / 79.0,
8.512 / 20.0,
8.86 / 25.0,
0.7340 / 3.0,
]
stats_vals = [
0.4117 / 5.0,
6.20478 / 79.0,
8.511 / 20.0,
9.27 / 25.0,
0.7346 / 3.0,
]
for i in range(len(names)):
vals.append([names[i], mean_vals[i], "Monte Carlo simulation"])
vals.append([names[i], stats_vals[i], "Statistical estimation"])
cols = ["Connectivity", "Expected proportion connected", "Calculation"]
df = | pd.DataFrame(vals, columns=cols) | pandas.DataFrame |
from aggregate.decennial_census.decennial_census_001020 import decennial_census_001020
from aggregate.aggregation_helpers import order_aggregated_columns
import pandas as pd
from internal_review.set_internal_review_file import set_internal_review_files
from utils.PUMA_helpers import clean_PUMAs, puma_to_borough
dcp_pop_races = ["anh", "bnh", "hsp", "onh", "wnh"]
race_labels = ["", "_wnh", "_bnh", "_hsp", "_anh", "_onh"]
pop_labels = ["Total Population", "White", "Black", "Hispanic", "Asian", "Other"]
def nycha_tenants(geography: str, write_to_internal_review=False):
assert geography in ["citywide", "borough", "puma"]
clean_data = load_clean_nycha_data()
census20 = decennial_census_001020(
geography=geography, year="1519"
) # this is in fact pulling 2020 census but design has it mapped from 1519 to 2020
if geography == "puma":
final = get_percentage( | pd.concat([census20, clean_data], axis=1) | pandas.concat |
"""
Contains the machine learning code for Taxonomist
Authors:
<NAME> (1), <NAME> (1), <NAME> (1), <NAME> (2),
<NAME> (2), <NAME> (1), <NAME> (1)
Affiliations:
(1) Department of Electrical and Computer Engineering, Boston University
(2) Sandia National Laboratories
This work has been partially funded by Sandia National Laboratories. Sandia
National Laboratories is a multimission laboratory managed and operated by
National Technology and Engineering Solutions of Sandia, LLC., a wholly owned
subsidiary of Honeywell International, Inc., for the U.S. Department of
Energy’s National Nuclear Security Administration under Contract DENA0003525.
"""
import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from sklearn.multiclass import OneVsRestClassifier
from sklearn.utils.validation import check_is_fitted
def generate_features(timeseries, feature_tuples, trim=60):
""" Generate features from timeseries
Parameters
----------
timeseries : pd.DataFrame[time, metric]
DataFrame of metrics over time.
feature_tuples : Iterable[(feature_name, feature_function)]
List of feature name strings and feature functions.
trim : int
The amount of time to trim from both ends to remove startup and
finalization steps.
Returns
-------
features : Array[metric * feature_types]
The calculated list of features.
"""
if trim != 0:
timeseries = timeseries[trim:-trim]
features = []
for col in timeseries.columns:
for name, func in feature_tuples:
features.append(pd.Series(
name=name + '_' + col,
data=func(timeseries[col])
))
return pd.concat(features, axis=1)
class Taxonomist(OneVsRestClassifier):
""" The main class implementing Taxonomist
Parameters
----------
estimator : estimator object
The main estimator that the classifier is going to use.
n_jobs : int
Number of parallel processes to use.
threshold : float
The confidence threshold.
"""
def __init__(self, estimator, n_jobs=1, threshold=0.9):
self.threshold = threshold
self.scaler = MinMaxScaler()
super().__init__(estimator, n_jobs)
def fit(self, X, y):
norm_X = self.scaler.fit_transform(X)
super().fit(norm_X, y)
def decision_function(self, X):
""" Reports the distance from the decision boundary
for classifiers that support it.
We need to override the `decision_function` from scikit-learn because
we need a likelihood estimate for classifiers that only report
`predict_proba`. After pull request
[#10612](https://github.com/scikit-learn/scikit-learn/pull/10612)
is merged, we can use the normal `decision_function` from sklearn.
"""
check_is_fitted(self, 'estimators_')
if len(X) == 0:
return pd.DataFrame(data=[], index=X.index, columns=self.classes_)
try:
T = np.array([est.decision_function(X).ravel()
for est in self.estimators_]).T
except AttributeError:
T = np.array([e.predict_proba(X)[:, 1] * 2 - 1
for e in self.estimators_]).T
if len(self.estimators_) == 1:
T = T.ravel()
return | pd.DataFrame(data=T, columns=self.classes_, index=X.index) | pandas.DataFrame |
# python3
# coding: utf-8
# import threading
import openpyxl as px
import pandas as pd
from helper_Word import helper_Word
from Docx_to_pdf import Docx_to_PDF
from PDF_Combiner import Combine_PDF
from shutil import copyfile
import os
# from collections import OrderedDict
import time
import json_helper
# import Excel_to_Word_in_arbeit
# from helper_Word import helper_Word as hw
__version__ = "0.0.16"
__author__ = "<NAME>"
__repo__ = r"https://github.com/StefanHol/SchoolReport_Excel2Word2PDF"
__config_json__ = "config.json"
__Anleitung__ = "SchoolReport Excel2Word2PDF.pdf"
# rebuild_GUI = True
rebuild_GUI = False
# # ToDo: Add certificate
# # Could not find a suitable TLS CA certificate bundle, invalid path
# # https://github.com/pyinstaller/pyinstaller/issues/6352
used_Qt_Version = 0
try:
from PyQt5.QtWidgets import QMainWindow, QInputDialog, QMessageBox
from PyQt5.QtWidgets import QWidget, QComboBox, QCheckBox, QLineEdit, QFileDialog, QTableWidgetItem
from PyQt5.QtGui import QFont, QIcon, QPixmap
from PyQt5.QtWidgets import QTableView, QAbstractItemView, QCompleter, QLineEdit, QHeaderView
from PyQt5.QtCore import QAbstractTableModel, Qt
used_Qt_Version = 5
except Exception as e:
print(e)
exit()
pass
def compile_GUI():
if used_Qt_Version == 4:
print("Compile QUI for Qt Version: " + str(used_Qt_Version))
os.system("pyuic4 -o GUI\Converter_ui.py GUI\Converter.ui")
elif used_Qt_Version == 5:
print("Compile QUI for Qt Version: " + str(used_Qt_Version))
os.system("pyuic5 -o GUI\Converter_ui.py GUI\Converter.ui")
if rebuild_GUI:
compile_GUI()
from GUI.Converter_ui import Ui_MainWindow
import logging
logging.basicConfig(level=logging.WARNING)
class PandasModel(QAbstractTableModel):
"""
Class to populate a table view with a pandas dataframe
https://stackoverflow.com/questions/31475965/fastest-way-to-populate-qtableview-from-pandas-data-frame
"""
def __init__(self, data, parent=None):
QAbstractTableModel.__init__(self, parent)
self._data = data
logger = logging.getLogger(__name__)
logger.debug("init Pandas Model")
def rowCount(self, parent=None):
return self._data.shape[0]
def columnCount(self, parent=None):
return self._data.shape[1]
def data(self, index, role=Qt.DisplayRole):
if index.isValid():
if role == Qt.DisplayRole:
return str(self._data.iloc[index.row(), index.column()])
return None
def headerData(self, col, orientation, role):
if orientation == Qt.Horizontal and role == Qt.DisplayRole:
return self._data.columns[col]
return None
class create_letter_of_reference():
def __init__(self):
self.logger = logging.getLogger("SR_E2W2P.create_letter_of_reference")
self.logger.info("init create_letter_of_reference")
self.Array_CheckBox_Namen = None
self.Text_Feld_Namen = None
self.wb = None
self.df = None
self.srcFileName = ""
self.destination_Folder = ""
self.Excel_Filename = ""
self.wichtige_meldung = ""
def read_word_information_fields(self, srcFileName):
self.srcFileName = srcFileName
self.logger.info("read_word_information_fields")
word_doc = helper_Word()
word_doc.init_file(srcFileName, False)
self.logger.info("get_all_fieldnames_from_word")
word_doc.get_all_fieldnames_from_word()
self.logger.info("find_arrays_and_text_field_names")
word_doc.find_arrays_and_text_field_names()
self.logger.info("find_arrays_and_text_field_names: done")
self.Array_CheckBox_Namen = word_doc.Text_FieldArray_Row_Names
self.Text_Feld_Namen = word_doc.Text_Field_Names
self.logger.info("Array_CheckBox_Namen:")
self.logger.info(self.Array_CheckBox_Namen)
self.logger.info("Text_Feld_Namen:")
self.logger.info(self.Text_Feld_Namen)
try:
word_doc.doc.Close()
self.logger.info("Word Document Closed")
except Exception as e:
self.logger.error(e)
return self.Array_CheckBox_Namen, self.Text_Feld_Namen
def read_excel_file_to_pandas(self, Excel_Filename):
self.logger.debug("read_excel_file_to_pandas")
# print("Excel_Filename")
self.Excel_Filename = Excel_Filename
# print("self.Excel_Filename: ", self.Excel_Filename)
self.wb = px.load_workbook(self.Excel_Filename, data_only=True)
self.logger.info("loaded Excel File: {}".format(Excel_Filename))
self.logger.info("Array_CheckBox_Namen\n{}".format(self.Array_CheckBox_Namen))
self.df = self.create_dataframe_for_InputFields(self.Array_CheckBox_Namen, self.Text_Feld_Namen)
# print("self.df", self.df)
self.df = self.remove_empty_data(self.df)
self.logger.debug("self.df {}".format(self.df))
return self.df
def get_values_By_range_name(self, range_name):
value_array = []
self.logger.debug("check: {}".format(range_name))
try:
address = list(self.wb.defined_names[range_name].destinations)
# address
for sheetname, cellAddress in address:
cellAddress = cellAddress.replace('$', '')
cellAddress
worksheet = self.wb[sheetname]
for i in range(0, len(worksheet[cellAddress])):
for item in worksheet[cellAddress][i]:
# print(item.value)
value_array.append(item.value)
except Exception as e:
self.logger.error("Error: Textfeld {} ist in Worddokument definiert,".format(range_name) +
"kann aber nicht im Exceldokument gefunden werden.\n{}".format(e))
self.wichtige_meldung = ("Warnung: Textfeld {} ist in Worddokument definiert,".format(range_name) +
"kann aber nicht im Exceldokument gefunden werden.\n{}\n".format(e) +
"Vorlagen überprüfen!\nDie entsprechenden Daten werden nicht übertragen.\n")
return value_array
def create_folder_if_not_exist(self, folder):
if not os.path.exists(folder):
os.mkdir(folder)
def ExtractFileName(self, mypath):
name = mypath.split(os.path.sep)
return name[len(name) - 1]
def zahl_zu_bewertung(self, value):
if str(value) == "1":
return "sehr gut"
if str(value) == "2":
return "gut"
if str(value) == "3":
return "schlecht"
if str(value) == "4":
return "sehr schlecht"
def Copy_word_file_and_write_data(self, df, targetname, df_index):
# copy File and create target file object
self.create_folder_if_not_exist(self.destination_Folder)
FileName = self.srcFileName.replace(".docx", "_-_" + (df["Name"].iloc[df_index]).replace(" ", "_") + ".docx")
FileName = self.ExtractFileName(
self.srcFileName.replace(".docx", "_-_" + (df["Name"].iloc[df_index]).replace(" ", "_") + ".docx"))
# dstFileName = srcFileName.replace(".docx", "_-_" + (df["Name"].iloc[df_index]).replace(" ", "_") + ".docx")
logging.info(FileName)
dstFileName = self.destination_Folder + os.path.sep + FileName
# print(srcFileName,"\n"+ dstFileName)
copyfile(self.srcFileName, dstFileName)
# wordFile.doc.Close()
wordFile = helper_Word()
wordFile.init_file(dstFileName, False)
self.logger.info(FileName)
for ColumnName in df:
# print(df["Name"].iloc[df_index], ":\t",ColumnName , "\t", df[ColumnName].iloc[df_index])
# ToDo: Call Input Function here
SchülerName = df["Name"].iloc[df_index]
ZellenNameOderArray = ColumnName
Cellen_Oder_Array_Wert = df[ColumnName].iloc[df_index]
self.logger.info("Name: {} \t {} \t {}".format(SchülerName, ColumnName, Cellen_Oder_Array_Wert))
# ToDo: Call Input Function here
try:
counter = 0
for TextElement in self.Text_Feld_Namen:
# print(counter)
# print(TextElement)
counter += 1
outputText = df[TextElement].iloc[df_index]
try:
try:
self.logger.info("int: TextElement {} {}".format(TextElement, int(outputText)))
outputText = int(outputText)
except Exception as e:
self.logger.info("str: TextElement {} {}".format(TextElement, str(outputText)))
outputText = str(outputText)
# print(e, str(outputText), str(TextElement))
wordFile.set_WordField_Text(TextElement, str(outputText))
self.logger.info("TextElement {} {}".format(TextElement, wordFile.get_WordField_Text(TextElement)))
except Exception as e:
self.logger.debug("{} {} {}".format(e, str(outputText), str(TextElement)))
# print(e, str(outputText), str(TextElement))
counter = 0
for ArrayElement in self.Array_CheckBox_Namen:
# print(counter)
counter += 1
outputText = df[ArrayElement].iloc[df_index]
#########################################################################
# Noten CheckBox und Text
# korrigieren
#########################################################################
SetCheckBox = False
realerror = True
error_message = ""
try:
outputText = int(outputText)
self.logger.debug("int: ArrayElement {} {}".format(outputText, ArrayElement))
self.logger.debug(str(ArrayElement) + " = " + self.zahl_zu_bewertung(outputText))
realerror = False
except Exception as e:
try:
outputText = str(outputText)
self.logger.debug("str: ArrayElement {} {}".format(outputText, ArrayElement))
self.logger.debug(str(ArrayElement) + " = " + self.zahl_zu_bewertung(outputText))
realerror = False
except Exception as e:
realerror = True
self.logger.debug("{} try of try outputText: {} {}".format(e, ArrayElement, outputText))
error_message = "{}: try of try outputText: {}, {}".format(e, ArrayElement, outputText)
# print(e, ArrayElement, outputText)
pass
try:
if not (outputText is None):
CheckBox = ArrayElement + str(outputText - 1)
SetCheckBox = True
realerror = False
else:
self.logger.debug("Skip Checkbox: {} {}".format(outputText, ArrayElement))
pass
except Exception as e:
realerror = True
self.logger.debug("tryexcept 2: {} {} {}".format(e, outputText, ArrayElement))
error_message = "warning: nichts in checkbox eingetragen {}, {}, {}".format(e, outputText,
ArrayElement)
SetCheckBox = False
# print(CheckBox)
if SetCheckBox:
realerror = False
wordFile.check_checkbox(CheckBox)
# save & close target file here
if realerror:
self.logger.debug("Hinweis: {}".format(error_message))
except Exception as e:
self.logger.error("Fehler hier: {}".format(e))
finally:
try:
wordFile.save_and_close()
except Exception as e:
print(e)
return FileName
def create_wordDocxs_from_dataframe(self, df):
# print(df.head())
if True:
start_time = time.time()
file_name_list = []
for index in range(len(df)):
# print(index)
# #ToDo: Call Input Function here
self.logger.debug(str(df["Name"].iloc[index]))
file_name = self.Copy_word_file_and_write_data(df, df["Name"].iloc[index], index)
file_name_list.append(file_name)
if True:
self.logger.info("Creation takes %.2f seconds" % (time.time() - start_time))
# print("create_wordDocxs_from_dataframe", file_name_list)
return file_name_list
def create_dataframe_for_InputFields(self, Array_CheckBox_Namen, Text_Feld_Namen):
self.logger.debug("create_dataframe_for_InputFields")
df = | pd.DataFrame({}) | pandas.DataFrame |
import os
import time
import pickle
import numpy as np
import pandas as pd
from scipy import stats
from IPython.display import display
# Base classes
from sklearn.base import ClassifierMixin, TransformerMixin
# Random search & splitting
from sklearn.model_selection import RandomizedSearchCV, train_test_split
# Classifiers
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import BaggingClassifier
from xgboost import XGBClassifier
# Transformers
from sklearn.preprocessing import MinMaxScaler, StandardScaler
from sklearn.preprocessing import FunctionTransformer
# Metrics
from sklearn.metrics import make_scorer, accuracy_score, f1_score, roc_auc_score
# transformers
from twitter_utils import twitter_feature_generation_transformer, twitter_feature_selection_transformer
# custom scorer
def afr(y_true, y_pred, **kwargs):
"""The afr scoring function gives a weighted average of accuracy,
balanced F1 and roc_auc scores, with .2, .3 and .5 respectively.
"""
accuracy = accuracy_score(y_true, y_pred)
f1 = f1_score(y_true, y_pred, average="weighted")
roc_auc = roc_auc_score(y_true, y_pred, average="weighted")
return (accuracy * .2) + (f1 * .3) + (roc_auc * .5)
afr_scorer = make_scorer(afr, greater_is_better=True)
afr_scorer.name = 'afr'
def passthrough(df):
return df.copy()
passthrough_transformer = FunctionTransformer(passthrough)
# Base class for pipeline
class BinaryClassifierPipelineStep(TransformerMixin, ClassifierMixin):
def __init__(self, context={}):
self._context = context
def set_context(self, context):
self._context = context
return self
def get_fitted_classifiers(self):
return self._context._clfs
def get_best_classifier(self):
return self._context._best
def get_info(self):
return self._context._info
class DataSplitStep(BinaryClassifierPipelineStep):
"""
"""
def __init__(self, training_size=.64, validation_size=.16, splitting=None):
self._training = training_size
self._validation = validation_size
if callable(splitting):
self._splitter = splitting
else:
self._splitter = train_test_split
def transform(self, X, y):
t_size = self._training if isinstance(self._training, int) else int(len(X)*self._training)
X_tv, X_train, y_tv, y_train = self._splitter(X, y, test_size=t_size, random_state=42)
# Split remaing data into training and validation
t_size = self._validation if isinstance(self._validation, int) else int(len(X)*self._validation)
X_val, X_test, y_val, y_test = self._splitter(X_tv, y_tv, test_size=t_size, random_state=42)
return X_train, X_val, X_test, y_train, y_val, y_test
class FeatureEngineeringStep(BinaryClassifierPipelineStep):
"""
"""
def __init__(self, feature_generation=None, feature_selection=None, feature_scaling=None, context={}):
self._context = context
# Define the trasnformer to be used for feature generation
if callable(getattr(feature_generation, "transform", None)):
self._feature_generation = feature_generation
else:
self._feature_generation = twitter_feature_generation_transformer
# Define the trasnformer to be used for feature selection
if callable(getattr(feature_selection, "transform", None)):
self._feature_selection = feature_selection
else:
self._feature_selection = twitter_feature_selection_transformer
# The transformer used for feature scaling will be defined after the
# pipeline context is set
self._scaling = feature_scaling
def _setup(self):
# Define the transformer to be used for feature scaling
self._context._scaling = self._scaling
if self._scaling == 'min-max':
self._context._scaler = MinMaxScaler()
elif self._scaling == 'standard':
self._context._scaler = StandardScaler()
elif callable(getattr(self._scaling, "transform", None)):
self._context._scaling = getattr(self._scaling, "name", type(self._scaling))
self._context._scaler = self._scaling
else:
self._context._scaling = 'none'
self._context._scaler = passthrough_transformer
def fit_transform(self, X):
# Setup scaler on the pipeline context
self._setup()
# Run feature generation transform
X_t = self._feature_generation.transform(X)
# Run feature selection transform
X_t = self._feature_selection.transform(X_t)
# run feature scaling transform
return self._context._scaler.fit_transform(X_t)
def transform(self, X):
X_t = self._feature_generation.transform(X)
X_t = self._feature_selection.transform(X_t)
return self._context._scaler.transform(X_t)
class ModelTuningStep(BinaryClassifierPipelineStep):
def __init__(self, scoring=None, n_iter=20):
# Define number of iteractions for random search
self._n_iter = n_iter
# the scoring will be setup after context is set
self._scoring = scoring
# Setup must run after pipeline context is set
def _setup(self):
# Define the scoring function used in cross-validation
self._context._scoring = self._scoring
if self._scoring == 'roc_auc':
self._context._scorer = make_scorer(roc_auc_score)
elif self._scoring == 'f1':
self._context._scorer = make_scorer(f1_score)
elif self._scoring == 'accuracy':
self._context._scorer = make_scorer(accuracy_score)
elif callable(self._scoring):
self._context._scoring = getattr(self._scoring, "name", type(self._scoring))
self._context._scorer = self._scoring
else:
self._context._scoring = 'roc_auc'
self._context._scorer = make_scorer(roc_auc_score)
# Define the classifier's hyper-parameters search space used in
# the training and tuning step
self._context._clfs = {
'knn': {
'name': 'K-Nearest Neighbors',
'base': KNeighborsClassifier(),
'param_distributions': {
'n_neighbors': [int(x) for x in np.linspace(2, 50, num=20)],
'weights': ['uniform', 'distance'],
'algorithm': ['auto', 'ball_tree', 'kd_tree', 'brute']
}
},
'log_reg': {
'name': 'Logistic Regression',
'base': LogisticRegression(random_state=42),
'param_distributions': {
'penalty': ['l1', 'l2', 'elasticnet'],
'fit_intercept': [True, False],
'max_iter': [int(x) for x in np.linspace(100, 1000, num=20)]
}
},
'svm': {
'name': 'Support Vector Machines',
'base': SVC(random_state=42),
'param_distributions': {
'C': [round(x, 3) for x in np.linspace(0.1, 5, num=10)],
'kernel': ['linear', 'poly', 'rbf', 'sigmoid'],
'gamma': ['scale', 'auto']
}
},
'tree': {
'name': 'Decision Tree',
'base': DecisionTreeClassifier(random_state=42),
'param_distributions': {
"max_depth": [int(x) for x in np.linspace(1, 12, num=5)],
"max_features": [int(x) for x in np.linspace(1, 20, num=5)],
"min_samples_leaf": [int(x) for x in np.linspace(1, 200, num=20)],
"criterion": ["gini", "entropy"]
}
},
'rf': {
'name': 'Random Forest',
'base': RandomForestClassifier(random_state=42),
'param_distributions': {
'n_estimators': [int(x) for x in np.linspace(start=100, stop=1500, num=10)],
'max_features': [.5, 'sqrt', 'log2'],
'max_depth': [None] + [int(x) for x in np.linspace(5, 50, num=10)],
'min_samples_split': [2, 5, 10],
'min_samples_leaf': [1, 2, 4],
'bootstrap': [True, False]
}
},
'bagging': {
'name': 'Baggin',
'base': BaggingClassifier(random_state=42),
'param_distributions': {
"n_estimators": [int(x) for x in np.linspace(start=100, stop=1500, num=10)],
"max_samples": np.arange(start=0.1, stop=1.0, step=0.1)
}
},
'xgboost': {
'name': 'XGBoost',
'base': XGBClassifier(random_state=42, objective='binary:logistic'),
'param_distributions': {
'n_estimators': stats.randint(150, 1000),
'learning_rate': stats.uniform(0.01, 0.6),
'max_depth': [3, 4, 5, 6, 7, 8, 9]
}
}
}
return self
def fit(self, X_training, y_training):
# setup context objects
self._setup()
self._context._X_training = X_training
self._context._y_training = y_training
for clf in self._context._clfs:
# Load a previously fitted model
if self._context._save and os.path.isfile(f'output/models/{self._context._name}/{clf}.model'):
self._context._clfs[clf]['sclf'] = pickle.load(open(f'output/models/{self._context._name}/{clf}.model', 'rb'))
# or fit the model and save it for future use
else:
t = time.process_time()
sclf = RandomizedSearchCV(
self._context._clfs[clf]['base'],
self._context._clfs[clf]['param_distributions'],
random_state=42,
n_iter=self._n_iter,
cv=None,#self._cv,
scoring=self._context._scorer,
n_jobs=-1
).fit(X_training, y_training)
sclf.run_time = time.process_time() - t
if self._context._save:
if not os.path.exists(f'output/models/{self._context._name}'):
os.makedirs(f'output/models/{self._context._name}')
pickle.dump(sclf, open(f'output/models/{self._context._name}/{clf}.model', 'wb'))
self._context._clfs[clf]['sclf'] = sclf
return self
class ModelSelectionStep(BinaryClassifierPipelineStep):
def __init__(self, scoring=None):
self._scoring_p = scoring
def _setup(self):
# Define the scoring function used in cross-validation and model selection
self._scoring = self._scoring_p
if self._scoring_p == 'roc_auc':
self._scorer = make_scorer(roc_auc_score)
elif self._scoring_p == 'f1':
self._scorer = make_scorer(f1_score)
elif self._scoring_p == 'accuracy':
self._scorer = make_scorer(accuracy_score)
elif callable(self._scoring_p):
self._scoring = getattr(self._scoring_p, "name", type(self._scoring_p))
self._scorer = self._scoring_p
else:
self._scoring = self._context._scoring
self._scorer = self._context._scorer
def fit(self, X_valid, y_valid):
# setup scorer, after context is set
self._setup()
info = | pd.DataFrame() | pandas.DataFrame |
#!/usr/bin/env python
# coding: utf-8
# # EDA and Modeling Employee Attrition
# In[ ]:
# make sure we have the latest seaborb package
print()
# In[ ]:
# should be version 11
import seaborn as sns
sns.__version__
# In[ ]:
import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
import os
for dirname, _, filenames in os.walk("../../../input/patelprashant_employee-attrition"):
for filename in filenames:
print(os.path.join(dirname, filename))
# In[ ]:
df = | pd.read_csv("../../../input/patelprashant_employee-attrition/WA_Fn-UseC_-HR-Employee-Attrition.csv") | pandas.read_csv |
"""
PTC
---
Data handling for turn-by-turn measurement files from the ``PTC`` code, which can be obtained by performing
particle tracking of your machine through the ``MAD-X PTC`` interface. The files are very close in
structure to **TFS** files, with the difference that the data part is split into "segments" relating
containing data for a given observation point.
"""
import copy
import logging
from collections import namedtuple
from datetime import datetime
from pathlib import Path
from typing import Any, Dict, List, Sequence, Tuple, Union
import numpy as np
import pandas as pd
from dateutil import tz
from turn_by_turn.constants import (
COLPARTICLE,
COLTURN,
COLX,
COLY,
DATE,
HEADER,
NAMES,
PLANES,
SEGMENT_MARKER,
SEGMENTS,
TIME,
TIME_FORMAT,
TYPES,
)
from turn_by_turn.errors import PTCFormatError
from turn_by_turn.structures import TbtData, TransverseData
LOGGER = logging.getLogger()
Segment = namedtuple("Segment", ["number", "turns", "particles", "element", "name"])
def read_tbt(file_path: Union[str, Path]) -> TbtData:
"""
Reads turn-by-turn data from the ``PTC`` **trackone** format file.
Args:
file_path (Union[str, Path]): path to the turn-by-turn measurement file.
Returns:
A ``TbTData`` object with the loaded data.
"""
file_path = Path(file_path)
LOGGER.debug(f"Reading PTC trackone file at path: '{file_path.absolute()}'")
lines: List[str] = file_path.read_text().splitlines()
LOGGER.debug("Reading header from file")
date, header_length = _read_header(lines)
lines = lines[header_length:]
# parameters
bpms, particles, column_indices, n_turns, n_particles = _read_from_first_turn(lines)
# read into dict first for speed then convert to DFs
matrices = [{p: {bpm: np.zeros(n_turns) for bpm in bpms} for p in PLANES} for _ in range(n_particles)]
matrices = _read_data(lines, matrices, column_indices)
for bunch in range(n_particles):
matrices[bunch] = TransverseData(
X= | pd.DataFrame(matrices[bunch]["X"]) | pandas.DataFrame |
import logging
import random
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
from torch.nn import functional as F
from tqdm import tqdm
from beam_search import beam_decode
logger = logging.getLogger(__name__)
def set_seed(seed):
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
def top_k_logits(logits, k):
v, ix = torch.topk(logits, k)
out = logits.clone()
out[out < v[:, [-1]]] = -float('inf')
return out
def convert_weights(model: nn.Module):
"""Convert applicable model parameters to fp16"""
def _convert_weights_to_fp16(l):
if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)):
l.weight.data = l.weight.data.half()
if l.bias is not None:
l.bias.data = l.bias.data.half()
if isinstance(l, nn.MultiheadAttention):
for attr in [*[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]], "in_proj_bias", "bias_k", "bias_v"]:
tensor = getattr(l, attr)
if tensor is not None:
tensor.data = tensor.data.half()
for name in ["text_projection", "proj"]:
if hasattr(l, name):
attr = getattr(l, name)
if attr is not None:
attr.data = attr.data.half()
model.apply(_convert_weights_to_fp16)
def get_model_attr(mconf, tconf):
n_head = mconf.n_head
n_block = mconf.n_layer
nembd = mconf.n_embd
data = tconf.dataset[-20:-4]
model_attr = f"Head:{n_head}_Block{n_block}_nembd:{nembd}_data:{data}"
return model_attr
def set_plot_params():
## fonts
plt.rcParams['font.family'] = 'serif'
plt.rcParams['font.serif'] = 'Ubuntu'
plt.rcParams['font.monospace'] = 'Ubuntu mono'
plt.rcParams['axes.labelweight'] = 'bold'
# # font sizes
# plt.rcParams['font.size'] = 16
# plt.rcParams['axes.labelsize'] = 12
# plt.rcParams['xtick.labelsize'] = 10
# plt.rcParams['ytick.labelsize'] = 10
# plt.rcParams['legend.fontsize'] = 14
# plt.rcParams['figure.titlesize'] = 16
## colors
plt.rcParams['text.color'] = 'white'
plt.rcParams['axes.labelcolor'] = 'white'
plt.rcParams['xtick.color'] = 'white'
plt.rcParams['ytick.color'] = 'white'
plt.rcParams["figure.facecolor"] = '202020'
plt.rcParams['axes.facecolor']= '202020'
plt.rcParams['savefig.facecolor']= '202020'
def set_plot_white():
# Set the global font to be DejaVu Sans, size 10 (or any other sans-serif font of your choice!)
plt.rc('font',**{'family':'sans-serif','sans-serif':['DejaVu Sans'],'size':10})
# Set the font used for MathJax - more on this later
plt.rc('mathtext',**{'default':'regular'})
plt.rcParams['text.color'] = 'black'
plt.rcParams['axes.labelcolor'] = 'black'
plt.rcParams['xtick.color'] = 'black'
plt.rcParams['ytick.color'] = 'black'
plt.rcParams["figure.facecolor"] = 'white'
plt.rcParams['axes.facecolor']= 'white'
plt.rcParams['savefig.facecolor']= 'white'
def set_plot_black():
plt.rcParams['text.color'] = 'white'
plt.rcParams['axes.labelcolor'] = 'white'
plt.rcParams['xtick.color'] = 'white'
plt.rcParams['ytick.color'] = 'white'
plt.rcParams["figure.facecolor"] = '202020'
plt.rcParams['axes.facecolor']= '202020'
plt.rcParams['savefig.facecolor']= '202020'
def plot_losses(trainer):
plt.figure(figsize=(20,5))
# plotting train losses
plt.subplot(1,2,1)
plt.title('%s training losses' % str(trainer)[1:8])
for i, losses in enumerate(trainer.train_losses):
plt.plot(losses, label=i)
plt.legend(title="epoch")
# plotting testing losses
plt.subplot(1,2,2)
plt.title('%s testing losses' % str(trainer)[1:8])
for i, losses in enumerate(trainer.test_losses):
plt.plot(losses, label=i)
plt.legend(title="epoch")
plt.show()
def plot_losses_wattr(trainer, model_attr):
plt.figure(figsize=(20,5))
# plotting train losses
plt.subplot(1,2,1)
plt.title('%s training losses' % model_attr)
for i, losses in enumerate(trainer.train_losses):
plt.plot(losses, label=i)
plt.legend(title="epoch")
# plotting testing losses
plt.subplot(1,2,2)
plt.title('%s testing losses' % model_attr)
for i, losses in enumerate(trainer.test_losses):
plt.plot(losses, label=i)
plt.legend(title="epoch")
plt.show()
def print_full(df, length=None):
length = len(df) if length is None else len(df)
print(length)
pd.set_option('display.max_rows', length)
torch.set_printoptions(threshold=1e3)
print(df)
pd.reset_option('display.max_rows')
torch.set_printoptions(threshold=1e3)
# results = predict_raster_recursive_time_auto(model, loader, window, stoi, itos_dt, sample=True, top_p=0.95, top_p_t=0.95, frame_end=0, get_dt=True, gpu=False)
def process_predictions(results, stoi, window):
pred_keys = ['ID', 'dt', 'Trial', 'Interval']
predicted_dict = {k: results[k] for k in results if k in pred_keys}
df_pred = | pd.DataFrame(predicted_dict) | pandas.DataFrame |
# Copyright 2020 Google LLC
#
# 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 math
from random import shuffle
from pathlib import Path
from functools import partial
from typing import Any, Dict, List
import numpy
from pandas import DataFrame, Series, read_csv, concat
from lib.cast import safe_int_cast
from lib.concurrent import thread_map
from lib.data_source import DataSource
from lib.net import download_snapshot
from lib.utils import URL_OUTPUTS_PROD, combine_tables
_COLUMN_MAPPING = {
"DATE": "date",
"STATION": "noaa_station",
"TMIN": "minimum_temperature",
"TMAX": "maximum_temperature",
"PRCP": "rainfall",
"SNOW": "snowfall",
}
_OUTPUT_COLUMNS = [
"date",
"key",
"noaa_station",
"noaa_distance",
"minimum_temperature",
"maximum_temperature",
"rainfall",
"snowfall",
]
_DISTANCE_THRESHOLD = 300
_INVENTORY_URL = "https://open-covid-19.github.io/weather/ghcn/ghcnd-inventory.txt"
_STATION_URL_TPL = "https://open-covid-19.github.io/weather/ghcn/{}.csv"
# _INVENTORY_URL = "https://www1.ncdc.noaa.gov/pub/data/ghcn/daily/ghcnd-inventory.txt"
# _STATION_URL_TPL = (
# "https://www.ncei.noaa.gov/data/global-historical-climatology-network-daily/access/{}.csv"
# )
class NoaaGhcnDataSource(DataSource):
# A bit of a circular dependency but we need the latitude and longitude to compute weather
def fetch(
self, output_folder: Path, cache: Dict[str, str], fetch_opts: List[Dict[str, Any]]
) -> Dict[str, str]:
geo_url = f"{URL_OUTPUTS_PROD}/geography.csv"
download_opts = (fetch_opts or [{}])[0].get("opts", {})
return {0: download_snapshot(geo_url, output_folder, **download_opts)}
@staticmethod
def haversine_distance(
stations: DataFrame, lat: float, lon: float, radius: float = 6373.0
) -> Series:
""" Compute the distance between two <latitude, longitude> pairs in kilometers """
# Compute the pairwise deltas
lat_diff = stations.lat - lat
lon_diff = stations.lon - lon
# Apply Haversine formula
a = numpy.sin(lat_diff / 2) ** 2
a += math.cos(lat) * numpy.cos(stations.lat) * numpy.sin(lon_diff / 2) ** 2
c = numpy.arctan2(numpy.sqrt(a), numpy.sqrt(1 - a)) * 2
return radius * c
@staticmethod
def fix_temp(value: int):
value = safe_int_cast(value)
return None if value is None else "%.1f" % (value / 10.0)
@staticmethod
def station_records(station_cache: Dict[str, DataFrame], stations: DataFrame, location: Series):
nearest = stations.copy()
nearest["key"] = location.key
# Get the nearest stations from our list of stations given lat and lon
nearest["distance"] = NoaaGhcnDataSource.haversine_distance(
nearest, location.lat, location.lon
)
# Filter out the 10 nearest stations
nearest = nearest[nearest.distance < _DISTANCE_THRESHOLD].sort_values("distance").iloc[:20]
# Early exit: no stations found within distance threshold
if len(nearest) == 0:
return DataFrame(columns=_OUTPUT_COLUMNS)
# Query the cache and pull data only if not already cached
for station_id in filter(lambda x: x not in station_cache, nearest.id.values):
# Read the records from the nearest station
# Use our mirror since NOAA's website is very flaky
station_url = _STATION_URL_TPL.format(station_id)
data = read_csv(station_url, usecols=lambda column: column in _COLUMN_MAPPING.keys())
data = data.rename(columns=_COLUMN_MAPPING)
# Convert temperature to correct values
data["minimum_temperature"] = data["minimum_temperature"].apply(
NoaaGhcnDataSource.fix_temp
)
data["maximum_temperature"] = data["maximum_temperature"].apply(
NoaaGhcnDataSource.fix_temp
)
# Get only data for 2020 and add location values
data = data[data.date > "2019-12-31"]
# Save into the cache
station_cache[station_id] = data
# Get station records from the cache
nearest = nearest.rename(columns={"id": "noaa_station", "distance": "noaa_distance"})
station_tables = [station_cache[station_id] for station_id in nearest.noaa_station.values]
station_tables = [table.merge(nearest) for table in station_tables]
data = combine_tables(reversed(station_tables), ["date", "key"])
# Return all the available data from the records
return data[[col for col in _OUTPUT_COLUMNS if col in data.columns]]
def parse_dataframes(
self, dataframes: List[DataFrame], aux: Dict[str, DataFrame], **parse_opts
):
# Get all the weather stations with data up until 2020
stations = read_csv(
_INVENTORY_URL,
sep=r"\s+",
names=("id", "lat", "lon", "measurement", "year_start", "year_end"),
)
stations = stations[stations.year_end == 2020][["id", "lat", "lon", "measurement"]]
# Filter stations that at least provide max and min temps
measurements = ["TMIN", "TMAX"]
stations = stations.groupby(["id", "lat", "lon"]).agg(lambda x: "|".join(x))
stations = stations[stations.measurement.apply(lambda x: all(m in x for m in measurements))]
stations = stations.reset_index()
# Get all the POI from metadata and go through each key
keep_columns = ["key", "latitude", "longitude"]
metadata = dataframes[0][keep_columns].dropna()
# Only use keys present in the metadata table
metadata = metadata.merge(aux["metadata"])[keep_columns]
# Convert all coordinates to radians
stations["lat"] = stations.lat.apply(math.radians)
stations["lon"] = stations.lon.apply(math.radians)
metadata["lat"] = metadata.latitude.apply(math.radians)
metadata["lon"] = metadata.longitude.apply(math.radians)
# Use a cache to avoid having to query the same station multiple times
station_cache: Dict[str, DataFrame] = {}
# Make sure the stations and the cache are sent to each function call
map_func = partial(NoaaGhcnDataSource.station_records, station_cache, stations)
# We don't care about the index while iterating over each metadata item
map_iter = [record for _, record in metadata.iterrows()]
# Shuffle the iterables to try to make better use of the caching
shuffle(map_iter)
# Bottleneck is network so we can use lots of threads in parallel
records = thread_map(map_func, map_iter, total=len(metadata))
return | concat(records) | pandas.concat |
# -*- coding: utf-8 -*-
"""
This module contains the ReadSets class that is in charge
of reading the sets files, reshaping them to be used in
the build class, creating and reading the parameter files and
checking the errors in the definition of the sets and parameters
"""
import itertools as it
from openpyxl import load_workbook
import pandas as pd
from hypatia.error_log.Checks import (
check_nan,
check_index,
check_index_data,
check_table_name,
check_mapping_values,
check_mapping_ctgry,
check_sheet_name,
check_tech_category,
check_carrier_type,
check_years_mode_consistency,
)
from hypatia.error_log.Exceptions import WrongInputMode
import numpy as np
from hypatia.utility.constants import (
global_set_ids,
regional_set_ids,
technology_categories,
carrier_types,
)
from hypatia.utility.constants import take_trade_ids, take_ids, take_global_ids
MODES = ["Planning", "Operation"]
class ReadSets:
""" Class that reads the sets of the model, creates the parameter files with
default values and reads the filled parameter files
Attributes
------------
mode:
The mode of optimization including the operation and planning mode
path:
The path of the set files given by the user
glob_mapping : dict
A dictionary of the global set tables given by the user in the global.xlsx file
mapping : dict
A dictionary of the regional set tables given by the user in the regional
set files
connection_sheet_ids: dict
A nested dictionary that defines the sheet names of the parameter file of
the inter-regional links with their default values, indices and columns
global_sheet_ids : dict
A nested dictionary that defines the sheet names of the global parameter file
with their default values, indices and columns
regional_sheets_ids : dict
A nested dictionary that defines the sheet names of the regional parameter files
with their default values, indices and columns
trade_data : dict
A nested dictionary for storing the inter-regional link data
global_data : dict
A nested dictionary for storing the global data
data : dict
A nested dictionary for storing the regional data
"""
def __init__(self, path, mode="Planning"):
self.mode = mode
self.path = path
self._init_by_xlsx()
def _init_by_xlsx(self,):
"""
Reads and organizes the global and regional sets
"""
glob_mapping = {}
wb_glob = load_workbook(r"{}/global.xlsx".format(self.path))
sets_glob = wb_glob["Sets"]
set_glob_category = {key: value for key, value in sets_glob.tables.items()}
for entry, data_boundary in sets_glob.tables.items():
data_glob = sets_glob[data_boundary]
content = [[cell.value for cell in ent] for ent in data_glob]
header = content[0]
rest = content[1:]
df = pd.DataFrame(rest, columns=header)
glob_mapping[entry] = df
self.glob_mapping = glob_mapping
check_years_mode_consistency(
mode=self.mode, main_years=list(self.glob_mapping["Years"]["Year"])
)
for key, value in self.glob_mapping.items():
check_table_name(
file_name="global",
allowed_names=list(global_set_ids.keys()),
table_name=key,
)
check_index(value.columns, key, "global", pd.Index(global_set_ids[key]))
check_nan(key, value, "global")
if key == "Technologies":
check_tech_category(value, technology_categories, "global")
if key == "Carriers":
check_carrier_type(value, carrier_types, "global")
self.regions = list(self.glob_mapping["Regions"]["Region"])
self.main_years = list(self.glob_mapping["Years"]["Year"])
if "Timesteps" in self.glob_mapping.keys():
self.time_steps = list(self.glob_mapping["Timesteps"]["Timeslice"])
self.timeslice_fraction = self.glob_mapping["Timesteps"][
"Timeslice_fraction"
].values
else:
self.time_steps = ["Annual"]
self.timeslice_fraction = np.ones((1, 1))
# possible connections among the regions
if len(self.regions) > 1:
lines_obj = it.permutations(self.regions, r=2)
self.lines_list = []
for item in lines_obj:
if item[0] < item[1]:
self.lines_list.append("{}-{}".format(item[0], item[1]))
mapping = {}
for reg in self.regions:
wb = load_workbook(r"{}/{}.xlsx".format(self.path, reg))
sets = wb["Sets"]
self._setbase_reg = [
"Technologies",
"Carriers",
"Carrier_input",
"Carrier_output",
]
set_category = {key: value for key, value in sets.tables.items()}
reg_mapping = {}
for entry, data_boundary in sets.tables.items():
data = sets[data_boundary]
content = [[cell.value for cell in ent] for ent in data]
header = content[0]
rest = content[1:]
df = pd.DataFrame(rest, columns=header)
reg_mapping[entry] = df
mapping[reg] = reg_mapping
for key, value in mapping[reg].items():
check_table_name(
file_name=reg,
allowed_names=list(regional_set_ids.keys()),
table_name=key,
)
check_index(value.columns, key, reg, pd.Index(regional_set_ids[key]))
check_nan(key, value, reg)
if key == "Technologies":
check_tech_category(value, technology_categories, reg)
if key == "Carriers":
check_carrier_type(value, carrier_types, reg)
if key == "Carrier_input" or key == "Carrier_output":
check_mapping_values(
value,
key,
mapping[reg]["Technologies"],
"Technologies",
"Technology",
"Technology",
reg,
)
check_mapping_values(
mapping[reg]["Carrier_input"],
"Carrier_input",
mapping[reg]["Carriers"],
"Carriers",
"Carrier_in",
"Carrier",
reg,
)
check_mapping_values(
mapping[reg]["Carrier_output"],
"Carrier_output",
mapping[reg]["Carriers"],
"Carriers",
"Carrier_out",
"Carrier",
reg,
)
check_mapping_ctgry(
mapping[reg]["Carrier_input"],
"Carrier_input",
mapping[reg]["Technologies"],
"Supply",
reg,
)
check_mapping_ctgry(
mapping[reg]["Carrier_output"],
"Carrier_output",
mapping[reg]["Technologies"],
"Demand",
reg,
)
self.mapping = mapping
Technologies = {}
for reg in self.regions:
regional_tech = {}
for key in list(self.mapping[reg]["Technologies"]["Tech_category"]):
regional_tech[key] = list(
self.mapping[reg]["Technologies"].loc[
self.mapping[reg]["Technologies"]["Tech_category"] == key
]["Technology"]
)
Technologies[reg] = regional_tech
self.Technologies = Technologies
self._create_input_data()
def _create_input_data(self):
"""
Defines the sheets, indices and columns of the parameter files
"""
if len(self.regions) > 1:
# Create the columns of inter-regional links as a multi-index of the
# pairs of regions and the transmitted carriers
indexer = pd.MultiIndex.from_product(
[self.lines_list, self.glob_mapping["Carriers_glob"]["Carrier"]],
names=["Line", "Transmitted Carrier"],
)
self.connection_sheet_ids = {
"F_OM": {
"value": 0,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer,
},
"V_OM": {
"value": 0,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer,
},
"Residual_capacity": {
"value": 0,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer,
},
"Capacity_factor_line": {
"value": 1,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer,
},
"Line_efficiency": {
"value": 1,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer,
},
"AnnualProd_perunit_capacity": {
"value": 1,
"index": pd.Index(
["AnnualProd_Per_UnitCapacity"], name="Performance Parameter"
),
"columns": indexer,
},
}
self.global_sheet_ids = {
"Max_production_global": {
"value": 1e30,
"index": pd.Index(self.main_years, name="Years"),
"columns": self.glob_mapping["Technologies_glob"].loc[
(
self.glob_mapping["Technologies_glob"]["Tech_category"]
!= "Demand"
)
& (
self.glob_mapping["Technologies_glob"]["Tech_category"]
!= "Storage"
)
]["Technology"],
},
"Min_production_global": {
"value": 0,
"index": pd.Index(self.main_years, name="Years"),
"columns": self.glob_mapping["Technologies_glob"].loc[
(
self.glob_mapping["Technologies_glob"]["Tech_category"]
!= "Demand"
)
& (
self.glob_mapping["Technologies_glob"]["Tech_category"]
!= "Storage"
)
]["Technology"],
},
"Glob_emission_cap_annual": {
"value": 1e30,
"index": pd.Index(self.main_years, name="Years"),
"columns": ["Global Emission Cap"],
},
}
if self.mode == "Planning":
self.connection_sheet_ids.update(
{
"INV": {
"value": 0,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer,
},
"Decom_cost": {
"value": 0,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer,
},
"Min_totalcap": {
"value": 0,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer,
},
"Max_totalcap": {
"value": 1e10,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer,
},
"Min_newcap": {
"value": 0,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer,
},
"Max_newcap": {
"value": 1e10,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer,
},
"Line_lifetime": {
"value": 1,
"index": pd.Index(
["Technical Life Time"], name="Performance Parameter"
),
"columns": indexer,
},
"Line_Economic_life": {
"value": 1,
"index": pd.Index(
["Economic Life time"], name="Performance Parameter"
),
"columns": indexer,
},
"Interest_rate": {
"value": 0.05,
"index": pd.Index(
["Interest Rate"], name="Performance Parameter"
),
"columns": indexer,
},
}
)
self.global_sheet_ids.update(
{
"Min_totalcap_global": {
"value": 0,
"index": pd.Index(self.main_years, name="Years"),
"columns": self.glob_mapping["Technologies_glob"].loc[
self.glob_mapping["Technologies_glob"]["Tech_category"]
!= "Demand"
]["Technology"],
},
"Max_totalcap_global": {
"value": 1e10,
"index": pd.Index(self.main_years, name="Years"),
"columns": self.glob_mapping["Technologies_glob"].loc[
self.glob_mapping["Technologies_glob"]["Tech_category"]
!= "Demand"
]["Technology"],
},
"Min_newcap_global": {
"value": 0,
"index": pd.Index(self.main_years, name="Years"),
"columns": self.glob_mapping["Technologies_glob"].loc[
self.glob_mapping["Technologies_glob"]["Tech_category"]
!= "Demand"
]["Technology"],
},
"Max_newcap_global": {
"value": 1e10,
"index": pd.Index(self.main_years, name="Years"),
"columns": self.glob_mapping["Technologies_glob"].loc[
self.glob_mapping["Technologies_glob"]["Tech_category"]
!= "Demand"
]["Technology"],
},
"Discount_rate": {
"value": 0.05,
"index": pd.Index(self.main_years, name="Years"),
"columns": ["Annual Discount Rate"],
},
}
)
self.regional_sheets_ids = {}
indexer_reg = {}
indexer_reg_drop1 = {}
indexer_reg_drop2 = {}
add_indexer = {}
conversion_plus_indexin = {}
conversion_plus_indexout = {}
# Creates the columns of the carrier_ratio_in and carrier_ratio_out sheets
# by finding the conversion plus technologies and their input and output carriers
for reg in self.regions:
if "Conversion_plus" in self.Technologies[reg].keys():
take_carrierin = [
self.mapping[reg]["Carrier_input"]
.loc[self.mapping[reg]["Carrier_input"]["Technology"] == tech][
"Carrier_in"
]
.values
for tech in self.Technologies[reg]["Conversion_plus"]
]
take_carrierin_ = [
carr
for index, value in enumerate(take_carrierin)
for carr in take_carrierin[index]
]
take_technologyin = [
self.mapping[reg]["Carrier_input"]
.loc[self.mapping[reg]["Carrier_input"]["Technology"] == tech][
"Technology"
]
.values
for tech in self.Technologies[reg]["Conversion_plus"]
]
take_technologyin_ = [
tech
for index, value in enumerate(take_technologyin)
for tech in take_technologyin[index]
]
take_carrierout = [
self.mapping[reg]["Carrier_output"]
.loc[self.mapping[reg]["Carrier_output"]["Technology"] == tech][
"Carrier_out"
]
.values
for tech in self.Technologies[reg]["Conversion_plus"]
]
take_carrierout_ = [
carr
for index, value in enumerate(take_carrierout)
for carr in take_carrierout[index]
]
take_technologyout = [
self.mapping[reg]["Carrier_output"]
.loc[self.mapping[reg]["Carrier_output"]["Technology"] == tech][
"Technology"
]
.values
for tech in self.Technologies[reg]["Conversion_plus"]
]
take_technologyout_ = [
tech
for index, value in enumerate(take_technologyout)
for tech in take_technologyout[index]
]
conversion_plus_indexin[reg] = pd.MultiIndex.from_arrays(
[take_technologyin_, take_carrierin_],
names=["Tech_category", "Technology"],
)
conversion_plus_indexout[reg] = pd.MultiIndex.from_arrays(
[take_technologyout_, take_carrierout_],
names=["Tech_category", "Technology"],
)
# Creates the columns of the technology-specific parameter files
# based on the technology categories and the technologies within each
# caregory
dict_ = self.Technologies[reg]
level1 = []
level2 = []
for key, values in dict_.items():
if key != "Demand":
for value in values:
level1.append(key)
level2.append(value)
indexer_reg[reg] = pd.MultiIndex.from_arrays(
[level1, level2], names=["Tech_category", "Technology"]
)
if "Storage" in self.Technologies[reg].keys():
indexer_reg_drop1[reg] = indexer_reg[reg].drop("Storage", level=0)
else:
indexer_reg_drop1[reg] = indexer_reg[reg]
if "Transmission" in self.Technologies[reg].keys():
indexer_reg_drop2[reg] = indexer_reg_drop1[reg].drop(
"Transmission", level=0
)
else:
indexer_reg_drop2[reg] = indexer_reg_drop1[reg]
level1_ = level1 * 2
level2_ = level2 * 2
tax = []
sub = []
for tech in level2:
tax.append("Tax")
sub.append("Sub")
taxsub = tax + sub
add_indexer[reg] = pd.MultiIndex.from_arrays(
[taxsub, level1_, level2_],
names=["Taxes or Subsidies", "Tech_category", "Technology"],
)
self.regional_sheets_ids[reg] = {
"F_OM": {
"value": 0,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer_reg[reg],
},
"V_OM": {
"value": 0,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer_reg[reg],
},
"Residual_capacity": {
"value": 0,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer_reg[reg],
},
"Max_production": {
"value": 1e20,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer_reg_drop2[reg],
},
"Min_production": {
"value": 0,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer_reg_drop2[reg],
},
"Capacity_factor_tech": {
"value": 1,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer_reg[reg],
},
"Tech_efficiency": {
"value": 1,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer_reg_drop1[reg],
},
"Specific_emission": {
"value": 0,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer_reg_drop2[reg],
},
"Carbon_tax": {
"value": 0,
"index": pd.Index(self.main_years, name="Years"),
"columns": indexer_reg_drop2[reg],
},
"Fix_taxsub": {
"value": 0,
"index": pd.Index(self.main_years, name="Years"),
"columns": add_indexer[reg],
},
"Emission_cap_annual": {
"value": 1e10,
"index": | pd.Index(self.main_years, name="Years") | pandas.Index |
# Copyright (c) 2016-2018 <NAME> <<EMAIL>>
#
# This module is free software. You can redistribute it and/or modify it under
# the terms of the MIT License, see the file COPYING included with this
# distribution.
"""Class implementing the maelstrom method (Bruse & van Heeringen, 2018)
Examples
--------
run_maelstrom(input, "hg38", outdir)
mr = MaelstromResult(outdir)
"""
import glob
import os
import re
import subprocess as sp
import shutil
import sys
from tempfile import NamedTemporaryFile
import logging
from functools import partial
import numpy as np
import pandas as pd
from sklearn.preprocessing import scale
from scipy.cluster import hierarchy
from scipy.spatial import distance
# Plotting
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style('white')
from gimmemotifs.background import RandomGenomicFasta
from gimmemotifs.config import MotifConfig
from gimmemotifs.moap import moap, Moap
from gimmemotifs.rank import rankagg
from gimmemotifs.motif import read_motifs
from gimmemotifs.scanner import Scanner
from gimmemotifs.report import maelstrom_html_report
from gimmemotifs.utils import join_max, pwmfile_location
from multiprocessing import Pool
BG_LENGTH = 200
BG_NUMBER = 10000
FPR = 0.01
logger = logging.getLogger("gimme.maelstrom")
def scan_to_table(input_table, genome, scoring, pwmfile=None, ncpus=None):
"""Scan regions in input table with motifs.
Parameters
----------
input_table : str
Filename of input table. Can be either a text-separated tab file or a
feather file.
genome : str
Genome name. Can be either the name of a FASTA-formatted file or a
genomepy genome name.
scoring : str
"count" or "score"
pwmfile : str, optional
Specify a PFM file for scanning.
ncpus : int, optional
If defined this specifies the number of cores to use.
Returns
-------
table : pandas.DataFrame
DataFrame with motif ids as column names and regions as index. Values
are either counts or scores depending on the 'scoring' parameter.s
"""
config = MotifConfig()
if pwmfile is None:
pwmfile = config.get_default_params().get("motif_db", None)
if pwmfile is not None:
pwmfile = os.path.join(config.get_motif_dir(), pwmfile)
if pwmfile is None:
raise ValueError("no pwmfile given and no default database specified")
logger.info("reading table")
if input_table.endswith("feather"):
df = pd.read_feather(input_table)
idx = df.iloc[:,0].values
else:
df = | pd.read_table(input_table, index_col=0, comment="#") | pandas.read_table |
from datetime import datetime
from unittest import TestCase
from unittest.mock import Mock
from zoneinfo import ZoneInfo
from etl.src.extractor import TimeSeriesExtractor, Clock
import pandas as pd
from pandas.testing import assert_series_equal
def to_milliseconds(ts: datetime) -> int:
return int(ts.timestamp() * 1000)
class TestExtractor(TestCase):
def setUp(self):
self.mock_api = Mock()
tz = ZoneInfo("Europe/Berlin")
ts_1 = datetime(2021, 4, 11, hour=5, tzinfo=tz)
ts_2 = datetime(2021, 4, 11, hour=10, tzinfo=tz)
ts_3 = datetime(2021, 4, 11, hour=22, tzinfo=tz)
self.ts_1 = to_milliseconds(ts_1)
self.ts_2 = to_milliseconds(ts_2)
self.ts_3 = to_milliseconds(ts_3)
self.mock_api.query.return_value = {
"results": [
{
"statement_id": 0,
"series": [
{
"name": "ppm",
"columns": ["time", "value"],
"values": [
[self.ts_1, 500],
[self.ts_2, 502],
[self.ts_3, 535],
],
}
],
}
]
}
clock = Mock()
clock.now.return_value = datetime(2021, 4, 11, hour=23, tzinfo=tz)
self.extractor = TimeSeriesExtractor(
home_api=self.mock_api, day_start_hour=6, clock=clock
)
def test_has_extract_accepts_query(self):
self.extractor.extract(query="query")
def test_returns_time_series(self):
index = | pd.to_datetime([self.ts_2, self.ts_3], unit="ms") | pandas.to_datetime |
import streamlit as st
import pandas as pd
from pyvis.network import Network
import networkx as nx
import matplotlib.pyplot as plt
import bz2
import pickle
import _pickle as cPickle
import pydot
import math
import numpy as num
def decompress_pickle(file):
data = bz2.BZ2File(file, 'rb')
data = cPickle.load(data)
return data
uploaded_files = st.sidebar.file_uploader("Choose files", accept_multiple_files=True)
# sidebar for navigating pages
page_nav = st.sidebar.selectbox("Select view:",('Document overviews','Focus concepts','Path views','Active Study view','Study phenomena','Study sets'))
@st.cache
def do_this_first(uploaded_files):
#st.write(st.__version__)
# Load any compressed pickle file
# for uploaded_file in uploaded_files:
# concepts = decompress_pickle(uploaded_file)
# st.write("filename:", uploaded_file.name)
filenames = [file.name for file in uploaded_files] # return this
import pandas as pd
Agg_Conceptdata = pd.DataFrame()
All_Conceptdata = pd.DataFrame()
Agg_np_to_sent = dict()
Agg_sent_to_npflat = dict()
Agg_sent_to_phen = dict()
Agg_phen_to_sent = dict()
Agg_att_to_sent = dict()
Agg_sent_to_att = dict()
Agg_ins_to_sent = dict()
Agg_sent_to_ins = dict()
Agg_set_to_sent = dict()
Agg_sent_to_set = dict()
Agg_np_to_forms = dict()
doc_to_np = dict()
np_to_doc = dict()
Agg_df = pd.DataFrame()
Agg_df = pd.DataFrame()
Agg_np_to_roles = dict()
Agg_sent_to_clt = dict()
Agg_sents = dict()
#Agg_sents_df = pd.DataFrame()
#Agg_docs_df = pd.DataFrame()
All_df = pd.DataFrame()
for uploaded_file in uploaded_files:
concepts = decompress_pickle(uploaded_file)
filename = uploaded_file.name
#st.write("filename:", uploaded_file.name)
Conceptdata = concepts['Conceptdata']
sent_to_npflat = concepts['sent_to_npflat']
np_to_sent = concepts['np_to_sent']
np_to_forms = concepts['np_to_forms']
sent_to_phen = concepts['sent_to_phen']
phen_to_sent = concepts['phen_to_sent']
sent_to_att = concepts['sent_to_att']
att_to_sent = concepts['att_to_sent']
att_to_sent = concepts['att_to_sent']
ins_to_sent = concepts['ins_to_sent']
sent_to_ins = concepts['sent_to_ins']
set_to_sent = concepts['set_to_sent']
sent_to_set = concepts['sent_to_set']
np_to_roles = concepts['np_to_roles']
sent_to_clt = concepts['sent_to_clt']
sents = concepts['sents']
df = concepts['df']
Conceptdata['docname'] = filename
Agg_Conceptdata = Agg_Conceptdata.append(Conceptdata,ignore_index=True)
Agg_sent_to_clt[filename.replace(".pbz2","")] = sent_to_clt
Agg_np_to_sent[filename.replace(".pbz2","")] = np_to_sent
Agg_sents[filename.replace(".pbz2","")] = sents
Agg_sent_to_npflat[filename.replace(".pbz2","")] = sent_to_npflat
Agg_sent_to_set[filename.replace(".pbz2","")] = sent_to_set
Agg_sent_to_att[filename.replace(".pbz2","")] = sent_to_att
Agg_sent_to_phen[filename.replace(".pbz2","")] = sent_to_phen
Agg_sent_to_ins[filename.replace(".pbz2","")] = sent_to_ins
Agg_df = Agg_df.append(df,ignore_index=True)
doc_to_np[filename] = list(np_to_sent.keys()) # return this
for np in np_to_sent:
# if np in Agg_np_to_sent:
# Agg_np_to_sent[np] = Agg_np_to_sent[np] + [(filename,s) for s in np_to_sent[np]]
# else:
# Agg_np_to_sent[np] = [(filename,s) for s in np_to_sent[np]]
if np in np_to_doc:
np_to_doc[np] = np_to_doc[np] + [filename]
else:
np_to_doc[np] = [filename]
for np in np_to_forms:
if np in Agg_np_to_forms:
Agg_np_to_forms[np] = Agg_np_to_forms[np] + np_to_forms[np]
else:
Agg_np_to_forms[np] = np_to_forms[np]
for np in np_to_roles:
if np in Agg_np_to_roles:
Agg_np_to_roles[np] = Agg_np_to_roles[np] + np_to_roles[np]
else:
Agg_np_to_roles[np] = np_to_roles[np]
for np in phen_to_sent:
if np in Agg_phen_to_sent:
Agg_phen_to_sent[np] = Agg_phen_to_sent[np] + [(filename,s) for s in phen_to_sent[np]]
else:
Agg_phen_to_sent[np] = [(filename,s) for s in phen_to_sent[np]]
for np in att_to_sent:
if np in Agg_att_to_sent:
Agg_att_to_sent[np] = Agg_att_to_sent[np] + [(filename,s) for s in att_to_sent[np]]
else:
Agg_att_to_sent[np] = [(filename,s) for s in att_to_sent[np]]
for np in set_to_sent:
if np in Agg_set_to_sent:
Agg_set_to_sent[np] = Agg_set_to_sent[np] + [(filename,s) for s in set_to_sent[np]]
else:
Agg_set_to_sent[np] = [(filename,s) for s in set_to_sent[np]]
for np in ins_to_sent:
if np in Agg_ins_to_sent:
Agg_ins_to_sent[np] = Agg_ins_to_sent[np] + [(filename,s) for s in ins_to_sent[np]]
else:
Agg_ins_to_sent[np] = [(filename,s) for s in ins_to_sent[np]]
#st.write(Agg_Conceptdata.columns)
All_Conceptdata = pd.DataFrame()
def most_common_form(np):
return pd.Series(Agg_np_to_forms[np]).value_counts().sort_values(ascending=False).index[0]
Agg_np_to_mcform = dict()
for np in Agg_np_to_forms:
Agg_np_to_mcform[np] = most_common_form(np)
All_Conceptdata = Agg_Conceptdata.groupby('Concept').agg(doc_Occurence = pd.NamedAgg('docname',lambda x: list(x)),
doc_Frequency = pd.NamedAgg('docname',lambda x: x.shape[0]),
Raw_Frequency = pd.NamedAgg('Frequency','sum'),
Mean = pd.NamedAgg('Mean','mean'),
Median = pd.NamedAgg('Median','mean'),
Sdev = pd.NamedAgg('Sdev','mean'),
Ext_IDF = pd.NamedAgg('IDF',num.nanmin))
All_Conceptdata['Mean_Frequency'] = All_Conceptdata['Raw_Frequency']/All_Conceptdata['doc_Frequency']
All_Conceptdata['normalized_RawFreq'] = All_Conceptdata['Raw_Frequency']/All_Conceptdata['Raw_Frequency'].max()
All_Conceptdata['normalized_MeanFreq'] = All_Conceptdata['Mean_Frequency']/All_Conceptdata['Mean_Frequency'].max()
All_Conceptdata['intIDF'] = All_Conceptdata['doc_Frequency'].apply(lambda x: math.log(len(filenames),2)-abs(math.log(1+x,2)))
All_Conceptdata['intmeanTFIDF'] = All_Conceptdata['normalized_MeanFreq']*All_Conceptdata['intIDF']
for filename in filenames:
colname = filename.replace(".pbz2","")
All_Conceptdata = pd.merge(left = All_Conceptdata,
right = Agg_Conceptdata.loc[Agg_Conceptdata['docname']==filename,['Concept','Frequency']],
how='left',
left_on = 'Concept',
right_on = 'Concept')
All_Conceptdata[colname+'_TF'] = All_Conceptdata['Frequency']
del All_Conceptdata['Frequency']
All_Conceptdata[colname+'_TF'].fillna(0,inplace=True)
All_Conceptdata[colname+'_IntTFIDF'] = All_Conceptdata[colname+'_TF']*All_Conceptdata['intIDF']
All_Conceptdata['MCForm'] = All_Conceptdata['Concept'].apply(lambda x: Agg_np_to_mcform[x])
All_Conceptdata['role_frac'] = All_Conceptdata['Concept'].apply(lambda x: dict(pd.Series(Agg_np_to_roles[x]).value_counts(normalize=True)))
All_Conceptdata['phen_frac'] = All_Conceptdata['role_frac'].apply(lambda x: x.get('phen',0))
All_Conceptdata['att_frac'] = All_Conceptdata['role_frac'].apply(lambda x: x.get('att',0))
All_Conceptdata['set_frac'] = All_Conceptdata['role_frac'].apply(lambda x: x.get('set',0))
All_Conceptdata['ins_frac'] = All_Conceptdata['role_frac'].apply(lambda x: x.get('ins',0))
del All_Conceptdata['role_frac']
All_df = pd.DataFrame()
Agg_df['tuple'] = Agg_df[['Concept1','Concept2']].apply(lambda x:tuple(x),axis=1)
All_df = Agg_df.groupby('tuple').agg(Concept1 = pd.NamedAgg('Concept1',lambda x: list(x)[0]),
Concept2 = pd.NamedAgg('Concept2',lambda x: list(x)[0]),
Bondstrength = pd.NamedAgg('Bondstrength','sum'),
mean_dAB = pd.NamedAgg('dAB',num.nanmean),
mean_dBA = pd.NamedAgg('dBA',num.nanmean),
ExtIDFA = pd.NamedAgg('IDFA',num.nanmean),
ExtIDFB = pd.NamedAgg('IDFB',num.nanmean),
SdevA = pd.NamedAgg('SdevA',num.nanmean),
SdevB = pd.NamedAgg('SdevB',num.nanmean),
)
All_df = | pd.merge(left = All_df,right = All_Conceptdata.loc[:,['Concept','Raw_Frequency']],how="left",left_on = 'Concept1',right_on='Concept') | pandas.merge |
import pandas as pd
import numpy as np
import matplotlib.pyplot as pl
import os
from scipy import stats
from tqdm import tqdm
import mdtraj as md
########################################################
def get_3drobot_native(data_flag):
root_dir = '/home/hyang/bio/erf/data/decoys/3DRobot_set'
pdb_list = | pd.read_csv(f'{root_dir}/pdb_no_missing_residue.csv') | pandas.read_csv |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Jul 21 10:48:15 2020
@author: <NAME>
OK TODO: make it work from the command line
OK TODO get json file
OK TODO get all json variables
OK TODO checks all JSON variables
OK TODO try except error management with setting file
OK TODO add test to see if file exists
OK TODO add test for filepath
OK TODO: change CFD mesh
OK TODO: inject the framat setting file to the wrapper
OK TODO: Compute the error
OK TODO: File management with csv deformation
OK TODO do a better job with the settings files workflow
OK TODO: get CFD forces for csv file
OK TODO: compute CFD moments
OK TODO: Verify that the displacements do not add up
TODO: checks folder structure and prints the potential errors
TODO: In deformation from csv mode the program should read a logfile where
there is the results of the previous simulations
TODO: set the logging level from the command line
TODO: add gravity in Pytornado and SU2
TODO: add motor push
WARNING the table accepted names is not supported in all classes
"""
import logging
import json
import aeroframe_2.deformation.functions as aeroDef
import aeroframe_2.deformation.framatNormalVecConverter as normalVecFramat
import aeroframe_2.csdImportGeometry.importGeomerty as importGeomerty
import aeroframe_2.informationTransfer.mapping as mapping
import aeroframe_2.informationTransfer.mappingSU2 as mappingSU2
import aeroframe_2.wrappers.framatWrapper as framatWrapper
# import aeroframe_2.wrappers.framatWrapperSU2 as framatWrapperSU2
import pytornado.stdfun.run as cfd
import ceasiompy.SU2Run.su2run as SU2_fsi
import numpy as np
# import pickle
import sys
import matplotlib.pyplot as plt
import copy
# import pandas as pd
import os
from mpl_toolkits.mplot3d import Axes3D
import pandas as pd
# from ceasiompy.SU2Run.func.extractloads import extract_loads
# import SU2_CFD
# TODO take the information from the args parameters
logging.basicConfig(level=logging.DEBUG)
__prog_name__ = "aeroframe_2"
logger = logging.getLogger(__prog_name__+"."+__name__)
def getSettings(inputFileAndPath):
"""
Reads the json input file. This files contains the user input choices. If
there is no file, the function throws an error.
Parameters
----------
inputFileAndPath : string
Contains the path to the user input JSON file.
Raises
------
FileNotFoundError
If the file is not found the function throws that error
Returns
-------
settings : Dictionay
Returns a dictionaly with all the user input settings like which CFD
solver should be used, which CSD solver, wings mechanical properties,
materials, etc..
"""
try:
with open(inputFileAndPath) as f:
settings = json.load(f)
f.close()
except FileNotFoundError:
logger.error("<setting file>.json not found for aeroframe")
raise FileNotFoundError
return settings
def pytornadoMeshing(args, aeroframeSettings):
"""
Calls pytornado functions to build up a lattice (which is basically the
mesh and our point of interest for aeroelasticity) and all other
variables/instances needed by pytornado.
Parameters
----------
args : sys.argv
Unser input from the command line.
aeroframeSettings : Dicitonary
Contains all the information that there is in the input JSON file, i.e.
the which solver to use and mechanical properties of the wing
Returns
-------
pytornadoSttings : string
Contains the equivalent of a command line input command for pytornado.
With this variable we are tricking pytornado into thinking that he is
called from the command line which is not the case.
pytornadoVariables : list
Variables containing the mesh, the results and some other information,
necessary to run a pytornado simulation.
"""
# Virtual command line setting file input path. the "args" contains the
# rest of the needed information
pytornadoSttings = args.cwd + "/CFD/settings/" + aeroframeSettings["CFD_settings_file"]
# Buids CFD mesh
lattice,vlmdata,settings,aircraft,cur_state,state = cfd.meshing(args,pytornadoSttings)
# Join all the variables for ease of use.
pytornadoVariables = [lattice, vlmdata, settings, aircraft, cur_state, state]
logger.info("Pytornado meshing done")
return pytornadoSttings, pytornadoVariables
def csvDeformation(args,pytornadoSettings,aeroframeSettings,pytornadoVariables):
"""
Deforms the VLM mesh from a csv file, by calling the aeroDef class and the
method Mesh_Def.
Parameters
----------
args : sys.argv
Unser input from the command line.
pytornadoSettings : TYPE
Settings variables files needed to run pytornado
aeroframeSettings : Dicitonary
Contains all the information that there is in the input JSON file, i.e.
the which solver to use and mechanical properties of the wing
pytornadoVariables : list
Variables containing the mesh, the results and some other information,
necessary to run a pytornado simulation.
Returns
-------
pytornadoVariables : list
Variables containing the mesh, the results and some other information,
necessary to run a pytornado simulation.
"""
# Extract the vlm mesh
lattice = pytornadoVariables[0]
# Feeds all the needed settings in order to read the .csv deformation file
# and then be able to deform the mesh (basically compute the new normnal
# vector).
mesh_def = aeroDef.Mesh_Def(args,aeroframeSettings,lattice)
# Calls the deformation function that computes the new points positions
if aeroframeSettings['deformation_from_file']:
mesh_def.deformation()
# Feeds the result back to an understandable pytornado mesh. The idea is
# not to touch any unwanted variable, hence the action of feeding back the
# new point to the old lattice variable.
lattice.p = mesh_def.f_p
lattice.v = mesh_def.f_v
lattice.c = mesh_def.f_c
lattice.bound_leg_midpoints = mesh_def.f_b
lattice.n = mesh_def.f_n
lattice.a = mesh_def.f_a
# For ease of use and code readability
pytornadoVariables[0] = lattice
return pytornadoVariables
def feeder(pytornadoVariables,meshDeformation):
"""
Transfers the deformed mesh points to pytornadoVariables.
Parameters
----------
pytornadoVariables : list
Variables containing the mesh, the results and some other information,
necessary to run a pytornado simulation.
meshDeformation : aeroDef
Vairalbe of class aeroDef that contains all the necessary mesh points
to run pytornado.
Returns
-------
pytornadoVariables : list
Variables containing the mesh, the results and some other information,
necessary to run a pytornado simulation.
"""
pytornadoVariables[0].p = meshDeformation.f_p
pytornadoVariables[0].v = meshDeformation.f_v
pytornadoVariables[0].c = meshDeformation.f_c
pytornadoVariables[0].a = meshDeformation.f_a
pytornadoVariables[0].bound_leg_midpoints = meshDeformation.f_b
pytornadoVariables[0].n = meshDeformation.f_n
return pytornadoVariables
def forcesToCsv(args,pytornadoVariables,results):
"""
Writes the results to a csv file. WARNING at the moment (19.08.20) there is
another function doing the same in CEASIOMpy but that function extracts the
loads at the boundleg midpoint which not what the FEM mesh needs.
Parameters
----------
args : sys.argv
Unser input from the command line.
pytornadoVariables : list
Variables containing the mesh, the results and some other information,
necessary to run a pytornado simulation.
results : pytornado result class
Variable containg all the panelwise results, hence airspeed, forces,
etc.
Returns
-------
None.
"""
# assembless the path
path = args.cwd + "/CSD/results/panelwiseForces.csv"
headers = "x;y;z;fx;fy;fz"
# Gets simulation values
panelCoordinates = pytornadoVariables[0].c
panelFx = results["vlmdata"].panelwise['fx']
panelFy = results["vlmdata"].panelwise['fy']
panelFz = results["vlmdata"].panelwise['fz']
# panelMx = results["vlmdata"].panelwise['mx']
# panelMy = results["vlmdata"].panelwise['my']
# panelMz = results["vlmdata"].panelwise['mz']
results = np.array([panelCoordinates[:,0],
panelCoordinates[:,1],
panelCoordinates[:,2],
panelFx,
panelFy,
panelFz,
# panelMx,
# panelMy,
# panelMz
])
np.savetxt(path, results.T, delimiter=';', header=headers)
logger.info("Simulation finised")
def solverPytornadoCSV(args, aeroframeSettings, acceptedNames):
"""
The workflow is as follows:
1) The function builds CFD mesh.
2) Then it deforms the CFD mesh.
3) Solves the CFD problem. (basically calls the solver)
4) Extract panelwise forces and saves them into a csv file.
Parameters
----------
args : sys.argv
Unser input from the command line.
aeroframeSettings : Dicitonary
Contains all the information that there is in the input JSON file, i.e.
the which solver to use and mechanical properties of the wing
acceptedNames : list
List containing all the implemented solvers. If the user asks a solver
which is not implemented the program will throw an error and close
itself.
Returns
-------
None.
"""
# Step 1) pytornado meshing
pytornadoSettings, pytornadoVariables = pytornadoMeshing(args, aeroframeSettings)
# Step 2) Deforms CFD mesh if necessary
if aeroframeSettings['deformation_from_file']:
lattice = pytornadoVariables[0]
meshDeformation = aeroDef.Mesh_Def(args,aeroframeSettings,lattice)
meshDeformation.deformation(acceptedNames)
pytornadoVariables = feeder(pytornadoVariables,meshDeformation)
# Step 3) Computes the CFD problem
pytornadoVariables, results = cfd.solver(pytornadoVariables)
# Step 4) Saves panelwise forces results
forcesToCsv(args,pytornadoVariables,results)
logger.info("End of simulation")
sys.exit()
def solverPytornadoFramat(args, aeroframeSettings, acceptedNames):
"""
Function called when the user desires to do a simulation with the VLM
solver Pytornado and the structure solver FramAT.
The workflow is as follows:
1) Builds CFD mesh.
2) Reads CPACS files and computes the nodes of pseudo 1D structural
mesh.
3) Builds CSD instance in FramAT.
4) Computes the transformation matrices
5) Computes CFD problem.
6) Enters the aeroelastic loop.
7) Projects the loads on CSD instance.
8) Computes CSD solution
9) Deforms the CFD mesh.
10) Computes the norm of the displacement error
11) Computes new CFD problem.
12) loops back to point 6) if simulation has not converged.
13) Saves the results to a CSV file
Parameters
----------
args : sys.argv
Unser input from the command line.
aeroframeSettings : Dicitonary
Contains all the information that there is in the input JSON file, i.e.
the which solver to use and mechanical properties of the wing
acceptedNames : list
List containing all the implemented solvers. If the user asks a solver
which is not implemented the program will throw an error and close
itself.
Returns
-------
None.
"""
# Step 1) pytornado meshing
pytornadoSettings, pytornadoVariables = pytornadoMeshing(args, aeroframeSettings)
# Step 2) Reads CPACS files and computes the nodes of beam model structural
# mesh. Aeroframe function pre-meshes the aircraft to get each
# structure node.
preMeshedStructre = importGeomerty.CsdGeometryImport(args,aeroframeSettings)
preMeshedStructre.getAllPoints()
# Step 3) feeds the computed nodes to the structure solver and builds a
# structure mesh
csdSolverClassVar = framatWrapper.framat(preMeshedStructre)
csdSolverClassVar.mesh()
# Step 4) feeds the computed nodes to a mapping function which computes the
# tranformation matrices (based on RBF)
logger.debug(pytornadoVariables[0].c)
# sys.exit()
transform = mapping.mapper(pytornadoVariables,preMeshedStructre,csdSolverClassVar)
transform.computesTransformationsMatrices()
# Step 5) Computes CFD problem.
cfd.solver(pytornadoVariables)
pytornadoVariablesInit = copy.deepcopy(pytornadoVariables)
# Setp 6) Aeroelastic loop.
N = aeroframeSettings["MaxIterationsNumber"]
i = 0
maxDisplacement = np.array([0])
error = []
absoluteDisplacement = []
aeroFx = []
aeroFy = []
aeroFz = []
aeroMx = []
aeroMy = []
aeroMz = []
structFx = []
structFy = []
structFz = []
structMx = []
structMy = []
structMz = []
pVold = pytornadoVariables
tol = aeroframeSettings["ConvergeanceTolerence"]
while (i < N):
# basic user comminication
logger.debug("aeroelastic loop number: "+str(i))
# Saves the aerodynamic results
points = pVold[0].bound_leg_midpoints
Fx = pVold[1].panelwise['fx']
Fy = pVold[1].panelwise['fy']
Fz = pVold[1].panelwise['fz']
Mx = pVold[1].panelwise['mx']
My = pVold[1].panelwise['my']
Mz = pVold[1].panelwise['mz']
df = pd.DataFrame(points)
df['Fx'] = Fx
df['Fy'] = Fy
df['Fz'] = Fz
df['Mx'] = Mx
df['My'] = My
df['Mz'] = Mz
df.columns = ['x', 'y', 'z', 'Fx', 'Fy', 'Fz', 'Mx', 'My', 'Mz']
df.to_csv(args.cwd + '/CFD/_results/forces' + str(i) + '.csv')
# Step 7) Projects the loads on CSD instance.
transform.aeroToStructure(args,i)
logger.debug(transform)
# Step 8) Compute structure solution
csdSolverClassVar.run(transform)
# Step 9) deforms the CFD mesh. Computes beam deformation
latticeCurrent = pytornadoVariablesInit[0]
meshDeformation = aeroDef.Mesh_Def(args,aeroframeSettings,latticeCurrent)
# Step 10) computes new aerodynamic points
transform.structureToAero(args,i)
meshDeformation.deformation(acceptedNames,transform)
pytornadoVariables = feeder(pytornadoVariables,meshDeformation)
# Step 11) Computes the norm of the displacement error
# Max structure displacement form one aeroelastic iteration to the next
maxDisplacement = np.append(maxDisplacement, np.max(np.abs(transform.suz)))
error.append(np.abs(maxDisplacement[-1] - maxDisplacement[-2]))
# Max structure displacement from undeformed state
absoluteDisplacement.append(np.abs(maxDisplacement[-1] - maxDisplacement[0]))
aeroFx.append(transform.totalAerodynamicFx)
aeroFy.append(transform.totalAerodynamicFy)
aeroFz.append(transform.totalAerodynamicFz)
aeroMx.append(transform.totalAerodynamicMx)
aeroMy.append(transform.totalAerodynamicMy)
aeroMz.append(transform.totalAerodynamicMz)
structFx.append(transform.totalStructureFx)
structFy.append(transform.totalStructureFy)
structFz.append(transform.totalStructureFz)
structMx.append(transform.totalStructureMx)
structMy.append(transform.totalStructureMy)
structMz.append(transform.totalStructureMz)
logger.info("Max error between two iteration: "+str(error))
logger.info("Max displacement between two iteration: "+str(absoluteDisplacement))
# logger.info('G load: '+str(transform.G))
# Step 12) Deforms the CFD mesh.
pytornadoVariables, results = cfd.solver(pytornadoVariables)
# logger.debug(pytornadoVariables[0].bound_leg_midpoints)
# sys.exit()
del(csdSolverClassVar)
csdSolverClassVar = framatWrapper.framat(preMeshedStructre)
csdSolverClassVar.mesh()
# del(transform)
transform = mapping.mapper(pytornadoVariables,preMeshedStructre,csdSolverClassVar)
transform.computesTransformationsMatrices()
# sys.exit()
i += 1
if i == N-1:
logger.warning("Simulation has reached max number of step,")
logger.warning("convergeance is yet to determine!")
if error[-1] <= tol:
logger.info("Simulation has converged")
i = N
# Writes a file which contains the error for each timestep
N = len(error)
path = args.cwd + "/results.csv"
MyFile = open(path,"w")
MyFile.write("Relative error; max displacement;"\
" aero Fx; aero Fy; aero Fz; aero Mx; aero My; aero Mz;"\
" struct Fx; struct Fy; struct Fz; struct Mx; struct My; struct Mz"\
)
MyFile.write("\n")
for i in range(N):
MyFile.write(str(error[i]) + ";" + \
str(absoluteDisplacement[i]) + ";" + \
str(aeroFx[i]) + ";" + \
str(aeroFy[i]) + ";" + \
str(aeroFz[i]) + ";" + \
str(aeroMx[i]) + ";" + \
str(aeroMy[i]) + ";" + \
str(aeroMz[i]) + ";" + \
str(structFx[i]) + ";" + \
str(structFy[i]) + ";" + \
str(structFz[i]) + ";" + \
str(structMx[i]) + ";" + \
str(structMy[i]) + ";" + \
str(structMz[i]) + ";"
)
MyFile.write("\n")
MyFile.close()
# Writes the forces and points at which they apply
sys.exit()
def solverSU2Framat(args, aeroframeSettings, acceptedNames):
"""
Function called when the user desires to couple the CFD solver SU2
and the structure solver FramAT.
Parameters
----------
args : sys.argv
Unser input from the command line.
aeroframeSettings : Dicitonary
Contains all the information that there is in the input JSON file, i.e.
the which solver to use and mechanical properties of the wing
acceptedNames : list
List containing all the implemented solvers. If the user asks a solver
which is not implemented the program will throw an error and close
itself.
Returns
-------
None.
"""
# TODO Step ) Checks the entry data.
# Step 1) Initialization of the loop
# Creation of the current loop directory done by the su2run.py file.
# Case s2etup
iteration = 0
wkdir = args.cwd
# TODO: read it form the config file
nb_proc = aeroframeSettings["SU2_Nproc"]
logger.debug("Configuration path: \n"+str(aeroframeSettings))
logger.debug("nb of proc: \n"+str(nb_proc))
logger.debug("WKDIR: \n"+str(wkdir))
# Step 2) Runs a single SU2 simulation
case = '/Case/'
###
# WARNING
###
SU2_fsi.run_SU2_fsi(aeroframeSettings, wkdir, case, iteration)
# Step 3) Reads CPACS files and computes the nodes of 3D beam structural
# mesh. Aeroframe_2 function 'importGeomerty' pre-meshes the
# aircraft to get each structure node.
preMeshedStructre = importGeomerty.CsdGeometryImport(args,aeroframeSettings)
preMeshedStructre.getAllPoints()
logger.info("Structure mesh points computed")
# Step 4) feeds the computed nodes to the structure solver and builds a
# structure mesh
csdSolverClassVar = framatWrapper.framat(preMeshedStructre)
csdSolverClassVar.mesh()
logger.info("FramAT mesh computed")
# Step 5) feeds the computed nodes to a mapping function which computes the
# tranformation matrices (based on RBF)
logger.debug("Next step is transformation")
forceFile = '/CFD/Case/' + str(iteration) + '/force.csv'
logger.debug(wkdir)
logger.debug(forceFile)
forceInitFilePath = wkdir + forceFile
transform = mappingSU2.mapper(forceInitFilePath,preMeshedStructre,csdSolverClassVar)
transform.computesTransformationsMatrices(forceInitFilePath)
# Setp 6) Aeroelastic loop.
N = aeroframeSettings["MaxIterationsNumber"]
maxDisplacement = np.array([0])
error = []
absoluteDisplacement = []
Gloads = []
tol = aeroframeSettings["ConvergeanceTolerence"]
while (iteration < N):
# basic user comminication
logger.debug("aeroelastic loop number: "+str(iteration))
forceFilePath = wkdir + '/CFD/Case/' + str(iteration) + '/force.csv'
# Makes a copy to avoid memory linked mistakes
transformCurrent = transform
csdSolverClassVarCurrent = csdSolverClassVar
# Step 7) Projects the loads on CSD instance.
transformCurrent.aeroToStructure(args,forceFilePath,iteration)
# Step 8) Compute structure solution
csdSolverClassVarCurrent.run(transformCurrent)
transformCurrent.structureToAero(args,iteration,forceInitFilePath,forceFilePath)
# Step 9) Computes convergence
maxDisplacement = np.append(maxDisplacement, np.max(np.abs(transform.displacements)))
error.append(np.abs(maxDisplacement[-1] - maxDisplacement[-2]))
absoluteDisplacement.append(np.abs(maxDisplacement[-1] - maxDisplacement[0]))
Gloads.append(transform.G)
logger.info("Max error between two iteration: "+str(error))
logger.info("Max displacement between two iteration: "+str(absoluteDisplacement))
logger.info('G load: '+str(Gloads[iteration]))
# WARNING do not change it's place unless you know what you are doing
iteration += 1
# Step 10) computes new CFD solution
SU2_fsi.run_SU2_fsi(aeroframeSettings, wkdir, case, iteration)
# Step 11) frees memory in order to avoir piling displacements in FramAT
del(csdSolverClassVar)
csdSolverClassVar = framatWrapper.framat(preMeshedStructre)
csdSolverClassVar.mesh()
# del(transform)
transform = mappingSU2.mapper(forceInitFilePath,preMeshedStructre,csdSolverClassVar)
transform.computesTransformationsMatrices(forceInitFilePath)
if iteration == N-1:
logger.warning("Simulation has reached max number of step,")
logger.warning("convergeance is yet to determine!")
if error[-1] <= tol:
logger.info("Simulation has converged")
iteration = N
# Writes a file which contains the error for each timestep
N = len(error)
path = args.cwd + "/results.csv"
MyFile = open(path,"w")
MyFile.write("Relative error; max displacement")
MyFile.write("\n")
for i in range(N):
MyFile.write(str(error[i]) + ";" + \
str(absoluteDisplacement[i]) + ";" + \
str(Gloads[i]))
MyFile.write("\n")
MyFile.close()
sys.exit()
def solverSU2CSV(args, aeroframeSettings, acceptedNames):
iteration = aeroframeSettings['SU2_iteration']
wkdir = args.cwd
# TODO: read it form the config file
nb_proc = aeroframeSettings["SU2_Nproc"]
logger.debug("Configuration path: \n"+str(aeroframeSettings))
logger.debug("nb of proc: \n"+str(nb_proc))
logger.debug("WKDIR: \n"+str(wkdir))
# Step 2) Runs a single SU2 simulation
case = '/Case00_alt0_mach0.3_aoa2.0_aos0.0/'
if iteration > 0:
SU2_deformationConverter(aeroframeSettings, wkdir, case, iteration)
SU2_fsi.run_SU2_fsi(aeroframeSettings, wkdir, case, iteration)
def SU2_deformationConverter(aeroframeSettings, wkdir, case, iteration):
defFilePath = wkdir + aeroframeSettings['deformation_file']
defData = | pd.read_csv(defFilePath) | pandas.read_csv |
# %% imports
import numpy as np
import pandas as pd
import config as cfg
from src.utils.data_processing import hours_in_year, medea_path
# --------------------------------------------------------------------------- #
# %% settings and initializing
# --------------------------------------------------------------------------- #
STATIC_FNAME = medea_path('data', 'processed', 'data_static.xlsx')
idx = pd.IndexSlice
# --------------------------------------------------------------------------- #
# %% read in data
# --------------------------------------------------------------------------- #
static_data = {
'CAP_R': pd.read_excel(STATIC_FNAME, 'INITIAL_CAP_R', header=[0], index_col=[0, 1]),
'CAPCOST_R': pd.read_excel(STATIC_FNAME, 'CAPITALCOST_R', header=[0], index_col=[0, 1]),
'potentials': pd.read_excel(STATIC_FNAME, 'potentials', header=[0], index_col=[0]),
'tec': pd.read_excel(STATIC_FNAME, 'parameters_G'),
'feasops': pd.read_excel(STATIC_FNAME, 'FEASIBLE_INPUT-OUTPUT'),
'cost_transport': pd.read_excel(STATIC_FNAME, 'COST_TRANSPORT', header=[0], index_col=[0]),
'CAPCOST_K': pd.read_excel(STATIC_FNAME, 'CAPITALCOST_S', header=[0], index_col=[0, 1]),
'CAP_X': pd.read_excel(STATIC_FNAME, 'ATC', index_col=[0]),
'DISTANCE': pd.read_excel(STATIC_FNAME, 'KM', index_col=[0]),
'AIR_POLLUTION': pd.read_excel(STATIC_FNAME, 'AIR_POLLUTION', index_col=[0])
}
# --------------------------------------------------------------------------------------------------------------------
plant_data = {
'hydro': pd.read_excel(medea_path('data', 'processed', 'plant-list_hydro.xlsx'), 'opsd_hydro'),
'conventional': pd.read_excel(medea_path('data', 'processed', 'power_plant_db.xlsx'))
}
ts_data = {
'timeseries': pd.read_csv(medea_path('data', 'processed', 'medea_regional_timeseries.csv'))
}
# --------------------------------------------------------------------------- #
# %% prepare set data
# --------------------------------------------------------------------------- #
dict_sets = {
'f': {
'Nuclear': [10],
'Lignite': [20],
'Coal': [30],
'Gas': [40],
'Oil': [50],
'Hydro': [60],
'Biomass': [70],
'Solar': [80],
'Wind': [90],
'Power': [100],
'Heat': [110],
'Syngas': [120]
},
'l': {f'l{x}': [True] for x in range(1, 5)},
'm': {
'el': True,
'ht': True
},
'n': {
'pv': [True],
'ror': [True],
'wind_on': [True],
'wind_off': [True]
},
'k': {
'psp_day': [True],
'psp_week': [True],
'psp_season': [True],
'res_day': [True],
'res_week': [True],
'res_season': [True],
'battery': [True]
},
't': {f't{hour}': [True] for hour in range(1, hours_in_year(cfg.year) + 1)},
'z': {zone: [True] for zone in cfg.zones}
}
# convert to DataFrames
for key, value in dict_sets.items():
dict_sets.update({key: pd.DataFrame.from_dict(dict_sets[key], orient='index', columns=['Value'])})
# --------------------------------------------------------------------------- #
# %% prepare static data
# --------------------------------------------------------------------------- #
# Source 'CO2_INTENSITY': CO2 Emission Factors for Fossil Fuels, UBA, 2016
dict_static = {
'CO2_INTENSITY': {
'Nuclear': [0],
'Lignite': [0.399],
'Coal': [0.337],
'Gas': [0.201],
'Oil': [0.266],
'Hydro': [0],
'Biomass': [0],
'Solar': [0],
'Wind': [0],
'Power': [0],
'Heat': [0],
'Syngas': [0]
},
'eta': {
'nuc': [0.34],
'lig_stm': [0.31], 'lig_stm_chp': [0.31],
'lig_boa': [0.43], 'lig_boa_chp': [0.43],
'coal_sub': [0.32], 'coal_sub_chp': [0.32],
'coal_sc': [0.41], 'coal_sc_chp': [0.41],
'coal_usc': [0.44], 'coal_usc_chp': [0.44],
'coal_igcc': [0.55],
'ng_stm': [0.40], 'ng_stm_chp': [0.40],
'ng_cbt_lo': [0.34], 'ng_cbt_lo_chp': [0.34],
'ng_cbt_hi': [0.40], 'ng_cbt_hi_chp': [0.40],
'ng_cc_lo': [0.38], 'ng_cc_lo_chp': [0.38],
'ng_cc_hi': [0.55], 'ng_cc_hi_chp': [0.55],
'ng_mtr': [0.40], 'ng_mtr_chp': [0.40],
'ng_boiler_chp': [0.90],
'oil_stm': [0.31], 'oil_stm_chp': [0.31],
'oil_cbt': [0.35], 'oil_cbt_chp': [0.35],
'oil_cc': [0.42], 'oil_cc_chp': [0.42],
'bio': [0.35], 'bio_chp': [0.35],
'heatpump_pth': [3.0]
},
'map_name2fuel': {
'nuc': 'Nuclear',
'lig': 'Lignite',
'coal': 'Coal',
'ng': 'Gas',
'oil': 'Oil',
'bio': 'Biomass',
'heatpump': 'Power'
},
'CAPCOST_X': {
'AT': [1250],
'DE': [1250]
},
'VALUE_NSE': {
'AT': [12500],
'DE': [12500]
},
'LAMBDA': [0.125],
'SIGMA': [0.175]
}
dict_additions = {
'boilers': {
# 'medea_type': [49.5],
'set_element': 'ng_boiler_chp',
('cap', 'AT'): [4.5],
('cap', 'DE'): [25.5],
('eta', 'AT'): [0.9],
('eta', 'DE'): [0.9]
# ('count', 'AT'): [15],
# ('count', 'DE'): [85],
# ('num', 'AT'): [85],
# ('num', 'DE'): [255]
},
'heatpumps': {
# 'medea_type': [100],
'set_element': 'heatpump_pth',
('cap', 'AT'): [0.1],
('cap', 'DE'): [0.1],
('eta', 'AT'): [3.0],
('eta', 'DE'): [3.0]
# ('count', 'AT'): [1],
# ('count', 'DE'): [1],
# ('num', 'AT'): [1],
# ('num', 'DE'): [1]
},
'batteries': {
'power_in': [0],
'power_out': [0],
'energy_max': [0],
'efficiency_in': [0.96],
'efficiency_out': [0.96],
'cost_power': [static_data['CAPCOST_K'].loc[('AT', 'battery'), 'annuity-power'].round(4)],
'cost_energy': [static_data['CAPCOST_K'].loc[('AT', 'battery'), 'annuity-energy'].round(4)],
'inflow_factor': [0]
}
}
dict_instantiate = {'CO2_INTENSITY': pd.DataFrame.from_dict(dict_static['CO2_INTENSITY'],
orient='index', columns=['Value'])}
dict_instantiate.update({'efficiency': pd.DataFrame.from_dict(dict_static['eta'], orient='index', columns=['l1'])})
dict_instantiate['efficiency']['product'] = 'el'
dict_instantiate['efficiency'].loc[dict_instantiate['efficiency'].index.str.contains('pth'), 'product'] = 'ht'
dict_instantiate['efficiency'].loc['ng_boiler_chp', 'product'] = 'ht'
dict_instantiate['efficiency']['fuel'] = dict_instantiate['efficiency'].index.to_series().str.split('_').str.get(
0).replace(dict_static['map_name2fuel'])
dict_instantiate['efficiency'].set_index(['product', 'fuel'], append=True, inplace=True)
dict_instantiate['efficiency'].index.set_names(['medea_type', 'product', 'fuel_name'], inplace=True)
for i in range(1, 6):
dict_instantiate['efficiency'][f'l{i}'] = dict_instantiate['efficiency']['l1']
dict_instantiate.update({'CAP_R': static_data['CAP_R'].loc[idx[:, cfg.year], :]})
dict_instantiate.update({'CAP_X': static_data['CAP_X'].loc[
static_data['CAP_X'].index.str.contains('|'.join(cfg.zones)),
static_data['CAP_X'].columns.str.contains('|'.join(cfg.zones))] / 1000})
dict_instantiate.update({'DISTANCE': static_data['DISTANCE'].loc[static_data['DISTANCE'].index.str.contains(
'|'.join(cfg.zones)), static_data['DISTANCE'].columns.str.contains('|'.join(cfg.zones))]})
static_data.update({'CAPCOST_X': pd.DataFrame.from_dict(dict_static['CAPCOST_X'], orient='index', columns=['Value'])})
static_data.update({'VALUE_NSE': pd.DataFrame.from_dict(dict_static['VALUE_NSE'], orient='index', columns=['Value'])})
static_data.update({'LAMBDA': pd.DataFrame(dict_static['LAMBDA'], columns=['Value'])})
static_data.update({'SIGMA': pd.DataFrame(dict_static['SIGMA'], columns=['Value'])})
# --------------------------------------------------------------------------- #
# %% preprocessing plant data
# --------------------------------------------------------------------------- #
# dispatchable (thermal) plants
# filter active thermal plants
plant_data.update({'active': plant_data['conventional'].loc[
(plant_data['conventional']['UnitOperOnlineDate'] < pd.Timestamp(cfg.year, 1, 1)) &
(plant_data['conventional']['UnitOperRetireDate'] > pd.Timestamp(cfg.year, 12, 31)) |
np.isnat(plant_data['conventional']['UnitOperRetireDate'])]})
# exclude hydro power plant
plant_data['active'] = plant_data['active'].loc[(plant_data['active']['MedeaType'] < 60) |
(plant_data['active']['MedeaType'] >= 70)]
# capacities by country in GW
prop_g = plant_data['active'].groupby(['MedeaType', 'PlantCountry'])['UnitNameplate'].sum().to_frame() / 1000
prop_g['eta'] = plant_data['active'].groupby(['MedeaType', 'PlantCountry'])['Eta'].mean().to_frame()
# prop_g['count'] = plant_data['active'].groupby(['MedeaType'])['PlantCountry'].value_counts().to_frame(name='count')
# prop_g['num'] = (prop_g['UnitNameplate'].round(decimals=1) * 10).astype(int)
prop_g.rename(index={'Germany': 'DE', 'Austria': 'AT'}, columns={'UnitNameplate': 'cap'}, inplace=True)
prop_g = prop_g.unstack(-1)
prop_g.drop(0.0, axis=0, inplace=True)
# index by plant element names instead of medea_type-numbers
prop_g.index = prop_g.index.map(pd.Series(static_data['tec']['set_element'].values,
index=static_data['tec']['medea_type'].values).to_dict())
# update 'empirical' efficiencies with generic efficiencies
for zone in cfg.zones:
prop_g.loc[:, idx['eta', zone]].update(pd.DataFrame.from_dict(dict_static['eta'],
orient='index', columns=['eta']).iloc[:, 0])
# add data for heat boilers
prop_g = prop_g.append(pd.DataFrame.from_dict(dict_additions['boilers']).set_index('set_element'))
# add data for heatpumps
prop_g = prop_g.append(pd.DataFrame.from_dict(dict_additions['heatpumps']).set_index('set_element'))
# remove non-existent plant
prop_g = prop_g.stack(-1).swaplevel(axis=0)
prop_g = prop_g.dropna()
# update instantiation dictionary
dict_instantiate.update({'tec_props': prop_g})
# add 'tec'-set to dict_sets
dict_sets.update({'i': pd.DataFrame(data=True, index=prop_g.index.get_level_values(1).unique().values,
columns=['Value'])})
static_data['feasops']['fuel_name'] = (static_data['feasops']['medea_type'] / 10).apply(np.floor) * 10
static_data['feasops']['fuel_name'].replace({y: x for x, y in dict_sets['f'].itertuples()}, inplace=True)
static_data['feasops']['set_element'] = static_data['feasops']['medea_type']
static_data['feasops']['set_element'].replace(
{x: y for x, y in static_data['tec'][['medea_type', 'set_element']].values}, inplace=True)
static_data['feasops'].dropna(inplace=True)
static_data['feasops'].set_index(['set_element', 'l', 'fuel_name'], inplace=True)
# following line produces memory error (0xC00000FD) --> workaround with element-wise division
# df_feasops['fuel_need'] = df_feasops['fuel']/ df_eff
# TODO: PerformanceWarning: indexing past lexsort depth may impact performance (3 times)
static_data['feasops']['fuel_need'] = np.nan
for typ in static_data['feasops'].index.get_level_values(0).unique():
for lim in static_data['feasops'].index.get_level_values(1).unique():
static_data['feasops'].loc[idx[typ, lim], 'fuel_need'] = static_data['feasops'].loc[
idx[typ, lim], 'fuel'].mean() / \
dict_static['eta'][typ][0]
# adjust static_data['tec'] to reflect modelled power plants
static_data['tec'].set_index('set_element', inplace=True)
static_data['tec'] = static_data['tec'].loc[static_data['tec'].index.isin(dict_sets['i'].index), :]
dict_instantiate['efficiency'] = \
dict_instantiate['efficiency'].loc[
dict_instantiate['efficiency'].index.get_level_values(0).isin(dict_sets['i'].index), :]
static_data['feasops'] = \
static_data['feasops'].loc[static_data['feasops'].index.get_level_values(0).isin(dict_sets['i'].index), :]
# --------------------------------------------------------------------------- #
# hydro storage data
# drop all ror data
plant_data['hydro'].drop(plant_data['hydro'][plant_data['hydro'].technology == 'Run-of-river'].index, inplace=True)
# filter out data without reservoir size in GWh
plant_data['hydro'].dropna(subset=['energy_max', 'power_in'], inplace=True)
# calculate duration of generation from full reservoir
plant_data['hydro']['max_duration'] = plant_data['hydro']['energy_max'] / plant_data['hydro']['power_out'] * 1000 / 24
plant_data['hydro']['count'] = 1
plant_data.update({'hydro_clusters': plant_data['hydro'].groupby(['technology', 'country',
pd.cut(plant_data['hydro']['max_duration'],
[0, 2, 7, 75])]).sum()})
plant_data['hydro_clusters']['efficiency_in'] = plant_data['hydro_clusters']['efficiency_in'] / \
plant_data['hydro_clusters']['count']
plant_data['hydro_clusters']['efficiency_out'] = plant_data['hydro_clusters']['efficiency_out'] / \
plant_data['hydro_clusters']['count']
plant_data['hydro_clusters']['cost_power'] = np.nan
plant_data['hydro_clusters']['cost_energy'] = np.nan
# assign technology and zone index to rows
plant_data['hydro_clusters']['country'] = plant_data['hydro_clusters'].index.get_level_values(1)
plant_data['hydro_clusters']['category'] = plant_data['hydro_clusters'].index.get_level_values(2).rename_categories(
['day', 'week', 'season']).astype(str)
plant_data['hydro_clusters']['tech'] = plant_data['hydro_clusters'].index.get_level_values(0)
plant_data['hydro_clusters']['tech'] = plant_data['hydro_clusters']['tech'].replace(['Pumped Storage', 'Reservoir'],
['psp', 'res'])
plant_data['hydro_clusters']['set_elem'] = plant_data['hydro_clusters']['tech'] + '_' + plant_data['hydro_clusters'][
'category']
plant_data['hydro_clusters'] = plant_data['hydro_clusters'].set_index(['set_elem', 'country'])
plant_data['hydro_clusters'].fillna(0, inplace=True)
plant_data['hydro_clusters']['power_out'] = plant_data['hydro_clusters']['power_out'] / 1000 # conversion from MW to GW
plant_data['hydro_clusters']['power_in'] = plant_data['hydro_clusters']['power_in'] / 1000 # conversion from MW to GW
plant_data['hydro_clusters']['inflow_factor'] = (
plant_data['hydro_clusters']['energy_max'] / plant_data['hydro_clusters']['energy_max'].sum())
plant_data['hydro_clusters'] = plant_data['hydro_clusters'].loc[:, ['power_in', 'power_out', 'energy_max',
'efficiency_in', 'efficiency_out', 'cost_power',
'cost_energy', 'inflow_factor']].copy()
# append battery data
bat_idx = pd.MultiIndex.from_product([['battery'], list(cfg.zones)])
df_battery = pd.DataFrame(np.nan, bat_idx, dict_additions['batteries'].keys())
for zone in list(cfg.zones):
for key in dict_additions['batteries'].keys():
df_battery.loc[('battery', zone), key] = dict_additions['batteries'][key][0]
plant_data['storage_clusters'] = plant_data['hydro_clusters'].append(df_battery)
# --------------------------------------------------------------------------- #
# %% process time series data
# --------------------------------------------------------------------------- #
ts_data['timeseries']['DateTime'] = pd.to_datetime(ts_data['timeseries']['DateTime'])
ts_data['timeseries'].set_index('DateTime', inplace=True)
# constrain data to scenario year
ts_data['timeseries'] = ts_data['timeseries'].loc[
(pd.Timestamp(cfg.year, 1, 1, 0, 0).tz_localize('UTC') <= ts_data['timeseries'].index) & (
ts_data['timeseries'].index <= pd.Timestamp(cfg.year, 12, 31, 23, 0).tz_localize('UTC'))]
# drop index and set index of df_time instead
if len(ts_data['timeseries']) == len(dict_sets['t']):
ts_data['timeseries'].set_index(dict_sets['t'].index, inplace=True)
else:
raise ValueError('Mismatch of time series data and model time resolution. Is cfg.year wrong?')
ts_data['timeseries']['DE-power-load'] = ts_data['timeseries']['DE-power-load'] / 0.91
# for 0.91 scaling factor see
# https://www.entsoe.eu/fileadmin/user_upload/_library/publications/ce/Load_and_Consumption_Data.pdf
# create price time series incl transport cost
ts_data['timeseries']['Nuclear'] = 3.5
ts_data['timeseries']['Lignite'] = 4.5
ts_data['timeseries']['Biomass'] = 6.5
# subset of zonal time series
ts_data['zonal'] = ts_data['timeseries'].loc[:, ts_data['timeseries'].columns.str.startswith(('AT', 'DE'))].copy()
ts_data['zonal'].columns = ts_data['zonal'].columns.str.split('-', expand=True)
# adjust column naming to reflect proper product names ('el' and 'ht')
ts_data['zonal'] = ts_data['zonal'].rename(columns={'power': 'el', 'heat': 'ht'})
model_prices = ['Coal', 'Oil', 'Gas', 'EUA', 'Nuclear', 'Lignite', 'Biomass', 'price_day_ahead']
ts_data['price'] = pd.DataFrame(index=ts_data['timeseries'].index,
columns=pd.MultiIndex.from_product([model_prices, cfg.zones]))
for zone in cfg.zones:
for fuel in model_prices:
if fuel in static_data['cost_transport'].index:
ts_data['price'][(fuel, zone)] = ts_data['timeseries'][fuel] + static_data['cost_transport'].loc[fuel, zone]
else:
ts_data['price'][(fuel, zone)] = ts_data['timeseries'][fuel]
ts_inflows = pd.DataFrame(index=list(ts_data['zonal'].index),
columns=pd.MultiIndex.from_product([cfg.zones, dict_sets['k'].index]))
for zone in list(cfg.zones):
for strg in dict_sets['k'].index:
if 'battery' not in strg:
ts_inflows.loc[:, (zone, strg)] = ts_data['zonal'].loc[:, idx[zone, 'inflows', 'reservoir']] * \
plant_data['storage_clusters'].loc[(strg, zone), 'inflow_factor']
ts_data.update({'inflows': ts_inflows})
dict_instantiate.update({'ancil': ts_data['zonal'].loc[:, idx[:, 'el', 'load']].max().unstack((1, 2)).squeeze() * 0.125
+ dict_instantiate['CAP_R'].unstack(1).drop('ror', axis=1).sum(axis=1) * 0.075})
dict_instantiate.update({'PEAK_LOAD': ts_data['zonal'].loc[:, idx[:, 'el', 'load']].max().unstack((1, 2)).squeeze()})
dict_instantiate.update({'PEAK_PROFILE': ts_data['zonal'].loc[:, idx[:, :, 'profile']].max().unstack(2).drop(
'ror', axis=0, level=1)})
# drop rows with all zeros
plant_data['storage_clusters'] = \
plant_data['storage_clusters'].loc[~(plant_data['storage_clusters'] == 0).all(axis=1), :].copy()
# --------------------------------------------------------------------------- #
# %% limits on investment - long-run vs short-run & # TODO: potentials
# --------------------------------------------------------------------------- #
invest_limits = {}
lim_invest_thermal = pd.DataFrame([0])
if cfg.invest_conventionals:
lim_invest_thermal = pd.DataFrame([float('inf')])
invest_limits.update({'thermal': lim_invest_thermal})
# dimension lim_invest_itm[r, tec_itm]
lim_invest_itm = pd.DataFrame(data=0, index=cfg.zones, columns=dict_sets['n'].index)
if cfg.invest_renewables:
for zone in cfg.zones:
for itm in lim_invest_itm.columns:
lim_invest_itm.loc[zone, itm] = float(static_data['potentials'].loc[itm, zone])
invest_limits.update({'intermittent': lim_invest_itm})
# dimension lim_invest_storage[r, tec_strg]
lim_invest_storage = pd.DataFrame(data=0, index=cfg.zones, columns=dict_sets['k'].index)
if cfg.invest_storage:
for zone in cfg.zones:
for strg in lim_invest_storage.columns:
lim_invest_storage.loc[zone, strg] = float(static_data['potentials'].loc[strg, zone])
invest_limits.update({'storage': lim_invest_storage})
# dimension lim_invest_atc[r,rr]
lim_invest_atc = | pd.DataFrame(data=0, index=cfg.zones, columns=cfg.zones) | pandas.DataFrame |
# -*- coding:utf-8 -*-
# =========================================================================== #
# Project : Data Mining #
# File : \mymain.py #
# Python : 3.9.1 #
# --------------------------------------------------------------------------- #
# Author : <NAME> #
# Company : nov8.ai #
# Email : <EMAIL> #
# URL : https://github.com/john-james-sf/Data-Mining/ #
# --------------------------------------------------------------------------- #
# Created : Tuesday, March 9th 2021, 12:24:24 am #
# Last Modified : Tuesday, March 9th 2021, 12:24:24 am #
# Modified By : <NAME> (<EMAIL>) #
# --------------------------------------------------------------------------- #
# License : BSD #
# Copyright (c) 2021 nov8.ai #
# =========================================================================== #
# =========================================================================== #
# 1. LIBRARIES #
# =========================================================================== #
#%%
# System and python libraries
from abc import ABC, abstractmethod
import datetime
import glob
import itertools
from joblib import dump, load
import os
import pickle
import time
import uuid
# Manipulating, analyzing and processing data
from collections import OrderedDict
import numpy as np
import pandas as pd
import scipy as sp
from scipy.stats.stats import pearsonr, f_oneway
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.compose import ColumnTransformer
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer, SimpleImputer
from sklearn.neighbors import LocalOutlierFactor
from sklearn.preprocessing import FunctionTransformer, StandardScaler
from sklearn.preprocessing import OneHotEncoder, PowerTransformer
from category_encoders import TargetEncoder, LeaveOneOutEncoder
# Feature and model selection and evaluation
from sklearn.feature_selection import RFECV, SelectKBest
from sklearn.feature_selection import VarianceThreshold, f_regression
from sklearn.metrics import make_scorer, mean_squared_error
from sklearn.model_selection import KFold
from sklearn.pipeline import make_pipeline, Pipeline, FeatureUnion
from sklearn.model_selection import GridSearchCV
# Regression based estimators
from sklearn.linear_model import LinearRegression, Lasso, Ridge, ElasticNet
# Tree-based estimators
from sklearn.experimental import enable_hist_gradient_boosting
from sklearn.ensemble import AdaBoostRegressor, BaggingRegressor, ExtraTreesRegressor
from sklearn.ensemble import GradientBoostingRegressor, RandomForestRegressor
from sklearn.ensemble import HistGradientBoostingRegressor
from sklearn.tree import DecisionTreeRegressor
# Visualizing data
import seaborn as sns
import matplotlib.pyplot as plt
from tabulate import tabulate
# Utilities
from utils import notify, PersistEstimator, comment, print_dict, print_dict_keys
# Data Source
from data import AmesData
pd.set_option('display.max_rows', None)
| pd.set_option('display.max_columns', None) | pandas.set_option |
import pandas as pd
import pathlib
import yaml
from cooler.util import binnify, read_chromsizes
import numpy as np
import time
from statsmodels.stats.multitest import multipletests
from scipy.stats import norm
import subprocess
import pybedtools
from concurrent.futures import as_completed, ProcessPoolExecutor
import cemba_data
PACKAGE_DIR = pathlib.Path(cemba_data.__path__[0])
DSS_TWO_GROUP_TEMPLATE = PACKAGE_DIR / 'dmr/dss/DSS.TwoGroup.SingleRegionDML.ipynb'
def prepare_snakemake(allc_table_path, output_dir, chrom_sizes_path, template_path, chroms=None, smoothing=True,
chunk_size=50000000):
output_dir = pathlib.Path(output_dir).absolute()
output_dir.mkdir(exist_ok=True)
allc_table = pd.read_csv(allc_table_path, sep='\t')
allc_table.columns = ['allc_path', 'sample', 'group']
if allc_table['group'].unique().size != 2:
raise ValueError(
f"There must be two and only two different groups, got {allc_table['group'].unique().size}."
)
group1, group2 = allc_table['group'].unique()
group1_allc = allc_table.loc[allc_table['group'] == group1,
'allc_path'].tolist()
group2_allc = allc_table.loc[allc_table['group'] == group2,
'allc_path'].tolist()
group1_id = allc_table.loc[allc_table['group'] == group1, 'sample'].tolist()
group2_id = allc_table.loc[allc_table['group'] == group2, 'sample'].tolist()
chrom_sizes = read_chromsizes(chrom_sizes_path).reindex(chroms)
if chroms is None:
chroms = chrom_sizes.index.tolist()
bins = binnify(chrom_sizes.loc[chroms], binsize=chunk_size)
regions = []
for _, (chrom, start, end) in bins.iterrows():
region = f'{chrom}:{start}-{end}'
regions.append(region)
for region in regions:
config_path = f'{output_dir}/{region}.yaml'
parameters = dict(region=region,
allc_paths=group1_allc + group2_allc,
group1=group1_id,
group2=group2_id,
smoothing=smoothing)
with open(config_path, 'w') as f:
f.write(yaml.dump(parameters))
snakefile = f"""
regions = {regions}
rule main:
input:
expand('{{region}}.DSS.DML.hdf', region=regions)
rule papermill:
input:
nb='{template_path}',
config='{{region}}.yaml'
output:
nb='{{region}}.ipynb',
data='{{region}}.DSS.DML.hdf'
shell:
'papermill {{input.nb}} {{output.nb}} -f {{input.config}} && sleep 10'
"""
snakefile_path = f'{output_dir}/Snakefile'
with open(snakefile_path, 'w') as f:
f.write(snakefile)
return snakefile_path
def _parse_dml_ids(string):
ids = np.array(string.split(',')).astype(int)
start = min(ids)
end = max(ids)
result = pd.Series({
'idx_start': start,
'idx_end': end,
'n_sig': ids.size,
'total_dml': end - start + 1,
'sig_ratio': ids.size / (end - start + 1)
})
return result
def call_dmr_single_chromosome(output_dir, chrom, p_threshold, min_cg, min_len,
sig_ratio, delta, chrom_sizes_path):
# read DML for one chromosome
print(f'Reading DML tables for {chrom}')
dss_paths = list(pathlib.Path(output_dir).glob(f'{chrom}:*DSS.DML.hdf'))
dmls = []
for path in dss_paths:
try:
df = pd.read_hdf(path)
if df.shape[0] > 0:
dmls.append(df)
except ValueError:
# this happens when the HDF5 is empty
pass
dmls = pd.concat(dmls)
dmls.sort_values('pos', inplace=True)
dmls.dropna(subset=['pval'], inplace=True)
dmls.reset_index(drop=True, inplace=True)
print('Selecting significant DMLs to merge DMRs')
# Select sig
# recalculate FDR
_, fdr, *_ = multipletests(dmls['pval'], method='fdr_bh')
dmls['fdr'] = fdr
# Calculate delta significance Pr(diff.abs() > delta)
delta_p = 1 - norm.cdf(dmls['diff'].abs() - delta, scale=dmls['diff.se'])
# select sig DML to merge DMR
dmls['sig'] = (dmls['fdr'] < p_threshold) & (delta_p < p_threshold)
dmls.to_hdf(f'{output_dir}/{chrom}.DML.hdf', key='data', format="table")
sig_dmls = dmls[dmls['sig']]
# Merge DMR
print('Merge DMRs')
dml_bed = sig_dmls[['chr', 'pos', 'pos']].reset_index()
dml_bed.columns = ['id', 'chr', 'start', 'end']
dml_bed['end'] += 1
dml_bed = dml_bed.iloc[:, [1, 2, 3, 0]]
dml_bed = pybedtools.BedTool.from_dataframe(dml_bed)
try:
dmr_bed = dml_bed.sort(g=chrom_sizes_path).merge(
d=250, c='4', o='collapse').to_dataframe()
except pybedtools.helpers.BEDToolsError:
return False
# Annotate DMR
print('Annotating DMRs')
name = dmr_bed.pop('name')
dmr_bed = pd.concat([dmr_bed, name.apply(_parse_dml_ids)], axis=1)
dmr_bed = dmr_bed.astype({
'idx_start': int,
'idx_end': int,
'n_sig': int,
'total_dml': int
})
def _region_stat(row):
idx_start = row['idx_start']
idx_end = row['idx_end']
return dmls.iloc[idx_start:idx_end + 1].agg({
'mu1': 'mean',
'mu2': 'mean',
'stat': 'sum'
})
dmr_stats = dmr_bed.apply(_region_stat, axis=1)
dmr_bed = pd.concat([dmr_bed, dmr_stats], axis=1)
dmr_bed['diff'] = dmr_bed['mu1'] - dmr_bed['mu2']
dmr_bed['length'] = dmr_bed['end'] - dmr_bed['start']
# final DMR filter
judge = (dmr_bed['n_sig'] >= min_cg) & (
dmr_bed['sig_ratio'] > sig_ratio) & (dmr_bed['length'] >= min_len) & (
dmr_bed['diff'].abs() > delta)
dmr_bed['selected_dmr'] = judge
dmr_bed.to_hdf(f'{output_dir}/{chrom}.DMR.hdf', key='data')
return True
def run_dss_two_group(allc_table_path, output_dir, study_name, chrom_sizes_path, chroms=None, smoothing=True,
p_threshold=0.001, min_cg=1, min_len=1, sig_ratio=0.5, delta=0.1, cpu=10, save_dml=False,
template_path='default', chunk_size=50000000):
# prepare template
if template_path == 'default':
template_path = DSS_TWO_GROUP_TEMPLATE
# prepare snakemake
output_dir = pathlib.Path(output_dir).absolute()
this_study_dir = output_dir / f'{study_name}_DSS'
prepare_snakemake(allc_table_path=allc_table_path,
output_dir=this_study_dir,
chrom_sizes_path=chrom_sizes_path,
chroms=chroms,
smoothing=smoothing,
template_path=template_path,
chunk_size=chunk_size)
# the ipykernel package raise "zmq.error.ZMQError: Address already in use" due to parallel execution,
# restart likely solve the problem.
snakemake_cmd = f'snakemake -d {this_study_dir} --snakefile {this_study_dir}/Snakefile ' \
f'-j {cpu} --default-resources mem_mb=100 --resources mem_mb={int(5000 * cpu)} ' \
f'--restart-times 3'
subprocess.run(snakemake_cmd, shell=True, check=True)
with ProcessPoolExecutor(cpu) as exe:
futures = {}
for chrom in chroms:
f = exe.submit(call_dmr_single_chromosome,
output_dir=this_study_dir,
chrom=chrom,
p_threshold=p_threshold,
min_cg=min_cg,
min_len=min_len,
sig_ratio=sig_ratio,
delta=delta,
chrom_sizes_path=chrom_sizes_path)
futures[f] = chrom
time.sleep(1)
total_dmrs = []
for future in as_completed(futures):
chrom = futures[future]
print(f'{chrom} finished')
success_flag = future.result()
if success_flag:
total_dmrs.append( | pd.read_hdf(f'{this_study_dir}/{chrom}.DMR.hdf') | pandas.read_hdf |
# Data Worker
# %%
import os
import pandas as pd
import plotly.express as px
from pypinyin import lazy_pinyin
locations_url = 'https://blog.csdn.net/envbox/article/details/80290103'
filename = 'locations.json'
sync_folder = os.environ.get('Sync', '.')
mapbox = dict(
mapbox_accesstoken=open(os.path.join(
os.environ['onedrive'], '.mapbox_token')).read(),
mapbox_style='light'
)
def fetch_locations():
locations = | pd.read_html(locations_url) | pandas.read_html |
# -*- coding: utf-8 -*-
"""
Created on Sun Feb 24 19:08:39 2019
@author: <NAME> et al. - "Evaluation of machine learning models for
automatic detection of DNA double strand breaks after irradiation using a gH2AX
foci assay", PLOS One, 2020
"""
# main file for training machine learning models using previously labeled data
###############################################################################
# Parameters and file path that have to be set manually:
# Parameters:
# min area of nucleus
min_area = 4000
# color channel of nucleus. 0 = red, 1 = grenn, 2 = blue. for grayscale images
# this value is ignored.
nuc_chan = 2
# color channel of foci. 0 = red, 1 = grenn, 2 = blue. for grayscale images
# this value is ignored.
foci_chan = 1
# color channel of marked image. 0 = red, 1 = grenn, 2 = blue. corresponds to
# the color of the markings in the manually labeled foci images
mark_chan = 0
# adjust image size - might be usefull to save calculation time. needs to be
# identical for foci and nucleus images
# image rescale factor:
rescale_factor = 1.0
# take only those PCA components cumulatively explaining var_max of the variance
# 0<var_max<=1.
var_max = 0.95
# randomly sample a proportion of the training data from each image (0<sampling<=1).
# speeds up training process if smaller than 1
sampling = 1
# used filter sizes
filt_range = [2,3,4,5,8,10,15,20,25,30,35]
# scaling range for frangi filter
sc_range = list(range(2,11))
#frequency range for gabor filter
freq = [0.08,0.10,0.13,0.16,0.2]
# Name used for saving the trained model and related images:
model_name = "MLP"
# directory containing the foci images:
im_path_foci = "D:\\Sample Images\\foci"
# directory containing the manually labeled foci images:
im_path_foci_marked = "D:\\Sample Images\\foci_marked"
# directory containing the nucleus images:
im_path_dapi = "D:\\Sample Images\\dapi"
###############################################################################
###############################################################################
###############################################################################
# turn of warnings, this is especially annoying with sklearn stuff
def warn(*args, **kwargs):
pass
import warnings
warnings.warn = warn
# Get packages:
# For directory, file handling etc.
import os
import sys
# import pandas:
import pandas as pd
# import numpy
import numpy as np
# For image analysis:
from skimage.io import imread, imshow
from skimage.io import imsave
from skimage.transform import rescale
# import packages related to (pre-) processing of data and model results:
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import GridSearchCV
# import model packages:
from sklearn.naive_bayes import ComplementNB
from sklearn.neural_network import MLPClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, BaggingClassifier, VotingClassifier
from sklearn.svm import LinearSVC
from sklearn.metrics import precision_score, recall_score
sys.path.append(os.getcwd())
main_file_path = os.getcwd()
# self written functions:
from FociDetectImgAnalysis import get_nuclei, GoToFiles
from GetFociData import get_labeled_data
from GetBestParams import image_pipeline
###############################################################################
# Start analysis of dapi images
# go to nucleus folder:
os.chdir(im_path_dapi)
print("Analyzing nucleus images ...")
# go to the directory containing the foci images:
#im_path = os.getcwd()+"\Sample Images\foci"
#os.chdir(im_path)
# start reading in image files:
stats = []
# get file names
save_path = "Single Nuclei"
files = GoToFiles(im_path_dapi,save_path)
for file_num in range(len(files)):
file_name, extension = os.path.splitext(files[file_num])
# print(file_name + " " + extension)
if extension in [".png",".tif",".jpg",".bmp"]:
# read image:
image = imread(files[file_num])
image = rescale(image, rescale_factor, order=1,preserve_range = True)
image = np.uint8(image)
#imshow(image)
# get region props of the blue channel:
if(len(image.shape)<3):
stats.append(get_nuclei(image[:,:],file_name))
else:
stats.append(get_nuclei(image[:,:,nuc_chan],file_name))
# Get x and y data for model training and the coordinate for each image:
# y_data is boolean with True were pixel was marked as foci and false otherwise
x_data, y_data, coords = get_labeled_data(im_path_foci,stats,im_path_foci_marked,filt_range,freq,sc_range,rescale_factor,foci_chan, mark_chan)
# When done with everything go back to the main folder:
os.chdir(main_file_path)
###############################################################################
# This part is for model training assuming "get_labeled_data" was ran successfully
# get trainingsdata:
x_train_transformed, y_train, idx, s1, s2, p, mnmx = image_pipeline(x_data,y_data,removed_im = [],var_max = var_max, sampling = sampling)
# Chose the model to train:
# neural network:
model = MLPClassifier(alpha=0.1, batch_size = 2000, learning_rate = "adaptive", learning_rate_init = 0.1, max_iter = 300, tol = 10**-4, early_stopping = True)
parameters = {'batch_size':[100,500,1000,2000,3000,4000,5000],'alpha':[10**-4,10**-3,10**-2,10**-1,1]}
# random forest:
# clf = RandomForestClassifier(criterion = "entropy",min_weight_fraction_leaf = 0.005, n_estimators = 15,max_depth = 50, min_samples_leaf = 10,min_samples_split = 100, n_jobs = -1)
# model = AdaBoostClassifier(base_estimator = clf, n_estimators=5)
# parameters = {'base_estimator__min_weight_fraction_leaf':[0.0001,0.001,0.005],'base_estimator__n_estimators':[5,10,15,20],'base_estimator__min_samples_leaf':[10,20,100]}
# complement naive bayes:
# clf = ComplementNB(alpha = 0.0, norm = True)
# model = AdaBoostClassifier(base_estimator = clf, n_estimators=15)
# parameters = {'base_estimator__alpha': [0,0.01,0.02,0.03,0.04,0.05,0.06], 'base_estimator__norm': [True, False]}
# support vector machine:
# linear svm
# clf = LinearSVC(penalty = "l2", loss = "hinge", C = 2, class_weight = "balanced", max_iter = 5000)
# model = AdaBoostClassifier(base_estimator = clf, n_estimators=5,algorithm='SAMME')
# parameters = {"base_estimator__C": [0.1,0.3,0.6,1,2,3]}
print("Performing grid search ...")
# get best model parameters:
clf = GridSearchCV(model, parameters, cv = 3)
clf.fit(x_train_transformed, y_train)
###############################################################################
# train models based on on all but one of the images and test on the remaining
# one. Do this for all combinations of images.
# Save images and some resulting statistics.
# save path:
save_path = im_path_foci + "\Results Model Validation"
# set model:
# neural network:
# model = MLPClassifier(alpha=0.1, batch_size = 2000, learning_rate = "adaptive", learning_rate_init = 0.1, max_iter = 300, tol = 10**-4, early_stopping = True)
model = clf.best_estimator_
im_stats = []
# create data sets leaving out one image:
print("Training model (leave one out) ...")
for im in range(len(x_data)):
print("Current Image:" + str(im+1))
removed_im = [im]
x_train_transformed, y_train, idx, s1, s2, p, mnmx = image_pipeline(x_data,y_data,removed_im,var_max = 0.95, sampling = 1)
# use some defined model and train it with the x-featues:
model.fit(x_train_transformed, y_train)
# create variables for test image:
x_vals_im = | pd.DataFrame(x_data[removed_im[0]]) | pandas.DataFrame |
import sklearn.ensemble as ek
from sklearn.model_selection import train_test_split
from sklearn import tree
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import confusion_matrix
from sklearn.linear_model import LogisticRegression
import pickle
import pandas as pd
import numpy as np
import pyprind
import re
from collections import Counter
import math
import traceback
model_dir = r'C:\Users\86151\Desktop\Data Mining Homework\Wee 8\ML-for-SQL-Injection\ML_for_SQL\data\models\model.model'
def entropy(s):
p, lns = Counter(s), float(len(s))
return -sum(count / lns * math.log(count / lns, 2) for count in p.values())
def getFeatures(url,label):
result = []
url = str(url)
result.append(url)
num_len=0
capital_len=0
key_num=0
feature3=0
num_len=len(re.compile(r'\d').findall(url))
try:
if len(url)!=0:
num_f=num_len/len(url)#数字字符频率
capital_len=len(re.compile(r'[A-Z]').findall(url))
if len(url)!=0:
capital_f=capital_len/len(url)#大写字母频率
url=url.lower()
key_num=url.count('and%20')+url.count('or%20')+url.count('xor%20')+url.count('sysobjects%20')+url.count('version%20')+url.count('substr%20')+url.count('len%20')+url.count('substring%20')+url.count('exists%20')
key_num=key_num+url.count('mid%20')+url.count('asc%20')+url.count('inner join%20')+url.count('xp_cmdshell%20')+url.count('version%20')+url.count('exec%20')+url.count('having%20')+url.count('unnion%20')+url.count('order%20')+url.count('information schema')
key_num=key_num+url.count('load_file%20')+url.count('load data infile%20')+url.count('into outfile%20')+url.count('into dumpfile%20')
if len(url)!=0:
space_f=(url.count(" ")+url.count("%20"))/len(url)#空格百分比
special_f=(url.count("{")*2+url.count('28%')*2+url.count('NULL')+url.count('[')+url.count('=')+url.count('?'))/len(url)
prefix_f=(url.count('\\x')+url.count('&')+url.count('\\u')+url.count('%'))/len(url)
result.append(len(url))
result.append(key_num)
result.append(capital_f)
result.append(num_f)
result.append(space_f)
result.append(special_f)
result.append(prefix_f)
result.append(entropy(url))
result.append(str(label))
return result
except:
traceback.print_exc()
exit(-1)
def plot_feature_importances(feature_importances,title,feature_names):
# 将重要性值标准化
feature_importances = 100.0*(feature_importances/max(feature_importances))
# 将得分从高到低排序
index_sorted = np.flipud(np.argsort(feature_importances))
# 让X坐标轴上的标签居中显示
pos = np.arange(index_sorted.shape[0])+0.5
# plt.figure(figsize=(16,4))
# plt.bar(pos,feature_importances[index_sorted],align='center')
# plt.xticks(pos,feature_names[index_sorted])
# plt.ylabel('Relative Importance')
# plt.title(title)
# plt.show()
if __name__ == '__main__':
# 提取特征
df = | pd.read_csv("data/dataset.csv") | pandas.read_csv |
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import math
import scipy.stats as stats
from matplotlib import gridspec
from matplotlib.lines import Line2D
from .util import *
import seaborn as sns
from matplotlib.ticker import FormatStrFormatter
import matplotlib.pylab as pl
import matplotlib.dates as mdates
from matplotlib.patches import Patch
from matplotlib.lines import Line2D
import matplotlib.patheffects as pe
from .sanker import Sanker
import imageio
class Visualizer():
def __init__(self, district_list, private_list, city_list, contract_list, bank_list, leiu_list):
self.district_list = district_list.copy()
self.private_list = private_list.copy()
for x in city_list:
self.private_list.append(x)
self.contract_list = contract_list
self.bank_list = bank_list
self.leiu_list = leiu_list
self.private_districts = {}
for x in self.private_list:
self.private_districts[x.name] = []
for xx in x.district_list:
self.private_districts[x.name].append(xx)
inflow_inputs = pd.read_csv('calfews_src/data/input/calfews_src-data.csv', index_col=0, parse_dates=True)
x2_results = pd.read_csv('calfews_src/data/input/x2DAYFLOW.csv', index_col=0, parse_dates=True)
self.observations = inflow_inputs.join(x2_results)
self.observations['delta_outflow'] = self.observations['delta_inflow'] + self.observations['delta_depletions'] - self.observations['HRO_pump'] - self.observations['TRP_pump']
self.index_o = self.observations.index
self.T_o = len(self.observations)
self.day_month_o = self.index_o.day
self.month_o = self.index_o.month
self.year_o = self.index_o.year
kern_bank_observations = pd.read_csv('calfews_src/data/input/kern_water_bank_historical.csv')
kern_bank_observations = kern_bank_observations.set_index('Year')
semitropic_bank_observations = pd.read_csv('calfews_src/data/input/semitropic_bank_historical.csv')
semitropic_bank_observations = semitropic_bank_observations.set_index('Year')
total_bank_kwb = np.zeros(self.T_o)
total_bank_smi = np.zeros(self.T_o)
for x in range(0, self.T_o):
if self.month_o[x] > 9:
year_str = self.year_o[x]
else:
year_str = self.year_o[x] - 1
if self.month_o[x] == 9 and self.day_month_o[x] == 30:
year_str = self.year_o[x]
total_bank_kwb[x] = kern_bank_observations.loc[year_str, 'Ag'] + kern_bank_observations.loc[year_str, 'Mixed Purpose']
deposit_history = semitropic_bank_observations[semitropic_bank_observations.index <= year_str]
total_bank_smi[x] = deposit_history['Metropolitan'].sum() + deposit_history['South Bay'].sum()
self.observations['kwb_accounts'] = pd.Series(total_bank_kwb, index=self.observations.index)
self.observations['smi_accounts'] = pd.Series(total_bank_smi, index=self.observations.index)
def get_results_sensitivity_number(self, results_file, sensitivity_number, start_month, start_year, start_day):
self.values = {}
numdays_index = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
with h5py.File(results_file, 'r') as f:
data = f['s' + sensitivity_number]
names = data.attrs['columns']
names = list(map(lambda x: str(x).split("'")[1], names))
df_data = pd.DataFrame(data[:], columns=names)
for x in df_data:
self.values[x] = df_data[x]
datetime_index = []
monthcount = start_month
yearcount = start_year
daycount = start_day
leapcount = np.remainder(start_year, 4)
for t in range(0, len(self.values[x])):
datetime_index.append(str(yearcount) + '-' + str(monthcount) + '-' + str(daycount))
daycount += 1
if leapcount == 0 and monthcount == 2:
numdays_month = numdays_index[monthcount - 1] + 1
else:
numdays_month = numdays_index[monthcount - 1]
if daycount > numdays_month:
daycount = 1
monthcount += 1
if monthcount == 13:
monthcount = 1
yearcount += 1
leapcount += 1
if leapcount == 4:
leapcount = 0
self.values['Datetime'] = pd.to_datetime(datetime_index)
self.values = pd.DataFrame(self.values)
self.values = self.values.set_index('Datetime')
self.index = self.values.index
self.T = len(self.values.index)
self.day_year = self.index.dayofyear
self.day_month = self.index.day
self.month = self.index.month
self.year = self.index.year
self.starting_year = self.index.year[0]
self.ending_year = self.index.year[-1]
self.number_years = self.ending_year - self.starting_year
total_kwb_sim = np.zeros(len(self.values))
total_smi_sim = np.zeros(len(self.values))
for district_partner in ['DLR', 'KCWA', 'ID4', 'SMI', 'TJC', 'WON', 'WRM']:
total_kwb_sim += self.values['kwb_' + district_partner]
self.values['kwb_total'] = pd.Series(total_kwb_sim, index = self.values.index)
for district_partner in ['SOB', 'MET']:
total_smi_sim += self.values['semitropic_' + district_partner]
self.values['smi_total'] = pd.Series(total_smi_sim, index = self.values.index)
def set_figure_params(self):
self.figure_params = {}
self.figure_params['delta_pumping'] = {}
self.figure_params['delta_pumping']['extended_simulation'] = {}
self.figure_params['delta_pumping']['extended_simulation']['outflow_list'] = ['delta_outflow', 'delta_outflow']
self.figure_params['delta_pumping']['extended_simulation']['pump1_list'] = ['delta_HRO_pump', 'HRO_pump']
self.figure_params['delta_pumping']['extended_simulation']['pump2_list'] = ['delta_TRP_pump', 'TRP_pump']
self.figure_params['delta_pumping']['extended_simulation']['scenario_labels'] = ['Model Validation', 'Extended Simulation']
self.figure_params['delta_pumping']['extended_simulation']['simulation_labels'] = ['delta_HRO_pump', 'delta_TRP_pump', 'delta_outflow']
self.figure_params['delta_pumping']['extended_simulation']['observation_labels'] = ['HRO_pump', 'TRP_pump', 'delta_outflow']
self.figure_params['delta_pumping']['extended_simulation']['agg_list'] = ['AS-OCT', 'AS-OCT', 'D']
self.figure_params['delta_pumping']['extended_simulation']['unit_mult'] = [1.0, 1.0, cfs_tafd]
self.figure_params['delta_pumping']['extended_simulation']['max_value_list'] = [5000, 5000, 15]
self.figure_params['delta_pumping']['extended_simulation']['use_log_list'] = [False, False, True]
self.figure_params['delta_pumping']['extended_simulation']['use_cdf_list'] = [False, False, True]
self.figure_params['delta_pumping']['extended_simulation']['scenario_type_list'] = ['observation', 'validation', 'scenario']
self.figure_params['delta_pumping']['extended_simulation']['x_label_list'] = ['Total Pumping, SWP Delta Pumps (tAF/year)', 'Total Pumping, CVP Delta Pumps (tAF/year)', 'Daily Exceedence Probability', '']
self.figure_params['delta_pumping']['extended_simulation']['y_label_list'] = ['Probability Density', 'Probability Density', 'Daily Delta Outflow (tAF)', 'Relative Frequency of Water-year Types within Simulation']
self.figure_params['delta_pumping']['extended_simulation']['legend_label_names1'] = ['Historical (1996-2016) Observations', 'Historical (1996-2016) Model Validation', 'Extended Simulation']
self.figure_params['delta_pumping']['extended_simulation']['legend_label_names2'] = ['Critical', 'Dry', 'Below Normal', 'Above Normal', 'Wet']
self.figure_params['state_estimation'] = {}
for x in ['publication', 'sacramento', 'sanjoaquin', 'tulare']:
self.figure_params['state_estimation'][x] = {}
self.figure_params['state_estimation'][x]['non_log'] = ['Snowpack (SWE)',]
self.figure_params['state_estimation'][x]['predictor values'] = ['Mean Inflow, Prior 30 Days (tAF/day)','Snowpack (SWE)']
self.figure_params['state_estimation'][x]['colorbar_label_index'] = [0, 30, 60, 90, 120, 150, 180]
self.figure_params['state_estimation'][x]['colorbar_label_list'] = ['Oct', 'Nov', 'Dec', 'Jan', 'Feb', 'Mar', 'Apr']
self.figure_params['state_estimation'][x]['subplot_annotations'] = ['A', 'B', 'C', 'D']
self.figure_params['state_estimation'][x]['forecast_periods'] = [30,'SNOWMELT']
self.figure_params['state_estimation'][x]['all_cols'] = ['DOWY', 'Snowpack', '30MA']
self.figure_params['state_estimation'][x]['forecast_values'] = []
for forecast_days in self.figure_params['state_estimation'][x]['forecast_periods']:
if forecast_days == 'SNOWMELT':
self.figure_params['state_estimation'][x]['forecast_values'].append('Flow Estimation, Snowmelt Season (tAF)')
self.figure_params['state_estimation'][x]['all_cols'].append('Snowmelt Flow')
else:
self.figure_params['state_estimation'][x]['forecast_values'].append('Flow Estimation, Next ' + str(forecast_days) + ' Days (tAF)')
self.figure_params['state_estimation'][x]['all_cols'].append(str(forecast_days) + ' Day Flow')
self.figure_params['state_estimation']['publication']['watershed_keys'] = ['SHA', 'ORO', 'MIL', 'ISB']
self.figure_params['state_estimation']['publication']['watershed_labels'] = ['Shasta', 'Oroville', 'Millerton', 'Isabella']
self.figure_params['state_estimation']['sacramento']['watershed_keys'] = ['SHA', 'ORO', 'FOL', 'YRS']
self.figure_params['state_estimation']['sacramento']['watershed_labels'] = ['Shasta', 'Oroville', 'Folsom', 'New Bullards Bar']
self.figure_params['state_estimation']['sanjoaquin']['watershed_keys'] = ['NML', 'DNP', 'EXC', 'MIL']
self.figure_params['state_estimation']['sanjoaquin']['watershed_labels'] = ['New Melones', '<NAME>', 'Exchequer', 'Millerton']
self.figure_params['state_estimation']['tulare']['watershed_keys'] = ['PFT', 'KWH', 'SUC', 'ISB']
self.figure_params['state_estimation']['tulare']['watershed_labels'] = ['Pine Flat', 'Kaweah', 'Success', 'Isabella']
self.figure_params['model_validation'] = {}
for x in ['delta', 'sierra', 'sanluis', 'bank']:
self.figure_params['model_validation'][x] = {}
self.figure_params['model_validation']['delta']['title_labels'] = ['State Water Project Pumping', 'Central Valley Project Pumping', 'Delta X2 Location']
num_subplots = len(self.figure_params['model_validation']['delta']['title_labels'])
self.figure_params['model_validation']['delta']['label_name_1'] = ['delta_HRO_pump', 'delta_TRP_pump', 'delta_x2']
self.figure_params['model_validation']['delta']['label_name_2'] = ['HRO_pump', 'TRP_pump', 'DAY_X2']
self.figure_params['model_validation']['delta']['unit_converstion_1'] = [1.0, 1.0, 1.0]
self.figure_params['model_validation']['delta']['unit_converstion_2'] = [cfs_tafd, cfs_tafd, 1.0]
self.figure_params['model_validation']['delta']['y_label_timeseries'] = ['Pumping (tAF/week)', 'Pumping (tAF/week)', 'X2 inland distance (km)']
self.figure_params['model_validation']['delta']['y_label_scatter'] = ['(tAF/yr)', '(tAF/yr)', '(km)']
self.figure_params['model_validation']['delta']['timeseries_timestep'] = ['W', 'W', 'W']
self.figure_params['model_validation']['delta']['scatter_timestep'] = ['AS-OCT', 'AS-OCT', 'M']
self.figure_params['model_validation']['delta']['aggregation_methods'] = ['sum', 'sum', 'mean']
self.figure_params['model_validation']['delta']['notation_location'] = ['top'] * num_subplots
self.figure_params['model_validation']['delta']['show_legend'] = [True] * num_subplots
self.figure_params['model_validation']['sierra']['title_labels'] = ['Shasta', 'Oroville', 'Folsom', 'New Bullards Bar', 'New Melones', '<NAME>', 'Exchequer', 'Millerton', 'Pine Flat', 'Kaweah', 'Success', 'Isabella']
num_subplots = len(self.figure_params['model_validation']['sierra']['title_labels'])
self.figure_params['model_validation']['sierra']['label_name_1'] = ['shasta_S', 'oroville_S', 'folsom_S', 'yuba_S', 'newmelones_S', 'donpedro_S', 'exchequer_S', 'millerton_S', 'pineflat_S', 'kaweah_S', 'success_S', 'isabella_S']
self.figure_params['model_validation']['sierra']['label_name_2'] = ['SHA_storage', 'ORO_storage', 'FOL_storage', 'YRS_storage', 'NML_storage', 'DNP_storage', 'EXC_storage', 'MIL_storage', 'PFT_storage', 'KWH_storage', 'SUC_storage', 'ISB_storage']
self.figure_params['model_validation']['sierra']['unit_converstion_1'] = [1.0/1000.0] * num_subplots
self.figure_params['model_validation']['sierra']['unit_converstion_2'] = [1.0/1000000.0] * num_subplots
self.figure_params['model_validation']['sierra']['y_label_timeseries'] = ['Storage (mAF)'] * num_subplots
self.figure_params['model_validation']['sierra']['y_label_scatter'] = []
self.figure_params['model_validation']['sierra']['timeseries_timestep'] = ['W'] * num_subplots
self.figure_params['model_validation']['sierra']['scatter_timestep'] = []
self.figure_params['model_validation']['sierra']['aggregation_methods'] = ['mean'] * num_subplots
self.figure_params['model_validation']['sierra']['notation_location'] = ['bottom'] * num_subplots
self.figure_params['model_validation']['sierra']['show_legend'] = [False] * num_subplots
counter_kaweah = self.figure_params['model_validation']['sierra']['title_labels'].index('Kaweah')
counter_success = self.figure_params['model_validation']['sierra']['title_labels'].index('Success')
counter_isabella = self.figure_params['model_validation']['sierra']['title_labels'].index('Isabella')
self.figure_params['model_validation']['sierra']['notation_location'][counter_kaweah] = 'top'
self.figure_params['model_validation']['sierra']['notation_location'][counter_success] = 'topright'
self.figure_params['model_validation']['sierra']['show_legend'][counter_isabella] = True
self.figure_params['model_validation']['sanluis']['title_labels'] = ['State (SWP) Portion, San Luis Reservoir', 'Federal (CVP) Portion, San Luis Reservoir']
num_subplots = len(self.figure_params['model_validation']['sanluis']['title_labels'])
self.figure_params['model_validation']['sanluis']['label_name_1'] = ['sanluisstate_S', 'sanluisfederal_S']
self.figure_params['model_validation']['sanluis']['label_name_2'] = ['SLS_storage', 'SLF_storage']
self.figure_params['model_validation']['sanluis']['unit_converstion_1'] = [1.0/1000.0] * num_subplots
self.figure_params['model_validation']['sanluis']['unit_converstion_2'] = [1.0/1000000.0] * num_subplots
self.figure_params['model_validation']['sanluis']['y_label_timeseries'] = ['Storage (mAF)'] * num_subplots
self.figure_params['model_validation']['sanluis']['y_label_scatter'] = ['(mAF)'] * num_subplots
self.figure_params['model_validation']['sanluis']['timeseries_timestep'] = ['W'] * num_subplots
self.figure_params['model_validation']['sanluis']['scatter_timestep'] = ['M'] * num_subplots
self.figure_params['model_validation']['sanluis']['aggregation_methods'] = ['point'] * num_subplots
self.figure_params['model_validation']['sanluis']['notation_location'] = ['top'] * num_subplots
self.figure_params['model_validation']['sanluis']['show_legend'] = [True] * num_subplots
self.figure_params['model_validation']['bank']['title_labels'] = ['Kern Water Bank Accounts', 'Semitropic Water Bank Accounts']
num_subplots = len(self.figure_params['model_validation']['bank']['title_labels'])
self.figure_params['model_validation']['bank']['label_name_1'] = ['kwb_total', 'smi_total']
self.figure_params['model_validation']['bank']['label_name_2'] = ['kwb_accounts', 'smi_accounts']
self.figure_params['model_validation']['bank']['unit_converstion_1'] = [1.0/1000.0] * num_subplots
self.figure_params['model_validation']['bank']['unit_converstion_2'] = [1.0/1000000.0, 1.0/1000.0]
self.figure_params['model_validation']['bank']['y_label_timeseries'] = ['Storage (mAF)'] * num_subplots
self.figure_params['model_validation']['bank']['y_label_scatter'] = ['(mAF)'] * num_subplots
self.figure_params['model_validation']['bank']['timeseries_timestep'] = ['W'] * num_subplots
self.figure_params['model_validation']['bank']['scatter_timestep'] = ['AS-OCT'] * num_subplots
self.figure_params['model_validation']['bank']['aggregation_methods'] = ['change'] * num_subplots
self.figure_params['model_validation']['bank']['notation_location'] = ['top'] * num_subplots
self.figure_params['model_validation']['bank']['show_legend'] = [False] * num_subplots
self.figure_params['model_validation']['bank']['show_legend'][0] = True
self.figure_params['state_response'] = {}
self.figure_params['state_response']['sanluisstate_losthills'] = {}
self.figure_params['state_response']['sanluisstate_losthills']['contract_list'] = ['swpdelta',]
self.figure_params['state_response']['sanluisstate_losthills']['contributing_reservoirs'] = ['delta_uncontrolled_swp', 'oroville', 'yuba']
self.figure_params['state_response']['sanluisstate_losthills']['groundwater_account_names'] = ['LHL','WON']
self.figure_params['state_response']['sanluisstate_losthills']['reservoir_features'] = ['S', 'days_til_full', 'flood_deliveries']
self.figure_params['state_response']['sanluisstate_losthills']['reservoir_feature_colors'] = ['teal', '#3A506B', '#74B3CE', 'steelblue']
self.figure_params['state_response']['sanluisstate_losthills']['district_contracts'] = ['tableA',]
self.figure_params['state_response']['sanluisstate_losthills']['subplot_titles'] = ['State Water Project Delta Operations', 'Lost Hills Drought Management', 'San Luis Reservoir Operations', 'Lost Hills Flood Management']
self.figure_params['state_response']['sanluisstate_losthills']['legend_list_1'] = ['Y.T.D Delta Pumping', 'Projected Unstored Exports', 'Projected Stored Exports, Oroville', 'Projected Stored Exports, New Bullards']
self.figure_params['state_response']['sanluisstate_losthills']['legend_list_2'] = ['Storage', 'Projected Days to Fill', 'Flood Release Deliveries']
self.figure_params['state_response']['sanluisstate_losthills']['legend_list_3'] = ['Remaining SW Allocation', 'SW Deliveries', 'Private GW Pumping', 'District GW Bank Recovery', 'Remaining GW Bank Recovery Capacity']
self.figure_params['state_response']['sanluisstate_losthills']['legend_list_4'] = ['Carryover Recharge Capacity', 'Recharged from Contract Allocation' 'Recharge of Uncontrolled Flood Spills']
self.figure_params['state_response'] = {}
self.figure_params['state_response']['sanluisstate_wheeler'] = {}
self.figure_params['state_response']['sanluisstate_wheeler']['contract_list'] = ['swpdelta',]
self.figure_params['state_response']['sanluisstate_wheeler']['contributing_reservoirs'] = ['delta_uncontrolled_swp', 'oroville', 'yuba']
self.figure_params['state_response']['sanluisstate_wheeler']['groundwater_account_names'] = ['WRM']
self.figure_params['state_response']['sanluisstate_wheeler']['reservoir_features'] = ['S', 'days_til_full', 'flood_deliveries']
self.figure_params['state_response']['sanluisstate_wheeler']['reservoir_feature_colors'] = ['teal', '#3A506B', '#74B3CE', 'lightsteelblue']
self.figure_params['state_response']['sanluisstate_wheeler']['district_contracts'] = ['tableA',]
self.figure_params['state_response']['sanluisstate_wheeler']['subplot_titles'] = ['State Water Project Delta Operations', 'Wheeler Ridge Drought Management', 'San Luis Reservoir Operations', 'Wheeler Ridge Flood Management']
self.figure_params['state_response']['sanluisstate_wheeler']['legend_list_1'] = ['Y.T.D Delta Pumping', 'Projected Unstored Exports', 'Projected Stored Exports, Oroville', 'Projected Stored Exports, New Bullards']
self.figure_params['state_response']['sanluisstate_wheeler']['legend_list_2'] = ['Storage', 'Projected Days to Fill', 'Flood Release Deliveries']
self.figure_params['state_response']['sanluisstate_wheeler']['legend_list_3'] = ['Remaining SW Allocation', 'SW Deliveries', 'Private GW Pumping', 'District GW Bank Recovery', 'Remaining GW Bank Recovery Capacity']
self.figure_params['state_response']['sanluisstate_wheeler']['legend_list_4'] = ['Carryover Recharge Capacity', 'Recharge of Uncontrolled Flood Spills', 'Recharged from Contract Allocation']
self.figure_params['district_water_use'] = {}
self.figure_params['district_water_use']['physical'] = {}
self.figure_params['district_water_use']['physical']['district_groups'] = ['Municipal Districts', 'Kern County Water Agency', 'CVP - Friant Contractors', 'CVP - San Luis Contractors', 'Groundwater Banks']
self.figure_params['district_water_use']['physical']['Municipal Districts'] = ['bakersfield', 'ID4', 'fresno', 'southbay', 'socal', 'centralcoast']
self.figure_params['district_water_use']['physical']['Kern County Water Agency'] = ['berrenda', 'belridge', 'buenavista', 'cawelo', 'henrymiller', 'losthills', 'rosedale', 'semitropic', 'tehachapi', 'tejon', 'westkern', 'wheeler', 'northkern', 'kerntulare']
self.figure_params['district_water_use']['physical']['CVP - Friant Contractors'] = ['arvin', 'delano', 'pixley', 'exeter', 'kerntulare', 'lindmore', 'lindsay', 'lowertule', 'porterville', 'saucelito', 'shaffer', 'sosanjoaquin', 'teapot', 'terra', 'chowchilla', 'maderairr', 'tulare', 'fresnoid']
self.figure_params['district_water_use']['physical']['CVP - San Luis Contractors'] = ['westlands', 'panoche', 'sanluiswater', 'delpuerto']
self.figure_params['district_water_use']['physical']['Groundwater Banks'] = ['stockdale', 'kernriverbed', 'poso', 'pioneer', 'kwb', 'b2800', 'irvineranch', 'northkernwb']
self.figure_params['district_water_use']['physical']['subplot columns'] = 2
self.figure_params['district_water_use']['physical']['color map'] = 'YlGbBu_r'
self.figure_params['district_water_use']['physical']['write file'] = True
self.figure_params['district_water_use']['annual'] = {}
self.figure_params['district_water_use']['annual']['district_groups'] = ['Municipal Districts', 'Kern County Water Agency', 'CVP - Friant Contractors', 'CVP - San Luis Contractors']
self.figure_params['district_water_use']['annual']['Municipal Districts'] = ['bakersfield', 'ID4', 'fresno', 'southbay', 'socal', 'centralcoast']
self.figure_params['district_water_use']['annual']['Kern County Water Agency'] = ['berrenda', 'belridge', 'buenavista', 'cawelo', 'henrymiller', 'losthills', 'rosedale', 'semitropic', 'tehachapi', 'tejon', 'westkern', 'wheeler']
self.figure_params['district_water_use']['annual']['CVP - Friant Contractors'] = ['arvin', 'delano', 'pixley', 'exeter', 'kerntulare', 'lindmore', 'lindsay', 'lowertule', 'porterville', 'saucelito', 'shaffer', 'sosanjoaquin', 'teapot', 'terra', 'chowchilla', 'maderairr', 'tulare', 'fresnoid']
self.figure_params['district_water_use']['annual']['CVP - San Luis Contractors'] = ['westlands', 'panoche', 'sanluiswater', 'delpuerto']
self.figure_params['district_water_use']['annual']['subplot columns'] = 2
self.figure_params['district_water_use']['annual']['color map'] = 'BrBG_r'
self.figure_params['district_water_use']['annual']['write file'] = True
self.figure_params['flow_diagram'] = {}
self.figure_params['flow_diagram']['tulare'] = {}
self.figure_params['flow_diagram']['tulare']['column1'] = ['Shasta', 'Folsom', 'Oroville', 'New Bullards', 'Uncontrolled']
self.figure_params['flow_diagram']['tulare']['row1'] = ['Delta Outflow', 'Carryover',]
self.figure_params['flow_diagram']['tulare']['column2'] = ['San Luis (Fed)', 'San Luis (State)', 'Millerton', 'Isabella', 'Pine Flat', 'Kaweah', 'Success']
self.figure_params['flow_diagram']['tulare']['row2'] = ['Carryover',]
self.figure_params['flow_diagram']['tulare']['column3'] = ['Exchange', 'CVP-Delta', 'Cross Valley', 'State Water Project', 'Friant Class 1','Friant Class 2', 'Kern River', 'Kings River', 'Kaweah River', 'Tule River', 'Flood']
self.figure_params['flow_diagram']['tulare']['row3'] = ['Private Pumping', 'GW Banks']
self.figure_params['flow_diagram']['tulare']['column4'] = ['Exchange', 'CVP-Delta', 'Urban', 'KCWA', 'CVP-Friant','Other']
self.figure_params['flow_diagram']['tulare']['row4'] = ['Carryover',]
self.figure_params['flow_diagram']['tulare']['column5'] = ['Irrigation', 'Urban', 'In-Lieu Recharge', 'Direct Recharge']
self.figure_params['flow_diagram']['tulare']['titles'] = ['Sacramento Basin\nSupplies', 'Tulare Basin\nSupplies', 'Surface Water\nContract Allocations', 'Contractor Groups', 'Water Use Type']
def scenario_compare(self, folder_name, figure_name, plot_name, validation_values, show_plot):
outflow_list = self.figure_params[figure_name][plot_name]['outflow_list']
pump1_list = self.figure_params[figure_name][plot_name]['pump1_list']
pump2_list = self.figure_params[figure_name][plot_name]['pump2_list']
scenario_labels = self.figure_params[figure_name][plot_name]['scenario_labels']
simulation_labels = self.figure_params[figure_name][plot_name]['simulation_labels']
observation_labels = self.figure_params[figure_name][plot_name]['observation_labels']
agg_list = self.figure_params[figure_name][plot_name]['agg_list']
unit_mult = self.figure_params[figure_name][plot_name]['unit_mult']
max_value_list = self.figure_params[figure_name][plot_name]['max_value_list']
use_log_list = self.figure_params[figure_name][plot_name]['use_log_list']
use_cdf_list = self.figure_params[figure_name][plot_name]['use_cdf_list']
scenario_type_list = self.figure_params[figure_name][plot_name]['scenario_type_list']
x_label_list = self.figure_params[figure_name][plot_name]['x_label_list']
y_label_list = self.figure_params[figure_name][plot_name]['y_label_list']
legend_label_names1 = self.figure_params[figure_name][plot_name]['legend_label_names1']
legend_label_names2 = self.figure_params[figure_name][plot_name]['legend_label_names2']
color1 = sns.color_palette('spring', n_colors = 3)
color2 = sns.color_palette('summer', n_colors = 3)
color_list = np.array([color1[0], color1[2], color2[0]])
max_y_val = np.zeros(len(simulation_labels))
fig = plt.figure(figsize = (20, 16))
gs = gridspec.GridSpec(3,2, width_ratios=[3,1], figure = fig)
ax1 = plt.subplot(gs[0, 0])
ax2 = plt.subplot(gs[1, 0])
ax3 = plt.subplot(gs[2, 0])
ax4 = plt.subplot(gs[:, 1])
axes_list = [ax1, ax2, ax3]
counter = 0
for sim_label, obs_label, agg, max_value, use_log, use_cdf, ax_loop in zip(simulation_labels, observation_labels, agg_list, max_value_list, use_log_list, use_cdf_list, axes_list):
data_type_dict = {}
data_type_dict['scenario'] = self.values[sim_label].resample(agg).sum() * unit_mult[0]
data_type_dict['validation'] = validation_values[sim_label].resample(agg).sum() * unit_mult[1]
data_type_dict['observation'] = self.observations[obs_label].resample(agg).sum() * unit_mult[2]
if use_log:
for scen_type in scenario_type_list:
values_int = data_type_dict[scen_type]
data_type_dict[scen_type] = np.log(values_int[values_int > 0])
for scen_type in scenario_type_list:
max_y_val[counter] = max([max(data_type_dict[scen_type]), max_y_val[counter]])
counter += 1
if use_cdf:
for scen_type, color_loop in zip(scenario_type_list, color_list):
cdf_values = np.zeros(100)
values_int = data_type_dict[scen_type]
for x in range(0, 100):
x_val = int(np.ceil(max_value)) * (x/100)
cdf_values[x] = len(values_int[values_int > x_val])/len(values_int)
ax_loop.plot(cdf_values, np.arange(0, int(np.ceil(max_value)), int(np.ceil(max_value))/100), linewidth = 3, color = color_loop)
else:
pos = np.linspace(0, max_value, 101)
for scen_type, color_loop in zip(scenario_type_list, color_list):
kde_est = stats.gaussian_kde(data_type_dict[scen_type])
ax_loop.fill_between(pos, kde_est(pos), edgecolor = 'black', alpha = 0.6, facecolor = color_loop)
sri_dict = {}
sri_dict['validation'] = validation_values['delta_forecastSRI']
sri_dict['scenario'] = self.values['delta_forecastSRI']
sri_cutoffs = {}
sri_cutoffs['W'] = [9.2, 100]
sri_cutoffs['AN'] = [7.8, 9.2]
sri_cutoffs['BN'] = [6.6, 7.8]
sri_cutoffs['D'] = [5.4, 6.6]
sri_cutoffs['C'] = [0.0, 5.4]
wyt_list = ['W', 'AN', 'BN', 'D', 'C']
scenario_type_list = ['validation', 'scenario']
colors = sns.color_palette('RdBu_r', n_colors = 5)
percent_years = {}
for wyt in wyt_list:
percent_years[wyt] = np.zeros(len(scenario_type_list))
for scen_cnt, scen_type in enumerate(scenario_type_list):
ann_sri = []
for x_cnt, x in enumerate(sri_dict[scen_type]):
if sri_dict[scen_type].index.month[x_cnt] == 9 and sri_dict[scen_type].index.day[x_cnt] == 30:
ann_sri.append(x)
ann_sri = np.array(ann_sri)
for x_cnt, wyt in enumerate(wyt_list):
mask_value = (ann_sri >= sri_cutoffs[wyt][0]) & (ann_sri < sri_cutoffs[wyt][1])
percent_years[wyt][scen_cnt] = len(ann_sri[mask_value])/len(ann_sri)
colors = sns.color_palette('RdBu_r', n_colors = 5)
last_type = np.zeros(len(scenario_type_list))
for cnt, x in enumerate(wyt_list):
ax4.bar(['Validated Period\n(1997-2016)', 'Extended Simulation\n(1906-2016)'], percent_years[x], alpha = 1.0, label = wyt, facecolor = colors[cnt], edgecolor = 'black', bottom = last_type)
last_type += percent_years[x]
ax1.set_xlim([0.0, 500.0* np.ceil(max_y_val[0]/500.0)])
ax2.set_xlim([0.0, 500.0* np.ceil(max_y_val[1]/500.0)])
ax3.set_xlim([0.0, 1.0])
ax4.set_ylim([0, 1.15])
ax1.set_yticklabels('')
ax2.set_yticklabels('')
label_list = []
loc_list = []
for value_x in range(0, 120, 20):
label_list.append(str(value_x) + ' %')
loc_list.append(value_x/100.0)
ax4.set_yticklabels(label_list)
ax4.set_yticks(loc_list)
ax3.set_xticklabels(label_list)
ax3.set_xticks(loc_list)
ax3.set_yticklabels(['4', '8', '16', '32', '64', '125', '250', '500', '1000', '2000', '4000'])
ax3.set_yticks([np.log(4), np.log(8), np.log(16), np.log(32), np.log(64), np.log(125), np.log(250), np.log(500), np.log(1000), np.log(2000), np.log(4000)])
ax3.set_ylim([np.log(4), np.log(4000)])
for ax, x_lab, y_lab in zip([ax1, ax2, ax3, ax4], x_label_list, y_label_list):
ax.set_xlabel(x_lab, fontsize = 16, fontname = 'Gill Sans MT', fontweight = 'bold')
ax.set_ylabel(y_lab, fontsize = 16, fontname = 'Gill Sans MT', fontweight = 'bold')
ax.grid(False)
for tick in ax.get_xticklabels():
tick.set_fontname('Gill Sans MT')
tick.set_fontsize(14)
for tick in ax.get_yticklabels():
tick.set_fontname('Gill Sans MT')
tick.set_fontsize(14)
legend_elements = []
for x_cnt, x in enumerate(legend_label_names1):
legend_elements.append(Patch(facecolor = color_list[x_cnt], edgecolor = 'black', label = x))
ax1.legend(handles = legend_elements, loc = 'upper left', framealpha = 0.7, shadow = True, prop={'family':'Gill Sans MT','weight':'bold','size':14})
legend_elements_2 = []
for x_cnt, x in enumerate(legend_label_names2):
legend_elements_2.append(Patch(facecolor = colors[x_cnt], edgecolor = 'black', label = x))
ax4.legend(handles = legend_elements_2, loc = 'upper left', framealpha = 0.7, shadow = True, prop={'family':'Gill Sans MT','weight':'bold','size':14})
plt.savefig(folder_name + figure_name + '_' + plot_name + '.png', dpi = 150, bbox_inches = 'tight', pad_inches = 0.0)
if show_plot:
plt.show()
plt.close()
def make_deliveries_by_district(self, folder_name, figure_name, plot_name, scenario_name, show_plot):
if plot_name == 'annual':
name_bridge = {}
name_bridge['semitropic'] = 'KER01'
name_bridge['westkern'] = 'KER02'
name_bridge['wheeler'] = 'KER03'
name_bridge['kerndelta'] = 'KER04'
name_bridge['arvin'] = 'KER05'
name_bridge['belridge'] = 'KER06'
name_bridge['losthills'] = 'KER07'
name_bridge['northkern'] = 'KER08'
name_bridge['northkernwb'] = 'KER08'
name_bridge['ID4'] = 'KER09'
name_bridge['sosanjoaquin'] = 'KER10'
name_bridge['berrenda'] = 'KER11'
name_bridge['buenavista'] = 'KER12'
name_bridge['cawelo'] = 'KER13'
name_bridge['rosedale'] = 'KER14'
name_bridge['shaffer'] = 'KER15'
name_bridge['henrymiller'] = 'KER16'
name_bridge['kwb'] = 'KER17'
name_bridge['b2800'] = 'KER17'
name_bridge['pioneer'] = 'KER17'
name_bridge['irvineranch'] = 'KER17'
name_bridge['kernriverbed'] = 'KER17'
name_bridge['poso'] = 'KER17'
name_bridge['stockdale'] = 'KER17'
name_bridge['delano'] = 'KeT01'
name_bridge['kerntulare'] = 'KeT02'
name_bridge['lowertule'] = 'TUL01'
name_bridge['tulare'] = 'TUL02'
name_bridge['lindmore'] = 'TUL03'
name_bridge['saucelito'] = 'TUL04'
name_bridge['porterville'] = 'TUL05'
name_bridge['lindsay'] = 'TUL06'
name_bridge['exeter'] = 'TUL07'
name_bridge['terra'] = 'TUL08'
name_bridge['teapot'] = 'TUL09'
name_bridge['bakersfield'] = 'BAK'
name_bridge['fresno'] = 'FRE'
name_bridge['southbay'] = 'SOB'
name_bridge['socal'] = 'SOC'
name_bridge['tehachapi'] = 'TEH'
name_bridge['tejon'] = 'TEJ'
name_bridge['centralcoast'] = 'SLO'
name_bridge['pixley'] = 'PIX'
name_bridge['chowchilla'] = 'CHW'
name_bridge['maderairr'] = 'MAD'
name_bridge['fresnoid'] = 'FSI'
name_bridge['westlands'] = 'WTL'
name_bridge['panoche'] = 'PAN'
name_bridge['sanluiswater'] = 'SLW'
name_bridge['delpuerto'] = 'DEL'
elif plot_name == 'monthly':
name_bridge = {}
name_bridge['semitropic'] = 'Semitropic Water Storage District'
name_bridge['westkern'] = 'West Kern Water District'
name_bridge['wheeler'] = 'Wheeler Ridge-Maricopa Water Storage District'
name_bridge['kerndelta'] = 'Kern Delta Water District'
name_bridge['arvin'] = 'Arvin-Edison Water Storage District'
name_bridge['belridge'] = 'Belridge Water Storage District'
name_bridge['losthills'] = 'Lost Hills Water District'
name_bridge['northkern'] = 'North Kern Water Storage District'
name_bridge['northkernwb'] = 'North Kern Water Storage District'
name_bridge['ID4'] = 'Urban'
name_bridge['sosanjoaquin'] = 'Southern San Joaquin Municipal Utility District'
name_bridge['berrenda'] = 'Berrenda Mesa Water District'
name_bridge['buenavista'] = 'Buena Vista Water Storage District'
name_bridge['cawelo'] = 'Cawelo Water District'
name_bridge['rosedale'] = 'Rosedale-Rio Bravo Water Storage District'
name_bridge['shaffer'] = 'Shafter-Wasco Irrigation District'
name_bridge['henrymiller'] = 'Henry Miller Water District'
name_bridge['kwb'] = 'Kern Water Bank Authority'
name_bridge['b2800'] = 'Kern Water Bank Authority'
name_bridge['pioneer'] = 'Kern Water Bank Authority'
name_bridge['irvineranch'] = 'Kern Water Bank Authority'
name_bridge['kernriverbed'] = 'Kern Water Bank Authority'
name_bridge['poso'] = 'Kern Water Bank Authority'
name_bridge['stockdale'] = 'Kern Water Bank Authority'
name_bridge['delano'] = 'Delano-Earlimart Irrigation District'
name_bridge['kerntulare'] = 'Kern-Tulare Water District'
name_bridge['lowertule'] = 'Lower Tule River Irrigation District'
name_bridge['tulare'] = 'Tulare Irrigation District'
name_bridge['lindmore'] = 'Lindmore Irrigation District'
name_bridge['saucelito'] = 'Saucelito Irrigation District'
name_bridge['porterville'] = 'Porterville Irrigation District'
name_bridge['lindsay'] = 'Lindsay-Strathmore Irrigation District'
name_bridge['exeter'] = 'Exeter Irrigation District'
name_bridge['terra'] = 'Terra Bella Irrigation District'
name_bridge['teapot'] = 'Tea Pot Dome Water District'
name_bridge['bakersfield'] = 'Urban'
name_bridge['fresno'] = 'Urban'
name_bridge['southbay'] = 'Urban'
name_bridge['socal'] = 'Urban'
name_bridge['tehachapi'] = 'Tehachapi - Cummings County Water District'
name_bridge['tejon'] = 'Tejon-Castac Water District'
name_bridge['centralcoast'] = 'SLO'
name_bridge['pixley'] = 'Pixley Irrigation District'
name_bridge['chowchilla'] = 'Chowchilla Water District'
name_bridge['maderairr'] = 'Madera Irrigation District'
name_bridge['fresnoid'] = 'Fresno Irrigation District'
name_bridge['westlands'] = 'Westlands Water District'
name_bridge['panoche'] = 'Panoche Water District'
name_bridge['sanluiswater'] = 'San Luis Water District'
name_bridge['delpuerto'] = 'Del Puerto Water District'
name_bridge['alta'] = 'Alta Irrigation District'
name_bridge['consolidated'] = 'Consolidated Irrigation District'
location_type = plot_name
self.total_irrigation = {}
self.total_recharge = {}
self.total_pumping = {}
self.total_flood_purchases = {}
self.total_recovery_rebate = {}
self.total_recharge_sales = {}
self.total_recharge_purchases = {}
self.total_recovery_sales = {}
self.total_recovery_purchases = {}
for bank in self.bank_list:
self.total_irrigation[bank.name] = np.zeros(self.number_years*12)
self.total_recharge[bank.name] = np.zeros(self.number_years*12)
self.total_pumping[bank.name] = np.zeros(self.number_years*12)
self.total_flood_purchases[bank.name] = np.zeros(self.number_years*12)
self.total_recovery_rebate[bank.name] = np.zeros(self.number_years*12)
self.total_recharge_sales[bank.name] = np.zeros(self.number_years*12)
self.total_recharge_purchases[bank.name] = np.zeros(self.number_years*12)
self.total_recovery_sales[bank.name] = np.zeros(self.number_years*12)
self.total_recovery_purchases[bank.name] = np.zeros(self.number_years*12)
for district in self.district_list:
self.total_irrigation[district.name] = np.zeros(self.number_years*12)
self.total_recharge[district.name] = np.zeros(self.number_years*12)
self.total_pumping[district.name] = np.zeros(self.number_years*12)
self.total_flood_purchases[district.name] = np.zeros(self.number_years*12)
self.total_recovery_rebate[district.name] = np.zeros(self.number_years*12)
self.total_recharge_sales[district.name] = np.zeros(self.number_years*12)
self.total_recharge_purchases[district.name] = np.zeros(self.number_years*12)
self.total_recovery_sales[district.name] = np.zeros(self.number_years*12)
self.total_recovery_purchases[district.name] = np.zeros(self.number_years*12)
date_list_labels = []
for year_num in range(self.starting_year, 2017):
start_month = 1
end_month = 13
if year_num == self.starting_year:
start_month = 10
if year_num == 2016:
end_month = 10
for month_num in range(start_month, end_month):
date_string_start = str(year_num) + '-' + str(month_num) + '-01'
date_list_labels.append(date_string_start)
for district in self.district_list:
inleiu_name = district.name + '_inleiu_irrigation'
inleiu_recharge_name = district.name + '_inleiu_recharge'
direct_recover_name = district.name + '_recover_banked'
indirect_surface_name = district.name + '_exchanged_SW'
indirect_ground_name = district.name + '_exchanged_GW'
inleiu_pumping_name = district.name + '_leiupumping'
pumping_name = district.name + '_pumping'
recharge_name = district.name + '_' + district.key + '_recharged'
numdays_month = [31, 28, 31, 30, 31, 30, 31, 31, 29, 31, 30, 31]
for year_num in range(0, self.number_years+1):
year_str = str(year_num + self.starting_year)
start_month = 1
end_month = 13
if year_num == 0:
start_month = 10
if year_num == self.number_years:
end_month = 10
for month_num in range(start_month, end_month):
if month_num == 1:
month_num_prev = '12'
year_str_prior = str(year_num + self.starting_year - 1)
end_day_prior = str(numdays_month[11])
else:
month_num_prev = str(month_num - 1)
year_str_prior = str(year_num + self.starting_year)
end_day_prior = str(numdays_month[month_num-2])
date_string_current = year_str + '-' + str(month_num) + '-' + str(numdays_month[month_num-1])
date_string_prior = year_str_prior + '-' + month_num_prev + '-' + end_day_prior
###GW/SW exchanges,
if indirect_surface_name in self.values:
if month_num == 10:
total_delivery = self.values.loc[pd.DatetimeIndex([date_string_current]), indirect_surface_name].values[0]
else:
total_delivery = self.values.loc[pd.DatetimeIndex([date_string_current]), indirect_surface_name].values[0] - self.values.loc[pd.DatetimeIndex([date_string_prior]), indirect_surface_name].values[0]
#count irrigation deliveries for district that gave up SW (for GW in canal)
self.total_irrigation[district.name][year_num*12 + month_num - 10] += total_delivery
###GW/SW exchanges,
if indirect_ground_name in self.values:
if month_num == 10:
total_delivery = self.values.loc[pd.DatetimeIndex([date_string_current]), indirect_ground_name].values[0]
else:
total_delivery = self.values.loc[pd.DatetimeIndex([date_string_current]), indirect_ground_name].values[0] - self.values.loc[pd.DatetimeIndex([date_string_prior]), indirect_ground_name].values[0]
self.total_recovery_purchases[district.name][year_num*12 + month_num - 10] += total_delivery
##In leiu deliveries for irrigation
if inleiu_name in self.values:
if month_num == 10:
total_delivery = self.values.loc[pd.DatetimeIndex([date_string_current]), inleiu_name].values[0]
else:
total_delivery = self.values.loc[pd.DatetimeIndex([date_string_current]), inleiu_name].values[0] - self.values.loc[pd.DatetimeIndex([date_string_prior]), inleiu_name].values[0]
#attibute inleiu deliveries for irrigation to district operating the bank
self.total_irrigation[district.name][year_num*12 + month_num - 10] += total_delivery
self.total_recharge_sales[district.name][year_num*12 + month_num - 10] += total_delivery
if inleiu_recharge_name in self.values:
if month_num == 10:
total_recharge = self.values.loc[pd.DatetimeIndex([date_string_current]), inleiu_recharge_name].values[0]
else:
total_recharge = self.values.loc[pd.DatetimeIndex([date_string_current]), inleiu_recharge_name].values[0] - self.values.loc[pd.DatetimeIndex([date_string_prior]), inleiu_recharge_name].values[0]
#attibute inleiu deliveries for irrigation to district operating the bank
self.total_recharge[district.name][year_num*12 + month_num - 10] += total_recharge
self.total_recharge_sales[district.name][year_num*12 + month_num - 10] += total_recharge
#GW recovery
if direct_recover_name in self.values:
if month_num == 10:
total_delivery = self.values.loc[pd.DatetimeIndex([date_string_current]), direct_recover_name].values[0]
else:
total_delivery = self.values.loc[pd.DatetimeIndex([date_string_current]), direct_recover_name].values[0] - self.values.loc[pd.DatetimeIndex([date_string_prior]), direct_recover_name].values[0]
#if classifying by physical location, attribute to district recieving water (as irrigation)
self.total_irrigation[district.name][year_num*12 + month_num - 10] += total_delivery
self.total_recovery_purchases[district.name][year_num*12 + month_num - 10] += total_delivery
##Pumnping for inleiu recovery
if inleiu_pumping_name in self.values:
if month_num == 10:
total_leiupumping = self.values.loc[pd.DatetimeIndex([date_string_current]), inleiu_pumping_name].values[0]
else:
total_leiupumping = self.values.loc[pd.DatetimeIndex([date_string_current]), inleiu_pumping_name].values[0] - self.values.loc[pd.DatetimeIndex([date_string_prior]), inleiu_pumping_name].values[0]
#if classifying by physical location, to district operating the bank
self.total_pumping[district.name][year_num*12 + month_num - 10] += total_leiupumping
self.total_recovery_sales[district.name][year_num*12 + month_num - 10] += total_leiupumping
self.total_recovery_rebate[district.name][year_num*12 + month_num - 10] += total_leiupumping
#Recharge, in- and out- of district
if recharge_name in self.values:
if month_num == 10:
total_recharge = self.values.loc[pd.DatetimeIndex([date_string_current]), recharge_name].values[0]
else:
total_recharge = self.values.loc[pd.DatetimeIndex([date_string_current]), recharge_name].values[0] - self.values.loc[pd.DatetimeIndex([date_string_prior]), recharge_name].values[0]
self.total_recharge[district.name][year_num*12 + month_num - 10] += total_recharge
for bank_name in self.bank_list:
bank_recharge_name = district.name + '_' + bank_name.key + '_recharged'
if bank_recharge_name in self.values:
if month_num == 10:
total_recharge = self.values.loc[pd.DatetimeIndex([date_string_current]), bank_recharge_name].values[0]
else:
total_recharge = self.values.loc[pd.DatetimeIndex([date_string_current]), bank_recharge_name].values[0] - self.values.loc[pd.DatetimeIndex([date_string_prior]), bank_recharge_name].values[0]
self.total_recharge[bank_name.name][year_num*12 + month_num - 10] += total_recharge
self.total_recharge_purchases[district.name][year_num*12 + month_num - 10] += total_recharge
for bank_name in self.leiu_list:
bank_recharge_name = district.name + '_' + bank_name.key + '_recharged'
if bank_recharge_name in self.values:
if month_num == 10:
total_recharge = self.values.loc[pd.DatetimeIndex([date_string_current]), bank_recharge_name].values[0]
else:
total_recharge = self.values.loc[pd.DatetimeIndex([date_string_current]), bank_recharge_name].values[0] - self.values.loc[pd.DatetimeIndex([date_string_prior]), bank_recharge_name].values[0]
self.total_recharge_purchases[district.name][year_num*12 + month_num - 10] += total_recharge
#Contract deliveries
for contract in self.contract_list:
delivery_name = district.name + '_' + contract.name + '_delivery'
recharge_contract_name = district.name + '_' + contract.name + '_recharged'
flood_irr_name = district.name + '_' + contract.name + '_flood_irrigation'
flood_name = district.name + '_' + contract.name + '_flood'
###All deliveries made from a district's contract
if delivery_name in self.values:
if month_num == 10:
total_delivery = self.values.loc[pd.DatetimeIndex([date_string_current]), delivery_name].values[0]
else:
total_delivery = self.values.loc[pd.DatetimeIndex([date_string_current]), delivery_name].values[0] - self.values.loc[pd.DatetimeIndex([date_string_prior]), delivery_name].values[0]
self.total_irrigation[district.name][year_num*12 + month_num - 10] += total_delivery
##Deliveries made for recharge are subtracted from the overall contract deliveries
if recharge_contract_name in self.values:
if month_num == 10:
total_recharge = self.values.loc[pd.DatetimeIndex([date_string_current]), recharge_contract_name].values[0]
else:
total_recharge = self.values.loc[pd.DatetimeIndex([date_string_current]), recharge_contract_name].values[0] - self.values.loc[pd.DatetimeIndex([date_string_prior]), recharge_contract_name].values[0]
self.total_irrigation[district.name][year_num*12 + month_num - 10] -= total_recharge
#flood water used for irrigation - always attribute as irrigation
if flood_irr_name in self.values:
if month_num == 10:
total_delivery = self.values.loc[ | pd.DatetimeIndex([date_string_current]) | pandas.DatetimeIndex |
import pandas as pd
import numpy as np
import requests
from fake_useragent import UserAgent
import io
import os
import time
import json
import demjson
from datetime import datetime
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
# Main Economic Indicators: https://alfred.stlouisfed.org/release?rid=205
url = {
"fred_econ": "https://fred.stlouisfed.org/graph/fredgraph.csv?",
"philfed": "https://www.philadelphiafed.org/surveys-and-data/real-time-data-research/",
"chicagofed": "https://www.chicagofed.org/~/media/publications/",
"OECD": "https://stats.oecd.org/sdmx-json/data/DP_LIVE/"
}
def date_transform(df, format_origin, format_after):
return_list = []
for i in range(0, len(df)):
return_list.append(datetime.strptime(df[i], format_origin).strftime(format_after))
return return_list
def gdp_quarterly(startdate="1947-01-01", enddate="2021-01-01"):
"""
Full Name: <NAME>omestic Product
Description: Billions of Dollars, Quarterly, Seasonally Adjusted Annual Rate
Return: pd.DataFrame
"""
tmp_url = url["fred_econ"]
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "GDP",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df.columns = ["Date", "GDP"]
df["Date"] = pd.to_datetime(df["Date"], format = "%Y-%m-%d")
df["GDP"] = df["GDP"].astype(float)
return df
def gdpc1_quarterly(startdate="1947-01-01", enddate="2021-01-01"):
"""
Full Name: Real Gross Domestic Product
Description: Billions of Chained 2012 Dollars, Quarterly, Seasonally Adjusted Annual Rate
Return: pd.DataFrame
"""
tmp_url = url["fred_econ"]
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "GDPC1",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
return df
def oecd_gdp_monthly(startdate="1947-01-01", enddate="2021-01-01"):
"""
Full Name: Real Gross Domestic Product
Description: Billions of Chained 2012 Dollars, Quarterly, Seasonally Adjusted Annual Rate
Return: pd.DataFrame
"""
tmp_url = url["fred_econ"]
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "USALORSGPNOSTSAM",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
return df
def payems_monthly(startdate="1939-01-01", enddate="2021-01-01"):
"""
Full Name: All Employees, Total Nonfarm
Description: Thousands of Persons,Seasonally Adjusted, Monthly
Return: pd.DataFrame
"""
tmp_url = url["fred_econ"]
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "PAYEMS",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df.columns = ["Date", "Payems"]
df["Date"] = pd.to_datetime(df["Date"], format = "%Y-%m-%d")
df["Payems"] = df["Payems"].astype(float)
return df
def ppi():
tmp_url = url["fred_econ"] + "bgcolor=%23e1e9f0&chart_type=line&drp=0&fo=open%20sans&graph_bgcolor=%23ffffff&height=450&mode=fred&recession_bars=on&txtcolor=%23444444&ts=12&tts=12&width=968&nt=0&thu=0&trc=0&show_legend=yes&show_axis_titles=yes&show_tooltip=yes&id=PPIACO,PCUOMFGOMFG&scale=left,left&cosd=1913-01-01,1984-12-01&coed=2021-04-01,2021-04-01&line_color=%234572a7,%23aa4643&link_values=false,false&line_style=solid,solid&mark_type=none,none&mw=3,3&lw=2,2&ost=-99999,-99999&oet=99999,99999&mma=0,0&fml=a,a&fq=Monthly,Monthly&fam=avg,avg&fgst=lin,lin&fgsnd=2020-02-01,2020-02-01&line_index=1,2&transformation=lin,lin&vintage_date=2021-06-10,2021-06-10&revision_date=2021-06-10,2021-06-10&nd=1913-01-01,1984-12-01"
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
r = requests.get(tmp_url, headers=request_header)
data_text = r.content
df = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df["DATE"] = pd.to_datetime(df["DATE"], format="%Y-%m-%d")
#df = df[list(df.columns[1:])].replace(".", np.nan).astype(float)
name_list = {
"PPIACO": "Producer Price Index by Commodity: All Commodities",
"PCUOMFGOMFG": "Producer Price Index by Industry: Total Manufacturing Industries"
}
df.replace(".", np.nan, inplace = True)
df.columns = ["Date", "PPI_C", "PPI_I"]
df["Date"] = pd.to_datetime(df["Date"], format = "%Y-%m-%d")
df[["PPI_C", "PPI_I"]] = df[["PPI_C", "PPI_I"]].astype(float)
return df
def pmi():
t = time.time()
res = requests.get(
f"https://cdn.jin10.com/dc/reports/dc_usa_ism_pmi_all.js?v={str(int(round(t * 1000))), str(int(round(t * 1000)) + 90)}"
)
json_data = json.loads(res.text[res.text.find("{"): res.text.rfind("}") + 1])
date_list = [item["date"] for item in json_data["list"]]
value_list = [item["datas"]["美国ISM制造业PMI报告"] for item in json_data["list"]]
value_df = pd.DataFrame(value_list)
value_df.columns = json_data["kinds"]
value_df.index = pd.to_datetime(date_list)
temp_df = value_df["今值"]
url = "https://datacenter-api.jin10.com/reports/list_v2"
params = {
"max_date": "",
"category": "ec",
"attr_id": "28",
"_": str(int(round(t * 1000))),
}
headers = {
"accept": "*/*",
"accept-encoding": "gzip, deflate, br",
"accept-language": "zh-CN,zh;q=0.9,en;q=0.8",
"cache-control": "no-cache",
"origin": "https://datacenter.jin10.com",
"pragma": "no-cache",
"referer": "https://datacenter.jin10.com/reportType/dc_usa_michigan_consumer_sentiment",
"sec-fetch-dest": "empty",
"sec-fetch-mode": "cors",
"sec-fetch-site": "same-site",
"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36",
"x-app-id": "rU6QIu7JHe2gOUeR",
"x-csrf-token": "",
"x-version": "1.0.0",
}
r = requests.get(url, params=params, headers=headers)
temp_se = pd.DataFrame(r.json()["data"]["values"]).iloc[:, :2]
temp_se.index = pd.to_datetime(temp_se.iloc[:, 0])
temp_se = temp_se.iloc[:, 1]
temp_df = temp_df.append(temp_se)
temp_df.dropna(inplace=True)
temp_df.sort_index(inplace=True)
temp_df = temp_df.reset_index()
temp_df.drop_duplicates(subset="index", inplace=True)
temp_df.set_index("index", inplace=True)
temp_df = temp_df.squeeze()
temp_df.index.name = None
temp_df.name = "usa_ism_pmi"
temp_df = temp_df.astype("float")
PMI_I = pd.DataFrame()
PMI_I["Date"] = pd.to_datetime(temp_df.index, format = "%Y-%m-%d")
PMI_I["ISM_PMI_I"] = np.array(temp_df).astype(float)
t = time.time()
res = requests.get(
f"https://cdn.jin10.com/dc/reports/dc_usa_ism_non_pmi_all.js?v={str(int(round(t * 1000))), str(int(round(t * 1000)) + 90)}"
)
json_data = json.loads(res.text[res.text.find("{"): res.text.rfind("}") + 1])
date_list = [item["date"] for item in json_data["list"]]
value_list = [item["datas"]["美国ISM非制造业PMI报告"] for item in json_data["list"]]
value_df = pd.DataFrame(value_list)
value_df.columns = json_data["kinds"]
value_df.index = pd.to_datetime(date_list)
temp_df = value_df["今值"]
url = "https://datacenter-api.jin10.com/reports/list_v2"
params = {
"max_date": "",
"category": "ec",
"attr_id": "29",
"_": str(int(round(t * 1000))),
}
headers = {
"accept": "*/*",
"accept-encoding": "gzip, deflate, br",
"accept-language": "zh-CN,zh;q=0.9,en;q=0.8",
"cache-control": "no-cache",
"origin": "https://datacenter.jin10.com",
"pragma": "no-cache",
"referer": "https://datacenter.jin10.com/reportType/dc_usa_michigan_consumer_sentiment",
"sec-fetch-dest": "empty",
"sec-fetch-mode": "cors",
"sec-fetch-site": "same-site",
"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36",
"x-app-id": "rU6QIu7JHe2gOUeR",
"x-csrf-token": "",
"x-version": "1.0.0",
}
r = requests.get(url, params=params, headers=headers)
temp_se = pd.DataFrame(r.json()["data"]["values"]).iloc[:, :2]
temp_se.index = pd.to_datetime(temp_se.iloc[:, 0])
temp_se = temp_se.iloc[:, 1]
temp_df = temp_df.append(temp_se)
temp_df.dropna(inplace=True)
temp_df.sort_index(inplace=True)
temp_df = temp_df.reset_index()
temp_df.drop_duplicates(subset="index", inplace=True)
temp_df.set_index("index", inplace=True)
temp_df = temp_df.squeeze()
temp_df.index.name = None
temp_df.name = "usa_ism_non_pmi"
temp_df = temp_df.astype("float")
PMI_NI = pd.DataFrame()
PMI_NI["Date"] = pd.to_datetime(temp_df.index, format = "%Y-%m-%d")
PMI_NI["ISM_PMI_NI"] = np.array(temp_df).astype(float)
PMI = pd.merge_asof(PMI_I, PMI_NI, on = "Date")
return PMI
def unrate(startdate="1948-01-01", enddate="2021-01-01"):
"""
Full Name: Unemployment Rate: Aged 15-64: All Persons for the United States
Description: Percent, Seasonally Adjusted, Monthly, Quarterly and Annually
Return: pd.DataFrame
"""
tmp_url = url["fred_econ"]
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "LRUN64TTUSM156S",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df_monthly = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df_monthly["DATE"] = pd.to_datetime(df_monthly["DATE"], format="%Y-%m-%d")
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "LRUN64TTUSQ156S",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df_quarterly = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df_quarterly["DATE"] = pd.to_datetime(
df_quarterly["DATE"], format="%Y-%m-%d")
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "LRUN64TTUSA156S",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df_annually = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df_annually["DATE"] = pd.to_datetime(
df_annually["DATE"], format="%Y-%m-%d")
df = pd.merge_asof(
df_monthly,
df_quarterly,
on="DATE",
direction="backward")
df = pd.merge_asof(df, df_annually, on="DATE", direction="backward")
df.columns = ["Date", "UR_Monthly", "UR_Quarterly", "UR_Annually"]
return df
def erate(startdate="1955-01-01", enddate="2021-01-01"):
"""
Full Name: Employment Rate: Aged 25-54: All Persons for the United States
Description: Percent,Seasonally Adjusted, Monthly, Quarterly and Annually
Return: pd.DataFrame
"""
tmp_url = url["fred_econ"]
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "LREM25TTUSM156S",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df_monthly = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df_monthly["DATE"] = pd.to_datetime(df_monthly["DATE"], format="%Y-%m-%d")
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "LREM25TTUSQ156S",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df_quarterly = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df_quarterly["DATE"] = pd.to_datetime(
df_quarterly["DATE"], format="%Y-%m-%d")
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "LREM25TTUSA156S",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df_annually = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df_annually["DATE"] = pd.to_datetime(
df_annually["DATE"], format="%Y-%m-%d")
df = pd.merge_asof(
df_monthly,
df_quarterly,
on="DATE",
direction="backward")
df = pd.merge_asof(df, df_annually, on="DATE", direction="backward")
df.columns = ["Date", "ER_Monthly", "ER_Quarterly", "ER_Annually"]
def pce_monthly(startdate="1959-01-01", enddate="2021-01-01"):
"""
Full Name: PCE
Description: Percent, Monthly, Seasonally Adjusted
Return: pd.DataFrame
"""
tmp_url = url["fred_econ"]
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "PCE",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
return df
def cpi(startdate="1960-01-01", enddate="2021-01-01"):
"""
Full Name: Consumer Price Index: Total All Items for the United States
Description: Percent, Monthly, Quarterly and Annually, Seasonally Adjusted
Return: pd.DataFrame
"""
tmp_url = url["fred_econ"]
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "CPALTT01USM661S",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df_monthly = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df_monthly["DATE"] = pd.to_datetime(df_monthly["DATE"], format="%Y-%m-%d")
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "CPALTT01USQ661S",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df_quarterly = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df_quarterly["DATE"] = pd.to_datetime(
df_quarterly["DATE"], format="%Y-%m-%d")
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "CPALTT01USA661S",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df_annually = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df_annually["DATE"] = pd.to_datetime(
df_annually["DATE"], format="%Y-%m-%d")
df = pd.merge_asof(
df_monthly,
df_quarterly,
on="DATE",
direction="backward")
df = pd.merge_asof(df, df_annually, on="DATE", direction="backward")
df.columns = ["Date", "CPI_Monthly", "CPI_Quarterly", "CPI_Annually"]
df["Date"] = pd.to_datetime(df["Date"], format = "%Y-%m-%d")
df[["CPI_Monthly", "CPI_Quarterly", "CPI_Annually"]] = df[["CPI_Monthly", "CPI_Quarterly", "CPI_Annually"]].astype(float)
return df
def m1(startdate="1960-01-01", enddate="2021-01-01"):
"""
Full Name: Consumer Price Index: M3 for the United States
Description: Growth Rate Previous Period, Monthly, Quarterly and Annually, Seasonally Adjusted
Return: pd.DataFrame
"""
tmp_url = url["fred_econ"]
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "WM1NS",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df_weekly = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df_weekly["DATE"] = pd.to_datetime(df_weekly["DATE"], format="%Y-%m-%d")
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "MANMM101USM657S",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df_monthly = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df_monthly["DATE"] = pd.to_datetime(df_monthly["DATE"], format="%Y-%m-%d")
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "MANMM101USQ657S",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df_quarterly = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df_quarterly["DATE"] = pd.to_datetime(
df_quarterly["DATE"], format="%Y-%m-%d")
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "MANMM101USA657S",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df_annually = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df_annually["DATE"] = pd.to_datetime(
df_annually["DATE"], format="%Y-%m-%d")
df = pd.merge_asof(df_weekly, df_monthly, on="DATE", direction="backward")
df = pd.merge_asof(df, df_quarterly, on="DATE", direction="backward")
df = pd.merge_asof(df, df_annually, on="DATE", direction="backward")
df.columns = [
"Date",
"M1_Weekly",
"M1_Monthly",
"M1_Quarterly",
"M1_Annually"]
return df
def m2(startdate="1960-01-01", enddate="2021-01-01"):
"""
Full Name: <NAME>
Description: Seasonally Adjusted, Weekly, Monthly, Quarterly and Annually, Seasonally Adjusted
Return: pd.DataFrame
"""
tmp_url = url["fred_econ"]
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "WM2NS",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df_weekly = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df_weekly["DATE"] = pd.to_datetime(df_weekly["DATE"], format="%Y-%m-%d")
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "M2SL",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df_monthly = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df_monthly["DATE"] = pd.to_datetime(df_monthly["DATE"], format="%Y-%m-%d")
df = pd.merge_asof(df_weekly, df_monthly, on="DATE", direction="backward")
df.columns = ["Date", "M2_Weekly", "M2_Monthly"]
return df
def m3(startdate="1960-01-01", enddate="2021-01-01"):
"""
Full Name: Consumer Price Index: M3 for the United States
Description: Growth Rate Previous Period, Monthly, Quarterly and Annually, Seasonally Adjusted
Return: pd.DataFrame
"""
tmp_url = url["fred_econ"]
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "MABMM301USM657S",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df_monthly = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df_monthly["DATE"] = pd.to_datetime(df_monthly["DATE"], format="%Y-%m-%d")
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "MABMM301USQ657S",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df_quarterly = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df_quarterly["DATE"] = pd.to_datetime(
df_quarterly["DATE"], format="%Y-%m-%d")
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "MABMM301USA657S",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df_annually = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df_annually["DATE"] = pd.to_datetime(
df_annually["DATE"], format="%Y-%m-%d")
df = pd.merge_asof(
df_monthly,
df_quarterly,
on="DATE",
direction="backward")
df = pd.merge_asof(df, df_annually, on="DATE", direction="backward")
df.columns = ["Date", "M3_Monthly", "M3_Quarterly", "M3_Annually"]
return df
def ltgby_10(startdate="1955-01-01", enddate="2021-01-01"):
"""
Full Name: Long-Term Government Bond Yields: 10-year: Main (Including Benchmark) for the United States
Description: Percent,Not Seasonally Adjusted, Monthly, Quarterly and Annually
Return: pd.DataFrame
"""
tmp_url = url["fred_econ"]
ua = UserAgent(verify_ssl=False)
request_header = {"User-Agent": ua.random}
request_params = {
"id": "IRLTLT01USM156N",
"cosd": "{}".format(startdate),
"coed": "{}".format(enddate)
}
r = requests.get(tmp_url, params=request_params, headers=request_header)
data_text = r.content
df_monthly = pd.read_csv(io.StringIO(data_text.decode('utf-8')))
df_monthly["DATE"] = | pd.to_datetime(df_monthly["DATE"], format="%Y-%m-%d") | pandas.to_datetime |
#!/usr/bin/python
import sys
from collections import defaultdict
from os import listdir, path
import pandas
import json
PIPELINE_NAME = "neoANT-HILL"
LOG_FILE = "/params.log"
PICARD = "/home/biodocker/picard.jar"
GATK = "/home/biodocker/gatk-4.1.0.0/gatk"
SNPEFF = "/home/biodocker/snpEff/snpEff.jar"
SNPSIFT = "/home/biodocker/snpEff/SnpSift.jar"
QUANTISEQ = "Rscript /home/biodocker/quantiseq/deconvolution/quanTIseq_decon.R "
ABSOLUTE_PATH = "/home/biodocker/neoanthill/"
OUTPUT_PATH = "/home/biodocker/output/"
INPUT_PATH = "/home/biodocker/input/"
#FUNCTIONS
ADD_PROCESS = ["aprediction", "equantification", "linfiltrates"]
APREDICTION_PROCESS = 0
EQUANTIFICATION_PROCESS = 1
LINFILTRATES_PROCESS = 2
# GENERIC OPTIONS
ABSOLUTE_PATH_OPTION = "absolute_path"
ADD_PROCESSING_OPTION = "aprocessing"
INPUT_OPTION = "input"
FASTQ_INPUT_OPTION = "fastq"
OUTPUT_OPTION = "output"
# BP OPTIONS
TYPE_OPTION = "type"
CLASS_OPTION = "class"
METHOD_OPTION = "method"
PARALLEL_OPTION = "parallel"
LENGTH_OPTION = "length"
ALLELE_OPTION = "allele"
# DIRECTORIES
MUTATION_DIRECTORY = "/mutations/"
PREDICTION_FILTERED_DIRECTORY = "predictions/filtered/"
PREDICTION_NOT_FILTERED_DIRECTORY = "predictions/not_filtered/"
PREDICTION_RAW_DIRECTORY = "predictions/raw/"
ALLELE_DIRECTORY = "/allele_prediction/"
VARIANT_CALLING_DIRECTORY = "/variant_calling/"
GENE_EXPRESSION = "/gene_expression/"
IMMUNE_INFILTRATING = "/immune_infiltrating/"
# MUTATIONS
MUTATION_MISSENSE = "missense_variant"
MUTATION_FRAMESHIFT = "frameshift_variant"
MUTATION_INFRAME = ["conservative_inframe_insertion", "disruptive_inframe_insertion", "conservative_inframe_deletion", "disruptive_inframe_deletion"]
# TASKS
TASK_ANALYZE_PARAMETERS = "analysing parameters"
TASK_EXTRACT_VCF_INFO = "extracting vcf info"
TASK_LOAD_PROTEIN_FILE = "loading protein refseqs"
TASK_LOAD_TRANSCRIPT_FILE = "loading transcript refseqs"
TASK_PROCESS_MUTATION = "processing mutations"
TASK_WRITE_REPORT_FILE = "writting report files"
TASK_PREDICT_BINDING = "predicting bindings"
TASK_FILTER_BINDING = "filtering predictions"
TASK_GENE_EXPRESSION = "quantifying transcript expression"
TASK_ANNOTATING_VCF = "annotating vcf"
TASK_VARIANT_CALLING = "calling variants"
TASK_TUMOR_IMMUNE_PROFILE = "profiling tumor-immune cells"
TASK_ALLELE_TYPING = "typing HLA alleles"
# TASK STATUS
TASK_ERROR = "er"
TASK_SUCCESS = "ok"
# DATA
DBSNP = ABSOLUTE_PATH + "data/dbsnp_138.b37.vcf.gz"
MILLS = ABSOLUTE_PATH + "data/Mills_and_1000G_gold_standard.indels.b37.vcf.gz"
KNOWN = ABSOLUTE_PATH + "data/1000G_phase1.indels.b37.vcf.gz"
GENOME_FASTA_FILE = ABSOLUTE_PATH + "data/Homo_sapiens.GRCh37.fa"
REFSEQ_TRANSCRIPTS_FASTA = ABSOLUTE_PATH + "data/transcript_refseq.fasta"
REFSEQ_HUMAN_FASTA = ABSOLUTE_PATH + "data/protein_refseq.fasta"
HUMAN_TRANSCRIPTS_INDEX = ABSOLUTE_PATH +"data/human_transcript_index"
DEFAULT_ALLELE_LIST = [0, ABSOLUTE_PATH + "data/hla_class_i.alleles", ABSOLUTE_PATH + "data/hla_class_ii.alleles"]
# PREDICT METHODS
PREDIC_METHODS = [0,
["IEDB_recommended",
"ann",
"comblib_sidney2008",
"consensus",
"netmhcstabpan",
"netmhcpan",
"smm",
"smmpmbec",
"pickpocket",
"netmhccons"],
["IEDB_recommended",
"comblib",
"consensus3",
"NetMHCIIpan",
"nn_align",
"smm_align",
"sturniolo"]
]
# FILTERS
FILTER_LIST = {"percentile_rank": 7, "ann_ic50": 8, "smm_ic50": 10, "comblib_sidney2008_score": 12, "netmhcpan_ic50": 14, "ic50": 6, }
REPORT = "report: "
GENERAL_USAGE = "general usage: ./main [-opt] [arg] [inputfile]"
AMINO = {'Ala': 'a', 'Arg': 'r', 'Asn': 'n', 'Asp': 'd', 'Cys': 'c', 'Gln': 'q',
'Glu': 'e', 'Gly': 'g', 'His': 'h', 'Ile': 'i', 'Leu': 'l', 'Lys': 'k',
'Met': 'm', 'Phe': 'f', 'Pro': 'p', 'Ser': 's', 'Thr': 't', 'Trp': 'w',
'Tyr': 'y', 'Val': 'v', 'Ter': '*'}
CODON = {'TTT': 'F', 'TTC': 'F', 'TTA': 'L', 'TTG': 'L', 'CTT': 'L',
'CTC': 'L', 'CTA': 'L', 'CTG': 'L', 'ATT': 'I', 'ATC': 'I',
'ATA': 'I', 'ATG': 'M', 'GTT': 'V', 'GTC': 'V', 'GTA': 'V',
'GTG': 'V', 'TCT': 'S', 'TCC': 'S', 'TCA': 'S', 'TCG': 'S',
'CCT': 'P', 'CCC': 'P', 'CCA': 'P', 'CCG': 'P', 'ACT': 'T',
'ACC': 'T', 'ACA': 'T', 'ACG': 'T', 'GCT': 'A', 'GCC': 'A',
'GCA': 'A', 'GCG': 'A', 'TAT': 'Y', 'TAC': 'Y', 'CAT': 'H',
'CAC': 'H', 'CAA': 'Q', 'CAG': 'Q', 'AAT': 'N', 'AAC': 'N',
'AAA': 'K', 'AAG': 'K', 'GAT': 'D', 'GAC': 'D', 'GAA': 'E',
'GAG': 'E', 'TGT': 'C', 'TGC': 'C', 'TGG': 'W', 'CGT': 'R',
'CGC': 'R', 'CGA': 'R', 'CGG': 'R', 'AGT': 'S', 'AGC': 'S',
'AGA': 'R', 'AGG': 'R', 'GGT': 'G', 'GGC': 'G', 'GGA': 'G',
'GGG': 'G', 'TAA': 'STOP', 'TAG': 'STOP', 'TGA': 'STOP'}
DEFAULT_METHOD = "IEDB_recommended"
PREDICTION_CLASS_COMMAND = [0, "/home/biodocker/iedb/mhc_i/src/predict_binding.py ", "/home/biodocker/iedb/mhc_ii/mhc_II_binding.py "]
def print_task(task):
repetition = 40 - len(task)
print ("[ -> " + task + " " + ("." * repetition)),
sys.stdout.flush()
def print_status(status):
if status == TASK_SUCCESS:
print (status + " ]")
else:
print (status + " ]")
def save_log(ops):
output = ops[OUTPUT_OPTION]
if CLASS_OPTION in ops.keys():
p_class = str(ops[CLASS_OPTION])
ops[p_class + METHOD_OPTION] = ops[METHOD_OPTION]
ops[p_class + ALLELE_OPTION] = ops[ALLELE_OPTION]
ops[p_class + LENGTH_OPTION] = ops[LENGTH_OPTION]
ops.pop(METHOD_OPTION, None)
ops.pop(ALLELE_OPTION, None)
ops.pop(LENGTH_OPTION, None)
if path.isfile(output + LOG_FILE):
with open(output + LOG_FILE, "r") as f:
dic = json.load(f)
dic.update(ops)
ops = dic
with open(output + LOG_FILE, "w") as f:
json.dump(ops, f)
def read_log(out):
params = None
with open(OUTPUT_PATH + out + LOG_FILE, "r") as f:
params = json.load(f)
return params
def read_list(filepath):
elements = []
with open(filepath, "r") as f:
for row in f:
row = row.strip("\r")
row = row.strip("\n")
elements.append(row)
return elements
def read_predicted_alleles(outpath):
outpath += ALLELE_DIRECTORY
files = [f for f in listdir(outpath) if path.isfile(path.join(outpath, f))]
p_allele = defaultdict(list)
str_result = ""
for file in files:
if file.endswith(".tsv"):
sample = file.split(".tsv")[0]
with open(outpath + file, "r") as f:
f.readline()
for line in f:
p_allele[line.rstrip()].append(sample)
else:
continue
for allele in sorted(p_allele.keys()):
str_result += allele + " ("
for sample in p_allele[allele]:
str_result += sample + ", "
str_result = str_result[0:-2] + ")\n"
return str_result
def read_c1_binding_results(out, sample):
result_path = OUTPUT_PATH + out + "/c1_predictions/not_filtered/" + sample + ".txt"
try:
c1_lines = pandas.read_csv(result_path, sep='\t')
except:
c1_lines = pandas.DataFrame()
return c1_lines
def read_c2_binding_results(out, sample):
result_path = OUTPUT_PATH + out + "/c2_predictions/not_filtered/" + sample + ".txt"
try:
c2_lines = pandas.read_csv(result_path, sep='\t')
except:
c2_lines = pandas.DataFrame()
return c2_lines
def read_gene_exp(out, sample):
result_path = OUTPUT_PATH + out + "/gene_expression/" + sample + ".tsv"
try:
gene_exp = | pandas.read_csv(result_path, sep='\t') | pandas.read_csv |
import argparse
from email.mime import image
import os
from tqdm import tqdm
import pandas as pd
import logging
from src.utils.common import read_yaml, create_directories
from src.stage_01_get_data import main as loader_main
from sklearn.metrics import confusion_matrix, f1_score
import numpy as np
import warnings
import torch
STAGE = "STAGE_NAME" ## <<< change stage name
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter("[%(asctime)s: %(levelname)s: %(module)s]: %(message)s")
file_handler = logging.FileHandler(os.path.join("logs", "running_logs.log"))
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
warnings.filterwarnings('ignore')
def main(config_path):
## read config files
config = read_yaml(config_path)
train_data_loader, test_data_loader, labels_dict = loader_main(config_path)
pred = np.array([])
target = np.array([])
prediction_data_dir = config['data']['PRED_DATA_DIR']
create_directories([prediction_data_dir])
prediction_data_file_name = config['data']['PRED_DATA_FILE_NAME']
prediction_data_file_path = os.path.join(prediction_data_dir, prediction_data_file_name)
model_dir = config['artifacts']['model_dir']
trained_model_name = config['artifacts']['trained_model_name']
trained_model_path = os.path.join(model_dir, trained_model_name)
model = torch.load(trained_model_path)
logger.info(f"trained model loaded")
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
model.to(DEVICE)
logger.info(f"trained model loaded into {DEVICE}")
with torch.no_grad():
for batch, data in enumerate(test_data_loader):
images = data[0].to(DEVICE)
labels = data[1].to(DEVICE)
y_pred = model(images)
pred = np.concatenate((pred, torch.argmax(y_pred, 1).cpu().numpy()))
target = np.concatenate((target, labels.cpu().numpy()))
logger.info("prediction for test data finished")
df = | pd.DataFrame({"Actual":target, "Prediction":pred}) | pandas.DataFrame |
from django.core.management.base import BaseCommand, CommandError
from etldjango.settings import GCP_PROJECT_ID, BUCKET_NAME, BUCKET_ROOT
from .utils.storage import Bucket_handler, GetBucketData
from .utils.extractor import Data_Extractor
from datetime import datetime, timedelta
from .utils.unicodenorm import normalizer_str
from etldata.models import DB_minsa_muertes, DB_positividad_salida, DB_capacidad_hosp, DB_minsa_muertes, DB_rt, DB_epidemiologico, DB_vacunas
from django.contrib.gis.geos import Point
# from django.utils import timezone
from django.db.models import F, Sum, Avg, Count, StdDev, Max, Q
from tqdm import tqdm
import pandas as pd
import numpy as np
import os
import time
# datetime.now(tz=timezone.utc) # you can use this value
#db = DB_epidemiologico.objects.filter(fecha="2021-05-17")
#db.delete()
class Command(BaseCommand):
help = "Epidemiolog: Command for create the resumen using the current date in the DB"
bucket = Bucket_handler(project_id=GCP_PROJECT_ID)
filename = 'poblacion.csv'
def add_arguments(self, parser):
"""
Example:
- for initialize the database using the last three weeks
$python manage.py worker_t_epidem full --w 3
- for append the last three weeks
$python manage.py worker_t_epidem last --w 3
"""
parser.add_argument(
'mode', type=str, help="full/last , full: load the last 5 weeks, last: load the last week")
parser.add_argument(
'--w', type=int, help="reset the database and load the #w last weeks")
def print_shell(self, text):
self.stdout.write(self.style.SUCCESS(text))
def save_table(self, table, db, mode):
if mode == 'full':
records = table.to_dict(orient='records')
records = [db(**record) for record in tqdm(records)]
_ = db.objects.all().delete()
_ = db.objects.bulk_create(records)
elif mode == 'last':
# this is posible because the table is sorter by "-fecha"
last_record = db.objects.all()[:1]
last_record = list(last_record)
if len(last_record) > 0:
last_date = str(last_record[0].fecha.date())
else:
last_date = '2021-01-01'
table = table.loc[table.fecha > last_date]
if len(table):
self.print_shell("Storing new records")
records = table.to_dict(orient='records')
records = [db(**record) for record in tqdm(records)]
_ = db.objects.bulk_create(records)
else:
self.print_shell("No new data was found to store")
def handle(self, *args, **options):
mode = options["mode"]
w = options["w"]
assert mode in ['full', 'last'], "Error in --mode argument"
weeks = self.get_weeks_from_args(mode, w)
self.print_shell("Computing epidemiology score")
# Downloading data from bucket
self.downloading_source_csv()
self.load_poblacion_table_popu()
table_vacc = self.query_vacunados(DB_vacunas, weeks)
#
table_pos = self.query_test_positivos(DB_positividad_salida, weeks)
table_pos = self.normalizer_100k_population(table_pos,
['total', 'total_pos'])
table_uci = self.query_uci_status(DB_capacidad_hosp, weeks)
table_minsa = self.query_deaths_minsa(DB_minsa_muertes, weeks)
table_minsa = self.normalizer_100k_population(table_minsa,
['n_muertes'])
table_rt = self.query_rt_score(DB_rt, weeks)
table = self.merge_tables(
table_pos, table_uci, table_minsa, table_rt, table_vacc)
table = self.aggregate_avg_by_week(table)
table = self.calc_vacc_progress(table)
table = self.scoring_variables(table)
table = self.last_week_comparation(table)
self.save_table(table, DB_epidemiologico, mode)
self.print_shell('Work Done!')
def get_weeks_from_args(self, mode, weeks):
if weeks:
return weeks + 2
elif mode == 'full':
return 6
elif mode == 'last':
return 4
def downloading_source_csv(self):
"""
Function to download the csv file which contain all the url and standar names
for the the data from the goberment, then
read that file and download all the files form source.
"""
self.print_shell('Downloading poblacion.csv ... ')
self.bucket.download_blob(bucket_name=BUCKET_NAME,
source_blob_name="data_source/"+self.filename,
destination_file_name="temp/"+self.filename)
def load_poblacion_table_popu(self):
table = pd.read_csv('temp/'+self.filename)
table.rename(columns={
'Region': 'region',
'total': 'poblacion'
}, inplace=True)
table.region = table.region.apply(lambda x: normalizer_str(x))
print(table)
self.table_popu = table
def get_fecha_max(self, db, fecha='fecha'):
query = db.objects.values(fecha)
query = query.aggregate(Max(fecha))
query = query[fecha+'__max'].date()
print(query)
return query
def query_test_positivos(self, db, weeks):
fecha_max = self.get_fecha_max(db)
fecha_min = fecha_max - timedelta(days=8*weeks)
query = db.objects.values('fecha',
'region',
'total_test',
'total_pos')
query = query.filter(fecha__gt=fecha_min)
query = query.annotate(positividad=(
F('total_pos') / F('total_test')*100))
query = query.order_by('region')
query = pd.DataFrame.from_records(query)
query.rename(columns={
'total_test': 'total'
}, inplace=True)
print(query)
return query
def query_uci_status(self, db, weeks):
fecha_max = self.get_fecha_max(db, 'fecha_corte')
fecha_min = fecha_max - timedelta(days=8*weeks)
query = db.objects.values('fecha_corte',
'region',
)
query = query.filter(fecha_corte__gt=fecha_min)
query = query.exclude(region='PERU')
query = query.annotate(uci_p=F('uci_zc_cama_ocup') /
F('uci_zc_cama_total')*100,
camas_p=F('uci_znc_cama_ocup') /
F('uci_znc_cama_total')*100
)
query = pd.DataFrame.from_records(query)
query.rename(columns={'fecha_corte': 'fecha'}, inplace=True)
print(query)
return query
def query_deaths_minsa(self, db, weeks):
columns = ['fecha',
'region',
'n_muertes', ]
fecha_max = self.get_fecha_max(db,)
fecha_min = fecha_max - timedelta(days=8*weeks)
query = db.objects
query = query.filter(fecha__gt=fecha_min)
query = query.exclude(region='PERU')
query = query.order_by('region')
query = query.values(*columns)
query = pd.DataFrame.from_records(query)
print(query.loc[query.region == 'PUNO'].n_muertes.mean())
print(query.loc[query.region == 'PUNO'])
return query
def query_rt_score(self, db, weeks):
fecha_max = self.get_fecha_max(db, 'date')
fecha_min = fecha_max - timedelta(days=8*weeks)
query = db.objects
query = query.values('date',
'region',
'ml')
query = query.filter(date__gt=fecha_min)
query = query.exclude(region='PERU')
query = query.order_by('region')
query = pd.DataFrame.from_records(query)
query.rename(columns={'date': 'fecha'}, inplace=True)
print(query)
return query
def normalizer_100k_population(self, table, columns):
def change_normal(x, column):
if x['region'] == 'LIMA':
x['region'] = 'LIMA METROPOLITANA'
n_pp = self.table_popu.loc[self.table_popu.region == x['region']]
n_pp = n_pp['poblacion'].tolist()[0]
return x[column]/n_pp*100000
for column in columns:
table[column] = table.apply(change_normal, args=(column,), axis=1)
print(table.isnull().sum())
print(table.info())
return table
@ staticmethod
def rename_total_table_columns(table):
table.rename(columns={
'total': 'avg_test',
'total_pos': 'incid_100',
'n_muertes': 'fall_100',
'ml': 'rt',
'uci_p': 'uci',
'camas_p': 'camas_covid',
'vacc_acum': 'vacc_acum',
}, inplace=True)
return table
def merge_tables(self, posit, uci, minsa, rt, table_vacc):
total = posit.merge(uci,
on=["fecha", "region"],
how="outer")
total = total.merge(minsa,
on=["fecha", "region"],
how="outer")
total = total.merge(rt,
on=["fecha", "region"],
how="outer")
total = total.merge(table_vacc,
on=["fecha", "region"],
how="outer")
total = total.merge(self.table_popu,
on=['region'],
how='outer')
total['n_week'] = total.fecha.apply(lambda x: (x).isocalendar()[1])
# total['n_week'] = total.fecha.apply(
# lambda x: (x+timedelta(days=1)).isocalendar()[1])
# total['n_week'] =
# the current week never process
curr_week = (datetime.now()).isocalendar()[1]
print('current week ', curr_week)
total = total.loc[(total['n_week'] > total['n_week'].min())
& (total['n_week'] < curr_week)
]
total = self.rename_total_table_columns(total)
print(total.isnull().sum())
cols = total.columns.tolist()
cols.remove('fecha')
total[cols] = total[cols].apply(pd.to_numeric, errors='ignore')
# print(total.sort_values(by='fecha').tail(50))
# print(total.loc[total.region == 'LIMA METROPOLITANA'])
# print(posit.loc[posit.region ==
# 'LIMA METROPOLITANA'].sort_values(by='fecha'))
return total
def scoring_variables(self, table):
print(table.info())
print(table.head())
print(table.isnull().sum())
table = table.fillna(0)
cut_fall = [-0.01, 2, 5, 7, 1e7]
cut_uci = [-0.01, 70, 90, 98, 100]
cut_incid = [-0.01, 80, 100, 120, 1e7]
cut_rt = [-0.01, .7, 1.1, 1.6, 1e7]
cut_pos = [-0.01, 11, 15, 20, 1e7]
cut_test = [-1e7, 34*7, 60*7, 100*7, 1e7]
color = [1, 2, 3, 4]
table['fall_score'] = pd.cut(table.fall_100,
cut_fall,
labels=color).astype(int)
table['uci_score'] = pd.cut(table.uci,
cut_uci,
labels=color).astype(int)
table['incid_score'] = pd.cut(table.incid_100,
cut_incid,
labels=color).astype(int)
table['rt_score'] = pd.cut(table.rt,
cut_rt,
labels=color).astype(int)
table['posit_score'] = pd.cut(table.positividad,
cut_pos,
labels=color).astype(int)
table['test_score'] = pd.cut(table.avg_test,
cut_test,
labels=color[::-1]).astype(int)
table['score'], table['val_score'] = self.calculate_score(table)
print(table.describe())
return table
@ staticmethod
def calculate_score(table):
cut_score = [0, 31, 38, 43, 1e7]
color = [1, 2, 3, 4]
w = [4, 3, 2.5, 2, 1.5, 1]
result = table['fall_score']*w[0] + table['uci_score']*w[1] + \
table['incid_score'] * w[2] + table['rt_score']*w[3] + \
table['posit_score'] * w[4] + table['test_score']*w[5]
return pd.cut(result, cut_score, labels=color).astype(int), result
def date_table_factory(self, fechas_orig, region_name):
min_ = fechas_orig.min()
max_ = fechas_orig.max()
totaldatelist = pd.date_range(start=min_, end=max_).tolist()
totaldatelist = pd.DataFrame(data={"fecha": totaldatelist})
totaldatelist['region'] = region_name
return totaldatelist
def aggregate_avg_by_week(self, table):
table = table.groupby(["region", ])
table_acum = pd.DataFrame()
for region in table:
region_name = region[0]
temp = region[1].sort_values(by="fecha")
totaldatelist = self.date_table_factory(temp.fecha, region_name)
temp = totaldatelist.merge(temp,
on=["fecha", 'region'],
how="outer",
)
temp = temp.sort_values(by="fecha")
temp = temp.reset_index(drop=True)
temp = temp.fillna(method="ffill")
temp = temp.fillna(method="bfill")
temp = temp.dropna()
temp = temp.groupby(["n_week", "region"]).agg({
'fecha': 'first',
'avg_test': 'sum',
'incid_100': 'sum',
'positividad': 'mean',
'uci': 'last',
'camas_covid': 'last',
'fall_100': 'sum',
'rt': 'mean',
'vacc_acum': 'max',
'poblacion': 'last',
})
temp = temp.reset_index()
# temp.fecha = temp.fecha.apply(lambda x: x.date())
table_acum = table_acum.append(temp, ignore_index=True)
# print(table_acum.info())
table_acum['rt'] = table_acum['rt'].astype(float)
# print(table_acum.head())
# print(table_acum.tail(12))
# print(table_acum.head(12))
return table_acum
def calc_vacc_progress(self, table):
table['vacc_prog'] = table.vacc_acum/table.poblacion*100
return table
def query_vacunados(self, db, weeks):
fecha_max = self.get_fecha_max(db,)
fecha_min = fecha_max - timedelta(days=8*weeks)
# Records diarios por region
query = db.objects
query = query.filter(dosis=1)
histo = query.values('fecha', 'region')
histo = histo.annotate(vacc_acum=Sum('cantidad'))
histo = histo.order_by('fecha', 'region')
histo = | pd.DataFrame.from_records(histo) | pandas.DataFrame.from_records |
import pandas as pd
import numpy as np
from texttable import Texttable
from cape_privacy.pandas import dtypes
from cape_privacy.pandas.transformations import NumericPerturbation
from cape_privacy.pandas.transformations import DatePerturbation
from cape_privacy.pandas.transformations import NumericRounding
from cape_privacy.pandas.transformations import Tokenizer
from faker import Faker
from anonympy.pandas import utils_pandas as _utils
from sklearn.decomposition import PCA
class dfAnonymizer(object):
"""
Initializes pandas DataFrame as a dfAnonymizer object.
Parameters:
----------
df: pandas DataFrame
Returns:
----------
dfAnonymizer object
Raises
----------
Exception:
* If ``df`` is not a DataFrame
See also
----------
dfAnonymizer.to_df : Return a DataFrame
Examples
----------
>>> from anonympy.pandas import dfAnonymizer
>>> from anonympy.pandas.utils_pandas import load_dataset
Contructing dfAnonymizer object:
>>> df = load_dataset()
>>> anonym = dfAnonymizer(df)
>>> anonym.to_df()
name age ... email ssn
0 Bruce 33 ... <EMAIL> 343554334
1 Tony 48 ... <EMAIL> 656564664
"""
def __init__(self,
df: pd.DataFrame):
if df.__class__.__name__ != "DataFrame":
raise Exception(f"{df} is not a pandas DataFrame.")
# Private Attributes
self._df = df.copy()
self._df2 = df.copy()
self._methods_applied = {}
self._synthetic_data = 'Synthetic Data'
self._tokenization = 'Tokenization'
self._numeric_perturbation = 'Numeric Perturbation'
self._datetime_perturbation = 'Datetime Perturbation'
self._round = 'Generalization - Rounding'
self._bin = 'Generalization - Binning'
self._drop = 'Column Suppression'
self._sample = 'Resampling'
self._PCA = 'PCA Masking'
self._email = 'Partial Masking'
# Public Attributes
self.anonymized_columns = []
self.columns = self._df.columns.tolist()
self.unanonymized_columns = self.columns.copy()
self.numeric_columns = _utils.get_numeric_columns(self._df)
self.categorical_columns = _utils.get_categorical_columns(self._df)
self.datetime_columns = _utils.get_datetime_columns(self._df)
self._available_methods = _utils.av_methods
self._fake_methods = _utils.faker_methods
def __str__(self):
return self._info().draw()
def __repr__(self):
return self._info().draw()
def _dtype_checker(self, column: str):
'''
Returns the dtype of the column
Parameters
----------
column: str
Returns
----------
dtype: numpy dtype
'''
dtype = self._df[column].dtype
if dtype == np.float32:
return dtypes.Float
elif dtype == np.float64:
return dtypes.Double
elif dtype == np.byte:
return dtypes.Byte
elif dtype == np.short:
return dtypes.Short
elif dtype == np.int32:
return dtypes.Integer
elif dtype == np.int64:
return dtypes.Long
else:
return None
def anonymize(self,
methods=None,
locale=['en_US'],
seed=None,
inplace=True):
'''
Anonymize all columns using different methods for each dtype.
If dictionary is not provided, for numerical columns
``numeric_rounding`` is applied.
``categorical_fake`` and ``categorical_tokenization`` for
categorical columns
and ``datetime_noise`` or ``datetime_fake`` are applied for columns of
datetime type.
Parameters
----------
methods : Optional[Dict[str, str]], default None
{column_name: anonympy_method}. Call ``available_methods`` for list
of all methods.
locale : str or List[str], default ['en_US']
See https://faker.readthedocs.io/en/master/locales.html for all
faker's locales.
inplace : bool, default True
If True the changes will be applied to `dfAnonymizer` obejct, else
output is returned.
seed : Optional[int], default None
Pass an integer for reproducible output across multiple function
calls.
Returns
----------
If inplace is False, pandas Series or DataFrame is returned
See Also
--------
dfAnonymizer.categorical_fake_auto : Replace values with synthetically
generated ones
Examples
----------
>>> from anonympy.pandas import dfAnonymizer
>>> from anonympy.pandas.utils_pandas import load_dataset, \
available_methods
>>> df = load_dataset()
>>> anonym = dfAnonymizer(df)
If methods None:
>>> anonym.anonymize(inplace = False)
name age ... email ssn
0 <NAME> 30 ... <EMAIL> 718-51-5290
1 <NAME> 50 ... <EMAIL> 684-81-8137
Passing a dict for specifying which methods to apply:
>>> available_methods('numeric')
numeric_noise numeric_binning numeric_masking numeric_rounding
>>> anonym.anonymize({'name':'categorical_fake',
... 'age':'numeric_noise',
... 'email':'categorical_email_masking',
... 'salary': 'numeric_rounding'}, inplace = False)
name age email salary
0 <NAME> 37 <EMAIL> 60000.0
1 <NAME> 52 <EMAIL> 50000.0
'''
if not methods:
if inplace:
# try synthetic data
self.categorical_fake_auto(locale=locale, seed=seed)
# if there are still columns left unanonymized
if self.unanonymized_columns:
for column in self.unanonymized_columns.copy():
if column in self.numeric_columns:
self.numeric_rounding(column)
elif column in self.categorical_columns:
self.categorical_tokenization(column,
key=str(seed))
elif column in self.datetime_columns:
self.datetime_noise(column, seed=seed)
else:
# try synthetic data
temp = self.categorical_fake_auto(locale=locale,
inplace=False,
seed=seed)
unanonymized = self.unanonymized_columns.copy()
if isinstance(temp, pd.DataFrame):
unanonymized = [column for column in unanonymized
if column not in temp.columns.to_list()]
elif isinstance(temp, pd.Series):
unanonymized.remove(temp.name)
temp = | pd.DataFrame(temp) | pandas.DataFrame |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import talib
pd.set_option('display.max_rows', 500)
pd.set_option('display.max_columns', 30)
pd.set_option('precision', 7)
pd.options.display.float_format = '{:,.3f}'.format
import warnings
warnings.simplefilter(action = "ignore", category = FutureWarning)
from sklearn import preprocessing, svm, cross_validation, metrics, pipeline, grid_search
from scipy.stats import sem
from sklearn.decomposition import PCA, KernelPCA
from sklearn.metrics import matthews_corrcoef
'''
读入一支股票指定年份的ohlcv数据
输入:baseDir,stockCode为字符, startYear,yearNum为整数，
输出:dataframe
'''
def readWSDFile(baseDir, stockCode, startYear, yearNum=1):
# 解析日期
dateparse = lambda x: | pd.datetime.strptime(x, '%Y-%m-%d') | pandas.datetime.strptime |
#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
Date: 2021/11/8 17:48
Desc: 同花顺-板块-行业板块
http://q.10jqka.com.cn/thshy/
"""
import os
from datetime import datetime
import pandas as pd
import requests
from bs4 import BeautifulSoup
from py_mini_racer import py_mini_racer
from tqdm import tqdm
from mssdk.utils import demjson
def _get_js_path_ths(name: str = None, module_file: str = None) -> str:
"""
获取 JS 文件的路径(从模块所在目录查找)
:param name: 文件名
:type name: str
:param module_file: 模块路径
:type module_file: str
:return: 路径
:rtype: str
"""
module_folder = os.path.abspath(os.path.dirname(os.path.dirname(module_file)))
module_json_path = os.path.join(module_folder, "stock_feature", name)
return module_json_path
def _get_file_content_ths(file_name: str = "ase.min.js") -> str:
"""
获取 JS 文件的内容
:param file_name: JS 文件名
:type file_name: str
:return: 文件内容
:rtype: str
"""
setting_file_name = file_name
setting_file_path = _get_js_path_ths(setting_file_name, __file__)
with open(setting_file_path) as f:
file_data = f.read()
return file_data
def stock_board_industry_name_ths() -> pd.DataFrame:
"""
同花顺-板块-行业板块-行业
http://q.10jqka.com.cn/thshy/
:return: 所有行业板块的名称和链接
:rtype: pandas.DataFrame
"""
code_name_ths_map = {'881101': '种植业与林业',
'881102': '养殖业',
'881103': '农产品加工',
'881104': '农业服务',
'881105': '煤炭开采加工',
'881107': '油气开采及服务',
'881108': '化学原料',
'881109': '化学制品',
'881110': '化工合成材料',
'881112': '钢铁',
'881114': '金属新材料',
'881115': '建筑材料',
'881116': '建筑装饰',
'881117': '通用设备',
'881118': '专用设备',
'881119': '仪器仪表',
'881120': '电力设备',
'881121': '半导体及元件',
'881122': '光学光电子',
'881123': '其他电子',
'881124': '消费电子',
'881125': '汽车整车',
'881126': '汽车零部件',
'881127': '非汽车交运',
'881128': '汽车服务',
'881129': '通信设备',
'881130': '计算机设备',
'881131': '白色家电',
'881132': '黑色家电',
'881133': '饮料制造',
'881134': '食品加工制造',
'881135': '纺织制造',
'881136': '服装家纺',
'881137': '造纸',
'881138': '包装印刷',
'881139': '家用轻工',
'881140': '化学制药',
'881141': '中药',
'881142': '生物制品',
'881143': '医药商业',
'881144': '医疗器械',
'881145': '电力',
'881146': '燃气',
'881148': '港口航运',
'881149': '公路铁路运输',
'881151': '机场航运',
'881152': '物流',
'881153': '房地产开发',
'881155': '银行',
'881156': '保险及其他',
'881157': '证券',
'881158': '零售',
'881159': '贸易',
'881160': '景点及旅游',
'881161': '酒店及餐饮',
'881162': '通信服务',
'881163': '计算机应用',
'881164': '传媒',
'881165': '综合',
'881166': '国防军工',
'881167': '非金属材料',
'881168': '工业金属',
'881169': '贵金属',
'881170': '小金属',
'881171': '自动化设备',
'881172': '电子化学品',
'881173': '小家电',
'881174': '厨卫电器',
'881175': '医疗服务',
'881176': '房地产服务',
'881177': '互联网电商',
'881178': '教育',
'881179': '其他社会服务',
'881180': '石油加工贸易',
'881181': '环保',
'881182': '美容护理',
'884001': '种子生产',
'884002': '粮食种植',
'884003': '其他种植业',
'884004': '林业',
'884005': '海洋捕捞',
'884006': '水产养殖',
'884007': '畜禽养殖',
'884008': '饲料',
'884009': '果蔬加工',
'884010': '粮油加工',
'884011': '其他农产品加工',
'884012': '农业综合',
'884013': '动物保健',
'884014': '煤炭开采',
'884015': '焦炭加工',
'884016': '油气开采',
'884018': '油服工程',
'884020': '石油加工',
'884021': '油品石化贸易',
'884022': '纯碱',
'884023': '氯碱',
'884024': '无机盐',
'884025': '其他化学原料',
'884026': '氮肥',
'884027': '磷肥及磷化工',
'884028': '农药',
'884030': '涂料油墨',
'884031': '钾肥',
'884032': '民爆用品',
'884033': '纺织化学用品',
'884034': '其他化学制品',
'884035': '复合肥',
'884036': '氟化工',
'884039': '聚氨酯',
'884041': '涤纶',
'884043': '粘胶',
'884044': '其他纤维',
'884045': '氨纶',
'884046': '其他塑料制品',
'884048': '改性塑料',
'884050': '其他橡胶制品',
'884051': '炭黑',
'884052': '普钢',
'884053': '铝',
'884054': '铜',
'884055': '铅锌',
'884056': '其他金属新材料',
'884057': '磁性材料',
'884058': '非金属材料Ⅲ',
'884059': '玻璃玻纤',
'884060': '水泥',
'884062': '其他建材',
'884063': '耐火材料',
'884064': '管材',
'884065': '装饰园林',
'884066': '房屋建设',
'884067': '基础建设',
'884068': '专业工程',
'884069': '机床工具',
'884071': '磨具磨料',
'884073': '制冷空调设备',
'884074': '其他通用设备',
'884075': '金属制品',
'884076': '纺织服装设备',
'884077': '工程机械',
'884078': '农用机械',
'884080': '能源及重型设备',
'884081': '印刷包装机械',
'884082': '其他专用设备',
'884083': '楼宇设备',
'884084': '环保设备',
'884085': '电机',
'884086': '电气自控设备',
'884088': '输变电设备',
'884089': '线缆部件及其他',
'884090': '分立器件',
'884091': '半导体材料',
'884092': '印制电路板',
'884093': '被动元件',
'884094': '面板',
'884095': 'LED',
'884096': '光学元件',
'884098': '消费电子零部件及组装',
'884099': '乘用车',
'884100': '商用载货车',
'884101': '商用载客车',
'884105': '轨交设备',
'884106': '其他交运设备',
'884107': '汽车服务Ⅲ',
'884112': '冰洗',
'884113': '空调',
'884115': '小家电Ⅲ',
'884116': '其他白色家电',
'884117': '彩电',
'884118': '其他黑色家电',
'884119': '其他酒类',
'884120': '软饮料',
'884123': '肉制品',
'884124': '调味发酵品',
'884125': '乳品',
'884126': '其他食品',
'884128': '棉纺',
'884130': '印染',
'884131': '辅料',
'884132': '其他纺织',
'884136': '鞋帽及其他',
'884137': '家纺',
'884139': '家具',
'884140': '其他家用轻工',
'884141': '饰品',
'884142': '文娱用品',
'884143': '原料药',
'884144': '化学制剂',
'884145': '医疗设备',
'884146': '火电',
'884147': '水电',
'884149': '热力',
'884150': '新能源发电',
'884152': '燃气Ⅲ',
'884153': '港口',
'884154': '高速公路',
'884155': '铁路运输',
'884156': '机场',
'884157': '航空运输',
'884158': '多元金融',
'884159': '保险',
'884160': '百货零售',
'884161': '专业连锁',
'884162': '商业物业经营',
'884163': '人工景点',
'884164': '自然景点',
'884165': '旅游综合',
'884167': '酒店',
'884168': '餐饮',
'884172': '有线电视网络',
'884173': '通信服务Ⅲ',
'884174': '软件开发',
'884176': '出版',
'884177': '影视院线',
'884178': '广告营销',
'884179': '其他传媒',
'884180': '航天装备',
'884181': '航空装备',
'884182': '地面兵装',
'884183': '航海装备',
'884184': '特钢',
'884185': '贵金属Ⅲ',
'884186': '其他小金属',
'884188': '白酒',
'884189': '啤酒',
'884191': '航运',
'884192': '仪器仪表Ⅲ',
'884193': '其他电子Ⅲ',
'884194': '汽车零部件Ⅲ',
'884195': '造纸Ⅲ',
'884197': '中药Ⅲ',
'884199': '医药商业Ⅲ',
'884200': '公交',
'884201': '物流Ⅲ',
'884202': '住宅开发',
'884203': '产业地产',
'884205': '证券Ⅲ',
'884206': '贸易Ⅲ',
'884207': '计算机设备Ⅲ',
'884208': '综合Ⅲ',
'884209': '钛白粉',
'884210': '食品及饲料添加剂',
'884211': '有机硅',
'884212': '合成树脂',
'884213': '膜材料',
'884214': '冶钢原料',
'884215': '稀土',
'884216': '能源金属',
'884217': '工程咨询服务',
'884218': '机器人',
'884219': '工控设备',
'884220': '激光设备',
'884221': '其他自动化设备',
'884222': '光伏设备',
'884223': '风电设备',
'884224': '电池',
'884225': '其他电源设备',
'884226': '集成电路设计',
'884227': '集成电路制造',
'884228': '集成电路封测',
'884229': '半导体设备',
'884230': '品牌消费电子',
'884231': '电子化学品Ⅲ',
'884232': '厨卫电器Ⅲ',
'884233': '休闲食品',
'884234': '服装',
'884235': '印刷',
'884236': '包装',
'884237': '瓷砖地板',
'884238': '血液制品',
'884239': '疫苗',
'884240': '其他生物制品',
'884242': '医疗耗材',
'884243': '体外诊断',
'884244': '医疗研发外包',
'884245': '其他医疗服务',
'884246': '电能综合服务',
'884247': '商业地产',
'884248': '房地产服务Ⅲ',
'884249': '国有大型银行',
'884250': '股份制银行',
'884251': '城商行',
'884252': '农商行',
'884253': '其他银行',
'884254': '旅游零售',
'884255': '互联网电商Ⅲ',
'884256': '教育Ⅲ',
'884257': '专业服务',
'884258': '体育',
'884259': '其他社会服务Ⅲ',
'884260': '游戏',
'884261': '数字媒体',
'884262': '通信网络设备及器件',
'884263': '通信线缆及配套',
'884264': '通信终端及配件',
'884265': '其他通信设备',
'884266': '军工电子',
'884267': '大气治理',
'884268': '水务及水治理',
'884269': '固废治理',
'884270': '综合环境治理',
'884271': '个护用品',
'884272': '化妆品',
'884273': '医疗美容',
'884274': 'IT服务'}
temp_df = | pd.DataFrame.from_dict(code_name_ths_map, orient="index") | pandas.DataFrame.from_dict |
import pandas as pd
import matplotlib
import matplotlib.pyplot as plt
matplotlib.use("Qt5Agg") # 声明使用QT5
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.figure import Figure
import mpl_finance as mpf
from matplotlib.pylab import date2num
class Figure_Canvas(FigureCanvas):
def __init__(self, parent=None, width=30, height=4, dpi=100):
plt.rcParams['font.sans-serif'] = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False # 用来正常显示负号
fig = Figure(figsize=(width, height), dpi=100) # 创建一个Figure
FigureCanvas.__init__(self, fig) # 初始化父类
self.setParent(parent)
self.axes = fig.add_subplot(111) # 调用figure下面的add_subplot方法
def pricePlot(self, date, start, end, high, low):
"""
Draw k-line chart.
:param date: stock date, a pd series type
:param start: open price, a pd series type
:param end: closed price, a pd series type
:param high: the highest price, a pd series type
:param low: the lowest price, a pd series type
:return: None
"""
date = pd.to_datetime(date)
date1 = date.apply(lambda x: date2num(x))
data = | pd.concat([date1, start, end, high, low], axis=1) | pandas.concat |
# -*- coding: utf-8 -*-
# pylint: disable=W0612,E1101
from datetime import datetime
import operator
import nose
from functools import wraps
import numpy as np
import pandas as pd
from pandas import Series, DataFrame, Index, isnull, notnull, pivot, MultiIndex
from pandas.core.datetools import bday
from pandas.core.nanops import nanall, nanany
from pandas.core.panel import Panel
from pandas.core.series import remove_na
import pandas.core.common as com
from pandas import compat
from pandas.compat import range, lrange, StringIO, OrderedDict, signature
from pandas import SparsePanel
from pandas.util.testing import (assert_panel_equal, assert_frame_equal,
assert_series_equal, assert_almost_equal,
assert_produces_warning, ensure_clean,
assertRaisesRegexp, makeCustomDataframe as
mkdf, makeMixedDataFrame)
import pandas.core.panel as panelm
import pandas.util.testing as tm
def ignore_sparse_panel_future_warning(func):
"""
decorator to ignore FutureWarning if we have a SparsePanel
can be removed when SparsePanel is fully removed
"""
@wraps(func)
def wrapper(self, *args, **kwargs):
if isinstance(self.panel, SparsePanel):
with assert_produces_warning(FutureWarning,
check_stacklevel=False):
return func(self, *args, **kwargs)
else:
return func(self, *args, **kwargs)
return wrapper
class PanelTests(object):
panel = None
def test_pickle(self):
unpickled = self.round_trip_pickle(self.panel)
assert_frame_equal(unpickled['ItemA'], self.panel['ItemA'])
def test_rank(self):
self.assertRaises(NotImplementedError, lambda: self.panel.rank())
def test_cumsum(self):
cumsum = self.panel.cumsum()
assert_frame_equal(cumsum['ItemA'], self.panel['ItemA'].cumsum())
def not_hashable(self):
c_empty = Panel()
c = Panel(Panel([[[1]]]))
self.assertRaises(TypeError, hash, c_empty)
self.assertRaises(TypeError, hash, c)
class SafeForLongAndSparse(object):
_multiprocess_can_split_ = True
def test_repr(self):
repr(self.panel)
@ignore_sparse_panel_future_warning
def test_copy_names(self):
for attr in ('major_axis', 'minor_axis'):
getattr(self.panel, attr).name = None
cp = self.panel.copy()
getattr(cp, attr).name = 'foo'
self.assertIsNone(getattr(self.panel, attr).name)
def test_iter(self):
tm.equalContents(list(self.panel), self.panel.items)
def test_count(self):
f = lambda s: notnull(s).sum()
self._check_stat_op('count', f, obj=self.panel, has_skipna=False)
def test_sum(self):
self._check_stat_op('sum', np.sum)
def test_mean(self):
self._check_stat_op('mean', np.mean)
def test_prod(self):
self._check_stat_op('prod', np.prod)
def test_median(self):
def wrapper(x):
if isnull(x).any():
return np.nan
return np.median(x)
self._check_stat_op('median', wrapper)
def test_min(self):
self._check_stat_op('min', np.min)
def test_max(self):
self._check_stat_op('max', np.max)
def test_skew(self):
try:
from scipy.stats import skew
except ImportError:
raise nose.SkipTest("no scipy.stats.skew")
def this_skew(x):
if len(x) < 3:
return np.nan
return skew(x, bias=False)
self._check_stat_op('skew', this_skew)
# def test_mad(self):
# f = lambda x: np.abs(x - x.mean()).mean()
# self._check_stat_op('mad', f)
def test_var(self):
def alt(x):
if len(x) < 2:
return np.nan
return np.var(x, ddof=1)
self._check_stat_op('var', alt)
def test_std(self):
def alt(x):
if len(x) < 2:
return np.nan
return np.std(x, ddof=1)
self._check_stat_op('std', alt)
def test_sem(self):
def alt(x):
if len(x) < 2:
return np.nan
return np.std(x, ddof=1) / np.sqrt(len(x))
self._check_stat_op('sem', alt)
# def test_skew(self):
# from scipy.stats import skew
# def alt(x):
# if len(x) < 3:
# return np.nan
# return skew(x, bias=False)
# self._check_stat_op('skew', alt)
def _check_stat_op(self, name, alternative, obj=None, has_skipna=True):
if obj is None:
obj = self.panel
# # set some NAs
# obj.ix[5:10] = np.nan
# obj.ix[15:20, -2:] = np.nan
f = getattr(obj, name)
if has_skipna:
def skipna_wrapper(x):
nona = remove_na(x)
if len(nona) == 0:
return np.nan
return alternative(nona)
def wrapper(x):
return alternative(np.asarray(x))
for i in range(obj.ndim):
result = f(axis=i, skipna=False)
assert_frame_equal(result, obj.apply(wrapper, axis=i))
else:
skipna_wrapper = alternative
wrapper = alternative
for i in range(obj.ndim):
result = f(axis=i)
if not tm._incompat_bottleneck_version(name):
assert_frame_equal(result, obj.apply(skipna_wrapper, axis=i))
self.assertRaises(Exception, f, axis=obj.ndim)
# Unimplemented numeric_only parameter.
if 'numeric_only' in signature(f).args:
self.assertRaisesRegexp(NotImplementedError, name, f,
numeric_only=True)
class SafeForSparse(object):
_multiprocess_can_split_ = True
@classmethod
def assert_panel_equal(cls, x, y):
assert_panel_equal(x, y)
def test_get_axis(self):
assert (self.panel._get_axis(0) is self.panel.items)
assert (self.panel._get_axis(1) is self.panel.major_axis)
assert (self.panel._get_axis(2) is self.panel.minor_axis)
def test_set_axis(self):
new_items = Index(np.arange(len(self.panel.items)))
new_major = Index(np.arange(len(self.panel.major_axis)))
new_minor = Index(np.arange(len(self.panel.minor_axis)))
# ensure propagate to potentially prior-cached items too
item = self.panel['ItemA']
self.panel.items = new_items
if hasattr(self.panel, '_item_cache'):
self.assertNotIn('ItemA', self.panel._item_cache)
self.assertIs(self.panel.items, new_items)
# TODO: unused?
item = self.panel[0] # noqa
self.panel.major_axis = new_major
self.assertIs(self.panel[0].index, new_major)
self.assertIs(self.panel.major_axis, new_major)
# TODO: unused?
item = self.panel[0] # noqa
self.panel.minor_axis = new_minor
self.assertIs(self.panel[0].columns, new_minor)
self.assertIs(self.panel.minor_axis, new_minor)
def test_get_axis_number(self):
self.assertEqual(self.panel._get_axis_number('items'), 0)
self.assertEqual(self.panel._get_axis_number('major'), 1)
self.assertEqual(self.panel._get_axis_number('minor'), 2)
def test_get_axis_name(self):
self.assertEqual(self.panel._get_axis_name(0), 'items')
self.assertEqual(self.panel._get_axis_name(1), 'major_axis')
self.assertEqual(self.panel._get_axis_name(2), 'minor_axis')
def test_get_plane_axes(self):
# what to do here?
index, columns = self.panel._get_plane_axes('items')
index, columns = self.panel._get_plane_axes('major_axis')
index, columns = self.panel._get_plane_axes('minor_axis')
index, columns = self.panel._get_plane_axes(0)
@ignore_sparse_panel_future_warning
def test_truncate(self):
dates = self.panel.major_axis
start, end = dates[1], dates[5]
trunced = self.panel.truncate(start, end, axis='major')
expected = self.panel['ItemA'].truncate(start, end)
assert_frame_equal(trunced['ItemA'], expected)
trunced = self.panel.truncate(before=start, axis='major')
expected = self.panel['ItemA'].truncate(before=start)
assert_frame_equal(trunced['ItemA'], expected)
trunced = self.panel.truncate(after=end, axis='major')
expected = self.panel['ItemA'].truncate(after=end)
assert_frame_equal(trunced['ItemA'], expected)
# XXX test other axes
def test_arith(self):
self._test_op(self.panel, operator.add)
self._test_op(self.panel, operator.sub)
self._test_op(self.panel, operator.mul)
self._test_op(self.panel, operator.truediv)
self._test_op(self.panel, operator.floordiv)
self._test_op(self.panel, operator.pow)
self._test_op(self.panel, lambda x, y: y + x)
self._test_op(self.panel, lambda x, y: y - x)
self._test_op(self.panel, lambda x, y: y * x)
self._test_op(self.panel, lambda x, y: y / x)
self._test_op(self.panel, lambda x, y: y ** x)
self._test_op(self.panel, lambda x, y: x + y) # panel + 1
self._test_op(self.panel, lambda x, y: x - y) # panel - 1
self._test_op(self.panel, lambda x, y: x * y) # panel * 1
self._test_op(self.panel, lambda x, y: x / y) # panel / 1
self._test_op(self.panel, lambda x, y: x ** y) # panel ** 1
self.assertRaises(Exception, self.panel.__add__, self.panel['ItemA'])
@staticmethod
def _test_op(panel, op):
result = op(panel, 1)
assert_frame_equal(result['ItemA'], op(panel['ItemA'], 1))
def test_keys(self):
tm.equalContents(list(self.panel.keys()), self.panel.items)
def test_iteritems(self):
# Test panel.iteritems(), aka panel.iteritems()
# just test that it works
for k, v in self.panel.iteritems():
pass
self.assertEqual(len(list(self.panel.iteritems())),
len(self.panel.items))
@ignore_sparse_panel_future_warning
def test_combineFrame(self):
def check_op(op, name):
# items
df = self.panel['ItemA']
func = getattr(self.panel, name)
result = func(df, axis='items')
assert_frame_equal(result['ItemB'], op(self.panel['ItemB'], df))
# major
xs = self.panel.major_xs(self.panel.major_axis[0])
result = func(xs, axis='major')
idx = self.panel.major_axis[1]
assert_frame_equal(result.major_xs(idx),
op(self.panel.major_xs(idx), xs))
# minor
xs = self.panel.minor_xs(self.panel.minor_axis[0])
result = func(xs, axis='minor')
idx = self.panel.minor_axis[1]
assert_frame_equal(result.minor_xs(idx),
op(self.panel.minor_xs(idx), xs))
ops = ['add', 'sub', 'mul', 'truediv', 'floordiv']
if not compat.PY3:
ops.append('div')
# pow, mod not supported for SparsePanel as flex ops (for now)
if not isinstance(self.panel, SparsePanel):
ops.extend(['pow', 'mod'])
else:
idx = self.panel.minor_axis[1]
with assertRaisesRegexp(ValueError, "Simple arithmetic.*scalar"):
self.panel.pow(self.panel.minor_xs(idx), axis='minor')
with assertRaisesRegexp(ValueError, "Simple arithmetic.*scalar"):
self.panel.mod(self.panel.minor_xs(idx), axis='minor')
for op in ops:
try:
check_op(getattr(operator, op), op)
except:
com.pprint_thing("Failing operation: %r" % op)
raise
if compat.PY3:
try:
check_op(operator.truediv, 'div')
except:
com.pprint_thing("Failing operation: %r" % 'div')
raise
@ignore_sparse_panel_future_warning
def test_combinePanel(self):
result = self.panel.add(self.panel)
self.assert_panel_equal(result, self.panel * 2)
@ignore_sparse_panel_future_warning
def test_neg(self):
self.assert_panel_equal(-self.panel, self.panel * -1)
# issue 7692
def test_raise_when_not_implemented(self):
p = Panel(np.arange(3 * 4 * 5).reshape(3, 4, 5),
items=['ItemA', 'ItemB', 'ItemC'],
major_axis=pd.date_range('20130101', periods=4),
minor_axis=list('ABCDE'))
d = p.sum(axis=1).ix[0]
ops = ['add', 'sub', 'mul', 'truediv', 'floordiv', 'div', 'mod', 'pow']
for op in ops:
with self.assertRaises(NotImplementedError):
getattr(p, op)(d, axis=0)
@ignore_sparse_panel_future_warning
def test_select(self):
p = self.panel
# select items
result = p.select(lambda x: x in ('ItemA', 'ItemC'), axis='items')
expected = p.reindex(items=['ItemA', 'ItemC'])
self.assert_panel_equal(result, expected)
# select major_axis
result = p.select(lambda x: x >= datetime(2000, 1, 15), axis='major')
new_major = p.major_axis[p.major_axis >= datetime(2000, 1, 15)]
expected = p.reindex(major=new_major)
self.assert_panel_equal(result, expected)
# select minor_axis
result = p.select(lambda x: x in ('D', 'A'), axis=2)
expected = p.reindex(minor=['A', 'D'])
self.assert_panel_equal(result, expected)
# corner case, empty thing
result = p.select(lambda x: x in ('foo', ), axis='items')
self.assert_panel_equal(result, p.reindex(items=[]))
def test_get_value(self):
for item in self.panel.items:
for mjr in self.panel.major_axis[::2]:
for mnr in self.panel.minor_axis:
result = self.panel.get_value(item, mjr, mnr)
expected = self.panel[item][mnr][mjr]
assert_almost_equal(result, expected)
@ignore_sparse_panel_future_warning
def test_abs(self):
result = self.panel.abs()
result2 = abs(self.panel)
expected = np.abs(self.panel)
self.assert_panel_equal(result, expected)
self.assert_panel_equal(result2, expected)
df = self.panel['ItemA']
result = df.abs()
result2 = abs(df)
expected = np.abs(df)
assert_frame_equal(result, expected)
assert_frame_equal(result2, expected)
s = df['A']
result = s.abs()
result2 = abs(s)
expected = np.abs(s)
assert_series_equal(result, expected)
assert_series_equal(result2, expected)
self.assertEqual(result.name, 'A')
self.assertEqual(result2.name, 'A')
class CheckIndexing(object):
_multiprocess_can_split_ = True
def test_getitem(self):
self.assertRaises(Exception, self.panel.__getitem__, 'ItemQ')
def test_delitem_and_pop(self):
expected = self.panel['ItemA']
result = self.panel.pop('ItemA')
assert_frame_equal(expected, result)
self.assertNotIn('ItemA', self.panel.items)
del self.panel['ItemB']
self.assertNotIn('ItemB', self.panel.items)
self.assertRaises(Exception, self.panel.__delitem__, 'ItemB')
values = np.empty((3, 3, 3))
values[0] = 0
values[1] = 1
values[2] = 2
panel = Panel(values, lrange(3), lrange(3), lrange(3))
# did we delete the right row?
panelc = panel.copy()
del panelc[0]
assert_frame_equal(panelc[1], panel[1])
assert_frame_equal(panelc[2], panel[2])
panelc = panel.copy()
del panelc[1]
assert_frame_equal(panelc[0], panel[0])
assert_frame_equal(panelc[2], panel[2])
panelc = panel.copy()
del panelc[2]
assert_frame_equal(panelc[1], panel[1])
assert_frame_equal(panelc[0], panel[0])
def test_setitem(self):
# LongPanel with one item
lp = self.panel.filter(['ItemA', 'ItemB']).to_frame()
with tm.assertRaises(ValueError):
self.panel['ItemE'] = lp
# DataFrame
df = self.panel['ItemA'][2:].filter(items=['A', 'B'])
self.panel['ItemF'] = df
self.panel['ItemE'] = df
df2 = self.panel['ItemF']
assert_frame_equal(df, df2.reindex(index=df.index, columns=df.columns))
# scalar
self.panel['ItemG'] = 1
self.panel['ItemE'] = True
self.assertEqual(self.panel['ItemG'].values.dtype, np.int64)
self.assertEqual(self.panel['ItemE'].values.dtype, np.bool_)
# object dtype
self.panel['ItemQ'] = 'foo'
self.assertEqual(self.panel['ItemQ'].values.dtype, np.object_)
# boolean dtype
self.panel['ItemP'] = self.panel['ItemA'] > 0
self.assertEqual(self.panel['ItemP'].values.dtype, np.bool_)
self.assertRaises(TypeError, self.panel.__setitem__, 'foo',
self.panel.ix[['ItemP']])
# bad shape
p = Panel(np.random.randn(4, 3, 2))
with tm.assertRaisesRegexp(ValueError,
"shape of value must be \(3, 2\), "
"shape of given object was \(4, 2\)"):
p[0] = np.random.randn(4, 2)
def test_setitem_ndarray(self):
from pandas import date_range, datetools
timeidx = date_range(start=datetime(2009, 1, 1),
end=datetime(2009, 12, 31),
freq=datetools.MonthEnd())
lons_coarse = np.linspace(-177.5, 177.5, 72)
lats_coarse = np.linspace(-87.5, 87.5, 36)
P = Panel(items=timeidx, major_axis=lons_coarse,
minor_axis=lats_coarse)
data = np.random.randn(72 * 36).reshape((72, 36))
key = datetime(2009, 2, 28)
P[key] = data
assert_almost_equal(P[key].values, data)
def test_set_minor_major(self):
# GH 11014
df1 = DataFrame(['a', 'a', 'a', np.nan, 'a', np.nan])
df2 = | DataFrame([1.0, np.nan, 1.0, np.nan, 1.0, 1.0]) | pandas.DataFrame |
import datetime as dt
import gc
import json
import logging
import os
import pickle
from glob import glob
from typing import Dict, List, Optional, Tuple, Union
import h5py
import matplotlib as mpl
import matplotlib.dates as mdates
import matplotlib.gridspec as gs
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import pyproj
import rasterio as rio
import simplekml
from cataloging.vi import gliImage, ngrdiImage, osaviImage
from fluidml.common import Task
#from PIL import Image
from pycpd import RigidRegistration
from pykml import parser
from rasterio.enums import Resampling
from rasterio.transform import rowcol, xy
from rasterio.windows import Window
from scipy.ndimage import distance_transform_edt
from scipy.optimize import curve_fit
from scipy.signal import find_peaks
#from skimage.exposure import equalize_adapthist
from skimage.feature import peak_local_max
from skimage.filters import gaussian, threshold_otsu
from skimage.measure import label, regionprops
from skimage.segmentation import watershed
from skimage.transform import hough_line, hough_line_peaks, resize
from sklearn.neighbors import NearestNeighbors
logger = logging.getLogger(__name__)
# suppress pickle 'error' from rasterio
logging.Logger.manager.loggerDict['rasterio'].setLevel(logging.CRITICAL)
logging.Logger.manager.loggerDict['matplotlib'].setLevel(logging.CRITICAL)
import warnings
warnings.filterwarnings("ignore")
mpl.use('Agg')
def read_raster(
image_path: str,
all_channels: np.array,
channels: List[str]
):
ch = [np.argmax(all_channels == c)+1 for c in channels]
raster = rio.open(image_path)
if raster.dtypes[0] == "float32":
data = raster.read(ch, fill_value=np.nan)
data /= np.nanmax(data)
elif raster.dtypes[0] == "uint8":
if "alpha" in all_channels:
data = raster.read(ch).astype(np.float32)
alpha_ch = raster.read(int(np.argmax(all_channels == "alpha")+1))
for d in data[:,:]:
d[alpha_ch == 0] = np.nan
else:
data = raster.read(ch, fill_value=0).astype(np.float32)
else:
raise NotImplementedError()
return np.transpose(data, axes=(1,2,0))
def write_onechannel_raster(
image_path: str,
image: np.array,
meta: Dict, dtype: str
):
if dtype == 'float32':
meta.update({
'dtype': 'float32',
'height': image.shape[0],'count': 1,'nodata': -32767,
'width': image.shape[1]})
elif dtype == 'uint8':
meta.update({
'dtype': 'uint8',
'height': image.shape[0],'count': 1,'nodata': 0,
'width': image.shape[1]})
else:
raise NotImplementedError()
with rio.open(image_path, "w", **meta) as dest:
dest.write(image,1)
def calc_m_per_px(
raster_meta: Dict
) -> float:
# read CRS of rasterio data
proj_crs = pyproj.crs.CRS.from_user_input(raster_meta["crs"])
# GPS coordinates of anchor point
lon0, lat0 = xy(raster_meta["transform"],0,0)
# calculate UTM zone
utm_zone = int(np.floor((lon0/360)*60+31))
utm = pyproj.Proj(proj='utm', zone=utm_zone, ellps='WGS84')
UTM0_x, UTM0_y = utm(*xy(raster_meta["transform"],0,0))
UTM1_x, UTM1_y = utm(*xy(raster_meta["transform"],0,1))
UTM2_x, UTM2_y = utm(*xy(raster_meta["transform"],1,0))
# calculate unit pixel distances
pxx = abs(UTM1_x - UTM0_x)
pxy = abs(UTM2_y - UTM0_y)
# take mean (assume quadratic pixels)
m_per_px = np.mean([pxx, pxy])
return m_per_px
def px_to_utm(
point_cloud: np.ndarray,
raster_meta: Dict
) -> Tuple[np.ndarray, pyproj.proj.Proj]:
# read CRS of rasterio data
proj_crs = pyproj.crs.CRS.from_user_input(raster_meta["crs"])
# GPS coordinates of point cloud
lon, lat = np.asarray(xy(raster_meta["transform"],*point_cloud.T))
# calculate UTM zone
utm_zone = int(np.floor((lon.mean()/360)*60+31))
utm_transform = pyproj.Proj(proj='utm', zone=utm_zone, ellps='WGS84')
utm = np.asarray(utm_transform(lon, lat)).T
return utm, utm_transform
def readCoordsFromKml(
filename: str
) -> np.ndarray:
with open(filename, "r") as kmlfile:
root = parser.parse(kmlfile).getroot()
lonlat = []
for c in root.Document.iterchildren():
lonlat.append([float(x) for x in c.Point.coordinates.text.split(",")[:2]])
lonlat = np.asarray(lonlat)
return lonlat
def growFunction(
x: float,
g: float,
lg: float,
xg: float,
d: float,
ld: float,
xd: float
) -> float:
if d > 0:
return (g/(1+np.exp(-lg*(x-xg)))) - d/(1+np.exp(-ld*(x-xd)))
else:
return (g/(1+np.exp(-lg*(x-xg))))
def cumDays(
observation_dates: Union[List[float],np.array]
) -> np.array:
cum_days = np.cumsum([d.days for d in np.diff(np.sort(observation_dates))]).astype(float)
cum_days = np.hstack((0, cum_days))
return cum_days
def growScaling(
cum_days: np.array,
bounds: Tuple,
grow_func_params: np.array
) -> np.array:
earliest, latest = bounds
grow_func = growFunction(cum_days, *grow_func_params)
maxgrow_val = np.max(grow_func)
grow_func = (grow_func - grow_func[0]) / (maxgrow_val - grow_func[0])
scaled = grow_func * (latest - earliest) + earliest
return scaled
def makeDirectory(
directory: str
) -> None:
if not os.path.exists(directory):
os.makedirs(directory)
def group_points(
points: np.array,
layers: np.array,
max_dist: float
) -> Tuple[np.array, np.array]:
nn = NearestNeighbors(n_neighbors=1, n_jobs=-1)
# initialization
# -> all labels to -1
labels = -np.ones_like(layers)
# all given layers
uni_layers = np.unique(layers)
# -> give points of first layer individual group labels
labels[layers == uni_layers[0]] = np.arange(np.sum(layers == uni_layers[0]))
# -> first evaluation point cloud: first layer
centroids = points[layers == uni_layers[0]]
ind = np.arange(len(points))
for i in range(1, len(uni_layers)):
# fit nearest neighbor model
nn.fit(centroids)
# evaluate on next layer
dist, ass_group = nn.kneighbors(points[layers == uni_layers[i]])
dist = dist.flatten()
ass_group = ass_group.flatten()
# exclude points that have more than max_dist distance to a neighbor
# new_member array:
# 1 = valid member candidate for existing group
# 0 = valid member candidate for new group
# -1 = excluded due to multiple candidates for a single group
new_member = (dist <= max_dist).astype(int)
# if multiple (valid!) points are assigned to the same group, take the nearest
valid = np.copy(new_member).astype(bool)
valid_ind = np.arange(len(valid))[valid]
for j, counts in enumerate(np.bincount(ass_group[valid])):
if counts > 1:
ass_group_ind = valid_ind[ass_group[valid] == j]
best_ind = ass_group_ind[np.argsort(dist[ass_group_ind])]
new_member[best_ind[1:]] = -1
# assign the group labels to the new members
layer_ind = ind[layers == uni_layers[i]]
old_layer_ind = layer_ind[new_member == 1]
labels[old_layer_ind] = ass_group[new_member == 1]
# give new group labels to points not registered so far
new_layer_ind = layer_ind[new_member == 0]
labels[new_layer_ind] = np.arange(labels.max()+1, labels.max()+1+len(new_layer_ind))
# new reference cloud are the centroids of the so far accumulated clusters
centroids = np.stack([np.mean(points[labels == label], axis=0) for label in range(labels.max()+1)])
return labels, centroids
def inverse_transform(
xy_centered_aligned,
xy_center,
transform_coeffs
):
s = transform_coeffs[0]
rot = np.deg2rad(transform_coeffs[1])
t = transform_coeffs[2:]
rot_inv = np.array([[np.cos(rot), np.sin(rot)], [-np.sin(rot), np.cos(rot)]])
return rot_inv@(xy_centered_aligned-t).T/s + xy_center
def add_non_detected(
df_less: pd.DataFrame,
df_meta: pd.DataFrame
) -> pd.DataFrame:
dates = np.unique(df_meta["date"])
xy_center = df_meta["xy_center"].iloc[0]
df_add = pd.DataFrame()
for g_id in np.unique(df_less["group_id"]):
df_group = df_less[df_less["group_id"] == g_id]
missing_dates = dates[np.isin(dates, df_group["date"], invert=True)]
for d in missing_dates:
xy_centered_aligned = df_group["xy_centered_aligned_cm"].mean(axis=0) # group centroid [cm (UTM)]
cropline_y = df_group["y_cropline_rotated_cm"].iloc[0]
align_transform = df_meta[df_meta["date"] == d]["align_transform"].iloc[0]
gps_transform = df_meta[df_meta["date"] == d]["gps_transform"].iloc[0]
utm_transform = df_meta[df_meta["date"] == d]["utm_transform"].iloc[0]
#cr = df_meta[df_meta["date"] == d]["cover_ratio"].values
#mc = df_meta[df_meta["date"] == d]["align_median_confidence"].values
xy_backtrans = inverse_transform(xy_centered_aligned, xy_center, align_transform)
lonlat_backtrans = utm_transform(*xy_backtrans/100., inverse=True)
df_add = df_add.append(
dict([("field_id" , df_group["field_id"].iloc[0]),
("date" , d),
("group_id" , g_id),
("group_size" , df_group["group_size"].iloc[0]),
("group_cropline_id" , df_group["group_cropline_id"].iloc[0]),
("xy_cm" , xy_backtrans),
("xy_px" , list(rowcol(gps_transform, *lonlat_backtrans))),
("lonlat" , lonlat_backtrans),
("xy_centered_aligned_cm" , xy_centered_aligned),
("xy_centroid_centered_aligned_cm" , xy_centered_aligned),
("y_cropline_rotated_cm" , cropline_y),
("centroid_dist_cm" , 0.),
("detected" , False)]), ignore_index=True)
return df_add
def filterGoodPlantsByPercDet(
plants_df: pd.DataFrame,
meta_df: pd.DataFrame,
filter_coverratio: float,
perc_min_det: float
) -> pd.DataFrame:
plants_meta_df = plants_df.merge(meta_df, on=["date", "field_id"], how="left")
n_dates = len(np.unique(meta_df["date"]))
# good plant group := at least perc_min_det direct detection ratio up to certain given cover ratio
good_idx = []
for f_id in np.unique(meta_df["field_id"]):
n_counts_below_cr_thres = np.sum(np.unique(plants_meta_df[plants_meta_df["field_id"]==f_id]["cover_ratio"]) <= filter_coverratio)
groups, counts = np.unique(plants_meta_df[(plants_meta_df["field_id"]==f_id) & (plants_meta_df["cover_ratio"] <= filter_coverratio) & (plants_meta_df["detected"] == True)]["group_id"], return_counts=True)
interest_groups = groups[counts/float(n_counts_below_cr_thres) >= perc_min_det]
candidates = plants_meta_df[(plants_meta_df["field_id"]==f_id) & (np.isin(plants_meta_df["group_id"], interest_groups))]
for g_id in interest_groups:
cand_group = candidates[candidates["group_id"]==g_id]
if len(cand_group)==n_dates:
good_idx.extend(cand_group.index)
good_df = plants_meta_df.loc[good_idx].sort_values(["field_id", "group_id", "date"])
return good_df
class SegmentSoilPlants(Task):
def __init__(
self,
image_path: str,
image_channels: List[str],
veg_index: str,
use_watershed: bool,
max_coverratio: float,
make_orthoimage: bool,
orthoimage_dir: str,
plot_result: bool,
plot_dir: str,
plot_format: str,
plot_dpi: int,
plot_cmap: str
):
super().__init__()
self.image_path = image_path
self.image_channels = np.asarray(image_channels)
self.veg_index = veg_index
self.use_watershed = use_watershed
self.max_coverratio = max_coverratio
self.make_orthoimage = make_orthoimage
self.orthoimage_dir = orthoimage_dir
self.plot_result = plot_result
self.plot_dir = plot_dir
self.plot_format = plot_format
self.plot_dpi = plot_dpi
self.plot_cmap = plot_cmap
def plot_raw(
self
):
logger.info(f"{self.name}-{self.date.date()} -> Plot raw image.")
if len(self.image_channels) < 4:
n_rows, n_cols = 1, len(self.image_channels)
else:
n_rows, n_cols = 2, len(self.image_channels)//2
fig, ax = plt.subplots(n_rows, n_cols, sharex=True, sharey=True, figsize=(self.width/500*n_cols, self.height/800*n_rows))
data = read_raster(self.image_path, self.image_channels, self.image_channels)
for (i, (a, c)) in enumerate(zip(ax.ravel(), self.image_channels)):
im = a.imshow(data[:,:,i], cmap=self.plot_cmap)
try:
fig.colorbar(im, ax=a)
except:
pass
a.set(xlabel='x', ylabel='y', title = c, aspect='equal')
fig.suptitle("raw image data")
fig.savefig(os.path.join(self.plot_dir, f"{self.field_id}_{self.date.date()}_01_channels"+self.plot_format), dpi=self.plot_dpi, bbox_inches='tight')
fig.clf()
del data, fig, ax, im
plt.close("all")
gc.collect()
def plot_segmentation(
self
):
logger.info(f"{self.name}-{self.date.date()} -> Plot segmentation image.")
fig = plt.figure(figsize=(3*self.width/500, self.height/500), tight_layout=True)
gridspec = gs.GridSpec(1,3,width_ratios=[2,1,2], figure=fig)
ax1 = fig.add_subplot(gridspec[0])
ax2 = fig.add_subplot(gridspec[1])
ax3 = fig.add_subplot(gridspec[2])
m = ax1.imshow(self.vi_image.astype(float), cmap=self.plot_cmap, vmin=-1, vmax=1)
cb = fig.colorbar(m, ax=ax1)
cb.set_label("VI")
ax1.set(title=f"{self.veg_index} image", xlabel="px", ylabel="px")
ax2.hist(self.vi_image[np.isfinite(self.vi_image)], bins=256, orientation="horizontal", color="C0")
ax2.set(title=f"{self.veg_index} value distribution", ylim=(-1,1), xlabel="counts", xscale="log")
if self.cover_ratio_est < 0.01:
ax2.axhline(self.thres, c='r', label=f"Threshold (99-percentile): {self.thres:.2f}")
else:
ax2.axhline(self.thres, c='r', label=f"Threshold (Otsu): {self.thres:.2f}")
ax2.legend()
ax3.imshow(self.seg_mask, cmap=self.plot_cmap)
ax3.set(title=f"Segmented plant area (cover ratio: {100.*self.cover_ratio:.2f} %)", xlabel="px", ylabel="px")
fig.savefig(os.path.join(self.plot_dir, f"{self.field_id}_{self.date.date()}_02_segmentation"+self.plot_format), dpi=self.plot_dpi, bbox_inches='tight')
fig.clf()
plt.close("all")
del fig, ax1, ax2, ax3
gc.collect()
def run(
self
):
try:
self.field_id, d = os.path.basename(self.image_path).replace(".tif", "").split("_")[:2]
year = int(d[:4])
month = int(d[4:6])
day = int(d[6:8])
self.date = dt.datetime(year, month, day)
except:
logger.error(f"Wrong image path or no files found: {self.image_path}")
logger.info(f"{self.name}-{self.date.date()} -> Load image.")
raster = rio.open(self.image_path)
raster_meta = raster.meta
self.height, self.width = raster.shape
px_res = calc_m_per_px(raster_meta)*100. # cm/px
logger.info(f"{self.name}-{self.date.date()} -> Calculated resolution: {px_res:.4f} cm/px.")
del raster
gc.collect()
# calculate Vegetation Index which has values in [-1,1]
if self.veg_index == "NGRDI":
channels = read_raster(self.image_path, self.image_channels, ["R", "G"])
self.vi_image = ngrdiImage(R = channels[:,:,0], G = channels[:,:,1])
est_thres = 0
elif self.veg_index == "GLI":
channels = read_raster(self.image_path, self.image_channels, ["R", "G", "B"])
self.vi_image = gliImage(R = channels[:,:,0], G = channels[:,:,1], B = channels[:,:,2])
est_thres = 0.2
elif self.veg_index == "OSAVI":
channels = read_raster(self.image_path, self.image_channels, ["R", "NIR"])
self.vi_image = osaviImage(R = channels[:,:,0], NIR = channels[:,:,1], y_osavi = 0.6)
est_thres = 0.25
del channels
gc.collect()
# cover ratio estimation
self.cover_ratio_est = np.nansum(self.vi_image >= est_thres)/np.sum(np.isfinite(self.vi_image))
logger.info(f"{self.name}-{self.date.date()} -> Use {self.veg_index} Vegetation Index. Cover ratio estimation: {self.cover_ratio_est*100.:.2f} %")
if self.cover_ratio_est <= self.max_coverratio:
# calculate threshold with Otsu's method
if self.cover_ratio_est < 0.01:
self.thres = np.percentile(self.vi_image[np.isfinite(self.vi_image)], 99)
logger.warn(f"{self.name}-{self.date.date()} -> Estimated cover ratio below 1 % -> Take 99-percentile as threshold: {self.thres:.2f}")
else:
self.thres = threshold_otsu(self.vi_image[np.isfinite(self.vi_image)])
logger.info(f"{self.name}-{self.date.date()} -> Otsu threshold: {self.thres:.2f}")
# segmentation
if self.use_watershed:
logger.info(f"{self.name}-{self.date.date()} -> Segment soil and plants with watershed method.")
markers = np.zeros_like(self.vi_image, dtype=np.uint8)
markers[self.vi_image <= self.thres] = 1 # soil
markers[self.vi_image > self.thres] = 2 # plant
self.seg_mask = (watershed(self.vi_image, markers) - 1).astype(bool) # True -> plant, False -> soil
del markers
else:
logger.info(f"{self.name}-{self.date.date()} -> Segment soil and plants without watershed method.")
self.seg_mask = np.zeros_like(self.vi_image, dtype=bool) # True -> plant, False -> soil
self.seg_mask[self.vi_image > self.thres] = True # plant
self.cover_ratio = np.sum(self.seg_mask)/np.sum(np.isfinite(self.vi_image))
logger.info(f"{self.name}-{self.date.date()} -> Cover ratio recalculated: {self.cover_ratio*100.:.2f} %")
if self.plot_result:
makeDirectory(self.plot_dir)
self.plot_segmentation()
gc.collect()
else:
logger.warn(f"{self.name}-{self.date.date()} -> Estimated cover ratio ({self.cover_ratio_est*100.:.2f} %) is too high to extract plants -> Skip plot.")
self.seg_mask = []
self.cover_ratio = self.cover_ratio_est
self.save(obj=self.seg_mask, name="segmentation_mask", type_='pickle')
self.save(obj=self.cover_ratio, name="cover_ratio", type_='json')
self.save(obj=self.field_id, name="field_id", type_='json')
self.save(obj=self.date, name="date", type_='pickle')
self.save(obj=raster_meta, name="raster_meta", type_='pickle')
self.save(obj=px_res, name="px_resolution", type_='json')
if (self.make_orthoimage) and (self.seg_mask != []):
makeDirectory(self.orthoimage_dir)
logger.info(f"{self.name}-{self.date.date()} -> Save segmentation mask as orthoimage.")
write_onechannel_raster(os.path.join(self.orthoimage_dir, f"{self.field_id}_{self.date.date()}_segmentation.tif"),
np.uint8(self.seg_mask*255),
raster_meta,
"uint8")
# plot raw channel information
if self.plot_result:
makeDirectory(self.plot_dir)
self.plot_raw()
gc.collect()
class FitGrowFunction(Task):
def __init__(
self,
plot_result: bool,
plot_dir: str,
plot_format: str,
plot_dpi: int
):
super().__init__()
self.plot_result = plot_result
self.plot_dir = plot_dir
self.plot_format = plot_format
self.plot_dpi = plot_dpi
def plot(
self
):
logger.info(f"{self.name} -> Plot Grow function.")
g, lg, xg, d, ld, xd = self.fit
cd = np.linspace(0, self.cum_days[-1], 1000)
cal_days = [self.observation_dates[0] + dt.timedelta(days=x) for x in self.cum_days]
fig, ax = plt.subplots()
ax.scatter(self.cum_days, self.cover_ratios, label="observations")
if d > 0:
label = r"grow function fit: $f(x)=\frac{g}{1+e^{-\lambda_g(x-x_g)}}-\frac{d}{1+e^{-\lambda_d(x-x_d)}}$"+f"\n$g$={g:.4g}, $\\lambda_g$={lg:.4g}, $x_g$={xg:.4g}\n$d$={d:.4g}, $\\lambda_d$={ld:.4g}, $x_d$={xd:.4g}"
else:
label = r"grow function fit: $f(x)=\frac{g}{1+e^{-\lambda_g(x-x_g)}}$"+f"\n$g$={g:.4g}, $\\lambda_g$={lg:.4g}, $x_g$={xg:.4g}"
ax.plot(cd, growFunction(cd, *self.fit), c="r", label=label)
ax.format_xdata = mdates.DateFormatter('%Y-%m-%d')
ax.set(xlabel="days", ylabel="cover ratio")
ax.legend()
ax.grid()
ax_dt = ax.twiny()
ax_dt.set_xlim(map(lambda cd: self.observation_dates[0] + dt.timedelta(days=cd), ax.get_xlim()))
ax_dt.set_xlabel("calendar date")
ax_dt.set_xticks(cal_days)
ax_dt.tick_params(axis='x', labelrotation=90)
ax.set(title=f"{self.field_id}: grow function fit")
savename = os.path.join(self.plot_dir, f"{self.field_id}_grow_function"+self.plot_format)
fig.savefig(savename, dpi=self.plot_dpi, bbox_inches='tight')
plt.close("all")
del fig, ax, ax_dt
def run(
self,
reduced_results: List[Dict[str, Dict]]
):
cover_ratios = []
observation_dates = []
for r in reduced_results:
cover_ratios.append(r["result"]["cover_ratio"])
observation_dates.append(r["result"]["date"])
observation_dates = np.asarray(observation_dates)
cover_ratios = np.asarray(cover_ratios)
sort = np.argsort(observation_dates)
self.observation_dates = observation_dates[sort]
self.cover_ratios = cover_ratios[sort]
self.cum_days = cumDays(self.observation_dates)
self.field_id = reduced_results[0]["result"]["field_id"]
try:
self.fit, self.cov = curve_fit(growFunction, self.cum_days, self.cover_ratios,
p0=[0.8, 0.1, self.cum_days[-1]/3, 0.3, 0.1, 2*self.cum_days[-1]/3],
maxfev=1000000)
# calculate corrected cover ratios with grow function
#gf_cover_ratio = growFunction(self.cum_days, *self.fit)
#self.save(obj=gf_cover_ratio, name="grow_function_cover_ratios", type_='pickle')
#self.save(obj=self.observation_dates, name="dates", type_='pickle')
logger.info(f"{self.name} -> Grow function fitted")
if self.plot_result:
makeDirectory(self.plot_dir)
self.plot()
gc.collect()
except Exception as e:
self.fit = np.nan
self.cov = np.nan
logger.warning(f"{self.name} -> Grow function could not be fitted. Error: {e}")
self.save(obj=self.fit, name="grow_function_fit_params", type_='pickle')
self.save(obj=self.cov, name="grow_function_cov_matrix", type_='pickle')
class ExtractPlantPositions(Task):
def __init__(
self,
min_peak_distance: float,
peak_threshold: float,
gauss_sigma_bounds: Tuple[float, float],
use_growfunction: bool,
make_orthoimage: bool,
orthoimage_dir: str,
plot_result: bool,
plot_dir: str,
plot_format: str,
plot_dpi: int,
plot_cmap: str
):
super().__init__()
self.min_peak_distance = min_peak_distance
self.peak_threshold = peak_threshold
self.gauss_sigma_bounds = gauss_sigma_bounds
self.use_growfunction = use_growfunction
self.make_orthoimage = make_orthoimage
self.orthoimage_dir = orthoimage_dir
self.plot_result = plot_result
self.plot_dir = plot_dir
self.plot_format = plot_format
self.plot_dpi = plot_dpi
self.plot_cmap = plot_cmap
def plot_gauss_blur(
self
):
logger.info(f"{self.name}-{self.date.date()} -> Plot Gaussian blur image.")
fig, ax = plt.subplots(figsize=(self.width/500, self.height/500))
im = ax.imshow(self.blurred, cmap='gray')
ax.set(title=f"Gaussian blur ($\sigma$ = {self.sigma:.2f} px)", aspect='equal', xlabel='x [cm]', ylabel='y [cm]')
fig.savefig(os.path.join(self.plot_dir, f"{self.field_id}_{self.date.date()}_03_gauss_blur"+self.plot_format), dpi=self.plot_dpi, bbox_inches='tight')
fig.clf()
plt.close("all")
del fig, ax
def plot_peaks(
self
):
logger.info(f"{self.name}-{self.date.date()} -> Plot peak position image.")
fig, ax = plt.subplots(figsize=(self.width/500, self.height/500))
ax.scatter(*self.peaks.T[::-1], color='red', s=2, label=f"{len(self.peaks)} peaks")
ax.imshow(self.blurred, cmap=self.plot_cmap)
ax.set(title=f"Peaks (min. distance = {self.min_peak_distance} cm = {self.min_peak_distance/self.px_res:.2f} px)", aspect='equal', xlabel='x [px]', ylabel='y [px]')
ax.legend()
fig.savefig(os.path.join(self.plot_dir, f"{self.field_id}_{self.date.date()}_04_peaks"+self.plot_format), dpi=self.plot_dpi, bbox_inches='tight')
fig.clf()
plt.close("all")
del fig, ax
def run(
self,
segmentation_mask: np.ndarray,
#grow_function_cover_ratios: np.array,
#dates: np.array,
px_resolution: float,
cover_ratio: float,
date: dt.datetime,
field_id: str,
raster_meta: Dict
):
self.date = date
self.field_id = field_id
self.px_res = px_resolution
if len(segmentation_mask) > 0:
# apply gaussian filter with scaled sigma
if self.use_growfunction:
raise NotImplementedError()
#cover_ratio = grow_function_cover_ratios[dates == date]
#logger.info(f"{self.name}-{self.date.date()} -> Use cover ratio from grow function fit. ({100.*cover_ratio:.2f} %)")
else:
logger.info(f"{self.name}-{self.date.date()} -> Use standard cover ratio. ({100.*cover_ratio:.2f} %)")
self.sigma = (self.gauss_sigma_bounds[0] + cover_ratio*np.diff(self.gauss_sigma_bounds)[0]) / self.px_res
logger.info(f"{self.name}-{self.date.date()} -> Blurring with sigma = {self.sigma*px_resolution:.2f} cm = {self.sigma:.2f} px.")
self.blurred = gaussian(segmentation_mask.astype(np.float32), sigma=self.sigma)
# detect peaks
logger.info(f"{self.name}-{self.date.date()} -> Detect peaks with threshold {self.peak_threshold} and min. distance = {self.min_peak_distance} cm = {self.min_peak_distance/self.px_res:.2f} px.")
self.peaks = peak_local_max(self.blurred, min_distance=int(np.round(self.min_peak_distance/self.px_res)), threshold_abs=self.peak_threshold, exclude_border=False)
# convert peak position from pixel to cm coordinates with UTM coordinate transformation
utm_peaks, utm_transform = px_to_utm(point_cloud=self.peaks, raster_meta=raster_meta)
utm_peaks *= 100 # m * 100 = cm
n_peaks = len(self.peaks)
self.height, self.width = self.blurred.shape
logger.info(f"{self.name}-{self.date.date()} -> {n_peaks} peaks detected.")
if (self.make_orthoimage):
makeDirectory(self.orthoimage_dir)
logger.info(f"{self.name}-{self.date.date()} -> Save Gauss blurred orthoimage.")
write_onechannel_raster(os.path.join(self.orthoimage_dir, f"{self.field_id}_{self.date.date()}_blurred.tif"),
self.blurred,
raster_meta,
"float32")
logger.info(f"{self.name}-{self.date.date()} -> Export found peak positions as KML file.")
kml = simplekml.Kml()
for (lon, lat) in np.asarray(xy(raster_meta["transform"], *self.peaks.T)).T:
kml.newpoint(coords=[(lon, lat)])
kml.save(os.path.join(self.orthoimage_dir, f"{self.field_id}_{self.date.date()}_peaks.kml"))
else:
logger.warn(f"{self.name}-{self.date.date()} -> No segmentation mask due to large cover ratio -> Skip plot.")
utm_peaks = np.array([])
# calculate UTM zone
lon, lat = np.asarray(xy(raster_meta["transform"], raster_meta["height"]//2, raster_meta["width"]//2))
utm_zone = int(np.floor((lon/360)*60+31))
utm_transform = pyproj.Proj(proj='utm', zone=utm_zone, ellps='WGS84')
self.save(obj=utm_peaks, name="plant_positions", type_="pickle")
self.save(obj=utm_transform, name="utm_transform", type_="pickle")
# plot blurred image and contrast image with peak positions
if (len(segmentation_mask) > 0) and self.plot_result:
makeDirectory(self.plot_dir)
self.plot_gauss_blur()
self.plot_peaks()
gc.collect()
class LoadPeaks(Task):
def __init__(
self,
field_id: str,
plot_result: bool,
plot_dir: str,
plot_format: str,
plot_dpi: int,
plot_cmap: str
):
super().__init__()
self.field_id = field_id
self.plot_result = plot_result
self.plot_dir = plot_dir
self.plot_format = plot_format
self.plot_dpi = plot_dpi
self.plot_cmap = plot_cmap
def plot(
self
):
logger.info(f"{self.name} -> Plot raw peaks image.")
fig, ax = plt.subplots()
ax.scatter(*self.C.T, s=2, alpha=0.8, c=self.layers, cmap=self.plot_cmap)
ax.set(title=f"{self.field_id}\nraw points", xlabel='x [cm]', ylabel='y [cm]', aspect='equal')
fig.savefig(os.path.join(self.plot_dir, f"{self.field_id}_01_raw"+self.plot_format), dpi=self.plot_dpi, bbox_inches='tight')
fig.clf()
plt.close("all")
del fig, ax
def run(
self,
reduced_results: List[Dict[str, Dict]]
):
cover_ratios, dates, gps_transforms, px_resolutions, field_ids, peaks, utm_transforms, segmentation_masks = [], [], [], [], [], [], [], []
for r in reduced_results:
try:
if len(r["config"].keys()) == 1:
cover_ratios.append(r["result"]["cover_ratio"])
dates.append(r["result"]["date"])
gps_transforms.append(r["result"]["raster_meta"]["transform"])
px_resolutions.append(r["result"]["px_resolution"])
field_ids.append(r["result"]["field_id"])
segmentation_masks.append(r["result"]["segmentation_mask"])
else:
peaks.append(r["result"]["plant_positions"])
utm_transforms.append(r["result"]["utm_transform"])
except:
logger.error(r)
assert len(np.unique(field_ids)) == 1, logger.error(f"{self.name} -> Multiple field IDs!")
assert np.unique(field_ids)[0] == self.field_id, logger.error(f"{self.name} -> Wrong field ID!")
cover_ratios = np.asarray(cover_ratios)
px_resolutions = np.asarray(px_resolutions)
dates = | pd.DatetimeIndex(dates) | pandas.DatetimeIndex |
"""Perform classifications using landsat, sentinel-1 or both."""
import os
import rasterio
import rasterio.features
import numpy as np
import pandas as pd
import geopandas as gpd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.decomposition import PCA
from sklearn.metrics import (
f1_score, precision_score, recall_score, accuracy_score
)
from tqdm import tqdm
from imblearn.over_sampling import RandomOverSampler
from scipy.ndimage import uniform_filter
from metadata import CASE_STUDIES, DATA_DIR
def list_available_features(data_dir):
"""List all available images in a given directory and its
subdirectories.
Parameters
----------
data_dir : str
Path to the directory where images are stored.
Returns
-------
features : list of tuple
Available features as a list of tuples (label, path).
"""
features = []
for directory, _, files in os.walk(data_dir):
files = [f for f in files if f.endswith('.tif')]
for f in files:
path = os.path.join(directory, f)
label = f.replace('.tif', '')
features.append((label, path))
return features
def ndarray_from_images(images, mask):
"""Construct X ndarray from an iterable of images and according to
a provided binary raster mask.
Parameters
----------
images : iterable of numpy 2d arrays
Images as an iterable of numpy 2d arrays.
mask : binary numpy 2d array
Raster mask ; true pixels will be excluded.
Returns
-------
X : numpy array
Array of shape (n_samples, n_images).
"""
# Initialize the X array of shape (n_samples, n_images)
out_shape = (images[0][~mask].ravel().shape[0], len(images))
X = np.empty(shape=out_shape, dtype=np.float64)
# Populate with image data
for i, img in enumerate(images):
X[:, i] = img[~mask].ravel()
return X
def get_train_test(data_dir, case_study, test_size=0.3, seed=111):
"""Construct train and test rasters from reference land cover shapefiles.
Train and test samples are randomly splitted at the polygon-level.
Parameters
----------
data_dir : str
Path to the directory where reference shapefiles are stored.
case_study : Metadata
Metadata object corresponding to a given case study. Used
to retrieve rasterization parameters.
test_size : float
Size of the test sample (between 0 and 1).
seed : int
Random seed for reproducibility.
Returns
-------
train : 2d array
Training samples as a 2d numpy array.
test : 2d array
Testing samples as a 2d numpy array.
"""
# Get built-up train and test samples
bu = gpd.read_file(os.path.join(reference_dir, 'builtup.shp'))
if bu.crs != case_study.crs:
bu = bu.to_crs(case_study.crs)
bu_train, bu_test = train_test_split(
bu, test_size=test_size, random_state=seed)
train = rasterio.features.rasterize(
shapes=((geom, 1) for geom in bu_train.geometry),
out_shape=(case_study.height, case_study.width),
transform=case_study.affine, dtype=np.uint8)
test = rasterio.features.rasterize(
shapes=((geom, 1) for geom in bu_test.geometry),
out_shape=(case_study.height, case_study.width),
transform=case_study.affine, dtype=np.uint8)
# Get non-built-up train and test samples
# Each land cover is splitted individually at the polygon-level
# Legend: so=2, lv=3, hv=4
NB_LAND_COVERS = ['baresoil', 'lowveg', 'highveg']
for i, land_cover in enumerate(NB_LAND_COVERS):
lc = gpd.read_file(os.path.join(reference_dir, land_cover + '.shp'))
if lc.crs != case_study.crs:
lc = lc.to_crs(case_study.crs)
lc_train, lc_test = train_test_split(
lc, test_size=test_size, random_state=seed)
lc_train_raster = rasterio.features.rasterize(
shapes=((geom, 1) for geom in lc_train.geometry),
out_shape=(case_study.height, case_study.width),
transform=case_study.affine, dtype=np.uint8)
lc_test_raster = rasterio.features.rasterize(
shapes=((geom, 1) for geom in lc_test.geometry),
out_shape=(case_study.height, case_study.width),
transform=case_study.affine, dtype=np.uint8)
train[lc_train_raster == 1] = i + 2
test[lc_test_raster == 1] = i + 2
return train, test
def dim_reduction(X, n_components=6):
"""Perform dimensionality reduction on input data
using PCA.
Parameters
----------
X : array
Input data as an array of shape (n_samples, n_features).
n_components : int
PCA components.
Returns
-------
X_reduced : array
Output reduced data array of shape (n_samples, n_components).
"""
pca = PCA(n_components=6)
pca.fit(X)
return pca.transform(X)
def random_forest(X, train, mask, seed=111, **kwargs):
"""Classify image data based on a given training dataset with
the Random Forest classifier.
Parameters
----------
X : array
Image data to classify. Array of shape
(n_samples, n_features).
train : 2d array
Training samples as a 2d numpy array.
mask : 2d array
Pixels to exclude from the analysis.
seed : int
Random seed for reproducibility.
**kwargs : args
Parameters to pass to the RF classifier.
Returns
-------
probabilities : 2d array
RF probabilistic output as a 2d image.
importances : array
RF feature importances as an array of shape
(n_features).
"""
# Construct training dataset from X based on `train`
X_train = X[train[~mask].ravel() > 0, :]
y_train = train[~mask].ravel()[train[~mask].ravel() > 0]
y_train[y_train > 1] = 2
# Oversampling to handle class imbalance
ros = RandomOverSampler(random_state=seed)
X_train, y_train = ros.fit_sample(X_train, y_train)
# Classification with RF
rf = RandomForestClassifier(random_state=seed, **kwargs)
rf.fit(X_train, y_train)
X_pred = rf.predict_proba(X)[:, 0]
# Reconstruct probabilities raster with original shape
probabilities = np.zeros(shape=mask.shape, dtype=np.float64)
probabilities[~mask] = X_pred
return probabilities, rf.feature_importances_
def assess(probabilities, test, mask, prob_threshold=0.75):
"""Compute assessment metrics based on the provided test samples.
Metrics computed: F1-score, precision, recall, and accuracy
in each land cover.
Parameters
----------
probabilities : 2d array
RF probabilistic output.
test : 2d array
Test samples.
mask : 2d array
Pixels excluded from the analysis.
prob_threshold : float
RF probabilities binary threshold.
Returns
-------
metrics : pandas Serie
Assessment metrics.
"""
metrics = | pd.Series() | pandas.Series |
# plots.py
import matplotlib
matplotlib.rcParams = matplotlib.rc_params_from_file('../../matplotlibrc')
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
def randomWalk():
"""Creates plot of symmetric one-D random lattice walk"""
N = 1000 #length of random walk
s = np.zeros(N)
s[1:] = np.random.binomial(1, .5, size=(N-1,))*2-1 #coin flips
s = pd.Series(s)
s = s.cumsum() #random walk
s.plot()
plt.ylim([-50,50])
plt.savefig("randomWalk.pdf")
#randomWalk()
def biasedRandomWalk():
"""Create plots of biased random walk of different lengths."""
N = 100 #length of random walk
s1 = np.zeros(N)
s1[1:] = np.random.binomial(1, .51, size=(N-1,))*2-1 #coin flips
s1 = pd.Series(s1)
s1 = s1.cumsum() #random walk
plt.subplot(211)
s1.plot()
N = 10000 #length of random walk
s1 = np.zeros(N)
s1[1:] = np.random.binomial(1, .51, size=(N-1,))*2-1 #coin flips
s1 = pd.Series(s1)
s1 = s1.cumsum() #random walk
plt.subplot(212)
s1.plot()
plt.savefig("biasedRandomWalk.pdf")
#biasedRandomWalk()
def dfPlot():
"""Plot columns of DataFrame against each other."""
xvals = pd.Series(np.sqrt(np.arange(1000)))
yvals = pd.Series(np.random.randn(1000).cumsum())
df = | pd.DataFrame({'xvals':xvals,'yvals':yvals}) | pandas.DataFrame |
#!/usr/bin/env python
"""
BSD 2-Clause License
Copyright (c) 2021 (<EMAIL>)
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""
from __future__ import division
import argparse
import itertools
import json
import operator
import os
import re
import sys
import pickle
import math
from distutils.util import strtobool
import numpy as np
import pysam
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
from matplotlib.backends.backend_pdf import PdfPages
from polyleven import levenshtein
from Bio import SeqIO
import seaborn as sns
import pandas as pd
from scipy import stats
###### Usage
#python plot_identity_error_alignment_normUnal.py -i basecaller1/norm_unaligned_assembly_polished basecaller2/norm_unaligned_assembly_polished basecaller3/norm_unaligned_assembly_polished -l basecaller1 basecaller2 basecaller3 -o outfolder -p appendix_outputname
#
def safe_div(x, y):
if y == 0:
return None
return x / y
plt.rcParams["patch.force_edgecolor"] = False
def plot_error_identity(df, pdf=None):
sns.set(font_scale=1)
fig = plt.figure(figsize=(13,2))
fig.subplots_adjust(left=0, right=1, bottom=0, top=2, hspace=0.2, wspace=0.2)
ax = fig.add_subplot(1, 2, 1)
sns.barplot(x="basecaller", hue="genome", y="error", data=df, linewidth=0, ax=ax)
plt.xlabel("Basecallers")
plt.ylabel("Error")
plt.title("Error rate of aligned reads to reference genome")
ax.get_legend().remove()
ax = fig.add_subplot(1, 2, 2)
sns.barplot(x="basecaller", hue="genome", y="identity", data=df, linewidth=0, ax=ax)
plt.xlabel("Basecallers")
plt.ylabel("Identity")
plt.title("Identity rate of aligned reads to reference genome")
ax.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0., fontsize=10)
if pdf is not None:
pdf.savefig(fig, bbox_inches="tight")
plt.close("all")
def plot_match_mismatch_indels(df, pdf=None, stacked=True):
sns.set(font_scale=1)
fig = plt.figure(figsize=(10,5))
fig.subplots_adjust(left=0, right=1, bottom=0, top=2, hspace=0.2, wspace=0.2)
if stacked:
ax = fig.add_subplot(2, 2, 1)
ax2 = ax.twiny()
#sns.barplot(x="basecaller", hue="genome", y="match", data=df, linewidth=0, ax=ax)
#plt.xlabel("Basecallers")
#plt.ylabel("%Matches")
#plt.title("Matches")
df0 = df[['basecaller', 'genome', 'mismatch', 'deletion', 'insertion', 'unaligned']]
cols = df0.columns
u, idx = np.unique(df.basecaller.tolist(), return_index=True)
order = u[np.argsort(idx)] #[u[index] for index in sorted(idx)]
df0['basecaller'] = pd.Categorical(df0.basecaller, categories=order, ordered=True) # ['f', 'a', 'w', 'h'] # prevent sorting
df0.set_index(['basecaller', 'genome'], inplace=True)
colors = plt.cm.Paired.colors
df1 = df0.unstack(level=-1) # unstack the 'Context' column
(df1['mismatch']+df1['deletion']+df1['insertion']+df1['unaligned']).plot(kind='bar', color=[colors[1], colors[0]], rot=0, ax=ax, linewidth=0)
print(df1['mismatch']+df1['deletion']+df1['insertion']+df1['unaligned'])
(df1['deletion']+df1['insertion']+df1['unaligned']).plot(kind='bar', color=[colors[3], colors[2]], rot=0, ax=ax, linewidth=0)
(df1['insertion']+df1['unaligned']).plot(kind='bar', color=[colors[5], colors[4]], rot=0, ax=ax, linewidth=0)
df1['unaligned'].plot(kind='bar', color=[colors[7], colors[6]], rot=0, ax=ax, linewidth=0)
#legend_labels = [f'{val} ({context})' for val, context in df1.columns]
ticks = []
for r in range(df.shape[0]//2):
ticks.append(r - 0.25)
ticks.append(r + 0.05)
ax.set_xticks(ticks)
ax.set_xticklabels(['lambda', 'ecoli'] * (df.shape[0]//2), rotation=45, fontsize=8)
ax.grid(axis="x")
legend_labels = []
labels = ["mismatch", "", "deletion", "", "insertion", "", "unaligned", ""]
#for val in labels:
# if val in legend_labels:
# legend_labels.append("")
# else:
# legend_labels.append(val)
#legend_labels = [f'{val} ({context})' for val, context in df1.columns]3
ax.legend(labels, bbox_to_anchor=(-0.08, 1.2), loc=2, borderaxespad=0., ncol=4, fontsize=10) #(1.05, 1)
ax.set_ylabel("mean error in %")
ax.set_xlabel("species")
ax.set_yscale('log') #,base=20)
#ax.text(0.02, -0.2, ' '.join(order), transform=ax.transAxes, fontsize=11) #horizontalalignment='center', verticalalignment='center'
ax2.set_xlim(ax.get_xlim())
ax2.set_xticks([0.02, 1, 2, 3])
ax2.set_xticklabels(order, fontsize=10)
ax.xaxis.set_ticks_position('none')
#ax2.xaxis.set_ticks_position('none')
ax2.grid(axis="x")
#ax.legend(legend_labels, bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
plt.ylabel("Proportion of errors")
else:
ax = fig.add_subplot(2, 2, 1)
sns.barplot(x="basecaller", hue="genome", y="mismatch", data=df, linewidth=0, ax=ax)
plt.xlabel("Basecallers")
plt.ylabel("Mismatches")
plt.title("Mismatches")
ax.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
plt.xticks(fontsize=8)
#ax._legend.remove()
ax = fig.add_subplot(2, 2, 3)
sns.barplot(x="basecaller", hue="genome", y="deletion", data=df, linewidth=0, ax=ax)
plt.xlabel("Basecallers")
plt.ylabel("Deletion")
plt.title("Deletion")
ax.get_legend().remove()
plt.xticks(fontsize=8)
#ax._legend.remove()
ax = fig.add_subplot(2, 2, 4)
sns.barplot(x="basecaller", hue="genome", y="insertion", data=df, linewidth=0, ax=ax)
plt.xlabel("Basecallers")
plt.ylabel("Insertion")
plt.title("Insertion")
ax.get_legend().remove()
plt.xticks(fontsize=8)
#ax._legend.remove()
if pdf is not None:
pdf.savefig(fig, bbox_inches="tight")
plt.close("all")
def plot_boxplot(data, labels, pdf=None, title="relative read length", ylabel="read length / reference length in %", reference=None):
sns.set(font_scale=1)
fig = plt.figure(figsize=(6,2))
fig.subplots_adjust(left=0, right=1, bottom=0, top=2, hspace=0.2, wspace=0.2)
ax = fig.add_subplot(1, 1, 1)
box = plt.boxplot(data, patch_artist=True)
ticks = np.arange(1, len(labels)+1)
plt.xticks(ticks, labels, rotation=45, ha="right")
plt.ylabel(ylabel)
plt.xlabel("Basecaller")
plt.title(title)
#plt.yscale('log') #,base=20)
if reference is not None:
plt.axhline(reference, c='r')
colors = len(labels[-3:]) * ['#EAEAF2'] + 3* ["#88888C"]
#colors2 = len(labels[-3:]) * ['#DD8655'] + 3* ["#181819"]
for patch, color in zip(box['boxes'], colors):
patch.set_facecolor(color)
#med.set_facecolor(color2)
if pdf is not None:
pdf.savefig(fig, bbox_inches="tight")
plt.close("all")
def make_argparser():
parser = argparse.ArgumentParser(description='Prints summary about alignment of basecalled reads.')
parser.add_argument('-i', '--fastq', nargs="*",
help='FASTA/Q files with basecalled reads.')
parser.add_argument('-l', '--labels', nargs="*",
help='list of labels. same order as list with fastq/a files')
parser.add_argument('-o', '--out',
help='out path.')
parser.add_argument('-p', '--prefix', default="basecalled",
help='out path.')
parser.add_argument('--stacked', type=lambda x:bool(strtobool(x)), nargs='?', const=True, default=True,
help='stack error rates in plot.')
return parser
def median_abs_dev(x):
return(stats.median_absolute_deviation(x))
def report_errors(argv):
parser = make_argparser()
args = parser.parse_args(argv[1:])
fastq = args.fastq
basecallers = args.labels
out = args.out
prefix = args.prefix
stacked = args.stacked
with PdfPages(out + "/{}_error_alignment_rates.pdf".format(prefix)) as pdf:
lambd = []
ecoli = []
df = pd.DataFrame(columns=['basecaller', 'genome', 'match', 'mismatch', 'deletion', 'insertion', 'unaligned', 'identity', 'error', 'mqual', 'relative read length', 'aligned \% of read'])
df_std = pd.DataFrame(columns=['basecaller', 'genome', 'match', 'mismatch', 'deletion', 'insertion', 'unaligned','identity', 'error', 'mqual', 'relative read length', 'aligned \% of read'])
df_all = pd.DataFrame(columns=['basecaller', 'genome', 'match', 'mismatch', 'deletion', 'insertion', 'unaligned', 'identity', 'error', 'mqual', 'relative read length', 'aligned \% of read'])
df_all_std = pd.DataFrame(columns=['basecaller', 'genome', 'match', 'mismatch', 'deletion', 'insertion', 'unaligned','identity', 'error', 'mqual', 'relative read length', 'aligned \% of read'])
df_median = | pd.DataFrame(columns=['basecaller', 'genome', 'match', 'mismatch', 'deletion', 'insertion', 'unaligned', 'identity', 'error', 'mqual', 'relative read length', 'aligned \% of read']) | pandas.DataFrame |
import logging
from collections import defaultdict
import numpy as np
import pandas as pd
from sklearn.cluster import MiniBatchKMeans
from sklearn.cluster._kmeans import _mini_batch_convergence
from sklearn.utils.validation import check_random_state
from progressivis import ProgressiveError, SlotDescriptor
from progressivis.core.utils import indices_len
from ..table.module import TableModule
from ..table import Table, TableSelectedView
from ..table.dshape import dshape_from_dtype, dshape_from_columns
from ..io import DynVar
from ..utils.psdict import PsDict
from ..core.decorators import process_slot, run_if_any
from ..table.filtermod import FilterMod
from ..stats import Var
logger = logging.getLogger(__name__)
class MBKMeans(TableModule):
"""
Mini-batch k-means using the sklearn implementation.
"""
parameters = [('samples', np.dtype(int), 50)]
inputs = [
SlotDescriptor('table', type=Table, required=True),
SlotDescriptor('var', type=Table, required=True),
SlotDescriptor('moved_center', type=PsDict, required=False)
]
outputs = [
SlotDescriptor('labels', type=Table, required=False),
SlotDescriptor('conv', type=PsDict, required=False)
]
def __init__(self, n_clusters, columns=None, batch_size=100, tol=0.01,
is_input=True, is_greedy=True, random_state=None, **kwds):
super().__init__(**kwds)
self.mbk = MiniBatchKMeans(n_clusters=n_clusters,
batch_size=batch_size,
verbose=True,
tol=tol,
random_state=random_state)
self.columns = columns
self.n_clusters = n_clusters
self.default_step_size = 100
self._labels = None
self._remaining_inits = 10
self._initialization_steps = 0
self._is_input = is_input
self._tol = tol
self._conv_out = PsDict({'convergence': 'unknown'})
self.params.samples = n_clusters
self._is_greedy = is_greedy
self._arrays = None
self.convergence_context = {}
def predict_step_size(self, duration):
p = super().predict_step_size(duration)
return max(p, self.n_clusters)
def reset(self, init='k-means++'):
self.mbk = MiniBatchKMeans(n_clusters=self.mbk.n_clusters,
batch_size=self.mbk.batch_size,
init=init,
# tol=self._rel_tol,
random_state=self.mbk.random_state)
dfslot = self.get_input_slot('table')
dfslot.reset()
self.set_state(self.state_ready)
self.convergence_context = {}
# do not resize result to zero
# it contains 1 row per centroid
if self._labels is not None:
self._labels.truncate()
def starting(self):
super().starting()
opt_slot = self.get_output_slot('labels')
if opt_slot:
logger.debug('Maintaining labels')
self.maintain_labels(True)
else:
logger.debug('Not maintaining labels')
self.maintain_labels(False)
def maintain_labels(self, yes=True):
if yes and self._labels is None:
self._labels = Table(self.generate_table_name('labels'),
dshape="{labels: int64}",
create=True)
elif not yes:
self._labels = None
def labels(self):
return self._labels
def get_data(self, name):
if name == 'labels':
return self.labels()
if name == 'conv':
return self._conv_out
return super().get_data(name)
def is_greedy(self):
return self._is_greedy
def _process_labels(self, locs):
labels = self.mbk.labels_
u_locs = locs & self._labels.index # ids to update
if not u_locs: # shortcut
self._labels.append({'labels': labels},
indices=locs)
return
a_locs = locs - u_locs # ids to append
if not a_locs: # 2nd shortcut
self._labels.loc[locs, 'labels'] = labels
return
df = | pd.DataFrame({'labels': labels}, index=locs) | pandas.DataFrame |
import pathlib
import pandas as pd
import pytest
from pytest import approx
import process_improve.batch.features as features
# General
@pytest.fixture(scope="module")
def batch_data():
"""Returns a small example of a batch data set."""
folder = (
pathlib.Path(__file__).parents[2] / "process_improve" / "datasets" / "batch"
)
return pd.read_csv(
folder / "batch-fake-data.csv",
index_col=1,
header=0,
)
# return
def test_verify_file(batch_data):
df = batch_data
assert df.shape[0] == 501
assert df.shape[1] == 5
def test_corner_cases(batch_data):
"""
Certain corner cases: to ensure coverage in
"""
df = batch_data
data = df.set_index(pd.to_datetime(df["DateTime"])).drop("DateTime", axis=1)
step1 = features.f_mean(data).reset_index()
# Tests removal of internal columns.
_, tags, *_ = features._prepare_data(step1)
assert "__phase_grouper__" not in tags
assert "__batch_grouper__" not in tags
# Test calling a single tag name
assert features.f_mean(data, tags="Temp1").loc[:, "Temp1_mean"].values[0] == approx(
-19.482056, rel=1e-7
)
def test_age_col_specification(batch_data):
"""
Some features, like slopes, need to know a value from the x-axis. Often this is a column
representing the time since start of the batch: age_col
"""
df = batch_data
df = df.drop("DateTime", axis=1)
# Check that the index is currently the time-tag
assert df.index.name == "UCI_minutes"
# This test is for the case when the time_tag is NOT the index. So reset that:
df = df.reset_index()
slopes = features.f_slope(
df, x_axis_tag="UCI_minutes", tags=["Temp1", "Temp2"], age_col="UCI_minutes"
)
assert slopes.shape == (1, 2)
def test_data_preprocessing(batch_data):
"""Simple tests regarding the mean, median, etc. Location-based features."""
df = batch_data
df = df.set_index( | pd.to_datetime(df["DateTime"]) | pandas.to_datetime |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import pandas
import decimal
class Response(object):
def __init__(self, data=None):
self.__data__ = data
def data(self):
return | pandas.DataFrame(self.__data__) | pandas.DataFrame |
from pymongo import MongoClient
import pandas as pd
pd.set_option("display.max_rows",None,"display.max_columns",None)
pd.options.mode.chained_assignment = None
import datetime
from datetime import datetime
server = MongoClient('mongodb://localhost:27017')
db=server['salesfokuz_lead']
leadsactivity = db['lead_log']
dadb = server['da']
meeting_time_users= dadb['meetingtime_user_id']
meeting_time_organizations= dadb['meetingtime_organization_id']
livepipeline = [
{
"$addFields": {
"punch_status": {
"$toString": "$data.punch_status"
}}
},
{
"$addFields": {
"punch_in": {
"$toString": "$data.punch_in_datetime"
}}
},
{
"$addFields": {
"punch_out": {
"$toString": "$data.punch_out_datetime"
}}
},
{
"$addFields": {
"organization_id": {
"$toString": "$data.organization_id"
}
}
},
{
'$project': {
'_id': 0,
'user_id': 1,
"module": 1,
"action": 1,
"lead_id":1,
"punch_in":1,
"organization_id":1,
"punch_out": 1,
"punch_status": 1,
}
}
]
################## END #######################
################## aggregating data from mongodb using the pipeline #############
leadlogdata = list(leadsactivity.aggregate(livepipeline))
# print(leadlogdata)
################## END #######################
leaddf = pd.DataFrame(leadlogdata)
# print(leaddf)
leaddf.fillna(0, inplace = True)
leaddf=leaddf.replace('', 0)
leaddf=leaddf.drop(leaddf[leaddf.punch_in == 0].index)
leaddf=leaddf.drop(leaddf[leaddf.punch_out == 0].index)
leaddf=leaddf.drop(leaddf[leaddf.action == 'Cancelled the'].index)
leaddf=leaddf[leaddf.module == 'meeting']
# print(leaddf)
################################################
leaddf['punch_in']=pd.to_datetime(leaddf['punch_in'])
leaddf['punch_out']= | pd.to_datetime(leaddf['punch_out']) | pandas.to_datetime |
# Copyright 2016 Google Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
# in compliance with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software distributed under the License
# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
# or implied. See the License for the specific language governing permissions and limitations under
# the License.
import numpy as np
import itertools
import json
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.metrics import confusion_matrix
import google.datalab.bigquery as bq
from . import _util
class ConfusionMatrix(object):
"""Represents a confusion matrix."""
def __init__(self, cm, labels):
"""
Args:
cm: a 2-dimensional matrix with row index being target, column index being predicted,
and values being count.
labels: the labels whose order matches the row/column indexes.
"""
self._cm = cm
self._labels = labels
@staticmethod
def from_csv(input_csv, headers=None, schema_file=None):
"""Create a ConfusionMatrix from a csv file.
Args:
input_csv: Path to a Csv file (with no header). Can be local or GCS path.
headers: Csv headers. If present, it must include 'target' and 'predicted'.
schema_file: Path to a JSON file containing BigQuery schema. Used if "headers" is None.
If present, it must include 'target' and 'predicted' columns.
Returns:
A ConfusionMatrix that can be plotted.
Raises:
ValueError if both headers and schema_file are None, or it does not include 'target'
or 'predicted' columns.
"""
if headers is not None:
names = headers
elif schema_file is not None:
with _util.open_local_or_gcs(schema_file, mode='r') as f:
schema = json.load(f)
names = [x['name'] for x in schema]
else:
raise ValueError('Either headers or schema_file is needed')
all_files = _util.glob_files(input_csv)
all_df = []
for file_name in all_files:
with _util.open_local_or_gcs(file_name, mode='r') as f:
all_df.append(pd.read_csv(f, names=names))
df = | pd.concat(all_df, ignore_index=True) | pandas.concat |
import numpy as np
import pandas as pd
from typing import Mapping, List, Tuple
from collections import defaultdict, OrderedDict
import matplotlib.pyplot as plt
import matplotlib as mpl
from sklearn.linear_model import LinearRegression, Lasso
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import RandomForestRegressor
from sklearn.datasets import load_boston, load_iris, load_wine, load_digits, \
load_breast_cancer, load_diabetes, fetch_mldata
from matplotlib.collections import LineCollection
import time
from pandas.api.types import is_string_dtype, is_object_dtype, is_categorical_dtype, \
is_bool_dtype
from sklearn.ensemble.partial_dependence import partial_dependence, \
plot_partial_dependence
from sklearn import svm
from sklearn.neighbors import KNeighborsRegressor
from pdpbox import pdp
from rfpimp import *
from scipy.integrate import cumtrapz
from stratx.partdep import *
from stratx.ice import *
import inspect
import statsmodels.api as sm
from sklearn.datasets import load_boston
from stratx.partdep import *
def df_string_to_cat(df: pd.DataFrame) -> dict:
catencoders = {}
for colname in df.columns:
if is_string_dtype(df[colname]) or is_object_dtype(df[colname]):
df[colname] = df[colname].astype('category').cat.as_ordered()
catencoders[colname] = df[colname].cat.categories
return catencoders
def toy_weather_data():
def temp(x): return np.sin((x + 365 / 2) * (2 * np.pi) / 365)
def noise(state): return np.random.normal(-5, 5, sum(df['state'] == state))
df = pd.DataFrame()
df['dayofyear'] = range(1, 365 + 1)
df['state'] = np.random.choice(['CA', 'CO', 'AZ', 'WA'], len(df))
df['temperature'] = temp(df['dayofyear'])
df.loc[df['state'] == 'CA', 'temperature'] = 70 + df.loc[
df['state'] == 'CA', 'temperature'] * noise('CA')
df.loc[df['state'] == 'CO', 'temperature'] = 40 + df.loc[
df['state'] == 'CO', 'temperature'] * noise('CO')
df.loc[df['state'] == 'AZ', 'temperature'] = 90 + df.loc[
df['state'] == 'AZ', 'temperature'] * noise('AZ')
df.loc[df['state'] == 'WA', 'temperature'] = 60 + df.loc[
df['state'] == 'WA', 'temperature'] * noise('WA')
return df
def weather():
df_yr1 = toy_weather_data()
df_yr1['year'] = 1980
df_yr2 = toy_weather_data()
df_yr2['year'] = 1981
df_yr3 = toy_weather_data()
df_yr3['year'] = 1982
df_raw = pd.concat([df_yr1, df_yr2, df_yr3], axis=0)
df = df_raw.copy()
catencoders = df_string_to_cat(df_raw.copy())
# states = catencoders['state']
# print(states)
#
# df_cat_to_catcode(df)
names = {'CO': 5, 'CA': 10, 'AZ': 15, 'WA': 20}
df['state'] = df['state'].map(names)
catnames = OrderedDict()
for k,v in names.items():
catnames[v] = k
X = df.drop('temperature', axis=1)
y = df['temperature']
# leaf_xranges, leaf_slopes, slope_counts_at_x, dx, slope_at_x, pdpx, pdpy, ignored_ = \
# partial_dependence(X=X, y=y, colname='dayofyear',
# verbose=True)
# print(pdpx)
# print(pdpy)
plot_catstratpd(X, y, 'state', 'temperature', catnames=catnames,
# min_samples_leaf=30,
n_trials=10,
min_y_shifted_to_zero=True,
show_x_counts=False,
bootstrap=True,
yrange=(-2, 60),
figsize=(2.1,2.5)
)
plt.show()
def bigX_data(n):
x1 = np.random.uniform(-1, 1, size=n)
x2 = np.random.uniform(-1, 1, size=n)
x3 = np.random.uniform(-1, 1, size=n)
y = 0.2 * x1 - 5 * x2 + 10 * x2 * np.where(x3 >= 0, 1, 0) + np.random.normal(0, 1,
size=n)
df = pd.DataFrame()
df['x1'] = x1
df['x2'] = x2
df['x3'] = x3
df['y'] = y
return df
def bigX():
print(f"----------- {inspect.stack()[0][3]} -----------")
n = 1000
df = bigX_data(n=n)
X = df.drop('y', axis=1)
y = df['y']
# plot_stratpd_gridsearch(X, y, 'x2', 'y',
# min_samples_leaf_values=[2,5,10,20,30],
# # nbins_values=[1,3,5,6,10],
# yrange=(-4,4))
#
# plt.tight_layout()
# plt.show()
# return
# Partial deriv is just 0.2 so this is correct. flat deriv curve, net effect line at slope .2
# ICE is way too shallow and not line at n=1000 even
fig, axes = plt.subplots(2, 2, figsize=(4, 4), sharey=True)
# Partial deriv wrt x2 is -5 plus 10 about half the time so about 0
# Should not expect a criss-cross like ICE since deriv of 1_x3>=0 is 0 everywhere
# wrt to any x, even x3. x2 *is* affecting y BUT the net effect at any spot
# is what we care about and that's 0. Just because marginal x2 vs y shows non-
# random plot doesn't mean that x2's net effect is nonzero. We are trying to
# strip away x1/x3's effect upon y. When we do, x2 has no effect on y.
# Ask what is net effect at every x2? 0.
plot_stratpd(X, y, 'x2', 'y', ax=axes[0, 0], yrange=(-4, 4),
show_slope_lines=True,
n_trials=1,
min_samples_leaf=20,
pdp_marker_size=2)
# Partial deriv wrt x3 of 1_x3>=0 is 0 everywhere so result must be 0
plot_stratpd(X, y, 'x3', 'y', ax=axes[1, 0], yrange=(-4, 4),
show_slope_lines=True,
n_trials=1,
min_samples_leaf=20,
pdp_marker_size=2)
rf = RandomForestRegressor(n_estimators=100, min_samples_leaf=1, oob_score=True)
rf.fit(X, y)
print(f"RF OOB {rf.oob_score_}")
ice = predict_ice(rf, X, 'x2', 'y', numx=100)
plot_ice(ice, 'x2', 'y', ax=axes[0, 1], yrange=(-4, 4))
ice = predict_ice(rf, X, 'x3', 'y', numx=100)
plot_ice(ice, 'x3', 'y', ax=axes[1, 1], yrange=(-4, 4))
axes[0, 1].get_yaxis().set_visible(False)
axes[1, 1].get_yaxis().set_visible(False)
axes[0, 0].set_title("StratPD", fontsize=10)
axes[0, 1].set_title("PD/ICE", fontsize=10)
plt.show()
def boston():
boston = load_boston()
df = pd.DataFrame(boston.data, columns=boston.feature_names)
df['MEDV'] = boston.target
X = df.drop('MEDV', axis=1)
y = df['MEDV']
# WORKS ONLY WITH DATAFRAMES AT MOMENT
plt.figure(figsize=(3.5,3.5))
plot_stratpd(X, y, 'LSTAT', 'MEDV', yrange=(-20, 5), n_trials=10)
plt.tight_layout()
plt.savefig("../../images/boston_LSTAT.svg")
plt.show()
def diabetes():
diabetes = load_diabetes()
df = | pd.DataFrame(diabetes.data, columns=diabetes.feature_names) | pandas.DataFrame |
import sys, os, time, datetime, warnings, configparser
import pandas as pd
import numpy as np
import talib
import concurrent.futures
import matplotlib.pyplot as plt
from tqdm import tqdm
cur_path = os.path.dirname(os.path.abspath(__file__))
for _ in range(2):
root_path = cur_path[0:cur_path.rfind('/', 0, len(cur_path))]
cur_path = root_path
sys.path.append(root_path + "/" + 'Source/FetchData/')
sys.path.append(root_path + "/" + 'Source/DataBase/')
from Fetch_Data_Stock_US_StockList import getStocksList_US
from Fetch_Data_Stock_US_Daily import updateStockData_US_Daily
from Fetch_Data_Stock_US_Weekly import updateStockData_US_Weekly
from Fetch_Data_Stock_US_Monthly import updateStockData_US_Monthly
from DB_API import queryStock
def get_single_stock_data_daily(root_path, symbol):
'''
All data is from quandl wiki dataset
Feature set: [Open High Low Close Volume Ex-Dividend Split Ratio Adj. Open Adj. High Adj. Low
Adj. Close Adj. Volume]
'''
df, lastUpdateTime = queryStock(root_path, "DB_STOCK", "SHEET_US", "_DAILY", symbol, "daily_update")
df.index = pd.to_datetime(df.index)
if df.empty:
print("daily empty df", symbol)
return df
if 'adj_close' in df:
df = df.drop('close', 1)
df = df.rename(columns = {'adj_close':'close'})
return df
def get_single_stock_data_weekly(root_path, symbol):
'''
All data is from quandl wiki dataset
Feature set: [Open High Low Close Volume Ex-Dividend Split Ratio Adj. Open Adj. High Adj. Low
Adj. Close Adj. Volume]
'''
df, lastUpdateTime = queryStock(root_path, "DB_STOCK", "SHEET_US", "_WEEKLY", symbol, "weekly_update")
df.index = | pd.to_datetime(df.index) | pandas.to_datetime |
from pathlib import Path
import logging
import numpy as np
import pandas as pd
from pytest import approx, mark
from lenskit.algorithms.user_knn import UserUser
from lenskit.algorithms.item_knn import ItemItem
from lenskit.algorithms.basic import PopScore
from lenskit.algorithms.ranking import PlackettLuce
from lenskit.algorithms import Recommender
from lenskit.util.test import ml_test, demo_recs
from lenskit.metrics.topn import _dcg, precision, recall
from lenskit import topn, batch, crossfold as xf
_log = logging.getLogger(__name__)
def test_split_keys():
rla = topn.RecListAnalysis()
recs, truth = topn._df_keys(['algorithm', 'user', 'item', 'rank', 'score'],
['user', 'item', 'rating'])
assert truth == ['user']
assert recs == ['algorithm', 'user']
def test_split_keys_gcol():
recs, truth = topn._df_keys(['algorithm', 'user', 'item', 'rank', 'score', 'fishtank'],
['user', 'item', 'rating'],
['algorithm', 'fishtank', 'user'])
assert truth == ['user']
assert recs == ['algorithm', 'fishtank', 'user']
def test_run_one():
rla = topn.RecListAnalysis()
rla.add_metric(topn.precision)
rla.add_metric(topn.recall)
recs = | pd.DataFrame({'user': 1, 'item': [2]}) | pandas.DataFrame |
import sys
import glob
import pandas as pd
from flask import Flask
from flask import jsonify
# list of dataframes
dfs = []
# Read the CSV files
for f in glob.glob("Firewall*.csv"):
print("Reading file: [%s]" % f)
local_df = pd.read_csv(f, low_memory=False)
dfs.append(local_df)
full_df = | pd.concat(dfs) | pandas.concat |
import gc as _gc
import pandas as _pd
import numpy as _np
from . import databases as _databases
from . import profiles as _profiles
class Columns(_databases.Columns):
"""
Container for the columns names defined in this module.
"""
SPLIT_SUF = '_SPLIT'
REF = 'REF'
QRY = 'QRY'
REF_SPLIT = '{}{}'.format(REF, SPLIT_SUF)
QRY_SPLIT = '{}{}'.format(QRY, SPLIT_SUF)
PROF_Q = _databases.Columns.PROF_Q
PROF_A = _databases.Columns.PROF_A
STR_SEP = '|'
def get_IDs_names(
species,
):
"""
Returns dict of KEGG Organism IDs as keys and biological names as values.
Parameters
-------
species: list of str
List of full biological names to convert into KEGG Organism IDs.
Returns
------
dict
"""
kegg_db = _databases.KEGG('Orthology')
kegg_db.parse_organism_info(
organism=None,
reference_species=species,
IDs=None,
X_ref=None,
KOs=None,
IDs_only=True,
)
return {k.lower(): v for k, v in kegg_db.ID_name.items()}
def profilize_organism(*args, **kwargs):
"""
Returns pandas.DataFrame with Phylogenetic Profile for each ORF name of an
organism.
Parameters
-------
organism: str
Full biological name of the organism.
reference_species: list of str
List of full biological names to build the Phylogenetic Profile.
IDs: str, path
Filename of the KEGG Organism IDs. Downloaded to a temporary file if
<None>.
X_ref: str, path
Filename of the ORF-KEGG Orthology Group cross-reference.
Downloaded to a temporary file if <None>.
KOs: str, path
Filename of the KEGG Orthology Group-Organism cross-reference.
Downloaded to a temporary file if <None>.
threads: int
Number of threads to utilize when downloading from KEGG. More means
faster but can make KEGG block the download temporarily. Default: <2>
Returns
------
pandas.DataFrame
"""
kegg_db = _databases.KEGG('Orthology')
kegg_db.parse_organism_info(*args, **kwargs)
return kegg_db.organism_info.drop(columns=_databases.Columns.KEGG_ID)
def read_sga(
filename,
version=2,
):
"""
Returns pandas.DataFrame with Genetic Interaction Network from
the Costanzo's SGA experiment either version 1 or 2.
Parameters
-------
filename: str, path
Filename of the SGA.
version: int
Version number of the Costanzo's SGA experiment. 1 or 2 available.
Returns
-------
pandas.DataFrame
"""
if version == 1:
sga = _databases.SGA1()
elif version == 2:
sga = _databases.SGA2()
else:
raise errors.ParserError("Only versions 1 and 2 of Costanzo's SGA experiment are supported.")
sga.parse(filename=filename)
return sga.sga
def read_profiles(
filename,
**kwargs
):
"""
Returns pandas.Series with prwlr.profiles.Profile objects from CSV file.
Together with prwlr.core.save_profiles provides a convenient way of
saving/reading-in prwlr.profiles.Profile objects to/from a flat text file.
Parameters
-------
filename: str, path
CSV file name.
Returns
------
pandas.Series
"""
ref_qry_df = | _pd.read_csv(filename, **kwargs) | pandas.read_csv |
import _io
import random
import numpy as np
import pandas as pd
import networkx as nx
from pandas.core.indexing import IndexingError
from recommenders.lod_reordering import LODPersonalizedReordering
import evaluation_utils as eval
class PathReordering(LODPersonalizedReordering):
def __init__(self, train_file: str, output_rec_file: str, prop_path: str, prop_cols: list, cols_used: list,
n_reorder: int,
policy: str, p_items: float, hybrid=False, n_sentences=3):
"""
Path Reordering class: this algorithm will reorder the output of other recommendation algorithm based on the
best path from an historic item and a recommended one. The best paths are extracted based on the value for each
object of the LOD with the semantic profile
:param train_file: train file in which the recommendations of where computed
:param output_rec_file: output file of the recommendation algorithm
:param prop_path: path to the properties on dbpedia or wikidata
:param prop_cols: columns of the property set
:param cols_used: columns used from the test and train set
:param policy: the policy to get the historic items to get the best paths. Possible values: 'all' for all items
'last' for the last interacted items, 'first' for the first interacted items and 'random' for
the random interacted items
:param p_items: percentage from 0 to 1 of items to consider in the policy. E.g. policy last and p_items = 0.1,
then the paths will consider only the last 0.1 * len(items inteacted). If p_items is bigger than 1
it will use the policy of the p_items of the user historic
:param hybrid: if the reorder of the recommendations should [True] or not consider the score from the recommender
:param n_sentences: number of paths to generate the sentence of explanation
"""
self.policy = policy
self.p_items = p_items
self.output_name = 'path[policy=' + str(policy) + "_items=" + str(p_items).replace('.', '') + "_reorder=" + str(
n_reorder) + "]"
if self.policy == 'random':
random.seed(42)
if hybrid:
self.output_name = self.output_name[:-1] + "_hybrid]"
super().__init__(train_file, output_rec_file, self.output_name, prop_path, prop_cols, cols_used, n_reorder,
hybrid, n_sentences)
def reorder(self):
"""
Function that reorders the recommendations made by the recommendation algorithm based on an adapted TF-IDF to
the LOD, where the words of a document are the values of properties of the items the user iteracted and all the
documents are all items properties
:return: file with recommendations for every user reordered
"""
reorder = pd.DataFrame({'user_id': pd.Series([], dtype=int),
'item_id': | pd.Series([], dtype=int) | pandas.Series |
import copy
import time
import numpy as np
import pandas as pd
import torch
from torch.utils.data import Dataset, IterableDataset
class Column(object):
"""A column. Data is write-once, immutable-after.
Typical usage:
col = Column('myCol').Fill(data).SetDistribution(domain_vals)
"data" and "domain_vals" are NOT copied.
"""
def __init__(self, name, distribution_size=None, pg_name=None):
self.name = name
# Data related fields.
self.data = None
self.all_distinct_values = None
self.distribution_size = distribution_size
# pg_name is the name of the corresponding column in Postgres. This is
# put here since, e.g., PG disallows whitespaces in names.
self.pg_name = pg_name if pg_name else name
self._val_to_bin_cache = {}
def Name(self):
"""Name of this column."""
return self.name
def DistributionSize(self):
"""This column will take on discrete values in [0, N).
Used to dictionary-encode values to this discretized range.
"""
return self.distribution_size
def BinToVal(self, bin_id):
assert bin_id >= 0 and bin_id < self.distribution_size, bin_id
return self.all_distinct_values[bin_id]
def ValToBin(self, val):
if val in self._val_to_bin_cache:
return self._val_to_bin_cache[val]
if isinstance(self.all_distinct_values, list):
return self.all_distinct_values.index(val)
inds = np.where(self.all_distinct_values == val)
if len(inds[0]) <= 0:
raise IndexError("Value not found")
res = inds[0][0]
self._val_to_bin_cache[val] = res
return res
def SetDistribution(self, distinct_values):
"""This is all the values this column will ever see."""
assert self.all_distinct_values is None
# pd.isnull returns true for both np.nan and np.datetime64('NaT').
is_nan = pd.isnull(distinct_values)
contains_nan = np.any(is_nan)
dv_no_nan = distinct_values[~is_nan]
# IMPORTANT: np.sort puts NaT values at beginning, and NaN values at
# end for our purposes we always add any null value to the beginning.
vs = np.sort(np.unique(dv_no_nan))
if contains_nan and np.issubdtype(distinct_values.dtype, np.datetime64):
vs = np.insert(vs, 0, np.datetime64('NaT'))
elif contains_nan:
vs = np.insert(vs, 0, np.nan)
if self.distribution_size is not None:
assert len(vs) == self.distribution_size
self.all_distinct_values = vs
self.distribution_size = len(vs)
return self
def Fill(self, data_instance, infer_dist=False):
assert self.data is None
self.data = data_instance
# If no distribution is currently specified, then infer distinct values
# from data.
if infer_dist:
self.SetDistribution(self.data)
return self
def __repr__(self):
return 'Column({}, distribution_size={})'.format(
self.name, self.distribution_size)
class Table(object):
"""A collection of Columns."""
def __init__(self, name, columns, pg_name=None, validate_cardinality=True):
"""Creates a Table.
Args:
name: Name of this table object.
columns: List of Column instances to populate this table.
pg_name: name of the corresponding table in Postgres.
"""
self.name = name
if validate_cardinality:
self.cardinality = self._validate_cardinality(columns)
else:
# Used as a wrapper, not a real table.
self.cardinality = None
self.columns = columns
# Bin to val funcs useful for sampling. Takes
# (col 1's bin id, ..., col N's bin id)
# and converts it to
# (col 1's val, ..., col N's val).
self.column_bin_to_val_funcs = [c.BinToVal for c in columns]
self.val_to_bin_funcs = [c.ValToBin for c in columns]
self.name_to_index = {c.Name(): i for i, c in enumerate(self.columns)}
if pg_name:
self.pg_name = pg_name
else:
self.pg_name = name
def __repr__(self):
return '{}({})'.format(self.name, self.columns)
def _validate_cardinality(self, columns):
"""Checks that all the columns have same the number of rows."""
cards = [len(c.data) for c in columns]
c = np.unique(cards)
assert len(c) == 1, c
return c[0]
def to_df(self):
return pd.DataFrame({c.name: c.data for c in self.columns})
def Name(self):
"""Name of this table."""
return self.name
def Columns(self):
"""Return the list of Columns under this table."""
return self.columns
def ColumnIndex(self, name):
"""Returns index of column with the specified name."""
assert name in self.name_to_index
return self.name_to_index[name]
class CsvTable(Table):
def __init__(self,
name,
filename_or_df,
cols,
type_casts,
pg_name=None,
pg_cols=None,
dropna=False,
is_str_col=False,
order_seed=None,
char_limit=200,
tie_cols=False,
**kwargs):
"""Accepts same arguments as pd.read_csv().
Args:
filename_or_df: pass in str to reload; otherwise accepts a loaded
pd.Dataframe.
"""
self.name = name
self.pg_name = pg_name
self.tie_cols = tie_cols
if isinstance(filename_or_df, str):
self.data = self._load(filename_or_df, cols, **kwargs)
else:
assert (isinstance(filename_or_df, pd.DataFrame))
self.data = filename_or_df
if is_str_col:
self.data = self._separate_characters(self.data, cols, char_limit)
if order_seed is not None:
ordering = self.data.columns.tolist()
rng = np.random.RandomState(order_seed)
rng.shuffle(ordering)
print(
"Rearranging columns from", self.data.columns.tolist(),
"to", ordering, "seed", order_seed)
self.data = self.data[ordering]
self.dropna = dropna
if dropna:
# NOTE: this might make the resulting dataframe much smaller.
self.data = self.data.dropna()
cols = self.data.columns
self.columns = self._build_columns(self.data, cols, type_casts, pg_cols)
super(CsvTable, self).__init__(name, self.columns, pg_name)
def _load(self, filename, cols, **kwargs):
print('Loading csv...', end=' ')
s = time.time()
# Use [cols] here anyway to reorder columns by 'cols'.
df = pd.read_csv(filename, usecols=cols, **kwargs)[cols]
print('done, took {:.1f}s'.format(time.time() - s))
return df
def _build_columns(self, data, cols, type_casts, pg_cols):
"""Example args:
cols = ['Model Year', 'Reg Valid Date', 'Reg Expiration Date']
type_casts = {'Model Year': int}
Returns: a list of Columns.
"""
print('Parsing...', end=' ')
s = time.time()
for col, typ in type_casts.items():
if col not in data:
continue
if typ != np.datetime64:
data[col] = data[col].astype(typ, copy=False)
else:
# Both infer_datetime_format and cache are critical for perf.
data[col] = pd.to_datetime(data[col],
infer_datetime_format=True,
cache=True)
# Discretize & create Columns.
columns = []
if pg_cols is None:
pg_cols = [None] * len(cols)
if self.tie_cols:
vocab = np.concatenate([
data[c].value_counts(dropna=False).index.values for c in cols
])
vocab = np.sort(np.unique(vocab))
else:
vocab = None
for c, p in zip(cols, pg_cols):
col = Column(c, pg_name=p)
col.Fill(data[c])
# dropna=False so that if NA/NaN is present in data,
# all_distinct_values will capture it.
#
# For numeric: np.nan
# For datetime: np.datetime64('NaT')
# For strings: ?? (haven't encountered yet)
#
# To test for former, use np.isnan(...).any()
# To test for latter, use np.isnat(...).any()
if vocab is not None:
col.SetDistribution(vocab)
else:
col.SetDistribution(data[c].value_counts(dropna=False).index.values)
columns.append(col)
print('done, took {:.1f}s'.format(time.time() - s))
return columns
def _separate_characters(self, data, cols, limit):
assert len(cols) == 1, "should only have 1 str col"
str_col = data[cols[0]]
return pd.DataFrame(str_col.apply(lambda x: list(x[:limit])).tolist()).fillna(value="$")
class TableDataset(Dataset):
"""Wraps a Table and yields each row as a Dataset element."""
def __init__(self, table, input_encoding=None):
"""Wraps a Table.
Args:
table: the Table.
"""
super(TableDataset, self).__init__()
self.table = copy.deepcopy(table)
print('Discretizing table...', end=' ')
s = time.time()
# [cardianlity, num cols].
self.tuples_np = np.stack(
[self.Discretize(c) for c in self.table.Columns()], axis=1)
self.tuples = torch.as_tensor(
self.tuples_np.astype(np.float32, copy=False))
print('done, took {:.1f}s'.format(time.time() - s))
def Discretize(self, col):
"""Discretize values into its Column's bins.
Args:
col: the Column.
Returns:
col_data: discretized version; an np.ndarray of type np.int32.
"""
return Discretize(col)
def size(self):
return len(self.tuples)
def __len__(self):
return len(self.tuples)
def __getitem__(self, idx):
return self.tuples[idx]
def Discretize(col, data=None):
"""Transforms data values into integers using a Column's vocab.
Args:
col: the Column.
data: list-like data to be discretized. If None, defaults to col.data.
Returns:
col_data: discretized version; an np.ndarray of type np.int32.
"""
# pd.Categorical() does not allow categories be passed in an array
# containing np.nan. It makes it a special case to return code -1
# for NaN values.
if data is None:
data = col.data
# pd.isnull returns true for both np.nan and np.datetime64('NaT').
isnan = pd.isnull(col.all_distinct_values)
if isnan.any():
# We always add nan or nat to the beginning.
assert isnan.sum() == 1, isnan
assert isnan[0], isnan
dvs = col.all_distinct_values[1:]
bin_ids = | pd.Categorical(data, categories=dvs) | pandas.Categorical |
from flask import Flask, redirect, request, url_for,render_template
from application import app, db
from application.models import Products,Orders,Customers #,SummaryOrder,OrdersSummary,ItemTable,OrdersTable,,CustomersTable
import sqlalchemy as sql
import pandas as pd
from datetime import datetime
@app.route('/')
def home():
return render_template('home.html',title='home')
# create customers
@app.route('/customers/add', methods=['GET','POST'])
def add_customer():
return ('<h1>Add New Customer</h1><br>' + render_template('customerform.html',title='add_customer')
+('<br><br> <a href="/customers" type="button">Return to Customers home</a> </br>')
+ ('<br> <a href="/customers/update2" type="button">Update customer records</a> </br>')
+ ('<br> <a href="/" type="button">Return to home</a> </br>'))
@app.route('/customers/add/customer',methods=['GET','POST'])
def add_customers():
connect_string ="mysql+pymysql://root:[email protected]/Tuckshop"
sql_engine = sql.create_engine(connect_string)
df = pd.read_sql_table('customers', sql_engine)
if request.method=='POST':
if len(df.loc[(df.first_name == request.form['first_name']) & (df.last_name == request.form['last_name']) & ((df.customer_dob == request.form['customer_dob'])|(df.customer_address == request.form['customer_address']))]) == 0:
new_first_name = request.form['first_name']
new_last_name = request.form['last_name']
new_customer_address = request.form['customer_address']
new_customer_dob = request.form['customer_dob']
new_customer = Customers(first_name=new_first_name,last_name=new_last_name,customer_address=new_customer_address,customer_dob=new_customer_dob)#,prepaid_balance=new_prepaid_balance)
db.session.add(new_customer)
db.session.commit()
return redirect(url_for('read_customers'))
else:
return ("<h4><br>"+"It looks like " + str(request.form['first_name']) + " " + str(request.form['last_name'])+ " already exists in the system." + "</h4>" + '<a href="/customers/add" type="button">Try again?</a> </br>'
+ ('<br><br> <a href="/customers/update2" type="button">Update customer records</a> </br>')+('<br> <a href="/customers" type="button">Return to Customers home</a> </br>'))
# read customers
@app.route('/customers')
def read_customers():
connect_string ="mysql+pymysql://root:[email protected]/Tuckshop"
sql_engine = sql.create_engine(connect_string)
df = pd.read_sql_table('customers', sql_engine)
df.rename(columns={'id':'Customer ID','first_name':'First Name','last_name':'Surname','customer_address':'Address','customer_dob':'Date of Birth'},inplace=True)
html = df.to_html()
return ('<h1>Customers</h1><br>')+html+('<br> <a href="/customers/add" type="button">Add new customer</a> </br>')+('<br> <a href="/customers/update2" type="button">Edit customer records (Update/Delete)</a> </br>')+('<br><br><br> <a href="/products">Navigate to Products</a><br><br>')+('<a href="/orders">Navigate to Orders</a>')+('<br><br> <a href="/" type="button">Return to Home</a> </br>')
# update customers
@app.route('/customers/update2')
def customer_update_page():
connect_string ="mysql+pymysql://root:[email protected]/Tuckshop"
sql_engine = sql.create_engine(connect_string)
df = pd.read_sql_table('customers', sql_engine)
df1 = df.copy()
df1['Update'] = 'update'
df1['Delete'] = 'delete'
for n in range(len(df1)):
df1.iloc[n,-1] = "<a href=/customers/delete/"+ str(df1.loc[n,'id']) + ">delete</a>"
df1.iloc[n,-2] = "<a href=/customers/update/"+ str(df1.loc[n,'id']) + ">update</a>"
df1.rename(columns={'id':'Customer ID','first_name':'First Name','last_name':'Surname','customer_address':'Address','customer_dob':'Date of Birth'},inplace=True)
html = df1.to_html(render_links=True,escape=False)
return ('<h1>Update Customers</h1><br>')+ html + ('<br> <a href="/customers">Back to Customers</a> </br>') + ('<br> <a href="/products">Navigate to Products</a> </br>') + ('<br> <a href="/orders">Navigate to Orders</a> </br>')
@app.route('/customers/update', methods = ['GET','POST'])
def update_customer():
update_record = Customers.query.filter_by(id=request.form['entry']).first()
if request.method=='POST':
update_record = Customers.query.filter_by(id=request.form['entry']).first()
update_record.first_name = request.form['first_name']
update_record.last_name = request.form['last_name']
update_record.customer_address = request.form['customer_address']
update_record.customer_dob = request.form['customer_dob']
db.session.commit()
return redirect(url_for('read_customers'))
@app.route('/customers/update/<int:customer_record>',methods=['GET','POST'])
def customer_update1(customer_record):
people = str(customer_record)
connect_string ="mysql+pymysql://root:[email protected]/Tuckshop"
sql_engine = sql.create_engine(connect_string)
df = pd.read_sql_table('customers', sql_engine)
df1 = df.loc[df.id==int(customer_record),:]
df1.rename(columns={'id':'Customer ID','first_name':'<NAME>','last_name':'Surname','customer_address':'Address','customer_dob':'Date of Birth'},inplace=True)
html = df1.to_html(escape=False)
record_no = customer_record
return ('<h1>Update Customers</h1><br>')+ html + "<br><br>" + render_template('customer_update.html',value=record_no) +('<br> <a href="/customers">Back to Customers</a> </br>')+('<br> <a href="/products">Navigate to Products</a> </br>')+('<br> <a href="/orders">Navigate to Orders</a> </br>')
# delete customers
@app.route('/customers/delete/<int:customer_>')
def delete_customers(customer_):
if Orders.query.filter_by(fk_customer_id=customer_).count() == 0:
customer_to_delete = Customers.query.filter_by(id=customer_).first()
db.session.delete(customer_to_delete)
db.session.commit()
return redirect(url_for('read_customers'))
else:
return "Oops! The customer you tried to delete has already placed an order. Please update the orders records if you need to remove this customer." +('<br> <a href="/customers">Return to Customers?</a> </br>')
# create products
@app.route('/products/add', methods=['GET','POST'])
def add_product():
if request.method == 'POST':
page = ''
return '<h1>Add New Product</h1><br>'+ render_template('stockform.html',title='add_item')+('<br><br> <a href="/products" type="button">Return to Products home</a> </br>')+ ('<br> <a href="/products/update2" type="button">Update product records</a> </br>')
@app.route('/products/add/item',methods=['GET','POST'])
def add_products():
connect_string ="mysql+pymysql://root:[email protected]/Tuckshop"
sql_engine = sql.create_engine(connect_string)
df = pd.read_sql_table('products', sql_engine)
if request.method=='POST':
if len(df.loc[(df.product_name == request.form['product_name']) & (df.product_brand == request.form['brand'])]) == 0:
new_product_name = request.form['product_name']
new_product_brand = request.form['brand']
new_product_quantity = request.form['quantity']
new_product_itemcost = request.form['itemcost']
new_product_price = request.form['price']
new_product = Products(product_name=new_product_name,product_brand=new_product_brand,quantity_in_stock=new_product_quantity,cost_per_item=new_product_itemcost,price=new_product_price)
db.session.add(new_product)
db.session.commit()
return redirect(url_for('read_products'))
else:
return ("<h4><br>"+"It looks like " + str(request.form['brand']) + " " + str(request.form['product_name'])+ " already exists in the system." + "</h4>" + '<a href="/products/add" type="button">Try again?</a> </br>'
+ ('<br><br> <a href="/products/update2" type="button">Update products records</a> </br>')+('<br> <a href="/products" type="button">Return to Products home</a> </br>')+('<br> <br><a href="/" type="button">Return to Home</a> </br>'))
# read products
@app.route('/products')
def read_products():
connect_string ="mysql+pymysql://root:[email protected]/Tuckshop"
sql_engine = sql.create_engine(connect_string)
df = pd.read_sql_table('products', sql_engine)
df.price = ('£'+df.price.astype('str')).str.ljust(5,'0')
df.cost_per_item = ('£'+df.cost_per_item.astype('str')).str.ljust(5,'0')
df.rename(columns={'id':'Product ID','product_name':'Product','product_brand':'Brand','quantity_in_stock':'Quantity in stock','cost_per_item':'Individual Cost','price':'Price'},inplace=True)
html = df.to_html()
return ('<h1>Products</h1><br>')+html+('<br> <a href="/products/add">Add new item to stocklist</a> </br>')+('<br> <a href="/products/update2">Edit stocklist (Update/Delete)</a> </br><br>')+('<br><br> <a href="/orders">Navigate to Orders</a> </br>')+('<br> <a href="/customers">Navigate to Customers</a> </br>') +('<br><br> <a href="/" type="button">Return to Home</a> </br>')
# update products
@app.route('/products/update2')
def products_update_page():
connect_string ="mysql+pymysql://root:[email protected]/Tuckshop"
sql_engine = sql.create_engine(connect_string)
df = pd.read_sql_table('products', sql_engine)
df1 = df.copy()
df1['Update'] = 'update'
df1['Delete'] = 'delete'
for n in range(len(df1)):
df1.iloc[n,-1] = "<a href=/products/delete/"+ str(df1.loc[n,'id']) + ">delete</a>"
df1.iloc[n,-2] = "<a href=/products/update/"+ str(df1.loc[n,'id']) + ">update</a>"
df1.price = ('£' + df1.price.astype('str')).str.ljust(5,'0')
df1.cost_per_item = ('£' + df1.cost_per_item.astype('str')).str.ljust(5,'0')
df1.rename(columns={'id':'Product ID','product_name':'Product','product_brand':'Brand','quantity_in_stock':'Quantity in stock','cost_per_item':'Individual Cost','price':'Price'},inplace=True)
html = df1.to_html(render_links=True,escape=False)
return ('<h1>Update Product List</h1><br>')+ html +('<br> <a href="/products">Back to Products home</a> </br>')+('<br> <br><a href="/customers">Navigate to Customers</a> </br>')+('<br> <a href="/orders">Navigate to Orders</a> </br>')+('<br> <br><a href="/" type="button">Return to Home</a> </br>')
@app.route('/products/update', methods = ['GET','POST'])
def update_product():
if request.method=='POST':
update_record = Products.query.filter_by(id=request.form['entry']).first()
update_record.product_name = request.form['product_name']
update_record.product_brand = request.form['product_brand']
update_record.price = request.form['price']
update_record.quantity_in_stock = request.form['quantity_in_stock']
update_record.cost_per_item = request.form['cost_per_item']
db.session.commit()
return redirect(url_for('products_update_page'))
@app.route('/products/update/<int:product_record>',methods=['GET','POST'])
def product_update1(product_record):
connect_string ="mysql+pymysql://root:[email protected]/Tuckshop"
sql_engine = sql.create_engine(connect_string)
df = pd.read_sql_table('products', sql_engine)
df1 = df.loc[df.id==int(product_record),:]
df1.rename(columns={'id':'Product ID','product_name':'Product','product_brand':'Brand','quantity_in_stock':'Quantity in stock','cost_per_item':'Individual Cost','price':'Price'},inplace=True)
html = df1.to_html(escape=False)
record_no = product_record
return ('<h1>Update Products List</h1><br>')+html + "<br><br>" + render_template('product_update.html', value1 = record_no) + ('<br> <a href="/products">Back to Products</a> </br>')+('<br> <a href="/customers">Navigate to Customers</a> </br>')+('<br> <a href="/orders">Navigate to Orders</a> </br>')+('<br> <a href="/products" type="button">Return to Products home</a> </br>')+('<br> <br><a href="/" type="button">Return to Home</a> </br>')
# delete products
@app.route('/products/delete/<int:product_>',methods=['GET','POST'])
def delete_products(product_):
if Orders.query.filter_by(fk_product_id=product_).count() == 0:
product_to_delete = Products.query.filter_by(id=product_).first()
db.session.delete(product_to_delete)
db.session.commit()
return redirect(url_for('read_products'))
else: return "Oops! You tried to delete a product that has already been purchased"+('<br> <br><a href="/products/update2">Try Again?</a> </br>')+('<br> <br><br><a href="/products">Return to Products</a> </br>') +('<br> <a href="/products" type="button">Return to Products home</a> </br>')+('<br> <br><a href="/" type="button">Return to Home</a> </br>')
# create orders
@app.route('/orders/add', methods = ['GET','POST'])
def add_order():
connect_string ="mysql+pymysql://root:[email protected]/Tuckshop"
sql_engine = sql.create_engine(connect_string)
df = | pd.read_sql_table('products', sql_engine) | pandas.read_sql_table |
# 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)
df = DataFrame(np.random.randn(20, 3), index=index)
result = df[start:end]
expected = df.iloc[5:16]
tm.assert_frame_equal(result, expected)
result = df.loc[start:end]
tm.assert_frame_equal(result, expected)
def test_setitem(self):
self.ts[self.ts.index[5]] = np.NaN
self.ts[[1, 2, 17]] = np.NaN
self.ts[6] = np.NaN
self.assertTrue(np.isnan(self.ts[6]))
self.assertTrue(np.isnan(self.ts[2]))
self.ts[np.isnan(self.ts)] = 5
self.assertFalse(np.isnan(self.ts[2]))
# caught this bug when writing tests
series = Series(tm.makeIntIndex(20).astype(float),
index=tm.makeIntIndex(20))
series[::2] = 0
self.assertTrue((series[::2] == 0).all())
# set item that's not contained
s = self.series.copy()
s['foobar'] = 1
app = Series([1], index=['foobar'], name='series')
expected = self.series.append(app)
assert_series_equal(s, expected)
# Test for issue #10193
key = pd.Timestamp('2012-01-01')
series = pd.Series()
series[key] = 47
expected = pd.Series(47, [key])
assert_series_equal(series, expected)
series = pd.Series([], pd.DatetimeIndex([], freq='D'))
series[key] = 47
expected = pd.Series(47, pd.DatetimeIndex([key], freq='D'))
assert_series_equal(series, expected)
def test_setitem_dtypes(self):
# change dtypes
# GH 4463
expected = Series([np.nan, 2, 3])
s = Series([1, 2, 3])
s.iloc[0] = np.nan
assert_series_equal(s, expected)
s = Series([1, 2, 3])
s.loc[0] = np.nan
assert_series_equal(s, expected)
s = Series([1, 2, 3])
s[0] = np.nan
assert_series_equal(s, expected)
s = Series([False])
s.loc[0] = np.nan
assert_series_equal(s, Series([np.nan]))
s = Series([False, True])
s.loc[0] = np.nan
assert_series_equal(s, Series([np.nan, 1.0]))
def test_set_value(self):
idx = self.ts.index[10]
res = self.ts.set_value(idx, 0)
self.assertIs(res, self.ts)
self.assertEqual(self.ts[idx], 0)
# equiv
s = self.series.copy()
res = s.set_value('foobar', 0)
self.assertIs(res, s)
self.assertEqual(res.index[-1], 'foobar')
self.assertEqual(res['foobar'], 0)
s = self.series.copy()
s.loc['foobar'] = 0
self.assertEqual(s.index[-1], 'foobar')
self.assertEqual(s['foobar'], 0)
def test_setslice(self):
sl = self.ts[5:20]
self.assertEqual(len(sl), len(sl.index))
self.assertTrue(sl.index.is_unique)
def test_basic_getitem_setitem_corner(self):
# invalid tuples, e.g. self.ts[:, None] vs. self.ts[:, 2]
with tm.assertRaisesRegexp(ValueError, 'tuple-index'):
self.ts[:, 2]
with tm.assertRaisesRegexp(ValueError, 'tuple-index'):
self.ts[:, 2] = 2
# weird lists. [slice(0, 5)] will work but not two slices
result = self.ts[[slice(None, 5)]]
expected = self.ts[:5]
assert_series_equal(result, expected)
# OK
self.assertRaises(Exception, self.ts.__getitem__,
[5, slice(None, None)])
self.assertRaises(Exception, self.ts.__setitem__,
[5, slice(None, None)], 2)
def test_basic_getitem_with_labels(self):
indices = self.ts.index[[5, 10, 15]]
result = self.ts[indices]
expected = self.ts.reindex(indices)
assert_series_equal(result, expected)
result = self.ts[indices[0]:indices[2]]
expected = self.ts.ix[indices[0]:indices[2]]
assert_series_equal(result, expected)
# integer indexes, be careful
s = Series(np.random.randn(10), index=lrange(0, 20, 2))
inds = [0, 2, 5, 7, 8]
arr_inds = np.array([0, 2, 5, 7, 8])
result = s[inds]
expected = s.reindex(inds)
assert_series_equal(result, expected)
result = s[arr_inds]
expected = s.reindex(arr_inds)
assert_series_equal(result, expected)
# GH12089
# with tz for values
s = Series(pd.date_range("2011-01-01", periods=3, tz="US/Eastern"),
index=['a', 'b', 'c'])
expected = Timestamp('2011-01-01', tz='US/Eastern')
result = s.loc['a']
self.assertEqual(result, expected)
result = s.iloc[0]
self.assertEqual(result, expected)
result = s['a']
self.assertEqual(result, expected)
def test_basic_setitem_with_labels(self):
indices = self.ts.index[[5, 10, 15]]
cp = self.ts.copy()
exp = self.ts.copy()
cp[indices] = 0
exp.ix[indices] = 0
assert_series_equal(cp, exp)
cp = self.ts.copy()
exp = self.ts.copy()
cp[indices[0]:indices[2]] = 0
exp.ix[indices[0]:indices[2]] = 0
assert_series_equal(cp, exp)
# integer indexes, be careful
s = Series(np.random.randn(10), index=lrange(0, 20, 2))
inds = [0, 4, 6]
arr_inds = np.array([0, 4, 6])
cp = s.copy()
exp = s.copy()
s[inds] = 0
s.ix[inds] = 0
assert_series_equal(cp, exp)
cp = s.copy()
exp = s.copy()
s[arr_inds] = 0
s.ix[arr_inds] = 0
assert_series_equal(cp, exp)
inds_notfound = [0, 4, 5, 6]
arr_inds_notfound = np.array([0, 4, 5, 6])
self.assertRaises(Exception, s.__setitem__, inds_notfound, 0)
self.assertRaises(Exception, s.__setitem__, arr_inds_notfound, 0)
# GH12089
# with tz for values
s = Series(pd.date_range("2011-01-01", periods=3, tz="US/Eastern"),
index=['a', 'b', 'c'])
s2 = s.copy()
expected = Timestamp('2011-01-03', tz='US/Eastern')
s2.loc['a'] = expected
result = s2.loc['a']
self.assertEqual(result, expected)
s2 = s.copy()
s2.iloc[0] = expected
result = s2.iloc[0]
self.assertEqual(result, expected)
s2 = s.copy()
s2['a'] = expected
result = s2['a']
self.assertEqual(result, expected)
def test_ix_getitem(self):
inds = self.series.index[[3, 4, 7]]
assert_series_equal(self.series.ix[inds], self.series.reindex(inds))
assert_series_equal(self.series.ix[5::2], self.series[5::2])
# slice with indices
d1, d2 = self.ts.index[[5, 15]]
result = self.ts.ix[d1:d2]
expected = self.ts.truncate(d1, d2)
assert_series_equal(result, expected)
# boolean
mask = self.series > self.series.median()
assert_series_equal(self.series.ix[mask], self.series[mask])
# ask for index value
self.assertEqual(self.ts.ix[d1], self.ts[d1])
self.assertEqual(self.ts.ix[d2], self.ts[d2])
def test_ix_getitem_not_monotonic(self):
d1, d2 = self.ts.index[[5, 15]]
ts2 = self.ts[::2][[1, 2, 0]]
self.assertRaises(KeyError, ts2.ix.__getitem__, slice(d1, d2))
self.assertRaises(KeyError, ts2.ix.__setitem__, slice(d1, d2), 0)
def test_ix_getitem_setitem_integer_slice_keyerrors(self):
s = Series(np.random.randn(10), index=lrange(0, 20, 2))
# this is OK
cp = s.copy()
cp.ix[4:10] = 0
self.assertTrue((cp.ix[4:10] == 0).all())
# so is this
cp = s.copy()
cp.ix[3:11] = 0
self.assertTrue((cp.ix[3:11] == 0).values.all())
result = s.ix[4:10]
result2 = s.ix[3:11]
expected = s.reindex([4, 6, 8, 10])
assert_series_equal(result, expected)
assert_series_equal(result2, expected)
# non-monotonic, raise KeyError
s2 = s.iloc[lrange(5) + lrange(5, 10)[::-1]]
self.assertRaises(KeyError, s2.ix.__getitem__, slice(3, 11))
self.assertRaises(KeyError, s2.ix.__setitem__, slice(3, 11), 0)
def test_ix_getitem_iterator(self):
idx = iter(self.series.index[:10])
result = self.series.ix[idx]
assert_series_equal(result, self.series[:10])
def test_setitem_with_tz(self):
for tz in ['US/Eastern', 'UTC', 'Asia/Tokyo']:
orig = pd.Series(pd.date_range('2016-01-01', freq='H', periods=3,
tz=tz))
self.assertEqual(orig.dtype, 'datetime64[ns, {0}]'.format(tz))
# scalar
s = orig.copy()
s[1] = pd.Timestamp('2011-01-01', tz=tz)
exp = pd.Series([pd.Timestamp('2016-01-01 00:00', tz=tz),
pd.Timestamp('2011-01-01 00:00', tz=tz),
pd.Timestamp('2016-01-01 02:00', tz=tz)])
tm.assert_series_equal(s, exp)
s = orig.copy()
s.loc[1] = pd.Timestamp('2011-01-01', tz=tz)
tm.assert_series_equal(s, exp)
s = orig.copy()
s.iloc[1] = pd.Timestamp('2011-01-01', tz=tz)
tm.assert_series_equal(s, exp)
# vector
vals = pd.Series([pd.Timestamp('2011-01-01', tz=tz),
pd.Timestamp('2012-01-01', tz=tz)], index=[1, 2])
self.assertEqual(vals.dtype, 'datetime64[ns, {0}]'.format(tz))
s[[1, 2]] = vals
exp = pd.Series([pd.Timestamp('2016-01-01 00:00', tz=tz),
pd.Timestamp('2011-01-01 00:00', tz=tz),
pd.Timestamp('2012-01-01 00:00', tz=tz)])
tm.assert_series_equal(s, exp)
s = orig.copy()
s.loc[[1, 2]] = vals
tm.assert_series_equal(s, exp)
s = orig.copy()
s.iloc[[1, 2]] = vals
tm.assert_series_equal(s, exp)
def test_setitem_with_tz_dst(self):
# GH XXX
tz = 'US/Eastern'
orig = pd.Series(pd.date_range('2016-11-06', freq='H', periods=3,
tz=tz))
self.assertEqual(orig.dtype, 'datetime64[ns, {0}]'.format(tz))
# scalar
s = orig.copy()
s[1] = pd.Timestamp('2011-01-01', tz=tz)
exp = pd.Series([pd.Timestamp('2016-11-06 00:00', tz=tz),
pd.Timestamp('2011-01-01 00:00', tz=tz),
pd.Timestamp('2016-11-06 02:00', tz=tz)])
tm.assert_series_equal(s, exp)
s = orig.copy()
s.loc[1] = pd.Timestamp('2011-01-01', tz=tz)
tm.assert_series_equal(s, exp)
s = orig.copy()
s.iloc[1] = pd.Timestamp('2011-01-01', tz=tz)
tm.assert_series_equal(s, exp)
# vector
vals = pd.Series([pd.Timestamp('2011-01-01', tz=tz),
pd.Timestamp('2012-01-01', tz=tz)], index=[1, 2])
self.assertEqual(vals.dtype, 'datetime64[ns, {0}]'.format(tz))
s[[1, 2]] = vals
exp = pd.Series([pd.Timestamp('2016-11-06 00:00', tz=tz),
pd.Timestamp('2011-01-01 00:00', tz=tz),
pd.Timestamp('2012-01-01 00:00', tz=tz)])
tm.assert_series_equal(s, exp)
s = orig.copy()
s.loc[[1, 2]] = vals
tm.assert_series_equal(s, exp)
s = orig.copy()
s.iloc[[1, 2]] = vals
tm.assert_series_equal(s, exp)
def test_where(self):
s = Series(np.random.randn(5))
cond = s > 0
rs = s.where(cond).dropna()
rs2 = s[cond]
assert_series_equal(rs, rs2)
rs = s.where(cond, -s)
assert_series_equal(rs, s.abs())
rs = s.where(cond)
assert (s.shape == rs.shape)
assert (rs is not s)
# test alignment
cond = Series([True, False, False, True, False], index=s.index)
s2 = -(s.abs())
expected = s2[cond].reindex(s2.index[:3]).reindex(s2.index)
rs = s2.where(cond[:3])
assert_series_equal(rs, expected)
expected = s2.abs()
expected.ix[0] = s2[0]
rs = s2.where(cond[:3], -s2)
assert_series_equal(rs, expected)
self.assertRaises(ValueError, s.where, 1)
self.assertRaises(ValueError, s.where, cond[:3].values, -s)
# GH 2745
s = Series([1, 2])
s[[True, False]] = [0, 1]
expected = Series([0, 2])
assert_series_equal(s, expected)
# failures
self.assertRaises(ValueError, s.__setitem__, tuple([[[True, False]]]),
[0, 2, 3])
self.assertRaises(ValueError, s.__setitem__, tuple([[[True, False]]]),
[])
# unsafe dtype changes
for dtype in [np.int8, np.int16, np.int32, np.int64, np.float16,
np.float32, np.float64]:
s = Series(np.arange(10), dtype=dtype)
mask = s < 5
s[mask] = lrange(2, 7)
expected = Series(lrange(2, 7) + lrange(5, 10), dtype=dtype)
assert_series_equal(s, expected)
self.assertEqual(s.dtype, expected.dtype)
# these are allowed operations, but are upcasted
for dtype in [np.int64, np.float64]:
s = Series(np.arange(10), dtype=dtype)
mask = s < 5
values = [2.5, 3.5, 4.5, 5.5, 6.5]
s[mask] = values
expected = Series(values + lrange(5, 10), dtype='float64')
assert_series_equal(s, expected)
self.assertEqual(s.dtype, expected.dtype)
# GH 9731
s = Series(np.arange(10), dtype='int64')
mask = s > 5
values = [2.5, 3.5, 4.5, 5.5]
s[mask] = values
expected = Series(lrange(6) + values, dtype='float64')
assert_series_equal(s, expected)
# can't do these as we are forced to change the itemsize of the input
# to something we cannot
for dtype in [np.int8, np.int16, np.int32, np.float16, np.float32]:
s = Series(np.arange(10), dtype=dtype)
mask = s < 5
values = [2.5, 3.5, 4.5, 5.5, 6.5]
self.assertRaises(Exception, s.__setitem__, tuple(mask), values)
# GH3235
s = Series(np.arange(10), dtype='int64')
mask = s < 5
s[mask] = lrange(2, 7)
expected = Series(lrange(2, 7) + lrange(5, 10), dtype='int64')
assert_series_equal(s, expected)
self.assertEqual(s.dtype, expected.dtype)
s = Series(np.arange(10), dtype='int64')
mask = s > 5
s[mask] = [0] * 4
expected = Series([0, 1, 2, 3, 4, 5] + [0] * 4, dtype='int64')
assert_series_equal(s, expected)
s = Series(np.arange(10))
mask = s > 5
def f():
s[mask] = [5, 4, 3, 2, 1]
self.assertRaises(ValueError, f)
def f():
s[mask] = [0] * 5
self.assertRaises(ValueError, f)
# dtype changes
s = Series([1, 2, 3, 4])
result = s.where(s > 2, np.nan)
expected = Series([np.nan, np.nan, 3, 4])
assert_series_equal(result, expected)
# GH 4667
# setting with None changes dtype
s = Series(range(10)).astype(float)
s[8] = None
result = s[8]
self.assertTrue(isnull(result))
s = Series(range(10)).astype(float)
s[s > 8] = None
result = s[isnull(s)]
expected = Series(np.nan, index=[9])
assert_series_equal(result, expected)
def test_where_setitem_invalid(self):
# GH 2702
# make sure correct exceptions are raised on invalid list assignment
# slice
s = Series(list('abc'))
def f():
s[0:3] = list(range(27))
self.assertRaises(ValueError, f)
s[0:3] = list(range(3))
expected = Series([0, 1, 2])
assert_series_equal(s.astype(np.int64), expected, )
# slice with step
s = Series(list('abcdef'))
def f():
s[0:4:2] = list(range(27))
self.assertRaises(ValueError, f)
s = Series(list('abcdef'))
s[0:4:2] = list(range(2))
expected = Series([0, 'b', 1, 'd', 'e', 'f'])
assert_series_equal(s, expected)
# neg slices
s = Series(list('abcdef'))
def f():
s[:-1] = list(range(27))
self.assertRaises(ValueError, f)
s[-3:-1] = list(range(2))
expected = Series(['a', 'b', 'c', 0, 1, 'f'])
assert_series_equal(s, expected)
# list
s = Series(list('abc'))
def f():
s[[0, 1, 2]] = list(range(27))
self.assertRaises(ValueError, f)
s = Series(list('abc'))
def f():
s[[0, 1, 2]] = list(range(2))
self.assertRaises(ValueError, f)
# scalar
s = Series(list('abc'))
s[0] = list(range(10))
expected = Series([list(range(10)), 'b', 'c'])
assert_series_equal(s, expected)
def test_where_broadcast(self):
# Test a variety of differently sized series
for size in range(2, 6):
# Test a variety of boolean indices
for selection in [
# First element should be set
np.resize([True, False, False, False, False], size),
# Set alternating elements]
np.resize([True, False], size),
# No element should be set
np.resize([False], size)]:
# Test a variety of different numbers as content
for item in [2.0, np.nan, np.finfo(np.float).max,
np.finfo(np.float).min]:
# Test numpy arrays, lists and tuples as the input to be
# broadcast
for arr in [np.array([item]), [item], (item, )]:
data = np.arange(size, dtype=float)
s = Series(data)
s[selection] = arr
# Construct the expected series by taking the source
# data or item based on the selection
expected = Series([item if use_item else data[
i] for i, use_item in enumerate(selection)])
assert_series_equal(s, expected)
s = Series(data)
result = s.where(~selection, arr)
assert_series_equal(result, expected)
def test_where_inplace(self):
s = Series(np.random.randn(5))
cond = s > 0
rs = s.copy()
rs.where(cond, inplace=True)
assert_series_equal(rs.dropna(), s[cond])
assert_series_equal(rs, s.where(cond))
rs = s.copy()
rs.where(cond, -s, inplace=True)
assert_series_equal(rs, s.where(cond, -s))
def test_where_dups(self):
# GH 4550
# where crashes with dups in index
s1 = Series(list(range(3)))
s2 = Series(list(range(3)))
comb = pd.concat([s1, s2])
result = comb.where(comb < 2)
expected = Series([0, 1, np.nan, 0, 1, np.nan],
index=[0, 1, 2, 0, 1, 2])
assert_series_equal(result, expected)
# GH 4548
# inplace updating not working with dups
comb[comb < 1] = 5
expected = Series([5, 1, 2, 5, 1, 2], index=[0, 1, 2, 0, 1, 2])
assert_series_equal(comb, expected)
comb[comb < 2] += 10
expected = Series([5, 11, 2, 5, 11, 2], index=[0, 1, 2, 0, 1, 2])
assert_series_equal(comb, expected)
def test_where_datetime(self):
s = Series(date_range('20130102', periods=2))
expected = Series([10, 10], dtype='datetime64[ns]')
mask = np.array([False, False])
rs = s.where(mask, [10, 10])
assert_series_equal(rs, expected)
rs = s.where(mask, 10)
assert_series_equal(rs, expected)
rs = s.where(mask, 10.0)
assert_series_equal(rs, expected)
rs = s.where(mask, [10.0, 10.0])
assert_series_equal(rs, expected)
rs = s.where(mask, [10.0, np.nan])
expected = Series([10, None], dtype='datetime64[ns]')
assert_series_equal(rs, expected)
def test_where_timedelta(self):
s = Series([1, 2], dtype='timedelta64[ns]')
expected = Series([10, 10], dtype='timedelta64[ns]')
mask = np.array([False, False])
rs = s.where(mask, [10, 10])
assert_series_equal(rs, expected)
rs = s.where(mask, 10)
assert_series_equal(rs, expected)
rs = s.where(mask, 10.0)
assert_series_equal(rs, expected)
rs = s.where(mask, [10.0, 10.0])
assert_series_equal(rs, expected)
rs = s.where(mask, [10.0, np.nan])
expected = Series([10, None], dtype='timedelta64[ns]')
assert_series_equal(rs, expected)
def test_mask(self):
# compare with tested results in test_where
s = Series(np.random.randn(5))
cond = s > 0
rs = s.where(~cond, np.nan)
assert_series_equal(rs, s.mask(cond))
rs = s.where(~cond)
rs2 = s.mask(cond)
assert_series_equal(rs, rs2)
rs = s.where(~cond, -s)
rs2 = s.mask(cond, -s)
assert_series_equal(rs, rs2)
cond = Series([True, False, False, True, False], index=s.index)
s2 = -(s.abs())
rs = s2.where(~cond[:3])
rs2 = s2.mask(cond[:3])
assert_series_equal(rs, rs2)
rs = s2.where(~cond[:3], -s2)
rs2 = s2.mask(cond[:3], -s2)
assert_series_equal(rs, rs2)
self.assertRaises(ValueError, s.mask, 1)
self.assertRaises(ValueError, s.mask, cond[:3].values, -s)
# dtype changes
s = Series([1, 2, 3, 4])
result = s.mask(s > 2, np.nan)
expected = Series([1, 2, np.nan, np.nan])
assert_series_equal(result, expected)
def test_mask_broadcast(self):
# GH 8801
# copied from test_where_broadcast
for size in range(2, 6):
for selection in [
# First element should be set
np.resize([True, False, False, False, False], size),
# Set alternating elements]
np.resize([True, False], size),
# No element should be set
np.resize([False], size)]:
for item in [2.0, np.nan, np.finfo(np.float).max,
np.finfo(np.float).min]:
for arr in [np.array([item]), [item], (item, )]:
data = np.arange(size, dtype=float)
s = Series(data)
result = s.mask(selection, arr)
expected = Series([item if use_item else data[
i] for i, use_item in enumerate(selection)])
assert_series_equal(result, expected)
def test_mask_inplace(self):
s = Series(np.random.randn(5))
cond = s > 0
rs = s.copy()
rs.mask(cond, inplace=True)
assert_series_equal(rs.dropna(), s[~cond])
assert_series_equal(rs, s.mask(cond))
rs = s.copy()
rs.mask(cond, -s, inplace=True)
assert_series_equal(rs, s.mask(cond, -s))
def test_ix_setitem(self):
inds = self.series.index[[3, 4, 7]]
result = self.series.copy()
result.ix[inds] = 5
expected = self.series.copy()
expected[[3, 4, 7]] = 5
assert_series_equal(result, expected)
result.ix[5:10] = 10
expected[5:10] = 10
assert_series_equal(result, expected)
# set slice with indices
d1, d2 = self.series.index[[5, 15]]
result.ix[d1:d2] = 6
expected[5:16] = 6 # because it's inclusive
assert_series_equal(result, expected)
# set index value
self.series.ix[d1] = 4
self.series.ix[d2] = 6
self.assertEqual(self.series[d1], 4)
self.assertEqual(self.series[d2], 6)
def test_where_numeric_with_string(self):
# GH 9280
s = pd.Series([1, 2, 3])
w = s.where(s > 1, 'X')
self.assertFalse(is_integer(w[0]))
self.assertTrue(is_integer(w[1]))
self.assertTrue(is_integer(w[2]))
self.assertTrue(isinstance(w[0], str))
self.assertTrue(w.dtype == 'object')
w = s.where(s > 1, ['X', 'Y', 'Z'])
self.assertFalse(is_integer(w[0]))
self.assertTrue(is_integer(w[1]))
self.assertTrue(is_integer(w[2]))
self.assertTrue(isinstance(w[0], str))
self.assertTrue(w.dtype == 'object')
w = s.where(s > 1, np.array(['X', 'Y', 'Z']))
self.assertFalse(is_integer(w[0]))
self.assertTrue(is_integer(w[1]))
self.assertTrue(is_integer(w[2]))
self.assertTrue(isinstance(w[0], str))
self.assertTrue(w.dtype == 'object')
def test_setitem_boolean(self):
mask = self.series > self.series.median()
# similiar indexed series
result = self.series.copy()
result[mask] = self.series * 2
expected = self.series * 2
assert_series_equal(result[mask], expected[mask])
# needs alignment
result = self.series.copy()
result[mask] = (self.series * 2)[0:5]
expected = (self.series * 2)[0:5].reindex_like(self.series)
expected[-mask] = self.series[mask]
assert_series_equal(result[mask], expected[mask])
def test_ix_setitem_boolean(self):
mask = self.series > self.series.median()
result = self.series.copy()
result.ix[mask] = 0
expected = self.series
expected[mask] = 0
assert_series_equal(result, expected)
def test_ix_setitem_corner(self):
inds = list(self.series.index[[5, 8, 12]])
self.series.ix[inds] = 5
self.assertRaises(Exception, self.series.ix.__setitem__,
inds + ['foo'], 5)
def test_get_set_boolean_different_order(self):
ordered = self.series.sort_values()
# setting
copy = self.series.copy()
copy[ordered > 0] = 0
expected = self.series.copy()
expected[expected > 0] = 0
assert_series_equal(copy, expected)
# getting
sel = self.series[ordered > 0]
exp = self.series[self.series > 0]
assert_series_equal(sel, exp)
def test_setitem_na(self):
# these induce dtype changes
expected = Series([np.nan, 3, np.nan, 5, np.nan, 7, np.nan, 9, np.nan])
s = Series([2, 3, 4, 5, 6, 7, 8, 9, 10])
s[::2] = np.nan
assert_series_equal(s, expected)
# get's coerced to float, right?
expected = Series([np.nan, 1, np.nan, 0])
s = Series([True, True, False, False])
s[::2] = np.nan
assert_series_equal(s, expected)
expected = Series([np.nan, np.nan, np.nan, np.nan, np.nan, 5, 6, 7, 8,
9])
s = Series(np.arange(10))
s[:5] = np.nan
assert_series_equal(s, expected)
def test_basic_indexing(self):
s = Series(np.random.randn(5), index=['a', 'b', 'a', 'a', 'b'])
self.assertRaises(IndexError, s.__getitem__, 5)
self.assertRaises(IndexError, s.__setitem__, 5, 0)
self.assertRaises(KeyError, s.__getitem__, 'c')
s = s.sort_index()
self.assertRaises(IndexError, s.__getitem__, 5)
self.assertRaises(IndexError, s.__setitem__, 5, 0)
def test_int_indexing(self):
s = Series(np.random.randn(6), index=[0, 0, 1, 1, 2, 2])
self.assertRaises(KeyError, s.__getitem__, 5)
self.assertRaises(KeyError, s.__getitem__, 'c')
# not monotonic
s = Series(np.random.randn(6), index=[2, 2, 0, 0, 1, 1])
self.assertRaises(KeyError, s.__getitem__, 5)
self.assertRaises(KeyError, s.__getitem__, 'c')
def test_datetime_indexing(self):
from pandas import date_range
index = date_range('1/1/2000', '1/7/2000')
index = index.repeat(3)
s = Series(len(index), index=index)
stamp = Timestamp('1/8/2000')
self.assertRaises(KeyError, s.__getitem__, stamp)
s[stamp] = 0
self.assertEqual(s[stamp], 0)
# not monotonic
s = Series(len(index), index=index)
s = s[::-1]
self.assertRaises(KeyError, s.__getitem__, stamp)
s[stamp] = 0
self.assertEqual(s[stamp], 0)
def test_timedelta_assignment(self):
# GH 8209
s = Series([])
s.loc['B'] = timedelta(1)
tm.assert_series_equal(s, Series(Timedelta('1 days'), index=['B']))
s = s.reindex(s.index.insert(0, 'A'))
tm.assert_series_equal(s, Series(
[np.nan, Timedelta('1 days')], index=['A', 'B']))
result = s.fillna(timedelta(1))
expected = Series(Timedelta('1 days'), index=['A', 'B'])
tm.assert_series_equal(result, expected)
s.loc['A'] = timedelta(1)
tm.assert_series_equal(s, expected)
# GH 14155
s = Series(10 * [np.timedelta64(10, 'm')])
s.loc[[1, 2, 3]] = np.timedelta64(20, 'm')
expected = pd.Series(10 * [np.timedelta64(10, 'm')])
expected.loc[[1, 2, 3]] = pd.Timedelta(np.timedelta64(20, 'm'))
tm.assert_series_equal(s, expected)
def test_underlying_data_conversion(self):
# GH 4080
df = DataFrame(dict((c, [1, 2, 3]) for c in ['a', 'b', 'c']))
df.set_index(['a', 'b', 'c'], inplace=True)
s = Series([1], index=[(2, 2, 2)])
df['val'] = 0
df
df['val'].update(s)
expected = DataFrame(
dict(a=[1, 2, 3], b=[1, 2, 3], c=[1, 2, 3], val=[0, 1, 0]))
expected.set_index(['a', 'b', 'c'], inplace=True)
tm.assert_frame_equal(df, expected)
# GH 3970
# these are chained assignments as well
pd.set_option('chained_assignment', None)
df = DataFrame({"aa": range(5), "bb": [2.2] * 5})
df["cc"] = 0.0
ck = [True] * len(df)
df["bb"].iloc[0] = .13
# TODO: unused
df_tmp = df.iloc[ck] # noqa
df["bb"].iloc[0] = .15
self.assertEqual(df['bb'].iloc[0], 0.15)
pd.set_option('chained_assignment', 'raise')
# GH 3217
df = DataFrame(dict(a=[1, 3], b=[np.nan, 2]))
df['c'] = np.nan
df['c'].update(pd.Series(['foo'], index=[0]))
expected = DataFrame(dict(a=[1, 3], b=[np.nan, 2], c=['foo', np.nan]))
tm.assert_frame_equal(df, expected)
def test_preserveRefs(self):
seq = self.ts[[5, 10, 15]]
seq[1] = np.NaN
self.assertFalse(np.isnan(self.ts[10]))
def test_drop(self):
# unique
s = Series([1, 2], index=['one', 'two'])
expected = Series([1], index=['one'])
result = s.drop(['two'])
assert_series_equal(result, expected)
result = s.drop('two', axis='rows')
assert_series_equal(result, expected)
# non-unique
# GH 5248
s = Series([1, 1, 2], index=['one', 'two', 'one'])
expected = Series([1, 2], index=['one', 'one'])
result = s.drop(['two'], axis=0)
assert_series_equal(result, expected)
result = s.drop('two')
assert_series_equal(result, expected)
expected = Series([1], index=['two'])
result = s.drop(['one'])
assert_series_equal(result, expected)
result = s.drop('one')
assert_series_equal(result, expected)
# single string/tuple-like
s = Series(range(3), index=list('abc'))
self.assertRaises(ValueError, s.drop, 'bc')
self.assertRaises(ValueError, s.drop, ('a', ))
# errors='ignore'
s = Series(range(3), index=list('abc'))
result = s.drop('bc', errors='ignore')
assert_series_equal(result, s)
result = s.drop(['a', 'd'], errors='ignore')
expected = s.ix[1:]
assert_series_equal(result, expected)
# bad axis
self.assertRaises(ValueError, s.drop, 'one', axis='columns')
# GH 8522
s = Series([2, 3], index=[True, False])
self.assertTrue(s.index.is_object())
result = s.drop(True)
expected = Series([3], index=[False])
assert_series_equal(result, expected)
def test_align(self):
def _check_align(a, b, how='left', fill=None):
aa, ab = a.align(b, join=how, fill_value=fill)
join_index = a.index.join(b.index, how=how)
if fill is not None:
diff_a = aa.index.difference(join_index)
diff_b = ab.index.difference(join_index)
if len(diff_a) > 0:
self.assertTrue((aa.reindex(diff_a) == fill).all())
if len(diff_b) > 0:
self.assertTrue((ab.reindex(diff_b) == fill).all())
ea = a.reindex(join_index)
eb = b.reindex(join_index)
if fill is not None:
ea = ea.fillna(fill)
eb = eb.fillna(fill)
assert_series_equal(aa, ea)
assert_series_equal(ab, eb)
self.assertEqual(aa.name, 'ts')
self.assertEqual(ea.name, 'ts')
self.assertEqual(ab.name, 'ts')
self.assertEqual(eb.name, 'ts')
for kind in JOIN_TYPES:
_check_align(self.ts[2:], self.ts[:-5], how=kind)
_check_align(self.ts[2:], self.ts[:-5], how=kind, fill=-1)
# empty left
_check_align(self.ts[:0], self.ts[:-5], how=kind)
_check_align(self.ts[:0], self.ts[:-5], how=kind, fill=-1)
# empty right
_check_align(self.ts[:-5], self.ts[:0], how=kind)
_check_align(self.ts[:-5], self.ts[:0], how=kind, fill=-1)
# both empty
_check_align(self.ts[:0], self.ts[:0], how=kind)
_check_align(self.ts[:0], self.ts[:0], how=kind, fill=-1)
def test_align_fill_method(self):
def _check_align(a, b, how='left', method='pad', limit=None):
aa, ab = a.align(b, join=how, method=method, limit=limit)
join_index = a.index.join(b.index, how=how)
ea = a.reindex(join_index)
eb = b.reindex(join_index)
ea = ea.fillna(method=method, limit=limit)
eb = eb.fillna(method=method, limit=limit)
assert_series_equal(aa, ea)
assert_series_equal(ab, eb)
for kind in JOIN_TYPES:
for meth in ['pad', 'bfill']:
_check_align(self.ts[2:], self.ts[:-5], how=kind, method=meth)
_check_align(self.ts[2:], self.ts[:-5], how=kind, method=meth,
limit=1)
# empty left
_check_align(self.ts[:0], self.ts[:-5], how=kind, method=meth)
_check_align(self.ts[:0], self.ts[:-5], how=kind, method=meth,
limit=1)
# empty right
_check_align(self.ts[:-5], self.ts[:0], how=kind, method=meth)
_check_align(self.ts[:-5], self.ts[:0], how=kind, method=meth,
limit=1)
# both empty
_check_align(self.ts[:0], self.ts[:0], how=kind, method=meth)
_check_align(self.ts[:0], self.ts[:0], how=kind, method=meth,
limit=1)
def test_align_nocopy(self):
b = self.ts[:5].copy()
# do copy
a = self.ts.copy()
ra, _ = a.align(b, join='left')
ra[:5] = 5
self.assertFalse((a[:5] == 5).any())
# do not copy
a = self.ts.copy()
ra, _ = a.align(b, join='left', copy=False)
ra[:5] = 5
self.assertTrue((a[:5] == 5).all())
# do copy
a = self.ts.copy()
b = self.ts[:5].copy()
_, rb = a.align(b, join='right')
rb[:3] = 5
self.assertFalse((b[:3] == 5).any())
# do not copy
a = self.ts.copy()
b = self.ts[:5].copy()
_, rb = a.align(b, join='right', copy=False)
rb[:2] = 5
self.assertTrue((b[:2] == 5).all())
def test_align_sameindex(self):
a, b = self.ts.align(self.ts, copy=False)
self.assertIs(a.index, self.ts.index)
self.assertIs(b.index, self.ts.index)
# a, b = self.ts.align(self.ts, copy=True)
# self.assertIsNot(a.index, self.ts.index)
# self.assertIsNot(b.index, self.ts.index)
def test_align_multiindex(self):
# GH 10665
midx = pd.MultiIndex.from_product([range(2), range(3), range(2)],
names=('a', 'b', 'c'))
idx = pd.Index(range(2), name='b')
s1 = pd.Series(np.arange(12, dtype='int64'), index=midx)
s2 = pd.Series(np.arange(2, dtype='int64'), index=idx)
# these must be the same results (but flipped)
res1l, res1r = s1.align(s2, join='left')
res2l, res2r = s2.align(s1, join='right')
expl = s1
tm.assert_series_equal(expl, res1l)
tm.assert_series_equal(expl, res2r)
expr = pd.Series([0, 0, 1, 1, np.nan, np.nan] * 2, index=midx)
tm.assert_series_equal(expr, res1r)
tm.assert_series_equal(expr, res2l)
res1l, res1r = s1.align(s2, join='right')
res2l, res2r = s2.align(s1, join='left')
exp_idx = pd.MultiIndex.from_product([range(2), range(2), range(2)],
names=('a', 'b', 'c'))
expl = pd.Series([0, 1, 2, 3, 6, 7, 8, 9], index=exp_idx)
tm.assert_series_equal(expl, res1l)
tm.assert_series_equal(expl, res2r)
expr = pd.Series([0, 0, 1, 1] * 2, index=exp_idx)
tm.assert_series_equal(expr, res1r)
tm.assert_series_equal(expr, res2l)
def test_reindex(self):
identity = self.series.reindex(self.series.index)
# __array_interface__ is not defined for older numpies
# and on some pythons
try:
self.assertTrue(np.may_share_memory(self.series.index,
identity.index))
except (AttributeError):
pass
self.assertTrue(identity.index.is_(self.series.index))
self.assertTrue(identity.index.identical(self.series.index))
subIndex = self.series.index[10:20]
subSeries = self.series.reindex(subIndex)
for idx, val in compat.iteritems(subSeries):
self.assertEqual(val, self.series[idx])
subIndex2 = self.ts.index[10:20]
subTS = self.ts.reindex(subIndex2)
for idx, val in compat.iteritems(subTS):
self.assertEqual(val, self.ts[idx])
stuffSeries = self.ts.reindex(subIndex)
self.assertTrue(np.isnan(stuffSeries).all())
# This is extremely important for the Cython code to not screw up
nonContigIndex = self.ts.index[::2]
subNonContig = self.ts.reindex(nonContigIndex)
for idx, val in compat.iteritems(subNonContig):
self.assertEqual(val, self.ts[idx])
# return a copy the same index here
result = self.ts.reindex()
self.assertFalse((result is self.ts))
def test_reindex_nan(self):
ts = Series([2, 3, 5, 7], index=[1, 4, nan, 8])
i, j = [nan, 1, nan, 8, 4, nan], [2, 0, 2, 3, 1, 2]
assert_series_equal(ts.reindex(i), ts.iloc[j])
ts.index = ts.index.astype('object')
# reindex coerces index.dtype to float, loc/iloc doesn't
assert_series_equal(ts.reindex(i), ts.iloc[j], check_index_type=False)
def test_reindex_corner(self):
# (don't forget to fix this) I think it's fixed
self.empty.reindex(self.ts.index, method='pad') # it works
# corner case: pad empty series
reindexed = self.empty.reindex(self.ts.index, method='pad')
# pass non-Index
reindexed = self.ts.reindex(list(self.ts.index))
assert_series_equal(self.ts, reindexed)
# bad fill method
ts = self.ts[::2]
self.assertRaises(Exception, ts.reindex, self.ts.index, method='foo')
def test_reindex_pad(self):
s = Series(np.arange(10), dtype='int64')
s2 = s[::2]
reindexed = s2.reindex(s.index, method='pad')
reindexed2 = s2.reindex(s.index, method='ffill')
assert_series_equal(reindexed, reindexed2)
expected = Series([0, 0, 2, 2, 4, 4, 6, 6, 8, 8], index=np.arange(10))
assert_series_equal(reindexed, expected)
# GH4604
s = Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])
new_index = ['a', 'g', 'c', 'f']
expected = Series([1, 1, 3, 3], index=new_index)
# this changes dtype because the ffill happens after
result = s.reindex(new_index).ffill()
assert_series_equal(result, expected.astype('float64'))
result = s.reindex(new_index).ffill(downcast='infer')
assert_series_equal(result, expected)
expected = Series([1, 5, 3, 5], index=new_index)
result = s.reindex(new_index, method='ffill')
assert_series_equal(result, expected)
# inferrence of new dtype
s = Series([True, False, False, True], index=list('abcd'))
new_index = 'agc'
result = s.reindex(list(new_index)).ffill()
expected = Series([True, True, False], index=list(new_index))
assert_series_equal(result, expected)
# GH4618 shifted series downcasting
s = Series(False, index=lrange(0, 5))
result = s.shift(1).fillna(method='bfill')
expected = Series(False, index=lrange(0, 5))
assert_series_equal(result, expected)
def test_reindex_nearest(self):
s = Series(np.arange(10, dtype='int64'))
target = [0.1, 0.9, 1.5, 2.0]
actual = s.reindex(target, method='nearest')
expected = Series(np.around(target).astype('int64'), target)
assert_series_equal(expected, actual)
actual = s.reindex_like(actual, method='nearest')
assert_series_equal(expected, actual)
actual = s.reindex_like(actual, method='nearest', tolerance=1)
assert_series_equal(expected, actual)
actual = s.reindex(target, method='nearest', tolerance=0.2)
expected = Series([0, 1, np.nan, 2], target)
assert_series_equal(expected, actual)
def test_reindex_backfill(self):
pass
def test_reindex_int(self):
ts = self.ts[::2]
int_ts = Series(np.zeros(len(ts), dtype=int), index=ts.index)
# this should work fine
reindexed_int = int_ts.reindex(self.ts.index)
# if NaNs introduced
self.assertEqual(reindexed_int.dtype, np.float_)
# NO NaNs introduced
reindexed_int = int_ts.reindex(int_ts.index[::2])
self.assertEqual(reindexed_int.dtype, np.int_)
def test_reindex_bool(self):
# A series other than float, int, string, or object
ts = self.ts[::2]
bool_ts = Series(np.zeros(len(ts), dtype=bool), index=ts.index)
# this should work fine
reindexed_bool = bool_ts.reindex(self.ts.index)
# if NaNs introduced
self.assertEqual(reindexed_bool.dtype, np.object_)
# NO NaNs introduced
reindexed_bool = bool_ts.reindex(bool_ts.index[::2])
self.assertEqual(reindexed_bool.dtype, np.bool_)
def test_reindex_bool_pad(self):
# fail
ts = self.ts[5:]
bool_ts = Series(np.zeros(len(ts), dtype=bool), index=ts.index)
filled_bool = bool_ts.reindex(self.ts.index, method='pad')
self.assertTrue(isnull(filled_bool[:5]).all())
def test_reindex_like(self):
other = self.ts[::2]
assert_series_equal(self.ts.reindex(other.index),
self.ts.reindex_like(other))
# GH 7179
day1 = datetime(2013, 3, 5)
day2 = datetime(2013, 5, 5)
day3 = datetime(2014, 3, 5)
series1 = Series([5, None, None], [day1, day2, day3])
series2 = Series([None, None], [day1, day3])
result = series1.reindex_like(series2, method='pad')
expected = Series([5, np.nan], index=[day1, day3])
assert_series_equal(result, expected)
def test_reindex_fill_value(self):
# -----------------------------------------------------------
# floats
floats = Series([1., 2., 3.])
result = floats.reindex([1, 2, 3])
expected = Series([2., 3., np.nan], index=[1, 2, 3])
assert_series_equal(result, expected)
result = floats.reindex([1, 2, 3], fill_value=0)
expected = Series([2., 3., 0], index=[1, 2, 3])
assert_series_equal(result, expected)
# -----------------------------------------------------------
# ints
ints = Series([1, 2, 3])
result = ints.reindex([1, 2, 3])
expected = Series([2., 3., np.nan], index=[1, 2, 3])
assert_series_equal(result, expected)
# don't upcast
result = ints.reindex([1, 2, 3], fill_value=0)
expected = Series([2, 3, 0], index=[1, 2, 3])
self.assertTrue(issubclass(result.dtype.type, np.integer))
assert_series_equal(result, expected)
# -----------------------------------------------------------
# objects
objects = Series([1, 2, 3], dtype=object)
result = objects.reindex([1, 2, 3])
expected = Series([2, 3, np.nan], index=[1, 2, 3], dtype=object)
assert_series_equal(result, expected)
result = objects.reindex([1, 2, 3], fill_value='foo')
expected = Series([2, 3, 'foo'], index=[1, 2, 3], dtype=object)
assert_series_equal(result, expected)
# ------------------------------------------------------------
# bools
bools = Series([True, False, True])
result = bools.reindex([1, 2, 3])
expected = Series([False, True, np.nan], index=[1, 2, 3], dtype=object)
assert_series_equal(result, expected)
result = bools.reindex([1, 2, 3], fill_value=False)
expected = | Series([False, True, False], index=[1, 2, 3]) | pandas.Series |
import numpy as np
import pandas as pd
def fetch_students():
''' Fetches the two dataset csv files and merges it '''
student_mat = pd.read_csv("dataset/student-mat.csv")
student_por = pd.read_csv("dataset/student-por.csv")
students = pd.concat([student_mat, student_por])
return students
def create_data_for_nn(students_dataframe):
input_data = pd.DataFrame()
output_data = pd.DataFrame()
# Input data
# Numerical
# Age
input_data['age'] = pd.Series(
data=students_dataframe['age'].values, index=students_dataframe.index)
# Absences count
input_data['absences'] = pd.Series(
data=students_dataframe['absences'].values, index=students_dataframe.index)
# Family relationship status [bad to good -> 0-1]
input_data['famrel'] = pd.Series(
data=((students_dataframe['famrel'].values - 1) / 4), index=students_dataframe.index)
# Health status [bad to good -> 0-1]
input_data['health'] = pd.Series(
data=((students_dataframe['health'].values - 1) / 4), index=students_dataframe.index)
# Free time after school [0-1]
input_data['freetime'] = pd.Series(
data=((students_dataframe['freetime'].values - 1) / 4), index=students_dataframe.index)
# Going out with friends [0-1]
input_data['goout'] = pd.Series(
data=((students_dataframe['goout'].values - 1) / 4), index=students_dataframe.index)
# Travel time in minutes [0 to 60+ minutes -> 0 to 1]
input_data['traveltime'] = pd.Series(
data=((students_dataframe['traveltime'].values) / 4), index=students_dataframe.index)
# Weekly study time in hours [0 to 10+ hours -> 0 to 1]
input_data['studytime'] = pd.Series(
data=((students_dataframe['studytime'].values) / 4), index=students_dataframe.index)
# Number of past class failures [0 to 4+ failures -> 0 to 1]
input_data['failures'] = pd.Series(
data=((students_dataframe['failures'].values) / 4), index=students_dataframe.index)
# School success [Bad to good -> 0-1]
# Rounded average of the G1, G2 and G3 divided by 20 will be used as school success from 0 to 1
input_data['success'] = pd.Series(data=(students_dataframe['G1'] +
students_dataframe['G2'] +
students_dataframe['G3']) / 3 / 20,
index=students_dataframe.index)
# Mother education status
# [None, Primary education (4th grade), 5th to 9th grade, Secondary education, Higher education]
input_data['Medu_none'] = pd.Series(data=0, index=students_dataframe.index)
input_data['Medu_primary'] = pd.Series(
data=0, index=students_dataframe.index)
input_data['Medu_fivenine'] = pd.Series(
data=0, index=students_dataframe.index)
input_data['Medu_secondary'] = pd.Series(
data=0, index=students_dataframe.index)
input_data['Medu_higher'] = pd.Series(
data=0, index=students_dataframe.index)
input_data.loc[students_dataframe['Medu'] == 0, 'Medu_none'] = 1
input_data.loc[students_dataframe['Medu'] == 1, 'Medu_primary'] = 1
input_data.loc[students_dataframe['Medu'] == 2, 'Medu_fivenine'] = 1
input_data.loc[students_dataframe['Medu'] == 3, 'Medu_secondary'] = 1
input_data.loc[students_dataframe['Medu'] == 4, 'Medu_higher'] = 1
# Father education status
# [None, Primary education (4th grade), 5th to 9th grade, Secondary education, Higher education]
input_data['Fedu_none'] = pd.Series(data=0, index=students_dataframe.index)
input_data['Fedu_primary'] = pd.Series(
data=0, index=students_dataframe.index)
input_data['Fedu_fivenine'] = pd.Series(
data=0, index=students_dataframe.index)
input_data['Fedu_secondary'] = pd.Series(
data=0, index=students_dataframe.index)
input_data['Fedu_higher'] = pd.Series(
data=0, index=students_dataframe.index)
input_data.loc[students_dataframe['Fedu'] == 0, 'Fedu_none'] = 1
input_data.loc[students_dataframe['Fedu'] == 1, 'Fedu_primary'] = 1
input_data.loc[students_dataframe['Fedu'] == 2, 'Fedu_fivenine'] = 1
input_data.loc[students_dataframe['Fedu'] == 3, 'Fedu_secondary'] = 1
input_data.loc[students_dataframe['Fedu'] == 4, 'Fedu_higher'] = 1
# Mother's job
# [Teacher, Health care related, Civil services, At home, Other]
input_data['Mjob_teacher'] = pd.Series(
data=0, index=students_dataframe.index)
input_data['Mjob_health'] = pd.Series(
data=0, index=students_dataframe.index)
input_data['Mjob_civilser'] = pd.Series(
data=0, index=students_dataframe.index)
input_data['Mjob_athome'] = pd.Series(
data=0, index=students_dataframe.index)
input_data['Mjob_other'] = pd.Series(
data=0, index=students_dataframe.index)
input_data.loc[students_dataframe['Mjob'] == 'teacher', 'Mjob_teacher'] = 1
input_data.loc[students_dataframe['Mjob'] == 'health', 'Mjob_health'] = 1
input_data.loc[students_dataframe['Mjob']
== 'services', 'Mjob_civilser'] = 1
input_data.loc[students_dataframe['Mjob'] == 'at_home', 'Mjob_athome'] = 1
input_data.loc[students_dataframe['Mjob'] == 'other', 'Mjob_other'] = 1
# Father's job
# [Teacher, Health care related, Civil services, At home, Other]
input_data['Fjob_teacher'] = pd.Series(
data=0, index=students_dataframe.index)
input_data['Fjob_health'] = pd.Series(
data=0, index=students_dataframe.index)
input_data['Fjob_civilser'] = pd.Series(
data=0, index=students_dataframe.index)
input_data['Fjob_athome'] = pd.Series(
data=0, index=students_dataframe.index)
input_data['Fjob_other'] = pd.Series(
data=0, index=students_dataframe.index)
input_data.loc[students_dataframe['Fjob'] == 'teacher', 'Fjob_teacher'] = 1
input_data.loc[students_dataframe['Fjob'] == 'health', 'Fjob_health'] = 1
input_data.loc[students_dataframe['Fjob']
== 'services', 'Fjob_civilser'] = 1
input_data.loc[students_dataframe['Fjob'] == 'at_home', 'Fjob_athome'] = 1
input_data.loc[students_dataframe['Fjob'] == 'other', 'Fjob_other'] = 1
# Reason to chose this school
# [ Close to home, School reputation, Course preference, Other ]
input_data['reason_closehome'] = pd.Series(
data=0, index=students_dataframe.index)
input_data['reason_rep'] = pd.Series(
data=0, index=students_dataframe.index)
input_data['reason_pref'] = pd.Series(
data=0, index=students_dataframe.index)
input_data['reason_other'] = pd.Series(
data=0, index=students_dataframe.index)
input_data.loc[students_dataframe['reason']
== 'home', 'reason_closehome'] = 1
input_data.loc[students_dataframe['reason']
== 'reputation', 'reason_rep'] = 1
input_data.loc[students_dataframe['reason'] == 'course', 'reason_pref'] = 1
input_data.loc[students_dataframe['reason'] == 'other', 'reason_other'] = 1
# One hot
# Sex [M(Male) = 0, F(Female) = 1]
input_data['sex'] = pd.Series(data=0, index=students_dataframe.index)
input_data.loc[students_dataframe['sex'] == 'F', 'sex'] = 1
# Address [R(Rural) = 0, U(Urban) = 1]
input_data['address'] = | pd.Series(data=0, index=students_dataframe.index) | pandas.Series |
"""
This module will include the guessing advantage implementation.
"""
from math import log, exp, sqrt, inf
from statistics import median
import time
from enum import Enum
from statsmodels.distributions.empirical_distribution import ECDF
import multiprocessing as mp
# import swifter
import numpy as np
import pandas as pd
from itertools import repeat
import os
import glob
import pickle
import gc
from scipy.stats import laplace
# import amun.multiprocessing_helper_functions
# import concurrent.futures
import math
class AggregateType(Enum):
SUM = 1
AVG = 2
MIN = 3
MAX = 4
FREQ= 5
def calculate_epsilon_from_delta(dfg, delta):
# we will eventually have different epsilons for frequency and for time
# we can output two epsilons, or have two different functions
# in any case, it is safe to take the minimum of these epsilons if DP interface takes only one
# for frequencies, we have r = 1
r = 1
# need to learn how to compute these things from dfg format
# for times, we need to compute r as the maximum possible time between two subsequent events
# we can get even better results if:
# 1) we have event log instead of dfg
# 2) we compute a diffrent epsilon for different edges of dfg
# r = ....
p = (1 - delta) / 2
epsilon = - log(p / (1 - p) * (1 / (delta + p) - 1)) / log(exp(1)) * (1 / r)
return epsilon
def calculate_epsilon_freq(dfg, delta):
sens = 1.0
p = (1.0 - delta) / 2.0
R_ij = 1.0 # from the discussion with Alisa
epsilon = - log(p / (1.0 - p) * (1.0 / (delta + p) - 1)) / log(exp(1.0)) * (1.0 / R_ij)
return epsilon, sens
def calculate_epsilon_time(dfg, delta, precision, aggregate_type):
epsilon = {}
sens = 1
n = 1 # length of the database
""" calculating sensitivity based on type of aggregate"""
if aggregate_type == AggregateType.AVG:
sens = 1 / n
elif aggregate_type == AggregateType.MAX or aggregate_type == AggregateType.MIN or aggregate_type == AggregateType.SUM:
sens = 1
else:
assert "Wrong aggregate type"
"""************parallel by edge******************"""
p = mp.Pool(mp.cpu_count())
result = p.starmap(calculate_epsilon_per_pair, zip(dfg.values(), repeat(delta), repeat(precision)))
p.close()
p.join()
epsilon = dict(zip(list(dfg.keys()), result))
return epsilon, sens
def calculate_epsilon_time_parallel(dfg, delta, precision, aggregate_type):
epsilon = {}
sens = 1
n = 1 # length of the database
""" calculating sensitivity based on type of aggregate"""
if aggregate_type == AggregateType.AVG:
sens = 1 / n
elif aggregate_type == AggregateType.MAX or aggregate_type == AggregateType.MIN or aggregate_type == AggregateType.SUM:
sens = 1
else:
assert "Wrong aggregate type"
"""************parallel by edge******************"""
p = mp.Pool(mp.cpu_count())
result = p.starmap(calculate_epsilon_per_pair_parallel, zip(dfg.values(), repeat(delta), repeat(precision)))
epsilon = dict(zip(list(dfg.keys()), list(result)))
p.close()
p.join()
return epsilon, sens
def calculate_epsilon_per_pair(values, delta, precision):
# values = [0.0, 0.2, .4, .6, .7, 10, 20, 100, 400, 500, 1000, 2000]
values =list(map(abs, values))
values = sorted(values)
R_ij = max(values)
epsilons = []
r_ij = R_ij * precision
cdf = ECDF(values)
epsilon = inf
flag = 1
prev = values[0]
for i in values:
if i != prev:
flag = 0
prev = i
if not flag:
for t_k in values:
p_k = calculate_cdf(cdf, t_k + r_ij) - calculate_cdf(cdf, t_k - r_ij)
# covering the case with risk less than or equal 1-p_k
if not (round(1 - p_k, 2) <= delta): # the round is for very small differences, like 0.050000000000000044
eps = - log(p_k / (1.0 - p_k) * (1.0 / (delta + p_k) - 1.0)) / log(exp(1.0)) * (1.0 / R_ij)
# eps= -(log( (1-p_k)/p_k * (1/(delta*p_k) -1) )) /(R_ij)
epsilons.append(eps)
else:
epsilons.append(inf)
if len(epsilons) > 0:
epsilon = min(epsilons)
else:
# fix the ECDF when all the values are equal.
# after the discussion, we decided to let the user know about that issue and maybe has can handle it on his own.
# epsilon=-inf
epsilon = inf
return epsilon
def calculate_epsilon_per_pair_parallel(values, delta, precision):
# values = [0.0, 0.2, .4, .6, .7, 10, 20, 100, 400, 500, 1000, 2000]
values =list(map(abs, values))
values = sorted(values)
R_ij = max(values)
epsilons = []
r_ij = R_ij * precision
cdf = ECDF(values)
epsilon = inf
flag = 1
prev = values[0]
for i in values:
if i != prev:
flag = 0
prev = i
if not flag:
for t_k in values:
p_k = calculate_cdf(cdf, t_k + r_ij) - calculate_cdf(cdf, t_k - r_ij)
# covering the case with risk less than or equal 1-p_k
if not (round(1 - p_k, 2) <= delta): # the round is for very small differences, like 0.050000000000000044
eps = - log(p_k / (1.0 - p_k) * (1.0 / (delta + p_k) - 1.0)) / log(exp(1.0)) * (1.0 / R_ij)
epsilons.append(eps)
else:
epsilons.append(inf)
if len(epsilons) > 0:
epsilon = min(epsilons)
else:
# fix the ECDF when all the values are equal.
# after the discussion, we decided to let the user know about that issue and maybe has can handle it on his own.
# epsilon=-inf
epsilon = inf
return epsilon
def calculate_epsilon_from_distance_time(dfg_time, distance, precision, aggregate_type=AggregateType.SUM):
beta = 0.05
# reflect the new equation of delta for the time per time instance. Then take the maximum delta from all the instances.
sens_time = 1
""" calculating sensitivity based on type of aggregate"""
if aggregate_type == AggregateType.AVG:
sens_time = 1 / len(dfg_time[0])
elif aggregate_type == AggregateType.MAX or aggregate_type == AggregateType.MIN or aggregate_type == AggregateType.SUM:
sens_time = 1
else:
assert "Wrong aggregate type"
# calculate epsilon
# the equation to be calculated per instance first as p is different from frequency.
epsilon_time = sens_time / distance * log(1 / beta)
# Calculate delta ( the risk) from guessing advantage equation
delta_time = []
delta_dfg = {}
for x in dfg_time.keys():
delta_edge = []
R_ij = max(dfg_time[x])
r_ij = R_ij * precision
# fix the case of time is fixed
flag = 1
prev = dfg_time[x][0]
current = dfg_time[x]
for t_k in dfg_time[x]:
# fix the case of time is fixed
if t_k != prev:
flag = 0
prev = t_k
cdf = ECDF(dfg_time[x])
# p_k is calculated for every instance.
cdf1 = calculate_cdf(cdf, t_k + r_ij)
cdf2 = calculate_cdf(cdf, t_k - r_ij)
p_k = cdf1 - cdf2
# current_delta = p_k*( 1/( (1-p_k) * exp(-R_ij * epsilon_time) +p_k) -1)
current_delta = (p_k / ((1 - p_k) * exp(-R_ij * epsilon_time) + p_k)) - p_k
# eps = - log(p_k / (1.0 - p_k) * (1.0 / (current_delta + p_k) - 1.0)) / log(exp(1.0)) * (1.0 / R_ij)
# we append the deltas and take the maximum delta out of them
# if current_delta != float.nan:
delta_edge.append(current_delta)
if current_delta != 0:
delta_time.append(current_delta)
delta_dfg[x] = max(delta_edge)
if len(delta_time) > 0:
delta_time = median(delta_time)
delta_time = median(delta_dfg.values())
return epsilon_time, delta_time, delta_dfg
def calculate_cdf(cdf, val):
cur_idx = 0
for idx, i in enumerate(cdf.x[:-1]):
if val > i:
cur_idx += 1
if val < cdf.x[idx + 1]:
cur_idx -= 1
break
return cdf.y[cur_idx]
def calculate_epsilon_from_distance_time_percentage_distance(dfg_time, distance, precision, aggregate_type=AggregateType.SUM):
beta = 0.05
# reflect the new equation of delta for the time per time instance. Then take the maximum delta from all the
# instances.
sens_time = 1
""" calculating sensitivity based on type of aggregate"""
if aggregate_type == AggregateType.AVG:
sens_time = 1 / len(dfg_time.keys())
elif aggregate_type == AggregateType.MAX or aggregate_type == AggregateType.MIN or aggregate_type == AggregateType.SUM:
sens_time = 1
else:
assert "Wrong aggregate type"
# m is the number of edges
m = len(dfg_time.keys())
# calculating R among all the edges
R = 0
for x in dfg_time.keys():
R = R + max(dfg_time[x])
# Calculate delta ( the risk) from guessing advantage equation
delta_time = []
delta_dfg = {}
epsilon_time = {}
delta_per_event=[]
"""************parallel by edge******************"""
""" Current slurm Bottleneck"""
p = mp.Pool(mp.cpu_count())
result = p.starmap(epsilon_time_from_distance,
zip(dfg_time.values(), repeat(aggregate_type), repeat(beta), repeat(distance), repeat(precision),
repeat(sens_time)))
p.close()
p.join()
delta_dfg = dict(zip(list(dfg_time.keys()), [x[0] for x in result]))
keys = list(dfg_time.keys())
for idx, res in enumerate(result):
delta_edge, delta_per_event_inner, delta_time_inner, epsilon_time_inner = res
key = keys[idx]
epsilon_time[key] = epsilon_time_inner
delta_time = delta_time + delta_time_inner
delta_per_event_inner = list(map(lambda i: [key, i], delta_per_event_inner))
delta_per_event = delta_per_event + delta_per_event_inner
delta_dfg[key] = max(delta_edge)
if len(delta_time) > 0:
delta_time = max(delta_time)
delta_time = median(delta_dfg.values())
return epsilon_time, delta_time, delta_dfg, delta_per_event
def epsilon_time_from_distance(dfg_time_inner, aggregate_type, beta, distance,
precision, sens_time):
delta_time_inner = []
delta_edge = []
delta_per_event = []
R_ij = max(dfg_time_inner)
r_ij = R_ij * precision
accurate_result = 0
# calculating the accurate result
if aggregate_type == AggregateType.AVG:
accurate_result = sum(dfg_time_inner) * 1.0 / len(dfg_time_inner)
elif aggregate_type == AggregateType.SUM:
accurate_result = sum(dfg_time_inner) * 1.0
elif aggregate_type == AggregateType.MIN:
accurate_result = min(dfg_time_inner) * 1.0
elif aggregate_type == AggregateType.MAX:
accurate_result = max(dfg_time_inner) * 1.0
# in case of the time is instant, we set epsilon to avoid the error of division by zero
if accurate_result == 0:
epsilon_time_ij = 1
else:
distance_ij = accurate_result * distance # hence distance is between 0 and 1
# calculate epsilon
epsilon_time_ij = sens_time / distance_ij * log(1 / beta)
epsilon_time_inner = epsilon_time_ij
# fix the case of time is fixed
flag = 1
prev = dfg_time_inner[0]
current = dfg_time_inner
for t_k in dfg_time_inner:
# fix the case of time is fixed
if t_k != prev:
flag = 0
prev = t_k
cdf = ECDF(dfg_time_inner)
# p_k is calculated for every instance.
cdf1 = calculate_cdf(cdf, t_k + r_ij)
cdf2 = calculate_cdf(cdf, t_k - r_ij)
p_k = cdf1 - cdf2
# current_delta = p_k*( 1/( (1-p_k) * exp(-R_ij * epsilon_time) +p_k) -1)
current_delta = (p_k / ((1 - p_k) * exp(-R_ij * epsilon_time_ij) + p_k)) - p_k
# eps = - log(p_k / (1.0 - p_k) * (1.0 / (current_delta + p_k) - 1.0)) / log(exp(1.0)) * (1.0 / R_ij)
# we append the deltas and take the maximum delta out of them
# if current_delta != float.nan:
delta_edge.append(current_delta)
# delta_per_event.append([x, current_delta])
delta_per_event.append(current_delta) # *****************!!!!!!!!!!!! changed
if current_delta != 0:
delta_time_inner.append(current_delta)
return delta_edge, delta_per_event, delta_time_inner, epsilon_time_inner
def calculate_epsilon_from_distance_freq_percentage_distances(dfg_freq, distance_percentage):
beta = 0.01
sens_freq = 1
# for frequencies, we have r = 1
r_freq = 1
delta_dfg = {}
epsilon_dfg = {}
p = mp.Pool(mp.cpu_count())
result = p.starmap(epsilon_freq_from_distance,
zip(dfg_freq.values(), repeat(beta), repeat(distance_percentage), repeat(sens_freq)))
p.close()
p.join()
delta_dfg = dict(zip(list(dfg_freq.keys()), [x[0] for x in result]))
epsilon_dfg = dict(zip(list(dfg_freq.keys()), [x[1] for x in result]))
delta_freq = max(list(delta_dfg.values()))
return epsilon_dfg, delta_dfg, delta_freq
def epsilon_freq_from_distance(dfg_freq_inner, beta, distance_percentage, sens_freq):
distance = distance_percentage * dfg_freq_inner
epsilon_freq = sens_freq / distance * log(1 / beta)
epsilon_dfg_inner = epsilon_freq
# Calculate delta ( the risk) from guessing advantage equation
# the following equation is validated by calculations
delta_freq = (1 - sqrt(exp(- epsilon_freq))) / (1 + sqrt(exp(- epsilon_freq)))
return delta_freq, epsilon_dfg_inner
def calculate_cdf_vectorized(data):
cdf, val=data.relative_time_ecdf,data.val_plus
cur_idx = 0
for idx, i in enumerate(cdf.x[:-1]):
if val > i:
cur_idx += 1
if val < cdf.x[idx + 1]:
cur_idx -= 1
break
return cdf.y[cur_idx]
def estimate_epsilon_risk_vectorized(data, delta, precision,tmp_dir):
# NOTE: in the current version, there are no fixed time values.
# Becuase the starting time now is being anonymized.
data_state_max = data.groupby('state').relative_time.max()
data_state_max['state'] = data_state_max.index
# data= pd.merge(data, data_cdf, on=['state'], suffixes=("","_ecdf"))
data = pd.merge(data, data_state_max, on=['state'], suffixes=("", "_max"))
#calculate cdfs in vectorized manner
data['r_ij']=data['relative_time_max']*precision
data['val_plus']=data['relative_time'] + data['r_ij']
data['val_minus'] = data['relative_time'] - data['r_ij']
data.drop(['r_ij'], inplace=True, axis=1)
# data['cdf_plus']=np.vectorize(calculate_cdf)(data.relative_time_ecdf,data.val_plus)
# data['cdf_minus'] = np.vectorize(calculate_cdf)(data.relative_time_ecdf, data.val_minus)
#optimize calculate cdf function
"""
CDF calculation using pandas
https://stackoverflow.com/questions/25577352/plotting-cdf-of-a-pandas-series-in-python
"""
# data['cdf_plus'] = data[['relative_time_ecdf','val_plus']].swifter.apply(lambda x: calculate_cdf(x.relative_time_ecdf,x.val_plus),axis=1)
# data['cdf_minus'] = data[['relative_time_ecdf', 'val_minus']].swifter.apply(
# lambda x: calculate_cdf(x.relative_time_ecdf, x.val_minus), axis=1)
#state, relative_time
stats_df = data.groupby(['state', 'relative_time'])['relative_time'].agg('count').pipe(pd.DataFrame).rename(
columns={'relative_time': 'frequency'})
# PDF
stats_df['pdf'] = stats_df['frequency'] / stats_df.groupby(['state']).frequency.sum()
# CDF
stats_df['cdf'] = stats_df['pdf'].groupby(['state']).cumsum()
stats_df = stats_df.reset_index()
stats_df.drop(['pdf'], inplace=True, axis=1)
#the plus_and_minus works like a value lookup
plus_and_minus=data.groupby(['state', 'relative_time','val_plus','val_minus']).state.agg('count').pipe(pd.DataFrame)\
.drop('state',axis=1)\
.reset_index()
#calculating CDF of the value + r_ij
# temp = stats_df[['state', 'relative_time', 'cdf']].merge(plus_and_minus[['state', 'val_plus']], how='cross',
# suffixes=("", "_right"))
# temp = temp.loc[
# (temp.state == temp.state_right) & (temp.val_plus >= temp.relative_time), ['state','relative_time', 'val_plus', 'cdf']]\
# .groupby(['state', 'val_plus']).cdf.max().reset_index()
stats_df=stats_df[['state', 'relative_time', 'cdf']]
# print("fix memory part")
#fixing memory issues
data.to_pickle('data.p')
del(data)
# stats_df.to_pickle('stats_df.p')
""" ********* Performing chunking join **********"""
# we use chunks to avoid running out of memory for large event logs
# stats_df.to_csv('stats_df.csv',index=False, header=True, float_format='%.15f', compression='gzip', encoding='utf-8')
# stats_df_cols=stats_df.columns
chunk_size=10000 # number of states per chunk
#the problem is the first state all cases go through it.
no_of_chunks, max_large_state=partitioning_df(stats_df,plus_and_minus,tmp_dir,chunk_size)
# print("Partitioning Done")
del(stats_df)
del(plus_and_minus)
gc.collect()
chunck_join(no_of_chunks,max_large_state,tmp_dir)
# del(plus_and_minus)
#loading data back from hard disk
data=pd.read_pickle('data.p')
#appending cdf
cdf=append_cdf(tmp_dir,1)
# add the first cdf values to the dataframe
data = data.merge(cdf, how='left', on=['state', 'relative_time'], suffixes=("", "_right"))
data.drop(['val_plus'], inplace=True, axis=1)
del(cdf)
#appending cdf2
cdf2=append_cdf(tmp_dir,2)
# add the values to the dataframe
data = data.merge(cdf2, how='left', on=['state', 'relative_time'], suffixes=("", "_right"))
del(cdf2)
# the minimum value of each distirubtion drops due to the condition "temp.val_minus >= temp.relative_time"
# to fix that, we perform left join and replace the nans with zeros which means that the CDF of a value that is lower than
# the minimum is zero
data.cdf_minus=data.cdf_minus.fillna(0)
# and the maximum is 1
data.cdf_plus = data.cdf_plus.fillna(1)
# print("Second CDF done")
# data= data.merge(cdf, how='left', on=['state','relative_time'], suffixes=("","_right"))
# print(cdf[['state','relative_time']])
# print(data.loc[data.cdf_plus.isna(), ['state','relative_time']])
# data['cdf_minus'] = data[['relative_time_ecdf', 'val_minus']].swifter.apply(calculate_cdf_vectorized,axis=1)
#calculate p_k in a vectorized manner
data['p_k'] = data.cdf_plus - data.cdf_minus
#calculate epsilon in a vectorized manner
# data['eps'] = - np.log(data.p_k / (1.0 - data.p_k) * (1.0 / (delta + data.p_k) - 1.0))/ log(exp(1.0))* (1.0 / data.relative_time_max)
data['eps'] = - np.log(data.p_k / (1.0 - data.p_k) * (1.0 / (delta + data.p_k) - 1.0))
data['eps']=data['eps']/ log(exp(1.0))
data['eps'] = data['eps']* (1.0 / data.relative_time_max.replace(0,-inf))
#drop unused columns
data.drop(['p_k','cdf_plus','cdf_minus','val_minus','relative_time_max'], inplace=True, axis=1)
# data.drop('case:concept:name_linker',inplace=True,axis=1)
# data['eps'] = data.swifter.apply(
# lambda x: estimate_epsilon_risk_dataframe(x['relative_time'], x['relative_time_ecdf'], x['relative_time_max'],
# delta, precision), axis=1)
return data
def get_noise_case_variant(delta):
p=(1-delta)/2.0
eps=- np.log(p / (1.0 - p) * (1.0 / (delta + p) - 1.0))
sens_time = 1
noise = laplace.rvs(loc=0, scale=sens_time / eps, size=1)[0]
noise = int(math.ceil(abs(noise)))
print("case variant noise: %s"%(noise))
return noise,eps
def normalize_relative_time(data):
if data['relative_time_min']==data['relative_time_max']:
#return 1 in case of equal values, that will help to extract the noise value later
return 1
return (data['relative_time']-data['relative_time_min'])/(data['relative_time_max']-data['relative_time_min'])
def match_vals(row, cumsum):
# cdf=float(cumsum[cumsum.index==row['relative_time']])
#cdf plus
# val_plus= row['relative_time']+precision
# group_cdf=cumsum.loc[(row['prev_state'], row['concept:name'], row['state']),['relative_time','cdf']]
group_cdf = cumsum.loc[(row['prev_state'], row['concept:name'], row['state']),['cdf']]
# t1 = group_cdf.loc[group_cdf.index <= row['val_plus']]
# cdf_plus=float(t1.iloc[-1][0])
if row['val_plus']>=1:
cdf_plus=1.0
else:
cdf_plus=group_cdf.loc[group_cdf.index <= row['val_plus']]
cdf_plus = float(cdf_plus.iloc[-1][0])
# cdf_plus=float(group_cdf[group_cdf.relative_time <= row['val_plus']].cdf.max())
#cdf minus
# val_minus = row['relative_time'] - precision
if row['val_minus'] <= 0:
cdf_minus = 0.0
else:
# query=group_cdf[group_cdf.relative_time <= row['val_minus']]
query=group_cdf.loc[group_cdf.index <= row['val_minus']]
if query.shape[0]==0:
#in case the val_minus is lower than the minimum value but greater than zero
cdf_minus=0
else:
cdf_minus = float(query.iloc[-1][0])
# cdf_minus = float(query.cdf.max())
# if cdf_minus==nan:
# cdf_minus===0
return [ cdf_plus, cdf_minus]
def estimate_epsilon_risk_vectorized_with_normalization(data,mode, delta, tmp_dir):
# NOTE: in the current version, there are no fixed time values.
# Becuase the starting time now is being anonymized.
# We estimate the min and max values for the normalization
data['relative_time_max'] = data.groupby(['prev_state','concept:name','state'])['relative_time'].transform('max')
data['relative_time_min'] = data.groupby(['prev_state','concept:name','state'])['relative_time'].transform('min')
# perform normalization (scaling the values between 0 and 1, we use min max method
data['relative_time_original']=data['relative_time']
data['relative_time']= data[['relative_time','relative_time_min', 'relative_time_max']].apply(normalize_relative_time, axis=1)
data=estimate_P_k(data, delta,tmp_dir)
#calculate epsilon in a vectorized manner
# handle p_k+delta >1
if mode=='filtering':
"""**************** Filtering ****************"""
'''delete records with prior knowledge + delta >=1'''
# cases_to_delete = data.loc[data.p_k==1]['case:concept:name'].unique()
cases_to_delete = data.loc[data.p_k+delta >= 1]['case:concept:name'].unique()
#if the resulted event log is empty filter only p_k==1
# this case happens only in the Credit Requirement.
if data['case:concept:name'].unique().shape[0]== cases_to_delete.shape[0]:
cases_to_delete = data.loc[data.p_k == 1]['case:concept:name'].unique()
data = data[~data['case:concept:name'].isin(cases_to_delete)]
data = data.reset_index(drop=True)
data = estimate_P_k(data, delta, tmp_dir)
"""******************************************"""
data['eps'] =data.apply(epsilon_vectorized_internal,delta=delta, axis=1)
#drop unused columns
# we keep the max and min to denormalize the values
data.drop([ 'cdf_plus', 'cdf_minus', 'val_minus','val_plus'], inplace=True, axis=1)
return data
def estimate_P_k(data, delta,tmp_dir):
# calculate cdfs in vectorized manner
"""for the normalized input, the r_ij equals 1"""
# The range became +/- precision as r_ij =1
# data['val_plus']=data['relative_time'] + precision
# data['val_minus'] = data['relative_time'] - precision
"""Estimate precision as one per unit time"""
# precision = 10 * 1 *(data['relative_time_max'] - data['relative_time_min'])/ (
# data['relative_time_max'] - data['relative_time_min'])**2 # within 10 minutes and time unit is in minutes
# #nans happens when max=min
# precision = precision.fillna(0)
data['precision'] = 10 * 1* (data['relative_time_max'] - data['relative_time_min']) / (data['relative_time_max'] - data['relative_time_min'])**2
data.precision = data.precision.fillna(0)
# precision >max becomes 1
data['precision'].loc[data.precision > 1] = 1
# normalize precision
# precision = (precision - data['relative_time_min']) / (data['relative_time_max'] - data['relative_time_min'])
# precision = (precision ) / (data['relative_time_max'] - data['relative_time_min'])
data['val_plus'] = data['relative_time'] + data['precision']
data['val_plus']=data.val_plus.replace(inf,1)
data['val_plus'].loc[data.val_plus > 1] = 1
data['val_minus'] = data['relative_time'] - data['precision']
data['val_minus'] = data.val_minus.replace(-inf, 0)
data['val_minus'].loc[data.val_minus<0]=0
# #no cdf below zero, so we replace -ve values with zeros
# # no cdf greater than 1, so we replace values >1 with 1
# optimize calculate cdf function
# start partitioning here
data=estimate_CDF_paritioned(data, tmp_dir)
# calculate p_k in a vectorized manner
data['p_k'] = 0
# adding a fix to the case of fixed distrubtion
data['p_k'] = data.apply(estimate_P_k_vectorized, delta=delta, axis=1)
data.drop('original_index',inplace=True, axis=1)
return data
def estimate_CDF_paritioned(data, tmp_dir, chunk_size = 1000):
""" the first state for large files is very large. We split the first state in a separate file.
Then all the other states are splitted into several files.
"""
# stats_df.to_csv('stats_df.csv', index=False, header=True, float_format='%.15f', compression='gzip',
# encoding='utf-8')
data=data.reset_index()
data=data.rename(columns={'index': 'original_index'})
data.to_pickle(os.path.join(tmp_dir, 'data_df_all'))
no_of_chunks, max_large_state = partition_eventlog(chunk_size, data, tmp_dir)
del data
# iterate over every partition
cdf_plus, cdf_minus=estimate_CDF_with_partitioning(no_of_chunks, max_large_state, tmp_dir)
# read data back from the pickle file
data=pd.read_pickle(os.path.join(tmp_dir, 'data_df_all'))
data['cdf_plus'] = cdf_plus
data['cdf_minus'] = cdf_minus
# return len(list(range(0, unique_states.shape[0], chunk_size))) #number of chunks
return data # number of chunks , max largest state
def partition_eventlog(chunk_size, data, tmp_dir):
large_state_size=1000
data.sort_values(['prev_state', 'concept:name', 'state'], ascending=True, inplace=True)
# unique_states = stats_df.state.unique()
# unique_states = data.groupby(['prev_state', 'concept:name', 'state']).size().reset_index().rename(
# columns={0: 'count'}).drop('count', axis=1)
unique_states = data.groupby(['prev_state', 'concept:name', 'state']).original_index.apply(list)
large_states = data.groupby(['prev_state', 'concept:name', 'state']).relative_time.count()
# separating large states from the others
small_states = list(large_states.loc[large_states <= large_state_size].index)
large_states = large_states.reset_index().rename(columns={'relative_time': 'counts'})
large_states = large_states[large_states.counts > large_state_size].reset_index()
unique_states = unique_states.loc[small_states]
# unique_states = unique_states.reset_index()
# unique_states = unique_states.loc[small_states]
unique_states=unique_states.reset_index()
# ['prev_state', 'concept:name', 'state']
curr_dir = os.getcwd()
idx = 0
"""large state separately"""
for index, row in large_states.iterrows():
res = data.loc[(data.state == row['state']) & (data.prev_state == row['prev_state']) & (
data['concept:name'] == row['concept:name']), :]
res.to_pickle(os.path.join(tmp_dir, 'data_df_%s' % (idx)))
# row_id = unique_states.index[
# (unique_states.state == row['state']) & (unique_states.prev_state == row['prev_state']) & (
# unique_states['concept:name'] == row['concept:name'])].tolist()[0]
# unique_states.drop(row_id, axis=0, inplace=True)
idx += 1
""" splitting other states regularly"""
max_index_of_large_states = idx
# print("partition of large states is %s"%(max_index_of_large_states-1))
for i in range(0, unique_states.shape[0], chunk_size):
# print("Current Chunck is: %s" % (i))
current_states = unique_states.loc[i:i + chunk_size-1,'original_index']
current_states = current_states.apply(pd.Series).stack().reset_index(drop=True)
# res = stats_df.loc[stats_df.state.isin(current_states), :]
# res = data.iloc[current_states.index]
current_states = current_states.astype('int32')
res = data.loc[current_states]
# res = data.iloc[current_states]
res.to_pickle(os.path.join(tmp_dir, 'data_df_%s' % (idx)))
# plus_and_minus.loc[plus_and_minus.state.isin(current_states), :]\
# .to_pickle(os.path.join( tmp_dir,'plus_and_minus_%s'%(idx)))
idx += 1
return idx, max_index_of_large_states
def estimate_CDF_with_partitioning(num_of_chunks, max_large_state, tmp_dir):
cdf_plus_combined=pd.Series()
cdf_minus_combined = pd.Series()
cdf_plus_lst=[]
for i in range(0,num_of_chunks):
data=pd.read_pickle(os.path.join( tmp_dir, 'data_df_%s' % (i)))
data=data[['original_index','prev_state', 'concept:name', 'state', 'relative_time','val_plus','val_minus']]
#the first state is large, so we separate it from the others
if i<max_large_state:
#single state partitions
cdf_minus, cdf_plus = estimate_CDF_per_partition_single_transition(data)
# print("*")
# chunk_merge_plus_single_large_state(stats_df,plus_and_minus,i,tmp_dir)
else:
#multiple states partitions
cdf_minus, cdf_plus = estimate_CDF_per_partition(data)
# chunk_merge_plus(stats_df,plus_and_minus,i,tmp_dir)
# store the cdf and keep the same index as the the orignial data
cdf_plus_combined= cdf_plus_combined.append(cdf_plus)
cdf_minus_combined= cdf_minus_combined.append(cdf_minus)
cdf_plus_lst.append(cdf_plus)
return cdf_plus_combined, cdf_minus_combined
def estimate_CDF_per_partition(data):
stats_df = data.groupby(['prev_state', 'concept:name', 'state', 'relative_time'])['relative_time'].agg(
'count').pipe(pd.DataFrame).rename(
columns={'relative_time': 'frequency'})
# PDF
stats_df['pdf'] = stats_df['frequency'] / stats_df.groupby(['prev_state', 'concept:name', 'state']).frequency.sum()
""" CDF plus"""
stats_df['cdf'] = stats_df['pdf'].groupby(['prev_state', 'concept:name', 'state']).cumsum()
temp = data[['prev_state', 'concept:name', 'state', 'relative_time', 'val_plus']]
stats_df = stats_df[['cdf']]
stats_df = stats_df.reset_index()
temp = temp.merge(stats_df, how='inner', on=['prev_state', 'concept:name', 'state'],
suffixes=("", "_right"))
temp = temp.loc[temp.val_plus >= temp.relative_time_right]
temp = temp.groupby(['prev_state', 'concept:name', 'state', 'relative_time', 'val_plus']).cdf.max().reset_index()
#reseting the data index to keep it the same after merge
data=data.reset_index()
t_join = data.merge(temp, on=['prev_state', 'concept:name', 'state', 'relative_time'], how='left')
#reindexing the t_join dataframe with the original data index
t_join=t_join.set_index('index')
cdf_plus = t_join.cdf
"""CDF minus"""
temp = data[['prev_state', 'concept:name', 'state', 'relative_time', 'val_minus']]
temp = temp.merge(stats_df, how='inner', on=['prev_state', 'concept:name', 'state'],
suffixes=("", "_right"))
# negative values
temp.loc[temp.val_minus < 0, 'val_minus'] = 0
temp = temp.loc[temp.val_minus >= temp.relative_time_right]
temp = temp.groupby(['prev_state', 'concept:name', 'state', 'relative_time', 'val_minus']).cdf.max().reset_index()
#reseting the data index to keep it the same after merge
data=data.reset_index()
t_join = data.merge(temp, on=['prev_state', 'concept:name', 'state', 'relative_time'], how='left')
# reindexing the t_join dataframe with the original data index
t_join = t_join.set_index('index')
cdf_minus = t_join.cdf
cdf_minus = cdf_minus.fillna(0)
return cdf_minus, cdf_plus
# def estimate_CDF_per_partition_single_transition(data):
# stats_df = data.groupby(['prev_state', 'concept:name', 'state', 'relative_time'])['relative_time'].agg(
# 'count').pipe(pd.DataFrame).rename(
# columns={'relative_time': 'frequency'})
# # stats_df = data.groupby(['relative_time'])['relative_time'].agg(
# # 'count').pipe(pd.DataFrame).rename(
# # columns={'relative_time': 'frequency'})
# # PDF
# stats_df['pdf'] = stats_df['frequency'] / stats_df.groupby(['prev_state', 'concept:name', 'state']).frequency.sum()
# # stats_df['pdf'] = stats_df['frequency'] / stats_df.frequency.sum()
# """ CDF plus"""
# # stats_df['cdf'] = stats_df['pdf'].groupby(['prev_state', 'concept:name', 'state']).cumsum()
# stats_df['cdf'] = stats_df['pdf'].cumsum()
#
# temp = data[['prev_state', 'concept:name', 'state', 'relative_time', 'val_plus']]
# stats_df = stats_df[['cdf']]
# stats_df = stats_df.reset_index()
#
# # fix the below error (memory)
# temp = temp.merge(stats_df, how='inner', on=['prev_state', 'concept:name', 'state'],
# suffixes=("", "_right"))
# temp = temp.loc[temp.val_plus >= temp.relative_time_right]
# temp = temp.groupby(['prev_state', 'concept:name', 'state', 'relative_time', 'val_plus']).cdf.max().reset_index()
#
# #reseting the data index to keep it the same after merge
# data=data.reset_index()
# t_join = data.merge(temp, on=['prev_state', 'concept:name', 'state', 'relative_time'], how='left')
# #reindexing the t_join dataframe with the original data index
# t_join=t_join.set_index('index')
#
# cdf_plus = t_join.cdf
#
# """CDF minus"""
# temp = data[['prev_state', 'concept:name', 'state', 'relative_time', 'val_minus']]
# temp = temp.merge(stats_df, how='inner', on=['prev_state', 'concept:name', 'state'],
# suffixes=("", "_right"))
# # negative values
# temp.loc[temp.val_minus < 0, 'val_minus'] = 0
# temp = temp.loc[temp.val_minus >= temp.relative_time_right]
# temp = temp.groupby(['prev_state', 'concept:name', 'state', 'relative_time', 'val_minus']).cdf.max().reset_index()
#
# #reseting the data index to keep it the same after merge
# data=data.reset_index()
#
# t_join = data.merge(temp, on=['prev_state', 'concept:name', 'state', 'relative_time'], how='left')
#
# # reindexing the t_join dataframe with the original data index
# t_join = t_join.set_index('index')
#
# cdf_minus = t_join.cdf
# cdf_minus = cdf_minus.fillna(0)
#
# return cdf_minus, cdf_plus
def estimate_CDF_per_partition_single_transition(data):
#here we don't need to group by 'prev_state', 'concept:name', 'state'
stats_df = data.groupby(['prev_state', 'concept:name', 'state', 'relative_time'])['relative_time'].agg(
'count').pipe(pd.DataFrame).rename(
columns={'relative_time': 'frequency'})
# PDF
stats_df['pdf'] = stats_df['frequency'] / stats_df.groupby(['prev_state', 'concept:name', 'state']).frequency.sum()
stats_df['cdf'] = stats_df['pdf'].groupby(['prev_state', 'concept:name', 'state']).cumsum()
stats_df = stats_df[['cdf']]
stats_df = stats_df.reset_index()
cdf_plus = cdf_plus_single_state(data, stats_df)
cdf_minus = cdf_minus_single_state(data, stats_df)
return cdf_minus, cdf_plus
def cdf_minus_single_state(data, stats_df):
"""CDF minus"""
temp = data[['original_index','prev_state', 'concept:name', 'state', 'relative_time', 'val_minus']]
# negative values
temp.loc[temp.val_minus < 0, 'val_minus'] = 0
#todo: replicate the above.
# temp = temp.merge(stats_df, how='inner', on=['prev_state', 'concept:name', 'state'],
# suffixes=("", "_right"))
# temp = temp.loc[temp.val_minus >= temp.relative_time_right]
stats_df.state = stats_df.state.astype('int32')
stats_df.prev_state = stats_df.prev_state.astype('int32')
temp.sort_values('val_minus', inplace=True)
stats_df.sort_values('relative_time', inplace=True)
temp = pd.merge_asof(temp, stats_df, left_on='val_minus', right_on='relative_time',
# by=['prev_state', 'concept:name', 'state', 'relative_time'],
# direction="backward", tolerance=None,
suffixes=("", "_right"))
temp = temp.groupby(['prev_state', 'concept:name', 'state', 'relative_time', 'val_minus']).cdf.max().reset_index()
# reseting the data index to keep it the same after merge
data = data.reset_index()
t_join = data.merge(temp, on=['prev_state', 'concept:name', 'state', 'relative_time'], how='left')
# reindexing the t_join dataframe with the original data index
t_join = t_join.set_index('original_index')
cdf_minus = t_join.cdf
cdf_minus = cdf_minus.fillna(0)
return cdf_minus
def cdf_plus_single_state(data, stats_df):
""" CDF plus"""
temp = data[['original_index','prev_state', 'concept:name', 'state', 'relative_time', 'val_plus']]
# TODO: reduce the size used by the following merge
# temp = temp.merge(stats_df, how='inner', on=['prev_state', 'concept:name', 'state'],
# suffixes=("", "_right"))
# temp = temp.loc[temp.val_plus >= temp.relative_time_right]
stats_df.state = stats_df.state.astype('int32')
stats_df.prev_state = stats_df.prev_state.astype('int32')
temp.sort_values('val_plus', inplace=True)
stats_df.sort_values('relative_time', inplace=True)
temp=pd.merge_asof(temp,stats_df,left_on='val_plus', right_on='relative_time', #by=['prev_state', 'concept:name', 'state', 'relative_time'],
# direction="backward", tolerance=None,
suffixes=("", "_right"))
temp = temp.groupby(['prev_state', 'concept:name', 'state', 'relative_time', 'val_plus']).cdf.max().reset_index()
# reseting the data index to keep it the same after merge
data = data.reset_index()
t_join = data.merge(temp, on=['prev_state', 'concept:name', 'state', 'relative_time'], how='left')
# reindexing the t_join dataframe with the original data index
t_join = t_join.set_index('original_index')
cdf_plus = t_join.cdf
return cdf_plus
def estimate_P_k_vectorized(data,delta):
if data.relative_time_max==data.relative_time_min:
#in case of fixed distribution, use the worst case scenario
return (1-delta)/2
elif data.prev_state==0: #start time
return 0
return data.cdf_plus - data.cdf_minus
def epsilon_vectorized_internal(data, delta):
if data.p_k+delta >=1:
#in case p_k+delta>1, set epsilon = 0.5
return 0.7
if data.p_k==0:
#in case of cdf_plus == cdf_minus, the epsilon will be inf
# we set epsilon to 10 at that case.
return 10
# r =1 because of normalization
return (- np.log(data.p_k / (1.0 - data.p_k) * (1.0 / (delta + data.p_k) - 1.0)))
def partitioning_df(stats_df,plus_and_minus,tmp_dir,chunk_size = 1000):
""" the first state for large files is very large. We split the first state in a separate file.
Then all the other states are splitted into several files.
"""
# stats_df.to_csv('stats_df.csv', index=False, header=True, float_format='%.15f', compression='gzip',
# encoding='utf-8')
stats_df.sort_values(['prev_state','concept:name','state'], ascending=True, inplace=True)
plus_and_minus.sort_values(['prev_state','concept:name','state'], ascending=True, inplace=True)
# unique_states = stats_df.state.unique()
unique_states = stats_df.groupby(['prev_state','concept:name','state']).size().reset_index().rename(columns={0:'count'}).drop('count',axis=1)
large_states=stats_df.groupby(['prev_state','concept:name','state']).relative_time.count()
#separating large states from the others
large_states=large_states[large_states>1000].reset_index()
#['prev_state', 'concept:name', 'state']
curr_dir = os.getcwd()
idx=0
"""large state separately"""
for index,row in large_states.iterrows():
res = stats_df.loc[(stats_df.state==row['state']) & (stats_df.prev_state==row['prev_state']) & (stats_df['concept:name']==row['concept:name']), :]
res.to_pickle(os.path.join( tmp_dir, 'stats_df_%s' % (idx)))
plus_and_minus.loc[ (plus_and_minus.state==row['state']) & (plus_and_minus.prev_state==row['prev_state']) & (plus_and_minus['concept:name']==row['concept:name']), :] \
.to_pickle(os.path.join( tmp_dir, 'plus_and_minus_%s' % (idx)))
# unique_states=unique_states[unique_states!=current_state]
row_id=unique_states.index[ (unique_states.state==row['state'] )& (unique_states.prev_state==row['prev_state']) & (unique_states['concept:name']==row['concept:name'])].tolist()[0]
unique_states.drop(row_id, axis=0,inplace=True)
idx += 1
""" splitting other states regularly"""
max_index_of_large_states=idx
# print("partition of large states is %s"%(max_index_of_large_states-1))
for i in range(0, unique_states.shape[0], chunk_size):
# print("Current Chunck is: %s" % (i))
current_states = unique_states[i:i + chunk_size]
# res = stats_df.loc[stats_df.state.isin(current_states), :]
res = stats_df.iloc[current_states.index]
res.to_pickle(os.path.join( tmp_dir,'stats_df_%s'%(idx)))
# plus_and_minus.loc[plus_and_minus.state.isin(current_states), :]\
# .to_pickle(os.path.join( tmp_dir,'plus_and_minus_%s'%(idx)))
plus_and_minus.iloc[current_states.index] \
.to_pickle(os.path.join( tmp_dir, 'plus_and_minus_%s' % (idx)))
idx+=1
# return len(list(range(0, unique_states.shape[0], chunk_size))) #number of chunks
return idx , max_index_of_large_states # number of chunks , max largest state
def append_cdf(tmp_dir,num=1):
cdf_name=0
if num==1:
cdf_name='cdf_*'
else:
cdf_name='cdf2_*'
curr_dir = os.getcwd()
# dir_path=os.path.join( tmp_dir,cdf_name)
list_of_files = glob.glob(os.path.join( tmp_dir,cdf_name))
cdf=[]
for i in list_of_files:
with open(i,'rb') as handle:
cdf.append(pickle.load(handle))
cdf= | pd.concat(cdf) | pandas.concat |
from wf_core_data_dashboard import core
import wf_core_data
import mefs_utils
import pandas as pd
import inflection
import urllib.parse
import os
def generate_mefs_table_data(
test_events_path,
student_info_path,
student_assignments_path
):
test_events = pd.read_pickle(test_events_path)
student_info = pd.read_pickle(student_info_path)
student_assignments = pd.read_pickle(student_assignments_path)
students = mefs_utils.summarize_by_student(
test_events=test_events,
student_info=student_info,
student_assignments=student_assignments
)
groups = mefs_utils.summarize_by_group(
students=students,
grouping_variables=[
'school_year',
'group_name_mefs'
]
)
return students, groups
def groups_page_html(
groups,
school_year=None,
group_name_mefs=None,
title=None,
subtitle=None,
include_details_link=True
):
if title is None:
title = 'MEFS results'
if subtitle is None:
subtitle = ':'.join(filter(
lambda x: x is not None,
[
school_year,
group_name_mefs
]
)).replace('/', ':')
table_html = groups_table_html(
groups,
school_year=school_year,
group_name_mefs=group_name_mefs,
include_details_link=include_details_link
)
template = core.get_template("groups_table.html")
return template.render(
title=title,
subtitle=subtitle,
table_html=table_html
)
def students_page_html(
students,
school_year=None,
group_name_mefs=None,
title=None,
subtitle=None
):
if title is None:
title = 'MEFS results'
if subtitle is None:
subtitle = ':'.join(filter(
lambda x: x is not None,
[
school_year,
group_name_mefs
]
)).replace('/', ':')
table_html = students_table_html(
students=students,
school_year=school_year,
group_name_mefs=group_name_mefs
)
template = core.get_template("students_table.html")
return template.render(
title=title,
subtitle=subtitle,
table_html=table_html
)
def groups_table_html(
groups,
school_year=None,
group_name_mefs=None,
include_details_link=True
):
groups = groups.copy()
groups['mean_ending_total_score_sem_range'] = groups.apply(
lambda row: '{:.1f} – {:.1f}'.format(
row['mean_ending_total_score'] - row['mean_ending_total_score_sem'],
row['mean_ending_total_score'] + row['mean_ending_total_score_sem'],
) if not pd.isna(row['mean_ending_total_score']) and not pd.isna(row['mean_ending_total_score_sem']) else '',
axis=1
)
groups['mean_total_score_growth_sem_range'] = groups.apply(
lambda row: '{:+.1f} – {:+.1f}'.format(
row['mean_total_score_growth'] - row['mean_total_score_growth_sem'],
row['mean_total_score_growth'] + row['mean_total_score_growth_sem'],
) if not pd.isna(row['mean_total_score_growth']) and not pd.isna(row['mean_total_score_growth_sem']) else '',
axis=1
)
groups['mean_total_score_growth_per_school_year_sem_range'] = groups.apply(
lambda row: '{:+.1f} – {:+.1f}'.format(
row['mean_total_score_growth_per_school_year'] - row['mean_total_score_growth_per_school_year_sem'],
row['mean_total_score_growth_per_school_year'] + row['mean_total_score_growth_per_school_year_sem'],
) if not pd.isna(row['mean_total_score_growth_per_school_year']) and not pd.isna(row['mean_total_score_growth_per_school_year_sem']) else '',
axis=1
)
groups['mean_ending_percentile_sem_range'] = groups.apply(
lambda row: '{:.1f} – {:.1f}'.format(
row['mean_ending_percentile'] - row['mean_ending_percentile_sem'],
row['mean_ending_percentile'] + row['mean_ending_percentile_sem'],
) if not pd.isna(row['mean_ending_percentile']) and not pd.isna(row['mean_ending_percentile_sem']) else '',
axis=1
)
groups['mean_percentile_growth_sem_range'] = groups.apply(
lambda row: '{:+.1f} – {:+.1f}'.format(
row['mean_percentile_growth'] - row['mean_percentile_growth_sem'],
row['mean_percentile_growth'] + row['mean_percentile_growth_sem'],
) if not pd.isna(row['mean_percentile_growth']) and not pd.isna(row['mean_percentile_growth_sem']) else '',
axis=1
)
groups['mean_percentile_growth_per_school_year_sem_range'] = groups.apply(
lambda row: '{:+.1f} – {:+.1f}'.format(
row['mean_percentile_growth_per_school_year'] - row['mean_percentile_growth_per_school_year_sem'],
row['mean_percentile_growth_per_school_year'] + row['mean_percentile_growth_per_school_year_sem'],
) if not pd.isna(row['mean_percentile_growth_per_school_year']) and not pd.isna(row['mean_percentile_growth_per_school_year_sem']) else '',
axis=1
)
groups['mean_ending_total_score'] = groups['mean_ending_total_score'].apply(
lambda x: '{:.1f}'.format(x) if not pd.isna(x) else ''
)
groups['ending_total_score_sd'] = groups['ending_total_score_sd'].apply(
lambda x: '{:.1f}'.format(x) if not pd.isna(x) else ''
)
groups['mean_ending_total_score_sem'] = groups['mean_ending_total_score_sem'].apply(
lambda x: '{:.1f}'.format(x) if not pd.isna(x) else ''
)
groups['mean_ending_percentile'] = groups['mean_ending_percentile'].apply(
lambda x: '{:.1f}'.format(x) if not pd.isna(x) else ''
)
groups['ending_percentile_sd'] = groups['ending_percentile_sd'].apply(
lambda x: '{:.1f}'.format(x) if not pd.isna(x) else ''
)
groups['mean_ending_percentile_sem'] = groups['mean_ending_percentile_sem'].apply(
lambda x: '{:.1f}'.format(x) if not pd.isna(x) else ''
)
groups['mean_total_score_growth'] = groups['mean_total_score_growth'].apply(
lambda x: '{:+.1f}'.format(x) if not pd.isna(x) else ''
)
groups['total_score_growth_sd'] = groups['total_score_growth_sd'].apply(
lambda x: '{:.1f}'.format(x) if not pd.isna(x) else ''
)
groups['mean_total_score_growth_sem'] = groups['mean_total_score_growth_sem'].apply(
lambda x: '{:.1f}'.format(x) if not pd.isna(x) else ''
)
groups['mean_total_score_growth_per_school_year'] = groups['mean_total_score_growth_per_school_year'].apply(
lambda x: '{:+.1f}'.format(x) if not pd.isna(x) else ''
)
groups['total_score_growth_per_school_year_sd'] = groups['total_score_growth_per_school_year_sd'].apply(
lambda x: '{:.1f}'.format(x) if not pd.isna(x) else ''
)
groups['mean_total_score_growth_per_school_year_sem'] = groups['mean_total_score_growth_per_school_year_sem'].apply(
lambda x: '{:.1f}'.format(x) if not pd.isna(x) else ''
)
groups['mean_percentile_growth'] = groups['mean_percentile_growth'].apply(
lambda x: '{:+.1f}'.format(x) if not pd.isna(x) else ''
)
groups['percentile_growth_sd'] = groups['percentile_growth_sd'].apply(
lambda x: '{:.1f}'.format(x) if not pd.isna(x) else ''
)
groups['mean_percentile_growth_sem'] = groups['mean_percentile_growth_sem'].apply(
lambda x: '{:.1f}'.format(x) if not pd.isna(x) else ''
)
groups['mean_percentile_growth_per_school_year'] = groups['mean_percentile_growth_per_school_year'].apply(
lambda x: '{:+.1f}'.format(x) if not | pd.isna(x) | pandas.isna |
# Arithmetic tests for DataFrame/Series/Index/Array classes that should
# behave identically.
# Specifically for datetime64 and datetime64tz dtypes
from datetime import (
datetime,
time,
timedelta,
)
from itertools import (
product,
starmap,
)
import operator
import warnings
import numpy as np
import pytest
import pytz
from pandas._libs.tslibs.conversion import localize_pydatetime
from pandas._libs.tslibs.offsets import shift_months
from pandas.errors import PerformanceWarning
import pandas as pd
from pandas import (
DateOffset,
DatetimeIndex,
NaT,
Period,
Series,
Timedelta,
TimedeltaIndex,
Timestamp,
date_range,
)
import pandas._testing as tm
from pandas.core.arrays import (
DatetimeArray,
TimedeltaArray,
)
from pandas.core.ops import roperator
from pandas.tests.arithmetic.common import (
assert_cannot_add,
assert_invalid_addsub_type,
assert_invalid_comparison,
get_upcast_box,
)
# ------------------------------------------------------------------
# Comparisons
class TestDatetime64ArrayLikeComparisons:
# Comparison tests for datetime64 vectors fully parametrized over
# DataFrame/Series/DatetimeIndex/DatetimeArray. Ideally all comparison
# tests will eventually end up here.
def test_compare_zerodim(self, tz_naive_fixture, box_with_array):
# Test comparison with zero-dimensional array is unboxed
tz = tz_naive_fixture
box = box_with_array
dti = date_range("20130101", periods=3, tz=tz)
other = np.array(dti.to_numpy()[0])
dtarr = tm.box_expected(dti, box)
xbox = get_upcast_box(dtarr, other, True)
result = dtarr <= other
expected = np.array([True, False, False])
expected = tm.box_expected(expected, xbox)
tm.assert_equal(result, expected)
@pytest.mark.parametrize(
"other",
[
"foo",
-1,
99,
4.0,
object(),
timedelta(days=2),
# GH#19800, GH#19301 datetime.date comparison raises to
# match DatetimeIndex/Timestamp. This also matches the behavior
# of stdlib datetime.datetime
datetime(2001, 1, 1).date(),
# GH#19301 None and NaN are *not* cast to NaT for comparisons
None,
np.nan,
],
)
def test_dt64arr_cmp_scalar_invalid(self, other, tz_naive_fixture, box_with_array):
# GH#22074, GH#15966
tz = tz_naive_fixture
rng = date_range("1/1/2000", periods=10, tz=tz)
dtarr = tm.box_expected(rng, box_with_array)
assert_invalid_comparison(dtarr, other, box_with_array)
@pytest.mark.parametrize(
"other",
[
# GH#4968 invalid date/int comparisons
list(range(10)),
np.arange(10),
np.arange(10).astype(np.float32),
np.arange(10).astype(object),
pd.timedelta_range("1ns", periods=10).array,
np.array(pd.timedelta_range("1ns", periods=10)),
list(pd.timedelta_range("1ns", periods=10)),
pd.timedelta_range("1 Day", periods=10).astype(object),
pd.period_range("1971-01-01", freq="D", periods=10).array,
pd.period_range("1971-01-01", freq="D", periods=10).astype(object),
],
)
def test_dt64arr_cmp_arraylike_invalid(
self, other, tz_naive_fixture, box_with_array
):
tz = tz_naive_fixture
dta = date_range("1970-01-01", freq="ns", periods=10, tz=tz)._data
obj = tm.box_expected(dta, box_with_array)
assert_invalid_comparison(obj, other, box_with_array)
def test_dt64arr_cmp_mixed_invalid(self, tz_naive_fixture):
tz = tz_naive_fixture
dta = date_range("1970-01-01", freq="h", periods=5, tz=tz)._data
other = np.array([0, 1, 2, dta[3], Timedelta(days=1)])
result = dta == other
expected = np.array([False, False, False, True, False])
tm.assert_numpy_array_equal(result, expected)
result = dta != other
tm.assert_numpy_array_equal(result, ~expected)
msg = "Invalid comparison between|Cannot compare type|not supported between"
with pytest.raises(TypeError, match=msg):
dta < other
with pytest.raises(TypeError, match=msg):
dta > other
with pytest.raises(TypeError, match=msg):
dta <= other
with pytest.raises(TypeError, match=msg):
dta >= other
def test_dt64arr_nat_comparison(self, tz_naive_fixture, box_with_array):
# GH#22242, GH#22163 DataFrame considered NaT == ts incorrectly
tz = tz_naive_fixture
box = box_with_array
ts = Timestamp("2021-01-01", tz=tz)
ser = Series([ts, NaT])
obj = tm.box_expected(ser, box)
xbox = get_upcast_box(obj, ts, True)
expected = Series([True, False], dtype=np.bool_)
expected = tm.box_expected(expected, xbox)
result = obj == ts
tm.assert_equal(result, expected)
class TestDatetime64SeriesComparison:
# TODO: moved from tests.series.test_operators; needs cleanup
@pytest.mark.parametrize(
"pair",
[
(
[Timestamp("2011-01-01"), NaT, Timestamp("2011-01-03")],
[NaT, NaT, Timestamp("2011-01-03")],
),
(
[Timedelta("1 days"), NaT, Timedelta("3 days")],
[NaT, NaT, Timedelta("3 days")],
),
(
[Period("2011-01", freq="M"), NaT, Period("2011-03", freq="M")],
[NaT, NaT, Period("2011-03", freq="M")],
),
],
)
@pytest.mark.parametrize("reverse", [True, False])
@pytest.mark.parametrize("dtype", [None, object])
@pytest.mark.parametrize(
"op, expected",
[
(operator.eq, Series([False, False, True])),
(operator.ne, Series([True, True, False])),
(operator.lt, Series([False, False, False])),
(operator.gt, Series([False, False, False])),
(operator.ge, Series([False, False, True])),
(operator.le, Series([False, False, True])),
],
)
def test_nat_comparisons(
self,
dtype,
index_or_series,
reverse,
pair,
op,
expected,
):
box = index_or_series
l, r = pair
if reverse:
# add lhs / rhs switched data
l, r = r, l
left = Series(l, dtype=dtype)
right = box(r, dtype=dtype)
result = op(left, right)
tm.assert_series_equal(result, expected)
@pytest.mark.parametrize(
"data",
[
[Timestamp("2011-01-01"), NaT, Timestamp("2011-01-03")],
[Timedelta("1 days"), NaT, Timedelta("3 days")],
[Period("2011-01", freq="M"), NaT, Period("2011-03", freq="M")],
],
)
@pytest.mark.parametrize("dtype", [None, object])
def test_nat_comparisons_scalar(self, dtype, data, box_with_array):
box = box_with_array
left = Series(data, dtype=dtype)
left = tm.box_expected(left, box)
xbox = get_upcast_box(left, NaT, True)
expected = [False, False, False]
expected = tm.box_expected(expected, xbox)
if box is pd.array and dtype is object:
expected = pd.array(expected, dtype="bool")
tm.assert_equal(left == NaT, expected)
tm.assert_equal(NaT == left, expected)
expected = [True, True, True]
expected = tm.box_expected(expected, xbox)
if box is pd.array and dtype is object:
expected = pd.array(expected, dtype="bool")
tm.assert_equal(left != NaT, expected)
tm.assert_equal(NaT != left, expected)
expected = [False, False, False]
expected = tm.box_expected(expected, xbox)
if box is pd.array and dtype is object:
expected = pd.array(expected, dtype="bool")
tm.assert_equal(left < NaT, expected)
tm.assert_equal(NaT > left, expected)
tm.assert_equal(left <= NaT, expected)
tm.assert_equal(NaT >= left, expected)
tm.assert_equal(left > NaT, expected)
tm.assert_equal(NaT < left, expected)
tm.assert_equal(left >= NaT, expected)
tm.assert_equal(NaT <= left, expected)
@pytest.mark.parametrize("val", [datetime(2000, 1, 4), datetime(2000, 1, 5)])
def test_series_comparison_scalars(self, val):
series = Series(date_range("1/1/2000", periods=10))
result = series > val
expected = Series([x > val for x in series])
tm.assert_series_equal(result, expected)
@pytest.mark.parametrize(
"left,right", [("lt", "gt"), ("le", "ge"), ("eq", "eq"), ("ne", "ne")]
)
def test_timestamp_compare_series(self, left, right):
# see gh-4982
# Make sure we can compare Timestamps on the right AND left hand side.
ser = Series(date_range("20010101", periods=10), name="dates")
s_nat = ser.copy(deep=True)
ser[0] = Timestamp("nat")
ser[3] = Timestamp("nat")
left_f = getattr(operator, left)
right_f = getattr(operator, right)
# No NaT
expected = left_f(ser, Timestamp("20010109"))
result = right_f(Timestamp("20010109"), ser)
tm.assert_series_equal(result, expected)
# NaT
expected = left_f(ser, Timestamp("nat"))
result = right_f(Timestamp("nat"), ser)
tm.assert_series_equal(result, expected)
# Compare to Timestamp with series containing NaT
expected = left_f(s_nat, Timestamp("20010109"))
result = right_f(Timestamp("20010109"), s_nat)
tm.assert_series_equal(result, expected)
# Compare to NaT with series containing NaT
expected = left_f(s_nat, NaT)
result = right_f(NaT, s_nat)
tm.assert_series_equal(result, expected)
def test_dt64arr_timestamp_equality(self, box_with_array):
# GH#11034
ser = Series([Timestamp("2000-01-29 01:59:00"), Timestamp("2000-01-30"), NaT])
ser = tm.box_expected(ser, box_with_array)
xbox = get_upcast_box(ser, ser, True)
result = ser != ser
expected = tm.box_expected([False, False, True], xbox)
tm.assert_equal(result, expected)
warn = FutureWarning if box_with_array is pd.DataFrame else None
with tm.assert_produces_warning(warn):
# alignment for frame vs series comparisons deprecated
result = ser != ser[0]
expected = tm.box_expected([False, True, True], xbox)
tm.assert_equal(result, expected)
with tm.assert_produces_warning(warn):
# alignment for frame vs series comparisons deprecated
result = ser != ser[2]
expected = tm.box_expected([True, True, True], xbox)
tm.assert_equal(result, expected)
result = ser == ser
expected = tm.box_expected([True, True, False], xbox)
tm.assert_equal(result, expected)
with tm.assert_produces_warning(warn):
# alignment for frame vs series comparisons deprecated
result = ser == ser[0]
expected = tm.box_expected([True, False, False], xbox)
tm.assert_equal(result, expected)
with tm.assert_produces_warning(warn):
# alignment for frame vs series comparisons deprecated
result = ser == ser[2]
expected = tm.box_expected([False, False, False], xbox)
tm.assert_equal(result, expected)
@pytest.mark.parametrize(
"datetimelike",
[
Timestamp("20130101"),
datetime(2013, 1, 1),
np.datetime64("2013-01-01T00:00", "ns"),
],
)
@pytest.mark.parametrize(
"op,expected",
[
(operator.lt, [True, False, False, False]),
(operator.le, [True, True, False, False]),
(operator.eq, [False, True, False, False]),
(operator.gt, [False, False, False, True]),
],
)
def test_dt64_compare_datetime_scalar(self, datetimelike, op, expected):
# GH#17965, test for ability to compare datetime64[ns] columns
# to datetimelike
ser = Series(
[
Timestamp("20120101"),
Timestamp("20130101"),
np.nan,
Timestamp("20130103"),
],
name="A",
)
result = op(ser, datetimelike)
expected = Series(expected, name="A")
tm.assert_series_equal(result, expected)
class TestDatetimeIndexComparisons:
# TODO: moved from tests.indexes.test_base; parametrize and de-duplicate
def test_comparators(self, comparison_op):
index = tm.makeDateIndex(100)
element = index[len(index) // 2]
element = Timestamp(element).to_datetime64()
arr = np.array(index)
arr_result = comparison_op(arr, element)
index_result = comparison_op(index, element)
assert isinstance(index_result, np.ndarray)
tm.assert_numpy_array_equal(arr_result, index_result)
@pytest.mark.parametrize(
"other",
[datetime(2016, 1, 1), Timestamp("2016-01-01"), np.datetime64("2016-01-01")],
)
def test_dti_cmp_datetimelike(self, other, tz_naive_fixture):
tz = tz_naive_fixture
dti = date_range("2016-01-01", periods=2, tz=tz)
if tz is not None:
if isinstance(other, np.datetime64):
# no tzaware version available
return
other = localize_pydatetime(other, dti.tzinfo)
result = dti == other
expected = np.array([True, False])
tm.assert_numpy_array_equal(result, expected)
result = dti > other
expected = np.array([False, True])
tm.assert_numpy_array_equal(result, expected)
result = dti >= other
expected = np.array([True, True])
tm.assert_numpy_array_equal(result, expected)
result = dti < other
expected = np.array([False, False])
tm.assert_numpy_array_equal(result, expected)
result = dti <= other
expected = np.array([True, False])
tm.assert_numpy_array_equal(result, expected)
@pytest.mark.parametrize("dtype", [None, object])
def test_dti_cmp_nat(self, dtype, box_with_array):
left = DatetimeIndex([Timestamp("2011-01-01"), NaT, Timestamp("2011-01-03")])
right = DatetimeIndex([NaT, NaT, Timestamp("2011-01-03")])
left = tm.box_expected(left, box_with_array)
right = tm.box_expected(right, box_with_array)
xbox = get_upcast_box(left, right, True)
lhs, rhs = left, right
if dtype is object:
lhs, rhs = left.astype(object), right.astype(object)
result = rhs == lhs
expected = np.array([False, False, True])
expected = tm.box_expected(expected, xbox)
tm.assert_equal(result, expected)
result = lhs != rhs
expected = np.array([True, True, False])
expected = tm.box_expected(expected, xbox)
tm.assert_equal(result, expected)
expected = np.array([False, False, False])
expected = tm.box_expected(expected, xbox)
tm.assert_equal(lhs == NaT, expected)
tm.assert_equal(NaT == rhs, expected)
expected = np.array([True, True, True])
expected = tm.box_expected(expected, xbox)
tm.assert_equal(lhs != NaT, expected)
tm.assert_equal(NaT != lhs, expected)
expected = np.array([False, False, False])
expected = tm.box_expected(expected, xbox)
tm.assert_equal(lhs < NaT, expected)
tm.assert_equal(NaT > lhs, expected)
def test_dti_cmp_nat_behaves_like_float_cmp_nan(self):
fidx1 = pd.Index([1.0, np.nan, 3.0, np.nan, 5.0, 7.0])
fidx2 = pd.Index([2.0, 3.0, np.nan, np.nan, 6.0, 7.0])
didx1 = DatetimeIndex(
["2014-01-01", NaT, "2014-03-01", NaT, "2014-05-01", "2014-07-01"]
)
didx2 = DatetimeIndex(
["2014-02-01", "2014-03-01", NaT, NaT, "2014-06-01", "2014-07-01"]
)
darr = np.array(
[
np.datetime64("2014-02-01 00:00"),
np.datetime64("2014-03-01 00:00"),
np.datetime64("nat"),
np.datetime64("nat"),
np.datetime64("2014-06-01 00:00"),
np.datetime64("2014-07-01 00:00"),
]
)
cases = [(fidx1, fidx2), (didx1, didx2), (didx1, darr)]
# Check pd.NaT is handles as the same as np.nan
with tm.assert_produces_warning(None):
for idx1, idx2 in cases:
result = idx1 < idx2
expected = np.array([True, False, False, False, True, False])
tm.assert_numpy_array_equal(result, expected)
result = idx2 > idx1
expected = np.array([True, False, False, False, True, False])
tm.assert_numpy_array_equal(result, expected)
result = idx1 <= idx2
expected = np.array([True, False, False, False, True, True])
tm.assert_numpy_array_equal(result, expected)
result = idx2 >= idx1
expected = np.array([True, False, False, False, True, True])
tm.assert_numpy_array_equal(result, expected)
result = idx1 == idx2
expected = np.array([False, False, False, False, False, True])
tm.assert_numpy_array_equal(result, expected)
result = idx1 != idx2
expected = np.array([True, True, True, True, True, False])
tm.assert_numpy_array_equal(result, expected)
with tm.assert_produces_warning(None):
for idx1, val in [(fidx1, np.nan), (didx1, NaT)]:
result = idx1 < val
expected = np.array([False, False, False, False, False, False])
tm.assert_numpy_array_equal(result, expected)
result = idx1 > val
tm.assert_numpy_array_equal(result, expected)
result = idx1 <= val
tm.assert_numpy_array_equal(result, expected)
result = idx1 >= val
tm.assert_numpy_array_equal(result, expected)
result = idx1 == val
tm.assert_numpy_array_equal(result, expected)
result = idx1 != val
expected = np.array([True, True, True, True, True, True])
tm.assert_numpy_array_equal(result, expected)
# Check pd.NaT is handles as the same as np.nan
with tm.assert_produces_warning(None):
for idx1, val in [(fidx1, 3), (didx1, datetime(2014, 3, 1))]:
result = idx1 < val
expected = np.array([True, False, False, False, False, False])
tm.assert_numpy_array_equal(result, expected)
result = idx1 > val
expected = np.array([False, False, False, False, True, True])
tm.assert_numpy_array_equal(result, expected)
result = idx1 <= val
expected = np.array([True, False, True, False, False, False])
tm.assert_numpy_array_equal(result, expected)
result = idx1 >= val
expected = np.array([False, False, True, False, True, True])
tm.assert_numpy_array_equal(result, expected)
result = idx1 == val
expected = np.array([False, False, True, False, False, False])
tm.assert_numpy_array_equal(result, expected)
result = idx1 != val
expected = np.array([True, True, False, True, True, True])
tm.assert_numpy_array_equal(result, expected)
def test_comparison_tzawareness_compat(self, comparison_op, box_with_array):
# GH#18162
op = comparison_op
box = box_with_array
dr = date_range("2016-01-01", periods=6)
dz = dr.tz_localize("US/Pacific")
dr = tm.box_expected(dr, box)
dz = tm.box_expected(dz, box)
if box is pd.DataFrame:
tolist = lambda x: x.astype(object).values.tolist()[0]
else:
tolist = list
if op not in [operator.eq, operator.ne]:
msg = (
r"Invalid comparison between dtype=datetime64\[ns.*\] "
"and (Timestamp|DatetimeArray|list|ndarray)"
)
with pytest.raises(TypeError, match=msg):
op(dr, dz)
with pytest.raises(TypeError, match=msg):
op(dr, tolist(dz))
with pytest.raises(TypeError, match=msg):
op(dr, np.array(tolist(dz), dtype=object))
with pytest.raises(TypeError, match=msg):
op(dz, dr)
with pytest.raises(TypeError, match=msg):
op(dz, tolist(dr))
with pytest.raises(TypeError, match=msg):
op(dz, np.array(tolist(dr), dtype=object))
# The aware==aware and naive==naive comparisons should *not* raise
assert np.all(dr == dr)
assert np.all(dr == tolist(dr))
assert np.all(tolist(dr) == dr)
assert np.all(np.array(tolist(dr), dtype=object) == dr)
assert np.all(dr == np.array(tolist(dr), dtype=object))
assert np.all(dz == dz)
assert np.all(dz == tolist(dz))
assert np.all(tolist(dz) == dz)
assert np.all(np.array(tolist(dz), dtype=object) == dz)
assert np.all(dz == np.array(tolist(dz), dtype=object))
def test_comparison_tzawareness_compat_scalars(self, comparison_op, box_with_array):
# GH#18162
op = comparison_op
dr = date_range("2016-01-01", periods=6)
dz = dr.tz_localize("US/Pacific")
dr = tm.box_expected(dr, box_with_array)
dz = tm.box_expected(dz, box_with_array)
# Check comparisons against scalar Timestamps
ts = Timestamp("2000-03-14 01:59")
ts_tz = Timestamp("2000-03-14 01:59", tz="Europe/Amsterdam")
assert np.all(dr > ts)
msg = r"Invalid comparison between dtype=datetime64\[ns.*\] and Timestamp"
if op not in [operator.eq, operator.ne]:
with pytest.raises(TypeError, match=msg):
op(dr, ts_tz)
assert np.all(dz > ts_tz)
if op not in [operator.eq, operator.ne]:
with pytest.raises(TypeError, match=msg):
op(dz, ts)
if op not in [operator.eq, operator.ne]:
# GH#12601: Check comparison against Timestamps and DatetimeIndex
with pytest.raises(TypeError, match=msg):
op(ts, dz)
@pytest.mark.parametrize(
"other",
[datetime(2016, 1, 1), Timestamp("2016-01-01"), np.datetime64("2016-01-01")],
)
# Bug in NumPy? https://github.com/numpy/numpy/issues/13841
# Raising in __eq__ will fallback to NumPy, which warns, fails,
# then re-raises the original exception. So we just need to ignore.
@pytest.mark.filterwarnings("ignore:elementwise comp:DeprecationWarning")
@pytest.mark.filterwarnings("ignore:Converting timezone-aware:FutureWarning")
def test_scalar_comparison_tzawareness(
self, comparison_op, other, tz_aware_fixture, box_with_array
):
op = comparison_op
tz = tz_aware_fixture
dti = date_range("2016-01-01", periods=2, tz=tz)
dtarr = tm.box_expected(dti, box_with_array)
xbox = get_upcast_box(dtarr, other, True)
if op in [operator.eq, operator.ne]:
exbool = op is operator.ne
expected = np.array([exbool, exbool], dtype=bool)
expected = tm.box_expected(expected, xbox)
result = op(dtarr, other)
tm.assert_equal(result, expected)
result = op(other, dtarr)
tm.assert_equal(result, expected)
else:
msg = (
r"Invalid comparison between dtype=datetime64\[ns, .*\] "
f"and {type(other).__name__}"
)
with pytest.raises(TypeError, match=msg):
op(dtarr, other)
with pytest.raises(TypeError, match=msg):
op(other, dtarr)
def test_nat_comparison_tzawareness(self, comparison_op):
# GH#19276
# tzaware DatetimeIndex should not raise when compared to NaT
op = comparison_op
dti = DatetimeIndex(
["2014-01-01", NaT, "2014-03-01", NaT, "2014-05-01", "2014-07-01"]
)
expected = np.array([op == operator.ne] * len(dti))
result = op(dti, NaT)
tm.assert_numpy_array_equal(result, expected)
result = op(dti.tz_localize("US/Pacific"), NaT)
tm.assert_numpy_array_equal(result, expected)
def test_dti_cmp_str(self, tz_naive_fixture):
# GH#22074
# regardless of tz, we expect these comparisons are valid
tz = tz_naive_fixture
rng = date_range("1/1/2000", periods=10, tz=tz)
other = "1/1/2000"
result = rng == other
expected = np.array([True] + [False] * 9)
tm.assert_numpy_array_equal(result, expected)
result = rng != other
expected = np.array([False] + [True] * 9)
tm.assert_numpy_array_equal(result, expected)
result = rng < other
expected = np.array([False] * 10)
tm.assert_numpy_array_equal(result, expected)
result = rng <= other
expected = np.array([True] + [False] * 9)
tm.assert_numpy_array_equal(result, expected)
result = rng > other
expected = np.array([False] + [True] * 9)
tm.assert_numpy_array_equal(result, expected)
result = rng >= other
expected = np.array([True] * 10)
tm.assert_numpy_array_equal(result, expected)
def test_dti_cmp_list(self):
rng = date_range("1/1/2000", periods=10)
result = rng == list(rng)
expected = rng == rng
tm.assert_numpy_array_equal(result, expected)
@pytest.mark.parametrize(
"other",
[
pd.timedelta_range("1D", periods=10),
pd.timedelta_range("1D", periods=10).to_series(),
pd.timedelta_range("1D", periods=10).asi8.view("m8[ns]"),
],
ids=lambda x: type(x).__name__,
)
def test_dti_cmp_tdi_tzawareness(self, other):
# GH#22074
# reversion test that we _don't_ call _assert_tzawareness_compat
# when comparing against TimedeltaIndex
dti = date_range("2000-01-01", periods=10, tz="Asia/Tokyo")
result = dti == other
expected = np.array([False] * 10)
tm.assert_numpy_array_equal(result, expected)
result = dti != other
expected = np.array([True] * 10)
tm.assert_numpy_array_equal(result, expected)
msg = "Invalid comparison between"
with pytest.raises(TypeError, match=msg):
dti < other
with pytest.raises(TypeError, match=msg):
dti <= other
with pytest.raises(TypeError, match=msg):
dti > other
with pytest.raises(TypeError, match=msg):
dti >= other
def test_dti_cmp_object_dtype(self):
# GH#22074
dti = date_range("2000-01-01", periods=10, tz="Asia/Tokyo")
other = dti.astype("O")
result = dti == other
expected = np.array([True] * 10)
tm.assert_numpy_array_equal(result, expected)
other = dti.tz_localize(None)
result = dti != other
tm.assert_numpy_array_equal(result, expected)
other = np.array(list(dti[:5]) + [Timedelta(days=1)] * 5)
result = dti == other
expected = np.array([True] * 5 + [False] * 5)
tm.assert_numpy_array_equal(result, expected)
msg = ">=' not supported between instances of 'Timestamp' and 'Timedelta'"
with pytest.raises(TypeError, match=msg):
dti >= other
# ------------------------------------------------------------------
# Arithmetic
class TestDatetime64Arithmetic:
# This class is intended for "finished" tests that are fully parametrized
# over DataFrame/Series/Index/DatetimeArray
# -------------------------------------------------------------
# Addition/Subtraction of timedelta-like
@pytest.mark.arm_slow
def test_dt64arr_add_timedeltalike_scalar(
self, tz_naive_fixture, two_hours, box_with_array
):
# GH#22005, GH#22163 check DataFrame doesn't raise TypeError
tz = tz_naive_fixture
rng = date_range("2000-01-01", "2000-02-01", tz=tz)
expected = date_range("2000-01-01 02:00", "2000-02-01 02:00", tz=tz)
rng = tm.box_expected(rng, box_with_array)
expected = tm.box_expected(expected, box_with_array)
result = rng + two_hours
tm.assert_equal(result, expected)
rng += two_hours
tm.assert_equal(rng, expected)
def test_dt64arr_sub_timedeltalike_scalar(
self, tz_naive_fixture, two_hours, box_with_array
):
tz = tz_naive_fixture
rng = date_range("2000-01-01", "2000-02-01", tz=tz)
expected = date_range("1999-12-31 22:00", "2000-01-31 22:00", tz=tz)
rng = tm.box_expected(rng, box_with_array)
expected = tm.box_expected(expected, box_with_array)
result = rng - two_hours
tm.assert_equal(result, expected)
rng -= two_hours
tm.assert_equal(rng, expected)
# TODO: redundant with test_dt64arr_add_timedeltalike_scalar
def test_dt64arr_add_td64_scalar(self, box_with_array):
# scalar timedeltas/np.timedelta64 objects
# operate with np.timedelta64 correctly
ser = Series([Timestamp("20130101 9:01"), Timestamp("20130101 9:02")])
expected = Series(
[Timestamp("20130101 9:01:01"), Timestamp("20130101 9:02:01")]
)
dtarr = tm.box_expected(ser, box_with_array)
expected = tm.box_expected(expected, box_with_array)
result = dtarr + np.timedelta64(1, "s")
tm.assert_equal(result, expected)
result = np.timedelta64(1, "s") + dtarr
tm.assert_equal(result, expected)
expected = Series(
[Timestamp("20130101 9:01:00.005"), Timestamp("20130101 9:02:00.005")]
)
expected = tm.box_expected(expected, box_with_array)
result = dtarr + np.timedelta64(5, "ms")
tm.assert_equal(result, expected)
result = np.timedelta64(5, "ms") + dtarr
tm.assert_equal(result, expected)
def test_dt64arr_add_sub_td64_nat(self, box_with_array, tz_naive_fixture):
# GH#23320 special handling for timedelta64("NaT")
tz = tz_naive_fixture
dti = date_range("1994-04-01", periods=9, tz=tz, freq="QS")
other = np.timedelta64("NaT")
expected = DatetimeIndex(["NaT"] * 9, tz=tz)
obj = tm.box_expected(dti, box_with_array)
expected = tm.box_expected(expected, box_with_array)
result = obj + other
tm.assert_equal(result, expected)
result = other + obj
tm.assert_equal(result, expected)
result = obj - other
tm.assert_equal(result, expected)
msg = "cannot subtract"
with pytest.raises(TypeError, match=msg):
other - obj
def test_dt64arr_add_sub_td64ndarray(self, tz_naive_fixture, box_with_array):
tz = tz_naive_fixture
dti = date_range("2016-01-01", periods=3, tz=tz)
tdi = TimedeltaIndex(["-1 Day", "-1 Day", "-1 Day"])
tdarr = tdi.values
expected = date_range("2015-12-31", "2016-01-02", periods=3, tz=tz)
dtarr = tm.box_expected(dti, box_with_array)
expected = tm.box_expected(expected, box_with_array)
result = dtarr + tdarr
tm.assert_equal(result, expected)
result = tdarr + dtarr
tm.assert_equal(result, expected)
expected = date_range("2016-01-02", "2016-01-04", periods=3, tz=tz)
expected = tm.box_expected(expected, box_with_array)
result = dtarr - tdarr
tm.assert_equal(result, expected)
msg = "cannot subtract|(bad|unsupported) operand type for unary"
with pytest.raises(TypeError, match=msg):
tdarr - dtarr
# -----------------------------------------------------------------
# Subtraction of datetime-like scalars
@pytest.mark.parametrize(
"ts",
[
Timestamp("2013-01-01"),
Timestamp("2013-01-01").to_pydatetime(),
Timestamp("2013-01-01").to_datetime64(),
],
)
def test_dt64arr_sub_dtscalar(self, box_with_array, ts):
# GH#8554, GH#22163 DataFrame op should _not_ return dt64 dtype
idx = date_range("2013-01-01", periods=3)._with_freq(None)
idx = tm.box_expected(idx, box_with_array)
expected = TimedeltaIndex(["0 Days", "1 Day", "2 Days"])
expected = tm.box_expected(expected, box_with_array)
result = idx - ts
tm.assert_equal(result, expected)
def test_dt64arr_sub_datetime64_not_ns(self, box_with_array):
# GH#7996, GH#22163 ensure non-nano datetime64 is converted to nano
# for DataFrame operation
dt64 = np.datetime64("2013-01-01")
assert dt64.dtype == "datetime64[D]"
dti = date_range("20130101", periods=3)._with_freq(None)
dtarr = tm.box_expected(dti, box_with_array)
expected = TimedeltaIndex(["0 Days", "1 Day", "2 Days"])
expected = tm.box_expected(expected, box_with_array)
result = dtarr - dt64
tm.assert_equal(result, expected)
result = dt64 - dtarr
tm.assert_equal(result, -expected)
def test_dt64arr_sub_timestamp(self, box_with_array):
ser = date_range("2014-03-17", periods=2, freq="D", tz="US/Eastern")
ser = ser._with_freq(None)
ts = ser[0]
ser = tm.box_expected(ser, box_with_array)
delta_series = Series([np.timedelta64(0, "D"), np.timedelta64(1, "D")])
expected = tm.box_expected(delta_series, box_with_array)
tm.assert_equal(ser - ts, expected)
tm.assert_equal(ts - ser, -expected)
def test_dt64arr_sub_NaT(self, box_with_array):
# GH#18808
dti = DatetimeIndex([NaT, Timestamp("19900315")])
ser = tm.box_expected(dti, box_with_array)
result = ser - NaT
expected = Series([NaT, NaT], dtype="timedelta64[ns]")
expected = tm.box_expected(expected, box_with_array)
tm.assert_equal(result, expected)
dti_tz = dti.tz_localize("Asia/Tokyo")
ser_tz = tm.box_expected(dti_tz, box_with_array)
result = ser_tz - NaT
expected = Series([NaT, NaT], dtype="timedelta64[ns]")
expected = tm.box_expected(expected, box_with_array)
tm.assert_equal(result, expected)
# -------------------------------------------------------------
# Subtraction of datetime-like array-like
def test_dt64arr_sub_dt64object_array(self, box_with_array, tz_naive_fixture):
dti = date_range("2016-01-01", periods=3, tz=tz_naive_fixture)
expected = dti - dti
obj = tm.box_expected(dti, box_with_array)
expected = tm.box_expected(expected, box_with_array)
with tm.assert_produces_warning(PerformanceWarning):
result = obj - obj.astype(object)
tm.assert_equal(result, expected)
def test_dt64arr_naive_sub_dt64ndarray(self, box_with_array):
dti = date_range("2016-01-01", periods=3, tz=None)
dt64vals = dti.values
dtarr = tm.box_expected(dti, box_with_array)
expected = dtarr - dtarr
result = dtarr - dt64vals
tm.assert_equal(result, expected)
result = dt64vals - dtarr
tm.assert_equal(result, expected)
def test_dt64arr_aware_sub_dt64ndarray_raises(
self, tz_aware_fixture, box_with_array
):
tz = tz_aware_fixture
dti = date_range("2016-01-01", periods=3, tz=tz)
dt64vals = dti.values
dtarr = tm.box_expected(dti, box_with_array)
msg = "subtraction must have the same timezones or"
with pytest.raises(TypeError, match=msg):
dtarr - dt64vals
with pytest.raises(TypeError, match=msg):
dt64vals - dtarr
# -------------------------------------------------------------
# Addition of datetime-like others (invalid)
def test_dt64arr_add_dt64ndarray_raises(self, tz_naive_fixture, box_with_array):
tz = tz_naive_fixture
dti = date_range("2016-01-01", periods=3, tz=tz)
dt64vals = dti.values
dtarr = tm.box_expected(dti, box_with_array)
assert_cannot_add(dtarr, dt64vals)
def test_dt64arr_add_timestamp_raises(self, box_with_array):
# GH#22163 ensure DataFrame doesn't cast Timestamp to i8
idx = DatetimeIndex(["2011-01-01", "2011-01-02"])
ts = idx[0]
idx = tm.box_expected(idx, box_with_array)
assert_cannot_add(idx, ts)
# -------------------------------------------------------------
# Other Invalid Addition/Subtraction
@pytest.mark.parametrize(
"other",
[
3.14,
np.array([2.0, 3.0]),
# GH#13078 datetime +/- Period is invalid
Period("2011-01-01", freq="D"),
# https://github.com/pandas-dev/pandas/issues/10329
time(1, 2, 3),
],
)
@pytest.mark.parametrize("dti_freq", [None, "D"])
def test_dt64arr_add_sub_invalid(self, dti_freq, other, box_with_array):
dti = DatetimeIndex(["2011-01-01", "2011-01-02"], freq=dti_freq)
dtarr = tm.box_expected(dti, box_with_array)
msg = "|".join(
[
"unsupported operand type",
"cannot (add|subtract)",
"cannot use operands with types",
"ufunc '?(add|subtract)'? cannot use operands with types",
"Concatenation operation is not implemented for NumPy arrays",
]
)
assert_invalid_addsub_type(dtarr, other, msg)
@pytest.mark.parametrize("pi_freq", ["D", "W", "Q", "H"])
@pytest.mark.parametrize("dti_freq", [None, "D"])
def test_dt64arr_add_sub_parr(
self, dti_freq, pi_freq, box_with_array, box_with_array2
):
# GH#20049 subtracting PeriodIndex should raise TypeError
dti = DatetimeIndex(["2011-01-01", "2011-01-02"], freq=dti_freq)
pi = dti.to_period(pi_freq)
dtarr = tm.box_expected(dti, box_with_array)
parr = tm.box_expected(pi, box_with_array2)
msg = "|".join(
[
"cannot (add|subtract)",
"unsupported operand",
"descriptor.*requires",
"ufunc.*cannot use operands",
]
)
assert_invalid_addsub_type(dtarr, parr, msg)
def test_dt64arr_addsub_time_objects_raises(self, box_with_array, tz_naive_fixture):
# https://github.com/pandas-dev/pandas/issues/10329
tz = tz_naive_fixture
obj1 = date_range("2012-01-01", periods=3, tz=tz)
obj2 = [time(i, i, i) for i in range(3)]
obj1 = tm.box_expected(obj1, box_with_array)
obj2 = tm.box_expected(obj2, box_with_array)
with warnings.catch_warnings(record=True):
# pandas.errors.PerformanceWarning: Non-vectorized DateOffset being
# applied to Series or DatetimeIndex
# we aren't testing that here, so ignore.
warnings.simplefilter("ignore", PerformanceWarning)
# If `x + y` raises, then `y + x` should raise here as well
msg = (
r"unsupported operand type\(s\) for -: "
"'(Timestamp|DatetimeArray)' and 'datetime.time'"
)
with pytest.raises(TypeError, match=msg):
obj1 - obj2
msg = "|".join(
[
"cannot subtract DatetimeArray from ndarray",
"ufunc (subtract|'subtract') cannot use operands with types "
r"dtype\('O'\) and dtype\('<M8\[ns\]'\)",
]
)
with pytest.raises(TypeError, match=msg):
obj2 - obj1
msg = (
r"unsupported operand type\(s\) for \+: "
"'(Timestamp|DatetimeArray)' and 'datetime.time'"
)
with pytest.raises(TypeError, match=msg):
obj1 + obj2
msg = "|".join(
[
r"unsupported operand type\(s\) for \+: "
"'(Timestamp|DatetimeArray)' and 'datetime.time'",
"ufunc (add|'add') cannot use operands with types "
r"dtype\('O'\) and dtype\('<M8\[ns\]'\)",
]
)
with pytest.raises(TypeError, match=msg):
obj2 + obj1
class TestDatetime64DateOffsetArithmetic:
# -------------------------------------------------------------
# Tick DateOffsets
# TODO: parametrize over timezone?
def test_dt64arr_series_add_tick_DateOffset(self, box_with_array):
# GH#4532
# operate with pd.offsets
ser = Series([Timestamp("20130101 9:01"), Timestamp("20130101 9:02")])
expected = Series(
[Timestamp("20130101 9:01:05"), Timestamp("20130101 9:02:05")]
)
ser = tm.box_expected(ser, box_with_array)
expected = tm.box_expected(expected, box_with_array)
result = ser + pd.offsets.Second(5)
tm.assert_equal(result, expected)
result2 = pd.offsets.Second(5) + ser
tm.assert_equal(result2, expected)
def test_dt64arr_series_sub_tick_DateOffset(self, box_with_array):
# GH#4532
# operate with pd.offsets
ser = Series([Timestamp("20130101 9:01"), Timestamp("20130101 9:02")])
expected = Series(
[Timestamp("20130101 9:00:55"), Timestamp("20130101 9:01:55")]
)
ser = tm.box_expected(ser, box_with_array)
expected = tm.box_expected(expected, box_with_array)
result = ser - pd.offsets.Second(5)
tm.assert_equal(result, expected)
result2 = -pd.offsets.Second(5) + ser
tm.assert_equal(result2, expected)
msg = "(bad|unsupported) operand type for unary"
with pytest.raises(TypeError, match=msg):
pd.offsets.Second(5) - ser
@pytest.mark.parametrize(
"cls_name", ["Day", "Hour", "Minute", "Second", "Milli", "Micro", "Nano"]
)
def test_dt64arr_add_sub_tick_DateOffset_smoke(self, cls_name, box_with_array):
# GH#4532
# smoke tests for valid DateOffsets
ser = Series([Timestamp("20130101 9:01"), Timestamp("20130101 9:02")])
ser = tm.box_expected(ser, box_with_array)
offset_cls = getattr(pd.offsets, cls_name)
ser + offset_cls(5)
offset_cls(5) + ser
ser - offset_cls(5)
def test_dti_add_tick_tzaware(self, tz_aware_fixture, box_with_array):
# GH#21610, GH#22163 ensure DataFrame doesn't return object-dtype
tz = tz_aware_fixture
if tz == "US/Pacific":
dates = date_range("2012-11-01", periods=3, tz=tz)
offset = dates + pd.offsets.Hour(5)
assert dates[0] + pd.offsets.Hour(5) == offset[0]
dates = date_range("2010-11-01 00:00", periods=3, tz=tz, freq="H")
expected = DatetimeIndex(
["2010-11-01 05:00", "2010-11-01 06:00", "2010-11-01 07:00"],
freq="H",
tz=tz,
)
dates = tm.box_expected(dates, box_with_array)
expected = tm.box_expected(expected, box_with_array)
# TODO: sub?
for scalar in [pd.offsets.Hour(5), np.timedelta64(5, "h"), timedelta(hours=5)]:
offset = dates + scalar
tm.assert_equal(offset, expected)
offset = scalar + dates
tm.assert_equal(offset, expected)
# -------------------------------------------------------------
# RelativeDelta DateOffsets
def test_dt64arr_add_sub_relativedelta_offsets(self, box_with_array):
# GH#10699
vec = DatetimeIndex(
[
Timestamp("2000-01-05 00:15:00"),
Timestamp("2000-01-31 00:23:00"),
Timestamp("2000-01-01"),
Timestamp("2000-03-31"),
Timestamp("2000-02-29"),
Timestamp("2000-12-31"),
Timestamp("2000-05-15"),
Timestamp("2001-06-15"),
]
)
vec = tm.box_expected(vec, box_with_array)
vec_items = vec.iloc[0] if box_with_array is pd.DataFrame else vec
# DateOffset relativedelta fastpath
relative_kwargs = [
("years", 2),
("months", 5),
("days", 3),
("hours", 5),
("minutes", 10),
("seconds", 2),
("microseconds", 5),
]
for i, (unit, value) in enumerate(relative_kwargs):
off = DateOffset(**{unit: value})
expected = DatetimeIndex([x + off for x in vec_items])
expected = tm.box_expected(expected, box_with_array)
tm.assert_equal(expected, vec + off)
expected = DatetimeIndex([x - off for x in vec_items])
expected = tm.box_expected(expected, box_with_array)
tm.assert_equal(expected, vec - off)
off = DateOffset(**dict(relative_kwargs[: i + 1]))
expected = DatetimeIndex([x + off for x in vec_items])
expected = tm.box_expected(expected, box_with_array)
tm.assert_equal(expected, vec + off)
expected = DatetimeIndex([x - off for x in vec_items])
expected = tm.box_expected(expected, box_with_array)
tm.assert_equal(expected, vec - off)
msg = "(bad|unsupported) operand type for unary"
with pytest.raises(TypeError, match=msg):
off - vec
# -------------------------------------------------------------
# Non-Tick, Non-RelativeDelta DateOffsets
# TODO: redundant with test_dt64arr_add_sub_DateOffset? that includes
# tz-aware cases which this does not
@pytest.mark.parametrize(
"cls_and_kwargs",
[
"YearBegin",
("YearBegin", {"month": 5}),
"YearEnd",
("YearEnd", {"month": 5}),
"MonthBegin",
"MonthEnd",
"SemiMonthEnd",
"SemiMonthBegin",
"Week",
("Week", {"weekday": 3}),
"Week",
("Week", {"weekday": 6}),
"BusinessDay",
"BDay",
"QuarterEnd",
"QuarterBegin",
"CustomBusinessDay",
"CDay",
"CBMonthEnd",
"CBMonthBegin",
"BMonthBegin",
"BMonthEnd",
"BusinessHour",
"BYearBegin",
"BYearEnd",
"BQuarterBegin",
("LastWeekOfMonth", {"weekday": 2}),
(
"FY5253Quarter",
{
"qtr_with_extra_week": 1,
"startingMonth": 1,
"weekday": 2,
"variation": "nearest",
},
),
("FY5253", {"weekday": 0, "startingMonth": 2, "variation": "nearest"}),
("WeekOfMonth", {"weekday": 2, "week": 2}),
"Easter",
("DateOffset", {"day": 4}),
("DateOffset", {"month": 5}),
],
)
@pytest.mark.parametrize("normalize", [True, False])
@pytest.mark.parametrize("n", [0, 5])
def test_dt64arr_add_sub_DateOffsets(
self, box_with_array, n, normalize, cls_and_kwargs
):
# GH#10699
# assert vectorized operation matches pointwise operations
if isinstance(cls_and_kwargs, tuple):
# If cls_name param is a tuple, then 2nd entry is kwargs for
# the offset constructor
cls_name, kwargs = cls_and_kwargs
else:
cls_name = cls_and_kwargs
kwargs = {}
if n == 0 and cls_name in [
"WeekOfMonth",
"LastWeekOfMonth",
"FY5253Quarter",
"FY5253",
]:
# passing n = 0 is invalid for these offset classes
return
vec = DatetimeIndex(
[
Timestamp("2000-01-05 00:15:00"),
Timestamp("2000-01-31 00:23:00"),
Timestamp("2000-01-01"),
Timestamp("2000-03-31"),
Timestamp("2000-02-29"),
Timestamp("2000-12-31"),
Timestamp("2000-05-15"),
Timestamp("2001-06-15"),
]
)
vec = tm.box_expected(vec, box_with_array)
vec_items = vec.iloc[0] if box_with_array is pd.DataFrame else vec
offset_cls = getattr(pd.offsets, cls_name)
with warnings.catch_warnings(record=True):
# pandas.errors.PerformanceWarning: Non-vectorized DateOffset being
# applied to Series or DatetimeIndex
# we aren't testing that here, so ignore.
warnings.simplefilter("ignore", PerformanceWarning)
offset = offset_cls(n, normalize=normalize, **kwargs)
expected = DatetimeIndex([x + offset for x in vec_items])
expected = tm.box_expected(expected, box_with_array)
tm.assert_equal(expected, vec + offset)
expected = DatetimeIndex([x - offset for x in vec_items])
expected = tm.box_expected(expected, box_with_array)
tm.assert_equal(expected, vec - offset)
expected = DatetimeIndex([offset + x for x in vec_items])
expected = tm.box_expected(expected, box_with_array)
tm.assert_equal(expected, offset + vec)
msg = "(bad|unsupported) operand type for unary"
with pytest.raises(TypeError, match=msg):
offset - vec
def test_dt64arr_add_sub_DateOffset(self, box_with_array):
# GH#10699
s = date_range("2000-01-01", "2000-01-31", name="a")
s = tm.box_expected(s, box_with_array)
result = s + DateOffset(years=1)
result2 = DateOffset(years=1) + s
exp = date_range("2001-01-01", "2001-01-31", name="a")._with_freq(None)
exp = tm.box_expected(exp, box_with_array)
tm.assert_equal(result, exp)
tm.assert_equal(result2, exp)
result = s - DateOffset(years=1)
exp = date_range("1999-01-01", "1999-01-31", name="a")._with_freq(None)
exp = tm.box_expected(exp, box_with_array)
tm.assert_equal(result, exp)
s = DatetimeIndex(
[
Timestamp("2000-01-15 00:15:00", tz="US/Central"),
Timestamp("2000-02-15", tz="US/Central"),
],
name="a",
)
s = tm.box_expected(s, box_with_array)
result = s + pd.offsets.Day()
result2 = pd.offsets.Day() + s
exp = DatetimeIndex(
[
Timestamp("2000-01-16 00:15:00", tz="US/Central"),
Timestamp("2000-02-16", tz="US/Central"),
],
name="a",
)
exp = tm.box_expected(exp, box_with_array)
tm.assert_equal(result, exp)
tm.assert_equal(result2, exp)
s = DatetimeIndex(
[
Timestamp("2000-01-15 00:15:00", tz="US/Central"),
Timestamp("2000-02-15", tz="US/Central"),
],
name="a",
)
s = tm.box_expected(s, box_with_array)
result = s + pd.offsets.MonthEnd()
result2 = pd.offsets.MonthEnd() + s
exp = DatetimeIndex(
[
Timestamp("2000-01-31 00:15:00", tz="US/Central"),
Timestamp("2000-02-29", tz="US/Central"),
],
name="a",
)
exp = tm.box_expected(exp, box_with_array)
tm.assert_equal(result, exp)
tm.assert_equal(result2, exp)
@pytest.mark.parametrize(
"other",
[
np.array([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)]),
np.array([pd.offsets.DateOffset(years=1), pd.offsets.MonthEnd()]),
np.array( # matching offsets
[pd.offsets.DateOffset(years=1), pd.offsets.DateOffset(years=1)]
),
],
)
@pytest.mark.parametrize("op", [operator.add, roperator.radd, operator.sub])
@pytest.mark.parametrize("box_other", [True, False])
def test_dt64arr_add_sub_offset_array(
self, tz_naive_fixture, box_with_array, box_other, op, other
):
# GH#18849
# GH#10699 array of offsets
tz = tz_naive_fixture
dti = date_range("2017-01-01", periods=2, tz=tz)
dtarr = tm.box_expected(dti, box_with_array)
other = np.array([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)])
expected = DatetimeIndex([op(dti[n], other[n]) for n in range(len(dti))])
expected = tm.box_expected(expected, box_with_array)
if box_other:
other = tm.box_expected(other, box_with_array)
with tm.assert_produces_warning(PerformanceWarning):
res = op(dtarr, other)
tm.assert_equal(res, expected)
@pytest.mark.parametrize(
"op, offset, exp, exp_freq",
[
(
"__add__",
DateOffset(months=3, days=10),
[
Timestamp("2014-04-11"),
Timestamp("2015-04-11"),
Timestamp("2016-04-11"),
Timestamp("2017-04-11"),
],
None,
),
(
"__add__",
DateOffset(months=3),
[
Timestamp("2014-04-01"),
Timestamp("2015-04-01"),
Timestamp("2016-04-01"),
Timestamp("2017-04-01"),
],
"AS-APR",
),
(
"__sub__",
DateOffset(months=3, days=10),
[
Timestamp("2013-09-21"),
Timestamp("2014-09-21"),
Timestamp("2015-09-21"),
Timestamp("2016-09-21"),
],
None,
),
(
"__sub__",
DateOffset(months=3),
[
Timestamp("2013-10-01"),
Timestamp("2014-10-01"),
Timestamp("2015-10-01"),
Timestamp("2016-10-01"),
],
"AS-OCT",
),
],
)
def test_dti_add_sub_nonzero_mth_offset(
self, op, offset, exp, exp_freq, tz_aware_fixture, box_with_array
):
# GH 26258
tz = tz_aware_fixture
date = date_range(start="01 Jan 2014", end="01 Jan 2017", freq="AS", tz=tz)
date = tm.box_expected(date, box_with_array, False)
mth = getattr(date, op)
result = mth(offset)
expected = DatetimeIndex(exp, tz=tz)
expected = tm.box_expected(expected, box_with_array, False)
tm.assert_equal(result, expected)
class TestDatetime64OverflowHandling:
# TODO: box + de-duplicate
def test_dt64_overflow_masking(self, box_with_array):
# GH#25317
left = Series([Timestamp("1969-12-31")])
right = Series([NaT])
left = tm.box_expected(left, box_with_array)
right = tm.box_expected(right, box_with_array)
expected = TimedeltaIndex([NaT])
expected = tm.box_expected(expected, box_with_array)
result = left - right
tm.assert_equal(result, expected)
def test_dt64_series_arith_overflow(self):
# GH#12534, fixed by GH#19024
dt = Timestamp("1700-01-31")
td = Timedelta("20000 Days")
dti = date_range("1949-09-30", freq="100Y", periods=4)
ser = Series(dti)
msg = "Overflow in int64 addition"
with pytest.raises(OverflowError, match=msg):
ser - dt
with pytest.raises(OverflowError, match=msg):
dt - ser
with pytest.raises(OverflowError, match=msg):
ser + td
with pytest.raises(OverflowError, match=msg):
td + ser
ser.iloc[-1] = NaT
expected = Series(
["2004-10-03", "2104-10-04", "2204-10-04", "NaT"], dtype="datetime64[ns]"
)
res = ser + td
tm.assert_series_equal(res, expected)
res = td + ser
tm.assert_series_equal(res, expected)
ser.iloc[1:] = NaT
expected = Series(["91279 Days", "NaT", "NaT", "NaT"], dtype="timedelta64[ns]")
res = ser - dt
tm.assert_series_equal(res, expected)
res = dt - ser
tm.assert_series_equal(res, -expected)
def test_datetimeindex_sub_timestamp_overflow(self):
dtimax = pd.to_datetime(["now", Timestamp.max])
dtimin = pd.to_datetime(["now", Timestamp.min])
tsneg = Timestamp("1950-01-01")
ts_neg_variants = [
tsneg,
tsneg.to_pydatetime(),
tsneg.to_datetime64().astype("datetime64[ns]"),
tsneg.to_datetime64().astype("datetime64[D]"),
]
tspos = Timestamp("1980-01-01")
ts_pos_variants = [
tspos,
tspos.to_pydatetime(),
tspos.to_datetime64().astype("datetime64[ns]"),
tspos.to_datetime64().astype("datetime64[D]"),
]
msg = "Overflow in int64 addition"
for variant in ts_neg_variants:
with pytest.raises(OverflowError, match=msg):
dtimax - variant
expected = Timestamp.max.value - tspos.value
for variant in ts_pos_variants:
res = dtimax - variant
assert res[1].value == expected
expected = Timestamp.min.value - tsneg.value
for variant in ts_neg_variants:
res = dtimin - variant
assert res[1].value == expected
for variant in ts_pos_variants:
with pytest.raises(OverflowError, match=msg):
dtimin - variant
def test_datetimeindex_sub_datetimeindex_overflow(self):
# GH#22492, GH#22508
dtimax = pd.to_datetime(["now", Timestamp.max])
dtimin = pd.to_datetime(["now", Timestamp.min])
ts_neg = pd.to_datetime(["1950-01-01", "1950-01-01"])
ts_pos = pd.to_datetime(["1980-01-01", "1980-01-01"])
# General tests
expected = Timestamp.max.value - ts_pos[1].value
result = dtimax - ts_pos
assert result[1].value == expected
expected = Timestamp.min.value - ts_neg[1].value
result = dtimin - ts_neg
assert result[1].value == expected
msg = "Overflow in int64 addition"
with pytest.raises(OverflowError, match=msg):
dtimax - ts_neg
with pytest.raises(OverflowError, match=msg):
dtimin - ts_pos
# Edge cases
tmin = pd.to_datetime([Timestamp.min])
t1 = tmin + Timedelta.max + Timedelta("1us")
with pytest.raises(OverflowError, match=msg):
t1 - tmin
tmax = pd.to_datetime([Timestamp.max])
t2 = tmax + Timedelta.min - Timedelta("1us")
with pytest.raises(OverflowError, match=msg):
tmax - t2
class TestTimestampSeriesArithmetic:
def test_empty_series_add_sub(self):
# GH#13844
a = Series(dtype="M8[ns]")
b = Series(dtype="m8[ns]")
tm.assert_series_equal(a, a + b)
tm.assert_series_equal(a, a - b)
tm.assert_series_equal(a, b + a)
msg = "cannot subtract"
with pytest.raises(TypeError, match=msg):
b - a
def test_operators_datetimelike(self):
# ## timedelta64 ###
td1 = Series([timedelta(minutes=5, seconds=3)] * 3)
td1.iloc[2] = np.nan
# ## datetime64 ###
dt1 = Series(
[
Timestamp("20111230"),
Timestamp("20120101"),
Timestamp("20120103"),
]
)
dt1.iloc[2] = np.nan
dt2 = Series(
[
Timestamp("20111231"),
Timestamp("20120102"),
Timestamp("20120104"),
]
)
dt1 - dt2
dt2 - dt1
# datetime64 with timetimedelta
dt1 + td1
td1 + dt1
dt1 - td1
# timetimedelta with datetime64
td1 + dt1
dt1 + td1
def test_dt64ser_sub_datetime_dtype(self):
ts = Timestamp(datetime(1993, 1, 7, 13, 30, 00))
dt = datetime(1993, 6, 22, 13, 30)
ser = Series([ts])
result = pd.to_timedelta(np.abs(ser - dt))
assert result.dtype == "timedelta64[ns]"
# -------------------------------------------------------------
# TODO: This next block of tests came from tests.series.test_operators,
# needs to be de-duplicated and parametrized over `box` classes
def test_operators_datetimelike_invalid(self, all_arithmetic_operators):
# these are all TypeEror ops
op_str = all_arithmetic_operators
def check(get_ser, test_ser):
# check that we are getting a TypeError
# with 'operate' (from core/ops.py) for the ops that are not
# defined
op = getattr(get_ser, op_str, None)
# Previously, _validate_for_numeric_binop in core/indexes/base.py
# did this for us.
with pytest.raises(
TypeError, match="operate|[cC]annot|unsupported operand"
):
op(test_ser)
# ## timedelta64 ###
td1 = Series([timedelta(minutes=5, seconds=3)] * 3)
td1.iloc[2] = np.nan
# ## datetime64 ###
dt1 = Series(
[Timestamp("20111230"), Timestamp("20120101"), Timestamp("20120103")]
)
dt1.iloc[2] = np.nan
dt2 = Series(
[Timestamp("20111231"), Timestamp("20120102"), Timestamp("20120104")]
)
if op_str not in ["__sub__", "__rsub__"]:
check(dt1, dt2)
# ## datetime64 with timetimedelta ###
# TODO(jreback) __rsub__ should raise?
if op_str not in ["__add__", "__radd__", "__sub__"]:
check(dt1, td1)
# 8260, 10763
# datetime64 with tz
tz = "US/Eastern"
dt1 = Series(date_range("2000-01-01 09:00:00", periods=5, tz=tz), name="foo")
dt2 = dt1.copy()
dt2.iloc[2] = np.nan
td1 = Series(pd.timedelta_range("1 days 1 min", periods=5, freq="H"))
td2 = td1.copy()
td2.iloc[1] = np.nan
if op_str not in ["__add__", "__radd__", "__sub__", "__rsub__"]:
check(dt2, td2)
def test_sub_single_tz(self):
# GH#12290
s1 = Series([Timestamp("2016-02-10", tz="America/Sao_Paulo")])
s2 = Series([Timestamp("2016-02-08", tz="America/Sao_Paulo")])
result = s1 - s2
expected = Series([Timedelta("2days")])
tm.assert_series_equal(result, expected)
result = s2 - s1
expected = Series([Timedelta("-2days")])
tm.assert_series_equal(result, expected)
def test_dt64tz_series_sub_dtitz(self):
# GH#19071 subtracting tzaware DatetimeIndex from tzaware Series
# (with same tz) raises, fixed by #19024
dti = date_range("1999-09-30", periods=10, tz="US/Pacific")
ser = Series(dti)
expected = Series(TimedeltaIndex(["0days"] * 10))
res = dti - ser
tm.assert_series_equal(res, expected)
res = ser - dti
tm.assert_series_equal(res, expected)
def test_sub_datetime_compat(self):
# see GH#14088
s = Series([datetime(2016, 8, 23, 12, tzinfo=pytz.utc), NaT])
dt = datetime(2016, 8, 22, 12, tzinfo=pytz.utc)
exp = Series([Timedelta("1 days"), NaT])
tm.assert_series_equal(s - dt, exp)
tm.assert_series_equal(s - Timestamp(dt), exp)
def test_dt64_series_add_mixed_tick_DateOffset(self):
# GH#4532
# operate with pd.offsets
s = Series([Timestamp("20130101 9:01"), Timestamp("20130101 9:02")])
result = s + pd.offsets.Milli(5)
result2 = pd.offsets.Milli(5) + s
expected = Series(
[Timestamp("20130101 9:01:00.005"), Timestamp("20130101 9:02:00.005")]
)
tm.assert_series_equal(result, expected)
tm.assert_series_equal(result2, expected)
result = s + pd.offsets.Minute(5) + pd.offsets.Milli(5)
expected = Series(
[Timestamp("20130101 9:06:00.005"), Timestamp("20130101 9:07:00.005")]
)
tm.assert_series_equal(result, expected)
def test_datetime64_ops_nat(self):
# GH#11349
datetime_series = Series([NaT, Timestamp("19900315")])
nat_series_dtype_timestamp = Series([NaT, NaT], dtype="datetime64[ns]")
single_nat_dtype_datetime = Series([NaT], dtype="datetime64[ns]")
# subtraction
tm.assert_series_equal(-NaT + datetime_series, nat_series_dtype_timestamp)
msg = "bad operand type for unary -: 'DatetimeArray'"
with pytest.raises(TypeError, match=msg):
-single_nat_dtype_datetime + datetime_series
tm.assert_series_equal(
-NaT + nat_series_dtype_timestamp, nat_series_dtype_timestamp
)
with pytest.raises(TypeError, match=msg):
-single_nat_dtype_datetime + nat_series_dtype_timestamp
# addition
tm.assert_series_equal(
nat_series_dtype_timestamp + NaT, nat_series_dtype_timestamp
)
tm.assert_series_equal(
NaT + nat_series_dtype_timestamp, nat_series_dtype_timestamp
)
tm.assert_series_equal(
nat_series_dtype_timestamp + NaT, nat_series_dtype_timestamp
)
tm.assert_series_equal(
NaT + nat_series_dtype_timestamp, nat_series_dtype_timestamp
)
# -------------------------------------------------------------
# Invalid Operations
# TODO: this block also needs to be de-duplicated and parametrized
@pytest.mark.parametrize(
"dt64_series",
[
Series([Timestamp("19900315"), Timestamp("19900315")]),
Series([NaT, Timestamp("19900315")]),
Series([NaT, NaT], dtype="datetime64[ns]"),
],
)
@pytest.mark.parametrize("one", [1, 1.0, np.array(1)])
def test_dt64_mul_div_numeric_invalid(self, one, dt64_series):
# multiplication
msg = "cannot perform .* with this index type"
with pytest.raises(TypeError, match=msg):
dt64_series * one
with pytest.raises(TypeError, match=msg):
one * dt64_series
# division
with pytest.raises(TypeError, match=msg):
dt64_series / one
with pytest.raises(TypeError, match=msg):
one / dt64_series
# TODO: parametrize over box
def test_dt64_series_add_intlike(self, tz_naive_fixture):
# GH#19123
tz = tz_naive_fixture
dti = DatetimeIndex(["2016-01-02", "2016-02-03", "NaT"], tz=tz)
ser = Series(dti)
other = Series([20, 30, 40], dtype="uint8")
msg = "|".join(
[
"Addition/subtraction of integers and integer-arrays",
"cannot subtract .* from ndarray",
]
)
assert_invalid_addsub_type(ser, 1, msg)
assert_invalid_addsub_type(ser, other, msg)
assert_invalid_addsub_type(ser, np.array(other), msg)
assert_invalid_addsub_type(ser, pd.Index(other), msg)
# -------------------------------------------------------------
# Timezone-Centric Tests
def test_operators_datetimelike_with_timezones(self):
tz = "US/Eastern"
dt1 = Series(date_range("2000-01-01 09:00:00", periods=5, tz=tz), name="foo")
dt2 = dt1.copy()
dt2.iloc[2] = np.nan
td1 = Series(pd.timedelta_range("1 days 1 min", periods=5, freq="H"))
td2 = td1.copy()
td2.iloc[1] = np.nan
assert td2._values.freq is None
result = dt1 + td1[0]
exp = (dt1.dt.tz_localize(None) + td1[0]).dt.tz_localize(tz)
tm.assert_series_equal(result, exp)
result = dt2 + td2[0]
exp = (dt2.dt.tz_localize(None) + td2[0]).dt.tz_localize(tz)
tm.assert_series_equal(result, exp)
# odd numpy behavior with scalar timedeltas
result = td1[0] + dt1
exp = (dt1.dt.tz_localize(None) + td1[0]).dt.tz_localize(tz)
tm.assert_series_equal(result, exp)
result = td2[0] + dt2
exp = (dt2.dt.tz_localize(None) + td2[0]).dt.tz_localize(tz)
tm.assert_series_equal(result, exp)
result = dt1 - td1[0]
exp = (dt1.dt.tz_localize(None) - td1[0]).dt.tz_localize(tz)
tm.assert_series_equal(result, exp)
msg = "(bad|unsupported) operand type for unary"
with pytest.raises(TypeError, match=msg):
td1[0] - dt1
result = dt2 - td2[0]
exp = (dt2.dt.tz_localize(None) - td2[0]).dt.tz_localize(tz)
tm.assert_series_equal(result, exp)
with pytest.raises(TypeError, match=msg):
td2[0] - dt2
result = dt1 + td1
exp = (dt1.dt.tz_localize(None) + td1).dt.tz_localize(tz)
tm.assert_series_equal(result, exp)
result = dt2 + td2
exp = (dt2.dt.tz_localize(None) + td2).dt.tz_localize(tz)
tm.assert_series_equal(result, exp)
result = dt1 - td1
exp = (dt1.dt.tz_localize(None) - td1).dt.tz_localize(tz)
tm.assert_series_equal(result, exp)
result = dt2 - td2
exp = (dt2.dt.tz_localize(None) - td2).dt.tz_localize(tz)
tm.assert_series_equal(result, exp)
msg = "cannot (add|subtract)"
with pytest.raises(TypeError, match=msg):
td1 - dt1
with pytest.raises(TypeError, match=msg):
td2 - dt2
class TestDatetimeIndexArithmetic:
# -------------------------------------------------------------
# Binary operations DatetimeIndex and int
def test_dti_addsub_int(self, tz_naive_fixture, one):
# Variants of `one` for #19012
tz = tz_naive_fixture
rng = date_range("2000-01-01 09:00", freq="H", periods=10, tz=tz)
msg = "Addition/subtraction of integers"
with pytest.raises(TypeError, match=msg):
rng + one
with pytest.raises(TypeError, match=msg):
rng += one
with pytest.raises(TypeError, match=msg):
rng - one
with pytest.raises(TypeError, match=msg):
rng -= one
# -------------------------------------------------------------
# __add__/__sub__ with integer arrays
@pytest.mark.parametrize("freq", ["H", "D"])
@pytest.mark.parametrize("int_holder", [np.array, pd.Index])
def test_dti_add_intarray_tick(self, int_holder, freq):
# GH#19959
dti = date_range("2016-01-01", periods=2, freq=freq)
other = int_holder([4, -1])
msg = "|".join(
["Addition/subtraction of integers", "cannot subtract DatetimeArray from"]
)
assert_invalid_addsub_type(dti, other, msg)
@pytest.mark.parametrize("freq", ["W", "M", "MS", "Q"])
@pytest.mark.parametrize("int_holder", [np.array, pd.Index])
def test_dti_add_intarray_non_tick(self, int_holder, freq):
# GH#19959
dti = date_range("2016-01-01", periods=2, freq=freq)
other = int_holder([4, -1])
msg = "|".join(
["Addition/subtraction of integers", "cannot subtract DatetimeArray from"]
)
assert_invalid_addsub_type(dti, other, msg)
@pytest.mark.parametrize("int_holder", [np.array, pd.Index])
def test_dti_add_intarray_no_freq(self, int_holder):
# GH#19959
dti = DatetimeIndex(["2016-01-01", "NaT", "2017-04-05 06:07:08"])
other = int_holder([9, 4, -1])
msg = "|".join(
["cannot subtract DatetimeArray from", "Addition/subtraction of integers"]
)
assert_invalid_addsub_type(dti, other, msg)
# -------------------------------------------------------------
# Binary operations DatetimeIndex and TimedeltaIndex/array
def test_dti_add_tdi(self, tz_naive_fixture):
# GH#17558
tz = tz_naive_fixture
dti = DatetimeIndex([Timestamp("2017-01-01", tz=tz)] * 10)
tdi = pd.timedelta_range("0 days", periods=10)
expected = date_range("2017-01-01", periods=10, tz=tz)
expected = expected._with_freq(None)
# add with TimdeltaIndex
result = dti + tdi
tm.assert_index_equal(result, expected)
result = tdi + dti
tm.assert_index_equal(result, expected)
# add with timedelta64 array
result = dti + tdi.values
tm.assert_index_equal(result, expected)
result = tdi.values + dti
tm.assert_index_equal(result, expected)
def test_dti_iadd_tdi(self, tz_naive_fixture):
# GH#17558
tz = tz_naive_fixture
dti = DatetimeIndex([Timestamp("2017-01-01", tz=tz)] * 10)
tdi = pd.timedelta_range("0 days", periods=10)
expected = date_range("2017-01-01", periods=10, tz=tz)
expected = expected._with_freq(None)
# iadd with TimdeltaIndex
result = DatetimeIndex([Timestamp("2017-01-01", tz=tz)] * 10)
result += tdi
tm.assert_index_equal(result, expected)
result = pd.timedelta_range("0 days", periods=10)
result += dti
tm.assert_index_equal(result, expected)
# iadd with timedelta64 array
result = DatetimeIndex([Timestamp("2017-01-01", tz=tz)] * 10)
result += tdi.values
tm.assert_index_equal(result, expected)
result = pd.timedelta_range("0 days", periods=10)
result += dti
tm.assert_index_equal(result, expected)
def test_dti_sub_tdi(self, tz_naive_fixture):
# GH#17558
tz = tz_naive_fixture
dti = DatetimeIndex([Timestamp("2017-01-01", tz=tz)] * 10)
tdi = pd.timedelta_range("0 days", periods=10)
expected = date_range("2017-01-01", periods=10, tz=tz, freq="-1D")
expected = expected._with_freq(None)
# sub with TimedeltaIndex
result = dti - tdi
tm.assert_index_equal(result, expected)
msg = "cannot subtract .*TimedeltaArray"
with pytest.raises(TypeError, match=msg):
tdi - dti
# sub with timedelta64 array
result = dti - tdi.values
tm.assert_index_equal(result, expected)
msg = "cannot subtract a datelike from a TimedeltaArray"
with pytest.raises(TypeError, match=msg):
tdi.values - dti
def test_dti_isub_tdi(self, tz_naive_fixture):
# GH#17558
tz = tz_naive_fixture
dti = DatetimeIndex([Timestamp("2017-01-01", tz=tz)] * 10)
tdi = pd.timedelta_range("0 days", periods=10)
expected = date_range("2017-01-01", periods=10, tz=tz, freq="-1D")
expected = expected._with_freq(None)
# isub with TimedeltaIndex
result = DatetimeIndex([Timestamp("2017-01-01", tz=tz)] * 10)
result -= tdi
tm.assert_index_equal(result, expected)
# DTA.__isub__ GH#43904
dta = dti._data.copy()
dta -= tdi
tm.assert_datetime_array_equal(dta, expected._data)
out = dti._data.copy()
np.subtract(out, tdi, out=out)
tm.assert_datetime_array_equal(out, expected._data)
msg = "cannot subtract .* from a TimedeltaArray"
with pytest.raises(TypeError, match=msg):
tdi -= dti
# isub with timedelta64 array
result = DatetimeIndex([Timestamp("2017-01-01", tz=tz)] * 10)
result -= tdi.values
| tm.assert_index_equal(result, expected) | pandas._testing.assert_index_equal |
# -*- coding: utf-8 -*-
"""Generator capacity factor plots .
This module contain methods that are related to the capacity factor
of generators and average output plots
"""
import logging
import numpy as np
import pandas as pd
import marmot.config.mconfig as mconfig
from marmot.plottingmodules.plotutils.plot_data_helper import PlotDataHelper
from marmot.plottingmodules.plotutils.plot_library import PlotLibrary
from marmot.plottingmodules.plotutils.plot_exceptions import (MissingInputData, MissingZoneData)
class MPlot(PlotDataHelper):
"""capacity_factor MPlot class.
All the plotting modules use this same class name.
This class contains plotting methods that are grouped based on the
current module name.
The capacity_factor.py module contain methods that are
related to the capacity factor of generators.
MPlot inherits from the PlotDataHelper class to assist in creating figures.
"""
def __init__(self, argument_dict: dict):
"""
Args:
argument_dict (dict): Dictionary containing all
arguments passed from MarmotPlot.
"""
# iterate over items in argument_dict and set as properties of class
# see key_list in Marmot_plot_main for list of properties
for prop in argument_dict:
self.__setattr__(prop, argument_dict[prop])
# Instantiation of MPlotHelperFunctions
super().__init__(self.Marmot_Solutions_folder, self.AGG_BY, self.ordered_gen,
self.PLEXOS_color_dict, self.Scenarios, self.ylabels,
self.xlabels, self.gen_names_dict, self.TECH_SUBSET,
Region_Mapping=self.Region_Mapping)
self.logger = logging.getLogger('marmot_plot.'+__name__)
self.x = mconfig.parser("figure_size","xdimension")
self.y = mconfig.parser("figure_size","ydimension")
def avg_output_when_committed(self,
start_date_range: str = None,
end_date_range: str = None, **_):
"""Creates barplots of the percentage average generation output when committed by technology type.
Each scenario is plotted by a different colored grouped bar.
Args:
start_date_range (str, optional): Defines a start date at which to represent data from.
Defaults to None.
end_date_range (str, optional): Defines a end date at which to represent data to.
Defaults to None.
Returns:
dict: dictionary containing the created plot and its data table.
"""
outputs = {}
# List of properties needed by the plot, properties are a set of tuples and contain 3 parts:
# required True/False, property name and scenarios required, scenarios must be a list.
properties = [(True,"generator_Generation",self.Scenarios),
(True,"generator_Installed_Capacity",self.Scenarios)]
# Runs get_formatted_data within PlotDataHelper to populate PlotDataHelper dictionary
# with all required properties, returns a 1 if required data is missing
check_input_data = self.get_formatted_data(properties)
if 1 in check_input_data:
return MissingInputData()
for zone_input in self.Zones:
CF_all_scenarios = | pd.DataFrame() | pandas.DataFrame |
from define_collection_wave import folder
from helpers import create_folder, headers
import requests
from datetime import date
import json
import pandas as pd
path_greggs = create_folder('4_Greggs',folder)
request_url = 'https://production-digital.greggs.co.uk/api/v1.0/articles/masters?ExcludeUnpublished=true&ExcludeDuplicates=true&ExcludeHiddenFromMenu=true'
product_list = requests.get(request_url, headers=headers).json()
with open(path_greggs + '/greggs.json', 'w') as f:
json.dump(product_list, f)
greggs = []
category_map = requests.get('https://api.storyblok.com/v2/cdn/datasource_entries/?datasource=category-ids&version=published&token=<KEY>').json().get('datasource_entries')
lookup = {cat.get('value'): cat.get('name')for cat in category_map}
for product in product_list:
cat_id = product.get('articleCategoryId')
product_dict = {
'collection_date':date.today().strftime("%b-%d-%Y"),
'rest_name': 'Greggs',
'menu_id': product.get('articleCode'),
'item_name': product.get('articleName'),
'servingsize': product.get('articleSize').get('size'),
'servingsizeunit': product.get('articleSize').get('unitOfMeasure'),
'item_description': product.get('customerDescription').strip(),
'category': lookup[str(cat_id)],
'allergens': [allergen.get('name') for allergen in product.get('ingredients')]}
nutrient_dict = product.get('nutritionalValues')
for nutrient in nutrient_dict:
product_dict.update({nutrient.get('name'):nutrient.get('value'),
nutrient.get('name')+'_100': nutrient.get('valuePerHundredArticleSizeUnit')})
greggs.append(product_dict)
greggs = | pd.DataFrame(greggs) | pandas.DataFrame |
"""
Main interface module to use pyEPR.
Contains code to conenct to ansys and to analyze hfss files using the EPR method.
Further contains code to be able to do autogenerated reports, analysis, and such.
Copyright <NAME>, <NAME>, and the pyEPR tea
2015, 2016, 2017, 2018, 2019, 2020
"""
from __future__ import print_function # Python 2.7 and 3 compatibility
import os
import sys
import time
import pickle
import shutil
import warnings
import numpy as np
import pandas as pd
import matplotlib as mpl
import matplotlib.pyplot as plt
# Standard imports
from numpy import pi
from numpy.linalg import inv
from stat import S_ISREG, ST_CTIME, ST_MODE
from pandas import Series, DataFrame
from collections import OrderedDict
from pathlib import Path
# pyEPR custom imports
from . import ansys
from . import logger
from . import config
from . import Dict
from .ansys import ureg, CalcObject, ConstantVecCalcObject, set_property
from .toolbox.pythonic import print_NoNewLine, print_color, deprecated, fact, nck, \
divide_diagonal_by_2, print_matrix, DataFrame_col_diff, get_instance_vars,\
sort_df_col, sort_Series_idx
from .calcs.constants import epsilon_0, hbar, Planck, fluxQ
from .calcs.basic import CalcsBasic
from .calcs.back_box_numeric import bbq_hmt, make_dispersive
from .toolbox.plotting import cmap_discrete, legend_translucent
from .reports import plot_convergence_f_vspass, plot_convergence_max_df,\
plot_convergence_solved_elem, plot_convergence_maxdf_vs_sol
class Project_Info(object):
"""
Class containing options and information about the manipulation and analysis in HFSS.
Junction info:
-----------------------
self.junctions : OrderedDict()
A Josephson tunnel junction has to have its parameters specified here for the analysis.
Each junction is given a name and is specified by a dictionary.
It has the following properties:
`Lj_variable`: Name of HFSS variable that specifies junction inductance Lj defined
on the boundary condition in HFSS. DO NOT USE Global names that start
with $.
`rect`: Name of HFSS rectangle on which lumped boundary condition is specified.
`line`: Name of HFSS polyline which spans the length of the recntalge.
Used to define the voltage across the junction.
Used to define the current orientation for each junction.
Used to define sign of ZPF.
`length`: Length in HFSS of the junction rectangle and line
(specified in meters). You can use epr.parse_units('100um')
Example definition:
..code-block python
# Define a single junction
pinfo = Project_Info('')
pinfo.junctions['j1'] = {'Lj_variable' : 'Lj1',
'rect' : 'JJrect1',
'line' : 'JJline1',
'length' : parse_units('50um')} # Length is in meters
# Specify multiple junctions in HFSS model
n_junctions = 5
for i in range(1, 1+n_junctions):
pinfo.junctions[f'j{i}'] = {'Lj_variable' : f'Lj{i}',
'rect' : f'JJrect{i}',
'line' : f'JJline{i}',
'length' : parse_units('50um')}
HFSS app connection settings
-----------------------
project_path : str
Directory path to the hfss project file. Should be the directory, not the file.
default = None: Assumes the project is open, and thus gets the project based
on `project_name`
project_name : str, None
Name of the project within the project_path. "None" will get the current active one.
design_name : str, None
Name of the design within the project. "None" will get the current active one.
setup_name : str, None
Name of the setup within the design. "None" will get the current active one.
Additional init setting:
-----------------------
do_connect : True by default. Connect to HFSS
HFSS desgin settings
-----------------------
describe junction parameters
junc_rects = None
Name of junction rectangles in HFSS
junc_lines = None
Name of lines in HFSS used to define the current orientation for each junction
junc_LJ_names = None
Name of junction inductance variables in HFSS.
Note, DO NOT USE Global names that start with $.
junc_lens = None
Junciton rect. length, measured in meters.
"""
class _Dissipative:
#TODO: remove and turn to dict
def __init__(self):
self.dielectrics_bulk = None
self.dielectric_surfaces = None
self.resistive_surfaces = None
self.seams = None
def __init__(self, project_path=None, project_name=None, design_name=None,
setup_name=None, do_connect=True):
# Path: format path correctly to system convention
self.project_path = str(Path(project_path)) \
if not (project_path is None) else None
self.project_name = project_name
self.design_name = design_name
self.setup_name = setup_name
## HFSS desgin: describe junction parameters
# TODO: introduce modal labels
self.junctions = Dict() # See above for help
self.ports = Dict()
## Dissipative HFSS volumes and surfaces
self.dissipative = self._Dissipative()
self.options = config.ansys
# Conected to HFSS variable
self.app = None
self.desktop = None
self.project = None
self.design = None
self.setup = None
if do_connect:
self.connect()
_Forbidden = ['app', 'design', 'desktop', 'project',
'dissipative', 'setup', '_Forbidden', 'junctions']
def save(self):
'''
Return a dicitonary to save
'''
return dict(
pinfo=pd.Series(get_instance_vars(self, self._Forbidden)),
dissip=pd.Series(get_instance_vars(self.dissipative)),
options=pd.Series(get_instance_vars(self.options)),
junctions= | pd.DataFrame(self.junctions) | pandas.DataFrame |
import pandas as pd
from pandas import Period, offsets
from pandas.util import testing as tm
from pandas.tseries.frequencies import _period_code_map
class TestFreqConversion(tm.TestCase):
"Test frequency conversion of date objects"
def test_asfreq_corner(self):
val = Period(freq='A', year=2007)
result1 = val.asfreq('5t')
result2 = val.asfreq('t')
expected = Period('2007-12-31 23:59', freq='t')
self.assertEqual(result1.ordinal, expected.ordinal)
self.assertEqual(result1.freqstr, '5T')
self.assertEqual(result2.ordinal, expected.ordinal)
self.assertEqual(result2.freqstr, 'T')
def test_conv_annual(self):
# frequency conversion tests: from Annual Frequency
ival_A = Period(freq='A', year=2007)
ival_AJAN = Period(freq="A-JAN", year=2007)
ival_AJUN = Period(freq="A-JUN", year=2007)
ival_ANOV = Period(freq="A-NOV", year=2007)
ival_A_to_Q_start = Period(freq='Q', year=2007, quarter=1)
ival_A_to_Q_end = Period(freq='Q', year=2007, quarter=4)
ival_A_to_M_start = Period(freq='M', year=2007, month=1)
ival_A_to_M_end = Period(freq='M', year=2007, month=12)
ival_A_to_W_start = Period(freq='W', year=2007, month=1, day=1)
ival_A_to_W_end = Period(freq='W', year=2007, month=12, day=31)
ival_A_to_B_start = Period(freq='B', year=2007, month=1, day=1)
ival_A_to_B_end = Period(freq='B', year=2007, month=12, day=31)
ival_A_to_D_start = Period(freq='D', year=2007, month=1, day=1)
ival_A_to_D_end = Period(freq='D', year=2007, month=12, day=31)
ival_A_to_H_start = Period(freq='H', year=2007, month=1, day=1, hour=0)
ival_A_to_H_end = Period(freq='H', year=2007, month=12, day=31,
hour=23)
ival_A_to_T_start = Period(freq='Min', year=2007, month=1, day=1,
hour=0, minute=0)
ival_A_to_T_end = Period(freq='Min', year=2007, month=12, day=31,
hour=23, minute=59)
ival_A_to_S_start = Period(freq='S', year=2007, month=1, day=1, hour=0,
minute=0, second=0)
ival_A_to_S_end = Period(freq='S', year=2007, month=12, day=31,
hour=23, minute=59, second=59)
ival_AJAN_to_D_end = Period(freq='D', year=2007, month=1, day=31)
ival_AJAN_to_D_start = Period(freq='D', year=2006, month=2, day=1)
ival_AJUN_to_D_end = Period(freq='D', year=2007, month=6, day=30)
ival_AJUN_to_D_start = Period(freq='D', year=2006, month=7, day=1)
ival_ANOV_to_D_end = Period(freq='D', year=2007, month=11, day=30)
ival_ANOV_to_D_start = Period(freq='D', year=2006, month=12, day=1)
self.assertEqual(ival_A.asfreq('Q', 'S'), ival_A_to_Q_start)
self.assertEqual(ival_A.asfreq('Q', 'e'), ival_A_to_Q_end)
self.assertEqual(ival_A.asfreq('M', 's'), ival_A_to_M_start)
self.assertEqual(ival_A.asfreq('M', 'E'), ival_A_to_M_end)
self.assertEqual(ival_A.asfreq('W', 'S'), ival_A_to_W_start)
self.assertEqual(ival_A.asfreq('W', 'E'), ival_A_to_W_end)
self.assertEqual(ival_A.asfreq('B', 'S'), ival_A_to_B_start)
self.assertEqual(ival_A.asfreq('B', 'E'), ival_A_to_B_end)
self.assertEqual(ival_A.asfreq('D', 'S'), ival_A_to_D_start)
self.assertEqual(ival_A.asfreq('D', 'E'), ival_A_to_D_end)
self.assertEqual(ival_A.asfreq('H', 'S'), ival_A_to_H_start)
self.assertEqual(ival_A.asfreq('H', 'E'), ival_A_to_H_end)
self.assertEqual(ival_A.asfreq('min', 'S'), ival_A_to_T_start)
self.assertEqual(ival_A.asfreq('min', 'E'), ival_A_to_T_end)
self.assertEqual(ival_A.asfreq('T', 'S'), ival_A_to_T_start)
self.assertEqual(ival_A.asfreq('T', 'E'), ival_A_to_T_end)
self.assertEqual(ival_A.asfreq('S', 'S'), ival_A_to_S_start)
self.assertEqual(ival_A.asfreq('S', 'E'), ival_A_to_S_end)
self.assertEqual(ival_AJAN.asfreq('D', 'S'), ival_AJAN_to_D_start)
self.assertEqual(ival_AJAN.asfreq('D', 'E'), ival_AJAN_to_D_end)
self.assertEqual(ival_AJUN.asfreq('D', 'S'), ival_AJUN_to_D_start)
self.assertEqual(ival_AJUN.asfreq('D', 'E'), ival_AJUN_to_D_end)
self.assertEqual(ival_ANOV.asfreq('D', 'S'), ival_ANOV_to_D_start)
self.assertEqual(ival_ANOV.asfreq('D', 'E'), ival_ANOV_to_D_end)
self.assertEqual(ival_A.asfreq('A'), ival_A)
def test_conv_quarterly(self):
# frequency conversion tests: from Quarterly Frequency
ival_Q = Period(freq='Q', year=2007, quarter=1)
ival_Q_end_of_year = Period(freq='Q', year=2007, quarter=4)
ival_QEJAN = Period(freq="Q-JAN", year=2007, quarter=1)
ival_QEJUN = Period(freq="Q-JUN", year=2007, quarter=1)
ival_Q_to_A = Period(freq='A', year=2007)
ival_Q_to_M_start = Period(freq='M', year=2007, month=1)
ival_Q_to_M_end = Period(freq='M', year=2007, month=3)
ival_Q_to_W_start = Period(freq='W', year=2007, month=1, day=1)
ival_Q_to_W_end = Period(freq='W', year=2007, month=3, day=31)
ival_Q_to_B_start = Period(freq='B', year=2007, month=1, day=1)
ival_Q_to_B_end = Period(freq='B', year=2007, month=3, day=30)
ival_Q_to_D_start = Period(freq='D', year=2007, month=1, day=1)
ival_Q_to_D_end = Period(freq='D', year=2007, month=3, day=31)
ival_Q_to_H_start = Period(freq='H', year=2007, month=1, day=1, hour=0)
ival_Q_to_H_end = Period(freq='H', year=2007, month=3, day=31, hour=23)
ival_Q_to_T_start = Period(freq='Min', year=2007, month=1, day=1,
hour=0, minute=0)
ival_Q_to_T_end = Period(freq='Min', year=2007, month=3, day=31,
hour=23, minute=59)
ival_Q_to_S_start = Period(freq='S', year=2007, month=1, day=1, hour=0,
minute=0, second=0)
ival_Q_to_S_end = Period(freq='S', year=2007, month=3, day=31, hour=23,
minute=59, second=59)
ival_QEJAN_to_D_start = Period(freq='D', year=2006, month=2, day=1)
ival_QEJAN_to_D_end = Period(freq='D', year=2006, month=4, day=30)
ival_QEJUN_to_D_start = Period(freq='D', year=2006, month=7, day=1)
ival_QEJUN_to_D_end = Period(freq='D', year=2006, month=9, day=30)
self.assertEqual(ival_Q.asfreq('A'), ival_Q_to_A)
self.assertEqual(ival_Q_end_of_year.asfreq('A'), ival_Q_to_A)
self.assertEqual(ival_Q.asfreq('M', 'S'), ival_Q_to_M_start)
self.assertEqual(ival_Q.asfreq('M', 'E'), ival_Q_to_M_end)
self.assertEqual(ival_Q.asfreq('W', 'S'), ival_Q_to_W_start)
self.assertEqual(ival_Q.asfreq('W', 'E'), ival_Q_to_W_end)
self.assertEqual(ival_Q.asfreq('B', 'S'), ival_Q_to_B_start)
self.assertEqual(ival_Q.asfreq('B', 'E'), ival_Q_to_B_end)
self.assertEqual(ival_Q.asfreq('D', 'S'), ival_Q_to_D_start)
self.assertEqual(ival_Q.asfreq('D', 'E'), ival_Q_to_D_end)
self.assertEqual(ival_Q.asfreq('H', 'S'), ival_Q_to_H_start)
self.assertEqual(ival_Q.asfreq('H', 'E'), ival_Q_to_H_end)
self.assertEqual(ival_Q.asfreq('Min', 'S'), ival_Q_to_T_start)
self.assertEqual(ival_Q.asfreq('Min', 'E'), ival_Q_to_T_end)
self.assertEqual(ival_Q.asfreq('S', 'S'), ival_Q_to_S_start)
self.assertEqual(ival_Q.asfreq('S', 'E'), ival_Q_to_S_end)
self.assertEqual(ival_QEJAN.asfreq('D', 'S'), ival_QEJAN_to_D_start)
self.assertEqual(ival_QEJAN.asfreq('D', 'E'), ival_QEJAN_to_D_end)
self.assertEqual(ival_QEJUN.asfreq('D', 'S'), ival_QEJUN_to_D_start)
self.assertEqual(ival_QEJUN.asfreq('D', 'E'), ival_QEJUN_to_D_end)
self.assertEqual(ival_Q.asfreq('Q'), ival_Q)
def test_conv_monthly(self):
# frequency conversion tests: from Monthly Frequency
ival_M = Period(freq='M', year=2007, month=1)
ival_M_end_of_year = Period(freq='M', year=2007, month=12)
ival_M_end_of_quarter = Period(freq='M', year=2007, month=3)
ival_M_to_A = Period(freq='A', year=2007)
ival_M_to_Q = Period(freq='Q', year=2007, quarter=1)
ival_M_to_W_start = Period(freq='W', year=2007, month=1, day=1)
ival_M_to_W_end = Period(freq='W', year=2007, month=1, day=31)
ival_M_to_B_start = Period(freq='B', year=2007, month=1, day=1)
ival_M_to_B_end = Period(freq='B', year=2007, month=1, day=31)
ival_M_to_D_start = Period(freq='D', year=2007, month=1, day=1)
ival_M_to_D_end = Period(freq='D', year=2007, month=1, day=31)
ival_M_to_H_start = Period(freq='H', year=2007, month=1, day=1, hour=0)
ival_M_to_H_end = Period(freq='H', year=2007, month=1, day=31, hour=23)
ival_M_to_T_start = Period(freq='Min', year=2007, month=1, day=1,
hour=0, minute=0)
ival_M_to_T_end = Period(freq='Min', year=2007, month=1, day=31,
hour=23, minute=59)
ival_M_to_S_start = Period(freq='S', year=2007, month=1, day=1, hour=0,
minute=0, second=0)
ival_M_to_S_end = Period(freq='S', year=2007, month=1, day=31, hour=23,
minute=59, second=59)
self.assertEqual(ival_M.asfreq('A'), ival_M_to_A)
self.assertEqual(ival_M_end_of_year.asfreq('A'), ival_M_to_A)
self.assertEqual(ival_M.asfreq('Q'), ival_M_to_Q)
self.assertEqual(ival_M_end_of_quarter.asfreq('Q'), ival_M_to_Q)
self.assertEqual(ival_M.asfreq('W', 'S'), ival_M_to_W_start)
self.assertEqual(ival_M.asfreq('W', 'E'), ival_M_to_W_end)
self.assertEqual(ival_M.asfreq('B', 'S'), ival_M_to_B_start)
self.assertEqual(ival_M.asfreq('B', 'E'), ival_M_to_B_end)
self.assertEqual(ival_M.asfreq('D', 'S'), ival_M_to_D_start)
self.assertEqual(ival_M.asfreq('D', 'E'), ival_M_to_D_end)
self.assertEqual(ival_M.asfreq('H', 'S'), ival_M_to_H_start)
self.assertEqual(ival_M.asfreq('H', 'E'), ival_M_to_H_end)
self.assertEqual(ival_M.asfreq('Min', 'S'), ival_M_to_T_start)
self.assertEqual(ival_M.asfreq('Min', 'E'), ival_M_to_T_end)
self.assertEqual(ival_M.asfreq('S', 'S'), ival_M_to_S_start)
self.assertEqual(ival_M.asfreq('S', 'E'), ival_M_to_S_end)
self.assertEqual(ival_M.asfreq('M'), ival_M)
def test_conv_weekly(self):
# frequency conversion tests: from Weekly Frequency
ival_W = Period(freq='W', year=2007, month=1, day=1)
ival_WSUN = Period(freq='W', year=2007, month=1, day=7)
ival_WSAT = Period(freq='W-SAT', year=2007, month=1, day=6)
ival_WFRI = Period(freq='W-FRI', year=2007, month=1, day=5)
ival_WTHU = Period(freq='W-THU', year=2007, month=1, day=4)
ival_WWED = Period(freq='W-WED', year=2007, month=1, day=3)
ival_WTUE = Period(freq='W-TUE', year=2007, month=1, day=2)
ival_WMON = Period(freq='W-MON', year=2007, month=1, day=1)
ival_WSUN_to_D_start = Period(freq='D', year=2007, month=1, day=1)
ival_WSUN_to_D_end = Period(freq='D', year=2007, month=1, day=7)
ival_WSAT_to_D_start = Period(freq='D', year=2006, month=12, day=31)
ival_WSAT_to_D_end = Period(freq='D', year=2007, month=1, day=6)
ival_WFRI_to_D_start = Period(freq='D', year=2006, month=12, day=30)
ival_WFRI_to_D_end = Period(freq='D', year=2007, month=1, day=5)
ival_WTHU_to_D_start = Period(freq='D', year=2006, month=12, day=29)
ival_WTHU_to_D_end = | Period(freq='D', year=2007, month=1, day=4) | pandas.Period |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import pandas
from pandas.api.types import is_scalar
from pandas.compat import to_str, string_types, numpy as numpy_compat, cPickle as pkl
import pandas.core.common as com
from pandas.core.dtypes.common import (
_get_dtype_from_object,
is_list_like,
is_numeric_dtype,
is_datetime_or_timedelta_dtype,
is_dtype_equal,
is_object_dtype,
is_integer_dtype,
)
from pandas.core.index import _ensure_index_from_sequences
from pandas.core.indexing import check_bool_indexer, convert_to_index_sliceable
from pandas.util._validators import validate_bool_kwarg
import itertools
import functools
import numpy as np
import re
import sys
import warnings
from modin.error_message import ErrorMessage
from .utils import from_pandas, to_pandas, _inherit_docstrings
from .iterator import PartitionIterator
from .series import SeriesView
@_inherit_docstrings(
pandas.DataFrame, excluded=[pandas.DataFrame, pandas.DataFrame.__init__]
)
class DataFrame(object):
def __init__(
self,
data=None,
index=None,
columns=None,
dtype=None,
copy=False,
query_compiler=None,
):
"""Distributed DataFrame object backed by Pandas dataframes.
Args:
data (numpy ndarray (structured or homogeneous) or dict):
Dict can contain Series, arrays, constants, or list-like
objects.
index (pandas.Index, list, ObjectID): The row index for this
DataFrame.
columns (pandas.Index): The column names for this DataFrame, in
pandas Index object.
dtype: Data type to force. Only a single dtype is allowed.
If None, infer
copy (boolean): Copy data from inputs.
Only affects DataFrame / 2d ndarray input.
query_compiler: A query compiler object to manage distributed computation.
"""
if isinstance(data, DataFrame):
self._query_compiler = data._query_compiler
return
# Check type of data and use appropriate constructor
if data is not None or query_compiler is None:
pandas_df = pandas.DataFrame(
data=data, index=index, columns=columns, dtype=dtype, copy=copy
)
self._query_compiler = from_pandas(pandas_df)._query_compiler
else:
self._query_compiler = query_compiler
def __str__(self):
return repr(self)
def _build_repr_df(self, num_rows, num_cols):
# Add one here so that pandas automatically adds the dots
# It turns out to be faster to extract 2 extra rows and columns than to
# build the dots ourselves.
num_rows_for_head = num_rows // 2 + 1
num_cols_for_front = num_cols // 2 + 1
if len(self.index) <= num_rows:
head = self._query_compiler
tail = None
else:
head = self._query_compiler.head(num_rows_for_head)
tail = self._query_compiler.tail(num_rows_for_head)
if len(self.columns) <= num_cols:
head_front = head.to_pandas()
# Creating these empty to make the concat logic simpler
head_back = pandas.DataFrame()
tail_back = pandas.DataFrame()
if tail is not None:
tail_front = tail.to_pandas()
else:
tail_front = pandas.DataFrame()
else:
head_front = head.front(num_cols_for_front).to_pandas()
head_back = head.back(num_cols_for_front).to_pandas()
if tail is not None:
tail_front = tail.front(num_cols_for_front).to_pandas()
tail_back = tail.back(num_cols_for_front).to_pandas()
else:
tail_front = tail_back = pandas.DataFrame()
head_for_repr = pandas.concat([head_front, head_back], axis=1)
tail_for_repr = pandas.concat([tail_front, tail_back], axis=1)
return pandas.concat([head_for_repr, tail_for_repr])
def __repr__(self):
# In the future, we can have this be configurable, just like Pandas.
num_rows = 60
num_cols = 30
result = repr(self._build_repr_df(num_rows, num_cols))
if len(self.index) > num_rows or len(self.columns) > num_cols:
# The split here is so that we don't repr pandas row lengths.
return result.rsplit("\n\n", 1)[0] + "\n\n[{0} rows x {1} columns]".format(
len(self.index), len(self.columns)
)
else:
return result
def _repr_html_(self):
"""repr function for rendering in Jupyter Notebooks like Pandas
Dataframes.
Returns:
The HTML representation of a Dataframe.
"""
# In the future, we can have this be configurable, just like Pandas.
num_rows = 60
num_cols = 20
# We use pandas _repr_html_ to get a string of the HTML representation
# of the dataframe.
result = self._build_repr_df(num_rows, num_cols)._repr_html_()
if len(self.index) > num_rows or len(self.columns) > num_cols:
# We split so that we insert our correct dataframe dimensions.
return result.split("<p>")[
0
] + "<p>{0} rows x {1} columns</p>\n</div>".format(
len(self.index), len(self.columns)
)
else:
return result
def _get_index(self):
"""Get the index for this DataFrame.
Returns:
The union of all indexes across the partitions.
"""
return self._query_compiler.index
def _get_columns(self):
"""Get the columns for this DataFrame.
Returns:
The union of all indexes across the partitions.
"""
return self._query_compiler.columns
def _set_index(self, new_index):
"""Set the index for this DataFrame.
Args:
new_index: The new index to set this
"""
self._query_compiler.index = new_index
def _set_columns(self, new_columns):
"""Set the columns for this DataFrame.
Args:
new_index: The new index to set this
"""
self._query_compiler.columns = new_columns
index = property(_get_index, _set_index)
columns = property(_get_columns, _set_columns)
def _validate_eval_query(self, expr, **kwargs):
"""Helper function to check the arguments to eval() and query()
Args:
expr: The expression to evaluate. This string cannot contain any
Python statements, only Python expressions.
"""
if isinstance(expr, str) and expr is "":
raise ValueError("expr cannot be an empty string")
if isinstance(expr, str) and "@" in expr:
ErrorMessage.not_implemented("Local variables not yet supported in eval.")
if isinstance(expr, str) and "not" in expr:
if "parser" in kwargs and kwargs["parser"] == "python":
ErrorMessage.not_implemented("'Not' nodes are not implemented.")
@property
def size(self):
"""Get the number of elements in the DataFrame.
Returns:
The number of elements in the DataFrame.
"""
return len(self.index) * len(self.columns)
@property
def ndim(self):
"""Get the number of dimensions for this DataFrame.
Returns:
The number of dimensions for this DataFrame.
"""
# DataFrames have an invariant that requires they be 2 dimensions.
return 2
@property
def ftypes(self):
"""Get the ftypes for this DataFrame.
Returns:
The ftypes for this DataFrame.
"""
# The ftypes are common across all partitions.
# The first partition will be enough.
dtypes = self.dtypes.copy()
ftypes = ["{0}:dense".format(str(dtype)) for dtype in dtypes.values]
result = pandas.Series(ftypes, index=self.columns)
return result
@property
def dtypes(self):
"""Get the dtypes for this DataFrame.
Returns:
The dtypes for this DataFrame.
"""
return self._query_compiler.dtypes
@property
def empty(self):
"""Determines if the DataFrame is empty.
Returns:
True if the DataFrame is empty.
False otherwise.
"""
return len(self.columns) == 0 or len(self.index) == 0
@property
def values(self):
"""Create a numpy array with the values from this DataFrame.
Returns:
The numpy representation of this DataFrame.
"""
return to_pandas(self).values
@property
def axes(self):
"""Get the axes for the DataFrame.
Returns:
The axes for the DataFrame.
"""
return [self.index, self.columns]
@property
def shape(self):
"""Get the size of each of the dimensions in the DataFrame.
Returns:
A tuple with the size of each dimension as they appear in axes().
"""
return len(self.index), len(self.columns)
def _update_inplace(self, new_query_compiler):
"""Updates the current DataFrame inplace.
Args:
new_query_compiler: The new QueryCompiler to use to manage the data
"""
old_query_compiler = self._query_compiler
self._query_compiler = new_query_compiler
old_query_compiler.free()
def add_prefix(self, prefix):
"""Add a prefix to each of the column names.
Returns:
A new DataFrame containing the new column names.
"""
return DataFrame(query_compiler=self._query_compiler.add_prefix(prefix))
def add_suffix(self, suffix):
"""Add a suffix to each of the column names.
Returns:
A new DataFrame containing the new column names.
"""
return DataFrame(query_compiler=self._query_compiler.add_suffix(suffix))
def applymap(self, func):
"""Apply a function to a DataFrame elementwise.
Args:
func (callable): The function to apply.
"""
if not callable(func):
raise ValueError("'{0}' object is not callable".format(type(func)))
ErrorMessage.non_verified_udf()
return DataFrame(query_compiler=self._query_compiler.applymap(func))
def copy(self, deep=True):
"""Creates a shallow copy of the DataFrame.
Returns:
A new DataFrame pointing to the same partitions as this one.
"""
return DataFrame(query_compiler=self._query_compiler.copy())
def groupby(
self,
by=None,
axis=0,
level=None,
as_index=True,
sort=True,
group_keys=True,
squeeze=False,
**kwargs
):
"""Apply a groupby to this DataFrame. See _groupby() remote task.
Args:
by: The value to groupby.
axis: The axis to groupby.
level: The level of the groupby.
as_index: Whether or not to store result as index.
sort: Whether or not to sort the result by the index.
group_keys: Whether or not to group the keys.
squeeze: Whether or not to squeeze.
Returns:
A new DataFrame resulting from the groupby.
"""
axis = pandas.DataFrame()._get_axis_number(axis)
idx_name = ""
if callable(by):
by = by(self.index)
elif isinstance(by, string_types):
idx_name = by
by = self.__getitem__(by).values.tolist()
elif is_list_like(by):
if isinstance(by, pandas.Series):
by = by.values.tolist()
mismatch = (
len(by) != len(self) if axis == 0 else len(by) != len(self.columns)
)
if all(obj in self for obj in by) and mismatch:
# In the future, we will need to add logic to handle this, but for now
# we default to pandas in this case.
pass
elif mismatch:
raise KeyError(next(x for x in by if x not in self))
from .groupby import DataFrameGroupBy
return DataFrameGroupBy(
self,
by,
axis,
level,
as_index,
sort,
group_keys,
squeeze,
idx_name,
**kwargs
)
def sum(
self,
axis=None,
skipna=True,
level=None,
numeric_only=None,
min_count=0,
**kwargs
):
"""Perform a sum across the DataFrame.
Args:
axis (int): The axis to sum on.
skipna (bool): True to skip NA values, false otherwise.
Returns:
The sum of the DataFrame.
"""
axis = pandas.DataFrame()._get_axis_number(axis) if axis is not None else 0
self._validate_dtypes_sum_prod_mean(axis, numeric_only, ignore_axis=False)
return self._query_compiler.sum(
axis=axis,
skipna=skipna,
level=level,
numeric_only=numeric_only,
min_count=min_count,
**kwargs
)
def abs(self):
"""Apply an absolute value function to all numeric columns.
Returns:
A new DataFrame with the applied absolute value.
"""
self._validate_dtypes(numeric_only=True)
return DataFrame(query_compiler=self._query_compiler.abs())
def isin(self, values):
"""Fill a DataFrame with booleans for cells contained in values.
Args:
values (iterable, DataFrame, Series, or dict): The values to find.
Returns:
A new DataFrame with booleans representing whether or not a cell
is in values.
True: cell is contained in values.
False: otherwise
"""
return DataFrame(query_compiler=self._query_compiler.isin(values=values))
def isna(self):
"""Fill a DataFrame with booleans for cells containing NA.
Returns:
A new DataFrame with booleans representing whether or not a cell
is NA.
True: cell contains NA.
False: otherwise.
"""
return DataFrame(query_compiler=self._query_compiler.isna())
def isnull(self):
"""Fill a DataFrame with booleans for cells containing a null value.
Returns:
A new DataFrame with booleans representing whether or not a cell
is null.
True: cell contains null.
False: otherwise.
"""
return DataFrame(query_compiler=self._query_compiler.isnull())
def keys(self):
"""Get the info axis for the DataFrame.
Returns:
A pandas Index for this DataFrame.
"""
return self.columns
def transpose(self, *args, **kwargs):
"""Transpose columns and rows for the DataFrame.
Returns:
A new DataFrame transposed from this DataFrame.
"""
return DataFrame(query_compiler=self._query_compiler.transpose(*args, **kwargs))
T = property(transpose)
def dropna(self, axis=0, how="any", thresh=None, subset=None, inplace=False):
"""Create a new DataFrame from the removed NA values from this one.
Args:
axis (int, tuple, or list): The axis to apply the drop.
how (str): How to drop the NA values.
'all': drop the label if all values are NA.
'any': drop the label if any values are NA.
thresh (int): The minimum number of NAs to require.
subset ([label]): Labels to consider from other axis.
inplace (bool): Change this DataFrame or return a new DataFrame.
True: Modify the data for this DataFrame, return None.
False: Create a new DataFrame and return it.
Returns:
If inplace is set to True, returns None, otherwise returns a new
DataFrame with the dropna applied.
"""
inplace = validate_bool_kwarg(inplace, "inplace")
if is_list_like(axis):
axis = [pandas.DataFrame()._get_axis_number(ax) for ax in axis]
result = self
for ax in axis:
result = result.dropna(axis=ax, how=how, thresh=thresh, subset=subset)
return self._create_dataframe_from_compiler(result._query_compiler, inplace)
axis = pandas.DataFrame()._get_axis_number(axis)
if how is not None and how not in ["any", "all"]:
raise ValueError("invalid how option: %s" % how)
if how is None and thresh is None:
raise TypeError("must specify how or thresh")
if subset is not None:
if axis == 1:
indices = self.index.get_indexer_for(subset)
check = indices == -1
if check.any():
raise KeyError(list(np.compress(check, subset)))
else:
indices = self.columns.get_indexer_for(subset)
check = indices == -1
if check.any():
raise KeyError(list(np.compress(check, subset)))
new_query_compiler = self._query_compiler.dropna(
axis=axis, how=how, thresh=thresh, subset=subset
)
return self._create_dataframe_from_compiler(new_query_compiler, inplace)
def add(self, other, axis="columns", level=None, fill_value=None):
"""Add this DataFrame to another or a scalar/list.
Args:
other: What to add this this DataFrame.
axis: The axis to apply addition over. Only applicaable to Series
or list 'other'.
level: A level in the multilevel axis to add over.
fill_value: The value to fill NaN.
Returns:
A new DataFrame with the applied addition.
"""
axis = pandas.DataFrame()._get_axis_number(axis)
if level is not None:
if isinstance(other, DataFrame):
other = other._query_compiler.to_pandas()
return self._default_to_pandas(
pandas.DataFrame.add,
other,
axis=axis,
level=level,
fill_value=fill_value,
)
other = self._validate_other(other, axis, numeric_or_object_only=True)
new_query_compiler = self._query_compiler.add(
other=other, axis=axis, level=level, fill_value=fill_value
)
return self._create_dataframe_from_compiler(new_query_compiler)
def agg(self, func, axis=0, *args, **kwargs):
return self.aggregate(func, axis, *args, **kwargs)
def aggregate(self, func, axis=0, *args, **kwargs):
axis = pandas.DataFrame()._get_axis_number(axis)
result = None
if axis == 0:
try:
result = self._aggregate(func, axis=axis, *args, **kwargs)
except TypeError:
pass
if result is None:
kwargs.pop("is_transform", None)
return self.apply(func, axis=axis, args=args, **kwargs)
return result
def _aggregate(self, arg, *args, **kwargs):
_axis = kwargs.pop("_axis", None)
if _axis is None:
_axis = getattr(self, "axis", 0)
kwargs.pop("_level", None)
if isinstance(arg, string_types):
return self._string_function(arg, *args, **kwargs)
# Dictionaries have complex behavior because they can be renamed here.
elif isinstance(arg, dict):
return self._default_to_pandas(pandas.DataFrame.agg, arg, *args, **kwargs)
elif is_list_like(arg) or callable(arg):
return self.apply(arg, axis=_axis, args=args, **kwargs)
else:
# TODO Make pandas error
raise ValueError("type {} is not callable".format(type(arg)))
def _string_function(self, func, *args, **kwargs):
assert isinstance(func, string_types)
f = getattr(self, func, None)
if f is not None:
if callable(f):
return f(*args, **kwargs)
assert len(args) == 0
assert (
len([kwarg for kwarg in kwargs if kwarg not in ["axis", "_level"]]) == 0
)
return f
f = getattr(np, func, None)
if f is not None:
return self._default_to_pandas(pandas.DataFrame.agg, func, *args, **kwargs)
raise ValueError("{} is an unknown string function".format(func))
def align(
self,
other,
join="outer",
axis=None,
level=None,
copy=True,
fill_value=None,
method=None,
limit=None,
fill_axis=0,
broadcast_axis=None,
):
if isinstance(other, DataFrame):
other = other._query_compiler.to_pandas()
return self._default_to_pandas(
pandas.DataFrame.align,
other,
join=join,
axis=axis,
level=level,
copy=copy,
fill_value=fill_value,
method=method,
limit=limit,
fill_axis=fill_axis,
broadcast_axis=broadcast_axis,
)
def all(self, axis=0, bool_only=None, skipna=None, level=None, **kwargs):
"""Return whether all elements are True over requested axis
Note:
If axis=None or axis=0, this call applies df.all(axis=1)
to the transpose of df.
"""
if axis is not None:
axis = pandas.DataFrame()._get_axis_number(axis)
else:
if bool_only:
raise ValueError("Axis must be 0 or 1 (got {})".format(axis))
return self._query_compiler.all(
axis=axis, bool_only=bool_only, skipna=skipna, level=level, **kwargs
)
def any(self, axis=0, bool_only=None, skipna=None, level=None, **kwargs):
"""Return whether any elements are True over requested axis
Note:
If axis=None or axis=0, this call applies on the column partitions,
otherwise operates on row partitions
"""
if axis is not None:
axis = pandas.DataFrame()._get_axis_number(axis)
else:
if bool_only:
raise ValueError("Axis must be 0 or 1 (got {})".format(axis))
return self._query_compiler.any(
axis=axis, bool_only=bool_only, skipna=skipna, level=level, **kwargs
)
def append(self, other, ignore_index=False, verify_integrity=False, sort=None):
"""Append another DataFrame/list/Series to this one.
Args:
other: The object to append to this.
ignore_index: Ignore the index on appending.
verify_integrity: Verify the integrity of the index on completion.
Returns:
A new DataFrame containing the concatenated values.
"""
if isinstance(other, (pandas.Series, dict)):
if isinstance(other, dict):
other = | pandas.Series(other) | pandas.Series |
'''
Expression.py - wrap various differential expression tools
===========================================================
:Tags: Python
Purpose
-------
This module provides tools for differential expression analysis
for a variety of methods.
Methods implemented are:
DESeq
EdgeR
ttest
The aim of this module is to run these individual tools and
output a table in a common format.
Usage
-----
Documentation
-------------
Requirements:
* DESeq >= 1.17
* DESeq2 >= 1.5.62
* edgeR >= 3.7.16
* gplots >= 2.14.2
* ggplot2 >= 1.0.0
* reshape >= 0.8.5
* RColorBrewer >= 1.0.5
* grid >= 3.1.1
* limma >= 3.21.18
* samr >= 2.0 (optional)
* siggenes >= 1.39.0 (optional)
Code
----
To do:
--check contrasts against design model
'''
import os
import math
import numpy
import sys
import collections
import itertools
import re
import pandas
import copy
import numpy as np
from scipy.stats import ttest_ind
import matplotlib
import matplotlib.pyplot as plt
import rpy2
from rpy2.robjects import r
from rpy2.robjects import r as R
import rpy2.robjects as ro
from rpy2.robjects import pandas2ri
from rpy2.robjects.packages import importr
from rpy2.robjects.vectors import FloatVector
try:
from rpy2.rinterface import RRuntimeError
except ImportError:
from rpy2.rinterface_lib.embedded import RRuntimeError
try:
import cgatcore.experiment as E
import cgatcore.iotools as iotools
import cgat.Stats as Stats
except ImportError:
import experiment as E
import iotools
import Stats
# activate pandas/rpy conversion
# pandas2ri.activate()
# AH: Only do this on demand, module might not be
# be able to be imported if there are any issues.
# grdevices = importr('grDevices')
def runDETest(raw_DataFrame,
design_file,
outfile,
de_caller,
**kwargs):
''' provide higher level API to run tools with default setting '''
if de_caller.lower() == "deseq":
pass
else:
raise ValueError("Unknown caller")
def splitModel(model):
'''returns the terms in the model'''
return [x for x in
re.split("[\.:,~+\s*]", re.sub("~(\s*)?", "", model)) if
len(x) > 0]
def adjustPvalues(p_values):
'''return a list of BH adjusted pvalues'''
# import r stats module to adjust pvalues
stats = importr('stats')
adj_pvalues = list(stats.p_adjust(FloatVector(p_values), method='BH'))
return adj_pvalues
def pvaluesToSignficant(p_values, fdr):
'''return a list of bools for significance'''
return [int(x < fdr) for x in p_values]
class ExperimentalDesign(object):
"""Objects representing experimental designs.
This class takes an experimental design in tabular
form and exports several convenience functions and
attributes.
`filename_or_table` can be a filename of a tab-separated table
with the following columns.
track
the sample name
include
whether or not this sample should be included
in the design
groups
a label grouping several samples into a group
pair
for paired tests, a numeric identifier linking
samples that are paired.
An example of an experimtal design with two groups and paired
samples is below::
track include group pair
sample1 1 treatment 1
sample2 1 treatment 2
sample3 1 control 1
sample4 1 control 2
When providing `filename_or_table`, the `include` column is used
to directly filter the design to remove any non-included samples.
Additional columns will be added as factors to the design.
Alternatively, `filename_or_table` can be a pandas DataFrame with
sample names as row index and the appropriate columns.
Attributes
-----------
table : pandas DataFrame
dataframe object describing the design
groups : list
list of groups in the design
conditions : list
group for each sample
pairs : list
pair status for each sample
samples: list
sample names
factors: list
factors for each sample
has_replicates : bool
True if at least one group has multiple samples
has_pairs : bool
True if design is a paired design
"""
def __init__(self, filename_or_table):
# read in table in the constructor for ExpDesign
# e.g design = ExpDesign(pd.read_csv(...))
if isinstance(filename_or_table, str):
self.table = pandas.read_csv(filename_or_table, sep="\t",
index_col=0)
elif isinstance(filename_or_table, pandas.core.frame.DataFrame):
self.table = filename_or_table
else:
raise ValueError("Type needs to be string or pandas data frame."
"Type = %s", type(filename_or_table))
assert self.table.shape, "design table is empty"
# parse the design table. Users probably expect this
# to happen once data is uploaded.
self._update()
def _update(self):
"""parse design file and fill class attributes.
Call this function whenever self.table changes.
"""
# remove all entries that should not be included
self.table = self.table[self.table["include"] != 0]
# define attributes
self.conditions = self.table['group'].tolist()
self.pairs = self.table['pair'].tolist()
# TS - use OrderedDict to retain order in unique
self.groups = (list(collections.OrderedDict.fromkeys(
self.conditions)))
self.samples = self.table.index.tolist()
# Test if replicates exist, i.e at least one group has multiple samples
# TS - does this need to be extended to check whether replicates exist
# for each group?
max_per_group = max([self.conditions.count(x) for x in self.groups])
self.has_replicates = max_per_group >= 2
# Test if pairs exist:
npairs = len(set(self.pairs))
has_pairs = npairs == 2
# ..if so, at least two samples are required per pair
if has_pairs:
min_per_pair = min([self.pairs.count(x) for x in set(self.pairs)])
self.has_pairs = min_per_pair >= 2
else:
self.has_pairs = False
# all columns except "include" may be considered as factors
self.factors = self.table.drop(["include"], axis=1)
# remove "pair" from factor if design does not include pairs
if not self.has_pairs:
self.factors.drop("pair", inplace=True, axis=1)
def validate(self, counts=None, model=None):
if counts is not None:
missing = set(self.samples).difference(set(counts.table.columns))
if len(missing) > 0:
raise ValueError(
"following samples in design table are missing"
" from counts table: %s" % ", ".join(missing))
if model is not None:
# check all model terms exist
model_terms = splitModel(model)
missing = set(model_terms).difference(
set(self.table.columns.tolist()))
if len(missing) > 0:
raise ValueError("following terms in the model are missing"
" from the design table: %s" %
", ".join(missing))
# check there are at least two values for each level
for term in model_terms:
levels = set(self.table.ix[:, term])
if len(levels) < 2:
raise ValueError("term '%s' in the model has less "
"than two levels (%s) in the "
" design table" %
(term, ", ".join(levels)))
def restrict(self, counts):
''' return design with samples not in counts table removed '''
self.table = self.table.ix[counts.table.columns, :]
def revalidate(self, counts, model=None):
''' re-validate, i.e post filtering of counts table '''
if len(set(self.samples).symmetric_difference(
set(counts.table.columns))) > 0:
self.restrict(counts)
self._update()
self.validate(counts, model)
else:
pass
def firstPairOnly(self):
'''restrict the design table to the first pair only.
If unpaired will retain whole design table
'''
if not self.pairs:
self.pairs = self.table['pair'].tolist()
self.table = self.table.ix[self.table['pair'] == min(self.pairs), ]
def getSamplesInGroup(self, group):
"""return list of sample names belonging to group."""
if group not in self.groups:
raise KeyError("group '%s' not present")
return self.table[self.table["group"] == group].index.tolist()
def getGroupForSample(self, sample):
"""return group a sample belongs to"""
return self.table.loc[sample]["group"]
def getGroups2Samples(self):
"""return a dictionary mapping a group to samples within the group.
Returns
-------
dict
with groups as keys and list of samples within a group as values.
"""
groups_to_tracks = {}
for group in self.groups:
match_group = (self.table['group'] == group).tolist()
subset = self.table.iloc[match_group, ]
groups_to_tracks[group] = subset.index.tolist()
return groups_to_tracks
def mapGroupsSuffix(self, shuffle_suffix, keep_suffix):
'''use suffixes supplied to extract groups from the
design table and return dictionaries mapping each group to tracks
for keeping with tracks which should be shuffled
'''
groups_to_keep_tracks = {}
groups_to_spike_tracks = {}
keep_suffix = keep_suffix.split(",")
for group in self.groups:
match_group = (self.table['group'] == group).tolist()
tmp_design = self.table.iloc[match_group, ]
groups_to_spike_tracks[group] = [
x + shuffle_suffix for x in tmp_design.index.tolist()]
groups_to_keep_tracks[group] = copy.copy(
groups_to_spike_tracks[group])
groups_to_keep_tracks[group].extend(
[x + y for x in tmp_design.index.tolist() for y in keep_suffix])
return groups_to_keep_tracks, groups_to_spike_tracks
class DEExperiment(object):
''' base clase for DE experiments '''
def __init__(self):
pass
def run(self):
''' Custom DE functions
return a DEResult object'''
class DEResult(object):
''' base class for DE result '''
def __init__(self, testTable=None):
self.table = testTable
def getResults(self):
''' post-process results into generic output
columns are:
- contrast
- treatment_name
- control_name
- test_id
- control_mean
- treatment_mean
- control_std
- treatment_std
- p_value
- p_value_adj
- significant
- l2fold
- transformed_l2fold
- fold
- status
'''
def calculateIHW(self, alpha=0.1):
''' Use the Independent Hypothesis Weighting method from
IGNATIADIS et al (2016) to perform weighted FDR'''
if not ('control_mean' in self.table.columns and
'treatment_mean' in self.table.columns and
'p_value' in self.table.columns):
E.error("IHW requires control_mean, treatment_mean and p_value "
"columns, have you first run the getResults method?")
runIHW = r('''function(df){
library(IHW)
mean_expression = (df$control_mean + df$treatment_mean)/2
ihw_res = ihw(df$p_value ~ mean_expression, alpha = %(alpha)s)
df$p_value_adj = adj_pvalues(ihw_res)
return(df)
}''' % locals())
self.table = pandas2ri.ri2py(runIHW(pandas2ri.py2ri(self.table)))
self.table["significant"] = pvaluesToSignficant(
self.table["p_value_adj"], alpha)
def summariseDEResults(self):
''' summarise DE results. Counts instances of possible outcomes'''
# TS: the summarising is now split by the comparison being made and a
# dict returned with keys=comparisons, value=E.Counter per comparison
self.Summary = {}
control_names = set(self.table['control_name'])
treatment_names = set(self.table['treatment_name'])
for control, treatment in itertools.product(control_names,
treatment_names):
tmp_table = self.table[self.table['control_name'] == control]
tmp_table = tmp_table[tmp_table['treatment_name'] == treatment]
tmp_table.reset_index(inplace=True)
# check control, treatment combination exists
n_rows = tmp_table.shape[0]
if n_rows > 0:
if control != treatment:
label = control + "_" + treatment
else:
label = control
label = re.sub(":", "_int_", label)
counts = E.Counter()
counts.signficant = sum(tmp_table['significant'])
counts.insignficant = (len(tmp_table['significant']) -
counts.signficant)
counts.all_over = sum([x > 0 for x in tmp_table['l2fold']])
counts.all_under = sum([x < 0 for x in tmp_table['l2fold']])
counts.signficant_over = sum(
[tmp_table['significant'][x] == 1 and
tmp_table['l2fold'][x] > 0 for x in range(0, n_rows)])
counts.signficant_under = sum(
[tmp_table['significant'][x] == 1 and
tmp_table['l2fold'][x] < 0 for x in range(0, n_rows)])
self.Summary[label] = counts
def plotMA(self, contrast=None, outfile_prefix=None,
point_alpha=1, point_size=1, R=None):
''' base function for making a MA plot '''
if not R:
R = rpy2.robjects.r
ro.globalenv['tmp_df'] = pandas2ri.py2ri(self.table)
R('''
suppressMessages(library(ggplot2))
suppressMessages(library(grid))
l_txt = element_text(size=20)
tmp_df = tmp_df[tmp_df$contrast=="%(contrast)s",]
tmp_df = tmp_df[order(-tmp_df$p_value_adj),]
p = ggplot(tmp_df, aes(log((control_mean+treatment_mean)/2,2),
transformed_l2fold,
colour=as.factor(significant))) +
geom_point(size=%(point_size)f, alpha=%(point_alpha)f) +
xlab("log2 mean expression") + ylab("log2 fold change")+
ggtitle("%(contrast)s") +
scale_colour_manual(name="Significant", values=c("black", "red")) +
guides(colour = guide_legend(override.aes = list(size=10)))+
theme_bw() +
theme(axis.text.x = l_txt, axis.text.y = l_txt,
axis.title.x = l_txt, axis.title.y = l_txt,
legend.title = l_txt, legend.text = l_txt,
title=l_txt, legend.key.size=unit(1, "cm"),
aspect.ratio=1)
suppressMessages(
ggsave(file="%(outfile_prefix)s_%(contrast)s_MA_plot.png",
width=10, height=10))''' % locals())
def plotVolcano(self, contrast=None, outfile_prefix=None, R=None):
''' base function for Volcano plotting'''
if not R:
R = rpy2.robjects.r
ro.globalenv['tmp_df'] = pandas2ri.py2ri(self.table)
R('''
suppressMessages(library(ggplot2))
suppressMessages(library(grid))
l_txt = element_text(size=20)
tmp_df = tmp_df[tmp_df$contrast=="%(contrast)s",]
p = ggplot(tmp_df, aes(transformed_l2fold, -log(p_value,10),
colour=as.factor(significant))) +
geom_point() + xlab("log2 fold change") + ylab("p-value (-log10)") +
ggtitle("%(contrast)s") +
scale_colour_manual(name="Significant", values=c("black", "#619CFF")) +
guides(colour = guide_legend(override.aes = list(size=10))) +
theme_bw() +
theme(axis.text.x = l_txt, axis.text.y = l_txt,
axis.title.x = l_txt, axis.title.y = l_txt,
legend.title = l_txt, legend.text = l_txt,
title=l_txt, legend.key.size=unit(1, "cm"))
suppressMessages(
ggsave(file="%(outfile_prefix)s_%(contrast)s_volcano_plot.png",
width=10, height=10))''' % locals())
def plotPvalueHist(self, contrast=None, outfile_prefix=None, R=None):
''' base function for Volcano plotting'''
if not R:
R = rpy2.robjects.r
ro.globalenv['tmp_df'] = pandas2ri.py2ri(self.table)
R('''
suppressMessages(library(ggplot2))
suppressMessages(library(grid))
l_txt = element_text(size=20)
tmp_df = tmp_df[tmp_df$contrast=="%(contrast)s",]
p = ggplot(tmp_df, aes(p_value)) +
geom_histogram(fill="dodgerblue4") +
xlab("p-value") + ylab("count") +
ggtitle("p-value histogram - %(contrast)s") +
theme_bw() +
theme(axis.text.x = l_txt, axis.text.y = l_txt,
axis.title.x = l_txt, axis.title.y = l_txt,
title=l_txt)
suppressMessages(
ggsave(file="%(outfile_prefix)s_%(contrast)s_p_value_histogram.png",
width=10, height=10))''' % locals())
def plotPvalueQQ(self, contrast=None, outfile_prefix=None, R=None):
''' base function for Volcano plotting'''
if not R:
R = rpy2.robjects.r
ro.globalenv['tmp_df'] = pandas2ri.py2ri(self.table)
R('''
log_obs_pvalues = sort(-log10(tmp_df[['p_value']]))
uni_pvalues=runif(length(log_obs_pvalues))
log_uni_pvalues= -log10(uni_pvalues)
log_uni_pvalues = sort(log_uni_pvalues)
png(file="%(outfile_prefix)s_%(contrast)s_p_value_qq_plot.png")
plot(log_uni_pvalues,log_obs_pvalues,
xlab=expression(Theoretical~~-log[10](italic(p))),
ylab=expression(Observed~~-log[10](italic(p))),
main="P-value QQ-plot",
pch=20)
abline(0,1)''' % locals())
class DEExperiment_TTest(DEExperiment):
'''DECaller object to run TTest on counts data'''
# TS: to do: deal with genes/regions with zero counts
def run(self, counts, design, normalise=True,
normalise_method="deseq-size-factors"):
# TS: normalisation performed here rather than earlier as
# the method of normalisation is dependent upon the DE test
if normalise is True:
counts.normalise(method=normalise_method)
df_dict = collections.defaultdict(list)
for combination in itertools.combinations(design.groups, 2):
control, treatment = combination
n_rows = counts.table.shape[0]
df_dict["control_name"].extend((control,)*n_rows)
df_dict["treatment_name"].extend((treatment,)*n_rows)
df_dict["test_id"].extend(counts.table.index.tolist())
# set all status values to "OK"
df_dict["status"].extend(("OK",)*n_rows)
# subset counts table for each combination
c_keep = [x == control for
x in design.conditions]
control_counts = counts.table.iloc[:, c_keep]
t_keep = [x == treatment for
x in design.conditions]
treatment_counts = counts.table.iloc[:, t_keep]
c_mean = control_counts.mean(axis=1)
df_dict["control_mean"].extend(c_mean)
df_dict["control_std"].extend(control_counts.std(axis=1))
t_mean = treatment_counts.mean(axis=1)
df_dict["treatment_mean"].extend(t_mean)
df_dict["treatment_std"].extend(treatment_counts.std(axis=1))
t, prob = ttest_ind(control_counts, treatment_counts, axis=1)
df_dict["p_value"].extend(prob)
result = DEResult_TTest(testTable=pandas.DataFrame(df_dict))
result.table.set_index("test_id", inplace=True)
return result
class DEResult_TTest(DEResult):
def getResults(self, fdr):
''' post-process test results table into generic results output '''
# TS - what about zero values?!
self.table["fold"] = (
self.table["treatment_mean"] / self.table["control_mean"])
self.table["p_value_adj"] = adjustPvalues(self.table["p_value"])
self.table["significant"] = pvaluesToSignficant(
self.table["p_value_adj"], fdr)
self.table["l2fold"] = list(numpy.log2(self.table["fold"]))
# note: the transformed log2 fold change is not transformed for TTest
self.table["transformed_l2fold"] = self.table["l2fold"]
self.table["contrast"] = "_vs_".join((self.table['control_name'],
self.table['treatment_name']))
class DEExperiment_edgeR(DEExperiment):
'''DEExperiment object to run edgeR on counts data
See page 13 of the EdgeR user guide::
2. Simply pick a reasonable dispersion value, based on your
experience with similar data, and use that. Although
subjective, this is still more defensible than assuming Poisson
variation. Typical values are dispersion=0.4 for human data,
dispersion=0.1 for data on genetically identical model
organisms or dispersion=0.01 for technical replicates.
'''
def run(self,
counts,
design,
model=None,
contrast=None,
outfile_prefix=None,
ref_group=None,
fdr=0.1,
dispersion=None):
if not design.has_replicates and dispersion is None:
raise ValueError("no replicates and no dispersion")
# create r objects
r_counts = pandas2ri.py2ri(counts.table)
r_groups = ro.StrVector(design.conditions)
r_pairs = ro.StrVector(design.pairs)
r_has_pairs = ro.BoolVector([design.has_pairs])
r_has_replicates = ro.BoolVector([design.has_replicates])
if model is not None:
r_factors_df = pandas2ri.py2ri(design.factors)
else:
r_factors_df = ro.default_py2ri(False)
E.info('running edgeR: groups=%s, replicates=%s, pairs=%s, '
'additional_factors:%s' %
(design.groups, design.has_replicates, design.has_pairs,
design.factors))
levels = set(design.table[contrast])
if len(levels) > 2:
E.warn(
"There are more than 2 levels for the "
"contrast specified" "(%s:%s). The log2fold changes in the "
"results table and MA plots will be for the first two "
"levels in the contrast. The p-value will be the p-value "
"for the overall significance of the contrast. Hence, some "
"genes will have a signficant p-value but 0-fold change "
"between the first two levels" % (contrast, levels))
# build DGEList object
buildDGEList = r('''
suppressMessages(library('edgeR'))
function(counts){
countsTable = DGEList(counts)
countsTable = calcNormFactors(countsTable)
return(countsTable)}''' % locals())
r_countsTable = buildDGEList(r_counts)
# build design matrix
buildDesign = r('''
function(factors_df){
for (level in colnames(factors_df)){
factors_df[[level]] <- factor(factors_df[[level]])
}
factors_df$%(contrast)s <- relevel(
factors_df$%(contrast)s, ref="%(ref_group)s")
design <- model.matrix(%(model)s, data=factors_df)
return(design)}''' % locals())
r_design = buildDesign(r_factors_df)
# fit model
fitModel = r('''
function(countsTable, design, has_replicates){
if (has_replicates[1] == TRUE) {
# estimate common dispersion
countsTable = estimateGLMCommonDisp( countsTable, design )
# estimate trended dispersion
countsTable <- estimateGLMTrendedDisp( countsTable, design)
# estimate tagwise dispersion
countsTable = estimateGLMTagwiseDisp( countsTable, design )
# fitting model to each tag
fit = glmFit( countsTable, design ) }
else {
# fitting model to each tag
fit = glmFit(countsTable, design, dispersion=%(dispersion)s) }
return(fit)}''' % locals())
r_fit = fitModel(r_countsTable, r_design, r_has_replicates)
E.info("Conducting likelihood ratio tests")
lrtTest = r('''
function(fit, design, factors_df, countsTable){
suppressMessages(library(reshape2))
lrt = glmLRT(fit)
lrt_table = as.data.frame(lrt$table)
lrt_table$contrast <- "%(contrast)s"
for (level in colnames(factors_df)){
factors_df[[level]] <- factor(factors_df[[level]])
}
factors_df$%(contrast)s <- relevel(
factors_df$%(contrast)s, ref="%(ref_group)s")
contrast_levels = as.vector(levels(factor(factors_df[["%(contrast)s"]])))
lrt_table$control_name <- contrast_levels[1]
lrt_table$treatment_name <- contrast_levels[2]
dt <- decideTestsDGE(lrt, adjust.method="BH", p.value=%(fdr)s)
isDE <- as.logical(dt)
DEnames <- rownames(fit)[isDE]
png(paste0(c("%(outfile_prefix)s", "MA.png"), collapse="_"))
plotSmear(lrt, de.tags=DEnames, cex=0.35, main="%(contrast)s")
abline(h=c(-1,1), col="blue")
dev.off()
return(lrt_table)}''' % locals())
r_lrt_table = lrtTest(r_fit, r_design, r_factors_df, r_countsTable)
result = DEResult_edgeR(testTable=pandas2ri.ri2py(r_lrt_table))
return result
class DEResult_edgeR(DEResult):
def getResults(self, fdr, DEtype="GLM"):
''' post-process test results table into generic results output '''
E.info("Generating output - results table")
df_dict = collections.defaultdict()
n_rows = self.table.shape[0]
df_dict["treatment_name"] = self.table['treatment_name']
df_dict["control_name"] = self.table['control_name']
df_dict["contrast"] = self.table['contrast']
df_dict["test_id"] = self.table.index
df_dict["control_mean"] = self.table['logCPM']
df_dict["treatment_mean"] = self.table['logCPM']
df_dict["control_std"] = (0,)*n_rows
df_dict["treatment_std"] = (0,)*n_rows
df_dict["p_value"] = self.table['PValue']
df_dict["p_value_adj"] = adjustPvalues(self.table['PValue'])
df_dict["significant"] = pvaluesToSignficant(
df_dict["p_value_adj"], fdr)
df_dict["l2fold"] = (self.table['logFC'])
# TS: the transformed log2 fold change is not transformed!
df_dict["transformed_l2fold"] = df_dict["l2fold"]
# TS: check what happens when no fold change is available
# TS: may need an if/else in list comprehension. Raise E.warn too?
df_dict["fold"] = [math.pow(2, float(x)) for
x in self.table['logFC']]
# set all status values to "OK"
# TS: again, may need an if/else to check...
df_dict["status"] = ("OK",)*n_rows
self.table = pandas.DataFrame(df_dict)
class DEExperiment_DESeq2(DEExperiment):
'''DEExperiment object to run DESeq2 on counts data'''
def run(self,
counts,
design,
fdr=0.1,
fit_type="parametric",
model=None,
outfile_prefix=None,
ref_group=None,
contrast=None,
DEtest="Wald",
R=None):
if not R:
R = rpy2.robjects.r
pandas2ri.activate()
# R will replace any "-" with "." in rownames.
# Here, we make sure the design and counts samples are the same
design.table.index = [x.replace("-", ".") for x in design.table.index]
design.factors.index = [x.replace("-", ".") for x in design.factors.index]
counts.table.columns = [x.replace("-", ".") for x in counts.table.columns]
# create r objects
ro.globalenv['counts'] = pandas2ri.py2ri(counts.table)
ro.globalenv['design'] = pandas2ri.py2ri(design.table)
ro.globalenv['factors_df'] = pandas2ri.py2ri(design.factors)
model_terms = [x for x in re.split("[\+~ ]+", model)[1:]
if x != "0"]
E.info('running DESeq2: groups=%s, replicates=%s, pairs=%s, '
'DE test: %s, additional_factors:%s, ' %
(design.groups, design.has_replicates, design.has_pairs,
DEtest, design.factors))
# load DESeq
R('''suppressMessages(library('DESeq2'))''')
# build DESeq2 Datasets (dds)
assert contrast, ("must supply a contrast for wald or LRT "
"(for LRT, contrast is used to derive reduced model")
if DEtest == "wald":
assert ref_group, "Must supply a ref_group to perform Wald test"
if ref_group:
R('''
for(column in colnames(factors_df)){
factors_df[[column]] = factor(factors_df[[column]])
}
full_model <- formula("%(model)s")
factors_df$%(contrast)s <- relevel(
factors_df$%(contrast)s, ref="%(ref_group)s")
dds <- suppressMessages(DESeqDataSetFromMatrix(
countData= counts,
colData = factors_df,
design = full_model))
''' % locals())
else:
R('''
for(column in colnames(factors_df)){
factors_df[[column]] = factor(factors_df[[column]])
}
full_model <- formula("%(model)s")
dds <- suppressMessages(DESeqDataSetFromMatrix(
countData= counts,
colData = factors_df,
design = full_model))
''' % locals())
if DEtest == "wald":
levels = set(design.table[contrast])
if len(levels) > 2:
E.warn('''Using Wald test for factor with more than 2
levels (%s:%s), Consider LRT''' % (contrast, levels))
contrast = model_terms[-1]
contrast_levels = set(design.factors[contrast])
# performDifferentialTesting
R('''
dds = suppressMessages(
DESeq(dds, test="Wald", fitType="%(fit_type)s"))
contrast_levels = as.vector(levels(dds@colData$%(contrast)s))
png("%(outfile_prefix)s_dispersion.png")
plotDispEsts(dds)
dev.off()
res = suppressMessages(results(dds))
png(paste0(c("%(outfile_prefix)s", "MA.png"), collapse="_"))
plotMA(res, alpha=%(fdr)s)
dev.off()
res = as.data.frame(res)
c = counts(dds, normalized = TRUE)
res$contrast = "%(contrast)s"
contrast_levels = levels(dds@colData$%(contrast)s)
res$control = contrast_levels[1]
res$treatment = contrast_levels[2]
res['test_id'] = rownames(res)
''' % locals())
results = pandas2ri.ri2py(ro.globalenv['res'])
# liklihood ratio test
# Note that if there are more than 3 levels for the contrast,
# the results table will include a log2-fold change from the
# first two levels only, however, MA plots will be generated
# for each combination of levels
elif DEtest == "lrt":
levels = set(design.table[contrast])
if len(levels) > 2:
E.warn('''There are more than 2 levels for the
contrast specified" "(%s:%s). The log2fold changes in the
results table and MA plots will be for the first two
levels in the contrast. The p-value will be the p-value
for the overall significance of the contrast. Hence, some
genes may have a signficant p-value but ~0-fold change
between the first two levels''' % (contrast, levels))
n = 0
reduced_model = [x for x in model_terms if x != contrast]
if len(reduced_model) > 0:
reduced_model = "~" + "+".join(reduced_model)
else:
reduced_model = "~1"
print('''
ddsLRT <- suppressMessages(
DESeq(dds, test="LRT", reduced=formula("%(reduced_model)s"),
betaPrior=TRUE, fitType="%(fit_type)s"))
png("%(outfile_prefix)s_dispersion.png")
plotDispEsts(ddsLRT)
dev.off()
contrast_levels = as.vector(levels(dds@colData$%(contrast)s))
res = suppressMessages(results(ddsLRT, addMLE=TRUE,
contrast=c("%(contrast)s",
contrast_levels[2], contrast_levels[1])))
png(paste0(c("%(outfile_prefix)s", "MA.png"), collapse="_"))
plotMA(res, alpha=%(fdr)s)
dev.off()
res = as.data.frame(res)
res$contrast = "%(contrast)s"
if(length(contrast_levels)==2){
res$control = contrast_levels[1]
res$treatment = contrast_levels[2]
}
else{
res$control = "%(contrast)s"
res$treatment = "%(contrast)s"
}
res['test_id'] = rownames(res)
''' % locals())
R('''
ddsLRT <- suppressMessages(
DESeq(dds, test="LRT", reduced=formula("%(reduced_model)s"),
betaPrior=TRUE, fitType="%(fit_type)s"))
png("%(outfile_prefix)s_dispersion.png")
plotDispEsts(ddsLRT)
dev.off()
contrast_levels = as.vector(levels(dds@colData$%(contrast)s))
res = suppressMessages(results(ddsLRT, addMLE=TRUE,
contrast=c("%(contrast)s",
contrast_levels[2], contrast_levels[1])))
png(paste0(c("%(outfile_prefix)s", "MA.png"), collapse="_"))
plotMA(res, alpha=%(fdr)s)
dev.off()
res = as.data.frame(res)
res$contrast = "%(contrast)s"
if(length(contrast_levels)==2) {
res$control = contrast_levels[1]
res$treatment = contrast_levels[2]
} else {
res$control = "%(contrast)s"
res$treatment = "%(contrast)s"
}
res['test_id'] = rownames(res)
''' % locals())
results = pandas2ri.ri2py(ro.globalenv['res'])
else:
raise ValueError("DEtest must be 'wald' or 'lrt'")
final_result = DEResult_DESeq2(testTable=results)
return final_result
class DEResult_DESeq2(DEResult):
def getResults(self, fdr):
''' post-process test results table into generic results output '''
E.info("Generating output - results table")
df_dict = collections.defaultdict()
n_rows = self.table.shape[0]
df_dict["treatment_name"] = self.table['treatment']
df_dict["control_name"] = self.table['control']
df_dict["test_id"] = self.table['test_id']
df_dict["contrast"] = self.table['contrast']
df_dict["control_mean"] = self.table['baseMean']
df_dict["treatment_mean"] = self.table['baseMean']
df_dict["control_std"] = (0,)*n_rows
df_dict["treatment_std"] = (0,)*n_rows
df_dict["p_value"] = self.table['pvalue']
df_dict["p_value_adj"] = adjustPvalues(self.table['pvalue'])
df_dict["significant"] = pvaluesToSignficant(
df_dict["p_value_adj"], fdr)
df_dict["l2fold"] = self.table['log2FoldChange']
# Transformed l2fold is the shrunken values
df_dict["transformed_l2fold"] = self.table['log2FoldChange']
# TS: check what happens when no fold change is available
# TS: may need an if/else in list comprehension. Raise E.warn too?
df_dict["fold"] = [math.pow(2, float(x)) for
x in df_dict["l2fold"]]
# set all status values to "OK"
# TS: again, may need an if/else to check...
df_dict["status"] = ("OK",)*n_rows
self.table = pandas.DataFrame(df_dict)
# causes errors if multiple instance of same test_id exist, for example
# if multiple constrasts have been tested
# self.table.set_index("test_id", inplace=True)
class DEExperiment_DEXSeq(DEExperiment):
'''DEExperiment object to run DEXSeq on counts data'''
def run(self,
design,
base_dir,
model=None,
flattenedfile=None,
outfile_prefix=None,
ref_group=None,
contrast=None,
fdr=0.1):
pandas2ri.activate()
# create r objects
E.info('running DEXSeq: groups=%s, pairs=%s, replicates=%s, pairs=%s,'
' additional_factors:' %
(design.groups, design.pairs, design.has_replicates,
design.has_pairs))
# load DEXSeq
R('''suppressMessages(library('DEXSeq'))''')
sampleTable = design.table
allfiles = [file for file in os.listdir(base_dir)]
countfiles = []
for item in list(design.table.index):
countfiles += [base_dir+"/"+x for x in allfiles if item in x]
E.info("Processing Samples. Sample table:")
E.info("%s" % sampleTable)
buildCountDataSet = R('''
function(countFiles, gff, sampleTable, model){
full_model <- formula("%(model)s")
dxd <- suppressMessages(DEXSeqDataSetFromHTSeq(
countFiles,
sampleData=sampleTable,
flattenedfile=gff,
design=full_model))
contrast_levels = as.vector(levels(dxd@colData$%(contrast)s))
dxd = estimateSizeFactors(dxd)
dxd = estimateDispersions(dxd)
png("%(outfile_prefix)s_dispersion.png")
plotDispEsts(dxd)
dev.off()
dxd = testForDEU(dxd)
dxd = estimateExonFoldChanges( dxd, fitExpToVar="%(contrast)s")
result = DEXSeqResults(dxd)
result = as.data.frame(result)
result$contrast = "%(contrast)s"
result$log2FoldChange = result$log2fold
if(length(contrast_levels)==2) {
result$control = contrast_levels[1]
result$treatment = contrast_levels[2]
} else {
result$control = "%(contrast)s"
result$treatment = "%(contrast)s"
}
return(result)
}''' % locals())
result = pandas2ri.ri2py(
buildCountDataSet(countfiles, flattenedfile, sampleTable, model))
result['test_id'] = result.index
result['contrast'] = contrast
final_result = DEResult_DEXSeq(result)
return final_result
class DEResult_DEXSeq(DEResult):
def getResults(self, fdr):
''' post-process test results table into generic results output '''
E.info("Generating output - results table")
df_dict = collections.defaultdict()
n_rows = self.table.shape[0]
df_dict["treatment_name"] = self.table['treatment']
df_dict["control_name"] = self.table['control']
df_dict["test_id"] = self.table['test_id']
df_dict["contrast"] = self.table['contrast']
df_dict["control_mean"] = self.table['exonBaseMean']
df_dict["treatment_mean"] = self.table['exonBaseMean']
df_dict["control_std"] = (0,)*n_rows
df_dict["treatment_std"] = (0,)*n_rows
df_dict["p_value"] = self.table['pvalue']
df_dict["p_value_adj"] = adjustPvalues(self.table['pvalue'])
df_dict["significant"] = pvaluesToSignficant(
df_dict["p_value_adj"], fdr)
df_dict["l2fold"] = ("NA",)*n_rows
# Transformed l2fold is the shrunken values
df_dict["transformed_l2fold"] = self.table['log2FoldChange']
df_dict["fold"] = ("NA",)*n_rows
df_dict["status"] = ("OK",)*n_rows
self.table = pandas.DataFrame(df_dict)
# causes errors if multiple instance of same test_id exist, for example
# if multiple constrasts have been tested
# self.table.set_index("test_id", inplace=True)
def plotMAplot(self, design, outfile_prefix):
# need to implement DEXSeq specific MA plot
raise ValueError("MA plotting is not yet implemented for DESeq")
class DEExperiment_Sleuth(DEExperiment):
'''DEExperiment object to run sleuth on kallisto bootstrap files
Unlike the other DEExperiment instances, this does not operate on
a Counts.Counts object but instead reads the bootstrap hd5 files
from kallisto into memory in R and then performs the differential
testing
The run method expects all kallisto abundance.h5 files to be under
a single directory with a subdirectory for each sample
Note: LRT does not generate fold change estimates (see DEResult_Sleuth)
use dummy_run = True if you don't want to perform differential
testing but want the counts/tpm outfiles
'''
def run(self,
design,
base_dir,
model=None,
contrast=None,
outfile_prefix=None,
counts=None,
tpm=None,
fdr=0.1,
DE_test="wald",
reduced_model=None,
dummy_run=False,
genewise=False,
gene_biomart=None,
ref_group=None):
if DE_test == "lrt":
E.info("Note: LRT will not generate fold changes")
assert reduced_model is not None, ("need to provide a reduced "
"model to use LRT")
# Design table needs a "sample" column
design.table['sample'] = design.table.index
r_design_df = pandas2ri.py2ri(design.table)
E.info('running sleuth: groups=%s, pairs=%s, replicates=%s, pairs=%s, '
'additional_factors:' %
(design.groups, design.pairs, design.has_replicates,
design.has_pairs))
# load sleuth
r('''suppressMessages(library('sleuth'))''')
# make variates string to ensure all model terms are in the
# design dataframe for sleuth
model_terms = [x for x in re.split("[\+~ ]+", model)[1:]
if x != "0"]
variates = "c(%s)" % ",".join(model_terms)
# need to code in option to not use a reference group (e.g for LRT)
if genewise:
assert gene_biomart, ("for genewise analysis, "
"must provide a 'gene_biomart'")
createSleuthObject = r('''
function(design_df){
library(biomaRt)
sample_id = design_df$sample
kal_dirs <- sapply(sample_id,
function(id) file.path('%(base_dir)s', id))
design_df <- dplyr::select(design_df, sample = sample,
%(variates)s)
design_df <- dplyr::mutate(design_df, path = kal_dirs)
%(contrast)s <- factor(design_df$%(contrast)s)
%(contrast)s <- relevel(%(contrast)s,ref='%(ref_group)s')
md <- model.matrix(%(model)s, design_df)
colnames(md)[grep("%(contrast)s", colnames(md))] <- '%(contrast)s%(ref_group)s'
mart <- biomaRt::useMart(biomart = "ENSEMBL_MART_ENSEMBL",
#dataset = "hsapiens_gene_ensembl",
dataset = "%(gene_biomart)s",
host="www.ensembl.org")
t2g <- biomaRt::getBM(
attributes = c("ensembl_transcript_id","ensembl_gene_id",
"external_gene_name"), mart = mart)
t2g <- dplyr::rename(t2g, target_id = ensembl_transcript_id,
ens_gene = ensembl_gene_id,
ext_gene = external_gene_name)
so <- sleuth_prep(design_df, md,
target_mapping = t2g, aggregation_column = 'ens_gene')
so <- suppressMessages(sleuth_fit(so))
return(so)
}''' % locals())
else:
createSleuthObject = r('''
function(design_df){
sample_id = design_df$sample
kal_dirs <- sapply(sample_id,
function(id) file.path('%(base_dir)s', id))
design_df <- dplyr::select(design_df, sample = sample,
%(variates)s)
design_df <- dplyr::mutate(design_df, path = kal_dirs)
%(contrast)s <- factor(design_df$%(contrast)s)
%(contrast)s <- relevel(%(contrast)s,ref='%(ref_group)s')
md <- model.matrix(%(model)s, design_df)
colnames(md)[grep("%(contrast)s", colnames(md))] <- '%(contrast)s%(ref_group)s'
so <- sleuth_prep(design_df, md)
so <- sleuth_fit(so)
return(so)
}''' % locals())
so = createSleuthObject(r_design_df)
# write out counts and tpm tables if required
if counts:
makeCountsTable = r('''
function(so){
library('reshape')
df = cast(so$obs_raw, target_id~sample, value = "est_counts")
colnames(df)[1] <- "transcript_id"
write.table(df, "%(counts)s", sep="\t", row.names=F, quote=F)
}''' % locals())
makeCountsTable(so)
if tpm:
makeTPMTable = r('''
function(so){
library('reshape')
df = cast(so$obs_raw, target_id~sample, value = "tpm")
colnames(df)[1] <- "transcript_id"
write.table(df, "%(tpm)s", sep="\t", row.names=F, quote=F)
}''' % locals())
makeTPMTable(so)
if dummy_run:
return None
if DE_test == "lrt":
differentialTesting = r('''
function(so){
so <- suppressMessages(sleuth_fit(so, formula = %(reduced_model)s,
fit_name = "reduced"))
so <- suppressMessages(sleuth_lrt(so, "reduced", "full"))
results_table <- sleuth_results(so, test = 'reduced:full',
test_type = 'lrt')
return(results_table)
} ''' % locals())
final_result = DEResult_Sleuth(pandas2ri.ri2py(
differentialTesting(so)))
elif DE_test == "wald":
differentialTesting = r('''
function(so){
so <- sleuth_wt(so, which_beta = '%(contrast)s%(ref_group)s')
p_ma = plot_ma(so, '%(contrast)s%(ref_group)s')
ggsave("%(outfile_prefix)s_%(contrast)s_sleuth_ma.png",
width=15, height=15, units="cm")
p_vars = plot_vars(so, '%(contrast)s%(ref_group)s')
ggsave("%(outfile_prefix)s_%(contrast)s_sleuth_vars.png",
width=15, height=15, units="cm")
p_mean_var = plot_mean_var(so)
ggsave("%(outfile_prefix)s_%(contrast)s_sleuth_mean_var.png",
width=15, height=15, units="cm")
results_table <- sleuth_results(so, test = '%(contrast)s%(ref_group)s')
return(results_table)
} ''' % locals())
results = pandas2ri.ri2py(differentialTesting(so))
results['contrast'] = contrast
else:
raise ValueError("unknown DE test type, use 'wald' or 'lrt'")
final_result = DEResult_Sleuth(results)
return final_result
class DEResult_Sleuth(DEResult):
def getResults(self, fdr):
''' post-process test results table into generic results output
expression and fold changes from Sleuth are natural logs'''
E.info("Generating output - results table")
df_dict = collections.defaultdict()
n_rows = self.table.shape[0]
df_dict["treatment_name"] = ("NA",)*n_rows
df_dict["control_name"] = ("NA",)*n_rows
df_dict["test_id"] = self.table['target_id']
df_dict["contrast"] = self.table['contrast']
df_dict["control_mean"] = [math.exp(float(x)) for
x in self.table['mean_obs']]
df_dict["treatment_mean"] = df_dict["control_mean"]
df_dict["control_std"] = (0,)*n_rows
df_dict["treatment_std"] = (0,)*n_rows
df_dict["p_value"] = self.table['pval']
df_dict["p_value_adj"] = adjustPvalues(self.table['pval'])
df_dict["significant"] = pvaluesToSignficant(df_dict["p_value_adj"],
fdr)
df_dict["fold"] = [math.exp(float(x)) for
x in self.table['b']]
df_dict["l2fold"] = [math.log(float(x), 2) for x in df_dict['fold']]
df_dict["transformed_l2fold"] = df_dict["l2fold"]
# set all status values to "OK"
# TS: again, may need an if/else to check...
df_dict["status"] = ("OK",)*n_rows
self.table = pandas.DataFrame(df_dict)
# causes errors if multiple instance of same test_id exist, for example
# if multiple constrasts have been tested
# self.table.set_index("test_id", inplace=True)
###############################################################################
def buildProbeset2Gene(infile,
outfile,
database="hgu133plus2.db",
mapping="hgu133plus2ENSEMBL"):
'''build map relating a probeset to an ENSEMBL gene_id'''
R.library(database)
# map is a Bimap object
m = r(mapping)
result = R.toTable(m)
outf = open(outfile, "w")
outf.write("probe_id\tgene_id\n")
for probeset_id, gene_id in zip(result["probe_id"],
result["ensembl_id"]):
outf.write("%s\t%s\n" % (probeset_id, gene_id))
outf.close()
E.info("written %i mappings to %s: probes=%i, genes=%i" %
(len(result),
outfile,
len(set(result["probe_id"])),
len(set(result["ensembl_id"]))))
GeneExpressionResult = collections.namedtuple(
"GeneExpressionResult",
"test_id treatment_name treatment_mean treatment_std "
"control_name control_mean control_std "
"pvalue qvalue l2fold fold transformed_l2fold "
"significant status")
def writeExpressionResults(outfile, result):
'''output expression results table.'''
if outfile == sys.stdout:
outf = outfile
else:
outf = iotools.open_file(outfile, "w")
outf.write("%s\n" % "\t".join(GeneExpressionResult._fields))
for x in sorted(result):
outf.write("%s\n" % "\t".join(map(str, x)))
if outf != sys.stdout:
outf.close()
class WelchsTTest(object):
'''base class for computing expression differences.
'''
def __call__(self,
probesets,
treatments,
controls):
assert len(probesets) == len(treatments[0])
assert len(probesets) == len(controls[0])
nskipped = 0
results = []
for probeset, treatment, control in zip(
probesets, zip(*treatments), zip(*controls)):
nval1, nval2 = len(treatment), len(control)
mean1, mean2 = numpy.mean(treatment), numpy.mean(control)
stddev1, stddev2 = numpy.std(treatment), numpy.std(control)
try:
s = Stats.doWelchsTTest(nval1, mean1, stddev1,
nval2, mean2, stddev2,
alpha=0.05)
except ValueError:
E.warn(
"expressionDifferences: standard deviations are 0 for "
"probeset %s - skipped" % probeset)
nskipped += 1
continue
s.mProbeset = probeset
results.append(s)
qvalues = Stats.doFDR([x.mPValue for x in results]).mQValues
for s, qvalue in zip(results, qvalues):
s.mQValue = qvalue
return results, nskipped
class SAMR(object):
'''SAM analysis of microarray data.
Use the Two-Class Unpaired Case Assuming Unequal Variances.
This uses the samr library.
Significant genes are either called at *fdr* or the
top *ngenes* are returned.
*treatments* and *control* are arrays of
arrays of expression values.
See
https://stat.ethz.ch/pipermail/bioconductor/2008-July/023251.html
for an explanation of the differences between siggens SAM
and Excel SAM. This version is parameterised to reproduce Excel SAM
by setting::
var.equal = TRUE
med = TRUE
.. note::
SAM requires log2 scaled expression levels.
'''
def __call__(self, probesets,
treatments,
controls,
pattern=None,
fdr=0.10,
ngenes=None,
npermutations=1000,
ndelta=10,
method="ttest"):
if ngenes and fdr:
raise ValueError("either supply ngenes or fdr, but not both.")
R.library("samr")
m = numpy.matrix(treatments + controls)
m = numpy.transpose(m)
labels = numpy.array([1] * len(treatments) + [2] * len(controls))
R.assign("x", numpy.array(m))
R.assign("y", labels)
R.assign("probesets", probesets)
data = r(
'''data=list( x=x, y=y, geneid=1:length(probesets), genenames=probesets, logged2=TRUE)''')
result = r(
'''samr.obj<-samr(data, resp.type="Two class unpaired", nperms=100)''')
r('''plot(samr.obj, delta=.4)''')
class SAM(object):
'''SAM analysis of microarray data.
Use the Two-Class Unpaired Case Assuming Unequal Variances.
This uses the siggenes library. Note that there is also
an rsam package at:
http://rss.acs.unt.edu/Rdoc/library/samr/html/samr.html
Significant genes are either called at *fdr* or the
top *ngenes* are returned.
*treatments* and *control* are arrays of
arrays of expression values.
See
https://stat.ethz.ch/pipermail/bioconductor/2008-July/023251.html
for an explanation of the differences between siggens SAM
and Excel SAM. To parameterize the FDR to excel sam, set the
flag *use_excel_sam*.
.. note::
SAM requires log2 scaled expression levels.
I ran into trouble using this library. I was not able to
reproduce the same results from the original SAM study getting
differences in d and in the fdr.
fold change is treatment / control.
'''
def __call__(self, probesets,
treatments,
controls,
pattern=None,
fdr=0.10,
ngenes=None,
npermutations=1000,
ndelta=10,
method="ttest",
use_excel_sam=False,
treatment_label="treatment",
control_label="control"):
if ngenes and fdr:
raise ValueError("either supply ngenes or fdr, but not both.")
R.library("siggenes")
m = numpy.matrix(treatments + controls)
m = numpy.transpose(m)
E.debug("build expression matrix: %i x %i" % m.shape)
labels = numpy.array([1] * len(treatments) + [0] * len(controls))
# 1000 permutations for P-Values of down to 0.0001. Setting this
# to a high value improved reproducibility of results.
kwargs = {}
# kwargs set to replicate excel SAM
if use_excel_sam:
kwargs.update(
{"control":
r('''samControl( lambda = 0.5, n.delta = %(ndelta)s) ''' %
locals()),
"med": True,
"var.equal": True})
else:
kwargs.update({"control":
r('''samControl( n.delta = %(ndelta)s ) ''' %
locals())},)
# the option B needs to be not set if wilc.stat is chosen
if method == "ttest":
kwargs["method"] = r('''d.stat''')
kwargs["B"] = npermutations
elif method == "wilc":
kwargs["method"] = r('''wilc.stat''')
elif method == "cat":
kwargs["method"] = r('''cat.stat''')
else:
raise ValueError("unknown statistic `%s`" % method)
E.info("running sam with the following options: %s" % str(kwargs))
a = R.sam(numpy.array(m),
labels,
gene_names=numpy.array(probesets),
**kwargs)
# E.debug("%s" % str(a))
R.assign("a", a)
fdr_data = collections.namedtuple("sam_fdr", (
"delta", "p0", "false", "significant", "fdr", "cutlow",
"cutup", "j2", "j1"))
cutoff_data = collections.namedtuple(
"sam_cutoff", ("delta", "significant", "fdr"))
gene_data = collections.namedtuple(
"sam_fdr", ("row", "dvalue", "stddev", "rawp", "qvalue", "rfold"))
def _totable(robj):
'''convert robj to a row-wise table.'''
s = numpy.matrix(robj)
t = [numpy.array(x).reshape(-1,) for x in s]
return t
# extract the fdr values
# returns R matrix
t = _totable(a.do_slot('mat.fdr'))
assert len(t[0]) == len(fdr_data._fields)
# for x in t: E.debug( "x=%s" % str(x))
fdr_values = [fdr_data(*x) for x in t]
# find d cutoff
if fdr is not None and fdr > 0:
s = numpy.matrix(R.findDelta(a, fdr))
try:
cutoffs = [cutoff_data(*numpy.array(x).reshape(-1,))
for x in s]
E.debug("sam cutoffs for fdr %f: %s" % (fdr, str(cutoffs)))
cutoff = cutoffs[-1]
except TypeError:
E.debug("could not get cutoff")
cutoff = None
elif ngenes:
s = numpy.matrix(R.findDelta(a, ngenes))
try:
cutoffs = [cutoff_data(*numpy.array(x).reshape(-1,))
for x in s]
E.debug("sam cutoffs for fdr %f: %s" % (fdr, str(cutoffs)))
cutoff = cutoffs[-1]
except TypeError:
E.debug("could not get cutoff")
cutoff = None
else:
raise ValueError("either supply ngenes or fdr")
# collect (unadjusted) p-values and qvalues for all probesets
pvalues = dict(zip(probesets, r('''<EMAIL>''')))
qvalues = dict(zip(probesets, r('''a<EMAIL>''')))
if pattern:
outfile = pattern % "sam.pdf"
R.pdf(outfile)
if cutoff:
R.plot(a, cutoff.delta)
else:
R.plot(a)
r['dev.off']()
siggenes = {}
significant_genes = set()
if cutoff is not None:
E.debug("using cutoff %s" % str(cutoff))
summary = r('''summary( a, %f )''' % cutoff.delta)
# summary = R.summary( a, cutoff.delta )
R.assign("summary", summary)
significant_genes = set(
[probesets[int(x) - 1] for x
in r('''<EMAIL>''')])
# E.debug( "significant genes=%s" % str(significant_genes))
r_result = zip(*_totable(summary.do_slot('mat.sig')))
if len(r_result) > 0:
assert len(r_result[0]) == 6, \
"expected six columns from siggenes module, got: %s" % \
len(r_result[0])
for x in r_result:
if x[4] > fdr:
E.warn("%s has qvalue (%f) larger than cutoff, but "
"is significant significant." % (str(x), x[4]))
# except TypeError:
# only a single value
# x = [r_result[y] for y in ("Row", "d.value", "stdev", "rawp", "q.value", "R.fold") ]
# if x[4] > fdr:
# E.warn( "%s has qvalue (%f) larger than cutoff, but is called significant." % (str(x), x[4]))
siggenes[probesets[int(x[0]) - 1]] = gene_data(*x)
else:
E.debug("no cutoff found - no significant genes.")
genes = []
for probeset, treatment, control in zip(
probesets, zip(*treatments), zip(*controls)):
mean1, mean2 = numpy.mean(treatment), numpy.mean(control)
if probeset in siggenes:
s = siggenes[probeset]
pvalue = s.rawp
qvalue = s.qvalue
else:
pvalue = pvalues[probeset]
qvalue = qvalues[probeset]
significant = (0, 1)[probeset in significant_genes]
genes.append(GeneExpressionResult._make((probeset,
treatment_label,
mean1,
numpy.std(treatment),
control_label,
mean2,
numpy.std(control),
pvalue,
qvalue,
mean1 - mean2,
math.pow(
2, mean1 - mean2),
math.pow(
2, mean1 - mean2),
significant,
"OK")))
return genes, cutoff, fdr_values
#########################################################################
#########################################################################
#########################################################################
def loadTagData(tags_filename, design_filename):
'''load tag data for deseq/edger analysis.
*tags_file* is a tab-separated file with counts.
*design_file* is a tab-separated file with the
experimental design with a minimum of four columns::
track include group pair
CW-CD14-R1 0 CD14 1
CW-CD14-R2 0 CD14 1
CW-CD14-R3 1 CD14 1
CW-CD4-R1 1 CD4 1
FM-CD14-R1 1 CD14 2
FM-CD4-R2 0 CD4 2
FM-CD4-R3 0 CD4 2
FM-CD4-R4 0 CD4 2
track
name of track - should correspond to column header in *infile*
include
flag to indicate whether or not to include this data
group
group indicator - experimental group
pair
pair that sample belongs to (for paired tests)
Additional columns in design file are taken to contain levels for
additional factors and may be included for tests that allow multi-factor
model designs.
This method creates various R objects:
countsTable : data frame with counts.
groups : vector with groups
pairs : vector with pairs
factors : df of additional factors for more complex model designs
'''
# Load counts table
E.info("loading tag data from %s" % tags_filename)
r('''counts_table = read.table('%(tags_filename)s',
header=TRUE,
row.names=1,
stringsAsFactors=TRUE,
comment.char='#')''' % locals())
E.info("read data: %i observations for %i samples" %
tuple(r('''dim(counts_table)''')))
E.debug("sample names: %s" % r('''colnames(counts_table)'''))
# Load comparisons from file
r('''pheno = read.delim(
'%(design_filename)s',
header=TRUE,
stringsAsFactors=TRUE,
comment.char='#')''' % locals())
# Make sample names R-like - substitute - for .
r('''pheno[,1] = gsub('-', '.', pheno[,1]) ''')
E.debug("design names: %s" % r('''pheno[,1]'''))
# Ensure pheno rows match count columns
pheno = r(
'''pheno2 = pheno[match(colnames(counts_table),pheno[,1]),,drop=FALSE]''')
missing = r('''colnames(counts_table)[is.na(pheno2)][1]''')
if missing:
E.warn("missing samples from design file are ignored: %s" %
missing)
# subset data & set conditions
r('''includedSamples <- !(is.na(pheno2$include) | pheno2$include == '0') ''')
E.debug("included samples: %s" %
r('''colnames(counts_table)[includedSamples]'''))
r('''countsTable <- counts_table[ , includedSamples ]''')
r('''groups <- factor(pheno2$group[ includedSamples ])''')
r('''conds <- pheno2$group[ includedSamples ]''')
r('''pairs <- factor(pheno2$pair[ includedSamples ])''')
# if additional columns present, pass to 'factors'
r('''if (length(names(pheno2)) > 4) {
factors <- data.frame(pheno2[includedSamples,5:length(names(pheno2))])
} else {
factors <- NA
}''')
E.info("filtered data: %i observations for %i samples" %
tuple(r('''dim(countsTable)''')))
def filterTagData(filter_min_counts_per_row=1,
filter_min_counts_per_sample=10,
filter_percentile_rowsums=0):
'''filter tag data.
* remove rows with fewer than x counts in most highly expressed sample
* remove samples with fewer than x counts in most highly expressed row
* remove the lowest percentile of rows in the table, sorted
by total tags per row
'''
# Remove windows with no data
r('''max_counts = apply(countsTable,1,max)''')
r('''countsTable = countsTable[max_counts>=%i,]''' %
filter_min_counts_per_row)
E.info("removed %i empty rows" %
tuple(r('''sum(max_counts == 0)''')))
observations, samples = tuple(r('''dim(countsTable)'''))
E.info("trimmed data: %i observations for %i samples" %
(observations, samples))
# remove samples without data
r('''max_counts = apply(countsTable,2,max)''')
empty_samples = tuple(
r('''max_counts < %i''' % filter_min_counts_per_sample))
sample_names = r('''colnames(countsTable)''')
nempty_samples = sum(empty_samples)
if nempty_samples:
E.warn("%i empty samples are being removed: %s" %
(nempty_samples,
",".join([sample_names[x]
for x, y in enumerate(empty_samples) if y])))
r('''countsTable <- countsTable[, max_counts >= %i]''' %
filter_min_counts_per_sample)
r('''groups <- groups[max_counts >= %i]''' %
filter_min_counts_per_sample)
r('''pairs <- pairs[max_counts >= %i]''' %
filter_min_counts_per_sample)
r('''if (!is.na(factors)) {factors <- factors[max_counts >= %i,]}''' %
filter_min_counts_per_sample)
observations, samples = tuple(r('''dim(countsTable)'''))
# percentile filtering
if filter_percentile_rowsums > 0:
percentile = float(filter_percentile_rowsums) / 100.0
r('''sum_counts = rowSums( countsTable )''')
r('''take = (sum_counts > quantile(sum_counts, probs = %(percentile)f))''' %
locals())
discard, keep = r('''table( take )''')
E.info("percentile filtering at level %f: keep=%i, discard=%i" %
(filter_percentile_rowsums,
keep, discard))
r('''countsTable = countsTable[take,]''')
observations, samples = tuple(r('''dim(countsTable)'''))
return observations, samples
def groupTagData(ref_group=None, ref_regex=None):
'''compute groups and pairs from tag data table.'''
if ref_regex is not None and ref_group is None:
groups = r('''levels(groups)''')
for g in groups:
rx = re.compile(ref_regex)
if rx.search(g):
ref_group = g
# Relevel the groups so that the reference comes first
if ref_group is not None:
E.info("reference group (control) is '%s'" % ref_group)
r('''groups <- relevel(groups, ref="%s")''' % ref_group)
groups = r('''levels(groups)''')
pairs = r('''levels(pairs)''')
factors = r('''factors''')
# JJ - check whether there are additional factors in design file...
# warning... isintance(df, rpy.robjects.vectors.Vector) returns True
if isinstance(factors, rpy2.robjects.vectors.DataFrame):
E.warn("There are additional factors in design file that are ignored"
" by groupTagData: %s" % factors.r_repr())
# AH: uncommented as it causes an issue with rpy2 2.7.7
# else:
# # Hack... must be a better way to evaluate r NA instance in python?
# import pdb; pdb.set_trace()
# assert len(list(factors)) == 1 and bool(list(factors)[0]) is False, \
# "factors must either be DataFrame or NA in R global namespace"
# Test if replicates exist - at least one group must have multiple samples
max_per_group = r('''max(table(groups)) ''')[0]
has_replicates = max_per_group >= 2
# Test if pairs exist:
npairs = r('''length(table(pairs)) ''')[0]
has_pairs = npairs == 2
# at least two samples per pair
if has_pairs:
min_per_pair = r('''min(table(pairs)) ''')[0]
has_pairs = min_per_pair >= 2
return groups, pairs, has_replicates, has_pairs
def plotCorrelationHeatmap(method="correlation"):
'''plot a heatmap of correlations derived from
countsTable.
'''
if method == "correlation":
r('''dists <- dist( (1 - cor(countsTable)) / 2 )''')
else:
r('''dists <- dist( t(as.matrix(countsTable)), method = '%s' )''' %
method)
r('''heatmap( as.matrix( dists ), symm=TRUE )''')
def plotPairs():
'''requires counts table'''
# Plot pairs
r('''panel.pearson <- function(x, y, digits=2, prefix="", cex.cor, ...)
{
usr <- par("usr"); on.exit(par(usr))
par(usr = c(0, 1, 0, 1))
r <- abs(cor(x, y))
txt <- format(c(r, 0.123456789), digits=digits)[1]
txt <- paste(prefix, txt, sep="")
if(missing(cex.cor)) cex <- 0.6/strwidth(txt)
x = 0.5;
y = 0.5;
if (par("xlog")) { x = 10^x };
if (par("ylog")) { y = 10^y };
text(x, y, txt, cex = cex);
}
''')
try:
r('''pairs(countsTable,
lower.panel = panel.pearson,
pch=".",
labels=colnames(countsTable),
log="xy")''')
except RRuntimeError:
E.warn("can not plot pairwise scatter plot")
def plotPCA(groups=True):
'''plot a PCA plot from countsTable using ggplot.
If groups is *True*, the variable ``groups`` is
used for colouring. If *False*, the groups are
determined by sample labels.
'''
r('''suppressMessages(library(ggplot2))''')
r('''pca = prcomp(t(countsTable))''')
# Build factor groups by splitting labels at "."
r('''colour=groups''')
r('''shape=0''')
r('''size=1''')
if groups is False:
r('''mm = matrix(
unlist(sapply(colnames(countsTable),strsplit,'[.]')),
nrow=length(colnames(countsTable)),
byrow=T)''')
nrows, nlevels = r('''dim(mm)''')
if nlevels > 1:
r('''colour=mm[,1]''')
if nlevels > 2:
r('''shape=mm[,2]''')
try:
r('''p1 = ggplot(
as.data.frame(pca$x),
aes(x=PC1, y=PC2,
colour=colour,
shape=shape,
label=rownames(pca$x))) \
+ geom_text(size=4, vjust=1) \
+ geom_point()''')
r('''p2 = qplot(x=PC1, y=PC3,
data = as.data.frame(pca$x),
label=rownames(pca$x),
shape=shape,
colour=colour)''')
r('''p3 = qplot(x=PC2, y=PC3,
data = as.data.frame(pca$x),
label=rownames(pca$x),
shape=shape,
colour=colour)''')
# TODO: plot all in a multi-plot with proper scale
# the following squishes the plots
# r('''source('%s')''' %
# os.path.join(os.path.dirname(E.__file__),
# "../R",
# "multiplot.R"))
# r('''multiplot(p1, p2, p3, cols=2)''')
r('''plot(p1)''')
except RRuntimeError as msg:
E.warn("could not plot in plotPCA(): %s" % msg)
def runEdgeR(outfile,
outfile_prefix="edger.",
fdr=0.1,
prefix="",
dispersion=None,
ref_group=None,
ref_regex=None,
):
'''run EdgeR on countsTable.
Results are stored in *outfile* and files prefixed by *outfile_prefix*.
The dispersion is usually measuered from replicates. If there are no
replicates, you need to set the *dispersion* explicitely.
See page 13 of the EdgeR user guide::
2. Simply pick a reasonable dispersion value, based on your
experience with similar data, and use that. Although
subjective, this is still more defensible than assuming Poisson
variation. Typical values are dispersion=0.4 for human data,
dispersion=0.1 for data on genetically identical model
organisms or dispersion=0.01 for technical replicates.
'''
# load library
r('''suppressMessages(library('edgeR'))''')
groups, pairs, has_replicates, has_pairs = groupTagData(ref_group,
ref_regex)
# output heatmap plot
fn = '%(outfile_prefix)sheatmap.png' % locals()
E.info("outputing heatmap to {}".format(fn))
R.png(fn)
plotCorrelationHeatmap()
r['dev.off']()
E.info('running EdgeR: groups=%s, pairs=%s, replicates=%s, pairs=%s' %
(groups, pairs, has_replicates, has_pairs))
if has_pairs:
# output difference between groups
R.png('''%(outfile_prefix)sbalance_groups.png''' % locals())
first = True
for g1, g2 in itertools.combinations(groups, 2):
r('''a = rowSums( countsTable[groups == '%s'] ) ''' % g1)
r('''b = rowSums( countsTable[groups == '%s'] ) ''' % g2)
if first:
r('''plot(cumsum(sort(a - b)), type = 'l') ''')
first = False
else:
r('''lines(cumsum(sort(a - b))) ''')
r['dev.off']()
r('''suppressMessages(library('ggplot2'))''')
r('''suppressMessages(library('reshape'))''')
# output difference between pairs within groups
first = True
legend = []
for pair in pairs:
for g1, g2 in itertools.combinations(groups, 2):
key = re.sub("-", "_", "pair_%s_%s_vs_%s" % (pair, g1, g2))
legend.append(key)
# print r('''colnames( countsTable) ''')
# print r(''' pairs=='%s' ''' % pair)
# print r(''' groups=='%s' ''' % g1)
r('''a = rowSums( countsTable[pairs == '%s' & groups == '%s'])''' % (
pair, g1))
r('''b = rowSums( countsTable[pairs == '%s' & groups == '%s'])''' % (
pair, g2))
r('''c = cumsum( sort(a - b) )''')
r('''c = c - min(c)''')
if first:
data = r('''d = data.frame( %s = c)''' % key)
first = False
else:
r('''d$%s = c''' % key)
# remove row names (gene idenitifiers)
r('''row.names(d) = NULL''')
# add numbers of genes (x-axis)
r('''d$genes=1:nrow(d)''')
# merge data for ggplot
r('''d = melt( d, 'genes', variable_name = 'comparison' )''')
# plot
r('''gp = ggplot(d)''')
r('''pp = gp + \
geom_line(aes(x=genes,y=value,group=comparison,color=comparison))''')
try:
R.ggsave('''%(outfile_prefix)sbalance_pairs.png''' % locals())
r['dev.off']()
except RRuntimeError:
E.warn("could not plot")
# build DGEList object
# ignore message: "Calculating library sizes from column totals"
r('''countsTable = suppressMessages(DGEList(countsTable, group=groups))''')
# Relevel groups to make the results predictable - IMS
if ref_group is not None:
r('''countsTable$samples$group <- relevel(countsTable$samples$group,
ref = "%s")''' % ref_group)
else:
# if no ref_group provided use first group in groups
r('''countsTable$sample$group <- relevel(countsTable$samples$group,
ref = "%s")''' % groups[0])
# calculate normalisation factors
E.info("calculating normalization factors")
r('''countsTable = calcNormFactors( countsTable )''')
E.info("output")
# output MDS plot
R.png('''%(outfile_prefix)smds.png''' % locals())
try:
r('''plotMDS( countsTable )''')
except RRuntimeError:
E.warn("can not plot mds")
r['dev.off']()
# build design matrix
if has_pairs:
r('''design = model.matrix(~pairs + countsTable$samples$group)''')
else:
r('''design = model.matrix(~countsTable$samples$group)''')
# r('''rownames(design) = rownames( countsTable$samples )''')
# r('''colnames(design)[length(colnames(design))] = "CD4" ''' )
# fitting model to each tag
if has_replicates:
# estimate common dispersion
r('''countsTable = estimateGLMCommonDisp(countsTable, design)''')
# estimate tagwise dispersion
r('''countsTable = estimateGLMTagwiseDisp(countsTable, design)''')
# fitting model to each tag
r('''fit = glmFit(countsTable, design)''')
else:
# fitting model to each tag
if dispersion is None:
raise ValueError("no replicates and no dispersion")
E.warn("no replicates - using a fixed dispersion value")
r('''fit = glmFit(countsTable, design, dispersion=%f)''' %
dispersion)
# perform LR test
r('''lrt = glmLRT(fit)''')
E.info("Generating output")
# output cpm table
r('''suppressMessages(library(reshape2))''')
r('''countsTable.cpm <- cpm(countsTable, normalized.lib.sizes=TRUE)''')
r('''melted <- melt(countsTable.cpm)''')
r('''names(melted) <- c("test_id", "sample", "ncpm")''')
# melt columns are factors - convert to string for sorting
r('''melted$test_id = levels(melted$test_id)[as.numeric(melted$test_id)]''')
r('''melted$sample = levels(melted$sample)[as.numeric(melted$sample)]''')
# sort cpm table by test_id and sample
r('''sorted = melted[with(melted, order(test_id, sample)),]''')
r('''gz = gzfile("%(outfile_prefix)scpm.tsv.gz", "w" )''' % locals())
r('''write.table(sorted, file=gz, sep = "\t",
row.names=FALSE, quote=FALSE)''')
r('''close(gz)''')
# compute adjusted P-Values
r('''padj = p.adjust(lrt$table$PValue, 'BH')''')
rtype = collections.namedtuple("rtype", "lfold logCPM LR pvalue")
# output differences between pairs
if len(groups) == 2:
R.png('''%(outfile_prefix)smaplot.png''' % locals())
r('''plotSmear(countsTable, pair=c('%s'))''' % "','".join(groups))
r('''abline(h=c(-2, 2), col='dodgerblue') ''')
r['dev.off']()
# I am assuming that logFC is the base 2 logarithm foldchange.
# Parse results and parse to file
results = []
counts = E.Counter()
df = r('''lrt$table''')
df["padj"] = r('''padj''')
counts.significant = sum(df.padj <= fdr)
counts.insignificant = sum(df.padj > fdr)
counts.significant_over = sum((df.padj <= fdr) & (df.logFC > 0))
counts.significant_under = sum((df.padj <= fdr) & (df.logFC < 0))
counts.input = len(df)
counts.all_over = sum(df.logFC > 0)
counts.all_under = sum(df.logFC < 0)
counts.fail = sum(df.PValue.isnull())
counts.ok = counts.input - counts.fail
df["fold"] = df.logFC.pow(2.0)
df["significant"] = df.padj <= fdr
# TODO: use pandas throughout
for interval, d in df.iterrows():
# fold change is determined by the alphabetical order of the factors.
# Is the following correct?
results.append(GeneExpressionResult._make((
interval,
groups[1],
d.logCPM,
0,
groups[0],
d.logCPM,
0,
d.PValue,
d.padj,
d.logFC,
d.fold,
d.logFC, # no transform of lfold
str(int(d.significant)),
"OK")))
writeExpressionResults(outfile, results)
outf = iotools.open_file("%(outfile_prefix)ssummary.tsv" % locals(), "w")
outf.write("category\tcounts\n%s\n" % counts.asTable())
outf.close()
# needs to put into class
##
def deseqPlotSizeFactors(outfile):
'''plot size factors - requires cds object.'''
R.png(outfile)
r('''par(mar=c(8,4,4,2))''')
r('''barplot( sizeFactors( cds ), main="size factors", las=2)''')
r['dev.off']()
def deseqOutputSizeFactors(outfile):
'''output size factors - requires cds object.'''
size_factors = r('''sizeFactors( cds )''')
samples = r('''names(sizeFactors(cds))''')
with iotools.open_file(outfile, "w") as outf:
outf.write("sample\tfactor\n")
for name, x in zip(samples, size_factors):
outf.write("%s\t%s\n" % (name, str(x)))
def deseqPlotCorrelationHeatmap(outfile, vsd):
'''plot a heatmap
Use variance stabilized data in object vsd.
Should be 'blind', as then the transform is
not informed by the experimental design.
'''
# rpy2.4.2 - passing of arrays seems to be broken - do it in R
# dists = r['as.matrix'](R.dist(R.t(R.exprs(vsd))))
dists = r('''as.matrix(dist(t(exprs(vsd))))''')
R.png(outfile)
r['heatmap.2'](
dists,
trace='none',
margin=ro.IntVector((10, 10)))
r['dev.off']()
def deseqPlotGeneHeatmap(outfile,
data,
Rowv=False,
Colv=False):
'''plot a heatmap of all genes
Use variance stabilized data in object vsd.
Should be 'blind', as then the transform is
not informed by the experimental design.
'''
if len(data) == 0:
return
# do not print if not enough values in one
# direction (single row or column)
if min(R.dim(data)) < 2:
return
R.png(outfile, width=500, height=2000)
hmcol = R.colorRampPalette(r['brewer.pal'](9, "GnBu"))(100)
r['heatmap.2'](
data,
col=hmcol,
trace="none",
dendrogram="none",
Rowv=Rowv,
Colv=Colv,
labRow=False,
margin=ro.IntVector((5, 5)),
lhei=ro.IntVector((1, 10)),
key=False)
r['dev.off']()
def deseqPlotPCA(outfile, vsd, max_genes=500):
'''plot a PCA
Use variance stabilized data in object vsd.
Should be 'blind', as then the transform is
not informed by the experimental design.
'''
R.png(outfile)
# if there are more than 500 genes (after filtering)
# use the 500 most variable in the PCA
# else use the number of genes
r('''ntop = ifelse(as.integer(dim(vsd))[1] >= %(max_genes)i,
%(max_genes)i,
as.integer(dim(vsd))[1])''' % locals())
try:
r('''plotPCA(vsd)''')
except RRuntimeError as msg:
E.warn("can not plot PCA: %s" % msg)
r['dev.off']()
def deseqPlotPairs(outfile):
'''requires counts table'''
# Plot pairs
R.png(outfile, width=960, height=960)
plotPairs()
r['dev.off']()
def deseqPlotPvaluesAgainstRowsums(outfile):
'''plot pvalues against row sum rank.
This plot is useful to see if quantile filtering could
be applied.
'''
r('''counts_sum = rowSums( countsTable )''')
R.png(outfile)
r('''plot( rank( counts_sum)/length(counts_sum),
-log10( res$pval),
pch = 16,
cex= 0.1)''')
r('''abline( a=3, b=0, col='red')''')
r['dev.off']()
def deseqParseResults(control_name, treatment_name, fdr, vsd=False):
'''parse deseq output.
retrieve deseq results from object 'res' in R namespace.
The 'res' object is a dataframe with the following columns (from the
DESeq manual):
id: The ID of the observable, taken from the row names of the
counts slots.
baseMean: The base mean (i.e., mean of the counts divided by the size
factors) for the counts for both conditions
baseMeanA: The base mean (i.e., mean of the counts divided by the size
factors) for the counts for condition A
baseMeanB: The base mean for condition B
foldChange: The ratio meanB/meanA
log2FoldChange: The log2 of the fold change
pval: The p value for rejecting the null hypothesis 'meanA==meanB'
padj: The adjusted p values (adjusted with 'p.adjust( pval,
method="BH")')
vsd_log2FoldChange: The log2 fold change after variance stabilization.
This data field is not part of DESeq proper, but has been added
in this module in the runDESeq() method.
Here, 'conditionA' is 'control' and 'conditionB' is 'treatment'
such that a foldChange of 2 means that treatment is twice
upregulated compared to control.
Returns a list of results.
If vsd is True, the log fold change will be computed from the variance
stabilized data.
'''
results = []
counts = E.Counter()
res_df = pandas2ri.ri2py(r["res"])
for index, data in res_df.iterrows():
counts.input += 1
# set significant flag
if data['padj'] <= fdr:
signif = 1
counts.significant += 1
if data['log2FoldChange'] > 0:
counts.significant_over += 1
else:
counts.significant_under += 1
else:
signif = 0
counts.insignificant += 1
if data['log2FoldChange'] > 0:
counts.all_over += 1
else:
counts.all_under += 1
# set lfold change to 0 if both are not expressed
if data['baseMeanA'] == 0.0 and data['baseMeanB'] == 0.0:
data['foldChange'] = 0
data['log2FoldChange'] = 0
if data['pval'] != r('''NA'''):
status = "OK"
else:
status = "FAIL"
counts[status] += 1
counts.output += 1
# check if our assumptions about the direction of fold change
# are correct
assert (data['foldChange'] > 1) == (data['baseMeanB'] > data['baseMeanA'])
# note that fold change is computed as second group (B) divided by
# first (A)
results.append(GeneExpressionResult._make((
data['id'],
treatment_name,
data['baseMeanB'],
0,
control_name,
data['baseMeanA'],
0,
data['pval'],
data['padj'],
data['log2FoldChange'],
data['foldChange'],
data['transformed_log2FoldChange'],
str(signif),
status)))
return results, counts
def deseq2ParseResults(treatment_name, control_name, fdr, vsd=False):
'''
Standardises the output format from deseq2.
Deseq2 has the following output columns:
baseMean log2FoldChange lfcSE stat pvalue padj
described in
https://bioconductor.org/packages/release/bioc/
vignettes/DESeq2/inst/doc/DESeq2.pdf
Standardised columns are generated from this output as follows:
test_id - the gene or region tested, row names from raw output
treatment_name - the first group in this differential expression
comparison (from the design file)
treatment_mean - the mean expression value for this treatment from the
normalised count table generated by deseq2
treatment_std - the standard deviation of experssion for this treatment
from the normalised count table generated by deseq2
control_name - the second group in this differential expression
comparison (from the design file)
control_mean - the mean expression value for this treatment from the
normalised count table generated by deseq2
control_std - the standard deviation of experssion for this treatment
from the normalised count table generated by deseq2
pvalue - the pvalue generated by deseq2 (from the pvalue column)
qvalue - the adjusted pvalue generated by deseq2 (from the padj column)
l2fold - the log2fold change between normalised counts generated by
deseq2 (log2FoldChange column). If betaPrior is set to TRUE, this is the
shrunken log2 fold change. If set to FALSE, no shrinkage.
fold - control mean / treatment mean
transformed_l2fold - not applicable, set to 0 (see deseq2 manual,
"The variance stabilizing and rlog transformations are provided
for applications other than differential testing,
for example clustering of samples or other machine learning applications.
For differential testing we recommend the DESeqfunction applied to raw
counts"
signif = True if the qvalue is less than the FDR set in `term`PARAMS.
status = OK if a pvalue has been generated, else FAIL
'''
r(''' fdr=%s ''' % fdr)
# assign standard column names
r('''cols = c("test_id",
"treatment_name",
"treatment_mean",
"treatment_std",
"control_name",
"control_mean",
"control_std",
"pvalue",
"qvalue",
"l2fold",
"fold",
"transformed_l2fold",
"signif",
"status") ''')
# extract normalised counts
r('''normalcounts = counts(dds, normalized=T)''')
# build empty dataframe
r('''res2 = data.frame(matrix(nrow=nrow(res), ncol=length(cols)))''')
r('''colnames(res2) = cols''')
# fill columns with values described above
r('''res2['test_id'] = rownames(res)''')
r('''g = unique(groups[groups == "%s" | groups == "%s"])''' % (treatment_name, control_name))
r('''g1 = which(groups == g[1])''')
r('''g2 = which(groups == g[2])''')
r('''res2['treatment_name'] = g[1]''')
r('''res2['treatment_mean'] = rowMeans(normalcounts[,g1])''')
r('''res2['treatment_std'] = apply(normalcounts[,g1], 1, sd)''')
r('''res2['control_name'] = g[2]''')
r('''res2['control_mean'] = rowMeans(normalcounts[,g2])''')
r('''res2['control_std'] = apply(normalcounts[,g2], 1, sd)''')
r('''res2['pvalue'] = res$pvalue''')
r('''res2['qvalue'] = res$padj''')
r('''res2['l2fold'] = res$log2FoldChange''')
# Fold change here does not reflect the shrinkage applied to
# log2fold changes
r('''res2['fold'] = res2$control_mean / res2$treatment_mean''')
r('''res2['signif'] = as.integer(res2$qvalue <= fdr)''')
r('''res2['status'] = ifelse(is.na(res2$pvalue), "FAIL", "OK")''')
# replace l2fold change and fold for expression levels of 0 in treatment
# and control with 0
r('''z1 = which(res2$treatment_mean == 0)''')
r('''z2 = which(res2$control_mean == 0)''')
r('''zeros = intersect(z1, z2)''')
r('''res2$l2fold[zeros] = 0''')
r('''res2$fold[zeros] = 0''')
# occupy transformed l2fold with 0s
r('''res2$transformed_l2fold = 0''')
D = r('res2')
D.index = D['test_id']
D = D.drop('test_id', 1)
return D
def runDESeq(outfile,
outfile_prefix="deseq.",
fdr=0.1,
prefix="",
fit_type="parametric",
dispersion_method="pooled",
sharing_mode="maximum",
ref_group=None,
ref_regex=None,
):
'''run DESeq on countsTable.
Results are stored in *outfile* and files prefixed by *outfile_prefix*.
The current analysis follows the analysis as outlined in version
1.14.0
DESeq ignores any pair information in the design matrix.
The output is treatment and control. Fold change values are
computed as treatment divided by control.
'''
# load library
r('''suppressMessages(library('DESeq'))''')
r('''suppressMessages(library('gplots'))''')
r('''suppressMessages(library('RColorBrewer'))''')
groups, pairs, has_replicates, has_pairs = groupTagData(ref_group,
ref_regex)
# Run DESeq
# Create Count data object
E.info("running DESeq: replicates=%s" % (has_replicates))
r('''cds <-newCountDataSet( countsTable, groups) ''')
# Estimate size factors
r('''cds <- estimateSizeFactors( cds )''')
no_size_factors = r('''is.na(sum(sizeFactors(cds)))''')[0]
if no_size_factors:
E.warn("no size factors - can not estimate - no output")
return
# estimate variance
if has_replicates:
E.info("replicates - estimating variance from replicates")
else:
E.info("no replicates - estimating variance with method='blind'")
dispersion_method = "blind"
E.info("dispersion_method=%s, fit_type=%s, sharing_mode=%s" %
(dispersion_method, fit_type, sharing_mode))
r('''cds <- estimateDispersions( cds,
method='%(dispersion_method)s',
fitType='%(fit_type)s',
sharingMode='%(sharing_mode)s')''' % locals())
# bring into python namespace
cds = r('''cds''')
# plot fit - if method == "pooled":
if dispersion_method == "pooled":
R.png('%sdispersion_estimates_pooled.png' %
outfile_prefix)
R.plotDispEsts(cds)
r['dev.off']()
elif not has_replicates:
# without replicates the following error appears
# in the rpy2.py2ri conversion:
# 'dims' cannot be of length 0
pass
else:
dispersions = r('''ls(cds@fitInfo)''')
for dispersion in dispersions:
R.png('%sdispersion_estimates_%s.png' %
(outfile_prefix, dispersion))
R.plotDispEsts(cds, name=dispersion)
r['dev.off']()
# plot size factors
deseqPlotSizeFactors('%(outfile_prefix)ssize_factors.png' % locals())
# output size factors
deseqOutputSizeFactors("%(outfile_prefix)ssize_factors.tsv" % locals())
# plot scatter plots of pairs
deseqPlotPairs('%(outfile_prefix)spairs.png' % locals())
if dispersion_method not in ("blind",):
# also do a blind dispersion estimate for
# a variance stabilizing transform
r('''cds_blind <- estimateDispersions( cds,
method='blind',
fitType='%(fit_type)s',
sharingMode='%(sharing_mode)s')''' % locals())
else:
r('''cds_blind = cds''')
# perform variance stabilization for log2 fold changes
vsd = r('''vsd = varianceStabilizingTransformation(cds_blind)''')
# output normalized counts (in order)
# gzfile does not work with rpy 2.4.2 in python namespace
# using R.gzfile, so do it in R-space
r('''t = counts(cds, normalized=TRUE);
write.table(t[order(rownames(t)),],
file=gzfile('%(outfile_prefix)scounts.tsv.gz'),
row.names=TRUE,
col.names=NA,
quote=FALSE,
sep='\t') ''' % locals())
# output variance stabilized counts (in order)
r('''t = exprs(vsd);
write.table(t[order(rownames(t)),],
file=gzfile('%(outfile_prefix)svsd.tsv.gz'),
row.names=TRUE,
col.names=NA,
quote=FALSE,
sep='\t')
''' % locals())
# plot correlation heatmap of variance stabilized data
deseqPlotCorrelationHeatmap(
'%scorrelation_heatmap.png' % outfile_prefix,
vsd)
# plot PCA
deseqPlotPCA('%spca.png' % outfile_prefix,
vsd)
# plot gene heatmap for all genes - order by average expression
# subtract one to get numpy indices
select = R.order(R.rowMeans(R.counts(cds)), decreasing=True)
# the following uses R-based indexing
deseqPlotGeneHeatmap(
'%sgene_heatmap.png' % outfile_prefix,
r['as.matrix'](R.exprs(vsd).rx(select)))
# plot heatmap of top 200 expressed genes
deseqPlotGeneHeatmap(
'%sgene_heatmap_top200.png' % outfile_prefix,
r['as.matrix'](R.exprs(vsd).rx(select[:200])))
# Call diffential expression for all pairings of groups included in the
# design
all_results = []
for combination in itertools.combinations(groups, 2):
control, treatment = combination
gfix = "%s_vs_%s_" % (control, treatment)
outfile_groups_prefix = outfile_prefix + gfix
E.info(("calling differential expression for "
"control=%s vs treatment=%s") %
(control, treatment))
res = r('''res = nbinomTest(cds, '%s', '%s')''' % (control, treatment))
# plot significance
R.png('''%(outfile_groups_prefix)ssignificance.png''' % locals())
r('''plot(
res$baseMean,
res$log2FoldChange,
log="x",
pch=20, cex=.1,
col = ifelse( res$padj < %(fdr)s, "red", "black"))''' % locals())
r['dev.off']()
# plot pvalues against rowsums
deseqPlotPvaluesAgainstRowsums(
'%(outfile_groups_prefix)spvalue_rowsums.png' % locals())
E.info("Generating output (%s vs %s)" % (control, treatment))
# get variance stabilized fold changes - note the reversal of
# treatment/control
r('''vsd_l2f =
(rowMeans(exprs(vsd)[,conditions(cds) == '%s', drop=FALSE])
- rowMeans( exprs(vsd)[,conditions(cds) == '%s', drop=FALSE]))''' %
(treatment, control))
# plot vsd correlation, see Figure 14 in the DESeq manual
# if you also want to colour by expression level
R.png('''%(outfile_groups_prefix)sfold_transformation.png''' %
locals())
r('''plot(
res$log2FoldChange, vsd_l2f,
pch=20, cex=.1,
col = ifelse( res$padj < %(fdr)s, "red", "black" ) )''' % locals())
r['dev.off']()
# plot heatmap of differentially expressed genes
# plot gene heatmap for all genes - order by average expression
select = r('''select = res['padj'] < %f''' % fdr)
if r('''sum(select)''')[0] > 0:
E.info('%s vs %s: plotting %i genes in heatmap' %
(treatment, control, len(select)))
data = R.exprs(vsd).rx(select)
if not isinstance(data, rpy2.robjects.vectors.FloatVector):
order = R.order(R.rowMeans(data), decreasing=True)
deseqPlotGeneHeatmap(
'%sgene_heatmap.png' % outfile_groups_prefix,
r['as.matrix'](data[order]),
Colv=False,
Rowv=True)
else:
E.warn('can not plot differentially expressed genes')
else:
E.warn('no differentially expressed genes at fdr %f' % fdr)
# Plot pvalue histogram
R.png('''%(outfile_groups_prefix)spvalue_histogram.png''' % locals())
r('''pvalues = res$pval''')
r('''hist(pvalues, breaks=50, col='skyblue' )''')
r['dev.off']()
# Plot diagnostic plots for FDR
if has_replicates:
r('''orderInPlot = order(pvalues)''')
r('''showInPlot = (pvalues[orderInPlot] < 0.08)''')
# Jethro - previously plotting x =
# pvalues[orderInPlot][showInPlot]
# pvalues[orderInPlot][showInPlot] contains all NA values
# from pvalues which(showInPlot) doesn't... removing NA
# values
r('''true.pvalues <- pvalues[orderInPlot][showInPlot]''')
r('''true.pvalues <- true.pvalues[is.finite(true.pvalues)]''')
if r('''sum(showInPlot)''')[0] > 0:
R.png('''%(outfile_groups_prefix)sfdr.png''' % locals())
# failure when no replicates:
# rpy2.rinterface.RRuntimeError:
# Error in plot.window(...) : need finite 'xlim' values
r('''plot( seq( along=which(showInPlot)),
true.pvalues,
pch='.',
xlab=expression(rank(p[i])),
ylab=expression(p[i]))''')
r('''abline(a = 0, b = %(fdr)f / length(pvalues), col = "red")
''' % locals())
r['dev.off']()
else:
E.warn('no p-values < 0.08')
# Add log2 fold with variance stabilized l2fold value
r('''res$transformed_log2FoldChange = vsd_l2f''')
# Parse results and parse to file
results, counts = deseqParseResults(control,
treatment,
fdr=fdr)
all_results += results
E.info(counts)
outf = iotools.open_file(
"%(outfile_groups_prefix)ssummary.tsv" % locals(), "w")
outf.write("category\tcounts\n%s\n" % counts.asTable())
outf.close()
writeExpressionResults(outfile, all_results)
def runDESeq2(outfile,
outfile_prefix="deseq2",
fdr=0.1,
ref_group=None,
model=None,
contrasts=None,
plot=1,
):
"""
Run DESeq2 on counts table.
If no model is passed, then defaults to the group column in design file
Does not make use of group tag data bc function doesn't accomodate
multi-factor designs
To Do: Parse results into standard output format.
KB: I have done this but I'm not sure if it is compatible with complex
design tables
Fix fact that plotMA is hardcoded.
"""
# load libraries
r('''suppressMessages(library('DESeq2'))''')
# Create metadata... this will eventually be a pandas dataframe
if isinstance(r('''factors'''), rpy2.robjects.vectors.DataFrame):
E.info("DESeq2: Merging additional factors in design file to"
"create metadata table")
r('''mdata <- cbind(groups, factors)''')
mdata = tuple(r('''names(mdata)'''))
else:
r('''mdata <- data.frame(group=groups)''')
mdata = "group"
E.info("DESeq2 colData headers are: %s" % mdata)
# Check for model and that model terms are in metadata table
if model:
assert contrasts, "Must specifiy contrasts if model design provided"
terms = set([x for x in re.split("\W", model) if x != ''])
assert terms.issubset(mdata), \
"DESeq2: design formula has terms not present in colData"
else:
if mdata != "group":
E.warn("DESeq2 model specified, with no metadata in design file")
terms = ["group", ]
model = "~ group"
E.info("DESeq2 design formula is: %s" % model)
# Create DESeqDataSet, using countsTable, mdata, model
r('''suppressMessages(dds <- DESeqDataSetFromMatrix(countData=countsTable,
colData=mdata,
design=%(model)s))''' % locals())
# WARNING: This is not done automatically... I don't know why?
r('''colnames(dds) <- colnames(countsTable)''')
E.info("Combined colata, design formula and counts table to create"
" DESeqDataSet instance")
# Rlog transform
r('''suppressMessages(rld <- rlog(dds))''')
if plot == 1:
# Plot PCA of rlog transformed count data for top 500
for factor in terms:
outf = outfile_prefix + factor + "_PCAplot500.tiff"
E.info("Creating PCA plot for factor: %s" % outf)
r('''x <- plotPCA(rld, intgroup="%(factor)s")''' % locals())
# r('''saveRDS(x, '%(outf)s')''' % locals())
r('''tiff("%(outf)s")''' % locals())
r('''plot(x)''')
r('''dev.off()''')
# Extract rlog transformed count data...
r('''rlogtab = as.data.frame(assay(rld))''')
r('''rlogtab$test_id = rownames(rlogtab)''')
r('''rlogtab = rlogtab[, c(ncol(rlogtab), 1:ncol(rlogtab)-1)]''')
r('''rlogtab = as.data.frame(rlogtab)''')
R.data('rlogtab')
rlog_out = r('rlogtab')
rlogoutf = outfile_prefix + "rlog.tsv"
rlog_out.to_csv(rlogoutf, sep="\t", index=False)
os.system("gzip %s" % rlogoutf)
# Run DESeq2
r('''suppressMessages(dds <- DESeq(dds))''')
E.info("Completed DESeq2 differential expression analysis")
# Extract contrasts...
if contrasts:
contrasts = (x.split(":") for x in contrasts.split(","))
else:
# created by loadTagData...
groups = r('''levels(groups)''')
contrasts = (("group",) + x for x in itertools.combinations(groups, 2))
df_final = pandas.DataFrame()
raw_final = pandas.DataFrame()
all_results = []
for combination in contrasts:
variable, control, treatment = combination
# Fetch results
gfix = "%s_%s_vs_%s" % (variable, control, treatment)
outfile_groups_prefix = outfile_prefix + gfix + "_MAplot.png"
r('''res <- results(dds, contrast=c("%(variable)s",
"%(treatment)s",
"%(control)s"))''' % locals())
E.info("Extracting contrast for levels %s (treatment) vs %s (control)"
" for factor %s" % (treatment, control, variable))
# plot MA plot
if plot == 1:
r('''png("%(outfile_groups_prefix)s")''' % locals())
r('''plotMA(res, alpha=%f)''' % fdr)
r('''dev.off()''')
E.info("Plotted MA plot for levels %s (treatment) vs %s (control)"
" for factor %s" % (treatment, control, variable))
r('''res_df <- as.data.frame(res)''')
r('''res_df$test_id = rownames(res_df)''')
r('''res_df = res_df[, c(ncol(res_df), 1:ncol(res_df)-1)]''')
R.data('res_df')
raw_out = r('res_df')
# manipulate output into standard format
df_out = deseq2ParseResults(treatment, control, fdr, vsd=False)
# label the deseq2 raw output file and append it to the raw output tab
raw_out["treatment"] = [treatment, ]*len(df_out.index)
raw_out["control"] = [control, ]*len(df_out.index)
raw_out["variable"] = [variable, ]*len(df_out.index)
raw_final = raw_final.append(raw_out, ignore_index=True)
# write the standardised output table
df_out.to_csv(iotools.open_file(outfile_prefix + gfix + ".tsv.gz", "w"),
sep="\t",
index_label="test_id")
E.info("Extracted results table for contrast '%s' (treatment) vs '%s'"
" (control) for factor '%s'" % (treatment, control, variable))
# append to final dataframe
df_out.reset_index(inplace=True)
df_out.rename(columns={"index": "test_id"}, inplace=True)
df_final = df_final.append(df_out, ignore_index=True)
results = df_final.values.tolist()
# write final dataframe into standard format
writeExpressionResults(outfile, results)
rawoutf = outfile_prefix + "raw.tsv"
raw_final.to_csv(rawoutf, sep="\t", index=False)
os.system("gzip %s" % rawoutf)
Design = collections.namedtuple("Design", ("include", "group", "pair"))
def readDesignFile(design_file):
'''reads a design file.'''
design = collections.OrderedDict()
with iotools.open_file(design_file) as inf:
for line in inf:
if line.startswith("track"):
continue
track, include, group, pair = line.split("\t")[:4]
if track in design:
raise ValueError("duplicate track '%s'" % track)
design[track] = Design._make((int(include), group, pair))
return design
def plotTagStats(infile, design_file, outfile_prefix):
'''provide summary plots for tag data.'''
loadTagData(infile, design_file)
nobservations, nsamples = filterTagData()
if nobservations == 0:
E.warn("no observations - no output")
return
if nsamples == 0:
E.warn("no samples remain after filtering - no output")
return
groups, pairs, has_replicates, has_pairs = groupTagData()
# import rpy2.robjects.lib.ggplot2 as ggplot2
r('''suppressMessages(library('ggplot2'))''')
r('''suppressMessages(library('reshape'))''')
r('''d = melt( log10(countsTable + 1), variable_name = 'sample' )''')
# Note that ggsave does not work if there is
# X display.
R.png(outfile_prefix + ".densities.png")
r('''gp = ggplot(d)''')
r('''pp = gp + geom_density(aes(x=value, group=sample,
color=sample, fill=sample), alpha=I(1/3))''')
r('''plot(pp)''')
r['dev.off']()
R.png(outfile_prefix + ".boxplots.png")
r('''gp = ggplot(d)''')
r('''pp = gp +
geom_boxplot(aes(x=sample,y=value,color=sample,fill=sample),
size=0.3,
alpha=I(1/3)) +
theme(axis.text.x = element_text( angle=90, hjust=1, size=8 ) )''')
r('''plot(pp)''')
r['dev.off']()
def plotDETagStats(infile, outfile_prefix,
additional_file=None,
join_columns=None,
additional_columns=None):
'''provide summary plots for tag data.
Stratify boxplots and densities according to differential
expression calls.
The input file is the output of any of the DE
tools, see GeneExpressionResults for column names.
Additional file will be joined with infile and any additional
columns will be output as well.
'''
table = pandas.read_csv(iotools.open_file(infile),
sep="\t")
if additional_file is not None:
additional_table = pandas.read_csv(
iotools.open_file(additional_file),
sep="\t")
table = pandas.merge(table,
additional_table,
on=join_columns,
how="left",
sort=False)
# remove index. If it is numbered starting from 1, there is a bug
# in ggplot, see https://github.com/yhat/ggplot/pull/384
table.reset_index(inplace=True)
# add log-transformed count data
table['log10_treatment_mean'] = numpy.log10(table['treatment_mean'] + 1)
table['log10_control_mean'] = numpy.log10(table['control_mean'] + 1)
table['dmr'] = numpy.array(["insignicant"] * len(table))
table.loc[
(table["l2fold"] > 0) & (table["significant"] == 1), "dmr"] = "up"
table.loc[
(table["l2fold"] < 0) & (table["significant"] == 1), "dmr"] = "down"
def _dplot(table, outfile, column):
plot = ggplot.ggplot(
ggplot.aes(column,
colour='dmr',
fill='dmr'),
data=table) + \
ggplot.geom_density(alpha=0.5)
try:
plot.save(filename=outfile)
except Exception as msg:
E.warn("no plot for %s: %s" % (column, msg))
def _bplot(table, outfile, column):
plot = ggplot.ggplot(
ggplot.aes(x='dmr', y=column),
data=table) + \
ggplot.geom_boxplot()
try:
plot.save(filename=outfile)
except ValueError as msg:
# boxplot fails if all values are the same
# see https://github.com/yhat/ggplot/issues/393
E.warn(msg)
# TODO: ggplot not supported, replace with plotnine
# _dplot(table,
# outfile_prefix + ".densities_tags_control.png",
# "log10_control_mean")
# _dplot(table,
# outfile_prefix + ".densities_tags_treatment.png",
# "log10_treatment_mean")
# _bplot(table,
# outfile_prefix + ".boxplot_tags_control.png",
# "log10_control_mean")
# _bplot(table,
# outfile_prefix + ".boxplot_tags_treatment.png",
# "log10_treatment_mean")
if additional_columns:
for column in additional_columns:
_dplot(table,
outfile_prefix + ".densities_%s.png" % column,
column)
_bplot(table,
outfile_prefix + ".boxplot_%s.png" % column,
column)
return
def runMockAnalysis(outfile,
outfile_prefix,
ref_group=None,
ref_regex=None,
pseudo_counts=0):
'''run a mock analysis on a count table.
compute fold enrichment values, but do not normalize or
perform any test.
'''
groups, pairs, has_replicates, has_pairs = groupTagData(ref_group,
ref_regex)
all_results = []
for combination in itertools.combinations(groups, 2):
control, treatment = combination
r('''control_counts = rowSums( countsTable[groups == '%s'] )''' %
control)
r('''treatment_counts = rowSums( countsTable[groups == '%s'] )''' %
treatment)
# add pseudocounts to enable analysis of regions
# that are absent/present
if pseudo_counts:
r('''control_counts = control_counts + %f''' % pseudo_counts)
r('''treatment_counts = treatment_counts + %f''' % pseudo_counts)
r('''fc = treatment_counts / control_counts''')
results = []
for identifier, treatment_count, control_count, foldchange in \
zip(r('''rownames( countsTable)'''),
r('''treatment_counts'''),
r('''control_counts'''),
r('''fc''')):
try:
log2fold = math.log(foldchange)
except ValueError:
log2fold = "Inf"
results.append(GeneExpressionResult._make((
identifier,
treatment,
treatment_count,
0,
control,
control_count,
0,
1,
1,
log2fold,
foldchange,
log2fold,
"0",
"OK")))
all_results.extend(results)
writeExpressionResults(outfile, all_results)
def outputTagSummary(filename_tags,
outfile,
output_filename_pattern,
filename_design=None):
'''output summary values for a count table.'''
E.info("loading tag data from %s" % filename_tags)
if filename_design is not None:
# load all tag data
loadTagData(filename_tags, filename_design)
# filter
nobservations, nsamples = filterTagData()
else:
# read complete table
r('''countsTable = read.delim('%(filename_tags)s',
header = TRUE,
row.names = 1,
stringsAsFactors = TRUE,
comment.char = '#')''' % locals())
nobservations, nsamples = tuple(r('''dim(countsTable)'''))
E.info("read data: %i observations for %i samples" %
(nobservations, nsamples))
# remove samples without data
r('''max_counts = apply(countsTable,2,max)''')
filter_min_counts_per_sample = 1
empty_samples = tuple(
r('''max_counts < %i''' % filter_min_counts_per_sample))
sample_names = r('''colnames(countsTable)''')
nempty_samples = sum(empty_samples)
if nempty_samples:
E.warn("%i empty samples are being removed: %s" %
(nempty_samples,
",".join([sample_names[x]
for x, y in enumerate(empty_samples) if y])))
r('''countsTable <- countsTable[, max_counts >= %i]''' %
filter_min_counts_per_sample)
nobservations, nsamples = tuple(r('''dim(countsTable)'''))
r('''groups = factor(colnames( countsTable ))''')
E.debug("sample names: %s" % r('''colnames(countsTable)'''))
nrows, ncolumns = tuple(r('''dim(countsTable)'''))
outfile.write("metric\tvalue\tpercent\n")
outfile.write("number of observations\t%i\t100\n" % nobservations)
outfile.write("number of samples\t%i\t100\n" % nsamples)
# Count windows with no data
r('''max_counts = apply(countsTable,1,max)''')
# output distribution of maximum number of counts per window
outfilename = output_filename_pattern + "max_counts.tsv.gz"
E.info("outputting maximum counts per window to %s" % outfilename)
r('''write.table(table(max_counts),
file=gzfile('%(outfilename)s'),
sep="\t",
row.names=FALSE,
quote=FALSE)''' %
locals())
# removing empty rows
E.info("removing rows with no counts in any sample")
r('''countsTable = countsTable[max_counts>0,]''')
if nrows > 0:
for x in range(0, 20):
nempty = tuple(r('''sum(max_counts <= %i)''' % x))[0]
outfile.write("max per row<=%i\t%i\t%f\n" %
(x, nempty, 100.0 * nempty / nrows))
E.info("removed %i empty rows" % tuple(r('''sum(max_counts == 0)''')))
observations, samples = tuple(r('''dim(countsTable)'''))
E.info("trimmed data: %i observations for %i samples" %
(observations, samples))
# build correlation
r('''correlations = cor(countsTable)''')
outfilename = output_filename_pattern + "correlation.tsv"
E.info("outputting sample correlations table to %s" % outfilename)
r('''write.table(correlations, file='%(outfilename)s',
sep="\t",
row.names=TRUE,
col.names=NA,
quote=FALSE)''' % locals())
# output scatter plots
outfilename = output_filename_pattern + "scatter.png"
E.info("outputting scatter plots to %s" % outfilename)
R.png(outfilename, width=960, height=960)
plotPairs()
r['dev.off']()
# output heatmap based on correlations
outfilename = output_filename_pattern + "heatmap.svg"
E.info("outputting correlation heatmap to %s" % outfilename)
R.svg(outfilename)
plotCorrelationHeatmap(method="correlation")
r['dev.off']()
# output PCA
outfilename = output_filename_pattern + "pca.svg"
E.info("outputting PCA plot to %s" % outfilename)
R.svg(outfilename)
plotPCA(groups=False)
r['dev.off']()
# output an MDS plot
r('''suppressMessages(library('limma'))''')
outfilename = output_filename_pattern + "mds.svg"
E.info("outputting mds plot to %s" % outfilename)
R.svg(outfilename)
try:
r('''plotMDS(countsTable)''')
except RRuntimeError:
E.warn("can not plot mds")
r['dev.off']()
def dumpTagData(filename_tags, filename_design, outfile):
'''output filtered tag table.'''
if outfile == sys.stdout:
outfilename = ""
else:
outfilename = outfile.name
# load all tag data
loadTagData(filename_tags, filename_design)
# filter
nobservations, nsamples = filterTagData()
# output
r('''write.table( countsTable,
file='%(outfilename)s',
sep='\t',
quote=FALSE)''' % locals())
def runTTest(outfile,
outfile_prefix,
fdr=0.1,
ref_group=None,
ref_regex=None):
'''apply a ttest on the data.
For the T-test it is best to use FPKM values as
this method does not perform any library normalization.
'''
groups, pairs, has_replicates, has_pairs = groupTagData(ref_group,
ref_regex)
results = []
for combination in itertools.combinations(groups, 2):
control, treatment = combination
r = r('''r = apply(countsTable, 1,
function(x) { t.test(
x[groups == '%(treatment)s'],
x[groups == '%(control)s']) } )
''' % locals())
for test_id, ttest in zip(r.names, r):
# TS, swapped order below as assignment was incorrect
treatment_mean, control_mean = tuple(ttest.rx2('estimate'))
fold_change = treatment_mean / control_mean
pvalue = tuple(ttest.rx2('p.value'))[0]
significant = (0, 1)[pvalue < fdr]
results.append(GeneExpressionResult._make((test_id,
treatment,
treatment_mean,
0,
control,
control_mean,
0,
pvalue,
pvalue,
numpy.log2(fold_change),
fold_change,
numpy.log2(fold_change),
significant,
"OK")))
writeExpressionResults(outfile, results)
#####################################################################
# Pandas-based functions and matplotlib-based plotting functions ####
#####################################################################
def loadTagDataPandas(tags_filename, design_filename):
'''load tag data for deseq/edger analysis.
*Infile* is a tab-separated file with counts.
*design_file* is a tab-separated file with the
experimental design with four columns::
track include group pair
CW-CD14-R1 0 CD14 1
CW-CD14-R2 0 CD14 1
CW-CD14-R3 1 CD14 1
CW-CD4-R1 1 CD4 1
FM-CD14-R1 1 CD14 2
FM-CD4-R2 0 CD4 2
FM-CD4-R3 0 CD4 2
FM-CD4-R4 0 CD4 2
track
name of track - should correspond to column header in *infile*
include
flag to indicate whether or not to include this data
group
group indicator - experimental group
pair
pair that sample belongs to (for paired tests)
This method creates various R objects:
countsTable : data frame with counts.
groups : vector with groups
pairs : vector with pairs
'''
E.info("loading tag data from %s" % tags_filename)
inf = iotools.open_file(tags_filename)
counts_table = pandas.read_csv(inf,
sep="\t",
index_col=0,
comment="#")
inf.close()
E.info("read data: %i observations for %i samples" %
counts_table.shape)
E.debug("sample names: %s" % list(counts_table.columns))
inf = iotools.open_file(design_filename)
design_table = pandas.read_csv(inf, sep="\t", index_col=0)
inf.close()
E.debug("design names: %s" % list(design_table.index))
missing = set(counts_table.columns).difference(design_table.index)
if missing:
E.warn("missing samples from design file are ignored: %s" % missing)
# remove unnecessary samples
design_table = design_table[design_table["include"] != 0]
E.debug("included samples: %s" % list(design_table.index))
counts_table = counts_table[list(design_table.index)]
E.info("filtered data: %i observations for %i samples" %
counts_table.shape)
return counts_table, design_table
def filterTagDataPandas(counts_table,
design_table,
filter_min_counts_per_row=1,
filter_min_counts_per_sample=10,
filter_percentile_rowsums=0):
'''filter tag data.
* remove rows with at least x number of counts
* remove samples with a maximum of *min_sample_counts*
* remove the lowest percentile of rows in the table, sorted
by total tags per row
'''
# Remove windows with no data
max_counts_per_row = counts_table.max(1)
counts_table = counts_table[
max_counts_per_row >= filter_min_counts_per_row]
observations, samples = counts_table.shape
E.info("trimmed data: %i observations for %i samples" %
(observations, samples))
# remove samples without data
max_counts_per_sample = counts_table.max()
empty_samples = max_counts_per_sample < filter_min_counts_per_sample
sample_names = counts_table.columns
nempty_samples = sum(empty_samples)
if nempty_samples:
E.warn("%i empty samples are being removed: %s" %
(nempty_samples,
",".join([sample_names[x] for x, y in
enumerate(empty_samples) if y])))
raise NotImplementedError("removing empty samples needs to be done")
# r('''countsTable <- countsTable[, max_counts >= %i]''' % filter_min_counts_per_sample)
# r('''groups <- groups[max_counts >= %i]''' % filter_min_counts_per_sample)
# r('''pairs <- pairs[max_counts >= %i]''' % filter_min_counts_per_sample)
# observations, samples = tuple( r('''dim(countsTable)'''))
# percentile filtering
if filter_percentile_rowsums > 0:
percentile = float(filter_percentile_rowsums) / 100.0
sum_counts = counts_table.sum(1)
take = sum_counts > sum_counts.quantile(percentile)
E.info("percentile filtering at level %f: keep=%i, discard=%i" %
(filter_percentile_rowsums,
sum(take),
len(take) - sum(take)))
counts_table = counts_table[take]
return counts_table
def identifyVariablesPandas(design_table):
# design table should have been processed by loadTagDataPandas already
# just in case, re-filter for not included samples here
design_table = design_table[design_table["include"] != 0]
conds = design_table['group'].tolist()
pairs = design_table['pair'].tolist()
# TS, adapted from JJ code for DESeq2 design tables:
# if additional columns present, pass to 'factors'
if len(design_table.columns) > 3:
factors = design_table.iloc[:, 3:]
else:
factors = None
return conds, pairs, factors
def checkTagGroupsPandas(design_table, ref_group=None):
'''compute groups and pairs from tag data table.'''
conds, pairs, factors = identifyVariablesPandas(design_table)
groups = list(set(conds))
# Relevel the groups so that the reference comes first
# how to do this in python?
# if ref_group is not None:
# r('''groups <- relevel(groups, ref = "%s")''' % ref_group)
# check this works, will need to make factors from normal df
# TS adapted from JJ code for DESeq2 -
# check whether there are additional factors in design file...
if factors:
E.warn("There are additional factors in design file that are ignored"
" by groupTagData: ", factors)
else:
pass
# Test if replicates exist - at least one group must have multiple samples
max_per_group = max([conds.count(x) for x in groups])
has_replicates = max_per_group >= 2
# Test if pairs exist:
npairs = len(set(pairs))
has_pairs = npairs == 2
# ..if so, at least two samples are required per pair
if has_pairs:
min_per_pair = min([pairs.count(x) for x in set(pairs)])
has_pairs = min_per_pair >= 2
return groups, pairs, conds, factors, has_replicates, has_pairs
ResultColumns = ["test_id", "treatment_name", "treatment_mean",
"treatment_std", "control_name", "control_mean",
"control_std", "p_value", "p_value_adj", "l2fold", "fold",
"transformed_l2fold", "significant", "status"]
ResultColumns_dtype = {"test_id": object, "treatment_name": object,
"treatment_mean": float, "treatment_std":
float, "control_name": object, "control_mean":
float, "control_std": float, "p_value": float,
"p_value_adj": float, "l2fold": float, "fold":
float, "transformed_l2fold": float,
"significant": int, "status": object}
def makeEmptyDataFrameDict():
return {key: [] for key in ResultColumns}
def runTTestPandas(counts_table,
design_table,
outfile,
outfile_prefix,
fdr,
ref_group=None):
'''apply a ttest on the data.
For the T-test it is best to use FPKM values as
this method does not perform any library normalization.
Alternatively, perform normalisation on counts table using Counts.py
'''
stats = importr('stats')
(groups, pairs, conds, factors, has_replicates,
has_pairs) = checkTagGroupsPandas(design_table, ref_group)
df_dict = makeEmptyDataFrameDict()
for combination in itertools.combinations(groups, 2):
# as each combination may have different numbers of samples in control
# and treatment, calculations have to be performed on a per
# combination basis
control, treatment = combination
n_rows = counts_table.shape[0]
df_dict["control_name"].extend((control,)*n_rows)
df_dict["treatment_name"].extend((treatment,)*n_rows)
df_dict["test_id"].extend(counts_table.index.tolist())
# subset counts table for each combination
c_keep = [x == control for x in conds]
control_counts = counts_table.iloc[:, c_keep]
t_keep = [x == treatment for x in conds]
treatment_counts = counts_table.iloc[:, t_keep]
c_mean = control_counts.mean(axis=1)
df_dict["control_mean"].extend(c_mean)
df_dict["control_std"].extend(control_counts.std(axis=1))
t_mean = treatment_counts.mean(axis=1)
df_dict["treatment_mean"].extend(t_mean)
df_dict["treatment_std"].extend(treatment_counts.std(axis=1))
t, prob = ttest_ind(control_counts, treatment_counts, axis=1)
df_dict["p_value"].extend(prob)
# what about zero values?!
df_dict["fold"].extend(t_mean / c_mean)
df_dict["p_value_adj"].extend(
list(stats.p_adjust(FloatVector(df_dict["p_value"]), method='BH')))
df_dict["significant"].extend(
[int(x < fdr) for x in df_dict["p_value_adj"]])
df_dict["l2fold"].extend(list(numpy.log2(df_dict["fold"])))
# note: the transformed log2 fold change is not transformed!
df_dict["transformed_l2fold"].extend(list(numpy.log2(df_dict["fold"])))
# set all status values to "OK"
df_dict["status"].extend(("OK",)*n_rows)
results = pandas.DataFrame(df_dict)
results.set_index("test_id", inplace=True)
results.to_csv(outfile, sep="\t", header=True, index=True)
def plotCorrelationHeatmapMatplot(counts, outfile, method="correlation",
cor_method="pearson"):
'''plot a heatmap of correlations derived from
countsTable.
'''
# to do: add other methods?
# define outside function? - Will we reuse?
heatmap_cdict_b_to_y = {
'red': ((0.0, 0.4, .4), (0.01, .4, .4), (1., .95, .95)),
'green': ((0.0, 0.4, 0.4), (0.01, .4, .4), (1., .95, .95)),
'blue': ((0.0, .9, .9), (0.01, .9, .9), (1., 0.4, 0.4))}
cm = matplotlib.colors.LinearSegmentedColormap(
'', heatmap_cdict_b_to_y, 256)
df = counts.corr(method=cor_method)
plt.pcolor(np.array(df), cmap=cm)
plt.colorbar()
plt.title("%(cor_method)s correlation heatmap" % locals())
plt.yticks(np.arange(0.5, len(df.index), 1), df.index)
plt.xticks(np.arange(0.5, len(df.columns), 1), df.columns, rotation=90)
plt.tight_layout()
plt.savefig(outfile)
def runEdgeRPandas(counts,
design_table,
outfile,
outfile_prefix="edger.",
fdr=0.1,
prefix="",
dispersion=None,
ref_group=None):
'''run EdgeR on countsTable.
Results are stored in *outfile* and files prefixed by *outfile_prefix*.
The dispersion is usually measuered from replicates. If there are no
replicates, you need to set the *dispersion* explicitely.
See page 13 of the EdgeR user guide::
2. Simply pick a reasonable dispersion value, based on your
experience with similar data, and use that. Although
subjective, this is still more defensible than assuming Poisson
variation. Typical values are dispersion=0.4 for human data,
dispersion=0.1 for data on genetically identical model
organisms or dispersion=0.01 for technical replicates.
'''
# load library
r('''suppressMessages(library('edgeR'))''')
(groups, pairs, conds, factors, has_replicates,
has_pairs) = checkTagGroupsPandas(design_table, ref_group)
if not has_replicates and dispersion is None:
raise ValueError("no replicates and no dispersion")
# output heatmap plot
plotCorrelationHeatmapMatplot(counts,
'%(outfile_prefix)sheatmap.png' % locals(),
cor_method="spearman")
E.info('running EdgeR: groups=%s, pairs=%s, replicates=%s, pairs=%s' %
(groups, pairs, has_replicates, has_pairs))
r_counts = pandas2ri.py2ri(counts)
passDFtoRGlobalEnvironment = r('''function(df){
countsTable <<- df}''')
passDFtoRGlobalEnvironment(r_counts)
if has_pairs:
# output difference between groups
# TS #####
# this is performed on non-normalised data
# should we use Counts.py to normalise first?
# also, this isn't edgeR specific, should this be
# moved to a seperate summary function?
# also move the MDS plotting?
# #####
first = True
pairs_df = | pandas.DataFrame() | pandas.DataFrame |
import pandas as pd
import numpy as np
# Filter csv data based on application args
def filter(filter_args):
# Read in csv data
df = pd.read_csv('soilgenerate/data/12072016_plants_sheff.csv', encoding="utf-8")
## BEGIN Default Filters
# Filter nan
is_not_nan = pd.notnull(df['Growth Rate'])
df = df[is_not_nan]
is_not_nan = | pd.notnull(df['Planting Density per Acre, Maximum']) | pandas.notnull |
import os, gzip, logging, re
import pandas as pd
from typing import List, Tuple
from common.base_parser import BaseParser
from common.constants import *
logging.basicConfig(level=logging.INFO, format='%(asctime)s %(message)s',
handlers=[logging.StreamHandler()])
# protein name types:
REC_FULLNAME = 'recommended full name'
REC_SHORTNAME = 'recommended short name'
ALT_FULLNAME = 'alternative full name'
ALT_SHORTNAME = 'alternative short name'
UNIPROT_FILE = 'sprot.tsv'
UNIPROT_2_GENE = 'sprot2gene.tsv'
UNIPROT_2_GO = 'sprot2go.tsv'
UNIPROT_SYNONYM = 'sprot2syn.tsv'
UNIPROT_SYNONYM_DERIVED = 'sprot2syn_derived.tsv'
class Entry:
def __init__(self):
self.id: str = ''
self.other_accessions = []
self.name: str = ''
self.gene_name: str = ''
self.dataset: str = 'Swiss-Prot'
self.protein_names: List[Tuple[str, str]] = []
self.tax_id: str = ''
self.function: str = ''
self.pathway: str = ''
self.go_ids = []
def add_protein_name(self, type, name):
if name:
self.protein_names.append((type, name))
def get_all_names(self):
names = []
for _, name in self.protein_names:
names.append(name)
return names
def get_synonym_rows(self):
s = ''
for protein_type, name in self.protein_names:
s += f'{self.id}\t{name}\t{protein_type}\n'
return s
def get_alternative_accession_rows(self):
s = ''
for item in self.other_accessions:
s += f'{self.id}\t{item}\n'
return s
def get_go_rows(self):
s = ''
for k in self.go_ids:
go_id = k.replace('GO:', '')
s += f'{self.id}\t{go_id}\n'
return s
class UniprotParser(BaseParser):
def __init__(self, prefix: str):
BaseParser.__init__(self, prefix, 'uniprot')
self.uniprot_file = 'uniprot_sprot.dat.gz'
self.id_mapping_file = 'idmapping_selected.tab.gz'
self.logger = logging.getLogger(__name__)
def parse_uniprot_file(self):
entries = []
self.logger.info("Start parsing file:" + self.uniprot_file)
with gzip.open(os.path.join(self.download_dir, self.uniprot_file), 'rt') as f:
for line in f:
if not line.startswith('CC '):
function = False
pathway = False
if line.startswith('ID'):
if entries and len(entries) % 10000 == 0:
logging.info(str(len(entries)))
pre_line_type = None
entry = Entry()
entry.name = line[3:].strip().split(' ')[0]
entries.append(entry)
else:
# ID indicates the start of a new section block
# otherwise get the last entry to update it
entry = entries[-1]
if line.startswith('AC'):
line = line[3:].strip().strip(';')
items = re.split(';\s*', line)
# currently we are not storing other accession in neo4j. Could be useful in the future if we need to use it
if not entry.id:
entry.id = items[0]
if len(items) > 1:
entry.other_accessions = entry.other_accessions + items[1:]
else:
entry.other_accessions = entry.other_accessions + items
elif line.startswith('DE'):
text = line[3:].strip()
if text.startswith('RecName: Full='):
entry.add_protein_name(REC_FULLNAME, self._clean_name(text[len('RecName: Full='):]))
pre_line_type = 'RecName'
elif text.startswith('AltName: Full='):
entry.add_protein_name(ALT_FULLNAME, self._clean_name(text[len('AltName: Full='):]))
pre_line_type = 'AltName'
elif text.startswith('Short='):
if pre_line_type == 'RecName':
entry.add_protein_name(REC_SHORTNAME, self._clean_name(text[len('Short='):]))
elif pre_line_type == 'AltName':
entry.add_protein_name(ALT_SHORTNAME, self._clean_name(text[len('Short='):]))
elif line.startswith('OX NCBI_TaxID='):
entry.tax_id = self._clean_name(line[len('OX NCBI_TaxID='):])
elif line.startswith('GN Name='):
entry.gene_name = self._clean_name(line[len('GN Name='):])
elif line.startswith('DR GO;'):
entry.go_ids.append(self._clean_name(line[len('DR GO;'):]))
elif line.startswith('CC -!- FUNCTION:'):
function = True
entry.function = self._clean_name(line[len('CC -!- FUNCTION:'):], False)
elif line.startswith('CC -!- PATHWAY:'):
pathway = True
if entry.pathway:
entry.pathway += '; '
entry.pathway += self._clean_name(line[len('CC -!- PATHWAY:'):], False)
elif line.startswith('CC '):
if function:
entry.function += ' ' + self._clean_name(line[len('CC '):], False)
elif pathway:
entry.pathway += ' ' + self._clean_name(line[len('CC '):], False)
self.logger.info(f'Total entries: {len(entries)}')
return entries
def _clean_name(self, text:str, clean_brace=True):
item = text.split(';')[0]
if clean_brace and '{' in item:
item = item[:item.find('{')]
return item.strip()
def parse_and_write_data_files(self):
entries = self.parse_uniprot_file()
self.write_protein_file(entries)
self.write_protein2synonym_file(entries)
self.write_protein2go_file(entries)
self.parse_and_write_sprot2gene_file()
self.extract_protein_symbol_as_synonym()
self.extract_multiple_genes_from_sprot2gene()
def write_protein_file(self, entries):
self.logger.info("write sprot.tsv")
with open(os.path.join(self.output_dir, self.file_prefix + 'sprot.tsv'), 'w') as f:
f.write('\t'.join([PROP_ID, PROP_NAME, PROP_GENE_NAME, PROP_TAX_ID, PROP_PATHWAY, PROP_FUNCTION]) + '\n')
f.writelines('\t'.join([entry.id, entry.name, entry.gene_name, entry.tax_id, entry.pathway, entry.function])+'\n' for entry in entries)
def write_protein2synonym_file(self, entries):
self.logger.info("write sprot2syn")
names = set()
for entry in entries:
names.update(entry.get_all_names())
with open(os.path.join(self.output_dir, self.file_prefix + 'sprot2syn.tsv'), 'w') as f:
f.write('\t'.join([PROP_ID, PROP_NAME, PROP_TYPE]) + '\n')
f.writelines(entry.get_synonym_rows() for entry in entries)
def write_protein2go_file(self, entries):
self.logger.info("write sprot2go")
with open(os.path.join(self.output_dir, self.file_prefix + 'sprot2go.tsv'), 'w') as f:
f.write(f'{PROP_ID}\t{PROP_GO_ID}\n')
f.writelines(entry.get_go_rows() for entry in entries)
def parse_and_write_sprot2gene_file(self):
self.logger.info("write sprot2gene")
# get sprot ids
df = pd.read_table(os.path.join(self.output_dir, self.file_prefix + 'sprot.tsv'))
sprot_ids = set([id for id in df[PROP_ID]])
with gzip.open(os.path.join(self.download_dir, self.id_mapping_file), 'rt') as f:
self.logger.info('opened gzip idmapping_selected.tab.gz to start writing sprot2gene')
with open(os.path.join(self.output_dir, self.file_prefix + 'sprot2gene.tsv'), 'w') as outfile:
outfile.write(f'{PROP_ID}\t{PROP_GENE_ID}\n')
rows = 0
lines = 0
for line in f:
lines += 1
# if lines % 10000 == 0:
# print(lines)
if len(line) > 10000:
# some rows are too long, truncate it as we only need the first two columns
line = line[:1000]
row = line.split('\t')
if len(row) < 2:
break
if row[2] and row[0] in sprot_ids:
rows += 1
outfile.write(f'{row[0]}\t{row[2]}\n')
self.logger.info('finished writing sprot2gene.tsv. rows:' + str(rows))
def extract_multiple_genes_from_sprot2gene(self):
self.logger.info('split gene_id columns when values have multiple gene ids')
df = pd.read_table(os.path.join(self.output_dir, self.file_prefix + 'sprot2gene.tsv'))
print('sprot2gene:', len(df))
df_m = df[df[PROP_GENE_ID].str.contains(';')]
df = df[~df[PROP_GENE_ID].str.contains(';')]
print('sprot2gene with multiple genes:', len(df_m), 'single gene:', len(df))
df_m.set_index(PROP_ID, inplace=True)
df_m = df_m[PROP_GENE_ID].str.split(';', expand=True).stack()
df_m = df_m.reset_index().rename(columns={0: PROP_GENE_ID})
df_m[PROP_GENE_ID] = df_m[PROP_GENE_ID].str.strip()
df_m = df_m[[PROP_ID, PROP_GENE_ID]]
print('split genes:', len(df_m))
df = | pd.concat([df, df_m]) | pandas.concat |
#!/usr/bin/env python
# coding: utf-8
# Author:
# <NAME>
# Emotional Sentiment on Twitter
# A coronavirus vaccine online firestorm
# In this python script you will find examples of some of the most common
# NLP (Natural Language Processing) techniques used to uncover patterns of
# sentiment and emotion on social media microblogging platforms like Twitter.
# It is organized as follows:
# - Step 1: Exploratory analysis
# - Step 2: Text processing
# - Step 3: Sentiment analysis
# - Step 4: Word frequency
# - Step 5: LDA topics extraction
# - Step 6: Emotion analysis
#
# ## Step 1: EXPLORATORY ANALYSIS
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from collections import defaultdict
from datetime import date
import re # for regular expressions
import string
# Importing the data
tweets = pd.read_csv('input/tweets.csv')
# getting the date column ready for datetime operations
tweets['datetime']= pd.to_datetime(tweets['datetime'])
# A plot of the tweets with the word "CureVac" over the past 6 years.
fig = plt.figure(figsize=(15, 10))
ax = sns.lineplot(data=tweets.set_index("datetime").groupby(pd.Grouper(freq='Y')).count())
plt.title('Tweets with "CureVac" from 2014 to 2020', fontsize=20)
plt.xlabel('Years', fontsize=15)
plt.ylabel('Tweets', fontsize=15)
fig.savefig("images/All_Tweets_2014-2020.png")
# creating a column to filter the online storm period (from 15 and 18 March)
def make_onlinestorm_field():
for i, row in tweets.iterrows():
if pd.to_datetime(tweets.at[i, 'datetime']) > pd.Timestamp(date(2020,3,15)):
tweets.at[i, 'onlinestorm'] = True
else:
tweets.at[i, 'onlinestorm'] = False
make_onlinestorm_field()
# counting tweets during the three days online storm
print('In three days, tweets went over {}, all around the world.'.format(tweets[tweets['onlinestorm']]['onlinestorm'].count()))
tweets[tweets['onlinestorm']]
# Let's now have a look at the distribution of the tweets, by the hour, during the online storm.
fig = plt.figure(figsize=(15, 10))
ax = sns.lineplot(data=tweets[tweets['onlinestorm'] == True].set_index("datetime").groupby(pd.Grouper(freq='H')).onlinestorm.count())
plt.title('Tweets per hour from 15 to 18 March 2020', fontsize=20)
plt.xlabel('Time (hours)', fontsize=15)
plt.ylabel('No. Tweets', fontsize=15)
fig.savefig("images/All_Tweets_Onlinestorm.png")
# It is time to have a first look at the content of the tweets and do some descriptive statistics.
# For now, I will focus only on features like hastags, mentions, urls, capital words and words in general.
# A function to count tweets based on regular expressions
def count_tweets(reg_expression, tweet):
tweets_list = re.findall(reg_expression, tweet)
return len(tweets_list)
# Creating a dictionary to hold these counts
content_count = {
'words' : tweets['text'].apply(lambda x: count_tweets(r'\w+', x)),
'mentions' : tweets['text'].apply(lambda x: count_tweets(r'@\w+', x)),
'hashtags' : tweets['text'].apply(lambda x: count_tweets(r'#\w+', x)),
'urls' : tweets['text'].apply(lambda x: count_tweets(r'http.?://[^\s]+[\s]?', x)),
}
df = pd.concat([tweets, pd.DataFrame(content_count)], axis=1)
# Tweets descriptive statistics
# Display descriptive statistics fdor words, mentions,
# hashtags and urls
for key in content_count.keys():
print()
print('Descriptive statistics for {}'.format(key))
print(df.groupby('onlinestorm')[key].describe())
# Now plot them
for key in content_count.keys():
bins = np.arange(df[key].min(), df[key].max() + 1)
g = sns.FacetGrid(df, col='onlinestorm', height=5, hue='onlinestorm', palette="RdYlGn")
g = g.map(sns.distplot, key, kde=False, norm_hist=True, bins=bins)
plt.savefig('images/Descriptive_stats_for_' + key + '.png')
# Step 2: TEXT PROCESSING
import nltk
from nltk.corpus import stopwords
from nltk.stem.snowball import SnowballStemmer
from nltk.stem import WordNetLemmatizer
from nltk.tokenize import sent_tokenize, word_tokenize
from nltk import pos_tag
# I am adding my own stopwords list to the NLTK list.
# This way we can drop words that are irrelevant for text processing
MY_STOPWORDS = ['curevac','vaccine','german','mrna','biotech','cancer', 'lilly','eli','ag','etherna_immuno', 'translatebio', 'mooreorless62','boehringer', 'ingelheim','biopharmaceutical', 'company']
STOPLIST = set(stopwords.words('english') + list(MY_STOPWORDS))
SYMBOLS = " ".join(string.punctuation).split(" ") + ["-", "...", "”", "``", ",", ".", ":", "''","#","@"]
# The NLTK lemmatizer and stemmer classes
lemmatizer = WordNetLemmatizer()
stemmer = SnowballStemmer('english')
# read english selected tweets, no duplicates
tweets = pd.read_csv('input/tweets_en.csv')
# I use the POS tagging from NLTK to retain only adjectives, verbs, adverbs
# and nouns as a base for for lemmatization.
def get_lemmas(tweet):
# A dictionary to help convert Treebank tags to WordNet
treebank2wordnet = {'NN':'n', 'JJ':'a', 'VB':'v', 'RB':'r'}
postag = ''
lemmas_list = []
for word, tag in pos_tag(word_tokenize(tweet)):
if tag.startswith("JJ") or tag.startswith("RB") or tag.startswith("VB") or tag.startswith("NN"):
try:
postag = treebank2wordnet[tag[:2]]
except:
postag = 'n'
lemmas_list.append(lemmatizer.lemmatize(word.lower(), postag))
return lemmas_list
# We will now pre-process the tweets, following a pipeline of tokenization,
# filtering, case normalization and lemma extraction.
# This is the function to clean and filter the tokens in each tweet
def clean_tweet(tokens):
filtered = []
for token in tokens:
if re.search('[a-zA-Z]', token):
if token not in STOPLIST:
if token[0] not in SYMBOLS:
if not token.startswith('http'):
if '/' not in token:
if '-' not in token:
filtered.append(token)
return filtered
# Prior to lemmatization, I apply POS (part-of-speech) tagging to make sure that only the
# adjectives, verbs, adverbs and nouns are retained.
# Starts the lemmatization process
def get_lemmatized(tweet):
all_tokens_string = ''
filtered = []
tokens = []
# lemmatize
tokens = [token for token in get_lemmas(tweet)]
# filter
filtered = clean_tweet(tokens)
# join everything into a single string
all_tokens_string = ' '.join(filtered)
return all_tokens_string
# get the lemmatized tweets and puts the result in an "edited" text column
# for future use in this script
edited = ''
for i, row in tweets.iterrows():
edited = get_lemmatized(tweets.loc[i]['text'])
if len(edited) > 0:
tweets.at[i,'edited'] = edited
else:
tweets.at[i,'edited'] = None
# After lemmatization, some tweets may end up with the same words
# Let's make sure that we have no duplicates
tweets.drop_duplicates(subset=['edited'], inplace=True)
tweets.dropna(inplace=True)
# With these text processing steps, and the removal of duplicates,
# the final sample counts 5,508 English-language tweets,
# with an average of 30 words (SD 12.5, ranging from 4 to 61 words).
# Using apply/lambda to create a new column with the number of words in each tweet
tweets['word_count'] = tweets.apply(lambda x: len(x['text'].split()),axis=1)
t = pd.DataFrame(tweets['word_count'].describe()).T
tweets.head()
# Step 3: SENTIMENT ANALYSIS
# Let us import the VADER analyser.
from nltk.sentiment.vader import SentimentIntensityAnalyzer
# For the puropose of the timeseries analysis, we must make sure that the tweets are all correctly sorted.
tweets['datetime']=pd.to_datetime(tweets['datetime'])
tweets.sort_values('datetime', inplace=True, ascending=True)
tweets = tweets.reset_index(drop=True)
# Creating a column to "filter" the online storm period.
make_onlinestorm_field()
# To avoid repetitions in our code, here are some plotting functions
# that will be called often ...
def plot_sentiment_period(df, info):
# Using the mean values of sentiment for each period
df1 = df.groupby(df['datetime'].dt.to_period(info['period'])).mean()
df1.reset_index(inplace=True)
df1['datetime'] = pd.PeriodIndex(df1['datetime']).to_timestamp()
plot_df = pd.DataFrame(df1, df1.index, info['cols'])
plt.figure(figsize=(15, 10))
ax = sns.lineplot(data=plot_df, linewidth = 3, dashes = False)
plt.legend(loc='best', fontsize=15)
plt.title(info['title'], fontsize=20)
plt.xlabel(info['xlab'], fontsize=15)
plt.ylabel(info['ylab'], fontsize=15)
plt.tight_layout()
plt.savefig('images/' + info['fname'])
return
def plot_fractions(props, title, fname):
plt1 = props.plot(kind='bar', stacked=False, figsize=(16,5), colormap='Spectral')
plt.legend(bbox_to_anchor=(1.005, 1), loc=2, borderaxespad=0.)
plt.xlabel('Online storm', fontweight='bold', fontsize=18)
plt.xticks(rotation=0,fontsize=14)
#plt.ylim(0, 0.5)
plt.ylabel('Fraction of Tweets', fontweight='bold', fontsize=18)
plt1.set_title(label=title, fontweight='bold', size=20)
plt.tight_layout()
plt.savefig('images/' + fname + '.png')
return
def plot_frequency_chart(info):
fig, ax = plt.subplots(figsize=(14, 8))
sns.set_context("notebook", font_scale=1)
ax = sns.barplot(x=info['x'], y=info['y'], data=info['data'], palette=(info['pal']))
ax.set_title(label=info['title'], fontweight='bold', size=18)
plt.ylabel(info['ylab'], fontsize=16)
plt.xlabel(info['xlab'], fontsize=16)
plt.xticks(rotation=info['angle'],fontsize=14)
plt.yticks(fontsize=14)
plt.tight_layout()
plt.savefig('images/' + info['fname'])
return
# Calling VADER
analyzer = SentimentIntensityAnalyzer()
# Get VADER Compound value for sentiment intensity
tweets['sentiment_intensity'] = [analyzer.polarity_scores(v)['compound'] for v in tweets['edited']]
# This function returns the sentiment category
def get_sentiment(intensity):
if intensity >= 0.05:
return 'Positive'
elif (intensity >= -0.05) and (intensity < 0.05):
return 'Neutral'
else:
return 'Negative'
# Using pandas apply/lambda to speed up the process
tweets['sentiment'] = tweets.apply(lambda x: get_sentiment(x['sentiment_intensity']),axis=1)
# The next plot gives us a clear image of the “explosion” of contradictory sentiments in this period:
df=tweets.loc[:,['datetime','sentiment_intensity']]
# filter for these dates
df.set_index('datetime',inplace=True)
df=df[(df.index>='2020-03-12') & (df.index<'2020-03-18')]
df.plot(figsize=(12,6));
plt.ylabel('Compoud score', fontsize=15)
plt.xlabel('Tweets', fontsize=15)
plt.legend().set_visible(False)
plt.title('Sentiment on tweets with CureVac (12 March to 18 March)', fontsize=20)
plt.tight_layout()
sns.despine(top=True)
plt.savefig('images/Sentiment_during_onlinestorm.png')
plt.show()
# And this one will shows us a comparison of the sentiments before and during the online strom.
# Values are normalized to take into account the number of tweets in each
# of the two different periods
props = tweets.groupby('onlinestorm')['sentiment'].value_counts(normalize=True).unstack()
plot_fractions(props,'Percentage of sentiments before and during the online storm',
'Fraction_sentiments_before_and_during_onlinestorm')
# Step 4: Word frequency
# We need these imports for the wordcloud representation:
from PIL import Image
from wordcloud import WordCloud, STOPWORDS, ImageColorGenerator
from matplotlib.colors import makeMappingArray
from palettable.colorbrewer.diverging import Spectral_4
from collections import Counter # Counts the most common items in a list
def display_wordcloud(tokens, title, fname):
tokens_upper = [token.upper() for token in tokens]
cloud_mask = np.array(Image.open("images/cloud_mask.png"))
wordcloud = WordCloud(max_font_size=100,
max_words=50, width=2500,
height=1750,mask=cloud_mask,
background_color="white").generate(" ".join(tokens_upper))
plt.figure()
fig, ax = plt.subplots(figsize=(14, 8))
plt.title(title, fontsize=20)
plt.imshow(wordcloud, interpolation="bilinear")
plt.axis("off")
plt.savefig('images/'+ fname + '.png')
plt.show()
return
def join_edited_string(edited_tweets):
edited_string = ''
for row in edited_tweets:
edited_string = edited_string + ' ' + row
return edited_string
def get_trigrams(trigrams, top_grams):
grams_str = []
data = []
gram_counter = Counter(trigrams)
for grams in gram_counter.most_common(10):
gram = ''
grams_str = grams[0]
grams_str_count = []
for n in range(0,3):
gram = gram + grams_str[n] + ' '
grams_str_count.append(gram)
grams_str_count.append(grams[1])
data.append(grams_str_count)
print(grams_str_count)
df = pd.DataFrame(data, columns = ['Grams', 'Count'])
return df
# Let’s have a look at the 20 most frequent words in tweets before the online storm.
# Filtering the tweets of the 6 years before the online storm
df = tweets[tweets['onlinestorm'] == False]
# Join all the edited tweets in one single string
joined_string = join_edited_string(df['edited'])
# Get tokens
tokens = joined_string.split(' ')
# get trigrams
trigrams = nltk.trigrams(tokens)
# plot word frequency during online storm
word_counter = Counter(tokens)
df_counter = pd.DataFrame(word_counter.most_common(20), columns = ['word', 'freq'])
info = {'data': df_counter, 'x': 'freq', 'y': 'word',
'xlab': 'Count', 'ylab': 'Words', 'pal':'viridis',
'title': 'Most frequent words before online storm',
'fname':'word_frequency_before_onlinestorm.png',
'angle': 90}
plot_frequency_chart(info)
# plot trigram frequency
df_trigrams = get_trigrams(trigrams, 10)
info = {'data': df_trigrams, 'x': 'Grams', 'y': 'Count',
'xlab': 'Trigrams', 'ylab': 'Count', 'pal':'viridis',
'title': 'Most frequent trigrams before online storm',
'fname':'trigrams_frequency_before_onlinestorm.png',
'angle': 40}
plot_frequency_chart(info)
# And the wordcloud ...
display_wordcloud(tokens, 'Wordcloud of most frequent words before online storm',
'WordCloud_before_onlinestorm')
# Filtering the tweets of the 3 days of the online storm
df =tweets[tweets['onlinestorm']]
# Join all the edited tweets in one single string
joined_string = join_edited_string(df['edited'])
# Get tokens
tokens = joined_string.split(' ')
# get trigrams
trigrams = nltk.trigrams(tokens)
# plot word frequency during online storm
word_counter = Counter(tokens)
df_counter = pd.DataFrame(word_counter.most_common(20), columns = ['word', 'freq'])
info = {'data': df_counter, 'x': 'freq', 'y': 'word',
'xlab': 'Count', 'ylab': 'Words', 'pal':'inferno',
'title': 'Most frequent words during online storm',
'fname':'word_frequency_during_onlinestorm.png',
'angle': 90}
plot_frequency_chart(info)
# In[139]:
# plot trigrams frequency
df_trigrams = get_trigrams(trigrams, 10)
info = {'data': df_trigrams, 'x': 'Grams', 'y': 'Count',
'xlab': 'Trigrams', 'ylab': 'Count', 'pal':'inferno',
'title': 'Most frequent trigrams during online storm',
'fname':'trigrams_frequency_during_onlinestorm.png',
'angle': 40}
plot_frequency_chart(info)
# In[140]:
display_wordcloud(tokens, 'Wordcloud of most frequent words during online storm',
'WordCloud_during_onlinestorm')
# Step 5: LDA topics extraction
from sklearn.decomposition import LatentDirichletAllocation
from sklearn.feature_extraction.text import TfidfVectorizer
# I am using here Susan Li's functions to get the top words from a topic:
def get_keys(topic_matrix):
'''
returns an integer list of predicted topic
categories for a given topic matrix
'''
keys = topic_matrix.argmax(axis=1).tolist()
return keys
def keys_to_counts(keys):
'''
returns a tuple of topic categories and their
accompanying magnitudes for a given list of keys
'''
count_pairs = Counter(keys).items()
categories = [pair[0] for pair in count_pairs]
counts = [pair[1] for pair in count_pairs]
return (categories, counts)
def get_top_n_words(n, n_topics, keys, document_term_matrix, tfidf_vectorizer):
'''
returns a list of n_topic strings, where each string contains the n most common
words in a predicted category, in order
'''
top_word_indices = []
for topic in range(n_topics):
temp_vector_sum = 0
for i in range(len(keys)):
if keys[i] == topic:
temp_vector_sum += document_term_matrix[i]
temp_vector_sum = temp_vector_sum.toarray()
top_n_word_indices = np.flip(np.argsort(temp_vector_sum)[0][-n:],0)
top_word_indices.append(top_n_word_indices)
top_words = []
for topic in top_word_indices:
topic_words = []
for index in topic:
temp_word_vector = np.zeros((1,document_term_matrix.shape[1]))
temp_word_vector[:, index] = 1
the_word = tfidf_vectorizer.inverse_transform(temp_word_vector)[0][0]
try:
topic_words.append(the_word.encode('ascii').decode('utf-8'))
except:
pass
top_words.append(", ".join(topic_words))
return top_words
# And here is a function for topics extraction using LDA, in which I produce a dataframe
# with the topics and their top words to facilitate the plotting that follows.
# LDA topics
def get_topics(edited, n_topics, n_words):
eds = edited.values
vec = TfidfVectorizer(use_idf=True, smooth_idf=True)
document_term_matrix = vec.fit_transform(eds)
model = LatentDirichletAllocation(n_components=n_topics)
topic_matrix = model.fit_transform(document_term_matrix)
keys = get_keys(topic_matrix)
categories, counts = keys_to_counts(keys)
top_n_words = get_top_n_words(n_words, n_topics, keys, document_term_matrix, vec)
topics = ['Topic {}: \n'.format(i + 1) + top_n_words[i] for i in categories]
data=[]
for i, topic in enumerate(topics):
tmp = []
tmp.append(topic)
tmp.append(counts[i])
data.append(tmp)
df_topics = pd.DataFrame(data, columns = ['Topics', 'Count'])
return df_topics
# Topics before the online storm
# Filtering the tweets of the 6 years before the online storm
df = tweets[tweets['onlinestorm'] == False]
# LDA topics
df_topics = get_topics(df['edited'], 5, 5)
info = {'data': df_topics, 'x': 'Topics', 'y': 'Count',
'xlab': 'Topics', 'ylab': 'Count', 'pal':'viridis',
'title': 'LDA Topics before Online Storm',
'fname':'LDA_Topics_before_onlinestorm.png',
'angle': 40}
plot_frequency_chart(info)
# Topics during the online storm
# Filtering the tweets of the 3 days of the online storm
df =tweets[tweets['onlinestorm']]
# LDA topics
df_topics = get_topics(df['edited'], 5, 5)
info = {'data': df_topics, 'x': 'Topics', 'y': 'Count',
'xlab': 'Topics', 'ylab': 'Count', 'pal':'inferno',
'title': 'Main Topics during Online Storm',
'fname':'LDA_Topics_during_onlinestorm.png',
'angle': 40}
plot_frequency_chart(info)
# Step 6: Emotion analysis
import termcolor
import sys
from termcolor import colored, cprint
plt.style.use('fivethirtyeight')
# Importing the data from the NCR lexicon
ncr = pd.read_csv('input/NCR-lexicon.csv', sep =';')
# Let's create a list of the emotions
emotions = ['Anger', 'Anticipation','Disgust','Fear', 'Joy','Sadness', 'Surprise', 'Trust']
# Join all the edited tweets in one single string
joined_string = join_edited_string(df['edited'])
# Get tokens
tokens = joined_string.split(' ')
# We build now two dictionaries with indexes and unique words, for future reference
unique_words = set(tokens)
word_to_ind = dict((word, i) for i, word in enumerate(unique_words))
ind_to_word = dict((i, word) for i, word in enumerate(unique_words))
def plot_emotions_period(df, cols, title, fname, period = 'h' ):
df1 = df.groupby(df['datetime'].dt.to_period(period)).mean()
df1.reset_index(inplace=True)
df1['datetime'] = pd.PeriodIndex(df1['datetime']).to_timestamp()
plot_df = pd.DataFrame(df1, df1.index, cols)
plt.figure(figsize=(15, 10))
ax = sns.lineplot(data=plot_df, linewidth = 3,dashes = False)
plt.legend(loc='best', fontsize=15)
plt.title(title, fontsize=20)
plt.xlabel('Time (hours)', fontsize=15)
plt.ylabel('Z-scored Emotions', fontsize=15)
plt.savefig('images/'+ fname + '.png')
return
def get_tweet_emotions(df, emotions, col):
df_tweets = df.copy()
df_tweets.drop(['sentiment','sentiment_intensity'], axis=1, inplace=True)
emo_info = {'emotion':'' , 'emo_frq': defaultdict(int) }
list_emotion_counts = []
# creating a dictionary list to hold the frequency of the words
# contributing to the emotions
for emotion in emotions:
emo_info = {}
emo_info['emotion'] = emotion
emo_info['emo_frq'] = defaultdict(int)
list_emotion_counts.append(emo_info)
# bulding a zeros matrix to hold the emotions data
df_emotions = pd.DataFrame(0, index=df.index, columns=emotions)
# stemming the word to facilitate the search in NRC
stemmer = SnowballStemmer("english")
# iterating in the tweets data set
for i, row in df_tweets.iterrows(): # for each tweet ...
tweet = word_tokenize(df_tweets.loc[i][col])
for word in tweet: # for each word ...
word_stemmed = stemmer.stem(word.lower())
# check if the word is in NRC
result = ncr[ncr.English == word_stemmed]
# we have a match
if not result.empty:
# update the tweet-emotions counts
for idx, emotion in enumerate(emotions):
df_emotions.at[i, emotion] += result[emotion]
# update the frequencies dictionary list
if result[emotion].any():
try:
list_emotion_counts[idx]['emo_frq'][word_to_ind[word]] += 1
except:
continue
# append the emotions matrix to the tweets data set
df_tweets = | pd.concat([df_tweets, df_emotions], axis=1) | pandas.concat |
import pandas as pd
from . import processing
def plottable_sums(reference_df, behaviour, identifier_column="Animal_id", periods={}, period_label="period", metadata_columns={"TreatmentProtocol_code":"Treatment"}):
identifiers = list(set(reference_df[identifier_column]))
evaluation_df = pd.DataFrame({})
for identifier in identifiers:
identifier_df = reference_df[reference_df[identifier_column]==identifier]
evaluation_path = identifier_df["Evaluation_path"].values[0]
identifier_data = {}
for metadata_column in metadata_columns:
identifier_data[metadata_columns[metadata_column]] = identifier_df[metadata_column].values[0]
for period in periods:
period_start, period_end = periods[period]
sums = processing.timedelta_sums(evaluation_path, index_name=identifier, period_start=period_start, period_end=period_end)
#We need to calculate this explicitly since the start/end of th experiment may not align perfecty with the theoretical period
real_period_duration = sums.sum(axis=1).values[0]
#if the behaviour key is not found, there was none of that behaviour type in the period
try:
behaviour_ratio = sums[behaviour].values[0]/real_period_duration
except KeyError:
behaviour_ratio = 0
identifier_data[behaviour.title()+" Ratio"] = behaviour_ratio
identifier_data[period_label] = period
identifier_data["Identifier"] = identifier
period_df_slice = pd.DataFrame(identifier_data, index=[identifier])
evaluation_df = pd.concat([evaluation_df, period_df_slice])
#data is usually ordered as it comes, for nicer plots we sort it here
evaluation_df = evaluation_df.sort_values([period_label], ascending=True)
evaluation_df = evaluation_df.sort_values(list(metadata_columns.values()), ascending=False)
return evaluation_df
def plottable_sucrosepreference_df(reference_df):
cage_ids = list(set(reference_df["Cage_id"]))
preferences_df = pd.DataFrame({})
for cage_id in cage_ids:
cage_id_df = reference_df[reference_df["Cage_id"]==cage_id]
reference_dates = list(set(cage_id_df["SucrosePreferenceMeasurement_reference_date"]))
reference_dates.sort()
measurement_dates = list(set(cage_id_df["SucrosePreferenceMeasurement_date"]))
measurement_dates.sort()
first_date = reference_dates[0]
preferences={}
for measurement_date in measurement_dates:
cage_id_measurement_df = cage_id_df[cage_id_df["SucrosePreferenceMeasurement_date"] == measurement_date]
start_date = cage_id_measurement_df["SucrosePreferenceMeasurement_reference_date"].tolist()[0]
relative_start_day = start_date-first_date
rounded_relative_start_day = processing.rounded_days(relative_start_day)
relative_end_day = measurement_date-first_date
rounded_relative_end_day = processing.rounded_days(relative_end_day)
key = "{} to {}".format(rounded_relative_start_day, rounded_relative_end_day)
water_start = cage_id_measurement_df["SucrosePreferenceMeasurement_water_start_amount"].tolist()[0]
water_end = cage_id_measurement_df["SucrosePreferenceMeasurement_water_end_amount"].tolist()[0]
sucrose_start = cage_id_measurement_df["SucrosePreferenceMeasurement_sucrose_start_amount"].tolist()[0]
sucrose_end = cage_id_measurement_df["SucrosePreferenceMeasurement_sucrose_end_amount"].tolist()[0]
water_consumption = water_end - water_start
sucrose_consumption = sucrose_end - sucrose_start
sucrose_prefernce = sucrose_consumption/(water_consumption + sucrose_consumption)
preferences["Period [days]"] = key
preferences["Sucrose Preference Ratio"] = sucrose_prefernce
preferences["Sucrose Bottle Position"] = cage_id_measurement_df["SucrosePreferenceMeasurement_sucrose_bottle_position"].tolist()[0]
preferences["Sucrose Concentration"] = cage_id_measurement_df["SucrosePreferenceMeasurement_sucrose_concentration"].tolist()[0]
preferences["Treatment"] = cage_id_measurement_df["TreatmentProtocol_code"].tolist()[0]
preferences["Cage ID"] = cage_id # this may not actually be needed, as the same info is contained in the index
preferences_df_slice = pd.DataFrame(preferences, index=[cage_id])
preferences_df = | pd.concat([preferences_df, preferences_df_slice]) | pandas.concat |
import os
import pandas as pd
import numpy as np
import math
from datetime import datetime
import csv
from helpers import make_directory
# If date is specified, calculate ranking up until that date
def get_rankings(from_file, to_file, date=None, include_prediction=False, predicted_date_so_far=None, ranking_summary_file=None):
if date:
datet = datetime.strptime(date, '%Y-%m-%d')
if not (from_file and to_file):
raise ValueError("Error: get_rankings: Give a from_file/to_file pair")
df = pd.read_csv(from_file)
scores = dict()
for _, row in df.iterrows():
if type(row['Date']) is float:
continue
if date and datetime.strptime(row['Date'], '%Y-%m-%d') > datet:
break
# That means this row is a prediction value
if not include_prediction and row['FTHG'] == 0 and row['FTAG'] == 0 and row['FTR'] != 'D':
break
# Meaning this game is not played and not predicted yet
if row['FTR'] is np.nan:
break
home = row['HomeTeam']
away = row['AwayTeam']
if home not in scores:
scores[home] = {
'match_played': 0,
'points': 0,
'goal_diff': 0,
'win': 0
}
if away not in scores:
scores[away] = {
'match_played': 0,
'points': 0,
'goal_diff': 0,
'win': 0
}
scores[home]['match_played'] += 1
scores[away]['match_played'] += 1
match_goal_diff = row['FTHG'] - row['FTAG']
scores[home]['goal_diff'] += match_goal_diff
scores[away]['goal_diff'] -= match_goal_diff
if row['FTR'] == 'H':
scores[home]['points'] += 3
scores[home]['win'] += 1
elif row['FTR'] == 'A':
scores[away]['points'] += 3
scores[away]['win'] += 1
else:
scores[home]['points'] += 1
scores[away]['points'] += 1
teams = sorted(scores, key=lambda k: scores[k]['points'], reverse=True)
points, goal_diff, win_rate = [], [], []
for name in teams:
val = scores[name]
points.append(val['points'])
goal_diff.append(val['goal_diff'])
win_rate.append(val['win'] / val['match_played'])
df = pd.DataFrame(list(zip(teams, points, goal_diff, win_rate)), columns=['Team', 'Points', 'Goal_Diff', 'Win_Rate'])
make_directory(to_file)
df.to_csv(to_file, index=False)
if include_prediction and predicted_date_so_far and ranking_summary_file:
round_df = pd.DataFrame(list(zip(teams, points)), columns=['Team', predicted_date_so_far])
round_df.set_index('Team', inplace=True)
round_df = round_df.transpose()
round_df.index.name = 'Date'
if os.path.isfile(ranking_summary_file):
summary_df = | pd.read_csv(ranking_summary_file) | pandas.read_csv |
def scatter_plot(Matrix,identifier_dataframe,cmap_categ,cmap_multiplier,title,size,screen_labels):
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
"""
This function goal is to allow data visualization of 2D or 3D matrices of
data with different attributes
RESULT: A 2D or 3D visualization of the data, with different colors for
each different categories. The centroids of each class are also ploted.
(with the formula of unweighted barycenters)
PARAMS :
- 'Matrix' refers to a 2D or 3D Matrix of data
- 'identifier_dataframe' must have 2 columns :
--> "main_category" (String), the categorie's column of labels
-->"color" (Integer), it's color transposition
- 'cmap_categ' refers to the 'colormaps_reference' in matplotlib :
https://matplotlib.org/examples/color/colormaps_reference.html
- 'cmap_multiplier' is the multiplier to apply to the categories in order to
scale the colors between 1 and 100
- 'size' refers to the points sizes
- 'screen_labels' refers to the way of displaying the point's categories:
--> choose 'centroids' if you want to display the labels at the categories
centroids levels
--> let the string empty if you want to display one label each 50 points
"""
if Matrix.shape[1] ==1:
df_plot=pd.DataFrame(Matrix,columns =['X'])
df_plot['Y']=1
if Matrix.shape[1] ==2:
df_plot=pd.DataFrame(Matrix,columns =['X','Y'])
if Matrix.shape[1] ==3:
df_plot=pd.DataFrame(Matrix,columns =['X','Y','Z'])
fig = plt.figure(figsize=(13, 13))
ax = plt.axes(projection='3d')
min_X = min(df_plot.X)
max_X = max(df_plot.X)
min_Y = min(df_plot.Y)
max_Y = max(df_plot.Y)
min_Z = min(df_plot.Z)
max_Z = max(df_plot.Z)
# Data for a three-dimensional line
xline = np.linspace(min_X, max_X, 50)
yline = np.linspace(min_Y, max_Y, 50)
zline = np.linspace(min_Z, max_Z, 50)
ax.plot3D(xline, yline, zline, 'gray')
new_identifier_df = | pd.DataFrame(identifier_dataframe) | pandas.DataFrame |
from tweepy import OAuthHandler
from tweepy import API
from tweepy import Stream
from tweepy.streaming import StreamListener
import json
import time
import sys
import pandas as pd
import numpy as np
import twitter_dataprep as dataprep
import twitter_cache as tc
class SListener(StreamListener):
def __init__(self, api = None, fprefix = 'streamer'):
self.api = api or API()
self.counter = 0
self.fprefix = fprefix
self.output = open('tweets.json', 'w')
self.cache = tc.twitter_cache()
self.cache.clean_allcache()
def on_data(self, data):
if 'in_reply_to_status' in data:
##Debug
#print('=================='+str(self.counter)+'=========')
#print(data)
self.on_status(data)
elif 'delete' in data:
delete = json.loads(data)['delete']['status']
if self.on_delete(delete['id'], delete['user_id']) is False:
return False
elif 'limit' in data:
if self.on_limit(json.loads(data)['limit']['track']) is False:
return False
elif 'warning' in data:
warning = json.loads(data)['warnings']
print("WARNING: %s" % warning['message'])
return
def on_status(self, status):
self.output.write(status)
self.counter += 1
#if self.counter >= 20000:
if self.counter >= 1000:
self.output.close()
self.output = open('%s_%s.json' % (self.fprefix, time.strftime('%Y%m%d-%H%M%S')), 'w')
self.counter = 0
#print(self.counter)
df_tweets=pd.DataFrame(dataprep.process_raw(status))
#self.cache.add_df_cache(key=str(df_tweets.id.max()),df=df_tweets)
self.cache.add_cache(ns='twitter_cache:raw:',key=str(df_tweets.id.max()),value=str(df_tweets.to_json(orient='records')))
return
def on_delete(self, status_id, user_id):
print("Delete notice")
return
#def on_limit(self, track):
#print("WARNING: Limitation notice received, tweets missed: %d" % track)
# return
def on_error(self, status_code):
print('Encountered error with status code:', status_code)
return
def on_timeout(self):
print("Timeout, sleeping for 60 seconds...")
time.sleep(60)
return
class twitter_collector():
def __init__(self,cache=''):
##Init stream object
# Consumer key authentication(consumer_key,consumer_secret can be collected from our twitter developer profile)
auth = OAuthHandler('<KEY>', '<KEY>')
# Access key authentication(access_token,access_token_secret can be collected from our twitter developer profile)
auth.set_access_token('<KEY>', '<KEY>')
# Set up the API with the authentication handler
api = API(auth)
# Instantiate the cache object for twitter stream
#self.cache = tc.twitter_cache()
# Instantiate the SListener object
self.listen = SListener(api=api)
# Instantiate the Stream object
self.stream = Stream(auth, self.listen)
# Initiate collector counters
self.listen.cache.add_cache(ns='twitter_cache:summary:',key='total_tweets',value=0)
self.listen.cache.add_cache(ns='twitter_cache:summary:',key='trump_tweets',value=0)
self.listen.cache.add_cache(ns='twitter_cache:summary:',key='biden_tweets',value=0)
def start(self,keywords=['biden','trump'],duration=0):
# Begin collecting data
self.stream.filter(track = keywords, is_async=True)
# if collector object started with duration specified, stop after X seconds
if duration>0:
time.sleep(duration)
self.stream.disconnect()
print('streaming stopped after '+str(duration)+"s")
self.summary()
def stop(self):
#Disconnect the streaming object
self.stream.disconnect()
time.sleep(1)
print("Twitter collector stopped!")
self.summary()
def refresh_summary(self,clear_raw=True):
'''
Load raw tweets and process summary
Delete raw tweets from redis cache if [clear_raw=True]
'''
try:
df_summary=dataprep.repack_tweets(self.listen.cache.get_rawcache(ns='twitter_cache:raw:',return_df=True))
except Exception as e:
print ('Error to load raw tweets and refresh summary! Error Msg: {0}'.format(e))
return
if clear_raw:
self.listen.cache.clear_rawcache(ns='twitter_cache:raw:')
# Update counters
total_tweets=int(self.listen.cache.get_cache(ns='twitter_cache:summary:',key='total_tweets'))+len(df_summary.index)
trump_tweets=int(self.listen.cache.get_cache(ns='twitter_cache:summary:',key='trump_tweets'))+np.sum(dataprep.check_word_in_tweet('trump',df_summary))
biden_tweets=int(self.listen.cache.get_cache(ns='twitter_cache:summary:',key='biden_tweets'))+np.sum(dataprep.check_word_in_tweet('biden',df_summary))
self.listen.cache.add_cache(ns='twitter_cache:summary:',key='total_tweets',value=str(total_tweets))
self.listen.cache.add_cache(ns='twitter_cache:summary:',key='trump_tweets',value=str(trump_tweets))
self.listen.cache.add_cache(ns='twitter_cache:summary:',key='biden_tweets',value=str(biden_tweets))
## Build the word count histogram
trump_wcloud = df_summary[dataprep.check_word_in_tweet('trump',df_summary)].text.str.split(expand=True).stack().value_counts().rename_axis('keyword').to_frame('counts')
biden_wcloud = df_summary[dataprep.check_word_in_tweet('biden',df_summary)].text.str.split(expand=True).stack().value_counts().rename_axis('keyword').to_frame('counts')
exclude_word = ['AT_USER','rt','URL','is','am','are','was','were','a','an','of','the','to','in','for','and','i','you','at','this','there','that','he','she','it','his','her','will','on','by','about','with','and','or']
trump_wcloud=trump_wcloud[~trump_wcloud.index.isin(exclude_word)].nlargest(10,'counts')
biden_wcloud=biden_wcloud[~biden_wcloud.index.isin(exclude_word)].nlargest(10,'counts')
trump_wc = self.listen.cache.get_df_cache(ns='twitter_cache:summary:',key='trump_wc')
biden_wc = self.listen.cache.get_df_cache(ns='twitter_cache:summary:',key='biden_wc')
if not trump_wc.empty:
trump_wc = | pd.concat([trump_wc,trump_wcloud]) | pandas.concat |
# The MIT License (MIT)
# Copyright (c) 2018 Massachusetts Institute of Technology
#
# Author: <NAME>
# This software has been created in projects supported by the US National
# Science Foundation and NASA (PI: Pankratius)
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
# Standard library imports
from collections import OrderedDict
from getpass import getpass
# Scikit Data Access
from skdaccess.framework.data_class import DataFetcherStream, TableWrapper
# Third party packages
import pandas as pd
from alpha_vantage.timeseries import TimeSeries
class DataFetcher(DataFetcherStream):
""" Data Fetcher for retrieving stock data """
def __init__(self, ap_paramList, data_type, start_date=None, end_date=None, interval=None):
"""
@param ap_paramList[stock_symbol_list]: AutoList of stock symbols
@param data_type: Type of data to retrieve (daily, daily_adjusted, intraday, monthly, monthly_adjusted, weekly, weekly_adjusted)
@param start_date: Starting date
@param end_date: Ending date
@param interval: Interval for intraday (1min, 5min, 15min, 30min, 60min)
@return: Table data wrapper of stock data
"""
self.data_type = data_type
self.start_date = start_date
self.end_date = end_date
self.interval = interval
self.possible_intervals = ('1min', '5min', '15min', '30min', '60min')
self.possible_data_types = ("daily", "daily_adjusted", "intraday", "monthly", "monthly_adjusted", "weekly", "weekly_adjusted")
if interval not in self.possible_intervals and data_type == 'intraday':
raise RuntimeError('Did not understand interval: "' + str(interval) + '" to use with intraday data type')
elif interval is not None and data_type != 'intraday':
raise RuntimeError('interval is only used with data type intraday')
api_key = DataFetcher.getConfigItem('stocks', 'api_key')
write_key = False
while api_key is None or api_key == "":
api_key = getpass(prompt='Alpha Vantage API key')
write_key = True
if write_key:
DataFetcher.writeConfigItem('stocks','api_key', api_key)
super(DataFetcher, self).__init__(ap_paramList)
def output(self):
"""
Retrieve stock data
@return TableWrapper of stock data
"""
stock_symbols = self.ap_paramList[0]()
timeseries_retriever = TimeSeries(key=DataFetcher.getConfigItem('stocks','api_key'),
output_format='pandas',
indexing_type = 'date')
data_dict = OrderedDict()
metadata_dict = OrderedDict()
for symbol in stock_symbols:
# Extract data
if self.data_type == 'daily':
data, metadata = timeseries_retriever.get_daily(symbol, outputsize='full')
elif self.data_type == 'daily_adjusted':
data, metadata = timeseries_retriever.get_daily_adjusted(symbol, outputsize='full')
elif self.data_type == 'monthly':
data, metadata = timeseries_retriever.get_monthly(symbol)
elif self.data_type == 'monthly_adjusted':
data, metadata = timeseries_retriever.get_monthly_adjusted(symbol)
elif self.data_type == 'weekly':
data, metadata = timeseries_retriever.get_weekly(symbol)
elif self.data_type == 'weekly_adjusted':
data, metadata = timeseries_retriever.get_weekly_adjusted(symbol)
elif self.data_type == 'intraday':
data, metadata = timeseries_retriever.get_weekly_adjusted(symbol, self.interval, outputsize='full')
# Convert index to pandas datetime
if self.data_type == 'intraday':
data.index = | pd.to_datetime(data.index) | pandas.to_datetime |
# coding: utf-8
import os
import pandas as pd
from tqdm import tqdm
from czsc.objects import RawBar, Freq
from czsc.utils.bar_generator import BarGenerator, freq_end_time
from test.test_analyze import read_1min
cur_path = os.path.split(os.path.realpath(__file__))[0]
kline = read_1min()
def test_freq_end_time():
assert freq_end_time(pd.to_datetime("2021-11-11 09:43"), Freq.F1) == pd.to_datetime("2021-11-11 09:43")
assert freq_end_time(pd.to_datetime("2021-11-11 09:43"), Freq.F5) == pd.to_datetime("2021-11-11 09:45")
assert freq_end_time(pd.to_datetime("2021-11-11 09:43"), Freq.F15) == pd.to_datetime("2021-11-11 09:45")
assert freq_end_time(pd.to_datetime("2021-11-11 09:45"), Freq.F15) == pd.to_datetime("2021-11-11 09:45")
assert freq_end_time(pd.to_datetime("2021-11-11 14:56"), Freq.F15) == pd.to_datetime("2021-11-11 15:00")
assert freq_end_time(pd.to_datetime("2021-11-11 09:43"), Freq.F30) == pd.to_datetime("2021-11-11 10:00")
assert freq_end_time( | pd.to_datetime("2021-11-11 09:43") | pandas.to_datetime |
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
import numpy as np
import random
import pandas as pd
from sklearn.metrics import confusion_matrix, f1_score, roc_curve, auc, accuracy_score
import joblib
from collections import Counter
from sklearn.model_selection import GridSearchCV
from sklearn.cluster import KMeans
import sys
import timeit
import matplotlib.pyplot as plt
def get_trainset(simhome, rna):
simfile = "%s/%s_result.txt" %(simhome, rna.upper())
with open(simfile, "r") as ifile:
for line in ifile:
if line.startswith("train"):
trainset = eval(next(ifile, '').strip())
trainset = [t.lower() for t in trainset]
return trainset
def get_full_trainset(home):
pdblist = "%s/data/pdblist.txt" %home
return | pd.read_csv(pdblist, delim_whitespace=True) | pandas.read_csv |
"""
Import as:
import core.test.test_statistics as cttsta
"""
import logging
from typing import List
import numpy as np
import pandas as pd
import pytest
import core.artificial_signal_generators as casgen
import core.finance as cfinan
import core.signal_processing as csproc
import core.statistics as cstati
import helpers.printing as hprint
import helpers.unit_test as hut
_LOG = logging.getLogger(__name__)
class TestComputeMoments(hut.TestCase):
def test1(self) -> None:
series = self._get_series(seed=1)
actual = cstati.compute_moments(series)
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
def test2(self) -> None:
series = self._get_series(seed=1)
actual = cstati.compute_moments(series, prefix="moments_")
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
# Smoke test for empty input.
def test3(self) -> None:
series = pd.Series([])
cstati.compute_moments(series)
def test4(self) -> None:
series = self._get_series(seed=1)
# Place some `NaN` values in the series.
series[:5] = np.nan
series[8:10] = np.nan
actual = cstati.compute_moments(series)
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
def test5(self) -> None:
series = self._get_series(seed=1)
# Place some `NaN` values in the series.
series[:5] = np.nan
series[8:10] = np.nan
actual = cstati.compute_moments(series, nan_mode="ffill_and_drop_leading")
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
# Smoke test for input of `np.nan`s.
def test6(self) -> None:
series = pd.Series([np.nan for i in range(10)])
cstati.compute_moments(series)
def test7(self) -> None:
"""
Test series with `inf`.
"""
series = self._get_series(seed=1)
# Place some `NaN` values in the series.
series[4] = np.inf
actual = cstati.compute_moments(series, nan_mode="ffill_and_drop_leading")
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
@staticmethod
def _get_series(seed: int) -> pd.Series:
arparams = np.array([0.75, -0.25])
maparams = np.array([0.65, 0.35])
arma_process = casgen.ArmaProcess(arparams, maparams)
date_range = {"start": "1/1/2010", "periods": 40, "freq": "M"}
series = arma_process.generate_sample(
date_range_kwargs=date_range, seed=seed
)
return series
class TestComputeFracZero(hut.TestCase):
def test1(self) -> None:
data = [0.466667, 0.2, 0.13333, 0.2, 0.33333]
index = [0, 1, 2, 3, 4]
expected = pd.Series(data=data, index=index)
actual = cstati.compute_frac_zero(self._get_df(seed=1))
pd.testing.assert_series_equal(actual, expected, check_less_precise=3)
def test2(self) -> None:
data = [
0.4,
0.0,
0.2,
0.4,
0.4,
0.2,
0.4,
0.0,
0.6,
0.4,
0.6,
0.2,
0.0,
0.0,
0.2,
]
index = pd.date_range(start="1-04-2018", periods=15, freq="30T")
expected = pd.Series(data=data, index=index)
actual = cstati.compute_frac_zero(self._get_df(seed=1), axis=1)
pd.testing.assert_series_equal(actual, expected, check_less_precise=3)
def test3(self) -> None:
# Equals 20 / 75 = num_zeros / num_points.
expected = 0.266666
actual = cstati.compute_frac_zero(self._get_df(seed=1), axis=None)
np.testing.assert_almost_equal(actual, expected, decimal=3)
def test4(self) -> None:
series = self._get_df(seed=1)[0]
expected = 0.466667
actual = cstati.compute_frac_zero(series)
np.testing.assert_almost_equal(actual, expected, decimal=3)
def test5(self) -> None:
series = self._get_df(seed=1)[0]
expected = 0.466667
actual = cstati.compute_frac_zero(series, axis=0)
np.testing.assert_almost_equal(actual, expected, decimal=3)
# Smoke test for empty input.
def test6(self) -> None:
series = pd.Series([])
cstati.compute_frac_zero(series)
@staticmethod
def _get_df(seed: int) -> pd.DataFrame:
nrows = 15
ncols = 5
num_nans = 15
num_infs = 5
num_zeros = 20
#
np.random.seed(seed=seed)
mat = np.random.randn(nrows, ncols)
mat.ravel()[np.random.choice(mat.size, num_nans, replace=False)] = np.nan
mat.ravel()[np.random.choice(mat.size, num_infs, replace=False)] = np.inf
mat.ravel()[np.random.choice(mat.size, num_infs, replace=False)] = -np.inf
mat.ravel()[np.random.choice(mat.size, num_zeros, replace=False)] = 0
#
index = pd.date_range(start="01-04-2018", periods=nrows, freq="30T")
df = pd.DataFrame(data=mat, index=index)
return df
class TestComputeFracNan(hut.TestCase):
def test1(self) -> None:
data = [0.4, 0.133333, 0.133333, 0.133333, 0.2]
index = [0, 1, 2, 3, 4]
expected = pd.Series(data=data, index=index)
actual = cstati.compute_frac_nan(self._get_df(seed=1))
pd.testing.assert_series_equal(actual, expected, check_less_precise=3)
def test2(self) -> None:
data = [
0.4,
0.0,
0.2,
0.4,
0.2,
0.2,
0.2,
0.0,
0.4,
0.2,
0.6,
0.0,
0.0,
0.0,
0.2,
]
index = pd.date_range(start="1-04-2018", periods=15, freq="30T")
expected = pd.Series(data=data, index=index)
actual = cstati.compute_frac_nan(self._get_df(seed=1), axis=1)
pd.testing.assert_series_equal(actual, expected, check_less_precise=3)
def test3(self) -> None:
# Equals 15 / 75 = num_nans / num_points.
expected = 0.2
actual = cstati.compute_frac_nan(self._get_df(seed=1), axis=None)
np.testing.assert_almost_equal(actual, expected, decimal=3)
def test4(self) -> None:
series = self._get_df(seed=1)[0]
expected = 0.4
actual = cstati.compute_frac_nan(series)
np.testing.assert_almost_equal(actual, expected, decimal=3)
def test5(self) -> None:
series = self._get_df(seed=1)[0]
expected = 0.4
actual = cstati.compute_frac_nan(series, axis=0)
np.testing.assert_almost_equal(actual, expected, decimal=3)
# Smoke test for empty input.
def test6(self) -> None:
series = pd.Series([])
cstati.compute_frac_nan(series)
@staticmethod
def _get_df(seed: int) -> pd.DataFrame:
nrows = 15
ncols = 5
num_nans = 15
num_infs = 5
num_zeros = 20
#
np.random.seed(seed=seed)
mat = np.random.randn(nrows, ncols)
mat.ravel()[np.random.choice(mat.size, num_infs, replace=False)] = np.inf
mat.ravel()[np.random.choice(mat.size, num_infs, replace=False)] = -np.inf
mat.ravel()[np.random.choice(mat.size, num_zeros, replace=False)] = 0
mat.ravel()[np.random.choice(mat.size, num_nans, replace=False)] = np.nan
#
index = pd.date_range(start="01-04-2018", periods=nrows, freq="30T")
df = pd.DataFrame(data=mat, index=index)
return df
class TestComputeNumFiniteSamples(hut.TestCase):
@staticmethod
# Smoke test for empty input.
def test1() -> None:
series = pd.Series([])
cstati.count_num_finite_samples(series)
class TestComputeNumUniqueValues(hut.TestCase):
@staticmethod
# Smoke test for empty input.
def test1() -> None:
series = pd.Series([])
cstati.count_num_unique_values(series)
class TestComputeDenominatorAndPackage(hut.TestCase):
@staticmethod
# Smoke test for empty input.
def test1() -> None:
series = pd.Series([])
cstati._compute_denominator_and_package(reduction=1, data=series)
class TestTTest1samp(hut.TestCase):
# Smoke test for empty input.
def test1(self) -> None:
series = pd.Series([])
cstati.ttest_1samp(series)
def test2(self) -> None:
series = self._get_series(seed=1)
# Place some `NaN` values in the series.
series[:5] = np.nan
series[8:10] = np.nan
actual = cstati.ttest_1samp(series)
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
def test3(self) -> None:
series = self._get_series(seed=1)
# Place some `NaN` values in the series.
series[:5] = np.nan
series[8:10] = np.nan
actual = cstati.ttest_1samp(series, nan_mode="ffill_and_drop_leading")
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
# Smoke test for input of `np.nan`s.
def test4(self) -> None:
series = pd.Series([np.nan for i in range(10)])
cstati.ttest_1samp(series)
@staticmethod
def _get_series(seed: int) -> pd.Series:
arparams = np.array([0.75, -0.25])
maparams = np.array([0.65, 0.35])
arma_process = casgen.ArmaProcess(arparams, maparams)
date_range = {"start": "1/1/2010", "periods": 40, "freq": "M"}
series = arma_process.generate_sample(
date_range_kwargs=date_range, seed=seed
)
return series
class TestMultipleTests(hut.TestCase):
# Smoke test for empty input.
def test1(self) -> None:
series = pd.Series([])
cstati.multipletests(series)
# Test if error is raised with default arguments when input contains NaNs.
@pytest.mark.xfail()
def test2(self) -> None:
series_with_nans = self._get_series(seed=1)
series_with_nans[0:5] = np.nan
actual = cstati.multipletests(series_with_nans)
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
def test3(self) -> None:
series_with_nans = self._get_series(seed=1)
series_with_nans[0:5] = np.nan
actual = cstati.multipletests(series_with_nans, nan_mode="drop")
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
@staticmethod
def _get_series(seed: int) -> pd.Series:
date_range = {"start": "1/1/2010", "periods": 40, "freq": "M"}
series = hut.get_random_df(
num_cols=1,
seed=seed,
**date_range,
)[0]
return series
class TestMultiTTest(hut.TestCase):
# Smoke test for empty input.
def test1(self) -> None:
df = pd.DataFrame(columns=["series_name"])
cstati.multi_ttest(df)
def test2(self) -> None:
df = self._get_df_of_series(seed=1)
actual = cstati.multi_ttest(df)
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
def test3(self) -> None:
df = self._get_df_of_series(seed=1)
actual = cstati.multi_ttest(df, prefix="multi_ttest_")
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
def test4(self) -> None:
df = self._get_df_of_series(seed=1)
actual = cstati.multi_ttest(df, popmean=1)
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
def test5(self) -> None:
df = self._get_df_of_series(seed=1)
actual = cstati.multi_ttest(df, nan_mode="fill_with_zero")
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
def test6(self) -> None:
df = self._get_df_of_series(seed=1)
actual = cstati.multi_ttest(df, method="sidak")
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
@pytest.mark.xfail()
def test7(self) -> None:
df = self._get_df_of_series(seed=1)
df.iloc[:, 0] = np.nan
actual = cstati.multi_ttest(df)
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
@staticmethod
def _get_df_of_series(seed: int) -> pd.DataFrame:
n_series = 7
arparams = np.array([0.75, -0.25])
maparams = np.array([0.65, 0.35])
arma_process = casgen.ArmaProcess(arparams, maparams)
date_range = {"start": "1/1/2010", "periods": 40, "freq": "M"}
# Generating a dataframe from different series.
df = pd.DataFrame(
[
arma_process.generate_sample(
date_range_kwargs=date_range, seed=seed + i
)
for i in range(n_series)
],
index=["series_" + str(i) for i in range(n_series)],
).T
return df
class TestApplyNormalityTest(hut.TestCase):
def test1(self) -> None:
series = self._get_series(seed=1)
actual = cstati.apply_normality_test(series)
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
def test2(self) -> None:
series = self._get_series(seed=1)
actual = cstati.apply_normality_test(series, prefix="norm_test_")
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
# Smoke test for empty input.
def test3(self) -> None:
series = pd.Series([])
cstati.apply_normality_test(series)
def test4(self) -> None:
series = self._get_series(seed=1)
# Place some `NaN` values in the series.
series[:5] = np.nan
series[8:10] = np.nan
actual = cstati.apply_normality_test(series)
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
def test5(self) -> None:
series = self._get_series(seed=1)
# Place some `NaN` values in the series.
series[:5] = np.nan
series[8:10] = np.nan
actual = cstati.apply_normality_test(
series, nan_mode="ffill_and_drop_leading"
)
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
# Smoke test for input of `np.nan`s.
def test6(self) -> None:
series = pd.Series([np.nan for i in range(10)])
cstati.apply_normality_test(series)
@staticmethod
def _get_series(seed: int) -> pd.Series:
arparams = np.array([0.75, -0.25])
maparams = np.array([0.65, 0.35])
arma_process = casgen.ArmaProcess(arparams, maparams)
date_range = {"start": "1/1/2010", "periods": 40, "freq": "M"}
series = arma_process.generate_sample(
date_range_kwargs=date_range, seed=seed
)
return series
class TestApplyAdfTest(hut.TestCase):
def test1(self) -> None:
series = self._get_series(seed=1)
actual = cstati.apply_adf_test(series)
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
def test2(self) -> None:
series = self._get_series(seed=1)
actual = cstati.apply_adf_test(series, regression="ctt")
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
def test3(self) -> None:
series = self._get_series(seed=1)
actual = cstati.apply_adf_test(series, maxlag=5)
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
def test4(self) -> None:
series = self._get_series(seed=1)
actual = cstati.apply_adf_test(series, autolag="t-stat")
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
def test5(self) -> None:
series = self._get_series(seed=1)
actual = cstati.apply_adf_test(series, prefix="adf_")
actual_string = hut.convert_df_to_string(actual, index=True)
self.check_string(actual_string)
# Smoke test for empty input.
def test6(self) -> None:
series = | pd.Series([]) | pandas.Series |
import datetime
import os
import urllib
from http.client import IncompleteRead
from urllib.request import Request
import bs4 as bs
import pandas as pd
from django.conf import settings
from core.models import CourseModel, UpdateModel
# FILE PATHS
my_path = os.path.abspath(os.path.dirname(__file__))
stopwords_path = os.path.join(settings.BASE_DIR, "api/datasets/stopwords.txt")
# Date Cleaner
def date_cleaner(date):
"""Clean DataTime columns helper function"""
datetime_format = "%d/%m/%Y"
if len(date) < 8:
date = "01/" + date
else:
date = date
clean_date = datetime.datetime.strptime(date, datetime_format).strftime("%Y/%m/%d")
return clean_date
# WEBCRAWLER
def data_extractor():
"""Dataset Extraction"""
# Load WebPage
try:
req = urllib.request.Request(
"http://springboardcourses.ie/results?keywords=&perPage=500",
data=None,
headers={
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.47 Safari/537.36"
})
except IncompleteRead:
req = urllib.request.Request(
"http://springboardcourses.ie/results?keywords=&perPage=500",
data=None,
headers={
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.47 Safari/537.36"
})
f = urllib.request.urlopen(req)
soup = bs.BeautifulSoup(f, "lxml")
for course_div in soup.find_all("div", class_="panel panel-primary"):
try:
# Course Title
title_div = course_div.find("div", class_="panel-heading").h3.text
title_div = title_div.strip()
title_div = title_div.replace(" ", "")
except Exception as e:
title_div = None
try:
# First Content Row
first_row = course_div.find("div", class_="panel-body")
# Provider:
provider = first_row.find("div", class_="col-md-12").p
provider = str(provider).split("</strong>")[1]
provider = provider.split("<")[0]
# Award:
award = first_row.find("div", class_="col-md-5").p
award = str(award).split("</strong>")[1]
award = award.split("<")[0]
# Delivery Method:
delivery = first_row.find("div", class_="col-md-4").p
delivery = str(delivery).split("</strong>")[1]
delivery = delivery.split("<")[0]
# ECTS credits:
ects_credits = first_row.find("div", class_="col-md-3")
ects_credits = str(ects_credits).split("</strong> ")[1]
ects_credits = ects_credits.split("<")[0]
# Second Content Row
second_row = first_row.find_all("div", "row")[2]
# Mode:
mode = second_row.find("div", class_="col-md-5")
mode = str(mode).split("</strong> ")[1]
mode = mode.split("<")[0]
# Application Deadline:
deadline = second_row.find("div", class_="col-md-4")
deadline = str(deadline).split("</strong>")[1]
deadline = deadline.split("<")[0]
deadline = date_cleaner(deadline)
# Start Date
start_date = second_row.find("div", class_="col-md-3")
start_date = str(start_date).split("</strong>")[1]
start_date = start_date.split("<")[0]
start_date = date_cleaner(start_date)
# End Date
end_date = second_row.find("div", class_="col-md-3")
end_date = str(end_date).split("</strong>")[2]
end_date = end_date.replace(" ", "")
end_date = end_date.split("<")[0]
end_date = date_cleaner(end_date)
# Bottom Content Row
third_row = first_row.find("div", "row margin-bottom-0")
# NFQ
nfq = third_row.find("div", class_="col-md-5").p
nfq = str(nfq).split("</strong>")[1]
nfq = nfq.split("<")[0]
nfq = nfq.replace("Level ", "")
# Open to those in employment
ote_flag = third_row.find("div", class_="col-md-4").p
ote_flag = str(ote_flag).split("</strong>")[1]
ote_flag = ote_flag.split("<")[0]
# Skills area
skill_list = third_row.find("div", class_="col-md-3")
skill_list = str(skill_list).split("</strong>")[1]
skill_list = skill_list.split("<")[0]
skill_list = skill_list.lower()
# Course Link
link = course_div.find("a")
link = link.get("href")
CourseModel.objects.get_or_create(
title=title_div,
provider=provider,
award=award,
ects_credits=ects_credits,
mode=mode,
deadline=deadline,
start_date=start_date,
end_date=end_date,
nfq=nfq,
ote_flag=ote_flag,
link=link,
skills=skill_list,
delivery=delivery
)
except Exception as e:
pass
UpdateModel.objects.create()
print("update done")
def statistical_data():
dataset = pd.DataFrame(list(CourseModel.objects.all().values()))
if len(dataset.index) > 0:
# top providers
occurence = dataset["provider"].value_counts()[:6]
top_providers_dict = occurence.to_dict()
# Delivery mode
dataset["less_than_50"] = dataset["ects_credits"].apply(
lambda x: "below 50 C" if int(x) < 50 else "over 50 C")
less_than_50_values = dataset["less_than_50"].value_counts()
lt50_dict = less_than_50_values.to_dict()
# partime/ fulltime
mode_values = dataset["mode"].value_counts()
mode_dict = mode_values.to_dict()
# NFQ
nfq_values = dataset["nfq"].value_counts()
nfq_dict = nfq_values.to_dict()
# Top popular categories
category_values = dataset["skills"].value_counts()[:6]
category_dict = category_values.to_dict()
stats_dict = {"top_providers_dict": top_providers_dict,
"lt50_dict": lt50_dict,
"nfq_dict": nfq_dict,
"mode_dict": mode_dict,
"category_dict": category_dict
}
else:
stats_dict = {}
return stats_dict
def fastest_diploma(queryset):
dataset = pd.DataFrame(list(queryset.values()))
if len(dataset.index) > 0:
diplomas = ["Diploma", "diploma"]
dataset["diploma"] = dataset["title"].apply(lambda x: 1 if any(w in x for w in diplomas) else 0)
dataset_diplomas = dataset[(dataset["diploma"] == 1)]
# top 12 shortest diplomas
if len(dataset_diplomas.index) > 0:
dataset_diplomas["start_date"] = | pd.to_datetime(dataset_diplomas["start_date"]) | pandas.to_datetime |
"""
Functions for categoricals
"""
from itertools import chain, product
import numpy as np
import pandas as pd
import pandas.api.types as pdtypes
from pandas.core.algorithms import value_counts
from .utils import last2
__all__ = [
'cat_anon',
'cat_collapse',
'cat_concat',
'cat_drop',
'cat_expand',
'cat_explicit_na',
'cat_infreq',
'cat_inorder',
'cat_inseq',
'cat_lump',
'cat_lump_lowfreq',
'cat_lump_min',
'cat_lump_n',
'cat_lump_prop',
'cat_move',
'cat_other',
'cat_recode',
'cat_relabel',
'cat_relevel',
'cat_rename',
'cat_reorder',
'cat_reorder2',
'cat_rev',
'cat_shift',
'cat_shuffle',
'cat_unify',
'cat_zip',
]
def cat_infreq(c, ordered=None):
"""
Reorder categorical by frequency of the values
Parameters
----------
c : list-like
Values that will make up the categorical.
ordered : bool
If ``True``, the categorical is ordered.
Returns
-------
out : categorical
Values
Examples
--------
>>> x = ['d', 'a', 'b', 'b', 'c', 'c', 'c']
>>> cat_infreq(x)
['d', 'a', 'b', 'b', 'c', 'c', 'c']
Categories (4, object): ['c', 'b', 'd', 'a']
>>> cat_infreq(x, ordered=True)
['d', 'a', 'b', 'b', 'c', 'c', 'c']
Categories (4, object): ['c' < 'b' < 'd' < 'a']
When two or more values occur the same number of times, if the
categorical is ordered, the order is preserved. If it is not
not ordered, the order depends on that of the values. Above 'd'
comes before 'a', and below 'a' comes before 'a'.
>>> c = pd.Categorical(
... x, categories=['a', 'c', 'b', 'd']
... )
>>> cat_infreq(c)
['d', 'a', 'b', 'b', 'c', 'c', 'c']
Categories (4, object): ['c', 'b', 'a', 'd']
>>> cat_infreq(c.set_ordered(True))
['d', 'a', 'b', 'b', 'c', 'c', 'c']
Categories (4, object): ['c' < 'b' < 'a' < 'd']
"""
kwargs = {} if ordered is None else {'ordered': ordered}
counts = value_counts(c)
if pdtypes.is_categorical_dtype(c):
original_cat_order = c.categories
else:
original_cat_order = pd.unique(c)
counts = counts.reindex(index=original_cat_order)
cats = (_stable_series_sort(counts, ascending=False)
.index
.to_list())
return pd.Categorical(c, categories=cats, **kwargs)
def cat_inorder(c, ordered=None):
"""
Reorder categorical by appearance
Parameters
----------
c : list-like
Values that will make up the categorical.
ordered : bool
If ``True``, the categorical is ordered.
Returns
-------
out : categorical
Values
Examples
--------
>>> import numpy as np
>>> x = [4, 1, 3, 4, 4, 7, 3]
>>> cat_inorder(x)
[4, 1, 3, 4, 4, 7, 3]
Categories (4, int64): [4, 1, 3, 7]
>>> arr = np.array(x)
>>> cat_inorder(arr)
[4, 1, 3, 4, 4, 7, 3]
Categories (4, int64): [4, 1, 3, 7]
>>> c = ['b', 'f', 'c', None, 'c', 'a', 'b', 'e']
>>> cat_inorder(c)
['b', 'f', 'c', NaN, 'c', 'a', 'b', 'e']
Categories (5, object): ['b', 'f', 'c', 'a', 'e']
>>> s = pd.Series(c)
>>> cat_inorder(s)
['b', 'f', 'c', NaN, 'c', 'a', 'b', 'e']
Categories (5, object): ['b', 'f', 'c', 'a', 'e']
>>> cat = pd.Categorical(c)
>>> cat_inorder(cat)
['b', 'f', 'c', NaN, 'c', 'a', 'b', 'e']
Categories (5, object): ['b', 'f', 'c', 'a', 'e']
>>> cat_inorder(cat, ordered=True)
['b', 'f', 'c', NaN, 'c', 'a', 'b', 'e']
Categories (5, object): ['b' < 'f' < 'c' < 'a' < 'e']
By default, ordered categories remain ordered.
>>> ocat = pd.Categorical(cat, ordered=True)
>>> ocat
['b', 'f', 'c', NaN, 'c', 'a', 'b', 'e']
Categories (5, object): ['a' < 'b' < 'c' < 'e' < 'f']
>>> cat_inorder(ocat)
['b', 'f', 'c', NaN, 'c', 'a', 'b', 'e']
Categories (5, object): ['b' < 'f' < 'c' < 'a' < 'e']
>>> cat_inorder(ocat, ordered=False)
['b', 'f', 'c', NaN, 'c', 'a', 'b', 'e']
Categories (5, object): ['b', 'f', 'c', 'a', 'e']
Notes
-----
``NaN`` or ``None`` are ignored when creating the categories.
"""
kwargs = {} if ordered is None else {'ordered': ordered}
if isinstance(c, (pd.Series, pd.Categorical)):
cats = c[~pd.isnull(c)].unique()
if hasattr(cats, 'to_list'):
cats = cats.to_list()
elif hasattr(c, 'dtype'):
cats = pd.unique(c[~pd.isnull(c)])
else:
cats = pd.unique([
x for x, keep in zip(c, ~pd.isnull(c))
if keep
])
return pd.Categorical(c, categories=cats, **kwargs)
def cat_inseq(c, ordered=None):
"""
Reorder categorical by numerical order
Parameters
----------
c : list-like
Values that will make up the categorical.
ordered : bool
If ``True``, the categorical is ordered.
Returns
-------
out : categorical
Values
Examples
--------
>>> x = pd.Categorical([5, 1, 3, 2, 4])
>>> cat_inseq(x)
[5, 1, 3, 2, 4]
Categories (5, int64): [1, 2, 3, 4, 5]
>>> x = pd.Categorical([5, 1, '3', 2, 4])
>>> cat_inseq(x)
[5, 1, 3, 2, 4]
Categories (5, int64): [1, 2, 3, 4, 5]
Values that cannot be coerced to numerical turn in ``NaN``,
and categories cannot be ``NaN``.
>>> x = pd.Categorical([5, 1, 'three', 2, 4])
>>> cat_inseq(x)
[5, 1, NaN, 2, 4]
Categories (4, int64): [1, 2, 4, 5]
Coerces values to numerical
>>> x = [5, 1, '3', 2, 4]
>>> cat_inseq(x, ordered=True)
[5, 1, 3, 2, 4]
Categories (5, int64): [1 < 2 < 3 < 4 < 5]
>>> x = [5, 1, '3', 2, '4.5']
>>> cat_inseq(x)
[5.0, 1.0, 3.0, 2.0, 4.5]
Categories (5, float64): [1.0, 2.0, 3.0, 4.5, 5.0]
Atleast one of the values must be coercible to the integer
>>> x = ['five', 'one', 'three', 'two', 'four']
>>> cat_inseq(x)
Traceback (most recent call last):
...
ValueError: Atleast one existing category must be a number.
>>> x = ['five', 'one', '3', 'two', 'four']
>>> cat_inseq(x)
[NaN, NaN, 3, NaN, NaN]
Categories (1, int64): [3]
"""
c = as_categorical(c)
# one value at a time to avoid turning integers into floats
# when some values create nans
numerical_cats = []
for x in c.categories:
_x = pd.to_numeric(x, 'coerce')
if not pd.isnull(_x):
numerical_cats.append(_x)
if len(numerical_cats) == 0 and len(c) > 0:
raise ValueError(
"Atleast one existing category must be a number."
)
# Change the original categories to numerical ones, making sure
# to rename the existing ones i.e '3' becomes 3. Only after that,
# change to order.
c = (c.set_categories(numerical_cats, rename=True)
.reorder_categories(sorted(numerical_cats)))
if ordered is not None:
c.set_ordered(ordered, inplace=True)
return c
def cat_reorder(c, x, fun=np.median, ascending=True):
"""
Reorder categorical by sorting along another variable
It is the order of the categories that changes. Values in x
are grouped by categories and summarised to determine the
new order.
Parameters
----------
c : list-like
Values that will make up the categorical.
x : list-like
Values by which ``c`` will be ordered.
fun : callable
Summarising function to ``x`` for each category in ``c``.
Default is the *median*.
ascending : bool
If ``True``, the ``c`` is ordered in ascending order of ``x``.
Examples
--------
>>> c = list('abbccc')
>>> x = [11, 2, 2, 3, 33, 3]
>>> cat_reorder(c, x)
['a', 'b', 'b', 'c', 'c', 'c']
Categories (3, object): ['b', 'c', 'a']
>>> cat_reorder(c, x, fun=max)
['a', 'b', 'b', 'c', 'c', 'c']
Categories (3, object): ['b', 'a', 'c']
>>> cat_reorder(c, x, fun=max, ascending=False)
['a', 'b', 'b', 'c', 'c', 'c']
Categories (3, object): ['c', 'a', 'b']
>>> c_ordered = pd.Categorical(c, ordered=True)
>>> cat_reorder(c_ordered, x)
['a', 'b', 'b', 'c', 'c', 'c']
Categories (3, object): ['b' < 'c' < 'a']
>>> cat_reorder(c + ['d'], x)
Traceback (most recent call last):
...
ValueError: Lengths are not equal. len(c) is 7 and len(x) is 6.
"""
if len(c) != len(x):
raise ValueError(
"Lengths are not equal. len(c) is {} and len(x) is {}.".format(
len(c), len(x)
)
)
summary = (pd.Series(x)
.groupby(c)
.apply(fun)
.sort_values(ascending=ascending)
)
cats = summary.index.to_list()
return pd.Categorical(c, categories=cats)
def cat_reorder2(c, x, y, *args, fun=last2, ascending=False, **kwargs):
"""
Reorder categorical by sorting along another variable
It is the order of the categories that changes. Values in x
are grouped by categories and summarised to determine the
new order.
Parameters
----------
c : list-like
Values that will make up the categorical.
x : list-like
Values by which ``c`` will be ordered.
y : list-like
Values by which ``c`` will be ordered.
*args : tuple
Position arguments passed to function fun.
fun : callable
Summarising function to ``x`` for each category in ``c``.
Default is the *median*.
ascending : bool
If ``True``, the ``c`` is ordered in ascending order of ``x``.
**kwargs : dict
Keyword arguments passed to ``fun``.
Examples
--------
Order stocks by the price in the latest year. This type of ordering
can be used to order line plots so that the ends match the order of
the legend.
>>> stocks = list('AAABBBCCC')
>>> year = [1980, 1990, 2000] * 3
>>> price = [12.34, 12.90, 13.55, 10.92, 14.73, 11.08, 9.02, 12.44, 15.65]
>>> cat_reorder2(stocks, year, price)
['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C']
Categories (3, object): ['C', 'A', 'B']
"""
if len(c) != len(x) or len(x) != len(y):
raise ValueError(
"Lengths are not equal. len(c) is {}, len(x) is {} and "
"len(y) is {}.".format(len(c), len(x), len(y))
)
# Wrap two argument function fun with a function that
# takes a dataframe, put x and y into a dataframe, then
# use dataframe.groupby
def _fun(cat_df):
return fun(cat_df['x'], cat_df['y'], *args, **kwargs)
summary = (pd.DataFrame({'x': x, 'y': y})
.groupby(c)
.apply(_fun)
.sort_values(ascending=ascending)
)
cats = summary.index.to_list()
return pd.Categorical(c, categories=cats)
def cat_move(c, *args, to=0):
"""
Reorder categories explicitly
Parameters
----------
c : list-like
Values that will make up the categorical.
*args : tuple
Categories to reorder. Any categories not mentioned
will be left in existing order.
to : int or inf
Position where to place the categories. ``inf``, puts
them at the end (highest value).
Returns
-------
out : categorical
Values
Examples
--------
>>> c = ['a', 'b', 'c', 'd', 'e']
>>> cat_move(c, 'e', 'b')
['a', 'b', 'c', 'd', 'e']
Categories (5, object): ['e', 'b', 'a', 'c', 'd']
>>> cat_move(c, 'c', to=np.inf)
['a', 'b', 'c', 'd', 'e']
Categories (5, object): ['a', 'b', 'd', 'e', 'c']
>>> cat_move(pd.Categorical(c, ordered=True), 'a', 'c', 'e', to=1)
['a', 'b', 'c', 'd', 'e']
Categories (5, object): ['b' < 'a' < 'c' < 'e' < 'd']
"""
c = as_categorical(c)
if np.isinf(to):
to = len(c.categories)
args = list(args)
unmoved_cats = c.categories.drop(args).to_list()
cats = unmoved_cats[0:to] + args + unmoved_cats[to:]
c.reorder_categories(cats, inplace=True)
return c
def cat_rev(c):
"""
Reverse order of categories
Parameters
----------
c : list-like
Values that will make up the categorical.
Returns
-------
out : categorical
Values
Examples
--------
>>> c = ['a', 'b', 'c']
>>> cat_rev(c)
['a', 'b', 'c']
Categories (3, object): ['c', 'b', 'a']
>>> cat_rev(pd.Categorical(c))
['a', 'b', 'c']
Categories (3, object): ['c', 'b', 'a']
"""
c = as_categorical(c)
c.reorder_categories(c.categories[::-1], inplace=True)
return c
def cat_shift(c, n=1):
"""
Shift and wrap-around categories to the left or right
Parameters
----------
c : list-like
Values that will make up the categorical.
n : int
Number of times to shift. If positive, shift to
the left, if negative shift to the right.
Default is 1.
Returns
-------
out : categorical
Values
Examples
--------
>>> c = ['a', 'b', 'c', 'd', 'e']
>>> cat_shift(c)
['a', 'b', 'c', 'd', 'e']
Categories (5, object): ['b', 'c', 'd', 'e', 'a']
>>> cat_shift(c, 2)
['a', 'b', 'c', 'd', 'e']
Categories (5, object): ['c', 'd', 'e', 'a', 'b']
>>> cat_shift(c, -2)
['a', 'b', 'c', 'd', 'e']
Categories (5, object): ['d', 'e', 'a', 'b', 'c']
>>> cat_shift(pd.Categorical(c, ordered=True), -3)
['a', 'b', 'c', 'd', 'e']
Categories (5, object): ['c' < 'd' < 'e' < 'a' < 'b']
"""
c = as_categorical(c)
cats = c.categories.to_list()
cats_extended = cats + cats
m = len(cats)
n = n % m
cats = cats_extended[n:m] + cats_extended[:n]
c.reorder_categories(cats, inplace=True)
return c
def cat_shuffle(c, random_state=None):
"""
Reverse order of categories
Parameters
----------
c : list-like
Values that will make up the categorical.
random_state : int or ~numpy.random.RandomState, optional
Seed or Random number generator to use. If ``None``, then
numpy global generator :class:`numpy.random` is used.
Returns
-------
out : categorical
Values
Examples
--------
>>> np.random.seed(123)
>>> c = ['a', 'b', 'c', 'd', 'e']
>>> cat_shuffle(c)
['a', 'b', 'c', 'd', 'e']
Categories (5, object): ['b', 'd', 'e', 'a', 'c']
>>> cat_shuffle(pd.Categorical(c, ordered=True), 321)
['a', 'b', 'c', 'd', 'e']
Categories (5, object): ['d' < 'b' < 'a' < 'c' < 'e']
"""
c = as_categorical(c)
if random_state is None:
random_state = np.random
elif isinstance(random_state, int):
random_state = np.random.RandomState(random_state)
elif not isinstance(random_state, np.random.RandomState):
raise TypeError(
"Unknown type `{}` of random_state".format(type(random_state))
)
cats = c.categories.to_list()
random_state.shuffle(cats)
c.reorder_categories(cats, inplace=True)
return c
# Change the value of categories
def cat_anon(c, prefix='', random_state=None):
"""
Anonymise categories
Neither the value nor the order of the categories is preserved.
Parameters
----------
c : list-like
Values that will make up the categorical.
random_state : int or ~numpy.random.RandomState, optional
Seed or Random number generator to use. If ``None``, then
numpy global generator :class:`numpy.random` is used.
Returns
-------
out : categorical
Values
Examples
--------
>>> np.random.seed(123)
>>> c = ['a', 'b', 'b', 'c', 'c', 'c']
>>> cat_anon(c)
['0', '1', '1', '2', '2', '2']
Categories (3, object): ['1', '0', '2']
>>> cat_anon(c, 'c-', 321)
['c-1', 'c-2', 'c-2', 'c-0', 'c-0', 'c-0']
Categories (3, object): ['c-0', 'c-2', 'c-1']
>>> cat_anon(pd.Categorical(c, ordered=True), 'c-', 321)
['c-1', 'c-2', 'c-2', 'c-0', 'c-0', 'c-0']
Categories (3, object): ['c-0' < 'c-2' < 'c-1']
"""
c = as_categorical(c)
if random_state is None:
random_state = np.random
elif isinstance(random_state, int):
random_state = np.random.RandomState(random_state)
elif not isinstance(random_state, np.random.RandomState):
raise TypeError(
"Unknown type `{}` of random_state".format(type(random_state))
)
# Shuffle two times,
# 1. to prevent predicable sequence to category mapping
# 2. to prevent reversing of the new categories to the old ones
fmt = '{}{}'.format
cats = [fmt(prefix, i) for i in range(len(c.categories))]
random_state.shuffle(cats)
c.rename_categories(cats, inplace=True)
cats = c.categories.to_list()
random_state.shuffle(cats)
c.reorder_categories(cats, inplace=True)
return c
def cat_collapse(c, mapping, group_other=False):
"""
Collapse categories into manually defined groups
Parameters
----------
c : list-like
Values that will make up the categorical.
mapping : dict
New categories and the old categories contained in them.
group_other : False
If ``True``, a category is created to contain all other
categories that have not been explicitly collapsed.
The name of the other categories is ``other``, it may be
postfixed by the first available integer starting from
2 if there is a category with a similar name.
Returns
-------
out : categorical
Values
Examples
--------
>>> c = ['a', 'b', 'c', 'd', 'e', 'f']
>>> mapping = {'first_2': ['a', 'b'], 'second_2': ['c', 'd']}
>>> cat_collapse(c, mapping)
['first_2', 'first_2', 'second_2', 'second_2', 'e', 'f']
Categories (4, object): ['first_2', 'second_2', 'e', 'f']
>>> cat_collapse(c, mapping, group_other=True)
['first_2', 'first_2', 'second_2', 'second_2', 'other', 'other']
Categories (3, object): ['first_2', 'second_2', 'other']
Collapsing preserves the order
>>> cat_rev(c)
['a', 'b', 'c', 'd', 'e', 'f']
Categories (6, object): ['f', 'e', 'd', 'c', 'b', 'a']
>>> cat_collapse(cat_rev(c), mapping)
['first_2', 'first_2', 'second_2', 'second_2', 'e', 'f']
Categories (4, object): ['f', 'e', 'second_2', 'first_2']
>>> mapping = {'other': ['a', 'b'], 'another': ['c', 'd']}
>>> cat_collapse(c, mapping, group_other=True)
['other', 'other', 'another', 'another', 'other2', 'other2']
Categories (3, object): ['other', 'another', 'other2']
"""
def make_other_name():
"""
Generate unique name for the other category
"""
if 'other' not in mapping:
return 'other'
for i in range(2, len(mapping)+2):
other = 'other' + str(i)
if other not in mapping:
return other
c = as_categorical(c)
if group_other:
mapping = mapping.copy()
other = make_other_name()
mapped_categories = list(chain(*mapping.values()))
unmapped_categories = c.categories.difference(mapped_categories)
mapping[other] = list(unmapped_categories)
inverted_mapping = {
cat: new_cat
for new_cat, old_cats in mapping.items()
for cat in old_cats
}
# Convert old categories to new values in order and remove
# any duplicates. The preserves the order
new_cats = pd.unique([
inverted_mapping.get(x, x)
for x in c.categories
])
c = pd.Categorical(
[inverted_mapping.get(x, x) for x in c],
categories=new_cats,
ordered=c.ordered
)
return c
def cat_other(c, keep=None, drop=None, other_category='other'):
"""
Replace categories with 'other'
Parameters
----------
c : list-like
Values that will make up the categorical.
keep : list-like
Categories to preserve. Only one of ``keep`` or ``drop``
should be specified.
drop : list-like
Categories to drop. Only one of ``keep`` or ``drop``
should be specified.
other_category : object
Value used for the 'other' values. It is placed at
the end of the categories.
Returns
-------
out : categorical
Values
Examples
--------
>>> c = ['a', 'b', 'a', 'c', 'b', 'b', 'b', 'd', 'c']
>>> cat_other(c, keep=['a', 'b'])
['a', 'b', 'a', 'other', 'b', 'b', 'b', 'other', 'other']
Categories (3, object): ['a', 'b', 'other']
>>> cat_other(c, drop=['a', 'b'])
['other', 'other', 'other', 'c', 'other', 'other', 'other', 'd', 'c']
Categories (3, object): ['c', 'd', 'other']
>>> cat_other(pd.Categorical(c, ordered=True), drop=['a', 'b'])
['other', 'other', 'other', 'c', 'other', 'other', 'other', 'd', 'c']
Categories (3, object): ['c' < 'd' < 'other']
"""
if keep is None and drop is None:
raise ValueError(
"Missing columns to `keep` or those to `drop`."
)
elif keep is not None and drop is not None:
raise ValueError(
"Only one of `keep` or `drop` should be given."
)
c = as_categorical(c)
cats = c.categories
if keep is not None:
if not pdtypes.is_list_like(keep):
keep = [keep]
elif drop is not None:
if not pdtypes.is_list_like(drop):
drop = [drop]
keep = cats.difference(drop)
inverted_mapping = {
cat: other_category
for cat in cats.difference(keep)
}
inverted_mapping.update({x: x for x in keep})
new_cats = cats.intersection(keep).to_list() + [other_category]
c = pd.Categorical(
[inverted_mapping.get(x, x) for x in c],
categories=new_cats,
ordered=c.ordered
)
return c
def _lump(lump_it, c, other_category):
"""
Return a categorical of lumped
Helper for cat_lump_* functions
Parameters
----------
lump_it : sequence[(obj, bool)]
Sequence of (category, lump_category)
c : cateorical
Original categorical.
other_category : object (default: 'other')
Value used for the 'other' values. It is placed at
the end of the categories.
Returns
-------
out : categorical
Values
"""
lookup = {
cat: other_category if lump else cat
for cat, lump in lump_it
}
new_cats = (
c.categories
.intersection(lookup.values())
.insert(len(c), other_category)
)
c = pd.Categorical(
[lookup[value] for value in c],
categories=new_cats,
ordered=c.ordered
)
return c
def cat_lump(
c,
n=None,
prop=None,
w=None,
other_category='other',
ties_method='min'
):
"""
Lump together least or most common categories
This is a general method that calls one of
:func:`~plydata.cat_tools.cat_lump_n`
:func:`~plydata.cat_tools.cat_lump_prop` or
:func:`~plydata.cat_tools.cat_lump_lowfreq`
depending on the parameters.
Parameters
----------
c : list-like
Values that will make up the categorical.
n : int (optional)
Number of most/least common values to preserve (not lumped
together). Positive ``n`` preserves the most common,
negative ``n`` preserves the least common.
Lumping happens on condition that the lumped category "other"
will have the smallest number of items.
You should only specify one of ``n`` or ``prop``
prop : float (optional)
Proportion above/below which the values of a category will be
preserved (not lumped together). Positive ``prop`` preserves
categories whose proportion of values is *more* than ``prop``.
Negative ``prop`` preserves categories whose proportion of
values is *less* than ``prop``.
Lumping happens on condition that the lumped category "other"
will have the smallest number of items.
You should only specify one of ``n`` or ``prop``
w : list[int|float] (optional)
Weights for the frequency of each value. It should be the same
length as ``c``.
other_category : object (default: 'other')
Value used for the 'other' values. It is placed at
the end of the categories.
ties_method : {'min', 'max', 'average', 'first', 'dense'} (default: min)
How to treat categories that occur the same number of times
(i.e. ties):
* min: lowest rank in the group
* max: highest rank in the group
* average: average rank of the group
* first: ranks assigned in order they appear in the array
* dense: like 'min', but rank always increases by 1 between groups.
Examples
--------
>>> cat_lump(list('abbccc'))
['other', 'b', 'b', 'c', 'c', 'c']
Categories (3, object): ['b', 'c', 'other']
When the least categories put together are not less than the next
smallest group.
>>> cat_lump(list('abcddd'))
['a', 'b', 'c', 'd', 'd', 'd']
Categories (4, object): ['a', 'b', 'c', 'd']
>>> cat_lump(list('abcdddd'))
['other', 'other', 'other', 'd', 'd', 'd', 'd']
Categories (2, object): ['d', 'other']
>>> c = pd.Categorical(list('abccdd'))
>>> cat_lump(c, n=1)
['other', 'other', 'c', 'c', 'd', 'd']
Categories (3, object): ['c', 'd', 'other']
>>> cat_lump(c, n=2)
['other', 'other', 'c', 'c', 'd', 'd']
Categories (3, object): ['c', 'd', 'other']
``n`` Least common categories
>>> cat_lump(c, n=-2)
['a', 'b', 'other', 'other', 'other', 'other']
Categories (3, object): ['a', 'b', 'other']
There are fewer than ``n`` categories that are the most/least common.
>>> cat_lump(c, n=3)
['a', 'b', 'c', 'c', 'd', 'd']
Categories (4, object): ['a', 'b', 'c', 'd']
>>> cat_lump(c, n=-3)
['a', 'b', 'c', 'c', 'd', 'd']
Categories (4, object): ['a', 'b', 'c', 'd']
By proportions, categories that make up *more* than ``prop`` fraction
of the items.
>>> cat_lump(c, prop=1/3.01)
['other', 'other', 'c', 'c', 'd', 'd']
Categories (3, object): ['c', 'd', 'other']
>>> cat_lump(c, prop=-1/3.01)
['a', 'b', 'other', 'other', 'other', 'other']
Categories (3, object): ['a', 'b', 'other']
>>> cat_lump(c, prop=1/2)
['other', 'other', 'other', 'other', 'other', 'other']
Categories (1, object): ['other']
Order of categoricals is maintained
>>> c = pd.Categorical(
... list('abccdd'),
... categories=list('adcb'),
... ordered=True
... )
>>> cat_lump(c, n=2)
['other', 'other', 'c', 'c', 'd', 'd']
Categories (3, object): ['d' < 'c' < 'other']
**Weighted lumping**
>>> c = list('abcd')
>>> weights = [3, 2, 1, 1]
>>> cat_lump(c, n=2) # No lumping
['a', 'b', 'c', 'd']
Categories (4, object): ['a', 'b', 'c', 'd']
>>> cat_lump(c, n=2, w=weights)
['a', 'b', 'other', 'other']
Categories (3, object): ['a', 'b', 'other']
"""
if n is not None:
return cat_lump_n(c, n, w, other_category, ties_method)
elif prop is not None:
return cat_lump_prop(c, prop, w, other_category)
else:
return cat_lump_lowfreq(c, other_category)
def cat_lump_n(
c,
n,
w=None,
other_category='other',
ties_method='min'
):
"""
Lump together most/least common n categories
Parameters
----------
c : list-like
Values that will make up the categorical.
n : int
Number of most/least common values to preserve (not lumped
together). Positive ``n`` preserves the most common,
negative ``n`` preserves the least common.
Lumping happens on condition that the lumped category "other"
will have the smallest number of items.
You should only specify one of ``n`` or ``prop``
w : list[int|float] (optional)
Weights for the frequency of each value. It should be the same
length as ``c``.
other_category : object (default: 'other')
Value used for the 'other' values. It is placed at
the end of the categories.
ties_method : {'min', 'max', 'average', 'first', 'dense'} (default: min)
How to treat categories that occur the same number of times
(i.e. ties):
* min: lowest rank in the group
* max: highest rank in the group
* average: average rank of the group
* first: ranks assigned in order they appear in the array
* dense: like 'min', but rank always increases by 1 between groups.
Examples
--------
>>> c = pd.Categorical(list('abccdd'))
>>> cat_lump_n(c, 1)
['other', 'other', 'c', 'c', 'd', 'd']
Categories (3, object): ['c', 'd', 'other']
>>> cat_lump_n(c, 2)
['other', 'other', 'c', 'c', 'd', 'd']
Categories (3, object): ['c', 'd', 'other']
``n`` Least common categories
>>> cat_lump_n(c, -2)
['a', 'b', 'other', 'other', 'other', 'other']
Categories (3, object): ['a', 'b', 'other']
There are fewer than ``n`` categories that are the most/least common.
>>> cat_lump_n(c, 3)
['a', 'b', 'c', 'c', 'd', 'd']
Categories (4, object): ['a', 'b', 'c', 'd']
>>> cat_lump_n(c, -3)
['a', 'b', 'c', 'c', 'd', 'd']
Categories (4, object): ['a', 'b', 'c', 'd']
Order of categoricals is maintained
>>> c = pd.Categorical(
... list('abccdd'),
... categories=list('adcb'),
... ordered=True
... )
>>> cat_lump_n(c, 2)
['other', 'other', 'c', 'c', 'd', 'd']
Categories (3, object): ['d' < 'c' < 'other']
**Weighted lumping**
>>> c = list('abcd')
>>> weights = [3, 2, 1, 1]
>>> cat_lump_n(c, n=2) # No lumping
['a', 'b', 'c', 'd']
Categories (4, object): ['a', 'b', 'c', 'd']
>>> cat_lump_n(c, n=2, w=weights)
['a', 'b', 'other', 'other']
Categories (3, object): ['a', 'b', 'other']
"""
c = as_categorical(c)
if len(c) == 0:
return c
if w is None:
counts = c.value_counts().sort_values(ascending=False)
else:
counts = (
pd.Series(w)
.groupby(c)
.apply(np.sum)
.sort_values(ascending=False)
)
if n < 0:
rank = counts.rank(method=ties_method)
n = -n
else:
rank = (-counts).rank(method=ties_method)
# Less than n categories outside the lumping,
if not (rank > n).any():
return c
lump_it = zip(rank.index, rank > n)
return _lump(lump_it, c, other_category)
def cat_lump_prop(
c,
prop,
w=None,
other_category='other',
):
"""
Lump together least or most common categories by proportion
Parameters
----------
c : list-like
Values that will make up the categorical.
prop : float
Proportion above/below which the values of a category will be
preserved (not lumped together). Positive ``prop`` preserves
categories whose proportion of values is *more* than ``prop``.
Negative ``prop`` preserves categories whose proportion of
values is *less* than ``prop``.
Lumping happens on condition that the lumped category "other"
will have the smallest number of items.
You should only specify one of ``n`` or ``prop``
w : list[int|float] (optional)
Weights for the frequency of each value. It should be the same
length as ``c``.
other_category : object (default: 'other')
Value used for the 'other' values. It is placed at
the end of the categories.
Examples
--------
By proportions, categories that make up *more* than ``prop`` fraction
of the items.
>>> c = pd.Categorical(list('abccdd'))
>>> cat_lump_prop(c, 1/3.01)
['other', 'other', 'c', 'c', 'd', 'd']
Categories (3, object): ['c', 'd', 'other']
>>> cat_lump_prop(c, -1/3.01)
['a', 'b', 'other', 'other', 'other', 'other']
Categories (3, object): ['a', 'b', 'other']
>>> cat_lump_prop(c, 1/2)
['other', 'other', 'other', 'other', 'other', 'other']
Categories (1, object): ['other']
"""
c = as_categorical(c)
if len(c) == 0:
return c
if w is None:
counts = c.value_counts().sort_values(ascending=False)
total = len(c)
else:
counts = (
pd.Series(w)
.groupby(c)
.apply(np.sum)
.sort_values(ascending=False)
)
total = counts.sum()
# For each category findout whether to lump it or keep it
# Create a generator of the form ((cat, lump), ...)
props = counts / total
if prop < 0:
if not (props > -prop).any():
# No proportion more than target, so no lumping
# the most common
return c
else:
lump_it = zip(props.index, props > -prop)
else:
if not (props <= prop).any():
# No proportion less than target, so no lumping
# the least common
return c
else:
lump_it = zip(props.index, props <= prop)
return _lump(lump_it, c, other_category)
def cat_lump_lowfreq(
c,
other_category='other',
):
"""
Lump together least categories
Ensures that the "other" category is still the smallest.
Parameters
----------
c : list-like
Values that will make up the categorical.
other_category : object (default: 'other')
Value used for the 'other' values. It is placed at
the end of the categories.
Examples
--------
>>> cat_lump_lowfreq(list('abbccc'))
['other', 'b', 'b', 'c', 'c', 'c']
Categories (3, object): ['b', 'c', 'other']
When the least categories put together are not less than the next
smallest group.
>>> cat_lump_lowfreq(list('abcddd'))
['a', 'b', 'c', 'd', 'd', 'd']
Categories (4, object): ['a', 'b', 'c', 'd']
>>> cat_lump_lowfreq(list('abcdddd'))
['other', 'other', 'other', 'd', 'd', 'd', 'd']
Categories (2, object): ['d', 'other']
"""
c = as_categorical(c)
if len(c) == 0:
return c
# For each category findout whether to lump it or keep it
# Create a generator of the form ((cat, lump), ...)
counts = c.value_counts().sort_values(ascending=False)
if len(counts) == 1:
return c
unique_counts = pd.unique(counts)
smallest = unique_counts[-1]
next_smallest = unique_counts[-2]
smallest_counts = counts[counts == smallest]
smallest_total = smallest_counts.sum()
smallest_cats = smallest_counts.index
if not smallest_total < next_smallest:
return c
lump_it = (
(cat, True) if cat in smallest_cats else (cat, False)
for cat in counts.index
)
return _lump(lump_it, c, other_category)
def cat_lump_min(
c,
min,
w=None,
other_category='other',
):
"""
Lump catogeries, preserving those that appear min number of times
Parameters
----------
c : list-like
Values that will make up the categorical.
min : int
Minum number of times a category must be represented to be
preserved.
w : list[int|float] (optional)
Weights for the frequency of each value. It should be the same
length as ``c``.
other_category : object (default: 'other')
Value used for the 'other' values. It is placed at
the end of the categories.
Examples
--------
>>> c = list('abccdd')
>>> cat_lump_min(c, min=1)
['a', 'b', 'c', 'c', 'd', 'd']
Categories (4, object): ['a', 'b', 'c', 'd']
>>> cat_lump_min(c, min=2)
['other', 'other', 'c', 'c', 'd', 'd']
Categories (3, object): ['c', 'd', 'other']
**Weighted Lumping**
>>> weights = [2, 2, .5, .5, 1, 1]
>>> cat_lump_min(c, min=2, w=weights)
['a', 'b', 'other', 'other', 'd', 'd']
Categories (4, object): ['a', 'b', 'd', 'other']
Unlike :func:`~plydata.cat_tools.cat_lump`, :func:`cat_lump_min`
can lump together and create a category larger than the preserved
categories.
>>> c = list('abxyzccdd')
>>> cat_lump_min(c, min=2)
['other', 'other', 'other', 'other', 'other', 'c', 'c', 'd', 'd']
Categories (3, object): ['c', 'd', 'other']
"""
c = as_categorical(c)
if len(c) == 0:
return c
if w is None:
counts = c.value_counts().sort_values(ascending=False)
else:
counts = (
pd.Series(w)
.groupby(c)
.apply(np.sum)
.sort_values(ascending=False)
)
if (counts >= min).all():
return c
lookup = {
cat: cat if freq >= min else other_category
for cat, freq in counts.items()
}
new_cats = (
c.categories
.intersection(lookup.values())
.insert(len(c), other_category)
)
c = pd.Categorical(
[lookup[value] for value in c],
categories=new_cats,
ordered=c.ordered
)
return c
def cat_rename(c, mapping=None, **kwargs):
"""
Change/rename categories manually
Parameters
----------
c : list-like
Values that will make up the categorical.
mapping : dict (optional)
Mapping of the form ``{old_name: new_name}`` for how to rename
the categories. Setting a value to ``None`` removes the category.
This arguments is useful if the old names are not valid
python parameters. Otherwise, ``kwargs`` can be used.
**kwargs : dict
Mapping to rename categories. Setting a value to ``None`` removes
the category.
Examples
--------
>>> c = list('abcd')
>>> cat_rename(c, a='A')
['A', 'b', 'c', 'd']
Categories (4, object): ['A', 'b', 'c', 'd']
>>> c = pd.Categorical(
... list('abcd'),
... categories=list('bacd'),
... ordered=True
... )
>>> cat_rename(c, b='B', d='D')
['a', 'B', 'c', 'D']
Categories (4, object): ['B' < 'a' < 'c' < 'D']
Remove categories by setting them to ``None``.
>>> cat_rename(c, b='B', d=None)
['a', 'B', 'c']
Categories (3, object): ['B' < 'a' < 'c']
"""
c = as_categorical(c)
if mapping is not None and len(kwargs):
raise ValueError("Use only one of `new` or the ``kwargs``.")
lookup = mapping or kwargs
if not lookup:
return c
# Remove categories set to None
remove = [
old
for old, new in lookup.items()
if new is None
]
if remove:
for cat in remove:
del lookup[cat]
c = c.remove_categories(remove).dropna()
# Separately change values (inplace) and the categories (using an
# array) old to the new names. Then reconcile the two lists.
categories = c.categories.to_numpy().copy()
c.add_categories(
pd.Index(lookup.values()).difference(c.categories),
inplace=True
)
for old, new in lookup.items():
if old not in c.categories:
raise IndexError("Unknown category '{}'.".format(old))
c[c == old] = new
categories[categories == old] = new
new_categories = pd.unique(categories)
c.remove_unused_categories(inplace=True)
c.set_categories(new_categories, inplace=True)
return c
def cat_relabel(c, func=None, *args, **kwargs):
"""
Change/rename categories and collapse as necessary
Parameters
----------
c : list-like
Values that will make up the categorical.
func : callable
Function to create the new name. The first argument to
the function will be a category to be renamed.
*args : tuple
Positional arguments passed to ``func``.
*kwargs : dict
Keyword arguments passed to ``func``.
Examples
--------
>>> c = list('abcde')
>>> cat_relabel(c, str.upper)
['A', 'B', 'C', 'D', 'E']
Categories (5, object): ['A', 'B', 'C', 'D', 'E']
>>> c = pd.Categorical([0, 1, 2, 1, 1, 0])
>>> def func(x):
... if x == 0:
... return 'low'
... elif x == 1:
... return 'mid'
... elif x == 2:
... return 'high'
>>> cat_relabel(c, func)
['low', 'mid', 'high', 'mid', 'mid', 'low']
Categories (3, object): ['low', 'mid', 'high']
When the function yields the same output for 2 or more
different categories, those categories are collapsed.
>>> def first(x):
... return x[0]
>>> c = pd.Categorical(['aA', 'bB', 'aC', 'dD'],
... categories=['bB', 'aA', 'dD', 'aC'],
... ordered=True
... )
>>> cat_relabel(c, first)
['a', 'b', 'a', 'd']
Categories (3, object): ['b' < 'a' < 'd']
"""
c = as_categorical(c)
new_categories = [func(x, *args, **kwargs) for x in c.categories]
new_categories_uniq = pd.unique(new_categories)
if len(new_categories_uniq) < len(c.categories):
# Collapse
lookup = dict(zip(c.categories, new_categories))
c = pd.Categorical(
[lookup[value] for value in c],
categories=new_categories_uniq,
ordered=c.ordered
)
else:
c.categories = new_categories
return c
def cat_expand(c, *args):
"""
Add additional categories to a categorical
Parameters
----------
c : list-like
Values that will make up the categorical.
*args : tuple
Categories to add.
Examples
--------
>>> cat_expand(list('abc'), 'd', 'e')
['a', 'b', 'c']
Categories (5, object): ['a', 'b', 'c', 'd', 'e']
>>> c = pd.Categorical(list('abcd'), ordered=True)
>>> cat_expand(c, 'e', 'f')
['a', 'b', 'c', 'd']
Categories (6, object): ['a' < 'b' < 'c' < 'd' < 'e' < 'f']
"""
c = as_categorical(c)
c.add_categories(
pd.Index(args).difference(c.categories),
inplace=True
)
return c
def cat_explicit_na(c, na_category='(missing)'):
"""
Give missing values an explicity category
Parameters
----------
c : list-like
Values that will make up the categorical.
na_category : object (default: '(missing)')
Category for missing values
Examples
--------
>>> c = pd.Categorical(
... ['a', 'b', None, 'c', None, 'd', 'd'],
... ordered=True
... )
>>> c
['a', 'b', NaN, 'c', NaN, 'd', 'd']
Categories (4, object): ['a' < 'b' < 'c' < 'd']
>>> cat_explicit_na(c)
['a', 'b', '(missing)', 'c', '(missing)', 'd', 'd']
Categories (5, object): ['a' < 'b' < 'c' < 'd' < '(missing)']
"""
c = as_categorical(c)
bool_idx = pd.isnull(c)
if any(bool_idx):
c.add_categories([na_category], inplace=True)
c[bool_idx] = na_category
return c
def cat_remove_unused(c, only=None):
"""
Remove unused categories
Parameters
----------
c : list-like
Values that will make up the categorical.
only : list-like (optional)
The categories to remove *if* they are empty. If not given,
all unused categories are dropped.
Examples
--------
>>> c = pd.Categorical(list('abcdd'), categories=list('bacdefg'))
>>> c
['a', 'b', 'c', 'd', 'd']
Categories (7, object): ['b', 'a', 'c', 'd', 'e', 'f', 'g']
>>> cat_remove_unused(c)
['a', 'b', 'c', 'd', 'd']
Categories (4, object): ['b', 'a', 'c', 'd']
>>> cat_remove_unused(c, only=['a', 'e', 'g'])
['a', 'b', 'c', 'd', 'd']
Categories (5, object): ['b', 'a', 'c', 'd', 'f']
"""
if not pdtypes.is_categorical_dtype(c):
# All categories are used
c = pd.Categorical(c)
return c
else:
c = c.copy()
if only is None:
only = c.categories
used_idx = pd.unique(c.codes)
used_categories = c.categories[used_idx]
c = c.remove_categories(
c.categories
.difference(used_categories)
.intersection(only)
)
return c
def cat_unify(cs, categories=None):
"""
Unify (union of all) the categories in a list of categoricals
Parameters
----------
cs : list-like
Categoricals
categories : list-like
Extra categories to apply to very categorical.
Examples
--------
>>> c1 = pd.Categorical(['a', 'b'], categories=list('abc'))
>>> c2 = pd.Categorical(['d', 'e'], categories=list('edf'))
>>> c1_new, c2_new = cat_unify([c1, c2])
>>> c1_new
['a', 'b']
Categories (6, object): ['a', 'b', 'c', 'e', 'd', 'f']
>>> c2_new
['d', 'e']
Categories (6, object): ['a', 'b', 'c', 'e', 'd', 'f']
>>> c1_new, c2_new = cat_unify([c1, c2], categories=['z', 'y'])
>>> c1_new
['a', 'b']
Categories (8, object): ['a', 'b', 'c', 'e', 'd', 'f', 'z', 'y']
>>> c2_new
['d', 'e']
Categories (8, object): ['a', 'b', 'c', 'e', 'd', 'f', 'z', 'y']
"""
cs = [as_categorical(c) for c in cs]
all_cats = list(chain(*(c.categories.to_list() for c in cs)))
if categories is None:
categories = pd.unique(all_cats)
else:
categories = | pd.unique(all_cats + categories) | pandas.unique |
# %%
import rasterio
import pandas as pds
import numpy as np
import numpy.ma as ma
from sklearn.pipeline import Pipeline
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt
import seaborn
# %%
HI_RES = '30s'
LOW_RES = '10m'
INCLUDE_VARS = [1,2,3,4,5,6,7,10,11]
vlab = ['meanT', 'diT', 'isoT', 'seaT', '+monT', '-monT', 'range', 'mean+Q', 'mean-Q']
def print_matrix(M, rlab=None, clab=None):
t = '\t'
if clab:
print('', end=t)
for cl in clab:
print(cl, end=t)
print('')
for ir, r in enumerate(M):
if rlab:
print(f'{rlab[ir]}', end=t)
for ic, c in enumerate(r):
print(f'{c:.2f}' if abs(c) > 0 else '', end=t)
print('')
def read_band(path):
with rasterio.open(path) as file:
return file.read(1, masked=True).ravel()
def build_matrix(res, varnums):
features = [read_band(f'./_data/wc2.1_{res}/bio_{num}.tif') for num in varnums]
return ma.mask_rows(ma.vstack(features).transpose())
# %%
raw_rows = build_matrix(LOW_RES, INCLUDE_VARS)
compressed = ma.compress_rows(raw_rows)
corr = np.corrcoef(compressed, rowvar=False)
cov = np.cov(compressed, rowvar=False)
# %%
scaler = StandardScaler()
scaled = scaler.fit_transform(compressed)
df = | pds.DataFrame(scaled, columns=vlab) | pandas.DataFrame |
# install imblearn package to a specific anaconda enviroment boston_house_price
# $ conda install -n boston_house_price -c conda-forge imbalanced-learn
# update imblearn package to a specific anaconda enviroment boston_house_price
# $ conda update -n boston_house_price -c glemaitre imbalanced-learn
# =============================================================
# Import libraries necessary for this project
import numpy as np
import pandas as pd
from time import time
# Set a random seed
import random
seed = 42
random.seed(seed)
# Import supplementary visualization code visuals.py
import scripts.visuals as vs
# Load the Census dataset
path = '../data/'
train_data = path + 'census.csv'
test_data = path + 'test_census.csv'
data = pd.read_csv(train_data)
print(data.head(n=1))
print(data.shape)
# get the types of columns
print(data.dtypes)
# Pandas has a helpful select_dtypes function
# which we can use to build a new dataframe containing only the object columns.
obj_data = data.select_dtypes(include=['object']).copy()
# Before going any further, we have to check if there are null values in the data that we need to clean up.
print(obj_data[obj_data.isnull().any(axis=1)])
# TODO: Total number of records
n_records = data.shape[0]
# TODO: Number of records where individual's income is more than $50,000
# TODO: Number of records where individual's income is at most $50,000
# Method1:
n_at_most_50k, n_greater_50k = data.income.value_counts()
# Method2: (optional) -->
# n2_greater_50k = data[data['income']=='>50K'].shape[0]
# n2_at_most_50k = data[data['income']=='<=50K'].shape[0]
n_aux = data.loc[(data['capital-gain'] > 0) & (data['capital-loss'] > 0)].shape
# TODO: Percentage of individuals whose income is more than $50,000
greater_percent = (100*n_greater_50k)/n_records
# Print the results
print("Total number of records: {}".format(n_records))
print("Individuals making more than $50,000: {}".format(n_greater_50k))
print("Individuals making at most $50,000: {}".format(n_at_most_50k))
print("Percentage of individuals making more than $50,000: {}%".format(greater_percent))
# Split the data into features and target label
income_raw = data['income']
features_raw = data.drop('income', axis = 1)
# Visualize skewed continuous features of original data
vs.distribution(data)
# Log-transform the skewed features
skewed = ['capital-gain', 'capital-loss']
features_log_transformed = pd.DataFrame(data = features_raw)
features_log_transformed[skewed] = features_raw[skewed].apply(lambda x: np.log(x + 1))
# Visualize the new log distributions
vs.distribution(features_log_transformed, transformed = True)
# Import sklearn.preprocessing.StandardScaler
from sklearn.preprocessing import MinMaxScaler, LabelEncoder
# Initialize a scaler, then apply it to the features
scaler = MinMaxScaler() # default=(0, 1)
numerical = ['age', 'education-num', 'capital-gain', 'capital-loss', 'hours-per-week']
features_log_minmax_transform = pd.DataFrame(data = features_log_transformed)
features_log_minmax_transform[numerical] = scaler.fit_transform(features_log_transformed[numerical])
# Show an example of a record with scaling applied
print(features_log_minmax_transform.head(n = 5))
# TODO: One-hot encode the 'features_log_minmax_transform' data using pandas.get_dummies()
features_final = pd.get_dummies(features_log_minmax_transform)
# TODO: Encode the 'income_raw' data to numerical values
# Method1:
encoder = LabelEncoder()
income = pd.Series(encoder.fit_transform(income_raw))
# Method2:(optional) -->
income1 =income_raw.map({'<=50K':0, '>50K':1})
# Method3:(optional) -->
income2 =pd.get_dummies(income_raw)['>50K']
# Print the number of features after one-hot encoding
encoded = list(features_final.columns)
print("{} total features after one-hot encoding.".format(len(encoded)))
# Uncomment the following line to see the encoded feature names
print(encoded)
#-----------------
# @Raafat: Some techniques to deal imbalanced data:
# --> under sampling
from imblearn.under_sampling import CondensedNearestNeighbour
cnn = CondensedNearestNeighbour(random_state=42)
X_res, y_res = cnn.fit_sample(features_final[0:300], income[0:300])
print('not Resampled dataset shape {}'.format(income[0:300].value_counts()))
print('cnn Resampled dataset shape {}'.format( | pd.Series(y_res) | pandas.Series |
# -*- coding: utf-8 -*-
"""
*This script contains a post-processing script for plotting times recorded by the main_constellation.py application*
Placeholder
"""
import numpy as np
import pandas as pd
from datetime import timedelta, datetime, timezone
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import seaborn as sns
from scipy import stats
# from scipy.stats import skew, kurtosis
font1 = {"family": "sans-serif", "weight": "bold", "size": 24}
font1 = {"family": "sans-serif", "weight": "bold", "size": 10}
start = pd.DataFrame(constellation.fires)
start.set_index("fireId", inplace=True)
detect = | pd.DataFrame(constellation.detect) | pandas.DataFrame |
from datetime import datetime
import numpy as np
import pytest
import pandas.util._test_decorators as td
from pandas.core.dtypes.base import _registry as ea_registry
from pandas.core.dtypes.common import (
is_categorical_dtype,
is_interval_dtype,
is_object_dtype,
)
from pandas.core.dtypes.dtypes import (
CategoricalDtype,
DatetimeTZDtype,
IntervalDtype,
PeriodDtype,
)
from pandas import (
Categorical,
DataFrame,
DatetimeIndex,
Index,
Interval,
IntervalIndex,
MultiIndex,
NaT,
Period,
PeriodIndex,
Series,
Timestamp,
cut,
date_range,
notna,
period_range,
)
import pandas._testing as tm
from pandas.core.arrays import SparseArray
from pandas.tseries.offsets import BDay
class TestDataFrameSetItem:
@pytest.mark.parametrize("dtype", ["int32", "int64", "float32", "float64"])
def test_setitem_dtype(self, dtype, float_frame):
arr = np.random.randn(len(float_frame))
float_frame[dtype] = np.array(arr, dtype=dtype)
assert float_frame[dtype].dtype.name == dtype
def test_setitem_list_not_dataframe(self, float_frame):
data = np.random.randn(len(float_frame), 2)
float_frame[["A", "B"]] = data
tm.assert_almost_equal(float_frame[["A", "B"]].values, data)
def test_setitem_error_msmgs(self):
# GH 7432
df = DataFrame(
{"bar": [1, 2, 3], "baz": ["d", "e", "f"]},
index=Index(["a", "b", "c"], name="foo"),
)
ser = Series(
["g", "h", "i", "j"],
index=Index(["a", "b", "c", "a"], name="foo"),
name="fiz",
)
msg = "cannot reindex from a duplicate axis"
with pytest.raises(ValueError, match=msg):
df["newcol"] = ser
# GH 4107, more descriptive error message
df = DataFrame(np.random.randint(0, 2, (4, 4)), columns=["a", "b", "c", "d"])
msg = "incompatible index of inserted column with frame index"
with pytest.raises(TypeError, match=msg):
df["gr"] = df.groupby(["b", "c"]).count()
def test_setitem_benchmark(self):
# from the vb_suite/frame_methods/frame_insert_columns
N = 10
K = 5
df = DataFrame(index=range(N))
new_col = np.random.randn(N)
for i in range(K):
df[i] = new_col
expected = DataFrame(np.repeat(new_col, K).reshape(N, K), index=range(N))
tm.assert_frame_equal(df, expected)
def test_setitem_different_dtype(self):
df = DataFrame(
np.random.randn(5, 3), index=np.arange(5), columns=["c", "b", "a"]
)
df.insert(0, "foo", df["a"])
df.insert(2, "bar", df["c"])
# diff dtype
# new item
df["x"] = df["a"].astype("float32")
result = df.dtypes
expected = Series(
[np.dtype("float64")] * 5 + [np.dtype("float32")],
index=["foo", "c", "bar", "b", "a", "x"],
)
tm.assert_series_equal(result, expected)
# replacing current (in different block)
df["a"] = df["a"].astype("float32")
result = df.dtypes
expected = Series(
[np.dtype("float64")] * 4 + [np.dtype("float32")] * 2,
index=["foo", "c", "bar", "b", "a", "x"],
)
tm.assert_series_equal(result, expected)
df["y"] = df["a"].astype("int32")
result = df.dtypes
expected = Series(
[np.dtype("float64")] * 4 + [np.dtype("float32")] * 2 + [np.dtype("int32")],
index=["foo", "c", "bar", "b", "a", "x", "y"],
)
tm.assert_series_equal(result, expected)
def test_setitem_empty_columns(self):
# GH 13522
df = DataFrame(index=["A", "B", "C"])
df["X"] = df.index
df["X"] = ["x", "y", "z"]
exp = DataFrame(data={"X": ["x", "y", "z"]}, index=["A", "B", "C"])
tm.assert_frame_equal(df, exp)
def test_setitem_dt64_index_empty_columns(self):
rng = date_range("1/1/2000 00:00:00", "1/1/2000 1:59:50", freq="10s")
df = DataFrame(index=np.arange(len(rng)))
df["A"] = rng
assert df["A"].dtype == np.dtype("M8[ns]")
def test_setitem_timestamp_empty_columns(self):
# GH#19843
df = DataFrame(index=range(3))
df["now"] = Timestamp("20130101", tz="UTC")
expected = DataFrame(
[[Timestamp("20130101", tz="UTC")]] * 3, index=[0, 1, 2], columns=["now"]
)
tm.assert_frame_equal(df, expected)
def test_setitem_wrong_length_categorical_dtype_raises(self):
# GH#29523
cat = Categorical.from_codes([0, 1, 1, 0, 1, 2], ["a", "b", "c"])
df = DataFrame(range(10), columns=["bar"])
msg = (
rf"Length of values \({len(cat)}\) "
rf"does not match length of index \({len(df)}\)"
)
with pytest.raises(ValueError, match=msg):
df["foo"] = cat
def test_setitem_with_sparse_value(self):
# GH#8131
df = DataFrame({"c_1": ["a", "b", "c"], "n_1": [1.0, 2.0, 3.0]})
sp_array = SparseArray([0, 0, 1])
df["new_column"] = sp_array
expected = Series(sp_array, name="new_column")
tm.assert_series_equal(df["new_column"], expected)
def test_setitem_with_unaligned_sparse_value(self):
df = DataFrame({"c_1": ["a", "b", "c"], "n_1": [1.0, 2.0, 3.0]})
sp_series = Series(SparseArray([0, 0, 1]), index=[2, 1, 0])
df["new_column"] = sp_series
expected = Series(SparseArray([1, 0, 0]), name="new_column")
tm.assert_series_equal(df["new_column"], expected)
def test_setitem_dict_preserves_dtypes(self):
# https://github.com/pandas-dev/pandas/issues/34573
expected = DataFrame(
{
"a": Series([0, 1, 2], dtype="int64"),
"b": Series([1, 2, 3], dtype=float),
"c": Series([1, 2, 3], dtype=float),
}
)
df = DataFrame(
{
"a": Series([], dtype="int64"),
"b": Series([], dtype=float),
"c": Series([], dtype=float),
}
)
for idx, b in enumerate([1, 2, 3]):
df.loc[df.shape[0]] = {"a": int(idx), "b": float(b), "c": float(b)}
tm.assert_frame_equal(df, expected)
@pytest.mark.parametrize(
"obj,dtype",
[
(Period("2020-01"), PeriodDtype("M")),
(Interval(left=0, right=5), IntervalDtype("int64", "right")),
(
Timestamp("2011-01-01", tz="US/Eastern"),
DatetimeTZDtype(tz="US/Eastern"),
),
],
)
def test_setitem_extension_types(self, obj, dtype):
# GH: 34832
expected = DataFrame({"idx": [1, 2, 3], "obj": Series([obj] * 3, dtype=dtype)})
df = DataFrame({"idx": [1, 2, 3]})
df["obj"] = obj
tm.assert_frame_equal(df, expected)
@pytest.mark.parametrize(
"ea_name",
[
dtype.name
for dtype in ea_registry.dtypes
# property would require instantiation
if not isinstance(dtype.name, property)
]
# mypy doesn't allow adding lists of different types
# https://github.com/python/mypy/issues/5492
+ ["datetime64[ns, UTC]", "period[D]"], # type: ignore[list-item]
)
def test_setitem_with_ea_name(self, ea_name):
# GH 38386
result = DataFrame([0])
result[ea_name] = [1]
expected = DataFrame({0: [0], ea_name: [1]})
tm.assert_frame_equal(result, expected)
def test_setitem_dt64_ndarray_with_NaT_and_diff_time_units(self):
# GH#7492
data_ns = np.array([1, "nat"], dtype="datetime64[ns]")
result = Series(data_ns).to_frame()
result["new"] = data_ns
expected = DataFrame({0: [1, None], "new": [1, None]}, dtype="datetime64[ns]")
tm.assert_frame_equal(result, expected)
# OutOfBoundsDatetime error shouldn't occur
data_s = np.array([1, "nat"], dtype="datetime64[s]")
result["new"] = data_s
expected = DataFrame({0: [1, None], "new": [1e9, None]}, dtype="datetime64[ns]")
| tm.assert_frame_equal(result, expected) | pandas._testing.assert_frame_equal |
# Functionality to read and store in HDF5 files
import h5py
import pandas as pd
import random
import string
import os
import datetime
import json
from data_science.data_transfer.data_api import Dataset
class HDF5Dataset:
def __init__(self, file_name, file_path, dataset_id,
random_string_in_name=10):
"""
Initialization.
:param self:
:param file_name: name for the file. No ending necessary
:param file_path: location path
:param dataset_id: dataset's id
:param random_string_in_name: lenght of the random string to add to
the name
"""
self.file_name = file_name
self.file_path = file_path
self.file_w_path = os.path.join(self.file_path, self.file_name)
self._dataset_id = dataset_id
self.random_string_in_name = random_string_in_name
@property
def dataset_id(self):
# do something
return self._dataset_id
@dataset_id.setter
def dataset_id(self, value):
self._dataset_id = value
def create_h5_file(self):
"""
Create the h5 file and add the groups.
:param self: self
"""
self.file_name = self.file_name + '-' + \
_generate_random_string(l=self.random_string_in_name) + '.h5'
self.file_w_path = os.path.join(self.file_path, self.file_name)
try:
f = h5py.File(self.file_w_path, 'a')
f.create_group('meta')
f.create_group('meta/columns')
f.create_group('data')
f.close()
return self.file_name
except ValueError as e:
print(e)
return
def add_dataset_meta_to_h5(self, dataset):
"""
Add the meta data of the dataset to the file. Consist of:
A dataframe with the dataset attributes.
A dataframe with the columns of the dataset.
:param self: self
:param dataset: a Dataset instance
"""
if not isinstance(dataset, Dataset):
raise TypeError('A dataset has to be provided.')
# create a df with the metadata
columns = list(dataset.dump_attributes_to_dictionary().keys())
df = pd.DataFrame(columns=columns)
df.loc[0] = dataset.dump_attributes_to_dictionary()
# insert to the file
df.to_hdf(self.file_w_path, key='meta/' + self._dataset_id, mode='a')
def add_dataset_data_df_to_h5(self, df):
"""
Add the data of the dataset to the file.
:param self: self
:param df: dataframe with the data
"""
# insert the df to the file
df.to_hdf(self.file_name, key='data/' + self._dataset_id, mode='a')
# insert the columns names as df to the metadata
df_col = pd.DataFrame(columns=['columns'])
df_col['columns'] = list(df.columns.values)
# insert to the file
df_col.to_hdf(self.file_w_path,
key='meta/columns/' + self._dataset_id,
mode='a')
def remove_dataset_from_h5(self):
"""
Remove the dataset from the file.
:param self: self
"""
try:
with h5py.File(self.file_w_path, 'a') as f:
del f['data/' + self._dataset_id]
del f['meta/' + self._dataset_id]
del f['meta/columns/' + self._dataset_id]
except KeyError as e:
print(e)
def read_dataset_data_df_from_h5(self):
"""
Read the data from the file. Returns a dataframe.
:param self: self
"""
try:
df = | pd.read_hdf(self.file_w_path, 'data/' + self._dataset_id, 'r') | pandas.read_hdf |
# -*- coding: utf-8 -*-
"""
Created on Mon May 07 17:34:56 2018
@author: gerar
"""
import os
import pandas as pd
import numpy as np
from scipy.stats.stats import pearsonr
#%%
def rmse(predictions, targets):
return np.sqrt(((predictions - targets) ** 2).mean())
#%%
def mae(predictions,targets):
return np.abs((predictions - targets)).mean()
#%%
def bias(predictions,targets):
return np.mean(predictions)-np.mean(targets)
#%%
def r_deming(x,y):
x_mean = np.mean(x)
y_mean = np.mean(y)
sxx = np.sum(np.power(x-x_mean,2.))/(len(x)-1.)
syy = np.sum(np.power(y-y_mean,2.))/(len(x)-1.)
sxy = np.sum((x-x_mean)*(y-y_mean))/(len(x)-1.)
lamb = 1#np.var(y)/np.var(x)
b1 = (syy-lamb*sxx+np.sqrt((syy-lamb*sxx)**2 +4*lamb*sxy**2))/(2*sxy)
b0 = y_mean - x_mean*b1
return [b1,b0]
#%%
def get_data(_file):
# data = pd.read_table(file_to_plot[0], parse_dates=[0],infer_datetime_format = True,usecols=(0,2,4)) #, parse_dates=[0],infer_datetime_format = True
# data = data.dropna() #[pd.notnull(data['AOD_AERONET'])]
# data = data.set_index('Date_MODIS')
modis_data,aeronet_data = np.loadtxt(_file,skiprows = 1,usecols=(2,4),unpack=True)
return modis_data, aeronet_data
#%%
def helper(x):
return pd.DataFrame({'AOD_MODIS':x['AOD_MODIS'].values,'AOD_AERONET':x['AOD_AERONET'].values})
#%%
def ee_fraction(predictions, targets):
_ee = np.abs(0.05 + 0.15*targets)
ee_plus = targets + _ee
ee_minus = targets - _ee
n_tot = len(predictions)
within_ee = predictions[np.logical_and(ee_minus<predictions,predictions<ee_plus)]
return '{:.2%}'.format(float(len(within_ee))/n_tot)
# m_plus,b_plus = np.polyfit(targets,ee_plus,1)
# m_minus,b_minus = np.polyfit(targets,ee_minus,1)
#%%
def db_results(row_names,data,s=None,e=None):
ix_names=['RMSE','R_pearson','MAE','BIAS','m_deming','b_deming','MEAN_MODIS','MEAN_AERONET','N','f']
if len(row_names) == 1:
db = pd.DataFrame(columns=row_names,index=ix_names)
db.loc['RMSE']=rmse(data[0],data[1])
db.loc['R_pearson']=pearsonr(data[0],data[1])[0]
db.loc['MAE']=mae(data[0],data[1])
db.loc['BIAS']=bias(data[0],data[1])
m,b = r_deming(data[1],data[0])
db.loc['m_deming']=m
db.loc['b_deming']=b
db.loc['MEAN_MODIS']=np.mean(data[0])
db.loc['MEAN_AERONET']=np.mean(data[1])
db.loc['N']=len(data[0])
db.loc['f']=ee_fraction(data[0],data[1])
else:
db = pd.DataFrame(columns=range(s,e),index=ix_names)
for col in row_names:
t_data = data.loc[col]
if len(t_data) <= 2:
continue
db.loc['RMSE'][col]=rmse(t_data['AOD_MODIS'],t_data['AOD_AERONET'])
db.loc['R_pearson'][col]=pearsonr(t_data['AOD_MODIS'],t_data['AOD_AERONET'])[0]
db.loc['MAE'][col]=mae(t_data['AOD_MODIS'],t_data['AOD_AERONET'])
db.loc['BIAS'][col]=bias(t_data['AOD_MODIS'],t_data['AOD_AERONET'])
m,b = r_deming(t_data['AOD_AERONET'],t_data['AOD_MODIS'])
db.loc['m_deming'][col]=m
db.loc['b_deming'][col]=b
db.loc['MEAN_MODIS'][col]=np.mean(t_data['AOD_MODIS'])
db.loc['MEAN_AERONET'][col]=np.mean(t_data['AOD_AERONET'])
db.loc['N'][col]=len(t_data['AOD_MODIS'])
db.loc['f'][col]=ee_fraction(t_data['AOD_MODIS'],t_data['AOD_AERONET'])
return db
#%%
def main():
files = [x for x in os.listdir(os.getcwd()) if x.endswith("matched_data_end.txt")]
for _file in files:
modis, aeronet = get_data(_file)
general_data = db_results(['Statistics'],[modis,aeronet])
data = | pd.read_table(_file,usecols=[0,2,4]) | pandas.read_table |
import logging
import traceback
import pandas as pd
import numpy as np
import seaborn as sns
from collections import defaultdict
import matplotlib
matplotlib.use('Agg')
matplotlib.rcParams['pdf.fonttype'] = 42
import matplotlib.ticker as ticker
from matplotlib import pyplot as plt
import matplotlib.patches as mpatches
from matplotlib.backends.backend_pdf import PdfPages
import inStrain.plotting.utilities
from inStrain.plotting.utilities import plot_genome
from inStrain.plotting.utilities import estimate_breadth
def genome_plot_from_IS(IS, plot_dir=False, **kwargs):
# Load the required data
try:
stb = IS.get('scaffold2bin')
b2s = defaultdict(list)
for s, b in stb.items():
b2s[b].append(s)
assert len(b2s.keys()) > 0
# Load the cache
covTs = kwargs.get('covT')#, IS.get('covT'))
clonTs = kwargs.get('clonT')#, IS.get('clonT'))
raw_linkage_table = kwargs.get('raw_linkage_table')#, IS.get('raw_linkage_table'))
cumulative_snv_table = kwargs.get('cumulative_snv_table')#, IS.get('cumulative_snv_table'))
scaffold2length = IS.get('scaffold2length')
rl = IS.get_read_length()
profiled_scaffolds = set(scaffold2length.keys())
except:
logging.error("Skipping plot 2 - you don't have all required information. You need to run inStrain genome_wide first")
traceback.print_exc()
return
# Make the plot
logging.info("Plotting plot 2")
name = 'genomeWide_microdiveristy_metrics.pdf'
pp = PdfPages(plot_dir + name)
for genome, scaffolds in b2s.items():
if not plot_genome(genome, IS, **kwargs):
continue
present_scaffolds = list(set(scaffolds).intersection(set(profiled_scaffolds)))
Wdb, breaks, midpoints = load_windowed_metrics(present_scaffolds,
scaffold2length,
rl,
report_midpoints=True,
covTs=covTs, clonTs=clonTs,
raw_linkage_table=raw_linkage_table,
cumulative_snv_table=cumulative_snv_table)
if len(Wdb) == 0:
logging.debug(f"{genome} could not have windowed metrics loaded")
continue
genomeWide_microdiveristy_metrics_plot(Wdb, breaks, title=genome)
fig = plt.gcf()
fig.set_size_inches(8, 5)
fig.tight_layout()
pp.savefig(fig)#, bbox_inches='tight')
#plt.show()
plt.close(fig)
# Save the figure
pp.close()
#plt.show()
plt.close('all')
def scaffold_inspection_from_IS(IS, plot_dir=False, **kwargs):
# Load the required data
try:
stb = IS.get('scaffold2bin')
b2s = defaultdict(list)
for s, b in stb.items():
b2s[b].append(s)
assert len(b2s.keys()) > 0
# Load the cache
covTs = kwargs.get('covTs', IS.get('covT'))
clonTs = kwargs.get('clonTs', IS.get('clonT'))
raw_linkage_table = kwargs.get('raw_linkage_table', IS.get('raw_linkage_table'))
cumulative_snv_table = kwargs.get('cumulative_snv_table', IS.get('cumulative_snv_table'))
scaffold2length = IS.get('scaffold2length')
rl = IS.get_read_length()
profiled_scaffolds = set(scaffold2length.keys())
except:
logging.error("Skipping plot 7 - you don't have all required information. You need to run inStrain genome_wide first")
traceback.print_exc()
return
# Make the plot
logging.info("Plotting plot 7")
name = 'ScaffoldInspection_plot.pdf'
pp = PdfPages(plot_dir + name)
for genome, scaffolds in b2s.items():
if not plot_genome(genome, IS, **kwargs):
continue
present_scaffolds = list(set(scaffolds).intersection(set(profiled_scaffolds)))
Wdb, breaks, midpoints = load_windowed_metrics(present_scaffolds,
scaffold2length,
rl,
report_midpoints=True,
covTs=covTs, clonTs=clonTs,
raw_linkage_table=raw_linkage_table,
cumulative_snv_table=cumulative_snv_table)
if len(Wdb) == 0:
logging.debug(f"{genome} could not have windowed metrics loaded")
continue
scaffold_inspection_plot(Wdb, breaks, midpoints, title=genome)
fig = plt.gcf()
fig.tight_layout()
pp.savefig(fig)#, bbox_inches='tight')
#plt.show()
plt.close(fig)
# Save the figure
pp.close()
#plt.show()
plt.close('all')
def genomeWide_microdiveristy_metrics_plot(Wdb, breaks, title=''):
'''
Make the multiple metrics plot
'''
# Get set up for multiple rows
i = len(Wdb['metric'].unique())
if i > 1:
fig, ax = plt.subplots(i, 1, sharex=True)
else:
ax = {}
ax[0] = plt.gca()
i = 0
for metric in ['linkage', 'snp_density', 'coverage', 'nucl_diversity']:
#for metric, wdb in Wdb.groupby('metric'):
if metric not in set(Wdb['metric'].tolist()):
continue
wdb = Wdb[Wdb['metric'] == metric]
med = wdb['value'].median()
# Rotate colors:
colors = ['red', 'blue', 'black']
c = 0
for mm, ddb in wdb.groupby('ANI'):
ax[i].plot(ddb['midpoint'], ddb['value'], c=colors[c], label=mm, marker='o', ms=1)#, ls='')
c += 1
ax[i].set_title("{0}".format(metric))
ax[i].grid(False)
if i == 0:
ax[i].legend(loc='upper left', title='Min read ANI (%)')
# Add breaks
for b in breaks:
ax[i].axvline(b, ls='-', c='lightgrey', zorder=-1)
i += 1
plt.xlabel('genome position')
plt.xlim(0, Wdb['midpoint'].max())
plt.suptitle(title, y=0.999)
plt.subplots_adjust(hspace=0.3)
def load_windowed_metrics(scaffolds, s2l, rLen, metrics=None, window_len=None, ANI_levels=[0, 100],
min_scaff_len=0, report_midpoints=False, covTs=False, clonTs=False,
raw_linkage_table=False, cumulative_snv_table=False):
if metrics is None:
metrics = ['coverage', 'nucl_diversity', 'linkage', 'snp_density']
if type(metrics) != type([]):
print("Metrics must be a list")
return
# Figure out the MMs needed
#rLen = IS.get_read_length()
mms = [_get_mm(None, ANI, rLen=rLen) for ANI in ANI_levels]
# Sort the scaffolds
#s2l = IS.get('scaffold2length')
scaffolds = sorted(scaffolds, key=s2l.get, reverse=True)
if min_scaff_len > 0:
scaffolds = [s for s in scaffolds if s2l[s] >= min_scaff_len]
# Figure out the window length
if window_len == None:
window_len = int(sum([s2l[s] for s in scaffolds]) / 100)
else:
window_len = int(window_len)
# Calculate the breaks
breaks = []
midpoints = {}
tally = 0
for scaffold in scaffolds:
midpoints[scaffold] = tally + int(s2l[scaffold] / 2)
tally += s2l[scaffold]
breaks.append(tally)
dbs = []
if 'coverage' in metrics:
if covTs == False:
logging.error("need covTs for coverage")
raise Exception
cdb = load_windowed_coverage_or_clonality('coverage', covTs, scaffolds, window_len, mms, ANI_levels, s2l)
cdb['metric'] = 'coverage'
dbs.append(cdb)
# if 'clonality' in metrics:
# cdb = load_windowed_coverage_or_clonality(IS, 'clonality', scaffolds, window_len, mms, ANI_levels, s2l)
# cdb['metric'] = 'clonality'
# dbs.append(cdb)
if 'nucl_diversity' in metrics:
if clonTs == False:
logging.error("need clonTs for microdiversity")
raise Exception
cdb = load_windowed_coverage_or_clonality('nucl_diversity', clonTs, scaffolds, window_len, mms, ANI_levels, s2l)
cdb['metric'] = 'nucl_diversity'
dbs.append(cdb)
if 'linkage' in metrics:
if raw_linkage_table is False:
logging.error("need raw_linkage_table for linkage")
raise Exception
cdb = load_windowed_linkage(raw_linkage_table, scaffolds, window_len, mms, ANI_levels, s2l)
cdb['metric'] = 'linkage'
dbs.append(cdb)
if 'snp_density' in metrics:
if cumulative_snv_table is False:
logging.error("need cumulative_snv_table for snp_density")
raise Exception
if len(cumulative_snv_table) > 0:
cdb = load_windowed_SNP_density(cumulative_snv_table, scaffolds, window_len, mms, ANI_levels, s2l)
cdb['metric'] = 'snp_density'
dbs.append(cdb)
if len(dbs) > 0:
Wdb = pd.concat(dbs, sort=True)
Wdb = Wdb.rename(columns={'avg_cov':'value'})
else:
Wdb = pd.DataFrame()
# Add blanks at the breaks
table = defaultdict(list)
for mm, ani in zip(mms, ANI_levels):
for metric in Wdb['metric'].unique():
for bre in breaks:
table['scaffold'].append('break')
table['mm'].append(mm)
table['ANI'].append(ani)
table['adjusted_start'].append(bre) # The minus one makes sure it doenst split things it shouldnt
table['adjusted_end'].append(bre)
table['value'].append(np.nan)
table['metric'].append(metric)
bdb = pd.DataFrame(table)
Wdb = pd.concat([Wdb, bdb], sort=False)
if len(Wdb) > 0:
Wdb['midpoint'] = [np.mean([x, y]) for x, y in zip(Wdb['adjusted_start'], Wdb['adjusted_end'])]
Wdb = Wdb.sort_values(['metric', 'mm', 'midpoint', 'scaffold'])
if report_midpoints:
return Wdb, breaks, midpoints
else:
return Wdb, breaks
def _get_mm(IS, ANI, rLen = None):
'''
Get the mm corresponding to an ANI level in an IS
'''
if ANI > 1:
ANI = ANI / 100
if rLen == None:
rLen = IS.get_read_length()
#rLen = IS.get('mapping_info')['mean_pair_length'].tolist()[0]
mm = int(round((rLen - (rLen * ANI))))
return mm
def load_windowed_coverage_or_clonality(thing, covTs, scaffolds, window_len, mms, ANI_levels, s2l):
'''
Get the windowed coverage
Pass in a clonTs for microdiversity and covTs for coverage
'''
if thing == 'coverage':
item = 'covT'
elif thing == 'nucl_diversity':
item = 'clonT'
else:
print("idk what {0} is".format(thing))
return
# Get the covTs
#covTs = IS.get(item, scaffolds=scaffolds)
# Make the windows
dbs = []
tally = 0
breaks = []
for scaffold in scaffolds:
if scaffold not in covTs:
tally += s2l[scaffold]
breaks.append(tally)
continue
else:
covT = covTs[scaffold]
for mm, ani in zip(mms, ANI_levels):
if item == 'covT':
cov = inStrain.profile.profile_utilities.mm_counts_to_counts_shrunk(covT, mm)
if len(cov) == 0:
continue
db = _gen_windowed_cov(cov, window_len, sLen=s2l[scaffold])
elif item == 'clonT':
cov = _get_basewise_clons3(covT, mm)
if len(cov) == 0:
continue
db = _gen_windowed_cov(cov, window_len, sLen=s2l[scaffold], full_len=False)
db['avg_cov'] = [1 - x if x == x else x for x in db['avg_cov']]
db['scaffold'] = scaffold
db['mm'] = mm
db['ANI'] = ani
db['adjusted_start'] = db['start'] + tally
db['adjusted_end'] = db['end'] + tally
dbs.append(db)
tally += s2l[scaffold]
breaks.append(tally)
if len(dbs) > 0:
Wdb = pd.concat(dbs)
else:
Wdb = pd.DataFrame()
return Wdb#, breaks
def load_windowed_linkage(Ldb, scaffolds, window_len, mms, ANI_levels, s2l, on='r2'):
# Get the linkage table
#Ldb = IS.get('raw_linkage_table')
Ldb = Ldb[Ldb['scaffold'].isin(scaffolds)].sort_values('mm')
got_scaffolds = set(Ldb['scaffold'].unique())
# Make the windows
dbs = []
tally = 0
breaks = []
for scaffold in scaffolds:
if scaffold not in got_scaffolds:
tally += s2l[scaffold]
breaks.append(tally)
continue
else:
ldb = Ldb[Ldb['scaffold'] == scaffold]
for mm, ani in zip(mms, ANI_levels):
db = ldb[ldb['mm'] <= int(mm)].drop_duplicates(subset=['scaffold', 'position_A', 'position_B'], keep='last')
cov = db.set_index('position_A')[on].sort_index()
db = _gen_windowed_cov(cov, window_len, sLen=s2l[scaffold], full_len=False)
db['scaffold'] = scaffold
db['mm'] = mm
db['ANI'] = ani
db['adjusted_start'] = db['start'] + tally
db['adjusted_end'] = db['end'] + tally
dbs.append(db)
tally += s2l[scaffold]
breaks.append(tally)
if len(dbs) > 0:
Wdb = pd.concat(dbs)
else:
Wdb = pd.DataFrame()
return Wdb
def load_windowed_SNP_density(Ldb, scaffolds, window_len, mms, ANI_levels, s2l):
# Get the table
#Ldb = IS.get('cumulative_snv_table')
Ldb = Ldb[Ldb['scaffold'].isin(scaffolds)].sort_values('mm')
got_scaffolds = list(Ldb['scaffold'].unique())
# Make the windows
dbs = []
tally = 0
breaks = []
for scaffold in scaffolds:
if scaffold not in got_scaffolds:
tally += s2l[scaffold]
breaks.append(tally)
continue
else:
ldb = Ldb[Ldb['scaffold'] == scaffold]
for mm, ani in zip(mms, ANI_levels):
db = ldb[ldb['mm'] <= int(mm)].drop_duplicates(subset=['scaffold', 'position'], keep='last')
cov = db.set_index('position')['ref_base'].sort_index()
db = _gen_windowed_cov(cov, window_len, sLen=s2l[scaffold], full_len='count')
db['scaffold'] = scaffold
db['mm'] = mm
db['ANI'] = ani
db['adjusted_start'] = db['start'] + tally
db['adjusted_end'] = db['end'] + tally
dbs.append(db)
tally += s2l[scaffold]
breaks.append(tally)
if len(dbs) > 0:
Wdb = pd.concat(dbs)
else:
Wdb = | pd.DataFrame() | pandas.DataFrame |
#!/usr/bin/env python3
"""Re-generate exps.csv from individual experiments
"""
import argparse
import logging
from os.path import join as pjoin
from logging import debug, info
import pandas as pd
import os
def create_exps_from_folders(expsdir, dffolderspath):
files = sorted(os.listdir(expsdir))
df = pd.DataFrame()
for i, d in enumerate(files):
dpath = pjoin(expsdir, d)
if not os.path.isdir(dpath): continue
expspath = pjoin(dpath, 'config.json')
dfaux = pd.read_json(expspath)
df = | pd.concat([df, dfaux], axis=0, sort=False) | pandas.concat |
import librosa
import numpy as np
import pandas as pd
from os import listdir
from os.path import isfile, join
from audioread import NoBackendError
def extract_features(path, label, emotionId, startid):
"""
提取path目录下的音频文件的特征，使用librosa库
:param path: 文件路径
:param label: 情绪类型
:param startid: 开始的序列号
:return: 特征矩阵 pandas.DataFrame
"""
id = startid # 序列号
feature_set = pd.DataFrame() # 特征矩阵
# 单独的特征向量
labels = pd.Series()
emotion_vector = pd.Series()
songname_vector = pd.Series()
tempo_vector = pd.Series()
total_beats = pd.Series()
average_beats = pd.Series()
chroma_stft_mean = pd.Series()
# chroma_stft_std = pd.Series()
chroma_stft_var = pd.Series()
# chroma_cq_mean = pd.Series()
# chroma_cq_std = pd.Series()
# chroma_cq_var = pd.Series()
# chroma_cens_mean = pd.Series()
# chroma_cens_std = pd.Series()
# chroma_cens_var = pd.Series()
mel_mean = pd.Series()
# mel_std = pd.Series()
mel_var = | pd.Series() | pandas.Series |
"""Daylight hours from http://www.sunrisesunset.com """
import re
import datetime
import requests
from six.moves import xrange
from os.path import join, abspath, dirname
import pandas as pd
url = "http://sunrisesunset.com/calendar.asp"
r0 = re.compile("<[^>]+>| |[\r\n\t]")
r1 = re.compile(r"(\d+)(DST Begins|DST Ends)?Sunrise: (\d+):(\d\d)Sunset: (\d+):(\d\d)")
def fetch_daylight_hours(lat, lon, tz, dst, year):
"""Fetch daylight hours from sunrisesunset.com for a given location.
Parameters
----------
lat : float
Location's latitude.
lon : float
Location's longitude.
tz : int or float
Time zone offset from UTC. Use floats for half-hour time zones.
dst : int
Daylight saving type, e.g. 0 -> none, 1 -> North America, 2 -> Europe.
See sunrisesunset.com/custom.asp for other possible values.
year : int
Year (1901..2099).
"""
daylight = []
summer = 0 if lat >= 0 else 1
for month in xrange(1, 12+1):
args = dict(url=url, lat=lat, lon=lon, tz=tz, dst=dst, year=year, month=month)
response = requests.get("%(url)s?comb_city_info=_;%(lon)s;%(lat)s;%(tz)s;%(dst)s&month=%(month)s&year=%(year)s&time_type=1&wadj=1" % args)
entries = r1.findall(r0.sub("", response.text))
for day, note, sunrise_hour, sunrise_minute, sunset_hour, sunset_minute in entries:
if note == "DST Begins":
summer = 1
elif note == "DST Ends":
summer = 0
date = datetime.date(year, month, int(day))
sunrise = datetime.time(int(sunrise_hour), int(sunrise_minute))
sunset = datetime.time(int(sunset_hour), int(sunset_minute))
daylight.append([date, sunrise, sunset, summer])
return pd.DataFrame(daylight, columns=["Date", "Sunrise", "Sunset", "Summer"])
# daylight_warsaw_2013 = fetch_daylight_hours(52.2297, -21.0122, 1, 2, 2013)
# daylight_warsaw_2013.to_csv("bokeh/sampledata/daylight_warsaw_2013.csv", index=False)
def load_daylight_hours(file):
path = join(dirname(abspath(__file__)), file)
df = | pd.read_csv(path, parse_dates=["Date", "Sunrise", "Sunset"]) | pandas.read_csv |
# -*- coding: utf-8 -*-
import pytest
import numpy as np
import pandas as pd
from pandas import Timestamp
def create_dataframe(tuple_data):
"""Create pandas df from tuple data with a header."""
return pd.DataFrame.from_records(tuple_data[1:], columns=tuple_data[0])
### REUSABLE FIXTURES --------------------------------------------------------
@pytest.fixture()
def indices_3years():
"""Three indices over 3 years."""
return pd.DataFrame.from_records(
[
(Timestamp('2012-01-01 00:00:00'), 100.0, 100.0, 100.0),
(Timestamp('2012-02-01 00:00:00'), 101.239553643, 96.60525323799999, 97.776838217),
(Timestamp('2012-03-01 00:00:00'), 102.03030533, 101.450821724, 96.59101862),
(Timestamp('2012-04-01 00:00:00'), 104.432402661, 98.000263617, 94.491213369),
(Timestamp('2012-05-01 00:00:00'), 105.122830333, 95.946873831, 93.731891785),
(Timestamp('2012-06-01 00:00:00'), 103.976692567, 97.45914568100001, 90.131064035),
(Timestamp('2012-07-01 00:00:00'), 106.56768678200001, 94.788761174, 94.53487522),
(Timestamp('2012-08-01 00:00:00'), 106.652151036, 98.478217946, 92.56165627700001),
(Timestamp('2012-09-01 00:00:00'), 108.97290730799999, 99.986521241, 89.647230903),
(Timestamp('2012-10-01 00:00:00'), 106.20124385700001, 99.237117891, 92.27819603799999),
(Timestamp('2012-11-01 00:00:00'), 104.11913898700001, 100.993436318, 95.758970985),
(Timestamp('2012-12-01 00:00:00'), 107.76600978, 99.60424011299999, 95.697091336),
(Timestamp('2013-01-01 00:00:00'), 98.74350698299999, 100.357120656, 100.24073830200001),
(Timestamp('2013-02-01 00:00:00'), 100.46305431100001, 99.98213513200001, 99.499007278),
(Timestamp('2013-03-01 00:00:00'), 101.943121499, 102.034291064, 96.043392231),
(Timestamp('2013-04-01 00:00:00'), 99.358987741, 106.513055039, 97.332012817),
(Timestamp('2013-05-01 00:00:00'), 97.128074038, 106.132168479, 96.799806436),
(Timestamp('2013-06-01 00:00:00'), 94.42944162, 106.615734964, 93.72086654600001),
(Timestamp('2013-07-01 00:00:00'), 94.872365481, 103.069773446, 94.490515359),
(Timestamp('2013-08-01 00:00:00'), 98.239415397, 105.458081805, 93.57271149299999),
(Timestamp('2013-09-01 00:00:00'), 100.36774827100001, 106.144579258, 90.314524375),
(Timestamp('2013-10-01 00:00:00'), 100.660205114, 101.844838294, 88.35136848399999),
(Timestamp('2013-11-01 00:00:00'), 101.33948384799999, 100.592230114, 93.02874928899999),
(Timestamp('2013-12-01 00:00:00'), 101.74876982299999, 102.709038791, 93.38277933200001),
(Timestamp('2014-01-01 00:00:00'), 101.73439491, 99.579700011, 104.755837919),
(Timestamp('2014-02-01 00:00:00'), 100.247760523, 100.76732961, 100.197855834),
(Timestamp('2014-03-01 00:00:00'), 102.82080245600001, 99.763171909, 100.252537549),
(Timestamp('2014-04-01 00:00:00'), 104.469889684, 96.207920184, 98.719797067),
(Timestamp('2014-05-01 00:00:00'), 105.268899775, 99.357641836, 99.99786671),
(Timestamp('2014-06-01 00:00:00'), 107.41649204299999, 100.844974811, 96.463821506),
(Timestamp('2014-07-01 00:00:00'), 110.146087435, 102.01075029799999, 94.332755083),
(Timestamp('2014-08-01 00:00:00'), 109.17068484100001, 101.562418115, 91.15410351700001),
(Timestamp('2014-09-01 00:00:00'), 109.872892919, 101.471759564, 90.502291475),
(Timestamp('2014-10-01 00:00:00'), 108.508436998, 98.801947543, 93.97423224399999),
(Timestamp('2014-11-01 00:00:00'), 109.91248118, 97.730489099, 90.50638234200001),
(Timestamp('2014-12-01 00:00:00'), 111.19756703600001, 99.734704555, 90.470418612),
],
).set_index(0, drop=True)
@pytest.fixture()
def weights_3years():
return pd.DataFrame.from_records(
[
(Timestamp('2012-01-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2013-01-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2014-01-01 00:00:00'), 6.23115844, 2.361303832, 3.5764532489999996),
],
).set_index(0, drop=True)
@pytest.fixture()
def weights_3years_start_feb(weights_3years):
return weights_3years.shift(1, freq='MS')
@pytest.fixture()
def weight_shares_3years():
return pd.DataFrame.from_records(
[
(Timestamp('2012-01-01 00:00:00'), 0.489537029, 0.21362007800000002, 0.29684289199999997),
(Timestamp('2013-01-01 00:00:00'), 0.535477885, 0.147572705, 0.31694941),
(Timestamp('2014-01-01 00:00:00'), 0.512055362, 0.1940439, 0.293900738),
],
).set_index(0, drop=True)
@pytest.fixture()
def weights_shares_start_feb(weight_shares_3years):
return weight_shares_3years.shift(1, freq='MS')
@pytest.fixture()
def indices_1year(indices_3years):
return indices_3years.loc['2012', :]
@pytest.fixture()
def weights_1year(weights_3years):
return weights_3years.loc['2012', :]
@pytest.fixture()
def indices_6months(indices_3years):
return indices_3years.loc['2012-Jan':'2012-Jun', :]
@pytest.fixture()
def weights_6months(weights_3years):
return weights_3years.loc['2012', :]
@pytest.fixture()
def indices_transposed(indices_3years):
return indices_3years.T
@pytest.fixture()
def weights_transposed(weights_3years):
return weights_3years.T
@pytest.fixture()
def indices_missing(indices_3years):
indices_missing = indices_3years.copy()
change_to_nans = [
('2012-06', 2),
('2012-12', 3),
('2013-10', 2),
('2014-07', 1),
]
for sl in change_to_nans:
indices_missing.loc[sl] = np.nan
return indices_missing
@pytest.fixture()
def indices_missing_transposed(indices_missing):
return indices_missing.T
### AGGREGATION FIXTURES -----------------------------------------------------
@pytest.fixture()
def aggregate_outcome_3years():
return pd.DataFrame.from_records(
[
(Timestamp('2012-01-01 00:00:00'), 100.0),
(Timestamp('2012-02-01 00:00:00'), 99.22169156),
(Timestamp('2012-03-01 00:00:00'), 100.29190240000001),
(Timestamp('2012-04-01 00:00:00'), 100.10739720000001),
(Timestamp('2012-05-01 00:00:00'), 99.78134264),
(Timestamp('2012-06-01 00:00:00'), 98.47443727),
(Timestamp('2012-07-01 00:00:00'), 100.4796172),
(Timestamp('2012-08-01 00:00:00'), 100.7233716),
(Timestamp('2012-09-01 00:00:00'), 101.31654509999998),
(Timestamp('2012-10-01 00:00:00'), 100.5806089),
(Timestamp('2012-11-01 00:00:00'), 100.9697697),
(Timestamp('2012-12-01 00:00:00'), 102.4399192),
(Timestamp('2013-01-01 00:00:00'), 99.45617890000001),
(Timestamp('2013-02-01 00:00:00'), 100.08652959999999),
(Timestamp('2013-03-01 00:00:00'), 100.0866599),
(Timestamp('2013-04-01 00:00:00'), 99.7722843),
(Timestamp('2013-05-01 00:00:00'), 98.35278839),
(Timestamp('2013-06-01 00:00:00'), 96.00322344),
(Timestamp('2013-07-01 00:00:00'), 95.96105198),
(Timestamp('2013-08-01 00:00:00'), 97.82558448),
(Timestamp('2013-09-01 00:00:00'), 98.03388747),
(Timestamp('2013-10-01 00:00:00'), 96.93374613),
(Timestamp('2013-11-01 00:00:00'), 98.59512718),
(Timestamp('2013-12-01 00:00:00'), 99.23888357),
(Timestamp('2014-01-01 00:00:00'), 102.2042938),
(Timestamp('2014-02-01 00:00:00'), 100.3339127),
(Timestamp('2014-03-01 00:00:00'), 101.4726729),
(Timestamp('2014-04-01 00:00:00'), 101.17674840000001),
(Timestamp('2014-05-01 00:00:00'), 102.57269570000001),
(Timestamp('2014-06-01 00:00:00'), 102.9223313),
(Timestamp('2014-07-01 00:00:00'), 103.9199248),
(Timestamp('2014-08-01 00:00:00'), 102.3992605),
(Timestamp('2014-09-01 00:00:00'), 102.54967020000001),
(Timestamp('2014-10-01 00:00:00'), 102.35333840000001),
(Timestamp('2014-11-01 00:00:00'), 101.8451732),
(Timestamp('2014-12-01 00:00:00'), 102.8815443),
],
).set_index(0, drop=True).squeeze()
@pytest.fixture()
def aggregate_outcome_1year(aggregate_outcome_3years):
return aggregate_outcome_3years.loc['2012']
@pytest.fixture()
def aggregate_outcome_6months(aggregate_outcome_3years):
return aggregate_outcome_3years.loc['2012-Jan':'2012-Jun']
@pytest.fixture()
def aggregate_outcome_missing():
return pd.DataFrame.from_records(
[
(Timestamp('2012-01-01 00:00:00'), 100.0),
(Timestamp('2012-02-01 00:00:00'), 99.22169156),
(Timestamp('2012-03-01 00:00:00'), 100.29190240000001),
(Timestamp('2012-04-01 00:00:00'), 100.10739720000001),
(Timestamp('2012-05-01 00:00:00'), 99.78134264),
(Timestamp('2012-06-01 00:00:00'), 98.75024119),
(Timestamp('2012-07-01 00:00:00'), 100.4796172),
(Timestamp('2012-08-01 00:00:00'), 100.7233716),
(Timestamp('2012-09-01 00:00:00'), 101.31654509999998),
(Timestamp('2012-10-01 00:00:00'), 100.5806089),
(Timestamp('2012-11-01 00:00:00'), 100.9697697),
(Timestamp('2012-12-01 00:00:00'), 105.2864531),
(Timestamp('2013-01-01 00:00:00'), 99.45617890000001),
(Timestamp('2013-02-01 00:00:00'), 100.08652959999999),
(Timestamp('2013-03-01 00:00:00'), 100.0866599),
(Timestamp('2013-04-01 00:00:00'), 99.7722843),
(Timestamp('2013-05-01 00:00:00'), 98.35278839),
(Timestamp('2013-06-01 00:00:00'), 96.00322344),
(Timestamp('2013-07-01 00:00:00'), 95.96105198),
(Timestamp('2013-08-01 00:00:00'), 97.82558448),
(Timestamp('2013-09-01 00:00:00'), 98.03388747),
(Timestamp('2013-10-01 00:00:00'), 96.08353503),
(Timestamp('2013-11-01 00:00:00'), 98.59512718),
(Timestamp('2013-12-01 00:00:00'), 99.23888357),
(Timestamp('2014-01-01 00:00:00'), 102.2042938),
(Timestamp('2014-02-01 00:00:00'), 100.3339127),
(Timestamp('2014-03-01 00:00:00'), 101.4726729),
(Timestamp('2014-04-01 00:00:00'), 101.17674840000001),
(Timestamp('2014-05-01 00:00:00'), 102.57269570000001),
(Timestamp('2014-06-01 00:00:00'), 102.9223313),
(Timestamp('2014-07-01 00:00:00'), 97.38610996),
(Timestamp('2014-08-01 00:00:00'), 102.3992605),
(Timestamp('2014-09-01 00:00:00'), 102.54967020000001),
(Timestamp('2014-10-01 00:00:00'), 102.35333840000001),
(Timestamp('2014-11-01 00:00:00'), 101.8451732),
(Timestamp('2014-12-01 00:00:00'), 102.8815443),
],
).set_index(0, drop=True).squeeze()
### WEIGHTS FIXTURES ------------------------------------------------------
@pytest.fixture()
def reindex_weights_to_indices_outcome_start_jan():
return pd.DataFrame.from_records(
[
(Timestamp('2012-01-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-02-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-03-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-04-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-05-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-06-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-07-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-08-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-09-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-10-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-11-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-12-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2013-01-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-02-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-03-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-04-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-05-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-06-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-07-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-08-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-09-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-10-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-11-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-12-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2014-01-01 00:00:00'), 6.23115844, 2.361303832, 3.5764532489999996),
(Timestamp('2014-02-01 00:00:00'), 6.23115844, 2.361303832, 3.5764532489999996),
(Timestamp('2014-03-01 00:00:00'), 6.23115844, 2.361303832, 3.5764532489999996),
(Timestamp('2014-04-01 00:00:00'), 6.23115844, 2.361303832, 3.5764532489999996),
(Timestamp('2014-05-01 00:00:00'), 6.23115844, 2.361303832, 3.5764532489999996),
(Timestamp('2014-06-01 00:00:00'), 6.23115844, 2.361303832, 3.5764532489999996),
(Timestamp('2014-07-01 00:00:00'), 6.23115844, 2.361303832, 3.5764532489999996),
(Timestamp('2014-08-01 00:00:00'), 6.23115844, 2.361303832, 3.5764532489999996),
(Timestamp('2014-09-01 00:00:00'), 6.23115844, 2.361303832, 3.5764532489999996),
(Timestamp('2014-10-01 00:00:00'), 6.23115844, 2.361303832, 3.5764532489999996),
(Timestamp('2014-11-01 00:00:00'), 6.23115844, 2.361303832, 3.5764532489999996),
(Timestamp('2014-12-01 00:00:00'), 6.23115844, 2.361303832, 3.5764532489999996),
],
).set_index(0, drop=True)
@pytest.fixture()
def reindex_weights_to_indices_outcome_start_feb():
return pd.DataFrame.from_records(
[
(Timestamp('2012-01-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-02-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-03-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-04-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-05-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-06-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-07-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-08-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-09-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-10-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-11-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2012-12-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2013-01-01 00:00:00'), 5.1869643839999995, 2.263444179, 3.145244219),
(Timestamp('2013-02-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-03-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-04-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-05-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-06-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-07-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-08-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-09-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-10-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
(Timestamp('2013-11-01 00:00:00'), 6.74500585, 1.8588606330000002, 3.992369584),
( | Timestamp('2013-12-01 00:00:00') | pandas.Timestamp |
'''
Created on Apr 23, 2018
@author: nishant.sethi
'''
import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.simplefilter(action = "ignore", category = FutureWarning)
'''load the matches file'''
matches = pd.read_csv('matches.csv')
matches["type"] = "pre-qualifier"
for year in range(2008, 2017):
final_match_index = matches[matches['season']==year][-1:].index.values[0]
matches = matches.set_value(final_match_index, "type", "final")
matches = matches.set_value(final_match_index-1, "type", "qualifier-2")
matches = matches.set_value(final_match_index-2, "type", "eliminator")
matches = matches.set_value(final_match_index-3, "type", "qualifier-1")
matches.groupby(["type"])["id"].count()
'''load the deliveries file'''
deliveries= | pd.read_csv('deliveries.csv') | pandas.read_csv |
'''
@Author: <NAME>
@Date: 2019-07-03 16:18:27
@LastEditors: Yudi
@LastEditTime: 2019-07-19 15:40:23
@Company: Cardinal Operation
@Email: <EMAIL>
@Description:
'''
import pickle
import gzip
import os
import gc
import time
import random
from itertools import chain
import numpy as np
import pandas as pd
import scipy.sparse as sparse
def parse(path):
g = gzip.open(path, 'rb')
for e in g:
yield eval(e)
def load_json_gz(path):
i = 0
df = {}
for d in parse(path):
df[i] = d
i += 1
return pd.DataFrame.from_dict(df, orient='index')
def load_init_influence(cat='yelp'):
wei_u = pickle.load(open(f'./data/experiment_result/influence_dict/{cat}/uid_influence_dict.pkl', 'rb'))
wei_i = pickle.load(open(f'./data/experiment_result/influence_dict/{cat}/iid_influence_dict.pkl', 'rb'))
return wei_u, wei_i
def load_weight(cat='yelp'):
p = f'./data/experiment_result/weight/{cat}/'
dec_i_wei = pickle.load(open(p + 'dec_i_wei.pkl', 'rb'))
dec_u_wei = pickle.load(open(p + 'dec_u_wei.pkl', 'rb'))
inc_i_wei = pickle.load(open(p + 'inc_i_wei.pkl', 'rb'))
inc_u_wei = pickle.load(open(p + 'inc_u_wei.pkl', 'rb'))
return inc_u_wei, inc_i_wei, dec_u_wei, dec_i_wei
def load_rid2id_ref(cat='yelp'):
p = f'./data/experiment_result/init_vec/{cat}/'
rid2id_u = pickle.load(open(p + 'rid2id_u.pkl', 'rb'))
rid2id_i = pickle.load(open(p + 'rid2id_i.pkl', 'rb'))
return rid2id_u, rid2id_i
def load_rate(cat_name, sample_num=None, sample_target='item'):
assert cat_name in ['yelp', 'amazon'], 'invalid dataset selected, try "yelp", "ml"'
assert sample_target in ['user', 'item', 'all'], 'sample_target must be set "user", "item" or "all"'
if sample_target == 'item' or sample_target == 'user':
assert type(sample_num) is int, 'sample number for full data set must be integer......'
else:
assert type(sample_num) is int or type(sample_num) is float, 'sample number for full data set must be integer or float value in [0, 1]......'
if cat_name == 'yelp':
p = './data/raw_data/yelp_academic_dataset_review.csv' # from business.json
assert os.path.isfile(p), f'No such file {p}, please check again......'
df = pd.read_csv(p)
df.rename(index=str, columns={'user_id': 'user',
'business_id': 'item',
'stars': 'rating',
'date':'timestamp'}, inplace=True)
df['timestamp'] = df.timestamp.agg(lambda x: time.mktime(time.strptime(x,'%Y-%m-%d'))).astype(int)
df = df[['user', 'item', 'rating', 'timestamp']]
max_u_num, max_i_num = df.user.unique().size, df.item.unique().size
if sample_num is not None:
if sample_target == 'item':
sample_num = min(sample_num, max_i_num)
sub_item_set = random.sample(df.item.unique().tolist(), sample_num)
df = df[df.item.isin(sub_item_set)].sort_values(['user', 'item', 'timestamp']).reset_index(drop=True)
elif sample_target == 'user':
sample_num = min(sample_num, max_u_num)
sub_user_set = random.sample(df.user.unique().tolist(), sample_num)
df = df[df.user.isin(sub_user_set)].sort_values(['user', 'item', 'timestamp']).reset_index(drop=True)
else:
if type(sample_num) is float:
df = df.sample(frac=sample_num, random_state=2019).reset_index(drop=True)
elif type(sample_num) is int:
df = df.sample(n=sample_num, random_state=2019).reset_index(drop=True)
df.to_csv('./data/processed_data/yelp_exp_uir_data.csv', index=False)
return df
elif cat_name == 'amazon':
p = './data/raw_data/ratings_Digital_Music.csv'
assert os.path.exists(p), f'No such file {p}, please check again......'
df = | pd.read_csv(p, names=['user', 'item', 'rating', 'timestamp']) | pandas.read_csv |
import matplotlib.pylab as pylab
import math as m
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import pdb
from pylab import rcParams
import matplotlib as mpl
mpl.use('AGG')
font = {'size': 40}
rcParams['figure.figsize'] = 10, 8
mpl.style.use('seaborn-paper')
rcParams['figure.figsize'] = 10, 8
# rcParams['savefig.pad_inches'] = 0.5
rcParams['figure.constrained_layout.use'] = True
mpl.rcParams['font.size'] = 15.0
params = {'legend.fontsize': 'x-large',
'axes.labelsize': 'x-large',
'axes.titlesize': 'x-large',
'xtick.labelsize': 'x-large',
'ytick.labelsize': 'x-large'}
pylab.rcParams.update(params)
labelmap = {
'pcc': 'PCC',
'bbr': 'BBR',
'cubic': 'Cubic',
'hybla': 'Hybla'
}
colormap = {
'pcc': 'firebrick',
'bbr': 'olivedrab',
'cubic': 'teal',
'hybla': 'darkorchid'
}
# DATA_DIR = './data/2020-05-09/'
# DATA_DIR = './data/2020-06-01/'
# DATA_DIR = './data/2020-07-12/'
DATA_DIR = './data/2020-09-20'
global PREFIX
PREFIX = ""
def plot_rtt_cdf(df, column='mean'):
plt.close()
for protocol, data in df.groupby('protocol'):
sorted_rtt = data[column].sort_values().reset_index()
plt.plot(sorted_rtt[column], sorted_rtt.index /
sorted_rtt[column].count() * 100, label=labelmap[protocol], color=colormap[protocol])
plt.legend()
plt.ylabel("Cumulative Distribution\n(percent)")
plt.xlabel(f"RTT (ms)")
plt.savefig(f"{DATA_DIR}/{PREFIX}cdf_rtt_{column}.png")
def plot_loss_cdf(df):
column = 'loss'
plt.close()
print(df.head())
for protocol, data in df.groupby('protocol'):
data = data[data['loss'] < 0.95]
sorted_loss = data[column].sort_values().reset_index()
plt.plot(sorted_loss[column] * 100, sorted_loss.index /
sorted_loss[column].count() * 100, label=labelmap[protocol], color=colormap[protocol])
plt.legend()
plt.ylabel("Cumulative Distribution\n(percent)")
plt.xlabel(f"Retranmission\n(percent)")
plt.savefig(f"{DATA_DIR}/{PREFIX}cdf_{column}.png")
def plot_througput_cdf(df, column='mean'):
plt.close()
for protocol, data in df.groupby('protocol'):
sorted_throughput = data[column].sort_values().reset_index()
plt.plot(sorted_throughput[column], sorted_throughput.index /
sorted_throughput[column].count() * 100, label=labelmap[protocol], color=colormap[protocol])
plt.legend()
plt.ylabel("Percent")
plt.xlabel(f"{column} throughput")
plt.savefig(f"{DATA_DIR}/{PREFIX}cdf_{column}.png")
def summary_statistics(prefix=PREFIX):
global PREFIX
fname = f"{DATA_DIR}/{prefix}quantiles.csv"
print(f"summary of {fname}")
df = pd.read_csv(fname, index_col=0).dropna(how='all')
mean = df.groupby('protocol').mean()['mean']
std = df.groupby('protocol').std()['mean']
print(f'{prefix} mean throughput', mean)
print(f'{prefix} std throughput', std)
with open('out.txt', 'w') as output_file:
print(df.groupby('protocol').describe(), file=output_file)
fname = f"{DATA_DIR}/{prefix}rtt_quantiles.csv"
df = | pd.read_csv(fname, index_col=0) | pandas.read_csv |
"""Network representation and utilities
<NAME>, <NAME> & <NAME>
"""
import os,sys
import re
import numpy as np
import pandas as pd
import geopandas as gpd
import pygeos
import pygeos.geometry as pygeom
import contextily as ctx
from rasterstats import zonal_stats
import pyproj
import pylab as pl
from IPython import display
import seaborn as sns
import subprocess
from shapely.wkb import loads
import time
from timeit import default_timer as timer
import feather
import igraph as ig
from pandas import DataFrame
from shapely.geometry import Point, MultiPoint, LineString, GeometryCollection, shape, mapping
from shapely.ops import split, linemerge
from tqdm import tqdm
from pathlib import Path
# path to python scripts
sys.path.append(os.path.join('..','src','trails'))
from flow_model import *
from simplify import *
from extract import railway,ferries,mainRoads,roads
import pathlib
pd.options.mode.chained_assignment = None
#data_path = os.path.join('..','data')
data_path = (Path(__file__).parent.absolute().parent.absolute().parent.absolute())
data_path = Path(r'C:/data/')
road_types = ['primary','trunk','motorway','motorway_link','trunk_link','primary_link','secondary','secondary_link','tertiary','tertiary_link']
# optional progress bars
'''
if 'SNKIT_PROGRESS' in os.environ and os.environ['SNKIT_PROGRESS'] in ('1', 'TRUE'):
try:
from tqdm import tqdm
except ImportError:
from snkit.utils import tqdm_standin as tqdm
else:
from snkit.utils import tqdm_standin as tqdm
'''
class Network():
"""A Network is composed of nodes (points in space) and edges (lines)
Parameters
----------
nodes : pandas.DataFrame, optional
edges : pandas.DataFrame, optional
Attributes
----------
nodes : pandas.DataFrame
edges : pandas.DataFrame
"""
def __init__(self, nodes=None, edges=None):
"""
"""
if nodes is None:
nodes = pd.DataFrame()
self.nodes = nodes
if edges is None:
edges = pd.DataFrame()
self.edges = edges
def set_crs(self, crs=None, epsg=None):
"""Set network (node and edge) crs
Parameters
----------
crs : dict or str
Projection parameters as PROJ4 string or in dictionary form.
epsg : int
EPSG code specifying output projection
"""
if crs is None and epsg is None:
raise ValueError("Either crs or epsg must be provided to Network.set_crs")
if epsg is not None:
crs = {'init': 'epsg:{}'.format(epsg)}
self.edges = pygeos.geometry.set_srid(point, epsg)
self.nodes = pygeos.geometry.set_srid(point, epsg)
def to_crs(self, crs=None, epsg=None):
"""Set network (node and edge) crs
Parameters
----------
crs : dict or str
Projection parameters as PROJ4 string or in dictionary form.
epsg : int
EPSG code specifying output projection
"""
if crs is None and epsg is None:
raise ValueError("Either crs or epsg must be provided to Network.set_crs")
if epsg is not None:
crs = {'init': 'epsg:{}'.format(epsg)}
self.edges.to_crs(crs, inplace=True)
self.nodes.to_crs(crs, inplace=True)
def add_ids(network, id_col='id', edge_prefix='', node_prefix=''):
"""Add or replace an id column with ascending ids
The ids are represented into int64s for easier conversion to numpy arrays
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
id_col (str, optional): [description]. Defaults to 'id'.
edge_prefix (str, optional): [description]. Defaults to ''.
node_prefix (str, optional): [description]. Defaults to ''.
Returns:
[type]: [description]
"""
nodes = network.nodes.copy()
if not nodes.empty:
nodes = nodes.reset_index(drop=True)
edges = network.edges.copy()
if not edges.empty:
edges = edges.reset_index(drop=True)
nodes[id_col] = range(len(nodes))
edges[id_col] = range(len(edges))
return Network(
nodes=nodes,
edges=edges
)
def add_topology(network, id_col='id'):
"""Add or replace from_id, to_id to edges
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
id_col (str, optional): [description]. Defaults to 'id'.
Returns:
network (class): A network composed of nodes (points in space) and edges (lines)
"""
from_ids = []
to_ids = []
node_ends = []
bugs = []
sindex = pygeos.STRtree(network.nodes.geometry)
for edge in tqdm(network.edges.itertuples(), desc="topology", total=len(network.edges)):
start, end = line_endpoints(edge.geometry)
try:
start_node = nearest_node(start, network.nodes,sindex)
from_ids.append(start_node[id_col])
except:
bugs.append(edge.id)
from_ids.append(-1)
try:
end_node = nearest_node(end, network.nodes,sindex)
to_ids.append(end_node[id_col])
except:
bugs.append(edge.id)
to_ids.append(-1)
#print(len(bugs)," Edges not connected to nodes")
edges = network.edges.copy()
nodes = network.nodes.copy()
edges['from_id'] = from_ids
edges['to_id'] = to_ids
edges = edges.loc[~(edges.id.isin(list(bugs)))].reset_index(drop=True)
return Network(
nodes=network.nodes,
edges=edges
)
def get_endpoints(network):
"""Get nodes for each edge endpoint
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
Returns:
[type]: [description]
"""
endpoints = []
for edge in tqdm(network.edges.itertuples(), desc="endpoints", total=len(network.edges)):
if edge.geometry is None:
continue
# 5 is MULTILINESTRING
if pygeom.get_type_id(edge.geometry) == '5':
for line in edge.geometry.geoms:
start, end = line_endpoints(line)
endpoints.append(start)
endpoints.append(end)
else:
start, end = line_endpoints(edge.geometry)
endpoints.append(start)
endpoints.append(end)
# create dataframe to match the nodes geometry column name
return matching_df_from_geoms(network.nodes, endpoints)
def add_endpoints(network):
"""Add nodes at line endpoints
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
Returns:
network (class): A network composed of nodes (points in space) and edges (lines)
"""
endpoints = get_endpoints(network)
nodes = concat_dedup([network.nodes, endpoints])
return Network(
nodes=nodes,
edges=network.edges
)
def round_geometries(network, precision=3):
"""Round coordinates of all node points and vertices of edge linestrings to some precision
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
precision (int, optional): [description]. Defaults to 3.
Returns:
network (class): A network composed of nodes (points in space) and edges (lines)
"""
def _set_precision(geom):
return set_precision(geom, precision)
network.nodes.geometry = network.nodes.geometry.apply(_set_precision)
network.edges.geometry = network.edges.geometry.apply(_set_precision)
return network
def split_multilinestrings(network):
"""Create multiple edges from any MultiLineString edge
Ensures that edge geometries are all LineStrings, duplicates attributes over any
created multi-edges.
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
Returns:
network (class): A network composed of nodes (points in space) and edges (lines)
"""
simple_edge_attrs = []
simple_edge_geoms = []
edges = network.edges
for edge in tqdm(edges.itertuples(index=False), desc="split_multi", total=len(edges)):
if pygeom.get_type_id(edge.geometry) == 5:
edge_parts = [x for x in pygeos.geometry.get_geometry(edge, pygeos.geometry.get_num_geometries(edge))]
else:
edge_parts = [edge.geometry]
for part in edge_parts:
simple_edge_geoms.append(part)
attrs = DataFrame([edge] * len(edge_parts))
simple_edge_attrs.append(attrs)
simple_edge_geoms = DataFrame(simple_edge_geoms, columns=['geometry'])
edges = pd.concat(simple_edge_attrs, axis=0).reset_index(drop=True).drop('geometry', axis=1)
edges = pd.concat([edges, simple_edge_geoms], axis=1)
return Network(
nodes=network.nodes,
edges=edges
)
def merge_multilinestrings(network):
"""Try to merge all multilinestring geometries into linestring geometries.
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
Returns:
network (class): A network composed of nodes (points in space) and edges (lines)
"""
edges = network.edges.copy()
edges['geometry']= edges.geometry.apply(lambda x: merge_multilinestring(x))
return Network(edges=edges,
nodes=network.nodes)
def merge_multilinestring(geom):
"""Merge a MultiLineString to LineString
Args:
geom (pygeos.geometry): A pygeos geometry, most likely a linestring or a multilinestring
Returns:
geom (pygeos.geometry): A pygeos linestring geometry if merge was succesful. If not, it returns the input.
"""
if pygeom.get_type_id(geom) == '5':
geom_inb = pygeos.line_merge(geom)
if geom_inb.is_ring: # still something to fix if desired
return geom_inb
else:
return geom_inb
else:
return geom
def snap_nodes(network, threshold=None):
"""Move nodes (within threshold) to edges
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
threshold ([type], optional): [description]. Defaults to None.
Returns:
[type]: [description]
"""
def snap_node(node):
snap = nearest_point_on_edges(node.geometry, network.edges)
distance = snap.distance(node.geometry)
if threshold is not None and distance > threshold:
snap = node.geometry
return snap
snapped_geoms = network.nodes.apply(snap_node, axis=1)
geom_col = geometry_column_name(network.nodes)
nodes = pd.concat([
network.nodes.drop(geom_col, axis=1),
DataFrame(snapped_geoms, columns=[geom_col])
], axis=1)
return Network(
nodes=nodes,
edges=network.edges
)
def link_nodes_to_edges_within(network, distance, condition=None, tolerance=1e-9):
"""Link nodes to all edges within some distance
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
distance ([type]): [description]
condition ([type], optional): [description]. Defaults to None.
tolerance ([type], optional): [description]. Defaults to 1e-9.
Returns:
[type]: [description]
"""
new_node_geoms = []
new_edge_geoms = []
for node in tqdm(network.nodes.itertuples(index=False), desc="link", total=len(network.nodes)):
# for each node, find edges within
edges = edges_within(node.geometry, network.edges, distance)
for edge in edges.itertuples():
if condition is not None and not condition(node, edge):
continue
# add nodes at points-nearest
point = nearest_point_on_line(node.geometry, edge.geometry)
if point != node.geometry:
new_node_geoms.append(point)
# add edges linking
line = LineString([node.geometry, point])
new_edge_geoms.append(line)
new_nodes = matching_df_from_geoms(network.nodes, new_node_geoms)
all_nodes = concat_dedup([network.nodes, new_nodes])
new_edges = matching_df_from_geoms(network.edges, new_edge_geoms)
all_edges = concat_dedup([network.edges, new_edges])
# split edges as necessary after new node creation
unsplit = Network(
nodes=all_nodes,
edges=all_edges
)
return split_edges_at_nodes(unsplit, tolerance)
def link_nodes_to_nearest_edge(network, condition=None):
"""Link nodes to all edges within some distance
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
condition ([type], optional): [description]. Defaults to None.
Returns:
[type]: [description]
"""
new_node_geoms = []
new_edge_geoms = []
for node in tqdm(network.nodes.itertuples(index=False), desc="link", total=len(network.nodes)):
# for each node, find edges within
edge = nearest_edge(node.geometry, network.edges)
if condition is not None and not condition(node, edge):
continue
# add nodes at points-nearest
point = nearest_point_on_line(node.geometry, edge.geometry)
if point != node.geometry:
new_node_geoms.append(point)
# add edges linking
line = LineString([node.geometry, point])
new_edge_geoms.append(line)
new_nodes = matching_df_from_geoms(network.nodes, new_node_geoms)
all_nodes = concat_dedup([network.nodes, new_nodes])
new_edges = matching_df_from_geoms(network.edges, new_edge_geoms)
all_edges = concat_dedup([network.edges, new_edges])
# split edges as necessary after new node creation
unsplit = Network(
nodes=all_nodes,
edges=all_edges
)
return split_edges_at_nodes(unsplit)
def find_roundabouts(network):
"""Methods to find roundabouts
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
Returns:
roundabouts (list): Returns the edges that can be identified as roundabouts
"""
roundabouts = []
for edge in network.edges.itertuples():
if pygeos.predicates.is_ring(edge.geometry): roundabouts.append(edge)
return roundabouts
def clean_roundabouts(network):
"""Methods to clean roundabouts and junctions should be done before
splitting edges at nodes to avoid logic conflicts
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
Returns:
network (class): A network composed of nodes (points in space) and edges (lines)
"""
sindex = pygeos.STRtree(network.edges['geometry'])
edges = network.edges
new_geom = network.edges
new_edge = []
remove_edge=[]
new_edge_id = []
attributes = [x for x in network.edges.columns if x not in ['geometry','osm_id']]
roundabouts = find_roundabouts(network)
testy = []
for roundabout in roundabouts:
round_bound = pygeos.constructive.boundary(roundabout.geometry)
round_centroid = pygeos.constructive.centroid(roundabout.geometry)
remove_edge.append(roundabout.Index)
edges_intersect = _intersects(roundabout.geometry, network.edges['geometry'], sindex)
#Drop the roundabout from series so that no snapping happens on it
edges_intersect.drop(roundabout.Index,inplace=True)
#index at e[0] geometry at e[1] of edges that intersect with
for e in edges_intersect.items():
edge = edges.iloc[e[0]]
start = pygeom.get_point(e[1],0)
end = pygeom.get_point(e[1],-1)
first_co_is_closer = pygeos.measurement.distance(end, round_centroid) > pygeos.measurement.distance(start, round_centroid)
co_ords = pygeos.coordinates.get_coordinates(edge.geometry)
centroid_co = pygeos.coordinates.get_coordinates(round_centroid)
if first_co_is_closer:
new_co = np.concatenate((centroid_co,co_ords))
else:
new_co = np.concatenate((co_ords,centroid_co))
snap_line = pygeos.linestrings(new_co)
snap_line = pygeos.linestrings(new_co)
#an edge should never connect to more than 2 roundabouts, if it does this will break
if edge.osm_id in new_edge_id:
a = []
counter = 0
for x in new_edge:
if x[0]==edge.osm_id:
a = counter
break
counter += 1
double_edge = new_edge.pop(a)
start = pygeom.get_point(double_edge[-1],0)
end = pygeom.get_point(double_edge[-1],-1)
first_co_is_closer = pygeos.measurement.distance(end, round_centroid) > pygeos.measurement.distance(start, round_centroid)
co_ords = pygeos.coordinates.get_coordinates(double_edge[-1])
if first_co_is_closer:
new_co = np.concatenate((centroid_co,co_ords))
else:
new_co = np.concatenate((co_ords,centroid_co))
snap_line = pygeos.linestrings(new_co)
new_edge.append([edge.osm_id]+list(edge[list(attributes)])+[snap_line])
else:
new_edge.append([edge.osm_id]+list(edge[list(attributes)])+[snap_line])
new_edge_id.append(edge.osm_id)
remove_edge.append(e[0])
new = pd.DataFrame(new_edge,columns=['osm_id']+attributes+['geometry'])
dg = network.edges.loc[~network.edges.index.isin(remove_edge)]
ges = pd.concat([dg,new]).reset_index(drop=True)
return Network(edges=ges, nodes=network.nodes)
def find_hanging_nodes(network):
"""Simply returns a dataframe of nodes with degree 1, technically not all of
these are "hanging"
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
Returns:
[type]: [description]
"""
hang_index = np.where(network.nodes['degree']==1)
return network.nodes.iloc[hang_index]
def add_distances(network):
"""This method adds a distance column using pygeos (converted from shapely)
assuming the new crs from the latitude and longitude of the first node
distance is in metres
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
Returns:
network (class): A network composed of nodes (points in space) and edges (lines)
"""
#Find crs of current df and arbitrary point(lat,lon) for new crs
current_crs="epsg:4326"
#The commented out crs does not work in all cases
#current_crs = [*network.edges.crs.values()]
#current_crs = str(current_crs[0])
lat = pygeom.get_y(network.nodes['geometry'].iloc[0])
lon = pygeom.get_x(network.nodes['geometry'].iloc[0])
# formula below based on :https://gis.stackexchange.com/a/190209/80697
approximate_crs = "epsg:" + str(int(32700-np.round((45+lat)/90,0)*100+np.round((183+lon)/6,0)))
#from pygeos/issues/95
geometries = network.edges['geometry']
coords = pygeos.get_coordinates(geometries)
transformer=pyproj.Transformer.from_crs(current_crs, approximate_crs,always_xy=True)
new_coords = transformer.transform(coords[:, 0], coords[:, 1])
result = pygeos.set_coordinates(geometries.copy(), np.array(new_coords).T)
dist = pygeos.length(result)
edges = network.edges.copy()
edges['distance'] = dist
return Network(
nodes=network.nodes,
edges=edges)
def add_travel_time(network):
"""Add travel time column to network edges. Time is in hours
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
Returns:
network (class): A network composed of nodes (points in space) and edges (lines)
"""
if 'distance' not in network.nodes.columns:
network = add_distances(network)
speed_d = {
'motorway':80000,
'motorway_link': 65000,
'trunk': 60000,
'trunk_link':50000,
'primary': 50000, # metres ph
'primary_link':40000,
'secondary': 40000, # metres ph
'secondary_link':30000,
'tertiary':30000,
'tertiary_link': 20000,
'unclassified':20000,
'service':20000,
'residential': 20000, # mph
}
def calculate_time(edge):
try:
return edge['distance'] / (edge['maxspeed']*1000) #metres per hour
except:
return edge['distance'] / speed_d.get('unclassified')
network.edges['time'] = network.edges.apply(calculate_time,axis=1)
return network
def calculate_degree(network):
"""Calculates the degree of the nodes from the from and to ids. It
is not wise to call this method after removing nodes or edges
without first resetting the ids
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
Returns:
Connectivity degree (numpy.array): [description]
"""
#the number of nodes(from index) to use as the number of bins
ndC = len(network.nodes.index)
if ndC-1 > max(network.edges.from_id) and ndC-1 > max(network.edges.to_id): print("Calculate_degree possibly unhappy")
return np.bincount(network.edges['from_id'],None,ndC) + np.bincount(network.edges['to_id'],None,ndC)
#Adds a degree column to the node dataframe
def add_degree(network):
"""[summary]
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
Returns:
network (class): A network composed of nodes (points in space) and edges (lines)
"""
degree = calculate_degree(network)
network.nodes['degree'] = degree
return network
def drop_hanging_nodes(network, tolerance = 0.005):
"""This method drops any single degree nodes and their associated edges given a
distance(degrees) threshold. This primarily happens when a road was connected to residential
areas, most often these are link roads that no longer do so.
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
tolerance (float, optional): The maximum allowed distance from hanging nodes to the network. Defaults to 0.005.
Returns:
network (class): A network composed of nodes (points in space) and edges (lines)
"""
if 'degree' not in network.nodes.columns:
deg = calculate_degree(network)
else: deg = network.nodes['degree'].to_numpy()
#hangNodes : An array of the indices of nodes with degree 1
hangNodes = np.where(deg==1)
ed = network.edges.copy()
to_ids = ed['to_id'].to_numpy()
from_ids = ed['from_id'].to_numpy()
hangTo = np.isin(to_ids,hangNodes)
hangFrom = np.isin(from_ids,hangNodes)
#eInd : An array containing the indices of edges that connect
#the degree 1 nodes
eInd = np.hstack((np.nonzero(hangTo),np.nonzero(hangFrom)))
degEd = ed.iloc[np.sort(eInd[0])]
edge_id_drop = []
for d in degEd.itertuples():
dist = pygeos.measurement.length(d.geometry)
#If the edge is shorter than the tolerance
#add the ID to the drop list and update involved node degrees
if dist < tolerance:
edge_id_drop.append(d.id)
deg[d.from_id] -= 1
deg[d.to_id] -= 1
# drops disconnected edges, some may still persist since we have not merged yet
if deg[d.from_id] == 1 and deg[d.to_id] == 1:
edge_id_drop.append(d.id)
deg[d.from_id] -= 1
deg[d.to_id] -= 1
edg = ed.loc[~(ed.id.isin(edge_id_drop))].reset_index(drop=True)
aa = ed.loc[ed.id.isin(edge_id_drop)]
edg.drop(labels=['id'],axis=1,inplace=True)
edg['id'] = range(len(edg))
n = network.nodes.copy()
n['degree'] = deg
#Degree 0 Nodes are cleaned in the merge_2 method
#x = n.loc[n.degree==0]
#nod = n.loc[n.degree > 0].reset_index(drop=True)
return Network(nodes = n,edges=edg)
def merge_edges(network, print_err=False):
"""This method removes all degree 2 nodes and merges their associated edges, at
the moment it arbitrarily uses the first edge's attributes for the new edges
column attributes, in the future the mean or another measure can be used
to set these new values. The general strategy is to find a node of degree 2,
and the associated 2 edges, then traverse edges and nodes in both directions
until a node of degree !=2 is found, at this point stop in this direction. Reset the
geometry and from/to ids for this edge, delete the nodes and edges traversed.
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
print_err (bool, optional): [description]. Defaults to False.
Returns:
network (class): A network composed of nodes (points in space) and edges (lines)
"""
net = network
nod = net.nodes.copy()
edg = net.edges.copy()
optional_cols = edg.columns.difference(['osm_id','geometry','from_id','to_id','id'])
edg_sindex = pygeos.STRtree(network.edges.geometry)
if 'degree' not in network.nodes.columns:
deg = calculate_degree(network)
else: deg = nod['degree'].to_numpy()
#For the 0.002s speed up, alternatively do a straightforward loc[degree==2]
degree2 = np.where(deg==2)
#n2: is the set of all node IDs that are degree 2
n2 = set((nod['id'].iloc[degree2]))
#TODO if you create a dictionary to mask values this geometry
#array nodGeom can be made to only contain the 'geometry' of degree 2
#nodes
nodGeom = nod['geometry']
eIDtoRemove =[]
nIDtoRemove =[]
c = 0
#pbar = tqdm(total=len(n2))
while n2:
newEdge = []
info_first_edge = []
possibly_delete = []
pos_0_deg = []
nodeID = n2.pop()
pos_0_deg.append(nodeID)
#Co-ordinates of current node
node_geometry = nodGeom[nodeID]
eID = set(edg_sindex.query(node_geometry,predicate='intersects'))
#Find the nearest 2 edges, unless there is an error in the dataframe
#this will return the connected edges using spatial indexing
if len(eID) > 2: edgePath1, edgePath2 = find_closest_2_edges(eID,nodeID,edg,node_geometry)
elif len(eID) < 2:
continue
else:
edgePath1 = edg.iloc[eID.pop()]
edgePath2 = edg.iloc[eID.pop()]
#For the two edges found, identify the next 2 nodes in either direction
nextNode1 = edgePath1.to_id if edgePath1.from_id==nodeID else edgePath1.from_id
nextNode2 = edgePath2.to_id if edgePath2.from_id==nodeID else edgePath2.from_id
if nextNode1==nextNode2: continue
possibly_delete.append(edgePath2.id)
#At the moment the first edge information is used for the merged edge
info_first_edge = edgePath1.id
newEdge.append(edgePath1.geometry)
newEdge.append(edgePath2.geometry)
#While the next node along the path is degree 2 keep traversing
while deg[nextNode1] == 2:
if nextNode1 in pos_0_deg: break
nextNode1Geom = nodGeom[nextNode1]
eID = set(edg_sindex.query(nextNode1Geom,predicate='intersects'))
eID.discard(edgePath1.id)
try:
edgePath1 = min([edg.iloc[match_idx] for match_idx in eID],
key= lambda match: pygeos.distance(nextNode1Geom,(match.geometry)))
except:
continue
pos_0_deg.append(nextNode1)
n2.discard(nextNode1)
nextNode1 = edgePath1.to_id if edgePath1.from_id==nextNode1 else edgePath1.from_id
newEdge.append(edgePath1.geometry)
possibly_delete.append(edgePath1.id)
while deg[nextNode2] == 2:
if nextNode2 in pos_0_deg: break
nextNode2Geom = nodGeom[nextNode2]
eID = set(edg_sindex.query(nextNode2Geom,predicate='intersects'))
eID.discard(edgePath2.id)
try:
edgePath2 = min([edg.iloc[match_idx] for match_idx in eID],
key= lambda match: pygeos.distance(nextNode2Geom,(match.geometry)))
except: continue
pos_0_deg.append(nextNode2)
n2.discard(nextNode2)
nextNode2 = edgePath2.to_id if edgePath2.from_id==nextNode2 else edgePath2.from_id
newEdge.append(edgePath2.geometry)
possibly_delete.append(edgePath2.id)
#Update the information of the first edge
new_merged_geom = pygeos.line_merge(pygeos.multilinestrings([x for x in newEdge]))
if pygeom.get_type_id(new_merged_geom) == 1:
edg.at[info_first_edge,'geometry'] = new_merged_geom
if nodGeom[nextNode1]==pygeom.get_point(new_merged_geom,0):
edg.at[info_first_edge,'from_id'] = nextNode1
edg.at[info_first_edge,'to_id'] = nextNode2
else:
edg.at[info_first_edge,'from_id'] = nextNode2
edg.at[info_first_edge,'to_id'] = nextNode1
eIDtoRemove += possibly_delete
possibly_delete.append(info_first_edge)
for x in pos_0_deg:
deg[x] = 0
mode_edges = edg.loc[edg.id.isin(possibly_delete)]
edg.at[info_first_edge,optional_cols] = mode_edges[optional_cols].mode().iloc[0].values
else:
if print_err: print("Line", info_first_edge, "failed to merge, has pygeos type ", pygeom.get_type_id(edg.at[info_first_edge,'geometry']))
#pbar.update(1)
#pbar.close()
edg = edg.loc[~(edg.id.isin(eIDtoRemove))].reset_index(drop=True)
#We remove all degree 0 nodes, including those found in dropHanging
n = nod.loc[nod.degree > 0].reset_index(drop=True)
return Network(nodes=n,edges=edg)
def find_closest_2_edges(edgeIDs, nodeID, edges, nodGeometry):
"""Returns the 2 edges connected to the current node
Args:
edgeIDs ([type]): [description]
nodeID ([type]): [description]
edges ([type]): [description]
nodGeometry ([type]): [description]
Returns:
[type]: [description]
"""
edgePath1 = min([edges.iloc[match_idx] for match_idx in edgeIDs],
key=lambda match: pygeos.distance(nodGeometry,match.geometry))
edgeIDs.remove(edgePath1.id)
edgePath2 = min([edges.iloc[match_idx] for match_idx in edgeIDs],
key=lambda match: pygeos.distance(nodGeometry,match.geometry))
return edgePath1, edgePath2
def geometry_column_name(df):
"""Get geometry column name, fall back to 'geometry'
Args:
df (pandas.DataFrame): [description]
Returns:
geom_col (string): [description]
"""
try:
geom_col = df.geometry.name
except AttributeError:
geom_col = 'geometry'
return geom_col
def matching_df_from_geoms(df, geoms):
"""Create a geometry-only DataFrame with column name to match an existing DataFrame
Args:
df (pandas.DataFrame): [description]
geoms (numpy.array): numpy array with pygeos geometries
Returns:
[type]: [description]
"""
geom_col = geometry_column_name(df)
return pd.DataFrame(geoms, columns=[geom_col])
def concat_dedup(dfs):
"""Concatenate a list of GeoDataFrames, dropping duplicate geometries
- note: repeatedly drops indexes for deduplication to work
Args:
dfs ([type]): [description]
Returns:
[type]: [description]
"""
cat = pd.concat(dfs, axis=0, sort=False)
cat.reset_index(drop=True, inplace=True)
cat_dedup = drop_duplicate_geometries(cat)
cat_dedup.reset_index(drop=True, inplace=True)
return cat_dedup
def node_connectivity_degree(node, network):
"""Get the degree of connectivity for a node.
Args:
node ([type]): [description]
network (class): A network composed of nodes (points in space) and edges (lines)
Returns:
[type]: [description]
"""
return len(
network.edges[
(network.edges.from_id == node) | (network.edges.to_id == node)
]
)
def drop_duplicate_geometries(df, keep='first'):
"""Drop duplicate geometries from a dataframe
Convert to wkb so drop_duplicates will work as discussed
in https://github.com/geopandas/geopandas/issues/521
Args:
df (pandas.DataFrame): [description]
keep (str, optional): [description]. Defaults to 'first'.
Returns:
[type]: [description]
"""
mask = df.geometry.apply(lambda geom: pygeos.to_wkb(geom))
# use dropped duplicates index to drop from actual dataframe
return df.iloc[mask.drop_duplicates(keep).index]
def nearest_point_on_edges(point, edges):
"""Find nearest point on edges to a point
Args:
point (pygeos.geometry): [description]
edges (network.edges): [description]
Returns:
[type]: [description]
"""
edge = nearest_edge(point, edges)
snap = nearest_point_on_line(point, edge.geometry)
return snap
def nearest_node(point, nodes,sindex):
"""Find nearest node to a point
Args:
point *pygeos.geometry): [description]
nodes (network.nodes): [description]
sindex ([type]): [description]
Returns:
[type]: [description]
"""
return nearest(point, nodes,sindex)
def nearest_edge(point, edges,sindex):
"""Find nearest edge to a point
Args:
point (pygeos.geometry): [description]
edges (network.edges): [description]
sindex ([type]): [description]
Returns:
[type]: [description]
"""
return nearest(point, edges,sindex)
def nearest(geom, df,sindex):
"""Find the element of a DataFrame nearest a geometry
Args:
geom (pygeos.geometry): [description]
df (pandas.DataFrame): [description]
sindex ([type]): [description]
Returns:
[type]: [description]
"""
matches_idx = sindex.query(geom)
nearest_geom = min(
[df.iloc[match_idx] for match_idx in matches_idx],
key=lambda match: pygeos.measurement.distance(match.geometry,geom)
)
return nearest_geom
def edges_within(point, edges, distance):
"""Find edges within a distance of point
Args:
point (pygeos.geometry): [description]
edges (network.edges): [description]
distance ([type]): [description]
Returns:
[type]: [description]
"""
return d_within(point, edges, distance)
def d_within(geom, df, distance):
"""Find the subset of a DataFrame within some distance of a shapely geometry
Args:
geom (pygeos.geometry): [description]
df (pandas.DataFrame): [description]
distance ([type]): [description]
Returns:
[type]: [description]
"""
return _intersects(geom, df, distance)
def _intersects(geom, df, sindex,tolerance=1e-9):
"""[summary]
Args:
geom (pygeos.geometry): [description]
df ([type]): [description]
sindex ([type]): [description]
tolerance ([type], optional): [description]. Defaults to 1e-9.
Returns:
[type]: [description]
"""
buffer = pygeos.buffer(geom,tolerance)
if pygeos.is_empty(buffer):
# can have an empty buffer with too small a tolerance, fallback to original geom
buffer = geom
try:
return _intersects_df(buffer, df,sindex)
except:
# can exceptionally buffer to an invalid geometry, so try re-buffering
buffer = pygeos.buffer(geom,0)
return _intersects_df(buffer, df,sindex)
def _intersects_df(geom, df,sindex):
"""[summary]
Args:
geom ([type]): [description]
df ([type]): [description]
sindex ([type]): [description]
Returns:
[type]: [description]
"""
return df[sindex.query(geom,'intersects')]
def intersects(geom, df, sindex, tolerance=1e-9):
"""Find the subset of a GeoDataFrame intersecting with a shapely geometry
Args:
geom ([type]): [description]
df ([type]): [description]
sindex ([type]): [description]
tolerance ([type], optional): [description]. Defaults to 1e-9.
Returns:
[type]: [description]
"""
return _intersects(geom, df, sindex, tolerance)
def nodes_intersecting(line,nodes,sindex,tolerance=1e-9):
"""Find nodes intersecting line
Args:
line ([type]): [description]
nodes ([type]): [description]
sindex ([type]): [description]
tolerance ([type], optional): [description]. Defaults to 1e-9.
Returns:
[type]: [description]
"""
return intersects(line, nodes,sindex, tolerance)
def line_endpoints(line):
"""Return points at first and last vertex of a line
Args:
line ([type]): [description]
Returns:
[type]: [description]
"""
start = pygeom.get_point(line,0)
end = pygeom.get_point(line,-1)
return start, end
def split_edge_at_points(edge, points, tolerance=1e-9):
"""Split edge at point/multipoint
Args:
edge ([type]): [description]
points (pygeos.geometry): [description]
tolerance ([type], optional): [description]. Defaults to 1e-9.
Returns:
[type]: [description]
"""
try:
segments = split_line(edge.geometry, points, tolerance)
except ValueError:
# if splitting fails, e.g. becuase points is empty GeometryCollection
segments = [edge.geometry]
edges = DataFrame([edge] * len(segments))
edges.geometry = segments
return edges
def split_line(line, points, tolerance=1e-9):
"""Split line at point or multipoint, within some tolerance
Args:
line (pygeos.geometry): [description]
points (pygeos.geometry): [description]
tolerance ([type], optional): [description]. Defaults to 1e-9.
Returns:
[type]: [description]
"""
to_split = snap_line(line, points, tolerance)
return list(split(to_split, points))
def snap_line(line, points, tolerance=1e-9):
"""Snap a line to points within tolerance, inserting vertices as necessary
Args:
line (pygeos.geometry): [description]
points (pygeos.geometry): [description]
tolerance ([type], optional): [description]. Defaults to 1e-9.
Returns:
[type]: [description]
"""
if pygeom.get_type_id(edge.geometry) == 0:
if pygeos.distance(point,line) < tolerance:
line = pygeos.snap(line, points, tolerance=1e-9)
elif pygeom.get_type_id(edge.geometry) == 4:
points = [point for point in points if pygeos.distance(point,line) < tolerance]
for point in points:
line = pygeos.snap(line, points, tolerance=1e-9)
return line
def nearest_point_on_line(point, line):
"""Return the nearest point on a line
Args:
point (pygeos.geometry): [description]
line (pygeos.geometry): [description]
Returns:
[type]: [description]
"""
return line.interpolate(line.project(point))
def set_precision(geom, precision):
"""Set geometry precision
Args:
geom (pygeos.geometry): [description]
precision ([type]): [description]
Returns:
[type]: [description]
"""
geom_mapping = mapping(geom)
geom_mapping['coordinates'] = np.round(np.array(geom_mapping['coordinates']), precision)
return shape(geom_mapping)
def reset_ids(network):
"""Resets the ids of the nodes and edges, editing the refereces in edge table
using dict masking
Args:
network (class): A network composed of nodes (points in space) and edges (lines)
Returns:
[type]: [description]
"""
nodes = network.nodes.copy()
edges = network.edges.copy()
to_ids = edges['to_id'].to_numpy()
from_ids = edges['from_id'].to_numpy()
new_node_ids = range(len(nodes))
#creates a dictionary of the node ids and the actual indices
id_dict = dict(zip(nodes.id,new_node_ids))
nt = np.copy(to_ids)
nf = np.copy(from_ids)
#updates all from and to ids, because many nodes are effected, this
#is quite optimal approach for large dataframes
for k,v in id_dict.items():
nt[to_ids==k] = v
nf[from_ids==k] = v
edges.drop(labels=['to_id','from_id'],axis=1,inplace=True)
edges['from_id'] = nf
edges['to_id'] = nt
nodes.drop(labels=['id'],axis=1,inplace=True)
nodes['id'] = new_node_ids
edges['id'] = range(len(edges))
edges.reset_index(drop=True,inplace=True)
nodes.reset_index(drop=True,inplace=True)
return Network(edges=edges,nodes=nodes)
def nearest_network_node_list(gdf_admin,gdf_nodes,sg):
"""[summary]
Args:
gdf_admin ([type]): [description]
gdf_nodes ([type]): [description]
sg ([type]): [description]
Returns:
[type]: [description]
"""
gdf_nodes = gdf_nodes.loc[gdf_nodes.id.isin(sg.vs['name'])]
gdf_nodes.reset_index(drop=True,inplace=True)
nodes = {}
for admin_ in gdf_admin.itertuples():
if (pygeos.distance((admin_.geometry),gdf_nodes.geometry).min()) > 0.005:
continue
nodes[admin_.id] = gdf_nodes.iloc[pygeos.distance((admin_.geometry),gdf_nodes.geometry).idxmin()].id
return nodes
def split_edges_at_nodes(network, tolerance=1e-9):
"""Split network edges where they intersect node geometries
"""
sindex_nodes = pygeos.STRtree(network.nodes['geometry'])
sindex_edges = pygeos.STRtree(network.edges['geometry'])
attributes = [x for x in network.edges.columns if x not in ['index','geometry','osm_id']]
grab_all_edges = []
for edge in (network.edges.itertuples(index=False)):
hits_nodes = nodes_intersecting(edge.geometry,network.nodes['geometry'],sindex_nodes, tolerance=1e-9)
hits_edges = nodes_intersecting(edge.geometry,network.edges['geometry'],sindex_edges, tolerance=1e-9)
hits_edges = pygeos.set_operations.intersection(edge.geometry,hits_edges)
try:
hits_edges = (hits_edges[~(pygeos.predicates.covers(hits_edges,edge.geometry))])
hits_edges = pd.Series([pygeos.points(item) for sublist in [pygeos.get_coordinates(x) for x in hits_edges] for item in sublist],name='geometry')
hits = [pygeos.points(x) for x in pygeos.coordinates.get_coordinates(
pygeos.constructive.extract_unique_points(pygeos.multipoints(pd.concat([hits_nodes,hits_edges]).values)))]
except TypeError:
return hits_edges
hits = pd.DataFrame(hits,columns=['geometry'])
# get points and geometry as list of coordinates
split_points = pygeos.coordinates.get_coordinates(pygeos.snap(hits,edge.geometry,tolerance=1e-9))
coor_geom = pygeos.coordinates.get_coordinates(edge.geometry)
# potentially split to multiple edges
split_locs = np.argwhere(np.isin(coor_geom, split_points).all(axis=1))[:,0]
split_locs = list(zip(split_locs.tolist(), split_locs.tolist()[1:]))
new_edges = [coor_geom[split_loc[0]:split_loc[1]+1] for split_loc in split_locs]
grab_all_edges.append([[edge.osm_id]*len(new_edges),[pygeos.linestrings(edge) for edge in new_edges],[edge[1:-1]]*len(new_edges)])
big_list = [list(zip(x[0],x[1],x[2])) for x in grab_all_edges]
# combine all new edges
edges = pd.DataFrame([[item[0],item[1]]+list(item[2]) for sublist in big_list for item in sublist],
columns=['osm_id','geometry']+attributes)
# return new network with split edges
return Network(
nodes=network.nodes,
edges=edges
)
def fill_attributes(network):
"""[summary]
Args:
edges ([type]): [description]
Returns:
[type]: [description]
"""
speed_d = {
'motorway':'80',
'motorway_link': '65',
'trunk': '60',
'trunk_link':'50',
'primary': '50', # metres ph
'primary_link':'40',
'secondary': '40', # metres ph
'secondary_link':'30',
'tertiary':'30',
'tertiary_link': '20',
'unclassified':'20',
'service':'20',
'residential': '20', # mph
}
lanes_d = {
'motorway':'4',
'motorway_link': '2',
'trunk': '4',
'trunk_link':'2',
'primary': '2', # metres ph
'primary_link':'1',
'secondary': '2', # metres ph
'secondary_link':'1',
'tertiary':'2',
'tertiary_link': '1',
'unclassified':'2',
'service':'1',
'residential': '1', # mph
}
df_speed = pd.DataFrame.from_dict(speed_d,orient='index',columns=['maxspeed'])
df_lanes = pd.DataFrame.from_dict(lanes_d,orient='index',columns=['lanes'])
def turn_to_int(x):
if isinstance(x.maxspeed,str):
if len(re.findall(r'\d+',x.maxspeed)) > 0:
return re.findall(r'\d+',x.maxspeed)[0]
else:
return speed_d[x.highway]
else:
return x.maxspeed
network.edges.maxspeed = network.edges.apply(turn_to_int,axis=1)
try:
vals_to_assign = network.edges.groupby('highway')[['lanes','maxspeed']].agg(pd.Series.mode)
except:
vals_to_assign = df_lanes.join(df_speed)
#print(vals_to_assign)
try:
vals_to_assign.lanes.iloc[0]
except:
print('NOTE: No maxspeed values available in the country, fall back on default')
vals_to_assign = vals_to_assign.join(df_lanes)
try:
vals_to_assign.maxspeed.iloc[0]
except:
print('NOTE: No maxspeed values available in the country, fall back on default')
vals_to_assign = vals_to_assign.join(df_speed)
def fill_empty_maxspeed(x):
if len(list(x.maxspeed)) == 0:
return speed_d[x.name]
else:
return x.maxspeed
def fill_empty_lanes(x):
if len(list(x.lanes)) == 0:
return lanes_d[x.name]
else:
return x.lanes
def get_max_in_vals_to_assign(x):
if isinstance(x,list):
return max([(y) for y in x])
else:
try:
return re.findall(r'\d+',x)[0]
except:
return x
def get_max(x):
return max([int(y) for y in x])
#fill empty cells
vals_to_assign.lanes = vals_to_assign.apply(lambda x: fill_empty_lanes(x),axis=1)
vals_to_assign.maxspeed = vals_to_assign.apply(lambda x: fill_empty_maxspeed(x),axis=1)
vals_to_assign.maxspeed = vals_to_assign.maxspeed.apply(lambda x: get_max_in_vals_to_assign(x))
def fill_oneway(x):
if isinstance(x.oneway,str):
return x.oneway
else:
return 'no'
def fill_lanes(x):
if isinstance(x.lanes,str):
try:
return int(x.lanes)
except:
try:
return int(get_max(re.findall(r'\d+', x.lanes)))
except:
return int(vals_to_assign.loc[x.highway].lanes)
elif x.lanes is None:
if isinstance(vals_to_assign.loc[x.highway].lanes,np.ndarray):
return int(get_max(vals_to_assign.loc[x.highway.split('_')[0]].lanes))
else:
return int(vals_to_assign.loc[x.highway].lanes)
elif np.isnan(x.lanes):
if isinstance(vals_to_assign.loc[x.highway].lanes,np.ndarray):
return int(get_max(vals_to_assign.loc[x.highway.split('_')[0]].lanes))
else:
return int(vals_to_assign.loc[x.highway].lanes)
def fill_maxspeed(x):
if isinstance(x.maxspeed,str):
try:
return [int(s) for s in x.maxspeed.split() if s.isdigit()][0]
except:
try:
return int(get_max(vals_to_assign.loc[x.highway.split('_')[0]].maxspeed))
except:
try:
return int(get_max(re.findall(r'\d+', x.maxspeed)))
except:
return int(vals_to_assign.loc[x.highway].maxspeed)
elif x.maxspeed is None:
if isinstance(vals_to_assign.loc[x.highway].maxspeed,np.ndarray):
return int(get_max(vals_to_assign.loc[x.highway.split('_')[0]].maxspeed))
else:
try:
return int(get_max(re.findall(r'\d+', x.maxspeed)))
except:
return int(vals_to_assign.loc[x.highway].maxspeed)
elif np.isnan(x.maxspeed):
if isinstance(vals_to_assign.loc[x.highway].maxspeed,np.ndarray):
try:
return int(get_max(vals_to_assign.loc[x.highway.split('_')[0]].maxspeed))
except:
print(vals_to_assign.loc[x.highway].maxspeed)
return int(vals_to_assign.loc[x.highway].maxspeed)
else:
return int(vals_to_assign.loc[x.highway].maxspeed)
network.edges['oneway'] = network.edges.apply(lambda x: fill_oneway(x),axis=1)
network.edges['lanes'] = network.edges.apply(lambda x: fill_lanes(x),axis=1)
network.edges['maxspeed'] = network.edges.apply(lambda x: fill_maxspeed(x),axis=1)
return network
def simplified_network(df,drop_hanging_nodes_run=True,fill_attributes_run=True):
"""returns a geopandas dataframe of a simplified network
Args:
df ([type]): [description]
drop_hanging_nodes_run (bool, optional): [description]. Defaults to True.
Returns:
[type]: [description]
"""
net = Network(edges=df)
net = clean_roundabouts(net)
net = add_endpoints(net)
net = split_edges_at_nodes(net)
net = add_endpoints(net)
net = add_ids(net)
net = add_topology(net)
if drop_hanging_nodes_run:
net = drop_hanging_nodes(net)
else:
net.nodes['degree'] = calculate_degree(net)
net = merge_edges(net)
net.edges = drop_duplicate_geometries(net.edges, keep='first')
net = reset_ids(net)
net = add_distances(net)
net = merge_multilinestrings(net)
if fill_attributes_run:
net = fill_attributes(net)
net = add_travel_time(net)
return net
def ferry_connected_network(country,data_path,tqdm_on=True):
"""
connect ferries to main network (and connect smaller sub networks automatically)
Args:
country ([type]): [description]
data_path ([type]): [description]
Returns:
[type]: [description]
"""
if not tqdm_on:
from utils import tqdm_standin as tqdm
# load full network
full_network = roads(str(data_path.joinpath('country_osm','{}.osm.pbf'.format(country))))
main_road_network = full_network.loc[full_network.highway.isin(road_types)].reset_index(drop=True)
# load ferries
ferry_network = ferries(str(data_path.joinpath('country_osm','{}.osm.pbf'.format(country))))
# create a main network where hanging nodes are not removed
network_with_hanging = simplified_network(main_road_network,drop_hanging_nodes_run=False)
nodes,edges = network_with_hanging.nodes.copy(),network_with_hanging.edges.copy()
# create connections between ferry network and the main network
connectors = connect_ferries(country,full_network,ferry_network)
# loop through ferry connectors to add to edges of main network
for link in connectors.itertuples():
start = pygeos.get_point(link.geometry,0)
end = pygeos.get_point(link.geometry,-1)
from_id = nodes.id.loc[nodes.geometry==start]
to_id = nodes.id.loc[nodes.geometry==end]
edges = edges.append({ 'osm_id': np.random.random_integers(1e7,1e8),
'geometry': link.geometry,
'highway': 'ferry_connector',
'maxspeed': 10,
'oneway': 'no',
'lanes': 2},
ignore_index=True)
# loop through ferry network to add to edges of main network
for iter_,ferry in ferry_network.iterrows():
start = pygeos.get_point(ferry.geometry,0)
end = pygeos.get_point(ferry.geometry,-1)
from_id = nodes.id.loc[nodes.geometry==start]
to_id = nodes.id.loc[nodes.geometry==end]
#if not from_id.empty and not to_id.empty:
edges = edges.append({ 'osm_id': ferry.osm_id,
'geometry': ferry.geometry,
'highway': 'ferry',
'maxspeed': 20,
'oneway': 'no',
'lanes': 2},
ignore_index=True)
# ensure the newly created edge network has the same order compared to the original one
new_edges = edges.iloc[:,:6]
new_edges = new_edges[[x for x in new_edges.columns if x != 'geometry']+['geometry']]
# create new network with ferry connections
net_final = simplified_network(new_edges,fill_attributes_run=False)
net_final.edges.osm_id = net_final.edges.osm_id.astype(int)
net_final.edges.geometry = pygeos.to_wkb(net_final.edges.geometry)
net_final.nodes.geometry = pygeos.to_wkb(net_final.nodes.geometry)
feather.write_dataframe(net_final.edges.copy(),data_path.joinpath('road_ferry_networks','{}-edges.feather'.format(country)))
feather.write_dataframe(net_final.nodes.copy(),data_path.joinpath('road_ferry_networks','{}-nodes.feather'.format(country)))
return net_final
def connect_ferries(country,full_network,ferry_network):
"""[summary]
Args:
country ([type]): [description]
full_network ([type]): [description]
ferry_network ([type]): [description]
Returns:
[type]: [description]
"""
# list in which we will connect new ferry connections
collect_connectors = []
# loop through all ferries
for iter_,ferry in (ferry_network.iterrows()):
# create buffer around ferry to get the full network around the ferry ends
ferry_buffer = pygeos.buffer(ferry.geometry,0.05)
# collect the road network around the ferry
sub_full_network = full_network.loc[pygeos.intersects(full_network.geometry,ferry_buffer)].reset_index(drop=True)
sub_main_network_nodes = [[pygeos.points(pygeos.get_coordinates(x)[0]),pygeos.points(pygeos.get_coordinates(x)[1])] for x in sub_full_network.loc[sub_full_network.highway.isin(road_types)].geometry]
sub_main_network_nodes = [item for sublist in sub_main_network_nodes for item in sublist]
sub_main_network_nodes = pd.DataFrame(sub_main_network_nodes,columns=['geometry'])
sub_main_network_nodes['id'] = [x+1 for x in range(len(sub_main_network_nodes))]
# create a dataframe of the ferry nodes
ferry_nodes = pd.DataFrame([pygeos.points(pygeos.get_coordinates(ferry.geometry)[0]),pygeos.points(pygeos.get_coordinates(ferry.geometry)[-1])],columns=['geometry'])
ferry_nodes['id'] = [1,2]
# create mini simplified network and graph of network around ferry
net = Network(edges=sub_full_network)
net = add_endpoints(net)
net = split_edges_at_nodes(net)
net = add_endpoints(net)
net = add_ids(net)
net = add_topology(net)
net = add_distances(net)
edges = net.edges.reindex(['from_id','to_id'] + [x for x in list(net.edges.columns) if x not in ['from_id','to_id']],axis=1)
graph= ig.Graph.TupleList(edges.itertuples(index=False), edge_attrs=list(edges.columns)[2:],directed=False)
sg = graph.copy()
# collect nearest nodes on network in graph
nearest_node_main = nearest_network_node_list(sub_main_network_nodes,net.nodes,sg)
nearest_node_ferry = nearest_network_node_list(ferry_nodes,net.nodes,sg)
dest_nodes = [sg.vs['name'].index(nearest_node_main[x]) for x in list(nearest_node_main.keys())]
ferry_nodes_graph = [sg.vs['name'].index(nearest_node_ferry[x]) for x in list(nearest_node_ferry.keys())]
# collect paths on both sides of the ferry, if both sides have an actual network nearby
if len(ferry_nodes_graph) == 2:
start_node,end_node = ferry_nodes_graph
# collect all shortest path from one side of the ferry to main network nodes
collect_start_paths = {}
for dest_node in dest_nodes:
paths = sg.get_shortest_paths(sg.vs[start_node],sg.vs[dest_node],weights='distance',output="epath")
if len(paths[0]) != 0:
collect_start_paths[dest_node] = sg.es[paths[0]]['id'],np.sum(sg.es[paths[0]]['distance'])
start_coords = ferry_nodes.geometry[ferry_nodes.id=={v: k for k, v in nearest_node_ferry.items()}[sg.vs[start_node]['name']]].values
# if there are paths, connect them up!
if len(collect_start_paths) != 0:
if len(pd.DataFrame.from_dict(collect_start_paths).T.min()) != 0:
path_1 = pd.DataFrame.from_dict(collect_start_paths).T.min()[0]
p_1 = []
for p in path_1:
high_type = net.edges.highway.loc[net.edges.id==p].values
if np.isin(high_type,road_types):
break
else:
p_1.append(p)
path_1 = net.edges.loc[net.edges.id.isin(p_1)]
# check if they are really connected, if not, we need to create a little linestring to connect the new connector path and the ferry
if len(p_1) > 0:
linestring = pygeos.linear.line_merge(pygeos.multilinestrings(path_1['geometry'].values))
endpoint1 = pygeos.points(pygeos.coordinates.get_coordinates(linestring))[0]
endpoint2 = pygeos.points(pygeos.coordinates.get_coordinates(linestring))[-1]
endpoint1_distance = pygeos.distance(start_coords,endpoint1)
endpoint2_distance = pygeos.distance(start_coords,endpoint2)
if (endpoint1_distance == 0) | (endpoint2_distance == 0):
collect_connectors.append(linestring)
elif endpoint1_distance < endpoint2_distance:
collect_connectors.append(pygeos.linestrings(np.concatenate((pygeos.coordinates.get_coordinates(start_coords),pygeos.coordinates.get_coordinates(linestring)),axis=0)))
else:
collect_connectors.append(pygeos.linestrings(np.concatenate((pygeos.coordinates.get_coordinates(linestring),pygeos.coordinates.get_coordinates(start_coords)),axis=0)))
else:
local_network = net.edges.loc[net.edges.id.isin(pd.DataFrame.from_dict(collect_start_paths).T.min()[0])]
sub_local_network = [[pygeos.points(pygeos.get_coordinates(x)[0]),pygeos.points(pygeos.get_coordinates(x)[-1])] for x in local_network.loc[local_network.highway.isin(road_types)].geometry]
sub_local_network = [item for sublist in sub_local_network for item in sublist]
location_closest_point = np.where(pygeos.distance(start_coords[0],sub_local_network) == np.amin(pygeos.distance(start_coords[0],sub_local_network)))[0][0]
collect_connectors.append(pygeos.linestrings(np.concatenate((pygeos.get_coordinates(start_coords),pygeos.get_coordinates(sub_local_network[location_closest_point])),axis=0)))
# if there are no paths, but if the ferry node is still very close to the main network, we create a new linestring to connect them up (sometimes the ferry dock has no road)
elif pygeos.distance(sub_main_network_nodes.geometry,start_coords).min() < 0.01:
get_new_end_point = pygeos.coordinates.get_coordinates(sub_main_network_nodes.iloc[pygeos.distance(sub_main_network_nodes.geometry,start_coords).idxmin()].geometry)
collect_connectors.append(pygeos.linestrings(np.concatenate((pygeos.coordinates.get_coordinates(start_coords),get_new_end_point),axis=0)))
# collect all shortest path from one side of the ferry to main network nodes
collect_end_paths = {}
for dest_node in dest_nodes:
paths = sg.get_shortest_paths(sg.vs[end_node],sg.vs[dest_node],weights='distance',output="epath")
if len(paths[0]) != 0:
collect_end_paths[dest_node] = sg.es[paths[0]]['id'],np.sum(sg.es[paths[0]]['distance'])
end_coords = ferry_nodes.geometry[ferry_nodes.id=={v: k for k, v in nearest_node_ferry.items()}[sg.vs[end_node]['name']]].values
# if there are paths, connect them up!
if len(collect_end_paths) != 0:
if len(pd.DataFrame.from_dict(collect_end_paths).T.min()) != 0:
path_2 = pd.DataFrame.from_dict(collect_end_paths).T.min()[0]
p_2 = []
for p in path_2:
high_type = net.edges.highway.loc[net.edges.id==p].values
if np.isin(high_type,road_types):
break
else:
p_2.append(p)
# check if they are really connected, if not, we need to create a little linestring to connect the new connector path and the ferry
path_2 = net.edges.loc[net.edges.id.isin(p_2)]
if len(p_2) > 0:
linestring = pygeos.linear.line_merge(pygeos.multilinestrings(path_2['geometry'].values))
endpoint1 = pygeos.points(pygeos.coordinates.get_coordinates(linestring))[0]
endpoint2 = pygeos.points(pygeos.coordinates.get_coordinates(linestring))[-1]
endpoint1_distance = pygeos.distance(end_coords,endpoint1)
endpoint2_distance = pygeos.distance(end_coords,endpoint2)
if (endpoint1_distance == 0) | (endpoint2_distance == 0):
collect_connectors.append(linestring)
elif endpoint1_distance < endpoint2_distance:
collect_connectors.append(pygeos.linestrings(np.concatenate((pygeos.coordinates.get_coordinates(end_coords),pygeos.coordinates.get_coordinates(linestring)),axis=0)))
else:
collect_connectors.append(pygeos.linestrings(np.concatenate((pygeos.coordinates.get_coordinates(linestring),pygeos.coordinates.get_coordinates(end_coords)),axis=0)))
else:
local_network = net.edges.loc[net.edges.id.isin(pd.DataFrame.from_dict(collect_end_paths).T.min()[0])]
sub_local_network = [[pygeos.points(pygeos.get_coordinates(x)[0]),pygeos.points(pygeos.get_coordinates(x)[-1])] for x in local_network.loc[local_network.highway.isin(road_types)].geometry]
sub_local_network = [item for sublist in sub_local_network for item in sublist]
location_closest_point = np.where(pygeos.distance(end_coords[0],sub_local_network) == np.amin(pygeos.distance(end_coords[0],sub_local_network)))[0][0]
collect_connectors.append(pygeos.linestrings(np.concatenate((pygeos.get_coordinates(end_coords),pygeos.get_coordinates(sub_local_network[location_closest_point])),axis=0)))
# if there are no paths, but if the ferry node is still very close to the main network, we create a new linestring to connect them up (sometimes the ferry dock has no road)
elif pygeos.distance(sub_main_network_nodes.geometry,end_coords).min() < 0.01:
get_new_end_point = pygeos.coordinates.get_coordinates(sub_main_network_nodes.iloc[pygeos.distance(sub_main_network_nodes.geometry,end_coords).idxmin()].geometry)
collect_connectors.append(pygeos.linestrings(np.concatenate((pygeos.coordinates.get_coordinates(end_coords),get_new_end_point),axis=0)))
# ferry is stand-alone, so we continue because there is nothing to connect
elif len(ferry_nodes_graph) == 0:
continue
# collect paths on one side of the ferry, as other side does not have a network nearby
else:
start_node = ferry_nodes_graph[0]
start_coords = ferry_nodes.geometry[ferry_nodes.id=={v: k for k, v in nearest_node_ferry.items()}[sg.vs[start_node]['name']]].values
# collect all shortest path from one side of the ferry to main network nodes
collect_start_paths = {}
for dest_node in dest_nodes:
paths = sg.get_shortest_paths(sg.vs[start_node],sg.vs[dest_node],weights='distance',output="epath")
if len(paths[0]) != 0:
collect_start_paths[dest_node] = sg.es[paths[0]]['id'],np.sum(sg.es[paths[0]]['distance'])
# if there are paths, connect them up!
if len(collect_start_paths) != 0:
path_1 = pd.DataFrame.from_dict(collect_start_paths).T.min()[0]
p_1 = []
for p in path_1:
high_type = net.edges.highway.loc[net.edges.id==p].values
if np.isin(high_type,road_types): break
else: p_1.append(p)
path_1 = net.edges.loc[net.edges.id.isin(p_1)]
# check if they are really connected, if not, we need to create a little linestring to connect the new connector path and the ferry
if len(p_1) > 0:
linestring = pygeos.linear.line_merge(pygeos.multilinestrings(path_1['geometry'].values))
endpoint1 = pygeos.points(pygeos.coordinates.get_coordinates(linestring))[0]
endpoint2 = pygeos.points(pygeos.coordinates.get_coordinates(linestring))[-1]
endpoint1_distance = pygeos.distance(start_coords,endpoint1)
endpoint2_distance = pygeos.distance(start_coords,endpoint2)
if (endpoint1_distance == 0) | (endpoint2_distance == 0):
collect_connectors.append(linestring)
elif endpoint1_distance < endpoint2_distance:
collect_connectors.append(pygeos.linestrings(np.concatenate((pygeos.coordinates.get_coordinates(start_coords),pygeos.coordinates.get_coordinates(linestring)),axis=0)))
else:
collect_connectors.append(pygeos.linestrings(np.concatenate((pygeos.coordinates.get_coordinates(linestring),pygeos.coordinates.get_coordinates(start_coords)),axis=0)))
else:
local_network = net.edges.loc[net.edges.id.isin( | pd.DataFrame.from_dict(collect_start_paths) | pandas.DataFrame.from_dict |
import pydoc
import pandas as pd
import os
import random
def read_excel():
df = pd.read_excel('/Users/ls/Downloads/babycare11-1.xlsx')
data = df.head(2)
print(str(data))
# print(df.head(2))
def merge_excel():
dfs = []
dir = '/Users/ls/babycare/'
des = '/Users/ls/babycare/babycare-stats-7-3.xlsx'
for root, dirs, files in os.walk(dir):
for file in files:
file_name = os.path.join(root, file)
# print(root,"==",file)
if 'babycare-stats-7-' in file_name:
df = pd.read_excel(file_name)
dfs.append(df)
print(len(files))
all_data = pd.concat(dfs)
all_data.rename(columns={'dt': '日期', 'task_id': '任务ID', 'conversion_user_pin_count': '触达人数',
'conversion_bought_user_pin_count': '触达-曾购数',
'conversion_non_bought_user_pin_count': '触达-未购数',
'browsered_pin_count': '浏览数',
'browsered_bought_pin_count': '浏览-曾购数',
'browsered_non_bought_pin_count': '浏览-未购数',
'purchased_pin_count': '加购数',
'purchased_bought_pin_count': '加购-曾购数',
'purchased_non_bought_pin_count': '加购-未购数',
'ordered_pin_count': '下单数',
'ordered_bought_pin_count': '下单-曾购数',
'ordered_non_bought_pin_count': '下单-未购数',
'paid_pin_count': '付款数',
'paid_bought_pin_count': '付款-曾购数',
'paid_non_bought_pin_count': '付款-未购数',
'consume_amount': '付款额',
'consume_bought_amount': '付款-曾购金额',
'consume_non_bought_amount': '付款-未购金额',
'per_amount': '客单价',
'per_bought_amount': '客单价-曾购价',
'per_non_bought_amount': '客单价-未购价'}, inplace=True)
# print(all_data.columns)
all_data.to_excel(des, index=False, encoding='gbk')
def simulation():
factor_low = 0.2
factor_high = 0.6
period_one_from = '/Users/ls/babycare/babycare-stats-1.xlsx'
period_seven_from = '/Users/ls/babycare/babycare-stats-7.xlsx'
period_one_des = '/Users/ls/babycare/babycare-stats-simu1.xlsx'
period_seven_des = '/Users/ls/babycare/babycare-stats-simu7.xlsx'
df = | pd.read_excel(period_seven_from) | pandas.read_excel |
#!/usr/bin/env python
# coding: utf-8
# In[1]:
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
from scipy import stats
from sklearn.linear_model import Ridge, RidgeCV
from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.metrics import mean_squared_error, make_scorer
# In[2]:
def calculate_pearson(df):
correlations = {}
numerical_features = df.select_dtypes(exclude = ["object"]).columns
numerical_features = numerical_features.drop("cod_municipio")
for i in numerical_features:
corr = stats.pearsonr(df[i], df['ideb'])[0]
correlations[i] = corr
df_corr = pd.DataFrame(list(correlations.items()), columns=['feature', 'correlation_with_ideb'])
df_corr = df_corr.dropna()
return df_corr
# In[3]:
def calculate_categorical_correlation(df):
categorical_features = df.select_dtypes(include = ["object"]).columns
return categorical_features
# # Puxa dados do CSV de cada integrante do grupo
# ### Dados Alexandre
# In[4]:
path = '../../data/'
# In[5]:
#Dados iniciais
alexandre_inicio_2015 = pd.read_csv(path + 'bases_ale/anos_iniciais/ideb_municipios_2015_ai.csv')
alexandre_inicio_2017 = pd.read_csv(path + 'bases_ale/anos_iniciais/ideb_municipios_2017_ai.csv')
# Dados finais
alexandre_final_2015 = pd.read_csv(path + 'bases_ale/anos_finais/ideb_municipios_2015_af.csv')
alexandre_final_2017 = pd.read_csv(path + 'bases_ale/anos_finais/ideb_municipios_2017_af.csv')
# ### Dados Lidia
# In[6]:
#Dados iniciais
lidia_inicio_2007 = pd.read_csv(path + 'bases_lidia/anos_iniciais/ideb_escola_2007_ai.csv')
lidia_inicio_2009 = pd.read_csv(path + 'bases_lidia/anos_iniciais/ideb_escola_2009_ai.csv')
lidia_inicio_2011 = pd.read_csv(path + 'bases_lidia/anos_iniciais/ideb_escola_2011_ai.csv')
lidia_inicio_2013 = pd.read_csv(path + 'bases_lidia/anos_iniciais/ideb_escola_2013_ai.csv')
lidia_inicio_2015 = pd.read_csv(path + 'bases_lidia/anos_iniciais/ideb_escola_2015_ai.csv')
lidia_inicio_2017 = pd.read_csv(path + 'bases_lidia/anos_iniciais/ideb_escola_2017_ai.csv')
# Dados finais
lidia_final_2007 = pd.read_csv(path + 'bases_lidia/anos_finais/ideb_escola_2007_af.csv')
lidia_final_2009 = pd.read_csv(path + 'bases_lidia/anos_finais/ideb_escola_2009_af.csv')
lidia_final_2011 = pd.read_csv(path + 'bases_lidia/anos_finais/ideb_escola_2011_af.csv')
lidia_final_2013 = pd.read_csv(path + 'bases_lidia/anos_finais/ideb_escola_2013_af.csv')
lidia_final_2015 = pd.read_csv(path + 'bases_lidia/anos_finais/ideb_escola_2015_af.csv')
lidia_final_2017 = pd.read_csv(path + 'bases_lidia/anos_finais/ideb_escola_2017_af.csv')
# ### Dados William
# In[7]:
#Dados iniciais
william_inicio_2005 = pd.read_csv(path + 'bases_william/anos_iniciais/dados2005_inic.csv')
william_inicio_2007 = pd.read_csv(path + 'bases_william/anos_iniciais/dados2007_inic.csv')
william_inicio_2009 = pd.read_csv(path + 'bases_william/anos_iniciais/dados2009_inic.csv')
william_inicio_2011 = pd.read_csv(path + 'bases_william/anos_iniciais/dados2011_inic.csv')
william_inicio_2013 = pd.read_csv(path + 'bases_william/anos_iniciais/dados2013_inic.csv')
william_inicio_2015 = pd.read_csv(path + 'bases_william/anos_iniciais/dados2015_inic.csv')
william_inicio_2017 = pd.read_csv(path + 'bases_william/anos_iniciais/dados2017_inic.csv')
# Dados finais
william_final_2005 = pd.read_csv(path + 'bases_william/anos_finais/dados2005_fim.csv')
william_final_2007 = pd.read_csv(path + 'bases_william/anos_finais/dados2007_fim.csv')
william_final_2009 = pd.read_csv(path + 'bases_william/anos_finais/dados2009_fim.csv')
william_final_2011 = pd.read_csv(path + 'bases_william/anos_finais/dados2011_fim.csv')
william_final_2013 = | pd.read_csv(path + 'bases_william/anos_finais/dados2013_fim.csv') | pandas.read_csv |
import pandas as pd
df1 = | pd.read_csv('data//alexander_algoaddition_adddate.csv') | pandas.read_csv |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Parsing of a csv game tracking sheet of type 'X', saving data in consice and relevant manner."""
# Here comes your imports
import sys
import logging as log
import pandas as pd
# Here comes your (few) global variables
# Here comes your class definitions
# Here comes your function definitions
def parse_pre_shot_situation(data, out):
"""parse the situation leading to the shot"""
# (cycle / free-hit / develop / counter / turnover / rebound / penalty / others)
situation_labels = \
['Festsetzen', 'Freischlag', 'Auslösung', 'Konter', \
'Ballgewinn', 'Abpraller', 'Penalty', 'Sonstige']
situation_categories = \
['CYC', 'FHT', 'DVL', 'CNT', 'TNV', 'RBD', 'PNT', 'OTH']
shot_situations = data[situation_labels]
shot_situations.columns = situation_categories
situation_count = shot_situations.notna().sum(axis=1)
if (situation_count != 1).any():
log.warning('no pre shot situation:\n%s', shot_situations[situation_count < 1])
log.warning('multiple pre shot situations:\n%s', shot_situations[situation_count > 1])
situation = pd.Categorical([''] * len(shot_situations.index), categories=situation_categories)
for label, content in shot_situations.items():
situation[content.notna()] = label
log.debug(pd.Series(situation))
log.debug(pd.Series(situation).value_counts())
out['sh_situ'] = pd.Series(situation)
def parse_shot_type(data, out):
"""parse the type of the shot"""
# (wrist / chip / slap / backhand / one-timer / volley / tip / in-tight)
type_labels = \
['Gezogen', 'Chip', 'Slapshot', 'Backhand', 'Direkt', 'Volley', 'Ablenker', 'InTight']
type_categories = \
['WRS', 'CHP', 'SLP', 'BKH', 'ONT', 'VOL', 'TIP', 'INT']
shot_types = data[type_labels]
shot_types.columns = type_categories
type_count = shot_types.notna().sum(axis=1)
if (type_count != 1).any():
log.warning('no shot type:\n%s', shot_types[type_count < 1])
log.warning('multiple shot types:\n%s', shot_types[type_count > 1])
shot_type = pd.Categorical([''] * len(shot_types.index), categories=type_categories)
for label, content in shot_types.items():
shot_type[content.notna()] = label
log.debug(pd.Series(shot_type))
log.debug(pd.Series(shot_type).value_counts())
out['sh_type'] = pd.Series(shot_type)
def parse_shot_result(data, out):
"""parse the result (blocked / missed / on-goal / goal) of the event / shot"""
result_categories = ['BL', 'MI', 'SOG', 'G']
shot_results = data[result_categories]
log.debug(shot_results.info())
result_count = shot_results.notna().sum(axis=1)
if (result_count < 1).any():
log.warning('no shot result:\n%s', shot_results[result_count < 1])
if (result_count > 1).any():
log.debug('multiple shot results:\n%s', shot_results[result_count > 1])
result = pd.Categorical([''] * len(shot_results.index), categories=result_categories)
for label, content in shot_results.items():
result[content.notna()] = label
log.debug(pd.Series(result))
log.debug(pd.Series(result).value_counts())
out['sh_outc'] = pd.Series(result)
def parse_involved_players_for(data, out):
"""parse the involved (on-field) players for"""
prefix = 'hm_'
players_goalies = data.filter(regex=("^g?[0-9]+$"))
numbers = pd.Series(list(players_goalies))
col = [prefix + str(i) for i in range(1, 7)]
players = | pd.DataFrame('', index=players_goalies.index, columns=col) | pandas.DataFrame |
import sys,os
#os.chdir("/Users/utkarshvirendranigam/Desktop/Homework/Project")
# required_packages=["PyQt5","re", "scipy","itertools","random","matplotlib","pandas","numpy","sklearn","pydotplus","collections","warnings","seaborn"]
#print(os.getcwd())
# for my_package in required_packages:
# try:
# command_string="conda install "+ my_package+ " --yes"
# os.system(command_string)
# except:
# count=1
from PyQt5.QtWidgets import (QMainWindow, QApplication, QWidget, QPushButton, QAction, QComboBox, QLabel,
QGridLayout, QCheckBox, QGroupBox, QVBoxLayout, QHBoxLayout, QLineEdit, QPlainTextEdit)
from PyQt5.QtGui import QIcon
from PyQt5.QtCore import pyqtSlot, QRect
from PyQt5.QtCore import pyqtSignal
from PyQt5.QtCore import Qt
# from scipy import interp
from itertools import cycle, combinations
import random
from PyQt5.QtWidgets import QDialog, QVBoxLayout, QSizePolicy, QFormLayout, QRadioButton, QScrollArea, QMessageBox
from PyQt5.QtGui import QPixmap
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar
from matplotlib.figure import Figure
import pandas as pd
import numpy as np
import pickle
from numpy.polynomial.polynomial import polyfit
from sklearn.preprocessing import LabelEncoder, OneHotEncoder, StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.tree import DecisionTreeClassifier, export_graphviz
from sklearn.compose import make_column_transformer
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
from sklearn.ensemble import RandomForestClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.metrics import roc_auc_score
from sklearn.metrics import roc_curve, auc, log_loss, brier_score_loss
from sklearn.calibration import calibration_curve
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import GradientBoostingClassifier
from sklearn import feature_selection
from sklearn import metrics
from sklearn.preprocessing import label_binarize
from sklearn.model_selection import cross_val_predict
# Libraries to display decision tree
from pydotplus import graph_from_dot_data
import collections
from sklearn.tree import export_graphviz
import webbrowser
import warnings
warnings.filterwarnings("ignore")
import matplotlib.pyplot as plt
from Preprocessing import PreProcessing
import random
import seaborn as sns
#%%-----------------------------------------------------------------------
import os
os.environ["PATH"] += os.pathsep + 'C:\\Program Files (x86)\\graphviz-2.38\\release\\bin'
#%%-----------------------------------------------------------------------
#::--------------------------------
# Deafault font size for all the windows
#::--------------------------------
font_size_window = 'font-size:18px'
class DecisionTree(QMainWindow):
#::--------------------------------------------------------------------------------
# Implementation of Random Forest Classifier using the happiness dataset
# the methods in this class are
# _init_ : initialize the class
# initUi : creates the canvas and all the elements in the canvas
# update : populates the elements of the canvas base on the parametes
# chosen by the user
#::---------------------------------------------------------------------------------
send_fig = pyqtSignal(str)
def __init__(self):
super(DecisionTree, self).__init__()
self.Title = "Decision Tree Classifier"
self.initUi()
def initUi(self):
#::-----------------------------------------------------------------
# Create the canvas and all the element to create a dashboard with
# all the necessary elements to present the results from the algorithm
# The canvas is divided using a grid loyout to facilitate the drawing
# of the elements
#::-----------------------------------------------------------------
self.setWindowTitle(self.Title)
self.setStyleSheet(font_size_window)
self.main_widget = QWidget(self)
self.layout = QGridLayout(self.main_widget)
self.groupBox1 = QGroupBox('Decision Tree Features')
self.groupBox1Layout= QGridLayout()
self.groupBox1.setLayout(self.groupBox1Layout)
self.feature0 = QCheckBox(features_list[0],self)
self.feature1 = QCheckBox(features_list[1],self)
self.feature2 = QCheckBox(features_list[2], self)
self.feature3 = QCheckBox(features_list[3], self)
self.feature4 = QCheckBox(features_list[4],self)
self.feature5 = QCheckBox(features_list[5],self)
self.feature6 = QCheckBox(features_list[6], self)
self.feature7 = QCheckBox(features_list[7], self)
self.feature8 = QCheckBox(features_list[8], self)
self.feature9 = QCheckBox(features_list[9], self)
self.feature10 = QCheckBox(features_list[10], self)
self.feature11 = QCheckBox(features_list[11], self)
self.feature12 = QCheckBox(features_list[12], self)
self.feature13 = QCheckBox(features_list[13], self)
self.feature14 = QCheckBox(features_list[14], self)
self.feature15 = QCheckBox(features_list[15], self)
self.feature16 = QCheckBox(features_list[16], self)
self.feature17 = QCheckBox(features_list[17], self)
self.feature18 = QCheckBox(features_list[18], self)
self.feature19 = QCheckBox(features_list[19], self)
self.feature20 = QCheckBox(features_list[20], self)
self.feature21 = QCheckBox(features_list[21], self)
self.feature22 = QCheckBox(features_list[22], self)
self.feature23 = QCheckBox(features_list[23], self)
self.feature24 = QCheckBox(features_list[24], self)
self.feature0.setChecked(True)
self.feature1.setChecked(True)
self.feature2.setChecked(True)
self.feature3.setChecked(True)
self.feature4.setChecked(True)
self.feature5.setChecked(True)
self.feature6.setChecked(True)
self.feature7.setChecked(True)
self.feature8.setChecked(True)
self.feature9.setChecked(True)
self.feature10.setChecked(True)
self.feature11.setChecked(True)
self.feature12.setChecked(True)
self.feature13.setChecked(True)
self.feature14.setChecked(True)
self.feature15.setChecked(True)
self.feature16.setChecked(True)
self.feature17.setChecked(True)
self.feature18.setChecked(True)
self.feature19.setChecked(True)
self.feature20.setChecked(True)
self.feature21.setChecked(True)
self.feature22.setChecked(True)
self.feature23.setChecked(True)
self.feature24.setChecked(True)
self.lblPercentTest = QLabel('Percentage for Test :')
self.lblPercentTest.adjustSize()
self.txtPercentTest = QLineEdit(self)
self.txtPercentTest.setText("30")
self.lblMaxDepth = QLabel('Maximun Depth :')
self.txtMaxDepth = QLineEdit(self)
self.txtMaxDepth.setText("3")
self.btnExecute = QPushButton("Run Model")
self.btnExecute.setGeometry(QRect(60, 500, 75, 23))
self.btnExecute.clicked.connect(self.update)
self.btnDTFigure = QPushButton("View Tree")
self.btnDTFigure.setGeometry(QRect(60, 500, 75, 23))
self.btnDTFigure.clicked.connect(self.view_tree)
# We create a checkbox for each feature
self.groupBox1Layout.addWidget(self.feature0, 0, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature1, 0, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature2, 1, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature3, 1, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature4, 2, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature5, 2, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature6, 3, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature7, 3, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature8, 4, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature9, 4, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature10, 5, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature11, 5, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature12, 6, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature13, 6, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature14, 7, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature15, 7, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature16, 8, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature17, 8, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature18, 9, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature19, 9, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature20, 10, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature21, 10, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature22, 11, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature23, 11, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature24, 12, 0, 1, 1)
self.groupBox1Layout.addWidget(self.lblPercentTest, 19, 0, 1, 1)
self.groupBox1Layout.addWidget(self.txtPercentTest, 19, 1, 1, 1)
self.groupBox1Layout.addWidget(self.lblMaxDepth, 20, 0, 1, 1)
self.groupBox1Layout.addWidget(self.txtMaxDepth, 20, 1, 1, 1)
self.groupBox1Layout.addWidget(self.btnExecute, 21, 0, 1, 1)
self.groupBox1Layout.addWidget(self.btnDTFigure, 21, 1, 1, 1)
self.groupBox2 = QGroupBox('Measurements:')
self.groupBox2Layout = QVBoxLayout()
self.groupBox2.setLayout(self.groupBox2Layout)
# self.groupBox2.setMinimumSize(400, 100)
self.current_model_summary = QWidget(self)
self.current_model_summary.layout = QFormLayout(self.current_model_summary)
self.txtCurrentAccuracy = QLineEdit()
self.txtCurrentPrecision = QLineEdit()
self.txtCurrentRecall = QLineEdit()
self.txtCurrentF1score = QLineEdit()
self.current_model_summary.layout.addRow('Accuracy:', self.txtCurrentAccuracy)
self.current_model_summary.layout.addRow('Precision:', self.txtCurrentPrecision)
self.current_model_summary.layout.addRow('Recall:', self.txtCurrentRecall)
self.current_model_summary.layout.addRow('F1 Score:', self.txtCurrentF1score)
self.groupBox2Layout.addWidget(self.current_model_summary)
self.groupBox3 = QGroupBox('Other Models Accuracy:')
self.groupBox3Layout = QVBoxLayout()
self.groupBox3.setLayout(self.groupBox3Layout)
self.other_models = QWidget(self)
self.other_models.layout = QFormLayout(self.other_models)
self.txtAccuracy_lr = QLineEdit()
self.txtAccuracy_gb = QLineEdit()
self.txtAccuracy_rf = QLineEdit()
self.other_models.layout.addRow('Logistic:', self.txtAccuracy_lr)
self.other_models.layout.addRow('Random Forest:', self.txtAccuracy_rf)
self.other_models.layout.addRow('Gradient Boosting:', self.txtAccuracy_gb)
self.groupBox3Layout.addWidget(self.other_models)
#::-------------------------------------
# Graphic 1 : Confusion Matrix
#::-------------------------------------
self.fig = Figure()
self.ax1 = self.fig.add_subplot(111)
self.axes=[self.ax1]
self.canvas = FigureCanvas(self.fig)
self.canvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.canvas.updateGeometry()
self.groupBoxG1 = QGroupBox('Confusion Matrix')
self.groupBoxG1Layout= QVBoxLayout()
self.groupBoxG1.setLayout(self.groupBoxG1Layout)
self.groupBoxG1Layout.addWidget(self.canvas)
#::---------------------------------------------
# Graphic 2 : ROC Curve
#::---------------------------------------------
self.fig2 = Figure()
self.ax2 = self.fig2.add_subplot(111)
self.axes2 = [self.ax2]
self.canvas2 = FigureCanvas(self.fig2)
self.canvas2.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.canvas2.updateGeometry()
self.groupBoxG2 = QGroupBox('ROC Curve')
self.groupBoxG2Layout = QVBoxLayout()
self.groupBoxG2.setLayout(self.groupBoxG2Layout)
self.groupBoxG2Layout.addWidget(self.canvas2)
#::-------------------------------------------
# Graphic 3 : Importance of Features
#::-------------------------------------------
self.fig3 = Figure()
self.ax3 = self.fig3.add_subplot(111)
self.axes3 = [self.ax3]
self.canvas3 = FigureCanvas(self.fig3)
self.canvas3.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.canvas3.updateGeometry()
self.groupBoxG3 = QGroupBox('Importance of Features')
self.groupBoxG3Layout = QVBoxLayout()
self.groupBoxG3.setLayout(self.groupBoxG3Layout)
self.groupBoxG3Layout.addWidget(self.canvas3)
#::--------------------------------------------
# Graphic 4 : ROC Curve by class
#::--------------------------------------------
self.fig4 = Figure()
self.ax4 = self.fig4.add_subplot(111)
self.axes4 = [self.ax4]
self.canvas4 = FigureCanvas(self.fig4)
self.canvas4.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.canvas4.updateGeometry()
self.groupBoxG4 = QGroupBox('ROC Curve by Class')
self.groupBoxG4Layout = QVBoxLayout()
self.groupBoxG4.setLayout(self.groupBoxG4Layout)
self.groupBoxG4Layout.addWidget(self.canvas4)
#::-------------------------------------------------
# End of graphs
#::-------------------------------------------------
self.layout.addWidget(self.groupBox1, 0, 0, 3, 2)
self.layout.addWidget(self.groupBoxG1, 0, 2, 1, 1)
self.layout.addWidget(self.groupBoxG3, 0, 3, 1, 1)
self.layout.addWidget(self.groupBoxG2, 1, 2, 1, 1)
self.layout.addWidget(self.groupBoxG4, 1, 3, 1, 1)
self.layout.addWidget(self.groupBox2, 2, 2, 1, 1)
self.layout.addWidget(self.groupBox3, 2, 3, 1, 1)
self.setCentralWidget(self.main_widget)
self.resize(1800, 1200)
self.show()
def update(self):
'''
Random Forest Classifier
We pupulate the dashboard using the parametres chosen by the user
The parameters are processed to execute in the skit-learn Random Forest algorithm
then the results are presented in graphics and reports in the canvas
:return:None
'''
# processing the parameters
self.list_corr_features = pd.DataFrame([])
if self.feature0.isChecked():
if len(self.list_corr_features)==0:
self.list_corr_features = df[features_list[0]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[0]]],axis=1)
if self.feature1.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[1]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[1]]],axis=1)
if self.feature2.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[2]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[2]]],axis=1)
if self.feature3.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[3]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[3]]],axis=1)
if self.feature4.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[4]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[4]]],axis=1)
if self.feature5.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[5]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[5]]],axis=1)
if self.feature6.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[6]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[6]]],axis=1)
if self.feature7.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[7]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[7]]],axis=1)
if self.feature8.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[8]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[8]]],axis=1)
if self.feature9.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[9]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[9]]],axis=1)
if self.feature10.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[10]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[10]]], axis=1)
if self.feature11.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[11]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[11]]], axis=1)
if self.feature12.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[12]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[12]]], axis=1)
if self.feature13.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[13]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[13]]], axis=1)
if self.feature14.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[14]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[14]]], axis=1)
if self.feature15.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[15]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[15]]], axis=1)
if self.feature16.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[16]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[16]]], axis=1)
if self.feature17.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[17]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[17]]], axis=1)
if self.feature18.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[18]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[18]]], axis=1)
if self.feature19.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[19]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[19]]], axis=1)
if self.feature20.isChecked():
if len(self.list_corr_features)==0:
self.list_corr_features = df[features_list[20]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[20]]],axis=1)
if self.feature21.isChecked():
if len(self.list_corr_features) == 20:
self.list_corr_features = df[features_list[1]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[21]]],axis=1)
if self.feature22.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[22]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[22]]],axis=1)
if self.feature23.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[23]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[23]]],axis=1)
if self.feature24.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[24]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[24]]],axis=1)
vtest_per = float(self.txtPercentTest.text())
vmax_depth = float(self.txtMaxDepth.text())
# Clear the graphs to populate them with the new information
self.ax1.clear()
self.ax2.clear()
self.ax3.clear()
self.ax4.clear()
# self.txtResults.clear()
# self.txtResults.setUndoRedoEnabled(False)
vtest_per = vtest_per / 100
# -----------------------------------------------------------------------
filename = 'dt_finalized_model.sav'
self.clf_entropy = pickle.load(open(filename, 'rb'))
y_test = y
X_test= X[features_list]
# predicton on test using entropy
y_pred_entropy = self.clf_entropy.predict(X_test)
# confusion matrix for RandomForest
conf_matrix = confusion_matrix(y_test, y_pred_entropy)
# accuracy score
self.ff_accuracy_score = accuracy_score(y_test, y_pred_entropy) * 100
self.txtCurrentAccuracy.setText(str(self.ff_accuracy_score))
# precision score
self.ff_precision_score = precision_score(y_test, y_pred_entropy) * 100
self.txtCurrentPrecision.setText(str(self.ff_precision_score))
# recall score
self.ff_recall_score = recall_score(y_test, y_pred_entropy) * 100
self.txtCurrentRecall.setText(str(self.ff_recall_score))
# f1_score
self.ff_f1_score = f1_score(y_test, y_pred_entropy)
self.txtCurrentF1score.setText(str(self.ff_f1_score))
#::------------------------------------
## Ghaph1 :
## Confusion Matrix
#::------------------------------------
class_names1 = ['', 'No', 'Yes']
self.ax1.matshow(conf_matrix, cmap=plt.cm.get_cmap('Blues', 14))
self.ax1.set_yticklabels(class_names1)
self.ax1.set_xticklabels(class_names1, rotation=90)
self.ax1.set_xlabel('Predicted label')
self.ax1.set_ylabel('True label')
for i in range(len(class_names)):
for j in range(len(class_names)):
y_pred_score = self.clf_entropy.predict_proba(X_test)
self.ax1.text(j, i, str(conf_matrix[i][j]))
self.fig.tight_layout()
self.fig.canvas.draw_idle()
#::----------------------------------------
## Graph 2 - ROC Curve
#::----------------------------------------
y_test_bin = pd.get_dummies(y_test).to_numpy()
n_classes = y_test_bin.shape[1]
# From the sckict learn site
# https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html
fpr = dict()
tpr = dict()
roc_auc = dict()
for i in range(n_classes):
fpr[i], tpr[i], _ = roc_curve(y_test_bin[:, i], y_pred_score[:, i])
roc_auc[i] = auc(fpr[i], tpr[i])
# Compute micro-average ROC curve and ROC area
fpr["micro"], tpr["micro"], _ = roc_curve(y_test_bin.ravel(), y_pred_score.ravel())
roc_auc["micro"] = auc(fpr["micro"], tpr["micro"])
lw = 2
self.ax2.plot(fpr[1], tpr[1], color='darkorange',
lw=lw, label='ROC curve (area = %0.2f)' % roc_auc[1])
self.ax2.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
self.ax2.set_xlim([0.0, 1.0])
self.ax2.set_ylim([0.0, 1.05])
self.ax2.set_xlabel('False Positive Rate')
self.ax2.set_ylabel('True Positive Rate')
self.ax2.set_title('ROC Curve Random Forest')
self.ax2.legend(loc="lower right")
self.fig2.tight_layout()
self.fig2.canvas.draw_idle()
######################################
# Graph - 3 Feature Importances
#####################################
# get feature importances
importances = self.clf_entropy.feature_importances_
# convert the importances into one-dimensional 1darray with corresponding df column names as axis labels
f_importances = pd.Series(importances, self.list_corr_features.columns)
# sort the array in descending order of the importances, only show the first 10
f_importances.sort_values(ascending=False, inplace=True)
f_importances = f_importances[0:10]
X_Features = f_importances.index
y_Importance = list(f_importances)
self.ax3.barh(X_Features, y_Importance)
self.ax3.set_aspect('auto')
# show the plot
self.fig3.tight_layout()
self.fig3.canvas.draw_idle()
#::-----------------------------------------------------
# Graph 4 - ROC Curve by Class
#::-----------------------------------------------------
str_classes = ['No','Yes']
colors = cycle(['magenta', 'darkorange'])
for i, color in zip(range(n_classes), colors):
self.ax4.plot(fpr[i], tpr[i], color=color, lw=lw,
label='{0} (area = {1:0.2f})'
''.format(str_classes[i], roc_auc[i]))
self.ax4.plot([0, 1], [0, 1], 'k--', lw=lw)
self.ax4.set_xlim([0.0, 1.0])
self.ax4.set_ylim([0.0, 1.05])
self.ax4.set_xlabel('False Positive Rate')
self.ax4.set_ylabel('True Positive Rate')
self.ax4.set_title('ROC Curve by Class')
self.ax4.legend(loc="lower right")
# show the plot
self.fig4.tight_layout()
self.fig4.canvas.draw_idle()
#::-----------------------------------------------------
# Other Models Comparison
#::-----------------------------------------------------
filename2 = 'lr_finalized_model.sav'
self.other_clf_lr = pickle.load(open(filename2, 'rb'))
y_pred_lr = self.other_clf_lr.predict(X_test)
self.accuracy_lr = accuracy_score(y_test, y_pred_lr) * 100
self.txtAccuracy_lr.setText(str(self.accuracy_lr))
filename3 = 'rf_finalized_model.sav'
self.other_clf_rf = pickle.load(open(filename3, 'rb'))
y_pred_rf = self.other_clf_rf.predict(X_test)
self.accuracy_rf = accuracy_score(y_test, y_pred_rf) * 100
self.txtAccuracy_rf.setText(str(self.accuracy_rf))
filename4 = 'gb_finalized_model.sav'
self.other_clf_gb = pickle.load(open(filename4, 'rb'))
y_pred_gb = self.other_clf_gb.predict(X_test)
self.accuracy_gb = accuracy_score(y_test, y_pred_gb) * 100
self.txtAccuracy_gb.setText(str(self.accuracy_gb))
def view_tree(self):
'''
Executes the graphviz to create a tree view of the information
then it presents the graphic in a pdf formt using webbrowser
:return:None
'''
webbrowser.open_new(r'decision_tree_entropy.pdf')
class RandomForest(QMainWindow):
#::--------------------------------------------------------------------------------
# Implementation of Random Forest Classifier using the happiness dataset
# the methods in this class are
# _init_ : initialize the class
# initUi : creates the canvas and all the elements in the canvas
# update : populates the elements of the canvas base on the parametes
# chosen by the user
#::---------------------------------------------------------------------------------
send_fig = pyqtSignal(str)
def __init__(self):
super(RandomForest, self).__init__()
self.Title = "Random Forest Classifier"
self.initUi()
def initUi(self):
#::-----------------------------------------------------------------
# Create the canvas and all the element to create a dashboard with
# all the necessary elements to present the results from the algorithm
# The canvas is divided using a grid loyout to facilitate the drawing
# of the elements
#::-----------------------------------------------------------------
self.setWindowTitle(self.Title)
self.setStyleSheet(font_size_window)
self.main_widget = QWidget(self)
self.layout = QGridLayout(self.main_widget)
self.groupBox1 = QGroupBox('Random Forest Features')
self.groupBox1Layout= QGridLayout()
self.groupBox1.setLayout(self.groupBox1Layout)
self.feature0 = QCheckBox(features_list[0],self)
self.feature1 = QCheckBox(features_list[1],self)
self.feature2 = QCheckBox(features_list[2], self)
self.feature3 = QCheckBox(features_list[3], self)
self.feature4 = QCheckBox(features_list[4],self)
self.feature5 = QCheckBox(features_list[5],self)
self.feature6 = QCheckBox(features_list[6], self)
self.feature7 = QCheckBox(features_list[7], self)
self.feature8 = QCheckBox(features_list[8], self)
self.feature9 = QCheckBox(features_list[9], self)
self.feature10 = QCheckBox(features_list[10], self)
self.feature11 = QCheckBox(features_list[11], self)
self.feature12 = QCheckBox(features_list[12], self)
self.feature13 = QCheckBox(features_list[13], self)
self.feature14 = QCheckBox(features_list[14], self)
self.feature15 = QCheckBox(features_list[15], self)
self.feature16 = QCheckBox(features_list[16], self)
self.feature17 = QCheckBox(features_list[17], self)
self.feature18 = QCheckBox(features_list[18], self)
self.feature19 = QCheckBox(features_list[19], self)
self.feature20 = QCheckBox(features_list[20], self)
self.feature21 = QCheckBox(features_list[21], self)
self.feature22 = QCheckBox(features_list[22], self)
self.feature23 = QCheckBox(features_list[23], self)
self.feature24 = QCheckBox(features_list[24], self)
self.feature0.setChecked(True)
self.feature1.setChecked(True)
self.feature2.setChecked(True)
self.feature3.setChecked(True)
self.feature4.setChecked(True)
self.feature5.setChecked(True)
self.feature6.setChecked(True)
self.feature7.setChecked(True)
self.feature8.setChecked(True)
self.feature9.setChecked(True)
self.feature10.setChecked(True)
self.feature11.setChecked(True)
self.feature12.setChecked(True)
self.feature13.setChecked(True)
self.feature14.setChecked(True)
self.feature15.setChecked(True)
self.feature16.setChecked(True)
self.feature17.setChecked(True)
self.feature18.setChecked(True)
self.feature19.setChecked(True)
self.feature20.setChecked(True)
self.feature21.setChecked(True)
self.feature22.setChecked(True)
self.feature23.setChecked(True)
self.feature24.setChecked(True)
self.lblPercentTest = QLabel('Percentage for Test :')
self.lblPercentTest.adjustSize()
self.txtPercentTest = QLineEdit(self)
self.txtPercentTest.setText("30")
self.lblMaxDepth = QLabel('Maximun Depth :')
self.txtMaxDepth = QLineEdit(self)
self.txtMaxDepth.setText("3")
self.btnExecute = QPushButton("Run Model")
self.btnExecute.setGeometry(QRect(60, 500, 75, 23))
self.btnExecute.clicked.connect(self.update)
# We create a checkbox for each feature
self.groupBox1Layout.addWidget(self.feature0, 0, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature1, 0, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature2, 1, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature3, 1, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature4, 2, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature5, 2, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature6, 3, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature7, 3, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature8, 4, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature9, 4, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature10, 5, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature11, 5, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature12, 6, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature13, 6, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature14, 7, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature15, 7, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature16, 8, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature17, 8, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature18, 9, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature19, 9, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature20, 10, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature21, 10, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature22, 11, 0, 1, 1)
self.groupBox1Layout.addWidget(self.feature23, 11, 1, 1, 1)
self.groupBox1Layout.addWidget(self.feature24, 12, 0, 1, 1)
self.groupBox1Layout.addWidget(self.lblPercentTest, 19, 0, 1, 1)
self.groupBox1Layout.addWidget(self.txtPercentTest, 19, 1, 1, 1)
self.groupBox1Layout.addWidget(self.lblMaxDepth, 20, 0, 1, 1)
self.groupBox1Layout.addWidget(self.txtMaxDepth, 20, 1, 1, 1)
self.groupBox1Layout.addWidget(self.btnExecute, 21, 0, 1, 1)
self.groupBox2 = QGroupBox('Measurements:')
self.groupBox2Layout = QVBoxLayout()
self.groupBox2.setLayout(self.groupBox2Layout)
# self.groupBox2.setMinimumSize(400, 100)
self.current_model_summary = QWidget(self)
self.current_model_summary.layout = QFormLayout(self.current_model_summary)
self.txtCurrentAccuracy = QLineEdit()
self.txtCurrentPrecision = QLineEdit()
self.txtCurrentRecall = QLineEdit()
self.txtCurrentF1score = QLineEdit()
self.current_model_summary.layout.addRow('Accuracy:', self.txtCurrentAccuracy)
self.current_model_summary.layout.addRow('Precision:', self.txtCurrentPrecision)
self.current_model_summary.layout.addRow('Recall:', self.txtCurrentRecall)
self.current_model_summary.layout.addRow('F1 Score:', self.txtCurrentF1score)
self.groupBox2Layout.addWidget(self.current_model_summary)
self.groupBox3 = QGroupBox('Other Models Accuracy:')
self.groupBox3Layout = QVBoxLayout()
self.groupBox3.setLayout(self.groupBox3Layout)
self.other_models = QWidget(self)
self.other_models.layout = QFormLayout(self.other_models)
self.txtAccuracy_lr = QLineEdit()
self.txtAccuracy_gb = QLineEdit()
self.txtAccuracy_dt = QLineEdit()
self.other_models.layout.addRow('Logistic:', self.txtAccuracy_lr)
self.other_models.layout.addRow('Gradient Boosting:', self.txtAccuracy_gb)
self.other_models.layout.addRow('Decision tree:', self.txtAccuracy_dt)
self.groupBox3Layout.addWidget(self.other_models)
#::-------------------------------------
# Graphic 1 : Confusion Matrix
#::-------------------------------------
self.fig = Figure()
self.ax1 = self.fig.add_subplot(111)
self.axes=[self.ax1]
self.canvas = FigureCanvas(self.fig)
self.canvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.canvas.updateGeometry()
self.groupBoxG1 = QGroupBox('Confusion Matrix')
self.groupBoxG1Layout= QVBoxLayout()
self.groupBoxG1.setLayout(self.groupBoxG1Layout)
self.groupBoxG1Layout.addWidget(self.canvas)
#::---------------------------------------------
# Graphic 2 : ROC Curve
#::---------------------------------------------
self.fig2 = Figure()
self.ax2 = self.fig2.add_subplot(111)
self.axes2 = [self.ax2]
self.canvas2 = FigureCanvas(self.fig2)
self.canvas2.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.canvas2.updateGeometry()
self.groupBoxG2 = QGroupBox('ROC Curve')
self.groupBoxG2Layout = QVBoxLayout()
self.groupBoxG2.setLayout(self.groupBoxG2Layout)
self.groupBoxG2Layout.addWidget(self.canvas2)
#::-------------------------------------------
# Graphic 3 : Importance of Features
#::-------------------------------------------
self.fig3 = Figure()
self.ax3 = self.fig3.add_subplot(111)
self.axes3 = [self.ax3]
self.canvas3 = FigureCanvas(self.fig3)
self.canvas3.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.canvas3.updateGeometry()
self.groupBoxG3 = QGroupBox('Importance of Features')
self.groupBoxG3Layout = QVBoxLayout()
self.groupBoxG3.setLayout(self.groupBoxG3Layout)
self.groupBoxG3Layout.addWidget(self.canvas3)
#::--------------------------------------------
# Graphic 4 : ROC Curve by class
#::--------------------------------------------
self.fig4 = Figure()
self.ax4 = self.fig4.add_subplot(111)
self.axes4 = [self.ax4]
self.canvas4 = FigureCanvas(self.fig4)
self.canvas4.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.canvas4.updateGeometry()
self.groupBoxG4 = QGroupBox('ROC Curve by Class')
self.groupBoxG4Layout = QVBoxLayout()
self.groupBoxG4.setLayout(self.groupBoxG4Layout)
self.groupBoxG4Layout.addWidget(self.canvas4)
#::-------------------------------------------------
# End of graphs
#::-------------------------------------------------
self.layout.addWidget(self.groupBox1, 0, 0, 3, 2)
self.layout.addWidget(self.groupBoxG1, 0, 2, 1, 1)
self.layout.addWidget(self.groupBoxG3, 0, 3, 1, 1)
self.layout.addWidget(self.groupBoxG2, 1, 2, 1, 1)
self.layout.addWidget(self.groupBoxG4, 1, 3, 1, 1)
self.layout.addWidget(self.groupBox2, 2, 2, 1, 1)
self.layout.addWidget(self.groupBox3, 2, 3, 1, 1)
self.setCentralWidget(self.main_widget)
self.resize(1800, 1200)
self.show()
def update(self):
'''
Random Forest Classifier
We pupulate the dashboard using the parametres chosen by the user
The parameters are processed to execute in the skit-learn Random Forest algorithm
then the results are presented in graphics and reports in the canvas
:return:None
'''
# processing the parameters
self.list_corr_features = pd.DataFrame([])
if self.feature0.isChecked():
if len(self.list_corr_features)==0:
self.list_corr_features = df[features_list[0]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[0]]],axis=1)
if self.feature1.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[1]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[1]]],axis=1)
if self.feature2.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[2]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[2]]],axis=1)
if self.feature3.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[3]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[3]]],axis=1)
if self.feature4.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[4]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[4]]],axis=1)
if self.feature5.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[5]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[5]]],axis=1)
if self.feature6.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[6]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[6]]],axis=1)
if self.feature7.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[7]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[7]]],axis=1)
if self.feature8.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[8]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[8]]],axis=1)
if self.feature9.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[9]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[9]]],axis=1)
if self.feature10.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[10]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[10]]], axis=1)
if self.feature11.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[11]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[11]]], axis=1)
if self.feature12.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[12]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[12]]], axis=1)
if self.feature13.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[13]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[13]]], axis=1)
if self.feature14.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[14]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[14]]], axis=1)
if self.feature15.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[15]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[15]]], axis=1)
if self.feature16.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[16]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[16]]], axis=1)
if self.feature17.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[17]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[17]]], axis=1)
if self.feature18.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[18]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[18]]], axis=1)
if self.feature19.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[19]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[19]]], axis=1)
if self.feature20.isChecked():
if len(self.list_corr_features)==0:
self.list_corr_features = df[features_list[20]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[20]]],axis=1)
if self.feature21.isChecked():
if len(self.list_corr_features) == 20:
self.list_corr_features = df[features_list[1]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[21]]],axis=1)
if self.feature22.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[22]]
else:
self.list_corr_features = pd.concat([self.list_corr_features, df[features_list[22]]],axis=1)
if self.feature23.isChecked():
if len(self.list_corr_features) == 0:
self.list_corr_features = df[features_list[23]]
else:
self.list_corr_features = | pd.concat([self.list_corr_features, df[features_list[23]]],axis=1) | pandas.concat |