Function softmax

dlib/cuda/cpu_dlib.cpp:1625–1696

        namespace ttimpl
        {
            void softmax(
                const long num_locations,
                const long num_channels,
                tensor& dest,
                const tensor& src,
                operation_mode mode = operation_mode::CHANNEL_WISE
            )
            {
                DLIB_ASSERT(num_channels * num_locations == src.nr() * src.nc() * src.k());
                DLIB_CASSERT(have_same_dimensions(dest, src));
                const auto d = dest.host();
                const auto s = src.host();

                for (long n = 0; n < src.num_samples(); ++n)
                {
                    auto ss = s + num_locations * num_channels * n;
                    auto dd = d + num_locations * num_channels * n;

                    if (mode == operation_mode::CHANNEL_WISE)
                    {
                        for (long i = 0; i < num_locations; ++i)
                        {
                            float max_val = -std::numeric_limits<float>::infinity();
                            for (long k = 0; k < num_channels; ++k)
                                max_val = std::max(max_val, ss[k * num_locations]);

                            float sum = 0.0f;
                            for (long k = 0; k < num_channels; ++k)
                            {
                                dd[k * num_locations] = std::exp(ss[k * num_locations] - max_val);
                                sum += dd[k * num_locations];
                            }
                            for (long k = 0; k < num_channels; ++k)
                                dd[k * num_locations] /= sum;

                            ++ss;
                            ++dd;
                        }
                    }
                    else if (mode == operation_mode::PLANE_WISE)
                    {
                        for (long k = 0; k < num_channels; ++k)
                        {
                            auto s_channel = ss + k * num_locations;
                            auto d_channel = dd + k * num_locations;
                            for (long r = 0; r < src.nr(); ++r)
                            {
                                float max_val = -std::numeric_limits<float>::infinity();
                                for (long c = 0, idx = r * src.nc(); c < src.nc(); ++c, ++idx)
                                    max_val = std::max(max_val, s_channel[idx]);

                                if (max_val == -std::numeric_limits<float>::infinity())
                                {
                                    for (long c = 0, idx = r * src.nc(); c < src.nc(); ++c, ++idx)
                                        d_channel[idx] = 0.0f;
                                }
                                else
                                {