// Encode the object
void EncodeSelf(NEncoder &theEncoder) const
{ NArray theArray;
NDictionary theDict;
NData theData;
theData = NData(NN_ARRAY_SIZE(kValueData), kValueData);
theArray.AppendValue(kValueBoolean1);
theArray.AppendValue(kValueNumber1);
theArray.AppendValue(kValueString);
theDict.SetValue(kKeyBoolean1, kValueBoolean1);
theDict.SetValue(kKeyNumber1, kValueNumber1);
theDict.SetValue(kKeyString, kValueString);
theDict.SetValue(kKeyPoint, kValuePoint);
theDict.SetValue(kKeySize, kValueSize);
theDict.SetValue(kKeyRectangle, kValueRectangle);
theEncoder.EncodeBoolean(kKeyBoolean1, kValueBoolean1);
theEncoder.EncodeBoolean(kKeyBoolean2, kValueBoolean2);
theEncoder.EncodeNumber( kKeyNumber1, kValueNumber1);
theEncoder.EncodeNumber( kKeyNumber2, kValueNumber2);
theEncoder.EncodeNumber( kKeyNumber3, kValueNumber3);
theEncoder.EncodeNumber( kKeyNumber4, kValueNumber4);
theEncoder.EncodeString( kKeyString, kValueString);
theEncoder.EncodeData( kKeyData, theData);
theEncoder.EncodeObject( kKeyArray, theArray);
theEncoder.EncodeObject( kKeyDictionary, theDict);
}
// Decode the object
void DecodeSelf(const NEncoder &theEncoder)
{ NArray theArray;
NDictionary theDict;
NData theData;
NN_ASSERT(theEncoder.DecodeBoolean(kKeyBoolean1) == kValueBoolean1);
NN_ASSERT(theEncoder.DecodeBoolean(kKeyBoolean2) == kValueBoolean2);
NN_ASSERT(theEncoder.DecodeNumber( kKeyNumber1) == kValueNumber1);
NN_ASSERT(theEncoder.DecodeNumber( kKeyNumber2) == kValueNumber2);
NN_ASSERT(theEncoder.DecodeNumber( kKeyNumber3) == kValueNumber3);
NN_ASSERT(theEncoder.DecodeNumber( kKeyNumber4) == kValueNumber4);
NN_ASSERT(theEncoder.DecodeString( kKeyString) == kValueString);
theData = theEncoder.DecodeData(kKeyData);
NN_ASSERT(theData.GetSize() == NN_ARRAY_SIZE(kValueData));
NN_ASSERT(memcmp(theData.GetData(), kValueData, (size_t) theData.GetSize()) == 0);
NN_ASSERT(theEncoder.DecodeObject(kKeyArray).GetValue(theArray));
NN_ASSERT(theArray.GetSize() == 3);
NN_ASSERT(theArray.GetValueBoolean(0) == kValueBoolean1);
NN_ASSERT(theArray.GetValue (1) == kValueNumber1);
NN_ASSERT(theArray.GetValueString (2) == kValueString);
NN_ASSERT(theEncoder.DecodeObject(kKeyDictionary).GetValue(theDict));
NN_ASSERT(theDict.GetSize() == 6);
NN_ASSERT(theDict.GetValueBoolean (kKeyBoolean1) == kValueBoolean1);
NN_ASSERT(theDict.GetValue (kKeyNumber1) == kValueNumber1);
NN_ASSERT(theDict.GetValueString (kKeyString) == kValueString);
NN_ASSERT(theDict.GetValuePoint (kKeyPoint) == kValuePoint);
NN_ASSERT(theDict.GetValueSize (kKeySize) == kValueSize);
NN_ASSERT(theDict.GetValueRectangle(kKeyRectangle) == kValueRectangle);
}
TEST(Histogram, Complex) {
auto& ms = MinervaSystem::Instance();
ms.SetDevice(cpu_device);
float input_raw[] = {5.25103347e-02, 1.92732021e-01, -8.96084910e-01, 7.90179056e-01, 4.56532361e-01, 6.36700023e-01, 4.45505669e-04, -6.37884921e-02, -8.12535948e-02, 4.19019560e-01, -6.43893988e-01, 6.28997687e-02, -6.64515542e-01, 5.37627837e-01, -2.45310092e-01, 6.97202824e-01, 8.22194457e-01, -2.32302558e-01, -3.69008193e-01, 1.36788306e-01, -6.24363930e-01, 9.46459963e-01, 2.68108754e-01, 7.76843450e-01, -9.17048249e-03, -2.96766940e-01, 4.28460737e-01, 7.85823290e-03, 8.30187347e-01, 8.90743668e-01, 6.64644593e-02, -4.95014811e-01, 4.41724116e-01, -2.65122472e-01, -2.70311418e-03, 5.37470894e-01, 5.63674207e-01, 7.04818966e-01, 8.99811480e-01, -7.85354176e-01, 8.21450712e-01, -3.27889676e-01, 5.59052417e-01, -1.98597912e-01, 5.89058463e-01, 7.86248621e-01, -4.75020618e-01, 9.78394015e-01, 7.06614198e-01, 9.11532892e-01, -9.99785487e-01, -9.66917916e-01, -3.71859885e-01, 9.90632349e-01, -7.02311554e-01, -6.65245763e-01, -9.79623568e-01, 5.49647726e-01, 5.88402017e-01, -7.00861097e-01, -9.52592736e-01, 5.24127542e-01, -5.52659640e-01, 6.93885994e-01, -2.43800926e-01, -1.35069767e-01, 6.65238353e-01, -2.57736129e-01, -9.18893456e-01, 1.09342972e-01, -6.13706128e-02, 1.25286858e-01, 3.22398678e-01, -7.55162650e-02, 2.47273891e-01, -5.56238738e-01, 4.65726234e-01, -6.95721875e-01, 5.42747408e-01, -4.89176535e-01, -7.44913190e-01, 3.30334307e-01, -1.74390103e-01, 3.35535533e-01, -6.26250490e-01, -4.07823970e-01, 5.97030118e-01, -4.10443414e-01, 3.94243187e-01, -4.54081542e-01, 8.25056903e-01, -2.81417189e-01, 3.64354606e-01, 8.42783940e-01, -7.10151312e-01, -8.00251230e-01, -1.76794447e-01, 9.50250742e-01, -3.67423692e-01, 2.20271553e-01, -5.97610574e-01, 3.83795433e-01, -5.10746058e-01, 3.60743392e-01, -2.81245422e-02, 6.82296085e-01, -6.07151251e-01, -3.38833141e-01, 8.93259770e-01, 1.21436991e-02, -1.93168283e-01, -9.45876923e-01, -3.31218962e-01, -8.64580115e-01, -9.92351503e-01, -9.18064393e-01, -3.02090269e-01, -8.16091378e-01, 4.06314529e-02, 5.24922383e-02, -1.20153861e-01, 3.23110491e-01, -7.30429651e-01, 5.75698010e-01, -7.24044598e-01, 2.65846595e-01, 5.78064850e-01, 3.24041516e-01, 4.23024858e-01, 7.75847324e-01, -7.16649418e-01, -7.04859753e-01, -3.48138314e-01, 2.32015221e-01, 9.16999718e-01, -4.17894767e-01, 3.73356925e-01, -9.15543539e-01, -8.74992737e-01, 6.28797391e-01, 6.70704305e-01, -6.64622476e-02, -1.57428024e-01, 1.41703106e-01, 4.78111913e-01, -8.89833183e-01, 2.48361298e-01, 1.71500734e-01, -1.03241151e-01, -2.92539465e-01, 8.67050469e-01, -4.65488136e-01, -4.37401239e-01, 9.81192729e-03, 1.76624177e-01, 4.63404565e-01, -6.48977854e-01, 2.10775692e-02, 5.69191679e-04, 7.85535264e-01, -2.34634585e-01, 8.96057273e-01, -3.05549564e-01, 3.67786398e-01, 6.49269763e-01, -2.74940115e-02, 9.68351743e-01, 2.07628076e-01, 1.85028318e-01, -3.49798716e-01, 8.73610682e-01, -8.08034049e-01, 7.66591492e-01, 1.36035466e-01, -8.76153051e-01, -9.42090961e-01, 2.54198007e-01, 2.09278522e-01, -8.43584950e-01, 5.45907125e-01, -7.13366751e-01, -7.26307843e-02, 4.97412749e-01, 7.79227666e-01, -2.41219689e-01, -4.15127476e-01, 1.85804799e-02, 6.56272008e-02, -7.89156759e-01, 5.95946891e-01, -5.11510156e-01, 6.07075484e-01, -4.03649869e-01, -6.54580737e-02, 8.65639316e-01, 8.19513569e-01, 2.93617672e-01, -3.35847054e-01, -7.71555326e-01, 1.42208982e-01, -3.96017041e-01, -6.12988788e-01, 1.29411384e-01, -1.88205315e-01, 3.31118167e-01, -6.05975908e-01, -5.16439080e-01, 2.46344907e-01, 5.97476702e-01, 8.92727341e-02, 8.77082477e-01, 4.78201578e-01, -9.46106323e-01, -2.35208227e-01, -9.78947208e-01, -8.69535860e-01, 3.62785391e-01, 7.88573716e-01, 4.13573947e-01, -4.22013528e-02, -5.68775015e-01, -8.36467872e-01, 3.46404408e-01, 9.89558378e-01, 8.96711938e-02, 9.67284551e-01, 4.71404282e-01, -8.13833601e-01, -4.15551966e-01, -4.53903666e-01, -8.57667173e-01, -5.76563967e-01, -4.14422920e-01, -2.87165417e-01, 9.12734981e-01, 3.20487724e-01, 9.01024809e-01, -8.06264818e-01, -4.12511687e-01, 2.99419879e-01, -1.58010723e-01, -8.50696651e-01, 4.77613710e-01, 1.70740085e-01, -3.10658805e-01, -4.22856328e-01, -4.71636816e-01, -4.46162130e-01, 6.84712020e-01, -6.60755426e-01, -4.95826747e-01, 1.83750401e-01};
float correct_raw[] = {-0.800744 , 26.000000,
-0.601702 , 24.000000,
-0.402660 , 27.000000,
-0.203618 , 25.000000,
-0.004577 , 21.000000,
0.194465 , 29.000000,
0.393507 , 26.000000,
0.592549 , 26.000000,
0.791591 , 23.000000,
0.990632 , 25.000000};
Scale size{7, 6, 3, 2};
shared_ptr<float> input_ptr(new float[size.Prod()], [](float* ptr) { delete[] ptr; });
memcpy(input_ptr.get(), input_raw, size.Prod() * sizeof(float));
int bins = 10;
NArray input = NArray::MakeNArray(size,input_ptr);
NArray out = input.Histogram(bins);
auto output_ptr = out.Get();
for (int i = 0; i < bins; ++i) {
EXPECT_NEAR(output_ptr.get()[i], correct_raw[2*i],0.001);
EXPECT_NEAR(output_ptr.get()[i+bins], correct_raw[2*i+1],0.001);
//printf("%f : %f\n",output_ptr.get()[i],output_ptr.get()[i+bins]);
}
}
TEST(PerfTest, LongChain) {
NArray a = NArray::Constant({10, 10}, 0.0);
for (int i = 0; i < 5000; ++i) {
a += 1;
}
a.WaitForEval();
}
void NQueue<Type, ALIGN_SIZE, memory>::reserve()
{
if(m_uActualBack < m_uActualFront) // In the middle
{
NArray<Type> temp;
temp.create(uSize); NCM_V(memory);
memcpy(temp.data(), m_data.data() + m_uActualFront, m_data.size() - m_uActualFront); // Copy front part
memcpy(temp.data() + m_data.size() - m_uActualFront, m_data.data(), m_uActualFront); // Copy back part
m_uActualFront = 0;
m_uActualBack = m_uSize - 1;
m_data.release();
m_data = temp;
}
else { m_data.resize(m_data.size() + m_uReallocSize); }
}
TType* typeChk(Symtable& t,TType* expected = NULL){
#ifdef DEBUG
cout <<"\nbeginnig arr typechk"<<endl;
#endif
TType* s = size.typeChk(t);
TType* x = t.lookupType(type.name);
TType* el = NULL;
if(elements!=NULL)
el = elements->typeChk(t);
#ifdef DEBUG
cout << "x s el " << x << " " << s << " " << el << endl;
#endif
if(x == NULL){
fprintf(stderr, "Array type does not exists.\n");
return NULL;
}else if(s->name!="integer"){
fprintf(stderr, "Array size expression is not an integer.\n");
return NULL;
}else if(elements!=NULL && el==NULL){
return NULL;
}else if(x!=NULL && el!=NULL && x->name!=el->name){
fprintf(stderr, "Array type is not the same type as array elements.\n");
return NULL;
}
return x;
}
TEST(LeftConst, CpuLeftConst) {
auto& ms = MinervaSystem::Instance();
ms.SetDevice(cpu_device);
int m = 8;
int k = 100;
NArray a = NArray::Randn({m, k}, 0.0, 1.0);
NArray b = 1 - a;
NArray b1 = 1 - b;
NArray b2 = 2 - b1;
NArray b3 = 3 - b2;
NArray b4 = 4 - b3;
NArray b5 = 5 - b4;
auto in = a.Get();
auto res = b.Get();
auto in_ptr = in.get();
auto res_ptr = res.get();
for (int i = 0; i < a.Size().Prod(); ++i) {
EXPECT_FLOAT_EQ(1 - in_ptr[i], res_ptr[i]);
}
}
void NQueue<Type, ALIGN_SIZE, memory>::push_back(const Type& element)
{
if(m_uSize + 1 > m_data.size()) // Full
{
if(m_uActualBack != (m_data.size() - 1)) // In the middle
{
NArray<Type, ALIGN_SIZE, memory> temp;
temp.create(m_data.size() + m_uReallocSize); NCM_V(memory);
memcpy(temp.data(), m_data.data() + m_uActualFront, m_data.size() - m_uActualFront); // Copy front part
memcpy(temp.data() + m_data.size() - m_uActualFront, m_data.data(), m_uActualFront); // Copy back part
m_uActualFront = 0;
m_data.release();
m_data = temp;
}
else { m_data.resize(m_data.size() + m_uReallocSize); NCM_V(memory);}
}
++m_uSize;
m_uActualBack = m_uActualFront + m_uSize > m_data.size() ? m_uSize - (m_data.size() - m_uActualFront) - 1 : m_uActualFront + m_uSize - 1;
m_data[m_uActualBack] = element;
}
TEST(Histogram, SameValues) {
auto& ms = MinervaSystem::Instance();
ms.SetDevice(cpu_device);
float input_raw[] = {2,2,2,2,2,2,2,2,2};
float correct_raw[] = {2.000000 , 9.000000,
2.000000 , 0.000000,
2.000000 , 0.000000};
Scale size{3, 3};
shared_ptr<float> input_ptr(new float[size.Prod()], [](float* ptr) { delete[] ptr; });
memcpy(input_ptr.get(), input_raw, size.Prod() * sizeof(float));
int bins = 3;
NArray input = NArray::MakeNArray(size,input_ptr);
NArray out = input.Histogram(bins);
auto output_ptr = out.Get();
for (int i = 0; i < bins; ++i) {
EXPECT_FLOAT_EQ(output_ptr.get()[i], correct_raw[2*i]);
EXPECT_FLOAT_EQ(output_ptr.get()[i+bins], correct_raw[2*i+1]);
//printf("%f : %f\n",output_ptr.get()[i],output_ptr.get()[i+bins]);
}
}
ImageBatch Convolution::ConvForward(ImageBatch src, Filter filter, NArray bias, ConvInfo info) {
CHECK_EQ(src.GetNumFeatureMaps(), filter.GetNumInputs()) << "#input channels mismatch";
CHECK_EQ(bias.Size().NumDims(), 1) << "bias dimension mismatch";
CHECK_EQ(bias.Size()[0], filter.GetNumOutputs()) << "bias size mismatch";
//no such limit
//CHECK_EQ((src.GetHeight() + 2 * info.pad_height - filter.GetHeight()) % info.stride_vertical, 0) << "filter height mismatch";
//CHECK_EQ((src.GetWidth() + 2 * info.pad_width - filter.GetWidth()) % info.stride_horizontal, 0) << "filter width mismatch";
Scale new_size {
(src.GetWidth() + 2 * info.pad_width - filter.GetWidth()) / info.stride_horizontal + 1,
(src.GetHeight() + 2 * info.pad_height - filter.GetHeight()) / info.stride_vertical + 1,
filter.GetNumOutputs(),
src.GetNumImages()
};
ConvForwardOp* op = new ConvForwardOp();
op->closure = {
info.pad_height,
info.pad_width,
info.stride_vertical,
info.stride_horizontal
};
return NArray::ComputeOne({src, filter, bias}, new_size, op);
}
TType* typeChk(Symtable& t,TType* expected = NULL){
bool err=false;
if (beg==NULL){
TType* artype;
if(array==NULL){
artype=cons_arr->typeChk(t);
if(artype==NULL){
err=true;
cerr<<"\tin for array"<<endl;
}
}else{
artype=array->typeChk(t);
if(artype==NULL){
err=true;
cerr<<"\tin for array var"<<endl;
}
}
}else{
TType* b= beg->typeChk(t);
TType* e= end->typeChk(t);
TType* s=NULL;
if(step!= NULL){
s=step->typeChk(t);
}
if(b==NULL){
err=true;
cerr<<"\tin for range beginning"<<endl;
}
if(e==NULL){
err=true;
cerr<<"\tin for range end"<<endl;
}
if(step!=NULL&&s==NULL){
err=true;
cerr<<"\tin for step"<<endl;
}
if(b->name!="integer" || e->name!="integer" || (step!=NULL && s->name!="integer")){
err=true;
cerr<<"Error: For ranges and steps must be integers"<<endl;
}
}
if(err)return NULL;
return t.lookupType("void");
}
void printTree(std::ostream& os, int depth =0){
os<<string(depth,' ')<<"NFor:"<<endl;
if(beg!=NULL){
os<<string(depth+1,' ')<<"range"<<endl;
beg->printTree(os,depth+2);
end->printTree(os,depth+2);
if(step!=NULL){
os<<string(depth+1,' ')<<"step"<<endl;
beg->printTree(os,depth+2);
}
}else{
os<<string(depth+1,' ')<<"arr"<<endl;
if(array!=NULL){
array->printTree(os,depth+2);
}else{
cons_arr->printTree(os,depth+2);
}
}
}
PQueue(uint16 FirstNode, int16 _Weight)
{ Next = NULL;
Weight = Weight;
Elements.Set(FirstNode,0); }
NInt AddRange(NInt baseIndex, const NArray & values)
{
NInt index;
NCheck(NArrayCollectionAddItemRange(GetHandle(), baseIndex, values.GetHandle(), &index));
return index;
}
void PrintTrainingAccuracy(NArray o, NArray t) {
NArray predict = o.Reshape({10, mb_size}).MaxIndex(0);
NArray groundtruth = t.Reshape({10, mb_size}).MaxIndex(0);
float correct = (predict - groundtruth).CountZero();
cout << "Training Error: " << (mb_size - correct) / mb_size << endl;
}
void printTree(std::ostream& os, int depth =0){
os<<string(depth,' ')<<"NArrayDecl: id= "<< id.name<<" type="<<type.name<<endl;
if(elements!=NULL) {
elements->printTree(os,depth+1);
}
}
TEST(PerfTest, LongChainInOne) {
NArray a = NArray::Constant({10, 10}, 0.0);
NArray b = NArray::ComputeOne({a}, {a.Size()}, new AddOneManyTimesOp());
b.WaitForEval();
}
void InsertRange(NInt baseIndex, NInt index, const NArray & values)
{
NCheck(NArrayCollectionInsertItemRange(GetHandle(), baseIndex, index, values.GetHandle()));
}
