public override float Product(SparseVec element1, SparseVec element2) { float chi = ChiSquaredKernel.ChiSquareDist(element1, element2); return (float)Math.Exp(-Gamma * chi); }
/// <summary> /// create dense vector based on sparese vector <see cref="mainVec"/> /// </summary> /// <param name="mainVec"></param> /// <param name="fillVector"></param> public static void FillDenseVector(SparseVec mainVec, float[] fillVector) { Array.Clear(fillVector, 0, fillVector.Length); for (int j = 0; j < mainVec.Count; j++) { int idx = mainVec.Indices[j]; float val = (float)mainVec.Values[j]; fillVector[idx] = val; } }
/// <summary> /// Convert sparse vectors into CSR fromat (three array, one for values, one for indexes and one for vector pointers) /// </summary> /// <param name="vecVals"></param> /// <param name="vecIdx"></param> /// <param name="vecLenght"></param> /// <param name="problemElements"></param> public static void TransformToCSRFormat(out float[] vecVals, out int[] vecIdx, out int[] vecLenght, SparseVec[] problemElements) { //transform elements to specific array format -> CSR http://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_row_.28CSR_or_CRS.29 int avgVectorLenght = problemElements[0].Count; //list for all vectors values List<float> vecValsL = new List<float>(problemElements.Length * avgVectorLenght); //list for all vectors indexes List<int> vecIdxL = new List<int>(problemElements.Length * avgVectorLenght); //list of lenght of each vector, list of pointers List<int> vecLenghtL = new List<int>(problemElements.Length); //arrays for values, indexes and lenght int vecStartIdx = 0; // Stopwatch timer = Stopwatch.StartNew(); for (int i = 0; i < problemElements.Length; i++) { var vec = problemElements[i]; //!!!vector not always has only one zero element at the end // mValues and mIndices have extra zero elements at the end, so //after conversion we have to remove zeros from the end //coping and converting from double to float using Linq //var converted = vec.mValues.Take(vec.mValueCount).Select(x => Convert.ToSingle(x)); //var converted = vec.mValues.Select(x => Convert.ToSingle(x)).Take(vec.mValueCount); //Array.ConstrainedCopy(vec.mValues, 0, vecVals, 0, vec.mValueCount); vecValsL.AddRange(vec.Values); vecIdxL.AddRange(vec.Indices); vecLenghtL.Add(vecStartIdx); vecStartIdx += vec.Count; } // timer.Stop(); //for last index vecLenghtL.Add(vecStartIdx); //convert list to arrays vecVals = vecValsL.ToArray(); vecIdx = vecIdxL.ToArray(); vecLenght = vecLenghtL.ToArray(); //set list reference to null to free memeory vecIdxL = null; vecLenghtL = null; vecValsL = null; }
/// <summary> /// set the value on position which are the same as sparse vector indexes /// </summary> /// <param name="sparseVector"></param> /// <param name="bufferPtr"></param> /// <param name="value"></param> internal static void SetBufferIdx(SparseVec sparseVector, IntPtr bufferPtr, float value) { unsafe { float *vecPtr = (float *)bufferPtr.ToPointer(); for (int j = 0; j < sparseVector.Count; j++) { int idx = sparseVector.Indices[j]; vecPtr[idx] = value; } } }
public override float Product(SparseVec element1, SparseVec element2) { float x1Squere = linKernel.Product(element1, element1); float x2Squere = linKernel.Product(element2, element2); float dot = linKernel.Product(element1, element2); float prod = (float)Math.Exp(-Gamma * (x1Squere + x2Squere - 2 * dot)); return prod; }
internal static void InitBuffer(SparseVec sparseVector, IntPtr bufferPtr) { unsafe { float *vecPtr = (float *)bufferPtr.ToPointer(); for (int j = 0; j < sparseVector.Count; j++) { int idx = sparseVector.Indices[j]; float val = (float)sparseVector.Values[j]; vecPtr[idx] = val; } } }
public static void TransformToCSCFormat2(out float[] vecVals, out int[] vecIdx, out int[] vecLenght, SparseVec[] problemElements) { //transform elements to specific array format -> CSR http://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_row_.28CSR_or_CRS.29 int avgVectorLenght = problemElements[0].Count; int Dim = problemElements[0].Dim; List<int>[] colIdx = new List<int>[Dim + 1]; List<float>[] colVals = new List<float>[Dim + 1]; for (int i = 1; i <= Dim; i++) { colIdx[i] = new List<int>(); colVals[i] = new List<float>(); } //list for all vectors values List<float> vecValsL = new List<float>(problemElements.Length * avgVectorLenght); //list for all vectors indexes List<int> vecIdxL = new List<int>(problemElements.Length * avgVectorLenght); //list of lenght of each vector, list of pointers List<int> vecLenghtL = new List<int>(Dim + 1); for (int k = 0; k < problemElements.Length; k++) { var vec = problemElements[k]; for (int s = 0; s < vec.Count; s++) { int idx = vec.Indices[s]; float val = vec.Values[s]; colIdx[idx].Add(k); colVals[idx].Add(val); } } int curColSize = 0; vecLenghtL.Add(curColSize); for (int i = 1; i <= Dim; i++) { curColSize += colIdx[i].Count; vecLenghtL.Add(curColSize); vecIdxL.AddRange(colIdx[i]); vecValsL.AddRange(colVals[i]); colIdx[i] = null; colVals[i] = null; } //convert list to arrays vecVals = vecValsL.ToArray(); vecIdx = vecIdxL.ToArray(); vecLenght = vecLenghtL.ToArray(); //set list reference to null to free memeory vecIdxL = null; vecLenghtL = null; vecValsL = null; }
/// <summary> /// Convert sparse vectors into compact sparse column(CSC) fromat (three array, one for values, one for indexes and one for vector pointers) /// /// /// </summary> /// <param name="vecVals"></param> /// <param name="vecIdx"></param> /// <param name="vecLenght"></param> /// <param name="problemElements"></param> public static void TransformToCSCFormat(out float[] vecVals, out int[] vecIdx, out int[] vecLenght, SparseVec[] problemElements) { //transform elements to specific array format -> CSR http://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_row_.28CSR_or_CRS.29 int avgVectorLenght = problemElements[0].Count; //list for all vectors values List<float> vecValsL = new List<float>(problemElements.Length * avgVectorLenght); //list for all vectors indexes List<int> vecIdxL = new List<int>(problemElements.Length * avgVectorLenght); int Dim = problemElements[0].Dim; //list of lenght of each vector, list of pointers List<int> vecLenghtL = new List<int>(Dim + 1); //arrays for values, indexes and lenght int[] elementsCheckedDims = new int[problemElements.Length]; int vecStartIdx = 0; int curColSize = 0; for (int i = 1; i <= Dim; i++) { curColSize = 0; for (int k = 0; k < problemElements.Length; k++) { var vec = problemElements[k]; int s = elementsCheckedDims[k]; //find max index while (s < vec.Indices.Length && vec.Indices[s] < i) { s++; } // int val = Array.BinarySearch(vec.Indices, s, vec.Indices.Length, i); elementsCheckedDims[k] = s; if (s < vec.Indices.Length && vec.Indices[s] == i) { //insert in to vals and idx vecValsL.Add(vec.Values[s]); vecIdxL.Add(k);//k-th vector in k- column curColSize++; } } vecLenghtL.Add(vecStartIdx); vecStartIdx += curColSize; } //for last index vecLenghtL.Add(vecStartIdx); //convert list to arrays vecVals = vecValsL.ToArray(); vecIdx = vecIdxL.ToArray(); vecLenght = vecLenghtL.ToArray(); //set list reference to null to free memeory vecIdxL = null; vecLenghtL = null; vecValsL = null; }
protected override void SetCudaEvalFuncParamsForVector(SparseVec vec) { cuda.SetParameter(cuFuncEval, vectorSelfDotParamOffset, vec.DotProduct()); }
/// <summary> /// Predicts the specified elements. /// </summary> /// <param name="elements">The elements.</param> /// <returns>array of predicted labels +1 or -1</returns> public override float[] Predict(SparseVec[] elements) { if (!IsInitialized) throw new ApplicationException("Evaluator is not initialized. Call init method"); //tranfsorm elements to matrix in CSR format // elements values float[] vecVals; //elements indexes int[] vecIdx; //elements lenght int[] vecLenght; CudaHelpers.TransformToCSRFormat(out vecVals, out vecIdx, out vecLenght, elements); //copy data to device, set cuda function parameters valsPtr = cuda.CopyHostToDevice(vecVals); idxPtr = cuda.CopyHostToDevice(vecIdx); vecLenghtPtr = cuda.CopyHostToDevice(vecLenght); //release arrays vecVals = null; vecIdx = null; vecLenght = null; uint memElementsSize = (uint)(elements.Length * sizeof(float)); //allocate mapped memory for our results outputIntPtr = cuda.HostAllocate(memElementsSize, CUDADriver.CU_MEMHOSTALLOC_DEVICEMAP); outputPtr = cuda.GetHostDevicePointer(outputIntPtr, 0); //outputPtr = cuda.Allocate(memElementsSize); // Set the cuda kernel paramerters #region set cuda parameters uint Rows = (uint)elements.Length; uint Cols = (uint)TrainedModel.SupportElements.Length; cuda.SetFunctionBlockShape(cuFunc, blockSizeX, blockSizeY, 1); int offset = 0; //set elements param cuda.SetParameter(cuFunc, offset, valsPtr.Pointer); offset += IntPtr.Size; cuda.SetParameter(cuFunc, offset, idxPtr.Pointer); offset += IntPtr.Size; cuda.SetParameter(cuFunc, offset, vecLenghtPtr.Pointer); offset += IntPtr.Size; //set labels param cuda.SetParameter(cuFunc, offset, labelsPtr.Pointer); offset += IntPtr.Size; //set alphas param cuda.SetParameter(cuFunc, offset, alphasPtr.Pointer); offset += IntPtr.Size; //set output (reslut) param cuda.SetParameter(cuFunc, offset, outputPtr.Pointer); offset += IntPtr.Size; //set number of elements param cuda.SetParameter(cuFunc, offset, (uint)Rows); offset += sizeof(int); //set number of support vectors param cuda.SetParameter(cuFunc, offset, (uint)Cols); offset += sizeof(int); //set support vector index param lastParameterOffset = offset; cuda.SetParameter(cuFunc, offset, (uint)0); offset += sizeof(int); cuda.SetParameterSize(cuFunc, (uint)offset); #endregion int gridDimX = (int)Math.Ceiling((Rows + 0.0) / (blockSizeX)); for (int k = 0; k < TrainedModel.SupportElements.Length; k++) { //set the buffer values from k-th support vector CudaHelpers.InitBuffer(TrainedModel.SupportElements[k], svVecIntPtrs[k % 2]); cuda.SynchronizeStream(stream); //copy asynchronously from buffer to devece cuda.CopyHostToDeviceAsync(mainVecPtr, svVecIntPtrs[k % 2], memSvSize, stream); //set the last parameter in kernel (column index) // colIndexParamOffset cuda.SetParameter(cuFunc, lastParameterOffset, (uint)k); //launch kernl cuda.LaunchAsync(cuFunc, gridDimX, 1, stream); if (k > 0) { //clear the previous host buffer CudaHelpers.SetBufferIdx(TrainedModel.SupportElements[k - 1], svVecIntPtrs[(k + 1) % 2], 0.0f); } } //CUdeviceptr symbolAdr; //CUDARuntime.cudaGetSymbolAddress(ref symbolAdr,"RHO"); rho = TrainedModel.Bias; //IntPtr symbolVal = new IntPtr(&rho); //CUDARuntime.cudaMemcpyToSymbol("RHO", symbolVal, 1, 1, cudaMemcpyKind.cudaMemcpyHostToDevice); cuda.SetFunctionBlockShape(cuFuncSign, blockSizeX, blockSizeY, 1); int signFuncOffset = 0; //set array param cuda.SetParameter(cuFuncSign, signFuncOffset, outputPtr.Pointer); signFuncOffset += IntPtr.Size; //set size cuda.SetParameter(cuFuncSign, signFuncOffset, Rows); signFuncOffset += sizeof(int); cuda.SetParameter(cuFuncSign, signFuncOffset, rho); signFuncOffset += sizeof(float); cuda.SetParameterSize(cuFuncSign, (uint)signFuncOffset); //gridDimX is valid for this function cuda.LaunchAsync(cuFuncSign, gridDimX, 1, stream); //wait for all computation cuda.SynchronizeContext(); float[] result = new float[elements.Length]; //copy result Marshal.Copy(outputIntPtr, result, 0, elements.Length); return result; }
private static void RBFProduct(SparseVec[] vectors, int mainIndex, ref float[] output) { SparseVec vec1 = vectors[mainIndex]; float vec1Dot = DotProd(vec1, vec1); for (int i = 0; i < vectors.Length; i++) { float dotVecI = DotProd(vectors[i], vectors[i]); float dotCross = DotProd(vec1, vectors[i]); float sum = dotVecI + vec1Dot - 2 * dotCross; output[i] = (float)Math.Exp(-Gamma * sum); } }
/// <summary> /// Convert sparse vector into slice ellpack format, all data has column majored ordering, with group of <see cref="threadPerRow"/> elements /// </summary> /// <param name="vecVals">vector values</param> /// <param name="vecCols"></param> /// <param name="sliceStart"></param> /// <param name="rowLenght"></param> /// <param name="problemElements"></param> /// <param name="threadsPerRow"></param> /// <param name="sliceSize"></param> public static void TransformToSERTILP(out float[] vecVals, out int[] vecCols, out int[] sliceStart, out int[] rowLenght, SparseVec[] problemElements, int threadsPerRow, int sliceSize,int preFetch) { //int alignold = 128 *(int) Math.Ceiling((float)(sliceSize * threadsPerRow) / 128); int alignParam = 64; //int align = (int)Math.Ceiling(sliceSize * threadsPerRow / 64.0)*64; //int align = (int)Math.Ceiling(sliceSize * threadsPerRow / 2.0) * 2; int align = (int)Math.Ceiling(1.0 * sliceSize * threadsPerRow / alignParam) * alignParam; int numRows = problemElements.Length; int numSlices = (int)Math.Ceiling((numRows + 0.0) / sliceSize); rowLenght = new int[numRows]; sliceStart = new int[numSlices + 1]; //max non-zero in slice int[] sliceMax = new int[numSlices]; int sliceNr = 0; //find max in slice for (int i = 0; i < numSlices; i++) { sliceMax[i] = -1; int idx = -1; for (int j = 0; j < sliceSize; j++) { idx = j + i * sliceSize; if (idx < numRows) { rowLenght[idx] = problemElements[idx].Count; if (sliceMax[i] < rowLenght[idx]) { sliceMax[i] = rowLenght[idx]; } rowLenght[idx] = (int)Math.Ceiling(1.0 * rowLenght[idx] / (threadsPerRow * preFetch)); } } //different than original Slice EllR-T, multiplicated by preFech sliceStart[i + 1] = sliceStart[i] + (int)Math.Ceiling( 1.0*sliceMax[i] /(preFetch* threadsPerRow) ) *preFetch * align; } // int nnzEl = sliceStart[numSlices]; vecCols = new int[nnzEl]; vecVals = new float[nnzEl]; sliceNr = 0; int rowInSlice = 0; //fill slice ellpack values and cols arrays for (int i = 0; i < numRows; i++) { //slice number in whole dataset sliceNr = i / sliceSize; //row number in particular slice rowInSlice = i % sliceSize; var vec = problemElements[i]; int threadNr = -1; float value = 0; int col = -1; int rowSlice = -1;// (int)Math.Ceiling((0.0 + vec.Count) / threadsPerRow); for (int k = 0; k < vec.Count; k++) { threadNr = k % threadsPerRow; rowSlice = k / threadsPerRow; value = vec.Values[k]; col = vec.Indices[k]; //eg. if sliceSize=8, threadsPerRow=4, for first vector (i=0) with size 9 //computed idx should be= [0 1 2 3 , 32,33,34,35, 64] int idx = sliceStart[sliceNr] + align * rowSlice + rowInSlice * threadsPerRow + threadNr; vecVals[idx] = value; vecCols[idx] = col; } } }
/// <summary> /// Convert sparse vectors into ERTILP format, all data has collumn majored ordering /// /// </summary> /// <param name="vecVals"></param> /// <param name="vecCols"></param> /// <param name="rowLength"></param> /// <param name="problemElements"></param> public static void TransformToERTILPFormat(out float[] vecVals, out int[] vecCols, out int[] rowLength, SparseVec[] problemElements, int align, int ThreadsPerRow) { int maxEl = 1; maxEl = (from m in problemElements select m.Count).AsParallel().Max(); //if align not divide maxEl var rest = maxEl % align; // we add small number in order to maxEll was divided by align if (rest != 0) maxEl = maxEl + align - rest; double avgEl = (from t in problemElements select t.Count).Average(); int numRows = problemElements.Length; //2d array stored in 1d array vecVals = new float[numRows * maxEl]; vecCols = new int[numRows * maxEl]; //1d array rowLength = new int[numRows]; for (int i = 0; i < numRows; i++) { var vec = problemElements[i]; for (int j = 0; j < vec.Count; j++) { int k = j / ThreadsPerRow; int t = j % ThreadsPerRow; vecVals[k * numRows * ThreadsPerRow + i * ThreadsPerRow + t] = vec.Values[j]; vecCols[k * numRows * ThreadsPerRow + i * ThreadsPerRow + t] = vec.Indices[j]; } rowLength[i] = (int)Math.Ceiling((vec.Count + 0.0) / align); } }
/// <summary> /// set the value on position which are the same as sparse vector indexes /// </summary> /// <param name="sparseVector"></param> /// <param name="bufferPtr"></param> /// <param name="value"></param> internal static void SetBufferIdx(SparseVec sparseVector, IntPtr bufferPtr, float value) { unsafe { float* vecPtr = (float*)bufferPtr.ToPointer(); for (int j = 0; j < sparseVector.Count; j++) { int idx = sparseVector.Indices[j]; vecPtr[idx] = value; } } }
public override float Product(SparseVec element1, SparseVec element2) { //return chiSquared.Product(element1, element2); return ChiSquaredNormKernel.ChiSquareNormDist(element1, element2); }
public override float Product(SparseVec element1, SparseVec element2) { return chiSquared.Product(element1, element2); }
public override float Product(SparseVec element1, SparseVec element2) { return linKernel.Product(element1, element2); }
public override float Product(SparseVec element1, SparseVec element2) { return(linKernel.Product(element1, element2)); }
public override Model <SparseVec> ComputeModel() { int j; int l = problem.ElementsCount; //prob.l; int n = problem.FeaturesCount; // prob.n; int w_size = n; // prob.n; Model <SparseVec> model = new Model <SparseVec>(); model.FeaturesCount = n; if (bias >= 0) { //Add to each feature vector last feature ==1; model.FeaturesCount = n - 1; } else { model.FeaturesCount = n; } model.Bias = bias; int[] perm = new int[l]; // group training data of the same class //GroupClassesReturn rv = groupClasses(prob, perm); int nr_class = 0; int[] label; // = new int[l];// = rv.label; int[] start; // = rv.start; int[] count; // = rv.count; groupClasses(problem, out nr_class, out label, out start, out count, perm); model.NumberOfClasses = nr_class; model.Labels = new float[nr_class]; for (int i = 0; i < nr_class; i++) { model.Labels[i] = (float)label[i]; } // calculate weighted C double[] weighted_C = new double[nr_class]; for (int i = 0; i < nr_class; i++) { weighted_C[i] = C; } SetClassWeights(nr_class, label, weighted_C); // constructing the subproblem //permutated vectors SparseVec[] permVec = new SparseVec[problem.ElementsCount]; Debug.Assert(l == problem.ElementsCount); for (int i = 0; i < l; i++) { permVec[i] = problem.Elements[perm[i]]; } Problem <SparseVec> sub_prob = new Problem <SparseVec>(); sub_prob.ElementsCount = l; sub_prob.FeaturesCount = n; //we set labels below sub_prob.Y = new float[sub_prob.ElementsCount]; sub_prob.Elements = permVec; //Initailize CUDA driver and load module InitCudaModule(); if (nr_class == 2) { float[] w = new float[w_size]; int e0 = start[0] + count[0]; int k = 0; for (; k < e0; k++) { sub_prob.Y[k] = +1; } for (; k < sub_prob.ElementsCount; k++) { sub_prob.Y[k] = -1; } //copy all needed data to CUDA device SetCudaData(sub_prob); //Fill data on CUDA FillDataOnCuda(sub_prob, w, weighted_C[0], weighted_C[1]); Stopwatch solverTime = Stopwatch.StartNew(); solve_l2r_l2_bb_svc_cuda(sub_prob, w, epsilon, weighted_C[0], weighted_C[1]); //solve_l2r_l1l2_svc(model.W, epsilon, weighted_C[0], weighted_C[1], solverType); solverTime.Stop(); Console.WriteLine("------ solver time {0}", solverTime.Elapsed); model.W = new double[w_size]; for (int s = 0; s < w.Length; s++) { model.W[s] = w[s]; } } else { model.W = new double[w_size * nr_class]; float[] w = new float[w_size]; SetCudaData(sub_prob); ///one against many for (int i = 0; i < nr_class; i++) { int si = start[i]; int ei = si + count[i]; int k = 0; for (; k < si; k++) { sub_prob.Y[k] = -1; } for (; k < ei; k++) { sub_prob.Y[k] = +1; } for (; k < sub_prob.ElementsCount; k++) { sub_prob.Y[k] = -1; } FillDataOnCuda(sub_prob, w, weighted_C[i], C); //train_one(sub_prob, param, w, weighted_C[i], param.C); solve_l2r_l2_bb_svc_cuda(sub_prob, w, epsilon, weighted_C[i], C); for (j = 0; j < n; j++) { model.W[j * nr_class + i] = w[j]; } } } DisposeCuda(); return(model); }
public override float Product(SparseVec element1, SparseVec element2) { return(chiSquared.Product(element1, element2)); }
/// <summary> /// Convert sparse vectors into ellpack-r format, all data has collumn majored ordering /// /// </summary> /// <param name="vecVals"></param> /// <param name="vecCols"></param> /// <param name="rowLength"></param> /// <param name="problemElements"></param> public static void TransformToEllpackRFormat(out float[] vecVals, out int[] vecCols, out int[] rowLength, SparseVec[] problemElements) { int maxEl = 1; //for (int i = 0; i < problemElements.Length; i++) //{ // if(maxEl<problemElements[i].Count) // maxEl=problemElements[i].Count; //} maxEl = (from m in problemElements select m.Count).AsParallel().Max(); double avgEl = (from t in problemElements select t.Count).Average(); int numRows = problemElements.Length; //2d array stored in 1d array vecVals = new float[numRows * maxEl]; vecCols = new int[numRows * maxEl]; //1d array rowLength = new int[numRows]; for (int i = 0; i < numRows; i++) { var vec = problemElements[i]; for (int j = 0; j < vec.Count; j++) { vecVals[j * numRows + i] = vec.Values[j]; vecCols[j * numRows + i] = vec.Indices[j]; } rowLength[i] = vec.Count; } }
private static void NormalSparseDotProduct(SparseVec[] vectors, int mainIndex, ref float[] output) { SparseVec vec1 = vectors[mainIndex]; for (int i = 0; i < vectors.Length; i++) { output[i] = DotProd(vec1, vectors[i]); } }
private static float DotProd(SparseVec vec1, SparseVec vec2) { int i1 = 0; int i2 = 0; float result = 0; while (i1 < vec1.size && i2 < vec2.size) { int index1 = vec1.indices[i1]; int index2 = vec2.indices[i2]; if (index1 == index2) { result += vec1.values[i1] * vec2.values[i2]; i1++; i2++; } else if (index1 < index2) { i1++; } else { i2++; } } return result; }
private static float[] NormalRBFDotProd() { //always the same values Random rnd = new Random(1); SparseVec[] vectors = new SparseVec[N]; mainIndex = StartingIndex; Console.WriteLine("array init "); Stopwatch t = Stopwatch.StartNew(); for (int i = 0; i < N; i++) { vectors[i] = new SparseVec(); int vecSize = avgElements + i % stdElements; vectors[i].size = vecSize; float[] vals = Helpers.InitValues(i, vecSize, maxVal); int[] index = Helpers.InitIndices(i, vecSize, ref maxIndex); vectors[i].indices = index; vectors[i].values = vals; } Console.WriteLine("init takes {0}", t.Elapsed); float[] output = new float[N]; Stopwatch timer = Stopwatch.StartNew(); RBFProduct(vectors, mainIndex, ref output); timer.Stop(); Console.Write("RBF kernel with mainIndex {0} and {1}-vectors takes {2}", mainIndex, N, timer.Elapsed); int lenght = Math.Min(displayCount, N); Console.WriteLine(); for (int i = 0; i < lenght; i++) { Console.WriteLine("{0}-{1}", i, output[i]); } return output; }
public override float Product(SparseVec element1, SparseVec element2) { //return chiSquared.Product(element1, element2); return(ChiSquaredNormKernel.ChiSquareNormDist(element1, element2)); }
internal static void InitBuffer(SparseVec sparseVector, IntPtr bufferPtr) { unsafe { float* vecPtr = (float*)bufferPtr.ToPointer(); for (int j = 0; j < sparseVector.Count; j++) { int idx = sparseVector.Indices[j]; float val = (float)sparseVector.Values[j]; vecPtr[idx] = val; } } }
protected override void SetCudaEvalFuncParamsForVector(SparseVec vec) { cuda.SetParameter(cuFuncEval, vectorSelfSumParamOffset, vec.Values.Sum()); }
public override Model<SparseVec> ComputeModel() { int j; int l = problem.ElementsCount; //prob.l; int n = problem.FeaturesCount;// prob.n; int w_size = n; // prob.n; Model<SparseVec> model = new Model<SparseVec>(); model.FeaturesCount = n; if (bias >= 0) { //Add to each feature vector last feature ==1; model.FeaturesCount = n - 1; } else model.FeaturesCount = n; model.Bias = bias; int[] perm = new int[l]; // group training data of the same class //GroupClassesReturn rv = groupClasses(prob, perm); int nr_class = 0; int[] label;// = new int[l];// = rv.label; int[] start;// = rv.start; int[] count;// = rv.count; groupClasses(problem, out nr_class, out label, out start, out count, perm); model.NumberOfClasses = nr_class; model.Labels = new float[nr_class]; for (int i = 0; i < nr_class; i++) model.Labels[i] = (float)label[i]; // calculate weighted C double[] weighted_C = new double[nr_class]; for (int i = 0; i < nr_class; i++) { weighted_C[i] = C; } SetClassWeights(nr_class, label, weighted_C); // constructing the subproblem //permutated vectors SparseVec[] permVec = new SparseVec[problem.ElementsCount]; Debug.Assert(l == problem.ElementsCount); for (int i = 0; i < l; i++) { permVec[i] = problem.Elements[perm[i]]; } Problem<SparseVec> sub_prob = new Problem<SparseVec>(); sub_prob.ElementsCount = l; sub_prob.FeaturesCount = n; //we set labels below sub_prob.Y = new float[sub_prob.ElementsCount]; sub_prob.Elements = permVec; //Initailize CUDA driver and load module InitCudaModule(); if (nr_class == 2) { float[] w = new float[w_size]; int e0 = start[0] + count[0]; int k = 0; for (; k < e0; k++) sub_prob.Y[k] = +1; for (; k < sub_prob.ElementsCount; k++) sub_prob.Y[k] = -1; Debug.WriteLine("init data on cuda"); //copy all needed data to CUDA device SetCudaData(sub_prob); Debug.WriteLine("set cuda data complete"); //Fill data on CUDA FillDataOnCuda(sub_prob, w, weighted_C[0], weighted_C[1]); Stopwatch solverTime = Stopwatch.StartNew(); solve_l2r_l2_bb_svc_cuda(sub_prob, w, epsilon, weighted_C[0], weighted_C[1]); //solve_l2r_l1l2_svc(model.W, epsilon, weighted_C[0], weighted_C[1], solverType); solverTime.Stop(); Console.WriteLine("------ solver time {0}", solverTime.Elapsed); model.W = new double[w_size]; for (int s = 0; s < w.Length; s++) { model.W[s] = w[s]; } } else { model.W = new double[w_size * nr_class]; float[] w = new float[w_size]; SetCudaData(sub_prob); ///one against many for (int i = 0; i < nr_class; i++) { int si = start[i]; int ei = si + count[i]; int k = 0; for (; k < si; k++) sub_prob.Y[k] = -1; for (; k < ei; k++) sub_prob.Y[k] = +1; for (; k < sub_prob.ElementsCount; k++) sub_prob.Y[k] = -1; FillDataOnCuda(sub_prob, w, weighted_C[i], C); //train_one(sub_prob, param, w, weighted_C[i], param.C); solve_l2r_l2_bb_svc_cuda(sub_prob, w, epsilon, weighted_C[i], C); for (j = 0; j < n; j++) model.W[j * nr_class + i] = w[j]; } } DisposeCuda(); return model; }
public override Model<SparseVec> ComputeModel() { int j; int l = problem.ElementsCount; //prob.l; int n = problem.FeaturesCount;// prob.n; int w_size = n; // prob.n; Model<SparseVec> model = new Model<SparseVec>(); model.FeaturesCount = n; if (bias >= 0) { //Add to each feature vector last feature ==1; model.FeaturesCount = n - 1; } else model.FeaturesCount = n; model.Bias = bias; int[] perm = new int[l]; // group training data of the same class //GroupClassesReturn rv = groupClasses(prob, perm); int nr_class = 0; int[] label;// = new int[l];// = rv.label; int[] start;// = rv.start; int[] count;// = rv.count; groupClasses(problem, out nr_class, out label, out start, out count, perm); model.NumberOfClasses = nr_class; model.Labels = new float[nr_class]; for (int i = 0; i < nr_class; i++) model.Labels[i] = (float)label[i]; // calculate weighted C double[] weighted_C = new double[nr_class]; for (int i = 0; i < nr_class; i++) { weighted_C[i] = C; } SetClassWeights(nr_class, label, weighted_C); // constructing the subproblem //permutated vectors SparseVec[] permVec = new SparseVec[problem.ElementsCount]; Debug.Assert(l == problem.ElementsCount); for (int i = 0; i < l; i++) { permVec[i] = problem.Elements[perm[i]]; } Problem<SparseVec> sub_prob = new Problem<SparseVec>(); sub_prob.ElementsCount = l; sub_prob.FeaturesCount = n; //we set labels below sub_prob.Y = new float[sub_prob.ElementsCount]; sub_prob.Elements = permVec; if (nr_class == 2) { float[] w = new float[w_size]; //for (int z = 0; z < w.Length; z++) //{ // w[z] = 1.0f; //} int e0 = start[0] + count[0]; int k = 0; for (; k < e0; k++) sub_prob.Y[k] = +1; for (; k < sub_prob.ElementsCount; k++) sub_prob.Y[k] = -1; solve_l2r_l2_svc_parallel(sub_prob, w, epsilon, weighted_C[0], weighted_C[1]); //solve_l2r_l1l2_svc(model.W, epsilon, weighted_C[0], weighted_C[1], solverType); model.W = new double[w_size]; for (int s = 0; s < w.Length; s++) { model.W[s] = w[s]; } } else { model.W = new double[w_size * nr_class]; float[] w = new float[w_size]; ///one against many for (int i = 0; i < nr_class; i++) { int si = start[i]; int ei = si + count[i]; int k = 0; for (; k < si; k++) sub_prob.Y[k] = -1; for (; k < ei; k++) sub_prob.Y[k] = +1; for (; k < sub_prob.ElementsCount; k++) sub_prob.Y[k] = -1; //train_one(sub_prob, param, w, weighted_C[i], param.C); solve_l2r_l2_svc_parallel(sub_prob, w, epsilon, weighted_C[i], C); for (j = 0; j < n; j++) model.W[j * nr_class + i] = w[j]; } } return model; }