//TODO
 public static double Calc(BaseVector x, BaseVector y)
 {
     int n = x.Length;
     int c = 0;
     for (int i = 0; i < n; i++){
         double d = x[i] - y[i];
         if (double.IsNaN(d)){
             continue;
         }
         c++;
     }
     if (c < 3){
         return double.NaN;
     }
     double sx = 0;
     double sy = 0;
     double sxy = 0;
     for (int i = 0; i < n; i++){
         double d = x[i] - y[i];
         if (double.IsNaN(d)){
             continue;
         }
         double wx = x[i];
         double wy = y[i];
         sx += wx*wx;
         sy += wy*wy;
         sxy += wx*wy;
     }
     sx /= c;
     sy /= c;
     sxy /= c;
     double corr = sxy/Math.Sqrt(sx*sy);
     return 1 - corr;
 }
Exemple #2
0
        public static double[] CalcSignificanceB(BaseVector ratios, BaseVector intens, TestSide side)
        {
            double[] result = new double[ratios.Length];
            for (int i = 0; i < result.Length; i++)
            {
                result[i] = 1;
            }
            List <double> lRatio     = new List <double>();
            List <double> lIntensity = new List <double>();
            List <int>    indices    = new List <int>();

            for (int i = 0; i < ratios.Length; i++)
            {
                if (!double.IsNaN(ratios[i]) && !double.IsInfinity(ratios[i]) && !double.IsNaN(intens[i]) &&
                    !double.IsInfinity(intens[i]))
                {
                    lRatio.Add(ratios[i]);
                    lIntensity.Add(intens[i]);
                    indices.Add(i);
                }
            }
            double[] ratioSignificanceB = NumUtils.MovingBoxPlot(lRatio.ToArray(), lIntensity.ToArray(), -1, side);
            for (int i = 0; i < indices.Count; i++)
            {
                result[indices[i]] = ratioSignificanceB[i];
            }
            return(result);
        }
        public override ClassificationModel Train(BaseVector[] x, int[][] y, int ngroups, Parameters param, int nthreads,
			Action<double> reportProgress)
        {
            int k = param.GetParam<int>("Number of neighbours").Value;
            IDistance distance = Distances.GetDistanceFunction(param);
            return new KnnClassificationModel(x, y, ngroups, k, distance);
        }
Exemple #4
0
        public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
                                ref IDocumentData[] documents, ProcessInfo processInfo)
        {
            int  ind        = param.GetParam <int>("Column").Value;
            bool descending = param.GetParam <bool>("Descending").Value;

            if (ind < mdata.ColumnCount)
            {
                BaseVector v = mdata.Values.GetColumn(ind);
                int[]      o = ArrayUtils.Order(v);
                if (descending)
                {
                    ArrayUtils.Revert(o);
                }
                mdata.ExtractRows(o);
            }
            else
            {
                double[] v = mdata.NumericColumns[ind - mdata.ColumnCount];
                int[]    o = ArrayUtils.Order(v);
                if (descending)
                {
                    ArrayUtils.Revert(o);
                }
                mdata.ExtractRows(o);
            }
        }
        public ClassificationModel Train(BaseVector[] x, int[][] y, int ngroups, IGroupDataProvider data, int nthreads,
			Action<double> reportProgress)
        {
            return groupWiseSelection
                        ? TrainGroupWise(x, y, ngroups, data, nthreads)
                        : TrainGlobal(x, y, ngroups, data, nthreads, reportProgress);
        }
 public override float[] PredictStrength(BaseVector x)
 {
     float[] result = new float[classifiers.Length];
     for (int i = 0; i < result.Length; i++){
         result[i] = classifiers[i].PredictStrength(x)[0];
     }
     return result;
 }
 public static BaseVector[] ExtractFeatures(IList<BaseVector> x, IList<int> inds)
 {
     BaseVector[] result = new BaseVector[x.Count];
     for (int i = 0; i < x.Count; i++){
         result[i] = x[i].SubArray(inds);
     }
     return result;
 }
Exemple #8
0
 private static double[] CalcDistances(IList <BaseVector> x, BaseVector xTest, IDistance distance)
 {
     double[] result = new double[x.Count];
     for (int i = 0; i < x.Count; i++)
     {
         result[i] = distance.Get(x[i], xTest);
     }
     return(result);
 }
Exemple #9
0
 public static BaseVector[] ExtractFeatures(IList <BaseVector> x, IList <int> inds)
 {
     BaseVector[] result = new BaseVector[x.Count];
     for (int i = 0; i < x.Count; i++)
     {
         result[i] = x[i].SubArray(inds);
     }
     return(result);
 }
 public override float[] PredictStrength(BaseVector x)
 {
     float[] result = new float[classifiers.Length];
     for (int i = 0; i < result.Length; i++)
     {
         result[i] = classifiers[i].PredictStrength(x)[0];
     }
     return(result);
 }
 public override float[] PredictStrength(BaseVector x)
 {
     double[] projectedTest = MatrixUtils.VectorTimesMatrix(x, projection);
     float[] distances = new float[ngroups];
     IDistance distance = new EuclideanDistance();
     for (int j = 0; j < ngroups; j++){
         distances[j] = -(float) distance.Get(projectedTest, projectedGroupMeans[j]);
     }
     return distances;
 }
 public override float Predict(BaseVector xTest)
 {
     int[] inds = KnnClassificationModel.GetNeighborInds(x, xTest, k, distance);
     float result = 0;
     foreach (int ind in inds){
         result += y[ind];
     }
     result /= inds.Length;
     return result;
 }
