1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "framesed.h"
#define CHECK(condition) do { \
if (!(condition)) { \
fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, #condition); \
return 1; \
} \
} while (0)
static int check_result(const framesed_result *result, double duration) {
CHECK(result->planes && result->num_groups == FRAMESED_CLASS_COUNT);
CHECK(result->num_frames == (size_t)ceil(duration / FRAMESED_FRAME_STEP));
for (size_t i = 0; i < result->num_groups * result->num_frames; ++i)
CHECK(result->planes[i] >= 0.0f && result->planes[i] <= 1.0f);
int music = 0;
for (size_t i = 0; i < result->num_events; ++i) {
const framesed_event *event = &result->events[i];
CHECK(event->class_group >= 0 && event->class_group < FRAMESED_CLASS_COUNT);
CHECK(event->label == framesed_class_label((size_t)event->class_group));
CHECK(event->start >= 0.0 && event->end > event->start && event->end <= duration);
CHECK(event->score >= 0.50f && event->score <= 1.0f);
CHECK(i == 0 || result->events[i - 1].start <= event->start);
if (event->class_group == 253)
music = 1;
}
CHECK(music);
CHECK(result->num_tracks > 0 && result->track_step == 0.2);
for (size_t i = 0; i < result->num_tracks; ++i) {
const framesed_track *track = &result->tracks[i];
CHECK(track->class_group >= 0 && track->class_group < FRAMESED_CLASS_COUNT);
CHECK(track->label == framesed_class_label((size_t)track->class_group));
CHECK(track->count == (result->num_frames + 4) / 5);
CHECK(i == 0 || result->tracks[i - 1].class_group < track->class_group);
const float *row = result->planes + (size_t)track->class_group * result->num_frames;
for (size_t j = 0; j < track->count; ++j) {
float maximum = 0.0f;
for (size_t f = j * 5; f < (j + 1) * 5 && f < result->num_frames; ++f)
if (row[f] > maximum)
maximum = row[f];
CHECK(track->values[j] == maximum);
}
}
return 0;
}
int main(int argc, char **argv) {
const char *weights = argc > 1 ? argv[1] : "models/framesed_weights.bin";
/* A partial final frame/window exercises padding and duration clipping. */
const size_t count = 30u * FRAMESED_SAMPLE_RATE + 137;
const double duration = (double)count / FRAMESED_SAMPLE_RATE;
int16_t *samples = malloc(count * sizeof(*samples));
CHECK(samples);
for (size_t i = 0; i < count; ++i) {
const double t = (double)i / FRAMESED_SAMPLE_RATE;
double value = (sin(2 * M_PI * 261.6 * t) + sin(2 * M_PI * 329.6 * t) +
sin(2 * M_PI * 392.0 * t)) / 3;
value *= 0.65 + 0.35 * sin(2 * M_PI * 4.0 * t);
samples[i] = (int16_t)(value * 0.10 * 32767.0);
}
framesed_t *engine = framesed_create(weights);
CHECK(engine);
framesed_options options = {
.threads = 1, .track_step = 0.2, .keep_planes = 1, .all_classes = 1,
};
framesed_result one = {0};
CHECK(framesed_detect_s16(engine, samples, 10u * FRAMESED_SAMPLE_RATE, &options, &one) == 0);
CHECK(check_result(&one, 10.0) == 0);
framesed_logits logits = {0};
CHECK(framesed_infer_s16(engine, samples, 10u * FRAMESED_SAMPLE_RATE, &logits) == 0);
CHECK(one.num_frames == logits.frames);
for (size_t i = 0; i < FRAMESED_CLASS_COUNT * logits.frames; ++i) {
const float expected = 1.0f / (1.0f + expf(-logits.logits[i]));
CHECK(fabsf(one.planes[i] - expected) < 2e-7f);
}
framesed_logits_free(&logits);
framesed_result_free(&one);
CHECK(framesed_detect_s16(engine, samples, count, &options, &one) == 0);
CHECK(check_result(&one, duration) == 0);
options.threads = 4;
framesed_result many = {0};
CHECK(framesed_detect_s16(engine, samples, count, &options, &many) == 0);
CHECK(check_result(&many, duration) == 0);
CHECK(one.num_events == many.num_events && one.num_tracks == many.num_tracks);
CHECK(one.num_frames == many.num_frames && one.num_groups == many.num_groups);
CHECK(memcmp(one.planes, many.planes,
one.num_frames * one.num_groups * sizeof(float)) == 0);
for (size_t i = 0; i < one.num_events; ++i) {
const framesed_event *a = &one.events[i], *b = &many.events[i];
CHECK(a->class_group == b->class_group && a->label == b->label);
CHECK(a->start == b->start && a->end == b->end && a->score == b->score);
}
for (size_t i = 0; i < one.num_tracks; ++i) {
const framesed_track *a = &one.tracks[i], *b = &many.tracks[i];
CHECK(a->class_group == b->class_group && a->label == b->label && a->count == b->count);
CHECK(memcmp(a->values, b->values, a->count * sizeof(float)) == 0);
}
printf("framesed classes: 447 score planes match native logits; 1/4 workers agree "
"(%zu events, %zu tracks)\n", one.num_events, one.num_tracks);
framesed_result_free(&one);
framesed_result_free(&many);
options.keep_planes = 0;
options.track_step = 0;
CHECK(framesed_detect_s16(engine, samples, 10u * FRAMESED_SAMPLE_RATE, &options, &one) == 0);
CHECK(one.num_events > 0 && !one.planes && !one.tracks);
CHECK(one.num_groups == 0 && one.num_frames == 0 && one.num_tracks == 0);
framesed_result_free(&one);
options.keep_planes = 1;
CHECK(framesed_detect_s16(engine, samples, 17, &options, &one) == 0);
CHECK(one.num_groups == FRAMESED_CLASS_COUNT && one.num_frames == 1 && one.planes);
CHECK(one.num_events == 0);
framesed_result_free(&one);
CHECK(framesed_detect_s16(engine, NULL, 0, &options, &one) == 0);
CHECK(!one.planes && !one.events && !one.tracks);
framesed_result_free(&one);
framesed_destroy(engine);
free(samples);
return 0;
}
|