int main() {
std::string baseName="weights/imagenet2012triangular";
SpatiallySparseDataset trainSet=ImageNet2012TrainSet();
SpatiallySparseDataset validationSet=ImageNet2012ValidationSet();
SpatiallySparseDataset validationSubset=validationSet.subset(500);
trainSet.summary();
validationSubset.summary();
{
ImagenetTriangular cnn(2,VLEAKYRELU,trainSet.nFeatures,trainSet.nClasses,cudaDevice,5);
if (epoch==0) {
SpatiallySparseDataset trainSubset=trainSet.subset(100*batchSize);
trainSubset.type=RESCALEBATCH;
cnn.processDataset(trainSubset,batchSize);
} else {
cnn.loadWeights(baseName,epoch);
cnn.processDatasetRepeatTest(validationSubset, batchSize,3);
}
for (epoch++;;epoch++) {
std::cout <<"epoch: " << epoch << std::endl;
SpatiallySparseDataset trainSubset=trainSet.subset(32000);
cnn.processDataset(trainSubset, batchSize,0.003,0.999);
cnn.saveWeights(baseName,epoch);
cnn.processDatasetRepeatTest(validationSubset, batchSize,1);
}
}
}
scalar cnoidalFirst::ddxPd
(
const point & x,
const scalar & time,
const vector & unitVector
) const
{
scalar Z(returnZ(x));
scalar arg(argument(x,time));
scalar snn(0.0), cnn(0.0), dnn(0.0);
gsl_sf_elljac_e( arg, m_, &snn, &cnn, &dnn);
scalar ddxPd(0);
ddxPd = rhoWater_ * Foam::mag(g_)
* (
eta_x(snn, cnn, dnn) + 1.0 / 2.0 * Foam::pow(h_, 2.0) * (1 - Foam::pow((Z + h_) / h_, 2.0)) * eta_xxx(snn, cnn, dnn)
);
ddxPd *= factor(time);
// Info << "ddxPd still isn't implemented. Need to think about the gradient on arbitrary directed mesh with arbitrary wave number vector! and arbitrary g-direction!!!" << endl;
return ddxPd;
}
int main(int lenArgs, char *args[]) {
std::string baseName = "weights/SHREC2015";
int fold = 0;
if (lenArgs > 1)
fold = atoi(args[1]);
std::cout << "Fold: " << fold << std::endl;
SpatiallySparseDataset trainSet = SHREC2015TrainSet(40, 6, fold);
trainSet.summary();
trainSet.repeatSamples(10);
SpatiallySparseDataset testSet = SHREC2015TestSet(40, 6, fold);
testSet.summary();
DeepC2 cnn(3, 5, 32, VLEAKYRELU, trainSet.nFeatures, trainSet.nClasses, 0.0f,
cudaDevice);
if (epoch > 0)
cnn.loadWeights(baseName, epoch);
for (epoch++; epoch <= 100 * 2; epoch++) {
std::cout << "epoch:" << epoch << ": " << std::flush;
cnn.processDataset(trainSet, batchSize, 0.003 * exp(-0.05 / 2 * epoch));
if (epoch % 20 == 0) {
cnn.saveWeights(baseName, epoch);
cnn.processDatasetRepeatTest(testSet, batchSize, 3);
}
}
}
void testConvolutionalNeuralNetworkCostFunction()
{
MNISTDataFunction mnistdf;
Config config;
updateMNISTConfig(config);
config.setValue("addBiasTerm", false);
config.setValue("meanStddNormalize", false);
config.setValue("debugMode", true);
mnistdf.configure(&config);
const int imageDim = 28; // height/width of image
const int filterDim = 9; // dimension of convolutional filter
const int numFilters = 2; // number of convolutional filters
const int poolDim = 5; // dimension of pooling area
const int numClasses = 10; // number of classes to predict
ConvolutionalNeuralNetworkCostFunction cnn(imageDim, filterDim, numFilters, poolDim, numClasses);
Vector_t theta = cnn.configure(mnistdf.getTrainingX(), mnistdf.getTrainingY());
std::cout << "theta: " << theta.size() << std::endl;
Vector_t grad;
double cost = cnn.evaluate(theta, mnistdf.getTrainingX(), mnistdf.getTrainingY(), grad);
std::cout << "cost: " << cost << std::endl;
std::cout << "grad: " << grad.size() << std::endl;
double error = cnn.getNumGrad(theta, mnistdf.getTrainingX(), mnistdf.getTrainingY());
std::cout << "error: " << error << std::endl;
}
int main ( int argc, char **argv ) {
// Read mnist labels
int count = 0;
uint8_t* labels_raw = read_mnist_test_labels(count);
int* in_labels = new int[count];
for (int i=0; i<count; i++) {
in_labels[i] = (int)labels_raw[i];
}
// std::cout << "count=" << count << std::endl;
// Read mnist data and cast into 'Images' objects
int in_rows, in_cols, in_number;
image_raw_type* in_raw = \
read_mnist_test_images ( in_number, in_rows, in_cols );
image_type* in_data = new image_type[in_number*in_rows*in_cols];
for ( int i=0; i<in_number*in_rows*in_cols; i++ ) {
in_data[i] = (image_type) in_raw[i];
}
std::vector<Images> in_imgs;
for ( int i=0; i<in_number; i++ ) {
Images im(1, in_rows, in_cols, in_data + i * in_rows * in_cols);
in_imgs.push_back(im);
}
int correct = 0;
for ( int i=0; i<300; i++ ) {
//in_imgs[i].print();
std::cout << "label: " << in_labels[i] << ", predicted: " << cnn(in_imgs[i]) << " -- ";
if ( in_labels[i] == cnn(in_imgs[i]) ) {
correct++;
std::cout << "Hit! " << correct << "/" << i+1 << std::endl;
}
else {
std::cout << "Miss! " << std::endl;
}
}
float rate = (float) correct / 300;
std::cout << "Accuracy = " << rate << std::endl;
return 0;
}
scalar cnoidalFirst::eta
(
const point & x,
const scalar & time
) const
{
scalar arg(argument(x,time));
scalar snn(0.0), cnn(0.0), dnn(0.0);
gsl_sf_elljac_e( arg, m_, &snn, &cnn, &dnn);
scalar eta = ( etaMin_ + H_ * Foam::pow(cnn,2.0) ) * factor(time) + seaLevel_;
return eta;
}
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);
}
int _tmain(int argc, _TCHAR* argv[])
{
IplImage* input_img = cvLoadImage("Carol_Niedermayer_0001.jpg",0);
Mat input_mat=cvarrToMat(input_img,true);
if (input_mat.cols == 0)
{
cout<<"can not load image"<<endl;
return 1;
}
Rect face_box = face_detect(input_mat);
cout<<"here"<<endl;
Mat aligned_face(128,128,CV_8UC1);
int flag = face_align(input_mat,&aligned_face,face_box);
if(flag == 0)
{
cout<<"can not align the face image"<<endl;
return 1;
}
imwrite("aligned_face.bmp",aligned_face);
char* modelPath = "casia_144_ve_id_model_iter_1210000.bin";
const int layer_index =14;
const int len = 320*8*8;
float* feature = (float*)malloc(320*sizeof(float));
clock_t start, end;
double time;
start = clock();
cnnFace cnn(modelPath,layer_index,len);
if (cnn.cnnFaceInit() != 0) {
return 1;
}
cnn.getFeature(aligned_face, feature);
//cnn.getFeature(imgFace2, feat2);
//float score = cnn.getScore(feat1, feat2);
end = clock();
time = (double)(end - start) / CLOCKS_PER_SEC;
cout << "The score is " << "\nTime is " << time << endl;
cnn.~cnnFace();
free(feature);
return 0;
}
int main() {
std::string baseName="weights/cifar100";
SpatiallySparseDataset trainSet=Cifar100TrainSet();
SpatiallySparseDataset testSet=Cifar100TestSet();
trainSet.summary();
testSet.summary();
DeepCNet cnn(2,5,32,VLEAKYRELU,trainSet.nFeatures,trainSet.nClasses,0.0f,cudaDevice);
if (epoch>0)
cnn.loadWeights(baseName,epoch);
for (epoch++;;epoch++) {
std::cout <<"epoch: " << epoch << std::flush;
cnn.processDataset(trainSet, batchSize,0.003*exp(-0.02 * epoch)); //reduce annealing rate for better results ...
if (epoch%50==0) {
cnn.saveWeights(baseName,epoch);
cnn.processDataset(testSet, batchSize);
}
}
}
vector cnoidalFirst::U
(
const point & x,
const scalar & time
) const
{
scalar Z(returnZ(x));
scalar arg(argument(x, time));
scalar snn(0.0), cnn(0.0), dnn(0.0);
gsl_sf_elljac_e( arg, m_, &snn, &cnn, &dnn);
scalar etaVal = eta(x,time);
scalar Uhorz = celerity_
* (
etaVal / h_
- Foam::pow(etaVal / h_, 2.0)
+ 1.0 / 2.0 *
(
1.0 / 3.0
- Foam::pow((Z + h_) / h_, 2.0)
)
* h_ * eta_xx(snn, cnn, dnn)
);
Uhorz *= factor(time);
scalar Uvert = - celerity_ * (Z + h_)
* (
eta_x(snn, cnn, dnn) / h_ * (1 - 2.0 * etaVal / h_)
+ 1.0 / 6.0 * h_ * eta_xxx(snn, cnn, dnn)
* (1 - Foam::pow((Z + h_) / h_, 2.0))
);
Uvert *= factor(time);
return Uhorz * propagationDirection_ - Uvert * direction_; // Note "-" because of "g" working in the opposite direction
}
int main() {
std::string baseName="weights/casia";
SpatiallySparseDataset trainSet=CasiaOLHWDB11TrainSet(40,Simple);
SpatiallySparseDataset testSet=CasiaOLHWDB11TestSet(40,Simple);
trainSet.summary();
testSet.summary();
CNN cnn(2,4,32,VLEAKYRELU,trainSet.nFeatures,trainSet.nClasses,0.0f,cudaDevice);
cnn.calculateInputRegularizingConstants(trainSet);
if (epoch>0)
cnn.loadWeights(baseName,epoch);
for (epoch++;;epoch++) {
std::cout <<"epoch:" << epoch << ": " << std::flush;
cnn.processDataset(trainSet, batchSize,0.003*exp(-epoch*0.1));
cnn.saveWeights(baseName,epoch);
if (epoch%2==0) {
cnn.processDataset(testSet, batchSize);
}
}
}
int main() {
std::string baseName="weights/casia3d";
SpatiallySparseDataset trainSet=CasiaOLHWDB11TrainSet(40,SpaceTime3d);
SpatiallySparseDataset testSet=CasiaOLHWDB11TestSet(40,SpaceTime3d);
trainSet.summary();
testSet.summary();
CNN cnn(3,4,64,RELU,trainSet.nFeatures,trainSet.nClasses,0.0f,cudaDevice);
//DeepC2 cnn(3,4,64,RELU,trainSet.nFeatures,trainSet.nClasses,0.0f,cudaDevice);
cnn.calculateInputRegularizingConstants(trainSet);
if (epoch>0)
cnn.loadWeights(baseName,epoch);
for (epoch++;;epoch++) {
std::cout <<"epoch:" << epoch << ": " << std::flush;
cnn.processDataset(trainSet, batchSize,0.003*exp(-0.03 * epoch),0.995);
cnn.saveWeights(baseName,epoch);
if (epoch%10==0) {
cnn.processDataset(testSet, batchSize);
}
}
}
int main() {
std::string baseName = "weights/cifar10big";
SpatiallySparseDataset trainSet = Cifar10TrainSet();
SpatiallySparseDataset testSet = Cifar10TestSet();
trainSet.summary();
testSet.summary();
POFMPSparseConvNet cnn(
2, 12, 160 /* 160n units in the n-th hidden layer*/, powf(2, 0.3333),
VLEAKYRELU, trainSet.nFeatures, trainSet.nClasses,
0.5f /*dropout multiplier in the range [0,0.5] */, cudaDevice);
if (epoch > 0)
cnn.loadWeights(baseName, epoch);
for (epoch++; epoch <= 810; epoch++) {
std::cout << "epoch: " << epoch << " " << std::flush;
cnn.processDataset(trainSet, batchSize, 0.003 * exp(-0.005 * epoch), 0.99);
if (epoch % 10 == 0)
cnn.saveWeights(baseName, epoch);
if (epoch % 100 == 0)
cnn.processDatasetRepeatTest(testSet, batchSize / 2, 3);
}
cnn.processDatasetRepeatTest(testSet, batchSize / 2, 100);
}
// cnn face detection test
void cnnFaceDetectionTest()
{
// configuration
string imgPath = "Z:\\User\\wuxiang\\data\\face_detection\\FDDB\\originalPics";
string listPath = "Z:\\User\\wuxiang\\data\\face_detection\\FDDB\\FDDB_list.txt";
string frPath = "Z:\\Temp\\CNN_Face_Detection\\fr\\man";
string bingModelPath = "D:\\svn\\Algorithm\\wuxiang\\Code\\C\\BING\\model\\ObjNessB2W8MAXBGR.wS1";
string cnnModelPath = "D:\\svn\\Algorithm\\wuxiang\\Code\\C\\BING\\model\\36_detection.bin";
string savePath = "D:\\BING\\36_net\\fr";
const int W = 8, NSS = 2, numPerSz = 150;
const int netSize = 36, netProbLayer = 7;
const float thr = 0.4;
vector<Vec4i> boxTestStageI;
ValStructVec<float, Vec4i> boxTestStageII;
ValStructVec<float, Vec4i> box;
char fr[_MAX_PATH];
// load image
DataSet dataSet(imgPath, listPath, frPath);
dataSet.loadAnnotations();
// predict
ObjectnessTest objectNessTest(dataSet, bingModelPath, W, NSS);
objectNessTest.loadTrainedModel(bingModelPath);
CnnFace cnn(cnnModelPath, netSize, netProbLayer);
cnn.loadTrainedModel();
#pragma openmp parallel for
for(int i = 0; i < dataSet.testNum; i++)
{
// face detection Stage I: get face region proposal
boxTestStageI.clear();
printf("Process %d images..\n", i);
CmTimer tm("Predict");
tm.Start();
Mat img = imread(dataSet.imgPath + "\\" + dataSet.imgPathName[i]);
boxTestStageI.reserve(10000);
objectNessTest.getFaceProposaksForPerImgFast(img, boxTestStageI, numPerSz);
// cnn
cnn.getFaceDetectionPerImg(img, boxTestStageI, boxTestStageII, thr);
// nms
cnn.nonMaxSup(boxTestStageII, box, 0.2);
tm.Stop();
printf("Predicting an image is %gs\n", tm.TimeInSeconds());
// save
sprintf(fr, "%s/%s", savePath.c_str(), dataSet.imgPathFr[i].c_str());
create_directory_from_filename(fr);
FILE *fp = fopen(fr, "wt");
fprintf(fp, "%d\n", box.size());
for (int j = 0; j < box.size(); j++)
{
Vec4i &out = box[j];
fprintf(fp, "%d\t%d\t%d\t%d\t%f\n", out[0], out[1], out[2], out[3], box(j));
}
fclose(fp);
img.~Mat();
}
}
