normaldlg.cpp

来自「OpenSVM was developped under Visual C++ 」· C++ 代码 · 共 406 行

// Normal.cpp : implementation file
//

#include "stdafx.h"
#include "OpenSVM.h"
#include "NormalDlg.h"


#include "MainFrm.h"
#include "OpenSVMDoc.h"
#include "ResultDlg.h"
#include "EnterDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CNormalDlg dialog


CNormalDlg::CNormalDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CNormalDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CNormalDlg)
	m_cacheSize = 128;
	m_eps = 0.001;
	m_nrFold = 5;


	m_csvcC = 1.0;
	m_nusvcNu = 0.5;
	
	m_svrC = 1.0;
	m_esvrE = 0.1;
	m_nusvrNu = 0.5;

	m_polyCoef = 0.0;
	m_polyDegree = 3;
	m_polyGamma = 0.0;

	m_rbfGamma = 0.0;

	m_sigmoidCoef = 0.0;
	m_sigmoidGamma = 0.0;


	//}}AFX_DATA_INIT

	//other val init
	m_kernelType = C_SVC;
	m_funcType   = RBF;
	m_ifDoShirinking =true;
	m_ifDoProbability=false;
	m_ifDoCrossValidation=false;

}


void CNormalDlg::DoDataExchange(CDataExchange* pDX)
{
	//addition
	((CButton *)GetDlgItem(IDC_SHRINKING))->SetCheck(1);
	((CButton *)GetDlgItem(IDC_CSVC     ))->SetCheck(1);
	((CButton *)GetDlgItem(IDC_FUNC_RBF ))->SetCheck(1);
	
	((CEdit	  *)GetDlgItem(IDC_RBF_GAMMA))->EnableWindow(true);
	((CEdit   *)GetDlgItem(IDC_CSVC_C	))->EnableWindow(true);
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CNormalDlg)
	DDX_Text(pDX, IDC_CACHESIZE, m_cacheSize);
	DDV_MinMaxUInt(pDX, m_cacheSize, 16, 512);
	DDX_Text(pDX, IDC_STOP_CRITICAL, m_eps);
	DDV_MinMaxDouble(pDX, m_eps, 1.e-005, 1.);
	DDX_Text(pDX, IDC_CSVC_C, m_csvcC);
	DDX_Text(pDX, IDC_POLY_GAMMA, m_polyGamma);
	DDX_Text(pDX, IDC_ESVR_E, m_esvrE);
	DDX_Text(pDX, IDC_NRFOLD, m_nrFold);
	DDX_Text(pDX, IDC_NUSVC_NU, m_nusvcNu);
	DDV_MinMaxDouble(pDX, m_nusvcNu, 0., 1.);
	DDX_Text(pDX, IDC_NUSVR_NU, m_nusvrNu);
	DDV_MinMaxDouble(pDX, m_nusvrNu, 0., 1.);
	DDX_Text(pDX, IDC_POLY_COEF, m_polyCoef);
	DDX_Text(pDX, IDC_POLY_DEGREE, m_polyDegree);
	DDX_Text(pDX, IDC_RBF_GAMMA, m_rbfGamma);
	DDX_Text(pDX, IDC_SIGMOID_COEF, m_sigmoidCoef);
	DDX_Text(pDX, IDC_SIGMOID_GAMMA, m_sigmoidGamma);
	DDX_Text(pDX, IDC_SVR_C, m_svrC);
	//}}AFX_DATA_MAP

}


BEGIN_MESSAGE_MAP(CNormalDlg, CDialog)
	//{{AFX_MSG_MAP(CNormalDlg)
	ON_BN_CLICKED(ID_TRAIN, OnTrain)
	ON_BN_CLICKED(IDC_CSVC, OnCsvc)
	ON_BN_CLICKED(IDC_NUSVC, OnNusvc)
	ON_BN_CLICKED(IDC_ESVR, OnEsvr)
	ON_BN_CLICKED(IDC_NUSVR, OnNusvr)
	ON_BN_CLICKED(IDC_FUNC_LINEAR, OnFuncLinear)
	ON_BN_CLICKED(IDC_FUNC_POLY, OnFuncPoly)
	ON_BN_CLICKED(IDC_FUNC_RBF, OnFuncRbf)
	ON_BN_CLICKED(IDC_FUNC_SIGMOD, OnFuncSigmoid)
	ON_BN_CLICKED(IDC_CROSSVAL, OnCrossval)
	ON_BN_CLICKED(IDC_SHRINKING, OnShrinking)
	ON_BN_CLICKED(IDC_PROBABILITY, OnProbability)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CNormalDlg message handlers