Exemple #13
0
 public static double KFunction(BaseVector x, BaseVector y, SvmParameter param)
 {
     IKernelFunction kf = param.kernelFunction;
     double sx = double.NaN;
     double sy = double.NaN;
     if (kf.UsesSquares){
         sx = x.Dot(x);
         sy = y.Dot(y);
     }
     return kf.Evaluate(x, y, sx, sy);
 }
 public RegressionModel Train(BaseVector[] x, float[] y, Parameters param, int nthreads)
 {
     ParameterWithSubParams<int> kernelParam = param.GetParamWithSubParams<int>("Kernel");
     SvmParameter sp = new SvmParameter{
         kernelFunction = KernelFunctions.GetKernelFunction(kernelParam.Value, kernelParam.GetSubParameters()),
         svmType = SvmType.EpsilonSvr,
         c = param.GetParam<double>("C").Value
     };
     SvmModel model = SvmMain.SvmTrain(new SvmProblem(x, y), sp);
     return new SvmRegressionModel(model);
 }
 public int[] PredictClasses(BaseVector x)
 {
     float[] w = PredictStrength(x);
     List<int> result = new List<int>();
     for (int i = 0; i < w.Length; i++){
         if (w[i] > 0){
             result.Add(i);
         }
     }
     return result.ToArray();
 }
 public RegressionModel Train(BaseVector[] x, float[] y, IGroupDataProvider data)
 {
     if (ranker == null || nfeatures >= x[0].Length){
         return regressionMethod.Train(x, y, regressionParam, 1);
     }
     int[] o = ranker.Rank(x, y, rankerParam, data, 1);
     int[] inds = nfeatures < o.Length ? ArrayUtils.SubArray(o, nfeatures) : o;
     return
         new RegressionOnSubFeatures(
             regressionMethod.Train(ClassificationWithRanking.ExtractFeatures(x, inds), y, regressionParam, 1), inds);
 }
Exemple #17
0
        private static BaseVector[] ToOneHotEncodingMixed(BaseVector[] x, int[] nominal)
        {
            int len = CalcTotalLength(nominal);

            BaseVector[] result = new BaseVector[x.Length];
            for (int i = 0; i < result.Length; i++)
            {
                result[i] = ToOneHotEncodingMixed(x[i], nominal, len);
            }
            return(result);
        }
Exemple #18
0
 public static double[] VectorTimesMatrix(BaseVector a, double[,] b)
 {
     double[] result = new double[b.GetLength(1)];
     for (int i = 0; i < result.Length; i++)
     {
         for (int k = 0; k < a.Length; k++)
         {
             result[i] += a[k] * b[k, i];
         }
     }
     return(result);
 }
        public ClassificationModel TrainGlobal(BaseVector[] x, int[][] y, int ngroups, IGroupDataProvider data, int nthreads,
			Action<double> reportProgress)
        {
            if (ranker == null || nfeatures >= x[0].Length){
                return classifier.Train(x, y, ngroups, classifierParam, nthreads, reportProgress);
            }
            int[] o = ranker.Rank(x, y, ngroups, rankerParam, data, nthreads);
            int[] inds = nfeatures < o.Length ? ArrayUtils.SubArray(o, nfeatures) : o;
            return
                new ClassificationOnSubFeatures(classifier.Train(ExtractFeatures(x, inds), y, ngroups, classifierParam, nthreads),
                    inds);
        }
Exemple #20
0
        public override float Predict(BaseVector xTest)
        {
            int[] inds   = KnnClassificationModel.GetNeighborInds(x, xTest, k, distance);
            float result = 0;

            foreach (int ind in inds)
            {
                result += y[ind];
            }
            result /= inds.Length;
            return(result);
        }
Exemple #21
0
        public override float[] PredictStrength(BaseVector x)
        {
            double[]  projectedTest = MatrixUtils.VectorTimesMatrix(x, projection);
            float[]   distances     = new float[ngroups];
            IDistance distance      = new EuclideanDistance();

            for (int j = 0; j < ngroups; j++)
            {
                distances[j] = -(float)distance.Get(projectedTest, projectedGroupMeans[j]);
            }
            return(distances);
        }
