gyrdym / ml_algo Goto Github PK

E/flutter ( 8937): [ERROR:flutter/lib/ui/ui_dart_state.cc(199)] Unhandled Exception: Exception: The dimension of the vector and the columns number of the matrix mismatch
E/flutter ( 8937): #0      MatrixImpl._matrixVectorMul (package:ml_linalg/src/matrix/matrix_impl.dart:500:7)
E/flutter ( 8937): #1      MatrixImpl.* (package:ml_linalg/src/matrix/matrix_impl.dart:89:14)
E/flutter ( 8937): #2      LinearRegressorImpl.predict (package:ml_algo/src/regressor/linear_regressor/linear_regressor_impl.dart:152:11)
E/flutter ( 8937): #3      AnalyticsLinearRegression.predict (package:trimlog/services/ml/analytics_linear_regression.dart:87:35)
E/flutter ( 8937): <asynchronous suspension>
E/flutter ( 8937): #4      _AnalyticGraphState.build.<anonymous closure>.<anonymous closure>.<anonymous closure>._predict.<anonymous closure> (package:trimlog/screens/analytics/analytics_graphs.dart:143:49)
E/flutter ( 8937): <asynchronous suspension>
E/flutter ( 8937):

class AnalyticsLinearRegression {
  List<Trim> trims;
  final String xCategory;
  final String xParameter;
  final String yCategory;
  final String yParameter;

  AnalyticsLinearRegression(this.trims, this.xCategory, this.xParameter, this.yCategory, this.yParameter);

  List<Series> _prepareData() {
    // Remove trims which do not contain the parameter shown in this analytic
    List<Trim> temp = new List.from(trims);
    trims.forEach((trim) {
      Map<String, dynamic> map = trim.toMap();
      if ((!(map[xCategory] as Map).containsKey(xParameter)) || (map[xCategory][xParameter] == null) || (!(map[yCategory] as Map).containsKey(yParameter)) || (map[yCategory][yParameter] == null))
        temp.remove(trim);
    });
    trims = temp;
    // Extract the parameters shown in the analytic from the trims
    List x = [];
    List y = [];
    trims.forEach((trim) {
      Map<String, dynamic> map = trim.toMap();
      x.add((map[xCategory][xParameter] is List ? map[xCategory][xParameter].first : map[xCategory][xParameter]) * 1.0);
      y.add((map[yCategory][yParameter] is List ? map[yCategory][yParameter].first : map[yCategory][yParameter]) * 1.0);
    });
    Series xSeries = Series(xParameter, x); // First column, given parameter
    Series ySeries = Series(yParameter, y); // Second column, predicted parameter
    return [xSeries, ySeries];
  }

  Future train() async {
    final Iterable<Series> data = _prepareData();
    final dataFrame = DataFrame.fromSeries(data);
    if (dataFrame.rows.length <= 2) return; // <= 2 datapoints results in errors
    final targetColumnName = yParameter; // The second column (y) contains the parameter that I later want to predict
    final splits = splitData(dataFrame, [0.7]);
    final validationData = splits[0];
    // final testData = splits[1];
    final validator = CrossValidator.kFold(validationData, numberOfFolds: validationData.rows.length - 1);
    final createClassifier = (DataFrame samples) => LinearRegressor(
          samples,
          targetColumnName,
          optimizerType: LinearOptimizerType.gradient,
          iterationsLimit: 90,
          learningRateType: LearningRateType.decreasingAdaptive,
          batchSize: samples.rows.length,
        );
    final scores = await validator.evaluate(createClassifier, MetricType.rmse);
    final accuracy = scores.mean();
    print('Accuracy on root mean squared error (RMSE) validation: ${accuracy.toStringAsFixed(2)}');
    // final testSplits = splitData(testData, [1.00]);
    // final classifier = createClassifier(testSplits[0]);
    // final finalScore = classifier.assess(testSplits[1], MetricType.rmse);
    // print(finalScore.toStringAsFixed(2));
    // await classifier.saveAsJson(xParameter + '_' + yParameter + '_classifier.json');
    final classifier = createClassifier(dataFrame);
    await classifier.saveAsJson(await _classifierPath);
  }

  Future retrain(List<Trim> newData) async {
    final classifier = await _linearRegressor;
    trims = newData;
    final Iterable<Series> data = _prepareData();
    final dataFrame = DataFrame.fromSeries(data);
    final retrainedClassifier = classifier.retrain(dataFrame);
    await retrainedClassifier.saveAsJson(await _classifierPath);
  }

