ift6266: utils/tables_series/series.py comparison

comparison utils/tables_series/series.py @ 210:dc0d77c8a878

Commented table_series code, changed ParamsStatisticsArray to take shared params instead, create DummySeries to use when we don't want to save a named series

author	savardf
date	Tue, 09 Mar 2010 10:15:19 -0500
parents	acb942530923
children

comparison

equal deleted inserted replaced

-:d982dfa583df
+:dc0d77c8a878
 are retrieved based on the variable name, which we can't programmatically set
 otherwise.
 '''
 def get_beginning_description_n_ints(int_names, int_width=64):
+"""
+Begins construction of a class inheriting from IsDescription
+to construct an HDF5 table with index columns named with int_names.
+See Series().__init__ to see how those are used.
+"""
 int_constructor = "Int64Col"
 if int_width == 32:
 int_constructor = "Int32Col"
 toexec = "class LocalDescription(IsDescription):\n"
 return LocalDescription
 class Series():
 def __init__(self, table_name, hdf5_file, index_names=('epoch',), title=None, hdf5_group='/'):
-"""This is used as metadata in the HDF5 file to identify the series"""
+"""Basic arguments each Series must get.
+Parameters
+----------
+table_name : str
+Name of the table to create under group "hd5_group" (other parameter). No spaces, ie. follow variable naming restrictions.
+hdf5_file : open HDF5 file
+File opened with openFile() in PyTables (ie. return value of openFile).
+index_names : tuple of str
+Columns to use as index for elements in the series, other example would be ('epoch', 'minibatch'). This would then allow you to call append(index, element) with index made of two ints, one for epoch index, one for minibatch index in epoch.
+title : str
+Title to attach to this table as metadata. Can contain spaces and be longer then the table_name.
+hdf5_group : str
+Path of the group (kind of a file) in the HDF5 file under which to create the table.
+"""
 self.table_name = table_name
 self.hdf5_file = hdf5_file
 self.index_names = index_names
 self.title = title
 def append(self, index, element):
 raise NotImplementedError
+# To put in a series dictionary instead of a real series, to do nothing
+# when we don't want a given series to be saved.
+class DummySeries():
+def append(self, index, element):
+pass
 class ErrorSeries(Series):
 def __init__(self, error_name, table_name, hdf5_file, index_names=('epoch',), title=None, hdf5_group='/'):
 Series.__init__(self, table_name, hdf5_file, index_names, title)
 self.error_name = error_name
 def _get_table_description(self):
 return get_description_with_n_ints_n_floats(self.index_names, (self.error_name,))
 def append(self, index, error):
+"""
+Parameters
+----------
+index : tuple of int
+Following index_names passed to __init__, e.g. (12, 15) if index_names were ('epoch', 'minibatch_size')
+error : float
+Next error in the series.
+"""
 if len(index) != len(self.index_names):
 raise ValueError("index provided does not have the right length (expected " \
 + str(len(self.index_names)) + " got " + str(len(index)))
 newrow = self._table.row
+# Columns for index in table are based on index_names
 for col_name, value in zip(self.index_names, index):
 newrow[col_name] = value
 newrow[self.error_name] = error
 newrow.append()
 class AccumulatorSeriesWrapper():
 """
 """
 def __init__(self, base_series, reduce_every, reduce_function=numpy.mean):
+"""
+Parameters
+----------
+base_series : Series
+This object must have an append(index, value) function.
+reduce_every : int
+Apply the reduction function (e.g. mean()) every time we get this number of elements. E.g. if this is 100, then every 100 numbers passed to append(), we'll take the mean and call append(this_mean) on the BaseSeries.
+reduce_function : function
+Must take as input an array of "elements", as passed to (this accumulator's) append(). Basic case would be to take an array of floats and sum them into one float, for example.
+"""
 self.base_series = base_series
 self.reduce_function = reduce_function
 self.reduce_every = reduce_every
 self._buffer = []
 ----------
 index : tuple of int
 The index used is the one of the last element reduced. E.g. if
 you accumulate over the first 1000 minibatches, the index
 passed to the base_series.append() function will be 1000.
+element : float
+Element that will be accumulated.
 """
 self._buffer.append(element)
 if len(self._buffer) == self.reduce_every:
 reduced = self.reduce_function(self._buffer)
 # were appended, which should be a red flag.
 assert len(self._buffer) < self.reduce_every
 # Outside of class to fix an issue with exec in Python 2.6.
 # My sorries to the God of pretty code.
-def BasicStatisticsSeries_construct_table_toexec(index_names):
+def _BasicStatisticsSeries_construct_table_toexec(index_names):
 toexec = get_beginning_description_n_ints(index_names)
 bpos = len(index_names)
 toexec += "\tmean = Float32Col(pos=" + str(bpos) + ")\n"
 toexec += "\tmin = Float32Col(pos=" + str(bpos+1) + ")\n"
 # This creates "LocalDescription", which we may then use
 exec(toexec)
 return LocalDescription
+basic_stats_functions = {'mean': lambda(x): numpy.mean(x),
+'min': lambda(x): numpy.min(x),
+'max': lambda(x): numpy.max(x),
+'std': lambda(x): numpy.std(x)}
 class BasicStatisticsSeries(Series):
 """
 Parameters
 ----------
 series_name : str
 Not optional here. Will be prepended with "Basic statistics for "
-"""
+stats_functions : dict, optional
-def __init__(self, table_name, hdf5_file, index_names=('epoch',), title=None, hdf5_group='/'):
+Dictionary with a function for each key "mean", "min", "max", "std". The function must take whatever is passed to append(...) and return a single number (float).
+"""
+def __init__(self, table_name, hdf5_file, stats_functions=basic_stats_functions, index_names=('epoch',), title=None, hdf5_group='/'):
 Series.__init__(self, table_name, hdf5_file, index_names, title)
 self.hdf5_group = hdf5_group
-self.construct_table()
+self.stats_functions = stats_functions
-def construct_table(self):
+self._construct_table()
-table_description = BasicStatisticsSeries_construct_table_toexec(self.index_names)
+def _construct_table(self):
+table_description = _BasicStatisticsSeries_construct_table_toexec(self.index_names)
 self._table = self.hdf5_file.createTable(self.hdf5_group, self.table_name, table_description)
 def append(self, index, array):
+"""
+Parameters
+----------
+index : tuple of int
+Following index_names passed to __init__, e.g. (12, 15) if index_names were ('epoch', 'minibatch_size')
+array
+Is of whatever type the stats_functions passed to __init__ can take. Default is anything numpy.mean(), min(), max(), std() can take.
+"""
 if len(index) != len(self.index_names):
 raise ValueError("index provided does not have the right length (expected " \
 + str(len(self.index_names)) + " got " + str(len(index)))
 newrow = self._table.row
 for col_name, value in zip(self.index_names, index):
 newrow[col_name] = value
-newrow["mean"] = numpy.mean(array)
+newrow["mean"] = self.stats_functions['mean'](array)
-newrow["min"] = numpy.min(array)
+newrow["min"] = self.stats_functions['min'](array)
-newrow["max"] = numpy.max(array)
+newrow["max"] = self.stats_functions['max'](array)
-newrow["std"] = numpy.std(array)
+newrow["std"] = self.stats_functions['std'](array)
 newrow.append()
 self.hdf5_file.flush()
 class SeriesArrayWrapper():
 """
 Simply redistributes any number of elements to sub-series to respective append()s.
+To use if you have many elements to append in similar series, e.g. if you have an array containing [train_error, valid_error, test_error], and 3 corresponding series, this allows you to simply pass this array of 3 values to append() instead of passing each element to each individual series in turn.
 """
 def __init__(self, base_series_list):
 self.base_series_list = base_series_list
 + str(len(self.base_series_list)) + " got " + str(len(elements)))
 for series, el in zip(self.base_series_list, elements):
 series.append(index, el)
-class ParamsStatisticsWrapper(SeriesArrayWrapper):
+class SharedParamsStatisticsWrapper(SeriesArrayWrapper):
+'''Save mean, min/max, std of shared parameters place in an array.
+This is specifically for cases where we have _shared_ parameters,
+as we take the .value of each array'''
 def __init__(self, arrays_names, new_group_name, hdf5_file, base_group='/', index_names=('epoch',), title=""):
+"""
+Parameters
+----------
+array_names : array of str
+Name of each array, in order of the array passed to append(). E.g. ('layer1_b', 'layer1_W', 'layer2_b', 'layer2_W')
+new_group_name : str
+Name of a new HDF5 group which will be created under base_group to store the new series.
+base_group : str
+Path of the group under which to create the new group which will store the series.
+title : str
+Here the title is attached to the new group, not a table.
+"""
 base_series_list = []
 new_group = hdf5_file.createGroup(base_group, new_group_name, title=title)
+stats_functions = {'mean': lambda(x): numpy.mean(x.value),
+'min': lambda(x): numpy.min(x.value),
+'max': lambda(x): numpy.max(x.value),
+'std': lambda(x): numpy.std(x.value)}
 for name in arrays_names:
 base_series_list.append(
 BasicStatisticsSeries(
 table_name=name,
 hdf5_file=hdf5_file,
-index_names=('epoch','minibatch'),
+index_names=index_names,
+stats_functions=stats_functions,
 hdf5_group=new_group._v_pathname))
 SeriesArrayWrapper.__init__(self, base_series_list)

Mercurial > ift6266

comparison utils/tables_series/series.py @ 210:dc0d77c8a878