Exemple #22
0
        public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
                                ref IDocumentData[] documents, ProcessInfo processInfo)
        {
            int[]          cols       = param.GetParam <int[]>("Columns").Value;
            int            truncIndex = param.GetParam <int>("Use for truncation").Value;
            TestTruncation truncation = truncIndex == 0
                                ? TestTruncation.Pvalue
                                : (truncIndex == 1 ? TestTruncation.BenjaminiHochberg : TestTruncation.PermutationBased);
            double   threshold = param.GetParam <double>("Threshold value").Value;
            int      sideInd   = param.GetParam <int>("Side").Value;
            TestSide side;

            switch (sideInd)
            {
            case 0:
                side = TestSide.Both;
                break;

            case 1:
                side = TestSide.Left;
                break;

            case 2:
                side = TestSide.Right;
                break;

            default:
                throw new Exception("Never get here.");
            }
            foreach (int col in cols)
            {
                BaseVector r     = mdata.Values.GetColumn(col);
                double[]   pvals = CalcSignificanceA(r, side);
                string[][] fdr;
                switch (truncation)
                {
                case TestTruncation.Pvalue:
                    fdr = PerseusPluginUtils.CalcPvalueSignificance(pvals, threshold);
                    break;

                case TestTruncation.BenjaminiHochberg:
                    double[] fdrs;
                    fdr = PerseusPluginUtils.CalcBenjaminiHochbergFdr(pvals, threshold, pvals.Length, out fdrs);
                    break;

                default:
                    throw new Exception("Never get here.");
                }
                mdata.AddNumericColumn(mdata.ColumnNames[col] + " Significance A", "", pvals);
                mdata.AddCategoryColumn(mdata.ColumnNames[col] + " A significant", "", fdr);
            }
        }
Exemple #23
0
 internal SvmKernel(int l, BaseVector[] x1, SvmParameter param)
 {
     kernelFunction = param.kernelFunction;
     x = (BaseVector[]) x1.Clone();
     if (kernelFunction.UsesSquares){
         xSquare = new double[l];
         for (int i = 0; i < l; i++){
             xSquare[i] = x[i].Dot(x[i]);
         }
     } else{
         xSquare = null;
     }
 }
Exemple #24
0
        public static double KFunction(BaseVector x, BaseVector y, SvmParameter param)
        {
            IKernelFunction kf = param.kernelFunction;
            double          sx = double.NaN;
            double          sy = double.NaN;

            if (kf.UsesSquares)
            {
                sx = x.Dot(x);
                sy = y.Dot(y);
            }
            return(kf.Evaluate(x, y, sx, sy));
        }
 public int[] Rank(BaseVector[] x, float[] y, Parameters param, IGroupDataProvider data, int nthreads)
 {
     int nfeatures = x[0].Length;
     double[] s = new double[nfeatures];
     for (int i = 0; i < nfeatures; i++){
         float[] xx = new float[x.Length];
         for (int j = 0; j < xx.Length; j++){
             xx[j] = (float)x[j][i];
         }
         s[i] = CalcScore(xx, y);
     }
     return ArrayUtils.Order(s);
 }
        public int[] PredictClasses(BaseVector x)
        {
            float[]    w      = PredictStrength(x);
            List <int> result = new List <int>();

            for (int i = 0; i < w.Length; i++)
            {
                if (w[i] > 0)
                {
                    result.Add(i);
                }
            }
            return(result.ToArray());
        }
 //TODO
 public static double Calc(BaseVector x, BaseVector y)
 {
     int n = x.Length;
     double sum = 0;
     int c = 0;
     for (int i = 0; i < n; i++){
         double d = x[i] - y[i];
         if (double.IsNaN(d)){
             continue;
         }
         sum += d*d;
         c++;
     }
     return c == 0 ? double.NaN : Math.Sqrt(sum/c*n);
 }
        /// <summary>
        /// Create distance matrix from <see cref="IDistance"/>.
        /// </summary>
        /// <param name="data"></param>
        /// <param name="distance"></param>
        public GenericDistanceMatrix(MatrixIndexer data, IDistance distance)
        {
            N         = data.RowCount;
            distances = new double[N * (N - 1) / 2];
            int k = 0;

            for (int i = 0; i < N; i++)
            {
                BaseVector xi = data.GetRow(i);
                for (int j = i + 1; j < N; j++)
                {
                    distances[k++] = distance.Get(xi, data.GetRow(j));
                }
            }
        }
        //TODO
        public static double Calc(BaseVector x, BaseVector y)
        {
            int    n  = x.Length;
            double mx = 0;
            double my = 0;
            int    c  = 0;

            for (int i = 0; i < n; i++)
            {
                double d = x[i] - y[i];
                if (double.IsNaN(d))
                {
                    continue;
                }
                mx += x[i];
                my += y[i];
                c++;
            }
            if (c < 3)
            {
                return(double.NaN);
            }
            mx /= c;
            my /= c;
            double sx  = 0;
            double sy  = 0;
            double sxy = 0;

            for (int i = 0; i < n; i++)
            {
                double d = x[i] - y[i];
                if (double.IsNaN(d))
                {
                    continue;
                }
                double wx = x[i] - mx;
                double wy = y[i] - my;
                sx  += wx * wx;
                sy  += wy * wy;
                sxy += wx * wy;
            }
            sx  /= c;
            sy  /= c;
            sxy /= c;
            double corr = sxy / Math.Sqrt(sx * sy);

            return(1 - corr);
        }
        public override int[] Rank(BaseVector[] x, int[][] y, int ngroups, Parameters param, IGroupDataProvider data,
			int nthreads, Action<double> reportProgress)
        {
            double s0 = param.GetParam<double>("s0").Value;
            int nfeatures = x[0].Length;
            int[][] yy = RearrangeGroups(y, ngroups);
            double[] s = new double[nfeatures];
            for (int i = 0; i < nfeatures; i++){
                double[] xx = new double[x.Length];
                for (int j = 0; j < xx.Length; j++){
                    xx[j] = x[j][i];
                }
                s[i] = CalcPvalue(xx, yy, ngroups, s0);
            }
            return ArrayUtils.Order(s);
        }