void CNormalDlg::OnTrain() 
{

	//add Initalized code

	UpdateData(true);
	FILE *fp = fopen("C:\\tempView.tmp","w");
	fflush(fp);
	fclose(fp);
	
	freopen("C:\\tempView.tmp","a",stdout);
	
	CMainFrame  *pFrame=(CMainFrame *)AfxGetMainWnd();   
	COpenSVMDoc *pDoc  =(COpenSVMDoc*)pFrame->GetActiveDocument();
	CString filename=pDoc->GetPathName();


	//add vitual_stolve code 
	GenerateParam();

	
	//add train code
	if(filename.GetLength() == 0)
	{
		MessageBox("You should open a data file before train.", "Error", 
			MB_ICONERROR | MB_OK);
	}
	else
	{
		if (m_ifDoCrossValidation)
			MessageBox("To do cross validation won't generate the model file.", "Note", 
			MB_ICONASTERISK | MB_OK);
		
		if ((!m_sigmoidGamma)||(!m_polyGamma)||(!m_rbfGamma))
			MessageBox("Gamma will set 1/k by default.", "Note",
			MB_ICONASTERISK | MB_OK);
		
		CSVM ownSVM;
		ownSVM.GetParam(virtualparam);
		ownSVM.ReadProblem(filename);
		srand(1);
		if (!m_ifDoCrossValidation)
		{
			ownSVM.DoTrain();
		}
		else 
		{
			if (m_nrFold <2)
			{
				MessageBox("NR_FOLD must >= 2");
			}
			else
			{
				ownSVM.DoCrossValidation(m_nrFold);
			}

		}
		fclose(stdout);

		CResultDlg result;
		result.DoModal();
		
		int ifSave=0;
		if(!m_ifDoCrossValidation)
		{
			ifSave=MessageBox("Would you want to save model?", "Question",
				MB_ICONQUESTION|MB_YESNO);
		
			if (ifSave == IDNO)
			{
				CDialog::OnOK();
			}
			else
			{
				CEnterDlg dlg;
				dlg.DoModal();
				
				if(dlg.m_enter.GetLength() == 0)
				{
					MessageBox("Model name cannot be empty.");
				}
				else
				{
					CString modelname=AppPath;
					modelname+="\\Models\\";
					FILE *base=fopen(modelname+"modelsbase","a");
					if (base == NULL)
					{
						CString modelDir=AppPath;
						modelDir+="\\Models";
						CreateDirectory(modelDir,NULL);
						base = fopen(modelname+"modelsbase","a");
					}
					fprintf(base,"%s\n",dlg.m_enter);
					fclose(base);
					
					modelname+=dlg.m_enter;
					ownSVM.StoreModel(modelname);
					ownSVM.StoreModelInfo(modelname);
				}

				CDialog::OnOK();
			}
		}
		else CDialog::OnOK();
	}
	
}

void CNormalDlg::OnCsvc() //Select C_SVC Kernel
{
	m_kernelType = C_SVC;
	//disable other options which aren't related
	((CEdit*)GetDlgItem(IDC_CSVC_C  ))->EnableWindow(true);
	((CEdit*)GetDlgItem(IDC_NUSVC_NU))->EnableWindow(false);

	((CEdit*)GetDlgItem(IDC_SVR_C   ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_ESVR_E  ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_NUSVR_NU))->EnableWindow(false);

	
}

void CNormalDlg::OnNusvc()//select nu_SVC Kernel
{
	m_kernelType = NU_SVC;
	//disable other options which aren't related
	((CEdit*)GetDlgItem(IDC_CSVC_C  ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_NUSVC_NU))->EnableWindow(true);
	((CEdit*)GetDlgItem(IDC_ESVR_E  ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_NUSVR_NU))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_SVR_C   ))->EnableWindow(false);
}

void CNormalDlg::OnEsvr() //select epsilon-SVR Kernel
{
	m_kernelType = EPSILON_SVR;
	//disable other options which aren't related
	((CEdit*)GetDlgItem(IDC_CSVC_C  ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_NUSVC_NU))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_ESVR_E  ))->EnableWindow(true);
	((CEdit*)GetDlgItem(IDC_NUSVR_NU))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_SVR_C   ))->EnableWindow(true);
}

void CNormalDlg::OnNusvr() //select nu-SVR Kernel
{
	m_kernelType = NU_SVR;
	//disable other options which aren't related
	((CEdit*)GetDlgItem(IDC_CSVC_C  ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_NUSVC_NU))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_ESVR_E  ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_NUSVR_NU))->EnableWindow(true);
	((CEdit*)GetDlgItem(IDC_SVR_C   ))->EnableWindow(true);
}

