edge_ml_dart

import 'package:edge_ml_dart/edge_ml_dart.dart';

final edgeml = EdgeML(apiKey: '<device api write key>');

// 1. record a labeled dataset
final collector = await edgeml.datasets.collector(
  'walk-1',
  ['accX', 'accY', 'accZ'],
  units: {'accX': 'm/s^2', 'accY': 'm/s^2', 'accZ': 'm/s^2'}, // optional, see Units
  quantities: {'accX': 'acceleration', 'accY': 'acceleration', 'accZ': 'acceleration'},
);
collector.startLabel('activity', 'walk');
collector.addSample({'accX': 0.1, 'accY': 9.8, 'accZ': 0.3}); // for every reading
collector.startLabel('activity', 'run'); // ends 'walk'
// ...
await collector.complete();

// 2. train a model from a preset
final model = await edgeml.models.train(
  name: 'activity-model',
  labeling: 'activity',
  preset: Presets.smallCnn,
  onProgress: (m) => print('${m.status.name} ${m.progress ?? ''}'),
);

// 3. run it on the device
final predictor = await edgeml.models.load(model.id, units: {'accX': 'm/s^2', 'accY': 'm/s^2', 'accZ': 'm/s^2'});
sensorStream.listen((e) async {
  predictor.addSample({'accX': e.x, 'accY': e.y, 'accZ': e.z});
  if (predictor.isReady) {
    final p = await predictor.predict();
    print('${p.label} (${p.confidence})');
  }
});

final edgeml = EdgeML(apiKey: key, backendUrl: 'https://edge-ml.my-lab.org');

final datasets = await edgeml.datasets.list();
for (final ds in datasets) {
  print('${ds.name}: ${ds.timeSeries.map((t) => '${t.name} [${t.unit}, ${t.quantity}]')}');
  for (final label in ds.labels) {
    print('  ${label.labeling}/${label.label} ${label.start}-${label.end}');
  }
}
final ds = await edgeml.datasets.get('walk-1'); // by id or name
final labelings = await edgeml.datasets.labelings();

final collector = await edgeml.datasets.collector(
  'session-3',
  ['accX', 'accY', 'accZ'],
  metadata: {'device': 'phone', 'person': 'p1'},
  units: {'accX': 'g', 'accY': 'g', 'accZ': 'g'},              // optional
  quantities: {'accX': 'acceleration', 'accY': 'acceleration', 'accZ': 'acceleration'},
  wholeDatasetLabel: ('person', 'p1'), // optional: one label over the whole dataset
);

collector.add('accX', 0.12);                       // one value
collector.addSample({'accX': 0.1, 'accY': 9.8, 'accZ': 0.3}, timestamp: t); // one value per series

collector.startLabel('activity', 'walk');          // label from now on ...
collector.stopLabel('activity');                   // ... until now
collector.addLabel(DatasetLabel('activity', 'sit', start: t1, end: t2)); // or a known range

await collector.complete(); // uploads the rest and all labels

final rec = DatasetRecording(
  'offline-1',
  units: {'accX': 'm/s^2'},
  quantities: {'accX': 'acceleration'}, // sent by upload(); the CSV only has the unit
);
rec.startLabel('activity', 'walk');
rec.addSample({'accX': 0.1, 'accY': 9.8});
rec.stopLabel('activity');

final datasetId = await edgeml.datasets.upload(rec);
final csv = rec.toCsv(); // time,sensor_accX[m/s^2],sensor_accY,label_activity_walk

// add a recording to a dataset, e.g. the one a collector just filled
final media = await edgeml.datasets.uploadMediaFile(
  collector.datasetId,
  '/path/to/walk-1.mp4',
  start: recordingStartedAt.millisecondsSinceEpoch, // lines it up with the sensor data
  name: 'front camera',                             // optional: defaults to the file name
);
print('${media.kind.name} ${media.duration} ${media.width}x${media.height}');

// from memory (also works on the web)
await edgeml.datasets.uploadMediaBytes(datasetId, bytes, fileName: 'voice.m4a');

// a dataset that only holds recordings
final id = await edgeml.datasets.create('interview-1');
await edgeml.datasets.uploadMediaFile(id, path);

// recordings are listed with the dataset and can be downloaded
final ds = await edgeml.datasets.get(id);
final bytes = await edgeml.datasets.downloadMedia(ds.id, ds.media.first.id);

final presets = await edgeml.models.presets(); // id, name, description

final model = await edgeml.models.train(
  name: 'gesture-model',
  labeling: 'gesture',                 // labeling name or id
  preset: Presets.largeCnn,
  datasets: ['g-1', 'g-2'],            // optional, default: every dataset with that labeling
  timeSeries: ['accX', 'accY', 'accZ'],// optional, default: series all datasets share
  disabledLabels: ['noise'],           // optional
  steps: {                             // optional overrides on top of the preset
    'windowing': StepOverride(parameters: {'window_size': 100, 'sliding_step': 50}),
    'classifier': StepOverride(parameters: {'epochs': 100}),
  },
  onProgress: (m) => print(m),
  onWarning: print,
);
print(model.metrics);

final predictor = await edgeml.models.load(modelId);
print(predictor.timeSeries); // the sensors it expects, e.g. [accX, accY, accZ]
print(predictor.labels);     // what it predicts
print(predictor.windowSize); // samples per window

predictor.addSample({'accX': x, 'accY': y, 'accZ': z}); // unused sensors are ignored
predictor.addValues([x, y, z], timestamp: t);           // in timeSeries order

if (predictor.isReady) {
  final p = await predictor.predict(); // classifies the latest window
  print(p.label);       // 'walk'
  print(p.confidence);  // 0.93
  print(p.byLabel);     // {walk: 0.93, run: 0.05, sit: 0.02}
}

await predictor.dispose();

final predictor = await Predictor.fromBytes(pteBytes, manifestJson);

final predictor = await edgeml.models.load(modelId, units: {'accX': 'g', 'temp': 'degF'});
predictor.addSample({'accX': 0.02, 'temp': 71.6}); // in g and °F

for (final u in predictor.inputUnits) {
  print('${u.name}: ${u.unit} (${u.quantity})'); // accX: m/s^2 (acceleration)
}
predictor.setUnits({'accX': 'm/s^2'}); // change the declaration later

final catalog = await edgeml.unitCatalog(); // works without a valid key
for (final q in catalog.quantities) {
  print('${q.id}: models expect ${q.defaultUnit}, units ${q.units.map((u) => u.id)}');
}