const tensor_t& model_t::output(const vector_t& input) const
{
assert(static_cast<size_t>(input.size()) == isize());
tensor_t xinput(idims(), irows(), icols());
xinput.vector() = input;
return output(xinput);
}
const tensor_t& pool_layer_t::output(const tensor_t& input)
{
assert(idims() == input.dims());
assert(irows() <= input.rows());
assert(icols() <= input.cols());
m_idata = input;
for (size_t o = 0; o < odims(); o ++)
{
pooling::output(
m_idata.matrix(o), m_alpha,
m_wdata.matrix(o),
m_sdata.matrix(o),
m_cdata.matrix(o),
m_odata.matrix(o));
}
return m_odata;
}
tensor_t model_t::generate(const vector_t& target) const
{
const square_loss_t loss;
// construct the optimization problem
const timer_t timer;
auto fn_size = [&] ()
{
return isize();
};
auto fn_fval = [&] (const vector_t& x)
{
const tensor_t output = this->output(x);
return loss.value(target, output.vector());
};
auto fn_grad = [&] (const vector_t& x, vector_t& gx)
{
const tensor_t output = this->output(x);
const vector_t ograd = loss.vgrad(target, output.vector());
gx = this->ginput(ograd).vector();
return loss.value(target, output.vector());
};
auto fn_wlog = [] (const string_t& message)
{
log_warning() << message;
};
auto fn_elog = [] (const string_t& message)
{
log_error() << message;
};
auto fn_ulog = [&] (const opt_state_t& /*result*/)
{
// log_info() << "[loss = " << result.f
// << ", grad = " << result.g.lpNorm<Eigen::Infinity>()
// << ", funs = " << result.n_fval_calls() << "/" << result.n_grad_calls()
// << "] done in " << timer.elapsed() << ".";
return true;
};
// assembly optimization problem & optimize the input
const optim::batch_optimizer optimizer = optim::batch_optimizer::LBFGS;
const size_t iterations = 256;
const scalar_t epsilon = 1e-6;
tensor_t input(idims(), irows(), icols());
input.setRandom(random_t<scalar_t>(0.0, 1.0));
const opt_state_t result = ncv::minimize(
fn_size, fn_fval, fn_grad, fn_wlog, fn_elog, fn_ulog,
input.vector(), optimizer, iterations, epsilon);
input.vector() = result.x;
log_info() << "[loss = " << result.f
<< ", grad = " << result.g.lpNorm<Eigen::Infinity>()
<< ", funs = " << result.n_fval_calls() << "/" << result.n_grad_calls()
<< "] done in " << timer.elapsed() << ".";
// OK
return input;
}
Array<T> join(const int dim, const std::vector<Array<T>> &inputs)
{
for (unsigned i=0; i<inputs.size(); ++i)
inputs[i].eval();
// All dimensions except join dimension must be equal
// Compute output dims
af::dim4 odims;
const dim_t n_arrays = inputs.size();
std::vector<af::dim4> idims(n_arrays);
dim_t dim_size = 0;
for(unsigned i = 0; i < idims.size(); i++) {
idims[i] = inputs[i].dims();
dim_size += idims[i][dim];
}
for(int i = 0; i < 4; i++) {
if(i == dim) {
odims[i] = dim_size;
} else {
odims[i] = idims[0][i];
}
}
Array<T> out = createEmptyArray<T>(odims);
switch(n_arrays) {
case 1:
getQueue().enqueue(kernel::join<T, 1>, dim, out, inputs);
break;
case 2:
getQueue().enqueue(kernel::join<T, 2>, dim, out, inputs);
break;
case 3:
getQueue().enqueue(kernel::join<T, 3>, dim, out, inputs);
break;
case 4:
getQueue().enqueue(kernel::join<T, 4>, dim, out, inputs);
break;
case 5:
getQueue().enqueue(kernel::join<T, 5>, dim, out, inputs);
break;
case 6:
getQueue().enqueue(kernel::join<T, 6>, dim, out, inputs);
break;
case 7:
getQueue().enqueue(kernel::join<T, 7>, dim, out, inputs);
break;
case 8:
getQueue().enqueue(kernel::join<T, 8>, dim, out, inputs);
break;
case 9:
getQueue().enqueue(kernel::join<T, 9>, dim, out, inputs);
break;
case 10:
getQueue().enqueue(kernel::join<T,10>, dim, out, inputs);
break;
}
return out;
}
