int main() {
setup();
int *A, *Ad;
for(int i=0; i<NUM_SIZE; i++) {
A = (int*)malloc(size[i]);
valSet(A, 1, size[i]);
hipMalloc(&Ad, size[i]);
std::cout<<"Malloc success at size: "<<size[i]<<std::endl;
for(int j=0; j<NUM_ITER; j++) {
std::cout<<"\r"<<"Iter: "<<j;
hipMemcpy(Ad, A, size[i], hipMemcpyHostToDevice);
}
std::cout<<std::endl;
hipDeviceSynchronize();
}
}
int main() {
std::string baseName = "weights/plankton";
OpenCVLabeledDataSet trainSet("Data/kagglePlankton/classList",
"Data/kagglePlankton/train", "*.jpg",
TRAINBATCH, 255, true, 0);
trainSet.summary();
std::cout << "\n ** Use the private test set as as extra source of "
"training data ! ** \n\n";
OpenCVLabeledDataSet cheekyExtraTrainSet("Data/kagglePlankton/classList",
"Data/kagglePlankton/testPrivate",
"*.jpg", TRAINBATCH, 255, true, 0);
cheekyExtraTrainSet.summary();
std::cout << "\n ** Use the public test set for validation ** \n\n";
OpenCVLabeledDataSet valSet("Data/kagglePlankton/classList",
"Data/kagglePlankton/testPublic", "*.jpg",
TESTBATCH, 255, true, 0);
valSet.summary();
FractionalSparseConvNet cnn(trainSet.nFeatures, trainSet.nClasses,
cudaDevice);
if (epoch > 0) {
cnn.loadWeights(baseName, epoch);
cnn.processDatasetRepeatTest(valSet, batchSize / 2, 12);
}
for (epoch++;; epoch++) {
std::cout << "epoch: " << epoch << std::endl;
float lr = 0.003 * exp(-0.1 * epoch);
for (int i = 0; i < 10; ++i) {
cnn.processDataset(trainSet, batchSize, lr, 0.999);
cnn.processDataset(cheekyExtraTrainSet, batchSize, lr, 0.999);
}
cnn.saveWeights(baseName, epoch);
cnn.processDatasetRepeatTest(valSet, batchSize, 6);
}
// For unlabelled data
// OpenCVUnlabeledDataSet
// testSet("Data/kagglePlankton/classList"," ... ","*.jpg",255,true,0);
// testSet.summary();
// cnn.processDatasetRepeatTest(testSet, batchSize/2,
// 24,"plankton.predictions",testSet.header);
}
void generate_mt(int stripe) {
boost::mt19937 rng_thread(abs(stripe + 1) * std::time(NULL));
if (Sample::generateSplit(data, &rng_thread, fp, splits[stripe], split_mode, depth)) {
std::vector<IntIndex> valSet(data.size());
for (unsigned int l = 0; l < data.size(); ++l) {
valSet[l].first = data[l]->evalTest(splits[stripe]);
valSet[l].second = l;
}
std::sort(valSet.begin(), valSet.end());
findThreshold(data, valSet, splits[stripe], &rng_thread);
splits[stripe].oob = 0;
} else {
splits[stripe].threshold = 0;
splits[stripe].info = boost::numeric::bounds<double>::lowest();
splits[stripe].gain = boost::numeric::bounds<double>::lowest();
splits[stripe].oob = boost::numeric::bounds<double>::highest();
}
}
int main(){
setup();
int *A, *Ad;
for(int i=0;i<NUM_SIZE;i++){
A = (int*)malloc(size[i]);
valSet(A, 1, size[i]);
hipMalloc(&Ad, size[i]);
std::cout<<"Malloc success at size: "<<size[i]<<std::endl;
for(int j=0;j<NUM_ITER;j++){
std::cout<<"Iter: "<<j<<std::endl;
hipMemcpy(Ad, A, size[i], hipMemcpyHostToDevice);
hipLaunchKernel(Add, dim3(1), dim3(size[i]/sizeof(int)), 0, 0, Ad);
hipMemcpy(A, Ad, size[i], hipMemcpyDeviceToHost);
}
hipDeviceSynchronize();
}
}
int main() {
setup();
int *A, *Ad;
for (int i = 0; i < NUM_SIZE; i++) {
std::cout << size[i] << std::endl;
A = (int*)malloc(size[i]);
valSet(A, 1, size[i]);
hipMalloc(&Ad, size[i]);
std::cout << "Malloc success at size: " << size[i] << std::endl;
clock_t start, end;
start = clock();
for (int j = 0; j < NUM_ITER; j++) {
// std::cout<<"At iter: "<<j<<std::endl;
hipMemcpy(Ad, A, size[i], hipMemcpyHostToDevice);
}
hipDeviceSynchronize();
end = clock();
double uS = (double)(end - start) * 1000 / (NUM_ITER * CLOCKS_PER_SEC);
std::cout << uS << std::endl;
}
}