Exemple #31
0
 internal override void SwapIndex(int i, int j)
 {
     {
         BaseVector tmp = x[i];
         x[i] = x[j];
         x[j] = tmp;
     }
     if (xSquare != null)
     {
         {
             double tmp = xSquare[i];
             xSquare[i] = xSquare[j];
             xSquare[j] = tmp;
         }
     }
 }
 //TODO
 public static double Calc(BaseVector x, BaseVector y)
 {
     int n = x.Length;
     double max = double.MinValue;
     for (int i = 0; i < n; i++){
         double d = x[i] - y[i];
         if (double.IsNaN(d) || double.IsInfinity(d)){
             continue;
         }
         double dist = Math.Abs(d);
         if (dist > max){
             max = dist;
         }
     }
     return max == double.MinValue ? double.NaN : max;
 }
        public override int[] Rank(BaseVector[] x, int[][] y, int ngroups, Parameters param, IGroupDataProvider data,
			int nthreads, Action<double> reportProgress)
        {
            SvmParameter sp = new SvmParameter{
                kernelFunction = new LinearKernelFunction(),
                svmType = SvmType.CSvc,
                c = param.GetParam<double>("C").Value
            };
            bool[] invert;
            SvmProblem[] problems = CreateProblems(x, y, ngroups, out invert);
            int[][] rankedSets = new int[problems.Length][];
            for (int i = 0; i < problems.Length; ++i){
                rankedSets[i] = RankBinary(problems[i], sp);
            }
            return CombineRankedFeaturesLists(rankedSets);
        }
 public override double Dot(BaseVector y)
 {
     if (y is SparseFloatVector){
         return SparseFloatVector.Dot(this, (SparseFloatVector) y);
     }
     if (y is SparseBoolVector){
         return SparseBoolVector.Dot(this, (SparseBoolVector) y);
     }
     if (y is DoubleArrayVector){
         return Dot(this, (DoubleArrayVector) y);
     }
     if (y is FloatArrayVector){
         return Dot(this, (FloatArrayVector) y);
     }
     return Dot(this, (BoolArrayVector) y);
 }
 public RegressionModel[] Train(BaseVector[] x, float[] y, IGroupDataProvider data)
 {
     int[] o = ranker.Rank(x, y, rankerParam, data, 1);
     int[] sizes = GetSizes(x[0].Length, reductionFactor, maxFeatures);
     RegressionModel[] result = new RegressionModel[sizes.Length];
     for (int i = 0; i < result.Length; i++){
         if (i == 0 && sizes[0] == x[0].Length){
             result[0] = classifier.Train(x, y, classifierParam, 1);
         } else{
             int[] inds = ArrayUtils.SubArray(o, sizes[i]);
             result[i] =
                 new RegressionOnSubFeatures(
                     classifier.Train(ClassificationWithRanking.ExtractFeatures(x, inds), y, classifierParam, 1), inds);
         }
     }
     return result;
 }
Exemple #36
0
 //TODO
 public static double Calc(BaseVector x, BaseVector y)
 {
     int n = x.Length;
     int c = 0;
     double sum = 0;
     for (int i = 0; i < n; i++){
         double d = x[i] - y[i];
         if (!double.IsNaN(d)){
             sum += Math.Abs(d);
             c++;
         }
     }
     if (c == 0){
         return double.NaN;
     }
     return sum/c*n;
 }
 //TODO
 public static double Calc(BaseVector x, BaseVector y)
 {
     int n = x.Length;
     List<int> valids = new List<int>();
     for (int i = 0; i < n; i++){
         double xx = x[i];
         double yy = y[i];
         if (double.IsNaN(xx) || double.IsNaN(yy) || double.IsInfinity(xx) || double.IsInfinity(yy)){
             continue;
         }
         valids.Add(i);
     }
     if (valids.Count < 3){
         return double.NaN;
     }
     return PearsonCorrelationDistance.Calc(ArrayUtils.Rank(x.SubArray(valids)), ArrayUtils.Rank(y.SubArray(valids)));
 }
Exemple #38
0
 public override double[] PredictStrength(BaseVector xTest)
 {
     int[]    inds   = GetNeighborInds(x, xTest, k, distance);
     double[] result = new double[ngroups];
     foreach (int ind in inds)
     {
         foreach (int i in y[ind])
         {
             result[i]++;
         }
     }
     for (int i = 0; i < ngroups; i++)
     {
         result[i] /= k;
     }
     return(result);
 }
 public override float[] PredictStrength(BaseVector x)
 {
     if (models.Length == 1){
         float[] result = new float[2];
         double[] decVal = new double[1];
         SvmMain.SvmPredictValues(models[0], x, decVal);
         result[0] = invert[0] ? -(float)decVal[0] : (float)decVal[0];
         result[1] = -result[0];
         return result;
     }
     float[] result1 = new float[models.Length];
     for (int i = 0; i < result1.Length; i++){
         double[] decVal = new double[1];
         SvmMain.SvmPredictValues(models[i], x, decVal);
         result1[i] = invert[i] ? -(float)decVal[0] : (float)decVal[0];
     }
     return result1;
 }
Exemple #40
0
        public static float SvmPredict(SvmModel model, BaseVector x)
        {
            int nrClass = model.nrClass;

            double[] decValues;
            if (model.param.svmType == SvmType.OneClass || model.param.svmType == SvmType.EpsilonSvr ||
                model.param.svmType == SvmType.NuSvr)
            {
                decValues = new double[1];
            }
            else
            {
                decValues = new double[nrClass * (nrClass - 1) / 2];
            }
            float predResult = SvmPredictValues(model, x, decValues);

            return(predResult);
        }
        //TODO
        public static double Calc(BaseVector x, BaseVector y)
        {
            int    n   = x.Length;
            double sum = 0;
            int    c   = 0;

            for (int i = 0; i < n; i++)
            {
                double d = x[i] - y[i];
                if (double.IsNaN(d))
                {
                    continue;
                }
                sum += d * d;
                c++;
            }
            return(c == 0 ? double.NaN : Math.Sqrt(sum / c * n));
        }
Exemple #42
0
        public static int[] GetNeighborInds(IList <BaseVector> x, BaseVector xTest, int k, IDistance distance)
        {
            double[]   d      = CalcDistances(x, xTest, distance);
            int[]      o      = ArrayUtils.Order(d);
            List <int> result = new List <int>();

            for (int i = 0; i < d.Length; i++)
            {
                if (!double.IsNaN(d[o[i]]) && !double.IsInfinity(d[o[i]]))
                {
                    result.Add(o[i]);
                }
                if (result.Count >= k)
                {
                    break;
                }
            }
            return(result.ToArray());
        }
 internal static string CheckInput(BaseVector[] x, int[][] y, int ngroups)
 {
     if (ngroups < 2){
         return "Number of groups has to be at least two.";
     }
     foreach (int[] ints in y){
         if (ints.Length == 0){
             return "There are unassigned items";
         }
         Array.Sort(ints);
     }
     int[] vals = ArrayUtils.UniqueValues(ArrayUtils.Concat(y));
     for (int i = 0; i < vals.Length; i++){
         if (vals[i] != i){
             //return "At least one group has no training example.";
         }
     }
     return null;
 }
        public static void CombineRows(this IMatrixData mdata, List <int> rowIdxs, Func <double[], double> combineNumeric,
                                       Func <string[], string> combineString, Func <string[][], string[]> combineCategory,
                                       Func <double[][], double[]> combineMultiNumeric)
        {
            if (!rowIdxs.Any())
            {
                return;
            }
            int resultRow = rowIdxs[0];

            for (int i = 0; i < mdata.Values.ColumnCount; i++)
            {
                BaseVector column = mdata.Values.GetColumn(i);
                BaseVector values = column.SubArray(rowIdxs);
                mdata.Values[resultRow, i] = combineNumeric(ArrayUtils.ToDoubles(values));
            }
            for (int i = 0; i < mdata.NumericColumnCount; i++)
            {
                double[] column = mdata.NumericColumns[i];
                double[] values = ArrayUtils.SubArray(column, rowIdxs);
                column[resultRow] = combineNumeric(values);
            }
            for (int i = 0; i < mdata.StringColumnCount; i++)
            {
                string[] column = mdata.StringColumns[i];
                string[] values = ArrayUtils.SubArray(column, rowIdxs);
                column[resultRow] = combineString(values);
            }
            for (int i = 0; i < mdata.CategoryColumnCount; i++)
            {
                string[][] column = mdata.GetCategoryColumnAt(i);
                string[][] values = ArrayUtils.SubArray(column, rowIdxs);
                column[resultRow] = combineCategory(values);
                mdata.SetCategoryColumnAt(column, i);
            }
            for (int i = 0; i < mdata.MultiNumericColumnCount; i++)
            {
                double[][] column = mdata.MultiNumericColumns[i];
                double[][] values = ArrayUtils.SubArray(column, rowIdxs);
                column[resultRow] = combineMultiNumeric(values);
            }
        }
 public override double[] PredictStrength(BaseVector x)
 {
     if (models.Length == 1)
     {
         double[] result = new double[2];
         double[] decVal = new double[1];
         SvmMain.SvmPredictValues(models[0], x, decVal);
         result[0] = invert[0] ? -(float)decVal[0] : (float)decVal[0];
         result[1] = -result[0];
         return(result);
     }
     double[] result1 = new double[models.Length];
     for (int i = 0; i < result1.Length; i++)
     {
         double[] decVal = new double[1];
         SvmMain.SvmPredictValues(models[i], x, decVal);
         result1[i] = invert[i] ? -(float)decVal[0] : (float)decVal[0];
     }
     return(result1);
 }
        //TODO
        public static double Calc(BaseVector x, BaseVector y)
        {
            int    n   = x.Length;
            double max = double.MinValue;

            for (int i = 0; i < n; i++)
            {
                double d = x[i] - y[i];
                if (double.IsNaN(d) || double.IsInfinity(d))
                {
                    continue;
                }
                double dist = Math.Abs(d);
                if (dist > max)
                {
                    max = dist;
                }
            }
            return(max == double.MinValue ? double.NaN : max);
        }
Exemple #47
0
        //TODO
        public static double Calc(BaseVector x, BaseVector y)
        {
            int        n      = x.Length;
            List <int> valids = new List <int>();

            for (int i = 0; i < n; i++)
            {
                double xx = x[i];
                double yy = y[i];
                if (double.IsNaN(xx) || double.IsNaN(yy) || double.IsInfinity(xx) || double.IsInfinity(yy))
                {
                    continue;
                }
                valids.Add(i);
            }
            if (valids.Count < 3)
            {
                return(double.NaN);
            }
            return(PearsonCorrelationDistance.Calc(ArrayUtils.Rank(x.SubArray(valids)), ArrayUtils.Rank(y.SubArray(valids))));
        }
Exemple #48
0
        //TODO
        public static double Calc(BaseVector x, BaseVector y)
        {
            int    n   = x.Length;
            int    c   = 0;
            double sum = 0;

            for (int i = 0; i < n; i++)
            {
                double d = x[i] - y[i];
                if (!double.IsNaN(d))
                {
                    sum += Math.Abs(d);
                    c++;
                }
            }
            if (c == 0)
            {
                return(double.NaN);
            }
            return(sum / c * n);
        }
        public override ClassificationModel Train(BaseVector[] x, int[][] y, int ngroups, Parameters param, int nthreads,
			Action<double> reportProgress)
        {
            string err = CheckInput(x, y, ngroups);
            if (err != null){
                throw new Exception(err);
            }
            ParameterWithSubParams<int> kernelParam = param.GetParamWithSubParams<int>("Kernel");
            SvmParameter sp = new SvmParameter{
                kernelFunction = KernelFunctions.GetKernelFunction(kernelParam.Value, kernelParam.GetSubParameters()),
                svmType = SvmType.CSvc,
                c = param.GetParam<double>("C").Value
            };
            bool[] invert;
            SvmProblem[] problems = CreateProblems(x, y, ngroups, out invert);
            SvmModel[] models = new SvmModel[problems.Length];
            ThreadDistributor td = new ThreadDistributor(nthreads, models.Length,
                i => { models[i] = SvmMain.SvmTrain(problems[i], sp); }, fractionDone => { reportProgress?.Invoke(fractionDone); });
            td.Start();
            return new SvmClassificationModel(models, invert);
        }
Exemple #50
0
        private static BaseVector ToOneHotEncodingMixed(BaseVector x, int[] nominal, int len)
        {
            float[] r   = new float[len];
            int     pos = 0;

            for (int i = 0; i < x.Length; i++)
            {
                int    nom = nominal[i];
                double w   = x[i];
                if (nom <= 2)
                {
                    r[pos] = (float)w;
                    pos++;
                }
                else
                {
                    r[pos + (int)Math.Round(w)] = 1;
                    pos += nom;
                }
            }
            return(new FloatArrayVector(r));
        }
Exemple #51
0
        private static BaseVector ToOneHotEncodingBoolean(BaseVector x, int[] nominal, int len)
        {
            bool[] r   = new bool[len];
            int    pos = 0;

            for (int i = 0; i < x.Length; i++)
            {
                int nom = nominal[i];
                int w   = (int)Math.Round(x[i]);
                if (nom == 2)
                {
                    r[pos] = w == 1;
                    pos++;
                }
                else
                {
                    r[pos + w] = true;
                    pos       += nom;
                }
            }
            return(new BoolArrayVector(r));
        }
Exemple #52
0
        public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
                                ref IDocumentData[] documents, ProcessInfo processInfo)
        {
            int  ind        = param.GetParam <int>("Column").Value;
            bool descending = param.GetParam <bool>("Descending").Value;

            if (ind < mdata.Values.ColumnCount)
            {
                BaseVector v = mdata.Values.GetColumn(ind);
                SortByValues(mdata, v.ToArray(), descending);
            }
            else if (ind < mdata.Values.ColumnCount + mdata.NumericColumnCount)
            {
                double[] v = mdata.NumericColumns[ind - mdata.ColumnCount];
                SortByValues(mdata, v, descending);
            }
            else
            {
                string[] v = mdata.StringColumns[ind - mdata.ColumnCount - mdata.NumericColumnCount];
                SortByValues(mdata, v, descending);
            }
        }
