void Net::Classify(const mxArray *mx_data, mxArray *&mx_pred) {
//mexPrintMsg("Start classification...");
ReadData(mx_data);
size_t test_num = data_.size1();
labels_.resize(test_num, layers_.back()->length_);
labels_.reorder(true, false);
size_t numbatches = DIVUP(test_num, params_.batchsize_);
size_t offset = 0;
Mat data_batch, pred_batch;
for (size_t batch = 0; batch < numbatches; ++batch) {
size_t batchsize = MIN(test_num - offset, params_.batchsize_);
data_batch.resize(batchsize, data_.size2());
SubSet(data_, data_batch, offset, true);
InitActiv(data_batch);
Forward(pred_batch, 0);
SubSet(labels_, pred_batch, offset, false);
offset += batchsize;
if (params_.verbose_ == 2) {
mexPrintInt("Batch", (int) batch + 1);
}
}
labels_.reorder(kMatlabOrder, true);
mx_pred = mexSetMatrix(labels_);
//mexPrintMsg("Classification finished");
}
void SubSet(T list[], int k, int m, int flags[]) {
int j;
if (k <= m) {
SubSet(list, k + 1, m, flags);
flags[k] = 1 - flags[k]; // Two states for a element in a subset, change it here
SubSet(list, k + 1, m, flags);
} else {
std::cout << "{";
for (j = 0; j <= m; ++j) {
if (flags[j]) {
std::cout << list[j] << ", ";
}
}
std::cout << "}" << std::endl;
}
}
void Net::Train(const mxArray *mx_data, const mxArray *mx_labels) {
//mexPrintMsg("Start training...");
ReadData(mx_data);
ReadLabels(mx_labels);
InitNorm();
size_t train_num = data_.size1();
size_t numbatches = DIVUP(train_num, params_.batchsize_);
trainerrors_.resize(params_.epochs_, 2);
trainerrors_.assign(0);
for (size_t epoch = 0; epoch < params_.epochs_; ++epoch) {
if (params_.shuffle_) {
Shuffle(data_, labels_);
}
StartTimer();
size_t offset = 0;
Mat data_batch, labels_batch, pred_batch;
for (size_t batch = 0; batch < numbatches; ++batch) {
size_t batchsize = MIN(train_num - offset, params_.batchsize_);
UpdateWeights(epoch, false);
data_batch.resize(batchsize, data_.size2());
labels_batch.resize(batchsize, labels_.size2());
SubSet(data_, data_batch, offset, true);
SubSet(labels_, labels_batch, offset, true);
ftype error1;
InitActiv(data_batch);
Forward(pred_batch, 1);
InitDeriv(labels_batch, error1);
trainerrors_(epoch, 0) += error1;
Backward();
UpdateWeights(epoch, true);
offset += batchsize;
if (params_.verbose_ == 2) {
mexPrintInt("Epoch", (int) epoch + 1);
mexPrintInt("Batch", (int) batch + 1);
}
} // batch
MeasureTime("totaltime");
if (params_.verbose_ == 1) {
mexPrintInt("Epoch", (int) epoch + 1);
}
} // epoch
trainerrors_ /= (ftype) numbatches;
//mexPrintMsg("Training finished");
}
vector<vector<int> > subsets(vector<int> &S) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
Init();
sort(S.begin(),S.end());
SubSet(S,0,S.size());
return ret;
}
void SubSet(vector<int> &S ,int s, int end)
{
if(s == end)
{
steps[current] = step;
ret.push_back(steps[current]);
current++;
return ;
}
vector<int>::iterator p = upper_bound(S.begin()+s, S.end(),S[s]);
int times = p - S.begin() - s ;
for( int i = 0 ; i < times ;i++)
{
step.push_back(S[s]);
SubSet(S, p-S.begin(), end);
}
while(times-- >= 1)
{
step.pop_back();
}
SubSet(S,p-S.begin(),end);
}
int PSubSet (IMAGE a, IMAGE b)
{
if (ImCompare(a, b)) return 0;
return SubSet (a, b);
}
