sparse_nn_single_inference.hpp

Go to the documentation of this file.

/*
 *   Copyright 2021 Huawei Technologies Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _H_GRB_ALGORITHMS_SPARSE_NN_SINGLE_INFERENCE
#define _H_GRB_ALGORITHMS_SPARSE_NN_SINGLE_INFERENCE

#include <limits>
#include <graphblas.hpp>


namespace grb {

    namespace algorithms {

        namespace internal {

            template<
                Descriptor descr,
                bool thresholded, typename ThresholdType,
                typename IOType, typename WeightType, typename BiasType,
                class ReluMonoid, class Ring, class MinMonoid
            >
            grb::RC sparse_nn_single_inference(
                grb::Vector< IOType > &out,
                const grb::Vector< IOType > &in,
                const std::vector< grb::Matrix< WeightType > > &layers,
                const std::vector< BiasType > &biases,
                const ThresholdType threshold,
                grb::Vector< IOType > &temp,
                const ReluMonoid &relu,
                const MinMonoid &min,
                const Ring &ring
            ) {
                static_assert( !(descr & descriptors::no_casting) ||
                    (
                        std::is_same< IOType, WeightType >::value &&
                        std::is_same< IOType, BiasType >::value
                    ), "Input containers have different domains even though the no_casting"
                    "descriptor was given"
                );

                const size_t num_layers = layers.size();

                // run-time checks
                {
                    const size_t n = grb::size( out );
                    if( num_layers == 0 ) {
                        return ILLEGAL;
                    }
                    if( biases.size() != num_layers ) {
                        return ILLEGAL;
                    }
                    if( grb::size( in ) != grb::nrows( ( layers[ 0 ] ) ) ||
                        grb::size( out ) != grb::ncols( ( layers[ num_layers - 1 ] ) ) ||
                        grb::size( out ) != grb::size( temp )
                    ) {
                        return MISMATCH;
                    }
                    for( size_t i = 1; i < num_layers; ++i ) {
                        if( grb::ncols( ( layers[ i - 1 ] ) ) != grb::nrows( ( layers[ i ] ) ) ) {
                            return MISMATCH;
                        }
                    }
                    for( size_t i = 0; i < num_layers; ++i ) {
                        if( grb::ncols( ( layers[ i ] ) ) != grb::nrows( ( layers[ i ] ) ) ) {
                            return ILLEGAL;
                        }
                    }
                    assert( n == grb::size( in ) );
                    assert( n == grb::size( temp ) );
                    if( grb::capacity( out ) != n ) {
                        return ILLEGAL;
                    }
                    if( grb::capacity( temp ) != n ) {
                        return ILLEGAL;
                    }
                }

                grb::RC ret = SUCCESS;

    /*
                // this is a correct implementation that does not unroll the first and the last iterations
                // we do not use it because it requires setting the input vector to the output vector
                // which results in copying data for 2*n elements

                ret = grb::set( out, in );

                for( size_t i = 1; ret == SUCCESS && i < num_layers ; ++i ) {

                    std::swap( out, temp );
                    ret = ret ? ret : grb::set( out, 0 );
                    ret = ret ? ret : grb::vxm( out, temp, *(layers[ i - 1 ]), ring );
                    ret = ret ? ret : grb::foldl< descriptors::dense >( out, biases[ i ], ring.getAdditiveMonoid() );
                    ret = ret ? ret : grb::foldl< descriptors::dense >( out, 0, relu );
                    if( thresholded ) {
                        ret = ret ? ret : grb::foldl< descriptors::dense >( out, threshold, min );
                    }
                }
    */

                ret = grb::set( out, 0 ); assert( ret == SUCCESS );

                ret = ret ? ret : grb::vxm( out, in, ( layers[ 0 ] ), ring );
                assert( ret == SUCCESS );

                ret = ret ? ret : grb::foldl< descriptors::dense >(
                    out, biases[ 1 ], ring.getAdditiveMonoid()
                ); assert( ret == SUCCESS );

                for( size_t i = 1; ret == SUCCESS && i < num_layers - 1; ++i ) {

                    ret = ret ? ret : grb::foldl< descriptors::dense >( out, 0, relu );
                    assert( ret == SUCCESS );

                    if( thresholded ) {
                        ret = ret ? ret : grb::foldl< descriptors::dense >( out, threshold, min );
                        assert( ret == SUCCESS );
                    }

                    if( ret == SUCCESS ) {
                        std::swap( out, temp );
                    }

                    ret = grb::set( out, 0 );
                    assert( ret == SUCCESS );

                    ret = ret ? ret : grb::vxm< descriptors::dense >(
                        out, temp, ( layers[ i ] ), ring
                    ); assert( ret == SUCCESS );

                    ret = ret ? ret : grb::foldl< descriptors::dense >(
                        out, biases[ i + 1 ], ring.getAdditiveMonoid()
                    ); assert( ret == SUCCESS );
                }

                ret = ret ? ret : grb::foldl< descriptors::dense >( out, 0, relu );
                assert( ret == SUCCESS );

                if( thresholded ) {
                    ret = ret ? ret : grb::foldl< descriptors::dense >( out, threshold, min );
                    assert( ret == SUCCESS );
                }

                return ret;
            }

        } // end namespace ``grb::internal''

        template< Descriptor descr = descriptors::no_operation,
            typename IOType,
            typename WeightType,
            typename BiasType,
            class ReluMonoid = Monoid<
                grb::operators::relu< IOType >,
                grb::identities::negative_infinity
            >,
            class Ring = Semiring<
                grb::operators::add< IOType >, grb::operators::mul< IOType >,
                grb::identities::zero, grb::identities::one
            >
        >
        grb::RC sparse_nn_single_inference(
            grb::Vector< IOType > &out,
            const grb::Vector< IOType > &in,
            const std::vector< grb::Matrix< WeightType > > &layers,
            const std::vector< BiasType > &biases,
            grb::Vector< IOType > &temp,
            const ReluMonoid &relu = ReluMonoid(),
            const Ring &ring = Ring()
        ) {
            static_assert( !(descr & descriptors::no_casting) ||
                (
                    std::is_same< IOType, WeightType >::value &&
                    std::is_same< IOType, BiasType >::value
                ), "Input containers have different domains even though the no_casting "
                "descriptor was given" );
            Monoid<
                grb::operators::min< IOType >, grb::identities::infinity
            > dummyTresholdMonoid;
            return internal::sparse_nn_single_inference<
                descr, false, double
            > (
                out, in, layers,
                biases, 0.0,
                temp,
                relu, dummyTresholdMonoid, ring
            );
        }

        template< Descriptor descr = descriptors::no_operation,
            typename IOType,
            typename WeightType,
            typename BiasType,
            typename ThresholdType = IOType,
            class MinMonoid = Monoid<
                grb::operators::min< IOType >, grb::identities::infinity
            >,
            class ReluMonoid = Monoid<
                grb::operators::relu< IOType >,
                grb::identities::negative_infinity
            >,
            class Ring = Semiring<
                grb::operators::add< IOType >, grb::operators::mul< IOType >,
                grb::identities::zero, grb::identities::one
            >
        >
        grb::RC sparse_nn_single_inference(
            grb::Vector< IOType > &out,
            const grb::Vector< IOType > &in,
            const std::vector< grb::Matrix< WeightType > > &layers,
            const std::vector< BiasType > &biases,
            const ThresholdType threshold,
            grb::Vector< IOType > &temp,
            const ReluMonoid &relu = ReluMonoid(),
            const MinMonoid &min = MinMonoid(),
            const Ring &ring = Ring()
        ) {
            static_assert( !(descr & descriptors::no_casting) ||
                (
                    std::is_same< IOType, WeightType >::value &&
                    std::is_same< IOType, BiasType >::value
                ), "Input containers have different domains even though the no_casting "
                "descriptor was given" );
            return internal::sparse_nn_single_inference<
                descr, true
            > (
                out, in, layers,
                biases, threshold,
                temp,
                relu, min, ring
            );
        }

    } // namespace algorithms

} // end namespace grb

#endif // end _H_GRB_ALGORITHMS_SPARSE_NN_SINGLE_INFERENCE