pooling_layer.cpp

//   OpenNN: Open Neural Networks Library
//   www.opennn.net
//
//   P O O L I N G   L A Y E R   C L A S S
//
//   Artificial Intelligence Techniques SL
//   artelnics@artelnics.com
 
#include "pooling_layer.h"
 
namespace OpenNN
{
 
 
PoolingLayer::PoolingLayer() : Layer()
{
    set_default();
}
 
 
PoolingLayer::PoolingLayer(const Tensor<Index, 1>& new_input_variables_dimensions) : Layer()
{
    set_default();
}
 
 
 
PoolingLayer::PoolingLayer(const Tensor<Index, 1>& new_input_variables_dimensions, const Tensor<Index, 1>& pool_dimensions) : Layer()
{
    pool_rows_number = pool_dimensions[0];
 
    pool_columns_number = pool_dimensions[1];
 
    set_default();
}
 
 
 
PoolingLayer::~PoolingLayer()
{
}
 
 
 
Tensor<type, 4> PoolingLayer::calculate_outputs(const Tensor<type, 4>& inputs)
{
#ifdef OPENNN_DEBUG
 
    const Index input_variables_dimensions_number = inputs.rank();
 
    if(input_variables_dimensions_number != 4)
    {
        ostringstream buffer;
 
        buffer << "OpenNN Exception: ConvolutionalLayer class.\n"
               << "Tensor<type, 2> calculate_outputs(const Tensor<type, 2>&) method.\n"
               << "Number of inputs dimensions (" << input_variables_dimensions_number << ") must be 4 (batch, filters, rows, columns).\n";
 
        throw logic_error(buffer.str());
    }
 
#endif
 
    switch(pooling_method)
    {
    case PoolingMethod::NoPooling:
        return calculate_no_pooling_outputs(inputs);
 
    case PoolingMethod::MaxPooling:
        return calculate_max_pooling_outputs(inputs);
 
    case PoolingMethod::AveragePooling:
        return calculate_average_pooling_outputs(inputs);
    }
 
    return Tensor<type, 4>();
}
 
 
 
Tensor<type, 4> PoolingLayer::calculate_average_pooling_outputs(const Tensor<type, 4>& inputs) const
{
    const Index images_number = inputs.dimension(0);
 
    const Index channels_number = inputs.dimension(1);
 
    const Index inputs_rows_number = inputs.dimension(2);
 
    const Index inputs_columns_number = inputs.dimension(3);
 
    const Index outputs_rows_number = (inputs_rows_number - pool_rows_number)/row_stride + 1;
 
    const Index outputs_columns_number = (inputs_columns_number - pool_columns_number)/column_stride + 1;
 
    Tensor<type, 4> outputs(images_number, channels_number, outputs_rows_number, outputs_columns_number);
 
    for(Index image_index = 0; image_index < images_number; image_index ++)
    {
        for(Index channel_index = 0; channel_index < channels_number; channel_index ++)
        {
            for(Index row_index = 0; row_index < outputs_rows_number; row_index ++)
            {
                for(Index column_index = 0; column_index < outputs_columns_number; column_index ++)
                {
                    outputs(image_index, channel_index, row_index, column_index) = type(0);
 
                    for(Index window_row = 0; window_row < pool_rows_number; window_row ++)
                    {
                        const Index row = row_index*row_stride + window_row;
 
                        for(Index window_column = 0; window_column < pool_columns_number; window_column ++)
                        {
                            const Index column = column_index*column_stride + window_column;
 
                            outputs(image_index, channel_index, row_index, column_index) += inputs(image_index, channel_index, row, column);
                        }
                    }
 
                    outputs(image_index, channel_index, row_index, column_index) /= type(pool_rows_number*pool_columns_number);
                }
            }
        }
    }
 
    return outputs;
}
 
 
 
Tensor<type, 4> PoolingLayer::calculate_no_pooling_outputs(const Tensor<type, 4>& inputs) const
{
    return inputs;
}
 
 
 
Tensor<type, 4> PoolingLayer::calculate_max_pooling_outputs(const Tensor<type, 4>& inputs) const
{
    const Index images_number = inputs.dimension(0);
 
    const Index channels_number = inputs.dimension(1);
 
    const Index inputs_rows_number = inputs.dimension(2);
 
    const Index inputs_columns_number = inputs.dimension(3);
 
    const Index outputs_rows_number = (inputs_rows_number - pool_rows_number)/row_stride + 1;
 
    const Index outputs_columns_number = (inputs_columns_number - pool_columns_number)/column_stride + 1;
 
    Tensor<type, 4> outputs(images_number, channels_number, outputs_rows_number, outputs_columns_number);
 
    for(Index image_index = 0; image_index < images_number; image_index ++)
    {
        for(Index channel_index = 0; channel_index < channels_number; channel_index ++)
        {
            for(Index row_index = 0; row_index < outputs_rows_number; row_index ++)
            {
                for(Index column_index = 0; column_index < outputs_columns_number; column_index ++)
                {
                    outputs(image_index, channel_index, row_index, column_index) =
                            inputs(image_index, channel_index, row_index*row_stride, column_index*column_stride);
 
                    for(Index window_row = 0; window_row < pool_rows_number; window_row ++)
                    {
                        const Index row = row_index*row_stride + window_row;
 
                        for(Index window_column = 0; window_column < pool_columns_number; window_column ++)
                        {
                            const Index column = column_index*column_stride + window_column;
 
                            if(inputs(image_index, channel_index, row, column) > outputs(image_index, channel_index, row_index, column_index))
                            {
                                outputs(image_index, channel_index, row_index, column_index) = inputs(image_index, channel_index, row, column);
                            }
 
                        }
                    }
                }
            }
        }
    }
 
    return outputs;
}
 
 
Tensor<type, 4> PoolingLayer::calculate_hidden_delta(Layer* next_layer_pointer,
        const Tensor<type, 4>& activations,
        const Tensor<type, 4>& activations_derivatives,
        const Tensor<type, 4>& next_layer_delta) const
{
    if(pooling_method == PoolingMethod::NoPooling) return next_layer_delta;
 
    else
    {
        const Type layer_type = next_layer_pointer->get_type();
 
        if(layer_type == Type::Convolutional)
        {
            ConvolutionalLayer* convolutional_layer = dynamic_cast<ConvolutionalLayer*>(next_layer_pointer);
 
            return calculate_hidden_delta_convolutional(convolutional_layer, activations, activations_derivatives, next_layer_delta);
        }
        else if(layer_type == Type::Pooling)
        {
            PoolingLayer* pooling_layer = dynamic_cast<PoolingLayer*>(next_layer_pointer);
 
            return calculate_hidden_delta_pooling(pooling_layer, activations, activations_derivatives, next_layer_delta);
        }
        else if(layer_type == Type::Perceptron)
        {
            PerceptronLayer* perceptron_layer = static_cast<PerceptronLayer*>(next_layer_pointer);
 
            return calculate_hidden_delta_perceptron(perceptron_layer, activations, activations_derivatives, next_layer_delta);
        }
        else if(layer_type == Type::Probabilistic)
        {
            ProbabilisticLayer* probabilistic_layer = dynamic_cast<ProbabilisticLayer*>(next_layer_pointer);
 
            return calculate_hidden_delta_probabilistic(probabilistic_layer, activations, activations_derivatives, next_layer_delta);
        }
    }
 
    return Tensor<type, 4>();
}
 
 
Tensor<type, 4> PoolingLayer::calculate_hidden_delta_convolutional(ConvolutionalLayer* next_layer_pointer,
        const Tensor<type, 4>&,
        const Tensor<type, 4>&,
        const Tensor<type, 4>& next_layer_delta) const
{
    // Current layer's values
 
    const Index images_number = next_layer_delta.dimension(0);
    const Index channels_number = get_inputs_channels_number();
    const Index output_rows_number = get_outputs_rows_number();
    const Index output_columns_number = get_outputs_columns_number();
 
    // Next layer's values
 
    const Index next_layers_filters_number = next_layer_pointer->get_kernels_number();
    const Index next_layers_filter_rows = next_layer_pointer->get_kernels_rows_number();
    const Index next_layers_filter_columns = next_layer_pointer->get_kernels_columns_number();
    const Index next_layers_output_rows = next_layer_pointer->get_outputs_rows_number();
    const Index next_layers_output_columns = next_layer_pointer->get_outputs_columns_number();
    const Index next_layers_row_stride = next_layer_pointer->get_row_stride();
    const Index next_layers_column_stride = next_layer_pointer->get_column_stride();
 
    const Tensor<type, 4> next_layers_weights = next_layer_pointer->get_synaptic_weights();
 
    // Hidden delta calculation
 
        Tensor<type, 4> hidden_delta(images_number, channels_number, output_rows_number, output_columns_number);
 
        const Index size = hidden_delta.size();
 
        #pragma omp parallel for
 
        for(Index tensor_index = 0; tensor_index < size; tensor_index++)
        {
            const Index image_index = tensor_index/(channels_number*output_rows_number*output_columns_number);
            const Index channel_index = (tensor_index/(output_rows_number*output_columns_number))%channels_number;
            const Index row_index = (tensor_index/output_columns_number)%output_rows_number;
            const Index column_index = tensor_index%output_columns_number;
 
            type sum = type(0);
 
            const Index lower_row_index = (row_index - next_layers_filter_rows)/next_layers_row_stride + 1;
            const Index upper_row_index = min(row_index/next_layers_row_stride + 1, next_layers_output_rows);
            const Index lower_column_index = (column_index - next_layers_filter_columns)/next_layers_column_stride + 1;
            const Index upper_column_index = min(column_index/next_layers_column_stride + 1, next_layers_output_columns);
 
            for(Index i = 0; i < next_layers_filters_number; i++)
            {
                for(Index j = lower_row_index; j < upper_row_index; j++)
                {
                    for(Index k = lower_column_index; k < upper_column_index; k++)
                    {
                        const type delta_element = next_layer_delta(image_index, i, j, k);
 
                        const type weight = next_layers_weights(i, channel_index, row_index - j*next_layers_row_stride, column_index - k*next_layers_column_stride);
 
                        sum += delta_element*weight;
                    }
                }
            }
 
            hidden_delta(image_index, channel_index, row_index, column_index) = sum;
        }
 
        return hidden_delta;
}
 
 
Tensor<type, 4> PoolingLayer::calculate_hidden_delta_pooling(PoolingLayer* next_layer_pointer,
        const Tensor<type, 4>& activations,
        const Tensor<type, 4>&,
        const Tensor<type, 4>& next_layer_delta) const
{
        switch(next_layer_pointer->get_pooling_method())
        {
            case OpenNN::PoolingLayer::PoolingMethod::NoPooling:
            {
                return next_layer_delta;
            }
 
            case OpenNN::PoolingLayer::PoolingMethod::AveragePooling:
            {
                // Current layer's values
 
                const Index images_number = next_layer_delta.dimension(0);
                const Index channels_number = get_inputs_channels_number();
                const Index output_rows_number = get_outputs_rows_number();
                const Index output_columns_number = get_outputs_columns_number();
 
                // Next layer's values
 
                const Index next_layers_pool_rows = next_layer_pointer->get_pool_rows_number();
                const Index next_layers_pool_columns = next_layer_pointer->get_pool_columns_number();
                const Index next_layers_output_rows = next_layer_pointer->get_outputs_rows_number();
                const Index next_layers_output_columns = next_layer_pointer->get_outputs_columns_number();
                const Index next_layers_row_stride = next_layer_pointer->get_row_stride();
                const Index next_layers_column_stride = next_layer_pointer->get_column_stride();
 
                // Hidden delta calculation
 
                Tensor<type, 4> hidden_delta(images_number, channels_number, output_rows_number, output_columns_number);
 
                const Index size = hidden_delta.size();
 
                #pragma omp parallel for
 
                for(Index tensor_index = 0; tensor_index < size; tensor_index++)
                {
                    const Index image_index = tensor_index/(channels_number*output_rows_number*output_columns_number);
                    const Index channel_index = (tensor_index/(output_rows_number*output_columns_number))%channels_number;
                    const Index row_index = (tensor_index/output_columns_number)%output_rows_number;
                    const Index column_index = tensor_index%output_columns_number;
 
                    type sum = type(0);
 
                    const Index lower_row_index = (row_index - next_layers_pool_rows)/next_layers_row_stride + 1;
                    const Index upper_row_index = min(row_index/next_layers_row_stride + 1, next_layers_output_rows);
                    const Index lower_column_index = (column_index - next_layers_pool_columns)/next_layers_column_stride + 1;
                    const Index upper_column_index = min(column_index/next_layers_column_stride + 1, next_layers_output_columns);
 
                    for(Index i = lower_row_index; i < upper_row_index; i++)
                    {
                        for(Index j = lower_column_index; j < upper_column_index; j++)
                        {
                            const type delta_element = next_layer_delta(image_index, channel_index, i, j);
 
                            sum += delta_element;
                        }
                    }
 
                    hidden_delta(image_index, channel_index, row_index, column_index) = sum;
                }
 
//                return hidden_delta/(next_layers_pool_rows*next_layers_pool_columns);
            }
 
            case OpenNN::PoolingLayer::PoolingMethod::MaxPooling:
            {
                // Current layer's values
 
                const Index images_number = next_layer_delta.dimension(0);
                const Index channels_number = get_inputs_channels_number();
                const Index output_rows_number = get_outputs_rows_number();
                const Index output_columns_number = get_outputs_columns_number();
 
                // Next layer's values
 
                const Index next_layers_pool_rows = next_layer_pointer->get_pool_rows_number();
                const Index next_layers_pool_columns = next_layer_pointer->get_pool_columns_number();
                const Index next_layers_output_rows = next_layer_pointer->get_outputs_rows_number();
                const Index next_layers_output_columns = next_layer_pointer->get_outputs_columns_number();
                const Index next_layers_row_stride = next_layer_pointer->get_row_stride();
                const Index next_layers_column_stride = next_layer_pointer->get_column_stride();
 
                // Hidden delta calculation
 
                Tensor<type, 4> hidden_delta(images_number, channels_number, output_rows_number, output_columns_number);
 
                const Index size = hidden_delta.size();
 
                #pragma omp parallel for
 
                for(Index tensor_index = 0; tensor_index < size; tensor_index++)
                {
                    const Index image_index = tensor_index/(channels_number*output_rows_number*output_columns_number);
                    const Index channel_index = (tensor_index/(output_rows_number*output_columns_number))%channels_number;
                    const Index row_index = (tensor_index/output_columns_number)%output_rows_number;
                    const Index column_index = tensor_index%output_columns_number;
 
                    type sum = type(0);
 
                    const Index lower_row_index = (row_index - next_layers_pool_rows)/next_layers_row_stride + 1;
                    const Index upper_row_index = min(row_index/next_layers_row_stride + 1, next_layers_output_rows);
                    const Index lower_column_index = (column_index - next_layers_pool_columns)/next_layers_column_stride + 1;
                    const Index upper_column_index = min(column_index/next_layers_column_stride + 1, next_layers_output_columns);
 
                    for(Index i = lower_row_index; i < upper_row_index; i++)
                    {
                        for(Index j = lower_column_index; j < upper_column_index; j++)
                        {
                            Tensor<type, 2> activations_current_submatrix(next_layers_pool_rows, next_layers_pool_columns);
 
                            for(Index submatrix_row_index = 0; submatrix_row_index < next_layers_pool_rows; submatrix_row_index++)
                            {
                                for(Index submatrix_column_index = 0; submatrix_column_index < next_layers_pool_columns; submatrix_column_index++)
                                {
                                    activations_current_submatrix(submatrix_row_index, submatrix_column_index) =
                                            activations(image_index, channel_index, i*next_layers_row_stride + submatrix_row_index, j*next_layers_column_stride + submatrix_column_index);
                                }
                            }
 
                            Tensor<type, 2> multiply_not_multiply(next_layers_pool_rows, next_layers_pool_columns);
 
                            type max_value = activations_current_submatrix(0,0);
 
                            for(Index submatrix_row_index = 0; submatrix_row_index < next_layers_pool_rows; submatrix_row_index++)
                            {
                                for(Index submatrix_column_index = 0; submatrix_column_index < next_layers_pool_columns; submatrix_column_index++)
                                {
                                    if(activations_current_submatrix(submatrix_row_index, submatrix_column_index) > max_value)
                                    {
                                        max_value = activations_current_submatrix(submatrix_row_index, submatrix_column_index);
 
                                        //multiply_not_multiply.resize(next_layers_pool_rows, next_layers_pool_columns, 0.0);
                                        //multiply_not_multiply(submatrix_row_index, submatrix_column_index) = type(1);
                                    }
                                }
                            }
 
                            const type delta_element = next_layer_delta(image_index, channel_index, i, j);
 
                            const type max_derivative = multiply_not_multiply(row_index - i*next_layers_row_stride, column_index - j*next_layers_column_stride);
 
                            sum += delta_element*max_derivative;
                        }
                    }
 
                    hidden_delta(image_index, channel_index, row_index, column_index) = sum;
                }
 
                return hidden_delta;
            }
        }
 
    return Tensor<type, 4>();
}
 
 
Tensor<type, 4> PoolingLayer::calculate_hidden_delta_perceptron(PerceptronLayer* next_layer_pointer,
        const Tensor<type, 4>&,
        const Tensor<type, 4>&,
        const Tensor<type, 4>& next_layer_delta) const
{
    // Current layer's values
 
    const Index images_number = next_layer_delta.dimension(0);
    const Index channels_number = get_inputs_channels_number();
    const Index output_rows_number = get_outputs_rows_number();
    const Index output_columns_number = get_outputs_columns_number();
 
    // Next layer's values
 
    const Index next_layers_output_columns = next_layer_delta.dimension(1);
 
    const Tensor<type, 2> next_layers_weights = next_layer_pointer->get_synaptic_weights();
 
    // Hidden delta calculation
 
    Tensor<type, 4> hidden_delta(images_number, channels_number, output_rows_number, output_columns_number);
 
    const Index size = hidden_delta.size();
 
    #pragma omp parallel for
 
    for(Index tensor_index = 0; tensor_index < size; tensor_index++)
    {
        //Index image_index = tensor_index/(channels_number*output_rows_number*output_columns_number);
        //Index channel_index = (tensor_index/(output_rows_number*output_columns_number))%channels_number;
        //Index row_index = (tensor_index/output_columns_number)%output_rows_number;
        //Index column_index = tensor_index%output_columns_number;
 
        //type sum = type(0);
 
        for(Index sum_index = 0; sum_index < next_layers_output_columns; sum_index++)
        {
            //const type delta_element = next_layer_delta(image_index, sum_index);
 
            //const type weight = next_layers_weights(channel_index + row_index*channels_number + column_index*channels_number*output_rows_number, sum_index);
 
            //sum += delta_element*weight;
        }
 
        //hidden_delta(image_index, channel_index, row_index, column_index) = sum;
    }
 
    return hidden_delta;
}
 
 
Tensor<type, 4> PoolingLayer::calculate_hidden_delta_probabilistic(ProbabilisticLayer* next_layer_pointer,
        const Tensor<type, 4>&,
        const Tensor<type, 4>&,
        const Tensor<type, 4>& next_layer_delta) const
{
    // Current layer's values
 
    const Index images_number = next_layer_delta.dimension(0);
    const Index channels_number = get_inputs_channels_number();
    const Index output_rows_number = get_outputs_rows_number();
    const Index output_columns_number = get_outputs_columns_number();
 
    // Next layer's values
 
    const Index next_layers_output_columns = next_layer_delta.dimension(1);
 
    const Tensor<type, 2> next_layers_weights = next_layer_pointer->get_synaptic_weights();
 
    // Hidden delta calculation
 
    Tensor<type, 4> hidden_delta(images_number, channels_number, output_rows_number, output_columns_number);
 
    const Index size = hidden_delta.size();
 
    #pragma omp parallel for
 
    for(Index tensor_index = 0; tensor_index < size; tensor_index++)
    {
        //const Index image_index = tensor_index/(channels_number*output_rows_number*output_columns_number);
        //const Index channel_index = (tensor_index/(output_rows_number*output_columns_number))%channels_number;
        //const Index row_index = (tensor_index/output_columns_number)%output_rows_number;
        //const Index column_index = tensor_index%output_columns_number;
 
        //type sum = type(0);
 
        for(Index sum_index = 0; sum_index < next_layers_output_columns; sum_index++)
        {
            // const type delta_element = next_layer_delta(image_index, sum_index);
 
            // const type weight = next_layers_weights(channel_index + row_index*channels_number + column_index*channels_number*output_rows_number, sum_index);
 
            // sum += delta_element*weight;
        }
 
        //hidden_delta(image_index, channel_index, row_index, column_index) = sum;
    }
 
    return hidden_delta;
}
 
 
Tensor<type, 1> PoolingLayer::calculate_error_gradient(const Tensor<type, 2>&,
        const LayerForwardPropagation&,
        const Tensor<type, 2>&)
{
    return Tensor<type, 1>();
}
 
 
 
Index PoolingLayer::get_neurons_number() const
{
    return get_outputs_rows_number() * get_outputs_columns_number();
}
 
 
 
Tensor<Index, 1> PoolingLayer::get_outputs_dimensions() const
{
    Tensor<Index, 1> outputs_dimensions(3);
 
//    outputs_dimensions[0] = input_variables_dimensions[0];
//    outputs_dimensions[1] = get_outputs_rows_number();
//    outputs_dimensions[2] = get_outputs_columns_number();
 
    return outputs_dimensions;
}
 
 
 
Index PoolingLayer::get_inputs_number() const
{
    return input_variables_dimensions.size();
}
 
 
 
Index PoolingLayer::get_inputs_channels_number() const
{
//    return input_variables_dimensions[0];
 
    return 0;
}
 
 
 
Index PoolingLayer::get_inputs_rows_number() const
{
//    return input_variables_dimensions[1];
 
    return 0;
}
 
 
 
Index PoolingLayer::get_inputs_columns_number() const
{
//    return input_variables_dimensions[2];
 
    return 0;
}
 
 
 
Index PoolingLayer::get_outputs_rows_number() const
{
//    return (input_variables_dimensions[1] - pool_rows_number)/row_stride + 1;
 
    return 0;
}
 
 
 
Index PoolingLayer::get_outputs_columns_number() const
{
//    return (input_variables_dimensions[2] - pool_columns_number)/column_stride + 1;
 
    return 0;
}
 
 
 
Index PoolingLayer::get_padding_width() const
{
    return padding_width;
}
 
 
 
Index PoolingLayer::get_row_stride() const
{
    return row_stride;
}
 
 
 
Index PoolingLayer::get_column_stride() const
{
    return column_stride;
}
 
 
 
Index PoolingLayer::get_pool_rows_number() const
{
    return pool_rows_number;
}
 
 
 
Index PoolingLayer::get_pool_columns_number() const
{
    return pool_columns_number;
}
 
 
 
Index PoolingLayer::get_parameters_number() const
{
    return 0;
}
 
 
 
Tensor<type, 1> PoolingLayer::get_parameters() const
{
    return Tensor<type, 1>();
}
 
 
 
PoolingLayer::PoolingMethod PoolingLayer::get_pooling_method() const
{
    return pooling_method;
}
 
 
 
void PoolingLayer::set_input_variables_dimensions(const Tensor<Index, 1>& new_input_variables_dimensions)
{
    input_variables_dimensions = new_input_variables_dimensions;
}
 
 
 
void PoolingLayer::set_padding_width(const Index& new_padding_width)
{
    padding_width = new_padding_width;
}
 
 
 
void PoolingLayer::set_row_stride(const Index& new_row_stride)
{
    row_stride = new_row_stride;
}
 
 
 
void PoolingLayer::set_column_stride(const Index& new_column_stride)
{
    column_stride = new_column_stride;
}
 
 
 
void PoolingLayer::set_pool_size(const Index& new_pool_rows_number,
                                 const Index& new_pool_columns_number)
{
    pool_rows_number = new_pool_rows_number;
 
    pool_columns_number = new_pool_columns_number;
}
 
 
 
void PoolingLayer::set_pooling_method(const PoolingMethod& new_pooling_method)
{
    pooling_method = new_pooling_method;
}
 
 
 
void PoolingLayer::set_default()
{
    layer_type = Layer::Type::Pooling;
}
}
 
// OpenNN: Open Neural Networks Library.
// Copyright(C) 2005-2021 Artificial Intelligence Techniques, SL.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
 
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA