tensor_expr_ext.h

Go to the documentation of this file.

#ifndef MSHADOW_TENSOR_EXPR_EXT_H
#define MSHADOW_TENSOR_EXPR_EXT_H

#include "tensor_expr_engine-inl.hpp"
namespace mshadow{
    // Declaration of expressions goes here
    namespace expr{
        template<typename Device, int dimdst, int dimcast>
        struct Broadcast1DExp: public MakeTensorExp< Broadcast1DExp<Device,dimdst,dimcast>,Tensor<Device,1>,dimdst>{
            const Tensor<Device,1> src_;
            Broadcast1DExp( const Tensor<Device,1> &src, Shape<dimdst> shape ):src_(src){
                this->shape_ = shape;
            }
        };

        template<typename SrcExp, int srcdim>
        struct UnpackPatchToColXExp: public MakeTensorExp< UnpackPatchToColXExp<SrcExp,srcdim>, SrcExp, 2>{
            const SrcExp& img_;
            index_t psize_;
            index_t pstride_;
            index_t i_channel_;
            index_t i_height_;
            index_t i_width_;            
            UnpackPatchToColXExp( const SrcExp &img, index_t psize, index_t pstride )
                :img_(img), psize_(psize), pstride_(pstride){
                Shape<srcdim> imshape = ShapeCheck<srcdim,SrcExp>::Check( img_ );
                utils::Assert( imshape[0] >= psize && imshape[1] >= psize, "UnpackPatchToCol:image shape smaller than patch size");
                this->i_channel_ = imshape[2];
                this->i_height_  = imshape[1];
                this->i_width_   = imshape[0];
                // calculate number of batches 
                const index_t num = imshape.ProdShape( 3, srcdim );
                const index_t o_height = ( i_height_ - psize ) / pstride + 1;
                const index_t o_width  = ( i_width_  - psize ) / pstride + 1;
                this->shape_[0] = o_height * o_width * num;
                this->shape_[1] = psize * psize * imshape[2];
            }
        };

        template<typename Device, int dstdim>
        struct PackColToPatchXExp: public MakeTensorExp< PackColToPatchXExp<Device,dstdim>, Tensor<Device,2>, dstdim>{
            const Tensor<Device,2>& mat_;
            index_t psize_;
            index_t pstride_;
            PackColToPatchXExp( const Tensor<Device,2> &mat, Shape<dstdim> imshape, index_t psize, index_t pstride )
                :mat_(mat), psize_(psize), pstride_(pstride){
                this->shape_ = imshape;
                const index_t o_height = ( imshape[1]  - psize ) / pstride + 1;                
                const index_t o_width  = ( imshape[0]  - psize ) / pstride + 1;                
                utils::Assert( mat.shape[0] == o_height * o_width * imshape.ProdShape(3,dstdim), "PackColToPatchExp: mat.shape[0] mismatch" );
                utils::Assert( mat.shape[1] == psize * psize * imshape[2], "PackColToPatchExp: mat.shape[1] mismatch" );
            }
        };

        template<typename SrcExp, int dimdst, int dimsrc>
        struct ReshapeExp: public MakeTensorExp< ReshapeExp<SrcExp,dimdst,dimsrc>, SrcExp, dimdst>{
            const SrcExp& src_;
            index_t ishape0_;
            ReshapeExp( const SrcExp &src, Shape<dimdst> shape ):src_(src){
                Shape<dimsrc> ishape = ShapeCheck<dimsrc,SrcExp>::Check( src_ );
                utils::Assert( ishape.Size() == shape.Size(), "reshape size must match" );
                ishape0_ = ishape[0];
                this->shape_ = shape;
            }
        };

        template<typename SrcExp,int dimsrc, int a1, int a2>
        struct SwapAxisExp: public MakeTensorExp< SwapAxisExp<SrcExp,dimsrc,a1,a2>, SrcExp, dimsrc>{
            const SrcExp& src_;
            SwapAxisExp( const SrcExp &src ):src_(src){                
                this->shape_ = ShapeCheck<dimsrc,SrcExp>::Check(src); 
                std::swap( this->shape_[a1], this->shape_[a2] );
            }
        };

        template<typename EType, typename Reducer,int dimkeep>
        struct ReduceTo1DExp: public Exp< ReduceTo1DExp<EType,Reducer, dimkeep>, type::kComplex >{
            const EType& src_;
            real_t scale_;
            ReduceTo1DExp( const EType& src, real_t scale ):src_(src),scale_(scale){}
        };

        template<typename Reducer, typename SrcExp, int srcdim>
        struct PoolingExp: public MakeTensorExp< PoolingExp<Reducer, SrcExp,srcdim>, SrcExp, srcdim> {
            const SrcExp& src_;
            index_t ksize_;
            index_t kstride_;
            index_t src_height_;
            index_t src_width_;
            PoolingExp( const SrcExp &src, index_t ksize, index_t kstride )
                : src_(src), ksize_(ksize), kstride_(kstride) {
                Shape< srcdim > sshape = ShapeCheck< srcdim,SrcExp>::Check( src_ );
                utils::Assert( sshape[0] >= ksize && sshape[1] >= ksize, "pool: kernel must be smaller than image" );
                this->src_height_ = sshape[1];
                this->src_width_  = sshape[0];
                this->shape_ = sshape;
                this->shape_[1] =  (src_height_ - ksize) / kstride + 1;                
                this->shape_[0] =  (src_width_  - ksize) / kstride + 1;
            }
            PoolingExp( const SrcExp &src, Shape<2> pshape, index_t ksize, index_t kstride )
                : src_(src), ksize_(ksize), kstride_(kstride) {
                Shape< srcdim > sshape = ShapeCheck< srcdim,SrcExp>::Check( src_ );
                utils::Assert( sshape[0] >= ksize && sshape[1] >= ksize, "pool: kernel must be smaller than image" );
                this->src_height_ = sshape[1];
                this->src_width_  = sshape[0];
                this->shape_    = sshape;
                this->shape_[1] = pshape[1];
                this->shape_[0] = pshape[0];
            } 
        };

        template<typename Reducer, typename Device>
        struct UnPoolingExp: public MakeTensorExp< UnPoolingExp<Reducer, Device>, Tensor<Device,4>, 4> {
            const Tensor<Device, 4>& data_src_;
            const Tensor<Device, 4>& data_pooled_;
            const Tensor<Device, 4>& grad_pooled_;
            index_t ksize_;
            index_t kstride_;
            UnPoolingExp( const Tensor<Device,4> &data_src,  const Tensor<Device,4> &data_pooled,
                          const Tensor<Device,4> &grad_pooled, index_t ksize, index_t kstride )
                : data_src_(data_src), data_pooled_(data_pooled), grad_pooled_(grad_pooled),
                  ksize_(ksize), kstride_(kstride) {
                utils::Assert( grad_pooled.shape == data_pooled.shape, "UnPoolingExp: pooled shape mismatch" );
                utils::Assert( grad_pooled.shape[2] == data_src.shape[2], "UnPoolingExp: pool and src shape mismatch" );
                utils::Assert( grad_pooled.shape[3] == data_src.shape[3], "UnPoolingExp: pool and src shape mismatch" );
                this->shape_ = data_src_.shape;
            }
        };

        template<typename SrcExp, int srcdim>
        struct PaddingExp : public MakeTensorExp<PaddingExp<SrcExp, srcdim>, SrcExp, srcdim> {
            const SrcExp& src_;
            index_t pad_;
            index_t src_height_;
            index_t src_width_;
            PaddingExp( const SrcExp &src, index_t pad )
                : src_(src), pad_(pad) {
                this->shape_ = ShapeCheck<srcdim,SrcExp>::Check( src_ );
                src_height_ = this->shape_[1];
                src_width_  = this->shape_[0];
                this->shape_[1] += pad * 2; // height
                this->shape_[0] += pad * 2; // width
            }
        };

        template<typename SrcExp, int srcdim>
        struct CroppingExp : public MakeTensorExp< CroppingExp<SrcExp, srcdim>, SrcExp, srcdim> {
            const SrcExp& src_;
            index_t pad_height_;
            index_t pad_width_;
            index_t src_height_;
            CroppingExp(const SrcExp &src, Shape<2> cshape ): src_(src) {
                this->shape_ = ShapeCheck<srcdim,SrcExp>::Check( src_ );
                utils::Assert(this->shape_[1] >= cshape[1], "CroppingExp: height requirement not met");
                utils::Assert(this->shape_[0] >= cshape[0], "CroppingExp: width requirement not met");
                pad_height_ = (this->shape_[1] - cshape[1]) / 2;
                pad_width_ = (this->shape_[0] - cshape[0]) / 2;
                src_height_ = this->shape_[1];
                this->shape_[1] = cshape[1]; // width
                this->shape_[0] = cshape[0]; // height
            }
            CroppingExp(const SrcExp &src, Shape<2> cshape, index_t start_height, index_t start_width  )
                : src_(src), pad_height_(start_height), pad_width_(start_width) {
                this->shape_ = ShapeCheck<srcdim,SrcExp>::Check( src_ );
                utils::Assert(this->shape_[1] >= cshape[1], "CroppingExp: height requirement not met");
                utils::Assert(this->shape_[0] >= cshape[0], "CroppingExp: width requirement not met");
                src_height_ = this->shape_[1];
                this->shape_[1] = cshape[1]; // width
                this->shape_[0] = cshape[0]; // height
            }

        }; // struct CroppingExp


        template<typename SrcExp, int srcdim>
        struct MirroringExp : public MakeTensorExp<MirroringExp<SrcExp, srcdim>, SrcExp, srcdim> {
            const SrcExp& src_;
            MirroringExp( const SrcExp &src ): src_(src) {
                this->shape_ = ShapeCheck<srcdim,SrcExp>::Check( src_ );
            }
        };

        template<typename Reducer, typename SrcExp, int srcdim>
        struct ChannelPoolingExp: public MakeTensorExp< ChannelPoolingExp<Reducer, SrcExp,srcdim>, SrcExp, srcdim> {
            const SrcExp& src_;
            index_t nsize_;            
            ChannelPoolingExp( const SrcExp &src, index_t nsize ): src_(src), nsize_(nsize){
                utils::Assert( nsize % 2 == 1, "ChannelPoolingExp: local size must be odd, to make it symmetric" );
                this->shape_ = ShapeCheck<srcdim,SrcExp>::Check( src_ );
                utils::Assert( this->shape_[2] >= nsize_, "ChannelPoolingExp: local size need to be smaller than number of channels" );
            }
        };
    }; // namespace expr


    // Declaration of all functions go here
    namespace expr{
        template<typename E, typename R,int d>
        inline ReduceTo1DExp<E,R,d> operator*( const ReduceTo1DExp<E,R,d> &e, real_t scale ){
            return ReduceTo1DExp<E,R,d>( e.src_, e.scale_*scale );
        }
        template<typename E, typename R,int d>
        inline ReduceTo1DExp<E,R,d> operator*( real_t scale, const ReduceTo1DExp<E,R,d> &e ){
            return ReduceTo1DExp<E,R,d>( e.src_, e.scale_*scale );
        }

        template<int dimcast,typename Device,int dimdst>
        inline Broadcast1DExp<Device,dimdst,dimcast> broadcast( const Tensor<Device,1> &src, Shape<dimdst> shape ){
            TypeCheckPass< dimcast<dimdst >::Error_Expression_Does_Not_Meet_Dimension_Req();
            utils::Assert( src.shape[0] == shape[dimcast], "broadcast, shape mismatch" );
            return Broadcast1DExp<Device,dimdst,dimcast>( src, shape );
        }

        template<typename SrcExp, int etype>
        inline UnpackPatchToColXExp<SrcExp, ExpInfo<SrcExp>::kDim > unpack_patch2col( const Exp<SrcExp,etype> &img, index_t psize, index_t pstride ){
            TypeCheckPass< ExpInfo<SrcExp>::kDim >= 3 >::Error_Expression_Does_Not_Meet_Dimension_Req();
            return UnpackPatchToColXExp<SrcExp, ExpInfo<SrcExp>::kDim >( img.self(), psize, pstride );
        }

        template<typename Device, int dstdim>
        inline PackColToPatchXExp<Device,dstdim> pack_col2patch( const Tensor<Device,2> &mat, Shape<dstdim> imshape, index_t psize, index_t pstride ){
            utils::Assert( imshape[0] >= psize && imshape[1] >= psize, "PackColToPatch:image shape smaller than patch size");
            return PackColToPatchXExp<Device,dstdim>( mat, imshape, psize, pstride );
        }
        template<typename SrcExp, int etype, int dimdst>
        inline ReshapeExp< SrcExp,dimdst, ExpInfo<SrcExp>::kDim > reshape( const Exp<SrcExp,etype> &src, Shape<dimdst> oshape ){
            return ReshapeExp< SrcExp,dimdst, ExpInfo<SrcExp>::kDim >( src.self(), oshape );
        }

        template<int a1, int a2, typename SrcExp, int etype>
        inline SwapAxisExp< SrcExp, ExpInfo<SrcExp>::kDim, a1,a2> swapaxis( const Exp<SrcExp,etype> &src ){ 
            typedef ExpInfo<SrcExp> Info;
            TypeCheckPass< Info::kDim>=a1+1 && Info::kDim >= a2+1 && a1+1 <= a2 >::Error_Expression_Does_Not_Meet_Dimension_Req();
            return SwapAxisExp< SrcExp,Info::kDim,a1,a2>( src.self() );
        }

        template<int dimkeep,  typename SrcExp, int etype>
        inline ReduceTo1DExp<SrcExp, red::sum, dimkeep > sumall_except_dim( const Exp<SrcExp,etype> &exp ){
            return ReduceTo1DExp<SrcExp,red::sum,dimkeep>( exp.self(), 1.0f );
        }

        template<typename Reducer, typename SrcExp, int etype>
        inline PoolingExp<Reducer,SrcExp, ExpInfo<SrcExp>::kDim > pool( const Exp<SrcExp,etype> &src, index_t ksize, index_t kstride ) {
            TypeCheckPass< ExpInfo<SrcExp>::kDim >= 2 >::Error_Expression_Does_Not_Meet_Dimension_Req();
            return PoolingExp<Reducer,SrcExp, ExpInfo<SrcExp>::kDim >(src.self(), ksize, kstride);
        }
        template<typename Reducer, typename SrcExp, int etype>
        inline PoolingExp<Reducer,SrcExp, ExpInfo<SrcExp>::kDim > pool( const Exp<SrcExp,etype> &src, Shape<2> pshape, index_t ksize, index_t kstride ) {
            TypeCheckPass< ExpInfo<SrcExp>::kDim >= 2 >::Error_Expression_Does_Not_Meet_Dimension_Req();
            return PoolingExp<Reducer,SrcExp, ExpInfo<SrcExp>::kDim >(src.self(), pshape, ksize, kstride);
        }
         template<typename Reducer, typename Device>
         inline UnPoolingExp<Reducer, Device> unpool( const Tensor<Device,4>&data_src, const Tensor<Device,4> &data_pooled,
                                                      const Tensor<Device,4> &grad_pooled, index_t ksize, index_t kstride ) {
             return UnPoolingExp<Reducer, Device>(data_src, data_pooled, grad_pooled,ksize, kstride);
         }

         template<typename SrcExp, int etype>
         inline PaddingExp<SrcExp, ExpInfo<SrcExp>::kDim> pad(const Exp<SrcExp, etype> &src, index_t pad) {
             TypeCheckPass< ExpInfo<SrcExp>::kDim >= 2 >::Error_Expression_Does_Not_Meet_Dimension_Req();
             return PaddingExp<SrcExp, ExpInfo<SrcExp>::kDim>(src.self(), pad);
         }

         template<typename SrcExp, int etype>
         inline CroppingExp<SrcExp, ExpInfo<SrcExp>::kDim> crop( const Exp<SrcExp, etype> &src, Shape<2> oshape ) {
             TypeCheckPass< ExpInfo<SrcExp>::kDim >= 2 >::Error_Expression_Does_Not_Meet_Dimension_Req();
             return CroppingExp<SrcExp, ExpInfo<SrcExp>::kDim>(src.self(), oshape);
         }
         template<typename SrcExp, int etype>
         inline CroppingExp<SrcExp, ExpInfo<SrcExp>::kDim> crop( const Exp<SrcExp, etype> &src, Shape<2> oshape, index_t start_height, index_t start_width ) {
             TypeCheckPass< ExpInfo<SrcExp>::kDim >= 2 >::Error_Expression_Does_Not_Meet_Dimension_Req();
             return CroppingExp<SrcExp, ExpInfo<SrcExp>::kDim>(src.self(), oshape, start_height, start_width);
         }

         template<typename SrcExp, int etype>
         inline MirroringExp<SrcExp, ExpInfo<SrcExp>::kDim> mirror(const Exp<SrcExp, etype> &src) {
             TypeCheckPass< ExpInfo<SrcExp>::kDim >= 2 >::Error_Expression_Does_Not_Meet_Dimension_Req();
             return MirroringExp<SrcExp, ExpInfo<SrcExp>::kDim>(src.self());
         }

        template<typename Reducer, typename SrcExp, int etype>
        inline ChannelPoolingExp<Reducer,SrcExp, ExpInfo<SrcExp>::kDim > chpool( const Exp<SrcExp,etype> &src, index_t nsize ) {
            TypeCheckPass< ExpInfo<SrcExp>::kDim >= 3 >::Error_Expression_Does_Not_Meet_Dimension_Req();
            return ChannelPoolingExp<Reducer,SrcExp, ExpInfo<SrcExp>::kDim >(src.self(),nsize);
        }
        // short cut functions
        template<typename Device>
        inline Broadcast1DExp<Device,2,0> repmat( const Tensor<Device,1> &src, index_t nrow ){
            return broadcast<0>( src, Shape2( nrow, src.shape[0] ) );
        }
        template<typename SrcExp, int etype>
        inline ReduceTo1DExp<SrcExp, red::sum, 0 > sum_rows( const Exp<SrcExp,etype> &exp ){
            return sumall_except_dim<0>( exp );
        }

    }; // namespace expr
}; // namespace mshadow

// ==================================================
//  implementations afterwards,
//  no need to read if only use the functions
// --------------------------------------------------
namespace mshadow{
    namespace expr{
        template<typename SV, typename Device, typename EType, typename Reducer, int dimkeep>
        struct ExpComplexEngine< SV, Device, 1, ReduceTo1DExp<EType,Reducer,dimkeep> >{
            inline static void Eval( Tensor<Device,1> &dst, const ReduceTo1DExp<EType,Reducer,dimkeep> &exp ){
                TypeCheckPass< dimkeep!=0 >::Error_Expression_Does_Not_Meet_Dimension_Req();
                MapReduceKeepHighDim<SV,Reducer,dimkeep>( dst, exp.src_, exp.scale_ );
            }
        };

        template<typename SV, typename Device, typename EType, typename Reducer>
        struct ExpComplexEngine< SV, Device, 1, ReduceTo1DExp<EType,Reducer,0> >{
            inline static void Eval( Tensor<Device,1> &dst, const ReduceTo1DExp<EType,Reducer,0> &exp ){
                MapReduceKeepLowest<SV,Reducer>( dst, exp.src_, exp.scale_ );
            }
        };
    }; // namespace expr

    namespace expr{
        template<typename Device, int dimdst, int dimcast>
        struct Plan< Broadcast1DExp<Device,dimdst,dimcast> >{
        public:
            Plan( const Broadcast1DExp<Device,dimdst,dimcast> &e )
                : dptr_( e.src_.dptr ), 
                  ystride_( e.shape_.ProdShape(1,dimcast) ),
                  length_(e.shape_[dimcast]){
                TypeCheckPass< dimcast!=0 >::Error_Expression_Does_Not_Meet_Dimension_Req();
            }
            MSHADOW_XINLINE real_t Eval( index_t y, index_t x ) const{
                return dptr_[ (y / ystride_) % length_ ];
            }
        private:
            const real_t  *dptr_;
            const index_t  ystride_, length_;
        };

        template<typename Device, int dimdst>
        struct Plan< Broadcast1DExp<Device,dimdst,0> >{
        public:
            Plan( const Broadcast1DExp<Device,dimdst,0> &e ): dptr_( e.src_.dptr ){}
            MSHADOW_XINLINE real_t Eval( index_t y, index_t x ) const{
                return dptr_[ x ];
            }
        private:
            const real_t *dptr_;
        };
    }; // namespace expr

    namespace expr{
        template<typename SrcExp, int srcdim>
        struct Plan< UnpackPatchToColXExp<SrcExp,srcdim> >{
        public:
            Plan( const UnpackPatchToColXExp<SrcExp,srcdim> &e )
                :src_(MakePlan(e.img_)),psize_(e.psize_), pstride_(e.pstride_),
                 i_channel_(e.i_channel_), i_height_(e.i_height_), i_width_(e.i_width_),                 
                 o_height_(( i_height_  - psize_ ) / pstride_ + 1),
                 o_width_ (( i_width_   - psize_ ) / pstride_ + 1){
            }
            MSHADOW_XINLINE real_t Eval( index_t i, index_t j ) const{
                const index_t x_offset = i % psize_;
                const index_t idivp    = i / psize_;
                const index_t y_offset = idivp % psize_;
                const index_t c = idivp / psize_;                
                const index_t x = (j % o_width_) * pstride_ + x_offset;
                const index_t jdivw = j / o_width_;
                const index_t y = (jdivw % o_height_) * pstride_ + y_offset;
                const index_t n = jdivw / o_height_;

                if( x < i_width_ && y < i_height_ ){
                    return src_.Eval( ( n * i_channel_  + c ) * i_height_ + y, x );
                }else{
                    return 0.0f;
                }
            }
        private:
            Plan<SrcExp> src_;
            const index_t psize_, pstride_, i_channel_, i_height_, i_width_, o_height_, o_width_;
        };

        template<typename Device, int dstdim>
        struct Plan< PackColToPatchXExp<Device, dstdim> >{
        public:
            Plan( const PackColToPatchXExp<Device, dstdim> &e )
                :mat_(e.mat_), psize_(e.psize_), pstride_(e.pstride_),
                 i_channel_(e.shape_[2]), i_height_(e.shape_[1]),
                 o_width_(( e.shape_[0]  - psize_ ) / pstride_ + 1),
                 o_height_(( e.shape_[1]  - psize_ ) / pstride_ + 1){
                // note: i/o convention are same as unpack
            }
            MSHADOW_XINLINE real_t Eval( index_t i, index_t j ) const{
                using namespace std;
                const index_t y = i % i_height_;
                const index_t idivh = i / i_height_;                
                const index_t c = idivh % i_channel_;
                const index_t n = idivh / i_channel_; 
                const index_t x = j;
                const index_t py_min = y < psize_ ? 0 : (y-psize_+pstride_)/pstride_;
                const index_t px_min = x < psize_ ? 0 : (x-psize_+pstride_)/pstride_;
                const index_t py_max = min( (y+pstride_)/pstride_, o_height_);
                const index_t px_max = min( (x+pstride_)/pstride_, o_width_ );
                real_t res = 0.0f;
                for( index_t py = py_min; py < py_max; ++py ){
                    for( index_t px = px_min; px < px_max; ++px ){
                        res += mat_[ (c * psize_ + y - py*pstride_) * psize_ + x - px*pstride_ ][ (n * o_height_ + py) * o_width_+px ];
                    }
                }
                return res;
            }
        private:
            Tensor<Device,2> mat_;
            const index_t psize_, pstride_, i_channel_, i_height_, o_width_, o_height_;
        };
    };

    namespace expr{
        template<typename SrcExp, int dimdst, int dimsrc>
        struct Plan< ReshapeExp<SrcExp,dimdst,dimsrc> >{
        public:
            Plan( const ReshapeExp<SrcExp,dimdst,dimsrc> &e )
                : src_(MakePlan(e.src_)), oshape0_(e.shape_[0]), ishape0_(e.ishape0_){
            }
            MSHADOW_XINLINE real_t Eval( index_t y, index_t x ) const{
                const index_t idx = y * oshape0_ + x;
                return src_.Eval( idx / ishape0_, idx % ishape0_ );
            }
        private:
            Plan<SrcExp> src_;
            const index_t oshape0_, ishape0_;
        };
        // special work plan for 1 dimensional data
        template<typename SrcExp,int dimdst>
        struct Plan< ReshapeExp<SrcExp,dimdst,1> >{
        public:
            Plan( const ReshapeExp<SrcExp,dimdst,1> &e )
                : src_(MakePlan(e.src_)), oshape0_(e.shape_[0]){
            }
            MSHADOW_XINLINE real_t Eval( index_t y, index_t x ) const{
                return src_.Eval( 0, y * oshape0_ + x );
            }
        private:
            Plan<SrcExp> src_;
            const index_t oshape0_;
        };
    };
    
    namespace expr{
        template<typename SrcExp,int dimsrc, int a1, int a2>
        struct Plan< SwapAxisExp<SrcExp,dimsrc,a1,a2> >{
        public:
            Plan( const SwapAxisExp<SrcExp,dimsrc,a1,a2> &e )
                : src_(MakePlan(e.src_)),
                  shape1_( e.shape_.ProdShape( 1, a1 ) ),
                  shape2_( e.shape_[a1] ),
                  shape3_( e.shape_.ProdShape( a1+1, a2 ) ),
                  shape4_( e.shape_[a2] ){
            }
            MSHADOW_XINLINE real_t Eval( index_t i, index_t j ) const{
                const index_t y = i % shape1_;
                i /= shape1_; 
                const index_t z = i % shape2_;
                i /= shape2_;
                const index_t c = i % shape3_;
                i /= shape3_;
                const index_t n = i % shape4_;
                // swap z and n
                return src_.Eval( ((((i/shape4_)*shape2_ + z) * shape3_+c) * shape4_ + n ) * shape1_ + y, j ); 
            }
        private:
            Plan<SrcExp> src_;
            const index_t shape1_, shape2_, shape3_, shape4_;
        };

        template<typename SrcExp,int dimsrc, int a2>
        struct Plan< SwapAxisExp<SrcExp,dimsrc,0,a2> >{
        public:
            Plan( const SwapAxisExp<SrcExp,dimsrc,0,a2> &e )
                : src_(MakePlan(e.src_)),
                  shape0_( e.shape_[0] ),
                  shape1_( e.shape_.ProdShape(1,a2) ),
                  shape2_( e.shape_[a2] ){
            }
            MSHADOW_XINLINE real_t Eval( index_t i, index_t x ) const{
                // swap x and z
                const index_t y = i % shape1_;
                i /= shape1_; 
                const index_t z = i % shape2_;
                const index_t n = i / shape2_;
                return src_.Eval(  ( n*shape0_ + x ) * shape1_ + y , z ); 
            }
        private:
            Plan<SrcExp> src_;
            const index_t shape0_, shape1_, shape2_;
        };
    };

    namespace expr{
        template<typename Reducer, typename SrcExp, int srcdim>
        struct Plan< PoolingExp< Reducer, SrcExp, srcdim> > {
        public:
            Plan( const PoolingExp<Reducer, SrcExp, srcdim> &e )
                : src_( MakePlan( e.src_ ) ), ksize_(e.ksize_), kstride_(e.kstride_),
                  src_height_(e.src_height_),src_width_(e.src_width_), new_height_(e.shape_[1]) {
            }
            MSHADOW_XINLINE real_t Eval(index_t i, index_t j) const {
                using namespace std;
                const index_t py = i % new_height_;
                const index_t y_start = py * kstride_;
                const index_t y_end = min( y_start + ksize_, src_height_ );
                const index_t px = j;
                const index_t x_start = px * kstride_;
                const index_t x_end = min( x_start + ksize_, src_width_ );
                const index_t c = i / new_height_;

                real_t res = Reducer::kInitV;
                for (index_t y = y_start; y < y_end; ++y) {
                    for (index_t x = x_start; x < x_end; ++x) {
                        Reducer::Reduce( res, src_.Eval( c*src_height_+y, x ) );
                    }
                }
                return res;
            }
        private:
            Plan<SrcExp> src_;
            const index_t ksize_, kstride_;
            const index_t src_height_, src_width_;
            const index_t new_height_;
        };

        template<typename Reducer, typename Device>
        struct Plan<UnPoolingExp<Reducer, Device> > {
        public:
            Plan(const UnPoolingExp<Reducer, Device> &e)
                : data_src_(e.data_src_), data_pooled_(e.data_pooled_), grad_pooled_(e.grad_pooled_),
                  ksize_(e.ksize_), kstride_(e.kstride_) {}
            MSHADOW_XINLINE real_t Eval(index_t i, index_t j) const {
                using namespace std;
                const index_t x = j;
                const index_t y = i % data_src_.shape[1];
                const index_t c = i / data_src_.shape[1];
                const real_t vsrc = data_src_[0][c][y][x];

                const index_t py_min = y < ksize_ ? 0 : (y-ksize_+kstride_)/kstride_;
                const index_t px_min = x < ksize_ ? 0 : (x-ksize_+kstride_)/kstride_;
                const index_t py_max = min( (y+kstride_)/kstride_, data_pooled_.shape[1]);
                const index_t px_max = min( (x+kstride_)/kstride_, data_pooled_.shape[0]);

                real_t val = 0;
                for( index_t py = py_min; py < py_max; ++py ){
                    for( index_t px = px_min; px < px_max; ++px ){
                        val += Reducer::PartialGrad(vsrc, data_pooled_[0][c][py][px]) * grad_pooled_[0][c][py][px];
                    }
                }
                return val;
            }
        private:
            Tensor<Device, 4> data_src_, data_pooled_, grad_pooled_;
            const index_t ksize_;
            const index_t kstride_;
        };
    }; // namespace expr