Exemple #53
0
 public static float SvmPredictProbability(SvmModel model, BaseVector x, double[] probEstimates)
 {
     if ((model.param.svmType == SvmType.CSvc || model.param.svmType == SvmType.NuSvc) && model.probA != null &&
         model.probB != null)
     {
         int      nrClass   = model.nrClass;
         double[] decValues = new double[nrClass * (nrClass - 1) / 2];
         SvmPredictValues(model, x, decValues);
         const double minProb      = 1e-7;
         double[][]   pairwiseProb = new double[nrClass][];
         for (int m = 0; m < nrClass; m++)
         {
             pairwiseProb[m] = new double[nrClass];
         }
         int k = 0;
         for (int i = 0; i < nrClass; i++)
         {
             for (int j = i + 1; j < nrClass; j++)
             {
                 pairwiseProb[i][j] = Math.Min(Math.Max(SigmoidPredict(decValues[k], model.probA[k], model.probB[k]), minProb),
                                               1 - minProb);
                 pairwiseProb[j][i] = 1 - pairwiseProb[i][j];
                 k++;
             }
         }
         MulticlassProbability(nrClass, pairwiseProb, probEstimates);
         int probMaxIdx = 0;
         for (int i = 1; i < nrClass; i++)
         {
             if (probEstimates[i] > probEstimates[probMaxIdx])
             {
                 probMaxIdx = i;
             }
         }
         return(model.label[probMaxIdx]);
     }
     return(SvmPredict(model, x));
 }
Exemple #54
0
 public override float Predict(BaseVector x)
 {
     return(SvmMain.SvmPredict(model, x));
 }
 public override float[] PredictStrength(BaseVector x)
 {
     return classifier.PredictStrength(x.SubArray(featureInds));
 }