void CNormalDlg::OnFuncLinear() //select linear function
{
	m_funcType = LINEAR;
	//disable other options which aren't related
	((CEdit*)GetDlgItem(IDC_POLY_COEF   ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_POLY_GAMMA  ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_POLY_DEGREE ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_RBF_GAMMA   ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_SIGMOD_COEF ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_SIGMOD_GAMMA))->EnableWindow(false);
}

void CNormalDlg::OnFuncPoly()  //select poly function
{
	m_funcType = POLY;
	//disable other options which aren't related
	((CEdit*)GetDlgItem(IDC_POLY_COEF   ))->EnableWindow(true);
	((CEdit*)GetDlgItem(IDC_POLY_GAMMA  ))->EnableWindow(true);
	((CEdit*)GetDlgItem(IDC_POLY_DEGREE ))->EnableWindow(true);
	((CEdit*)GetDlgItem(IDC_RBF_GAMMA   ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_SIGMOD_COEF ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_SIGMOD_GAMMA))->EnableWindow(false);
}

void CNormalDlg::OnFuncRbf()  //select RBF function
{
	m_funcType = RBF;
	//disable other options which aren't related
	((CEdit*)GetDlgItem(IDC_POLY_COEF   ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_POLY_GAMMA  ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_POLY_DEGREE ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_RBF_GAMMA   ))->EnableWindow(true);
	((CEdit*)GetDlgItem(IDC_SIGMOD_COEF ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_SIGMOD_GAMMA))->EnableWindow(false);
}

void CNormalDlg::OnFuncSigmoid() //select SIGMOID function
{
	m_funcType = SIGMOID;
	//disable other options which aren't related
	((CEdit*)GetDlgItem(IDC_POLY_COEF   ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_POLY_GAMMA  ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_POLY_DEGREE ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_RBF_GAMMA   ))->EnableWindow(false);
	((CEdit*)GetDlgItem(IDC_SIGMOD_COEF ))->EnableWindow(true);
	((CEdit*)GetDlgItem(IDC_SIGMOD_GAMMA))->EnableWindow(true);
}

void CNormalDlg::OnCrossval() 
{
	// TODO: Add your control notification handler code here
	m_ifDoCrossValidation=!m_ifDoCrossValidation;

	if (m_ifDoCrossValidation)
		((CEdit*)GetDlgItem(IDC_NRFOLD))->EnableWindow(true);
	else
		((CEdit*)GetDlgItem(IDC_NRFOLD))->EnableWindow(false);
}

void CNormalDlg::OnShrinking() 
{
	// TODO: Add your control notification handler code here
	m_ifDoShirinking = !m_ifDoShirinking;
}

void CNormalDlg::OnProbability() 
{
	// TODO: Add your control notification handler code here
	m_ifDoProbability = !m_ifDoProbability;
}

void CNormalDlg::GenerateParam()
{
	//Parameters for SVM types
	virtualparam.svm_type = m_kernelType;

	if (m_kernelType == C_SVC)
	{
		virtualparam.C   = m_csvcC;
	}

	if (m_kernelType == NU_SVC)
	{
		virtualparam.nu = m_nusvcNu;
	}

	
	if (m_kernelType == NU_SVR)
	{
		virtualparam.nu = m_nusvrNu;
		virtualparam.C  = m_svrC;
	}

	if (m_kernelType == EPSILON_SVR)
	{
		virtualparam.p  = m_esvrE;	
		virtualparam.C  = m_svrC;
	}

	//Parameters for Kernel Functions
	virtualparam.kernel_type = m_funcType;
	if (m_funcType == POLY)
	{
		virtualparam.coef0  = m_polyCoef;
		virtualparam.degree = m_polyDegree;
		virtualparam.gamma  = m_polyGamma;
	}
	else 
		virtualparam.degree = m_polyDegree;

	if (m_funcType == RBF)
	{
		virtualparam.gamma = m_rbfGamma;
	}


	if (m_funcType == SIGMOID)
	{
		virtualparam.coef0 = m_sigmoidCoef;
		virtualparam.gamma = m_sigmoidGamma;	
	}

	//Common Setting
	virtualparam.eps		= m_eps;
	virtualparam.cache_size	= m_cacheSize;
	virtualparam.shrinking	= (m_ifDoShirinking) ?1:0;
	virtualparam.probability= (m_ifDoProbability)?1:0;


	//default setting
	virtualparam.nr_weight		= 0;
	virtualparam.weight_label	= NULL;
	virtualparam.weight			= NULL;
}