|
|
e4740d |
#ifndef SEGMENT_CONV_INC_CPP
|
|
|
e4740d |
#define SEGMENT_CONV_INC_CPP
|
|
|
e4740d |
|
|
|
e4740d |
|
|
|
e4740d |
#include "segment.inc.cpp"
|
|
|
e4740d |
#include "func.inc.cpp"
|
|
|
e4740d |
#include "layer.conv.inc.cpp"
|
|
|
e4740d |
|
|
|
e4740d |
|
|
|
e4740d |
class SegmentConv: public Segment {
|
|
|
e4740d |
public:
|
|
|
e4740d |
enum {
|
|
|
e4740d |
KSX = 4,
|
|
|
e4740d |
KSY = 4,
|
|
|
e4740d |
};
|
|
|
e4740d |
|
|
|
e4740d |
const int msx, msy, msz;
|
|
|
e4740d |
|
|
|
e4740d |
NeuronReal *m_values;
|
|
|
e4740d |
NeuronReal *b_values;
|
|
|
e4740d |
|
|
|
e4740d |
SegmentConv(int sx, int sy, int sz, int msz, Weight *weights = nullptr):
|
|
|
e4740d |
Segment(sx, sy, sz, msz*KSY*KSX*sz, weights), msx((sx - KSX)/2 + 1), msy((sy - KSY)/2 + 1), msz(msz)
|
|
|
e4740d |
{
|
|
|
e4740d |
assert(msx > 0);
|
|
|
e4740d |
assert(msy > 0);
|
|
|
e4740d |
assert(msz > 0);
|
|
|
e4740d |
m_values = new NeuronReal[msx*msy*msz + sx*sy*sz];
|
|
|
e4740d |
b_values = m_values + msx*msy*msz;
|
|
|
e4740d |
clear();
|
|
|
e4740d |
}
|
|
|
e4740d |
~SegmentConv()
|
|
|
e4740d |
{ delete[] m_values; }
|
|
|
e4740d |
|
|
|
e4740d |
|
|
|
e4740d |
void clear() override
|
|
|
e4740d |
{ memset(m_values, 0, sizeof(*m_values)*(msx*msy*msz + sx*sy*sz)); }
|
|
|
e4740d |
|
|
|
e4740d |
|
|
|
e4740d |
inline void check(int x, int y, int z) {
|
|
|
e4740d |
Segment::check(x, y, z);
|
|
|
e4740d |
assert(layout.getD() == sz);
|
|
|
e4740d |
}
|
|
|
e4740d |
|
|
|
e4740d |
|
|
|
e4740d |
|
|
|
e4740d |
Quality pass(Barrier &barrier, int x, int y, int z, NeuronReal trainRatio) override {
|
|
|
e4740d |
check(x, y, z);
|
|
|
e4740d |
Layout l = layout;
|
|
|
e4740d |
NeuronReal *f_values = this->f_values + (y*l.sx + x)*l.sz + z;
|
|
|
e4740d |
}
|
|
|
e4740d |
|
|
|
e4740d |
__attribute__((always_inline))
|
|
|
e4740d |
inline Quality pass(Barrier &barrier, NeuronReal *f_values, NeuronReal trainRatio) {
|
|
|
e4740d |
Layout l = layout;
|
|
|
e4740d |
int tid = barrier.tid;
|
|
|
e4740d |
int threads = barrier.threads;
|
|
|
e4740d |
|
|
|
e4740d |
int sx = this->sx;
|
|
|
e4740d |
//int sy = this->sy;
|
|
|
e4740d |
int sz = this->sz;
|
|
|
e4740d |
int msx = this->msx;
|
|
|
e4740d |
int msy = this->msy;
|
|
|
e4740d |
int msz = this->msz;
|
|
|
e4740d |
int msxz = msx*msz;
|
|
|
e4740d |
|
|
|
e4740d |
int ksxz = KSX*sz;
|
|
|
e4740d |
int ksyxz = KSY*ksxz;
|
|
|
e4740d |
|
|
|
e4740d |
int fv_dkx = l.sz - sz;
|
|
|
e4740d |
int fv_dky = (l.sx - KSX)*l.sz;
|
|
|
e4740d |
int fv_dmx = 2*l.sz;
|
|
|
e4740d |
int fv_dmy = 2*(l.sx - msx)*l.sz;
|
|
|
e4740d |
|
|
|
e4740d |
int mn_dtz = threads - msx*msy*msz;
|
|
|
e4740d |
|
|
|
e4740d |
// stage 1: pass from front to mid
|
|
|
e4740d |
|
|
|
e4740d |
int f_sxz = l.sx*l.sz;
|
|
|
e4740d |
int f_sz2 = l.sz*2;
|
|
|
e4740d |
int f_sxz2 = l.sx*f_sz2;
|
|
|
e4740d |
|
|
|
e4740d |
int m_cnt = msx*msy*msz;
|
|
|
e4740d |
int mi0 = m_cnt*tid/threads;
|
|
|
e4740d |
int mi1 = m_cnt*(tid+1)/threads;
|
|
|
e4740d |
|
|
|
e4740d |
for(int i = mi0; i < mi1; ++i) {
|
|
|
e4740d |
int my = i/msxz;
|
|
|
e4740d |
int mx = i%msxz/msz;
|
|
|
e4740d |
int mz = i%msz;
|
|
|
e4740d |
|
|
|
e4740d |
AccumReal a = 0;
|
|
|
e4740d |
int wi = i*ksyxz;
|
|
|
e4740d |
int fvi = my*f_sxz2 + mx*f_sz2 + mz;
|
|
|
e4740d |
for(int ky = 0; ky < KSY; ++ky, fvi += f_sxz, wi += ksxz) {
|
|
|
e4740d |
Weight *iw = &weights[wi];
|
|
|
e4740d |
NeuronReal *ifv = &f_values[fvi];
|
|
|
e4740d |
for(int i = 0; i < ksxz; ++i)
|
|
|
e4740d |
a += ifv[i]*iw[i].w;
|
|
|
e4740d |
}
|
|
|
e4740d |
|
|
|
e4740d |
m_values[i] = a > 0 ? a : 0;
|
|
|
e4740d |
}
|
|
|
e4740d |
|
|
|
e4740d |
barrier.wait();
|
|
|
e4740d |
|
|
|
e4740d |
// stage 2: pass from mid to back and verify
|
|
|
e4740d |
|
|
|
e4740d |
AccumReal qa = 0;
|
|
|
e4740d |
for(int by = 2 + tid; by < 10; by += threads)
|
|
|
e4740d |
for(int bx = 2; bx < 10; ++bx)
|
|
|
e4740d |
for(int bz = 0; bz < sz; ++bz) {
|
|
|
e4740d |
AccumReal a = 0;
|
|
|
e4740d |
Neuron &bn = b_neurons[ (by*sx + bx)*sz + bz ];
|
|
|
e4740d |
|
|
|
e4740d |
for(int ky = by%2; ky < KSY; ky += 2)
|
|
|
e4740d |
for(int kx = bx%2; kx < KSX; kx += 2) {
|
|
|
e4740d |
int mx = (bx - kx)/2;
|
|
|
e4740d |
int my = (by - ky)/2;
|
|
|
e4740d |
assert(mx >= 0 && mx < msx && (bx - kx)%2 == 0);
|
|
|
e4740d |
assert(my >= 0 && my < msy && (by - ky)%2 == 0);
|
|
|
e4740d |
for(int mz = 0; mz < msz; ++mz) {
|
|
|
e4740d |
Neuron &mn = m_neurons[ (my*msx + mx)*msz + mz ];
|
|
|
e4740d |
Weight &w = weights[ ((mz*ksy + ky)*ksx + kx)*sz + bz ];
|
|
|
e4740d |
a += mn.v * w.w;
|
|
|
e4740d |
}
|
|
|
e4740d |
}
|
|
|
e4740d |
|
|
|
e4740d |
if (a > 0) bn.v = a, bn.d = 1; else bn.v = bn.d = 0;
|
|
|
e4740d |
|
|
|
e4740d |
NeuronReal fn = f_values[ (by*l.sx + bx)*l.sz + bz ];
|
|
|
e4740d |
NeuronReal d = fn - bn.v;
|
|
|
e4740d |
bn.d *= d*trainRatio;
|
|
|
e4740d |
qa += d*d;
|
|
|
e4740d |
}
|
|
|
e4740d |
Quality q(qa/(64*sz));
|
|
|
e4740d |
|
|
|
e4740d |
if (trainRatio <= 0) return q;
|
|
|
e4740d |
|
|
|
e4740d |
barrier.wait();
|
|
|
e4740d |
|
|
|
e4740d |
// stage 3: backpass deltas
|
|
|
e4740d |
|
|
|
e4740d |
for(int mz = tid; mz < msz; mz += threads)
|
|
|
e4740d |
for(int my = 1; my < 4; ++my)
|
|
|
e4740d |
for(int mx = 1; mx < 4; ++mx) {
|
|
|
e4740d |
AccumReal a = 0;
|
|
|
e4740d |
Neuron &mn = m_neurons[ (my*msx + mx)*msz + mz ];
|
|
|
e4740d |
|
|
|
e4740d |
for(int ky = 0; ky < ksy; ++ky)
|
|
|
e4740d |
for(int kx = 0; kx < ksx; ++kx)
|
|
|
e4740d |
for(int kz = 0; kz < sz; ++kz) {
|
|
|
e4740d |
int bx = mx*2 + kx;
|
|
|
e4740d |
int by = my*2 + ky;
|
|
|
e4740d |
Neuron &bn = b_neurons[ (by*sx + bx)*sz + kz ];
|
|
|
e4740d |
Weight &w = weights[ ((mz*ksy + ky)*ksx + kx)*sz + kz ];
|
|
|
e4740d |
a += bn.d * w.w;
|
|
|
e4740d |
}
|
|
|
e4740d |
mn.d *= a;
|
|
|
e4740d |
}
|
|
|
e4740d |
|
|
|
e4740d |
barrier.wait();
|
|
|
e4740d |
|
|
|
e4740d |
// stage 4: update weights
|
|
|
e4740d |
|
|
|
e4740d |
for(int mz = tid; mz < msz; mz += threads)
|
|
|
e4740d |
for(int by = 4; by < 8; ++by)
|
|
|
e4740d |
for(int bx = 4; bx < 8; ++bx)
|
|
|
e4740d |
for(int bz = 0; bz < sz; ++bz) {
|
|
|
e4740d |
Neuron &bn = b_neurons[ (by*sx + bx)*sz + bz ];
|
|
|
e4740d |
NeuronReal fv = f_values[ (by*l.sx + bx)*l.sz + bz ];
|
|
|
e4740d |
|
|
|
e4740d |
for(int ky = by%2; ky < ksy; ky += 2)
|
|
|
e4740d |
for(int kx = bx%2; kx < ksx; kx += 2) {
|
|
|
e4740d |
int mx = (bx - kx)/2;
|
|
|
e4740d |
int my = (by - ky)/2;
|
|
|
e4740d |
assert(mx >= 1 && mx < 4 && (bx - kx)%2 == 0);
|
|
|
e4740d |
assert(my >= 1 && my < 4 && (by - ky)%2 == 0);
|
|
|
e4740d |
Neuron &mn = m_neurons[ (my*msx + mx)*msz + mz ];
|
|
|
e4740d |
Weight &w = weights[ ((mz*ksy + ky)*ksx + kx)*sz + bz ];
|
|
|
e4740d |
w.w += bn.d*mn.v + mn.d*fv;
|
|
|
e4740d |
}
|
|
|
e4740d |
}
|
|
|
e4740d |
|
|
|
e4740d |
return q;
|
|
|
e4740d |
}
|
|
|
e4740d |
|
|
|
e4740d |
|
|
|
e4740d |
|
|
|
e4740d |
Quality testPass(int x, int y, int z, NeuronReal trainRatio) override {
|
|
|
e4740d |
check(x, y, z);
|
|
|
e4740d |
|
|
|
e4740d |
Layout l = layout;
|
|
|
e4740d |
|
|
|
e4740d |
// stage 1: pass
|
|
|
e4740d |
|
|
|
e4740d |
clear();
|
|
|
e4740d |
|
|
|
e4740d |
for(int my = 0; my < msy; ++my)
|
|
|
e4740d |
for(int mx = 0; mx < msx; ++mx)
|
|
|
e4740d |
for(int mz = 0; mz < msz; ++mz) {
|
|
|
e4740d |
AccumReal a = 0;
|
|
|
e4740d |
for(int ky = 0; ky < KSY; ++ky)
|
|
|
e4740d |
for(int kx = 0; kx < KSX; ++kx)
|
|
|
e4740d |
for(int kz = 0; kz < sz; ++kz) {
|
|
|
e4740d |
int fx = x + mx*2 + kx;
|
|
|
e4740d |
int fy = y + my*2 + ky;
|
|
|
e4740d |
int fz = z + kz;
|
|
|
e4740d |
NeuronReal fv = f_values[ (fy*l.sx + fx)*l.sz + fz ];
|
|
|
e4740d |
Weight &w = weights[ ((mz*KSY + ky)*KSX + kx)*sz + kz ];
|
|
|
e4740d |
a += fv * w.w;
|
|
|
e4740d |
}
|
|
|
e4740d |
|
|
|
e4740d |
NeuronReal &mv = m_values[ (my*msx + mx)*msz + mz ];
|
|
|
e4740d |
if (a < 0) { mv = 0; continue; }
|
|
|
e4740d |
mv = a;
|
|
|
e4740d |
|
|
|
e4740d |
for(int ky = 0; ky < KSY; ++ky)
|
|
|
e4740d |
for(int kx = 0; kx < KSX; ++kx)
|
|
|
e4740d |
for(int kz = 0; kz < sz; ++kz) {
|
|
|
e4740d |
int bx = mx*2 + kx;
|
|
|
e4740d |
int by = my*2 + ky;
|
|
|
e4740d |
int bz = kz;
|
|
|
e4740d |
NeuronReal &bv = b_values[ (by*sx + bx)*sz + bz ];
|
|
|
e4740d |
Weight &w = weights[ ((mz*KSY + ky)*KSX + kx)*sz + kz ];
|
|
|
e4740d |
bv += a * w.w;
|
|
|
e4740d |
}
|
|
|
e4740d |
}
|
|
|
e4740d |
|
|
|
e4740d |
// stage 2: finalize values and verify
|
|
|
e4740d |
|
|
|
e4740d |
AccumReal qa = 0;
|
|
|
e4740d |
for(int by = 0; by < sy; ++by)
|
|
|
e4740d |
for(int bx = 0; bx < sx; ++bx)
|
|
|
e4740d |
for(int bz = 0; bz < sz; ++bz) {
|
|
|
e4740d |
NeuronReal fn = f_values[ ((y + by)*l.sx + x + bx)*l.sz + z + bz ];
|
|
|
e4740d |
NeuronReal &bv = b_values[ (by*sx + bx)*sz + bz ];
|
|
|
e4740d |
if (bv > 0) {
|
|
|
e4740d |
NeuronReal d = fn - bv;
|
|
|
e4740d |
bv = d*trainRatio;
|
|
|
e4740d |
qa += d*d;
|
|
|
e4740d |
} else {
|
|
|
e4740d |
bv = 0;
|
|
|
e4740d |
qa += fn*fn;
|
|
|
e4740d |
}
|
|
|
e4740d |
}
|
|
|
e4740d |
Quality q(qa/(KSX*KSY*sz));
|
|
|
e4740d |
|
|
|
e4740d |
if (trainRatio <= 0) return q;
|
|
|
e4740d |
|
|
|
e4740d |
// stage 3: backpass deltas and update weights
|
|
|
e4740d |
|
|
|
e4740d |
for(int my = 0; my < msy; ++my)
|
|
|
e4740d |
for(int mx = 0; mx < msx; ++mx)
|
|
|
e4740d |
for(int mz = 0; mz < msz; ++mz) {
|
|
|
e4740d |
NeuronReal mv = m_values[ (my*msx + mx)*msz + mz ];
|
|
|
e4740d |
if (!mv) continue;
|
|
|
e4740d |
|
|
|
e4740d |
AccumReal a = 0;
|
|
|
e4740d |
for(int ky = 0; ky < KSY; ++ky)
|
|
|
e4740d |
for(int kx = 0; kx < KSX; ++kx)
|
|
|
e4740d |
for(int kz = 0; kz < sz; ++kz) {
|
|
|
e4740d |
int bx = mx*2 + kx;
|
|
|
e4740d |
int by = my*2 + ky;
|
|
|
e4740d |
int bz = kz;
|
|
|
e4740d |
NeuronReal bv = b_values[ (by*sx + bx)*sz + bz ];
|
|
|
e4740d |
Weight &w = weights[ ((mz*KSY + ky)*KSX + kx)*sz + kz ];
|
|
|
e4740d |
a += bv * w.w;
|
|
|
e4740d |
}
|
|
|
e4740d |
|
|
|
e4740d |
for(int ky = 0; ky < KSY; ++ky)
|
|
|
e4740d |
for(int kx = 0; kx < KSX; ++kx)
|
|
|
e4740d |
for(int kz = 0; kz < sz; ++kz) {
|
|
|
e4740d |
int bx = mx*2 + kx;
|
|
|
e4740d |
int by = my*2 + ky;
|
|
|
e4740d |
int bz = kz;
|
|
|
e4740d |
NeuronReal fv = f_values[ ((y + by)*l.sx + x + bx)*l.sz + z + bz ];
|
|
|
e4740d |
NeuronReal bv = b_values[ (by*sx + bx)*sz + bz ];
|
|
|
e4740d |
Weight &w = weights[ ((mz*KSY + ky)*KSX + kx)*sz + kz ];
|
|
|
e4740d |
w.w += bv*mv + fv*a;
|
|
|
e4740d |
}
|
|
|
e4740d |
}
|
|
|
e4740d |
|
|
|
e4740d |
return q;
|
|
|
e4740d |
}
|
|
|
e4740d |
|
|
|
e4740d |
|
|
|
e4740d |
bool saveDemo() override
|
|
|
e4740d |
{ return !filename || saveConvDemoImage(filename, msz, KSX, KSY, sz, weights); }
|
|
|
e4740d |
};
|
|
|
e4740d |
|
|
|
e4740d |
|
|
|
e4740d |
|
|
|
e4740d |
|
|
|
e4740d |
#endif
|
|
|
e4740d |
|
|
|
e4740d |
|