def is_normalized_test(self):
"""Test TimeSeries.is_normalized()."""
ts = TimeSeries(isNormalized=True)
assert ts.is_normalized()
ts = TimeSeries(isNormalized=False)
assert ts.is_normalized()
ts.add_entry(0.1, 3.2)
ts.add_entry(0.4, 3.2)
ts.add_entry(0.3, 3.2)
assert False == ts.is_normalized()
def optimize_value_error_test(self):
"""Test the optimize call."""
bom = BaseOptimizationMethod(BaseErrorMeasure, precision=-3)
bm = BaseMethod()
bom.optimize(TimeSeries(), [bm])
try:
bom.optimize(TimeSeries(), [])
except ValueError:
pass
else:
assert False # pragma: no cover
def error_calculation_test(self):
"""Test the calculation of the MeanSquaredError."""
tsOrg = TimeSeries()
tsCalc = TimeSeries()
for idx in range(len(self.dataOrg)):
tsOrg.add_entry(float(idx), self.dataOrg[idx])
tsCalc.add_entry(float(idx), self.dataCalc[idx])
mse = MeanSquaredError()
mse.initialize(tsOrg, tsCalc)
self.assertEquals("0.1472", str(mse.get_error())[:6])
def error_calculation_test(self):
"""Test the calculation of the MeanAbsolutePercentageError."""
tsOrg = TimeSeries()
tsCalc = TimeSeries()
for idx in range(len(self.dataOrg)):
tsOrg.add_entry(float(idx), self.dataOrg[idx])
tsCalc.add_entry(float(idx), self.dataCalc[idx])
mape = MeanAbsolutePercentageError()
mape.initialize(tsOrg, tsCalc)
self.assertEquals("139.78", str(mape.get_error())[:6])
def error_calculation_test(self):
msd = MeanSignedDifferenceError()
tsOrg = TimeSeries()
tsCalc = TimeSeries()
for idx in xrange(len(self.dataOrg)):
tsOrg.add_entry(float(idx), self.dataOrg[idx])
tsCalc.add_entry(float(idx), self.dataCalc[idx])
msd.initialize(tsOrg, tsCalc)
self.assertEquals(str(msd.get_error())[:6], '0.0727')
def error_calculation_test(self):
""" Test error calculation for MedianAbsolutePercentageError"""
mdape = MedianAbsolutePercentageError()
tsOrg = TimeSeries()
tsCalc = TimeSeries()
for idx in range(len(self.dataOrg)):
tsOrg.add_entry(float(idx), self.dataOrg[idx])
tsCalc.add_entry(float(idx), self.dataCalc[idx])
mdape.initialize(tsOrg, tsCalc)
self.assertEqual(mdape.get_error(), 100)
self.assertEqual(mdape.get_error(20.0, 50.0), 50)
def execute(self, timeSeries):
"""Creates a new TimeSeries containing the SMA values for the predefined windowsize.
:param TimeSeries timeSeries: The TimeSeries used to calculate the simple moving average values.
:return: TimeSeries object containing the smooth moving average.
:rtype: TimeSeries
:raise: Raises a :py:exc:`ValueError` wif the defined windowsize is larger than the number of elements
in timeSeries
:note: This implementation aims to support independent for loop execution.
"""
windowsize = self._parameters["windowsize"]
if len (timeSeries) < windowsize:
raise ValueError("windowsize is larger than the number of elements in timeSeries.")
tsLength = len(timeSeries)
nbrOfLoopRuns = tsLength - windowsize + 1
res = TimeSeries()
for idx in xrange(nbrOfLoopRuns):
end = idx + windowsize
data = timeSeries[idx:end]
timestamp = data[windowsize//2][0]
value = sum([i[1] for i in data])/windowsize
res.add_entry(timestamp, value)
res.sort_timeseries()
return res
def error_calculation_test(self):
"""Test the calculation of the Mean Absolute Deviation Error."""
#dataPtsOrg = [2.30, .373, .583, 1.88, 1.44, -0.0852, -.341, .619, .131, 1.27, 0]
#dataPtsCalc = [-1.21, -.445, .466, .226, -.694, -.575, 2.73, -1.49, -1.45, -.193, 0]
tsOrg = TimeSeries()
tsCalc = TimeSeries()
for idx in xrange(len(self.dataOrg)):
tsOrg.add_entry(float(idx), self.dataOrg[idx])
tsCalc.add_entry(float(idx), self.dataCalc[idx])
mad = MeanAbsoluteDeviationError()
mad.initialize(tsOrg, tsCalc)
# compare the strings due to accuracy
self.assertEqual("0.3454", str(mad.get_error())[:6])
def energy_data():
"""
Connects to the database and loads Readings for device 8.
"""
cur = db.cursor().execute("""SELECT timestamp, current FROM Readings""")
original = TimeSeries()
original.initialize_from_sql_cursor(cur)
original.normalize("day", fusionMethod = "sum")
return itty.Response(json.dumps(original, cls=PycastEncoder), content_type='application/json')
def timeseries_sort_test(self):
"""Tests the sort_timeseries function."""
data = [[0.0, 0.0], [0.1, 0.1], [0.2, 0.2], [0.3, 0.3], [0.4, 0.4], [0.5, 0.5]]
ts = TimeSeries.from_twodim_list(data)
ts.sort_timeseries()
ts.sort_timeseries(False)
ts = TimeSeries(isSorted=True)
ts.sort_timeseries()
def validity_of___str___test(self):
"""Test the validity of __str__ for a given TimeSeries."""
ts = TimeSeries()
ts.add_entry(0.0, 0.0)
ts.add_entry(0.1, 0.1)
ts.add_entry(0.2, 0.2)
ts.add_entry(0.3, 0.3)
ts.add_entry(0.4, 0.4)
matchres = re.match("TimeSeries\(\[(.*)\]\)", ts.__str__())
assert (None != matchres)
def list_initialization_test(self):
"""Test TimeSeries initialization from a given list."""
data = [[0.0, 0.0], [0.1, 0.1], [0.2, 0.2], [0.3, 0.3], [0.4, 0.4], [0.5, 0.5]]
tsOne = TimeSeries()
for entry in data:
tsOne.add_entry(*entry)
tsTwo = TimeSeries.from_twodim_list(data)
if not (len(tsOne) == len(tsTwo)): raise AssertionError
if not (tsOne == tsTwo): raise AssertionError
def error_calculation_test(self):
"""Test the calculation of the SymmetricMeanAbsolutePercentageError."""
dataPtsOrg = [
2.30, .373, .583, 1.88, 1.44, -0.0852, -.341, .619, .131, 1.27, 0
]
dataPtsCalc = [
-1.21, -.445, .466, .226, -.694, -.575, 2.73, -1.49, -1.45, -.193,
0
]
tsOrg = TimeSeries()
tsCalc = TimeSeries()
for idx in xrange(len(dataPtsOrg)):
tsOrg.add_entry(float(idx), dataPtsOrg[idx])
tsCalc.add_entry(float(idx), dataPtsCalc[idx])
smape = SymmetricMeanAbsolutePercentageError()
smape.initialize(tsOrg, tsCalc)
## compare the strings due to accuracy
assert "1.5706" == str(smape.get_error())[:6]
def check_for_consistency_test(self):
"""Tests if database initialization and manual initialization create equal TimeSeries instances."""
# read the number of rows from the database
cur = self._db.cursor().execute("""SELECT COUNT(*) from TestTable""")
nbrOfTuples = cur.fetchall()[0][0]
# SQL extraction statement
sqlstmt = """SELECT timestamp, value FROM TestTable ORDER BY timestamp ASC"""
# Initialize one TimeSeries instance manually
tsManual = TimeSeries()
data = self._db.cursor().execute(sqlstmt).fetchall()
for entry in data:
tsManual.add_entry(str(entry[0]), entry[1])
# Initialize one TimeSeries from SQL cursor
tsAuto = TimeSeries()
tsAuto.initialize_from_sql_cursor(self._db.cursor().execute(sqlstmt))
# check if those TimeSeries are equal
assert (nbrOfTuples == len(tsManual))
assert (nbrOfTuples == len(tsAuto))
assert (len(tsManual) == len(tsAuto))
assert (tsManual == tsAuto)
def initialize_test(self):
"""Test if calculate throws an error as expected."""
data = [[0.0, 0.0], [1, 0.1], [2, 0.2], [3, 0.3], [4, 0.4]]
tsOrg = TimeSeries.from_twodim_list(data)
tsCalc = TimeSeries.from_twodim_list(data)
bem = BaseErrorMeasure()
try:
bem.initialize(tsOrg, tsCalc)
except NotImplementedError:
pass
else:
assert False # pragma: no cover
assert not bem.initialize(tsOrg, TimeSeries())
def method_test(self):
"""Test if TimeSeries apply branches work correctly.
This is mainly to increase code coverage."""
mOne = BaseMethod([], hasToBeSorted=True, hasToBeNormalized=True)
mTwo = BaseMethod([], hasToBeSorted=False, hasToBeNormalized=True)
mThree = BaseMethod([], hasToBeSorted=True, hasToBeNormalized=False)
mFour = BaseMethod([], hasToBeSorted=False, hasToBeNormalized=False)
ts = TimeSeries(isNormalized=True)
ts.add_entry(0.0, 0.0)
ts.add_entry(0.1, 0.1)
ts.add_entry(0.2, 0.2)
ts.add_entry(0.3, 0.3)
ts.add_entry(0.4, 0.4)
try:
ts.apply(mOne)
except NotImplementedError:
pass
else:
assert False # pragma: no cover
try:
ts.apply(mTwo)
except NotImplementedError:
pass
else:
assert False # pragma: no cover
try:
ts.apply(mThree)
except NotImplementedError:
pass
else:
assert False # pragma: no cover
try:
ts.apply(mFour)
except NotImplementedError:
pass
else:
assert False # pragma: no cover
def execute_value_error_test(self):
"""Test for the ValueError in SimpleMovingAverage.execute()."""
tsOne = TimeSeries()
data = [[1.5, 10.0], [2.5, 12.4], [3.5, 17.380000000000003],
[4.5, 16.666], [5.5, 20.6662], [6.5, 23.46634],
[7.5, 20.026438]]
tsTwo = TimeSeries.from_twodim_list(data)
sma = SimpleMovingAverage(3)
tsOne.normalize("second")
res = tsTwo.apply(sma)
try:
res = tsOne.apply(sma)
except ValueError:
pass
else:
assert False # pragma: no cover
def select_star_test(self):
"""SELECT * FROM TestTable
This function tests if statements like
SELECT * FROM
can be used to initialize a TimeSeries instance. TimeSeries should therefore only
take the first two attributes for data initialization, regardless of their names.
"""
# read the number of rows from the database
cur = self._db.cursor().execute("""SELECT COUNT(*) from TestTable""")
nbrOfTuples = cur.fetchall()[0][0]
# initialize a TimeSeries instance from a database cursor
cur = self._db.cursor().execute("""SELECT * FROM TestTable""")
ts = TimeSeries()
ts.initialize_from_sql_cursor(cur)
# check if all values of the database got inserted into the TimeSeries
assert len(ts) == nbrOfTuples
def create_from_empty_timeseries_test(self):
"""Test for :py:exc:`ValueError` when creating a Matrix from an empty Timeseries."""
ts = TimeSeries()
self.assertRaises(ValueError, Matrix.from_timeseries, ts)
from pycast.common.timeseries import TimeSeries
from pycast.methods import HoltWintersMethod
from pycast.optimization import GridSearch
from pycast.errors import SymmetricMeanAbsolutePercentageError as SMAPE
with open('MC1001_season_indices.csv', 'r') as season_indices:
season_indices.readline() #header
with open('MC1001.csv', 'r') as data_file:
counter = 1
for series_line in data_file.readlines()[1:]:
#series line has format: Series,N Obs,Seasonality,NF,Type,Starting date,Category,1,2,3 ...
series_tuples = series_line.split(',')
number_obeservations = int(series_tuples[1])
number_forecast = int(series_tuples[3])
orig = TimeSeries(isNormalized=True)
for i in range(number_obeservations):
orig.add_entry(
i,
series_tuples[i + 7]) #offset to first data entry in line
#print orig
forecast_check = TimeSeries(isNormalized=True)
for j in range(number_obeservations,
number_obeservations + number_forecast):
forecast_check.add_entry(j, float(series_tuples[j + 7]))
#print forecast_check
#Season indices are given in season file
season_indices_tuple = season_indices.readline().split(',')