    namespace expr{
        template<typename SrcExp, int srcdim>
        struct Plan< PaddingExp<SrcExp, srcdim> > {
        public:
            Plan(const PaddingExp<SrcExp, srcdim> &e)
                : src_(MakePlan(e.src_)), pad_(e.pad_), new_height_(e.shape_[1]),
                  src_height_(e.src_height_), src_width_(e.src_width_) {}
            MSHADOW_XINLINE real_t Eval(index_t i, index_t j) const {
                const index_t x = j;
                const index_t y = i % new_height_;
                const index_t c = i / new_height_;
                if (y < pad_ || x < pad_) return 0.0f;
                const index_t h = y - pad_;
                const index_t w = x - pad_;
                if (h < src_height_ && w < src_width_) {
                    return src_.Eval(c * src_height_ + h, w);
                } else {
                    return 0.0f;
                }
            }
        private:
            Plan<SrcExp> src_;
            const index_t pad_;
            const index_t new_height_;
            const index_t src_height_;
            const index_t src_width_;
        };

        template<typename SrcExp, int srcdim>
        struct Plan<CroppingExp<SrcExp, srcdim> > {
        public:
            Plan(const CroppingExp<SrcExp, srcdim> &e)
                : src_(MakePlan(e.src_)), pad_height_(e.pad_height_),pad_width_(e.pad_width_), 
                  new_height_(e.shape_[1]), src_height_(e.src_height_) {}
            MSHADOW_XINLINE real_t Eval(index_t i, index_t j) const {
                const index_t x = j;
                const index_t y = i % new_height_;
                const index_t c = i / new_height_;
                const index_t h = y + pad_height_;
                const index_t w = x + pad_width_;
                return src_.Eval(c * src_height_ + h, w);
            }
        private:
            Plan<SrcExp> src_;
            const index_t pad_height_, pad_width_;
            const index_t new_height_;
            const index_t src_height_;
        };

        template<typename SrcExp, int srcdim>
        struct Plan< MirroringExp<SrcExp, srcdim> > {
        public:
            Plan(const MirroringExp<SrcExp, srcdim> &e)
                : src_(MakePlan(e.src_)), width_(e.shape_[0]){}
            MSHADOW_XINLINE real_t Eval(index_t i, index_t j) const {
                return src_.Eval( i, width_ - j - 1 );
            }
        private:
            Plan<SrcExp> src_;
            const index_t width_;
        };
    }; // namespace expr

    namespace expr{
        template<typename Reducer, typename SrcExp, int srcdim>
        struct Plan< ChannelPoolingExp< Reducer, SrcExp, srcdim> > {
        public:
            Plan( const ChannelPoolingExp<Reducer, SrcExp, srcdim> &e )
                : src_( MakePlan( e.src_ ) ), channel_(e.shape_[2]),
                  height_(e.shape_[1]),width_(e.shape_[0]), hnsize_(e.nsize_/2){
            }
            MSHADOW_XINLINE real_t Eval(index_t i, index_t j) const {
                using namespace std;
                const index_t y = i % height_;
                i /= height_;
                const index_t c = i % channel_;
                const index_t n = i / channel_;
                const index_t x = j;
                const index_t cstart = c < hnsize_ ? 0  : c - hnsize_;
                const index_t cend   = min( c + hnsize_ + 1, channel_ );
                real_t res = Reducer::kInitV;
                for( index_t cc = cstart; cc < cend; ++ cc ){
                    Reducer::Reduce( res, src_.Eval( (n*channel_+cc)*height_ + y, x ) );
                }
                return res;
            }
        private:
            Plan<SrcExp> src_;
            const index_t channel_, height_, width_, hnsize_;
        };
    };
}; // namespace mshadow

#if MSHADOW_USE_SSE
// implementations of SSE support, if possible
#include "tensor_sse-inl.hpp"
namespace mshadow{
    namespace expr{
        template<int dimdst>
        struct SSECheck< Broadcast1DExp<cpu,dimdst,0> >{
            const static bool kPass = true;
        };
        template<int dimdst>
        struct SSEAlignCheck<2, Broadcast1DExp<cpu,dimdst,0> >{
            inline static bool Check( const Broadcast1DExp<cpu,dimdst,0> &exp ){
                return sse2::CheckAlign( exp.src_.dptr );
            }
        };
        template<int dimdst>
        class SSEPlan< Broadcast1DExp<cpu,dimdst,0> >{
        public:
            SSEPlan( const Broadcast1DExp<cpu,dimdst,0> &t )
                :dptr_(t.src_.dptr){}
            MSHADOW_CINLINE sse2::FVec<real_t> EvalSSE( index_t y, index_t x ) const{
                return sse2::FVec<real_t>( &dptr_[ x ] );
            }
            MSHADOW_CINLINE real_t Eval( index_t y, index_t x ) const{
                return dptr_[ x ];
            }
        private:
            const real_t  *dptr_;
        };
    };
};
#endif

#endif