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;
}
public RegressionResult PerformRegression(MergedBacteria bacteria)
{
var trainSize = (int)(bacteria.Bacterium1.Measurements.Count() / 100.0 * TrainSizePercentage);
var trainX = bacteria.Bacterium1.Measurements.Take(trainSize).ToArray();
var testX = bacteria.Bacterium1.Measurements.Skip(trainSize).ToArray();
var trainY = bacteria.Bacterium2.Measurements.Take(trainSize).ToArray();
var testY = bacteria.Bacterium2.Measurements.Skip(trainSize).ToArray();
var result = RegressionModel.PerformRegression(trainX, trainY, testX, testY);
result.TrainX = trainX;
result.TrainY = trainY;
result.TestX = testX;
result.TestY = testY;
result.Error = new SquareLoss(trainX).Loss(result.PredictionOnTrainingSet);
return(result);
}
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);
}
private async Task CalculateModel(RegressionModel model, List <Expense> expenses, List <double[]> predictors,
int month)
{
var targets = new List <double?>();
foreach (var expense in expenses)
{
var target =
await GetMonthlyExpensesOfCategory(expense.UserId, expense.Date.AddMonths(month),
expense.CategoryId) -
await GetMonthlyExpensesOfCategory(expense.UserId, expense.Date.AddMonths(-1), expense.CategoryId);
if (target < 0.0d)
{
target = 0.0d;
}
targets.Add(target);
}
var dataSet = new DataSet(targets.ToArray(), predictors.ToArray());
model.CalculateCoefficients(dataSet);
}
public RegressionOnSubFeatures(RegressionModel regressionModel, int[] featureInds)
{
this.regressionModel = regressionModel;
this.featureInds = featureInds;
}
public bool IsProblemDataCompatible(IRegressionProblemData problemData, out string errorMessage)
{
return(RegressionModel.IsProblemDataCompatible(this, problemData, out errorMessage));
}
public RegressionPresenter(DataSetManagerPresenter dataSetPresenter)
{
this.dataSetPresenter = dataSetPresenter;
model = new RegressionModel();
}
// runs the adf test on the Xdata and Ydata
// returns true if the t statistic is less than the t critical value and false if otherwise
// sig is the significant level as a decimal
public bool adfuller(double sig)
{
// the test builds an OLS regression model on Y and lagged X values and then uses the t statistic
// from that test and compares it to the t critical values
Vector <double> Xdiff = Vector <double> .Build.DenseOfArray(math.linalg.ArrayManipulation.diff(Xdata.ToArray()));
Vector <double> Xlag = Vector <double> .Build.Dense(Xdata.Count - 1);
for (int i = 1; i < Xdata.Count; i++)
{
Xlag[i - 1] = Xdata[i];
}
Vector <double> Xlagdiff = Vector <double> .Build.DenseOfArray(math.linalg.ArrayManipulation.diff(Xlag.ToArray()));
Matrix <double> Xcomb = Matrix <double> .Build.Dense(Xlag.Count, 2);
Xcomb[0, 0] = Xlag[0];
Xcomb[0, 1] = 0;
for (int i = 0; i < Xlagdiff.Count; i++)
{
Xcomb[i + 1, 0] = Xlag[i + 1];
Xcomb[i + 1, 1] = Xlagdiff[i];
}
Vector <double> ytest = Vector <double> .Build.Dense(Xlag.Count);
Xdata.CopySubVectorTo(ytest, 2, 0, Xdata.Count - 2);
RegressionModel OLS_instance = new RegressionModel(Xcomb, ytest, "OLS");
Matrix <double> design = OLS_instance.designMatrix(Xcomb);
Vector <double> coeff = OLS_instance.fit(design, ytest);
double tstat = OLS_instance.testValue(Xcomb, Xdata, 1, coeff);
int abs50 = Math.Abs(Xdata.Count - 50);
int abs100 = Math.Abs(Xdata.Count - 100);
int abs200 = Math.Abs(Xdata.Count - 200);
int significance = (int)(sig * 100);
int min = Math.Min(abs50, Math.Min(abs100, abs200));
if (min == abs50)
{
if (min < TCritcalVals[50][significance])
{
return(true);
}
else
{
return(false);
}
}
else if (min == abs100)
{
if (min < TCritcalVals[100][significance])
{
return(true);
}
else
{
return(false);
}
}
else
{
if (min < TCritcalVals[200][significance])
{
return(true);
}
else
{
return(false);
}
}
}