Exemple #56
0
        //
        // Interface functions
        //
        public static SvmModel SvmTrain(SvmProblem prob, SvmParameter param)
        {
            SvmModel model = new SvmModel {
                param = param
            };

            if (param.svmType == SvmType.OneClass || param.svmType == SvmType.EpsilonSvr || param.svmType == SvmType.NuSvr)
            {
                // regression or one-class-svm
                model.nrClass = 2;
                model.label   = null;
                model.nSv     = null;
                model.probA   = null;
                model.probB   = null;
                model.svCoef  = new double[1][];
                if (param.probability && (param.svmType == SvmType.EpsilonSvr || param.svmType == SvmType.NuSvr))
                {
                    model.probA    = new double[1];
                    model.probA[0] = SvmSvrProbability(prob, param);
                }
                DecisionFunction f = SvmTrainOne(prob, param, 0, 0);
                model.rho    = new double[1];
                model.rho[0] = f.rho;
                int nSv = 0;
                int i;
                for (i = 0; i < prob.Count; i++)
                {
                    if (Math.Abs(f.alpha[i]) > 0)
                    {
                        ++nSv;
                    }
                }
                model.l         = nSv;
                model.sv        = new BaseVector[nSv];
                model.svCoef[0] = new double[nSv];
                int j = 0;
                for (i = 0; i < prob.Count; i++)
                {
                    if (Math.Abs(f.alpha[i]) > 0)
                    {
                        model.sv[j]        = prob.x[i];
                        model.svCoef[0][j] = f.alpha[i];
                        ++j;
                    }
                }
            }
            else
            {
                // classification
                int     l          = prob.Count;
                int[]   tmpNrClass = new int[1];
                int[][] tmpLabel   = new int[1][];
                int[][] tmpStart   = new int[1][];
                int[][] tmpCount   = new int[1][];
                int[]   perm       = new int[l];
                // group training data of the same class
                SvmGroupClasses(prob, tmpNrClass, tmpLabel, tmpStart, tmpCount, perm);
                int   nrClass = tmpNrClass[0];
                int[] label   = tmpLabel[0];
                int[] start   = tmpStart[0];
                int[] count   = tmpCount[0];
                if (nrClass == 1)
                {
                    Info("WARNING: training data in only one class. See README for details.\n");
                }
                BaseVector[] x = new BaseVector[l];
                int          i;
                for (i = 0; i < l; i++)
                {
                    x[i] = prob.x[perm[i]];
                }
                // calculate weighted C
                double[] weightedC = new double[nrClass];
                for (i = 0; i < nrClass; i++)
                {
                    weightedC[i] = param.c;
                }
                for (i = 0; i < param.nrWeight; i++)
                {
                    int j;
                    for (j = 0; j < nrClass; j++)
                    {
                        if (param.weightLabel[i] == label[j])
                        {
                            break;
                        }
                    }
                    if (j == nrClass)
                    {
                        Info("WARNING: class label " + param.weightLabel[i] + " specified in weight is not found\n");
                    }
                    else
                    {
                        weightedC[j] *= param.weight[i];
                    }
                }
                // train k*(k-1)/2 models
                bool[] nonzero = new bool[l];
                for (i = 0; i < l; i++)
                {
                    nonzero[i] = false;
                }
                DecisionFunction[] f     = new DecisionFunction[nrClass * (nrClass - 1) / 2];
                double[]           probA = null, probB = null;
                if (param.probability)
                {
                    probA = new double[nrClass * (nrClass - 1) / 2];
                    probB = new double[nrClass * (nrClass - 1) / 2];
                }
                int p = 0;
                for (i = 0; i < nrClass; i++)
                {
                    for (int j = i + 1; j < nrClass; j++)
                    {
                        int        si = start[i], sj = start[j];
                        int        ci = count[i], cj = count[j];
                        int        c       = ci + cj;
                        SvmProblem subProb = new SvmProblem {
                            x = new BaseVector[c], y = new float[c]
                        };
                        int k;
                        for (k = 0; k < ci; k++)
                        {
                            subProb.x[k] = x[si + k];
                            subProb.y[k] = +1;
                        }
                        for (k = 0; k < cj; k++)
                        {
                            subProb.x[ci + k] = x[sj + k];
                            subProb.y[ci + k] = -1;
                        }
                        if (param.probability)
                        {
                            double[] probAb = new double[2];
                            SvmBinarySvcProbability(subProb, param, weightedC[i], weightedC[j], probAb);
                            probA[p] = probAb[0];
                            probB[p] = probAb[1];
                        }
                        f[p] = SvmTrainOne(subProb, param, weightedC[i], weightedC[j]);
                        for (k = 0; k < ci; k++)
                        {
                            if (!nonzero[si + k] && Math.Abs(f[p].alpha[k]) > 0)
                            {
                                nonzero[si + k] = true;
                            }
                        }
                        for (k = 0; k < cj; k++)
                        {
                            if (!nonzero[sj + k] && Math.Abs(f[p].alpha[ci + k]) > 0)
                            {
                                nonzero[sj + k] = true;
                            }
                        }
                        ++p;
                    }
                }
                // build output
                model.nrClass = nrClass;
                model.label   = new int[nrClass];
                for (i = 0; i < nrClass; i++)
                {
                    model.label[i] = label[i];
                }
                model.rho = new double[nrClass * (nrClass - 1) / 2];
                for (i = 0; i < nrClass * (nrClass - 1) / 2; i++)
                {
                    model.rho[i] = f[i].rho;
                }
                if (param.probability)
                {
                    model.probA = new double[nrClass * (nrClass - 1) / 2];
                    model.probB = new double[nrClass * (nrClass - 1) / 2];
                    for (i = 0; i < nrClass * (nrClass - 1) / 2; i++)
                    {
                        model.probA[i] = probA[i];
                        model.probB[i] = probB[i];
                    }
                }
                else
                {
                    model.probA = null;
                    model.probB = null;
                }
                int   nnz     = 0;
                int[] nzCount = new int[nrClass];
                model.nSv = new int[nrClass];
                for (i = 0; i < nrClass; i++)
                {
                    int nSv = 0;
                    for (int j = 0; j < count[i]; j++)
                    {
                        if (nonzero[start[i] + j])
                        {
                            ++nSv;
                            ++nnz;
                        }
                    }
                    model.nSv[i] = nSv;
                    nzCount[i]   = nSv;
                }
                Info("Total nSV = " + nnz + "\n");
                model.l  = nnz;
                model.sv = new BaseVector[nnz];
                p        = 0;
                for (i = 0; i < l; i++)
                {
                    if (nonzero[i])
                    {
                        model.sv[p++] = x[i];
                    }
                }
                int[] nzStart = new int[nrClass];
                nzStart[0] = 0;
                for (i = 1; i < nrClass; i++)
                {
                    nzStart[i] = nzStart[i - 1] + nzCount[i - 1];
                }
                model.svCoef = new double[nrClass - 1][];
                for (i = 0; i < nrClass - 1; i++)
                {
                    model.svCoef[i] = new double[nnz];
                }
                p = 0;
                for (i = 0; i < nrClass; i++)
                {
                    for (int j = i + 1; j < nrClass; j++)
                    {
                        // classifier (i,j): coefficients with
                        // i are in sv_coef[j-1][nz_start[i]...],
                        // j are in sv_coef[i][nz_start[j]...]
                        int si = start[i];
                        int sj = start[j];
                        int ci = count[i];
                        int cj = count[j];
                        int q  = nzStart[i];
                        int k;
                        for (k = 0; k < ci; k++)
                        {
                            if (nonzero[si + k])
                            {
                                model.svCoef[j - 1][q++] = f[p].alpha[k];
                            }
                        }
                        q = nzStart[j];
                        for (k = 0; k < cj; k++)
                        {
                            if (nonzero[sj + k])
                            {
                                model.svCoef[i][q++] = f[p].alpha[ci + k];
                            }
                        }
                        ++p;
                    }
                }
            }
            return(model);
        }
 public override double SumSquaredDiffs(BaseVector y)
 {
     if (y is FloatArrayVector){
         return SumSquaredDiffs((FloatArrayVector) y, this);
     }
     if (y is DoubleArrayVector){
         return SumSquaredDiffs((DoubleArrayVector) y, this);
     }
     if (y is BoolArrayVector){
         return SumSquaredDiffs((BoolArrayVector) y, this);
     }
     return SumSquaredDiffs(this, (SparseFloatVector) y);
 }
 public RegressionModel Train(BaseVector[] x, float[] y, Parameters param, int ntheads)
 {
     int k = param.GetParam<int>("Number of neighbours").Value;
     IDistance distance = Distances.GetDistanceFunction(param);
     return new KnnRegressionModel(x, y, k, distance);
 }
 public double Evaluate(BaseVector xi, BaseVector xj, double xSquarei, double xSquarej)
 {
     return Math.Tanh(Gamma*xi.Dot(xj) + Offset);
 }
 public double Get(BaseVector x, BaseVector y)
 {
     return Calc(x, y);
 }