/* {WSF_ANY}.string_representation */
EIF_TYPED_VALUE F334_6432 (EIF_REFERENCE Current)
{
GTCX
char *l_feature_name = "string_representation";
RTEX;
EIF_REFERENCE loc1 = (EIF_REFERENCE) 0;
EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};
#define up1 up1x.it_p
EIF_REFERENCE tr1 = NULL;
EIF_REFERENCE tr2 = NULL;
EIF_REFERENCE Result = ((EIF_REFERENCE) 0);
RTSN;
RTDA;
RTLD;
RTLI(5);
RTLR(0,loc1);
RTLR(1,Current);
RTLR(2,tr1);
RTLR(3,tr2);
RTLR(4,Result);
RTLU (SK_REF, &Result);
RTLU (SK_REF, &Current);
RTLU(SK_REF, &loc1);
RTEAA(l_feature_name, 333, Current, 1, 0, 11063);
RTSA(Dtype(Current));
RTSC;
RTME(Dtype(Current), 0);
RTGC;
RTDBGEAA(333, Current, 11063);
RTIV(Current, RTAL);
RTHOOK(1);
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(5264, Dtype(Current)))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
loc1 = RTCCL(tr1);
if (EIF_TEST(loc1)) {
RTHOOK(2);
RTDBGAL(Current, 0, 0xF8000139, 0,0); /* Result */
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(8, "generating_type", loc1))(loc1)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
tr2 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(5161, "to_string_32", tr1))(tr1)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
Result = (EIF_REFERENCE) RTCCL(tr2);
} else {
RTHOOK(3);
RTDBGAL(Current, 0, 0xF8000139, 0,0); /* Result */
tr1 = RTMS_EX_H("Void",4,1450142052);
tr2 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(4615, "as_string_32", tr1))(tr1)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
Result = (EIF_REFERENCE) RTCCL(tr2);
}
RTVI(Current, RTAL);
RTRS;
RTHOOK(4);
RTDBGLE;
RTMD(0);
RTLE;
RTLO(3);
RTEE;
{ EIF_TYPED_VALUE r; r.type = SK_REF; r.it_r = Result; return r; }
#undef up1
}
/* {EXCEPTION}.description */
EIF_TYPED_VALUE F90_1559 (EIF_REFERENCE Current)
{
GTCX
char *l_feature_name = "description";
RTEX;
struct eif_ex_33 sloc1;
EIF_REFERENCE loc1 = (EIF_REFERENCE) sloc1.data;
EIF_REFERENCE loc2 = (EIF_REFERENCE) 0;
EIF_REFERENCE loc3 = (EIF_REFERENCE) 0;
EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};
#define up1 up1x.it_p
EIF_TYPED_VALUE ur1x = {{0}, SK_REF};
#define ur1 ur1x.it_r
EIF_TYPED_VALUE ur2x = {{0}, SK_REF};
#define ur2 ur2x.it_r
EIF_TYPED_VALUE ui4_1x = {{0}, SK_INT32};
#define ui4_1 ui4_1x.it_i4
EIF_TYPED_VALUE ui4_2x = {{0}, SK_INT32};
#define ui4_2 ui4_2x.it_i4
EIF_TYPED_VALUE ub1x = {{0}, SK_BOOL};
#define ub1 ub1x.it_b
EIF_REFERENCE tr1 = NULL;
EIF_INTEGER_32 ti4_1;
EIF_REFERENCE Result = ((EIF_REFERENCE) 0);
RTSN;
RTDA;
RTLD;
memset (&sloc1.overhead, 0, OVERHEAD + 0);
sloc1.overhead.ov_flags = EO_EXP | EO_STACK;
RT_DFS(&sloc1.overhead, 33);
RTLI(8);
RTLR(0,loc3);
RTLR(1,Current);
RTLR(2,tr1);
RTLR(3,loc2);
RTLR(4,loc1);
RTLR(5,ur1);
RTLR(6,ur2);
RTLR(7,Result);
RTLU (SK_REF, &Result);
RTLU (SK_REF, &Current);
RTLU(SK_REF, &loc1);
RTLU(SK_REF, &loc2);
RTLU(SK_REF, &loc3);
RTEAA(l_feature_name, 89, Current, 3, 0, 1495);
RTSA(Dtype(Current));
RTSC;
RTME(Dtype(Current), 0);
RTGC;
RTDBGEAA(89, Current, 1495);
RTIV(Current, RTAL);
wstdinit(loc1,loc1);
RTLXI(loc1);
RTHOOK(1);
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(1453, Dtype(Current)))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
loc3 = RTCCL(tr1);
if (EIF_TEST(loc3)) {
RTHOOK(2);
RTDBGAL(Current, 2, 0xF8000107, 0, 0); /* loc2 */
tr1 = RTLN(263);
ti4_1 = *(EIF_INTEGER_32 *)(loc3 + RTVA(1811, "count", loc3));
ui4_1 = ti4_1;
(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWC(4745, Dtype(tr1)))(tr1, ui4_1x);
RTNHOOK(2,1);
loc2 = (EIF_REFERENCE) RTCCL(tr1);
RTHOOK(3);
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(1808, "managed_data", loc3))(loc3)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
ur1 = RTCCL(tr1);
ui4_1 = ((EIF_INTEGER_32) 0L);
ti4_1 = *(EIF_INTEGER_32 *)(loc3 + RTVA(1811, "count", loc3));
ui4_2 = (EIF_INTEGER_32) (ti4_1 - ((EIF_INTEGER_32) 1L));
ub1 = (EIF_BOOLEAN) 0;
ur2 = RTCCL(loc2);
(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE, EIF_TYPED_VALUE, EIF_TYPED_VALUE, EIF_TYPED_VALUE, EIF_TYPED_VALUE)) RTVF(558, "utf_8_0_subpointer_into_escaped_string_32", loc1))(loc1, ur1x, ui4_1x, ui4_2x, ub1x, ur2x);
RTHOOK(4);
RTDBGAL(Current, 0, 0xF80000FE, 0,0); /* Result */
Result = (EIF_REFERENCE) RTCCL(loc2);
}
RTVI(Current, RTAL);
RTRS;
RTHOOK(5);
RTDBGLE;
RTMD(0);
RTLE;
RTLO(5);
RTEE;
{ EIF_TYPED_VALUE r; r.type = SK_REF; r.it_r = Result; return r; }
#undef up1
#undef ur1
#undef ur2
#undef ui4_1
#undef ui4_2
#undef ub1
}
/* {EXCEPTION}.set_description */
void F90_1570 (EIF_REFERENCE Current, EIF_TYPED_VALUE arg1x)
{
GTCX
char *l_feature_name = "set_description";
RTEX;
struct eif_ex_33 sloc1;
EIF_REFERENCE loc1 = (EIF_REFERENCE) sloc1.data;
EIF_REFERENCE loc2 = (EIF_REFERENCE) 0;
EIF_REFERENCE loc3 = (EIF_REFERENCE) 0;
EIF_REFERENCE loc4 = (EIF_REFERENCE) 0;
EIF_REFERENCE loc5 = (EIF_REFERENCE) 0;
#define arg1 arg1x.it_r
EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};
#define up1 up1x.it_p
EIF_TYPED_VALUE ur1x = {{0}, SK_REF};
#define ur1 ur1x.it_r
EIF_TYPED_VALUE ur2x = {{0}, SK_REF};
#define ur2 ur2x.it_r
EIF_TYPED_VALUE ur3x = {{0}, SK_REF};
#define ur3 ur3x.it_r
EIF_TYPED_VALUE ui4_1x = {{0}, SK_INT32};
#define ui4_1 ui4_1x.it_i4
EIF_REFERENCE tr1 = NULL;
EIF_INTEGER_32 ti4_1;
EIF_BOOLEAN tb1;
EIF_BOOLEAN tb2;
EIF_BOOLEAN tb3;
RTCDT;
RTSN;
RTDA;
RTLD;
memset (&sloc1.overhead, 0, OVERHEAD + 0);
sloc1.overhead.ov_flags = EO_EXP | EO_STACK;
RT_DFS(&sloc1.overhead, 33);
RTLI(11);
RTLR(0,arg1);
RTLR(1,loc3);
RTLR(2,Current);
RTLR(3,tr1);
RTLR(4,loc2);
RTLR(5,loc1);
RTLR(6,ur1);
RTLR(7,ur2);
RTLR(8,ur3);
RTLR(9,loc4);
RTLR(10,loc5);
RTLU (SK_VOID, NULL);
RTLU(SK_REF,&arg1);
RTLU (SK_REF, &Current);
RTLU(SK_REF, &loc1);
RTLU(SK_REF, &loc2);
RTLU(SK_REF, &loc3);
RTLU(SK_REF, &loc4);
RTLU(SK_REF, &loc5);
RTEAA(l_feature_name, 89, Current, 5, 1, 1474);
RTSA(dtype);
RTSC;
RTME(dtype, 0);
RTGC;
RTDBGEAA(89, Current, 1474);
if (arg1) {
RTCC(arg1, 89, l_feature_name, 1, eif_non_attached_type(254));
}
RTIV(Current, RTAL);
wstdinit(loc1,loc1);
RTLXI(loc1);
RTHOOK(1);
if ((EIF_BOOLEAN)(arg1 != NULL)) {
RTHOOK(2);
RTDBGAL(Current, 3, 0xF800009D, 0, 0); /* loc3 */
tr1 = RTLNSMART(eif_non_attached_type(RTWCT(1453, dtype, Dftype(Current))));
ti4_1 = (((FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(4784, "count", arg1))(arg1)).it_i4);
ui4_1 = ti4_1;
(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWC(1789, Dtype(tr1)))(tr1, ui4_1x);
RTNHOOK(2,1);
loc3 = (EIF_REFERENCE) RTCCL(tr1);
RTHOOK(3);
RTDBGAL(Current, 2, 0xF800035B, 0, 0); /* loc2 */
{
static EIF_TYPE_INDEX typarr0[] = {859,246,0xFFFF};
EIF_TYPE_INDEX typres0;
static EIF_TYPE_INDEX typcache0 = INVALID_DTYPE;
typres0 = (typcache0 != INVALID_DTYPE ? typcache0 : (typcache0 = eif_compound_id(Dftype(Current), typarr0)));
tr1 = RTLN(typres0);
}
ui4_1 = ((EIF_INTEGER_32) 0L);
(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWC(1914, Dtype(tr1)))(tr1, ui4_1x);
RTNHOOK(3,1);
loc2 = (EIF_REFERENCE) RTCCL(tr1);
RTHOOK(4);
ur1 = RTCCL(arg1);
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(1808, "managed_data", loc3))(loc3)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
ur2 = RTCCL(tr1);
ui4_1 = ((EIF_INTEGER_32) 0L);
ur3 = RTCCL(loc2);
(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE, EIF_TYPED_VALUE, EIF_TYPED_VALUE, EIF_TYPED_VALUE)) RTVF(552, "utf_32_string_into_utf_8_0_pointer", loc1))(loc1, ur1x, ur2x, ui4_1x, ur3x);
RTHOOK(5);
ti4_1 = (((FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(1913, "item", loc2))(loc2)).it_i4);
ui4_1 = ti4_1;
(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTVF(1815, "set_count", loc3))(loc3, ui4_1x);
RTHOOK(6);
RTDBGAA(Current, dtype, 1453, 0xF800009D, 0); /* c_description */
RTAR(Current, loc3);
*(EIF_REFERENCE *)(Current + RTWA(1453, dtype)) = (EIF_REFERENCE) RTCCL(loc3);
} else {
void ROIPoolingLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
const Dtype* bottom_data = bottom[0]->cpu_data();
const Dtype* bottom_rois = bottom[1]->cpu_data();
// Number of ROIs
int num_rois = bottom[1]->num();
int batch_size = bottom[0]->num();
int top_count = top[0]->count();
Dtype* top_data = top[0]->mutable_cpu_data();
caffe_set(top_count, Dtype(-FLT_MAX), top_data);
int* argmax_data = max_idx_.mutable_cpu_data();
caffe_set(top_count, -1, argmax_data);
// For each ROI R = [batch_index x1 y1 x2 y2]: max pool over R
for (int n = 0; n < num_rois; ++n) {
int roi_batch_ind = bottom_rois[0];
int roi_start_w = round(bottom_rois[1] * spatial_scale_);
int roi_start_h = round(bottom_rois[2] * spatial_scale_);
int roi_end_w = round(bottom_rois[3] * spatial_scale_);
int roi_end_h = round(bottom_rois[4] * spatial_scale_);
CHECK_GE(roi_batch_ind, 0);
CHECK_LT(roi_batch_ind, batch_size);
int roi_height = max(roi_end_h - roi_start_h + 1, 1);
int roi_width = max(roi_end_w - roi_start_w + 1, 1);
const Dtype bin_size_h = static_cast<Dtype>(roi_height)
/ static_cast<Dtype>(pooled_height_);
const Dtype bin_size_w = static_cast<Dtype>(roi_width)
/ static_cast<Dtype>(pooled_width_);
const Dtype* batch_data = bottom_data + bottom[0]->offset(roi_batch_ind);
for (int c = 0; c < channels_; ++c) {
for (int ph = 0; ph < pooled_height_; ++ph) {
for (int pw = 0; pw < pooled_width_; ++pw) {
// Compute pooling region for this output unit:
// start (included) = floor(ph * roi_height / pooled_height_)
// end (excluded) = ceil((ph + 1) * roi_height / pooled_height_)
int hstart = static_cast<int>(floor(static_cast<Dtype>(ph)
* bin_size_h));
int wstart = static_cast<int>(floor(static_cast<Dtype>(pw)
* bin_size_w));
int hend = static_cast<int>(ceil(static_cast<Dtype>(ph + 1)
* bin_size_h));
int wend = static_cast<int>(ceil(static_cast<Dtype>(pw + 1)
* bin_size_w));
hstart = min(max(hstart + roi_start_h, 0), height_);
hend = min(max(hend + roi_start_h, 0), height_);
wstart = min(max(wstart + roi_start_w, 0), width_);
wend = min(max(wend + roi_start_w, 0), width_);
bool is_empty = (hend <= hstart) || (wend <= wstart);
const int pool_index = ph * pooled_width_ + pw;
if (is_empty) {
top_data[pool_index] = 0;
argmax_data[pool_index] = -1;
}
for (int h = hstart; h < hend; ++h) {
for (int w = wstart; w < wend; ++w) {
const int index = h * width_ + w;
if (batch_data[index] > top_data[pool_index]) {
top_data[pool_index] = batch_data[index];
argmax_data[pool_index] = index;
}
}
}
}
}
// Increment all data pointers by one channel
batch_data += bottom[0]->offset(0, 1);
top_data += top[0]->offset(0, 1);
argmax_data += max_idx_.offset(0, 1);
}
// Increment ROI data pointer
bottom_rois += bottom[1]->offset(1);
}
}
inline int8_t caffe_sign(Dtype val) {
return (Dtype(0) < val) - (val < Dtype(0));
}
void BatchNormLayer<Dtype, MItype, MOtype>::Forward_cpu(
const vector<Blob<MItype>*>& bottom,
const vector<Blob<MOtype>*>& top) {
const Dtype* bottom_data = bottom[0]->cpu_data();
Dtype* top_data = top[0]->mutable_cpu_data();
int_tp num = bottom[0]->shape(0);
int_tp spatial_dim = bottom[0]->count() / (bottom[0]->shape(0) * channels_);
if (bottom[0] != top[0]) {
caffe_copy(bottom[0]->count(), bottom_data, top_data);
}
if (use_global_stats_) {
// use the stored mean/variance estimates.
const Dtype scale_factor = this->blobs_[2]->cpu_data()[0] == 0 ?
0 : 1 / this->blobs_[2]->cpu_data()[0];
caffe_scale(variance_.count(), scale_factor,
this->blobs_[0]->cpu_data(), mean_.mutable_cpu_data());
caffe_scale(variance_.count(), scale_factor,
this->blobs_[1]->cpu_data(), variance_.mutable_cpu_data());
} else {
// compute mean
caffe_gemv<Dtype>(CblasNoTrans, channels_ * num, spatial_dim,
1. / (num * spatial_dim), bottom_data,
spatial_sum_multiplier_.cpu_data(), 0.,
num_by_chans_.mutable_cpu_data());
caffe_gemv<Dtype>(CblasTrans, num, channels_, 1.,
num_by_chans_.cpu_data(), batch_sum_multiplier_.cpu_data(), 0.,
mean_.mutable_cpu_data());
}
// subtract mean
caffe_gemm<Dtype>(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1,
batch_sum_multiplier_.cpu_data(), mean_.cpu_data(), 0.,
num_by_chans_.mutable_cpu_data());
caffe_gemm<Dtype>(CblasNoTrans, CblasNoTrans, channels_ * num,
spatial_dim, 1, -1, num_by_chans_.cpu_data(),
spatial_sum_multiplier_.cpu_data(), 1., top_data);
if (!use_global_stats_) {
// compute variance using var(X) = E((X-EX)^2)
caffe_sqr<Dtype>(top[0]->count(), top_data,
temp_.mutable_cpu_data()); // (X-EX)^2
caffe_gemv<Dtype>(CblasNoTrans, channels_ * num, spatial_dim,
1. / (num * spatial_dim), temp_.cpu_data(),
spatial_sum_multiplier_.cpu_data(), 0.,
num_by_chans_.mutable_cpu_data());
caffe_gemv<Dtype>(CblasTrans, num, channels_, 1.,
num_by_chans_.cpu_data(), batch_sum_multiplier_.cpu_data(), 0.,
variance_.mutable_cpu_data()); // E((X_EX)^2)
// compute and save moving average
this->blobs_[2]->mutable_cpu_data()[0] *= moving_average_fraction_;
this->blobs_[2]->mutable_cpu_data()[0] += 1;
caffe_axpby(mean_.count(), Dtype(1), mean_.cpu_data(),
moving_average_fraction_, this->blobs_[0]->mutable_cpu_data());
int_tp m = bottom[0]->count()/channels_;
Dtype bias_correction_factor = m > 1 ? Dtype(m)/(m-1) : 1;
caffe_axpby(variance_.count(), bias_correction_factor,
variance_.cpu_data(), moving_average_fraction_,
this->blobs_[1]->mutable_cpu_data());
}
// normalize variance
caffe_add_scalar(variance_.count(), eps_, variance_.mutable_cpu_data());
caffe_sqrt(variance_.count(), variance_.cpu_data(),
variance_.mutable_cpu_data());
// replicate variance to input size
caffe_gemm<Dtype>(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1,
batch_sum_multiplier_.cpu_data(), variance_.cpu_data(),
0., num_by_chans_.mutable_cpu_data());
caffe_gemm<Dtype>(CblasNoTrans, CblasNoTrans, channels_ * num,
spatial_dim, 1, 1., num_by_chans_.cpu_data(),
spatial_sum_multiplier_.cpu_data(), 0.,
temp_.mutable_cpu_data());
caffe_div(temp_.count(), top_data, temp_.cpu_data(), top_data);
// TODO(cdoersch): The caching is only needed because later in-place layers
// might clobber the data. Can we skip this if they won't?
caffe_copy(x_norm_.count(), top_data, x_norm_.mutable_cpu_data());
}
/* {READABLE_INDEXABLE}.new_cursor */
EIF_TYPED_VALUE F682_12810 (EIF_REFERENCE Current)
{
GTCX
char *l_feature_name = "new_cursor";
RTEX;
EIF_TYPED_VALUE ur1x = {{0}, SK_REF};
#define ur1 ur1x.it_r
EIF_REFERENCE tr1 = NULL;
EIF_REFERENCE Result = ((EIF_REFERENCE) 0);
RTCDT;
RTSN;
RTDA;
RTLD;
RTLI(4);
RTLR(0,Current);
RTLR(1,tr1);
RTLR(2,ur1);
RTLR(3,Result);
RTLU (SK_REF, &Result);
RTLU (SK_REF, &Current);
RTEAA(l_feature_name, 681, Current, 0, 0, 5970);
RTSA(dtype);
RTSC;
RTME(dtype, 0);
RTGC;
RTDBGEAA(681, Current, 5970);
RTIV(Current, RTAL);
RTHOOK(1);
RTDBGAL(Current, 0, 0xF80002A6, 0,0); /* Result */
{
EIF_TYPE_INDEX typarr0[] = {678,0,0xFFFF};
EIF_TYPE_INDEX typres0;
typarr0[1] = RTWCT(11522, dtype, Dftype(Current));
typres0 = eif_compound_id(Dftype(Current), typarr0);
tr1 = RTLN(typres0);
}
ur1 = RTCCL(Current);
(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWC(11834, Dtype(tr1)))(tr1, ur1x);
RTNHOOK(1,1);
Result = (EIF_REFERENCE) RTCCL(tr1);
RTHOOK(2);
(FUNCTION_CAST(void, (EIF_REFERENCE)) RTVF(11851, "start", Result))(Result);
if (RTAL & CK_ENSURE) {
RTHOOK(3);
RTCT("result_attached", EX_POST);
if ((EIF_BOOLEAN)(Result != NULL)) {
RTCK;
} else {
RTCF;
}
}
RTVI(Current, RTAL);
RTRS;
RTHOOK(4);
RTDBGLE;
RTMD(0);
RTLE;
RTLO(2);
RTEE;
{ EIF_TYPED_VALUE r; r.type = SK_REF; r.it_r = Result; return r; }
#undef ur1
}
/* {INET_ADDRESS_IMPL_V6}.local_host_name */
EIF_TYPED_VALUE F865_6949 (EIF_REFERENCE Current)
{
GTCX
char *l_feature_name = "local_host_name";
RTEX;
EIF_REFERENCE loc1 = (EIF_REFERENCE) 0;
EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};
#define up1 up1x.it_p
EIF_TYPED_VALUE ui4_1x = {{0}, SK_INT32};
#define ui4_1 ui4_1x.it_i4
EIF_POINTER tp1;
EIF_REFERENCE tr1 = NULL;
EIF_REFERENCE Result = ((EIF_REFERENCE) 0);
RTSN;
RTDA;
RTLD;
RTLI(4);
RTLR(0,loc1);
RTLR(1,tr1);
RTLR(2,Result);
RTLR(3,Current);
RTLU (SK_REF, &Result);
RTLU (SK_REF, &Current);
RTLU(SK_REF, &loc1);
RTEAA(l_feature_name, 864, Current, 1, 0, 12484);
RTSA(Dtype(Current));
RTSC;
RTME(Dtype(Current), 0);
RTGC;
RTDBGEAA(864, Current, 12484);
RTIV(Current, RTAL);
RTHOOK(1);
RTDBGAL(Current, 1, 0xF8000095, 0, 0); /* loc1 */
tr1 = RTLN(149);
ui4_1 = ((EIF_INTEGER_32) 256L);
(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWPC(260, 0, Dtype(tr1)))(tr1, ui4_1x);
RTNHOOK(1,1);
loc1 = (EIF_REFERENCE) RTCCL(tr1);
RTHOOK(2);
tp1 = *(EIF_POINTER *)(loc1 + RTVPA(260, 6, "item", loc1));
up1 = tp1;
(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWF(864, 35, Dtype(Current)))(Current, up1x);
RTHOOK(3);
RTDBGAL(Current, 0, 0xF80000DA, 0,0); /* Result */
tr1 = RTLN(218);
tp1 = *(EIF_POINTER *)(loc1 + RTVPA(260, 6, "item", loc1));
up1 = tp1;
(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWPC(335, 2, Dtype(tr1)))(tr1, up1x);
RTNHOOK(3,1);
Result = (EIF_REFERENCE) RTCCL(tr1);
RTVI(Current, RTAL);
RTRS;
RTHOOK(4);
RTDBGLE;
RTMD(0);
RTLE;
RTLO(3);
RTEE;
{ EIF_TYPED_VALUE r; r.type = SK_REF; r.it_r = Result; return r; }
#undef up1
#undef ui4_1
}
void DataTransformer<Dtype>::Transform(Blob<Dtype>* input_blob,
Blob<Dtype>* transformed_blob) {
const int crop_size = param_.crop_size();
const int input_num = input_blob->num();
const int input_channels = input_blob->channels();
const int input_height = input_blob->height();
const int input_width = input_blob->width();
if (transformed_blob->count() == 0) {
// Initialize transformed_blob with the right shape.
if (crop_size) {
transformed_blob->Reshape(input_num, input_channels,
crop_size, crop_size);
} else {
transformed_blob->Reshape(input_num, input_channels,
input_height, input_width);
}
}
const int num = transformed_blob->num();
const int channels = transformed_blob->channels();
const int height = transformed_blob->height();
const int width = transformed_blob->width();
const int size = transformed_blob->count();
CHECK_LE(input_num, num);
CHECK_EQ(input_channels, channels);
CHECK_GE(input_height, height);
CHECK_GE(input_width, width);
const Dtype scale = param_.scale();
const bool do_mirror = param_.mirror() && Rand(2);
const bool has_mean_file = param_.has_mean_file();
const bool has_mean_values = mean_values_.size() > 0;
int h_off = 0;
int w_off = 0;
if (crop_size) {
CHECK_EQ(crop_size, height);
CHECK_EQ(crop_size, width);
// We only do random crop when we do training.
if (phase_ == TRAIN) {
h_off = Rand(input_height - crop_size + 1);
w_off = Rand(input_width - crop_size + 1);
} else {
h_off = (input_height - crop_size) / 2;
w_off = (input_width - crop_size) / 2;
}
} else {
CHECK_EQ(input_height, height);
CHECK_EQ(input_width, width);
}
Dtype* input_data = input_blob->mutable_cpu_data();
if (has_mean_file) {
CHECK_EQ(input_channels, data_mean_.channels());
CHECK_EQ(input_height, data_mean_.height());
CHECK_EQ(input_width, data_mean_.width());
for (int n = 0; n < input_num; ++n) {
int offset = input_blob->offset(n);
caffe_sub(data_mean_.count(), input_data + offset,
data_mean_.cpu_data(), input_data + offset);
}
}
if (has_mean_values) {
CHECK(mean_values_.size() == 1 || mean_values_.size() == input_channels) <<
"Specify either 1 mean_value or as many as channels: " << input_channels;
if (mean_values_.size() == 1) {
caffe_add_scalar(input_blob->count(), -(mean_values_[0]), input_data);
} else {
for (int n = 0; n < input_num; ++n) {
for (int c = 0; c < input_channels; ++c) {
int offset = input_blob->offset(n, c);
caffe_add_scalar(input_height * input_width, -(mean_values_[c]),
input_data + offset);
}
}
}
}
Dtype* transformed_data = transformed_blob->mutable_cpu_data();
for (int n = 0; n < input_num; ++n) {
int top_index_n = n * channels;
int data_index_n = n * channels;
for (int c = 0; c < channels; ++c) {
int top_index_c = (top_index_n + c) * height;
int data_index_c = (data_index_n + c) * input_height + h_off;
for (int h = 0; h < height; ++h) {
int top_index_h = (top_index_c + h) * width;
int data_index_h = (data_index_c + h) * input_width + w_off;
if (do_mirror) {
int top_index_w = top_index_h + width - 1;
for (int w = 0; w < width; ++w) {
transformed_data[top_index_w-w] = input_data[data_index_h + w];
}
} else {
for (int w = 0; w < width; ++w) {
transformed_data[top_index_h + w] = input_data[data_index_h + w];
}
}
}
}
}
if (scale != Dtype(1)) {
DLOG(INFO) << "Scale: " << scale;
caffe_scal(size, scale, transformed_data);
}
}
void TripletLossLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
Dtype eps = this->layer_param_.triplet_loss_param().eps();
Dtype loss = 0;
Dtype margin = this->layer_param_.triplet_loss_param().margin();
caffe_cpu_gemm(CblasNoTrans, CblasTrans, sample_num_, sample_num_,
feature_dim_, Dtype(1), bottom[0]->cpu_data(),
bottom[0]->cpu_data(), Dtype(0),
inner_matrix_.mutable_cpu_data());
for (int i = 0; i < triplet_num_; ++i) {
int a_idx = bottom[1]->cpu_data()[i * 3];
int p_idx = bottom[1]->cpu_data()[i * 3 + 1];
int n_idx = bottom[1]->cpu_data()[i * 3 + 2];
const Dtype *a_pointer = bottom[0]->cpu_data() + a_idx * feature_dim_;
const Dtype *p_pointer = bottom[0]->cpu_data() + p_idx * feature_dim_;
const Dtype *n_pointer = bottom[0]->cpu_data() + n_idx * feature_dim_;
const Dtype *inner_matrix_data = inner_matrix_.cpu_data();
Dtype a_norm = sqrt(inner_matrix_data[a_idx * sample_num_ + a_idx] + eps);
Dtype p_norm = sqrt(inner_matrix_data[p_idx * sample_num_ + p_idx] + eps);
Dtype n_norm = sqrt(inner_matrix_data[n_idx * sample_num_ + n_idx] + eps);
Dtype inner_ap = inner_matrix_data[a_idx * sample_num_ + p_idx];
Dtype inner_an = inner_matrix_data[a_idx * sample_num_ + n_idx];
Dtype dist_ap = inner_ap / (a_norm * p_norm);
Dtype dist_an = inner_an / (a_norm * n_norm);
if (dist_ap - dist_an - margin < 0) {
ComputeDiff_cpu(a_pointer, p_pointer, a_norm,
p_norm, inner_ap, diff_ap_.mutable_cpu_data());
ComputeDiff_cpu(a_pointer, n_pointer, a_norm,
n_norm, inner_an, diff_an_.mutable_cpu_data());
ComputeDiff_cpu(p_pointer, a_pointer, p_norm,
a_norm, inner_ap, diff_pa_.mutable_cpu_data());
ComputeDiff_cpu(n_pointer, a_pointer, n_norm,
a_norm, inner_an, diff_na_.mutable_cpu_data());
caffe_cpu_axpby(feature_dim_, Dtype(1),
diff_an_.cpu_data(), Dtype(1),
bottom_diff_.mutable_cpu_data() + (a_idx * feature_dim_));
caffe_cpu_axpby(feature_dim_, Dtype(-1),
diff_ap_.cpu_data(), Dtype(1),
bottom_diff_.mutable_cpu_data() + (a_idx * feature_dim_));
caffe_cpu_axpby(feature_dim_, Dtype(-1),
diff_pa_.cpu_data(), Dtype(1),
bottom_diff_.mutable_cpu_data() + (p_idx * feature_dim_));
caffe_cpu_axpby(feature_dim_, Dtype(1),
diff_na_.cpu_data(), Dtype(1),
bottom_diff_.mutable_cpu_data() + (n_idx * feature_dim_));
loss += dist_an + margin - dist_ap;
}
}
//Dtype scalar = Dtype(1) / triplet_num_;
Dtype scalar = Dtype(1) / sample_num_;
top[0]->mutable_cpu_data()[0] = loss * scalar;
}
/* {INET_ADDRESS_IMPL_V6}.loopback_address */
EIF_TYPED_VALUE F865_6951 (EIF_REFERENCE Current)
{
GTCX
char *l_feature_name = "loopback_address";
RTEX;
EIF_TYPED_VALUE ur1x = {{0}, SK_REF};
#define ur1 ur1x.it_r
EIF_TYPED_VALUE ur2x = {{0}, SK_REF};
#define ur2 ur2x.it_r
EIF_TYPED_VALUE ui4_1x = {{0}, SK_INT32};
#define ui4_1 ui4_1x.it_i4
EIF_REFERENCE tr1 = NULL;
EIF_REFERENCE tr2 = NULL;
EIF_REFERENCE tr3 = NULL;
EIF_REFERENCE tr4 = NULL;
EIF_NATURAL_8 tu1_1;
EIF_REFERENCE Result = ((EIF_REFERENCE) 0);
RTSN;
RTDA;
RTLD;
RTLI(8);
RTLR(0,tr1);
RTLR(1,tr2);
RTLR(2,ur1);
RTLR(3,Current);
RTLR(4,tr3);
RTLR(5,tr4);
RTLR(6,ur2);
RTLR(7,Result);
RTLU (SK_REF, &Result);
RTLU (SK_REF, &Current);
RTEAA(l_feature_name, 864, Current, 0, 0, 12486);
RTSA(Dtype(Current));
RTSC;
RTME(Dtype(Current), 0);
RTGC;
RTDBGEAA(864, Current, 12486);
RTIV(Current, RTAL);
RTHOOK(1);
RTDBGAL(Current, 0, 0xF8000361, 0,0); /* Result */
tr1 = RTLN(866);
tr2 = RTMS_EX_H("::1",3,3815985);
ur1 = tr2;
ui4_1 = ((EIF_INTEGER_32) 16L);
{
static EIF_TYPE_INDEX typarr0[] = {864,706,195,0xFFFF};
EIF_TYPE_INDEX typres0;
static EIF_TYPE_INDEX typcache0 = INVALID_DTYPE;
typres0 = (typcache0 != INVALID_DTYPE ? typcache0 : (typcache0 = eif_compound_id(Dftype(Current), 706, typarr0)));
tr4 = RTLNSP2(eif_non_attached_type(typres0),0,ui4_1,sizeof(EIF_NATURAL_8), EIF_TRUE);
RT_SPECIAL_COUNT(tr4) = 16L;
memset(tr4, 0, RT_SPECIAL_VISIBLE_SIZE(tr4));
}
tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);
*((EIF_NATURAL_8 *)tr4+0) = (EIF_NATURAL_8) tu1_1;
tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);
*((EIF_NATURAL_8 *)tr4+1) = (EIF_NATURAL_8) tu1_1;
tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);
*((EIF_NATURAL_8 *)tr4+2) = (EIF_NATURAL_8) tu1_1;
tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);
*((EIF_NATURAL_8 *)tr4+3) = (EIF_NATURAL_8) tu1_1;
tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);
*((EIF_NATURAL_8 *)tr4+4) = (EIF_NATURAL_8) tu1_1;
tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);
*((EIF_NATURAL_8 *)tr4+5) = (EIF_NATURAL_8) tu1_1;
tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);
*((EIF_NATURAL_8 *)tr4+6) = (EIF_NATURAL_8) tu1_1;
tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);
*((EIF_NATURAL_8 *)tr4+7) = (EIF_NATURAL_8) tu1_1;
tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);
*((EIF_NATURAL_8 *)tr4+8) = (EIF_NATURAL_8) tu1_1;
tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);
*((EIF_NATURAL_8 *)tr4+9) = (EIF_NATURAL_8) tu1_1;
tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);
*((EIF_NATURAL_8 *)tr4+10) = (EIF_NATURAL_8) tu1_1;
tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);
*((EIF_NATURAL_8 *)tr4+11) = (EIF_NATURAL_8) tu1_1;
tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);
*((EIF_NATURAL_8 *)tr4+12) = (EIF_NATURAL_8) tu1_1;
tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);
*((EIF_NATURAL_8 *)tr4+13) = (EIF_NATURAL_8) tu1_1;
tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);
*((EIF_NATURAL_8 *)tr4+14) = (EIF_NATURAL_8) tu1_1;
tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 1L);
*((EIF_NATURAL_8 *)tr4+15) = (EIF_NATURAL_8) tu1_1;
tr3 = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWPF(2, 8, Dtype(tr4)))(tr4).it_r;
ur2 = RTCCL(tr3);
(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE, EIF_TYPED_VALUE)) RTWC(866, 43, Dtype(tr1)))(tr1, ur1x, ur2x);
RTNHOOK(1,1);
Result = (EIF_REFERENCE) RTCCL(tr1);
RTVI(Current, RTAL);
RTRS;
RTHOOK(2);
RTDBGLE;
RTMD(0);
RTLE;
RTLO(2);
RTEE;
{ EIF_TYPED_VALUE r; r.type = SK_REF; r.it_r = Result; return r; }
#undef ur1
#undef ur2
#undef ui4_1
}
void TripletLossLayer<Dtype>::Reshape(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
caffe_set(bottom[0]->count(), Dtype(0), bottom_diff_.mutable_cpu_data());
vector<int> loss_shape(0);
top[0]->Reshape(loss_shape);
}
void ContrastiveLossLayer<Dtype>::Forward_cpu(
const vector<Blob<Dtype>*>& bottom,
vector<Blob<Dtype>*>* top) {
int count = bottom[0]->count();
caffe_sub(
count,
bottom[0]->cpu_data(), // a
bottom[1]->cpu_data(), // b
diff_.mutable_cpu_data()); // a_i-b_i
const int channels = bottom[0]->channels();
/*
* margin refers to the maximum value of energy -- parameter Q in the paper
*/
printf("CLL : the values of a_i are \n");
for (int i = 0; i < bottom[0]->num(); ++i) {
for (int j = 0; j < channels; ++j) {
printf("%f \t ",(float) bottom[0]->cpu_data()[i*channels+j] );
}
}
printf("CLL : End printing values of a_i\n");
printf("CLL : the values of b_i are \n");
for (int i = 0; i < bottom[1]->num(); ++i) {
for (int j = 0; j < channels; ++j) {
printf("%f \t ",(float) bottom[1]->cpu_data()[i*channels+j] );
}
}
printf("CLL : End printing values of b_i\n");
printf("CLL : the diff values for the input vector are \n");
for(int temp = 0 ; temp < count ; temp++){
printf("%f \t ",(float) diff_.mutable_cpu_data()[temp] );
}
printf("CLL : End printing the diff values\n");
Dtype margin = this->layer_param_.contrastive_loss_param().margin();
//margin = Dtype(1000);
Dtype loss(0.0);
for (int i = 0; i < bottom[0]->num(); ++i) {
dist_sq_.mutable_cpu_data()[i] = caffe_cpu_asum(channels,
diff_.cpu_data() + (i*channels));
printf("CLL : values of L1 norm are , %f \n", (float) dist_sq_.mutable_cpu_data()[i] );
/*
* 1 is similar pair, 0 is impostor pair.
* The paper follows opposite notation
*/
printf("CLL: label : %d \n", bottom[2]->cpu_data()[i]);
if (static_cast<int>(bottom[2]->cpu_data()[i])) { // similar pairs
loss += Dtype(2) / margin * dist_sq_.cpu_data()[i] * dist_sq_.cpu_data()[i];
printf(" CLL: loss computed : %f\n", dist_sq_.cpu_data()[i]);
} else { // dissimilar pairs
//loss += std::max(margin-dist_sq_.cpu_data()[i], Dtype(0.0));
printf("CLL : the exponent of 1 is : %f \n",exp(Dtype(1)));
printf("CLL : the exponent of -1 is : %f \n", exp(Dtype(-1)));
loss += Dtype(2) * margin * exp(-Dtype(2.77) / margin * dist_sq_.cpu_data()[i]);
printf(" CLL: loss computed : %f\n", dist_sq_.cpu_data()[i]);
}
printf("CLL: value of label : %d \n", static_cast<int>(bottom[2]->cpu_data()[i]));
printf("CLL: value of margin : %f \n", (float) margin);
}
loss = loss / static_cast<Dtype>(bottom[0]->num());
printf("CLL: value of loss : %f \n", loss);
(*top)[0]->mutable_cpu_data()[0] = loss;
}
void ContrastiveLossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
const vector<bool>& propagate_down, vector<Blob<Dtype>*>* bottom) {
Dtype margin = this->layer_param_.contrastive_loss_param().margin();
//margin = Dtype(1000);
for (int i = 0; i < 2; ++i) {
if (propagate_down[i]) {
const Dtype sign = (i == 0) ? 1 : -1;
const Dtype alpha = sign * top[0]->cpu_diff()[0] /
static_cast<Dtype>((*bottom)[i]->num());
// printf("CLL:value of alpha is %f \n", (float)alpha);
// printf("CLL:value of CPU diff is %f \n", (float) top[0]->cpu_diff()[0]);
// printf("CLL:value of bottom num is %d \n", (int) (*bottom)[i]->num());
int num = (*bottom)[i]->num();
int channels = (*bottom)[i]->channels();
for (int j = 0; j < num; ++j) {
Dtype* bout = (*bottom)[i]->mutable_cpu_diff();
if (static_cast<int>((*bottom)[2]->cpu_data()[j])) { // similar pairs
for(int k = 0 ; k < channels ; k ++){
Dtype gradient_sign = diff_.cpu_data()[(j*channels) + k] > 0 ? 1 : -1;
bout[(j*channels) + k] += alpha * dist_sq_.mutable_cpu_data()[j]
* gradient_sign * 4 / margin;
}
/*
caffe_cpu_axpby(
channels,
alpha,
diff_.cpu_data() + (j*channels),
Dtype(0.0),
bout + (j*channels));
*/
} else { // dissimilar pairs
for(int k = 0 ; k < channels ; k ++){
Dtype gradient_sign = diff_.cpu_data()[(j*channels) + k] > 0 ? 1 : -1;
bout[(j*channels) + k] += alpha * Dtype(2) * -Dtype(2.77)
* exp(-Dtype(2.77) / margin * dist_sq_.mutable_cpu_data()[j] )
* gradient_sign;
}
/*
if ((margin-dist_sq_.cpu_data()[j]) > Dtype(0.0)) {
caffe_cpu_axpby(
channels,
-alpha,
diff_.cpu_data() + (j*channels),
Dtype(0.0),
bout + (j*channels));
} else {
caffe_set(channels, Dtype(0), bout + (j*channels));
}
*/
}
}
}
}
/*
// print values for debugging
for (int i = 0; i < 2; ++i) {
int num = (*bottom)[i]->num();
int channels = (*bottom)[i]->channels();
for (int j = 0; j < num; ++j) {
Dtype* bout = (*bottom)[i]->mutable_cpu_diff();
// if (static_cast<int>((*bottom)[2]->cpu_data()[j])) { // similar pairs
for(int k = 0 ; k < channels ; k ++){
printf("CLL: Sample Num : %d, isSimilarPair : %d \n",j,static_cast<int>((*bottom)[2]->cpu_data()[j]));
printf("CLL: Bottom Blob Num : %d , Channel Num : %d , Gradient : %f \n", i , k, (float) bout[(j*channels) + k]);
}
}
}
*/
}
/* {BASE64}.encoded_string */
EIF_TYPED_VALUE F19_463 (EIF_REFERENCE Current, EIF_TYPED_VALUE arg1x)
{
GTCX
char *l_feature_name = "encoded_string";
RTEX;
EIF_INTEGER_32 loc1 = (EIF_INTEGER_32) 0;
EIF_INTEGER_32 loc2 = (EIF_INTEGER_32) 0;
EIF_INTEGER_32 loc3 = (EIF_INTEGER_32) 0;
EIF_REFERENCE loc4 = (EIF_REFERENCE) 0;
EIF_REFERENCE loc5 = (EIF_REFERENCE) 0;
#define arg1 arg1x.it_r
EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};
#define up1 up1x.it_p
EIF_TYPED_VALUE ur1x = {{0}, SK_REF};
#define ur1 ur1x.it_r
EIF_TYPED_VALUE ui4_1x = {{0}, SK_INT32};
#define ui4_1 ui4_1x.it_i4
EIF_TYPED_VALUE ub1x = {{0}, SK_BOOL};
#define ub1 ub1x.it_b
EIF_TYPED_VALUE uc1x = {{0}, SK_CHAR8};
#define uc1 uc1x.it_c1
EIF_REFERENCE tr1 = NULL;
EIF_REFERENCE tr2 = NULL;
EIF_REFERENCE tr3 = NULL;
EIF_INTEGER_32 ti4_1;
EIF_BOOLEAN tb1;
EIF_CHARACTER_8 tc1;
EIF_REFERENCE Result = ((EIF_REFERENCE) 0);
RTCFDT;
RTCDT;
RTSN;
RTDA;
RTLD;
RTLI(9);
RTLR(0,arg1);
RTLR(1,ur1);
RTLR(2,Current);
RTLR(3,tr1);
RTLR(4,tr2);
RTLR(5,loc5);
RTLR(6,loc4);
RTLR(7,tr3);
RTLR(8,Result);
RTLU (SK_REF, &Result);
RTLU(SK_REF,&arg1);
RTLU (SK_REF, &Current);
RTLU(SK_INT32, &loc1);
RTLU(SK_INT32, &loc2);
RTLU(SK_INT32, &loc3);
RTLU(SK_REF, &loc4);
RTLU(SK_REF, &loc5);
RTEAA(l_feature_name, 18, Current, 5, 1, 545);
RTSA(dtype);
RTSC;
RTME(dtype, 0);
RTGC;
RTDBGEAA(18, Current, 545);
RTCC(arg1, 18, l_feature_name, 1, eif_attached_type(218));
RTIV(Current, RTAL);
if ((RTAL & CK_REQUIRE) || RTAC) {
RTHOOK(1);
RTCT("valid_unencoded_string", EX_PRE);
ur1 = RTCCL(arg1);
tb1 = (((FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWF(458, dtype))(Current, ur1x)).it_b);
RTTE(tb1, label_1);
RTCK;
RTJB;
label_1:
RTCF;
}
body:;
if (RTAL & CK_ENSURE) {
in_assertion = ~0;
RTE_OT
tr1 = arg1;
tr2 = NULL;
RTE_O
tr2 = RTLA;
RTE_OE
in_assertion = 0;
}
RTHOOK(2);
RTDBGAA(Current, dtype, 469, 0x04000000, 1); /* has_error */
*(EIF_BOOLEAN *)(Current + RTWA(469, dtype)) = (EIF_BOOLEAN) (EIF_BOOLEAN) 0;
RTHOOK(3);
RTDBGAL(Current, 5, 0xF80000DA, 0, 0); /* loc5 */
loc5 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(468, dtype))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
RTHOOK(4);
RTDBGAL(Current, 2, 0x10000000, 1, 0); /* loc2 */
ti4_1 = *(EIF_INTEGER_32 *)(arg1 + RTVA(3756, "count", arg1));
loc2 = (EIF_INTEGER_32) ti4_1;
RTHOOK(5);
RTDBGAL(Current, 1, 0x10000000, 1, 0); /* loc1 */
loc1 = (EIF_INTEGER_32) (EIF_INTEGER_32) ((EIF_INTEGER_32) (((EIF_INTEGER_32) 8L) * loc2) % ((EIF_INTEGER_32) 6L));
RTHOOK(6);
if ((EIF_BOOLEAN) (loc1 > ((EIF_INTEGER_32) 0L))) {
RTHOOK(7);
RTDBGAL(Current, 4, 0xF80002AA, 0, 0); /* loc4 */
ub1 = (EIF_BOOLEAN) 0;
ui4_1 = (EIF_INTEGER_32) ((EIF_INTEGER_32) (((EIF_INTEGER_32) 8L) * loc2) + (EIF_INTEGER_32) (((EIF_INTEGER_32) 6L) - loc1));
{
static EIF_TYPE_INDEX typarr0[] = {682,202,0xFFFF};
EIF_TYPE_INDEX typres0;
static EIF_TYPE_INDEX typcache0 = INVALID_DTYPE;
typres0 = (typcache0 != INVALID_DTYPE ? typcache0 : (typcache0 = eif_compound_id(dftype, typarr0)));
if (ui4_1< 0) {
eraise ("non_negative_argument", EN_RT_CHECK);
}
tr3 = RTLNSP2(eif_non_attached_type(typres0),0,ui4_1,sizeof(EIF_BOOLEAN), EIF_TRUE);
}
(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE, EIF_TYPED_VALUE)) RTWC(2474, Dtype(tr3)))(tr3, ub1x, ui4_1x);
RTNHOOK(7,1);
loc4 = (EIF_REFERENCE) tr3;
} else {
/**
* @brief Returns the scalar loss associated with a top blob at a given index.
*/
inline Dtype loss(const int top_index) const {
return (loss_.size() > top_index) ? loss_[top_index] : Dtype(0);
}
void BatchNormLayer<Dtype, MItype, MOtype>::Backward_cpu(
const vector<Blob<MOtype>*>& top,
const vector<bool>& propagate_down,
const vector<Blob<MItype>*>& bottom) {
const Dtype* top_diff;
if (bottom[0] != top[0]) {
top_diff = top[0]->cpu_diff();
} else {
caffe_copy(x_norm_.count(), top[0]->cpu_diff(), x_norm_.mutable_cpu_diff());
top_diff = x_norm_.cpu_diff();
}
Dtype* bottom_diff = bottom[0]->mutable_cpu_diff();
if (use_global_stats_) {
caffe_div(temp_.count(), top_diff, temp_.cpu_data(), bottom_diff);
return;
}
const Dtype* top_data = x_norm_.cpu_data();
int_tp num = bottom[0]->shape()[0];
int_tp spatial_dim = bottom[0]->count()/(bottom[0]->shape(0)*channels_);
// if Y = (X-mean(X))/(sqrt(var(X)+eps)), then
//
// dE(Y)/dX =
// (dE/dY - mean(dE/dY) - mean(dE/dY \cdot Y) \cdot Y)
// ./ sqrt(var(X) + eps)
//
// where \cdot and ./ are hadamard product and elementwise division,
// respectively, dE/dY is the top diff, and mean/var/sum are all computed
// along all dimensions except the channels dimension. In the above
// equation, the operations allow for expansion (i.e. broadcast) along all
// dimensions except the channels dimension where required.
// sum(dE/dY \cdot Y)
caffe_mul(temp_.count(), top_data, top_diff, bottom_diff);
caffe_gemv<Dtype>(CblasNoTrans, channels_ * num, spatial_dim, 1.,
bottom_diff, spatial_sum_multiplier_.cpu_data(), 0.,
num_by_chans_.mutable_cpu_data());
caffe_gemv<Dtype>(CblasTrans, num, channels_, 1.,
num_by_chans_.cpu_data(),
batch_sum_multiplier_.cpu_data(), 0.,
mean_.mutable_cpu_data());
// reshape (broadcast) the above
caffe_gemm<Dtype>(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1,
batch_sum_multiplier_.cpu_data(), mean_.cpu_data(), 0.,
num_by_chans_.mutable_cpu_data());
caffe_gemm<Dtype>(CblasNoTrans, CblasNoTrans, channels_ * num,
spatial_dim, 1, 1., num_by_chans_.cpu_data(),
spatial_sum_multiplier_.cpu_data(), 0., bottom_diff);
// sum(dE/dY \cdot Y) \cdot Y
caffe_mul(temp_.count(), top_data, bottom_diff, bottom_diff);
// sum(dE/dY)-sum(dE/dY \cdot Y) \cdot Y
caffe_gemv<Dtype>(CblasNoTrans, channels_ * num, spatial_dim, 1.,
top_diff, spatial_sum_multiplier_.cpu_data(), 0.,
num_by_chans_.mutable_cpu_data());
caffe_gemv<Dtype>(CblasTrans, num, channels_, 1.,
num_by_chans_.cpu_data(),
batch_sum_multiplier_.cpu_data(), 0.,
mean_.mutable_cpu_data());
// reshape (broadcast) the above to make
// sum(dE/dY)-sum(dE/dY \cdot Y) \cdot Y
caffe_gemm<Dtype>(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1,
batch_sum_multiplier_.cpu_data(), mean_.cpu_data(), 0.,
num_by_chans_.mutable_cpu_data());
caffe_gemm<Dtype>(CblasNoTrans, CblasNoTrans, num * channels_,
spatial_dim, 1, 1., num_by_chans_.cpu_data(),
spatial_sum_multiplier_.cpu_data(), 1., bottom_diff);
// dE/dY - mean(dE/dY)-mean(dE/dY \cdot Y) \cdot Y
caffe_axpby(temp_.count(), Dtype(1), top_diff,
Dtype(-1. / (num * spatial_dim)), bottom_diff);
// note: temp_ still contains sqrt(var(X)+eps), computed during the forward
// pass.
caffe_div(temp_.count(), bottom_diff, temp_.cpu_data(), bottom_diff);
}
/**
* @brief Sets the loss associated with a top blob at a given index.
*/
inline void set_loss(const int top_index, const Dtype value) {
if (loss_.size() <= top_index) {
loss_.resize(top_index + 1, Dtype(0));
}
loss_[top_index] = value;
}
/* {EV_WINDOW_IMP}.maximum_height */
EIF_INTEGER_32 F1123_15412 (EIF_REFERENCE Current)
{
return *(EIF_INTEGER_32 *)(Current + O11959[Dtype(Current) - 1122]);
}
void PoolingLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
const vector<bool>& propagate_down, vector<Blob<Dtype>*>* bottom) {
if (!propagate_down[0]) {
return;
}
const Dtype* top_diff = top[0]->cpu_diff();
Dtype* bottom_diff = (*bottom)[0]->mutable_cpu_diff();
// Different pooling methods. We explicitly do the switch outside the for
// loop to save time, although this results in more codes.
caffe_set((*bottom)[0]->count(), Dtype(0), bottom_diff);
// We'll output the mask to top[1] if it's of size >1.
const bool use_top_mask = top.size() > 1;
const int* mask = NULL; // suppress warnings about uninitialized variables
const Dtype* top_mask = NULL;
switch (this->layer_param_.pooling_param().pool()) {
case PoolingParameter_PoolMethod_MAX:
// The main loop
if (use_top_mask) {
top_mask = top[1]->cpu_data();
} else {
mask = max_idx_->cpu_data();
}
for (int n = 0; n < top[0]->num(); ++n) {
for (int c = 0; c < channels_; ++c) {
for (int ph = 0; ph < pooled_height_; ++ph) {
for (int pw = 0; pw < pooled_width_; ++pw) {
const int index = ph * pooled_width_ + pw;
const int bottom_index =
use_top_mask ? top_mask[index] : mask[index];
bottom_diff[bottom_index] += top_diff[index];
}
}
bottom_diff += (*bottom)[0]->offset(0, 1);
top_diff += top[0]->offset(0, 1);
if (use_top_mask) {
top_mask += top[0]->offset(0, 1);
} else {
mask += top[0]->offset(0, 1);
}
}
}
break;
case PoolingParameter_PoolMethod_AVE:
// The main loop
for (int n = 0; n < top[0]->num(); ++n) {
for (int c = 0; c < channels_; ++c) {
for (int ph = 0; ph < pooled_height_; ++ph) {
for (int pw = 0; pw < pooled_width_; ++pw) {
int hstart = ph * stride_ - pad_;
int wstart = pw * stride_ - pad_;
int hend = min(hstart + kernel_size_, height_ + pad_);
int wend = min(wstart + kernel_size_, width_ + pad_);
int pool_size = (hend - hstart) * (wend - wstart);
hstart = max(hstart, 0);
wstart = max(wstart, 0);
hend = min(hend, height_);
wend = min(wend, width_);
for (int h = hstart; h < hend; ++h) {
for (int w = wstart; w < wend; ++w) {
bottom_diff[h * width_ + w] +=
top_diff[ph * pooled_width_ + pw] / pool_size;
}
}
}
}
// offset
bottom_diff += (*bottom)[0]->offset(0, 1);
top_diff += top[0]->offset(0, 1);
}
}
break;
case PoolingParameter_PoolMethod_STOCHASTIC:
NOT_IMPLEMENTED;
break;
default:
LOG(FATAL) << "Unknown pooling method.";
}
}
/* {ES_SUITE}.add_test */
void F891_7225 (EIF_REFERENCE Current, EIF_TYPED_VALUE arg1x)
{
GTCX
char *l_feature_name = "add_test";
RTEX;
EIF_REFERENCE loc1 = (EIF_REFERENCE) 0;
#define arg1 arg1x.it_r
EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};
#define up1 up1x.it_p
EIF_TYPED_VALUE up2x = {{0}, SK_POINTER};
#define up2 up2x.it_p
EIF_TYPED_VALUE ur1x = {{0}, SK_REF};
#define ur1 ur1x.it_r
EIF_REFERENCE tr1 = NULL;
EIF_REFERENCE tr2 = NULL;
RTCFDT;
RTCDT;
RTSN;
RTDA;
RTLD;
RTLI(6);
RTLR(0,arg1);
RTLR(1,Current);
RTLR(2,tr1);
RTLR(3,tr2);
RTLR(4,loc1);
RTLR(5,ur1);
RTLU (SK_VOID, NULL);
RTLU(SK_REF,&arg1);
RTLU (SK_REF, &Current);
RTLU(SK_REF, &loc1);
RTEAA(l_feature_name, 890, Current, 1, 1, 12838);
RTSA(dtype);
RTSC;
RTME(dtype, 0);
RTGC;
RTDBGEAA(890, Current, 12838);
RTCC(arg1, 890, l_feature_name, 1, eif_attached_type(892));
RTIV(Current, RTAL);
if ((RTAL & CK_REQUIRE) || RTAC) {
RTHOOK(1);
RTCT("unit_tests_class_exists", EX_PRE);
RTTE((EIF_BOOLEAN)(arg1 != NULL), label_1);
RTCK;
RTJB;
label_1:
RTCF;
}
body:;
RTHOOK(2);
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(5135, dtype))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
if ((EIF_BOOLEAN)(tr1 == NULL)) {
RTHOOK(3);
RTDBGAA(Current, dtype, 5135, 0xF8000169, 0); /* classes */
tr1 = RTLNSMART(eif_non_attached_type(RTWCT(5135, dtype, dftype)));
(FUNCTION_CAST(void, (EIF_REFERENCE)) RTWC(2540, Dtype(tr1)))(tr1);
RTNHOOK(3,1);
RTAR(Current, tr1);
*(EIF_REFERENCE *)(Current + RTWA(5135, dtype)) = (EIF_REFERENCE) RTCCL(tr1);
RTHOOK(4);
RTDBGAA(Current, dtype, 5134, 0xF80000DB, 0); /* name */
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(8, dtype))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
RTNHOOK(4,1);
tr2 = ((up2x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(3527, "name", tr1))(tr1)), (((up2x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up2x.it_r = RTBU(up2x))), (up2x.type = SK_POINTER), up2x.it_r);
RTNHOOK(4,2);
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(17, "twin", tr2))(tr2)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
RTNHOOK(4,3);
tr2 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(4381, "as_string_8", tr1))(tr1)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
RTAR(Current, tr2);
*(EIF_REFERENCE *)(Current + RTWA(5134, dtype)) = (EIF_REFERENCE) RTCCL(tr2);
}
Dtype PoolingLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
vector<Blob<Dtype>*>* top) {
const Dtype* bottom_data = bottom[0]->cpu_data();
Dtype* top_data = (*top)[0]->mutable_cpu_data();
const int top_count = (*top)[0]->count();
// We'll output the mask to top[1] if it's of size >1.
const bool use_top_mask = top->size() > 1;
int* mask = NULL; // suppress warnings about uninitalized variables
Dtype* top_mask = NULL;
// Different pooling methods. We explicitly do the switch outside the for
// loop to save time, although this results in more code.
switch (this->layer_param_.pooling_param().pool()) {
case PoolingParameter_PoolMethod_MAX:
// Initialize
if (use_top_mask) {
top_mask = (*top)[1]->mutable_cpu_data();
caffe_set(top_count, Dtype(-1), top_mask);
} else {
mask = max_idx_->mutable_cpu_data();
caffe_set(top_count, -1, mask);
}
caffe_set(top_count, Dtype(-FLT_MAX), top_data);
// The main loop
for (int n = 0; n < bottom[0]->num(); ++n) {
for (int c = 0; c < channels_; ++c) {
for (int ph = 0; ph < pooled_height_; ++ph) {
for (int pw = 0; pw < pooled_width_; ++pw) {
int hstart = ph * stride_ - pad_;
int wstart = pw * stride_ - pad_;
int hend = min(hstart + kernel_size_, height_);
int wend = min(wstart + kernel_size_, width_);
hstart = max(hstart, 0);
wstart = max(wstart, 0);
const int pool_index = ph * pooled_width_ + pw;
for (int h = hstart; h < hend; ++h) {
for (int w = wstart; w < wend; ++w) {
const int index = h * width_ + w;
if (bottom_data[index] > top_data[pool_index]) {
top_data[pool_index] = bottom_data[index];
if (use_top_mask) {
top_mask[pool_index] = static_cast<Dtype>(index);
} else {
mask[pool_index] = index;
}
}
}
}
}
}
// compute offset
bottom_data += bottom[0]->offset(0, 1);
top_data += (*top)[0]->offset(0, 1);
if (use_top_mask) {
top_mask += (*top)[0]->offset(0, 1);
} else {
mask += (*top)[0]->offset(0, 1);
}
}
}
break;
case PoolingParameter_PoolMethod_AVE:
for (int i = 0; i < top_count; ++i) {
top_data[i] = 0;
}
// The main loop
for (int n = 0; n < bottom[0]->num(); ++n) {
for (int c = 0; c < channels_; ++c) {
for (int ph = 0; ph < pooled_height_; ++ph) {
for (int pw = 0; pw < pooled_width_; ++pw) {
int hstart = ph * stride_ - pad_;
int wstart = pw * stride_ - pad_;
int hend = min(hstart + kernel_size_, height_ + pad_);
int wend = min(wstart + kernel_size_, width_ + pad_);
int pool_size = (hend - hstart) * (wend - wstart);
hstart = max(hstart, 0);
wstart = max(wstart, 0);
hend = min(hend, height_);
wend = min(wend, width_);
for (int h = hstart; h < hend; ++h) {
for (int w = wstart; w < wend; ++w) {
top_data[ph * pooled_width_ + pw] +=
bottom_data[h * width_ + w];
}
}
top_data[ph * pooled_width_ + pw] /= pool_size;
}
}
// compute offset
bottom_data += bottom[0]->offset(0, 1);
top_data += (*top)[0]->offset(0, 1);
}
}
break;
case PoolingParameter_PoolMethod_STOCHASTIC:
NOT_IMPLEMENTED;
break;
default:
LOG(FATAL) << "Unknown pooling method.";
}
return Dtype(0.);
}
/* {TO_SPECIAL}.make_filled_area */
void F431_2907 (EIF_REFERENCE Current, EIF_TYPED_VALUE arg1x, EIF_TYPED_VALUE arg2x)
{
GTCX
char *l_feature_name = "make_filled_area";
RTEX;
#define arg1 arg1x.it_r4
#define arg2 arg2x.it_i4
EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};
#define up1 up1x.it_p
EIF_TYPED_VALUE ur4_1x = {{0}, SK_REAL32};
#define ur4_1 ur4_1x.it_r4
EIF_TYPED_VALUE ui4_1x = {{0}, SK_INT32};
#define ui4_1 ui4_1x.it_i4
EIF_TYPED_VALUE ui4_2x = {{0}, SK_INT32};
#define ui4_2 ui4_2x.it_i4
EIF_REFERENCE tr1 = NULL;
EIF_INTEGER_32 ti4_1;
EIF_BOOLEAN tb1;
RTCDT;
RTSN;
RTDA;
RTLD;
if ((arg2x.type & SK_HEAD) == SK_REF) arg2x.it_i4 = * (EIF_INTEGER_32 *) arg2x.it_r;
if ((arg1x.type & SK_HEAD) == SK_REF) arg1x.it_r4 = * (EIF_REAL_32 *) arg1x.it_r;
RTLI(2);
RTLR(0,Current);
RTLR(1,tr1);
RTLU (SK_VOID, NULL);
RTLU(SK_REAL32,&arg1);
RTLU(SK_INT32,&arg2);
RTLU (SK_REF, &Current);
RTEAA(l_feature_name, 430, Current, 0, 2, 3385);
RTSA(dtype);
RTSC;
RTME(dtype, 0);
RTGC;
RTDBGEAA(430, Current, 3385);
RTIV(Current, RTAL);
if ((RTAL & CK_REQUIRE) || RTAC) {
RTHOOK(1);
RTCT("non_negative_argument", EX_PRE);
RTTE((EIF_BOOLEAN) (arg2 >= ((EIF_INTEGER_32) 0L)), label_1);
RTCK;
RTJB;
label_1:
RTCF;
}
body:;
RTHOOK(2);
RTDBGAA(Current, dtype, 2426, 0xF80001AF, 0); /* area */
ur4_1 = arg1;
ui4_1 = arg2;
if (ui4_1< 0) {
eraise ("non_negative_argument", EN_RT_CHECK);
}
tr1 = RTLNSP2(eif_non_attached_type(RTWCT(2426, dtype, Dftype(Current))),0,ui4_1,sizeof(EIF_REAL_32), EIF_TRUE);
(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE, EIF_TYPED_VALUE)) RTWC(2590, Dtype(tr1)))(tr1, ur4_1x, ui4_1x);
RTNHOOK(2,1);
RTAR(Current, tr1);
*(EIF_REFERENCE *)(Current + RTWA(2426, dtype)) = (EIF_REFERENCE) tr1;
if (RTAL & CK_ENSURE) {
RTHOOK(3);
RTCT("area_allocated", EX_POST);
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(2426, dtype))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
if ((EIF_BOOLEAN)(tr1 != NULL)) {
RTCK;
} else {
RTCF;
}
RTHOOK(4);
RTCT("capacity_set", EX_POST);
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(2426, dtype))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
RTNHOOK(4,1);
ti4_1 = (((FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(2494, "capacity", tr1))(tr1)).it_i4);
if ((EIF_BOOLEAN)(ti4_1 == arg2)) {
RTCK;
} else {
RTCF;
}
RTHOOK(5);
RTCT("count_set", EX_POST);
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(2426, dtype))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
RTNHOOK(5,1);
ti4_1 = (((FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(2493, "count", tr1))(tr1)).it_i4);
if ((EIF_BOOLEAN)(ti4_1 == arg2)) {
RTCK;
} else {
RTCF;
}
RTHOOK(6);
RTCT("area_filled", EX_POST);
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(2426, dtype))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
RTNHOOK(6,1);
ur4_1 = arg1;
ui4_1 = ((EIF_INTEGER_32) 0L);
ui4_2 = (EIF_INTEGER_32) (arg2 - ((EIF_INTEGER_32) 1L));
tb1 = (((FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE, EIF_TYPED_VALUE, EIF_TYPED_VALUE, EIF_TYPED_VALUE)) RTVF(2600, "filled_with", tr1))(tr1, ur4_1x, ui4_1x, ui4_2x)).it_b);
if (tb1) {
RTCK;
} else {
RTCF;
}
}
RTVI(Current, RTAL);
RTRS;
RTHOOK(7);
RTDBGLE;
RTMD(0);
RTLE;
RTLO(4);
RTEE;
#undef up1
#undef ur4_1
#undef ui4_1
#undef ui4_2
#undef arg2
#undef arg1
}
void MultinomialLogisticLossMaskLayer<Dtype>::Backward_cpu(
const vector<Blob<Dtype>*>& top, const vector<bool>& propagate_down,
const vector<Blob<Dtype>*>& bottom) {
if (propagate_down[1]) {
LOG(FATAL) << this->type()
<< " Layer cannot backpropagate to label inputs.";
}
const Dtype* bottom_data = bottom[0]->cpu_data();
const Dtype* bottom_label = bottom[1]->cpu_data();
const Dtype* bottom_mask = bottom[2]->cpu_data();
Dtype* bottom_diff = bottom[0]->mutable_cpu_diff();
Dtype* mask_diff = bottom[2]->mutable_cpu_diff();
int dim = bottom[0]->count() / outer_num_;
caffe_set(bottom[0]->count(), Dtype(0), bottom_diff);
caffe_set(bottom[2]->count(), Dtype(0), mask_diff);
if (propagate_down[0]) {
int count = 0;
for (int i = 0; i < outer_num_; ++i) {
for (int j = 0; j < inner_num_; j++) {
const int label_value = static_cast<int>(bottom_label[i * inner_num_ + j]);
if (has_ignore_label_ && label_value == ignore_label_) {
continue;
}
Dtype p = std::max(
bottom_data[i * dim + label_value * inner_num_ + j]
, Dtype(kLOG_THRESHOLD));
bottom_diff[i * dim + label_value * inner_num_ + j] = Dtype(1.0) / p;
++count;
}
}
Dtype scale = - top[0]->cpu_diff()[0] / (std::max(Dtype(1.0), Dtype(count)));
caffe_scal(bottom[0]->count(), scale, bottom_diff);
}
if (propagate_down[2]) {
int count = 0;
for (int i = 0; i < outer_num_; ++i) {
for (int j = 0; j < inner_num_; j++) {
const int label_value = static_cast<int>(bottom_label[i * inner_num_ + j]);
if (has_ignore_label_ && label_value == ignore_label_) {
continue;
}
Dtype m = std::max(
bottom_mask[i * inner_num_+ j]
, Dtype(kLOG_THRESHOLD));
if (label_value != 0){
mask_diff[i * inner_num_ + j] = Dtype(1.0) / m;
}
else{
mask_diff[i * inner_num_ + j] = Dtype(1.0) / (m-1);
}
++count;
}
}
Dtype scale = - top[0]->cpu_diff()[0] / (std::max(Dtype(1.0), Dtype(count)));
caffe_scal(bottom[2]->count(), scale, mask_diff);
}
}
/* {EXCEPTION}.message */
EIF_TYPED_VALUE F90_1558 (EIF_REFERENCE Current)
{
GTCX
char *l_feature_name = "message";
RTEX;
EIF_REFERENCE loc1 = (EIF_REFERENCE) 0;
EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};
#define up1 up1x.it_p
EIF_TYPED_VALUE ui4_1x = {{0}, SK_INT32};
#define ui4_1 ui4_1x.it_i4
EIF_TYPED_VALUE ui4_2x = {{0}, SK_INT32};
#define ui4_2 ui4_2x.it_i4
EIF_REFERENCE tr1 = NULL;
EIF_INTEGER_32 ti4_1;
EIF_REFERENCE Result = ((EIF_REFERENCE) 0);
RTSN;
RTDA;
RTLD;
RTLI(4);
RTLR(0,loc1);
RTLR(1,Current);
RTLR(2,tr1);
RTLR(3,Result);
RTLU (SK_REF, &Result);
RTLU (SK_REF, &Current);
RTLU(SK_REF, &loc1);
RTEAA(l_feature_name, 89, Current, 1, 0, 1494);
RTSA(Dtype(Current));
RTSC;
RTME(Dtype(Current), 0);
RTGC;
RTDBGEAA(89, Current, 1494);
RTIV(Current, RTAL);
RTHOOK(1);
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(1453, Dtype(Current)))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
loc1 = RTCCL(tr1);
if (EIF_TEST(loc1)) {
RTHOOK(2);
RTDBGAL(Current, 0, 0xF8000101, 0,0); /* Result */
ui4_1 = ((EIF_INTEGER_32) 1L);
ti4_1 = *(EIF_INTEGER_32 *)(loc1 + RTVA(1811, "count", loc1));
ui4_2 = ti4_1;
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE, EIF_TYPED_VALUE, EIF_TYPED_VALUE)) RTVF(1800, "substring", loc1))(loc1, ui4_1x, ui4_2x)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
Result = (EIF_REFERENCE) RTCCL(tr1);
}
RTVI(Current, RTAL);
RTRS;
RTHOOK(3);
RTDBGLE;
RTMD(0);
RTLE;
RTLO(3);
RTEE;
{ EIF_TYPED_VALUE r; r.type = SK_REF; r.it_r = Result; return r; }
#undef up1
#undef ui4_1
#undef ui4_2
}
/* {MISMATCH_CORRECTOR}.correct_mismatch */
void F116_2287 (EIF_REFERENCE Current)
{
GTCX
char *l_feature_name = "correct_mismatch";
RTEX;
EIF_REFERENCE loc1 = (EIF_REFERENCE) 0;
EIF_REFERENCE loc2 = (EIF_REFERENCE) 0;
EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};
#define up1 up1x.it_p
EIF_TYPED_VALUE up2x = {{0}, SK_POINTER};
#define up2 up2x.it_p
EIF_TYPED_VALUE ur1x = {{0}, SK_REF};
#define ur1 ur1x.it_r
EIF_REFERENCE tr1 = NULL;
EIF_REFERENCE tr2 = NULL;
RTSN;
RTDA;
RTLD;
RTLI(6);
RTLR(0,loc1);
RTLR(1,tr1);
RTLR(2,tr2);
RTLR(3,ur1);
RTLR(4,loc2);
RTLR(5,Current);
RTLU (SK_VOID, NULL);
RTLU (SK_REF, &Current);
RTLU(SK_REF, &loc1);
RTLU(SK_REF, &loc2);
RTEAA(l_feature_name, 115, Current, 2, 0, 4828);
RTSA(Dtype(Current));
RTSC;
RTME(Dtype(Current), 0);
RTGC;
RTDBGEAA(115, Current, 4828);
RTIV(Current, RTAL);
RTHOOK(1);
RTDBGAL(Current, 1, 0xF80000AA, 0, 0); /* loc1 */
tr1 = RTLN(170);
tr2 = RTMS_EX_H("Mismatch: ",10,1538098208);
ur1 = tr2;
(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWC(2970, Dtype(tr1)))(tr1, ur1x);
RTNHOOK(1,1);
loc1 = (EIF_REFERENCE) RTCCL(tr1);
RTHOOK(2);
RTDBGAL(Current, 2, 0xF800002A, 0, 0); /* loc2 */
tr1 = RTLN(42);
(FUNCTION_CAST(void, (EIF_REFERENCE)) RTWC(32, Dtype(tr1)))(tr1);
RTNHOOK(2,1);
loc2 = (EIF_REFERENCE) RTCCL(tr1);
RTHOOK(3);
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(8, Dtype(Current)))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
tr2 = ((up2x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(2057, "to_string_8", tr1))(tr1)), (((up2x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up2x.it_r = RTBU(up2x))), (up2x.type = SK_POINTER), up2x.it_r);
ur1 = RTCCL(tr2);
(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTVF(3098, "append", loc1))(loc1, ur1x);
RTHOOK(4);
ur1 = RTCCL(loc1);
(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTVF(787, "raise_retrieval_exception", loc2))(loc2, ur1x);
RTVI(Current, RTAL);
RTRS;
RTHOOK(5);
RTDBGLE;
RTMD(0);
RTLE;
RTLO(4);
RTEE;
#undef up1
#undef up2
#undef ur1
}
/* {EXCEPTION}.trace */
EIF_TYPED_VALUE F90_1561 (EIF_REFERENCE Current)
{
GTCX
char *l_feature_name = "trace";
RTEX;
struct eif_ex_33 sloc1;
EIF_REFERENCE loc1 = (EIF_REFERENCE) sloc1.data;
EIF_REFERENCE loc2 = (EIF_REFERENCE) 0;
EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};
#define up1 up1x.it_p
EIF_TYPED_VALUE ur1x = {{0}, SK_REF};
#define ur1 ur1x.it_r
EIF_REFERENCE tr1 = NULL;
EIF_REFERENCE Result = ((EIF_REFERENCE) 0);
RTSN;
RTDA;
RTLD;
memset (&sloc1.overhead, 0, OVERHEAD + 0);
sloc1.overhead.ov_flags = EO_EXP | EO_STACK;
RT_DFS(&sloc1.overhead, 33);
RTLI(6);
RTLR(0,loc2);
RTLR(1,Current);
RTLR(2,tr1);
RTLR(3,loc1);
RTLR(4,ur1);
RTLR(5,Result);
RTLU (SK_REF, &Result);
RTLU (SK_REF, &Current);
RTLU(SK_REF, &loc1);
RTLU(SK_REF, &loc2);
RTEAA(l_feature_name, 89, Current, 2, 0, 1497);
RTSA(Dtype(Current));
RTSC;
RTME(Dtype(Current), 0);
RTGC;
RTDBGEAA(89, Current, 1497);
RTIV(Current, RTAL);
wstdinit(loc1,loc1);
RTLXI(loc1);
RTHOOK(1);
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(1457, Dtype(Current)))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
loc2 = RTCCL(tr1);
if (EIF_TEST(loc2)) {
RTHOOK(2);
RTDBGAL(Current, 0, 0xF8000107, 0,0); /* Result */
ur1 = RTCCL(loc2);
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTVF(559, "utf_8_string_8_to_string_32", loc1))(loc1, ur1x)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
Result = (EIF_REFERENCE) RTCCL(tr1);
}
RTVI(Current, RTAL);
RTRS;
RTHOOK(3);
RTDBGLE;
RTMD(0);
RTLE;
RTLO(4);
RTEE;
{ EIF_TYPED_VALUE r; r.type = SK_REF; r.it_r = Result; return r; }
#undef up1
#undef ur1
}
/* {BASE64}.valid_encoded_string */
EIF_TYPED_VALUE F19_462 (EIF_REFERENCE Current, EIF_TYPED_VALUE arg1x)
{
GTCX
char *l_feature_name = "valid_encoded_string";
RTEX;
#define arg1 arg1x.it_r
EIF_TYPED_VALUE ur1x = {{0}, SK_REF};
#define ur1 ur1x.it_r
EIF_INTEGER_32 ti4_1;
EIF_BOOLEAN tb1;
EIF_BOOLEAN tb2;
EIF_BOOLEAN tb3;
EIF_BOOLEAN Result = ((EIF_BOOLEAN) 0);
RTSN;
RTDA;
RTLD;
RTLI(3);
RTLR(0,arg1);
RTLR(1,ur1);
RTLR(2,Current);
RTLU (SK_BOOL, &Result);
RTLU(SK_REF,&arg1);
RTLU (SK_REF, &Current);
RTEAA(l_feature_name, 18, Current, 0, 1, 544);
RTSA(Dtype(Current));
RTSC;
RTME(Dtype(Current), 0);
RTGC;
RTDBGEAA(18, Current, 544);
RTCC(arg1, 18, l_feature_name, 1, eif_attached_type(218));
RTIV(Current, RTAL);
RTHOOK(1);
RTDBGAL(Current, 0, 0x04000000, 1,0); /* Result */
tb1 = '\0';
ur1 = RTCCL(arg1);
tb2 = (((FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWF(459, 365))(Current, ur1x)).it_b);
if (tb2) {
tb2 = '\01';
tb3 = (((FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(3613, "is_empty", arg1))(arg1)).it_b);
if (!tb3) {
ti4_1 = *(EIF_INTEGER_32 *)(arg1 + RTVA(3756, "count", arg1));
tb2 = (EIF_BOOLEAN) (ti4_1 >= ((EIF_INTEGER_32) 4L));
}
tb1 = tb2;
}
Result = (EIF_BOOLEAN) tb1;
RTVI(Current, RTAL);
RTRS;
RTHOOK(2);
RTDBGLE;
RTMD(0);
RTLE;
RTLO(3);
RTEE;
{ EIF_TYPED_VALUE r; r.type = SK_BOOL; r.it_b = Result; return r; }
#undef ur1
#undef arg1
}
void SparseDepthMahalanobisLossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom)
{
for (int i = 0; i < 2; ++i) {
if (propagate_down[i]) {
const Dtype sign = (i == 0) ? 1 : -1;
const Dtype alpha = sign * top[0]->cpu_diff()[0] / bottom[i]->num();
if (bottom.size() >= 3) {
caffe_cpu_axpby(
bottom[i]->count(), // count
alpha, // alpha
UtUdiff_.cpu_data(), // a
Dtype(0), // beta
bottom[i]->mutable_cpu_diff()); // b
} else {
caffe_cpu_axpby(
bottom[i]->count(), // count
alpha, // alpha
diff_.cpu_data(), // a
Dtype(0), // beta
bottom[i]->mutable_cpu_diff()); // b
}
}
}
if (bottom.size() >= 3 && propagate_down[2])
{
const Dtype alpha = top[0]->cpu_diff()[0]/bottom[0]->num();
int num = bottom[0]->num();
int height = bottom[0]->height();
int width = bottom[0]->width();
int spatial_count = height*width;
const Dtype* label = bottom[1]->cpu_data();
for (int n = 0; n < num; ++n)
{
for (int h = 0; h < height; ++h)
{
for (int w = 0; w < width; ++w)
{
int offset = n*spatial_count + h*width + w;
Dtype d_loss = alpha*Udiff_.cpu_data()[offset]*diff_.cpu_data()[offset]; // the contribution from the loss
Dtype mask = *(label + bottom[1]->offset(n,0,h,w));
// the diagonal elements contribute to the regularizer and have an abs
// non linearity
Dtype d_reg = top[0]->cpu_diff()[0] / bottom[0]->num();
d_reg *= Dtype(-1) / (fabs(bottom[2]->cpu_data()[offset]) + Dtype(EPS));
if (bottom[2]->cpu_data()[offset] < 0)
{
d_loss *= -1;
d_reg *= -1;
}
if (mask == Dtype(MASK_VAL))
{
bottom[2]->mutable_cpu_diff()[offset] = Dtype(0);
}
else bottom[2]->mutable_cpu_diff()[offset] = d_loss + d_reg;
} // for w
} // for h
} // for n
} // if (bottom.size() >=3 ...
}
/* {NATURAL_16_REF}.to_natural_16 */
EIF_NATURAL_16 F870_9320 (EIF_REFERENCE Current)
{
GTCX
return (EIF_NATURAL_16) *(EIF_NATURAL_16 *)(Current+ _I16OFF_0_0_0_);
}
/* {NATURAL_16_REF}.to_natural_32 */
EIF_NATURAL_32 F870_9321 (EIF_REFERENCE Current)
{
GTCX
return (EIF_NATURAL_32) (FUNCTION_CAST(EIF_NATURAL_32, (EIF_REFERENCE)) R7462[Dtype(Current)-869])(Current);
}
/* {NATURAL_16_REF}.to_natural_64 */
EIF_NATURAL_64 F870_9322 (EIF_REFERENCE Current)
{
GTCX
return (EIF_NATURAL_64) (FUNCTION_CAST(EIF_NATURAL_64, (EIF_REFERENCE)) R7463[Dtype(Current)-869])(Current);
}
/* {NATURAL_16_REF}.to_integer_32 */
EIF_INTEGER_32 F870_9325 (EIF_REFERENCE Current)
{
GTCX