onlinesvr.cpp

在线支持向量机C＋＋程序,程序中包含了应用的例子

	}

	double OnlineSVR::Predict (double* X, int ElementsSize)
	{
		Vector<double>* V = new Vector<double>(X, ElementsSize);
		double PredictedValue = this->Predict(V);
		delete V;
		return PredictedValue;
	}

	double* OnlineSVR::Predict (double** X, int ElementsNumber, int ElementsSize)
	{
		Matrix<double>* M = new Matrix<double>(X,ElementsNumber,ElementsSize);
		Vector<double>* V = this->Predict(M);
		delete M;
		return V->Values;
	}

	double OnlineSVR::Margin (double* X, double Y, int ElementsSize)
	{
		return this->Predict(X,ElementsSize)-Y;
	}

	double* OnlineSVR::Margin (double** X, double* Y, int ElementsNumber, int ElementsSize)
	{
		Vector<double>* V1 = new Vector<double>(this->Predict(X,ElementsNumber,ElementsSize),ElementsNumber);
		Vector<double>* V2 = new Vector<double>(Y,ElementsNumber);
		V1->SubtractVector(V2);
		delete V2;
		return V1->Values;
	}

		
	// Other Kernel Operations
	Matrix<double>* OnlineSVR::Q (Vector<int>* V1, Vector<int>* V2)
	{
		if (!SaveKernelMatrix) {
			Matrix<double>* M = new Matrix<double>();
			for (int i=0; i<V1->GetLength(); i++) {
				Vector<double>* V = new Vector<double>(V1->GetLength());
				for (int j=0; j<V2->GetLength(); j++) {
					V->Add(this->Kernel(this->X->GetRowRef(V1->GetValue(i)),this->X->GetRowRef(V2->GetValue(j))));
				}
				M->AddRowRef(V);
			}
			return M;
		}
		else {
			Matrix<double>* M = new Matrix<double>();
			for (int i=0; i<V1->GetLength(); i++) {
				Vector<double>* V = new Vector<double>(V1->GetLength());
				for (int j=0; j<V2->GetLength(); j++) {
					V->Add(this->KernelMatrix->GetValue(V1->GetValue(i), V2->GetValue(j)));
				}
				M->AddRowRef(V);
			}
			return M;
		}
	}

	Matrix<double>* OnlineSVR::Q (Vector<int>* V)
	{
		if (!SaveKernelMatrix) {
			Matrix<double>* M = new Matrix<double>();
			for (int i=0; i<this->GetSamplesTrainedNumber(); i++) {
				Vector<double>* V2 = new Vector<double>(V->GetLength());
				for (int j=0; j<V->GetLength(); j++) {
					V2->Add(this->Kernel(this->X->GetRowRef(i),this->X->GetRowRef(V->GetValue(j))));
				}
				M->AddRowRef(V2);
			}
			return M;
		}
		else {
			Matrix<double>* M = new Matrix<double>();
			for (int i=0; i<this->GetSamplesTrainedNumber(); i++) {
				Vector<double>* V2 = new Vector<double>(V->GetLength());
				for (int j=0; j<V->GetLength(); j++) {
					V2->Add(this->KernelMatrix->GetValue(i,V->GetValue(j)));
				}
				M->AddRowRef(V2);
			}
			return M;
		}
	}

	Vector<double>* OnlineSVR::Q (Vector<int>* V, int Index)
	{
		if (!SaveKernelMatrix) {
			Vector<double>* V2 = new Vector<double>(V->GetLength());
			for (int i=0; i<V->GetLength(); i++) {
				V2->Add(this->Kernel(this->X->GetRowRef(V->GetValue(i)),this->X->GetRowRef(Index)));
			}
			return V2;
		}
		else {
			Vector<double>* V2 = new Vector<double>(V->GetLength());
			for (int i=0; i<V->GetLength(); i++) {
				V2->Add(this->KernelMatrix->GetValue(V->GetValue(i),Index));
			}
			return V2;
		}
	}

	Vector<double>* OnlineSVR::Q (int Index)
	{
		if (!SaveKernelMatrix) {
			Vector<double>* V = new Vector<double>(this->GetSamplesTrainedNumber());
			for (int i=0; i<this->GetSamplesTrainedNumber(); i++) {
				V->Add(this->Kernel(this->X->GetRowRef(i),this->X->GetRowRef(Index)));
			}
			return V;
		}
		else {
			Vector<double>* V = new Vector<double>(this->GetSamplesTrainedNumber());
			for (int i=0; i<this->GetSamplesTrainedNumber(); i++) {
				V->Add(this->KernelMatrix->GetValue(i,Index));
			}
			return V;
		}
	}

	double OnlineSVR::Q (int Index1, int Index2)
	{
		if (!SaveKernelMatrix) {
			return this->Kernel(this->X->GetRowRef(Index1),this->X->GetRowRef(Index2));
		}
		else {
			return this->KernelMatrix->GetValue(Index1,Index2);
		}
	}

		
	// Matrix R Operations
	void OnlineSVR::AddSampleToR (int SampleIndex, int SampleOldSet, Vector<double>* Beta, Vector<double>* Gamma)
	{
		if (this->R->GetLengthRows()==0) {
			Vector<double>* V1 = new Vector<double>(2);
			V1->Add(-this->Q(SampleIndex,SampleIndex));
			V1->Add(1);
			this->R->AddRowRef(V1);
			Vector<double>* V2 = new Vector<double>(2);
			V2->Add(1);
			V2->Add(0);
			this->R->AddRowRef(V2);
		}
		else {
			Vector<double>* NewBeta; 
			Vector<double>* NewGamma;
			if (SampleOldSet==this->ERROR_SET || SampleOldSet==this->REMAINING_SET) {
				// TODO: We only need of beta and Gamma(SampleIndex)
				int LastSupport = this->SupportSetIndexes->GetValue(this->GetSupportSetElementsNumber()-1);
				this->SupportSetIndexes->RemoveAt(this->GetSupportSetElementsNumber()-1);
				NewBeta = this->FindBeta(SampleIndex);
				NewGamma = Gamma;
				NewGamma->SetValue(SampleIndex, this->FindGammaSample(NewBeta, SampleIndex));
				this->SupportSetIndexes->Add(LastSupport);
			} 
			else {
				NewBeta = Beta->Clone();
				NewGamma = Gamma;
			}
			Vector<double>* Zeros = new Vector<double>(this->R->GetLengthCols()+1);
			for (int i=0; i<this->R->GetLengthCols(); i++) {
				Zeros->Add(0);
			}
			this->R->AddColCopy(Zeros);
			Zeros->Add(0);
			this->R->AddRowRef(Zeros);
			if (NewGamma->GetValue(SampleIndex)!=0) {			
				NewBeta->Add(1);
				Matrix<double>* BetaMatrix = BetaMatrix->ProductVectorVector(NewBeta,NewBeta);
				BetaMatrix->DivideScalar(NewGamma->GetValue(SampleIndex));
				this->R->SumMatrix(BetaMatrix);
				delete BetaMatrix;
			}
			delete NewBeta;
 		}
	}

	void OnlineSVR::RemoveSampleFromR (int SampleIndex)
	{
		Vector<double>* Row = this->R->GetRowCopy(SampleIndex+1);	
		Row->RemoveAt(SampleIndex+1);
		Vector<double>* Col = this->R->GetColCopy(SampleIndex+1);
		Col->RemoveAt(SampleIndex+1);
		double Rii = R->GetValue(SampleIndex+1,SampleIndex+1);
		this->R->RemoveRow(SampleIndex+1);
		this->R->RemoveCol(SampleIndex+1);
		if (Rii!=0) {
			Matrix<double>* RVariations = RVariations->ProductVectorVector(Col,Row);
			RVariations->DivideScalar(Rii);
			this->R->SubtractMatrix(RVariations);
			delete RVariations;
		}
		delete Row;
		delete Col;
		if (this->R->GetLengthRows()==1) {
			this->R->Clear();
		}
	}

	Vector<double>* OnlineSVR::FindBeta (int SampleIndex)
	{
		Vector<double>* Qsi = this->Q(this->SupportSetIndexes,SampleIndex);
		Qsi->AddAt(1,0);
		Vector<double>* Beta = this->R->ProductVector(Qsi);
		Beta->ProductScalar(-1);
		delete Qsi;
		return Beta;
	}

	Vector<double>* OnlineSVR::FindGamma (Vector<double>* Beta, int SampleIndex)
	{	
		if (this->GetSupportSetElementsNumber()==0) {
			Vector<double>* Gamma = new Vector<double>(this->GetSamplesTrainedNumber());
			for (int i=0; i<this->GetSamplesTrainedNumber(); i++) {
				Gamma->Add(1);
			}
			return Gamma;
		}
		else {
			Vector<double>* Qxi = this->Q(SampleIndex);
			Matrix<double>* Qxs = this->Q(this->SupportSetIndexes);
			Vector<double>* Ones = new Vector<double>(this->GetSamplesTrainedNumber());
			for (int i=0; i<this->GetSamplesTrainedNumber(); i++) {
				Ones->Add(1);
			}
			Qxs->AddColCopyAt(Ones,0);
			Vector<double>* Gamma = Qxs->ProductVector(Beta);
			Gamma->SumVector(Qxi);
			delete Ones;
			delete Qxi;
			delete Qxs;
			return Gamma;
		}
	}

	double OnlineSVR::FindGammaSample (Vector<double>* Beta, int SampleIndex)
	{	
		if (this->GetSupportSetElementsNumber()==0) {		
			return 1;
		}
		else {
			double Qii = this->Q(SampleIndex,SampleIndex);
			Vector<double>* Qsi = this->Q(this->SupportSetIndexes,SampleIndex);
			Qsi->AddAt(1,0);
			double Gamma = Qii + Beta->ProductVectorScalar(Qsi);
			delete Qsi;
			return Gamma;
		}
	}

		
	// KernelMatrix Operations
	void OnlineSVR::AddSampleToKernelMatrix (Vector<double>* X)
	{
		Vector<double>* V = new Vector<double>();
		if (this->SamplesTrainedNumber>1) {
			for (int i=0; i<this->KernelMatrix->GetLengthRows(); i++)
				V->Add(this->Kernel(this->X->GetRowRef(i),X));
			this->KernelMatrix->AddColCopy(V);
		}
		V->Add(this->Kernel(X,X));
		this->KernelMatrix->AddRowRef(V);
	}

	void OnlineSVR::RemoveSampleFromKernelMatrix (int SampleIndex)
	{
		if (this->KernelMatrix->GetLengthRows()>1) {
			this->KernelMatrix->RemoveRow(SampleIndex);	
			this->KernelMatrix->RemoveCol(SampleIndex);
		}
		else {
			this->KernelMatrix->RemoveRow(SampleIndex);	
		}
	}

	void OnlineSVR::BuildKernelMatrix ()
	{
		if (this->KernelMatrix->GetLengthRows()!=this->SamplesTrainedNumber) {
			KernelMatrix->Clear();
			for (int i=0; i<this->SamplesTrainedNumber; i++)
				this->AddSampleToKernelMatrix(this->X->GetRowRef(i));
		}
		else {
			for (int i=0; i<this->SamplesTrainedNumber; i++) {
				for (int j=0; j<=i; j++) {
					double Value = this->Kernel(this->X->GetRowRef(i),this->X->GetRowRef(j));
					this->KernelMatrix->SetValue(i, j, Value);
					this->KernelMatrix->SetValue(j, i, Value);
				}
			}
		}
	}

}
	
#endif