  /// Predicts the y value (seceond column) of a given x value (double)
  /// Can be used / Is used to get to points and draw a line through these points as a trendline (like here: https://google.github.io/charts/flutter/example/combo_charts/scatter_plot_line)
  Future<double> predict(double x) async {
    final classifier = await _linearRegressor;
    Series xSeries = Series(xParameter, [x]); // First column value (x)
    Series ySeries = Series(yParameter, []); // Second column value (y) should get predicted and returned, therefore this is empty
    final data = DataFrame.fromSeries([xSeries, ySeries]);
    final prediction = classifier.predict(data); // Predict the corresponding y value to the given x value
    return prediction.rows.first.first; // Prediction should only contain one row and this row should contain the predicted y value
  }

  Future<String> get _classifierPath async => (await getTemporaryDirectory()).path + "/" + xParameter + '_' + yParameter + '_classifier.json'; // Path where the classifier is saved
  Future<File> get _file async => File(await _classifierPath); // File containing the classifier (JSON)
  Future<String> get _encodedModel async => (await _file).readAsString(); // Classifier as JSON
  Future<LinearRegressor> get _linearRegressor async => LinearRegressor.fromJson(await _encodedModel); // Linear regressor from file
}

(src, day, time, dest)
(0, 0, 450, 4)
(1, 0, 110, 5)
(0, 1, 450, 4)
(1, 1, 110, 5)
(0, 2, 450, 4)
(1, 2, 110, 5)
(0, 3, 450, 4)
(1, 3, 110, 5)
(0, 4, 450, 4)
(1, 4, 110, 5)
(0, 5, 450, 4)
(1, 5, 110, 5)
(2, 6, 660, 6)
(3, 6, 1170, 7)
(0, 0, 450, 4)
(1, 0, 110, 5)
(0, 1, 450, 4)
(1, 1, 110, 5)
(0, 2, 450, 4)
(1, 2, 110, 5)
(0, 3, 450, 4)
(1, 3, 110, 5)
(0, 4, 450, 4)
(1, 4, 110, 5)
(0, 5, 450, 4)
(1, 5, 110, 5)
(2, 6, 660, 6)
(3, 6, 1170, 8)

Unhandled exception:
Invalid argument(s)
#0      _TypedList._setFloat32 (dart:typed_data-patch/typed_data_patch.dart:2126:36)
#1      _Float32ArrayView.[]= (dart:typed_data-patch/typed_data_patch.dart:4461:16)
#2      new Float32MatrixDataManager.fromList
package:ml_linalg/…/data_manager/float32_matrix_data_manager.dart:37

#3      MatrixFactoryImpl.fromList
package:ml_linalg/…/matrix/matrix_factory_impl.dart:21
#4      new Matrix.fromList
package:ml_linalg/matrix.dart:42
#5      DataFrameImpl.toMatrix
package:ml_dataframe/…/data_frame/data_frame_impl.dart:143
#6      createLogLikelihoodOptimizer
package:ml_algo/…/_helpers/create_log_likelihood_optimizer.dart:46

#7      LogisticRegressorFactoryImpl.create
package:ml_algo/…/logistic_regressor/logistic_regressor_factory_impl.dart:58
#8      new LogisticRegressor
package:ml_algo/…/logistic_regressor/logistic_regressor.dart:153
#9      main.<anonymous closure>
bin\knn.dart:41
#10     main
bin\knn.dart:53
<asynchronous suspension>

 final createClassifier = (DataFrame samples) => LogisticRegressor(
        samples,
        targetColumnName,
        optimizerType: LinearOptimizerType.gradient,
        iterationsLimit: 90,
        learningRateType: LearningRateType.decreasingAdaptive,
        batchSize: samples.rows.length,
        probabilityThreshold: 0.7,
      );

import 'package:ml_algo/ml_algo.dart';
import 'package:ml_dataframe/ml_dataframe.dart';
import 'package:xrange/xrange.dart';

main() {
 var a = 1;
 var n = 100;

 var _data = NumRange.closed(a, n).values().map((it) => [it, it]) ;

 final data = [['x', 'y'], ..._data];

 print(data);

 final samples = DataFrame(data, headerExists: true);
 final regressor = LinearRegressor(samples, 'y');

 var prediction = regressor.predict(DataFrame([['x', 'y'], [10.0,]],));

 print("a=$a n=$n -> k ${regressor.coefficients} rows ${prediction.rows}");
}